ctioga2 0.0

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

@@ -0,0 +1,90 @@
+# element.rb: base class of all drawable elements
+# 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'
+
+# 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) $')
+
+  # This module contains all graphical elements of CTioga2
+  module Graphics
+
+    # All elements that can be drawn onto a FigureMaker object
+    module Elements
+      
+      # The base class for every single object that is drawn on
+      # Tioga's output.
+      class TiogaElement
+        include Log
+
+        # The parent Container.
+        attr_accessor :parent
+
+        # 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}"
+          real_do(f)
+        end
+
+        # We plot everything but parent. If a prefix is given, it is prepended
+        # to all lines but the first (for indentation)
+        def inspect(prefix="")
+          ret = "#<#{self.class.name}:\n"
+          for i in instance_variables
+            next if i == "@parent"
+            var = instance_variable_get(i)
+            ret += "#{prefix}  - #{i} -> "
+            if var.is_a? TiogaElement
+              ret += "#{var.inspect("#{prefix}  ")}\n"
+            else
+              ret += "#{var.inspect}\n"
+            end
+          end
+          ret += "#{prefix}>"
+          return ret
+        end
+
+        protected
+        
+        def real_do(t)
+          raise "Should be reimplemented by children"
+        end
+      end 
+      
+
+#       # A unique method call to a FigureMaker object.
+#       class TiogaFuncall < TiogaElement
+
+#         # _symbol_ is the symbol to be called, and the remainder will
+#         # be used as arguments for the call.
+#         def initialize(symbol, *args)
+#           @symbol = symbol
+#           @args = args
+#         end
+
+#         protected
+        
+#         def real_do(f)
+#           f.send(@symbol, *@args)
+#         end
+#       end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+# primitive.rb: direct use of graphics primitives for tioga
+# 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 'ctioga2/graphics/types'
+require 'shellwords'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  Version::register_svn_info('$Revision: 101 $', '$Date: 2009-07-21 23:29:59 +0200 (Tue, 21 Jul 2009) $')
+
+  module Graphics
+
+    module Elements
+      
+      # A TiogaElement that represents a graphics primitive.
+      class TiogaPrimitiveCall < TiogaElement
+        
+        # Some kind of reimplementation of Command for graphics
+        # primitives
+        class TiogaPrimitive
+
+          # A name (not very useful, but, well, we never know)
+          attr_accessor :name
+
+          # An array of compulsory arguments (type specifications)
+          attr_accessor :compulsory_arguments
+          
+          # A hash of optional arguments
+          attr_accessor :optional_arguments
+          
+          # A block that will receive a FigureMaker object, the
+          # compulsory arguments and a hash containing optional ones.
+          attr_accessor :funcall
+
+          # Creates a TiogaPrimitive object
+          def initialize(name, comp, opts = {}, &code)
+            @name = name
+            @compulsory_arguments = comp
+            @optional_arguments = opts
+            @funcall = code
+          end
+        end
+
+        # A TiogaPrimitive object describing the current primitive
+        attr_accessor :primitive
+        
+        # An array containing the values of the compulsory arguments
+        attr_accessor :arguments
+
+        # A hash containing the values of the optional arguments
+        attr_accessor :options
+
+
+        # Creates a new TiogaPrimitiveCall object.
+        def initialize(primitive, arguments, options)
+          @primitive = primitive
+          @arguments = arguments
+          @options = options
+        end
+
+        @known_primitives = {}
+
+        PrimitiveCommands = {}
+
+        PrimitiveGroup = CmdGroup.new('tioga-primitives',
+                                      "Graphics primitives",
+                                      "Tioga graphics primitives", 3)
+
+        # Creates a new primitive with the given parameters, and makes
+        # it immediately available as a command.
+        def self.primitive(name, long_name, comp, opts = {}, &code)
+          primitive = TiogaPrimitive.new(name, comp, opts, &code)
+          @known_primitives[name] = primitive
+          
+          # Now, create the command
+          cmd_args = comp.map do |x|
+            CmdArg.new(x)
+          end
+
+          cmd_opts = {}
+          for k,v in opts
+            cmd_opts[k] = CmdArg.new(v)
+          end
+          
+          cmd = Cmd.new("draw-#{name}",nil,"--draw-#{name}", 
+                        cmd_args, cmd_opts) do |plotmaker, *rest|
+            options = rest.pop
+            call = Elements::
+              TiogaPrimitiveCall.new(primitive,
+                                     rest, options)
+            plotmaker.root_object.current_plot.
+              add_element(call)
+          end
+          cmd.describe("Draws #{long_name}",
+                       "Directly draws #{long_name} on the current plot", PrimitiveGroup)
+
+          PrimitiveCommands[name] = cmd
+        end
+
+
+        # Returns a pair primitive/primitive command for the named
+        # primitive, or [ _nil_, _nil_ ]
+        def self.get_primitive(name)
+          return [@known_primitives[name], PrimitiveCommands[name]]
+        end
+
+        # Now, a list of primitives, along with their code.
+
+        primitive("text", "text", [ 'point', 'text' ],
+                  {
+                    'color' => 'color',
+                    'scale' => 'float',
+                    'angle' => 'float',
+                    'justification' => 'justification',
+                    'alignment' => 'alignment',
+                  }
+                  ) do |t, point, string, options|
+          # TODO: add a way to specify fonts ???
+          options ||= {}
+          options['text'] = string
+          options['at'] = point.to_figure_xy(t)
+          t.show_text(options)
+        end
+
+        # TODO: add rendering mode !!
+        MarkerOptions = {
+          'color' => 'color',
+          'stroke_color' => 'color',
+          'fill_color' => 'color',
+          'scale' => 'float',
+          'horizontal_scale' => 'float',
+          'vertical_scale' => 'float',
+          'angle' => 'float',
+          'justification' => 'justification',
+          'alignment' => 'alignment',
+        }
+
+        primitive("marker", "marker", [ 'point', 'marker' ],
+                  MarkerOptions) do |t, point, marker, options|
+          # TODO: add a way to specify fonts ???
+          options ||= {}
+          options['marker'] = marker
+          options['at'] = point.to_figure_xy(t)
+          t.show_marker(options)
+        end
+
+        primitive("string-marker", "marker", [ 'point', 'text' ],
+                  {'font' => 'pdf-font' }.update(MarkerOptions)
+                  ) do |t, point, string, options|
+          # TODO: add a way to specify fonts ???
+          options ||= {}
+          options['text'] = string
+          options['at'] = point.to_figure_xy(t)
+          t.show_marker(options)
+        end
+
+        primitive("arrow", "arrow", [ 'point', 'point' ],
+                  {
+                    'color' => 'color',
+                    'head_scale' => 'float',
+                    'head_marker' => 'marker',
+                    'head_color' => 'color',
+                    'tail_scale' => 'float',
+                    'tail_marker' => 'marker',
+                    'tail_color' => 'color',
+                    'line_width' => 'float',
+                    'line_style' => 'line-style',
+                  }
+                  ) do |t, tail,head, options|
+          options ||= {}
+          options['head'] = head.to_figure_xy(t)
+          options['tail'] = tail.to_figure_xy(t)
+          t.show_arrow(options)
+        end
+ 
+        primitive("line", "line", [ 'point', 'point' ],
+                  {
+                    'color' => 'color',
+                    'line_width' => 'float',
+                    'line_style' => 'line-style',
+                  }
+                  ) do |t, tail,head, options|
+          options ||= {}
+          for a in ['head', 'tail'] 
+            options["#{a}_marker"] = "None"
+          end
+          options['head'] = head.to_figure_xy(t)
+          options['tail'] = tail.to_figure_xy(t)
+          t.show_arrow(options)
+        end
+
+
+        protected
+
+        # Draws the primitive
+        def real_do(t)
+          args = @arguments + [@options]
+          primitive.funcall.call(t, *args)
+        end
+        
+        DrawingSpecType = 
+          CmdType.new('drawing-spec', :string, <<EOD)
+A ctioga 1 --draw specification.
+EOD
+
+
+
+        # An emulation of the old ctioga behavior
+        CmdDraw = Cmd.new('draw', nil, '--draw',
+                          [CmdArg.new('drawing-spec')]) do |plotmaker, spec|
+          spec =~ /^([^:]+):(.*)/
+          name = $1
+          args = Shellwords.shellwords($2)
+          primitive, cmd = TiogaPrimitiveCall.get_primitive(name)
+          if primitive
+            # We build the arguments based on the number of compulsory ones
+            comp = args.slice!(0,primitive.compulsory_arguments.size)
+            opts = {}
+            for a in args
+              if a =~ /^\s*([^=]+)=(.*)/
+                opts[$1] = $2
+              else
+                plotmaker.error "Argument found where a option= was expected: #{a}"
+              end
+            end
+            plotmaker.interpreter.run_command(cmd, comp, opts)
+          else
+            plotmaker.error "Unkown graphics primitive: #{name}"
+          end
+        end
+
+        CmdDraw.describe("Draws graphics primitives",
+                         <<EOH, PrimitiveGroup)
+Tries to emulate the old --draw behavior of ctioga. Don't use it for new things.
+EOH
+      
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# subplot.rb: a subplot
+# 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: 95 $', '$Date: 2009-06-25 23:52:42 +0200 (Thu, 25 Jun 2009) $')
+
+  module Graphics
+
+    module Elements
+
+      # A subplot. It features:
+      # * inclusion of curves
+      # * legends
+      # * 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
+        
+        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")
+
+          @subframe = nil       # Automatic by default.
+
+          @style = style || Styles::PlotStyle.new
+
+          # By default, boundaries do not count for the parent
+          @count_boundaries = false
+        end
+
+        # Returns the boundaries of the SubPlot.
+        def get_boundaries
+          # raw boundaries
+          bounds = get_elements_boundaries
+          if @style.plot_margin
+            bounds.apply_margin!(@style.plot_margin)
+          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
+
+          @real_boundaries = get_boundaries
+
+          frames = @subframe || @style.estimate_margins(t)
+
+          # We wrap the call within a subplot
+          t.subplot(frames.to_frame_margins(t)) do
+
+            # Setup various aspects of the figure maker object.
+            @style.setup_figure_maker(t)
+            
+            # Manually creating the plot:
+            t.set_bounds(@real_boundaries.to_a)
+
+            # Drawing the background elements:
+            t.context do
+              t.clip_to_frame
+
+              @style.background.draw_background(t)
+
+              @style.draw_all_background_lines(t)
+              i = 0
+              for element in @elements 
+                element.do(t)
+                i += 1
+              end
+            end
+            @style.draw_all_axes(t)
+
+            # Now drawing legends:
+            if @legend_area
+              a, b = @legend_area.partition_frame(t, self)
+              t.context do 
+                t.set_subframe(b) 
+                @legend_area.display_legend(t, self)
+              end
+            end
+          end
+        end
+
+        
+        # Returns the boundaries of all the elements of this plot.
+        def get_elements_boundaries
+          elements_bounds = []
+          for el in @elements
+            if el.respond_to? :get_boundaries
+              if el.respond_to?(:count_boundaries) && ! (el.count_boundaries)
+                # Ignoring
+              else
+                elements_bounds << el.get_boundaries
+              end
+            end
+          end
+          return Types::Boundaries.overall_bounds(elements_bounds)
+        end
+
+      end
+    end
+  end
+end