ctioga2 0.0 → 0.1

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

@@ -0,0 +1,172 @@
+# -*- coding: undecided -*-
+# parametric2d.rb: a 2D curve whose parameters depend on Z values
+# copyright (c) 2006, 2007, 2008, 2009, 2010 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 'Dobjects/Function'
+
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 229 $', '$Date: 2011-01-17 17:34:57 +0100 (Mon, 17 Jan 2011) $')
+
+  module Graphics
+
+    module Elements
+
+      # This class represents a 3D (or more, to be seen later) dataset
+      # as markers with various parameters parametrized (color,
+      # transparency, marker scale, marker type (discrete), possibly
+      # stroke and fill colors ?
+      #
+      # @todo What would be interesting here would be to have indexed
+      # plots, ie draw one curve for each value of Z, with a color
+      # indexed by Z.
+      class Parametric2D  < TiogaElement
+
+        include Log
+        include Dobjects
+
+        # The Data::Dataset object that should get plotted.
+        attr_accessor :dataset
+
+        # A Styles::CurveStyle object saying how the curve should be
+        # drawn.
+        #
+        # Some of the elements will be overridden.
+        attr_accessor :curve_style
+
+        # For convenience only: xy functions
+        attr_accessor :function
+
+        # A hash Z value -> corresponding XY functions.
+        attr_accessor :planes
+
+
+
+        undef :location=, :location
+        
+        # Creates a new Curve2D object with the given _dataset_ and
+        # _style_.
+        def initialize(dataset, style = nil)
+          @dataset = dataset
+          @curve_style = style
+          prepare_data
+        end
+
+        # Prepares the internal storage of the data, from the @dataset
+        def prepare_data
+          @function = Function.new(@dataset.x.values.dup, 
+                                   @dataset.y.values.dup)
+
+          ## @todo this should eventually use Dataset::index_on_cols.
+          @planes = {}
+          @dataset.each_values do |i, x,y,*zs|
+            @planes[zs[0]] ||= Function.new(Dvector.new, Dvector.new)
+            @planes[zs[0]].x << x
+            @planes[zs[0]].y << y
+          end
+        end
+        
+        protected :prepare_data
+
+        # Returns the LocationStyle object of the curve. Returns the
+        # one from #curve_style.
+        def location
+          return @curve_style.location
+        end
+
+        # Returns the Types::Boundaries of this curve.
+        def get_boundaries
+          return Types::Boundaries.bounds(@function.x, @function.y)
+        end
+
+        # Draws the markers, if applicable.
+        def draw_path(t)
+          min = @dataset.z.values.min
+          max = @dataset.z.values.max
+          if @curve_style.has_line?
+            # We use a default color map for the lines
+            @curve_style.color_map ||= 
+              Styles::ColorMap.from_text("Red--Green")
+            cmap = @curve_style.color_map
+
+            for zs in @planes.keys.sort ## \todo have the sort
+                                        ## direction configurable.
+              f = @planes[zs]
+              color = cmap.z_color(zs, min, max)
+              t.context do 
+                @curve_style.line.set_stroke_style(t)
+                t.stroke_color = color
+                t.show_polyline(f.x, f.y)
+              end
+            end
+          end
+        end
+
+
+        # Draws the markers, if applicable.
+        def draw_markers(t)
+          min = @dataset.z.values.min
+          max = @dataset.z.values.max
+          if @curve_style.has_marker?
+            # We use a default color map for the markers
+            @curve_style.marker_color_map ||= 
+              Styles::ColorMap.from_text("Red--Green")
+            cmap = @curve_style.marker_color_map
+            for zs in @planes.keys.sort ## \todo have the sort
+                                        ## direction configurable.
+              f = @planes[zs]
+              color = cmap.z_color(zs, min, max)
+              @curve_style.marker.draw_markers_at(t, f.x, f.y, 
+                                                  { 'color' => color})
+            end
+          end
+        end
+        
+        ## Actually draws the curve
+        def real_do(t)
+          debug { "Plotting curve #{inspect}" }
+          t.context do
+            ## \todo allow customization of the order of drawing,
+            ## using a simple user-specificable array of path,
+            ## markers... and use the corresponding #draw_path or
+            ## #draw_markers... Ideally, any string could be used, and
+            ## warnings should be issued on missing symbols.
+
+            # draw_fill(t)
+            # draw_errorbars(t)
+            draw_path(t)
+            draw_markers(t)
+
+            if @curve_style.zaxis
+              begin
+                @parent.style.get_axis_style(@curve_style.zaxis).
+                  set_color_map(@curve_style.marker_color_map, 
+                                @dataset.z.values.min,
+                                @dataset.z.values.max)
+              rescue
+                error { "Could not set Z info to non-existent axis #{@curve_style.zaxis}" }
+              end
+            end
+
+            # draw_error_bars(t) ??
+          end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ 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) $')
+  Version::register_svn_info('$Revision: 151 $', '$Date: 2010-06-19 23:45:20 +0200 (Sat, 19 Jun 2010) $')
 
   module Graphics
 
