Changes between Version 7 and Version 8 of RemapFilter

Timestamp:

Jun 17, 2016, 12:09:09 PM (10 years ago)

Author:

Floris Sluiter

Comment:

--

RemapFilter

@@ -25 +25 @@
 * Samsung gear camera: input files for resolution 2560x1280
 
-Note: if you have a different camera or need other resolutions, let me know ( fsluiter_at_gmail.com). I can generate the input files if you sent me a sample frame.
-
+Note: for questions about these examples, let me know ( fsluiter_at_gmail.com). 
+
+How to generate PGM files:
+
+{{{
+#!div style="font-size: 80%"
+{{{#!c 
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <libgen.h>
+#include <string.h>
+#include <getopt.h>
+#include <math.h>
+
+
+
+/* Compile with: gcc projection.c -Wall -o project -lm
+ * math.h does not like to be linked directly...
+ */
+
+/* Flag set by ‘--verbose’. */
+static int verbose_flag;
+
+typedef struct double2{
+    double x;
+    double y;
+}double2;
+typedef struct double3{
+    double x;
+    double y;
+    double z;
+}double3;
+
+
+enum CameraMode {
+    FRONT,
+    FRONT235,
+    BACK,
+    UP,
+    DOWN,
+    SAMSUNG_GEAR_360,
+    THETAS
+};
+
+typedef struct configuration {
+    char* xmap_filename;
+    char* ymap_filename; 
+    int xmap_set;
+    int ymap_set;
+    int rows; // target
+    int cols; // target
+    int height; //source
+    int width;//source
+    int rows_set;
+    int cols_set;
+    int height_set;
+    int width_set;
+    int crop;
+    enum CameraMode mode;
+} configuration;
+
+configuration parse_options(int argc, char **argv){
+  int c;
+  configuration po; //to hold parsed options
+  po.xmap_filename=NULL;
+  po.ymap_filename=NULL;
+  po.xmap_set=0;
+  po.ymap_set=0;
+  po.rows=0;
+  po.cols=0;
+  po.rows_set=0;
+  po.cols_set=0;
+  po.height_set=0;
+  po.width_set=0;
+  po.mode=FRONT; //default
+
+  while (1)
+    {
+      static struct option long_options[] =
+        {
+          /* These options set a flag. */
+          {"verbose", no_argument,       &verbose_flag, 1},
+          {"brief",   no_argument,       &verbose_flag, 0},
+
+          /* These options don’t set a flag.
+             We distinguish them by their indices. */
+          {"help",  no_argument,       0, 'q'},
+
+          /* options with arg*/
+          {"xmap",    required_argument, 0, 'x'},
+          {"ymap",    required_argument, 0, 'y'},
+          {"rows",    required_argument, 0, 'r'},//target
+          {"cols",    required_argument, 0, 'c'},//target
+          {"height",  required_argument, 0, 'h'},//source
+          {"width",   required_argument, 0, 'w'},//source
+          {"mode",    required_argument, 0, 'm'},
+          {"crop",    required_argument, 0, 'b'},
+
+          {0, 0, 0, 0}
+        };
+      /* getopt_long stores the option index here. */
+      int option_index = 0;
+
+      c = getopt_long (argc, argv, "qx:y:r:c:h:w:m:b:",
+                       long_options, &option_index);
+
+      /* Detect the end of the options. */
+      if (c == -1)
+        break;
+
+      switch (c)
+        {
+        case 0:
+          /* If this option set a flag, do nothing else now. */
+          if (long_options[option_index].flag != 0)
+            break;
+          printf ("option %s", long_options[option_index].name);
+          if (optarg)
+            printf (" with arg %s", optarg);
+          printf ("\n");
+          break;
+
+        case 'x':
+          po.xmap_filename = optarg;
+          po.xmap_set++;
+          break;
+
+        case 'y':
+          po.ymap_filename = optarg;
+          po.ymap_set++;
+          break;
+        case 'h':
+          po.height = atoi(optarg);
+          po.height_set++;
+          break;
+        case 'w':
+          po.width = atoi(optarg);
+          po.width_set++;
+          break;
+        case 'c':
+          po.cols = atoi(optarg);
+          po.cols_set++;
+          break;
+        case 'r':
+          po.rows = atoi(optarg);
+          po.rows_set++;
+          break;
+        case 'b':
+          po.crop = atoi(optarg);
+          break;
+        case 'm':
+          if (strcmp(optarg, "front") == 0) 
+          {
+            po.mode = FRONT;
+          } 
+          else if (strcmp(optarg, "front235") == 0) 
+          {
+            po.mode = FRONT235;
+          } 
+          else if (strcmp(optarg, "down") == 0) 
+          {
+            po.mode = DOWN;
+          } 
+          else if (strcmp(optarg, "samsung_gear_360") == 0)
+          {
+            po.mode = SAMSUNG_GEAR_360;
+          }
+          else if (strcmp(optarg, "thetas") == 0)
+          {
+            po.mode = THETAS;
+          }
+          /* more else if clauses */
+          else /* default: */
+          {
+             printf("Camera mode %s not implemented \n",optarg); exit(1);
+          }
+          break;
+
+        case '?':
+          /* getopt_long already printed an error message. */
+        case 'q':
+          printf ("Usage: %s -x|--xmap FILE_x.pgm -y|--ymap FILE_y.pgm -h|--height 300 -w|--width 400 -r|--rows 600 -c|--cols 800 \n", argv[0]);
+          printf ("h,w is source size, r,c is targetsize \n");
+          exit(1);
+          break;
+
+        default:
+          abort ();
+        }
+    }
+
+  /* Instead of reporting ‘--verbose’
+     and ‘--brief’ as they are encountered,
+     we report the final status resulting from them. */
+  if(verbose_flag){
+    switch(po.mode){
+      case FRONT:   printf("Camera: Front proj\n"); break;
+      case FRONT235:   printf("Camera: Front 235 proj\n"); break;
+      case DOWN:   printf("Camera: Down proj\n"); break;
+      case SAMSUNG_GEAR_360: printf("Camera: samsung_gear_360\n"); break;
+      case THETAS: printf("Camera: Theta S\n"); break;
+      default: printf("Camera mode not in verbose, exiting\n"); exit(1);
+    }
+  }
+    /* Print any remaining command line arguments (not options). */
+    if (optind < argc)
+    {
+      printf ("ERROR: non-option ARGV-elements: ");
+      while (optind < argc)
+        printf ("%s ", argv[optind++]);
+      putchar ('\n');
+      exit(1);
+    }
+  
+    if(po.xmap_set!=1||po.ymap_set!=1){ printf("ERROR: Xmap and ymap are mandatory arguments and have to appear only once!\ntry --help for help\n\n ");exit(-1);}
+    if(po.rows_set!=1||po.cols_set!=1){ printf("ERROR: Target Rows and Cols are mandatory arguments and have to appear only once!\ntry --help for help\n\n ");exit(-1);}
+    if(po.height_set!=1||po.width_set!=1){ printf("ERROR: Source Height and Width are mandatory arguments and have to appear only once!\ntry --help for help\n\n ");exit(-1);}
+    return po;
+
+
+#define MAXROWS 4500
+#define MAXCOLS 4500
+
+int pgmWrite_ASCII(char* filename, int rows,int cols,
+             int **image,char* comment_string) {
+      FILE* file;        /* pointer to the file buffer */
+//      int maxval;        /* maximum value in the image array */
+      long nwritten = 0; /* counter for the number of pixels written */
+      long x,y;          /* for loop counters */
+
+      /* return 0 if the dimensions are larger than the image array. */
+      if (rows > MAXROWS || cols > MAXCOLS) {
+           printf ("ERROR: row/col specifications larger than image array:\n");
+           return (0);
+      }
+
+      /* open the file; write header and comments specified by the user. */
+      if ((file = fopen(filename, "w")) == NULL)        {
+           printf("ERROR: file open failed\n");
+           return(0);
+      }
+      fprintf(file,"P2\n");
+
+      if (comment_string != NULL) fprintf(file,"# %s \n", comment_string);
+    
+      /* write the dimensions of the image */   
+      fprintf(file,"%i %i \n", cols, rows);
+
+      /* NOTE: MAXIMUM VALUE IS WHITE; COLOURS ARE SCALED FROM 0 - */
+      /* MAXVALUE IN A .PGM FILE. */
+      
+      /* WRITE MAXIMUM VALUE TO FILE */
+      fprintf(file, "%d\n", (int)65535);
+
+      /* Write data */
+
+  for (y = 0; y<rows;y++){
+    for (x = 0; x < cols; x++){
+      fprintf(file,"%i ",image[y][x]);
+      nwritten++;
+    }
+  fprintf(file,"\n");
+  }
+  fprintf(file,"\n");
+
+      
+      printf ("\nNumber of pixels total(from rows*cols): %i\n",rows*cols);
+      printf ("Number of pixels written in file %s: %ld\n\n",filename,nwritten); 
+
+      fclose(file);
+      return(1);
+}
+
+
+
+
+/* So, to get the x’,y’ position for the circular image we will have to first pass the 
+ * coordinates x,y from the rectangular output image to spherical coordinates using the
+ * first coordinate system, then those to the second shown spherical coordinate system, 
+ * then those to the polar projection and then pass the polar system to cardinal x’,y’.
+ */
+double2 evaluatePixel_Front(double2 outCoord, double2 srcSize)
+{
+        double2 o;
+        double theta,phi;
+        double3 sphericCoords;
+        double phi2_over_pi;
+        double theta2;
+        double2 inCentered;
+
+//convert outcoords to radians (180 = pi, so half a sphere)
+        o.x = outCoord.x / srcSize.x; 
+        o.y = outCoord.y / srcSize.y; 
+        theta = (1.0-o.x) * M_PI; 
+        phi = o.y * M_PI;
+
+//Convert outcoords to spherical (x,y,z on unisphere)
+        sphericCoords.x = cos(theta)*sin(phi);
+        sphericCoords.y = sin(theta)*sin(phi);
+        sphericCoords.z = cos(phi);
+        
+//Convert spherical to input coordinates...
+        theta2 = atan2(-sphericCoords.z,sphericCoords.x);
+        phi2_over_pi = acos(sphericCoords.y)/(M_PI);
+        
+        inCentered.x = ((phi2_over_pi*cos(theta2))+0.5)*srcSize.x;
+        inCentered.y = ((phi2_over_pi*sin(theta2))+0.5)*srcSize.y;
+        
+        return inCentered;
+}
+
+
+void gen_front_maps(configuration cfg,int** image_x,int** image_y ){
+    int x,y;
+
+  printf("Front proj\n");
+  for (y = 0; y<cfg.rows;y++){
+    for (x = 0; x < cfg.cols; x++){
+      double2 o = evaluatePixel_Front((double2){((double)x/((double)cfg.cols)) * ((cfg.width)-(2*cfg.crop)),
+                                                ((double)y/(double)cfg.rows)   * ((cfg.height)  -(2*cfg.crop))}, 
+                                      (double2){(cfg.width)-(2*cfg.crop), cfg.height-(2*cfg.crop)});
+      image_x[y][x] = (int)round(o.x)+cfg.crop;
+      image_y[y][x] = (int)round(o.y)+cfg.crop;
+    }
+  }
+}
+
+
+int
+main (int argc, char **argv)
+{
+    int y;
+    int** image_x;
+    int** image_y;
+    configuration cfg = parse_options(argc,argv);
+
+
+    if(cfg.xmap_filename)  printf("xmapfile: %s\n",cfg.xmap_filename);
+    if(cfg.ymap_filename)  printf("ymapfile: %s\n",cfg.ymap_filename);
+
+      image_x = malloc((cfg.rows)*sizeof(*image_x));
+      for(y=0;y<(cfg.rows);y++) image_x[y]= malloc((cfg.cols)*sizeof(*(image_x[y])));
+      image_y = malloc((cfg.rows)*sizeof(*image_y));
+      for(y=0;y<(cfg.rows);y++) image_y[y]= malloc((cfg.cols)*sizeof(*(image_y[y])));
+
+
+    switch(cfg.mode){
+      case FRONT:    gen_front_maps(cfg,image_x,image_y); break;
+/*      case FRONT235:    gen_front235_maps(cfg,image_x,image_y); break;
+      case DOWN:    gen_down_maps(cfg,image_x,image_y); break;
+      case SAMSUNG_GEAR_360: gen_samsung_gear_360_maps(cfg,image_x,image_y); break;
+      case THETAS: gen_thetas_maps(cfg,image_x,image_y); break;
+*/
+      default: printf("Camera mode not implemented\n"); exit(1);
+
+    }
+
+
+
+
+  printf("Writing files\n");
+  pgmWrite_ASCII(cfg.ymap_filename, cfg.rows,cfg.cols,image_y,cfg.ymap_filename);
+  pgmWrite_ASCII(cfg.xmap_filename, cfg.rows,cfg.cols,image_x,cfg.xmap_filename);
+
+    if(image_y){
+         for (y = 0; y<cfg.rows;y++) free(image_y[y]);
+       free(image_y);
+    }
+    if(image_x){
+         for (y = 0; y<cfg.rows;y++) free(image_x[y]);
+       free(image_x);
+    }
+
+
+    exit (0);
+}
+
+}}}
+}}}