gfdnavi 1.3.0.0

data/app/helpers/analysis_helper.rb

@@ -0,0 +1,2 @@
+module AnalysisHelper
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,105 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+
+  @@locale = 'en'  # or 'ja' etc etc
+  def self.locale= (locale)
+    @@locale = locale
+  end
+
+  def render_erb(src)
+    ::ERB.new(src).result(binding)
+  end
+
+  def relative_url_root
+    if ActionController::Base.respond_to?(:relative_url_root)
+      # for >= 2.2.2
+      return ActionController::Base.relative_url_root  || ""
+    elsif controller.request.respond_to?(:relative_url_root)
+      # for < 2.2.2
+      return controller.request.relative_url_root
+    else
+      raise "bug"
+    end
+  end
+
+  def help_popup(html_file_partial)
+    if base_path
+      dir = File.join(base_path, controller.controller_name)
+    elsif defined?(finder)
+      dir = File.join(finder.view_paths[0], controller.controller_name)
+    else
+      dir = File.join(view_paths.to_a[0], controller.controller_name)
+    end
+    prefix = dir + '/__help_' + html_file_partial
+    if File.exists?( path = prefix+'.'+@@locale+'.html' ) ||
+	File.exists?( path = prefix+'.html' ) || 
+	File.exists?( path = prefix+'.en.html' )
+      help_text = File.read( path )
+    else
+      help_text = '[BUG] Sorry, no help text was found for '+html_file_partial
+    end
+
+    html =<<-EOS
+      <label id='#{'help_'+html_file_partial}' style="cursor:pointer">
+      #{image_tag('helpmark16.png', :title=>'Help')}
+      </label>
+      <script>
+        new PopupMenu('#{'help_'+html_file_partial}', 
+                      '#{escape_javascript(help_text)}',
+                      'Help' );
+      </script>
+    EOS
+    html
+  end
+
+  def host_information_table
+    request = controller.request
+    html =<<-"EOS"
+      <table>
+        <tr><td>Host</td><td>#{request.host_with_port}</td></tr>
+        <tr><td>Gfdnavi Root</td><td>/#{request.relative_url_root}</td></tr>
+        <tr><td>Path</td><td>#{request.path}</td></tr>
+        <tr><td>Env</td><td>#{RAILS_ENV}</td></tr>
+        <tr><td>Server Software</td><td>#{request.server_software}</td></tr>
+      </table>
+    EOS
+    return html
+  end
+
+  def image_path(obj)
+    case obj
+    when Image, Node
+      data_dl_url(:path => obj.path.sub(/^\//,""))
+    when DiagramCache
+      url_for(:controller => 'analysis', :action => 'show_image', :id => obj.id)
+    when String
+      image_tag(obj)
+    else
+      nil
+    end
+  end
+
+  def tree_lines(dir, user, first=true)
+    lines = ""
+    if (parent = dir.parent)
+      if parent.directory_nodes(:user=>user)[-1] == dir
+        if first
+          type = "last"
+        else
+          type = "none"
+        end
+      else
+        if first
+          type = "t"
+        else
+
+          type = "tate"
+        end
+      end
+      lines += tree_lines(parent, user, false)
+      lines += image_tag("tree/#{type}.gif", :border => "0", :align => "middle", :class => "tree")+"<span class=\"tree\">\n</span>"
+    end
+    return lines
+  end
+
+end

data/app/helpers/description_helper.rb

@@ -0,0 +1,2 @@
+module DescriptionHelper
+end

data/app/helpers/function_helper.rb

@@ -0,0 +1,2 @@
+module FunctionHelper
+end

data/app/helpers/group_helper.rb

@@ -0,0 +1,2 @@
+module GroupHelper
+end

data/app/helpers/search_helper.rb

@@ -0,0 +1,3 @@
+module SearchHelper
+
+end

data/app/helpers/user_helper.rb

@@ -0,0 +1,2 @@
+module UserHelper
+end

data/app/helpers/work_flow_helper.rb

@@ -0,0 +1,92 @@
+module WorkFlowHelper
+
+  def get_input_html(name, value, write_type=true)
+    html = ""
+    javascript = ""
+    if Array === value
+      ary = get_input_html(name+[0], value[0])
+      fname = "add_#{name.join("_")}"
+      html += "["
+      html += ary[0]
+      html += ", "
+      html += "<span class=\"link\" onclick=\"#{fname}(this);\">add</span>"
+      html += "]"
+      if ary[1]
+        javascript += ary[1]
+      end
+      tmp = "tmp#{name.length}"
+      ary = get_input_html(name+[tmp], value[0], false)
+      javascript +=<<"EOF"
+window.#{fname} = function(elm) {
+  if (elm.count)
+    elm.count += 1;
+  else
+    elm.count = 1;
+  new Insertion.Before(elm,'#{ary[0]}, '.gsub('#{tmp}',elm.count));
+EOF
+      if ary[1]
+        javascript += "  eval('#{escape_javascript(ary[1])}'.gsub('#{tmp}',elm.count));\n"
+      end
+    javascript += "}\n"
+    elsif Hash === value
+      html += '<ul style="margin:0">'
+      value.each{|k,v|
+        ary = get_input_html(name+[k], v)
+        html += "<li>#{k}: "
+        html += ary[0]
+        if ary[1]
+          javascript += ary[1]
+        end
+      }
+      html += '</ul>'
+    elsif value == "string"
+      if write_type
+        html += "(#{value})"
+      end
+      html += text_field_tag("apis[api_id][#{name.join("][")}]")
+    elsif value == "int" || value == "float" || value == "double"
+      if write_type
+        html += "(#{value})"
+      end
+      html += text_field_tag("apis[api_id][#{name.join("][")}]", nil, :size=>5)
+    elsif value == "boolean"
+      html += select_tag("apis[api_id][#{name.join("][")}]", "<option></option><option>true</option><option>false</option>")
+    elsif
+      if write_type
+        html += "(#{value})"
+      end
+      html += text_field_tag("apis[api_id][#{name.join("][")}]")
+    end
+    return html, javascript=="" ? nil : javascript
+  end
+
+  def get_output_text(value, type, name="")
+    if Array === value
+      case type
+      when "html"
+        return "[#{get_output_text(value[0], type)}]"
+      when "list"
+        ary = Array.new
+        3.times{|i|
+          ary[i] = get_output_text(value[0], type, name+"[#{i}]")
+        }
+        return ary.join(",")
+      end
+    elsif Hash === value
+      case type
+      when "html"
+        return "{#{value.collect{|k,v| k+"=>"+get_output_text(v,type)}.join(", ")}}"
+      when "list"
+        return value.collect{|k,v| get_output_text(v,type,name+"[#{k}]")}.join(", ")
+      end
+    else
+      case type
+      when "html"
+        return "(#{value})"
+      when "list"
+        return "'(#{value})#{name}'"
+      end
+    end
+  end
+
+end

data/app/models/actual_file.rb

@@ -0,0 +1,3 @@
+class ActualFile < ActiveRecord::Base
+  belongs_to :variable
+end

data/app/models/analysis.rb

@@ -0,0 +1,715 @@
+require "numru/gphys"
+require "no_rdb_base"
+require "vizshot_gfdnavi"
+
+class AnalysisColumn < ActiveRecord::ConnectionAdapters::Column
+
+  def type_cast_code(var_name)
+    case type
+    when :array
+      "#{self.class.name}.value_to_array(#{var_name})"
+    when :array_int
+      "#{self.class.name}.value_to_array(#{var_name}, :int)"
+    when :array_float
+      "#{self.class.name}.value_to_array(#{var_name}, :float)"
+    when :model
+      "#{self.class.name}.value_to_model(#{var_name})"
+    else
+      super("(#{var_name}=='NULL' ? nil : #{var_name})")
+    end
+  end
+
+  def self.value_to_array(value, val_type=nil)
+    if Array === value
+      ary = value
+    elsif Hash === value
+      ary = Array.new
+      value.each{|k,v|
+        ary[k.to_i] = v
+      }
+    elsif String === value
+      ary = value.split(/,/)
+    else
+      ary = [value]
+    end
+    case val_type
+    when :int
+      ary.collect!{|v| v.to_i}
+    when :float
+      ary.collect!{|v| v.to_f}
+    end
+    return ary
+  end
+
+  def self.value_to_model(value)
+    return nil if value.nil? || value[:name].nil?
+    if Hash === value && value[:class]
+      case value[:class]
+      when "user"
+        return User.find_by_login(value[:name])
+      when "function"
+        return Function.find(:first, :conditions=>["name=?",value[:name]], :user=>value[:user])
+      when "draw_method"
+        return DrawMethod.find(:first, :conditions=>["name=?",value[:name]], :user=>value[:user])
+      end
+    else
+      raise "a model is expected"
+    end
+  end
+
+  def default
+    Array===@default ? @default.dup : @default
+  end
+    
+
+  private
+  def simplified_type(type)
+    case type
+    when /array_int/i
+      :array_int
+    when /array_float/i
+      :array_float
+    when /array/i
+      :array
+    when /model/i
+      :model
+    else
+      super(type)
+    end
+  end
+
+end
+
+class Analysis < ActiveRecord::NoRdbBase
+
+  ACTION_TYPE = %w( draw analysis )
+
+  DRAW_PROJECTION = {1 => "rectangular uniform coordinate",
+                     2 => "semi-logarithmic coordinate (y axis)",
+                     3 => "semi-logarithmic coordinate (x axis)",
+                     4 => "logarithmic coordinate",
+                     5 => "polar coordinate",
+                     6 => "bipolar coordinate",
+#                     7 => "elliptic coordinate",
+                     10 => "equidistant cylindrical projection",
+                     11 => "Mercator's projection",
+                     12 => "Mollweide's projection",
+                     13 => "Hammer's projection",
+                     14 => "Eckert VI projection",
+                     15 => "Kitada's elliptic projection",
+                     20 => "equidistant conical projection",
+                     21 => "Lambert's equal-area conical projection",
+                     22 => "Lambert's conformal conical projection",
+                     23 => "Bonne's projection",
+                     30 => "orthographic projection",
+                     31 => "polar stereo projection",
+                     32 => "azimuthal equidistant projection",
+                     33 => "Lambert's azimuthal equal-area projection"
+                    }
+
+  DRAW_SIZE = [[700,700], [550,550], [400,400], [250,250]]
+
+
+  common_attrs =
+    [
+     {:name => "variables", :default => [], :type => "array"},
+     {:name => "action_type", :default => ACTION_TYPE.index("draw"), :type => "int"}
+    ]
+  draw_attrs =
+    [
+     {:name => "draw_share", :default => true, :type => "boolean"},
+     {:name => "draw_method", :type => "model"},
+     {:name => "x_axis", :type => "string"},
+     {:name => "y_axis", :type => "string"},
+     {:name => "z_axis", :type => "string"},
+     {:name => "draw_projection", :default => 1, :type => "int"},
+     {:name => "region", :default => {}, :type => "hash"},
+     {:name => "draw_pileup", :default => false, :type => "boolean"},
+     {:name => "draw_keep", :default => false, :type => "boolean"},
+     {:name => "draw_size", :default => 1, :type => "int"},
+     {:name => "anim", :default => false, :type => "boolean", :optional => true},
+     {:name => "anim_dim", :type => "string", :optional => true},
+     {:name => "viewport", :default => "0.2, 0.8, 0.2, 0.8", :type => "array_float", :optional => true},
+     {:name => "draw_variables_order", :default => [], :type => "array", :optional => true},
+     {:name => "map", :default => false, :type => "boolean", :optional => true}
+    ]
+  function_attrs =
+    [
+     {:name => "function", :type => "model"},
+     {:name => "function_arguments", :default => [], :type => "array"},
+     {:name => "function_variables_order", :default => [], :type => "array"}
+    ]
+
+  @@minmaxs =
+    {
+    "action_type" => [0, ACTION_TYPE.length-1],
+    "draw_size" => [0, DRAW_SIZE.length-1]
+  }
+
+  push_column AnalysisColumn.new("user", nil, "model", true)
+  (common_attrs +
+   draw_attrs +
+   function_attrs
+   ).each{ |hash|
+    push_column AnalysisColumn.new(hash[:name], hash[:default], hash[:type], hash[:optional]==true )
+  }
+  if ActiveRecord::Base.connection.tables.include?("nodes")
+    DrawMethod.find(:all, :user=>:all).each{|dm|
+      dm.draw_method_attributes.each{|dma|
+        push_column AnalysisColumn.new( "#{dm.name}_#{dma.name}", dma.default=="NULL"?nil : dma.default, dma.value_type.name, dma.optional)
+      }
+    }
+  end
+
+  def write_attribute(attr_name, value)
+    case attr_name.to_s
+    when "function"
+      unless Function === value
+        value =  Function.find(:first, :conditions=>["name=?",value], :user=>user)
+      end
+      value = {:class => "function", :name => value && value.name, :user => user}
+    when "draw_method"
+      unless DrawMethod === value
+        value = DrawMethod.find(:first, :conditions=>["name=?",value], :user=>user)
+      end
+      value = {:class => "draw_method", :name => value && value.name, :user => user}
+    when "user"
+      unless User === value
+        value = User.find_by_login(value)
+      end
+      value = {:class => "user", :name => value && value.login}
+    when "draw_variables_order"
+      value = variables_order(value)
+    when "function_variables_order"
+      value = variables_order(value)
+    end
+
+    value = nil if value == "NULL"
+
+    super(attr_name, value)
+
+    if (minmax = @@minmaxs[attr_name.to_s])
+      val = read_attribute(attr_name)
+      if val < minmax[0]
+        write_attribute(attr_name, minmax[0].to_s)
+      elsif val > minmax[1]
+        write_attribute(attr_name, minmax[1].to_s)
+      end
+    end
+    xa = read_attribute("x_axis")
+    ya = read_attribute("y_axis")
+    za = read_attribute("z_axis")
+    ad = read_attribute("anim") && read_attribute("anim_dim")
+    case attr_name.to_s
+    when "x_axis"
+=begin
+      if xa
+        if xa == ya
+          write_attribute("y_axis", nil)
+        elsif xa == za
+          write_attribute("z_axis", nil)
+        elsif xa == ad
+          write_attribute("anim_dim", nil)
+        end
+      end
+=end
+    when "y_axis"
+=begin
+      if ya
+        if ya == xa
+          write_attribute("x_axis", nil)
+        elsif ya == za
+          write_attribute("z_axis", nil)
+        elsif ya == ad
+          write_attribute("anim_dim", nil)
+        end
+      end
+=end
+    when "z_axis"
+=begin
+      if za
+        if za == xa
+          write_attribute("x_axis", nil)
+        elsif za == ya
+          write_attribute("y_axis", nil)
+        elsif ya == ad
+          write_attribute("anim_dim", nil)
+        end
+      end
+=end
+    when "anim_dim"
+=begin
+      if ad
+        if ad == xa
+          write_attribute("x_axis", nil)
+        elsif ad == ya
+          write_attribute("x_axis", nil)
+        elsif ad == za
+          write_attribute("z_axis", nil)
+        end
+      end
+=end
+    when "draw_projection"
+      unless DRAW_PROJECTION[value.to_i]
+        write_attribute("draw_projection", "1")
+      end
+    when "viewport"
+      unless viewport.length==4
+        write_attribute("viewport", Analysis.columns_hash["viewport"].default)
+      end
+    end
+  end
+
+  def variables
+    user_model = user && User.find_by_login(user)
+    vars = read_attribute("variables")
+    vars.each{|var|
+      next if var.new_record?
+      unless var.other_mode==4 || ( user_model && (var.rgroups & user_model.groups) )
+        raise "an invalid variable was set"
+      end
+    }
+    return vars
+  end
+
+  def draw_methods
+    dm = read_attribute("draw_method")
+    return dm if dm.nil?
+    user_model = user && User.find_by_login(user)
+    unless dm == DrawMethod.find(:first, :conditions=>["id=>",dm.node.id], :user=>user_model)
+      raise "an invalid draw method was set"
+    end
+    return dm
+  end
+
+  def functions
+    func = read_attribute("function")
+    return func if func.nil?
+    user_model = user && User.find_by_login(user)
+    unless func ==  Function.find(:first, :conditions=>["id=?",func.id], :user=>user_model)
+      raise "an invalid function was set"
+    end
+    return func
+  end
+
+
+  def variable_clear
+    @dimensions = nil
+    %w( variables region x_axis y_axis z_axis draw_variables_order function_variables_order ).each{|name|
+      column = column_for_attribute(name)
+      default = column.default
+      self[name] = default
+    }
+  end
+
+  def file_and_variable_names
+    variables.collect do |var|
+      [fname, vname]
+    end
+  end
+
+  def gphyses
+    variables.collect do |var|
+      var.gphys
+    end
+  end
+
+  def dimensions
+    unless @dimensions
+      axes = Hash.new
+      @dimensions = Array.new
+      self.gphyses.each{|gp|
+        gp.rank.times do |i|
+          ax = gp.axis(i)
+          ax_name = ax.name
+          if axes[ax_name]
+            ind, units, ary = axes[ax_name]
+            pos = ax.pos
+            ary2 = pos.val
+            unless pos.units == units
+              begin
+                factor,offset = Units.new(units).factor_and_offset(Units.new(pos.units))
+                ary2 = ary*factor + offset
+              rescue
+              end
+            end
+            ary += ary2.to_a
+            ary.sort!.uniq!
+            axes[ax_name] = [ind, units, ary]
+          else
+            pos = ax.pos
+            axes[ax_name] = [axes.length, pos.units, pos.val.to_a]
+          end
+        end
+        axes.each do |name, ary|
+          @dimensions[ary[0]] = {:name => name, :units => ary[1], :ary => ary[2]}
+        end
+      }
+    end
+    return @dimensions
+  end
+
+  def index
+    dims = region
+    if region.length == 0
+      dims = Hash.new
+      dimensions.each{|dim|
+        dims[dim[:name]] = {"min"=>dim[:ary][0], "max"=>dim[:ary][-1]}
+      }
+    end
+    twoD = dimensions.length > 1
+    threeD = dimensions.length > 2
+    dim0 = dimensions[0][:name]
+    dim1 = dimensions[1][:name] if twoD
+    dim2 = dimensions[2][:name] if threeD
+    unless x_axis
+      xa = dim0
+      xa = (twoD && y_axis==xa) ? dim1 : xa
+      xa = (threeD && z_axis==xa) ? dim2 : xa
+      self.x_axis = xa
+    end
+    if twoD && !y_axis
+      ya = dim1
+      ya = x_axis==ya ? dim0 : ya
+      ya = (threeD && z_axis==ya) ? dim2 : ya
+      self.y_axis = ya
+    end
+    if threeD && !z_axis
+      za = dim2
+      za = y_axis==za ? dim1 : za
+      za = x_axis==za ? dim0 : za
+      self.z_axis = za
+    end
+    hash = Hash.new
+    dims.each do |name,range|
+      if ACTION_TYPE[action_type]=="analysis" || (name==x_axis || (draw_method.ndims>1&&name==y_axis) || (draw_method.ndims>2&&name==z_axis))
+        min = range["min"].to_f
+        max = range["max"].to_f
+        hash[name] = min==max ? min : min..max
+      else
+        hash[name] = range["min"].to_f
+      end
+    end
+    return hash
+  end
+
+  def get_vizshots(basename)
+    options = Hash.new
+    vars = variables
+    nvars = variables.length
+    if nvars == 0
+      return [false, "at least one variable must be selected"]
+    end
+    dm_nvars = draw_method.nvars
+    if nvars%dm_nvars != 0
+      return [false, "number of variable must be multiples of #{dm_nvars}"]
+    end
+    ix = get_index_from_name(x_axis)
+    iy = get_index_from_name(y_axis)
+    iz = get_index_from_name(z_axis)
+
+    options[:method] = draw_method.vizshot_method.to_sym
+    options.update( get_vizshot_options )
+    options["transpose"] = true if draw_method.ndims>1 && ix && iy && ix > iy
+    options[:cut] = index
+
+    size = Analysis::DRAW_SIZE[draw_size]
+    vizs = Array.new
+    nfig = nvars/dm_nvars
+    nfig.times{|n|
+      if dm_nvars == 2
+        options[:variables] = [ vars[draw_variables_order[n][0]].path, vars[draw_variables_order[n][1]].path ]
+      else
+        options[:variables] = [ vars[n].path ]
+      end
+      if draw_pileup && vizs[0]
+        viz = vizs[0]
+      else
+        viz = NumRu::VizShot.new(:iwidth => size[0], :iheight => size[1], :basename => basename)
+        viz.set_fig('itr' => draw_projection, 'viewport' => viewport)
+        unless draw_projection == 5
+          viz.set_tone('tonf' => true )
+        end
+        vizs.push viz
+      end
+      viz.plot( options.dup )
+    }
+    return [true, vizs]
+  end
+
+
+
+
+  def diagram_label
+    label = draw_method.name
+    label += ", #{region[x_axis][:name]}(#{region[x_axis]["min"]}:#{region[x_axis]["max"]})"
+    if draw_method.ndims > 1
+      label += " vs #{region[y_axis][:name]}(#{region[y_axis]["min"]}:#{region[y_axis]["max"]})"
+    end
+    if draw_method.ndims > 2
+      label += " vs #{region[z_axis][:name]}(#{region[z_axis]["min"]}:#{region[z_axis]["max"]})"
+    end
+    tmp = Array.new
+    dimensions.each{|dim|
+      name = dim[:name]
+      next if name==x_axis
+      next if draw_method.ndims>1 && name==y_axis
+      next if draw_method.ndims>2 && name==z_axis
+      tmp.push "#{name}=#{region[name]["min"]}" if region[name]
+    }
+    label += " @ "+tmp.join(",") unless tmp.length==0
+    return label
+  end
+
+
+  def self.from_vizshot(viz)
+    if viz && (par = parse_vizshot(viz))
+      vars, params = par
+      analysis = Analysis.new
+      vars.each{|var|
+        analysis.variables.push var
+      }
+      analysis.action_type = ACTION_TYPE.index("draw")
+      params.each{|name,val|
+        analysis.send(name+"=", val)
+      }
+      return analysis
+    else
+      return nil
+    end
+  end
+
+
+  def self.uri_params_from_vizshot(viz)
+    if viz && (par = parse_vizshot(viz))
+      vars, params = par
+      ary = Array.new
+      vars.each{|var|
+        ary.push "variables[#{var.path}]=1"
+      }
+      ary.push "action_type=draw"
+      params.each{|name,val|
+        ary += param_to_str("analysis[#{name}]",val)
+      }
+      #    params.collect{|str| str.gsub(/[/,"%5B").gsub(/]/,"%5D")}.join("&")
+      URI.escape( ary.join("&") )
+    else
+      return nil
+    end
+  end
+
+
+
+  private
+  def self.parse_vizshot(viz)
+    if viz.get_variables.length == 0
+      return nil
+    end
+
+    plots = viz.get_plots
+    plots.each{|plot|
+      plot.each{|k,v|
+        plot[k.to_sym] = v if String === k
+      }
+    }
+    vars = Array.new
+    viz.get_variables.each{|var|
+      # return nil unless var.id   # commented out by horinout on 2007-06-28
+      vars.push var
+    }
+
+    params = Array.new
+
+    cut = plots[0][:cut]
+=begin
+    plots.each{|plot|
+      unless cut == plot[:cut]
+        raise "different cuts exist"
+      end
+    }
+=end
+    if Array === cut
+      gphys = vars[0].gphys
+      cut_ary = Array.new
+      gphys.rank.times{|i|
+        name = gphys.coord(i).name
+        cut_ary.push  [name, cut[i]]
+      }
+    else Hash === cut
+      gphys = vars[0].gphys
+      cut_ary = Array.new
+      gphys.rank.times{|i|
+        name = gphys.coord(i).name
+        cut_ary.push  [name, cut[name]]
+      }
+    end
+    reg = Hash.new
+    axes = Array.new
+
+    cut_ary.each{|name,range|
+      case range
+      when Range
+        reg[name] = {"min"=>range.first,"max"=>range.last}
+        axes.push name
+      when Numeric
+        reg[name] = {"min"=>range}
+      else
+        raise "[BUG]"
+      end
+    }
+
+    params.push ["region", reg]
+
+    method = plots[0][:method].to_s
+    draw_method = Node.find_draw_methods(:first, :conditions => ["vizshot_method=?",method]).entity
+    plots.each{|plot|
+=begin
+      unless method == plot[:method].to_s
+        raise "[BUG]"
+      end
+=end
+    }
+    unless draw_method.ndims == axes.length
+      raise "[BUG]"
+    end
+
+    params.push ["draw_method", draw_method.name]
+
+    axes = [axes[1],axes[0]] if draw_method.ndims>1 && plots[0][:transpose]
+    params.push ["x_axis", axes[0]]
+    params.push ["y_axis", axes[1]] if draw_method.ndims > 1
+    params.push ["z_axis", axes[2]] if draw_method.ndims > 2
+    params.push ["draw_projection", viz.get_itr]
+    params.push ["viewport", viz.get_viewport]
+
+    isize = DRAW_SIZE.index(viz.get_size)
+    unless isize
+      raise "[BUG]"
+    end
+    params.push ["draw_size", isize]
+
+    params += get_params_from_vizshot_plot(draw_method,plots[0])
+    if draw_method.ndims == 2
+      params.push ["draw_variables_order", {0 => {0=>0,1=>1}}]
+    end
+
+    return [vars, params]
+  end
+
+
+  def self.param_to_str(name, val)
+    ary = Array.new
+    case val
+    when String
+      ary.push "#{name}=#{val}"
+    when Numeric
+      val = val.to_i if Float === val && val.to_i == val
+      ary.push "#{name}=#{val}"
+    when TrueClass
+      ary.push "#{name}=1"
+    when FalseClass
+      ary.push "#{name}=0"
+    when Array
+      ary.push "#{name}=#{val.join(',')}"
+    when Hash
+      val = val.sort{|a,b|
+        if String===a
+          if a=="min"
+            return -1
+          elsif a=="max"
+            return 1
+          end
+        end
+        a <=> b
+      }
+      val.each{|k,v|
+        ary += param_to_str("#{name}[#{k}]", v)
+      }
+    else
+      ary.push "#{name}=#{val.inspect}"
+    end
+    return ary
+  end
+
+
+  def self.get_params_from_vizshot_plot(draw_method,plot)
+    ary = Array.new
+    draw_method.draw_method_attributes.each{|attr|
+      case attr.parser
+      when :vizshot, "vizshot"
+        name = attr.name.to_sym
+      when :ggraph, "ggraph"
+        name = attr.name
+      else
+        next
+      end
+      val = plot[name]
+      ary.push(["#{draw_method.name}_#{attr.name}",val]) if val
+    }
+    return ary
+  end
+
+
+
+  def variables_order(val)
+    unless Hash === val
+      return nil
+    end
+    variables_order = Hash.new
+    val.each{|k,v|
+      if Hash === v
+        tmp = Array.new
+        v.each{|k1,v1|
+          tmp[k1.to_i] = v1.to_i
+        }
+        variables_order[k.to_i] = tmp
+      else
+        return nil
+      end
+    }
+    ary = variables_order.values.flatten
+    unless ary.max == ary.length-1
+      return nil
+    end
+    ary.length.times{|i|
+      unless ary.include?(i)
+        return nil
+      end
+    }
+    return variables_order
+  end
+
+
+  def get_vizshot_options
+    hash = Hash.new
+    draw_method.draw_method_attributes.each{|attr|
+      case attr.parser
+      when :vizshot, "vizshot"
+        name = attr.name.to_sym
+      when :ggraph, "ggraph"
+        name = attr.name
+      else
+        next
+      end
+      val = self.send("#{draw_method.name}_#{attr.name}")
+      if !val.nil? && val!=[] && val!=""
+        hash[name] = val
+      elsif !attr.optional
+        raise "#{attr.name} of #{draw_method.name} cannot not be omitted"
+      end
+    }
+    return hash
+  end
+
+  def get_index_from_name(name)
+    dimensions.each_with_index{|dim,i|
+      if dim[:name] == name
+        return i
+      end
+    }
+    return nil
+  end
+
+
+
+end