ctioga2 0.11 → 0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf1d83cc2f6ff4a0a56457aaf1343632316fc54c
-  data.tar.gz: de6664912ac0b52b32dd6dc90520556a8a3408e1
+  metadata.gz: f25f506adfb25689dc8c090adcfb35beac30af3d
+  data.tar.gz: 1731cd6baf714e9bf480d9ea50039b9acc0ac9d4
 SHA512:
-  metadata.gz: 658b6530f9b7a6b05159f779b6e2b82df15e22b05e75e7c61404212193c46044b622d9a9e68980225a116012004a79f7c92b62445fd1e2ebbc8322f3b83658c3
-  data.tar.gz: 8f4d59ab2aa53836d4bd74f30696cfc2f3d4eaaff3c138d85878619f89304cad620093ba2ecd54dc240933ecc93526156fa1934138a07a6e768b0c4864077f54
+  metadata.gz: d7fb0ecfa3ed8cc7c2e3e8b5723b92b676ba837681eb33eb7fa19db61cf0f0131566cbf76f4a6c49c91969b074553607b3bdfcdae3df1d52510432339a22d1de
+  data.tar.gz: 87e302b8f937f3f638f24a0eca891cec89282aa10d7a2f7721432dbdd0e100711334efe883fd65a79dc7e72b540074336a5c5048844171b8cd8dcdf5b44554f2

data/Changelog

@@ -1,3 +1,20 @@
+ctioga2 (0.12)
+
+  * The xyz-map plot type now handles correctly inhomogeneous grids (so long
+    as points do not overlap)
+  * One can now separately choose the fill and the stroke color for
+    markers
+  * Selection of line width for axes
+  * A set of commands to manipulate styles (skip the next style or copy
+    the style of previous plots)
+  * Selection of error bar line width
+  * All lines are also arrows now (just with a different default)
+  * A pause command to ask for user input before quitting if there were
+    errors or warnings
+  * Improvement of error messages
+
+ -- Vincent <vincent.fourmond@9online.fr>  Sun 22 Mar 18:38:49 CET 2015
+
 ctioga2 (0.11)
 
   * Implemented patterned fills

data/lib/ctioga2/commands/commands.rb

@@ -204,7 +204,8 @@ module CTioga2
           if(@arguments.size == 0 && args.size == 1 && args[0] == true)
             return []
           else
-            raise ArgumentNumberMismatch, "Command #{@name} was called with #{args.size} arguments, but it takes #{@arguments.size}"
+            ar = args.map { |x| "'#{x}'"}
+            raise ArgumentNumberMismatch, "Command #{@name} was called with #{args.size} arguments: #{ar.join(", ")}, but it takes #{@arguments.size}"
           end
         end
         retval = []

data/lib/ctioga2/commands/doc/documentation-commands.rb

@@ -50,7 +50,8 @@ Writes a manual page based on a template
 EOH
 
       WriteHTMLOptions = {
-        'page-menu' => CmdArg.new('text')
+        'page-menu' => CmdArg.new('text'),
+        'snippets' => CmdArg.new('file')
       }
 
       WriteHTMLCommands = 

data/lib/ctioga2/commands/doc/html.rb

@@ -89,6 +89,16 @@ module CTioga2
         def write_commands(opts, out = STDOUT)
           cmds, groups = @doc.documented_commands
 
+          if opts['snippets']
+            require 'yaml'
+            snippets = begin
+                         YAML.load(IO.readlines(opts['snippets']).join())
+                       rescue Exception => e
+                         Log::error { "Failed to load snippets file '#{opts['snippets']}'\n => #{e.inspect}" }
+                         {}
+                       end
+          end
+
           write_page_menu(opts, out) do |out|
             out.puts "<div class='quick-jump'>"
             out.puts "<h3>Quick jump</h3>"
@@ -120,6 +130,23 @@ module CTioga2
               for cmd in commands
                 out.puts
                 out.puts command_documentation(cmd)
