ctioga2 0.0 → 0.1

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

@@ -16,7 +16,7 @@ require 'ctioga2/log'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 95 $', '$Date: 2009-06-25 23:52:42 +0200 (Thu, 25 Jun 2009) $')
+  Version::register_svn_info('$Revision: 196 $', '$Date: 2010-11-25 20:15:32 +0100 (Thu, 25 Nov 2010) $')
 
   module Graphics
 
@@ -28,29 +28,22 @@ module CTioga2
       # * a way to set/get its figure boundaries.
       class Subplot < Container
 
-        # A Boundaries object representing the boundaries imposed by
-        # the user.
-        attr_accessor :user_boundaries
-
-        # A Boundaries object representing the boundaries in
-        # effect. Only filled with meaningful values from within the
-        # real_do function.
-        attr_accessor :real_boundaries
-
         # Various stylistic aspects of the plot, as a
         # Styles::PlotStyle object.
         attr_accessor :style
 
-        # Whether or not the parent object should take the boundaries
-        # into account or not for its own internal boundaries.
-        attr_accessor :count_boundaries
-        
+        # User-specified boundaries. It is a hash axis -> SimpleRange,
+        # where the axis is a valid return value of PlotStyle#get_axis_key
+        attr_accessor :user_boundaries
+
+        # Computed boundaries. It also is a hash axis -> SimpleRange,
+        # just as #user_boundaries. Its value is not defined as long
+        # as #real_do hasn't been entered into.
+        attr_accessor :computed_boundaries
+
         def initialize(parent, root, style)
           super(parent, root)
 
-          @user_boundaries = Types::Boundaries.new(nil, nil, nil, nil)
-          @real_boundaries = nil
-
           @subframe = Types::MarginsBox.new("2.8dy", "2.8dy", 
                                             "2.8dy", "2.8dy")
 
@@ -58,30 +51,83 @@ module CTioga2
 
           @style = style || Styles::PlotStyle.new
 
-          # By default, boundaries do not count for the parent
-          @count_boundaries = false
+          @user_boundaries = {}
+        end
+
+        # Returns the boundaries that apply for the given _curve_ --
+        # it reads the curve's axes. #compute_boundaries must have
+        # been called beforehand, which means that it will only work
+        # from within #real_do.
+        #
+        # \todo This should not only apply to curves, but to any
+        # object. That also means that there should be a way to
+        # specify axes for them too.
+        def get_el_boundaries(el)
+          return get_given_boundaries(* el.location.get_axis_keys(style))
         end
 
-        # Returns the boundaries of the SubPlot.
+        # Returns the boundaries of the *default* axes. Plotting
+        # functions may safely assume that they are drawn using these
+        # boundaries, unless they asked for being drawn onto different
+        # axes.
         def get_boundaries
+          return get_given_boundaries(style.xaxis_location, 
+                                      style.yaxis_location)       
+        end 
+
+        # Sets the user boundaries for the given (named) axis:
+        def set_user_boundaries(axis, bounds)
+          key = @style.get_axis_key(axis)
+          @user_boundaries[key] = Types::SimpleRange.new(bounds)
+        end
+
+        def actual_subframe(t)
+          return @subframe || @style.estimate_margins(t)
+        end
+
+        # In general, subplot's boundaries do not count for the parent
+        # plot.
+        def count_boundaries?
+          return false
+        end
+
+        protected
+
+        # Makes up a Boundaries object from two axes keys
+        def get_given_boundaries(horiz, vert)
+          if @computed_boundaries
+            return Types::Boundaries.from_ranges(@computed_boundaries[horiz],
+                                                 @computed_boundaries[vert])
+          else
+            return nil
+          end
+        end
+
+        def compute_boundaries
           # raw boundaries
           bounds = get_elements_boundaries
           if @style.plot_margin
-            bounds.apply_margin!(@style.plot_margin)
+            for k,b in bounds
+              b.apply_margin!(@style.plot_margin)
+            end
+          end
+          for k,b in @user_boundaries
+            bounds[k] ||= Types::SimpleRange.new(nil,nil)
+            bounds[k].override(b)
           end
