tioga 1.4

data/split/Tioga/lib/Rectangles.rb

@@ -0,0 +1,94 @@
+#  Rectangles.rb
+
+module Tioga
+
+# These are the methods for creating and using rectangular paths for PDF graphics operations.
+
+class Rectangles < Doc < FigureMaker
+
+# Add a rectangle with corners at (_x_, _y_), (_x_ + _width_, _y_),
+# (_x_ + _width_, _y_ + _height_), and (_x_, _y_ + _height_).
+   def append_rect_to_path(x, y, width, height)
+   end
+   
+# Calls append_rect_to_path followed by #fill.
+   def fill_rect(x, y, width, height)
+   end
+
+# Calls append_rect_to_path followed by #stroke.
+   def stroke_rect(x, y, width, height)
+   end
+
+# Calls append_rect_to_path followed by fill_and_stroke.
+   def fill_and_stroke_rect(x, y, width, height)
+   end
+   
+# Calls append_rect_to_path followed by #clip.
+   def clip_rect(x, y, width, height)
+   end
+   
+# :call-seq:
+#               append_frame_to_path                         
+#                   
+# Calls append_rect_to_path with the current frame rectangle.
+   def append_frame_to_path
+   end
+
+# :call-seq:
+#               stroke_frame                         
+#                   
+# Calls append_frame_to_path followed by #stroke.
+   def stroke_frame
+   end
+
+# :call-seq:
+#               fill_frame                         
+#                   
+# Calls append_frame_to_path followed by #fill.
+   def fill_frame
+   end
+
+# :call-seq:
+#               fill_and_stroke_frame                         
+#                   
+# Calls append_frame_to_path followed by fill_and_stroke.
+   def fill_and_stroke_frame
+   end
+
+# :call-seq:
+#               clip_to_frame                         
+#                   
+# Calls append_frame_to_path followed by #clip.
+   def clip_to_frame
+   end
+   
+# Like append_rect_to_path, but with corners rounded with
+# curvatures given by _dx_ and _dy_.
+#
+# The illustration shows a rounded rectangle stroked and used as a clipping path
+# for showing the image.
+#
+# http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/append_rounded_rect.jpg
+#
+   def append_rounded_rect_to_path(x, y, width, height, dx, dy)
+   end
+   
+# Calls append_rounded_rect_to_path followed by #clip.
+   def clip_rounded_rect(x, y, width, height, dx, dy)
+   end
+   
+# Calls append_rounded_rect_to_path followed by #fill.
+   def fill_rounded_rect(x, y, width, height, dx, dy)
+   end
+   
+# Calls append_rounded_rect_to_path followed by #stroke.
+   def stroke_rounded_rect(x, y, width, height, dx, dy)
+   end
+
+# Calls append_rounded_rect_to_path followed by fill_and_stroke.
+   def fill_and_stroke_rounded_rect(x, y, width, height, dx, dy)
+   end
+
+
+end # class
+end # module Tioga

data/split/Tioga/lib/Shading.rb

