nyaplot 0.1.6 → 0.2.0.rc1

data/lib/nyaplot/glyph.rb

@@ -0,0 +1,227 @@
+module Nyaplot
+  module Glyph
+    class << self
+      #@example
+      # Nyaplot::Glyph.instantiate(:scatter)
+      def instantiate(df, name, hash)
+        glyph = Kernel
+          .const_get("Nyaplot")
+          .const_get("Glyph")
+          .const_get(name.to_s.capitalize)
+
+        hash[:data] = df
+        glyph.new(hash)
+      end
+    end
+
+    class Glyph2D
+      include Nyaplot::Base
+      optional_args :transform
+
+      def range(label)
+        if data[label].all? {|v| v.is_a? Numeric}
+          [data[label].min, data[label].max]
+        else
+          data[label].uniq
+        end
+      end
+
+      def range_x
+        range(x)
+      end
+
+      def range_y
+        range(y)
+      end
+
+      def position(*args) ; end
+    end
+
+    class Histogram < Glyph::Glyph2D
+      required_args :data, :value, :position, :scalex
+      optional_args :bin_num, :width, :color, :stroke_color, :stroke_width
+      type :histogram
+
+      def initialize(*args)
+        super
+        bin_num(20)
+      end
+
+      def before_to_json
+        scalex(position.x)
+      end
+
+      def range_x
+        [data[value].min, data[value].max]
+      end
+
+      def range_y
+        min, max = range_x
+        bin = (max - min)/bin_num
+        max_bin = (1..bin_num).to_a
+          .map{|val| [min+bin*(val-1), min+bin*val]}
+          .map{|range| data[value].to_a.select{|val| val>=range[0] && val<range[1]}.length}
+          .max
+        print max_bin
+        [0, max_bin*1.2]
+      end
+    end
+
+    class Scatter < Glyph::Glyph2D
+      required_args :data, :x, :y, :position
+      optional_args :color, :shape, :size, :stroke_color, :stroke_width
+      type :scatter
+
+      # Change symbol size according to data in specified column
+      def size_by(column_name)
+        range = size.nil? ? [10, 100] : size
+        df_scale = Nyaplot::DataFrameScale.new(data: data, column: column_name, range: range)
+        scale = Nyaplot::RowScale.new(column: column_name, scale: df_scale)
+        self.size(scale)
+      end
+
+      # Change symbol shape according to data in specified column
+      # Value range (ex. "circle", "diamond", ...) can be specified using Scatter#shape
+      # @example
+      #   x = ["a", "b", "a"]; y = [1, 2, 3]
+      #   sc = Scatter.new(data: data, x: :x, y: :y)
+      #   sc.shape_by(:x) #-> circle, triangle-up, circle (default)
+      #   sc.shape([:square, :cross]).shape_by(:x) #-> square, cross, square
+      #
+      def shape_by(column_name)
+        range = shape.nil? ? ['circle','triangle-up', 'diamond', 'square', 'triangle-down', 'cross'] : shape
+        df_scale = Nyaplot::DataFrameScale.new(data: data, column: column_name, range: range)
+        scale = Nyaplot::RowScale.new(column: column_name, scale: df_scale)
+        self.shape(scale)
+      end
+    end
+
+    class Line < Glyph::Glyph2D
+      required_args :data, :x, :y, :position
+      optional_args :color, :stroke_width
+      type :line
+    end
+
+    class Rect < Glyph::Glyph2D
+      required_args :data, :x, :y
+      optional_args :width, :height, :color, :stroke_width, :stroke_color, :x_base, :y_base
+      type :rect
+    end
+
+    class LineSegment < Glyph::Glyph2D
+      required_args :data, :x1, :y1, :x2, :y2
+      optional_args :color, :stroke_width
+      type :line_segment
+    end
+
+    class Bar < Glyph::Rect
+      optional_args :bin_size
+
+      # @example
+      # Plot.new(:bar, x: :[:hoge, :nya, :nyan], y: [100, 200, 10])
+      # -> df = DataFrame.new(x: [:hoge, :nya, :nyan], y: [100, 200, 10])
+      # -> Bar.new(x: :x, y: :y).data(df)
+      #
+      def initialize(*args)
+        super()
+        y_base "bottom"
+        bin_size 0.8
+        data args.first[:data]
+        @x_label = args.first[:x]
+        @y_label = args.first[:y]
+      end
+
+      def range_x
+        data[@x_label]
+      end
+
+      def range_y
+        column = data[@y_label]
+        min = column.min < 0 ? column.min : 0
+        [min, column.max]
+      end
+
+      def position(pos)
+        x RowScale.new(column: @x_label, scale: pos.x)
+        y(pos.y.range.max)
+        scale = Scale.new(range: pos.y.range.reverse, domain: pos.y.domain, type: pos.y.type)
+        height RowScale.new(column: @y_label, scale: scale)
+        width((pos.x.range.max/self.range_x.length)*bin_size)
+      end
+    end
+
+    class HeatMap < Glyph::Rect
+    end
+
+    class Box < Glyph::Rect
+      optional_args :bin_size
+      attr_reader :child
+
+      # @example
+      #   df = DataFrame.new({hoge: [1,2,3], nya: [2,3,4], nyan: [5,6,7]})
+      #   Plot.from(df).add(:box, :columns: [:hoge, :nya, :nyan])
+      #
+      def initialize(*args)
+        super()
+        bin_size 0.9
+        rows = args.first[:columns].map do |label|
+          column = args.first[:data][label]
+          q1, q3 = column.percentil(25), column.percentil(75)
+          h = q3 - q1
+          min = q1 - column.min > 1.5*h ? q1-1.5*h : column.min
+          max = column.max - q3 > 1.5*h ? q3+1.5*h : column.max
+          [
+            label,
+            max,
+            min,
+            q1,
+            q3,
+            q3 - q1,
+            column.median,
+            column.to_a.select{|val| val < min || val > max}.to_a
+          ]
+        end
+
+        columns = rows.transpose
+        @outlier = columns.pop
+        @child = LineSegment.new
+
+        class << @child
+          def range_x ; []; end
+          def range_y ; [Float::INFINITY, -Float::INFINITY]; end
+        end
+
+        add_dependency(@child)
+        data(DataFrame.new(columns, labels: [:label, :max, :min, :q1, :q3, :height, :median]))
+      end
+
+      def range_x
+        data[:label]
+      end
+
+      def range_y
+        [data[:min].min, data[:max].max]
+      end
+
+      def position(pos)
+        padding = pos.x.range.max/data.length
+
+        x RowScale.new(column: :label, scale: pos.x)
+        y RowScale.new(column: :q3, scale: pos.y)
+        height RowScale.new(column: :height, scale: pos.y)
+        width padding * bin_size
+        transform("translate(" + ((padding*(1-bin_size))/2).to_s  + ",0)")
+
+        @child
+          .data(data)
+          .x1(self.x)
+          .x2(self.x)
+          .y1(RowScale.new(column: :min, scale: pos.y))
+          .y2(RowScale.new(column: :max, scale: pos.y))
+          .stroke_width(1.5)
+          .color("#000")
+          .transform("translate(" + (padding/2).to_s + ",0)")
+      end
+    end
+  end
+end

