rubyvis 0.1.1 → 0.1.2

data/lib/rubyvis/scene/svg_bar.rb

@@ -3,27 +3,27 @@ module Rubyvis
     def self.bar(scenes)
       e=scenes._g.elements[1]
       scenes.each_with_index do |s,i|
-      next unless s.visible
-      fill=s.fill_style
-      stroke=s.stroke_style
-      next if(!fill.opacity and !stroke.opacity)
-      e=SvgScene.expect(e,'rect', {
-      "shape-rendering"=> s.antialias ? nil : "crispEdges",
-      "pointer-events"=> s.events,
-      "cursor"=> s.cursor,
-      "x"=> s.left,
-      "y"=> s.top,
-      "width"=> [1E-10, s.width].max,
-      "height"=> [1E-10, s.height].max,
-      "fill"=> fill.color,
-      "fill-opacity"=> (fill.opacity==0) ? nil : fill.opacity,
-      "stroke"=> stroke.color,
-      "stroke-opacity"=> (stroke.opacity==0) ? nil : stroke.opacity,
-      "stroke-width"=> stroke.opacity ? s.line_width / SvgScene.scale.to_f : nil
-      })
-      
-      e=SvgScene.append(e,scenes,i)
-      
+        next unless s.visible
+        fill=s.fill_style
+        stroke=s.stroke_style
+        next if(fill.opacity==0.0 and stroke.opacity==0.0)
+        e=SvgScene.expect(e,'rect', {
+          "shape-rendering"=> s.antialias ? nil : "crispEdges",
+          "pointer-events"=> s.events,
+          "cursor"=> s.cursor,
+          "x"=> s.left,
+          "y"=> s.top,
+          "width"=> [1E-10, s.width].max,
+          "height"=> [1E-10, s.height].max,
+          "fill"=> fill.color,
+          "fill-opacity"=> (fill.opacity==0) ? nil : fill.opacity,
+          "stroke"=> stroke.color,
+          "stroke-opacity"=> (stroke.opacity==0) ? nil : stroke.opacity,
+          "stroke-width"=> stroke.opacity ? s.line_width / SvgScene.scale.to_f : nil
+        })
+
+        e=SvgScene.append(e,scenes,i)
+
       end
       e
     end

data/lib/rubyvis/scene/svg_label.rb

@@ -3,47 +3,47 @@ module Rubyvis
     def self.label(scenes)
       e=scenes._g.elements[1]
       scenes.each_with_index do |s,i|
-      next unless s.visible
-      fill=s.text_style
-      next if(fill.opacity==0 or s.text.nil?)
-      x=0
-      y=0
-      dy=0
-      anchor='start'
-      case s.text_baseline
+        next unless s.visible
+        fill=s.text_style
+        next if(fill.opacity==0 or s.text.nil?)
+        x=0
+        y=0
+        dy=0
+        anchor='start'
+        case s.text_baseline
         when 'middle'
           dy=".35em"
         when "top"
           dy = ".71em"; y = s.text_margin
         when "bottom"
           y = "-" + s.text_margin.to_s
