ctioga 1.11.1

data/lib/CTioga/backends.rb

@@ -0,0 +1,88 @@
+# backends.rb, copyright (c) 2006 by Vincent Fourmond: 
+# The module handling the communication with backends. 
+  
+# 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).
+
+# The backend structure...
+require 'SciYAG/backends'
+require 'MetaBuilder/factory'
+require 'CTioga/utils'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 696 $', '$Date: 2007-12-06 20:59:20 +0100 (Thu, 06 Dec 2007) $')
+
+  # This module handles all manipulations of backends.
+  module Backends
+
+    include SciYAG
+    
+    # Initializes the backend structure.
+    def init_backend_structure
+      @backend_factory = 
+        MetaBuilder::Factories::UniqueFactory.new(SciYAG::Backends::Backend, 
+                                                  'text')
+      SciYAG::Backends::Backend.logger = self.logger
+    end
+
+    def backend
+      @backend_factory.current
+    end
+
+    def backends
+      @backend_factory.instances
+    end
+
+    def set_backend(str)
+      @backend_factory.current = str
+    end
+
+
+    # Push a filter onto the current backend
+    def current_push_filter(filter)
+      backend.push_xy_filter(filter)
+    end
+
+    # Fills an OptionParser with the apppropriate stuff to
+    # deal with backends:
+    def prepare_backend_options(op)
+      op.separator "\nHow to select backends, and their options:"
+      @backend_factory.option_parser_factory(op) 
+
+      op.separator "\nFilters to apply onto data:"
+      for filter_desc in SciYAG::Backends::Filter.description_list
+        filter_desc.parser_instantiate_option(op,
+                                              self,
+                                              :current_push_filter)
+      end
+      op.on("--filter-pop", "Removes the last filter pushed " +
+                 "onto the current backend") do
+        backend.pop_xy_filter
+      end
+
+      op.on("--filter-clear", "Removes all filters applying " +
+                 "to the current backend") do
+        backend.clear_xy_filters
+      end
+    end
+
+    # Interprets the +set+ with the current backend and returns the data
+    def xy_data_set(set)
+      return backend.xy_data(set) 
+    end
+
+    # Expands the current set according to the current's backend rules
+    def expand_spec(spec)
+      backend.expand_sets(spec)
+    end
+
+  end
+end

data/lib/CTioga/boundaries.rb