data/lib/nyaplot/interactive.rb

@@ -0,0 +1,94 @@
+module Nyaplot
+  module Interactive
+    @@callbacks = {}
+
+    def init_interactive_layer
+      path = File.expand_path("../templates/init_interactive.js", __FILE__)
+      js = File.read(path)
+      IRuby.display(IRuby.javascript(js))
+    end
+
+    def self.included(cls)
+      init_interactive_layer
+      comm_id = SecureRandom.hex(16)
+      @@comm = IRuby::Comm.new("nyaplot_interactive", comm_id)
+      @@comm.open
+      IRuby::Kernel.instance.register_comm(comm_id, @@comm)
+
+      on_msg = Proc.new do |msg|
+        content = msg
+        # msg: {type: "selected", uuid: , range: [0, 100]}
+        if content[:type.to_s] == "selected"
+          cb = @@callbacks[content[:stage_uuid.to_s]]
+          cb.call(content[:range.to_s])
+        end
+      end
+      @@comm.on_msg(on_msg)
+      @@comm.send({type: "hello"})
+    end
+  end
+
+  class Filter
+    include Nyaplot::Base
+    required_args :scalex, :scaley, :stage_uuid
+    optional_args :opacity, :color
+    type :interactive_layer
+  end
+
+  class Plot2D
+    def add_filter(&block)
+      if (stages = @pane.dependency.select{|d| d.is_a?(Nyaplot::Stage2D)}).length == 1
+        stages.first.add_filter(&block)
+      else
+        raise "specify stage to add filter."
+      end
+    end
+  end
+
+  class Stage2D
+    def add_filter(&block)
+      @filter = Filter.new(stage_uuid: @uuid)
+      add_sheet(@filter)
+      @@callbacks[@uuid] = block
+    end
+
+    def before_to_json
+      unless @filter.nil?
+        xscale = @axis.xscale
+        yscale = @axis.yscale
+        @filter.scalex(xscale).scaley(yscale)
+      end
+    end
+  end
+
+  class EmptyPlot
+    include PlotBase
+
+    def initialize(*args)
+      @pane = args.select{|a| a.is_a?(Nyaplot::Pane)}.first
+      args.delete(@pane)
+      @others = args
+    end
+
+    def update
+      # should be refactored
+      old_pane_uuid = @pane.uuid
+      msg = {
+        type: :update,
+        model: self.to_json
+      }
+      new_pane_uuid = @pane.uuid
+      msg[:model].gsub!(new_pane_uuid, old_pane_uuid)
+      @pane.uuid = old_pane_uuid
+      @@comm.send(msg)
+      STDERR.puts msg
+    end
+
+    def to_json(*args)
+      gen_list = generate_gen_list(@others)
+      list = gen_list.sort_by{|k, v| v}.map{|arr| arr.first.to_json}.reverse
+      list.push(@pane.to_json)
+      "[" + list.join(",") + "]"
+    end
+  end
+end

