tioga 1.17 → 1.18

data/ext/Tioga/FigureMaker/wrappers.c

@@ -273,70 +273,96 @@ OBJ_PTR FM_private_create_monochrome_image_data(OBJ_PTR fmkr, OBJ_PTR data,
       Number_to_int(first_row, &ierr), Number_to_int(last_row, &ierr), Number_to_int(first_column, &ierr), Number_to_int(last_column, &ierr),
       Number_to_double(boundary, &ierr), reverse != OBJ_FALSE, &ierr);
 }
-OBJ_PTR FM_private_show_jpg(OBJ_PTR fmkr, OBJ_PTR filename, 
-   OBJ_PTR width, OBJ_PTR height, OBJ_PTR image_destination, OBJ_PTR mask_obj_num) { int ierr=0;
-   c_private_show_jpg(fmkr, Get_FM(fmkr, &ierr), String_Ptr(filename, &ierr), 
-      Number_to_int(width, &ierr), Number_to_int(height, &ierr), image_destination, Number_to_int(mask_obj_num, &ierr), &ierr); RETURN_NIL; }
+OBJ_PTR FM_private_register_jpg(OBJ_PTR fmkr, OBJ_PTR filename, 
+   OBJ_PTR width, OBJ_PTR height, OBJ_PTR mask_obj_num) { int ierr=0;
+   return Integer_New(c_private_register_jpg(fmkr, Get_FM(fmkr, &ierr), String_Ptr(filename, &ierr), 
+                                             Number_to_int(width, &ierr), Number_to_int(height, &ierr), Number_to_int(mask_obj_num, &ierr), &ierr)); 
+}
+
+/* Get info on a JPEG file */
+OBJ_PTR FM_jpg_info(OBJ_PTR fmkr, OBJ_PTR filename) {
+   int ierr = 0;
+   JPG_Info * info = Parse_JPG(String_Ptr(filename, &ierr));
+   if(info) {
+      OBJ_PTR hsh = Hash_New();
+      Hash_Set_Obj(hsh, "width", Integer_New(info->width));
+      Hash_Set_Obj(hsh, "height", Integer_New(info->height));
+      Hash_Set_Obj(hsh, "jpg", filename);
+      Free_JPG(info);
+      return hsh;
+   }
+   else 
+      return OBJ_NIL;
+}
+
+#define Str_Or_NULL(obj, ierr) ((obj == OBJ_NIL) ? NULL : CString_Ptr(obj, ierr))
       
-OBJ_PTR FM_private_show_hls_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_hls_image(OBJ_PTR fmkr, 
+                                      OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num, OBJ_PTR components, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), HLS_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), OBJ_FALSE, 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), HLS_IMAGE, 
+                                   (interpolate != OBJ_FALSE), OBJ_FALSE, 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), &ierr);
+      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr),
+                               Number_to_int(components, &ierr), 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
 }
       
-OBJ_PTR FM_private_show_rgb_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_rgb_image(OBJ_PTR fmkr, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num, OBJ_PTR components, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), RGB_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), OBJ_FALSE, 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), RGB_IMAGE, 
+                                   (interpolate != OBJ_FALSE), OBJ_FALSE, 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), &ierr);
+      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr),
+                               Number_to_int(components, &ierr), 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
 }
 
-OBJ_PTR FM_private_show_cmyk_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_cmyk_image(OBJ_PTR fmkr, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num, OBJ_PTR components, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), CMYK_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), false, 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), CMYK_IMAGE, (interpolate != OBJ_FALSE), false, 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), &ierr);
+      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr),
+                               Number_to_int(components, &ierr), 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
 }
 
-OBJ_PTR FM_private_show_grayscale_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_grayscale_image(OBJ_PTR fmkr, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num, OBJ_PTR components, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), GRAY_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), false, 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), GRAY_IMAGE, (interpolate != OBJ_FALSE), false, 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), &ierr);
+      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr),
+                               Number_to_int(components, &ierr), 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
 }
 
-OBJ_PTR FM_private_show_monochrome_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR reversed, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_monochrome_image(OBJ_PTR fmkr, OBJ_PTR interpolate, OBJ_PTR reversed, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_obj_num, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), MONO_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), (reversed == OBJ_TRUE), 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), MONO_IMAGE, (interpolate != OBJ_FALSE), (reversed == OBJ_TRUE), 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), &ierr);
+                               OBJ_NIL, OBJ_NIL, OBJ_NIL, OBJ_NIL, Number_to_int(mask_obj_num, &ierr), 1, 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
 }
 