+                if snippets
+                  snpts = snippets[cmd.name]
+                  if snpts
+                    str = ""
+                    for k in snpts.keys.sort
+                      s = snpts[k]
+                      ln = s[:line].chomp
+                      # if ln[-1] == '\\'
+                      #   ln = ln[0..-2]
+                      # end
+                      # Strip links from the line
+                      ln.gsub!(/<a[^>]+>(.*?)<\/a>/) { || $1 }
+                      str += "<pre class='#{s[:cls]}'><a href='#{k}'>#{ln}</a></pre>\n"
+                    end
+                    out.puts "<h5 id='#snippets-h5-#{cmd.name}' onclick='toggleExamples(this);'>Examples...</h5>\n<div id='#snippets-#{cmd.name}' class='snippets'>#{str}</div>"
+                  end
+                end
               end
             end
           end

data/lib/ctioga2/commands/general-commands.rb

@@ -126,6 +126,19 @@ EOH
     
     VerboseLogging.describe("Makes ctioga2 more verbose", <<EOH, GeneralGroup)
 With this on, ctioga2 outputs quite a fair amount of informative messages.
+EOH
+
+    Pause = 
+      Cmd.new("pause", nil,  "--pause",
+              [ CmdArg.new('boolean') ]) do |plotmaker, val|
+      plotmaker.pause_on_errors = val
+    end
+    
+    Pause.describe("Pause on errors", <<EOH, GeneralGroup)
+When this is on, the program will ask for confirmation before finishing, 
+when errors or warnings have been shown. This is especially useful on windows 
+or other environments where the terminal shuts down as soon as ctioga2 
+has finished.
 EOH
 
     # Write debugging information.

data/lib/ctioga2/commands/type.rb

@@ -87,7 +87,7 @@ module CTioga2
 
       # Does the actual conversion from string to the real type
       def string_to_type(str)
-        return @type.string_to_type(str)
+        return @type.string_to_type(str, @name)
       end
 
       # Returns the long option for the option parser.

data/lib/ctioga2/data/dataset.rb

@@ -16,6 +16,8 @@ require 'ctioga2/log'
 require 'ctioga2/data/datacolumn'
 require 'ctioga2/data/indexed-dtable'
 
+require 'set'
+
 module CTioga2
 
   # \todo now, port the backend infrastructure...
@@ -57,6 +59,9 @@ module CTioga2
 
         # Cache for the indexed dtable
         @indexed_dtable = nil
+
+        # Cache for the homogeneous dtables
+        @homogeneous_dtables = nil
       end
 
       # Creates a 
@@ -340,6 +345,204 @@ module CTioga2
         return Dataset.new(name + "_mod", result)
       end
 