data/lib/nyaplot/pane.rb

@@ -0,0 +1,43 @@
+module Nyaplot
+  # The wrapper for pane of Nyaplotjs
+  # (https://github.com/domitry/Nyaplotjs/blob/v2/src/parser/pane.js)
+  #
+  # @example
+  #   p1 = Pane.new.columns(s1, s2)
+  #   p2 = Pane.new.columns(s3, s4)
+  #   p3 = Pane.new.rows(p1, p2)
+  #   p3.to_iruby
+
+  class Pane
+    include Nyaplot::Base
+
+    type :pane
+    required_args :parent_id, :layout
+
+    def before_to_json
+      @uuid = SecureRandom.uuid
+      parent_id("vis-" + @uuid)
+    end
+
+    def add(name, *stages)
+      contents = stages.map do |s|
+        if s.is_a? Nyaplot::Pane
+          s.layout
+        else s.is_a? Nyaplot::Stage2D
+          add_dependency(s)
+          {sync: s.uuid}
+        end
+      end
+      layout({type: name, contents: contents})
+      self
+    end
+
+    def self.columns(*stages)
+      self.new.add(:columns, *stages)
+    end
+
+    def self.rows(*stages)
+      self.new.add(:rows, *stages)
+    end
+  end
+end

data/lib/nyaplot/plot.rb

@@ -1,150 +1,199 @@
 module Nyaplot
+  # Base module for Plot-something of Nyaplot. (e.g. Nyaplot::Plot2D or Nyaplot::Plot)
+  # Plot have one root named "pane".
+  # Plot resolve dependency according to pane, create model, and generate html code according to it.
+  module PlotBase
+    def initialize(*args)
+      @pane = Nyaplot::Pane.new
+    end
 
