charma 0.1.0

data/examples/violin_charts.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'charma'
+
+SampleMaker = Struct.new(:size) do
+  def r
+    n=0.5
+    4.times.inject(0){ |acc,| acc + rand(-n..n) }
+  end
+
+  def samples(*peaks)
+    srand(0)
+    Array.new(size){
+      r + peaks.sample
+    }
+  end
+end
+
+foobar = SampleMaker.new(20000)
+
+small = SampleMaker.new(6)
+
+Charma::Document.new{ |doc|
+  [
+    {
+      title: "Lorem ipsum",
+      series:[
+        {
+          name: "foo",
+          y: Array.new(4){ |n| foobar.samples(n+2, (n+2)*2) }
+        },
+        {
+          name: "bar",
+          y: Array.new(4){ |n| foobar.samples(n+2, (n+2)*2, 6) }
+        },
+      ],
+      x_ticks: %w(Q1 Q2 Q3 Q4),
+    },
+    {
+      title: "Small size sample",
+      series:[
+        {
+          name: "foo",
+          y: Array.new(4){ |n| small.samples(n+2, (n+2)*2) }
+        },
+        {
+          name: "bar",
+          y: Array.new(4){ |n| small.samples(n+2, (n+2)*2, 6) }
+        },
+      ],
+      x_ticks: %w(Q1 Q2 Q3 Q4),
+    },
+  ].each do |opts|
+    doc.new_page do |page|
+      case opts
+      when Hash
+        page.add_violinchart( opts )
+      when Array
+        opts.each{ |o| page.add_violinchart( o ) }
+      else
+        raise "unexpected input #{opts.inspect}"
+      end
+    end
+  end
+}.render( File.basename(__FILE__, ".*")+".pdf" )

data/lib/charma/bar_chart.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Charma
+  class BarChart < Chart
+    def initialize(opts)
+      super(opts)
+    end
+
+    def draw_bar(pdf, rect, yrange, ys, cols)
+      ratio = 0.75
+      _, bars, = rect.hsplit( (1-ratio)/2, ratio, (1-ratio)/2 )
+      bar_rects = bars.hsplit(*Array.new(ys.size,1))
+      bar_rects.zip(ys, cols) do |bar, y, col|
+        ay = abs_y_positoin(y, bar, yrange)
+        zero = abs_y_positoin(0, bar, yrange)
+        b, t = [ ay, zero ].minmax
+        rc = Rect.new( bar.x, t, bar.w, (t-b) )
+        fill_rect( pdf, rc, col )
+      end
+    end
+
+    def render_chart(pdf, rect, yrange)
+      stroke_rect(pdf, rect)
+      y_values = values(:y).transpose
+      bar_areas = rect.hsplit(*Array.new(y_values.size,1))
+      cols = if y_values.first.size==1
+        colors(y_values.size).map{ |e| [e] }
+      else
+        [colors(y_values.first.size)] * y_values.size
+      end
+      y_values.zip(bar_areas, cols).each do |ys, rc, c|
+        draw_bar(pdf, rc, yrange, ys, c)
+      end
+    end
+
+    def render_xticks(pdf, area)
+      rects = area.hsplit(*Array.new(@opts[:x_ticks].size){ 1 }).map{ |rc0|
+        rc0.hsplit(1,8,1)[1]
+      }
+      draw_samesize_texts( pdf, rects, @opts[:x_ticks], valign: :top )
+    end
+
+    def bar_range
+      ymin = [0, values(:y).flatten.min * 1.1].min
+      ymax = [0, values(:y).flatten.max * 1.1].max
+      [ ymin, ymax ]
+    end
+
+    def render( pdf, rect )
+      stroke_rect(pdf, rect)
+      title_text = @opts[:title]
+      title, main, ticks, bottom = rect.vsplit(
+        (title_text ? 1 : 0),
+        7,
+        (@opts[:x_ticks] ? 0.5 : 0),
+        (bottom_legend? ? 0.5 : 0))
+      draw_text( pdf, title, title_text ) if title_text
+      hratio = [(@opts[:y_label] ? 1 : 0), 1, 10]
+      ylabel, yticks, chart = main.hsplit(*hratio)
+      yrange = @opts[:y_range] || bar_range
+      render_chart(pdf, chart, yrange)
+      if @opts[:y_label]
+        render_rottext(pdf, ylabel, @opts[:y_label] )
+      end
+      if @opts[:x_ticks]
+        _, _, xticks = ticks.hsplit(*hratio)
+        render_xticks(pdf, xticks)
+      end
+      yvalues = tick_values(:y, yrange)
+      render_yticks(pdf, yticks, yrange, yvalues)
+      render_y_grid(pdf, chart, yrange, yvalues)
+      render_legend(pdf, bottom) if bottom_legend?
+    end
+  end
+end

