tioga 1.4

data/split/Tioga/pdffile.c

@@ -0,0 +1,342 @@
+/* pdffile.c */
+/*
+   Copyright (C) 2005  Bill Paxton
+
+   This file is part of Tioga.
+
+   Tioga is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Tioga is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Tioga; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <time.h>
+#include "figures.h"
+#include "pdfs.h"
+
+#define FLATE_ENCODE 1
+
+#define Get_pdf_xoffset()  5.0
+#define Get_pdf_yoffset()  5.0
+
+char *predefined_Fonts[] = { /* must match the font numbers in FigureConstants.rb */
+   NULL,
+   "Times-Roman",
+   "Times-Italic", // 2
+   "Times-Bold",
+   "Times-BoldItalic",
+   "Helvetica",
+   "Helvetica-Oblique", // 6
+   "Helvetica-Bold",
+   "Helvetica-BoldOblique",
+   "Courier",
+   "Courier-Oblique",  // 10
+   "Courier-Bold",
+   "Courier-BoldOblique",
+   "Symbol",
+   "ZapfDingbats" // 14
+   };
+int num_predefined_fonts = 14;
+int num_pdf_standard_fonts = 14;
+
+long int *obj_offsets, capacity_obj_offsets, stream_start, stream_end, length_offset, xref_offset;
+int num_objects, next_available_object_number, next_available_gs_number, next_available_xo_number;
+int next_available_shade_number, next_available_font_number;
+Stroke_Opacity_State *stroke_opacities = NULL;
+Fill_Opacity_State *fill_opacities = NULL;
+XObject_Info *xobj_list = NULL;
+Function_Info *functions_list;
+Shading_Info *shades_list = NULL;
+Font_Dictionary *font_dictionaries = NULL;
+Old_Font_Dictionary *old_font_dictionaries = NULL;
+FILE *OF = NULL; // for the PDF file
+FILE *TF = NULL; // for the temp file
+
+/* PDF File Management */
+
+void Free_XObjects(void)
+{
+   XObject_Info *xo;
+   while (xobj_list != NULL) {
+      xo = xobj_list;
+      xobj_list = xo->next;
+      switch (xo->xobj_subtype) {
+         case JPG_SUBTYPE: Free_JPG((JPG_Info *)xo); break;
+         case SAMPLED_SUBTYPE: Free_Sampled((Sampled_Info *)xo); break;
+         default: rb_raise(rb_eArgError, "Invalid XObject subtype (%i)", xo->xobj_subtype);
+      }
+      free(xo);
+   }
+}
+
+void Init_pdf(void)
+{
+   int i;
+   writing_file = false;
+   capacity_obj_offsets = 1000;
+   num_objects = 0;
+   obj_offsets = ALLOC_N(long int, capacity_obj_offsets);
+   for (i=0; i < capacity_obj_offsets; i++) obj_offsets[i] = 0;
+}
+
+void Record_Object_Offset(int obj_number)
+{
+   long int offset = ftell(OF);
+   if (obj_number >= capacity_obj_offsets) {
+      int size_increment = 50, i;
+      REALLOC_N(obj_offsets, long int, obj_number + size_increment);
+      capacity_obj_offsets = obj_number + size_increment;
+      for (i=num_objects; i < capacity_obj_offsets; i++) obj_offsets[i] = 0;
+   }
+   obj_offsets[obj_number] = offset;
+   if (obj_number >= num_objects) num_objects = obj_number + 1;
+}
+
+static void Write_XObjects(void)
+{
+   XObject_Info *xo;
+   for (xo = xobj_list; xo != NULL; xo = xo->next) {
+      Record_Object_Offset(xo->obj_num);
+      fprintf(OF, "%i 0 obj << /Type /XObject ", xo->obj_num);
+      switch (xo->xobj_subtype) {
+         case JPG_SUBTYPE: Write_JPG((JPG_Info *)xo); break;
+         case SAMPLED_SUBTYPE: Write_Sampled((Sampled_Info *)xo); break;
+         default: rb_raise(rb_eArgError, "Invalid XObject subtype (%i)", xo->xobj_subtype);
+      }
+      fprintf(OF, ">> endobj\n");
+   }
+}
+
+#define INFO_OBJ 1
+#define PAGES_OBJ 2
+#define STREAM_OBJ 3
+#define PAGE_OBJ 4
+#define CATALOG_OBJ 5
+#define FIRST_OTHER_OBJ 6
+
+static void Free_Records()
+{
+   Free_Stroke_Opacities(); Free_Fill_Opacities(); Free_XObjects(); Free_Shadings(); Free_Functions();
+}
+
+static void Get_pdf_name(char *ofile, char *filename, int maxlen)
+{
+   char *dot;
+   strncpy(ofile, filename, maxlen);
+   dot = strrchr(ofile,'.');
+   if (dot != NULL) dot[0] = '\0';
+   strcat(ofile, "_figure.pdf");
+}
+
+void Open_pdf(VALUE fmkr, char *filename, bool quiet_mode)
+{
+   FM *p = Get_FM(fmkr);
+   int i;
+   if (writing_file) rb_raise(rb_eArgError, "Sorry: cannot start a new output file until finish current one.");
+   Clear_Fonts_In_Use_Flags();
+   Free_Records(); 
+   next_available_object_number = FIRST_OTHER_OBJ;
+   next_available_font_number = num_predefined_fonts + 1;
+   next_available_gs_number = 1;
+   next_available_xo_number = 1;
+   next_available_shade_number = 1;
+   writing_file = true;
+   time_t now = time(NULL);
+   char ofile[300], timestring[100];
+   Get_pdf_name(ofile, filename, 300);
+   if ((OF = fopen(ofile, "w")) == NULL)
+       rb_raise(rb_eArgError, "Sorry: can't open %s.\n", filename);
+   if ((TF = tmpfile()) == NULL)
+       rb_raise(rb_eArgError, "Sorry: can't create temp file for writing PDF file %s.\n", filename);
+   /* open PDF file and write header */
+   fprintf(OF, "%%PDF-1.4\n");
+   strcpy(timestring, ctime(&now));
+   i = strlen(timestring);
+   if (i > 0) timestring[i-1] = '\0';
+   Record_Object_Offset(INFO_OBJ);
+   fprintf(OF, "%i 0 obj <<\n/Creator (Tioga)\n/CreationDate (%s)\n>>\nendobj\n", INFO_OBJ, timestring);
+   Record_Object_Offset(PAGES_OBJ);
+   fprintf(OF, "%i 0 obj <<\n/Type /Pages\n/Kids [%i 0 R]\n/Count 1\n>> endobj\n", PAGES_OBJ, PAGE_OBJ);
+   Record_Object_Offset(STREAM_OBJ);
+   if (FLATE_ENCODE)
+      fprintf(OF, "%i 0 obj <<\t/Filter /FlateDecode   /Length ", STREAM_OBJ);
+   else
+      fprintf(OF, "%i 0 obj <<\t/Length ", STREAM_OBJ);
+   length_offset = ftell(OF);
+   fprintf(OF, "             \n>>\nstream\n");
+   stream_start = ftell(OF);
+   fprintf(TF, "%.2f 0 0 %.2f %.2f %.2f cm\n", 1.0/ENLARGE, 1.0/ENLARGE,
+      Get_pdf_xoffset(), Get_pdf_yoffset());
+   /* set stroke and fill colors to black */
+   have_current_point = constructing_path = false;
+   c_line_width_set(p, p->line_width);
+   c_line_cap_set(p, p->line_cap);
+   c_line_join_set(p, p->line_join);
+   c_miter_limit_set(p, p->miter_limit);
+   FM_line_type_set(fmkr, p->line_type);
+   FM_stroke_color_set(fmkr, p->stroke_color);
+   FM_fill_color_set(fmkr, p->fill_color);
+   // initialize clip region
+   bbox_llx = bbox_lly = 1e5;
+   bbox_urx = bbox_ury = -1e5;
+}
+
+void Start_Axis_Standard_State(FM *p, VALUE color, double line_width) {
+   fprintf(TF, "q 2 J [] 0 d\n");
+   c_line_width_set(p, line_width);
+   if (color != Qnil)
+      FM_stroke_color_set(p->fm, color);
+   else
+      fprintf(TF, "0 0 0 RG\n"); // black
+   /* 2 J sets the line cap style to square cap */
+   /* set stroke and fill colors to black.  set line type to solid */
+}
+
+void End_Axis_Standard_State(void) { Write_grestore(); }
+
+void Write_gsave(void)
+{
+   fprintf(TF, "q\n");
+}
+
+void Write_grestore(void)
+{
+   fprintf(TF, "Q\n");
+}
+
+void Print_Xref(long int offset) {
+   char line[80];
+   int i, len;
+   sprintf(line, "%li", offset);
+   len = strlen(line);
+   for (i=0; i < 10-len; i++) fputc('0', OF);
+   fprintf(OF, "%s 00000 n \n", line);
+   }
+
+static void Write_Stream(void)
+{
+   long int len = ftell(TF);
+   unsigned long int new_len = (len * 11) / 10 + 100;
+   unsigned char *buffer, *dest_buffer;
+   rewind(TF);
+   buffer = ALLOC_N(unsigned char, len+1);
+   dest_buffer = ALLOC_N(unsigned char, new_len+1);
+   fread(buffer, 1, len, TF);
+   fclose(TF);
+   if (FLATE_ENCODE) {
+      if (flate_compress(dest_buffer, &new_len, buffer, len) != FLATE_OK) {
+         free(buffer); free(dest_buffer);
+         rb_raise(rb_eArgError, "Error compressing PDF stream data");
+      }
+      fwrite(dest_buffer, 1, new_len, OF);
+   } else {
+      fwrite(buffer, 1, len, OF);
+   } 
+   free(buffer); free(dest_buffer);
+}
+
+void Close_pdf(VALUE fmkr, bool quiet_mode)
+{
+   FM *p = Get_FM(fmkr);
+   int i;
+   double llx, lly, urx, ury, xoff, yoff;
+   if (!writing_file) rb_raise(rb_eArgError, "Sorry: cannot End_Output if not writing file.");
+   writing_file = false;
+   if (constructing_path) rb_raise(rb_eArgError, "Sorry: must finish with current path before ending file");
+   Write_Stream();
+   stream_end = ftell(OF);
+   fprintf(OF, "endstream\nendobj\n");
+   Record_Object_Offset(PAGE_OBJ);
+   fprintf(OF, "%i 0 obj <<\n/Type /Page\n/Parent %i 0 R\n/MediaBox [ ", PAGE_OBJ, PAGES_OBJ);
+   if (bbox_llx < p->page_left) bbox_llx = p->page_left;
+   if (bbox_lly < p->page_bottom) bbox_lly = p->page_bottom;
+   if (bbox_urx > p->page_left + p->page_width) bbox_urx = p->page_left + p->page_width;
+   if (bbox_ury > p->page_bottom + p->page_height) bbox_ury = p->page_bottom + p->page_height;
+//#define MARGIN 3
+#define MARGIN 0
+   xoff = Get_pdf_xoffset();
+   yoff = Get_pdf_yoffset();
+   llx = bbox_llx / ENLARGE + xoff - MARGIN;  // convert back to points
+   lly = bbox_lly / ENLARGE + yoff - MARGIN;
+   urx = bbox_urx / ENLARGE + xoff + MARGIN;
+   ury = bbox_ury / ENLARGE + yoff + MARGIN;
+   if (urx < llx || ury < lly) rb_raise(rb_eArgError, "Sorry: Empty plot!");
+   fprintf(OF, "%d %d %d %d", ROUND(llx), ROUND(lly), ROUND(urx), ROUND(ury));
+   fprintf(OF, " ]\n/Contents %i 0 R\n/Resources << /ProcSet [/PDF /Text /ImageB /ImageC /ImageI]\n", STREAM_OBJ);
+   if (Used_Any_Fonts()) {
+      Font_Dictionary *f;      
+      fprintf(OF, "    /Font <<\n     ");
+      for (f = font_dictionaries; f != NULL; f = f->next) {
+         if (!f->in_use) continue;
+         fprintf(OF, "      /F%i %i 0 R\n", f->font_num, f->obj_num);
+      }
+      fprintf(OF, "    >>\n"); // end of /Font
+   }
+   if (fill_opacities != NULL || stroke_opacities != NULL) { // ExtGstate objects go here
+      Fill_Opacity_State *pf;
+      Stroke_Opacity_State *ps;
+      fprintf(OF, "    /ExtGState <<\n");
+      for (ps = stroke_opacities; ps != NULL; ps = ps->next) {
+         fprintf(OF, "      /GS%i %i 0 R\n", ps->gs_num, ps->obj_num);
+      }
+      for (pf = fill_opacities; pf != NULL; pf = pf->next) {
+         fprintf(OF, "      /GS%i %i 0 R\n", pf->gs_num, pf->obj_num);
+      }
+      fprintf(OF, "    >>\n"); // end of /ExtGState
+   }
+   if (xobj_list != NULL) { // Xobjects go here
+      XObject_Info *xo;
+      fprintf(OF, "    /XObject <<\n");
+      for (xo = xobj_list; xo != NULL; xo = xo->next) {
+         fprintf(OF, "      /XObj%i %i 0 R\n", xo->xo_num, xo->obj_num);
+      }
+      fprintf(OF, "    >>\n"); // end of /XObject
+   }
+   if (shades_list != NULL) { // Shadings go here
+      Shading_Info *so;
+      fprintf(OF, "    /Shading <<\n");
+      for (so = shades_list; so != NULL; so = so->next) {
+         fprintf(OF, "      /Shade%i %i 0 R\n", so->shade_num, so->obj_num);
+      }
+      fprintf(OF, "    >>\n"); // end of /Shading
+   }
+   fprintf(OF, "  >>\n"); // end of /Resources
+   fprintf(OF, ">> endobj\n");
+   Record_Object_Offset(CATALOG_OBJ);
+   fprintf(OF, "%i 0 obj <<\n/Type /Catalog\n/Pages %i 0 R\n>> endobj\n", CATALOG_OBJ, PAGES_OBJ);
+   Write_Font_Dictionaries();
+   Write_Font_Descriptors();
+   Write_Font_Widths();
+   Write_Stroke_Opacity_Objects();
+   Write_Fill_Opacity_Objects();
+   Write_XObjects();
+   Write_Functions();
+   Write_Shadings();
+   xref_offset = ftell(OF);
+   fprintf(OF, "xref\n0 %i\n0000000000 65535 f \n", num_objects);
+   for (i = 1; i < num_objects; i++) Print_Xref(obj_offsets[i]); // NB: DONT USE OBJECT 0
+   fprintf(OF, "trailer\n<<\n/Size %i\n/Root %i 0 R\n/Info %i 0 R\n>>\nstartxref\n%li\n%%%%EOF\n",
+      num_objects, CATALOG_OBJ, INFO_OBJ, xref_offset);
+   fseek(OF, length_offset, SEEK_SET);
+   fprintf(OF, "%li", stream_end - stream_start);
+   fclose(OF);
+   Free_Records(); 
+}
+
+void Rename_pdf(char *oldname, char *newname)
+{
+   char old_ofile[300], new_ofile[300];
+   Get_pdf_name(old_ofile, oldname, 300);
+   Get_pdf_name(new_ofile, newname, 300);
+   rename(old_ofile, new_ofile); // from stdio.h
+}
+