-  # Jsonizable Object to which diagrams are registered
-  # Properties of Nyaplot::Plot are embeded into the JSON object as a part of property 'panes' by Nyaplot::Frame
-  class Plot
-    include Jsonizable
-    # @!attribute width
-    #   @return [Numeric] the width
-    # @!attribute height
-    #   @return [Numeric] the height
-    # @!attribute margin
-    #   @return [Hash] the margin
-    # @!attribute xrange
-    #   @return [Array<Numeric>, Array<String>, Array<Symbol>] the name of width set
-    # @!attribute yrange
-    #   @return [Array<Numeric>, Array<String>, Array<Symbol>] the name of width set
-    # @!attribute x_label
-    #   @return [String] the name of label placed along x-axis
-    # @!attribute y_label
-    #   @return [String] the name of label placed along y-axis
-    # @!attribute bg_color
-    #   @return [String] the code of color which background is filled in
-    # @!attribute grid_color
-    #   @return [String] the code of color which grid lines are filled in
-    # @!attribute legend
-    #   @return [Boolean] whether to show legend or not
-    # @!attribute legend_width
-    #   @return [Numeric] the width of legend area
-    # @!attribute legend_options
-    #   @return [Hash] the name of width set
-    # @!attribute zoom
-    #   @return [Boolean] whether to enable zooming
-    # @!attribute rotate_x_label
-    #   @return [Numeric] the angle to rotate x label (radian)
-    # @!attribute rotate_y_label
-    #   @return [Numeric] the angle to rotate y label (radian)
-    # @!attribute x_scale
-    #   @return [String] the type of scale ("linear", "log" and "pow" are supported.)
-    # @!attribute y_scale
-    #   @return [String] the type of scale ("linear", "log" and "pow" are supported.)
-    define_properties(:diagrams, :filter)
-    define_group_properties(:options, [:width, :height, :margin, :xrange, :yrange, :x_label, :y_label, :bg_color, :grid_color, :legend, :legend_width, :legend_options, :zoom, :rotate_x_label, :rotate_y_label, :x_scale, :y_scale])
-
-    def initialize(&block)
-      init_properties
-      set_property(:diagrams, [])
-      set_property(:options, {})
-      set_property(:width, nil)
-      set_property(:legend, nil)
-      set_property(:zoom, nil)
-
-      yield if block_given?
-    end
-
-    # Add diagram with Array
-    # @param [Symbol] type the type of diagram to add
-    # @param [Array<Array>] *data array from which diagram is created
-    # @example
-    #    plot.add(:scatter, [0,1,2], [0,1,2])
-    def add(type, *data)
-      labels = data.map.with_index{|d, i| 'data' + i.to_s}
-      raw_data = data.each.with_index.reduce({}){|memo, (d, i)| memo[labels[i]]=d; next memo}
-      df = DataFrame.new(raw_data)
-      return add_with_df(df, type, *labels)
-    end
-
-    # Add diagram with DataFrame
-    # @param [DataFrame] DataFrame from which diagram is created
-    # @param [Symbol] type the type of diagram to add
-    # @param [Array<Symbol>] *labels column labels for x, y or some other dimension
-    # @example
-    #    df = Nyaplot::DataFrame.new({x: [0,1,2], y: [0,1,2]})
-    #    plot.add(df, :scatter, :x, :y)
-    def add_with_df(df, type, *labels)
-      diagram = Diagram.new(df, type, labels)
-      diagrams = get_property(:diagrams)
-      diagrams.push(diagram)
-      return diagram
+    # @return
+    #   {Obj1: 2, Obj2: 0, Obj3: 15, .., Objn: 0}
+    def generate_gen_list(stack)
+      gen = 0; gen_list = {}
+
+      while stack.length > 0
+        stack = stack.reduce([]) do |memo, obj|
+          gen_list[obj] = gen
+          obj.resolve_dependency if obj.respond_to? :resolve_dependency
+          memo.concat(obj.dependency)
+          next memo
+        end
+        gen += 1
+      end
+
+      gen_list
     end
 
+    # generate model
+    def to_json(*args)
+      gen_list = generate_gen_list([@pane])
+      "[" + gen_list.sort_by{|k, v| v}.map{|arr| arr.first.to_json}.reverse.join(",") + "]"
+    end
+
+    # generate html code for <body> tag
+    def generate_body
+      path = File.expand_path("../templates/iruby.erb", __FILE__)
+      template = File.read(path)
+      model = self.to_json
+      id = @pane.uuid
+      ERB.new(template).result(binding)
+    end
+
+    # generate static html file
+    # @return [String] generated html
+    def generate_html
+      body = generate_body
+      init = Nyaplot.generate_init_code
+      path = File.expand_path("../templates/static_html.erb", __FILE__)
+      template = File.read(path)
+      ERB.new(template).result(binding)
+    end
 
-    # Show plot automatically on IRuby notebook
+    # export static html file
+    def export_html(path="./plot.html")
+      path = File.expand_path(path, Dir::pwd)
+      str = generate_html
+      File.write(path, str)
+    end
+
+    # show plot automatically on IRuby notebook
     def to_iruby
-      Frame.new.tap {|f| f.add(self) }.to_iruby
+      html = generate_body
+      ['text/html', html]
     end
 
-    # Show plot on IRuby notebook
+    # show plot on IRuby notebook
     def show
-      Frame.new.tap {|f| f.add(self) }.show
+      IRuby.display(self)
     end
+  end
 
-    # export html file
-    def export_html(path=nil)
-      require 'securerandom'
-      path = "./plot-" + SecureRandom.uuid().to_s + ".html" if path.nil?
-      Frame.new.tap {|f| f.add(self) }.export_html(path)
+  # Base class for general 2-dimentional plots
+  # Plot2D have one pane, some stage2ds and glyphs
+  class Plot2D
+    include PlotBase
+    attr_accessor :pane, :stages, :glyphs
+
+    def initialize
+      super
+      stage = Stage2D.new
+      @pane = Pane.rows(stage)
+      @dependency = [@pane, stage]
     end
 
