ctioga2 0.0 → 0.1

data/lib/ctioga2/graphics/types/bijection.rb

@@ -16,7 +16,7 @@ require 'ctioga2/log'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 67 $', '$Date: 2009-05-30 23:38:00 +0200 (Sat, 30 May 2009) $')
+  Version::register_svn_info('$Revision: 155 $', '$Date: 2010-06-21 21:41:32 +0200 (Mon, 21 Jun 2010) $')
 
   module Graphics
 
@@ -61,10 +61,10 @@ module CTioga2
         # separated by :: -- or only one block in the case of an
         # involution (very common, actually, all 1/x transforms).
         #
-        # TODO: few things around here to change... in particular,
+        # \todo few things around here to change... in particular,
         # I should try to find a way to include Math... 
         #
-        # TODO: add very common cases ?
+        # \todo add very common cases ?
         def self.from_text(spec)
           blocks = spec.split(/::/).map do |code|
             eval("proc do |x|\n#{code}\nend")

data/lib/ctioga2/graphics/types/boundaries.rb

@@ -16,7 +16,7 @@ require 'ctioga2/log'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+  Version::register_svn_info('$Revision: 125 $', '$Date: 2010-01-12 00:56:15 +0100 (Tue, 12 Jan 2010) $')
 
   # This module contains all graphical elements of CTioga2
   module Graphics
@@ -25,7 +25,108 @@ module CTioga2
     # with Tioga
     module Types
 
+      # A range of coordinates.
+      class SimpleRange
+
+        attr_accessor :first, :last
+
+        # Create a new SimpleRange object that runs from _first_ to
+        # _last_ (_last_ can be less than _first_). A _nil_,
+        # _false_ or NaN in one of those means *unspecified*.
+        #
+        # Alternatively, _first_ can be an object that responds to
+        # #first and #last.
+        def initialize(first, last = nil)
+          if first.respond_to?(:first)
+            @first = first.first
+            @last = first.last
+          else
+            @first = first
+            @last = last
+          end
+        end
+
+        # Minimum value
+        def min
+          @first < @last ? @first : @last
+        end
+
+        # Maximum value
+        def max
+          @first > @last ? @first : @last
+        end
+
+        # Algebraic distance
+        def distance
+          return @last - @first
+        end
+
+        # This function makes sures that the SimpleRange object is big
+        # enough to encompass what it currently does and the _range_
+        # SimpleRange object.
+        #
+        # \todo this does not work correctly in the case of reversed
+        # boundaries. I don't think it can anyway.
+        #
+        # Actually, it even works with normal Range elements !
+        def extend(range)
+          # Left/right
+          if (! @first.is_a? Float) or @first.nan? or
+              (@first > range.first)
+            @first = range.first
+          end
+
+          if (! @last.is_a? Float) or @last.nan? or
+              (@last < range.last)
+            @last = range.last
+          end
+
+          return self
+        end
+
+
+        # Override the Boundaries with the contents of _override_. All
+        # elements which are not _nil_ or NaN from _override_
+        # precisely override those in _self_.
+        def override(override)
+          for el in [ :first, :last]
+            val = override.send(el)
+            if val and (val == val) # Strip NaN on the property that NaN != NaN
+              self.send("#{el}=", val)
+            end
+          end
+        end
+
+        # Apply a fixed margin on the Boundaries.
+        def apply_margin!(margin)
+          d = self.distance
+          @first = @first - margin * d
+          @last = @last + margin * d
+        end
+
+        # Returns a SimpleRange object that is large enough to exactly
+        # contain all _values_
+        def self.bounds(values)
+          return SimpleRange.new(values.min, values.max)
+        end
+
+        # Takes an array of Boundaries and returns a Boundaries object
+        # that precisely encompasses them all. Invalid floats are simply
+        # ignored.
+        def self.overall_range(ranges)
+          retval = SimpleRange.new(nil, nil)
+          for r in ranges
+            retval.extend(b)
+          end
+          return retval
+        end
+      end
+
+
       # An object representing boundaries for a plot.
+      #
+      # \todo Should be converted to using two SimpleRange
+      # objects. Will be more clear anyway.
       class Boundaries
 
         # Boundaries
@@ -65,6 +166,18 @@ module CTioga2
           @bottom > @top ? @bottom : @top
         end
 
+        # Returns a SimpleRange object corresponding to the horizontal
+        # range
+        def horizontal
+          return SimpleRange.new(@left, @right)
+        end
+
+        # Returns a SimpleRange object corresponding to the vertical
+        # range
+        def vertical
+          return SimpleRange.new(@bottom, @top)
+        end
+
 
         # Converts to an [xmin, xmax, ymin, ymax] array
         def extrema