-          bounds.override_boundaries(@user_boundaries)
           return bounds
         end
 
-        protected
+
 
         # Plots all the objects inside the plot.
         def real_do(t)
           # First thing, we setup the boundaries
+          @computed_boundaries = compute_boundaries
 
-          @real_boundaries = get_boundaries
+          real_boundaries = get_boundaries
 
-          frames = @subframe || @style.estimate_margins(t)
+          frames = actual_subframe(t)
 
           # We wrap the call within a subplot
           t.subplot(frames.to_frame_margins(t)) do
@@ -90,7 +136,7 @@ module CTioga2
             @style.setup_figure_maker(t)
             
             # Manually creating the plot:
-            t.set_bounds(@real_boundaries.to_a)
+            t.set_bounds(real_boundaries.to_a)
 
             # Drawing the background elements:
             t.context do
@@ -101,11 +147,14 @@ module CTioga2
               @style.draw_all_background_lines(t)
               i = 0
               for element in @elements 
-                element.do(t)
+                t.context do 
+                  t.set_bounds(get_el_boundaries(element).to_a)
+                  element.do(t)
+                end
                 i += 1
               end
             end
-            @style.draw_all_axes(t)
+            @style.draw_all_axes(t, @computed_boundaries)
 
             # Now drawing legends:
             if @legend_area
@@ -121,17 +170,28 @@ module CTioga2
         
         # Returns the boundaries of all the elements of this plot.
         def get_elements_boundaries
-          elements_bounds = []
+          boundaries = {}
           for el in @elements
             if el.respond_to? :get_boundaries
-              if el.respond_to?(:count_boundaries) && ! (el.count_boundaries)
+              if el.respond_to?(:count_boundaries?) && ! (el.count_boundaries?)
                 # Ignoring
               else
-                elements_bounds << el.get_boundaries
+                bounds = el.get_boundaries
+                xaxis, yaxis = *el.location.get_axis_keys(style)
+                if bounds.is_a? Hash
+                  ## \todo see if there will ever be a need for a hash
+                  ## ?
+                  raise "Not done yet"
+                else
+                  boundaries[xaxis] ||= Types::SimpleRange.new(nil,nil)
+                  boundaries[xaxis].extend(bounds.horizontal)
+                  boundaries[yaxis] ||= Types::SimpleRange.new(nil,nil)
+                  boundaries[yaxis].extend(bounds.vertical)
+                end
               end
             end
           end
-          return Types::Boundaries.overall_bounds(elements_bounds)
+          return boundaries
         end
 
       end

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

@@ -0,0 +1,99 @@
+# tangent.rb: code for drawing tangents
+# 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: 171 $', '$Date: 2010-10-22 17:07:52 +0200 (Fri, 22 Oct 2010) $')
+
+  module Graphics
+
+    module Elements
+
+      module Tangents
+
+        TangentOptions = {
+          'xfrom'   => 'float',
+          'xto'     => 'float',
+          'yfrom'   => 'float',
+          'yto'     => 'float',
+          'xextent' => 'float',
+          'yextent' => 'float',
+          'nbavg'  =>  'integer'
+        }.update(TiogaPrimitiveCall::ArrowOptions)
+      
+        TiogaPrimitiveCall.
+          primitive("tangent", "tangent", [ 'data-point'],
+                    TangentOptions) do |t, point,options|
+          options ||= {}
+          nb = options['nbavg'] || 7
+          x = point.x_val(nb)
+          y = point.y_val(nb)
+          slope = point.slope(nb)
+
+          # Now, we parse the head/tail spec.
+          if d = options['xextent']
+            options['tail'] = [x, y]
+            options['head'] = [x+d, y + d*slope]
+          elsif d = options['yextent']
+            options['tail'] = [x, y]
+            options['head'] = [x+d/slope, y + d]
+          elsif options['xfrom'] || options['yfrom'] || 
+              options['xto'] || options['yto']
+            if xf = options['xfrom']
+              options['tail'] = [xf, y - (x - xf)*slope]
+            elsif yf = options['yfrom']
+              options['tail'] = [x - (y-yf)/slope, yf]
+            else
+              options['tail'] = [x,y]
+            end
+
+            if xt = options['xto']
+              options['head'] = [xt, y - (x - xt)*slope]
+            elsif yt = options['yto']
+              options['head'] = [x - (y-yt)/slope, yt]
+            else
+              options['head'] = [x,y]
+            end
+          else
+            # We don't bother too much about the head/tail
+            options['head'] = [x, y]
+            dx = point.dx(nb) * 10
+            options['tail'] = [x-dx, y - dx*slope]
+            options['line_width'] = 0
+            options['tail_marker'] = "None"
+          end
+
+          # We look for any color argument:
+          if ! (options['color'] || options['tail_color'] || 
+                options['head_color'])
+            options['color'] = $last_curve_style.line.color
+          end
+          
+          # Now, we delete elements from the hash that don't have
+          # anything to do there:
+          for k in TangentOptions.keys - 
+              TiogaPrimitiveCall::ArrowOptions.keys
+            options.delete k
+          end
+          
+          t.show_arrow(options)
+        end
+      end
+      
+    end
+  end
+end

