ctioga2 0.8 → 0.9

data/Changelog

@@ -1,3 +1,18 @@
+ctioga2 (0.9)
+
+  * A --set command to set variable values from the command-line
+  * A basic ct2-make-movie script to facilitate the construction of movies
+    from a ctioga2 plot
+  * Definition of variables using ?= and ?:= that do not erase the
+    contents of variables if they already exist
+  * Makefile-like functions: eval and point
+  * More control on the position of major and minor ticks
+  * Automatic detection of text size for titles, labels and the like
+  * Minor bug fixes and documentation updates
+  * Now default to 6bp padding
+
+ -- Vincent <vincent.fourmond@9online.fr>  Thu  6 Feb 21:19:34 CET 2014
+
 ctioga2 (0.8)
 
   * New plot type for making histograms (including cumulative histograms)

data/bin/ct2-make-movie

@@ -0,0 +1,253 @@
+#!/usr/bin/env ruby
+
+=begin rdoc
+
+This program is copyright 2014 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.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+=end
+
+
+# This program is a wrapper around ctioga2 to make it easy to make
+# movies.
+
+require 'open3'
+require 'fileutils'
+require 'optparse'
+
+require 'shellwords'
+
+# Path to ctioga2 executable
+ct2 = "ctioga2"
+
+
+tmpdir = "tmp"
+target = nil
+
+DimensionConversion = {
+  "pt" => (72.0/72.27),
+  "bp" => 1.0,
+  "in" => 72.0,
+  "cm" => (72.0/2.54),
+  "mm" => (72.0/25.4),
+}
+
+def dim_to_points(dim)
+  if dim =~ /^\s*(\d+(\.\d*)?)\s*(pt|bp|cm|in|mm)\s*$/i
+    return $1.to_f * DimensionConversion[$3.downcase]
+  else
+    raise "Invalid dimension: #{dim}"
+  end
+end
+
+# Converts the given "real-size" resolution into postscript points
+def page_size_to_points(spec)
+  if spec =~ /(.*)x(.*)/i
+    return [dim_to_points($1), dim_to_points($2)]
+  else
+    raise "Invalid page size: #{spec}"
+  end
+end
+
+# @todo Build a movie from a list of PDF files. Maybe less error
+# checking than directly.
+
+# The target resolution
+res = [600,600]
+
+# The target page size (in bp)
+ct2_size = nil
+
+# The corresponding number of points
+
+# The conversion factor (between points and inches)
+conv = 250.0
+
+# The oversampling factor (to get something smooth in the end)
+oversampling = 2
+
+# Whether we use pdftoppm or not for the conversion. Much faster than
+# convert
+use_pdftoppm = false
+
+# Whether we keep all intermediate PDF files, or we reuse the same
+# file over and over again.
+store_all = true
+
+# Codec for ffmpeg
+codec = nil
+
+# Bitrate for ffmpeg
+bitrate = nil
+
+fargs = []
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #$0 [options] file.ct2 arguments..."
+
+  opts.on("-t", "--target FILE", "Target video file") do |t|
+    target = t
+  end
+
+  opts.on("", "--dir DIR", "Temporary directory for storage") do |t|
+    tmpdir = t
+  end
+
+  opts.on("", "--version", "Prints version string") do 
+    puts "0.0"
+  end
+
+  opts.on("-p", "--[no-]pdftoppm", "Whether or not to use pdftoppm") do |t|
+    use_pdftoppm = t
+  end
+
+  opts.on("", "--page-size SIZE", 
+          "Set ctioga2 page size (in TeX dimensions)") do |v|
+    ct2_size = page_size_to_points(v)
+  end
+
+  opts.on("", "--resolution RES",
+          "Set target resolution (overridden to some extent by page-size)") do |r|
+    r =~ /(\d+)x(\d+)/
+    res = [$1.to_f, $2.to_f]
+  end
+
+  opts.on("", "--[no-]store", "To store all or not..") do |v|
+    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
+
+opts.parse!(ARGV)
+
+# First, we choose the target page size and resolution. 
+
+if ct2_size
+  ct2_page_size = ct2_size.map { |x| "#{x}bp" }.join("x") 
+  # maintain aspect ratio
+  res[1] = res[0] * ct2_size[1]/ct2_size[0]
+  conv = res[0]/ct2_size[0] * 72.27
+else
+  ct2_page_size = res.map { |x| "#{x/conv}in"}.join("x")
+end
+
+size = res.map { |x| "#{x.to_i}"}.join("x")
+
+puts "Producing #{ct2_page_size} PDF and converting to #{size} for the video"
+
+
+file = ARGV.shift
+target ||= file.sub(/(\.ct2)?$/, ".avi")
+args = []
+
+for a in ARGV
+  # Expansion !
+  if a =~ /^(.*)\.\.(.*):(\d+)\s*$/
+    s = $1.to_f
+    e = $2.to_f
+    nb = $3.to_i
+    nb.times do |i|
+      args << "#{s + (e-s)*i/(nb-1.0)}"
+    end
+  else
+    args << a
+  end
+end
+
+
+FileUtils::mkpath(tmpdir)
+
+# Now, we compute the ctioga2 real size 
+
+
+# @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
+end
+
+ffmpeg_args += fargs
+ffmpeg_args << target
+
+encoder = IO::popen(ffmpeg_args, "wb")
+
+format = if store_all 
+           "#{tmpdir}/file-%04d"
+         else
+           "#{tmpdir}/file"
+         end
+
+
+index = 0
+for f in args
+  name = format % index
+
+  ct2_cmdline = [ct2, 
+                 "--set", "arg", f, 
+                 "--set", "index", "#{index}", 
+                "-f", file, "--name", name, "-r", ct2_page_size]
+  puts "Running: #{ct2_cmdline.join(" ")}"
+  system(*ct2_cmdline)
+
+  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,
+                          "-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,
+                          "-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)
+  index += 1
+end
+
+encoder.close

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

