tioga 1.17 → 1.18

data/Tioga_README

@@ -22,9 +22,16 @@ This is the README for the Tioga kernel, version 1.14, June 10, 2011.
 
 << What's new >>
 
-    Tioga 1.17 provides all the necessary fixes to have it run on
-windows, so now we also support the Redmond operating system (works
-with the ProTeXt LaTeX distribution).
+   Tioga 1.18 brings in a few new features. First, Dvector.fancy_read
+is now able to extract pure text columns. Second, a jpg_info function
+has been added that read the width and height from within a JPEG file,
+for use with show_image: you now don't have to know the image size
+beforehand. A load_png function was added that relies on pdflatex to
+read PNG files (except those with a custom palette). Feed the return
+value of load_png to show_image. It is now possible to reuse an image
+over and over again by saving its reference and using itagain.Finally,
+more control over the number of pdflatex executions is now available.
+There are also a couple of bug fixes.
 
 << Quick Installation of Tioga >>
 
@@ -164,6 +171,10 @@ Bill Paxton
 
 Here are the old release messages:
 
+    Tioga 1.17 provides all the necessary fixes to have it run on
+windows, so now we also support the Redmond operating system (works
+with the ProTeXt LaTeX distribution).
+
     Tioga 1.16 brings in a bug fix by Josiah Schwab in handling some
 HLS triplets. It also provides facilities to extract the pdflatex
 errors.

data/ext/Dobjects/Dvector/dvector.c

@@ -5623,6 +5623,12 @@ static VALUE dvector_convolve(VALUE self, VALUE kernel, VALUE middle)
   return retval;
 }
 
+static VALUE marked_array()
+{
+  VALUE v = rb_ary_new();
+  rb_gc_register_mark_object(v);
+  return v;
+}
 
 /*
   :call-seq:
@@ -5637,12 +5643,16 @@ static VALUE dvector_convolve(VALUE self, VALUE kernel, VALUE middle)
   * 'skip_first': skips that many lines before reading anything
   * 'index_col': if true, the first column returned contains the
     number of the line read
-  * 'remove_space': whether to remove spaces at the beginning of a line. *This 
-    option is currently not implemented !*
+  * 'remove_space': whether to remove spaces at the beginning of a line.
   * 'comment_out': this should be an array into which the comments
      will be dumped one by one.
   * 'default':  what to put when nothing was found but a number must be used
-
+  * 'last_col': when this is specified, it represents the last column which
+     is read and parsed as numbers (0-based, so the 3rd column is 2). 
+     The remaining is returned as text in one n+1 column
+  * 'text_columns': if provided, it is an array of integers containing the 
+    0-based indices of columns to be parsed as text rather than numbers.
+    
   In addition to these options that control the output, here are a few
   others to tune memory allocation; these can strongly improve the
   performance (or make it worse if you wish):
@@ -5666,11 +5676,65 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
   VALUE comments = rb_hash_aref(options, rb_str_new2("comments"));
   VALUE comment_out = rb_hash_aref(options, rb_str_new2("comment_out"));
 
+  /* Elements after that many columns  */
+  VALUE lc = rb_hash_aref(options, rb_str_new2("last_col"));
+  long last_col = RTEST(lc) ? FIX2LONG(lc) : -1;
+  VALUE text_columns = rb_hash_aref(options, rb_str_new2("text_columns"));
+
   /* Then, some various variables: */
   VALUE line;
 
   ID chomp_id = rb_intern("chomp!");
   ID gets_id = rb_intern("gets");