-OBJ_PTR FM_private_show_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry,
-    OBJ_PTR ulx, OBJ_PTR uly, OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data,
-    OBJ_PTR value_mask_min, OBJ_PTR value_mask_max, OBJ_PTR hival, OBJ_PTR lookup, OBJ_PTR mask_obj_num)
+OBJ_PTR FM_private_register_image(OBJ_PTR fmkr,OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data,
+    OBJ_PTR value_mask_min, OBJ_PTR value_mask_max, OBJ_PTR hival, OBJ_PTR lookup, OBJ_PTR mask_obj_num, OBJ_PTR components, OBJ_PTR filters)
 { int ierr=0;
-   return c_private_show_image(fmkr, Get_FM(fmkr, &ierr), COLORMAP_IMAGE, Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
-      Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
-      Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), (interpolate != OBJ_FALSE), false, 
+   return Integer_New(c_private_register_image(fmkr, Get_FM(fmkr, &ierr), COLORMAP_IMAGE, (interpolate != OBJ_FALSE), false, 
       Number_to_int(w, &ierr), Number_to_int(h, &ierr), (unsigned char *)String_Ptr(data, &ierr), String_Len(data, &ierr), 
-      value_mask_min, value_mask_max, hival, lookup, Number_to_int(mask_obj_num, &ierr), &ierr);
+      value_mask_min, value_mask_max, hival, lookup, Number_to_int(mask_obj_num, &ierr),
+                               Number_to_int(components, &ierr), 
+                                               Str_Or_NULL(filters, &ierr), &ierr));
+}
+
+OBJ_PTR FM_private_show_image_from_ref(OBJ_PTR fmkr, OBJ_PTR ref, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly)
+{
+   int ierr=0;
+   c_private_show_image_from_ref(fmkr, Get_FM(fmkr, &ierr), 
+                                 Number_to_int(ref, &ierr),
+                                 Number_to_double(llx, &ierr), Number_to_double(lly, &ierr), 
+                                 Number_to_double(lrx, &ierr), Number_to_double(lry, &ierr), 
+                                 Number_to_double(ulx, &ierr), Number_to_double(uly, &ierr), &ierr);
+   RETURN_NIL;
 }
 
 

data/ext/Tioga/FigureMaker/wrappers.h

@@ -152,30 +152,34 @@ extern OBJ_PTR FM_pdf_grestore(OBJ_PTR fmkr);
 
 /*======================================================================*/
 // pdfimage.c
-extern OBJ_PTR FM_private_show_jpg(OBJ_PTR fmkr, OBJ_PTR filename, 
-   OBJ_PTR width, OBJ_PTR height, OBJ_PTR image_destination, OBJ_PTR mask_xo_num);
 extern OBJ_PTR FM_private_create_image_data(OBJ_PTR fmkr, OBJ_PTR data,
    OBJ_PTR first_row, OBJ_PTR last_row, OBJ_PTR first_column, OBJ_PTR last_column,
    OBJ_PTR min_OBJ_PTR, OBJ_PTR max_OBJ_PTR, OBJ_PTR max_code, OBJ_PTR if_below_range, OBJ_PTR if_above_range);
 extern OBJ_PTR FM_private_create_monochrome_image_data(OBJ_PTR fmkr, OBJ_PTR data,
    OBJ_PTR first_row, OBJ_PTR last_row, OBJ_PTR first_column, OBJ_PTR last_column,
    OBJ_PTR boundary, OBJ_PTR reverse);