+      # Takes a list of x and y values, and subdivise into
+      # non-overlapping groups.
+      def self.subdivise(x,y, x_idx, y_idx)
+
+        # We make a list of sets. Each element of the list represent
+        # one column, and in each set we store the index of of lines
+        # that contain data.
+
+        cols = []
+        
+        x.each_index do |i|
+          ix = x_idx[x[i]]
+          iy = y_idx[y[i]]
+
+          cols[ix] ||= Set.new
+          cols[ix].add(iy)
+        end
+
+        # The return value is an array of [ [xindices] [yindices]]
+        ret = []
+
+        # Now, the hard part.
+
+        # We run for as long as there are sets ?
+        fc = 0
+        while fc < cols.size
+          # We start with the set of the current column
+          st = cols[fc]
+          # Empty, go to next column
+          if st.size == 0
+            fc += 1
+            next
+          end
+
+          # Set columns that contain the set
+          set_cols = [fc]
+          # Now, we look for restrictions on the set.
+          fc2 = fc + 1
+          while fc2 < cols.size
+            # if non-void intersection, we stick to that
+            inter = st.intersection(cols[fc2])
+            # p [fc, fc2, st, inter]
+            if inter.size > 0
+              st = inter
+              set_cols << fc2
+              fc2 += 1
+              break
+            end
+
+            fc2 += 1
+            # Try to implement other kinds of restrictions?
+          end
+
+          # Now, we have a decent set, we go on until the intersection
+          # with the set is not the set.
+          while fc2 < cols.size
+            inter = st.intersection(cols[fc2])
+            if inter.size > 0
+              if inter.size == st.size
+                set_cols << fc2
+              else
+                break
+              end
+            end
+            fc2 += 1
+          end
+
+          # Now, we have a set and all the indices that match.
+          ret << [ set_cols.dup.sort, st.to_a.sort ]
+          # And, now, go again through all the columns and remove the set
+          for c in set_cols
+            cols[c].subtract(st)
+          end
+        end
+
+        return ret
+      end
+
+      # Takes a list of indices, the corresponding vector (ie mapping
+      # the indices to the vector gives the actual coordinates) and
+      # returns a list of arrays of indices with homogeneous deltas.
+      def self.homogenenous_deltas_indices(indices, vector, tolerance = 1e-3)
+        vct = indices.map do |i|
+          vector[i]
+        end
+        subdiv = Utils::split_homogeneous_deltas(vct, tolerance)
+        rv = []
+        idx = 0
+        for s in subdiv
+          rv << indices[idx..idx+s.size-1]
+          idx += s.size
+        end
+        if idx != indices.size
+          error { "blundered ?" }
+        end
+        return rv
+      end
+
+      # Returns a series of IndexedDTable representing the XYZ data.
+      def homogeneous_dtables()
+        if @homogeneous_dtables
+          return @homogeneous_dtables
+        end
+        if @ys.size < 2
+          raise "Need at least 3 data columns in dataset '#{@name}'"
+        end
+        # We convert the index into three x,y and z arrays
+        x = @x.values.dup
+        y = @ys[0].values.dup
+        z = @ys[1].values.dup
+        
+        xvals = x.sort.uniq
+        yvals = y.sort.uniq
+        
+        # Now building reverse hashes to speed up the conversion:
+        x_index = {}
+        i = 0
+        xvals.each do |v|
+          x_index[v] = i
+          i += 1
+        end
+
+        y_index = {}
+        i = 0
+        yvals.each do |v|
+          y_index[v] = i
+          i += 1
+        end
+
+        fgrps = []
+        if x.size != xvals.size * yvals.size
+          # This is definitely not a homogeneous map
+          fgrps = Dataset.subdivise(x, y, x_index, y_index)
+        else
+          fgrps = [ [ x_index.values, y_index.values ] ]
+        end
+
+        # Now, we resplit according to the deltas:
+        grps = []
+        for grp in fgrps
+          xv, yv = *grp
+
+          xv_list = Dataset.homogenenous_deltas_indices(xv, xvals)
+          yv_list = Dataset.homogenenous_deltas_indices(yv, yvals)
+
+          for cxv in xv_list
+            for cyv in yv_list
+              grps << [ cxv, cyv]
+            end
+          end
+        end
+
+        # Now we construct a list of indexed dtables
+        rv = []
+        for grp in grps
+          xv = grp[0].sort
+          yv = grp[1].sort
+
+          # Build up intermediate hashes
+          xvh = {}
+          xvl = []
+          idx = 0
+          for xi in xv
+            val = xvals[xi]
+            xvh[val] = idx
+            xvl << val
+            idx += 1
+          end
+
+          yvh = {}
+          yvl = []
+          idx = 0
+          for yi in yv
+            val = yvals[yi]
+            yvh[val] = idx
+            yvl << val
+            idx += 1
+          end
+          
+          table = Dobjects::Dtable.new(xv.size, yv.size)
+          # We initialize all the values to NaN
+          table.set(0.0/0.0)
+        
+          x.each_index do |i|
+            ix = xvh[x[i]]
+            next unless ix
+            iy = yvh[y[i]]
+            next unless iy
+            # Y first !
+            table[iy, ix] = z[i]
+          end
+          rv << IndexedDTable.new(xvl, yvl, table)
+        end
+        @homogeneous_dtables = rv
+        return rv
+      end
+        
+
 
       # Returns an IndexedDTable representing the XYZ
       # data. Information about errors are not included.
