svg-lib 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0958d94cf32f41cfab9959fb9a0b1334feb3fdad141179787c16f61b632211fe'
-  data.tar.gz: 7d03990d325e1cfd66df81a112eee1b39dbdc9ee4f90701bd22a6d2e75722f65
+  metadata.gz: 1838ec9557c2332e4ca7a8daa07b3d3d64ae0aebccd8d373f88bcbec7a2ee5fd
+  data.tar.gz: f5b7bdf0371fd15426349d87e9cf80204aae66d4c719f26088830c400f22bf27
 SHA512:
-  metadata.gz: 75509788882b34a492f5192a0ed2fbba9ad021cb0a90ac5ae5f5df9a66cc34cddbbb77dd423dea3fcaced8bb003281a745efd702d0769ff015b35156df002b6f
-  data.tar.gz: b79c3d399c12bac44f10460a090c89ef6264ca0dd59078ebf73406c98210b1ca443ccd2858673d8cf8ee4eee753ce54b7dfa05a77b4836008baf99a77dab955a
+  metadata.gz: 1ec3399c2bb0cdf2a8da8acd9c83513d2e7563a4c0db4a81a3c74b9d587417edec65a34fec9671b18a07818e1e34766fb01bffff7a74c5768ab624cebe27e5b2
+  data.tar.gz: fea5449f4ccf671806db77cc29cfc9e48c53063324e6f20d5be2799fd9b627bb788cfee0564e3b94a76b5d5cd2398dbbdb009ea8db3c238b9b90f776b9079faa

data/bin/eplot

@@ -11,6 +11,8 @@ opts[:ylog] = false
 opts[:xlog] = false
 opts[:legend] = false
 opts[:scatterplot] = false
+opts[:lineplot] = false
+opts[:boxplot] = false
 opts[:minx] = nil
 opts[:maxx] = nil
 opts[:miny] = nil
@@ -22,8 +24,9 @@ opts[:linestyles] = []
 opts[:title] = ""
 opts[:xlabel] = ""
 
-opts[:width] = 500
-opts[:height] = 500
+opts[:width] = 800
+opts[:height] = 800
+opts[:noaxis] = false
 
 progname = File.basename($PROGRAM_NAME,File.extname($PROGRAM_NAME))
 parser = OptionParser.new do |parser|
@@ -47,6 +50,10 @@ parser = OptionParser.new do |parser|
     opts[:scatterplot] = true
   end 
 
+  parser.on("--boxplot","boxplot mode") do 
+    opts[:boxplot] = true
+  end 
+
   parser.on("--ylog","show logarithmic axis") do 
     opts[:ylog] = true
   end 
@@ -122,15 +129,15 @@ end
 
 # MAIN PROGRAM ================================================================
 
-SVG.new(x: 0.0, y: 0.0, width: opts[:width], height: opts[:height],font_family: "monospace") do |svg|
+SVG.new(x: 0.0, y: 0.0, width: opts[:width], height: opts[:height],font_family: "monospaced") do |svg|
   plt = SVG::Plot.new(svg)
   plt.title = opts[:title];
   plt.xlabel = opts[:xlabel];
   plt.ylabel = opts[:ylabel];
-  plt.minx   = opts[:minx];
-  plt.maxx   = opts[:maxx];
-  plt.miny   = opts[:miny];
-  plt.maxy   = opts[:maxy];
+  plt.minx   = opts[:minx] || plt.minx
+  plt.maxx   = opts[:maxx] || plt.maxx
+  plt.miny   = opts[:miny] || plt.miny
+  plt.maxy   = opts[:maxy] || plt.maxy
 
 
   datavar = []