data/lib/ctioga2/graphics/elements/xyz-map.rb

@@ -0,0 +1,126 @@
+# parametric2d.rb: a 2D curve whose parameters depend on Z values
+# 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
+# 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 'Dobjects/Function'
+
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 198 $', '$Date: 2010-11-30 00:48:23 +0100 (Tue, 30 Nov 2010) $')
+
+  module Graphics
+
+    module Elements
+
+      # This class represents a XY map of Z values, ie something that
+      # is represented using an image
+      #
+      # @todo There should be a way to automatically display level
+      # lines, and possibly only that.
+      class XYZMap  < TiogaElement
+
+        include Log
+        include Dobjects
+
+        # The Data::Dataset object that should get plotted.
+        attr_accessor :dataset
+
+        # A Styles::CurveStyle object saying how the curve should be
+        # drawn.
+        #
+        # Some of the elements will be overridden.
+        attr_accessor :curve_style
+
+        # The IndexedTable object representing the underlying data
+        attr_accessor :table
+
+
+        undef :location=, :location
+        
+        # Creates a new XYZMap object with the given _dataset_ and
+        # _style_.
+        def initialize(dataset, style = nil)
+          @dataset = dataset
+          @curve_style = style
+          prepare_data
+        end
+
+        # Prepares the internal storage of the data, from the @dataset
+        def prepare_data
+          @table = @dataset.indexed_table
+        end
+        
+        protected :prepare_data
+
+        # 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.
+        def get_boundaries
+          return @table.xy_boundaries
+        end
+        
+
+        ## Actually draws the curve
+        def real_do(t)
+          debug { "Plotting curve #{inspect}" }
+          t.context do
+            # Of course, there are still quite a few things to do
+            # ;-)...
+
+            # Ideas: for leaving things out, I may have to use min_gt
+            # along with masking.
+
+            ## @todo handle non-homogeneous XY maps.
+
+            @curve_style.color_map ||= 
+              Styles::ColorMap.from_text("Red--Green")
+            
+            dict = @curve_style.color_map.
+              prepare_data_display(t,@table.table,
+                                   @table.table.min,
+                                   @table.table.max)
+            if @curve_style.zaxis
+              begin
+                @parent.style.get_axis_style(@curve_style.zaxis).
+                  set_color_map(@curve_style.color_map, 
+                                @table.table.min,
+                                @table.table.max)
+              rescue
+                error { "Could not set Z info to non-existent axis #{@curve_style.zaxis}" }
+              end
+            end
+
+            dict.update(@table.corner_positions)
+            dict.update('width' => @table.width,
+                        'height' => @table.height)
+            dict.update('interpolate' => false)
+            if (! @curve_style.fill.transparency) || 
+                (@curve_style.fill.transparency < 0.99) 
+              t.show_image(dict)
+            else
+              info { 'Not showing map as transparency is over 0.99' }
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/ctioga2/graphics/generator.rb

@@ -18,7 +18,7 @@ require 'ctioga2/graphics/coordinates'
 
 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: 244 $', '$Date: 2011-01-23 23:36:02 +0100 (Sun, 23 Jan 2011) $')
 
   module Graphics
 