-extern OBJ_PTR FM_private_show_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
-   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR OBJ_PTR_mask_min, OBJ_PTR OBJ_PTR_mask_max,
-   OBJ_PTR hival, OBJ_PTR lookup, OBJ_PTR mask_xo_num);
-extern OBJ_PTR FM_private_show_hls_image(OBJ_PTR fmkr, 
-   OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
-   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num);
-extern OBJ_PTR FM_private_show_rgb_image(OBJ_PTR fmkr, 
-   OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
-   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num);
-extern OBJ_PTR FM_private_show_cmyk_image(OBJ_PTR fmkr, 
-   OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
-   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num);
-extern OBJ_PTR FM_private_show_grayscale_image(OBJ_PTR fmkr, 
-   OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
-   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num);
-extern OBJ_PTR FM_private_show_monochrome_image(OBJ_PTR fmkr, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly,
+
+extern OBJ_PTR FM_private_show_image_from_ref(OBJ_PTR fmkr, OBJ_PTR ref, OBJ_PTR llx, OBJ_PTR lly, OBJ_PTR lrx, OBJ_PTR lry, OBJ_PTR ulx, OBJ_PTR uly);
+
+extern OBJ_PTR FM_private_register_jpg(OBJ_PTR fmkr, OBJ_PTR filename, 
+                                       OBJ_PTR width, OBJ_PTR height, 
+                                       OBJ_PTR mask_xo_num);
+
+extern OBJ_PTR FM_jpg_info(OBJ_PTR fmkr, OBJ_PTR filename);
+
+extern OBJ_PTR FM_private_register_image(OBJ_PTR fmkr,
+                                         OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR OBJ_PTR_mask_min, OBJ_PTR OBJ_PTR_mask_max,
+   OBJ_PTR hival, OBJ_PTR lookup, OBJ_PTR mask_xo_num, OBJ_PTR components);
+
+extern OBJ_PTR FM_private_register_hls_image(OBJ_PTR fmkr, 
+   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num, OBJ_PTR components);
+extern OBJ_PTR FM_private_register_rgb_image(OBJ_PTR fmkr, 
+   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num, OBJ_PTR components);
+extern OBJ_PTR FM_private_register_cmyk_image(OBJ_PTR fmkr, 
+   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num, OBJ_PTR components);
+extern OBJ_PTR FM_private_register_grayscale_image(OBJ_PTR fmkr, 
+   OBJ_PTR interpolate, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num, OBJ_PTR components);
+extern OBJ_PTR FM_private_register_monochrome_image(OBJ_PTR fmkr, 
    OBJ_PTR interpolate, OBJ_PTR reversed, OBJ_PTR w, OBJ_PTR h, OBJ_PTR data, OBJ_PTR mask_xo_num);
 
 /*======================================================================*/

data/lib/Dobjects/Dvector_extras.rb

@@ -86,6 +86,8 @@ module Dobjects
       'default' => 0.0/0.0, # defaults to NaN
       'initial_size' => 5001,
       'remove_space' => true ,# removes spaces at the beginning of the lines
+      'last_col' => -1,       # Read all columns
+      'text_columns' => [],   # Not a single column is text
     }
 
     # This function is a wrapper for #fast_fancy_read that reflects the

data/lib/Tioga/FigMkr.rb

@@ -23,6 +23,9 @@
 require 'Tioga/FigureConstants.rb'
 require 'Tioga/Utils'
 
+require "tmpdir"
+require "fileutils"
+
 module Tioga
 class FigureMaker
     
@@ -38,7 +41,7 @@ class FigureMaker
 
     # This URL will contain tioga-(...) when it is exported from the
     # SVN repository. This is where we'll look for version information.
-    SVN_URL = '$HeadURL: svn+ssh://rubyforge.org/var/svn/tioga/tags/tioga/Tioga%201.17/lib/Tioga/FigMkr.rb $'
+    SVN_URL = '$HeadURL: svn+ssh://rubyforge.org/var/svn/tioga/tags/tioga/Tioga%201.18/lib/Tioga/FigMkr.rb $'
 
     TIOGA_VERSION = if SVN_URL =~ /tags\/tioga\/Tioga%20([^\/]+)/
                        $1
@@ -165,6 +168,11 @@ class FigureMaker
     attr_accessor :measures_info
 
 
+    # Maximum number of pdflatex calls. If nil, then unlimited, but
+    # that could be a very bad idea.
+    attr_accessor :max_nested_pdflatex_calls
+    attr_reader   :current_pdflatex_call
+
 
     # If we want to use #legend_bounding_box. It is off by default
     # as it causes a systematic second run of pdflatex.
@@ -317,6 +325,9 @@ class FigureMaker
         # We don't measure legends by default.
         @measure_legends = false
 