@@ -0,0 +1,100 @@
+#  Shading.rb
+
+module Tioga
+
+# These are the methods for doing shaded regions in PDF graphics.
+
+class Shading < Doc < FigureMaker
+
+=begin rdoc
+Draws a color blend that varies along a linear axis between two endpoints and extends indefinitely perpendicular to that axis to the limits of the current clipping region.  The color sequence is given by a colormap such as produced by create_colormap.  Color position 0.0 of the colormap
+goes at the start point, color position 1.0 of the colormap goes at the end point, and the intermediate colors are
+placed at the corresponding intermediate locations along the line joining the start point to the end point.
+
+If the 'extend_start' flag is +true+, then the start color is extended indefinitely beyond the start point to the
+limits of the clipping region. Similarly, if the 'extend_end' flag is +true+, the end color is extended
+indefinitely beyond the end point.
+
+See also radial_shading.
+
+Dictionary Entries
+    'x_start'         => a_float              # x coordinate of the start of the gradient
+    'y_start'         => a_float              # y coordinate of the start of the gradient
+    'start'           => [ x_start, y_start ] # coordinates of the start of the gradient
+    'start_point'                             # alias for 'start'
+    'x_end'           => a_float              # x coordinate of the end of the gradient
+    'y_end'           => a_float              # y coordinate of the end of the gradient
+    'end'             => [ x_end, y_end ]     # coordinates of the end of the gradient
+    'end_point'                               # alias for 'end'
+    'colormap'        => a_colormap           # determines the shading
+    'color_map'                               # alias for 'colormap'
+    'extend_start'    => true_or_false        # default false
+    'extend_end'      => true_or_false        # default false
+
+Example
+
+    def axial_shading
+        t.clip_rect(0, 0, 1, 1)
+        t.axial_shading(
+            'start_point' => [0, 0], 'end_point' => [1, 1], 
+            'colormap' => t.mellow_colormap)
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Axial_Shading.jpg
+
+=end
+    def axial_shading(dict)
+    end
+
+=begin rdoc
+Draws a color blend that varies between two circles.  The color sequence is given by a colormap such as produced by create_colormap.  Color position 0.0 of the colormap
+goes at the start circle, color position 1.0 of the colormap goes at the end circle, and the intermediate colors are
+placed on corresponding intermediate circles.  The circles can be stretched and rotated by the 'x_hat' and 'y_hat'
+arguments which tell how to map unit vectors in x and y respectively.
+
+If the 'extend_start' flag is +true+, then the start color is extended beyond the start circle. Similarly, if the 'extend_end' flag is +true+, the end color is extended beyond the end point.  Note that either of the starting and ending circles may be larger than the other. If the shading is extended at the smaller end, the family of blend circles continues as far as the radius of the blend circle is greater than 0; if the shading is extended at the larger end, the blend circles continue until the radius of the blend circle is large enough to encompass the shading's entire bounding box. Extending the shading can thus cause painting to extend beyond the areas defined by the two circles themselves.
+
+See also axial_shading.
+
+Dictionary Entries
+    'x_start'       => a_float       # x coordinate of the center of the start circle
+    'y_start'       => a_float       # y coordinate of the center of the start circle
+    'radius_start'  => a_float       # the radius of the start circle
+    'start_radius'                   # alias for 'radius_start'
+    'start'         => [ x_start, y_start, radius_start ]
+    'start_circle'                   # alias for 'start'
+    'x_end'         => a_float       # x coordinate of the center of the end circle
+    'y_end'         => a_float       # y coordinate of the center of the end circle
+    'radius_end'    => a_float       # the radius of the end circle
+    'end_radius'                     # alias for 'radius_end'
+    'end'           => [ x_end, y_end, radius_end ]
+    'end_circle'                     # alias for 'end'
+    'colormap'      => a_colormap    # determines the shading
+    'color_map'                      # alias for 'colormap'
+    'x_hat'         => [x, y]        # default is [1, 0]
+    'xhat'                           # alias for 'x_hat'
+    'y_hat'         => [x, y]        # default is [0, 1]
+    'yhat'                           # alias for 'y_hat'
+    'extend_start'  => true_or_false # default false
+    'extend_end'    => true_or_false # default false
+
+Example
+
+    def radial_shading
+        t.clip_rect(0, 0, 1, 1)
+        t.radial_shading(
+            'x_hat' => [0.5, 0.2], 'y_hat' => [0.0, 0.75],
+            'start_circle' => [0.75, 0.65, 0.9],
+            'end_circle' => [0.75, 0.65, 0.0], 
+            'colormap' => t.intense_colormap,
+            'extend_start' => true)
+    end
+    
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Radial_Shading.jpg
+=end
+    def radial_shading(dict)
+    end
+
+
+end # class
+end # module Tioga

data/split/Tioga/lib/Special_Paths.rb