@@ -54,6 +54,7 @@ module CTioga2
             @optional_arguments = opts
             @funcall = code
           end
+
         end
 
         # A TiogaPrimitive object describing the current primitive
@@ -65,6 +66,9 @@ module CTioga2
         # A hash containing the values of the optional arguments
         attr_accessor :options
 
+        # The last curve's style... 
+        attr_accessor :last_curve_style
+
 
         # Creates a new TiogaPrimitiveCall object.
         def initialize(primitive, arguments, options)
@@ -103,6 +107,7 @@ module CTioga2
             call = Elements::
               TiogaPrimitiveCall.new(primitive,
                                      rest, options)
+            call.last_curve_style = plotmaker.curve_style_stack.last
             plotmaker.root_object.current_plot.
               add_element(call)
           end
@@ -128,16 +133,21 @@ module CTioga2
                     'angle' => 'float',
                     'justification' => 'justification',
                     'alignment' => 'alignment',
+                    'font' => 'latex-font',
                   }
                   ) do |t, point, string, options|
-          # TODO: add a way to specify fonts ???
+          # @todo add a way to specify fonts ???
           options ||= {}
+          if options['font']
+            string = options['font'].fontify(string)
+            options.delete('font')
+          end
           options['text'] = string
           options['at'] = point.to_figure_xy(t)
           t.show_text(options)
         end
 
-        # TODO: add rendering mode !!
+        # @todo add rendering mode !!
         MarkerOptions = {
           'color' => 'color',
           'stroke_color' => 'color',
@@ -152,7 +162,7 @@ module CTioga2
 
         primitive("marker", "marker", [ 'point', 'marker' ],
                   MarkerOptions) do |t, point, marker, options|
-          # TODO: add a way to specify fonts ???
+          ## \todo add a way to specify fonts ???
           options ||= {}
           options['marker'] = marker
           options['at'] = point.to_figure_xy(t)
@@ -162,26 +172,30 @@ module CTioga2
         primitive("string-marker", "marker", [ 'point', 'text' ],
                   {'font' => 'pdf-font' }.update(MarkerOptions)
                   ) do |t, point, string, options|
-          # TODO: add a way to specify fonts ???
+          ## \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 for arrows (and therefore tangents)
+        ArrowOptions = {
+          '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',
+        }
+
+        primitive("arrow", "arrow", [ 'point', 'point' ], 
+                  ArrowOptions) do |t, tail,head, options|
+          ## \todo a scale or marker_scale option that sets the scale
+          ## of both head and tail
           options ||= {}
           options['head'] = head.to_figure_xy(t)
           options['tail'] = tail.to_figure_xy(t)
@@ -210,6 +224,9 @@ module CTioga2
         # Draws the primitive
         def real_do(t)
           args = @arguments + [@options]
+          ## @todo this is a really ugly hack for passing
+          ## last_curve_style around
+          $last_curve_style = @last_curve_style
           primitive.funcall.call(t, *args)
         end
         
@@ -219,7 +236,6 @@ 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|
@@ -235,12 +251,12 @@ EOD
               if a =~ /^\s*([^=]+)=(.*)/
                 opts[$1] = $2
               else
-                plotmaker.error "Argument found where a option= was expected: #{a}"
+                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}"
+            plotmaker.error { "Unkown graphics primitive: #{name}" }
           end
         end
 

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

