ctioga2 0.0 → 0.1

data/lib/ctioga2/graphics/coordinates.rb

@@ -17,19 +17,36 @@ 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: 177 $', '$Date: 2010-10-25 13:22:39 +0200 (Mon, 25 Oct 2010) $')
 
   module Graphics
 
     # Deals with transforming the coordinates of all datasets
     #
-    # TODO:
+    # \todo
     # * offsets
     # * scales
     # * x/y log
     # * non-linear transformations ?
     # * the possibility to provide locations using this.
     # * conversion of datasets.
+    #
+    # \todo Shouldn't this facility be axis-local ? Non-linear
+    # transformations definitely belong there as well (and that would
+    # be almost trivial to write !).
+    #
+    # @todo For now, this is a mess: these things completely mess up
+    # the data processing... This is a complex problem:
+    # 
+    # * if the Dataset are modified in place, this is a nightmare for
+    #   data processing
+    #   
+    # * on the other hand, if they are not modified in place, this
+    #   means that things that work on data sets and show things on
+    #   the plot (think TangentPrimitive, for instance) will have to
+    #   do additional things to get the target coordinates. This is
+    #   probably the best way to go, though... This would need some
+    #   functions to work directly on XY coordinates.
     class CoordinateTransforms
 
       # A scaling factor for coordinates:

data/lib/ctioga2/graphics/elements.rb

@@ -16,12 +16,19 @@ require 'ctioga2/graphics/types'
 require 'ctioga2/graphics/elements/element'
 require 'ctioga2/graphics/elements/containers'
 require 'ctioga2/graphics/elements/subplot'
+require 'ctioga2/graphics/elements/region'
+require 'ctioga2/graphics/elements/gradient-region'
 require 'ctioga2/graphics/elements/curve2d'
+require 'ctioga2/graphics/elements/parametric2d'
+require 'ctioga2/graphics/elements/xyz-map'
 require 'ctioga2/graphics/elements/primitive'
 
+require 'ctioga2/graphics/elements/tangent'
+require 'ctioga2/graphics/elements/contour'
+
 module CTioga2
 
-  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+  Version::register_svn_info('$Revision: 187 $', '$Date: 2010-11-07 11:02:25 +0100 (Sun, 07 Nov 2010) $')
 
   module Graphics
 
@@ -44,13 +51,16 @@ EOH
 
 
     # Various coordinate-related commands:
+    # 
+    # @todo All these commands should be axis-dependent, and not
+    # plot-dependent.
     CoordinateRelatedCommands = []
     [:x, :y].each do |x|
       cmd = 
         Cmd.new("#{x}range",nil,"--#{x}range", 
                 [ CmdArg.new('partial-float-range') ]) do |plotmaker, range|
         plotmaker.root_object.current_plot.
-          user_boundaries.set_from_range(range, x)
+          set_user_boundaries(x.to_s,range)
       end
       cmd.describe("Sets the #{x.to_s.upcase} range",
                            <<EOH, PlotCoordinatesGroup)

data/lib/ctioga2/graphics/elements/containers.rb

@@ -17,7 +17,7 @@ require 'ctioga2/log'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 38 $', '$Date: 2009-05-07 23:11:55 +0200 (Thu, 07 May 2009) $')
+  Version::register_svn_info('$Revision: 155 $', '$Date: 2010-06-21 21:41:32 +0200 (Mon, 21 Jun 2010) $')
 
   module Graphics
 
@@ -70,6 +70,13 @@ module CTioga2
           return @elements.size
         end
 
+        # Sometimes, the value of the subframe is _nil_ and determined
+        # during the plot. This function is guaranteed to return the
+        # correct value. It takes a reference to a FigureMaker object.
+        def actual_subframe(t)
+          return @subframe
+        end
+
         # Adds an element
         def add_element(element)
           element.parent = self
@@ -83,6 +90,11 @@ module CTioga2
           elsif element.is_a? Container
             add_legend_item(element)
           end
