ctioga2 0.9 → 0.10

data/Changelog

@@ -1,3 +1,30 @@
+ctioga2 (0.10)
+
+  * A draw-image function to include JPEG and PNG images
+  * Axes at origin (with at_x_origin and at_y_origin)
+  * A drawing-frame command to have pure drawing frames (no axes, 
+    no labels + coordinates given by physical units)
+  * A $(point index ...) returning the index of the dataset point
+  * Commands for drawing the currently available style items (colors,
+    markers, line styles and sets)
+  * Inline Ruby code in command files and running of external Ruby code
+    (for function definition only, since data processing/plotting is not
+    yet available on the Ruby side)
+  * Auto sizing of titles and labels
+  * Alignment for texts with a given width
+  * Smarter collision detection: now labels stick out of the graph only if
+    you really ask for it !
+  * Color sets from colorbrewer2.org
+  * Improved color maps specifications, including the possibility to
+    specify color sets as color maps
+  * A --list-styles command to list (the names of) all stylistic things
+    (and in particular, defined sets)
+  * Symmetric color maps
+  * Various bug fixes and documentation updates
+  * [ct2-make-movie] multiple outputs at once
+
+ -- Vincent <vincent.fourmond@9online.fr>  Sun 16 Mar 18:16:01 CET 2014
+
 ctioga2 (0.9)
 
   * A --set command to set variable values from the command-line

data/bin/ct2-make-movie

@@ -34,7 +34,55 @@ ct2 = "ctioga2"
 
 
 tmpdir = "tmp"
