Changeset 32695 for trunk/Ohana/src/kapa2

Timestamp:

Nov 17, 2011, 2:17:35 PM (15 years ago)

Author:

eugene

Message:

fix psphotStack 2nd pass (subtract 1st pass sources from the correct image); fix PS color plotting; plug a leak in psphotStack

Location:

trunk

Files:

• . (modified) (1 prop)
• Ohana/src/kapa2/doc/color.image.ps (copied) (copied from branches/eam_branches/ipp-20111110/Ohana/src/kapa2/doc/color.image.ps )
• Ohana/src/kapa2/include/prototypes.h (modified) (1 diff)
• Ohana/src/kapa2/include/structures.h (modified) (1 diff)
• Ohana/src/kapa2/src/PSPixmap.c (modified) (2 diffs)
• Ohana/src/kapa2/src/PSimage.c (modified) (2 diffs)
• Ohana/src/kapa2/src/Sections.c (modified) (1 diff)
• Ohana/src/kapa2/src/SetUpGraphic.c (modified) (1 diff)
• Ohana/src/kapa2/src/bDrawImage.c (modified) (2 diffs)
• Ohana/src/kapa2/src/bDrawIt.c (modified) (1 diff)

trunk/Ohana/src/kapa2/include/prototypes.h

@@ -126 +126 @@
 void          PSPixmap24          PROTO((Graphic *graphic, KapaImageWidget *image, FILE *f));
 void          PSPixmap32          PROTO((Graphic *graphic, KapaImageWidget *image, FILE *f));
+void          PSPixmap_3byte      PROTO((Graphic *graphic, KapaImageWidget *image, FILE *f));
 
 /* kapa bDraw Functions */

trunk/Ohana/src/kapa2/include/structures.h

@@ -26 +26 @@
   XFontStruct   *font;
   Cursor         cursor;
-  int            x,  y;
-  unsigned int   dx, dy;
+  int            x,  y;       // corner coord in X world coords
+  unsigned int   dx, dy;      // size of window in X coords
+  int            xwin, ywin;  // corner coord of display subregion (eg, png, ps plot)
+  int            dxwin, dywin; // corner coord of display subregion (eg, png, ps plot)
   CCNode        *cube;
   XColor        *cmap;

trunk/Ohana/src/kapa2/src/PSPixmap.c

@@ -1 +1 @@
 # include "Ximage.h"
-
-// XXX this stuff has been broken by the conversion to the pixmap stuff
 
 void PSPixmap8 (Graphic *graphic, KapaImageWidget *image, FILE *f) {
@@ -146 +144 @@
 }
 