+
+          # We call LocationStyle#finalize! if possible
+          if(self.respond_to?(:style) and element.respond_to?(:location))
+            element.location.finalize!(self.style)
+          end
         end
 
 
@@ -91,7 +103,7 @@ module CTioga2
           @legend_storage.add_item(item)
         end
 
-        # TODO: provide coordinate conversion facilities...
+        # \todo provide coordinate conversion facilities...
 
         protected 
 

data/lib/ctioga2/graphics/elements/contour.rb

@@ -0,0 +1,67 @@
+# contour.rb: contouring code for XYZ data
+# 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/graphics/elements/primitive'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 192 $', '$Date: 2010-11-07 18:07:01 +0100 (Sun, 07 Nov 2010) $')
+
+  module Graphics
+
+    module Elements
+
+      module Contours
+
+        ContoursOptions = {
+          'width' => 'float',
+          'color' => 'color',
+          'style' => 'line-style',
+          'closed' => 'boolean',
+        }
+
+        ## @todo Maybe this cumbersome level/point thing along with the
+        # $last_curve_style calls for a context for the primitive, ie
+        # which was the state of the dataset/curve stack at the moment
+        # when the primitive was drawn ?
+        TiogaPrimitiveCall.
+          primitive("contour", "contour", [ 'level'],
+                    ContoursOptions) do |t, level,options|
+          options ||= {}
+          # table = PlotMaker.plotmaker.data_stack.last.indexed_table
+          l, d = *level
+          table = d.indexed_table
+          contour = table.make_contour(l)
+          contour << options['closed']
+
+          ## @todo This $last_curve_style isn't beautiful.
+          ##
+          ## Worse, it won't work !
+          options['color'] ||= $last_curve_style.line.color
+
+          stroke_style = Styles::StrokeStyle.from_hash(options, '%s')
+          
+
+          t.context do 
+            stroke_style.set_stroke_style(t)
+            t.append_points_with_gaps_to_path(*contour)
+            t.stroke
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ctioga2/graphics/elements/curve2d.rb

@@ -1,5 +1,5 @@
 # curve2d.rb: a 2D curve
-# copyright (c) 2006, 2007, 2008, 2009 by Vincent Fourmond
+# copyright (c) 2006, 2007, 2008, 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
@@ -19,14 +19,20 @@ require 'Dobjects/Function'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+  Version::register_svn_info('$Revision: 184 $', '$Date: 2010-11-07 00:44:40 +0100 (Sun, 07 Nov 2010) $')
 
   module Graphics
 
     module Elements
 
-      # A Curve2D object represents a 2D curve, along with its style and so
-      # on.
+      # A Curve2D object represents a 2D curve, along with its style
+      # and so on.
+      #
+      # \todo Put back various stylistic aspects that were present in
+      # the old ctioga, such as:
+      #
+      # * transparency
+      # * drawing order
       class Curve2D  < TiogaElement
 
         include Log
@@ -36,6 +42,9 @@ module CTioga2
         # the sake of manipulations.
         attr_accessor :function
 
+        # Elements of the path, when there are more than one:
+        attr_accessor :path_elements
+
         # The Data::Dataset object that should get plotted.
         attr_accessor :dataset
 
@@ -43,24 +52,36 @@ module CTioga2
         # drawn.
         attr_accessor :curve_style
 
+        undef :location=, :location
+        
         # Creates a new Curve2D object with the given _dataset_ and
         # _style_.
         def initialize(dataset, style = nil)
           @dataset = dataset
           if @dataset.size > 2
-            warn "Columns Y2 and further were ignored for set #{dataset.name}"
+            warn { "Columns Y2 and further were ignored for set #{dataset.name}" }
           end
           # We build the function on a duplicate of the values ?
           @function = Function.new(@dataset.x.values.dup, 
                                    @dataset.y.values.dup)
+          @curve_style = style
 
