ctioga2 0.10.1 → 0.11

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

@@ -31,9 +31,15 @@ module CTioga2
         # The style of the line that is drawn, as a StrokeStyle. 
         sub_style :line, StrokeStyle
 
+        alias_for :color, :line_color
+
         # The style of markers that should be drawn, as a MarkerStyle.
         sub_style :marker, MarkerStyle
 
+
+        # Would have been nice, but that's a stupid idea, isn't it ?
+        alias_for :marker, :marker_marker
+
         # The text of the legend, if there is one.
         typed_attribute :legend, 'text'
 
@@ -43,6 +49,8 @@ module CTioga2
         # Filling of the curve, if applicable
         sub_style :fill, CurveFillStyle
 
+        alias_for :fill, :fill_close_type
+
         # Details of the location of the curve, a LocationStyle object.
         sub_style :location, LocationStyle, nil, true
 

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

@@ -59,6 +59,40 @@ module CTioga2
 
       end
 
+      # This class represents all the stylistic information necessary
+      # to draw a line parallel to a certain direction, indicated by
+      # an angle (default to horizontal)
+      class OrientedLineStyle < StrokeStyle
+        # The angle, in degrees.
+        typed_attribute :angle, 'float'
+
+        # The alignment of the line with respect to the point given.
+        typed_attribute :origin, 'justification'
+
+        # len is a dimension
+        def draw_oriented_line(t, xo, yo, len)
+
+          angle = @angle || 0.0
+
+          dx,dy = *len.to_figure(t, angle)
+
+          case @origin || Tioga::FigureConstants::LEFT_JUSTIFIED
+          when Tioga::FigureConstants::LEFT_JUSTIFIED
+            x1, y1 = xo, yo
+            x2, y2 = xo + dx, yo + dy
+          when Tioga::FigureConstants::CENTERED
+            x1, y1 = xo - 0.5 * dx, yo - 0.5 * dy
+            x2, y2 = xo + 0.5 * dx, yo + 0.5 * dy
+          when Tioga::FigureConstants::RIGHT_JUSTIFIED
+            x1, y1 = xo - dx, yo - dy
+            x2, y2 = xo, yo
+          end
+
+          draw_line(t, x1, y1, x2, y2)
+        end
+        
+      end
+
       # This class represents all the stylistic information to draw a
       # Marker.
       #
@@ -82,6 +116,7 @@ module CTioga2
         # \p override is a hash that can override part of the
         # dictionnary specification.
         def draw_markers_at(t, x, y, override = nil)
+          return if (! @marker || @marker == 'None')
           t.context do
             ## \todo allow custom line types for markers ?
             t.line_type = LineStyles::Solid
@@ -108,54 +143,6 @@ module CTioga2
         end
       end
 
-      # A style that handles drawing a fill.
-      #
-      # \todo add ways to specify complex fills, such as patterned
-      # fills and so on. Those would use clipping the path and base
-      # themselves on the coordinates of the current frame -- or more
-      # nicely use dimensions ? (which would allow to mix both to some
-      # extent ?)
-      #
-      # \todo more attributes ?
-      #
-      # @todo This class should also provide image-based fills, with
-      # CSS-like capacities (scaling, tiling, centering, and so on...)
-      class FillStyle < BasicStyle
-
-        # The color.
-        typed_attribute :color, "color"
-
-        # The transparency
-        typed_attribute :transparency, 'float'
-
-        # Sets up the parameters for the fill. Must be called before
-        # any path drawing.
-        #
-        # \warning You *must* call FillStyle#do_fill for
-        # filling. Directly calling FigureMaker#fill is not a good
-        # idea, as you lose all 'hand-crafted' fills !
-        def setup_fill(t)
-          t.fill_color = @color if @color
-          t.fill_transparency = @transparency if @transparency
-        end
-
-        # Does the actual filling step. Must be used within a context,
-        # as it quite messes up with many things. Must be called after
-        # a call to #setup_fill.
-        def do_fill(t)
-          t.fill
-        end
-
-      end
-
-      # Same as FillStyle, but with additional parameters that handle
-      # how the fill should be applied to curves.
-      class CurveFillStyle < FillStyle
-
-        typed_attribute :close_type, 'fill-until'
-        
-      end
-
     end
   end
 end

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

@@ -148,9 +148,9 @@ module CTioga2
 
         # A simple parameter is something whose target defines all, ie
         # only the name and a documentation text is necessary.
-        def self.simple_parameter(target, text, sets = nil)
+        def self.simple_parameter(target, text, sets = nil, short = nil)
           name = target.gsub(/_/, '-')
-          define_parameter(target, name, sets, text, nil)
+          define_parameter(target, name, sets, text, short)
         end
 
         # Returns the Hash containing the class parameters.