data/lib/charma/chart.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Charma
+  class Chart
+    def initialize(opts)
+      @opts = opts
+    end
+
+    def stroke_rect( pdf, rect )
+      pdf.stroke{
+        pdf.rectangle( [rect.x, rect.y], rect.w, rect.h )
+      }
+    end
+
+    def values(sym)
+      @opts[:series].map{ |s|
+        s[sym].map(&:to_f)
+      }
+    end
+
+    def bottom_legend?
+      has_legend?
+    end
+
+    def has_legend?
+      @opts[:series].any?{ |s| ! s[:name].nil? }
+    end
+
+    def scale_type(sym)
+      key = :"#{sym}_scale"
+      case @opts[key]
+      when :log10
+        :log10
+      else
+        :linear
+      end
+    end
+
+    def scale_value(axis, v)
+      case scale_type(axis)
+      when :log10
+        Math.log10(v)
+      else
+        v
+      end
+    end
+
+    def unscale_value(axis, v)
+      case scale_type(axis)
+      when :log10
+        10.0**v
+      else
+        v
+      end
+    end
+
+    def abs_x_positoin(v, rc, xrange)
+      rx, min, max = [ v, *xrange ].map{ |e| scale_value(:x, e) }
+      (rx-min) * rc.w / (max-min) + rc.x
+    end
+
+    def abs_y_positoin(v, rc, yrange)
+      ry, min, max = [ v, *yrange ].map{ |e| scale_value(:y, e) }
+      (ry-min) * rc.h / (max-min) + rc.bottom
+    end
+
+    def fill_rect( pdf, rect, col )
+      pdf.save_graphics_state do
+        pdf.fill{
+          pdf.fill_color( col )
+          pdf.rectangle( [rect.x, rect.y], rect.w, rect.h )
+        }
+      end
+    end
+
+    def draw_text( pdf, rect, text, opts = {} )
+      pdf.text_box( text,
+        at:rect.topleft,
+        width:rect.w,
+        height:rect.h,
+        align: (opts[:align] || :center),
+        valign: (opts[:valign] || :center),
+        size: (opts[:size] || rect.h),
+        overflow: :shrink_to_fit )
+    end
+
+    def colors(n)
+      case n
+      when 0, 1
+        return ["666666"]
+      else
+        f = ->(t0){
+          t = t0 % 3
+          v = case t
+          when 0..1 then t
+          when 1..2 then 2-t
+          else 0
+          end
+          "%02x" % (v**0.5*255).round
+        }
+        Array.new(n){ |i|
+          t = i*3.0/n+0.5
+          [f[t],f[t+1],f[t+2]].join
+        }
+      end
+    end
+
+    def draw_samesize_texts( pdf, rects, texts, opts={} )
+      pdf.save_graphics_state do
+        size = texts.zip(rects).map{ |txt,rc|
+          w = pdf.width_of(txt, size:1)
+          h = pdf.height_of(txt, size:1)
+          [rc.w.to_f/w ,rc.h.to_f/h].min
+        }.min
+        texts.zip(rects).each do |txt, rc|
+          draw_text( pdf, rc, txt, size:size, **opts )
+        end
+      end
+    end
+
+    def render_rottext( pdf, rect, text )
+      pdf.rotate(90, origin: rect.center) do
+        rc = rect.rot90
+        w = pdf.width_of(text, size:1)
+        h = pdf.height_of(text, size:1)
+        size = [rc.w.to_f/w ,rc.h.to_f/h].min
+        pdf.draw_text( text, size:size, at:rc.bottomleft )
+      end
+    end
+
+    def render_legend( pdf, rect )
+      names = @opts[:series].map.with_index{ |e,ix| e[:name] || "series #{ix}" }
+      rects = rect.hsplit( *([1]*names.size) )
+      name_areas, bar_areas = rects.map{ |rc| rc.hsplit(1,1) }.transpose
+      draw_samesize_texts( pdf, name_areas, names, align: :right )
+      cols = colors(names.size)
+      bar_areas.zip(cols).each do |rc0, col|
+        _, rc1, = rc0.vsplit(1,1,1)
+        rc, = rc1.hsplit(2,1)
+        fill_rect( pdf, rc, col )
+      end
+    end
+
+    def tick_unit(v)
+      base = (10**Math.log10(v).round).to_f
+      man = v/base
+      return 0.5*base if man<0.6
+      return base if man<1.2
+      base*2
+    end
+
+    def tick_values(axis, range)
+      min, max = range.minmax.map{ |e| scale_value( axis, e ) }
+      unit = tick_unit((max - min) * 0.1)
+      i_low = (min / unit).ceil
+      i_hi = (max / unit).floor
+      (i_low..i_hi).map{ |i| unscale_value( axis, i*unit ) }
+    end
+
+    def render_yticks(pdf, area, yrange, yvalues)
+      h = (area.h / yvalues.size) * 0.7
+      rects = yvalues.map{ |v|
+        abs_y = abs_y_positoin( v, area, yrange )
+        Rect.new( area.x, abs_y + h/2, area.w*0.9, h )
+      }
+      svalues = yvalues.map{ |v| "%g " % v }
+      draw_samesize_texts( pdf, rects, svalues, align: :right )
+    end
+    
+    def render_y_grid(pdf, area, yrange, yvalues)
+      pdf.save_graphics_state do
+        pdf.line_width = 0.5
+        yvalues.each do |v|
+          if v==0
+            pdf.stroke_color "000000"
+            pdf.undash
+          else
+            pdf.stroke_color "888888"
+            pdf.dash([2,2])
+          end
+          abs_y = abs_y_positoin( v, area, yrange )
+          pdf.stroke_horizontal_line area.x, area.right, at: abs_y
+        end
+      end
+    end
+
+  end
+end