-          # We remove NaN, as they are not very liked by Tioga...
-          #
-          # TODO: maybe there should be a way to *split* on NaN rather
-          # than to ignore them ?
+          # Preparation of the subpath elements
+          if @curve_style.split_on_nan
+            # This requires Tioga r601 !
+            @path_elements = @function.split_on_nan(:xy)
+            info { "Dividing into #{@path_elements.size} subpaths" }
+          else
+            @path_elements = [@function]
+          end
           @function.strip_nan
 
-          @curve_style = style
+        end
+
+        # Returns the LocationStyle object of the curve. Returns the
+        # one from #curve_style.
+        def location
+          return @curve_style.location
         end
 
         # Returns the Types::Boundaries of this curve.
@@ -74,16 +95,34 @@ module CTioga2
         # the current path, not attempt to create a new path or empty
         # what was done before.
         def make_path(t)
-          bnds = parent.real_boundaries
-          #           if @style.interpolate
-          #             for f in @function.split_monotonic
-          #               new_f = f.bound_values(*bnds.to_a)
-          #               t.append_interpolant_to_path(f.make_interpolant)
-          #             end
-          #           else
-          f = @function.bound_values(*bnds.extrema)
-          t.append_points_to_path(f.x, f.y)
-          #          end
+          bnds = parent.get_el_boundaries(self)
+
+          for func in @path_elements
+            case @curve_style.path_style
+            when /splines/
+              for f in func.split_monotonic
+                new_f = f.bound_values(*bnds.extrema)
+                t.append_interpolant_to_path(new_f.make_interpolant)
+              end
+            else
+              f = func.bound_values(*bnds.extrema)
+              t.move_to_point(f.x.first, f.y.first)
+              t.append_points_to_path(f.x[1..-1], f.y[1..-1])
+            end
+          end
+          
+        end
+
+        
+        # Adds a closed path to the given FigureMaker object. The path
+        # is closed according to the specification given as _fv_,
+        # which is the same as the _y0_ attribute of a CurveFillStyle.
+        #
+        # It must not be _false_
+        def make_closed_path(t, fv)
+          y0 = fill_value_to_y(fv)
+          make_path(t)
+          close_path(t, y0)
         end
 
         # Strokes the path.
@@ -114,39 +153,61 @@ module CTioga2
           t.close_path
         end
 
+        # Returns the AxisSyle objects for the X and Y axes as an array.
+        def get_axes
+          return [ 
+                  parent.style.get_axis_style(@curve_style.xaxis),
+                  parent.style.get_axis_style(@curve_style.yaxis)
+                 ]
+        end
+
         # Draws the filled region according to the :fill_type element
         # of the style pseudo-hash. It can be:
         def draw_fill(t)
-          #           y = y_value(@style.fill_type)
-          #           return unless y
-
-          #           t.fill_transparency = @style.fill_transparency || 0
-          #           # Now is the tricky part. To do the actual fill, we first make a
-          #           # path according to the make_path function.
-          #           make_path(t)
-
-          #           # Then we add two line segments that go from the end to the
-          #           # beginning.
-          #           close_path(t, y)
-
-          #           # Now the path is ready. Just strike -- or, rather, fill !
-          #           t.fill_color = @style.fill_color
-          #           t.fill
+          return unless @curve_style.fill.y0
+          t.context do
+            # Remember: first setup_fill, then draw path, then do_fill
+            @curve_style.fill.setup_fill(t)
+            make_closed_path(t,@curve_style.fill.y0)
+            @curve_style.fill.do_fill(t)
+          end
         end
 
+        def draw_errorbars(t)
+          return unless @dataset.has_xy_errors?
+          @dataset.each_values(true, true) do |*vals|
+            @curve_style.error_bar.show_error_bar(t, *(vals[1..6]))
+          end
+        end
+        
+        ## Actually draws the curve
         def real_do(t)
-          debug "Plotting curve #{inspect}"
+          debug { "Plotting curve #{inspect}" }
           t.context do
