ctioga2 0.0

data/lib/ctioga2/graphics/coordinates.rb

@@ -0,0 +1,73 @@
+# coordinates.rb: coordinate transformations
+# 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: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module Graphics
+
+    # Deals with transforming the coordinates of all datasets
+    #
+    # TODO:
+    # * offsets
+    # * scales
+    # * x/y log
+    # * non-linear transformations ?
+    # * the possibility to provide locations using this.
+    # * conversion of datasets.
+    class CoordinateTransforms
+
+      # A scaling factor for coordinates:
+      attr_accessor :x_scale, :y_scale
+
+      # An offset for coordinates
+      attr_accessor :x_offset, :y_offset
+
+      # Whether to use logarithmic coordinates
+      attr_accessor :x_log, :y_log
+
+      # Creates a CoordinateTransformations object.
+      def initialize
+      end
+
+      # Apply a transformation to a Data::Dataset holding 2D signals.
+      # Modifies the dataset in place.
+      def transform_2d!(dataset)
+        for w in [:x , :y]
+          if v = self.send("#{w}_scale") 
+            dataset.send(w).apply do |x|
+              x.mul!(v)
+            end
+          end
+          if v = self.send("#{w}_offset") 
+            dataset.send(w).apply do |x|
+              x.add!(v)
+            end
+          end
+          if v = self.send("#{w}_log") 
+            dataset.send(w).apply do |x|
+              x.safe_log10!
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/lib/ctioga2/graphics/elements.rb