@@ -44,6 +44,9 @@ module CTioga2
         # Wether or not to ignore blacklisted commands
         attr_accessor :ignore_blacklisted
 
+        # The functions
+        attr_accessor :functions
+
         # Create a Doc object caring about the current state of
         # registered commands and such.
         def initialize
@@ -51,6 +54,7 @@ module CTioga2
           @groups = Interpreter::groups
           @types = Interpreter::types
           @backends = Data::Backends::Backend::list_backends
+          @functions = Function::functions
 
           @ignore_blacklisted = ! (ENV.key?("CT2_DEV") && 
                                    ! ENV["CT2_DEV"].empty?)

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

@@ -49,24 +49,39 @@ module CTioga2
 Writes a manual page based on a template
 EOH
 
+      WriteHTMLOptions = {
+        'page-menu' => CmdArg.new('text')
+      }
 
       WriteHTMLCommands = 
         Cmd.new("write-html-commands", nil, "--write-html-commands", 
-                []) do |plotmaker|
+                [], WriteHTMLOptions) do |plotmaker, opts|
         html = HTML.new(plotmaker.interpreter.doc)
-        html.write_commands()
+        html.write_commands(opts)
       end
       
       WriteHTMLCommands.describe("HTML documentation for group and commands",
                                  <<EOH, DocumentationGenerationGroup)
 Prints the HTML documentation for group and commands to standard output.
+EOH
+
+      WriteHTMLFunctions = 
+        Cmd.new("write-html-functions", nil, "--write-html-functions", 
+                [], WriteHTMLOptions) do |plotmaker, opts|
+        html = HTML.new(plotmaker.interpreter.doc)
+        html.write_functions(opts)
+      end
+      
+      WriteHTMLFunctions.describe("HTML documentation for functions",
+                                 <<EOH, DocumentationGenerationGroup)
+Prints the HTML documentation for functions.
 EOH
 
       WriteHTMLTypes = 
         Cmd.new("write-html-types", nil, "--write-html-types", 
-                []) do |plotmaker|
+                [], WriteHTMLOptions) do |plotmaker, opts|
         html = HTML.new(plotmaker.interpreter.doc)
-        html.write_types()
+        html.write_types(opts)
       end
       
       WriteHTMLTypes.describe("HTML documentation for types",
@@ -76,9 +91,9 @@ EOH
 
       WriteHTMLBackends = 
         Cmd.new("write-html-backends", nil, "--write-html-backends", 
-                []) do |plotmaker|
+                [], WriteHTMLOptions) do |plotmaker, opts|
         html = HTML.new(plotmaker.interpreter.doc)