-target = nil
+
+
+# The class in charge of running ffmpeg
+class EncodingJob
+
+  # Target file
+  attr_accessor :target
+
+  # Bitrate
+  attr_accessor :bitrate
+
+  # Video codec
+  attr_accessor :codec
+
+  # Extra arguments
+  attr_accessor :extra_args
+
+  # Writes the given frame for encoding
+  def write_frame(data)
+    @encoder.write(data)
+  end
+
+  def add_args(args)
+    @extra_args ||= []
+    @extra_args += args
+  end
+
+  # Start job
+  def start_job(size)
+    ffmpeg_args = ["ffmpeg", '-y', "-f", "rawvideo", 
+                   "-r", "25", "-s", size, "-i", "-"]
+    if @bitrate
+      ffmpeg_args << "-b" << @bitrate
+    end
+    if @codec
+      ffmpeg_args << "-vcodec" << @codec
+    end
+
+    ffmpeg_args += @extra_args if @extra_args
+    ffmpeg_args << @target
+    p ffmpeg_args
+    @encoder = IO::popen(ffmpeg_args, "wb")
+  end
+
+  def close()
+    @encoder.close
+  end
+end
+
 
 DimensionConversion = {
   "pt" => (72.0/72.27),
@@ -86,35 +134,56 @@ use_pdftoppm = false
 # file over and over again.
 store_all = true
 
-# Codec for ffmpeg
-codec = nil
 
-# Bitrate for ffmpeg
-bitrate = nil
+encoders = [ EncodingJob.new ]
+cur_enc = encoders.first
+
 
-fargs = []
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: #$0 [options] file.ct2 arguments..."
 
+  ##################################################
+  # Encoding-related options
   opts.on("-t", "--target FILE", "Target video file") do |t|
-    target = t
+    if cur_enc.target
+      cur_enc = EncodingJob.new
+      encoders << cur_enc
+    end
+    cur_enc.target = t
+  end
+
+  opts.on("-b", "--bitrate RATE", "Bitrate (indicative)") do |v|
+    cur_enc.bitrate = v
+  end
+
+  opts.on("", "--codec CODEC", "Target codec") do |v|
+    cur_enc.codec = v
+  end
+
+  opts.on("", "--ffmpeg-args ARGS", "Extra ffmpeg args") do |v|
+     cur_enc.add_args(Shellwords.split(v))
   end
 
+
+  ##################################################
+  # 
+
   opts.on("", "--dir DIR", "Temporary directory for storage") do |t|
     tmpdir = t
   end
 
   opts.on("", "--version", "Prints version string") do 
-    puts "0.0"
+    puts "0.1"
   end
 
   opts.on("-p", "--[no-]pdftoppm", "Whether or not to use pdftoppm") do |t|
     use_pdftoppm = t
   end
 
-  opts.on("", "--page-size SIZE", 
+  opts.on("-r", "--page-size SIZE", 
           "Set ctioga2 page size (in TeX dimensions)") do |v|
     ct2_size = page_size_to_points(v)
+    p ct2_size
   end
 
   opts.on("", "--resolution RES",
@@ -127,17 +196,6 @@ opts = OptionParser.new do |opts|
     store_all = v
   end
 
-  opts.on("-b", "--bitrate RATE", "Bitrate (indicative)") do |v|
-    bitrate = v
-  end
-
-  opts.on("", "--codec CODEC", "Target codec") do |v|
-    codec = v
-  end
-
-  opts.on("", "--ffmpeg-args ARGS", "Extra ffmpeg args") do |v|
-    fargs += Shellwords.split(v)
-  end
 
 end
 
@@ -160,7 +218,7 @@ puts "Producing #{ct2_page_size} PDF and converting to #{size} for the video"
 
 
 file = ARGV.shift
-target ||= file.sub(/(\.ct2)?$/, ".avi")
+cur_enc.target ||= file.sub(/(\.ct2)?$/, ".avi")
 args = []
 
 for a in ARGV
@@ -184,22 +242,12 @@ FileUtils::mkpath(tmpdir)
 
 
 # @todo Use other encoding programs !
-# @todo bitrate control
 
-ffmpeg_args = ["ffmpeg", '-y', "-f", "rawvideo", 
-        "-r", "25", "-s", size, "-i", "-"]
-if bitrate
-  ffmpeg_args << "-b" << bitrate
-end
-if codec
-  ffmpeg_args << "-vcodec" << codec
+# Start all encoders
+for enc in encoders
+  enc.start_job(size)
 end
 
-ffmpeg_args += fargs
-ffmpeg_args << target
-
-encoder = IO::popen(ffmpeg_args, "wb")
-
 format = if store_all 
            "#{tmpdir}/file-%04d"
          else
@@ -218,36 +266,35 @@ for f in args
   puts "Running: #{ct2_cmdline.join(" ")}"
   system(*ct2_cmdline)
 
+  b = nil
+
   if use_pdftoppm
-    # @todo use other conversion programs !
     b1, s = Open3.capture2(
                           "pdftoppm",
                           "-r",
                           "#{(conv*oversampling).to_i}",
                            "#{name}.pdf",
                           :stdin_data=>"", :binmode=>true)
-    # @todo use other conversion programs !
     b, s = Open3.capture2("convert",
                           "PPM:-",
-                          "-resize", size,
+                          "-resize", "#{size}!",
                           "-depth", "8", "YUV:-",
                           :stdin_data=>b1, :binmode=>true)
   else
-    
-    # @todo use other conversion programs !
     b, s = Open3.capture2("convert",
                           "-density", "#{(conv*oversampling).to_i}",
                           "#{name}.pdf",
                           "-alpha", "Remove",
-                          "-resize", size,
+                          "-resize", "#{size}!",
                           "-depth", "8", "YUV:-",
                           :stdin_data=>"", :binmode=>true)
-    
-    # Use pdftoppm followed by convert, much much faster than just
-    # convert (gs takes too much time)
   end
-  encoder.write(b)
+  for enc in encoders
+    enc.write_frame(b)
+  end
   index += 1
 end
 
-encoder.close
+for enc in encoders
+  enc.close
+end

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

@@ -303,7 +303,7 @@ module CTioga2
               when String       # plain URL target
                 link = "#{it.target}"
               else
-                raise "The link target should be either a group, a command or a type, but is a #{it.target.class}"
+                raise "The link target should be either a group, a command or a type, but is a #{it.target.class} (#{it.dbg.inspect})"
               end
               str << "<a href='#{link}'>#{it.to_s}</a>"
             when MarkedUpText::MarkupItemize

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

@@ -128,6 +128,47 @@ module CTioga2
           end
         end
 
+        # Lists all the stylistic things, and in particular the names
+        # of color sets, marker sets and the like.
+        #
+        # This function will hold more data with time.
+        def list_styles
+
+          puts "Available color sets:"
+          sets = Graphics::Styles::CurveStyleFactory::parameters['line_color'].sets
+          set_names = sets.keys.sort
+
+          sets_by_prefix = Utils.group_by_prefix(set_names, /(.*?)\d+$/)
+
+
+          for pref in sets_by_prefix.keys.sort
+            vals = Utils.suffix_numeric_sort(sets_by_prefix[pref])
+            puts " * #{vals.join(", ")} "
+          end
+
+          puts "\nAvailable marker sets:"
+          sets = Graphics::Styles::CurveStyleFactory::parameters['marker_marker'].sets
+          set_names = sets.keys.sort
+
+          sets_by_prefix = Utils.group_by_prefix(set_names, /(.*?)\d+$/)
+          for pref in sets_by_prefix.keys.sort
+            vals = Utils.suffix_numeric_sort(sets_by_prefix[pref])
+            puts " * #{vals.join(", ")} "
+          end
+
+          puts "\nAvailable line style sets:"
+          sets = Graphics::Styles::CurveStyleFactory::parameters['line_style'].sets
+          set_names = sets.keys.sort
+
+          sets_by_prefix = Utils.group_by_prefix(set_names, /(.*?)\d+$/)
+          for pref in sets_by_prefix.keys.sort
+            vals = Utils.suffix_numeric_sort(sets_by_prefix[pref])
+            puts " * #{vals.join(", ")} "
+          end
+
+
+        end
+
 
         protected 
 
@@ -200,6 +241,17 @@ EOH
       ListTypesCmd.describe("List known types",
                              <<EOH, IntrospectionGroup)
 List all types known to ctioga2
+EOH
+
+      ListStylesCmd = 
+        Cmd.new('list-styles', nil, '--list-styles',
+                [], RawOption) do |p, opts|
+        Introspection.new.list_styles()
+      end
+
+      ListStylesCmd.describe("List stylistic information",
+                             <<EOH, IntrospectionGroup)
+Lists all available color sets, marker sets and the like.
 EOH
 
       EditCommandCmd = 

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

@@ -106,11 +106,15 @@ module CTioga2
         class MarkupLink < MarkupItem
           # The object target of the link
           attr_accessor :target
+
+          # For error reporting
+          attr_reader :dbg
           
           # _target_ is the name of the target, which can be of _type_
           # 'group', 'command', 'backend', 'type', 'function' and 'url'
           def initialize(doc, target, type)
             super(doc)
+            @dbg = [target, type]
             if type =~ /url/
               @target = target
             else

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

@@ -87,6 +87,25 @@ EOH
 Runs the given strings as commands, as if given from a command file.
 EOH
 
+
+    # Runs a ruby file
+    RunRubyFile = 
+      Cmd.new("ruby-run", nil, "--ruby-run", 
+              [ CmdArg.new('file')], 
+              {}
+              ) do |plotmaker, file, opts|
+      # Work around bug on windows !
+      file = Utils::transcode_until_found(file)
+      Ruby::run_file(file)
+    end
+    
+    RunRubyFile.describe("Run as Ruby code", <<EOH, GeneralGroup)
+Reads the file and runs the Ruby code found inside, a bit like
+Ruby would do with the @require@ command, excepted that @ctioga2@
+does not follow Ruby's file searching rules: you have to specify the
+full path.
+EOH
+
     # Evaluate a series of commands.
     SetCommand =  Cmd.new("set", nil, "--set", 
                           [ CmdArg.new('text'), 

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

@@ -19,7 +19,7 @@ module CTioga2
   module Commands
 
     FuncEval = Function.new("eval", "Evaluate Ruby code") do |pm, code|
-      eval(code)
+      Ruby::run_code(code)
     end
 
     FuncEval.describe <<EOD
@@ -35,6 +35,10 @@ They have no type. In particular, while this will work:
 # b := $(eval $(a) * 3)
 # # b is now 9
 
+However, you need to use quotes if you must call functions:
+
+# b := $(eval sqrt(2))
+
 Doing the same kind of things with text will be somewhat not satisfying:
 
 # a := "two words"
@@ -65,6 +69,8 @@ EOD
         point.y.to_s
       when "xy", "XY"
         "%g,%g" % point.point
+      when "index", "idx"
+        point.index
       else
         # The \ are not strictly speaking necessary, but they make
         # ruby-mode happier
@@ -82,6 +88,7 @@ dataset. Run this way:
 
 The first argument, here @x@ tells what we want to know about the
 given point: its @x@ value (passing @x@), its @y@ value (passing @y@),
+its @index@ (by passing @index@ or @idx@)
 both its @x@ and @y@ ready to be used as coordinates for drawing
 commands using @xy@. For instance, to draw a circle marker right in
 the middle of the last dataset plotted, just run

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

@@ -121,14 +121,25 @@ EOD
 
     # A color map
     ColorMapType = CmdType.new('colormap', :colormap, <<EOD)
-A Z color map
+A Z color map. It takes the form @Color1--Color2--Color3...@. All
+colors can optionally be followed by a number. For instance, for
+@Red--Blue--Pink--Green@, the colors are evenly spaced. In the case
+@Red--Blue(0.1)--Pink(0.2)--Green@, the Blue to Pink strech is located
+between Z values 0.1 and 0.2.
 
-\todo document !
+If a prefix @hls:@ or @wheel:@ is present, then linear interpolation
+is done in the HLS colorspace instead of the RGB one (the default).
+
+If a suffix @:sym:@_value_ is present, then the colormap is symmetric
+around that value.
+
+It is also possible to directly use a {type: color-set}, in which case
+eveything works as if the colors of the {type: color-set} had been
+given directly, without Z values.
 EOD
 
     # This ones get here since they mess up with syntax highlighting
 
-
     # A stored dataset.
     StoredDatasetType = CmdType.new('stored-dataset', 
                                     :string, <<EOD)

data/lib/ctioga2/commands/parsers/file.rb

@@ -71,6 +71,7 @@ module CTioga2
           idx = 0
           
 
+          has_ruby = false
           ## @todo line counting ?
           for l in lines
             idx += 1
@@ -81,8 +82,10 @@ module CTioga2
             ## or make it more accurate ? The problem is that in a
             ## large command file, there may be things that look like
             ## old style commands ?
-            
-            if l =~ /^([a-z0-9-]+)\(/
+
+            if l =~ /^\s*ruby\s*$/
+              has_ruby = true
+            elsif l =~ /^([a-z0-9-]+)\(/ && (!has_ruby)
               path = io.respond_to?(:path) ? io.path : io.to_s
               warn { "Found old style (deprecated) commands in '#{path}', using old style parser"}
               return OldFileParser.new.
@@ -112,10 +115,24 @@ module CTioga2
 
           # Now, we rearrange the lines...
           idx = -1
+          ruby = false
           for l in parsed_lines
             idx += 1
             interpreter.context.parsing_file(nil, io, lines_indices[idx])
-            if l =~ /^\s*([a-zA-Z0-9_-]+)\s*(\??)(=|:=)\s*(.*)/
+            if l =~ /^\s*ruby\s*$/
+              ruby = ""
+            elsif ruby
+              if l =~ /^\s*ruby\s+end\s*$/
+                begin
+                  Ruby.run_code(ruby)
+                  ruby = false
+                rescue Exception => e
+                  fatal { "Error #{e.inspect} running inline Ruby code at #{interpreter.context}" }
+                end
+              else
+                ruby << l
+              end
+            elsif l =~ /^\s*([a-zA-Z0-9_-]+)\s*(\??)(=|:=)\s*(.*)/
               symbol = $1
               value = InterpreterString.parse_until_unquoted(StringIO.new($4),"\n", false)
               override = !($2 == '?')