-            # TODO reinstate the choice of the order of drawing ???
+            ## \todo allow customization of the order of drawing,
+            ## using a simple user-specificable array of path,
+            ## markers... and use the corresponding #draw_path or
+            ## #draw_markers... Ideally, any string could be used, and
+            ## warnings should be issued on missing symbols.
+
+            draw_fill(t)
+            draw_errorbars(t)
             draw_path(t)
             draw_markers(t)
-            #             # The fill is always first
-            #             draw_fill(t)
+          end
+        end
+
+        protected 
 
-            #             for op in CurveStyle::DrawingOrder[@style[:drawing_order]]
-            #               self.send("draw_#{op}".to_sym, t)
-            #             end
+        # Converts the value of a fill value into a number (or nil)
+        def fill_value_to_y(fv)
+          return nil unless fv
+          case fv
+          when :bottom,:top
+            bnds = parent.get_el_boundaries(self)
+            return bnds.send(fv)
           end
+          return fv
         end
         
       end

data/lib/ctioga2/graphics/elements/element.rb

@@ -18,7 +18,7 @@ require 'ctioga2/log'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 54 $', '$Date: 2009-05-20 20:21:11 +0200 (Wed, 20 May 2009) $')
+  Version::register_svn_info('$Revision: 151 $', '$Date: 2010-06-19 23:45:20 +0200 (Sat, 19 Jun 2010) $')
 
   # This module contains all graphical elements of CTioga2
   module Graphics
@@ -34,12 +34,22 @@ module CTioga2
         # The parent Container.
         attr_accessor :parent
 
+        # Details pertaining to the location of the object, as a
+        # LocationStyle object
+        attr_writer :location
+
+        # Makes sure there is a location when one asks for it.
+        def location
+          @location ||= Styles::LocationStyle.new
+          return @location
+        end
+
         # This function must be called with a FigureMaker object to
         # draw the contents of the TiogaElement onto it. It calls
         # #real_do, which should be redefined by the children. You can
         # redefine _do_ too if you need another debugging output.
         def do(f)
-          debug "plotting #{self.inspect}"
+          debug { "plotting #{self.inspect}" }
           real_do(f)
         end
 

data/lib/ctioga2/graphics/elements/gradient-region.rb

@@ -0,0 +1,94 @@
+# region.rb: draw curves-delimited fills
+# copyright (c) 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'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 159 $', '$Date: 2010-07-26 17:29:47 +0200 (Mon, 26 Jul 2010) $')
+
+  module Graphics
+
+    module Elements
+
+      # A GradientRegion is an object that makes color gradient for
+      # the curves. Especially useful for a great number of curves,
+      # and when one doesn't want to compute...
+      #
+      # 
+      #
+      # Like Region It is a fake container in the sense that all the
+      # elements are actually forwarded to the parent.
+      class GradientRegion < Container
+
+        undef :elements
+        undef :subframe
+
+        # The curves which delimit the region
+        attr_accessor :curves
+
+        # The start and end colors
+        attr_accessor :start_color, :end_color
+
+        # Creates a new empty region
+        def initialize(parent = nil, root = nil)
+          @parent = parent
+          
+          # The curves whose color we should change
+          @curves = []
+
+          @root_object = root
+
+          @legend_area = nil
+
+          @start_color = Tioga::ColorConstants::Red
+          @end_color = Tioga::ColorConstants::Green
+
+        end
+
+        # Adds an element. Actually forwards it to the parent.
+        def add_element(element)
+          parent.add_element(element)
+          if element.respond_to?(:curve_style)
+            @curves << element
+          end
+        end
+
+        # Sets the various things from hash.
+        def set_from_hash(hash)
+        end
+
+        # Redirects to the parent's style
+        def style(*a)
+          return parent.style(*a)
+        end
+
+        protected 
+
+        # Simply sets the color of the curves.
+        def real_do(t)
+          nb = @curves.size
+          i = 0
+          for c in @curves
+            c.curve_style.line.color = 
+              Utils::mix_objects(@end_color,@start_color, i/(nb - 1.0))
+            i += 1
+          end
+        end
+
+      end
+    end
+  end
+end