@@ -36,33 +36,118 @@ module CTioga2
       # object.
       attr_accessor :legend_provider
 
+      # The current kind of generated. It is a symbol
+      attr_accessor :current_curves
+
       # Creates a CurveGenerator object.
       def initialize
         @legend_provider = Legends::LegendProvider.new
         @style_factory = Styles::CurveStyleFactory.new
+        @current_curves = :xy_plot
       end
 
       # Creates a Elements::TiogaElement representing the _dataset_
       # and returns it.
       #
-      # TODO:
-      # * coordinate transformations
+      # \todo
+      # * (other kinds of) coordinate transformations
       # * other kinds of curves (pseudo-3D, surfaces, histograms...)
       def curve_from_dataset(plot, dataset, options = {})
+        # Does coordinate transforms first ?
+        # \todo copy datasets here rather than overwriting them !
+        plot.style.transforms.transform_2d!(dataset)
+
+        return send(@current_curves, plot, dataset, options)
+      end
+
+      private
+      
+      ## \name Available kinds of curves
+      # 
+      # @{
+      # 
+      # The "classical" 2D plots.
+      def xy_plot(plot, dataset, options = {})
         legend = @legend_provider.dataset_legend(dataset)
         style = @style_factory.next(options)
         style.legend ||= legend # The legend specified as option to
                                 # the --plot command has precedence
                                 # over the one specified by --legend.
-
-        # TODO: copy datasets here !
-        plot.style.transforms.transform_2d!(dataset)
         curve = Graphics::Elements::Curve2D.new(dataset, style)
         return curve
       end
+
+      # XYZ plots formerly known as "parametric plots"
+      def xy_parametric(plot, dataset, options = {})
+        legend = @legend_provider.dataset_legend(dataset)
+        style = @style_factory.next(options)
+        style.legend = false
+        style.legend ||= legend # The legend specified as option to
+                                # the --plot command has precedence
+                                # over the one specified by --legend.
+        curve = Graphics::Elements::Parametric2D.new(dataset, style)
+        return curve
+      end
+
+      # XYZ maps
+      def xyz_map(plot, dataset, options = {})
+        legend = @legend_provider.dataset_legend(dataset)
+        style = @style_factory.next(options)
+        style.legend = false
+        style.legend ||= legend # The legend specified as option to
+                                # the --plot command has precedence
+                                # over the one specified by --legend.
+        curve = Graphics::Elements::XYZMap.new(dataset, style)
+        return curve
+      end
+
+
+      ## @}
       
     end
 
+
+    # The group for chosing plot types.
+    PlotTypesGroup =  
+      CmdGroup.new('plot-types',
+                   "Switch between different kinds of plots",
+                   "How to switch between different kinds of plot types", 01)
+    
+
+    XYParametricPlotCommand = 
+      Cmd.new("xy-parametric",nil,"--xy-parametric") do |plotmaker|
+      plotmaker.curve_generator.current_curves = :xy_parametric
+    end
+    
+    XYParametricPlotCommand.describe('select XY parametric plots', 
+                                     <<EOH, PlotTypesGroup)
+Switch to XY parametric plots, that is standard XY plots whose appearance
+(such as color, marker color, and, potentially, marker kinds and more)
+are governed by one (or more ?) Z values.
+EOH
+
+    XYPlotCommand = 
+      Cmd.new("xy-plot",nil,"--xy-plot") do |plotmaker|
+      plotmaker.curve_generator.current_curves = :xy_plot
+    end
+    
+    XYPlotCommand.describe('select XY plots', 
+                           <<EOH, PlotTypesGroup)
+Switch (back) to standard XY plots (ctioga\'s default)
+EOH
+
+    XYZMapCommand = 
+      Cmd.new("xyz-map",nil,"--xyz-map") do |plotmaker|
+      plotmaker.curve_generator.current_curves = :xyz_map
+    end
+    
+    XYZMapCommand.describe('select XYZ maps', 
+                            <<EOH, PlotTypesGroup)
+Switch to XYZ maps, ie plots where the color at a XY location is given by 
+its Z value.
+EOH
+
+
   end
 end