+  ID max_id = rb_intern("max");
+  ID size_id = rb_intern("size");
+  
+  /* We compute the maximum number of text columns */
+  long last_text_col = last_col+1;
+  VALUE mx = RTEST(text_columns) ? rb_funcall(text_columns, max_id, 0) : Qnil;
+  if(RTEST(mx) && last_text_col < 0) { /* Only taking the max into
+                                          account if the last col
+                                          stuff is not on */
+    long d = FIX2LONG(mx);
+    last_text_col = d;
+  }
+
+
+  /* array of Ruby arrays containing the text objects of interest */
+  VALUE * text_cols = NULL;
+
+  /*
+    Handling of text columns.
+
+    The number and position of text columns has to be known in
+    advance. For each of those, the value of text_columns isn't Qnil,
+    and the corresponding column is NULL.
+
+   */
+  if(last_text_col >= 0) {
+    text_cols = ALLOC_N(VALUE, last_text_col + 1);
+    int i;
+    for(i = 0; i < last_text_col + 1; i++)
+      text_cols[i] = Qnil;
+    if(last_col >= 0) {
+      text_cols[last_col+1] = marked_array();
+    }
+    if(RTEST(mx)) {
+      /* Todo */
+      int sz = RARRAY_LENINT(text_columns);
+      int i;
+      for(i = 0; i <  sz; i++) {
+        long idx = FIX2LONG(rb_ary_entry(text_columns, i));
+        if(idx >= 0 && (last_col < 0 || idx < last_col)) {
+          text_cols[idx] = marked_array();
+        }
+      }
+    }
+  }
+
+
+
+
   long line_number = 0;
 
   /* 
@@ -5690,6 +5754,8 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
 
 
   int i;
+  for(i = 0; i < current_size; i++)
+    vectors[i] = NULL;
 
   /* The return value */
   VALUE ary;
@@ -5742,47 +5808,76 @@ static VALUE dvector_fast_fancy_read(VALUE self, VALUE stream, VALUE options)
 	pre = post;
 	post = Qnil;
       }
-      a = StringValueCStr(pre);
-      double c = strtod(a, &b);
-      if(b == a) 
-	c = def;
-      if(col >= nb_vectors) {
-	nb_vectors++;
-	/* We need to create a new vector */
-	if(col >= current_size) { /* Increase the available size */
-	  current_size += 5;
-	  REALLOC_N(vectors, double * , current_size);
-	}
-	
-	double * vals = vectors[col] = ALLOC_N(double, allocated_size);
-	/* Filling it with the default value */
-	for(i = 0; i < index; i++) {
-	  vals[i] = def;
-	}
+      if(text_cols && col <= last_text_col && RTEST(text_cols[col])) {
+        rb_ary_push(text_cols[col], pre);
+        if(col >= nb_vectors) {
+          nb_vectors ++;
+          if(col < current_size)
+            vectors[col] = NULL;
+        }
+      }
+      else {
+        a = StringValueCStr(pre);
+        double c = strtod(a, &b);
+        if(b == a) 
+          c = def;
+        if(col >= nb_vectors) {
+          /* We need to create a new vector */
+          if(col >= current_size) { /* Increase the available size */
+            current_size = col + 5;
+            REALLOC_N(vectors, double * , current_size);
+          }
+          for(; nb_vectors <= col; nb_vectors++)
+            vectors[nb_vectors] = NULL; /* default to NULL */
+          
+          double * vals = vectors[col] = ALLOC_N(double, allocated_size);
+          /* Filling it with the default value */
+          for(i = 0; i < index; i++) {
+            vals[i] = def;
+          }
+        }
+        vectors[col][index] = c;
       }
-      vectors[col][index] = c;
       col++;
+      if(last_col >= 0 && col > last_col) {
+        rb_ary_push(text_cols[last_col + 1], post);
+        nb_vectors = col + 1;
+        col++;
+        break;
+      }
     }
     /* Now, we finish the line */
-    for(; col < nb_vectors; col++)
-      vectors[col][index] = def;
+    for(; col < nb_vectors; col++) {
+      if(text_cols && col <= last_text_col && RTEST(text_cols[col]))
+        rb_ary_push(text_cols[col], Qnil);
+      else
+        vectors[col][index] = def;
+    }
     index++;
     /* Now, we reallocate memory if necessary */
     if(index >= allocated_size) {
       allocated_size *= 2;	/* We double the size */
-      for(col = 0; col < nb_vectors; col++)
-	REALLOC_N(vectors[col], double, allocated_size);
+      for(col = 0; col < nb_vectors; col++) {
+        if(col < current_size && vectors[col])
+          REALLOC_N(vectors[col], double, allocated_size);
+      }
     }
   }
   /* Now, we make up the array */
   ary = rb_ary_new();
   for(i = 0; i < nb_vectors; i++) {
     /* We create a vector */
-    rb_ary_store(ary, i, make_dvector_from_data(cDvector, index, vectors[i]));
-    /* And free the memory */
-    free(vectors[i]);
+    if(text_cols && i <= last_text_col && RTEST(text_cols[i]))
+      rb_ary_store(ary, i, text_cols[i]);
+    else {
+      rb_ary_store(ary, i, make_dvector_from_data(cDvector, index, vectors[i]));
+      /* And free the memory */
+      free(vectors[i]);
+    }
   }
   free(vectors);