@@ -354,6 +557,9 @@ module CTioga2
         if @indexed_dtable
           return @indexed_dtable
         end
+        if @ys.size < 2
+          raise "Need at least 3 data columns in dataset '#{@name}'"
+        end
         # We convert the index into three x,y and z arrays
         x = @x.values.dup
         y = @ys[0].values.dup
@@ -377,6 +583,10 @@ module CTioga2
           i += 1
         end
 
+        if x.size != xvals.size * yvals.size
+          error {"Heterogeneous, stopping here for now"}
+        end
+
         table = Dobjects::Dtable.new(xvals.size, yvals.size)
         # We initialize all the values to NaN
         table.set(0.0/0.0)

data/lib/ctioga2/data/stack.rb

@@ -96,7 +96,7 @@ EOH
           begin
             datasets << backend.dataset(s)
           rescue Exception => e
-            error { "Could not load dataset #{s} -- #{e}" }
+            error { "Could not load dataset '#{s}' with backend '#{backend.description.name }':\n\t -> #{e}" }
             debug { "#{e.backtrace.join("\n")}" }
           end
         end

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

@@ -245,17 +245,19 @@ EOD
                          [ 'point', 'point' ], 
                          Styles::ArrowStyle,
                          'arrow') do |t, tail, head, style, options|
-          style.draw_arrow(t, *( tail.to_figure_xy(t) + 
-                           head.to_figure_xy(t) ))
+          stl = style.dup
+          stl.use_defaults_from(Styles::ArrowStyle::TiogaDefaults)
+          stl.draw_arrow(t, *( tail.to_figure_xy(t) + 
+                               head.to_figure_xy(t) ))
         end
 
         styled_primitive("line", "line", 
                          [ 'point', 'point' ],
-                         Styles::StrokeStyle,
+                         Styles::ArrowStyle,
                          'line'
                   ) do |t, tail, head, style, options|
-          style.draw_line(t, *( tail.to_figure_xy(t) + 
-                          head.to_figure_xy(t) ))
+          style.draw_arrow(t, *( tail.to_figure_xy(t) + 
+                                 head.to_figure_xy(t) ))
         end
 
         # @todo Do the same thing for arrows...
@@ -264,7 +266,7 @@ EOD
                          Styles::OrientedLineStyle,
                          'oriented-line'
                   ) do |t, org, dim, style, options|
-          style.draw_oriented_line(t, *org.to_figure_xy(t), dim)
+          style.draw_oriented_arrow(t, *org.to_figure_xy(t), dim)
         end
 
 

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

@@ -24,13 +24,6 @@ module CTioga2
       # * inclusion of curves
       # * legends
       # * a way to set/get its figure boundaries.
-      #
-      # @todo It would be interesting to feature several layers:
-      # background/normal/foreground, that could be addressed just
-      # using options to drawing commands
-      #
-      # @todo It would also be interesting to offer the possibility to
-      # output non-clipped objects.
       class Subplot < Container
 
         # Various stylistic aspects of the plot, as a

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

@@ -83,7 +83,9 @@ module CTioga2
           end
 
           coords = options['tail'] + options['head']
-          style.draw_arrow(t, *coords)
+          stl = style.dup
+          stl.use_defaults_from(Styles::ArrowStyle::TiogaDefaults)
+          stl.draw_arrow(t, *coords)
         end
       end
 

data/lib/ctioga2/graphics/elements/xyz-map.rb

