plGeoAdaptels

@@ -32,15 +32,40 @@ void init_cumul_sum(double* cumul_sum, long index, int nodata,

 }

 double calc_distance(double** layers, int n_layers, double* cumul_sum,

-                     long index, long superpixel_size) {

-	double diff, dist = 0.0;

+                     long index, long superpixel_size, int distance, double minkowski_p) {

+    double diff, dist = 0.0, A = 1.0, B = 1.0, AB = 1.0;

     int i;

+    switch(distance) {

+        case 0: // minkowski

             for(i=0; i<n_layers; i++) {

-		diff = cumul_sum[i] - layers[i][index]*superpixel_size;

-		dist += diff*diff;

+                diff = fabs(cumul_sum[i] - layers[i][index]*superpixel_size);

+                dist += pow(diff, minkowski_p);

             }

-	return sqrt(dist)/superpixel_size;

+            dist = pow(dist, 1.0/minkowski_p)/superpixel_size;

+            break;

+        case 1: // cosine

+            for(i=0; i<n_layers; i++) {

+                diff = cumul_sum[i]/superpixel_size;

+                A += pow(diff, 2.0);

+                B += pow(layers[i][index],2.0);

+                AB += layers[i][index]*diff;

+            }

+            dist = AB/sqrt(A*B);

+            break;

+        case 2: // angular

+            for(i=0; i<n_layers; i++) {

+                diff = cumul_sum[i]/superpixel_size;

+                A += pow(diff, 2.0);

+                B += pow(layers[i][index],2.0);

+                AB += layers[i][index]*diff;

+            }

+            dist = acos(AB/sqrt(A*B))/M_PI;

+            break;

+        default:

+            dist = 0.0;

+    }

+    return dist;

 }

 void get_cell_neighbour(CELL* c, int n, int* x, int* y) {

@@ -55,7 +80,7 @@ void grow_adaptel(int i, LABELS* labels, MINLIST* minlist, SEEDS* seeds,

                   double* distances, double** layers, int n_layers,

                   unsigned char* mask, int cols, int rows,

                   long size, double threshold, int connectivity,

-		          int* dIdx) {

+                  int* dIdx, int distance, double minkowski_p) {

     long idx1, idx2, index, superpixel_size;

     double* cumul_sum = (double*)malloc(sizeof(double)*n_layers);

@@ -91,7 +116,8 @@ void grow_adaptel(int i, LABELS* labels, MINLIST* minlist, SEEDS* seeds,

                             else

                                 dist = distances[idx1] + 

                                           calc_distance(layers, n_layers, cumul_sum,

-                                                        idx2, superpixel_size);

+                                                        idx2, superpixel_size,

+                                                        distance, minkowski_p);

                             if(dist < distances[idx2] || labels->labels[idx2] < 0) {

                                 distances[idx2] = dist;

@@ -150,7 +176,9 @@ LABELS* create_adaptels(

              int            cols,

              int            rows,

              const double   threshold,

-             const int      connectivity) {

+             const int      connectivity,

+             const int      distance,

+             const double   minkowski_p) {

     const long size = (long)cols*rows;

     long i;

@@ -171,7 +199,8 @@ LABELS* create_adaptels(

     for(i = 0; i < seeds->N; i++)

         grow_adaptel(i, labels, minlist, seeds, distances, 

                      layers, n_layers, mask, cols, rows,

-		             size, threshold, connectivity, dIdx);

+                     size, threshold, connectivity, dIdx,

+                     distance, minkowski_p);

     free_minlist(minlist);

     free_seeds(seeds);

@@ -10,6 +10,8 @@ LABELS* create_adaptels(

              int            cols, 

              int            rows,

              const double   threshold,

-             const int      connectivity);

+             const int      connectivity,

+             const int      distance,

+             const double   minkowski_p);

 #endif

@@ -43,18 +43,23 @@ void usage(char *progname, void *argtable) {

 int main(int argc, char **argv) {

     long i;

+    char* dist_names[] = {"minkowski","cosine","angular"};

     double thr_val = 60.0;

     int con_val = 4;

+    int distance_val = 0;

+    double minkowski_p_val = 2.0;

     struct arg_str  *inp  = arg_strn("i","input","<file_name>",1,99,"name of input file(s) (GeoTIFF)");

     struct arg_str  *out  = arg_str1("o","output","<file_name>","name of output file (GeoTIFF) with adaptels");

     struct arg_dbl  *thr  = arg_dbl0("t","threshold","<val>","threshold value for adaptels algorithm (default: 60.0)");

+    struct arg_str  *dist = arg_str0("d","distance","<distance name>","name of the distance measure: minkowki, cosine, angular (default: minkowski)");

+    struct arg_dbl  *mink = arg_dbl0("p","minkowski_p","<val>","value for minkowski distance (default: 2.0)");

     struct arg_lit  *con  = arg_lit0("8","Queen topology","cells connectivity (default: 4, Rook)");

     struct arg_lit  *norm = arg_lit0("n","normalize","normalize cells values to the interval [0,1] (default: no)");

     struct arg_lit  *help = arg_lit0("h","help","print this help and exit");

     struct arg_end  *end  = arg_end(20);

-    void* argtable[] = {inp,out,thr,con,norm,help,end};

+    void* argtable[] = {inp,out,thr,dist,mink,con,norm,help,end};

     int nerrors = arg_parse(argc,argv,argtable);

@@ -74,6 +79,16 @@ int main(int argc, char **argv) {

       }

     }

+    if(mink->count>0)

+      minkowski_p_val = mink->dval[0];

+

+    if(dist->count>0) {

+      if(strcmp(dist_names[1],dist->sval[0])==0)

+        distance_val = 1;

+      else if(strcmp(dist_names[2],dist->sval[0])==0)

+        distance_val = 2;

+    }

+

     if(con->count>0)

       con_val = 8;

@@ -163,6 +178,8 @@ int main(int argc, char **argv) {

       ezgdal_show_message(stderr,"OK");

     }

+    ezgdal_show_message_nolf(stderr,"Distance:             ");

+    ezgdal_show_message(stderr,dist_names[distance_val]);

     ezgdal_show_message_nolf(stderr,"Adaptels creating:    ");

     clock_t time_start, time_end;

@@ -172,7 +189,9 @@ int main(int argc, char **argv) {

     LABELS* labels = create_adaptels(input_buffers, inp->count, mask,

                                      input_layers[0]->cols, 

                                      input_layers[0]->rows, 

-                                     thr_val, con_val);

+                                     thr_val, con_val,

+                                     distance_val,

+                                     minkowski_p_val);

     time_end = clock();

     time_elapsed = ((double) (time_end - time_start)) / CLOCKS_PER_SEC;

     fprintf(stderr,"%d adaptels created in %.4lf seconds\n",labels->max_label, time_elapsed);