-        html.write_backends()
+        html.write_backends(opts)
       end
       
       WriteHTMLBackends.describe("HTML documentation for backends",
@@ -89,9 +104,9 @@ EOH
 
       WriteHTMLCommandLineOptions = 
         Cmd.new("write-html-commandline", nil, "--write-html-commandline", 
-                []) do |plotmaker|
+                [], WriteHTMLOptions) do |plotmaker, opts|
         html = HTML.new(plotmaker.interpreter.doc)
-        html.write_command_line_options()
+        html.write_command_line_options(opts)
       end
       
       WriteHTMLCommandLineOptions.describe("HTML documentation for types",

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

@@ -46,46 +46,87 @@ module CTioga2
           @types_url = "types.html"
           @commands_url = "commands.html"
           @backends_url = "backends.html"
+          @functions_url = "functions.html"
         end
 
-        # Ouputs HTML code to document all groups and commands 
-        def write_commands(out = STDOUT)
-          cmds, groups = @doc.documented_commands
+        def write_page_menu(opts, out)
+          if !opts['page-menu'] or opts['page-menu'] =~ /menu|full/i
+            yield out
+          end
+        end
 
-          out.puts "<div class='quick-jump'>"
-          out.puts "Quick jump to a specific group of commands:\n"
-          out.puts "<ul>\n"
-          for g in groups
-            out.puts "<li><a href='#group-#{g.id}'>#{g.name}</a></li>\n"
+        def write_page(opts, out)
+          if !opts['page-menu'] or opts['page-menu'] =~ /page|full/i
+            yield out
           end
-          out.puts "</ul>\n"
-          out.puts "</div>"
+        end
+
+        def write_functions(opts, out = STDOUT)
+          funcs = @doc.functions
+          names = funcs.keys.sort
           
-          for g in groups
-            out.puts 
-            out.puts "<h3 class='group' id='group-#{g.id}'>#{g.name}</h3>"
-            out.puts markup_to_html(g.description)
+          write_page_menu(opts, out) do |out|
+            out.puts "<div class='quick-jump'>"
+            out.puts "<h3>Quick jump</h3>"
+            out.puts "<ul>\n"
+            for n in names
+              out.puts "<li><a href='#func-#{n}'>#{n}</a></li>\n"
+            end
+            out.puts "</ul>\n"
+            out.puts "</div>"
+          end
+          write_page(opts, out) do |out|
+            for n in names
+              f = funcs[n]
+              out.puts 
+              out.puts "<h3 class='function' id='func-#{n}'>#{n} - #{f.short_description}</h3>"
+              out.puts markup_to_html(f.description)
+            end
+          end
+        end
 
-            commands = cmds[g].sort {|a,b|
-              a.name <=> b.name
-            }
-            
-            out.puts "<p>"
-            out.puts "<span class='bold'>Available commands:</span>\n"
-            out.puts commands.map {|c|
-              "<a href='#command-#{c.name}'><code>#{c.name}</code></a>"
-            }.join(' ')
-            out.puts "</p>"
+        # Ouputs HTML code to document all groups and commands 
+        def write_commands(opts, out = STDOUT)
+          cmds, groups = @doc.documented_commands
 
-            for cmd in commands
-              out.puts
-              out.puts command_documentation(cmd)
+          write_page_menu(opts, out) do |out|
+            out.puts "<div class='quick-jump'>"
+            out.puts "<h3>Quick jump</h3>"
+            out.puts "<ul>\n"
+            for g in groups
+              out.puts "<li><a href='#group-#{g.id}'>#{g.name}</a></li>\n"
+            end
+            out.puts "</ul>\n"
+            out.puts "</div>"
+          end
+          
+          write_page(opts, out) do |out|
+            for g in groups
+              out.puts 
+              out.puts "<h3 class='group' id='group-#{g.id}'>#{g.name}</h3>"
+              out.puts markup_to_html(g.description)
+              
+              commands = cmds[g].sort {|a,b|
+                a.name <=> b.name
+              }
+              
+              out.puts "<p>"
+              out.puts "<span class='bold'>Available commands:</span>\n"
+              out.puts commands.map {|c|
+                "<a href='#command-#{c.name}'><code>#{c.name}</code></a>"
+              }.join(' ')
+              out.puts "</p>"
+              
+              for cmd in commands
+                out.puts
+                out.puts command_documentation(cmd)
+              end
             end
           end
         end
 
         # Write a HTML table documenting all command-line options.
-        def write_command_line_options(out = STDOUT)
+        def write_command_line_options(opts, out = STDOUT)
           cmds, groups = @doc.documented_commands
 
           out.puts "<table>"
@@ -108,52 +149,60 @@ module CTioga2
 
 
         # Ouputs HTML code to document all types
-        def write_types(out = STDOUT)
+        def write_types(opts, out = STDOUT)
           types = @doc.types.sort.map { |d| d[1]}
 
 
-          out.puts "<div class='quick-jump'>"
-          out.puts "Quick jump to a specific type:\n"
-          out.puts "<ul>\n"
-          for t in types
-            out.puts "<li><a href='#type-#{t.name}'>#{t.name}</a></li>\n"
+          write_page_menu(opts, out) do |out|
+            out.puts "<div class='quick-jump'>"
+            out.puts "<h3>Quick jump</h3>"
+            out.puts "<ul>\n"
+            for t in types
+              out.puts "<li><a href='#type-#{t.name}'>#{t.name}</a></li>\n"
+            end
+            out.puts "</ul>\n"
+            out.puts "</div>"
           end
-          out.puts "</ul>\n"
-          out.puts "</div>"
  
-          for t in types
-            out.puts
-            out.puts "<h4 id='type-#{t.name}' class='type'>#{t.name}</h4>\n"
-            out.puts markup_to_html(t.description)
-            out.puts            # There is no need to wrap the markup
-            # in a paragraph.
+          write_page(opts, out) do |out|
+            for t in types
+              out.puts
+              out.puts "<h4 id='type-#{t.name}' class='type'>#{t.name}</h4>\n"
+              out.puts markup_to_html(t.description)
+              out.puts            # There is no need to wrap the markup
+              # in a paragraph.
+            end
           end
         end
         
 
         # Ouputs HTML code to all backends
-        def write_backends(out = STDOUT)
+        def write_backends(opts, out = STDOUT)
           backends = @doc.backends.sort.map { |d| d[1]}
 
 
-          out.puts "<div class='quick-jump'>"
-          out.puts "Quick jump to a specific backend:\n"
-          out.puts "<ul>\n"
-          for b in backends
-            out.puts "<li><a href='#backend-#{b.name}'>#{b.name}</a></li>\n"
+          write_page_menu(opts, out) do |out|
+            out.puts "<div class='quick-jump'>"
+            out.puts "<h3>Quick jump</h3>"
+            out.puts "<ul>\n"
+            for b in backends
+              out.puts "<li><a href='#backend-#{b.name}'>#{b.name}</a></li>\n"
+            end
+            out.puts "</ul>\n"
+            out.puts "</div>"
           end
-          out.puts "</ul>\n"
-          out.puts "</div>"
- 
-          for b in backends
-            out.puts
-            out.puts "<h3 id='backend-#{b.name}' class='backend'><code>#{b.name}</code>: #{b.long_name}</h3>\n"
-            out.puts markup_to_html(b.description)
-            out.puts
-            for param in b.param_list
-              out.puts "<h4 id='backend-#{b.name}-#{param.name}'>Parameter: #{param.name}</h4>"
-              out.puts "<p><code>/#{param.name}=<a href='#{@types_url}#type-#{param.type.name}'>#{param.type.name}</a></p>"
-              out.puts markup_to_html(param.description)
+          
+          write_page(opts, out) do |out|
+            for b in backends
+              out.puts
+              out.puts "<h3 id='backend-#{b.name}' class='backend'><code>#{b.name}</code>: #{b.long_name}</h3>\n"
+              out.puts markup_to_html(b.description)
+              out.puts
+              for param in b.param_list
+                out.puts "<h4 id='backend-#{b.name}-#{param.name}'>Parameter: #{param.name}</h4>"
+                out.puts "<p><code>/#{param.name}=<a href='#{@types_url}#type-#{param.type.name}'>#{param.type.name}</a></code></p>"
+                out.puts markup_to_html(param.description)
+              end
             end
           end
         end
@@ -243,6 +292,8 @@ module CTioga2
               case it.target
               when Command
                 link = "#{@commands_url}#command-#{it.target.name}"
+              when Function
+                link = "#{@functions_url}#func-#{it.target.name}"
               when CommandGroup
                 link = "#{@commands_url}#group-#{it.target.id}"
               when CommandType