ctioga2 0.10.1 → 0.11

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

@@ -29,6 +29,8 @@ module CTioga2
         undef :elements
         undef :subframe
 
+        define_style 'region'
+
         # The curves which delimit the region
         attr_accessor :curves
 
@@ -39,7 +41,10 @@ module CTioga2
         attr_accessor :reversed_fill_style
 
         # Creates a new empty region
-        def initialize(parent = nil, root = nil)
+        def initialize(parent, root, opts)
+          setup_style(parent, opts)
+          # A reason why we don't use the superclass constructor ?
+
           @parent = parent
           @clipped = true       # clipped by default !
           

data/lib/ctioga2/graphics/elements/style-lists.rb

@@ -241,7 +241,7 @@ module CTioga2
 
           tdy = txt_dy + box_dy
 
-          sets = Styles::CurveStyleFactory::parameters['line_color'].sets
+          sets = Styles::CurveStyleFactory::parameters['color'].sets
           
           set_names = sets.keys.sort
 
@@ -306,7 +306,7 @@ module CTioga2
 
           tdy = txt_dy + box_dy
 
-          sets = Styles::CurveStyleFactory::parameters['marker_marker'].sets
+          sets = Styles::CurveStyleFactory::parameters['marker'].sets
           
           set_names = sets.keys.sort
 

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

@@ -46,8 +46,8 @@ module CTioga2
         # as #real_do hasn't been entered into.
         attr_accessor :computed_boundaries
 
-        def initialize(parent, root, style)
-          super(parent, root)
+        def initialize(parent, root, opts)
+          super(parent, root, opts)
 
           @subframe = Types::MarginsBox.new("2.8dy", "2.8dy", 
                                             "2.8dy", "2.8dy")
@@ -56,7 +56,7 @@ module CTioga2
 
           @prev_subframe = nil
 
-          @style = style || Styles::PlotStyle.new
+          @style = Styles::PlotStyle.new(self)
 
           @user_boundaries = {}
 

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

@@ -30,12 +30,13 @@ module CTioga2
           'xextent' => 'float',
           'yextent' => 'float',
           'nbavg'  =>  'integer',
-          'base-style' => 'text'
-        }.update(Styles::ArrowStyle::options_hash)
+        } # .update(Styles::ArrowStyle::options_hash)
 
         TiogaPrimitiveCall.
-          primitive("tangent", "tangent", [ 'data-point'],
-                    TangentOptions) do |t, point,options|
+          styled_primitive("tangent", "tangent", [ 'data-point'],
+                           Styles::ArrowStyle,
+                           'arrow', [],
+                           TangentOptions) do |t, point,style,options|
           options ||= {}
           nb = options['nbavg'] || 7
           x = point.x_val(nb)
@@ -81,10 +82,6 @@ module CTioga2
             options['color'] = $last_curve_style.line.color
           end
 
-          st_name = options['base-style'] || "base"
-          style = Styles::StyleSheet.style_for(Styles::ArrowStyle ,st_name)
-          style.set_from_hash(options)
-
           coords = options['tail'] + options['head']
           style.draw_arrow(t, *coords)
         end

data/lib/ctioga2/graphics/generator.rb

@@ -85,6 +85,7 @@ module CTioga2
           plot.style.apply_transforms!(dataset)
         end
 