@@ -0,0 +1,111 @@
+# elements.rb: all drawable objects
+# 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/types'
+require 'ctioga2/graphics/elements/element'
+require 'ctioga2/graphics/elements/containers'
+require 'ctioga2/graphics/elements/subplot'
+require 'ctioga2/graphics/elements/curve2d'
+require 'ctioga2/graphics/elements/primitive'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+
+  module Graphics
+
+    # Now, various commands pertaining to various drawables
+
+    PlotCoordinatesGroup = CmdGroup.new('coordinates',
+                                        "Plot coordinates",
+                                        "Plot coordinates", 2)
+    PlotMarginCommand = 
+      Cmd.new("margin",nil,"--margin", 
+              [ CmdArg.new('float') ]) do |plotmaker, margin|
+      plotmaker.root_object.current_plot.style.plot_margin = margin
+    end
+
+    PlotMarginCommand.describe("Leaves a margin around data points",
+                               <<EOH, PlotCoordinatesGroup)
+Leaves a margin around the data points. Expressed in relative size of the
+whole plot.
+EOH
+
+
+    # Various coordinate-related commands:
+    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)
+      end
+      cmd.describe("Sets the #{x.to_s.upcase} range",
+                           <<EOH, PlotCoordinatesGroup)
+Sets the range of the #{x.to_s.upcase} coordinates.
+EOH
+      CoordinateRelatedCommands << cmd
+
+      cmd = 
+        Cmd.new("#{x}offset",nil,"--#{x}offset", 
+                [ CmdArg.new('float') ]) do |plotmaker, val|
+        plotmaker.root_object.current_plot.
+          style.transforms.send("#{x}_offset=", val)
+      end
+      cmd.describe("Offset #{x.to_s.upcase} data",
+                           <<EOH, PlotCoordinatesGroup)
+Adds the given offset to all #{x.to_s.upcase} coordinates.
+EOH
+      CoordinateRelatedCommands << cmd
+
+      cmd = 
+        Cmd.new("#{x}scale",nil,"--#{x}scale", 
+                [ CmdArg.new('float') ]) do |plotmaker, val|
+        plotmaker.root_object.current_plot.
+          style.transforms.send("#{x}_scale=", val)
+      end
+      cmd.describe("Scale #{x.to_s.upcase} data",
+                           <<EOH, PlotCoordinatesGroup)
+Multiplies the #{x.to_s.upcase} coordinates by this factor.
+EOH
+      CoordinateRelatedCommands << cmd
+
+      # Alias
+      cmd = 
+        Cmd.new("#{x}fact",nil,"--#{x}fact", 
+                [ CmdArg.new('float') ]) do |plotmaker, val|
+        plotmaker.root_object.current_plot.
+          style.transforms.send("#{x}_scale=", val)
+      end
+      cmd.describe("Alias for #{x}scale",
+                           <<EOH, PlotCoordinatesGroup)
+Alias for {command: #{x}scale}.
+EOH
+      CoordinateRelatedCommands << cmd
+
+      cmd = 
+        Cmd.new("#{x}log",nil,"--#{x}log", 
+                [ CmdArg.new('boolean') ]) do |plotmaker, val|
+        plotmaker.root_object.current_plot.
+          style.send("set_log_scale", x, val)
+      end
+      cmd.describe("Use log scale for #{x.to_s.upcase}",
+                           <<EOH, PlotCoordinatesGroup)
+Uses a logarithmic scale for the #{x.to_s.upcase} axis.
+EOH
+      CoordinateRelatedCommands << cmd
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# containers.rb: drawables that contains other drawables
+# copyright (c) 2006, 2007, 2008, 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: 38 $', '$Date: 2009-05-07 23:11:55 +0200 (Thu, 07 May 2009) $')
+
+  module Graphics
+
+    module Elements
+      
+      # A Container is a drawable object that contains several others, its
+      # #elements.
+      class Container < TiogaElement
+
+        # All drawable Element contained in this object. It may
+        # contain other Container subobjects.
+        attr_accessor :elements
+
+        # The subframe position of this element with respect to its
+        # parent. It is a Types::Box object.
+        attr_accessor :subframe
+
+        # A reference to the RootObject
+        attr_accessor :root_object
+
+        # The Legends::LegendArea dedicated to the display of the
+        # legend of this object and its children, or _nil_ if the
+        # parent should handle the display.
+        attr_accessor :legend_area
+
+        # The Legends::LegendStorage that holds all the legends of the
+        # object
+        attr_accessor :legend_storage
+
+        # Creates an empty new Container with the given _parent_.
+        def initialize(parent = nil, root = nil)
+          @parent = parent
+          
+          # elements to be given to tioga
+          @elements = []
+
+          # By default the frame takes up all the space.
+          @subframe = Types::MarginsBox.new(0, 0, 0, 0)
+
+          @root_object = root
+
+          @legend_storage = Legends::LegendStorage.new
+
+          # By default, don't display legends.
+          @legend_area = nil
+        end
+
+        # Returns the number of child elements
+        def size
+          return @elements.size
+        end
+
+        # Adds an element
+        def add_element(element)
+          element.parent = self
+          @elements << element
+          
+          # If the element has a curve_style, we add it as a
+          # CurveLegend
+          if element.respond_to?(:curve_style) and 
+              element.curve_style.has_legend?
+            add_legend_item(Legends::CurveLegend.new(element.curve_style))
+          elsif element.is_a? Container
+            add_legend_item(element)
+          end
+        end
+
+
+        # Adds a legend item to the #associated_legend_storage
+        def add_legend_item(item)
+          @legend_storage.add_item(item)
+        end
+
+        # TODO: provide coordinate conversion facilities...
+
+        protected 
+
+        # Creates the appropriate subfigure and draws all its elements
+        # within.
+        def real_do(t)
+          t.subfigure(@subframe.to_frame_margins(t)) do 
+            for el in @elements
+              el.do(t)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+# curve2d.rb: a 2D curve
+# copyright (c) 2006, 2007, 2008, 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'
+
+require 'Dobjects/Function'
+
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+
+  module Graphics
+
+    module Elements
+
+      # A Curve2D object represents a 2D curve, along with its style and so
+      # on.
+      class Curve2D  < TiogaElement
+
+        include Log
+        include Dobjects
+
+        # A Dobjects::Function holding the "real" X and Y values, for
+        # the sake of manipulations.
+        attr_accessor :function
+
+        # The Data::Dataset object that should get plotted.
+        attr_accessor :dataset
+
+        # A Styles::CurveStyle object saying how the curve should be
+        # drawn.
+        attr_accessor :curve_style
+
+        # 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}"
+          end
+          # We build the function on a duplicate of the values ?
+          @function = Function.new(@dataset.x.values.dup, 
+                                   @dataset.y.values.dup)
+
+          # 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 ?
+          @function.strip_nan
+
+          @curve_style = style
+        end
+
+        # Returns the Types::Boundaries of this curve.
+        def get_boundaries
+          return Types::Boundaries.bounds(@function.x, @function.y)
+        end
+
+        # Creates a path for the given curve. This should be defined
+        # with care, as it will be used for instance for region
+        # coloring and stroking. The function should only append to
+        # 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
+        end
+
+        # Strokes the path.
+        def draw_path(t)
+          if @curve_style.has_line?
+            t.context do 
+              @curve_style.line.set_stroke_style(t)
+              make_path(t)
+              t.stroke
+            end
+          end
+        end
+
+        # Draws the markers, if applicable.
+        def draw_markers(t)
+          if @curve_style.has_marker?
+            xs = @function.x
+            ys = @function.y
+            @curve_style.marker.draw_markers_at(t, xs, ys)
+          end
+        end
+
+        # A function to close the path created by make_path.
+        # Overridden in the histogram code.
+        def close_path(t, y0)
+          t.append_point_to_path(@function.x.last, y0)
+          t.append_point_to_path(@function.x.first, y0)
+          t.close_path
+        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
+        end
+
+        def real_do(t)
+          debug "Plotting curve #{inspect}"
+          t.context do
+            # TODO reinstate the choice of the order of drawing ???
+            draw_path(t)
+            draw_markers(t)
+            #             # The fill is always first
+            #             draw_fill(t)
+
+            #             for op in CurveStyle::DrawingOrder[@style[:drawing_order]]
+            #               self.send("draw_#{op}".to_sym, t)
+            #             end
+          end
+        end
+        
+      end
+    end
+  end
+end