ctioga2 0.0 → 0.1

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

@@ -0,0 +1,272 @@
+# colormap.rb: a way to map values to colors
+# copyright (c) 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: 199 $', '$Date: 2010-11-30 00:48:26 +0100 (Tue, 30 Nov 2010) $')
+
+  module Graphics
+
+    module Styles
+
+
+      # A mapping Z values -> color.
+      #
+      # It can be a simple two-point gradient, but it can also be much
+      # more complex.
+      #
+      # Basically, a ColorMap is a series of colors with an optional Z
+      # value (taken as the average of the ones around if missing) + a
+      # color for above and a color for below.
+      #
+      # @todo For now, ColorMap relies on the intrisic tioga color
+      # map, but it would be interesting to implement that "by hand"
+      # for the case when a byte of resolution isn't enough (which are
+      # going to be rare, I think)
+      class ColorMap
+
+        # Z values
+        attr_accessor :values
+
+        # Corresponding colors
+        attr_accessor :colors
+
+        # Colors for points of Z value below and above the limit;
+        # _nil_ for no specific value, :mask for masking them out
+        #
+        # @todo These are currently not implemented.
+        attr_accessor :below, :above
+
+        # Whether the map follows RGB (true) or HLS (false). On by
+        # default.
+        #
+        # It does not change anything with respect to how the colors
+        # are interpreted: whatever happens, the values are RGB.
+        attr_accessor :rgb
+
+        def initialize(values = [], colors = [])
+          @values = values.dup
+          @colors = colors.dup
+
+          @rgb = true
+        end
+        
+        # Creates a ColorMap from a text specification of the kind:
+        # 
+        #  Red--Blue(1.0)--Green
+        #  
+        # The specification can optionally be surrounded by colors with ::
+        # 
+        #  Green::Red--Blue::Orange
+        #  
+        # Means that Green are for colors below, Orange for
+        # above. These colors can also be "cut" or "mask", meaning
+        # that the corresponding side isn't displayed.
+        def self.from_text(str)
+          str = str.dup
+          hls = false
+          re = /natural:?/i     # Not too bad ?
+          if str =~ re
+            str.sub!(re,'')
+            hls = true
+          end
+
+          l = str.split(/::/)
+          
+
+          if l.size == 2        # This is the complex case
+            if l[1] =~ /--/
+              l.push('')
+            else
+              l.unshift('')
+            end
+          elsif l.size == 1
+            l.push('')
+            l.unshift('')
+          end
+
+          ## @todo More and more I find that this metabuilder thing is
+          ## a little cumbersome, especially since I have an
+          ## additional type system on top of this one.
+          colortype = Commands::CommandType.get_type('color')
+
+          
+          # Now, we have three elements
+          if l[0].size > 0
+            if l[0] =~ /mask|cut/i
+              below = :mask
+            else
+              below = colortype.string_to_type(l[0])
+            end
+          else
+            below = nil
+          end
+
+          if l[2].size > 0
+            if l[2] =~ /mask|cut/i
+              above = :mask
+            else
+              above = colortype.string_to_type(l[2])
+            end
+          else
+            above = nil
+          end
+
+          specs = l[1].split(/--/)
+
+          values = []
+          colors = []
+          for s in specs
+            if s =~ /([^(]+)\((.*)\)/
+              values << $2.to_f
+              colors << colortype.string_to_type($1)
+            else
+              values << nil
+              colors << colortype.string_to_type(s)
+            end
+          end
+          cm = ColorMap.new(values, colors)
+          cm.above = above
+          cm.below = below
+          cm.rgb = ! hls
+          return cm
+        end
+
+
+        # Prepares the 'data', 'colormap' and 'value_mask' arguments
+        # to t.create_image based on the given data, and the min and
+        # max Z levels
+        #
+        # @todo handle masking + in and out of range.
+        #
+        # @todo I don't think this function is named properly.
+        def prepare_data_display(t, data, zmin, zmax)
+          # We correct zmin and zmax
+          cmap, zmin, zmax = *self.to_colormap(t, zmin, zmax)
+          
+          data = t.create_image_data(data.reverse_rows,
+                                     'min_value' => zmin,
+                                     'max_value' => zmax)
+          
+          return { 'data' => data,
+            'colormap' => cmap
+          }
+        end
+
+        # Returns a color triplet corresponding to the given z value
+        #
+        # @todo For now, the HSV parameter isn't honored.
+        def z_color(z, zmin, zmax)
+          zvs = z_values(zmin, zmax)
+          
+          idx = zvs.where_first_ge(z)
+          if idx && idx > 0
+            x = (zvs[idx] - z)/(zvs[idx] - zvs[idx-1])
+            c = Utils::mix_objects(@colors[idx-1],@colors[idx], x)
+            # p [c, idx, z, zmin, zmax]
+            return c
+          elsif idx == 0
+            return @colors.first
+          else
+            return @colors.last
+          end
+        end
+
+        # Converts to a Tioga color_map
+        #
+        # @todo That won't work when there are things inside/outside
+        # of the map.
+        def to_colormap(t, zmin, zmax)
+
+          # OK. Now, we have correct z values. We just need to scale
+          # them between z_values[0] and z_values.last, to get a [0:1]
+          # interval.
+          zvs = z_values(zmin, zmax)
+          p_values = zvs.dup
+          p_values.sub!(p_values.first)
+          p_values.div!(p_values.last)
+          
+          dict = {
+            'points' => p_values
+          }
+          if @rgb
+            dict['Rs'] = []
+            dict['Gs'] = []
+            dict['Bs'] = []
+            for col in @colors
+              dict['Rs'] << col[0]
+              dict['Gs'] << col[1]
+              dict['Bs'] << col[2]
+            end
+          else
+            dict['Hs'] = []
+            dict['Ls'] = []
+            dict['Ss'] = []
+            for col in @colors
+              col = t.rgb_to_hls(col)
+              dict['Hs'] << col[0]
+              dict['Ls'] << col[1]
+              dict['Ss'] << col[2]
+            end
+          end
+          return [t.create_colormap(dict), zvs.first, zvs.last]
+        end
+
+        protected
+
+        # Returns a Dvector holding z values corresponding to each of
+        # the color.
+        #
+        # @todo This function will be called very often and is not
+        # very efficient; there should be a way to cache the results,
+        # either implicitly using a realy cache or explicitly by
+        # "instantiating" the colormap for given values of zmin and
+        # zmax.
+        #
+        # @todo This function doesn't ensure that the resulting z
+        # values are monotonic, which isn't quite that good.
+        def z_values(zmin, zmax)
+          # Real Z values.
+          z_values = @values.dup
+          z_values[0] ||= zmin
+          z_values[-1] ||= zmax
+
+          # Now, we replace all the nil values by the correct position
+          # (the middle or both around when only one _nil_ is found,
+          # 1/3 2/3 for 2 consecutive _nil_ values, and so on).
+          last_value = 0
+          1.upto(z_values.size-1) do |i|
+            if z_values[i]
+              if last_value + 1 < i
+                (last_value+1).upto(i - 1) do |j|
+                  frac = (j - last_value)/(i - last_value + 1.0)
+                  p [last_value, j, i, frac]
+                  z_values[j] = z_values[last_value] * frac + 
+                    z_values[i] * (1 - frac)
+                end
+              end
+              last_value = i
+            end
+          end
+          return Dobjects::Dvector[*z_values]
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ require 'ctioga2/log'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 2 $', '$Date: 2009-04-25 14:03:30 +0200 (Sat, 25 Apr 2009) $')
+  Version::register_svn_info('$Revision: 198 $', '$Date: 2010-11-30 00:48:23 +0100 (Tue, 30 Nov 2010) $')
 
   module Graphics
 
@@ -25,7 +25,7 @@ module CTioga2
 
       # A class holding all the styles for a curve.
       #
-      # TODO: maybe for objects different than Curve2D, a subclass of
+      # \todo maybe for objects different than Curve2D, a subclass of
       # CurveStyle could be used ? This way, we could have clearly
       # separated legends and the like ?
       class CurveStyle
@@ -39,6 +39,48 @@ module CTioga2
         # The text of the legend, if there is one.
         attr_accessor :legend
 
+        # The style of the error bars when needed, as a ErrorBarStyle.
+        attr_accessor :error_bar
+
+        # Filling of the curve, if applicable
+        attr_accessor :fill
+
+        # Details of the location of the curve, a LocationStyle object.
+        attr_accessor :location
+
+        # Whether in a region plot, the curve should be above or below
+        # the filled region.
+        attr_accessor :region_position
+
+        # A path style.
+        #
+        # @todo Ideas for a path tyle include
+        # - plain lines
+        # - impulses ?
+        # - splines
+        # See gnuplot help for "plot with" for inspiration.
+        attr_accessor :path_style
+
+        # A colormap for strokes (only for XYZ data)
+        #
+        # @todo There should be a very clear way to mark curve style
+        # elements which are specific to certain kinds of plots (and
+        # warn the user about misuses ?)
+        attr_accessor :color_map
+
+        # The name of an axis to create to use for the display of the
+        # Z scale.
+        #
+        # @todo specify the behaviour when the axis exists.
+        attr_accessor :zaxis
+
+        # A colormap for markers (only for XYZ data) 
+        attr_accessor :marker_color_map
+
+        # Whether the XY display should split on NaN values (wherever)
+        attr_accessor :split_on_nan
+
+
         # True if a line should be drawn.
         def has_line?
           return @line && @line.style
@@ -59,12 +101,30 @@ module CTioga2
         # * 'line_...': a StrokeStyle for the drawing the line
         # * 'marker_...': a MarkerStyle for the drawing of markers
         # * 'legend': the legend of the curve
+        # * '[xy]axis': the name of the axis the curve should be
+        #    plotted onto
         #
-        # TODO: make @legend another object derived from BasicStyle ?
+        # \todo make #legend another object derived from BasicStyle ?
         def set_from_hash(hash)
           @line = StrokeStyle.from_hash(hash, 'line_%s')
           @marker = MarkerStyle.from_hash(hash, 'marker_%s')
+          @error_bar = ErrorBarStyle.from_hash(hash, 'error_bar_%s')
+          @location = LocationStyle.from_hash(hash, 'location_%s')
+          @fill = CurveFillStyle.from_hash(hash, 'fill_%s')
+
+          @region_position = hash['region_position']
+
           @legend = hash['legend']
+
+          @path_style = hash['style']
+
+          @color_map = hash['color_map']
+
+          @marker_color_map = hash['marker_color_map']
+
+          @split_on_nan = hash['split_on_nan']
+
+          @zaxis = hash['zaxis']
         end
 
         # Creates a CurveStyle object straight from a hash
@@ -79,7 +139,7 @@ module CTioga2
         # Draws a legend pictogram that fills up the whole current
         # frame.
         #
-        # TODO: add more elements to the pictogram in case of more
+        # \todo add more elements to the pictogram in case of more
         # complex things.
         def draw_legend_pictogram(t)
           t.context do

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

@@ -17,7 +17,7 @@ require 'ctioga2/log'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 61 $', '$Date: 2009-05-29 01:00:56 +0200 (Fri, 29 May 2009) $')
+  Version::register_svn_info('$Revision: 158 $', '$Date: 2010-07-23 15:03:47 +0200 (Fri, 23 Jul 2010) $')
 
   module Graphics
 
@@ -47,7 +47,10 @@ module CTioga2
       # This class represents all the stylistic information to draw a
       # Marker.
       #
-      # TODO: many things are still missing here...
+      # \todo many things are still missing here...
+      # 
+      # * in particular, angles could be handled here, and they could
+      #   be handled directly in the marker specification...
       class MarkerStyle < BasicStyle
 
         # The color
@@ -60,27 +63,83 @@ module CTioga2
         attr_accessor :scale
 
         # Shows the marker at a given location/set of locations.
-        def draw_markers_at(t, x, y)
-          if x.is_a? Numeric
-            x = Dvector[x]
-            y = Dvector[y]
-          end
+        # 
+        # \p override is a hash that can override part of the
+        # dictionnary specification.
+        def draw_markers_at(t, x, y, override = nil)
           t.context do
-            # Always with line style solid (though that could change ?)
+            ## \todo allow custom line types for markers ?
             t.line_type = LineStyles::Solid
             dict = { 
-              'Xs' => x, 'Ys' => y,
               'marker' => @marker, 
               'color' => @color
             }
+            if x.is_a? Numeric
+              dict['x'] = x
+              dict['y'] = y
+            else
+              dict['Xs'] = x
+              dict['Ys'] = y
+            end
+
             if @scale
               dict['scale'] = @scale
             end
+            if override
+              dict.merge!(override)
+            end
             t.show_marker(dict)
           end
         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.
+      #
+      # \todo more attributes ?
+      class FillStyle < BasicStyle
+
+        # The color.
+        attr_accessor :color
+
+        # The transparency
+        attr_accessor :transparency
+
+        # 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
+
+        # At which Y value we should draw the horizontal line for the
+        # fill ? A float, or:
+        # * :top, :bottom
+        # * false, nil to disable filling altogether
+        attr_accessor :y0
+        
+      end
+
     end
   end
 end