+        old_opts = options.dup
         # Now, we trim options unrelated to the plotting
         options.delete_if { |k,v|
           ! Graphics::Styles::
@@ -99,6 +100,15 @@ module CTioga2
                                   # over the one specified by
                                   # --legend.
           curve = send(@current_curves, dataset, style)
+
+          # Here, we update the style from the stylesheet and then
+          # again from the options, so that the options provided on
+          # the command-line take precedence.
+          curve.setup_style(plot, old_opts)
+          curve.update_style(curve.curve_style)
+          curve.curve_style.
+            set_from_hash(@style_factory.hash_name_to_target(options))
+
           curve.curve_style.target = curve
         end
         return curve

data/lib/ctioga2/graphics/geometry.rb

@@ -0,0 +1,96 @@
+# geometry.rb: various geometry-related utility classes
+# copyright (c) 2014 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
+
+  # This module contains all graphical elements of CTioga2
+  module Graphics
+
+
+    # A geometry line, ie something that has a starting point and a
+    # direction. It is infinite
+    class Line
+
+      # Checks if within the bounds of the line (but not necessarily
+      # ON the line)
+      def within_bounds?(x, y)
+        return true
+      end
+
+      attr_accessor :x, :y, :dx, :dy
+
+      def initialize(x, y, dx, dy)
+        @x = x.to_f
+        @y = y.to_f
+        @dx = dx.to_f
+        @dy = dy.to_f
+      end
+
+      # Returns the X and Y positions of the intersection with the
+      # given Line, or false should there be none.
+      def intersection(line)
+        fact = @dx * line.dy - line.dx * @dy
+        rhs =  @dy * (line.x - @x) - @dx * (line.y - @y)
+        if fact != 0            # There is a unique intersection
+          beta = rhs/fact
+          nx = line.x + beta * line.dx
+          ny = line.y + beta * line.dy
+        # elsif rhs == 0
+        #   # Infinite, we return 
+        #   return 
+        else
+          return false
+        end
+        return [nx, ny] if (within_bounds?(nx, ny) and 
+                            line.within_bounds?(nx, ny))
+        return false
+      end
+    end
+
+    # Same as line, but with a beginning and an end
+    class Segment < Line
+
+      attr_accessor :x2, :y2
+
+      def initialize(x1, y1, x2, y2)
+        @x2 = x2
+        @y2 = y2
+        super(x1, y1, x2 - x1, y2 - y1)
+      end
+
+
+      def within_bounds?(x, y)
+        return (
+                (
+                 (x - @x) * (x - @x2) <= 0 or
+                 (x - @x).abs < 1e-15 or
+                 (x - @x2).abs < 1e-15
+                 ) and 
+                ((y - @y) * (y - @y2) <= 0 or
+                 (y - @y).abs < 1e-15 or
+                 (y - @y2).abs < 1e-15
+                 )
+                )
+      end
+
+      def to_line()
+        return Line.new(@x, @y, @dx, @dy)
+      end
+    end
+  end
+
+end
+

data/lib/ctioga2/graphics/legends.rb

@@ -96,11 +96,13 @@ they have the same meaning as corresponding ones of
 {command: define-box-style} with the @frame-@ bit dropped.
 EOH
 
+    opts = LegendStyleOptions
+    opts.merge!(Elements::TiogaElement::StyleBaseOptions)
     LegendInsideCommand = 
       Cmd.new("legend-inside", nil, "--legend-inside",
               [ CmdArg.new('aligned-point')],
-              LegendStyleOptions) do |plotmaker, point, options|
-      l = Legends::LegendArea.new(:inside)
+              opts) do |plotmaker, point, options|
+      l = Legends::LegendArea.new(:inside, plotmaker.root_object.current_plot, options)
       l.legend_position = point
       plotmaker.root_object.current_plot.legend_area = l
       l.legend_style.set_from_hash(options)

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

@@ -35,8 +35,11 @@ module CTioga2
       #   @legend_area for the current Elements::Container, with the
       #   given position.
       #
-      # \todo make a subclass for a top-level area ???? 
-      class LegendArea
+      # \todo make a subclass for a top-level area ????
+      #
+      # This class is a subclass of Elements::TiogaElement so that it
+      # can be styled just like the rest.
+      class LegendArea < Elements::TiogaElement
 
         # The style of the LegendStorage, a Styles::LegendStorageStyle
         # object (of course)
@@ -44,14 +47,19 @@ module CTioga2
 
         # The type of the legend. Can be :left, :right, :top, :bottom
         # or :inside
+        #
+        # @todo Should this move inside the style ? 
         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
+        define_style 'legend', Styles::LegendStorageStyle
+
+        def initialize(type = :right, parent = nil, opts = {})
+          setup_style(parent, opts)
+          @legend_style = get_style()
           @legend_type = type
           @legend_position = Types::AlignedPoint.new(0.5,0.5,:frame)
         end

data/lib/ctioga2/graphics/root.rb

@@ -48,7 +48,7 @@ module CTioga2
 
         @container_stack = []
 
-        @legend_area = Legends::LegendArea.new
+        @legend_area = Legends::LegendArea.new(:right, nil, {'class' => 'root'})
 
         @count_legend_in_page = false
         #     @count_legend_in_page = true
@@ -67,15 +67,17 @@ module CTioga2
         if @current_container
           return @current_container
         else
-          subplot = Elements::Subplot.new(nil, self, nil)
+          subplot = Elements::Subplot.new(nil, self, 
+                                          {'id' => 'root' })
           enter_subobject(subplot)
           return subplot
         end
       end
 
-      # Enters into a new Elements::Container, _new_object_.
-      def enter_subobject(new_object)
-        if @current_container
+      # Enters into a new Elements::Container, _new_object_, and adds
+      # it to the current container, unless _add_ is false.
+      def enter_subobject(new_object, add = true)
+        if @current_container && add
           @current_container.add_element(new_object)
         end
         @current_container = new_object
@@ -135,33 +137,33 @@ module CTioga2
       #
       # For the sake of convenience, returns the newly created
       # Elements::Subplot