data/split/Tioga/pdfimage.c

@@ -0,0 +1,536 @@
+/* pdfimage.c */
+/*
+   Copyright (C) 2005  Bill Paxton
+
+   This file is part of Tioga.
+
+   Tioga is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Library Public License as published
+   by the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   Tioga is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with Tioga; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "figures.h"
+#include "pdfs.h"
+
+/*  Images
+
+   invoke image by "/Image_name Do" in the content stream
+   
+   the resources dictionary must have image object names in XObject dictionary
+      /ProcSet [/PDF /Text /ImageB /ImageC /ImageI]
+      /XObject <<
+         /Image_name 30 0 R
+         ...
+         >>
+         
+   30 0 obj <<
+      /Type /XObject
+      /Subtype /Image
+      /Width <integer>  number of columns.  required for all.
+      /Height <integer>  number of rows.  required for all.
+      /Length <integer>  number of bytes in image data stream.  required for all.
+      /Interpolate <boolean>  optional for all.
+      /SMask <stream>  optional for all.
+      ...
+   >>
+   stream
+   ...image data...
+   endstream
+   endobj
+   
+   For JPEG2000 images:
+      /Filter /JPXDecode
+      /Mask <image_mask_name>  for explicit masking.  optional.
+   
+   For JPEG images:
+      /Filter /DCTDecode
+      /ColorSpace <name or array>.  required.  /DeviceRGB ?
+      /BitsPerComponent 8
+      /Mask <image_mask_name>  for explicit masking.  optional.
+   
+   For sampled images:
+      /Filter <name>  whatever filter being used for the image data.  optional.
+      /ColorSpace <name or array>.  required.
+      /BitsPerComponent 8
+      /Mask <image_mask_name>  for explicit masking.  optional.
+      /Mask [min, max] for masking out specified sample values.
+         for example, you can use 0 to stand for "undefined", then setting /Mask [0 0] will cause all
+            0 valued samples to be masked out of the image.
+      
+   For image masks:
+      /ImageMask true
+      /BitsPerComponent 1
+      /Decode [0 1] means sample values of 0 are included in the output, values of 1 are excluded
+      /Decode [1 0] means sample values of 1 are included in the output, values of 0 are excluded
+      
+*/     
+   
+
+void Free_JPG(JPG_Info *xo)
+{
+   if (xo->filename != NULL) free(xo->filename);
+}
+
+void Free_Sampled(Sampled_Info *xo)
+{
+   if (xo->image_data != NULL) free(xo->image_data);
+   if (xo->lookup != NULL) free(xo->lookup);
+}
+
+static bool Is_monochrome(int obj_num)
+{
+   XObject_Info *xo;
+   for (xo = xobj_list; xo != NULL; xo = xo->next) {
+      if (xo->xobj_subtype == SAMPLED_SUBTYPE && xo->obj_num == obj_num) {
+         Sampled_Info *p = (Sampled_Info *)xo;
+         return (p->image_type == MONO_IMAGE);
+      }
+   }
+   return false;
+}
+
+static void Write_Image_From_File(char *filename, int width, int height, char *out_info, int mask_obj_num)
+{
+   FILE *jpg = fopen(filename, "r");
+   if (jpg == NULL) rb_raise(rb_eArgError, "Sorry: cannot open file for showing image (%s)\n", filename);
+   unsigned char *buff;
+   int len, rd_len;
+   int buff_len = 256000;
+   buff = ALLOC_N(unsigned char, buff_len);
+   len = 0;
+   while ((rd_len = fread(buff, 1, buff_len, jpg)) == buff_len) len += buff_len;
+   len += rd_len;
+   fprintf(OF, "\t/Subtype /Image\n");
+   if (mask_obj_num > 0) {
+      if (!Is_monochrome(mask_obj_num)) fprintf(OF, "\t/SMask %i 0 R\n", mask_obj_num);
+      else fprintf(OF, "\t/Mask %i 0 R\n", mask_obj_num);
+   }
+   fprintf(OF, "\t/Width %i\n", width);
+   fprintf(OF, "\t/Height %i\n", height);
+   fprintf(OF, "%s", out_info);
+   fprintf(OF, "\t/Length %i\n\t>>\nstream\n", len);
+   if (len < buff_len) fwrite(buff, 1, len, OF);
+   else {
+      rewind(jpg);
+      while ((rd_len = fread(buff, 1, buff_len, jpg)) == buff_len) fwrite(buff, 1, buff_len, OF);
+      fwrite(buff, 1, rd_len, OF);
+   }
+   fprintf(OF, "\nendstream\n");
+   fclose(jpg);
+}
+
+void Write_JPG(JPG_Info *xo)
+{
+   Write_Image_From_File(xo->filename, xo->width, xo->height, 
+      "\t/Filter /DCTDecode\n\t/ColorSpace /DeviceRGB\n\t/BitsPerComponent 8\n", xo->mask_obj_num);
+}
+
+void Write_Sampled(Sampled_Info *xo)
+{
+   fprintf(OF, "\n\t/Subtype /Image\n");
+   fprintf(OF, "\t/Filter /FlateDecode\n\t/Interpolate %s\n", (xo->interpolate)? "true":"false");
+   fprintf(OF, "\t/Height %i\n", xo->height);
+   fprintf(OF, "\t/Width %i\n", xo->width);
+   int i, len;
+   unsigned long new_len;
+   unsigned char *buffer;
+   switch (xo->image_type) {
+      case RGB_IMAGE:
+         fprintf(OF, "\t/ColorSpace /DeviceRGB\n");
+         fprintf(OF, "\t/BitsPerComponent 8\n");
+         break;
+      case CMYK_IMAGE:
+         fprintf(OF, "\t/ColorSpace /DeviceCMYK\n");
+         fprintf(OF, "\t/BitsPerComponent 8\n");
+         break;
+      case GRAY_IMAGE:
+         fprintf(OF, "\t/ColorSpace /DeviceGray\n");
+         fprintf(OF, "\t/BitsPerComponent 8\n");
+         break;
+      case MONO_IMAGE:
+         fprintf(OF, "\t/ImageMask true\n");
+         fprintf(OF, "\t/BitsPerComponent 1\n");
+         if (!xo->reversed) fprintf(OF, "\t/Decode [0 1]\n");
+         else fprintf(OF, "\t/Decode [1 0]\n");
+         break;
+      default:
+         len = xo->lookup_len;
+         fprintf(OF, "\t/ColorSpace [ /Indexed /DeviceRGB %i <", xo->hival);
+         for (i = 0; i < len; i++) {
+            unsigned char c = xo->lookup[i];
+            if (c == 0) fprintf(OF, "00");
+            else if (c < 16) fprintf(OF, "0%x", c);
+            else fprintf(OF, "%x", c);
+         }
+         fprintf(OF, "> ]\n");
+         fprintf(OF, "\t/BitsPerComponent 8\n");
+   }
+   if (xo->mask_obj_num > 0) {
+      if (xo->image_type == MONO_IMAGE)
+         rb_raise(rb_eArgError, "Sorry: monochrome images must not have masks");
+      if (!Is_monochrome(xo->mask_obj_num)) fprintf(OF, "\t/SMask %i 0 R\n", xo->mask_obj_num);
+      else fprintf(OF, "\t/Mask %i 0 R\n", xo->mask_obj_num);
+   }
+   if (xo->value_mask_min >= 0 && xo->value_mask_max >= 0 &&
+      xo->value_mask_min <= 255 && xo->value_mask_max <= 255 && xo->value_mask_min <= xo->value_mask_max)
+      fprintf(OF, "\t/Mask [%i %i]\n", xo->value_mask_min, xo->value_mask_max);
+   new_len = (xo->length * 11)/10 + 100;
+   buffer = ALLOC_N(unsigned char, new_len);
+   if (flate_compress(buffer, &new_len, xo->image_data, xo->length) != FLATE_OK) {
+      free(buffer);
+      rb_raise(rb_eArgError, "Error compressing image data");
+   }
+   fprintf(OF, "\t/Length %li\n", new_len);
+   fprintf(OF, "\t>>\nstream\n");
+   if (fwrite(buffer, 1, new_len, OF) < new_len)
+      rb_raise(rb_eArgError, "Error writing image data");
+   free(buffer);
+   fprintf(OF, "\nendstream\nendobj\n");
+}
+
+void Create_Transform_from_Points( // transform maps (0,0), (1,0), and (0,1) to the given points
+   double llx, double lly, double lrx, double lry, double ulx, double uly,
+   double *a, double *b, double *c, double *d, double *e, double *f)
+{
+   *e = llx; *f = lly; lrx -= llx; ulx -= llx; lry -= lly; uly -= lly;
+   *a = lrx; *b = lry; *c = ulx; *d = uly;
+}
+
+void Get_Image_Dest(FM *p, VALUE image_destination, double *dest)
+{
+   image_destination = rb_Array(image_destination);
+   if (RARRAY(image_destination)->len != 6)
+      rb_raise(rb_eArgError, "Sorry: invalid image destination array: must have 6 entries");
+   int i;
+   for (i = 0; i < 6; i++) {
+      VALUE entry = rb_ary_entry(image_destination, i);
+      entry = rb_Float(entry);
+      if (i % 2 == 0)
+         dest[i] = convert_figure_to_output_x(p,NUM2DBL(entry));
+      else
+         dest[i] = convert_figure_to_output_y(p,NUM2DBL(entry));
+   }
+}
+
+static void Show_JPEG(FM *p, char *filename, int width, int height, double *dest, int subtype, int mask_obj_num)
+{
+   JPG_Info *xo = ALLOC(JPG_Info);
+   xo->xobj_subtype = subtype;
+   double llx = dest[0], lly = dest[1], lrx = dest[2], lry = dest[3], ulx = dest[4],  uly = dest[5];
+   double a, b, c, d, e, f; // the transform to position the image
+   xo->next = xobj_list;
+   xobj_list = (XObject_Info *)xo;
+   xo->xo_num = next_available_xo_number++;
+   xo->obj_num = next_available_object_number++;
+   xo->filename = ALLOC_N(char, strlen(filename)+1);
+   strcpy(xo->filename, filename);
+   xo->width = width;
+   xo->height = height;
+   xo->mask_obj_num = mask_obj_num;
+   Create_Transform_from_Points(llx, lly, lrx, lry, ulx, uly, &a, &b, &c, &d, &e, &f);
+   fprintf(TF, "q %0.2f %0.2f %0.2f %0.2f %0.2f %0.2f cm /XObj%i Do Q\n", a, b, c, d, e, f, xo->xo_num);
+   update_bbox(p, llx, lly);
+   update_bbox(p, lrx, lry);
+   update_bbox(p, ulx, uly);
+   update_bbox(p, lrx+ulx-llx, lry+uly-lly);
+}
+
+void c_show_jpg(FM *p, char *filename, int width, int height, double *dest, int mask_obj_num)
+{
+   Show_JPEG(p, filename, width, height, dest, JPG_SUBTYPE, mask_obj_num);
+}
+
+VALUE FM_private_show_jpg(VALUE fmkr, VALUE filename, VALUE width, VALUE height, VALUE image_destination, VALUE mask_obj_num)
+{
+   double dest[6];
+   FM *p = Get_FM(fmkr);
+   if (constructing_path) rb_raise(rb_eArgError, "Sorry: must finish with current path before calling show_jpg");
+   Get_Image_Dest(p, image_destination, dest);
+   width = rb_Integer(width);
+   height = rb_Integer(height);
+   mask_obj_num = rb_Integer(mask_obj_num);
+   filename = rb_String(filename);
+   c_show_jpg(p, RSTRING(filename)->ptr, NUM2INT(width), NUM2INT(height), dest, NUM2INT(mask_obj_num));
+   return fmkr;
+}
+
+VALUE c_private_create_image_data(FM *p, double **data, long num_cols, long num_rows,
+            int first_row, int last_row, int first_column, int last_column,
+            double min_value, double max_value, int max_code, int if_below_range, int if_above_range)
+{
+   if (first_column < 0) first_column += num_cols;
+   if (first_column < 0 || first_column >= num_cols)
+      rb_raise(rb_eArgError, "Sorry: invalid first_column specification (%i)", first_column);
+   if (last_column < 0) last_column += num_cols;
+   if (last_column < 0 || last_column >= num_cols)
+      rb_raise(rb_eArgError, "Sorry: invalid last_column specification (%i)", last_column);
+   if (first_row < 0) first_row += num_rows;
+   if (first_row < 0 || first_row >= num_rows)
+      rb_raise(rb_eArgError, "Sorry: invalid first_row specification (%i)", first_row);
+   if (last_row < 0) last_row += num_rows;
+   if (last_row < 0 || last_row >= num_rows)
+      rb_raise(rb_eArgError, "Sorry: invalid last_row specification (%i)", last_row);
+   if (min_value >= max_value)
+      rb_raise(rb_eArgError, "Sorry: invalid range specification: min %g max %g", min_value, max_value);
+   if (max_code <= 0 || max_code > 255)
+      rb_raise(rb_eArgError, "Sorry: invalid max_code specification (%i)", max_code);
+   if (if_below_range < 0 || if_below_range > 255)
+      rb_raise(rb_eArgError, "Sorry: invalid if_below_range specification (%i)", if_below_range);
+   if (if_above_range < 0 || if_above_range > 255)
+      rb_raise(rb_eArgError, "Sorry: invalid if_above_range specification (%i)", if_above_range);
+   int i, j, k, width = last_column - first_column + 1, height = last_row - first_row + 1;
+   int sz = width * height;
+   if (sz <= 0) rb_raise(rb_eArgError, "Sorry: invalid data specification: width (%i) height (%i)", width, height);
+   char *buff = ALLOC_N(char, sz);
+   for (k = 0, i = first_row; i <= last_row; i++) {
+      double *row = data[i];
+      for (j = first_column; j <= last_column; j++) {
+         double val = row[j];
+         if (val < min_value) buff[k++] = if_below_range;
+         else if (val > max_value) buff[k++] = if_above_range;
+         else {
+            val = max_code * (val - min_value)/(max_value - min_value);
+            buff[k++] = ROUND(val);
+         }
+      }
+   }
+   VALUE result = rb_str_new(buff, sz);
+   free(buff);
+   return result;
+}
+
+VALUE FM_private_create_image_data(VALUE fmkr, VALUE data,
+            VALUE first_row, VALUE last_row, VALUE first_column, VALUE last_column,
+            VALUE min_value, VALUE max_value, VALUE max_code, VALUE if_below_range, VALUE if_above_range)
+{
+   FM *p = Get_FM(fmkr);
+   long num_cols, num_rows;
+   double **ary = Dtable_Ptr(data, &num_cols, &num_rows);
+   first_row = rb_Integer(first_row);
+   last_row = rb_Integer(last_row);
+   first_column = rb_Integer(first_column);
+   last_column = rb_Integer(last_column);
+   max_code = rb_Integer(max_code);
+   if_below_range = rb_Integer(if_below_range);
+   if_above_range = rb_Integer(if_above_range);
+   min_value = rb_Float(min_value);
+   max_value = rb_Float(max_value);
+   return c_private_create_image_data(p, ary, num_cols, num_rows, 
+      NUM2INT(first_row), NUM2INT(last_row), NUM2INT(first_column), NUM2INT(last_column),
+      NUM2DBL(min_value), NUM2DBL(max_value), NUM2INT(max_code), NUM2INT(if_below_range), NUM2INT(if_above_range));
+}
+
+static VALUE c_private_create_monochrome_image_data(FM *p, double **data, long num_cols, long num_rows,
+            int first_row, int last_row, int first_column, int last_column,
+            double boundary, bool reversed)
+{
+   if (first_column < 0) first_column += num_cols;
+   if (first_column < 0 || first_column >= num_cols)
+      rb_raise(rb_eArgError, "Sorry: invalid first_column specification (%i)", first_column);
+   if (last_column < 0) last_column += num_cols;
+   if (last_column < 0 || last_column >= num_cols)
+      rb_raise(rb_eArgError, "Sorry: invalid last_column specification (%i)", last_column);
+   if (first_row < 0) first_row += num_rows;
+   if (first_row < 0 || first_row >= num_rows)
+      rb_raise(rb_eArgError, "Sorry: invalid first_row specification (%i)", first_row);
+   if (last_row < 0) last_row += num_rows;
+   if (last_row < 0 || last_row >= num_rows)
+      rb_raise(rb_eArgError, "Sorry: invalid last_row specification (%i)", last_row);
+   int i, j, k, width = last_column - first_column + 1, height = last_row - first_row + 1, bytes_per_row = (width+7)/8;
+   int sz = bytes_per_row * 8 * height;
+   if (sz <= 0) rb_raise(rb_eArgError, "Sorry: invalid data specification: width (%i) height (%i)", width, height);
+   // to simplify the process, do it in two stages: first get the values and then pack the bits
+   char *buff = ALLOC_N(char, sz);
+   for (k = 0, i = first_row; i <= last_row; i++) {
+      double *row = data[i];
+      for (j = first_column; j <= last_column; j++) {
+         double val = row[j];
+         buff[k++] = (reversed)? (val <= boundary) : (val > boundary);
+      }
+      for (j = last_column+1; j < bytes_per_row * 8; j++) {
+         buff[k++] = 0;
+      }
+   }
+   int num_bytes = (sz+7) >> 3;
+   char *bits = ALLOC_N(char, num_bytes), c = 0;
+   int num_bits = num_bytes << 3;
+   for (i = 0, k = -1; i < num_bits; i++) {
+      int bit = (i < sz)? buff[i] : 0;
+      int which_bit = i & 7;
+      if (which_bit != 0) c |= bit << (7-which_bit);
+      else {
+         if (k >= 0) bits[k] = c;
+         k++; c = bit << 7;
+      }
+   }
+   bits[k] = c;
+   VALUE result = rb_str_new(bits, num_bytes);
+   free(bits); free(buff);
+   return result;
+}
+
+VALUE FM_private_create_monochrome_image_data(VALUE fmkr, VALUE data,
+            VALUE first_row, VALUE last_row, VALUE first_column, VALUE last_column,
+            VALUE boundary, VALUE reverse)
+{
+   FM *p = Get_FM(fmkr);
+   long num_cols, num_rows;
+   double **ary = Dtable_Ptr(data, &num_cols, &num_rows);
+   first_row = rb_Integer(first_row);
+   last_row = rb_Integer(last_row);
+   first_column = rb_Integer(first_column);
+   last_column = rb_Integer(last_column);
+   boundary = rb_Float(boundary);
+   return c_private_create_monochrome_image_data(p, ary, num_cols, num_rows, 
+      NUM2INT(first_row), NUM2INT(last_row), NUM2INT(first_column), NUM2INT(last_column),
+      NUM2DBL(boundary), reverse != Qfalse);
+}
+
+int c_private_show_image(FM *p, int image_type, double *dest, bool interpolate, bool reversed, int w, int h, unsigned char* data, int len, 
+   int value_mask_min, int value_mask_max, int hival, unsigned char* lookup, int lookup_len, int mask_obj_num)
+{
+   Sampled_Info *xo = ALLOC(Sampled_Info);
+   xo->xobj_subtype = SAMPLED_SUBTYPE;
+   double llx = dest[0], lly = dest[1], lrx = dest[2], lry = dest[3], ulx = dest[4],  uly = dest[5];
+   double a, b, c, d, e, f; // the transform to position the image
+   int ir, ic, id;
+   xo->next = xobj_list;
+   xobj_list = (XObject_Info *)xo;
+   xo->xo_num = next_available_xo_number++;
+   xo->obj_num = next_available_object_number++;
+   xo->image_data = ALLOC_N(unsigned char, len);
+   xo->length = len;
+   xo->interpolate = interpolate;
+   xo->reversed = reversed;
+   MEMCPY(xo->image_data, data, unsigned char, len);
+   xo->image_type = image_type;
+   if (image_type != COLORMAP_IMAGE) xo->lookup = NULL;
+   else {
+      if ((hival+1)*3 > lookup_len)
+         rb_raise(rb_eArgError, "Sorry: color space hival (%i) is too large for length of lookup table (%i)", hival, lookup_len);
+      xo->hival = hival;
+      lookup_len = (hival+1) * 3;
+      xo->lookup = ALLOC_N(unsigned char, lookup_len);
+      xo->lookup_len = lookup_len;
+      MEMCPY(xo->lookup, lookup, unsigned char, lookup_len);
+   }
+   xo->width = w;
+   xo->height = h;
+   
+   if (0) {
+    printf("len=%i  w=%i  h=%i\ndata\n\n", len, w, h);
+   for (ir=0; ir<h; ir++) {
+    for (ic=0; ic<w; ic++) {
+        id = (int)data[ir*h+ic];
+        printf("%3i ",id);
+    }
+    printf("\n");
+   }
+   
+   
+    printf("\n\nxo->image_data\n");
+   for (ir=0; ir<h; ir++) {
+    for (ic=0; ic<w; ic++) {
+        id = (int)xo->image_data[ir*h+ic];
+        printf("%3i ",id);
+    }
+    printf("\n\n");
+   }
+   }
+   
+   
+   xo->value_mask_min = value_mask_min;
+   xo->value_mask_max = value_mask_max;
+   xo->mask_obj_num = mask_obj_num;
+   if (mask_obj_num == -1) return xo->obj_num; // this image is being used as an opacity mask
+   Create_Transform_from_Points(llx, lly, lrx, lry, ulx, uly, &a, &b, &c, &d, &e, &f);
+   fprintf(TF, "q %0.2f %0.2f %0.2f %0.2f %0.2f %0.2f cm /XObj%i Do Q\n", a, b, c, d, e, f, xo->xo_num);
+   update_bbox(p, llx, lly);
+   update_bbox(p, lrx, lry);
+   update_bbox(p, ulx, uly);
+   update_bbox(p, lrx+ulx-llx, lry+uly-lly);
+   return xo->obj_num;
+}
+
+static VALUE private_show_image(int image_type, VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE reversed, VALUE w, VALUE h, VALUE data, VALUE value_mask_min, VALUE value_mask_max,
+    VALUE hival, VALUE lookup, VALUE mask_obj_num)
+{
+   double dest[6];
+   unsigned char *lookup_str=NULL;
+   int mask_min = 256, mask_max = 256, lookup_len=0, hivalue=0;
+   FM *p = Get_FM(fmkr);
+   if (constructing_path) rb_raise(rb_eArgError, "Sorry: must finish with current path before calling show_image");
+   data = rb_String(data);
+   llx = rb_Float(llx);
+   lly = rb_Float(lly);
+   lrx = rb_Float(lrx);
+   lry = rb_Float(lry);
+   ulx = rb_Float(ulx);
+   uly = rb_Float(uly);
+   w = rb_Integer(w);
+   h = rb_Integer(h);
+   mask_obj_num = rb_Integer(mask_obj_num);
+   if (image_type == COLORMAP_IMAGE) {
+      value_mask_min = rb_Integer(value_mask_min); mask_min = NUM2INT(value_mask_min);
+      value_mask_max = rb_Integer(value_mask_max); mask_max = NUM2INT(value_mask_max);
+      hival = rb_Integer(hival);
+      hivalue = NUM2INT(hival);
+      lookup = rb_String(lookup);
+      lookup_str = (unsigned char *)(RSTRING(lookup)->ptr);
+      lookup_len = RSTRING(lookup)->len;
+   }
+   dest[0] = convert_figure_to_output_x(p,NUM2DBL(llx));
+   dest[1] = convert_figure_to_output_y(p,NUM2DBL(lly));
+   dest[2] = convert_figure_to_output_x(p,NUM2DBL(lrx));
+   dest[3] = convert_figure_to_output_y(p,NUM2DBL(lry));
+   dest[4] = convert_figure_to_output_x(p,NUM2DBL(ulx));
+   dest[5] = convert_figure_to_output_y(p,NUM2DBL(uly));
+   int obj_num = c_private_show_image(p, image_type, dest, (interpolate != Qfalse), (reversed == Qtrue), NUM2INT(w), NUM2INT(h), 
+      (unsigned char *)RSTRING(data)->ptr, RSTRING(data)->len, mask_min, mask_max, hivalue, lookup_str, lookup_len, NUM2INT(mask_obj_num));
+   return INT2FIX(obj_num);
+}
+
+VALUE FM_private_show_rgb_image(VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE w, VALUE h, VALUE data, VALUE mask_obj_num)
+{
+   return private_show_image(RGB_IMAGE, fmkr, llx, lly, lrx, lry, ulx, uly, interpolate, Qfalse, w, h, data, Qnil, Qnil, Qnil, Qnil, mask_obj_num);
+}
+
+VALUE FM_private_show_cmyk_image(VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE w, VALUE h, VALUE data, VALUE mask_obj_num)
+{
+   return private_show_image(CMYK_IMAGE, fmkr, llx, lly, lrx, lry, ulx, uly, interpolate, Qfalse, w, h, data, Qnil, Qnil, Qnil, Qnil, mask_obj_num);
+}
+
+VALUE FM_private_show_grayscale_image(VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE w, VALUE h, VALUE data, VALUE mask_obj_num)
+{
+   return private_show_image(GRAY_IMAGE, fmkr, llx, lly, lrx, lry, ulx, uly, interpolate, Qfalse, w, h, data, Qnil, Qnil, Qnil, Qnil, mask_obj_num);
+}
+
+VALUE FM_private_show_monochrome_image(VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE reversed, VALUE w, VALUE h, VALUE data, VALUE mask_obj_num)
+{
+   return private_show_image(MONO_IMAGE, fmkr, llx, lly, lrx, lry, ulx, uly, interpolate, reversed, 
+         w, h, data, Qnil, Qnil, Qnil, Qnil, mask_obj_num);
+}
+
+VALUE FM_private_show_image(VALUE fmkr, VALUE llx, VALUE lly, VALUE lrx, VALUE lry,
+    VALUE ulx, VALUE uly, VALUE interpolate, VALUE w, VALUE h, VALUE data,
+    VALUE value_mask_min, VALUE value_mask_max, VALUE hival, VALUE lookup, VALUE mask_obj_num)
+{
+   return private_show_image(COLORMAP_IMAGE, fmkr, llx, lly, lrx, lry, ulx, uly, interpolate, Qfalse, w, h, data, 
+      value_mask_min, value_mask_max, hival, lookup, mask_obj_num);
+}
+