data/lib/charma/document.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Charma
+  class Document
+    def initialize( &block )
+      @pages = []
+      block[self]
+    end
+
+    def new_page(&block)
+      page = Page.new(self)
+      block[page]
+      @pages.push page
+    end
+
+    def render( filename )
+      raise "no page added" if @pages.empty?
+      opts = @pages.first.create_opts
+      Prawn::Document.generate(filename, opts) do |pdf|
+        @pages.each.with_index do |page,ix|
+          pdf.start_new_page(page.create_opts) if ix != 0
+          page.render(pdf)
+        end
+      end
+    end
+  end
+end

data/lib/charma/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Charma
+  class Error < StandardError; end
+end

data/lib/charma/line_chart.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Charma
+  class LineChart < Chart
+    def initialize(opts)
+      super(opts)
+    end
+
+    def scaled_values(sym)
+      @opts[:series].map{ |e|
+        v = e[sym]
+        if v
+          e[sym].map{ |v| scale_value(sym, v) }
+        else
+          (1..e[:y].size).map(&:to_f)
+        end
+      }
+    end
+
+    def calc_range( sym )
+      r0 = scaled_values(sym).flatten.minmax
+      dist = r0[1] - r0[0]
+      delta = dist==0 ? 1 : dist*0.1
+      raw_range =
+        if 0<=r0[0]
+          [[r0[0]-delta, 0].max, r0[1]+delta]
+        else
+          [r0[0]-delta, r0[1]+delta]
+        end
+      raw_range.map{ |e| unscale_value( sym, e ) }
+    end
+
+    def render_series( pdf, rect, xrange, yrange, s)
+      xs = s[:x] || [*1..s[:y].size]
+      ys = s[:y]
+      points = xs.zip(ys).map{ |x,y|
+        [
+          abs_x_positoin( x, rect, xrange ),
+          abs_y_positoin( y, rect, yrange )
+        ]
+      }
+      pdf.stroke do
+        pdf.move_to( *points.first )
+        points.drop(1).each do |x,y|
+          pdf.line_to(x,y)
+        end
+      end
+    end
+
+    def render_chart(pdf, rect, xrange, yrange)
+      stroke_rect(pdf, rect)
+      cols = colors(@opts[:series].size)
+      pdf.save_graphics_state do
+        pdf.line_width( 4 )
+        @opts[:series].zip(cols).each do |s, col|
+          pdf.stroke_color( col )
+          render_series( pdf, rect, xrange, yrange, s)
+        end
+      end
+    end
+
+    def has_x_ticks?
+      if @opts[:x_ticks].nil?
+        !! @opts[:series].first[:x]
+      else
+        !! @opts[:x_ticks]
+      end
+    end
+
+    def render_xticks(pdf, area, xrange, xticks)
+      xtick_texts = @opts[:x_ticks] || xticks.map{ |e| "%g" % e }
+      w = area.w*0.7 / xticks.size
+      rects = xticks.map{ |rx|
+        ax = abs_x_positoin( rx, area, xrange )
+        Rect.new( ax-w/2, area.y, w, area.h )
+      }
+      draw_samesize_texts( pdf, rects, xtick_texts, valign: :top )
+    end
+
+    def render_x_grid(pdf, area, xrange, xvalues)
+      pdf.save_graphics_state do
+        pdf.line_width = 0.5
+        xvalues.each do |v|
+          if v==0
+            pdf.stroke_color "000000"
+            pdf.undash
+          else
+            pdf.stroke_color "888888"
+            pdf.dash([2,2])
+          end
+          abs_x = abs_x_positoin( v, area, xrange )
+          pdf.stroke_vertical_line area.y, area.bottom, at: abs_x
+        end
+      end
+    end
+
+    def tick_values(axis, range)
+      ticks = @opts[:"#{axis}_ticks"]
+      if @opts[:series].first[axis] || !ticks
+        super(axis, range)
+      else
+        (1..ticks.size).map(&:to_f)
+      end
+    end
+
+    def render( pdf, rect )
+      stroke_rect(pdf, rect)
+      title_text = @opts[:title]
+      title, main, ticks, bottom = rect.vsplit(
+        (title_text ? 1 : 0),
+        7, 
+        (has_x_ticks? ? 0.5 : 0),
+        (bottom_legend? ? 0.5 : 0))
+      draw_text( pdf, title, title_text ) if title_text
+      hratio = [(@opts[:y_label] ? 1 : 0), 1, 10]
+      ylabel, yticks, chart = main.hsplit(*hratio)
+      xrange = @opts[:x_range] || calc_range(:x)
+      yrange = @opts[:y_range] || calc_range(:y)
+      render_chart(pdf, chart, xrange, yrange)
+      xvalues = tick_values(:x, xrange )
+      if has_x_ticks?
+        _, _, xticks = ticks.hsplit(*hratio)
+        render_xticks(pdf, xticks, xrange, xvalues)
+      end
+      render_x_grid(pdf, chart, xrange, xvalues)
+      render_legend(pdf, bottom) if bottom_legend?
+      yvalues = tick_values(:y, yrange)
+      render_yticks(pdf, yticks, yrange, yvalues)
+      render_y_grid(pdf, chart, yrange, yvalues)
+        
+      # end
+      # if @opts[:x_ticks]
+      #   _, _, xticks = ticks.hsplit(*hratio)
+      #   render_xticks(pdf, xticks)
+      # end
+      # yvalues = ytick_values(yrange)
+      # render_yticks(pdf, yticks, yrange, yvalues)
+      # render_y_grid(pdf, chart, yrange, yvalues)
+    end  
+  end
+end