@@ -242,7 +242,7 @@ module CTioga2
           # Overrides as in the first ctioga
           @override_parameters = {
             'line_style' => LineStyles::Solid,
-            'marker_marker' => false,
+            'marker' => false,
             'marker_scale' => 0.5,
             'fill_color' => '=color'.to_sym,
             'error_bar_color' => '=marker_color'.to_sym
@@ -320,16 +320,14 @@ module CTioga2
         # Now, the parameters:
 
         # Lines:
-        define_parameter 'line_color', 'color', 
-        Sets::ColorSets, "line color", "-c"
+        simple_parameter 'color', "line color", Sets::ColorSets,  "-c"
 
         simple_parameter 'line_width', 'line width', Sets::LineWidthSets
 
         simple_parameter 'line_style', 'line style', Sets::LineStyleSets
 
         # Markers
-        define_parameter 'marker_marker', 'marker', 
-        Sets::MarkerSets, "marker", '-m'
+        simple_parameter  'marker', 'marker', Sets::MarkerSets, '-m'
 
         simple_parameter 'marker_color', "marker color", Sets::ColorSets
 
@@ -349,11 +347,12 @@ module CTioga2
         nil, "Y axis", nil, true
 
         # Now, fill style
-        define_parameter 'fill_close_type', 'fill', 
-        {}, "Fill until", nil
+        simple_parameter 'fill', 'Fill until', {}
 
         simple_parameter 'fill_color', "fill color", Sets::ColorSets
 
+        simple_parameter 'fill_pattern', "fill pattern", nil
+
         simple_parameter 'clipped', "clipped", nil
 
         simple_parameter 'depth', "depth", nil
@@ -396,6 +395,21 @@ module CTioga2
         # plot command.
         PlotCommandOptions = plot_optional_arguments
 
+        # Converts the one-time parameters, which is a hash whose keys
+        # are the names of the parameters to targets.
+        def hash_name_to_target(h)
+          retval = {}
+          convert = self.class.name_to_target
+          for k,v in h
+            if convert.key? k 
+              retval[convert[k]] = v
+            else
+              warn { "Unkown key for hash_name_to_target: #{k}" }
+            end
+          end
+          return retval
+        end
+
         protected
 
         # Returns the CurveFactoryParameterType object corresponding
@@ -413,20 +427,6 @@ module CTioga2
           return self.class.parameters
         end
 
-        # Converts the one-time parameters, which is a hash whose keys
-        # are the names of the parameters to targets.
-        def hash_name_to_target(h)
-          retval = {}
-          convert = self.class.name_to_target
-          for k,v in h
-            if convert.key? k 
-              retval[convert[k]] = v
-            else
-              warn { "Unkown key for hash_name_to_target: #{k}" }
-            end
-          end
-          return retval
-        end
 
         # Resolve potential links in the form of :=stuff within the
         # given hash, and returns a new version of the hash.

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

@@ -0,0 +1,268 @@
+# fill.rb: fill styles
+# 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'
+
+require 'ctioga2/graphics/geometry'
+require 'ctioga2/graphics/types/dimensions'
+
+# This module contains all the classes used by ctioga
+module CTioga2
+
+  module Graphics
+
+    # All the styles
+    module Styles
+
+
+      # This class handles drawing the pattern in a fill.
+      #
+      # It is a base class.
+      #
+      # Add transparency !
+      class FillPattern
+
+        # Draws the pattern over the whole output, with primary color
+        # _color_ and secondary color _secondary_ (not implemented
+        # yet).
+        #
+        # This does nothing. Derived classes do the job
+        def do(t, color, secondary = nil)
+        end
+
+        def self.from_text(str)
+          els = str.split(/\s*:\s*/)
+          args = []
+          if els.size > 1
+            args = els[1].split(/\s*,\s*/)
+          end
+          
+          case els[0]
+          when /^hlines$/i
+            return SingleLineFillPattern.new(0, *args)
+          when /^vlines$/i
+            return SingleLineFillPattern.new(90, *args)
+          when /^lines$/i
+            return SingleLineFillPattern.new(*args)
+          when /^xlines$/i
+            return CrossedLinesFillPattern.new(*args)
+          when /^(solid|plain)$/i
+            return false
+          end
+        end
+      end
+
+      FillPatternType = 
+        CmdType.new('fill-pattern', { 
+                      :type => :function_based,
+                      :class => Graphics::Styles::FillPattern
+                    }, <<EOD)
+A fill pattern, one of:
+ * @lines@:_angle_,_distance_,_width_
+ * @vlines@:_distance_,_width_
+ * @hlines@:_distance_,_width_
+ * @xlines@:_distance_,_width_,_angle_
+ * @solid@ or @plain@
+
+The first three are lines, of arbitrary orientation for @lines@,
+vertical for @vlines@ and horizontal for @hlines@. @xlines@ correspond
+to crossed perpendicular lines (the _angle_ is 45 by default). For
+these styles, the _distance_ and _width_ are all optional and
+correspond respectively to the distance between the lines and the line
+width.
+
+@solid@ or @plain@ correspond to solid fill (i.e. not patterned).
+EOD
+
+      # @
+      class SingleLineFillPattern
+
+        # Line width (in line widths units ?)
+        attr_accessor :line_width
+
+        # Separation between the lines, a dimension
+        attr_accessor :distance
+
+        # Angle of the lines
+        attr_accessor :angle
+
+        def initialize(an = 0,dst = nil, lw = nil)
+          @distance = if dst
+                        if dst.is_a? Types::Dimension
+                          dst
+                        else
+                          Types::Dimension::from_text(dst, :x, :bp)
+                        end
+                      else
+                        Types::Dimension.new(:bp, 5)
+                      end
+          @line_width = lw ? lw.to_f : 0.8
+          @angle = an.to_f
+        end
+
+        def do(t, color, secondary = nil)
+          # Secondary is not used
+
+          t.context do
+            t.stroke_color = color
+            t.line_width = @line_width
+            # Make figure coordinates page coordinates
+            t.set_bounds([t.convert_frame_to_page_x(0),
+                          t.convert_frame_to_page_x(1),
+                          t.convert_frame_to_page_y(1),
+                          t.convert_frame_to_page_y(0)])
+
+            # Now we can work
+            dx = -@distance.to_figure(t, :x) * 
+              Math.sin(Math::PI/180 * @angle)
+            sx = @distance.to_figure(t, :x) * 
+              Math.cos(Math::PI/180 * @angle)
+            dy = @distance.to_figure(t, :y) * 
+              Math.cos(Math::PI/180 * @angle)
+            sy = @distance.to_figure(t, :y) * 
+              Math.sin(Math::PI/180 * @angle)
+
+            if dy < 0
+              dy = -dy
+              dx = -dx
+            end
+
+            if dx.abs < 1e-12          # Horizontal lines
+              y = 0
+              while y <= 1
+                t.stroke_line(0, y, 1, y)
+                y += dy
+              end
+            elsif dy.abs < 1e-12
+              x = 0
+              dx = dx.abs
+              while x <= 1
+                t.stroke_line(x, 0, x, 1)
+                x += dx
+              end
+            else
+              if dx > 0
+                line = Line.new(0, 0, sx, sy)
+              else
+                line = Line.new(1, 0, sx, sy)
+              end
+              segs = [ Segment.new(0,0,1,0), Segment.new(1,0,1,1),
+                       Segment.new(1,1,0,1), Segment.new(0,1,0,0)]
+              while true
+                ints = []
+                for s in segs
+                  v = s.intersection(line)
+                  ints << v if v 
+                end
+                if ints.size == 0
+                  break
+                elsif ints.size == 2
+                  t.stroke_line(ints[0][0], ints[0][1],
+                                ints[1][0], ints[1][1])
+                elsif ints.size == 3
+                  # Rare case but must be handled anyway
+                  if ints[0][0] == ints[1][0]
+                    ints.shift
+                  end
+                  t.stroke_line(ints[0][0], ints[0][1],
+                                ints[1][0], ints[1][1])
+                end
+                line.x += dx
+                line.y += dy
+              end
+            end
+          end
+          
+        end
+      end
+
+
+      class CrossedLinesFillPattern
+
+        def initialize(dst1 = nil, lw1 = nil, angle = 45, 
+                       dst2 = nil, lw2 = nil, dangle = 90)
+          @first = SingleLineFillPattern.new(angle, dst1, lw1)
+          @second = SingleLineFillPattern.new(@first.angle + dangle.to_f, 
+                                              dst2 || dst1, lw2 || lw1)
+        end
+
+
+        def do(t, color, secondary = nil)
+          @first.do(t, color)
+          @second.do(t, secondary || color)
+        end
+      end
+
+      # A style that handles drawing a fill.
+      #
+      # \todo add ways to specify complex fills, such as patterned
+      # fills and so on. Those would use clipping the path and base
+      # themselves on the coordinates of the current frame -- or more
+      # nicely use dimensions ? (which would allow to mix both to some
+      # extent ?)
+      #
+      # \todo more attributes ?
+      #
+      # @todo This class should also provide image-based fills, with
+      # CSS-like capacities (scaling, tiling, centering, and so on...)
+      class FillStyle < BasicStyle
+
+        # The color.
+        typed_attribute :color, "color"
+
+        # The transparency
+        typed_attribute :transparency, 'float'
+
+        # The fill pattern
+        typed_attribute :pattern, "fill-pattern"
+
+        # Sets up the parameters for the fill. Must be called before
+        # any path drawing.
+        #
+        # \warning You *must* call FillStyle#do_fill for
+        # filling. Directly calling FigureMaker#fill is not a good
+        # idea, as you lose all 'hand-crafted' fills !
+        def setup_fill(t)
+          if ! @pattern
+            t.fill_color = @color if @color
+            t.fill_transparency = @transparency if @transparency
+          end
+        end
+
+        # Does the actual filling step. Must be used within a context,
+        # as it quite messes up with many things. Must be called after
+        # a call to #setup_fill.
+        def do_fill(t)
+          if @pattern  && @color
+            t.clip
+            @pattern.do(t, @color)
+          else
+            t.fill
+          end
+        end
+
+      end
+
+      # Same as FillStyle, but with additional parameters that handle
+      # how the fill should be applied to curves.
+      class CurveFillStyle < FillStyle
+
+        typed_attribute :close_type, 'fill-until'
+        
+      end
+
+    end
+  end
+end
+