ctioga2 0.0

data/lib/ctioga2/graphics/generator.rb

@@ -0,0 +1,68 @@
+# root.rb: the root object for creating a plot.
+# 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'
+
+require 'ctioga2/graphics/coordinates'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+
+  module Graphics
+
+    # This class is in charge of generating Elements::TiogaElement,
+    # such as Elements::Curve2D, from a dataset. It takes care of
+    # generating the appropriate style and of transforming the
+    # coordinates.
+    class CurveGenerator
+
+      # A Styles::CurveStyleFactory object that handles the
+      # styles for every single curve that will be drawn.
+      attr_accessor :style_factory
+
+      # The provider of legends, a Legends::LegendProvider
+      # object.
+      attr_accessor :legend_provider
+
+      # Creates a CurveGenerator object.
+      def initialize
+        @legend_provider = Legends::LegendProvider.new
+        @style_factory = Styles::CurveStyleFactory.new
+      end
+
+      # Creates a Elements::TiogaElement representing the _dataset_
+      # and returns it.
+      #
+      # TODO:
+      # * coordinate transformations
+      # * other kinds of curves (pseudo-3D, surfaces, histograms...)
+      def curve_from_dataset(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
+      
+    end
+
+  end
+end
+

data/lib/ctioga2/graphics/legends.rb

@@ -0,0 +1,108 @@
+# legends.rb: handling of legends
+# 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/legends/items'
+require 'ctioga2/graphics/legends/area'
+require 'ctioga2/graphics/legends/storage'
+require 'ctioga2/graphics/legends/provider'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 68 $', '$Date: 2009-05-31 00:02:56 +0200 (Sun, 31 May 2009) $')
+
+  module Graphics
+
+    # Now, various commands pertaining to legends
+
+    LegendGroup = CmdGroup.new('legends', "Legends", <<EOD, 1)
+Commands to specify legends and tweak their look.
+EOD
+
+    NextLegendCommand = 
+      Cmd.new("legend",'-l',"--legend", 
+              [ CmdArg.new('text') ]) do |plotmaker, legend|
+      plotmaker.curve_generator.legend_provider.current_legend = legend
+    end
+
+    NextLegendCommand.describe("Sets the legend for the next dataset",
+                               <<EOH, LegendGroup)
+Sets the legend for the next dataset. Overridden by the legend= option
+to the plot command.
+EOH
+
+    LegendLineCommand = 
+      Cmd.new("legend-line",nil,"--legend-line", 
+              [ CmdArg.new('text') ], 
+              Styles::FullTextStyleOptions) do |plotmaker, legend, opts|
+      l = Legends::LegendLine.new(legend, opts)
+      plotmaker.root_object.current_plot.add_legend_item(l)
+    end
+
+    LegendLineCommand.describe("Adds a pure text line to the legend",
+                               <<EOH, LegendGroup)
+Adds a line of text unrelated to any curve to the legend.
+EOH
+
+    LegendInsideCommand = 
+      Cmd.new("legend-inside", nil, "--legend-inside",
+              [ CmdArg.new('aligned-point')]) do |plotmaker, point|
+      l = Legends::LegendArea.new(:inside)
+      l.legend_position = point
+      plotmaker.root_object.current_plot.legend_area = l
+    end
+
+    LegendInsideCommand.describe("Draw legends inside the current plot",
+                                 <<EOH, LegendGroup)
+When this option is in effect, all legends for the current plot (and
+possibly subplots) are drawn inside the current plot, at the specified 
+position.
+EOH
+
+    AutoLegendCommand = 
+      Cmd.new("auto-legend",nil,"--auto-legend", 
+              [ CmdArg.new('boolean') ]) do |plotmaker, value|
+      plotmaker.curve_generator.legend_provider.auto_legend = value
+    end
+
+    AutoLegendCommand.describe("Automatically give legends to datasets",
+                               <<EOH, LegendGroup)
+When this option is in effect (off by default), all datasets get a legend, 
+their 'dataset name', unless another legend is manually specified.
+EOH
+
+    LegendStyleOptions = {
+      'dy' => CmdArg.new('dimension'),
+      'scale' => CmdArg.new('float'),
+      'text_scale' => CmdArg.new('float'),
+    }
+      
+
+    LegendStyleCommand = 
+      Cmd.new("legend-style",nil,"--legend-style", 
+              [], LegendStyleOptions) do |plotmaker, options|
+      plotmaker.root_object.current_legend_area.
+        legend_style.set_from_hash(options)
+    end
+
+    LegendStyleCommand.describe("Set the style of the legends",
+                                <<EOH, LegendGroup)
+Sets the various aspects of the style of the legends throught 
+its options:
+ * dy: the spacing between consecutive lines
+ * scale: the overall scale of the legends
+ * text_scale: the scale of the text (and the markers) inside the legends
+EOH
+
+  end
+end

data/lib/ctioga2/graphics/legends/area.rb

@@ -0,0 +1,199 @@
+# storage.rb: an object holding legends
+# 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: 80 $', '$Date: 2009-06-09 23:56:44 +0200 (Tue, 09 Jun 2009) $')
+
+  module Graphics
+
+    # This module holds all the classes dealing with legends
+    module Legends
+
+      # This class holds a series of legends for curves.
+      #
+      # TODO:
+      # 
+      # * a legend can be plotted either inside a plot or outside the
+      #   root object
+      #   
+      # * in case it is plotted outside the root object, the user should
+      #   be able to choose whether it should be counted in the
+      #   real-size or not.
+      #
+      # * legends should provide all the kind of things that were in the
+      #   first ctioga, such as background, frames, and so on...
+      #
+      # * legends could be organized as columns (especially at the
+      #   bottom of the graph).
+      #
+      # * whenever a --legend-inside is specified, we create a private
+      #   @legend_area for the current Elements::Container, with the
+      #   given position.
+      #
+      # TODO: make a subclass for a top-level area ???? 
+      class LegendArea
+
+        # The style of the LegendStorage, a Styles::LegendStorageStyle
+        # object (of course)
+        attr_accessor :legend_style
+
+        # The type of the legend. Can be :left, :right, :top, :bottom
+        # or :inside
+        attr_accessor :legend_type
+
+        # The position of the LegendArea. Only significant when the
+        # type is :inside. A Types::AlignedPoint instance.
+        attr_accessor :legend_position
+
+        def initialize(type = :right)
+          @legend_style = Styles::LegendStorageStyle.new
+          @legend_type = type
+          @legend_position = Types::AlignedPoint.new(0.5,0.5,:frame)
+        end
+
+
+        # Draws the legend of the given container and all its
+        # subobjects. It assumes that the frames have been set
+        # according to the return value of #partition_frame
+        #
+        # TODO:
+        # 
+        # * customization of the x and y of origin (y should match the
+        #   top of the corresponding graph, if applicable)
+        #
+        # * add padding on the external side of the legend, if
+        #   applicable ?
+        #
+        def display_legend(t, container)
+          items = container.legend_storage.harvest_contents
+          t.context do 
+            t.rescale(@legend_style.scale)
+            t.rescale_text(@legend_style.text_scale)
+
+            # We make figure coordinates frame coordinates
+            t.set_bounds([0, 1, 1, 0])
+            # TODO: customize this !
+            x, y = initial_xy(t, container)
+            for item in items
+              # TODO: transform the 0.0 for x into a negative
+              # user-specifiable stuff.
+              item.draw(t, @legend_style, x , y)
+              y -= @legend_style.dy.to_figure(t,:y)
+            end
+          end
+        end
+
+        # Returns the total size of the legend as a
+        #  [ width, height ]
+        # array in figure coordinates.
+        def size(t, container)
+          items = container.legend_storage.harvest_contents
+          width, height = 0,0
+          for item in items
+            w,h = item.size(t, @legend_style)
+            if w > width
+              width = w
+            end
+            # Hmmm... this is plain wrong... 
+            # height += h
+            height += @legend_style.dy.to_figure(t,:y) * 
+              @legend_style.scale * @legend_style.text_scale
+          end
+          return [ width, height ]
+        end
+
+
+        # Returns an enlarged page size that can accomodate for both
+        # the text and the legend.
+        def enlarged_page_size(t, container, width, height)
+          w, h = size(t, container)
+          case @legend_type
+          when :left, :right
+            return [width + t.convert_figure_to_output_dx(w)/10, 
+                    height]
+          when :top, :bottom
+            return [width, height + t.convert_figure_to_output_dy(h)/10]
+          when :inside
+            return [width, height]
+          end
+          raise "Unknown type: #{@legend_type}"
+        end
+
+
+        # Partitions the frame in two: the plot frame and the legend
+        # frame, according to various parameters:
+        # * the #type of the LegendArea
+        # * the #size of the legend.
+        #
+        # It returns two arrays:
+        # 
+        #  [ plot_margins, legend_margins]
+        #  
+        # These arrays can be used as arguments for subframe_margins
+        # or respectively the graph and the legends part of the plot.
+        #
+        # This function will *eventually* also work in the case of a
+        # #legend_type :inside?
+        def partition_frame(t, container)
+          w,h = size(t, container)
+          case @legend_type
+          when :right
+            w = t.convert_figure_to_frame_dx(w)
+            return [ [0, w, 0, 0], [1 - w, 0, 0, 0]]
+          when :left
+            w = t.convert_figure_to_frame_dx(w)
+            return [ [w, 0, 0, 0], [0, 1 - w, 0, 0]]
+          when :inside
+            return [ 
+                    [0, 0, 0, 0], 
+                    @legend_position.to_frame_margins(t, w, h)
+                   ]
+          else 
+            raise "Unimplemented yet..."
+          end
+          
+        end
+
+        protected
+
+        # Returns the X and Y values for the top left of the legend
+        # inside the legend frame. Depends on a lot of things,
+        # including the type of the legend.
+        def initial_xy(t, container)
+          case @legend_type
+          when :right
+            l,r,t,b = container.subframe.to_frame_margins(t)
+            # Here, we take profit from the fact that frame
+            # coordinates are also figure coordinates within the
+            # legend.
+
+            # TODO: that won't work in the case of labels on the
+            # right-hand-side.
+            return [- l/2, 1.0 - t]
+          when :inside
+            return [0.0, 1.0]
+          else
+            raise "Unimplemented yet..."
+          end
+        end
+      end
+
+    end
+  end
+
+end
+

data/lib/ctioga2/graphics/legends/items.rb

@@ -0,0 +1,183 @@
+# items.rb: individual legend items
+# copyright (c) 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 'ctioga2/graphics/styles'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 55 $', '$Date: 2009-05-27 00:01:34 +0200 (Wed, 27 May 2009) $')
+
+  module Graphics
+
+    module Legends
+
+      # All items that can be displayed in a legend derive from this
+      # one.
+      class LegendItem
+
+        # This class-wide variable is used to number text
+        # in a unique fashion
+        @@legend_item_numbering = 0
+
+        # Initializes the LegendItem. Children *must* call super to
+        # make sure the numbering is dealt with properly.
+        def initialize
+          @legend_number = @@legend_item_numbering
+          @@legend_item_numbering += 1
+        end
+
+        # Returns the (width, height) in figure coordinates of the
+        # legend element with the given Styles::LegendStyle and
+        # FigureMaker reference objects.
+        #
+        # The returned values can be inaccurate to some extent.
+        def size(t, legend_style)
+          return [0, 0]
+        end
+
+        # Draws the legend at the given top left position (_x_,_y_) in
+        # figure coordinates.
+        def draw(t, legend_style, x, y)
+        end
+
+
+        protected 
+
+        # The internal name for the legend - one we can use in a
+        # get_text_size query.
+        def legend_name
+          return "legend-#{@legend_number}"
+        end
+
+        # Returns the _y_ value for the baseline of the text in terms
+        # of figure coordinates.
+        def get_baseline_y(t, legend_style, y)
+          return y - Types::Dimension.new(:dy,1.0,:y).to_figure(t) 
+        end
+
+
+      end
+
+      # A class representing the style of a single legend line
+      # (unrelated to a curve)
+      class LegendLine < LegendItem
+
+        # The text of the line
+        attr_accessor :text
+
+        # The style of the text, a Styles.FullTextStyle object.
+        attr_accessor :style
+        
+        def initialize(text = "", style = {})
+          super()
+          @text = text
+          @style = Styles::FullTextStyle.from_hash(style)
+          @style.justification ||= Tioga::FigureConstants::LEFT_JUSTIFIED
+
+        end
+
+        # Draw one single text line.
+        def draw(t, legend_style, x, y)
+          y = get_baseline_y(t, legend_style, y) 
+          @style.draw_text(t, @text, x, y, legend_name)
+        end
+
+        # Computes the size of the line. Height should always be
+        # accurate, but width can be 0 sometimes...
+        def size(t, legend_style)
+          height = legend_style.dy.to_figure(t)
+
+          width = 0.0
+
+          info = t.get_text_size(legend_name)
+          
+          if info.key? 'width'
+            width += t.convert_output_to_figure_dx(10*info['width'])
+          end
+
+          return [ width, height ]
+        end
+        
+      end
+
+      # The legend of a curve object, or rather, the legend
+      # corresponding to a given
+      #
+      # TODO: finish to adapt: use FullTextStyle to draw the objects.
+      class CurveLegend < LegendItem
+
+        include CTioga2::Log
+        
+        attr_accessor :curve_style
+
+        def initialize(style)
+          super()
+          @curve_style = style
+        end
+        
+        # Draw one single text line
+        #
+        # TODO: adapt here !
+        #
+        # TODO: _x_ and _y_ are not taken into account the way they should be.
+        def draw(t, legend_style, x, y)
+          y = get_baseline_y(t, legend_style, y) 
+          t.context do 
+            # Position specification for the legend pictogram
+            margin_specs = { 'left' => x,
+              'right' => 1 - x - legend_style.picto_width.to_figure(t),
+              'bottom' => y,
+              'top' => 1 - y - legend_style.picto_height.to_figure(t)
+            }
+            debug "Legend margins for '#{@curve_style.legend}' : #{margin_specs.inspect}"
+            t.subfigure(margin_specs) do
+              # We make the markers slightly smaller than the text
+              # around.
+              t.rescale_text(0.8)
+              @curve_style.draw_legend_pictogram(t)
+            end
+          end
+          t.show_text('x' => x + 
+                      legend_style.picto_width.to_figure(t) + 
+                      legend_style.picto_to_text.to_figure(t), 
+                      'y' => y, 'text' => @curve_style.legend,
+                      'measure' => legend_name,
+                      'justification' => Tioga::FigureConstants::LEFT_JUSTIFIED)
+        end
+
+        # Computes the size of the line. Height should always
+        # be accurate, but width can be 0 sometimes...
+        def size(t, legend_style)
+          height = legend_style.dy.to_figure(t)
+
+          width = legend_style.picto_width.to_figure(t) + 
+            legend_style.picto_to_text.to_figure(t) 
+
+          info = t.get_text_size(legend_name)
+          
+          if info.key? 'width'
+            width += t.convert_output_to_figure_dx(10*info['width'])
+          end
+
+          return [ width, height ]
+        end
+        
+        
+      end
+    end
+
+  end
+end