ctioga2 0.0 → 0.1

data/lib/ctioga2/data/filters.rb

@@ -19,7 +19,7 @@ require 'ctioga2/data/backends/factory'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 82 $', '$Date: 2009-06-11 22:28:14 +0200 (Thu, 11 Jun 2009) $')
+  Version::register_svn_info('$Revision: 194 $', '$Date: 2010-11-22 10:26:54 +0100 (Mon, 22 Nov 2010) $')
 
 
   module Data
@@ -81,6 +81,8 @@ EOH
       TrimFilter = 
         Cmd.new("trim", nil, "--trim", 
                 [CmdArg.new('integer')], {}) do |plotmaker, number, opts|
+        ## @todo There should be a way to add commands in a type-safe
+        ## way, without having to convert to string first.
         plotmaker.data_stack.add_to_dataset_hook("trim-last(#{number})")
       end
       
@@ -124,6 +126,52 @@ Install the {command: cherry-pick-last} command as a dataset hook (see
 false for subsequent datasets will be removed.
 EOH
 
+      AverageDupOperation = 
+        Cmd.new("avg-dup-last", nil, "--avg-dup-last", 
+                [], {}) do |plotmaker|
+        plotmaker.data_stack.last.average_duplicates!
+      end
+      
+      AverageDupOperation.describe("Average successive elements with identical X values",
+                                   <<EOH, FiltersGroup)
+Averages successive points with identical X values. This algorithm is
+naive with respect to the min/max values and averages them just as
+well, whereas one might expect something more clever.
+
+To average over identical X values when they are not successive in the
+dataset, you might want to hand it over to {command: sort-last} first.
+
+EOH
+
+      AverageDupFilter = 
+        Cmd.new("avg-dup", nil, "--avg-dup", 
+                [], {}) do |plotmaker, formula|
+        plotmaker.data_stack.add_to_dataset_hook("avg-dup-last()")
+      end
+      
+      AverageDupFilter.describe("Systematicallly average successive elements with identical X values",
+                                <<EOH, FiltersGroup)
+Install the {command: avg-dup-last} command as a dataset hook (see
+{command: dataset-hook}): all datasets acquired after this is on will
+be averaged if they have identical successive values of X.
+EOH
+
+
+      SmoothOperation = 
+        Cmd.new("smooth-last", nil, "--smooth-last", 
+                [CmdArg.new('integer')], {}) do |plotmaker, number|
+        plotmaker.data_stack.last.naive_smooth!(number)
+      end
+      
+      SmoothOperation.describe("Smooths data using a gaussian filter",
+                               <<EOH, FiltersGroup)
+Smooth the data using a simple (naive even) gaussian filter. Good for
+producing 'lines to guide the eye'
+EOH
+
+
+
+
 
     end
   end

data/lib/ctioga2/data/indexed-dtable.rb

@@ -0,0 +1,137 @@
+# indexed-dtable.rb: A Dtable object with non-uniform XY values
+# 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'
+
+module CTioga2
+
+  Version::register_svn_info('$Revision: 181 $', '$Date: 2010-10-27 15:18:35 +0200 (Wed, 27 Oct 2010) $')
+
+
+  module Data
+
+    # An indexed Dtable.
+    #
+    # This object represents an indexed Dtable, that is a Dtable with
+    # given values of X and Y (not necessarily uniform). Its main use
+    # is to get back a uniform (non-indexed) Dtable, for use with
+    # create_image
+    #
+    # An important information is that places where there was no data
+    # is implicitly represented as NaN
+    class IndexedDTable
+
+      # The underlying Dtable
+      attr_accessor :table
+
+      # X values
+      attr_accessor :x_values
+
+      # Y values
+      attr_accessor :y_values
+
+      def initialize(x, y, t)
+        @table = t
+        @x_values = x
+        @y_values = y
+      end
+
+      # Returns the XY boundaries of the object
+      def xy_boundaries
+        return Graphics::Types::Boundaries.bounds(@x_values, @y_values)
+      end
+
+      # Returns the value by which one should shift the X and Y
+      # positions of the borders of the images in order to get the
+      # points centered on their pixel (for a *uniform* grid !).
+      #
+      # While this correction looks better on non-uniform grids, it
+      # does not guarantee that it places all the points int the
+      # middle of their pixel, but that is still true for the ones at
+      # the border.
+      def xy_correction
+        return [(@x_values.last - @x_values.first)/ (2 * @x_values.size),
+                (@y_values.last - @y_values.first)/ (2 * @y_values.size)]
+      end
+
+      # Returns the coordinates of the lower-left XY values
+      def ll
+        return [@x_values.first, @y_values.first]
+      end
+
+      # Returns the coordinates of the lower-left XY values
+      def lr
+        return [@x_values.last, @y_values.first]
+      end
+
+      # Returns the coordinates of the upper-right XY values
+      def ur
+        return [@x_values.last, @y_values.last]
+      end
+
+      # Returns the coordinates of the upper-right XY values
+      def ul
+        return [@x_values.first, @y_values.last]
+      end
+
+      # Returns a hash ul,ll,lr with the corresponding values of the
+      # the points, with the correction applied if correction is true
+      def corner_positions(correction = true)
+        dict = {
+          'll' => ll,
+          'lr' => lr,
+          'ul' => ul
+        }
+        if correction
+          dx, dy = *xy_correction
+          # This isn't really beautiful, but it just works.
+          dict['ll'][0] -= dx
+          dict['lr'][0] += dx
+          dict['ul'][0] -= dx
+
+          dict['ll'][1] -= dy
+          dict['lr'][1] -= dy
+          dict['ul'][1] += dy
+        end
+        return dict
+      end
+
+      def width
+        return @x_values.size
+      end
+
+      def height
+        return @y_values.size
+      end
+
+      # Returns a [xs, ys, gaps] triplet suitable for use with
+      # t.append_points_with_gaps_to_path to show the given level.
+      #
+      # @todo add algorithm choice too
+      def make_contour(level)
+        gaps = []
+        # Requires Tioga r598
+        xs, ys = *Tioga::FigureMaker.make_contour('data' => @table,
+                                                  'xs' => @x_values, 
+                                                  'ys' => @y_values,
+                                                  'gaps' => gaps,
+                                                  'level' => level)
+        return  [xs, ys, gaps]
+      end
+
+    end
+
+  end
+
+end
+

data/lib/ctioga2/data/point.rb

@@ -1,11 +1,11 @@
 # point.rb: a point in a given dataset
 # 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
@@ -17,7 +17,7 @@ require 'ctioga2/data/dataset'
 
 module CTioga2
 
-  Version::register_svn_info('$Revision: 76 $', '$Date: 2009-06-03 01:44:44 +0200 (Wed, 03 Jun 2009) $')
+  Version::register_svn_info('$Revision: 112 $', '$Date: 2009-11-09 22:34:12 +0100 (Mon, 09 Nov 2009) $')
 
 
   module Data
@@ -33,7 +33,9 @@ module CTioga2
       attr_accessor :index
       
       # Creates a DataPoint with the given information.
-      def initialize(index, dataset)
+      def initialize(dataset,index)
+        @dataset = dataset
+        @index = index
       end
 
       # Creates a DataPoint object based on the following _text_
@@ -50,6 +52,7 @@ module CTioga2
             idx = $3.to_i
           end
           dataset = plotmaker.data_stack.stored_dataset(which)
+          
           if ! dataset
             raise "Invalid or empty dataset: #{which}"
           end
@@ -61,11 +64,99 @@ module CTioga2
           raise "Not a valid datapoint specification: '#{text}'"
         end
       end
+
+      # @todo functions returning xy values + slope for the given
+      # datapoint. For each, possibility to average over several points.
+
+
+      # Returns the averaged X value around the datapoint
+      def x_val(navg = 3)
+
+        xvect = @dataset.x.values
+        di = (navg-1)/2
+        navg = 2*di + 1
+
+        idx = usable_index(di, xvect.size)
+
+        xval = 0
+        (idx-di).upto(idx+di) do |i|
+          xval += xvect[i]
+        end
+        return xval/(navg)
+      end
+      
+
+      # Returns the averaged Y value around the datapoint
+      def y_val(navg = 3)
+        yvect = @dataset.y.values
+        di = (navg-1)/2
+        navg = 2*di + 1
+
+        idx = usable_index(di, yvect.size)
+
+        yval = 0
+        (idx-di).upto(idx+di) do |i|
+          yval += yvect[i]
+        end
+        return yval/(navg)
+      end
+
+      # Returns the value of the slope around the datapoint. This is
+      # obtained using a linear regression, so it should be rather
+      # reliable.
+      def slope(navg = 3)
+        xvect = @dataset.x.values
+        yvect = @dataset.y.values
+        di = (navg-1)/2
+        navg = 2*di + 1
+
+        idx = usable_index(di, xvect.size)
+
+        sx = 0
+        sxx = 0
+        sxy = 0
+        sy = 0
+
+        (idx-di).upto(idx+di) do |i|
+          sx += xvect[i]
+          sy += yvect[i]
+          sxx += xvect[i]**2
+          sxy += xvect[i] * yvect[i]
+        end
+        if sxx*navg == sx*sx
+          return 1
+        else
+          return (sxy * navg - sx*sy)/(sxx * navg - sx*sx)
+        end
+      end
+
+      ## Returns the average value of the difference between two
+      # consecutive X values
+      def dx(navg = 3)
+        xvect = @dataset.x.values
+        di = (navg-1)/2
+        navg = 2*di + 1
+
+        idx = usable_index(di, xvect.size)
+        return (xvect[idx+di]-xvect[idx-di])/navg
+      end
+      
+
+      protected
+      # Makes sure the boudaries for averaging are fine
+      def usable_index(di, size)
+        # Boundary checks
+        if @index - di < 0
+          return di
+        elsif @index + di >= size
+          return size - 1 - di
+        end
+        return @index
+      end
+
+
     end
 
-    # TODO: functions returning xy values + slope for the given
-    # datapoint. For each, possibility to average over several points.
-    
   end
 
 end

data/lib/ctioga2/data/stack.rb

@@ -25,7 +25,7 @@ require 'ctioga2/data/filters'
 # This module contains all the classes used by ctioga
 module CTioga2
 
-  Version::register_svn_info('$Revision: 83 $', '$Date: 2009-06-11 23:18:35 +0200 (Thu, 11 Jun 2009) $')
+  Version::register_svn_info('$Revision: 233 $', '$Date: 2011-01-20 10:26:42 +0100 (Thu, 20 Jan 2011) $')
 
 
   module Data
@@ -33,7 +33,7 @@ module CTioga2
     # This is the central class for acquisition and handling of
     # Dataset objects, retrieved from from a Backends::BackendFactory.
     #
-    # TODO: provide real stack manipulation functions such as
+    # \todo provide real stack manipulation functions such as
     # 
     # * interpolation: pops the last object from the stack and add its
     #   interpolated values on the element before.
@@ -55,7 +55,7 @@ module CTioga2
       # A hook executed every time a dataset is pushed unto the stack
       # using #add_dataset.
       #
-      # TODO: this string is parsed for each call to
+      # \todo this string is parsed for each call to
       # #add_dataset. Perhaps it would be good to provide a way to
       # record a Command call, without parsing it from scratch ???
       # 
@@ -77,35 +77,39 @@ module CTioga2
       # Performs expansion on the given _set_ with the current
       # backend, retrieves corresponding Dataset objects, pushes them
       # onto the stack and returns them.
-      #
-      # _options_ is a Hash that can contain the options available to the
-      # 'load' command:
+      def get_datasets(set, options = {})
+        backend = @backend_factory.current
+        sets = backend.expand_sets(set)
+        datasets = sets.map do |s|
+          backend.dataset(s)
+        end
+        add_datasets(datasets, options)
+        return datasets
+      end
+
+      # Adds a series of datasets, and perform various operations
+      # according to the hash _options_:
       # 
       # * 'name' to name each element added to the stack. A %d will be
       #   replaced by the number of the dataset within the ones just
       #   added.
       #
       # Additional members of the Hash are simply ignored.
-      def get_datasets(set, options = {})
-        backend = @backend_factory.current
-        retval = []
+      def add_datasets(datasets, options = {})
         i = 0
-        for s in backend.expand_sets(set)
-          ds = backend.dataset(s)
-          add_dataset(ds, options['ignore_hooks'])
+        for ds in datasets
+          store_dataset(ds, options['ignore_hooks'])
 
           # Selection
           if options['where']
             ds.select_formula!(options['where'])
           end
 
-          retval << ds
           if options['name']
             @named_datasets[options['name'] % [i]] = ds
           end
           i += 1
         end
-        return retval
       end
 
       # Returns the stored dataset, either using its index in the
@@ -139,16 +143,16 @@ module CTioga2
       # necessary.
       #
       # Makes use of Plotmaker.plotmaker
-      def add_dataset(dataset, ignore_hooks = false)
+      def store_dataset(dataset, ignore_hooks = false)
         @stack << dataset
         if @dataset_hook && (! ignore_hooks)
-          # TODO: error handling
+          # \todo error handling
           begin
             PlotMaker.plotmaker.interpreter.run_commands(@dataset_hook)
           rescue Exception => e
-            error "There was a problem running the dataset hook '#{@dataset_hook}', disabling it"
+            error { "There was a problem running the dataset hook '#{@dataset_hook}', disabling it" }
             @dataset_hook = nil
-            info "-> '#{format_exception e}'"
+            info { "-> '#{format_exception e}'" }
           end
         end
       end
@@ -172,7 +176,7 @@ module CTioga2
         end
       end
 
-      # Pops the last _n_ datasets off the stack
+      # Pops the last _n_ datasets off the stack and pushes back the
       def concatenate_datasets(n = 2)
         ds = @stack.pop
         raise "Nothing on the stack" unless ds
@@ -184,6 +188,17 @@ module CTioga2
         @stack.push(ds)
       end
 
+      # Merges the last datasets into a new one.
+      #
+      # Over
+      def merge_datasets(n = 2, columns = [0], precision = nil)
+        ds = @stack.pop
+        raise "Nothing on the stack" unless ds
+        datasets = @stack[-1..-(n-1)]
+        ds.merge_datasets_in(datasets, columns, precision)
+        @stack.push(ds)
+      end
+
       # Returns the last Dataset pushed onto the stack.
       def last
         return @stack.last
@@ -223,12 +238,43 @@ number. See the type {type: stored-dataset} for more information.
 
 EOH
 
+    ContourOptions = LoadDatasetOptions.dup.update({
+      'which' => CmdArg.new('stored-dataset'),
+    })
+
+
+
+    MakeContourCommand = 
+      Cmd.new("make-contour", nil, "--make-contour", 
+              [ CmdArg.new('float'), ], 
+              ContourOptions) do |plotmaker, level, opts|
+      ds = plotmaker.data_stack.specified_dataset(opts)
+      f = ds.make_contour(level)
+      name = "Level #{level} for plot '#{ds.name}'"
+      newds = Dataset.new(name, [f.x, f.y])
+      plotmaker.data_stack.add_datasets([newds], opts)
+    end
+    
+    MakeContourCommand.describe("Pushes a contour on the data stack",
+                                <<EOH, DataStackGroup)
+EOH
+
+
+
 
     PrintLastCommand =
       Cmd.new("print-dataset", '-P', "--print-dataset",
-              [], {'which' => CmdArg.new('stored-dataset')}) do |plotmaker,opts|
+              [], {
+                'which' => CmdArg.new('stored-dataset'),
+                'save' => CmdArg.new('file'),
+              }) do |plotmaker,opts|
       ds = plotmaker.data_stack.specified_dataset(opts)