-    # @return [Array<String>] names of dataframe used by diagrams belog to this plot
-    def df_list
-      arr=[]
-      diagrams = get_property(:diagrams)
-      diagrams.each{|d| arr.push(d.df_name)}
-      return arr
-    end
+    class << self
+      # shortcut method for Plot#add
+      # @example
+      #   Plot.add(:scatter, a, b)
+      #
+      def add(*args)
+        self.new.add(*args)
+      end
 
-    def before_to_json
-      diagrams = get_property(:diagrams)
-      return if diagrams.length == 0
+      # shortcut method for Plot#from
+      # @example
+      #   df = DataFrame.new({hoge: [1,2,3], nya: [2,3,4]})
+      #   Plot.from(df).add(:scatter, :hoge, :nya)
+      #
+      def from(df)
+        self.new.from(df)
+      end
+    end
 
-      # set default values when not specified by users
-      zoom(true) if zoom.nil? && diagrams.all?{|d| d.zoom?}
+    def from(df)
+      if df.is_a? DataFrame
+        @df = df
+        self
+      else
+        raise ""
+      end
+    end
 
-      if width.nil?
-        if legend == true
-          width(800)
+    # Add glyph, sheet or stage to Plot
+    # @example
+    #    Plot.add(:scatter, x, y)
+    #    Plot.add(sc)
+    #
+    def add(*args)
+      if args.first.is_a? Symbol
+        name = args.shift
+        raise "invalid arguments" unless args.length == 1 && args.first.is_a?(Hash)
+        if (hash = args.first) && !(@df.nil?)
+          glyph = Nyaplot::Glyph.instantiate(@df, name, hash)
         else
-          width(700)
+          # hash: {x: [0, 1, 2], y: [1, 2, 3]}
+          df = DataFrame.new(hash)
+          arg = hash.reduce({}){|memo, val| memo[val[0]] = val[0]; memo}
+          glyph = Nyaplot::Glyph.instantiate(df, name, arg)
         end
-      end
-
-      [:xrange, :yrange].each do |symbol|
-        if get_property(:options)[symbol].nil?
-          range = []
-          diagrams.each{|diagram| range.push(diagram.send(symbol))}
-
-          if range.all? {|r| r.length == 2} # continuous data
-            range = range.transpose
-            range = [range[0].min, range[1].max]
-            self.send(symbol, range)
-          else # discrete data
-            range.flatten!.uniq!
-            self.send(symbol, range)
+        add_glyph(glyph)
+      else
+        args.each do |obj|
+          if obj.is_a? Nyaplot::Glyph2D
+            add_glyph(obj)
+          elsif obj.is_a? Nyaplot::Stage2D
+            add_stage(obj)
           end
         end
       end
+      self
     end
 
-    # Shortcut method to configure plot
-    # @example
-    #    plot = Nyaplot::Plot.new
-    #    plot.configure do
-    #      width(700)
-    #      height(700)
-    #    end
-    def configure(&block)
-      self.instance_eval(&block) if block_given?
+    def add_glyph(glyph)
+      stages = @dependency.select{|obj| obj.is_a? Nyaplot::Stage2D}
+      if stages.length == 0
+        stage = Nyaplot::Stage2D.new
+        add_stage(stage)
+        stage.context.add(glyph)
+      elsif stages.length == 1
+        stages.first.context.add(glyph)
+      else
+        raise "Specify stage to add the glyph."
+      end
+      @dependency.push(glyph)
+    end
+
+    def add_stage(stage)
+      @pane = Pane.columns(@pane, stage)
+      @dependency.push(stage)
+    end
+
+    def glyphs
+      if (s = self.stages).length == 1
+        context = s.first.context
+        context.glyphs
+      else
+        raise "Specify stage from which select glyphs from"
+      end
+    end
+
+    def glyph
+      self.glyphs.first
     end
+
+    def stages
+      @pane.dependency.select{|d| d.is_a?(Nyaplot::Stage2D)}
+    end
+
+    def stage
+      if (s = self.stages).length == 1
+        s.first
+      else
+        raise "This plot has 2>= stages."
+      end
+    end
+
+    def method_missing(name, *args)
+      super if @dependency.all?{|obj| !(obj.respond_to? name)}
+      @dependency.each do |obj|
+        break obj.send(name, *args) if obj.respond_to? name
+      end
+      self
+    end
+  end
+
+  # shortcut for Nyaplot::Plot2D
+  class Plot < Plot2D
   end
 end