@@ -0,0 +1,307 @@
+#  Special_Paths.rb
+
+module Tioga
+
+# These are the methods for creating and using various special paths including contours, splines, steps, arrows, and error bars.
+
+class Special_Paths < Doc < FigureMaker
+
+=begin rdoc
+Creates a path following a contour in a two dimensional table of data using an algorithm from
+Gri[http://gri.sourceforge.net/] done by Dan Kelley.
+(There is also an option to use the
+CONREC[http://local.wasp.uwa.edu.au/~pbourke/papers/conrec/] algorithm of Paul D. Bourke.)
+See show_contour.
+
+Dictionary Entries
+    'zs'        => a_dtable    # The data table
+    'data'                     # Alias for 'zs'
+    'xs'        => a_dvector   # The x figure coordinates for the columns of data
+    'ys'        => a_dvector   # The y figure coordinates for the rows of data
+    'legit'     => a_dtable    # Optional table, same size as zs, non-zero means corresponding data is okay.
+    'dest_xs'   => a_dvector   # The contour x values will be placed in this Dvector.
+    'dest_ys'   => a_dvector   # The contour y values will be placed in this Dvector.
+    'gaps'      => an_array    # Indices for gaps will be placed in this Array.
+    'z_level'   => a_float     # The contour level
+    'z'                        # Alias for 'z_level'
+    'level'                    # Alias for 'z_level'
+    'method'   => a_string     # (Optional) set to 'conrec' to use that algorithm instead of the one from Gri.
+
+Example
+
+    levels = [9,10,11,12,13,14,15,16,17]
+    t.show_plot('boundaries' => bounds) do
+        clip_press_image
+        t.stroke_color = SlateGray
+        t.line_width = 1
+        dest_xs = Dvector.new; dest_ys = Dvector.new; gaps = Array.new
+        dict = { 'dest_xs' => dest_xs, 'dest_ys' => dest_ys, 'gaps' => gaps,
+                'xs' => @eos_logRHOs, 'ys' => @eos_logTs,
+                'data' => @pres_data }
+        levels.each do |level|
+            dict['level'] = level
+            t.make_contour(dict)
+            t.append_points_with_gaps_to_path(dest_xs, dest_ys, gaps, true)
+            t.stroke
+        end
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Contours.jpg
+
+=end
+    def make_contour(dict)
+    end
+    
+=begin rdoc
+Creates a 'staircase' path with steps matching the given data points.  
+
+Dictionary Entries
+    'xfirst'        => a_float    # x location for the start of the steps
+    'x_first'                     # Alias for 'xfirst'
+    'yfirst'        => a_float    # y location for the start of the steps
+    'y_first'                     # Alias for 'yfirst'
+    'xlast'         => a_float    # x location for the end of the steps
+    'x_last'                      # Alias for 'xlast'
+    'ylast'         => a_float    # y location for the end of the steps
+    'y_last'                      # Alias for 'ylast'
+    'xs'            => a_dvector  # The data x in figure coordinates
+    'ys'            => a_dvector  # The data y in figure coordinates
+    'dest_xs'       => a_dvector  # The x values for the steps will go here.
+    'dest_ys'       => a_dvector  # The y values for the steps will go here.
+
+The widths of steps are determined by 'xfirst', 'xs', and 'xlast'; the heights of steps are
+determined by 'yfirst', 'ys', and 'ylast'.   The steps up and down occur at the midpoints between
+the given x locations.
+
+Example
+
+    def steps
+        t.do_box_labels("Steps", "Position", "Average Count")
+        xs = Dvector[ 1.0, 2.0, 5.0, 6.0, 7.0, 8.0, 10.0, 13.0, 17.0 ]
+        ys = Dvector[ 3.0, 3.7, 3.9, 4.2, 5.7, 6.6,  7.1,  6.7,  4.5 ]
+        data_pts = xs.size
+        x_first = 0.0; x_last = 18.0; y_first = y_last = 2.5
+        x_results = Dvector[]
+        y_results = Dvector[]
+        t.make_steps(
+            'xs' => xs, 'ys' => ys,
+            'dest_xs' => x_results, 'dest_ys' => y_results,
+            'x_first' => x_first, 'y_first' => y_first,
+            'x_last' => x_last, 'y_last' => y_last)
+        t.show_plot('boundaries' => [-1, 19, 8, 2]) do
+            t.fill_color = FloralWhite
+            t.fill_frame
+            t.stroke_color = Blue
+            t.append_points_to_path(x_results, y_results)
+            t.stroke
+            t.show_marker('Xs' => xs, 'Ys' => ys, 'marker' => Bullet,
+                'scale' => 0.6, 'color' => Red);
+        end
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Steps.jpg
+=end
+    def make_steps(dict)
+    end
+
+=begin rdoc
+Creates an interpolated series of points smoothly connecting the given data points.  
+See also append_interpolant_to_path for creating smooth paths based on
+Bezier curves rather than on sampled points joined by straight line segments.
+
+Dictionary Entries
+    'start_slope'      => a_float    # optional
+    'end_slope'        => a_float    # optional
+    'xs'               => a_dvector  # The data x in figure coordinates
+    'ys'               => a_dvector  # The data y in figure coordinates
+    'sample_xs'        => a_dvector  # The x values where will interpolate
+    'result_ys'        => a_dvector  # The y values will be placed here.
+
+A cubic spline interpolant is created (see make_interpolant) using 'start_slope', 'end_slope', 'xs', and
+'ys'.  At each x location in 'sample_xs', the interpolant is used to find the corresponding y location
+which is then placed in the 'result_ys' vector.  The results can passed to routines such as 
+append_points_to_path or show_polyline.
+
+Example
+
+    def sampled_splines
+        t.do_box_labels("Sampled Splines", "Position", "Average Count")
+        xs = Dvector[ 1.0, 2.0, 5.0, 6.0, 7.0, 8.0, 10.0, 13.0, 17.0 ]
+        ys = Dvector[ 3.0, 3.7, 3.9, 4.2, 5.7, 6.6,  7.1,  6.7,  4.5 ]
+        data_pts = xs.size
+        x_first = 0.0; x_last = 18.0; y_first = y_last = 2.5
+        x_results = Dvector[]
+        y_results = Dvector[]
+        t.make_steps(
+            'dest_xs' => x_results, 'dest_ys' => y_results,
+            'xs' => xs, 'ys' => ys,
+            'x_first' => x_first, 'y_first' => y_first,
+            'x_last' => x_last, 'y_last' => y_last)
+        t.show_plot('boundaries' => [-1, 19, 8, 2]) do
+            t.fill_color = FloralWhite
+            t.fill_frame
+            smooth_pts = 4*(data_pts-1) + 1
+            dx = (xs[data_pts-1] - xs[0])/(smooth_pts-1)
+            sample_xs = Dvector.new(smooth_pts) { |i| i*dx + xs[0] }
+            result_ys = Dvector.new
+            t.make_spline_interpolated_points(
+                'sample_xs' => sample_xs, 'result_ys' => result_ys,
+                'xs' => xs, 'ys' => ys,
+                'start_slope' => 2.5*(ys[1]-ys[0])/(xs[1]-xs[0]))
+            t.stroke_color = Blue
+            t.append_points_to_path(sample_xs, result_ys)
+            t.stroke
+            t.show_marker('Xs' => sample_xs, 'Ys' => result_ys,
+                'marker' => Bullet, 'scale' => 0.4, 'color' => Green);
+            t.show_marker('Xs' => xs, 'Ys' => ys,
+                'marker' => Bullet, 'scale' => 0.6, 'color' => Red);
+        end
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Sampled_Splines.jpg
+
+=end
+    def make_spline_interpolated_points(dict)
+    end
+
+=begin rdoc
+A cubic spline interpolant is created using 'start_slope', 'end_slope', 'xs', and
+'ys'.  The result can passed to append_interpolant_to_path or Dvector.spline_interpolate.
+
+If 'start_slope' is given, it is used as the initial slope of the curve.
+Otherwise, the starting slope is determined by the best fit with the starting second
+derivative set to 0 (known as a "free" or "natural" spline).  The 'end_slope' is
+treated similarly.
+
+Dictionary Entries
+    'start_slope'      => a_float    # optional
+    'end_slope'        => a_float    # optional
+    'xs'               => a_dvector  # The data x in figure coordinates
+    'ys'               => a_dvector  # The data y in figure coordinates
+
+Example
+
+    def splines # append bezier curves
+        t.do_box_labels("Splines", "Position", "Average Count")
+        xs = Dvector[ 1.0, 2.0, 5.0, 6.0, 7.0, 8.0, 10.0, 13.0, 17.0 ]
+        ys = Dvector[ 3.0, 3.7, 3.9, 4.2, 5.7, 6.6,  7.1,  6.7,  4.5 ]
+        t.show_plot('boundaries' => [-1, 19, 8, 2]) do
+            t.fill_color = FloralWhite
+            t.fill_frame
+            start_slope = 2.5*(ys[1]-ys[0])/(xs[1]-xs[0])
+            interp = t.make_interpolant('xs' => xs, 'ys' => ys,
+                'start_slope' => start_slope)
+            t.append_interpolant_to_path(interp)
+            t.stroke_color = Black
+            t.stroke
+            t.show_marker('Xs' => xs, 'Ys' => ys,
+                'marker' => Bullet, 'scale' => 0.6, 'color' => Red);
+        end
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Splines.jpg
+=end
+    def make_interpolant(dict)
+    end
+
+# Appends a series of Bezier curves to the path based on the cubic spline interpolant _interp_.
+# See make_interpolant.
+    def append_interpolant_to_path(interp)
+    end
+
+# Calls #context, then, inside the new context, changes line_type and stroke_color (if those arguments are not +nil+),
+# calls append_points_with_gaps_to_path, calls #stroke, and then saves the legend information (if _legend_
+# is not +nil+).
+    def show_polyline(xs, ys, color = nil, legend = nil, type = nil, gaps = nil, close_subpaths = nil)
+    end
+
+=begin rdoc
+Calls show_polyline with the close_subpaths argument set to +false+.  See make_contour.
+
+Note: If you zoom in on a contour line, you'll discover that it
+is made up of lots of very short, disconnected line segments.  This may be a bug in
+the implementation, or it may be inherent in the algorithm.  I don't know which.
+It only becomes a problem if you try to use dashes or dots to stroke the contour line.
+The sequence of dashes and dots restarts at each section of the stroked line,
+so. for contours, it is constantly restarting and never getting very far.  The result
+is definitely NOT what you'd expect.  
+
+Rather than using dots and dashes for contours, you might consider using different colors and line widths.  For example,
+you might make every N'th contour line thicker and darker to emphasize it.
+=end rdoc
+    def show_contour(xs, ys, gaps = nil, color = nil, type = nil, legend = nil)
+    end
+
+=begin rdoc
+Draws error bars at the given point.  The horizontal extent is given by 'dx' or by 'dx_plus' and 'dx_minus'
+in case they are different.  Similarly, the vertical extent is either 'dy' or 'dy_plus' and 'dy_minus'.
+The 'end_cap' parameter specifies the length of end caps on the error bars in units of the text height.
+
+Dictionary Entries
+    'x'           => a_float    # x coordinate of the point
+    'y'           => a_float    # x coordinate of the point
+    'dx'          => a_float    # horizontal error bar from x - dx to x + dx
+    'dy'          => a_float    # vertical error bar from y - dy to y + dy
+    'dx_plus'     => a_float    # horizontal error bar from x to x + dx_plus
+    'dx_minus'    => a_float    # horizontal error bar from x - dx_minus to x
+    'dy_plus'     => a_float    # vertical error bar from y to y + dy_plus
+    'dy_minus'    => a_float    # vertical error bar from y - dy_minus to y
+    'color'       => a_color    # default is Black.
+    'end_cap'     => a_float    # length in text heights (default is 0.15)
+    'line_width'  => a_float    # default is 1
+
+=end
+    def show_error_bars(dict)
+    end
+
+=begin rdoc
+Draws an arrow connecting the given head and tail points and optionally adds head and tail markers
+rotated to match the slope of the line.
+
+Dictionary Entries
+    'x_head'        => a_float      # x coordinate of the head of the arrow
+    'y_head'        => a_float      # y coordinate of the head of the arrow
+    'head'          => [ x_head, y_head ] # coordinates of the head of the arrow
+    'x_tail'        => a_float      # x coordinate of the tail of the arrow
+    'y_tail'        => a_float      # y coordinate of the tail of the arrow
+    'tail'          => [ x_tail, y_tail ] # coordinates of the tail of the arrow
+    'line_width'    => a_float      # for the line joining head to tail
+    'head_marker'   => a_marker     # default is Arrowhead (use 'None' to omit)
+    'tail_marker'   => a_marker     # default is BarThin (use 'None' to omit)
+    'head_scale'    => a_float      # scale for head_marker
+    'tail_scale'    => a_float      # scale for tail_marker
+    'color'         => a_color      # default for the following colors
+    'head_color'    => a_color      # color for show_marker with head_marker
+    'tail_color'    => a_color      # color for show_marker with tail_marker
+    'line_color'    => a_color      # color for line from head to tail
+
+Example: 't' in this is the default FigureMaker.
+
+    def show_arrows
+        t.stroke_rect(0,0,1,1)
+        center_x = 0.5; center_y = 0.5; len = 0.45
+        hls = t.rgb_to_hls(Red)
+        angles = 36
+        delta = 360.0/angles
+        angles.times do |angle|
+            angle *= delta
+            dx = len*cos(angle*RADIANS_PER_DEGREE)
+            dy = len*sin(angle*RADIANS_PER_DEGREE)
+            x = center_x + dx; y = center_y + dy
+            clr = t.hls_to_rgb([angle, hls[1], hls[2]])
+            t.show_arrow(
+                'head' => [x,y],
+                'tail'=> [center_x, center_y],
+                'head_scale' => 1.5,
+                'tail_marker' => 'None',
+                'head_color' => clr)
+        end
+    end
+
+http://theory.kitp.ucsb.edu/~paxton/tioga_jpegs/Arrows.jpg
+=end
+    def show_arrow(dict)
+    end
+
+end # class
+end # module Tioga