-# if (0)
-// XXX needs work!
-void PSPixmap32_RGB (Graphic *graphic, KapaImageWidget *image, FILE *f) {
-
-  int i, k, m, val;
-  double Nchar, Npix, start, slope, frac;
-  unsigned int *buff;
-  unsigned long back;
-  unsigned char 
-
-  ALLOCATE (pixelR, unsigned char, graphic[0].Npixels);
-  ALLOCATE (pixelG, unsigned char, graphic[0].Npixels);
-  ALLOCATE (pixelB, unsigned char, graphic[0].Npixels);
+# define WHITE_R 255
+# define WHITE_G 255
+# define WHITE_B 255
+
+void PSPixmap_3byte (Graphic *graphic, KapaImageWidget *image, FILE *f) {
+
+  int i, j, ii, jj;
+  int i_start, i_end, j_start, j_end;
+  int I_start, J_start;
+  int dropback;  /* this is a bit of a kludge... */
+  int dx, dy, DX, DY, inDX, inDY, Xs, Ys;
+  int expand_in, expand_out;
+  double expand, Ix, Iy;
+  unsigned short *in_pix, *in_pix_ref;
+  unsigned char *pixel1, *pixel2, *pixel3;
+
+  if (image == NULL) return;
+
+  ALLOCATE (pixel1, unsigned char, graphic[0].Npixels);
+  ALLOCATE (pixel2, unsigned char, graphic[0].Npixels);
+  ALLOCATE (pixel3, unsigned char, graphic[0].Npixels);
 
   /** cmap[i].pixel must be defined even if X is not used **/
   for (i = 0; i < graphic[0].Npixels; i++) { /* set up pixel array */
-    pixelR[i] = graphic[0].cmap[i].red >> 8;
-    pixelG[i] = graphic[0].cmap[i].green >> 8;
-    pixelB[i] = graphic[0].cmap[i].blue >> 8;
-  }
-
-  for (i = 0; i < image[0].picture.dy; i++) {
-    for (k = 0; k < image[0].picture.dx; k++, buff++) {
-      if (*buff == back) 
-        val = Nchar;
-      else {
-        for (m = 0; (graphic[0].cmap[m].pixel != *buff) && (m < Npix); m++);
-        val = Nchar - frac * MIN (MAX (start + m * slope, 0), Npix);
-      }
-      fprintf (f, "%02x", val);
-      if (!((k+1) % 40)) fprintf (f, "\n"); 
-    }
-    fprintf (f, "\n");
-    buff -= 2*image[0].picture.dx;
-  }
-  return;
-}
-# endif
+    pixel1[i] = graphic[0].cmap[i].red >> 8;
+    pixel2[i] = graphic[0].cmap[i].green >> 8;
+    pixel3[i] = graphic[0].cmap[i].blue >> 8;
+  }
+
+  assert ((image[0].picture.expand >= 1) || (image[0].picture.expand <= -2));
+  expand = expand_in = expand_out = 1.0;
+  if (image[0].picture.expand > 0) {
+    expand = 1 / (1.0*image[0].picture.expand);
+    expand_out = image[0].picture.expand;
+    expand_in  = 1;
+  }
+  if (image[0].picture.expand < 0) {
+    expand = fabs((double)image[0].picture.expand);
+    expand_out = 1;
+    expand_in  = -image[0].picture.expand;
+  }
+
+  Xs = image[0].picture.x;
+  Ys = image[0].picture.y;
+  dx = image[0].picture.dx;
+  dy = image[0].picture.dy;
+  DX = image[0].image[0].matrix.Naxis[0];
+  DY = image[0].image[0].matrix.Naxis[1];
+
+  // i_start, j_start are the closest lit screen pixel to 0,0
+  // I_start, J_start are the image pixel corresponding to i_start, j_start
+  Picture_Lower (&i_start, &j_start, &I_start, &J_start, &image[0].image[0].matrix, &image[0].picture);
+
+  // i_end, j_end are the closest lit screen pixel to dx, dy
+  // I_end, J_end are the image pixel corresponding to i_end, j_end
+  Picture_Upper (&i_end, &j_end, i_start, j_start, &image[0].image[0].matrix, &image[0].picture);
+
+  assert (i_start <= i_end);
+  assert (j_start <= j_end);
+
+  Ix = image[0].picture.flipx ? I_start - 1 : I_start;
+  Iy = image[0].picture.flipy ? J_start - 1 : J_start;
+
+  inDX = image[0].picture.flipx ? -1 : +1;
+  inDY = image[0].picture.flipy ? -1 : +1;
+
+  dropback = expand_out - (i_end - i_start) % expand_out;
+  if ((i_end - i_start) % expand_out == 0) dropback = 0;
+
+  in_pix_ref  = &image[0].pixmap[DX*(int)MAX(Iy,0) + (int)MAX(Ix,0)];
+
+  /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
+
+  // add in occasional return chars
+
+  /**** fill in bottom area ****/
+  for (j = 0; j < j_start; j++) {
+    for (i = 0; i < dx; i++) {
+      fprintf (f, "%02x%02x%02x", WHITE_R, WHITE_G, WHITE_B);
+    }
+  }
+  
+  // probably could do this all smarter with scale operations in PS...
+
+  /*** fill in the image data region ***/
+  for (j = j_start; j < j_end; j+= expand_out, in_pix_ref += inDY*expand_in*DX) {
+    
+    // repeat the section below 'expand_out' times
+    for (jj = 0; jj < expand_out; jj++) {
+
+      /* create one output image line */
+      in_pix = in_pix_ref;
+
+      /**** fill in area to the left of the picture ****/
+      for (i = 0; i < i_start; i++) {
+        fprintf (f, "%02x%02x%02x", WHITE_R, WHITE_G, WHITE_B);
+      }
+    
+      /*** fill in the picture region ***/
+      for (i = i_start; i < i_end; i+=expand_out, in_pix += inDX*expand_in) {
+        for (ii = 0; ii < expand_out; ii++) {
+          fprintf (f, "%02x%02x%02x", pixel1[*in_pix], pixel2[*in_pix], pixel3[*in_pix]);
+        }
+      }
+    
+      /**** fill in area to the right of the picture ****/
+      for (i = i_end; i < dx; i++) {
+        fprintf (f, "%02x%02x%02x", WHITE_R, WHITE_G, WHITE_B);
+      }
+    }
+  }
+
+  /**** fill in top area ****/
+  for (j = j_end; j < dy; j++) {
+    for (i = 0; i < dx; i++) { 
+      fprintf (f, "%02x%02x%02x", WHITE_R, WHITE_G, WHITE_B);
+    }
+  }
+
+  free (pixel1);
+  free (pixel2);
+  free (pixel3);
+
+  return;
+}

trunk/Ohana/src/kapa2/src/PSimage.c

@@ -13 +13 @@
   graphic = GetGraphic();
 