@@ -0,0 +1,224 @@
+# boundaries.rb: Small class for manipulating boundaries 
+# Copyright (c) 2008 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 'CTioga/utils'
+
+# A small add-on to the Array class, to make it easy to convert to
+# frame specifications.
+class Array
+
+  def to_frame(spec = "%s")
+    i = 0
+    h = {}
+    for side in %w(left right top bottom)
+      h[ spec % side] = self[i]
+      i += 1
+    end
+    return h
+  end
+
+end
+
+
+module CTioga
+  
+  Version::register_svn_info('$Revision: 825 $', '$Date: 2008-07-23 14:36:18 +0200 (Wed, 23 Jul 2008) $')
+  
+  module Utils
+
+
+    # Converting a boundary hash to an array
+    def self.frame_to_array(hash, format = '%s')
+      return %w(left right top bottom).map {|x| sprintf(format,x) }.map do |f|
+        hash[f]
+      end
+    end
+
+    # Compose two margins (in the form of arrays): you get the m2 expressed
+    # in the same frame as m1, but taken relative to m1.
+    def self.compose_margins(m1, m2)
+      width = 1 - m1[0] - m1[1]
+      height = 1 - m1[2] - m1[3]
+      
+      return [ m1[0] + m2[0] * width,
+               m1[1] + m2[1] * width,
+               m1[2] + m2[2] * height,
+               m1[3] + m2[3] * height
+             ]
+    end
+
+
+    # A small class to handle boundaries
+    class Boundaries
+      
+      attr_accessor :left, :right, :top, :bottom
+      
+      def initialize(*args)
+        args.flatten!
+
+        @left = args[0]
+        @right = args[1]
+        @top = args[2]
+        @bottom = args[3]
+      end
+
+      def xmin
+        if @left <= @right
+          return @left
+        else
+          return @right
+        end
+      end
+
+      def xmax
+        if @left <= @right
+          return @right
+        else
+          return @left
+        end
+      end
+
+      def ymin
+        if @top <= @bottom
+          return @top
+        else
+          return @bottom
+        end
+      end
+
+      def ymax
+        if @top <= @bottom
+          return @bottom
+        else
+          return @top
+        end
+      end
+
+      # Returns [xmin, xmax, ymin, ymax]. Useful, for instance,
+      # for Function#bound_values
+      def real_bounds
+        return [xmin, xmax, ymin, ymax]
+      end
+
+      def to_a
+        return [@left, @right, @top, @bottom]
+      end
+
+      # Returns a 'left' => ..., 'right' => .... hash containg the
+      # boundaries.
+      def to_hash
+        return {
+          'left' => @left,
+          'right' => @right, 
+          'top' => @top,
+          'bottom' => @bottom
+        }
+      end
+
+      # Returns true if the given X coordinate is within the bounds
+      def x_inside?(x)
+        return (x >= xmin && x <= xmax)
+      end
+
+      # Returns true if the given Y coordinate is within the bounds
+      def y_inside?(y)
+        return (y >= ymin && y <= ymax)
+      end
+
+      # The position of the given X coordinate with respect to the
+      # boundaries. Returns either :inside, :left or :right
+      def where_x?(x)
+        if x_inside?(x)
+          return :inside
+        elsif @left <= @right
+          if x < @left
+            return :left
+          else
+            return :right
+          end
+        else                    # Right-to-left order
+          if x < @right
+            return :right
+          else
+            return :left
+          end
+        end
+      end
+
+      # The position of the given Y coordinate with respect to the
+      # boundaries. Returns either :inside, :top or :bottom
+      def where_y?(y)
+        if y_inside?(y)
+          return :inside
+        elsif @top <= @bottom
+          if y < @top
+            return :top
+          else
+            return :bottom
+          end
+        else
+          if y < @top
+            return :bottom
+          else
+            return :top
+          end
+        end
+      end
+      
+    end
+
+    # A function that transforms an inset/legend specification into
+    # margins. Specifications understood are:
+    # * x,y:w(xh) : box centered on x,y of size w x h (or w x w if
+    #   h is omitted)
+    # * x1,y1;x2,y2 : the exact box 
+    def self.inset_margins(spec)
+      case spec
+      when /(.*),(.*):([^x]*)(?:x(.*))?/
+        x = $1.to_f; y = $2.to_f; w = $3.to_f
+        h = ($4 || $3).to_f
+        margins = [x - w/2, 1 - (x + w/2), 1 - (y+h/2), y - h/2]
+      when /(.*),(.*);(.*),(.*)/
+        x1 = $1.to_f; y1 = $2.to_f; 
+        x2 = $3.to_f; y2 = $4.to_f; 
+        left = [x1, x2].min
+        right = [x1, x2].max
+        top = [y1, y2].max
+        bottom = [y1, y2].min
+        margins = [left, 1 - right, 1 - top, bottom]
+      when /(.*)x(.*)([+-])(.*)([+-])(.*)/ # X geometry-like specification
+        w = $1.to_f; h = $2.to_f
+        if $3 == '+'            # Left
+          left = $4.to_f
+          right = left + w
+        else                    # Right
+          right = $4.to_f
+          left = right - w
+        end
+        if $5 == '+'            # Top
+          top = $6.to_f
+          bottom = top - h
+        else                    # Bottom
+          bottom = $6.to_f
+          top = bottom + h
+        end
+        margins = [left, 1 - right, 1 - top, bottom]
+      else
+        raise "Incorrect inset specification #{spec}"
+      end
+      return margins
+    end
+
+  end
+  
+end

data/lib/CTioga/ctable.rb