-      def subplot()
+      def subplot(opts)
         if ! @current_container
-          enter_subobject(Elements::Container.new(nil, self))
+          enter_subobject(Elements::Container.new(nil, self, {}))
         end
-        subplot = Elements::Subplot.new(@current_container, self, nil)
+        subplot = Elements::Subplot.new(@current_container, self, opts)
         enter_subobject(subplot)
         return subplot
       end
 
       # This function is the companion of #subplot, but for Region
       # objects. Returns the newly created Region.
-      def enter_region
+      def enter_region(opts)
         if ! @current_container
-          subplot
+          subplot({})
         end
-        region = Elements::Region.new(@current_container, self)
+        region = Elements::Region.new(@current_container, self, opts)
         enter_subobject(region)
         return region
       end
 
       # This function is the companion of #subplot, but for GradientRegion
       # objects. Returns the newly created GradientRegion
-      def enter_gradient
+      def enter_gradient(opts)
         if ! @current_container
-          subplot
+          subplot({})
         end
-        region = Elements::GradientRegion.new(@current_container, self)
+        region = Elements::GradientRegion.new(@current_container, self, opts)
         enter_subobject(region)
         return region
       end

data/lib/ctioga2/graphics/styles.rb

@@ -14,6 +14,7 @@
 require 'ctioga2/graphics/styles/base'
 
 require 'ctioga2/graphics/styles/drawable'
+require 'ctioga2/graphics/styles/fill'
 require 'ctioga2/graphics/styles/arrows'
 require 'ctioga2/graphics/styles/box'
 require 'ctioga2/graphics/styles/location'
@@ -31,6 +32,8 @@ require 'ctioga2/graphics/styles/errorbar'
 require 'ctioga2/graphics/styles/sets'
 require 'ctioga2/graphics/styles/ticks'
 
+require 'ctioga2/graphics/styles/curve'
+
 require 'ctioga2/graphics/styles/axes'
 require 'ctioga2/graphics/styles/map-axes'
 require 'ctioga2/graphics/styles/background'
@@ -39,9 +42,9 @@ require 'ctioga2/graphics/styles/plot'
 require 'ctioga2/graphics/styles/legend'
 
 
-require 'ctioga2/graphics/styles/curve'
 
 require 'ctioga2/graphics/styles/factory'
 
 # Style sheets
-require 'ctioga2/graphics/styles/sheet'
+require 'ctioga2/graphics/styles/stylesheet'
+require 'ctioga2/graphics/styles/styles'

data/lib/ctioga2/graphics/styles/arrows.rb

@@ -41,6 +41,11 @@ module CTioga2
           dict.rename_key('style', 'line_style')
           dict['head'] = [x2,y2]
           dict['tail'] = [x1,y1]
+          for w in %w(head tail)
+            if dict["#{w}_marker"] == false
+              dict["#{w}_marker"] = "None"
+            end
+          end
           t.show_arrow(dict)
         end
 

data/lib/ctioga2/graphics/styles/axes.rb

@@ -146,7 +146,7 @@ minor_tick_length minor_tick_width)
                          end
           t.show_axis(spec)
           # Now, we draw axis ticks
-          if type == Tioga::FigureConstants::AXIS_WITH_MAJOR_TICKS_AND_NUMERIC_LABELS || type == Tioga::FigureConstants::AXIS_WITH_TICKS_AND_NUMERIC_LABELS
+          if (type == Tioga::FigureConstants::AXIS_WITH_MAJOR_TICKS_AND_NUMERIC_LABELS) || (type == Tioga::FigureConstants::AXIS_WITH_TICKS_AND_NUMERIC_LABELS)
 
             fnc = info['vertical'] ? :convert_figure_to_frame_y : :convert_figure_to_frame_x
             stl = @tick_label_style.dup

data/lib/ctioga2/graphics/styles/base.rb

@@ -23,13 +23,53 @@ module CTioga2
 
       # This style is the base class of a series of style objects that
       # share one common feature: all their attributes can be set
-      # using the set_from_hash function.
+      # using the #set_from_hash function.
       class BasicStyle
 
         OldAttrAccessor = method(:attr_accessor)
 
         AllStyles = []
 
