tioga 1.7 → 1.8

data/Tioga_README

@@ -1,6 +1,7 @@
-This is the README for the Tioga kernel, version 1.6, March 17, 2007.
+This is the README for the Tioga kernel, version 1.8, April 4, 2008.
 
-    Copyright (C) 2005, 2006, 2007  Bill Paxton
+    Copyright (C) 2005, 2006, 2007, 2008  Bill Paxton
+    Copyright (C) 2007, 2008 Vincent Fourmond, Taro Sato
     
     This file is part of Tioga.
     
@@ -14,36 +15,21 @@ This is the README for the Tioga kernel, version 1.6, March 17, 2007.
     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 LicenseD
+    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
 
 << What's new >>
 
-    Version 1.7 adds an option in legends for markers without any line;
-just call save_legend_info with 'line_type' => 'None' in addition to
-the marker information.  It is also now possible to give a 'legend' argument
-to show_marker.  The value of the arg can be either a legend dictionary
-or simply the legend text in which case defaults will be supplied for
-the rest.  There is an example of this in samples/plots.rb
-in the Legend_Outside figure.
-
-    It saw a very significant improvement in that you can now query
-the exact size of a text typeset by LaTeX, with the function text_size. Please
-have a look at its documentation, and at the Text_size and 
-Text_size_with_rotation samples in samples/figures/figures.rb.
-
-    The code base was quite moved around so as to facilitate work on a 
-Python version that would share as much code as possible with the Ruby one;
-this should not bring user-visible changes (apart, maybe, from compilation
-problems, but we hope not).
+    Version 1.8 is essentially a cleanup/bug fix release. Tioga now compiles
+with hardly any warnings, thanks to the work by Taro Sato. show_axis can now
+take a hash instead of a simple location, and can draw axes basically
+anywhere. See the axes_fun function in samples/plots/plots.rb and
+show_axis documentation. Few bugs were fixed, in particular the
+position of ticks with ticks_inside/ticks_outside, and the
+installation via Rubygems which was broken for such a long time we are
+ashamed of it. 
 
-    Some bug fixes, including potential stack overflows (unprotected
-snprintfs), and some new methods of Function. Dvector.fancy_read has been
-reimplemented in C and benchmarked: it should be around three times faster
-than before.
-
-    Code should now compile cleanly with Ruby 1.9.
 
 << Quick Installation of Tioga >>
 
@@ -54,9 +40,10 @@ the whole thing with a 'sudo'.  For Linux, you may have to become root.
 Once you've taken care of that, just run the QUICK_INSTALL script and
 keep your fingers crossed.
 
-    You now have the option to run HOME_INSTALL instead, which will install the files to 
-your home directory (no root privileges needed). You just need to set your RUBYLIB 
-environment variable as reminded at the end of the file.
+    You now have the option to run HOME_INSTALL instead, which will
+install the files to your home directory (no root privileges
+needed). You just need to set your RUBYLIB environment variable as
+reminded at the end of the file.
 
     Please check that there are 0 failures and 0 errors at the end of the test.
 Then, in your favorite PDF previewer, open the newly created 'tests/Icon_Test.pdf'
@@ -191,6 +178,35 @@ Bill Paxton
 Here are the old release messages:
 
 
+--------------------------
+
+    Version 1.7 adds an option in legends for markers without any line;
+just call save_legend_info with 'line_type' => 'None' in addition to
+the marker information.  It is also now possible to give a 'legend' argument
+to show_marker.  The value of the arg can be either a legend dictionary
+or simply the legend text in which case defaults will be supplied for
+the rest.  There is an example of this in samples/plots.rb
+in the Legend_Outside figure.
+
+    It saw a very significant improvement in that you can now query
+the exact size of a text typeset by LaTeX, with the function text_size. Please
+have a look at its documentation, and at the Text_size and 
+Text_size_with_rotation samples in samples/figures/figures.rb.
+
+    The code base was quite moved around so as to facilitate work on a 
+Python version that would share as much code as possible with the Ruby one;
+this should not bring user-visible changes (apart, maybe, from compilation
+problems, but we hope not).
+
+    Some bug fixes, including potential stack overflows (unprotected
+snprintfs), and some new methods of Function. Dvector.fancy_read has been
+reimplemented in C and benchmarked: it should be around three times faster
+than before.
+
+    Code should now compile cleanly with Ruby 1.9.
+
+
+
 
 --------------------------
 