@@ -161,6 +274,12 @@ module CTioga2
           return retval
         end
 
+        # Creates a Boundaries object from two SimpleRange objects.
+        def self.from_ranges(horiz, vert)
+          return Boundaries.new(horiz.first, horiz.last,
+                                vert.last, vert.first)
+        end
+
       end
       
     end

data/lib/ctioga2/graphics/types/dimensions.rb

@@ -16,7 +16,7 @@ require 'ctioga2/log'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 92 $', '$Date: 2009-06-24 01:17:46 +0200 (Wed, 24 Jun 2009) $')
+  Version::register_svn_info('$Revision: 198 $', '$Date: 2010-11-30 00:48:23 +0100 (Tue, 30 Nov 2010) $')
 
   module Graphics
 
@@ -85,6 +85,13 @@ module CTioga2
                         to_figure(t, orientation))
         end
 
+        # Express the Dimension in units of text height (dy)
+        def to_text_height(t, orientation = nil)
+          orientation ||= @orientation
+          return self.to_figure(t, orientation)/
+            t.send("default_text_height_d#{orientation}")
+        end
+
         # Replace this Dimension by _dimension_ if the latter is
         # bigger. Conserves the current orientation.
         def replace_if_bigger(t, dimension)

data/lib/ctioga2/graphics/types/grid.rb