+        # Max number of pdflatex runs
+        @max_nested_pdflatex_calls = 3
+
         # By default, we use Bill's algorithm for major ticks positions
         self.vincent_or_bill = false
         self.log_minor_ticks_limit = 10
@@ -1651,13 +1662,97 @@ class FigureMaker
     
     
     @@keys_for_show_image = FigureMaker.make_name_lookup_hash([
-        'll', 'lr', 'ul', 'w', 'width', 'height', 'h',
-        'opacity_mask', 'stencil_mask', 
+        'll', 'lr', 'ul', 'w', 'width', 'height', 'h', 'ref',
+        'opacity_mask', 'stencil_mask', 'bits', 'pdf_filters',
         'jpg', 'JPG', 'jpeg', 'JPEG', 'interpolate', 'data', 'value_mask',
         'color_space', 'color_map', 'colormap'])
     def show_image(dict)
         internal_show_image(dict, false)
     end
+
+    # Only register an image
+    def register_image(dict)
+        internal_show_image(dict, true)
+    end
+
+    def load_png(file)
+      if File.readable?(file)
+        Dir::mktmpdir do |dir|
+          FileUtils::cp(file, "#{dir}/image.png")
+          Dir::chdir(dir) do
+            open("read.tex", "w") do |f|
+              f.puts <<'EOD'
+\documentclass{article}
+\usepackage{graphicx}
+\pdfcompresslevel=0
+\pdfobjcompresslevel=0
+\begin{document}
+\includegraphics[width=1cm]{image}
+\end{document}
+EOD
+            end
+            pdflatex = "pdflatex"
+            syscmd = "#{pdflatex} -interaction nonstopmode read.tex"
+            IO::popen(syscmd, "r+") do |f|
+              f.close_write      
+              for line in f
+                # Shall we do something with those ?
+              end
+            end
+            
+            # Now, we open the PDF file and have fun with it.
+            open("read.pdf", 'rb') do |f|
+              
+              ret = nil
+              cur = nil
+              len = nil
+              while l = f.gets("\n")
+                if ! ret && l =~ /\/Subtype\s*\/Image\s*/
+                  ret = {}
+                  cur = ret
+                elsif cur && l=~ /\/Width\s*(\d+)\s*/
+                  cur['width'] = $1.to_i
+                elsif cur && l=~ /\/Height\s*(\d+)\s*/
+                  cur['height'] = $1.to_i
+                elsif cur && l =~ /\/Length\s*(\d+)\s*/
+                  len = $1.to_i
+                elsif cur && l =~ /\/(Filter|DecodePar)/ && (!cur['data'])
+                  cur['pdf_filters'] ||= ''
+                  cur['pdf_filters'] << l
+                elsif cur && l =~ /^\s*\/BitsPerComponent\s*(\d+)\s*/
+                  cur['bits'] = $1.to_i
+                elsif cur && l =~ /\/ColorSpace\s*(\S+)\s*/
+                  cs = $1
+                  if cs == "/DeviceGray"
+                    cs = 'gray'
+                  elsif cs == "/DeviceRGB"
+                    cs = "rgb"
+                  else
+                    raise "Unsupported colorspace for file #{file}: '#{cs}'"
+                  end
+                  cur['color_space'] = cs
+                elsif cur && l =~ /\/SMask\s*(\d+)\s*/
+                  cur['opacity_mask'] = {}
+                elsif cur && len && l =~ /stream/
+                  cur['data'] = f.read(len)
+                  if cur['opacity_mask']
+                    cur = cur['opacity_mask']
+                    len = nil
+                  else
+                    return ret
+                  end
+                end
+              end
+              return ret
+            end
+            
+          end
+        end
+      else
+        raise "File #{file} not readable"
+      end
+    end
+
     
     @@keys_for_create_colormap = FigureMaker.make_name_lookup_hash(['length', 'points', 'Rs', 'Gs', 'Bs', 'Hs', 'Ls', 'Ss'])
     def create_colormap(dict)
@@ -1944,19 +2039,20 @@ class FigureMaker
         elsif loc == BOTTOM
             shift = self.text_shift_on_bottom if shift == nil
         else
+            angle_add = 0
             if (loc == AT_X_ORIGIN)
                 shift = self.text_shift_from_x_origin if shift == nil