data/split/Dvector/dvector.c

@@ -4601,7 +4601,7 @@ VALUE Read_Rows_of_Dvectors(char *filename, VALUE destinations, int first_row_of
          if (!is_okay_number(v)) {
             fclose(file);
             free(buff);
-            rb_raise(rb_eArgError, "ERROR: bad value %g in line i% of file %s", v, i, filename);
+            rb_raise(rb_eArgError, "ERROR: bad value %g in line %i of file %s", v, i, filename);
          }
          if (col < d->capa) { row_data[col] = v; d->len = col+1; }
          else {

data/split/Tioga/{shared/axes.c → axes.c}

@@ -1,6 +1,8 @@
+/* -*- c-basic-offset: 3; -*- */
 /* axes.c */
 /*
    Copyright (C) 2005  Bill Paxton
+   Copyright (C) 2008  Vincent Fourmond
 
    This file is part of Tioga.
 
@@ -21,6 +23,20 @@
 #include "figures.h"
 #include "pdfs.h"
 
+/* 
+   Here is my (Vincent) big TODO-list for the axes stuff:
+   * provide a way to reliably get the location from major/minor
+     ticks for a given axis, so users can build lines/grids that build on
+     top of that (or rather under it ;-)...)
+     -> this is partly done, as you can now get the major ticks position.
+   * let the users choose between the current way to pick up ticks position
+     and another, such as the one I'm using in SciYAG, which seems to give
+     results that are more according to my expectations.
+
+   * BUG fix: apparently, two calls to the axes stuff do no return the
+     same thing, so I'll need to have a careful look at that
+ */
+
 typedef struct {
    int type;
    int other_axis_type;
@@ -172,7 +188,14 @@ static void Get_yaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 
 /*======================================================================*/
 
-static void draw_axis_line(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *ierr)
+/* 
+   Internal values for axis locations.
+ */
+#define AXIS_FREE_LOCATION 1000
+
+/* Prepares the various coordinates according to the axis location */
+static void prepare_axis_coordinates(OBJ_PTR fmkr, FM *p, 
+				     int location, PlotAxis *s, int *ierr)
 {
    switch (location) {
       case LEFT:
@@ -253,7 +276,16 @@ static void draw_axis_line(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *
          s->other_axis_reversed = p->yaxis_reversed;
          s->top_or_right = false;
          break;
-   }
+      case AXIS_FREE_LOCATION:
+	 /* Nothing to be done here. */
+	 break;
+    }
+}
+
+static void draw_axis_line(OBJ_PTR fmkr, FM *p, int location, 
+			   PlotAxis *s, int *ierr)
+{
+   prepare_axis_coordinates(fmkr, p, location, s, ierr);
    c_line_width_set(fmkr, p, s->line_width, ierr);
    figure_join_and_stroke(fmkr, p, s->x0, s->y0, s->x1, s->y1, ierr);
 }
@@ -302,6 +334,7 @@ static char *Create_Label(double val, int scale, int prec,
    return string;
 }
 
+/* vincent: I wonder what this function is doing here ;-)...  */
 char *Get_String(OBJ_PTR ary, int index, int *ierr) {
    OBJ_PTR s = Array_Entry(ary,index,ierr);
    if (*ierr != 0) return NULL;
@@ -536,9 +569,11 @@ static void Pick_Major_Tick_Interval(OBJ_PTR fmkr, FM *p,
    }
 }
 
-static void draw_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
+/* This functions fills the majors attribute of the PlotAxis object
+   with the position of major ticks
+*/
+static void compute_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 {
-   s->num_minors = s->number_of_minor_intervals; 
    if (s->locations_for_major_ticks != OBJ_NIL) {
       long len;
       s->majors = Vector_Data_for_Read(s->locations_for_major_ticks, &len, ierr);
@@ -559,12 +594,22 @@ static void draw_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
       if (*ierr != 0) return;
       s->free_majors = true;
    }
+}
+
+static void draw_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
+{
+   s->num_minors = s->number_of_minor_intervals; 
+
+   /* Get the major ticks position in s->majors */
+   compute_major_ticks(fmkr, p, s, ierr);
+   if(*ierr != 0) return;
+
    int i;
    double inside=0.0, outside=0.0, length;
    bool did_line = false;
    length = s->major_tick_length * ((s->vertical)? p->default_text_height_dx : p->default_text_height_dy);
    if (s->ticks_inside) inside = length;
-   if (s->ticks_outside) outside = length;
+   if (s->ticks_outside) outside = -length;
    if (s->top_or_right) { inside = -inside; outside = -outside; }
    if (s->line_width != s->major_tick_width) {
       c_line_width_set(fmkr, p, s->line_width = s->major_tick_width, ierr);
@@ -607,7 +652,7 @@ static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    if (s->log_vals && nsub > 9) nsub = 9;
    length = s->minor_tick_length * ((s->vertical)? p->default_text_height_dx : p->default_text_height_dy);
    if (s->ticks_inside) inside = length;
-   if (s->ticks_outside) outside = length;
+   if (s->ticks_outside) outside = -length;
    if (s->top_or_right) { inside = -inside; outside = -outside; }
    if (s->line_width != s->minor_tick_width) {
       c_line_width_set(fmkr, p, s->line_width = s->minor_tick_width, ierr);
@@ -635,10 +680,12 @@ static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
             double subloc = loc + ((!s->log_vals) ? (j * subinterval) : log_subintervals[j-1]);
             if (subloc >= next_loc) break;
             if (subloc <= s->axis_min || subloc >= s->axis_max) continue;
-            if (s->vertical)
+            if (s->vertical) {
                figure_join(fmkr, p, s->x0+inside, subloc, s->x0+outside, subloc, ierr);
-            else
+            }
+            else {
                figure_join(fmkr, p, subloc, s->y0+inside, subloc, s->y0+outside, ierr);
+            }
             did_line = true;
             if (*ierr != 0) return;
          }
@@ -649,10 +696,41 @@ static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 
 static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s, 
    char *text, int location, double position, double shift, int *ierr)
-{ // position is in figure coords and must be converted to frame coords
-   double pos = ((!s->reversed)? (position - s->axis_min) : (s->axis_max - position)) / s->length;
-   c_show_rotated_text(fmkr, p, text, location, shift, pos, 
-		       s->numeric_label_scale, s->numeric_label_angle, s->numeric_label_justification, s->numeric_label_alignment, OBJ_NIL, ierr);
+{ 
+   if(location == AXIS_FREE_LOCATION) {
+      /* We convert the tick position into frame position */
+      double x,y, ft_ht = p->default_text_scale * 
+	 s->numeric_label_scale * p->default_font_size;
+      double angle;
+      /* Defaults to angle = +90, left side of the axis */
+      if(s->vertical) {
+	 y = position;
+	 x = s->x0 + convert_output_to_figure_dx(p,(s->reversed ? 1.0 : -1.0) *
+						 ft_ht * ENLARGE * shift);
+	    
+				      
+	 angle = 90;
+      }
+      else {
+	 angle = 0;
+	 x = position;
+	 y = s->y0 + convert_output_to_figure_dy(p,(s->reversed ? 1.0 : -1.0) *
+						 ft_ht * ENLARGE * shift);
+      }
+
+      c_show_rotated_label(fmkr, p, text, x, y, 
+			   s->numeric_label_scale, 
+			   s->numeric_label_angle + angle, 
+			   s->numeric_label_justification, 
+			   s->numeric_label_alignment, OBJ_NIL, ierr);
+      
+   }
+   else {
+      // position is in figure coords and must be converted to frame coords
+      double pos = ((!s->reversed)? (position - s->axis_min) : (s->axis_max - position)) / s->length;
+      c_show_rotated_text(fmkr, p, text, location, shift, pos, 
+			  s->numeric_label_scale, s->numeric_label_angle, s->numeric_label_justification, s->numeric_label_alignment, OBJ_NIL, ierr);
+   }
 }
 
 static void draw_numeric_labels(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *ierr)
@@ -669,6 +747,20 @@ static void draw_numeric_labels(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s,
    }
 }
 
+/* Frees all temporarily allocated memory */
+static void free_allocated_memory(PlotAxis *s)
+{
+   int i;
+   if (s->free_majors) free(s->majors);
+   if (s->labels != NULL) {
+      if (s->free_strings_for_labels) {
+         for (i = 0; i < s->nmajors; i++)
+            if (s->labels[i] != NULL) free(s->labels[i]);
+      }
+      free(s->labels);
+   }
+}
+
 static void c_show_side(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr) {
    int i;
    if (s->type == AXIS_HIDDEN) return;
@@ -694,32 +786,9 @@ static void c_show_side(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr) {
    if (*ierr != 0) return;
  done:
    End_Axis_Standard_State(); // grestore
-   if (s->free_majors) free(s->majors);
-   if (s->labels != NULL) {
-      if (s->free_strings_for_labels) {
-         for (i = 0; i < s->nmajors; i++)
-            if (s->labels[i] != NULL) free(s->labels[i]);
-      }
-      free(s->labels);
-   }
+   free_allocated_memory(s);
 }
 
-
-void c_show_axis(OBJ_PTR fmkr, FM *p, int location, int *ierr)
-{
-   PlotAxis axis;
-   if (location == LEFT || location == RIGHT || location == AT_X_ORIGIN) {
-      if (!p->yaxis_visible) return;
-      Get_yaxis_Specs(fmkr, p, &axis, ierr);
-   } else if (location == TOP || location == BOTTOM || location == AT_Y_ORIGIN) {
-      if (!p->xaxis_visible) return;
-      Get_xaxis_Specs(fmkr, p, &axis, ierr);
-   } else RAISE_ERROR_i(
-         "Sorry: invalid 'loc' for axis: must be one of LEFT, RIGHT, TOP, BOTTOM, AT_X_ORIGIN, or AT_Y_ORIGIN: is (%i)", location, ierr);
-   if (*ierr != 0) return;
-   axis.location = location;
-   c_show_side(fmkr, p, &axis, ierr);
-}
       
 void c_show_edge(OBJ_PTR fmkr, FM *p, int location, int *ierr)
 {
@@ -796,3 +865,258 @@ void c_no_bottom_edge(OBJ_PTR fmkr, FM *p, int *ierr)
    p->bottom_edge_visible = false;
 }
 
+
+/* Prepares the PlotAxis object for a standard use.
+   Returns 1 if the corresponding axis is marked as 
+   visible and 0 if not.
+
+   This function will be used later to get the exact same PlotAxis
+   object so as to get information about the ticks, for instance.
+*/
+static int prepare_standard_PlotAxis(OBJ_PTR fmkr, FM *p, 
+				     int location, PlotAxis * axis, 
+				     int *ierr)
+{
+   axis->location = location;
+   if (location == LEFT || location == RIGHT || location == AT_X_ORIGIN) {
+      Get_yaxis_Specs(fmkr, p, axis, ierr);
+      if (!p->yaxis_visible) return 0;
+   } 
+   else if (location == TOP || location == BOTTOM || location == AT_Y_ORIGIN) {
+      Get_xaxis_Specs(fmkr, p, axis, ierr);
+      if (!p->xaxis_visible) return 0;
+   } 
+   else 
+      RAISE_ERROR_i("Sorry: invalid 'loc' for axis: must be one of LEFT,"
+		    "RIGHT, TOP, BOTTOM, AT_X_ORIGIN, or AT_Y_ORIGIN: is (%i)",
+		    location, ierr);
+   if (*ierr != 0) 
+      return 0;
+   return 1;
+}
+
+
+void c_show_axis(OBJ_PTR fmkr, FM *p, int location, int *ierr)
+{
+   PlotAxis axis;
+   if(prepare_standard_PlotAxis(fmkr, p, location, &axis, ierr)) {
+      c_show_side(fmkr, p, &axis, ierr);
+   }
+}
+
+/* This function prepares a PlotAxis object based on the information
+   given in the dict argument.
+*/
+static int prepare_dict_PlotAxis(OBJ_PTR fmkr, FM *p, 
+				 OBJ_PTR axis_spec, PlotAxis * axis, 
+				 int *ierr)
+{
+   /* First, we get default from the location or from style.
+      Too many things need to be checked if we don't get default values
+      from a given point
+   */
+   if(Hash_Has_Key(axis_spec, "location")) {
+      int location = Number_to_int(Hash_Get_Obj(axis_spec, "location"), ierr); 
+      if (location == LEFT || location == RIGHT || location == AT_X_ORIGIN) {
+	 Get_yaxis_Specs(fmkr, p, axis, ierr); 
+      } 
+      else if (location == TOP || location == BOTTOM || 
+	       location == AT_Y_ORIGIN) {
+	 Get_xaxis_Specs(fmkr, p, axis, ierr);
+      } 
+      axis->location = location;
+   }
+   else {
+      if(Hash_Has_Key(axis_spec, "from") && Hash_Has_Key(axis_spec, "to")) {
+	 long dummy; 
+	 double *from = Vector_Data_for_Read(Hash_Get_Obj(axis_spec, "from"), 
+					     &dummy, ierr);
+	 double *to = Vector_Data_for_Read(Hash_Get_Obj(axis_spec, "to"),
+					   &dummy, ierr);
+	 axis->x0 = from[0];
+	 axis->x1 = to[0];
+	 axis->y0 = from[1];
+	 axis->y1 = to[1];
+
+	 /* We now determine various parameters attached to the axis:
+	    * its length
+	    * its min/max boundaries
+	    * whether it is reversed
+	  */
+	 if(axis->y0 != axis->y1) {
+	    Get_yaxis_Specs(fmkr, p, axis, ierr);
+	    if(axis->x0 != axis->x1) {
+	       RAISE_ERROR("show_axis: sorry, axes must be horizontal or "
+			   "vertical", ierr);
+	    }
+	    else {
+	       if(axis->y0 > axis->y1) {
+		  axis->reversed = true;
+		  axis->axis_min = axis->y1;
+		  axis->axis_max = axis->y0;
+		  axis->length = axis->y0 - axis->y1;
+	       }
+	       else {
+		  axis->reversed = false;
+		  axis->axis_min = axis->y0;
+		  axis->axis_max = axis->y1;
+		  axis->length = axis->y1 - axis->y0;
+	       }
+	       axis->vertical = true;
+	       axis->location = AXIS_FREE_LOCATION;
+	    }
+	 }
+	 else {
+	    Get_xaxis_Specs(fmkr, p, axis, ierr);
+	    if(axis->x0 > axis->x1) {
+	       axis->reversed = true;
+	       axis->axis_min = axis->x1;
+	       axis->axis_max = axis->x0;
+	       axis->length = axis->x0 - axis->x1;
+	    }
+	    else {
+	       axis->reversed = false;
+	       axis->axis_min = axis->x0;
+	       axis->axis_max = axis->x1;
+	       axis->length = axis->x1 - axis->x0;
+	    }
+	    axis->vertical = false;
+	    axis->location = AXIS_FREE_LOCATION;
+	 }
+      }
+      else {
+	 RAISE_ERROR("show_axis: there must be  'location' or 'to' and 'from'", ierr);
+      }
+   }
+
+   /* Some generic overrides */
+   if(Hash_Has_Key(axis_spec, "type"))
+      axis->type = Number_to_int(Hash_Get_Obj(axis_spec, "type"), ierr);
+
+   if(Hash_Has_Key(axis_spec, "ticks_inside")) {
+      OBJ_PTR val = Hash_Get_Obj(axis_spec, "ticks_inside");
+      if(val == OBJ_NIL || val == OBJ_FALSE) 
+	 axis->ticks_inside = false;
+      else
+	 axis->ticks_inside = true;
+   }
+
+   if(Hash_Has_Key(axis_spec, "ticks_outside")) {
+      OBJ_PTR val = Hash_Get_Obj(axis_spec, "ticks_outside");
+      if(val == OBJ_NIL || val == OBJ_FALSE) 
+	 axis->ticks_outside = false;
+      else
+	 axis->ticks_outside = true;
+   }
+
+   if(Hash_Has_Key(axis_spec, "major_ticks"))
+      axis->locations_for_major_ticks = Hash_Get_Obj(axis_spec, "major_ticks");
+   if(Hash_Has_Key(axis_spec, "minor_ticks"))
+      axis->locations_for_minor_ticks = Hash_Get_Obj(axis_spec, "minor_ticks");
+   if(Hash_Has_Key(axis_spec, "labels"))
+      axis->tick_labels = Hash_Get_Obj(axis_spec, "labels");
+
+
+   /* Various tick label attributes */
+   if(Hash_Has_Key(axis_spec, "shift"))
+      axis->numeric_label_shift = Hash_Get_Double(axis_spec, "shift");
+   if(Hash_Has_Key(axis_spec, "scale"))
+      axis->numeric_label_scale = Hash_Get_Double(axis_spec, "scale");
+   if(Hash_Has_Key(axis_spec, "angle"))
+      axis->numeric_label_angle = Hash_Get_Double(axis_spec, "angle");
+   
+   /* Ticks attributes */
+   if(Hash_Has_Key(axis_spec, "major_tick_width"))
+      axis->major_tick_width = Hash_Get_Double(axis_spec, "major_tick_width");
+   if(Hash_Has_Key(axis_spec, "minor_tick_width"))
+      axis->minor_tick_width = Hash_Get_Double(axis_spec, "minor_tick_width");
+   if(Hash_Has_Key(axis_spec, "major_tick_length"))
+      axis->major_tick_length = Hash_Get_Double(axis_spec, "major_tick_length");
+   if(Hash_Has_Key(axis_spec, "minor_tick_length"))
+      axis->minor_tick_length = Hash_Get_Double(axis_spec, "minor_tick_length");
+
+   return 1;
+}
+
+
+/* This function does nearly the same job as c_show_axis, but takes
+   a full hash instead of getting information from the FigureMaker object,
+   it retrieves them from the axis_spec hash. Following keys are
+   understood:
+   - location: position, as in show_axis. Can be omitted, if you
+     provide the position yourself
+
+   This function bypasses the axis_visible checks. Use with caution !
+*/
+void c_show_axis_generic(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec, int *ierr)
+{
+   PlotAxis axis;
+   if(prepare_dict_PlotAxis(fmkr, p, axis_spec, &axis, ierr)) {
+      c_show_side(fmkr, p, &axis, ierr);
+   }
+}
+
+
+/* 
+   This function takes an axis specification (either integer or
+   hash) and returns a hash containing the following keys:
+   * 'major' : position of all major ticks
+   * 'labels' : the names of all labels
+   * 'vertical' : if the axis is vertical or horizontal
+   * 'line_width' : the line width
+   * 'major_tick_width', 'major_tick_length' : the major tick width and length
+   * 'minor_tick_width', 'minor_tick_length' : the minor tick width and length
+   * 'scale', 'shift' and 'angle': the scale, shift and angle of numeric
+     labels
+   * 'x0', 'y0', 'x1', 'y1': the position of the axis in figure coordinates
+
+ */
+OBJ_PTR c_axis_get_information(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec,
+			       int *ierr)
+{
+   PlotAxis axis;
+   OBJ_PTR hash = Hash_New(), ar;
+   int i;
+   if(Is_Kind_of_Integer(axis_spec))
+      prepare_standard_PlotAxis(fmkr, p, Number_to_int(axis_spec, ierr),
+				&axis, ierr);
+   else 
+      prepare_dict_PlotAxis(fmkr, p, axis_spec, &axis, ierr);
+
+   /* First, major ticks positions */
+   prepare_axis_coordinates(fmkr, p, axis.location, &axis, ierr);
+   compute_major_ticks(fmkr, p, &axis, ierr);
+   Hash_Set_Obj(hash, "major", Vector_New(axis.nmajors, axis.majors));
+
+   /* Then, labels */
+   ar = Array_New(axis.nmajors);
+   axis.labels = Get_Labels(fmkr, p, &axis, ierr);
+   for (i=0; i < axis.nmajors; i++) {
+      if (axis.labels[i])
+	 Array_Store(ar, i, String_From_Cstring(axis.labels[i]), ierr);
+      else
+	 Array_Store(ar, i, OBJ_NIL, ierr);
+   }
+
+   Hash_Set_Obj(hash, "labels", ar);
+
+   Hash_Set_Obj(hash, "vertical", axis.vertical ? OBJ_TRUE : OBJ_FALSE);
+
+   Hash_Set_Double(hash, "line_width", axis.line_width);
+   Hash_Set_Double(hash, "major_tick_width", axis.major_tick_width);
+   Hash_Set_Double(hash, "minor_tick_width", axis.major_tick_width);
+   Hash_Set_Double(hash, "major_tick_length", axis.major_tick_length);
+   Hash_Set_Double(hash, "minor_tick_length", axis.major_tick_length);
+   Hash_Set_Double(hash, "shift", axis.numeric_label_shift);
+   Hash_Set_Double(hash, "scale", axis.numeric_label_scale);
+   Hash_Set_Double(hash, "angle", axis.numeric_label_angle);
+
+   /* Positions of the axis */
+   Hash_Set_Double(hash, "x0", axis.x0);
+   Hash_Set_Double(hash, "x1", axis.x1);
+   Hash_Set_Double(hash, "y0", axis.y0);
+   Hash_Set_Double(hash, "y1", axis.y1);
+
+   free_allocated_memory(&axis);
+   return hash;
+}