@@ -0,0 +1,196 @@
+# grib.rb: setup and use of a "graph grid"
+# copyright (c) 2009,2010 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/log'
+
+require 'ctioga2/graphics/types/dimensions'
+require 'ctioga2/graphics/types/boxes'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 147 $', '$Date: 2010-04-06 21:13:28 +0200 (Tue, 06 Apr 2010) $')
+
+  module Graphics
+
+    module Types
+
+      # The position of a single element in a GridLayout
+      #
+      # \todo add the possibility to override one element of the
+      # final positions.
+      class GridBox < Box
+
+        OptionHashRE = /([\w-]+)\s*=\s*([^,]+),?\s*/
+
+        GridBoxRE = /^\s*grid:(\d+)\s*,\s*(\d+)(?:,(#{OptionHashRE}+))?\s*$/
+
+        # This hash helps to convert from a hash-based representation
+        # of frame coordinates to the array-based one.
+        #
+        # \todo I should either use existing code or refactor into
+        # something globally useful.
+        FrameCoordsOverride = { 'xl' => 0,
+          'yt' => 1,
+          'xr' => 2,
+          'yb' => 3
+        }
+
+        def self.from_text(txt)
+          if txt =~ GridBoxRE
+            return GridBox.new(GridLayout.current_grid, $1.to_i, $2.to_i, 
+                               $3) # The latter being to remove
+                                          # the initial comma
+          else
+            raise "#{txt} is not a grid box."
+          end
+        end
+        
+        def initialize(grid, x, y, options = {})
+          if options.is_a? String
+            str = options
+            options = {}
+            str.split(/\s*,\s*/).map { |s|
+              s =~ OptionHashRE
+              options[$1] = 
+              BaseCoordinate.from_text($2,if FrameCoordsOverride[$1] % 2 == 0
+                                            :x
+                                          else
+                                            :y
+                                          end, :frame)
+            }
+          end
+          @x = x.to_i
+          @grid = grid
+          @y = y.to_i
+          @overrides = options || {}
+        end
+
+        def to_frame_coordinates(t)
+          a = @grid.frame_coordinates(t, @x, @y)
+          ## \todo write a framework for manipulating this !
+          for k,v in @overrides
+            next unless FrameCoordsOverride.key?(k)
+            a[FrameCoordsOverride[k]] = v.to_frame(t)
+          end
+          return a
+        end
+      end
+
+      # This class provides a grid-like layout through the use of a grid
+      # setup command and a grid box specification.
+      class GridLayout
+
+        # The margins (left, right, top, bottom) around the whole grid
+        attr_accessor :outer_margins
+
+        # The X offset to go from the right-hand side of one element to
+        # the left-hand-side of the next
+        attr_accessor :delta_x
+
+        # The Y offset to go from the bottom of one element to
+        # the top of the next.
+        attr_accessor :delta_y
+
+        # The nup: an array nb horizontal, nb vertical
+        attr_accessor :nup
+
+        # Horizontal scales
+        attr_accessor :hscales
+
+        # Vertical scales
+        attr_accessor :vscales
+
+        def initialize(nup = "2x2")
+          if nup.respond_to?(:split)
+            if nup =~ /,/
+              @hscales, @vscales = nup.split(/\s*x\s*/).map { |x| 
+                x.split(/\s*,\s*/).map { |y| y.to_f }
+              }
+              @nup = [@hscales.size, @vscales.size]
+            else
+              @nup = nup.split(/\s*x\s*/).map { |s| s.to_i }
+            end
+          else
+            @nup = nup.dup
+          end
+
+          # Initialize with the given
+          @outer_margins = {
+            'left' =>  Dimension.new(:dy, 2.5, :x),
+            'right' => Dimension.new(:bp, 6, :x),
+            'bottom' =>  Dimension.new(:dy, 2.5, :y),
+            'top' => Dimension.new(:dy, 2.5, :y)
+          }
+          @delta_x = Dimension.new(:dy, 2.5, :x)
+          @delta_y = Dimension.new(:dy, 2.5, :y)
+
+          @hscales ||= [1] * @nup[0]
+          @vscales ||= [1] * @nup[1]
+        end
+
+        # The grid currently in use.
+        @current_grid = nil
+        
+        def self.current_grid=(grid)
+          @current_grid = grid
+        end
+
+        def self.current_grid
+          return @current_grid
+        end
+
+        # Compute the frame coordinates fo the x,y element of the
+        # grid. They are numbered from the top,left element.
+        def frame_coordinates(t, x, y)
+          compute_lengths(t)
+          xo = if x > 0
+                 @hscales[0..(x-1)].inject(0,:+) * @wbase
+               else
+                 0
+               end
+          xl = @outer_margins['left'].to_frame(t, :x) + xo + 
+            x * @delta_x.to_frame(t, :x)
+          yo = if y > 0
+                 @vscales[0..(y-1)].inject(0,:+) * @hbase
+               else
+                 0
+               end
+          yt = 1 - (@outer_margins['top'].to_frame(t, :y) + yo +
+                    y * @delta_y.to_frame(t, :y))
+          return [xl, yt, 
+                  xl + @wbase * @hscales[x], 
+                  yt - @hbase * @vscales[y]]
+        end
+
+        protected 
+
+        # Compute the necessary variables in frame coordinates
+        def compute_lengths(t)
+          return if (@wbase && @hbase)
+          @wbase = (1 - 
+            (@outer_margins['left'].to_frame(t, :x) + 
+             @outer_margins['right'].to_frame(t, :x) + 
+             @delta_x.to_frame(t, :x) * (@nup[0]-1)))/@hscales.inject(0,:+)
+          @hbase = (1 - 
+            (@outer_margins['top'].to_frame(t, :y) + 
+             @outer_margins['bottom'].to_frame(t, :y) + 
+             @delta_y.to_frame(t, :y) * (@nup[1]-1)))/@vscales.inject(0,:+)
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/ctioga2/graphics/types/location.rb

@@ -0,0 +1,228 @@
+# location.rb: handling the concept of "location" (for an axis especially)
+# copyright (c) 2009 by Vincent Fourmond
+  
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+  
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details (in the COPYING file).
+
+require 'ctioga2/utils'
+require 'ctioga2/log'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 223 $', '$Date: 2011-01-11 01:07:48 +0100 (Tue, 11 Jan 2011) $')
+
+  module Graphics
+
+    module Types
+
+
+      # Location of an object (especially axes) in a plot, in terms of
+      # the side of the plot or the X and Y axis.
+      class PlotLocation
+
+        # Conversion between the #base_location attribute and the real
+        # constant used for Tioga
+        LocationToTiogaLocation = {
+          :left => Tioga::FigureConstants::LEFT,
+          :right => Tioga::FigureConstants::RIGHT,
+          :bottom => Tioga::FigureConstants::BOTTOM,
+          :top => Tioga::FigureConstants::TOP,
+          :at_x_origin => Tioga::FigureConstants::AT_X_ORIGIN,
+          :at_y_origin => Tioga::FigureConstants::AT_Y_ORIGIN
+        }
+
+        # Horizontal or vertical
+        LocationVertical = {
+          :left => true,
+          :right => true,
+          :bottom => false,
+          :top => false,
+          :at_x_origin => true,
+          :at_y_origin => false
+        }
+
+        # A few helper hashes to convert from sides to margins
+        # @todo won't work for origins.
+        LocationBaseMargins = {
+          :left => [0,1,0,0],
+          :right => [1,0,0,0],
+          :bottom => [0,0,1,0],
+          :top => [0,0,0,1]
+        }
+
+        # Multiply this by the frame dimension in the correct
+        # direction to get the frame margins.
+        LocationMarginMultiplier = {
+          :left => [-1,0,0,0],
+          :right => [0,-1,0,0],
+          :bottom => [0,0,0,-1],
+          :top => [0,0,-1,0]
+        }
+
+        LocationsReorientMargins = {
+          :left => [1,0,3,2],
+          :right => [0,1,2,3],
+          :top => [2,3,1,0],
+          :bottom => [3,2,0,1]
+        }
+
+        # The position of the object, one of :left, :right, :top,
+        # :bottom, :at_y_origin or :at_x_origin.
+        #
+        # @todo This will have to be extended to allow possibly
+        # arbitrary frame/figure placement.
+        attr_accessor :base_location
+
+        # The shift away from the position given by #base_location.
+        #
+        # This will be a Dimension object.
+        #
+        # @todo This is not currently implemented
+        attr_accessor :shift
+        
+
+        # Creates a new PlotLocation object, either copying the one
+        # given as argument or from scratch specifying at least the
+        # base location.
+        def initialize(location, shift = nil)
+          if location.respond_to? :shift
+            @base_location = location.base_location
+            @shift = shift || location.shift
+          else
+            @base_location = location
+            @shift = shift
+          end
+        end
+
+        # Returns the tioga location (ie that suitable for sending to
+        # show_axis for instance)
+        def tioga_location
+          return LocationToTiogaLocation[@base_location]
+        end
+
+        # Whether the given location is vertical or horizontal
+        def vertical?
+          return LocationVertical[@base_location]
+        end
+
+        # Returns the orientation away from the graph
+        def orientation
+          if vertical?
+            return :x
+          else
+            return :y
+          end
+        end
+
+        # Extra extension that should be reserved for a label on the
+        # given side based on simple heuristics. Value is returned in
+        # text height units.
+        def label_extra_space(t)
+          case @base_location
+          when :bottom, :right
+            extra = 0.5       # To account for baseline ?
+          when :top, :left
+            extra = 1
+          else                # We take the safe side !
+            extra = 1
+          end
+          if @shift
+            ## @todo Here add the shift
+          end
+          return extra
+        end
+
+        # Returns whether the location is on the given side.
+        def is_side?(which)
+          return @base_location == which
+        end
+
+        # Takes a set of margins, expressed in relative terms, ie
+        # * _close_ (the margins on the side next to the graph),
+        # * _away_ (on the other side),
+        # * _aleft_ (on the left going away from the graph) and
+        # * _aright_ (on the right going away from the graph)
+        # into a left,right,top,bottom suitable for standards margins calls.
+        def reorient_margins(close, away, aleft, aright)
+          a = [close, away, aleft, aright]
+          return LocationsReorientMargins[@base_location].map do |i|
+            a[i]
+          end
+        end
+
+        # Returns the margins argument suitable for sending to
+        # set_subframe to paint within the region defined by the given
+        # size at the given position.
+        # 
+        # _size_ is a Dimension object.
+        def frame_margins_for_size(t, size)
+          margins = Dobjects::Dvector[*LocationBaseMargins[@base_location]]
+          ## @todo handle the case of at Y and at X
+          dim = size.to_frame(t, orientation)
+
+          add = Dobjects::Dvector[*LocationMarginMultiplier[@base_location]]
+          add.mul!(dim)
+          margins += add
+          return margins
+        end
+
+        def do_sub_frame(t, size) 
+          margins = frame_margins_for_size(t, size)
+
+          ## @todo This is should integrate some common class.
+          left = t.convert_frame_to_page_x(margins[0])
+          right = t.convert_frame_to_page_x(1 - margins[1])
+          top = t.convert_frame_to_page_y(1 - margins[2])
+          bottom = t.convert_frame_to_page_y(margins[3])
+
+          # Ensure that we don't have coords outside of the page range
+          # because of rounding problems:
+          left = 0.0 if left < 0
+          bottom = 0.0 if bottom < 0
+          right = 1.0 if right > 1
+          top = 1.0 if top > 1
+
+          t.context do 
+            t.set_frame_sides(left, right, top, bottom)
+            yield
+          end
+        end
+
+        # Creates a location from the given text
+        #
+        # So far, no real parsing
+        def self.from_text(str)
+          str.gsub!(/-/,"_")
+          return PlotLocation.new(str.to_sym)
+        end
+
+        
+      end
+
+      # Something meant to be fed to PlotStyle#get_axis_style
+      LocationType = CmdType.new('location', { :type => :function_based,
+                                 :class => Graphics::Types::PlotLocation
+                                 }, <<EOD)
+A position on the plot, referenced with respect to the sides. Can be:
+ * @left@
+ * @right@
+ * @top@
+ * @bottom@
+
+In addition, there will one day be the possibility to specify an 
+offset from these locations. But that is still something to do.
+EOD
+
+
+      
+    end
+  end
+end
+