data/lib/charma/page.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Charma
+  class Page
+    def initialize( doc )
+      @doc = doc
+      @graphs = []
+    end
+
+    def create_opts
+      {
+        page_size: "A4",
+        page_layout: :landscape,
+      }
+    end
+
+    def split_rect( rc, pos, size )
+      horz = ([10,1]*size[0])[0..-2]
+      vrect = rc.hsplit( *horz ).select.with_index{ |_,ix| ix.even? }[pos[0]]
+      vert = ([10,1]*size[1])[0..-2]
+      vrect.vsplit( *vert ).select.with_index{ |_,ix| ix.even? }[pos[1]]
+    end
+
+    def area(mb, ix)
+      t = Rect.new(mb.left, mb.top, mb.width, mb.height)
+      c = @graphs.size
+      case c
+      when 1
+        t
+      when 2..3
+        split_rect( t, [ix,0], [c,1] )
+      else
+        w = Math.sqrt(c).ceil
+        h = (c.to_f/w).ceil
+        split_rect( t, ix.divmod(w).reverse, [w, h] )
+      end
+    end
+
+    def render(pdf)
+      pdf.stroke_axis
+      @graphs.each.with_index do |g,ix|
+        g.render( pdf, area(pdf.margin_box, ix) )
+      end
+    end
+
+    def add_barchart(opts)
+      @graphs.push BarChart.new(opts)
+    end
+
+    def add_linechart(opts)
+      @graphs.push LineChart.new(opts)
+    end
+
+    def add_violinchart(opts)
+      @graphs.push ViolinChart.new(opts)
+    end
+  end
+end

data/lib/charma/rect.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Charma
+  Rect = Struct.new( :x, :y, :w, :h ) do
+    def vsplit( *rel_hs )
+      rel_sum = rel_hs.sum
+      abs_y = y.to_f
+      rel_hs.map{ |rel_h|
+        abs_h = rel_h.to_f * h / rel_sum
+        rc = Rect.new( x, abs_y, w, abs_h )
+        abs_y -= abs_h
+        rc
+      }
+    end
+
+    def hsplit( *rel_ws )
+      rel_sum = rel_ws.sum
+      abs_x = x.to_f
+      rel_ws.map{ |rel_w|
+        abs_w = rel_w.to_f * w / rel_sum
+        rc = Rect.new( abs_x, y, abs_w, h )
+        abs_x += abs_w
+        rc
+      }
+    end
+
+    def center
+      [x+w/2, y-h/2]
+    end
+
+    def rot90
+      cx, cy = center
+      Rect.new( cx-h/2, cy+w/2, h, w )
+    end
+
+    def right
+      x+w
+    end
+
+    def bottom
+      y-h
+    end
+
+    def topleft
+      [x,y]
+    end
+
+    def bottomleft
+      [x, y-h]
+    end
+  end
+end

data/lib/charma/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Charma
+  VERSION = "0.1.0"
+end