@@ -1,5 +1,5 @@
-# parametric2d.rb: a 2D curve whose parameters depend on Z values
-# copyright (c) 2006, 2007, 2008, 2009, 2010 by Vincent Fourmond
+# xyz-map.rb: a heatmap
+# copyright (c) 2006, 2007, 2008, 2009, 2010, 2013, 2015 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
@@ -34,7 +34,7 @@ module CTioga2
         include Dobjects
 
         # The IndexedTable object representing the underlying data
-        attr_accessor :table
+        attr_accessor :tables
 
 
         # Creates a new XYZMap object with the given _dataset_ and
@@ -43,18 +43,33 @@ module CTioga2
           @dataset = dataset
           @curve_style = style
           prepare_data
+          @boundaries = nil
         end
 
         # Prepares the internal storage of the data, from the @dataset
         def prepare_data
-          @table = @dataset.indexed_table
+          @tables = @dataset.homogeneous_dtables
+          info {
+            str = ""
+            for tbl in @tables
+              str << " - #{tbl.x_values.min}, #{tbl.y_values.min} -> #{tbl.x_values.max}, #{tbl.y_values.max} #{tbl.width}x#{tbl.height}\n"
+            end
+            "There are #{@tables.size} different homogeneous submaps in #{@dataset.name}\n#{str}"
+          }
+          
         end
         
         protected :prepare_data
 
         # Returns the Types::Boundaries of this curve.
         def get_boundaries
-          return @table.xy_boundaries
+          if @boundaries
+            return @boundaries
+          end
+          bnds = Graphics::Types::Boundaries.bounds(@dataset.x.values,
+                                                    @dataset.y.values)
+          @boundaries = bnds
+          return bnds
         end
         
 
@@ -72,31 +87,35 @@ module CTioga2
 
             @curve_style.color_map ||= 
               Styles::ColorMap.from_text("Red--Green")
-            
-            dict = @curve_style.color_map.
-              prepare_data_display(t,@table.table,
-                                   @table.table.min,
-                                   @table.table.max)
-            if @curve_style.zaxis
-              begin
-                @parent.style.get_axis_style(@curve_style.zaxis).
-                  set_color_map(@curve_style.color_map, 
-                                @table.table.min,
-                                @table.table.max)
-              rescue
-                error { "Could not set Z info to non-existent axis #{@curve_style.zaxis}" }
+
+            zmin = @dataset.z.values.min
+            zmax = @dataset.z.values.max
+
+            for tbl in @tables
+              dict = @curve_style.color_map.
+                     prepare_data_display(t,tbl.table, zmin, zmax)
+              if @curve_style.zaxis
+                begin
+                  @parent.style.get_axis_style(@curve_style.zaxis).
+                    set_color_map(@curve_style.color_map, 
+                                  zmin,
+                                  zmax)
+                rescue
+                  error { "Could not set Z info to non-existent axis #{@curve_style.zaxis}" }
+                end
               end
-            end
 
-            dict.update(@table.corner_positions)
-            dict.update('width' => @table.width,
-                        'height' => @table.height)
-            dict.update('interpolate' => false)
-            if (! @curve_style.fill.transparency) || 
-                (@curve_style.fill.transparency < 0.99) 
-              t.show_image(dict)
-            else
-              info { 'Not showing map as transparency is over 0.99' }
+              dict.update(tbl.corner_positions)
+              dict.update('width' => tbl.width,
+                          'height' => tbl.height)
+              dict.update('interpolate' => false)
+              if (! @curve_style.fill.transparency) || 
+                 (@curve_style.fill.transparency < 0.99) 
+                t.show_image(dict)
+                # t.stroke_rect(dict['ul'][0], dict['ul'][1], dict['lr'][0] - dict['ul'][0], dict['lr'][1] - dict['ul'][1])
+              else
+                info { 'Not showing map as transparency is over 0.99' }
+              end
             end
           end
         end