@@ -157,30 +164,42 @@ SVG.new(x: 0.0, y: 0.0, width: opts[:width], height: opts[:height],font_family:
       x = (1 .. data.size).to_a.map{|e| e.to_f}
       data = data.map{|e| e[0]}
     end 
+
     rawx.push(x)
     rawdata.push(data)
-  end 
+  end
 
   plt.minmax(rawx,rawdata,xlog: opts[:xlog], ylog: opts[:ylog])
 
-  rawdata.each_with_index do |y,i|
-    if opts[:scatterplot]
-      plt.scatter(rawx[i],y,
-        ylog: opts[:ylog],
-        label: opts[:labels][i],
-        marker: opts[:markers][i])
-    else
-      plt.plot(rawx[i],y,
-        ylog: opts[:ylog],
-        label: opts[:labels][i],
-        marker: opts[:markers][i],
-        linestyle: opts[:linestyles][i])
+  
+  yticks,ylabels = plt.yticks(log: opts[:ylog])
+  if opts[:boxplot]
+    plt.boxplot(rawdata,ylog: opts[:ylog],labels: opts[:labels])
+    xticks,xlabels = plt.boxplotticks(rawdata.size)
+    xlabels = ["",*opts[:labels],""]
+    plt.axis(xticks,xlabels,stroke: "black",fill: "black",flip: true,rotang: -15) unless opts[:noaxis]
+  else
+    xticks,xlabels = plt.xticks(log: opts[:xlog]) 
+    rawdata.each_with_index do |y,i|
+      if opts[:scatterplot]
+        plt.scatter(rawx[i],y,
+          ylog: opts[:ylog],
+          label: opts[:labels][i],
+          marker: opts[:markers][i])
+      else
+        plt.plot(rawx[i],y,
+          ylog: opts[:ylog],
+          label: opts[:labels][i],
+          marker: opts[:markers][i],
+          linestyle: opts[:linestyles][i])
+      end 
     end 
 
+    plt.axis(xticks,xlabels,flip: true,rotang: 0) unless opts[:noaxis]
   end 
 
+  plt.axis(yticks,ylabels) unless opts[:noaxis]
   plt.legend if opts[:legend]
-  plt.axes(xlog: opts[:xlog],ylog: opts[:ylog])
   plt.title  
 end
 

data/lib/plot2d.rb

@@ -26,10 +26,6 @@ class SVG
     end 
   
     attr_accessor :minx,:maxx,:miny,:maxy
-    @minx = -1.0/0.0 
-    @maxx = 1.0/0.0
-    @miny = -1.0/0.0
-    @maxy = 1.0/0.0
 
     def minmax(x,y,xlog: false,ylog: false)
       miny,maxy = y.flatten.minmax
@@ -61,14 +57,14 @@ class SVG
     attr_accessor :legendfontsize,:legendbgcolor,:legendbgopacity,:legendfgcolor,
       :legendlinelen,:legendheight,:legendpad
     attr_accessor :title, :titlefontsize
-
+    
     def initialize(svg)
       @svg = svg
 
       @padleft   = 100
       @padright  = 50
       @padtop    = 50
-      @padbottom = 80
+      @padbottom = 90
       @colors    = [] 
       @labels    = []
       @markers   = [] 
@@ -84,34 +80,48 @@ class SVG
       @axcolor = "black"
       @axlinewidth = 2
       @axlabelstrokewidth = 0.5
-      @axlabelfontsize = 20
+      @axlabelfontsize = 25
+      @xlabelformat = "%-0.4f"
+      @ylabelformat = "%-0.4f"
    
 
       @ticksnum = 5
       @tickslen = 10 
       @tickstextlen = 60
-      @ticksfontsize = 12
+      @ticksfontsize = 18
       @ticksstrokewidth = 0.1
   
-      @legendfontsize = 10 
+      @legendfontsize = 20
       @legendbgcolor = "white"
-      @legendbgopacity = 0.5
+      @legendbgopacity = 0.8
       @legendfgcolor = "black"
       @legendlinelen = 50 
       @legendheight = 100 
       @legendpad = 10 
 
       @title = ""
-      @titlefontsize = 20 
+      @titlefontsize = 40 
+
+      @minx = -1.0/0.0 
+      @maxx = 1.0/0.0
+      @miny = -1.0/0.0
+      @maxy = 1.0/0.0
+
+    end 
+
+    def dark_mode
+      @axcolor = "white"
+      @legendbgcolor = "black"
+      @legendfgcolor = "white"
     end 
 
     def self.mapxcoords(x,minx,maxx,w,padleft,padright,log)
-      x = log ? Math.log(x,10) : x
+      begin x = log ? Math.log(x,10) : x rescue x = 1e-12 end 
       xnew = padleft + ((x - minx)/((maxx-minx) + 1e-100))*(w-(padleft + padright))
     end 
 
     def self.mapycoords(y,miny,maxy,h,padtop,padbottom,log)
-      y = log ? Math.log(y,10) : y
+      begin y = log ? Math.log(y,10) : y rescue y = 1e-12 end 
       ynew = padtop + ((maxy - y)/((maxy-miny) + 1e-100))*(h-(padtop + padbottom))
     end
 
@@ -136,71 +146,6 @@ class SVG
       @opacities.push(opacity)
     end 
 
-    def scatter(
-      xraw, yraw, 
-      minx: @minx, maxx:  @maxx, miny: @miny, maxy: @maxy,
-      label: nil, 
-      color:  nil, 
-      marker:  nil, 
-      opacity:  nil,
-      xlog: false, ylog: false,**args)
-     
-      self.set_plot_style(label,color,marker,"",opacity)
-      points = self.map_and_zip(xraw,yraw,minx,maxx,miny,maxy,xlog,ylog)
- 
-      @svg.g(id: @labels.last, stroke: "none",fill: @colors.last,opacity: @opacities.last) do |g|
-        points.each_with_index do |(x,y),i|
-          self.marker(@markers.last,x,y,"%g" % yraw[i])
-        end 
-      end 
-    
-    end 
-
-    def plot(
-      xraw, yraw,
-      minx: @minx,maxx:  @maxx,miny:  @miny,maxy:  @maxy,
-      label:  nil,
-      color: nil,
-      marker: nil,
-      linestyle: nil,
-      opacity:  nil,
-      xlog: false,ylog: false)
-
-      self.set_plot_style(label,color,marker,linestyle,opacity)
-      points = self.map_and_zip(xraw,yraw,minx,maxx,miny,maxy,xlog,ylog)
-      
-      @svg.g(
-        id: @labels.last,
-        stroke: @colors.last, 
-        fill: @colors.last, 
-        stroke_width: @linewidth,
-        opacity: @opacities.last) do |g|
-
-        g.path(title: @labels.last,fill: "none",stroke_dasharray: self.linestyle(linestyle)) do |path|
-          missing = true
-          points.each do |(x,y)|
-            if !x.finite? || !y.finite?
-              missing = true 
-              next
-            end 
-            if missing 
-              path.m(x,y)
-              missing = false
-            end 
-            path.l(x,y) 
-          end 
-        end 
-      
-        g.g(id: @labels.last+"-markers", fill: @colors.last) do |mg| 
-          points.each_with_index do |(x,y),i|
-            next if ((i % (points.size.to_i / @markernum.to_i)) != 0) || !x.finite? || !y.finite?
-            self.marker(@markers.last,x,y,yraw[i].round(2))
-          end 
-        end 
-      end  
-
-    end
-
     def title
       @svg.g(id: "title",text_anchor: "middle") do |g| 
         g.text(
@@ -211,7 +156,8 @@ class SVG
     end 
 
     def legend
-      legendwidth  = @legendlinelen + 2*@legendpad + @legendfontsize*@labels.map{|e| e.size}.max
+      legendtextwidth = @legendfontsize*@labels.map{|e| e.size}.max / 2
+      legendwidth  = @legendlinelen + 3*@legendpad + legendtextwidth
       legendheight = 2*@legendpad + @labels.size*2*@legendfontsize
 
       t = SVG.transform do |t|
@@ -229,7 +175,7 @@ class SVG
           opacity: @legendbgopacity)
 
         @labels.size.times do |i|
-          y = (i+1)*(2*@legendfontsize)
+          y = @legendpad + @legendfontsize + (i*2*@legendfontsize)
           g.g(id: "legend-marker-line-"+@labels[i],fill: @colors[i],stroke: @colors[i]) do |g|
             g.line(
               x1: @legendpad,
@@ -244,292 +190,134 @@ class SVG
               "",
               @legendfontsize)
           end 
-          g.text(x: @legendpad+@legendfontsize+@legendlinelen,y: y ,text: @labels[i]) 
+          g.text(x: @legendpad+@legendfontsize+@legendlinelen,y: y ,
+            stroke: "none" ,
+            fill: @legendfgcolor,
+            text: @labels[i],
+            font_size: @legendfontsize) 
         end 
       end 
     end 
 
-    def xaxis(min= @minx,max= @maxx,log= false)
-      @svg.g(id: "xaxis",text_anchor: "middle") do |xaxis|
-        xaxis.path(fill: "none") do |path|
-          path.m(@padleft,@svg.height-@padbottom)
-          path.l(@svg.width-@padright,@svg.height - @padbottom)
+    def axis(ticks,labels, flip: false, rotang: 0,**args)
+      min,max = ticks[0], ticks[-1]
+      # Dibujar el eje
+      @svg.g(id: "axis#{flip ? @xlabel : @ylabel}", text_anchor: "middle",stroke: @axcolor, fill: @axcolor,**args) do |axis|
+        axis.path() do |path|
+          path.m(min[0],min[1])
+          path.l(max[0],max[1])
         end 
 
+        # Mostrar nombre
         t = SVG.transform do |t|
-          t.translate(@svg.width / 2,@svg.height-@axlabelfontsize)
-        end 
-        xaxis.g(id: "xlabel",transform: t) do |g| 
-          g.text(text: @xlabel ,x: 0,y: 0,stroke_width: @axlabelstrokewidth)
-        end 
-
-        
-        tickypos = @svg.height - @padbottom - (@tickslen / 2)
-        ticks = [[min,Plot.mapxcoords(min,min,max,@svg.width,@padleft,@padright,false)]]
-        @ticksnum.times do |i|
-          v = min + ((max - min)/(@ticksnum+1))*(i+1)
-          ticks.push([v,Plot.mapxcoords(v,min,max,@svg.width,@padleft,@padright,false)])
-        end 
-        ticks.push([max,Plot.mapxcoords(max,min,max,@svg.width,@padleft,@padright,false)])
-
-        # Dibujar los ticks 
-        xaxis.path do |tickspath|
-          ticks.each do |tick|
-            tickspath.m(tick.last,tickypos)
-            tickspath.l(0,@tickslen,relative: true)
+          if flip
+            t.translate(@svg.width/2,@svg.height - @axlabelfontsize/2)
+          else 
+            t.translate(@axlabelfontsize/2,@svg.height/2)
+            t.rotate(-90,0,0)
           end 
         end 
-        
-        tickypos += @tickstextlen/2
-        ticks.each do |tick|
-          txt = tick.first.round(2).to_s
-          txt = log ? "10^"+txt : txt 
-          xaxis.text(
-            x: tick.last,
-            y: tickypos,
-            text: txt,
-            font_size: @ticksfontsize,
-            stroke_width: @ticksstrokewidth)
-
-        end 
-
-      end 
-    end 
-
-    def yaxis(min = @miny,max = @maxy ,log = false)
-      @svg.g(id: "yaxis") do |yaxis|
-        yaxis.path(fill: "none") do |path|
-          path.m(@padleft,@padtop)
-          path.l(@padleft,@svg.height-@padbottom)
-        end 
 
-        # Mostrar el nombre
-        t = SVG.transform do |t|
-          t.translate(@axlabelfontsize,@svg.height/2)
-          t.rotate(-90,0,0)
-        end 
-        yaxis.g(id: "yaxislabel",transform: t) do |g| 
-          g.text(text: @ylabel ,x: 0,y: 0,stroke_width: @axlabelstrokewidth)
-        end 
-
-
-        # Obtener la posición de los ticks
-        tickxpos = @padleft-@tickslen/2 
-        ticks = [[min,Plot.mapycoords(min,min,max,@svg.height,@padtop,@padbottom,false)]]
-        @ticksnum.times do |i|
-          v = min + ((max - min) / (@ticksnum+1)) * (i+1)
-          ticks.push([v,Plot.mapycoords(v,min,max,@svg.height,@padtop,@padbottom,false)])
-        end 
-        ticks.push([max,Plot.mapycoords(max,min,max,@svg.height,@padtop,@padbottom,false)])
+        axis.text(text: flip ? @xlabel : @ylabel, x: 0, y: 0, stroke_width: @axlabelstrokewidth,transform: t,
+          font_size: @axlabelfontsize)
 
-        # Dibujar los ticks 
-        yaxis.path do |tickspath|
-          ticks.each do |tick|
-            tickspath.m(tickxpos,tick.last)
+        # Colocar los ticks
+        axis.path do |tickspath|
+          (0 ... ticks.size).each do |i|
+            x,y = ticks[i]
+            tickspath.m(x-@tickslen/2,y)
             tickspath.l(@tickslen,0,relative: true)
+            tickspath.m(x,y-@tickslen/2)
+            tickspath.l(0,@tickslen,relative: true)
           end 
         end 
 
         # Colocar los valores 
-        tickxpos -= @tickstextlen/2
-        ticks.each do |tick|
-          txt = tick.first.round(2).to_s
-          txt = log ? "10^"+txt : txt 
-          yaxis.text(
-            x: tickxpos, y: tick.last, 
-            text: txt, 
-            text_anchor: "middle",
+        (0 ... ticks.size).each do |i| 
+          x,y = ticks[i]
+          x +=  flip ? 0 : -@tickslen 
+          y += !flip ? 0 : @tickslen + @ticksfontsize*1.5
+          text = labels[i]
+          axis.text(
+            x: x, 
+            y: y , 
+            text: text, 
+            text_anchor: flip ? "middle" : "end",
             stroke_width: @ticksstrokewidth,
-            font_size: @ticksfontsize)
+            font_size: @ticksfontsize,
+            transform: SVG.transform{|t| t.rotate(rotang,x,y)})
         end 
       end 
-    end 
-
-    def axes(minx: @minx,maxx: @maxx,miny: @miny,maxy: @maxy,xlog: false,ylog: false)
-      @svg.g(id: "axis" , stroke: @axcolor,fill: @axcolor,stroke_width: @axlinewidth) do |g|
-        self.xaxis(minx,maxx,xlog)
-        self.yaxis(miny,maxy,ylog)
-      end
-    end 
+    end
 
-    def linestyle(style)
-      case style
-      when "-" then "5 0"
-      when "--","dashed" then "5"
-      when "-.","dashdot" then "6 3 3 3"
-      when ":","dotted"  then "2"
-      when " ","","none" then "0 1"
-      else style
-      end 
-    end 
+    def yticks(min: @miny,max: @maxy,frmt: @ylabelformat, ticksnum: @ticksnum,log: false)
+      ticks = []
+      labels = []
 
-    def marker(marker,x,y,val,ms = @markersize)
-      t = SVG.transform do |t|
-        t.translate(x,y)
-        t.scale(ms)
-        case marker 
-        when "D","x","X" then t.rotate(45)
-        when ">","2","H" then t.rotate(90)
-        when "v","3" then t.rotate(180)
-        when "<","4" then t.rotate(270)
-        else nil
+      ticks.push([@padleft,Plot.mapycoords(min,min,max,@svg.height,@padtop,@padbottom,log)])
+      labels.push(frmt % min)
+        ticksnum.times do |i|
+          v = min + ((max - min) / (ticksnum+1)) * (i+1)
+          ticks.push([@padleft,Plot.mapycoords(v,min,max,@svg.height,@padtop,@padbottom,log)])
+          labels.push(frmt % v)
         end 
-      end 
-
-      case marker 
-      when "." then self.marker_point(t,val)
-      when "," then self.marker_pixel(t,val)
-      when "o" then self.marker_circle(t,val)
-      when "^",">","v","<" then self.marker_triangle(t,val)
-      when "s","D" then self.marker_square(t,val)
-      when "d" then self.marker_diamond(t,val)
-      when "+","x" then self.marker_plus(t,0.1,val)
-      when "P","X" then self.marker_plus(t,0.2,val)
-      when "1","2","3","4" then self.marker_tri(t,val)
-      when "h","H" then self.marker_hexagon(t,val)
-      when "p" then self.marker_pentagon(t,val)
-      when "8" then self.marker_octagon(t,val)
-      when "*" then self.marker_star(t,val)
-      else raise "unkown marker #{marker}"
-      end 
-    end 
-    
-    def marker_point(t,val="")
-      @svg.circle(cx: 0, cy: 0, r: 0.3, transform: t,title: val,stroke_width: 0)
+        ticks.push([@padleft,Plot.mapycoords(max,min,max,@svg.height,@padtop,@padbottom,log)])
+        labels.push(frmt % max)
+        return ticks,labels
     end 
 
-    def marker_pixel(t,val="")
-      @svg.circle(cx: 0, cy: 0, r: 0.2, transform: t,title: val,stroke_width: 0)
-    end 
+    def boxplotticks(nboxes,boxscale = 0.5)
+      ticks = []
+      labels = []
 
-    def marker_circle(t,val="")
-      @svg.circle(cx: 0, cy: 0, r: 0.45, transform: t,title: val,stroke_width: 0)
-    end 
-    
-    def marker_triangle(t,val="")
-      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
-        path.m(0,-0.5)
-        path.l(0.5,0.5)
-        path.l(-0.5,0.5)
-        path.z
-      end 
-    end 
+      w = (@svg.width - (@padleft + @padright)) / nboxes
+      boxwidth = boxscale * w
 
-    def marker_square(t,val="")
-      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
-        path.m(-0.4,-0.4)
-        path.h(0.4)
-        path.v(0.4)
-        path.h(-0.4)
-        path.z
+      ticks.push([@padleft,@svg.height - @padbottom])
+      labels.push("")
+      nboxes.times do |i| 
+        x =  @padleft + w*(i.to_f+0.5)
+        ticks.push([x,@svg.height - @padbottom])
+        labels.push("%d" % i)
       end 
-    end 
 
-    def marker_diamond(t,val="")
-      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
-        path.m(0,-0.5)
-        path.l(0.3,0)
-        path.l(0,0.5)
-        path.l(-0.3,0.0)
-        path.z
-      end 
+      ticks.push([@svg.width - @padright,@svg.height - @padbottom])
+      labels.push("")
+      return ticks,labels
     end 
 
-    def marker_plus(t,width,val="")
-      @svg.path(transform: t, title: val,stroke_width: 0 ) do |path|
-        path.m(-width,-0.5)
-        path.h(width)
-        path.v(0.5)
-        path.h(-width)
-        path.z
-      end 
-      @svg.path(transform: t, title: val,stroke_width: 0 ) do |path|
-        path.m(-0.5,-width)
-        path.v(width)
-        path.h(0.5)
-        path.v(-width)
-        path.z
-      end 
-    end 
+    def xticks(min: @minx, max: @maxy, ticksnum: @ticksnum, frmt: @xlabelformat,log: false)
+      ticks = []
+      labels = []
 
-    def marker_tri(t,val="")
-      @svg.g(title: val, transform: t,stroke_width: 0) do |g|
-        width = 0.1
-        @svg.path(title: val) do |path|
-          path.m(-width,0.5)
-          path.h(width)
-          path.v(0.0)
-          path.h(-width)
-          path.z
-        end 
-        @svg.path(
-          title: val,
-          transform: SVG.transform{|t| t.rotate(135)}) do |path|
-          path.m(-width,0.5)
-          path.h(width)
-          path.v(0.0)
-          path.h(-width)
-          path.z
-        end 
-        @svg.path(
-          title: val,
-          transform: SVG.transform{|t| t.rotate(225)}) do |path|
-          path.m(-width,0.5)
-          path.h(width)
-          path.v(0.0)
-          path.h(-width)
-          path.z
-        end 
+      ticks.push([Plot.mapxcoords(min,min,max,@svg.height,@padleft,@padright,log),@svg.height-@padbottom])
+      labels.push(frmt % min)
+      ticksnum.times do |i|
+        v = min + ((max - min) / (ticksnum+1)) * (i+1)
+        ticks.push([Plot.mapxcoords(v,min,max,@svg.height,@padleft,@padright,log),@svg.height-@padbottom])
+        labels.push(frmt % v)
       end 
-    end 
-    
-    def marker_hexagon(t,val="")
-      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
-        path.m( 0.00,-0.50)
-        path.l( 0.40,-0.20)
-        path.l( 0.40, 0.30)
-        path.l( 0.00, 0.50)
-        path.l(-0.40, 0.30)
-        path.l(-0.40,-0.20)
-        path.z
-      end 
-    end 
+      ticks.push([Plot.mapxcoords(max,min,max,@svg.height,@padleft,@padright,log),@svg.height-@padbottom])
+      labels.push(frmt % max)
+      return ticks,labels
 
-    def marker_pentagon(t,val="")
-      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
-        path.m( 0.00,-0.50)
-        path.l( 0.45,-0.10)
-        path.l( 0.30, 0.50)
-        path.l(-0.30, 0.50)
-        path.l(-0.45,-0.10)
-        path.z
-      end 
     end 
 
-    def marker_octagon(t,val="")
-      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
-        path.m(-0.25,-0.50)
-        path.l( 0.18,-0.50)
-        path.l( 0.50,-0.25)
-        path.l( 0.50, 0.18)
-        path.l( 0.18, 0.50)
-        path.l(-0.25, 0.50)
-        path.l(-0.50, 0.18)
-        path.l(-0.50,-0.25)
-        path.z
+    def linestyle(style)
+      case style
+      when "-" then "5 0"
+      when "--","dashed" then "5"
+      when "-.","dashdot" then "6 3 3 3"
+      when ":","dotted"  then "2"
+      when " ","","none" then "0 1"
+      else style
       end 
     end 
 
-    def marker_star(t,val="")
-      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
-        path.m(0,-0.5)
-        path.l(-0.3,0.5)
-        path.l(0.5,-0.1)
-        path.l(-0.5,-0.1)
-        path.l(0.3,0.5)
-        path.z
-      end 
-    end 
 
   end 
 end 
+require "plot2d/markers.rb"
+require "plot2d/scatter.rb"
+require "plot2d/lineplot.rb"
+require "plot2d/boxplot.rb"

data/lib/plot2d/boxplot.rb

@@ -0,0 +1,142 @@
+class SVG
+class Plot
+
+  def boxplot(
+      boxesdata,
+      colors: @@colors,
+      markers: @@markers,
+      linewidths: nil,
+      labels: nil,
+      opacity: nil,
+      ylog: false, **args)
+
+    @colors = colors.dup
+    @markers = markers.dup 
+    @labels = labels.dup 
+    linewidths = linewidths || @colors.size 
+
+    #
+    median = lambda do |arr|
+      len = arr.size
+      if arr.size.even? 
+        return (arr[len/2] + arr[(len+1)/2])/2.0
+      else 
+        return arr[len/2]
+      end
+    end 
+
+    mean = lambda do |arr|
+      return arr.reduce(0.0){|acc,d| acc + d} / arr.size 
+    end 
+
+    std = lambda do |arr,mean|
+      return (arr.reduce(0.0){|acc,d| acc + (d - mean)**2}/(arr.size-1))**0.5
+    end 
+ 
+
+    # Cantidad de cajas
+    nboxes = boxesdata.size 
+    min,max = boxesdata.flatten.minmax
+
+    # Obtener los estadísticos necesarios para el boxplot
+    boxes = [ ]
+    nboxes.times do |i|
+      box = {}
+      data = boxesdata[i] 
+    
+      sz = data.size; 
+      data = data.sort
+      box[:mean] = mean.call(data)
+      box[:q1] = median.call(data[0..data.size/2])
+      box[:q2] = median.call(data) 
+      box[:q3] = median.call(data[(data.size/2)+1..-1])
+      box[:iqr] = box[:q3] - box[:q1]
+      box[:median] = box[:q2]
+      box[:std] = std.call(data,box[:mean])
+    
+      box[:w1] = data[0]
+      (0 ... data.size).each do |i|
+        if data[i]  >= (box[:q1] - (1.5*box[:iqr]))
+          box[:w1] = data[i]
+          break
+        end 
+      end 
+      box[:w2] = data[-1]
+      (0 ... data.size).reverse_each do |i|
+        if data[i]  <= (box[:q3] + (1.5*box[:iqr]))
+          box[:w2] = data[i]
+          break
+        end 
+      end 
+
+      boxes.push(box)
+    end 
+
+    # Modificar el máximo y mínimo para mostrar mejor los boxplots 
+    @maxy = boxes.map{|b| b[:w2]*1.01}.max 
+    # @miny = boxes.map{|b| b[:w1]*0.1}.max
+
+    boxscale = 0.5
+    w = (@svg.width - (@padleft + @padright))  / nboxes
+    boxes.each_with_index do |box,i|
+      @svg.g(id: @labels.last,
+        stroke: @colors[i], 
+        fill: @colors[i],
+        stroke_width: @linewidth,
+        opacity: @opacities.last) do |g|
+
+        boxwidth = boxscale * w
+        x = @padleft + w*(i.to_f+0.5)
+
+        ymedian = Plot.mapycoords(box[:median],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+
+        # median line
+        g.line(x1: x - boxwidth/2, y1: ymedian, x2: x + boxwidth/2, y2: ymedian, stroke: "black")
+
+        # mean line 
+        ymean = Plot.mapycoords(box[:mean],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+        g.line(
+          x1: x - boxwidth/2, y1: ymean, 
+          x2: x + boxwidth/2, y2: ymean, 
+          stroke_dasharray: self.linestyle("--"),
+          stroke: "black")
+
+        # box 
+        yq3 = Plot.mapycoords(box[:q3],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+        yq1 = Plot.mapycoords(box[:q1],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+
+        g.rect(x: x-(boxwidth/2), y: yq3, width: boxwidth, height: (yq3-yq1).abs,opacity: 0.2)
+        g.rect(x: x-(boxwidth/2), y: yq3, width: boxwidth, height: (yq3-yq1).abs,fill: "none", stroke: "black")
+       
+        # whiskers
+        wisker_width = boxwidth/2
+        w1 = Plot.mapycoords(box[:w1],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+        w2 = Plot.mapycoords(box[:w2],@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+       
+        g.path(stroke_dasharray: self.linestyle("-"),stroke: "black") do |wp|
+          wp.m(x,w2)
+          wp.m(-wisker_width/2,0,relative: true)
+          wp.l(wisker_width,0,relative: true)
+          wp.m(x,w2)
+          wp.l(x,yq3)
+
+          wp.m(x,w1)
+          wp.m(-wisker_width/2,0,relative: true)
+          wp.l(wisker_width,0,relative: true)
+          wp.m(x,w1)
+          wp.l(x,yq1)
+        end  
+        # Draw outliers
+        boxesdata[i].each do |y| 
+          next if  (y >= box[:w1] && y <= box[:w2])
+          y = Plot.mapycoords(y,@miny,@maxy,@svg.height,@padtop,@padbottom,ylog)
+          self.marker(@markers[i],x,y,"%g" % y,8)
+        end  
+       
+      end 
+    end 
+    
+  end 
+
+end 
+end 

data/lib/plot2d/lineplot.rb

@@ -0,0 +1,48 @@
+class SVG
+  class Plot
+    def plot(
+      xraw, yraw,
+      minx: @minx,maxx:  @maxx,miny:  @miny,maxy:  @maxy,
+      label:  nil,
+      color: nil,
+      marker: nil,
+      linestyle: nil,
+      opacity:  nil,
+      xlog: false,ylog: false)
+
+      self.set_plot_style(label,color,marker,linestyle,opacity)
+      points = self.map_and_zip(xraw,yraw,minx,maxx,miny,maxy,xlog,ylog)
+      
+      @svg.g(
+        id: @labels.last,
+        stroke: @colors.last, 
+        fill: @colors.last, 
+        stroke_width: @linewidth,
+        opacity: @opacities.last) do |g|
+
+        g.path(title: @labels.last,fill: "none",stroke_dasharray: self.linestyle(linestyle)) do |path|
+          missing = true
+          points.each do |(x,y)|
+            if !x.finite? || !y.finite?
+              missing = true 
+              next
+            end 
+            if missing 
+              path.m(x,y)
+              missing = false
+            end 
+            path.l(x,y) 
+          end 
+        end 
+      
+        g.g(id: @labels.last+"-markers", fill: @colors.last) do |mg| 
+          points.each_with_index do |(x,y),i|
+            next if ((i % (points.size.to_i / @markernum.to_i)) != 0) || !x.finite? || !y.finite?
+            self.marker(@markers.last,x,y,yraw[i].round(2))
+          end 
+        end 
+      end  
+
+    end
+  end
+end 

data/lib/plot2d/markers.rb

@@ -0,0 +1,171 @@
+class SVG
+  class Plot 
+    def marker(marker,x,y,val,ms = @markersize)
+      t = SVG.transform do |t|
+        t.translate(x,y)
+        t.scale(ms)
+        case marker 
+        when "D","x","X" then t.rotate(45)
+        when ">","2","H" then t.rotate(90)
+        when "v","3" then t.rotate(180)
+        when "<","4" then t.rotate(270)
+        else nil
+        end 
+      end 
+
+      case marker 
+      when "." then self.marker_point(t,val)
+      when "," then self.marker_pixel(t,val)
+      when "o" then self.marker_circle(t,val)
+      when "^",">","v","<" then self.marker_triangle(t,val)
+      when "s","D" then self.marker_square(t,val)
+      when "d" then self.marker_diamond(t,val)
+      when "+","x" then self.marker_plus(t,0.1,val)
+      when "P","X" then self.marker_plus(t,0.2,val)
+      when "1","2","3","4" then self.marker_tri(t,val)
+      when "h","H" then self.marker_hexagon(t,val)
+      when "p" then self.marker_pentagon(t,val)
+      when "8" then self.marker_octagon(t,val)
+      when "*" then self.marker_star(t,val)
+      else raise "unkown marker #{marker}"
+      end 
+    end 
+    
+    def marker_point(t,val="")
+      @svg.circle(cx: 0, cy: 0, r: 0.3, transform: t,title: val,stroke_width: 0)
+    end 
+
+    def marker_pixel(t,val="")
+      @svg.circle(cx: 0, cy: 0, r: 0.2, transform: t,title: val,stroke_width: 0)
+    end 
+
+    def marker_circle(t,val="")
+      @svg.circle(cx: 0, cy: 0, r: 0.45, transform: t,title: val,stroke_width: 0)
+    end 
+    
+    def marker_triangle(t,val="")
+      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
+        path.m(0,-0.5)
+        path.l(0.5,0.5)
+        path.l(-0.5,0.5)
+        path.z
+      end 
+    end 
+
+    def marker_square(t,val="")
+      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
+        path.m(-0.4,-0.4)
+        path.h(0.4)
+        path.v(0.4)
+        path.h(-0.4)
+        path.z
+      end 
+    end 
+
+    def marker_diamond(t,val="")
+      @svg.path(transform: t, title: val,stroke_width: 0) do |path|
+        path.m(0,-0.5)
+        path.l(0.3,0)
+        path.l(0,0.5)
+        path.l(-0.3,0.0)
+        path.z
+      end 
+    end 
+
+    def marker_plus(t,width,val="")
+      @svg.path(transform: t, title: val,stroke_width: 0 ) do |path|
+        path.m(-width,-0.5)
+        path.h(width)
+        path.v(0.5)
+        path.h(-width)
+        path.z
+      end 
+      @svg.path(transform: t, title: val,stroke_width: 0 ) do |path|
+        path.m(-0.5,-width)
+        path.v(width)
+        path.h(0.5)
+        path.v(-width)
+        path.z
+      end 
+    end 
+
+    def marker_tri(t,val="")
+      @svg.g(title: val, transform: t,stroke_width: 0) do |g|
+        width = 0.1
+        @svg.path(title: val) do |path|
+          path.m(-width,0.5)
+          path.h(width)
+          path.v(0.0)
+          path.h(-width)
+          path.z
+        end 
+        @svg.path(
+          title: val,
+          transform: SVG.transform{|t| t.rotate(135)}) do |path|
+          path.m(-width,0.5)
+          path.h(width)
+          path.v(0.0)
+          path.h(-width)
+          path.z
+        end 
+        @svg.path(
+          title: val,
+          transform: SVG.transform{|t| t.rotate(225)}) do |path|
+          path.m(-width,0.5)
+          path.h(width)
+          path.v(0.0)
+          path.h(-width)
+          path.z
+        end 
+      end 
+    end 
+    
+    def marker_hexagon(t,val="")
+      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
+        path.m( 0.00,-0.50)
+        path.l( 0.40,-0.20)
+        path.l( 0.40, 0.30)
+        path.l( 0.00, 0.50)
+        path.l(-0.40, 0.30)
+        path.l(-0.40,-0.20)
+        path.z
+      end 
+    end 
+
+    def marker_pentagon(t,val="")
+      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
+        path.m( 0.00,-0.50)
+        path.l( 0.45,-0.10)
+        path.l( 0.30, 0.50)
+        path.l(-0.30, 0.50)
+        path.l(-0.45,-0.10)
+        path.z
+      end 
+    end 
+
+    def marker_octagon(t,val="")
+      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
+        path.m(-0.25,-0.50)
+        path.l( 0.18,-0.50)
+        path.l( 0.50,-0.25)
+        path.l( 0.50, 0.18)
+        path.l( 0.18, 0.50)
+        path.l(-0.25, 0.50)
+        path.l(-0.50, 0.18)
+        path.l(-0.50,-0.25)
+        path.z
+      end 
+    end 
+
+    def marker_star(t,val="")
+      @svg.path(title: val, transform: t,stroke_width: 0) do |path|
+        path.m(0,-0.5)
+        path.l(-0.3,0.5)
+        path.l(0.5,-0.1)
+        path.l(-0.5,-0.1)
+        path.l(0.3,0.5)
+        path.z
+      end 
+    end 
+  end 
+end 

data/lib/plot2d/scatter.rb

@@ -0,0 +1,24 @@
+class SVG
+  class Plot
+    def scatter(
+      xraw, yraw, 
+      minx: @minx, maxx:  @maxx, miny: @miny, maxy: @maxy,
+      label: nil, 
+      color:  nil, 
+      marker:  nil, 
+      opacity:  nil,
+      xlog: false, ylog: false,**args)
+     
+      self.set_plot_style(label,color,marker,"",opacity)
+      points = self.map_and_zip(xraw,yraw,minx,maxx,miny,maxy,xlog,ylog)
+ 
+      @svg.g(id: @labels.last, stroke: "none",fill: @colors.last,opacity: @opacities.last) do |g|
+        points.each_with_index do |(x,y),i|
+          self.marker(@markers.last,x,y,"%g" % yraw[i])
+        end 
+      end 
+    
+    end 
+
+  end
+end 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svg-lib
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Ricardo Nieto
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2020-10-17 00:00:00.000000000 Z
 dependencies: []
 description: basic svg-lib ruby implementation
 email: nifr91@gmail.com
@@ -20,6 +20,10 @@ files:
 - bin/eplot
 - lib/containers.rb
 - lib/plot2d.rb
+- lib/plot2d/boxplot.rb
+- lib/plot2d/lineplot.rb
+- lib/plot2d/markers.rb
+- lib/plot2d/scatter.rb
 - lib/shapes.rb
 - lib/svg-lib.rb
 - lib/text.rb