-                xloc = shift*self.char_height_dx
+                xloc = shift*self.default_text_height_dx
                 yloc = convert_frame_to_figure_y(position)
-                return
+                angle_add = 90
             elsif (loc == AT_Y_ORIGIN)
                 shift = self.text_shift_from_y_origin if shift == nil
-                yloc = shift*self.char_height_dy
+                yloc = shift*self.default_text_height_dx
                 xloc = convert_frame_to_figure_x(position)
             else
                 raise "Sorry: 'loc' must be LEFT, RIGHT, TOP, BOTTOM, AT_X_ORIGIN, or AT_Y_ORIGIN for show_text"
             end
-            show_rotated_label(text, xloc, yloc, scale, angle, just, align,
+            show_rotated_label(text, xloc, yloc, scale, angle + angle_add, just, align,
                                dict['measure'])
             return
         end
@@ -2148,17 +2244,25 @@ class FigureMaker
         num = get_num_for_pdf(num)
         result = start_making_pdf(num)
         return unless result
+
+        @current_pdflatex_call ||= 0
         begin
         @figure_pdfs[num] = finish_making_pdf(@figure_names[num])
         # If the keys have changed, we run that again.
         rescue Exception => e
           p e, e.backtrace
         end
-          
+
         if @measures.keys != old_measure_keys
-          # we dont need to pass &cmd since it has now been defined
-          make_pdf(num)
+          @current_pdflatex_call += 1
+
+          # We limit
+          if (!@max_nested_pdflatex_calls || (@current_pdflatex_call < @max_nested_pdflatex_calls))
+            # we dont need to pass &cmd since it has now been defined
+            make_pdf(num)
+          end
         end
+        @current_pdflatex_call = nil
         return @figure_pdfs[num]
     end
     
@@ -2390,6 +2494,12 @@ EOE
         # p @fm_data
         private_save_measure(key, *val)
       end
+
+      # Delete all keys in @
+      extra = @measures_info.keys - @measures.keys
+      for e in extra
+        @measures_info.delete(e)
+      end
         
       result = $?
         if !result
@@ -2441,74 +2551,71 @@ EOE
         return false
     end
 
-    def internal_show_image(dict, is_mask)
-        check_dict(dict, @@keys_for_show_image, 'show_image')
-        ll = dict['ll']; lr = dict['lr']; ul = dict['ul']
-        w = alt_names(dict, 'w', 'width')
-        h = alt_names(dict, 'h', 'height')
-        opacity_mask = alt_names(dict, 'opacity_mask', 'stencil_mask')
-        if opacity_mask != nil
-            mask_xo_num = internal_show_image(opacity_mask, true)
-        else
-            mask_xo_num = 0
-        end
-        filename = alt_names(dict, 'jpg', 'JPG')
-        filename = dict['jpeg'] if filename == nil
-        filename = dict['JPEG'] if filename == nil
-        if filename != nil
-            return private_show_jpg(filename, w, h, [ll[0], ll[1], lr[0], lr[1], ul[0], ul[1]], mask_xo_num)
-        end
+    def internal_show_image(dict, register_only)
+      check_dict(dict, @@keys_for_show_image, 'show_image')
+      ll = dict['ll']; lr = dict['lr']; ul = dict['ul']
+      w = alt_names(dict, 'w', 'width')
+      h = alt_names(dict, 'h', 'height')
+      opacity_mask = alt_names(dict, 'opacity_mask', 'stencil_mask')
+      bits = dict['bits'] || 8
+      filters = dict['pdf_filters'] || nil
+      ref = dict['ref'] || nil
+      if opacity_mask != nil
+        om = opacity_mask.dup
+        mask_xo_num = om['ref'] || internal_show_image(om, true)
+      else
+        mask_xo_num = 0
+      end
+      filename = alt_names(dict, 'jpg', 'JPG')
+      filename = dict['jpeg'] if filename == nil
+      filename = dict['JPEG'] if filename == nil
+      if ref
+        # Nothing to register, just reuse the image
+      elsif filename != nil
+        ref =  private_register_jpg(filename, w, h, mask_xo_num)
+      else
         interpolate = get_if_given_else_default(dict, 'interpolate', true)
         data = dict['data']
         value_mask = dict['value_mask']
         color_space = alt_names(dict, 'color_space', 'colormap')
         color_space = dict['color_map'] if color_space == nil
-        if color_space == nil
-            raise "Sorry: must specify 'color_space' for the image"
-        end
-        if color_space == 'MONO' || color_space == 'mono'
-            raise "Sorry: monochrome image must not itself have a mask" unless mask_xo_num == 0
-            reversed = get_if_given_else_default(dict, 'reversed', false)
-            xo_obj = private_show_monochrome_image(ll[0], ll[1], lr[0], lr[1], ul[0], ul[1], 
-                            interpolate, reversed, w, h, data, ((is_mask)? -1 : 0))
-            return is_mask ? xo_obj : self
-        end
-        if color_space == 'GRAY' || color_space == 'gray' || color_space == 'GREY' || color_space == 'grey'
-            if is_mask
-                raise("Sorry: mask must not itself have a mask") unless mask_xo_num == 0
-                mask_xo_num = -1
-            end
-            xo_obj = private_show_grayscale_image(ll[0], ll[1], lr[0], lr[1], ul[0], ul[1],
-                            interpolate, w, h, data, mask_xo_num)
-            return is_mask ? xo_obj : self
-        end
-        if is_mask
-            raise "Sorry: mask image must have 'color_space' set to 'gray' or 'mono'"
-        end
-        if color_space == 'RGB' || color_space == 'rgb'
-            private_show_rgb_image(ll[0], ll[1], lr[0], lr[1], ul[0], ul[1], interpolate, w, h, data, mask_xo_num)
-            return self
-        end
-        if color_space == 'HLS' || color_space == 'hls'
-            private_show_hls_image(ll[0], ll[1], lr[0], lr[1], ul[0], ul[1], interpolate, w, h, data, mask_xo_num)
-            return self
-        end
-        if color_space == 'CMYK' || color_space == 'cmyk'
-            private_show_cmyk_image(ll[0], ll[1], lr[0], lr[1], ul[0], ul[1], interpolate, w, h, data, mask_xo_num)
-            return self
-        end
-        if value_mask == nil
+        case color_space
+        when nil
+          raise "Sorry: must specify 'color_space' for the image"
+        when 'MONO', 'mono'
+          raise "Sorry: monochrome image must not itself have a mask" unless mask_xo_num == 0
+          reversed = get_if_given_else_default(dict, 'reversed', false)
+          ref = private_register_monochrome_image(interpolate, reversed, w, h, data, ((register_only)? -1 : 0), filters)
+        when 'GRAY', 'gray', 'GREY', 'grey'
+          if register_only
+            raise("Sorry: mask must not itself have a mask") unless mask_xo_num == 0
+            mask_xo_num = -1
+          end
+          ref = private_register_grayscale_image(interpolate, w, h, data, mask_xo_num, bits, filters)
+        when 'RGB', 'rgb'
+          ref = private_register_rgb_image(interpolate, w, h, data, mask_xo_num, bits, filters)
+        when 'HLS', 'hls'
+          ref = private_register_hls_image(interpolate, w, h, data, mask_xo_num, bits, filters)
+        when 'CMYK', 'cmyk'
+          ref = private_register_cmyk_image(interpolate, w, h, data, mask_xo_num, bits, filters)
+        else 
+          if value_mask == nil
             value_mask_min = value_mask_max = 256
-        elsif value_mask.kind_of?Integer
+          elsif value_mask.kind_of?Integer
             value_mask_min = value_mask_max = value_mask
-        else
+          else
             value_mask_min = value_mask[0];
             value_mask_max = value_mask[1];
+          end
+          ref = private_register_image(interpolate, 
+                                   w, h, data, value_mask_min, value_mask_max, color_space[0], color_space[1], mask_xo_num, bits, filters)
         end
-        private_show_image(
-                    ll[0], ll[1], lr[0], lr[1], ul[0], ul[1], interpolate, 
-                    w, h, data, value_mask_min, value_mask_max, color_space[0], color_space[1], mask_xo_num)
-        return self
+      end
+      if ! register_only
+        private_show_image_from_ref(ref, 
+                                    ll[0], ll[1], lr[0], lr[1], ul[0], ul[1])
+      end
+      return ref
     end
     
     def report_error(er, msg)