@@ -0,0 +1,134 @@
+=begin rdoc
+
+This program is copyright 2006 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.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+=end
+
+# This program enables one to print out as text the data read by the
+# backends. Can come in dead useful for debugging, or if you intend to plot
+# with another data
+
+require 'Dobjects/Dvector'
+require 'CTioga/backends'
+require 'CTioga/log'
+require 'optparse'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 753 $', '$Date: 2008-02-26 15:03:52 +0100 (Tue, 26 Feb 2008) $')
+
+  class CTable
+    include Log
+    include Backends
+
+    attr_accessor :block
+    attr_accessor :args
+    attr_accessor :print_banner
+
+    # This can be used by various scripts to add hooks on the parser.
+    # You can alternatively use your own parser beforehand, but you lose
+    # the benefits of the online help.
+    attr_accessor :parser
+
+    def initialize
+      init_logger
+      init_backend_structure
+      @args = []
+      @block = proc { |set,data,*a| 
+        puts "# #{set}"
+        data.each do |x,y|
+          puts "#{x}\t#{y}"
+        end
+      }
+
+      @print_banner = true
+
+      @parser = OptionParser.new
+      prepare_backend_options(@parser)
+
+      @parser.separator ""
+      @parser.separator "Code execution"
+
+      @parser.on("-e", "--execute BLOCK",
+                 "Executes the given ruby code for each set, " ,
+                 "yielding the set name and its data for each." ,
+                 "Use 'set' to refer to the set's name, and 'data' " ,
+                 "for it's data"
+                 ) do |code|
+        self.block = eval "proc { |set,data,*args| #{code}}"
+      end
+
+      @parser.on("-f", "--file FILE",
+                 "Same as -e except it's specifying a file which is ",
+                 "read an executed with the same parameters as the BLOCK"
+                 ) do |file|
+        self.block = eval "proc { |set,data,*args| #{IO.readlines(file).join}}"
+      end
+
+      @parser.on("-r", "--require FILE",
+                 "Ask ruby to require the file before data processing.",
+                 "You can use it to declare some external functions."
+                 ) do |file|
+        require file
+      end
+      
+      @parser.on("-a", "--arg a",  
+                 "Provides additionnal arguments to your code") do |arg|
+        @args << arg
+      end
+
+    end
+
+    def process_data_set(set)
+      data = xy_data_set(set)
+      @block.call(set,data,*@args)
+    end
+    
+    # Runs the program with the given command-line arguments. If a block
+    # is given, use this block rather than the default one. Be careful,
+    # though, as command-line arguments can still override this.
+    def run(cmd_line_args,*extra_args, &a)
+      $stderr.puts <<"EOBANNER" if @print_banner
+This is ctable version #{Version.version}, 
+copyright (C) 2006-2007 Vincent Fourmond. 
+ctable comes with absolutely NO WARRANTY. This is free software, you are 
+welcome to redistribute it under certain conditions. See the COPYING file
+in the original tarball for details. You are also welcome to contribute if
+you like it, see in the manual page where to ask.
+EOBANNER
+
+      # Use the user-given block
+      if block_given?
+        @block = a
+      end
+      @args = extra_args
+
+      @parser.order(cmd_line_args) do |spec|
+        # We use Backend#expand to leave room for the backend to
+        # interpret the text as many different sets.
+        expand_spec(spec).each do |set|
+          process_data_set(set)
+        end
+      end
+    end
+
+    # A simple convenience function.
+    def self.run(args, &a)
+      self.new.run(args,&a)
+    end
+    
+  end
+end

data/lib/CTioga/curve_style.rb