@@ -0,0 +1,143 @@
+# region.rb: draw curves-delimited fills
+# copyright (c) 2010 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: 139 $', '$Date: 2010-01-22 00:12:17 +0100 (Fri, 22 Jan 2010) $')
+
+  module Graphics
+
+    module Elements
+
+      # A Region is an object that draws filled regions among its
+      # "elements". It is a fake container in the sense that all the
+      # elements are actually forwarded to the parent.
+      class Region < Container
+
+        undef :elements
+        undef :subframe
+
+        # The curves which delimit the region
+        attr_accessor :curves
+
+        # The fill style
+        attr_accessor :fill_style
+
+        # The fill style for reversed polarity
+        attr_accessor :reversed_fill_style
+
+        # Creates a new empty region
+        def initialize(parent = nil, root = nil)
+          @parent = parent
+          
+          # elements to be given to tioga
+          @curves = []
+
+          @root_object = root
+
+          @legend_area = nil
+
+          @fill_style = Styles::FillStyle.new
+          @fill_style.color = [0.7,0.7,0.7]
+
+          # For reversed polarity
+          @reversed_fill_style = Styles::FillStyle.new
+        end
+
+        # Adds an element. Actually forwards it to the parent.
+        def add_element(element)
+          parent.add_element(element)
+          if element.respond_to?(:curve_style)  &&
+              element.curve_style.region_position
+            @curves << element
+          end
+        end
+
+        # Sets the various things from hash.
+        def set_from_hash(hash)
+          @fill_style.set_from_hash(hash)
+          # Reversed isn't what I want...
+          @reversed_fill_style.set_from_hash(hash, 'reversed_%s')
+        end
+
+        # Redirects to the parent's style
+        def style(*a)
+          return parent.style(*a)
+        end
+
+        protected 
+
+        # Creates the appropriate subfigure and draws all its elements
+        # within.
+        #
+        # \todo: attempt to work fine while mixing curves with
+        # different axes. That won't be easy.
+        #
+        # \todo: enable to do positive and negative. The only thing to
+        # do is to swap above for below and call again.
+        def real_do(t)
+          # This function will be called with the proper figure
+          # coordinates.
+          
+          if @fill_style.color
+            t.context do
+              @fill_style.setup_fill(t)
+              prepare_path(t)
+              @fill_style.do_fill(t)
+            end
+          end
+
+          if @reversed_fill_style.color
+            t.context do
+              @reversed_fill_style.setup_fill(t)
+              prepare_path(t, :reversed)
+              @reversed_fill_style.do_fill(t)
+            end
+          end
+          
+        end
+
+        # Prepares the path that will be filled, according to the
+        # given polarity.
+        def prepare_path(t, polarity = :normal)
+          # We clip the path for the given
+          case polarity
+          when :normal
+            conversion = {
+              :above => :bottom,
+              :below => :top
+            }
+          when :reversed
+            conversion = {
+              :above => :top,
+              :below => :bottom
+            }
+          end
+          # We clip for the first ones...
+          for c in @curves[0..-2]
+            c.make_closed_path(t, conversion[c.curve_style.region_position])
+            t.clip
+          end
+          # We don't clip on the last one !
+          c = @curves.last
+          c.make_closed_path(t, conversion[c.curve_style.region_position])
+        end
+
+      end
+    end
+  end
+end