+        # Returns the list of valid aliases, including those defined
+        # in parent classes.
+        def self.aliases
+          ret = if superclass.respond_to? :aliases
+                  superclass.aliases
+                else
+                  {}
+                end
+          if @aliases
+            ret.merge!(@aliases)
+          end
+          return ret
+        end
+
+        def self.normalize_in(name, fmt = "%s")
+          name = name.to_s.downcase.gsub('-', '_')
+          als = self.aliases
+          if als
+            for k, v in als
+              if fmt % k == name
+                name = fmt % v
+                break
+              end
+            end
+          end
+          return name
+        end
+
+        def self.normalize_out(name)
+          return name.gsub('_', '-')
+        end
+
+        def self.normalize_hash(hsh, fmt = "%s")
+          ret = {}
+          for k,v in hsh
+            ret[normalize_in(k, fmt)] = v
+          end
+          return ret
+        end
+
         def self.inherited(cls)
           AllStyles << cls
         end
@@ -57,6 +97,10 @@ module CTioga2
             end
         end
 
+        def self.defined_aliases
+          return @aliases || {}
+        end
+
         # Returns the type of all attributes (chaining to the parent
         # when applicable)
         def self.attribute_types
@@ -84,29 +128,31 @@ module CTioga2
         def self.typed_attribute(symbol, type)
           sym = symbol.to_sym
           self.attr_accessor(sym)
-          type = CmdArg.new(type) unless type.respond_to? :string_to_type
+          # The unless type.respond_to? :string_to_type seems
+          type = CmdArg.new(type) # unless type.respond_to? :string_to_type
           @attribute_types ||= {}
           @attribute_types[sym] = type
           return type
         end
 
         # Define an attribute to be the alias for something else.
-        def self.alias_for(symbol, target)
-          target = target.to_sym
-          if ! @attribute_types[target]
-            raise "Declaring alias #{symbol} for unexisting target #{target}"
+        #
+        # @todo Maybe make multiple aliases ?
+        def self.alias_for(what, target, define_methods = false)
+          target = self.normalize_in(target)
+          what = self.normalize_in(what)
+          @aliases ||= {}
+          @aliases[what] = target
+          if define_methods
+            alias_method what.to_sym, target.to_sym
+            alias_method "#{what}=".to_sym, "#{target}=".to_sym
           end
-          symbol = symbol.to_sym
-          @attribute_types[symbol] = @attribute_types[target]
-          @attributes << symbol
-          alias_method symbol, target
-          alias_method "#{symbol}=".to_sym, "#{target}=".to_sym
         end
 
         # Returns the type of an attribute, or _nil_ if there is no
         # attribute of that name. Handles sub-styles correctly.
         def self.attribute_type(symbol, fmt = "%s")
-          name = symbol.to_s
+          name = self.normalize_in(symbol.to_s, fmt)
 
           for k,v in attribute_types
             if (fmt % k.to_s) == name
@@ -122,7 +168,7 @@ module CTioga2
             for sub in @sub_styles
               sym, cls, fmt2, fc = *sub
               f = fmt % fmt2
-              ret = cls.attribute_type(symbol, f)
+              ret = cls.attribute_type(name, f)
               return ret if ret
             end
           end
@@ -179,6 +225,16 @@ module CTioga2
             end
           end
 
+          # And now we expand options
+          if @aliases
+            for k, v in @aliases
+              v =  key % v
+              if ret.key?(v)
+                ret[key % k] = ret[v]
+              end
+            end
+          end
+
           return ret
         end
 
@@ -201,6 +257,7 @@ module CTioga2
         # This function returns the number of properties that were
         # effectively set (including those set in sub-styles)
         def set_from_hash(hash, name = "%s")
+          hash = self.class.normalize_hash(hash, name)
           nb_set = 0
           for key_name in self.class.attributes
             hash_key = name % key_name
@@ -256,11 +313,16 @@ module CTioga2
         end
 
         # Converts to a hash. Does the reverse of #set_from_hash.
+        #
+        # _nil_ values get stripped off (but not false values, of course).
         def to_hash(name = "%s")
           retval = {}
           for attr in self.class.attributes
             if instance_variable_defined?("@#{attr}")
-              retval[name % attr] = instance_variable_get("@#{attr}")
+              val = instance_variable_get("@#{attr}")
+              if ! val.nil?
+                retval[name % attr] = val
+              end
             end
           end
           return retval
@@ -271,6 +333,25 @@ module CTioga2
           set_from_hash(other_object.to_hash)
         end
 
+        # Converts a hash in text format into a format suitable for
+        # feeding to #set_from_hash. Only relevant keys are
+        # converted. Keys that exist in the options hash but are not
+        # Strings are left untouched
+        def self.convert_string_hash(opts, key = "%s")
+          cnv = self.options_hash(key)
+          
+          ret = {}
+          for k,v in opts
+            if cnv.key? k
+              if v.is_a? String
+                ret[k] = cnv[k].type.string_to_type(v)
+              else
+                ret[k] = v
+              end
+            end
+          end
+          return ret
+        end
       end
     end
   end