@@ -0,0 +1,246 @@
+# curves.rb, copyright (c) 2006 by Vincent Fourmond: 
+# The class describing a curve to be plotted.
+  
+# 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 'CTioga/elements'
+require 'CTioga/utils'
+require 'CTioga/boundaries'
+
+module CTioga
+
+  Version::register_svn_info('$Revision: 873 $', '$Date: 2009-01-20 17:07:00 +0100 (Tue, 20 Jan 2009) $')
+
+  # This structure holds the different properties to be transmitted to
+  # a Curve object for appropriate drawing. 
+
+  # TODO: create StrokeStyle and a FillStyle objects that would handle every
+  # place where there are fills and strokes (background, grids,
+  # legend frame and of course curves) !!!
+
+  class CurveStyle
+    ELEMENTS = [
+                :color, :marker, :marker_color,
+                :line_style, :legend, :linewidth,
+                :interpolate, :marker_scale, 
+                :error_bar_color, :drawing_order,
+                :transparency,   # Stroke transparency
+                :marker_transparency, 
+                :error_bars_transparency,
+                # Now, fill information
+                :fill_type,     # not false/nil => there will be
+                # some filling. See Curve2D#draw_fill for more info
+                :fill_color, :fill_transparency,
+                :hist_type,      # See below
+                :hist_left,     # the position of the left part of the step
+                :hist_right,     # the position of the right part of the step
+               ]
+    attr_writer *ELEMENTS
+    
+    # Special accessors: they implement the :"=>stuff" redirection. Beware
+    # of circular redirections !!!
+    for el in ELEMENTS
+      eval <<"EOE"
+def #{el.to_s}
+  if @#{el.to_s}.is_a?(Symbol) && @#{el.to_s}.to_s =~ /^=>(.*)/
+    new_sym = $1.to_sym
+    if new_sym == :#{el.to_s}
+      return nil
+    end
+    return self[new_sym]
+  else
+    return @#{el.to_s}
+  end
+end
+EOE
+    end
+
+    # The order of the plotting operations. Default is 0
+    # (path then markers then error_bars)
+    DrawingOrder = [
+                    [:path, :markers, :error_bars],
+                    [:path, :error_bars, :markers],
+                    [:markers, :path, :error_bars],
+                    [:markers, :error_bars, :path ],
+                    [:error_bars, :path, :markers],
+                    [:error_bars,  :markers, :path]
+                   ]
+
+    Defaults = {
+      :marker_scale => 0.5,
+      :error_bar_color => :'=>color', # Defaults to the same as color
+      :drawing_order => 0,
+      :transparency => false,
+      :fill_type => false,      # No fill by default.
+      :fill_color => :'=>color', # Defaults to the same as color
+      :hist_type => false, # old style by default...
+      :hist_left => 0.0,       # joint lines by default
+      :hist_right => 1.0,       # joint lines by default
+    }
+
+    # A hash to deal with fill types, to be used as an argument for
+    # the Utils::interpret_arg function.
+    FillTypeArguments = {
+      /no(ne)?/ => false,
+      /y[_-]ax(is)?/ => :to_y_axis,
+      /bottom/ => :to_bottom,
+      /top/ => :to_top,
+      /old-styke/ => :old_style, # essentially for histograms
+    }
+    
+    # Creates a CurveStyle element. There are several ways to
+    # initialize:
+    # * no arguments (_args_ empty): a CurveStyle object is created
+    #   with all its values set to nil
+    # * at least one argument: arguments are taken as values in the
+    #   order given by the ELEMENTS array. In this case, arguments
+    #   not present default to the value given in the Defaults
+    #   hash. This behaviour is mainly to keep old things working.
+    # * The new and best way to do it is to feed it a hash, in which
+    #   case elements not present in the hash get the values in
+    #   Default.
+    def initialize(*args)
+      if args.length == 0
+        return                  # We don't set anything in this case
+      end
+      
+      if (h = args[0]).is_a? Hash
+        for el in ELEMENTS
+          if h.key?(el)
+            self[el] = h[el]
+          elsif Defaults.key?(el)
+            self[el] = Defaults[el]
+          end
+        end
+      else
+        # If there is at least one argument, we consider them as
+        # values in the order of ELEMENTS
+        for el in ELEMENTS
+          if args.length > 0
+            self[el] =  args.shift
+          else
+            if Defaults.key?(el)
+              self[el] = Defaults[el]
+            end
+          end
+        end
+      end
+
+      # This is not the place where to do this. It should be implemented
+      # as part of the attribute accessors.
+#       # Now, if there is any entry with a value of a symbol starting with
+#       # => , its value is replaced by the value for the pointed elements.
+#       # That is =>color means 'replace by the color'. Be careful however
+#       # with circular dependencies !!!
+#       for el in ELEMENTS
+#         if self[el].is_a?(Symbol) && self[el].to_s =~ /^=>(.*)/
+#           self[el] = self[$1.to_sym]
+#         end
+#       end
+    end
+    
+    # Overrides the style entries with the ones found in _other_.
+    def override!(other)
+      for iv in ELEMENTS
+        if other.instance_variables.include?("@" + iv.to_s)
+          # We use instance_variables.include? rather
+          # than instance_variable_defined?, as the latter
+          # is present only in recent versions of Ruby 1.8
+          send(iv.to_s + "=", other.send(iv))
+        end
+      end
+    end
+
+    # Returns a hash suitable to pass on to save_legend_info, or return
+    # false if there was no legend specified in the style.
+    def legend_info
+      if legend 
+        legend_info = {
+          'text' => legend,
+          'marker' => marker,
+          'marker_color' => marker_color,
+          'marker_scale' => marker_scale, 
+        }
+        if color && line_style
+          legend_info['line_color'] = color
+          legend_info['line_type'] = line_style
+        else                             # Line drawing is disabled.
+          legend_info["line_width"] = -1 
+        end
+        return legend_info
+      else
+        return false
+      end
+    end
+
+    # Returns true if the style element actually carries a legend
+    def has_legend?
+      return legend ? true : false
+    end
+
+
+    # Remove attributes. Can be used to 'unset' current default.
+    def delete(*vars)
+      for iv in vars
+        begin
+          remove_instance_variable('@' + iv.to_s)
+        rescue NameError
+        end
+      end
+    end
+
+    # Hash-like accessor:
+    def [](elem)
+      if ELEMENTS.include?(elem)
+        return self.send(elem)
+      else
+        raise NameError, "Unkown element of CurveStyle: #{elem}"
+      end
+    end
+
+    def []=(elem, value)
+      if ELEMENTS.include?(elem)
+        self.send(elem.to_s + '=', value)
+      else
+        raise NameError, "Unkown element of CurveStyle: #{elem}"
+      end
+    end
+
+    # A function to be used to output legend pictograms separately.
+    # It takes all the place available in the current context of the
+    # FigureMaker object _t_.
+    def output_legend_pictogram(t)
+      t.context do
+        # output line
+        if color && line_style 
+          t.line_color = color
+          t.line_width = linewidth if linewidth
+          #           t.line_cap = dict['line_cap']
+          t.line_type = line_style
+          t.stroke_line(0.0, 0.5, 1.0, 0.5)
+        end
+        if marker
+          t.line_type = Tioga::FigureConstants::Line_Type_Solid
+          t.show_marker( 'x' => 0.5,
+                         'y' => 0.5,
+                         'marker' => marker,
+                         'color' => marker_color,
+                         'scale' => marker_scale,
+                         'alignment' => Tioga::FigureConstants::ALIGNED_AT_MIDHEIGHT,
+                         'justification' => Tioga::FigureConstants::CENTERED
+                         )
+        end
+      end
+    end
+
+  end
+
+end