+  // Update this to generate color PS images: I need to test if the image if color or BW (based
+  // on the colormap).  If it is a color image, I need to generate a 24 bit image. the header
+  // should look the same (Nx Ny 8 [1 0 0 1 0 0]) but then it should finish with "false 3
+  // colorimage" instead of just "image" (see ../doc/color.image.s for an example).  the hex
+  // string needs to have RGB represented as chars (2 hex chars per R,G,B). 
+  // the values come from the following map: image[0].pixmap[i] -> cmap[pixel].red -> R (0-255)
+
   fprintf (f, " newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath\n\n", 
            (int) image[0].picture.x,                       graphic->dy - (int) image[0].picture.y, 
@@ -21 +28 @@
   fprintf (f, "%d %d translate\n", (int) image[0].picture.x, graphic->dy - (int) image[0].picture.y - image[0].picture.dy);
   fprintf (f, "%d %d 8\n", image[0].picture.dx, image[0].picture.dy);
-  fprintf (f, "[1 0 0 1 0 0]\n");
+  fprintf (f, "[1 0 0 -1 0 %d]\n", image[0].picture.dy);
+  // write out the image in normal order, but flip in PS
+
+# if (0)
+
   fprintf (f, "{currentfile %d string readhexstring pop} image\n\n", image[0].picture.dx);
+  PSPixmap_1byte (graphic, image, f);
 
-  /******** First we draw the picture itself ********/
-  /* in !USE_XWINDOW, we'll have to change this to use the JPEG function */
-  switch (graphic[0].Nbits) {
-  case 8:
-    PSPixmap8 (graphic, image, f);
-    break;
-  case 16:
-    PSPixmap16 (graphic, image, f);
-    break;
-  case 24:
-    PSPixmap24 (graphic, image, f);
-    break;
-  case 32:
-    PSPixmap32 (graphic, image, f);
-    break;
-  }
+# else
+
+  fprintf (f, "{currentfile %d string readhexstring pop} false 3 colorimage\n\n", 3*image[0].picture.dx);
+  PSPixmap_3byte (graphic, image, f);
+
+# endif
 
   fprintf (f, "grestore %% end of image\n");

trunk/Ohana/src/kapa2/src/Sections.c

@@ -237 +237 @@
   return (TRUE);
 }
+
+int SectionMinBoundary (Graphic *graphic) {
+
+    int i;
+    int Xs = graphic->dx;
+    int Ys = graphic->dy;
+    int Xe = 0;
+    int Ye = 0;
+
+    // the boundary for a single section should probably be adjusted depending on the 
+    // image status (should not include the imtool portion)
+    for (i = 0; i < Nsections; i++) {
+        Xs = MIN (Xs, sections[i][0].x);
+        Ys = MIN (Ys, sections[i][0].y);
+        Xe = MAX (Xe, sections[i][0].x + sections[i][0].dx);
+        Ye = MAX (Ye, sections[i][0].y + sections[i][0].dy);
+    }
+
+    if ((Xs >= Xe) || (Ys >- Ye)) {
+        // default values for the region window
+        graphic->xwin  = 0;
+        graphic->ywin  = 0;
+        graphic->dxwin = graphic->dx;
+        graphic->dywin = graphic->dy; 
+    }   
+    
+    // set min/max boundary (min window containing max range of sections)
+    graphic->xwin = Xs;
+    graphic->ywin = Ys;
+    graphic->dxwin = Xe - Xs;
+    graphic->dywin = Ye - Ys;
+    return TRUE;
+}

trunk/Ohana/src/kapa2/src/SetUpGraphic.c

@@ -16 +16 @@
   graphic->dx = 512;
   graphic->dy = 512; 
+
+  // default values for the region window
+  graphic->xwin  = 0;
+  graphic->ywin  = 0;
+  graphic->dxwin = graphic->dx;
+  graphic->dywin = graphic->dy; 
 
   if (!USE_XWINDOW) {

trunk/Ohana/src/kapa2/src/bDrawImage.c

@@ -47 +47 @@
   }
 
-  Xs = image[0].picture.x;
-  Ys = image[0].picture.y;
+  // Xs,Ys are in full-frame coords.  can we trim here?
+  Xs = image[0].picture.x - graphic[0].xwin;
+  Ys = image[0].picture.y - graphic[0].ywin;
   dx = image[0].picture.dx;
   dy = image[0].picture.dy;
@@ -54 +55 @@
   DY = image[0].image[0].matrix.Naxis[1];
 
+  // the created buffer is supposed to contain the output windows
   if (buffer[0].Nx < Xs + dx) {
     fprintf (stderr, "invalid condition\n");

trunk/Ohana/src/kapa2/src/bDrawIt.c

@@ -13 +13 @@
   black = KapaColorByName ("black");
 
-  buffer = bDrawBufferCreate (graphic->dx, graphic->dy, Nbyte, palette, Npalette);
+  // SectionMinBoundary (graphic);
+
+  // if we want to trim, we'll need to carry about the start in graphic coords and
+  // the dx,dy size.  
+  buffer = bDrawBufferCreate (graphic->dxwin, graphic->dywin, Nbyte, palette, Npalette);
   bDrawSetStyle (buffer, black, 0, 0);