-      end
-      case s.text_align
-      when 'rigth'
-        anchor = "end"; x = "-" + s.text_margin.to_s
-      when "center"
-        anchor = "middle"
-        
-      when "left"
-        x = s.text_margin
-      end
-      e=SvgScene.expect(e,'text', {
-        "pointer-events"=> s.events,
-        "cursor"=> s.cursor,
-        "x"=> x,
-        "y"=> y,
-        "dy"=> dy,
-        "transform"=> "translate(" + s.left.to_s + "," + s.top.to_s + ")" + (s.text_angle!=0 ? " rotate(" + (180 * s.text_angle / Math::PI).to_s + ")" : "") + (self.scale != 1 ? " scale(" + 1 / self.scale + ")" : ""),
-        "fill"=> fill.color,
-        "fill-opacity"=> fill.opacity || nil,
-        "text-anchor"=> anchor
-      }, {
+        end
+        case s.text_align
+        when 'rigth'
+          anchor = "end"; x = "-" + s.text_margin.to_s
+        when "center"
+          anchor = "middle"
+
+        when "left"
+          x = s.text_margin
+        end
+        e=SvgScene.expect(e,'text', {
+          "pointer-events"=> s.events,
+          "cursor"=> s.cursor,
+          "x"=> x,
+          "y"=> y,
+          "dy"=> dy,
+          "transform"=> "translate(" + s.left.to_s + "," + s.top.to_s + ")" + (s.text_angle!=0 ? " rotate(" + (180 * s.text_angle / Math::PI).to_s + ")" : "") + (self.scale != 1 ? " scale(" + 1 / self.scale + ")" : ""),
+          "fill"=> fill.color,
+          "fill-opacity"=> fill.opacity || nil,
+          "text-anchor"=> anchor
+        }, {
         "font"=> s.font, "text-shadow"=> s.text_shadow, "text-decoration"=> s.text_decoration      })
-      e.text=s.text
-      
-      
-      e=SvgScene.append(e,scenes,i)
-      
+        e.text=s.text
+
+
+        e=SvgScene.append(e,scenes,i)
+
       end
       e
     end

data/lib/rubyvis/scene/svg_line.rb

@@ -0,0 +1,185 @@
+module Rubyvis
+  module SvgScene
+    def self.line(scenes)
+
+      e=scenes._g.elements[1]
+      return e if (scenes.size < 2)
+      s = scenes[0]
+
+      # segmented */
+      return self.line_segment(scenes) if (s.segmented)
+
+      #/* visible */
+      return e if (!s.visible)
+      fill = s.fill_style
+      stroke = s.stroke_style
+
+      return e if (fill.opacity==0.0 and  stroke.opacity==0.0)
+      #/* points */
+
+      d = "M" + s.left.to_s + "," + s.top.to_s
+
+      if (scenes.size > 2 and (s.interpolate == "basis" or s.interpolate == "cardinal" or s.interpolate == "monotone"))
+        case (s.interpolate)
+        when "basis"
+          d = d+ curve_basis(scenes)
+        when "cardinal"
+          d = d+curve_cardinal(scenes, s.tension)
+        when "monotone"
+          d = d+curve_monotone(scenes)
+        end
+
+      else
+        (1...scenes.size).each {|i|
+          d+= path_segment(scenes[i-1],scenes[i])
+        }
+      end
+
+      e = SvgScene.expect(e, "path", {
+        "shape-rendering"=> s.antialias ? nil : "crispEdges",
+        "pointer-events"=> s.events,
+        "cursor"=> s.cursor,
+        "d"=> d,
+        "fill"=> fill.color,
+        "fill-opacity"=> (fill.opacity==0.0) ? nil : fill.opacity,
+        "stroke"=> stroke.color,
+        "stroke-opacity"=> (stroke.opacity==0.0) ? nil : stroke.opacity,
+        "stroke-width"=> (stroke.opacity>0) ? s.line_width / self.scale : nil,
+        "stroke-linejoin"=> s.line_join
+      });
+      return SvgScene.append(e, scenes, 0);
+    end
+
+    def self.line_segment(scenes)
+
+      e=scenes._g.elements[1]
+
+      s = scenes[0];
+      paths=nil
+      case s.interpolate
+      when "basis"
+        paths = curve_basis_segments(scenes)
+      when "cardinal"
+        paths=curve_cardinal_segments(scenes, s.tension)
+      when "monotone"
+        paths = curve_monotone_segments(scenes)
+      end
+
+      (scenes.length-1).times {|i|
+
+        s1 = scenes[i]
+        s2 = scenes[i + 1];
+
+        #/* visible */
+        next if (!s1.visible and !s2.visible)
+
+        stroke = s1.stroke_style
+        fill = pv.Color.transparent
+
+        next if stroke.opacity==0.0
+
+        #/* interpolate */
+        d=nil
+        if ((s1.interpolate == "linear") and (s1.lineJoin == "miter"))
+          fill = stroke;
+          stroke = pv.Color.transparent;
+          d = path_join(scenes[i - 1], s1, s2, scenes[i + 2]);
+        elsif(paths)
+          d = paths[i];
+        else
+          d = "M" + s1.left + "," + s1.top + path_segment(s1, s2);
+        end
+
+        e = SvgScene.expect(e, "path", {
+          "shape-rendering"=> s1.antialias ? nil : "crispEdges",
+          "pointer-events"=> s1.events,
+          "cursor"=> s1.cursor,
+          "d"=> d,
+          "fill"=> fill.color,
+          "fill-opacity"=> (fill.opacity==0.0) ? nil : fill.opacity,
+          "stroke"=> stroke.color,
+          "stroke-opacity"=> (stroke.opacity==0.0) ? nil : stroke.opacity,
+          "stroke-width"=> stroke.opacity>0 ? s1.line_width / self.scale : nil,
+          "stroke-linejoin"=> s1.line_join
+        });
+        e = SvgScene.append(e, scenes, i);
+      }
+      return e
+    end
+
+    #/** @private Returns the path segment for the specified points. */
+
+    def self.path_segment(s1, s2)
+      l = 1; # sweep-flag
+      case (s1.interpolate)
+      when "polar-reverse"
+        l = 0;
+      when "polar"
+        dx = s2.left - s1.left,
+        dy = s2.top - s1.top
+        e = 1 - s1.eccentricity
+        r = Math.sqrt(dx * dx + dy * dy) / (2 * e)
+        if !((e<=0) and (e>1))
+          return "A" + r + "," + r + " 0 0," + l + " " + s2.left + "," + s2.top
+        end
+      when "step-before"
+        return "V" + s2.top + "H" + s2.left
+      when "step-after"
+        return "H" + s2.left + "V" + s2.top
+      end
+      return "L" + s2.left.to_s + "," + s2.top.to_s
+    end
+
+    #/** @private Line-line intersection, per Akenine-Moller 16.16.1. */
+    def self.line_intersect(o1, d1, o2, d2)
+      return o1.plus(d1.times(o2.minus(o1).dot(d2.perp()) / d1.dot(d2.perp())));
+    end
+
+    #/** @private Returns the miter join path for the specified points. */
+    def self.path_join(s0, s1, s2, s3)
+      #
+      # P1-P2 is the current line segment. V is a vector that is perpendicular to
+      # the line segment, and has length lineWidth / 2. ABCD forms the initial
+      # bounding box of the line segment (i.e., the line segment if we were to do
+      # no joins).
+      #
+
+      p1 = pv.vector(s1.left, s1.top)
+
+      p2 = pv.vector(s2.left, s2.top)
+
+      p = p2.minus(p1)
+
+      v = p.perp().norm()
+
+      w = v.times(s1.lineWidth / (2 * this.scale))
+
+      a = p1.plus(w)
+      b = p2.plus(w)
+      c = p2.minus(w)
+      d = p1.minus(w)
+
+      #/*
+      # * Start join. P0 is the previous line segment's start point. We define the
+      # * cutting plane as the average of the vector perpendicular to P0-P1, and
+      # * the vector perpendicular to P1-P2. This insures that the cross-section of
+      # * the line on the cutting plane is equal if the line-width is unchanged.
+      # * Note that we don't implement miter limits, so these can get wild.
+      # */
+      if (s0 and s0.visible)
+        v1 = p1.minus(s0.left, s0.top).perp().norm().plus(v);
+        d = line_intersect(p1, v1, d, p);
+        a = line_intersect(p1, v1, a, p);
+      end
+
+      #/* Similarly, for end join. */
+      if (s3 && s3.visible)
+        v2 = pv.vector(s3.left, s3.top).minus(p2).perp().norm().plus(v);
+        c = line_intersect(p2, v2, c, p);
+        b = line_intersect(p2, v2, b, p);
+      end
+
+      return "M" + a.x + "," + a.y+ "L" + b.x + "," + b.y+ " " + c.x + "," + c.y+ " " + d.x + "," + d.y
+    end
+  end
+end

data/lib/rubyvis/scene/svg_panel.rb

@@ -1,14 +1,15 @@
 module Rubyvis
   module SvgScene
     def self.panel(scenes)
+      puts " -> panel: #{scenes.inspect}" if $DEBUG
       g=scenes._g
-      e=(@g.nil?) ? nil : @g.elements[1]
+      e=(g.nil?) ? nil : g.elements[1]
       if g
-        e=g.elements[0]
+        e=g.elements[1]
       end
       scenes.each_with_index do |s,i|
         next unless s.visible
-        
+
         if(!scenes.parent)
           if g and g.parent!=s.canvas
             g=s.canvas.elements[1]
@@ -31,7 +32,7 @@ module Rubyvis
         if s.overflow=='hidden'
           id=Rubyvis.id.to_s(36)
           c=self.expect(e,'g',{'clip-path'=>'url(#'+id+')'});
-          g.add_element(c) if(!c.parent) 
+          g.add_element(c) if(!c.parent)
           scenes._g=g=c
           e=c.elements[1]
           e=self.expect(e,'clipPath',{'id'=>id})
@@ -42,20 +43,21 @@ module Rubyvis
           r.attributes['height']=s.height
           g.add_element(e) if !e.parent
           e=e.next_sibling_node
-          
+
         end
         e=self.fill(e,scenes, i)
         k=self.scale
         t=s.transform
-        
+
         x=s.left+t.x
         y=s.top+t.y
-        
-        
+
+
         SvgScene.scale=SvgScene.scale*t.k
-        s.children.each_with_index {|child, i|
+
+        s.children.each_with_index {|child, i2|
           child._g=e=SvgScene.expect(e, "g", {
-              "transform"=> "translate(" + x.to_s + "," + y.to_s + ")" + (t.k != 1 ? " scale(" + t.k.to_s + ")" : "")
+            "transform"=> "translate(" + x.to_s + "," + y.to_s + ")" + (t.k != 1 ? " scale(" + t.k.to_s + ")" : "")
           })
           SvgScene.update_all(child)
           g.add_element(e) if(!e.parent)
@@ -63,46 +65,50 @@ module Rubyvis
         }
         SvgScene.scale=k
         e=SvgScene.stroke(e,scenes,i)
-        
-        return e
+        if (s.overflow=='hidden')
+          scenes._g=g=c.parent
+          e=c.next_sibling_node
+        end
       end
-    end 
+      return e
+      
+    end
+
+
 
- 
-    
     def self.fill(e,scenes,i)
       s=scenes[i]
       fill=s.fill_style
       if(fill.opacity>0 or s.events=='all')
         e=SvgScene.expect(e,'rect', {
-        "shape-rendering"=> s.antialias ? nil : "crispEdges",
-        "pointer-events"=> s.events,
-        "cursor"=> s.cursor,
-        "x"=> s.left,
-        "y"=> s.top,
-        "width"=> s.width,
-        "height"=> s.height,
-        "fill"=> fill.color,
-        "fill-opacity"=> fill.opacity,
-        "stroke"=> nil
-        })        
+          "shape-rendering"=> s.antialias ? nil : "crispEdges",
+          "pointer-events"=> s.events,
+          "cursor"=> s.cursor,
+          "x"=> s.left,
+          "y"=> s.top,
+          "width"=> s.width,
+          "height"=> s.height,
+          "fill"=> fill.color,
+          "fill-opacity"=> fill.opacity,
+          "stroke"=> nil
+        })
         e=SvgScene.append(e,scenes, i)
       end
       e
     end
-    
-    
+
+
     def self.stroke(e, scenes, i)
       s = scenes[i]
       stroke = s.stroke_style
-      if (stroke.opacity>0 or s.events == "all") 
+      if (stroke.opacity>0 or s.events == "all")
         e = self.expect(e, "rect", {
           "shape-rendering"=> s.antialias ? nil : "crispEdges",
           "pointer-events"=> s.events == "all" ? "stroke" : s.events,
           "cursor"=> s.cursor,
           "x"=> s.left,
           "y"=> s.top,
-          "width"=> [1E-10, s.width].max, 
+          "width"=> [1E-10, s.width].max,
           "height"=>[1E-10, s.height].max,
           "fill"=>nil,
           "stroke"=> stroke.color,

data/lib/rubyvis/scene/svg_rule.rb

@@ -3,25 +3,24 @@ module Rubyvis
     def self.rule(scenes)
       e=scenes._g.elements[1]
       scenes.each_with_index do |s,i|
-      next unless s.visible
-      stroke=s.stroke_style
-      
-      next if(!stroke.opacity)
-      e=SvgScene.expect(e,'line', {
-      "shape-rendering"=> s.antialias ? nil : "crispEdges",
-      "pointer-events"=> s.events,
-      "cursor"=> s.cursor,
-      "x1"=> s.left,
-      "y1"=> s.top,
-      'x2'=> s.left+s.width,
-      'y2'=>s.top+s.height,
-      "stroke"=> stroke.color,
-      "stroke-opacity"=> stroke.opacity,
-      "stroke-width"=> s.line_width/self.scale.to_f
-      })
-      
-      e=SvgScene.append(e,scenes,i)
-      
+        next unless s.visible
+        stroke=s.stroke_style
+        next if(!stroke.opacity)
+        e=SvgScene.expect(e,'line', {
+          "shape-rendering"=> s.antialias ? nil : "crispEdges",
+          "pointer-events"=> s.events,
+          "cursor"=> s.cursor,
+          "x1"=> s.left,
+          "y1"=> s.top,
+          'x2'=> s.left+s.width,
+          'y2'=>s.top+s.height,
+          "stroke"=> stroke.color,
+          "stroke-opacity"=> stroke.opacity,
+          "stroke-width"=> s.line_width/self.scale.to_f
+        })
+
+        e=SvgScene.append(e,scenes,i)
+
       end
       e
     end