+  if(text_cols)
+    free(text_cols);
   return ary;
 }
 

data/ext/Tioga/FigureMaker/__shared_axes.c

@@ -340,8 +340,12 @@ static char *Create_Label(double val, int scale, int prec,
      /* Exponential, i.e. 10^-1, 1, 10, 10^2, etc */
      double abs_diff = fabs(val - exponent);
      if (abs_diff > 0.1) snprintf(buff, sizeof(buff), (s->vertical)? "\\tiogayaxisnumericlabel{10^{%0.1f}}" : "\\tiogaxaxisnumericlabel{10^{%0.1f}}", val);
-     else if (exponent == 0) strcpy(buff, "1");
-     else if (exponent == 1) strcpy(buff, "10");
+     else if (exponent == 0) strcpy(buff, (s->vertical)? 
+                                    "\\tiogayaxisnumericlabel{1}" : 
+                                    "\\tiogaxaxisnumericlabel{1}");
+     else if (exponent == 1) strcpy(buff, (s->vertical)? 
+                                    "\\tiogayaxisnumericlabel{10}" : 
+                                    "\\tiogaxaxisnumericlabel{10}");
      else snprintf(buff, sizeof(buff),  (s->vertical)? "\\tiogayaxisnumericlabel{10^{%d}}" : "\\tiogaxaxisnumericlabel{10^{%d}}", exponent);
    } else {   /* Linear */
       double scale2;

data/ext/Tioga/FigureMaker/__shared_pdfimage.c

@@ -74,7 +74,122 @@
       /Decode [1 0] means sample values of 1 are included in the output, values of 0 are excluded
       
 */     
-   
+
+/*
+  Reads next byte, and set *eof on end of file
+*/
+static int read_byte(FILE * file, int *eof)
+{
+  int c = fgetc(file);
+  if(c == EOF)
+    *eof = 1;
+  else
+    *eof = 0;
+  return c;
+}
+
+/* Reads a 16 bits word */
+static unsigned read_word(FILE * file, int *eof)
+{
+  int v = fgetc(file);
+  int c = fgetc(file);
+  if(v == EOF || c == EOF)
+    *eof = 1;
+  else
+    *eof = 0;
+  return ((unsigned) v) << 8 | ((unsigned) c);
+}
+
+/* Reads until the next tag, and returns its code */
+static int read_next_tag(FILE * file, int *eof)
+{
+  int c;
+  *eof = 0;
+
+  /* Discard non 0xFF bytes */
+  do {
+    c = read_byte(file, eof);
+    if(*eof)
+      return 0xFF;
+  } while(c != 0xFF);
+
+  do {
+    c = read_byte(file, eof);
+    if(*eof)
+      return 0xFF;
+  } while (c == 0xFF);
+  return c;
+}
+
+static void skip_variable_length(FILE * file, int *eof)
+{
+  *eof = 0;
+  int len = read_word(file, eof);
+  if(*eof)
+    return;
+  if(len < 2) {
+    *eof = 1;
+    return;
+  }
+  len -= 2;
+  while(len > 0) {
+    --len;
+    read_byte(file, eof);
+    if(*eof)
+      return;
+  }
+}
+
+
+/* Parses a JPEG file and extracts the resolution data from it, and
+   returns a newly allocated JPG_Info structure.
+*/
+JPG_Info * Parse_JPG(const char * file) 
+{
+
+  FILE * f = fopen(file, "rb");
+  if(! f)
+    return NULL;
+
+  int eof = 0;
+  int tag = read_next_tag(f, &eof);
+  if(tag != 0xD8 || eof) {
+    fclose(f);
+    return NULL;
+  }
+
+  while(1) {
+    tag = read_next_tag(f, &eof);
+    if(eof)  {
+      fclose(f);
+      return NULL;
+    }
+    switch(tag) {
+    case 0xC0: /* image data */
+      {
+        int len = read_word(f, &eof);
+        int bps = read_byte(f, &eof);
+        int y = read_word(f, &eof);
+        int x = read_word(f, &eof);
+        int cmps = read_byte(f, &eof);
+        fclose(f);
+        if(eof)
+          return NULL;
+          
+        JPG_Info * val = (JPG_Info *)calloc(1, sizeof(JPG_Info));
+        val->filename = ALLOC_N_char(strlen(file)+1);
+        strcpy(val->filename, file);
+        val->width = x;
+        val->height = y;
+        return val;
+      }
+    default:
+      skip_variable_length(f, &eof);
+    }
+  }
+}
+
+
 
 void
 Free_JPG(JPG_Info *xo)
@@ -88,6 +203,7 @@ Free_Sampled(Sampled_Info *xo)
 {
    if (xo->image_data != NULL) free(xo->image_data);
    if (xo->lookup != NULL) free(xo->lookup);
+   if (xo->filters != NULL) free(xo->filters);
 }
 
 
@@ -164,7 +280,7 @@ void
 Write_Sampled(Sampled_Info *xo, int *ierr)
 {
    fprintf(OF, "\n\t/Subtype /Image\n");
-   fprintf(OF, "\t/Filter /FlateDecode\n\t/Interpolate %s\n",
+   fprintf(OF, "\t/Interpolate %s\n",
            (xo->interpolate)? "true":"false");
    fprintf(OF, "\t/Height %i\n", xo->height);
    fprintf(OF, "\t/Width %i\n", xo->width);
@@ -172,19 +288,20 @@ Write_Sampled(Sampled_Info *xo, int *ierr)
    unsigned long new_len;
    unsigned char *image_data;
    unsigned char *buffer;
+   unsigned char *wd;
    switch (xo->image_type) {
       case RGB_IMAGE:
       case HLS_IMAGE:
          fprintf(OF, "\t/ColorSpace /DeviceRGB\n");
-         fprintf(OF, "\t/BitsPerComponent 8\n");
+         fprintf(OF, "\t/BitsPerComponent %d\n", xo->components);
          break;
       case CMYK_IMAGE:
          fprintf(OF, "\t/ColorSpace /DeviceCMYK\n");
-         fprintf(OF, "\t/BitsPerComponent 8\n");
+         fprintf(OF, "\t/BitsPerComponent %d\n", xo->components);
          break;
       case GRAY_IMAGE:
          fprintf(OF, "\t/ColorSpace /DeviceGray\n");
-         fprintf(OF, "\t/BitsPerComponent 8\n");
+         fprintf(OF, "\t/BitsPerComponent %d\n", xo->components);
          break;
       case MONO_IMAGE:
          fprintf(OF, "\t/ImageMask true\n");
@@ -202,7 +319,7 @@ Write_Sampled(Sampled_Info *xo, int *ierr)
             else fprintf(OF, "%x", c);
          }
          fprintf(OF, "> ]\n");
-         fprintf(OF, "\t/BitsPerComponent 8\n");
+         fprintf(OF, "\t/BitsPerComponent %d\n", xo->components);
    }
    if (xo->mask_obj_num > 0) {
       if (xo->image_type == MONO_IMAGE) {
@@ -226,22 +343,35 @@ Write_Sampled(Sampled_Info *xo, int *ierr)
    } else {
       image_data = xo->image_data;
    }
-      
-   new_len = (xo->length * 11)/10 + 100;
-   buffer = ALLOC_N_unsigned_char(new_len);
-   if (do_flate_compress(buffer, &new_len, image_data, xo->length)
-       != FLATE_OK) {
-      free(buffer);
-      RAISE_ERROR("Error compressing image data", ierr); 
-      return;
+
+   buffer = NULL;
+   wd = image_data;
+   
+   if(xo->filters) {
+     new_len = xo->length;
+     fprintf(OF, "%s", xo->filters);
+   }
+   else {
+     fprintf(OF, "\t/Filter /FlateDecode\n");
+   
+     new_len = (xo->length * 11)/10 + 100;
+     buffer = ALLOC_N_unsigned_char(new_len);
+     if (do_flate_compress(buffer, &new_len, image_data, xo->length)
+         != FLATE_OK) {
+       free(buffer);
+       RAISE_ERROR("Error compressing image data", ierr); 
+       return;
+     }
+     wd = buffer;
    }
    fprintf(OF, "\t/Length %li\n", new_len);
    fprintf(OF, "\t>>\nstream\n");
-   if (fwrite(buffer, 1, new_len, OF) < new_len) {
+   if (fwrite(wd, 1, new_len, OF) < new_len) {
       RAISE_ERROR("Error writing image data", ierr);
       return;
    }
-   free(buffer);
+   if(buffer)
+     free(buffer);
    if (xo->image_type == HLS_IMAGE) free(image_data);
    fprintf(OF, "\nendstream\nendobj\n");
 }
@@ -258,8 +388,29 @@ Create_Transform_from_Points(double llx, double lly, double lrx, double lry,
 }
 
 
+/* Read the image here ?*/
+int
+c_private_register_jpg(OBJ_PTR fmkr, FM *p, char *filename, 
+                       int width, int height,
+                       int mask_obj_num, int *ierr)
+{
+  JPG_Info *xo = (JPG_Info *)calloc(1,sizeof(JPG_Info));
+  xo->xobj_subtype = JPG_SUBTYPE;
+  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;
+  return xo->obj_num;
+}
+
+
 static void
-Get_Image_Dest(FM *p, OBJ_PTR image_destination, double *dest, int *ierr)
+Expand_Array(OBJ_PTR image_destination, double *dest, int *ierr)
 {
    int len = Array_Len(image_destination,ierr);
    if (*ierr != 0) return;
@@ -272,58 +423,31 @@ Get_Image_Dest(FM *p, OBJ_PTR image_destination, double *dest, int *ierr)
    for (i = 0; i < 6; i++) {
       OBJ_PTR entry = Array_Entry(image_destination, i, ierr);
       if (*ierr != 0) return;
-      if (i % 2 == 0)
-         dest[i] = convert_figure_to_output_x(p,Number_to_double(entry, ierr));
-      else
-         dest[i] = convert_figure_to_output_y(p,Number_to_double(entry, ierr));
+      dest[i] = Number_to_double(entry, ierr);
       if (*ierr != 0) return;
    }
 }
 
-
-static void
-Show_JPEG(FM *p, char *filename, int width, int height, double *dest,
-          int subtype, int mask_obj_num)
-{
-   JPG_Info *xo = (JPG_Info *)calloc(1,sizeof(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_private_show_jpg(OBJ_PTR fmkr, FM *p, char *filename, 
                    int width, int height, OBJ_PTR image_destination,
                    int mask_obj_num, int *ierr)
 {
    double dest[6];
+   int ref;
    if (constructing_path) {
       RAISE_ERROR("Sorry: must finish with current path before "
                   "calling show_jpg", ierr);
       return;
    }
-   Get_Image_Dest(p, image_destination, dest, ierr);
+   ref = c_private_register_jpg(fmkr, p, filename, width, height, 
+                                mask_obj_num, *ierr);
+   Expand_Array(image_destination, dest, ierr);
    if (*ierr != 0) return;
-   Show_JPEG(p, filename, width, height, dest, JPG_SUBTYPE, mask_obj_num);
+
+   c_private_show_image_from_ref(fmkr, p, ref, dest[0], dest[1], 
+                                 dest[2], dest[3], dest[4], dest[5],
+                                 ierr);
 }
 
 
@@ -465,7 +589,29 @@ c_private_show_image(OBJ_PTR fmkr, FM *p, int image_type, double llx,
                      double uly, bool interpolate, bool reversed,
                      int w, int h, unsigned char* data, long len, 
                      OBJ_PTR mask_min, OBJ_PTR mask_max, OBJ_PTR hivalue,
-                     OBJ_PTR lookup_data, int mask_obj_num, int *ierr)
+                     OBJ_PTR lookup_data, int mask_obj_num, int components,
+                     const char * filters,
+                     int *ierr)
+{
+  int ref = c_private_register_image(fmkr, p, image_type,
+                                     interpolate, reversed,
+                                     w, h, data, len, mask_min, 
+                                     mask_max, hivalue, lookup_data, 
+                                     mask_obj_num, components, filters, ierr);
+  if (mask_obj_num != -1)
+    c_private_show_image_from_ref(fmkr, p, ref, llx, lly, 
+                                  lrx, lry, ulx, uly, ierr);
+  return Integer_New(ref);
+}
+
+int
+c_private_register_image(OBJ_PTR fmkr, FM *p, int image_type,
+                         bool interpolate, bool reversed,
+                         int w, int h, unsigned char* data, long len, 
+                         OBJ_PTR mask_min, OBJ_PTR mask_max, OBJ_PTR hivalue,
+                         OBJ_PTR lookup_data, int mask_obj_num, int components,
+                         const char * filters,
+                         int *ierr)
 {
    unsigned char *lookup = NULL;
    int value_mask_min = 256, value_mask_max = 256, lookup_len = 0, hival = 0;
@@ -483,12 +629,6 @@ c_private_show_image(OBJ_PTR fmkr, FM *p, int image_type, double llx,
       if (*ierr != 0) RETURN_NIL;
    }
    
-   llx = convert_figure_to_output_x(p, llx);
-   lly = convert_figure_to_output_y(p, lly);
-   lrx = convert_figure_to_output_x(p, lrx);
-   lry = convert_figure_to_output_y(p, lry);
-   ulx = convert_figure_to_output_x(p, ulx);
-   uly = convert_figure_to_output_y(p, uly);
 
    Sampled_Info *xo = (Sampled_Info *)calloc(1, sizeof(Sampled_Info));
    xo->xobj_subtype = SAMPLED_SUBTYPE;
@@ -502,8 +642,16 @@ c_private_show_image(OBJ_PTR fmkr, FM *p, int image_type, double llx,
    xo->length = len;
    xo->interpolate = interpolate;
    xo->reversed = reversed;
+   xo->components = components;
    memcpy(xo->image_data, data, len);
    xo->image_type = image_type;
+   if(filters) {
+     int len = strlen(filters) + 1;
+     xo->filters = calloc(1, len);
+     memcpy(xo->filters, filters, len);
+   }
+   else
+     xo->filters = NULL;
    if (image_type != COLORMAP_IMAGE) xo->lookup = NULL;
    else {
       if ((hival+1)*3 > lookup_len) {
@@ -523,17 +671,59 @@ c_private_show_image(OBJ_PTR fmkr, FM *p, int image_type, double llx,
    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 Integer_New(xo->obj_num); // this image is being used as
-                                       // an opacity mask
+   return xo->obj_num;
+}
+
+/* Goes through the xobject list and find the one whose object number
+   matches the one given, and returns the Xobject number. -1 if not
+   found. */
+
+int Find_XObjRef(int ref)
+{
+  XObject_Info * info = xobj_list;
+  while(1) {
+    if(info->obj_num == ref)
+      return info->xo_num;
+    info = info->next;
+    if(! info)
+      break;
+  }
+  return -1;
+}
+
+void
+c_private_show_image_from_ref(OBJ_PTR fmkr, FM *p, int ref, double llx,
+                              double lly, double lrx, double lry, double ulx,
+                              double uly,
+                              int *ierr)
+{
+   if (constructing_path) {
+      RAISE_ERROR("Sorry: must finish with current path before calling "
+                  "show_image", ierr);
+      return;
+   }
+
+   double a, b, c, d, e, f; // the transform to position the image
+   int xo_num = Find_XObjRef(ref);
+   if(xo_num < 0) {
+     RAISE_ERROR_i("Could not find image PDF object %d", ref,
+                    ierr);
+     return;
+   }
+
+   llx = convert_figure_to_output_x(p, llx);
+   lly = convert_figure_to_output_y(p, lly);
+   lrx = convert_figure_to_output_x(p, lrx);
+   lry = convert_figure_to_output_y(p, lry);
+   ulx = convert_figure_to_output_x(p, ulx);
+   uly = convert_figure_to_output_y(p, uly);
+
    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);
+           a, b, c, d, e, f, 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 Integer_New(xo->obj_num);
 }
-