-      plotmaker.data_stack.print_dataset(ds, STDOUT)
+      if opts['save']
+        out = open(opts['save'], 'w')
+      else
+        out = STDOUT
+      end
+      plotmaker.data_stack.print_dataset(ds, out)
     end
     
     PrintLastCommand.describe("Prints the dataset last pushed on the stack",
@@ -251,6 +297,37 @@ stack, concatenates them (older last) and push them back onto the
 stack.
 EOH
 
+
+    MergeToLastCommand = 
+      Cmd.new("merge-datasets", nil, "--merge-datasets", 
+              [], {'number' => CmdArg.new('integer')}) do |plotmaker, opts|
+      nb = opts['number'] || 2
+      ## @todo all
+      plotmaker.data_stack.merge_datasets(nb)
+    end
+    
+    MergeToLastCommand.describe("....",
+                               <<EOH, DataStackGroup)
+....
+EOH
+
+    XYReglinCommand = 
+      Cmd.new("xy-reglin", nil, "--xy-reglin", [], {
+                'which' => CmdArg.new('stored-dataset'),
+                'linear' => CmdArg.new('boolean'),
+              }) do |plotmaker,opts|
+      stack = plotmaker.data_stack
+      ds = stack.specified_dataset(opts)
+      coeffs, lines = ds.reglin(opts)
+      stack.store_dataset(lines, true)
+      stack.store_dataset(coeffs, true)
+    end
+    
+    XYReglinCommand.describe("....",
+                             <<EOH, DataStackGroup)
+....
+EOH
+
     SetDatasetHookCommand = 
       Cmd.new("dataset-hook", nil, "--dataset-hook", 
               [CmdArg.new('commands')], {}) do |plotmaker, commands, opts|