kumiki 0.1.1

data/lib/kumiki/chart/pie_chart.rb

@@ -0,0 +1,222 @@
+module Kumiki
+  # PieChart - pie/donut chart widget
+  # Supports slice labels, percentages, hover, donut mode
+
+  PIE_PI = 3.14159265358979323846
+
+  class PieChart < BaseChart
+    def initialize(labels, values)
+      super()
+      @labels = labels
+      @values = values
+      @donut = false
+      @donut_ratio = 0.5
+      @show_pct = true
+      @show_labels = true
+      @start_angle = -90.0
+      # Computed per-frame
+      @cx = 0.0
+      @cy = 0.0
+      @radius = 20.0
+      @total = 0.0
+    end
+
+    def donut(v)
+      @donut = v
+      self
+    end
+
+    def donut_ratio(r)
+      @donut_ratio = r
+      self
+    end
+
+    def show_percentages(v)
+      @show_pct = v
+      self
+    end
+
+    def show_labels(v)
+      @show_labels = v
+      self
+    end
+
+    def start_angle(a)
+      @start_angle = a
+      self
+    end
+
+    def set_data(labels, values)
+      @labels = labels
+      @values = values
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      return if @labels.length == 0
+      setup_pie(px, py, pw, ph)
+      return if @total <= 0.0
+      draw_slices(painter)
+      draw_donut_hole(painter)
+      draw_pie_legend(painter, px)
+    end
+
+    def setup_pie(px, py, pw, ph)
+      @total = compute_total
+      chart_size = pw
+      if ph < pw
+        chart_size = ph
+      end
+      @radius = chart_size / 2.0 - 10.0
+      if @radius < 20.0
+        @radius = 20.0
+      end
+      @cx = px + pw / 2.0
+      @cy = py + ph / 2.0
+    end
+
+    def compute_total
+      total = 0.0
+      i = 0
+      while i < @values.length
+        total = total + @values[i]
+        i = i + 1
+      end
+      total
+    end
+
+    def draw_slices(painter)
+      angle = @start_angle
+      i = 0
+      while i < @values.length
+        angle = draw_one_slice(painter, i, angle)
+        i = i + 1
+      end
+    end
+
+    def draw_one_slice(painter, i, angle)
+      fraction = @values[i] / @total
+      sweep = fraction * 360.0
+      c = series_color(i)
+      if @hover_index == i
+        c = painter.lighten_color(c, 0.3)
+      end
+      painter.fill_arc(@cx, @cy, @radius, angle, sweep, c)
+      if @show_pct
+        if fraction >= 0.03
+          draw_slice_label(painter, angle, sweep, fraction)
+        end
+      end
+      angle + sweep
+    end
+
+    def draw_slice_label(painter, angle, sweep, fraction)
+      mid_angle = angle + sweep / 2.0
+      rad = mid_angle * PIE_PI / 180.0
+      label_r = compute_label_radius
+      lx = @cx + label_r * painter.math_cos(rad)
+      ly = @cy + label_r * painter.math_sin(rad)
+      pct_val = fraction * 100.0
+      pct = painter.number_to_string(pct_val) + "%"
+      pw2 = painter.measure_text_width(pct, Kumiki.theme.font_family, 11.0)
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      painter.draw_text(pct, lx - pw2 / 2.0, ly + ascent / 2.0, Kumiki.theme.font_family, 11.0, 4294967295)
+    end
+
+    def compute_label_radius
+      if @donut
+        @radius * (1.0 + @donut_ratio) / 2.0
+      else
+        @radius * 0.65
+      end
+    end
+
+    def draw_donut_hole(painter)
+      if @donut
+        inner_r = @radius * @donut_ratio
+        painter.fill_circle(@cx, @cy, inner_r, Kumiki.theme.bg_primary)
+      end
+    end
+
+    def draw_pie_legend(painter, px)
+      if @show_legend
+        legend_y = @cy + @radius + 16.0
+        colors = []
+        i = 0
+        while i < @labels.length
+          colors << series_color(i)
+          i = i + 1
+        end
+        draw_legend(painter, @labels, colors, px + 8.0, legend_y)
+      end
+    end
+
+    def update_hover
+      return if @painter == nil
+      mx = @mouse_x
+      my = @mouse_y
+      dx = mx - @cx
+      dy = my - @cy
+      dist = @painter.math_sqrt(dx * dx + dy * dy)
+      if dist > @radius
+        @hover_index = -1
+        return
+      end
+      if @donut
+        inner = @radius * @donut_ratio
+        if dist < inner
+          @hover_index = -1
+          return
+        end
+      end
+      find_hover_slice(dx, dy)
+    end
+
+    def find_hover_slice(dx, dy)
+      angle_rad = @painter.math_atan2(dy, dx)
+      angle_deg = angle_rad * 180.0 / PIE_PI
+      relative = angle_deg - @start_angle
+      relative = normalize_angle(relative)
+      total = compute_total
+      if total <= 0.0
+        @hover_index = -1
+        return
+      end
+      find_slice_at_angle(relative, total)
+    end
+
+    def normalize_angle(a)
+      while a < 0.0
+        a = a + 360.0
+      end
+      while a >= 360.0
+        a = a - 360.0
+      end
+      a
+    end
+
+    def find_slice_at_angle(relative, total)
+      cumulative = 0.0
+      i = 0
+      while i < @values.length
+        fraction = @values[i] / total
+        sweep = fraction * 360.0
+        if relative >= cumulative
+          if relative < cumulative + sweep
+            @hover_index = i
+            return
+          end
+        end
+        cumulative = cumulative + sweep
+        i = i + 1
+      end
+      @hover_index = -1
+    end
+  end
+
+  def PieChart(labels, values)
+    PieChart.new(labels, values)
+  end
+
+end

data/lib/kumiki/chart/scales.rb

@@ -0,0 +1,79 @@
+module Kumiki
+  # Chart Scales - domain-to-pixel coordinate mapping
+  # Pure math classes, no UI dependency
+
+  class LinearScale
+    def initialize(domain_min, domain_max, range_min, range_max)
+      @domain_min = domain_min
+      @domain_max = domain_max
+      @range_min = range_min
+      @range_max = range_max
+      span = domain_max - domain_min
+      if span == 0.0
+        @factor = 0.0
+      else
+        @factor = (range_max - range_min) / span
+      end
+    end
+
+    def map(value)
+      @range_min + (value - @domain_min) * @factor
+    end
+
+    def domain_min
+      @domain_min
+    end
+
+    def domain_max
+      @domain_max
+    end
+
+    def range_min
+      @range_min
+    end
+
+    def range_max
+      @range_max
+    end
+  end
+
+  class BandScale
+    def initialize(count, range_min, range_max, padding)
+      @count = count
+      @range_min = range_min
+      @range_max = range_max
+      @padding = padding
+      total = range_max - range_min
+      @band_width = compute_band_width(count, total, padding)
+    end
+
+    def compute_band_width(count, total, padding)
+      if count > 0.0
+        slots = count + 1.0
+        pad_total = padding * slots
+        usable = total - pad_total
+        bw = usable / count
+        if bw < 1.0
+          bw = 1.0
+        end
+        bw
+      else
+        total
+      end
+    end
+
+    def map(index)
+      idx = index * 1.0
+      @range_min + @padding + idx * (@band_width + @padding)
+    end
+
+    def band_width
+      @band_width
+    end
+
+    def count
+      @count
+    end
+  end
+
+end

data/lib/kumiki/chart/scatter_chart.rb

@@ -0,0 +1,306 @@
+module Kumiki
+  # ScatterChart - XY scatter plot with point markers
+  # Supports multiple series, hover detection, value labels
+
+  class ScatterChart < BaseChart
+    def initialize(x_data, y_data, series_names)
+      super()
+      @x_data = x_data          # Array of Array[Float] (one per series)
+      @y_data = y_data          # Array of Array[Float] (one per series)
+      @series_names = series_names
+      @point_radius = 5.0
+      @show_grid = true
+      @data_x_min = 0.0
+      @data_x_max = 1.0
+      @data_y_min = 0.0
+      @data_y_max = 1.0
+      @x_scale = nil
+      @y_scale = nil
+      @x_ticks = nil
+      @y_ticks = nil
+      @num_series = 0
+      @chart_px = 0.0
+      @chart_py = 0.0
+      @chart_pw = 0.0
+      @chart_ph = 0.0
+      compute_scatter_range
+    end
+
+    def point_radius(r)
+      @point_radius = r
+      self
+    end
+
+    def show_grid(v)
+      @show_grid = v
+      self
+    end
+
+    def set_data(x_data, y_data, series_names)
+      @x_data = x_data
+      @y_data = y_data
+      @series_names = series_names
+      compute_scatter_range
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      return if @x_data.length == 0
+      @chart_px = px
+      @chart_py = py
+      @chart_pw = pw
+      @chart_ph = ph
+      @num_series = @x_data.length
+      setup_scatter_scales
+      draw_scatter_grid(painter)
+      draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+      draw_x_axis_line(painter, px, py, pw, ph)
+      draw_scatter_x_ticks(painter)
+      draw_all_scatter_points(painter)
+      draw_scatter_legend(painter, px, py)
+    end
+
+    def setup_scatter_scales
+      @x_ticks = compute_ticks(@data_x_min, @data_x_max, 5)
+      @y_ticks = compute_ticks(@data_y_min, @data_y_max, 5)
+      x_min = @data_x_min
+      x_max = @data_x_max
+      y_min = @data_y_min
+      y_max = @data_y_max
+      if @x_ticks.length > 0
+        x_min = @x_ticks[0]
+        x_max = @x_ticks[@x_ticks.length - 1]
+      end
+      if @y_ticks.length > 0
+        y_min = @y_ticks[0]
+        y_max = @y_ticks[@y_ticks.length - 1]
+      end
+      bottom = @chart_py + @chart_ph
+      right = @chart_px + @chart_pw
+      @x_scale = LinearScale.new(x_min, x_max, @chart_px, right)
+      @y_scale = LinearScale.new(y_min, y_max, bottom, @chart_py)
+    end
+
+    def draw_scatter_grid(painter)
+      return if !@show_grid
+      bc = Kumiki.theme.border
+      gc = painter.with_alpha(bc, 40)
+      # Vertical grid lines at x ticks
+      i = 0
+      while i < @x_ticks.length
+        xx = @x_scale.map(@x_ticks[i])
+        bottom = @chart_py + @chart_ph
+        painter.draw_line(xx, @chart_py, xx, bottom, gc, 1.0)
+        i = i + 1
+      end
+    end
+
+    def draw_scatter_x_ticks(painter)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @x_ticks.length
+        xx = @x_scale.map(@x_ticks[i])
+        label = painter.number_to_string(@x_ticks[i])
+        lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+        ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+        label_y = @chart_py + @chart_ph + 14.0 + ascent
+        painter.draw_text(label, xx - lw / 2.0, label_y, Kumiki.theme.font_family, 11.0, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_all_scatter_points(painter)
+      si = 0
+      while si < @num_series
+        c = series_color(si)
+        draw_scatter_series(painter, si, c)
+        si = si + 1
+      end
+    end
+
+    def draw_scatter_series(painter, si, c)
+      xs = @x_data[si]
+      ys = @y_data[si]
+      n = xs.length
+      if ys.length < n
+        n = ys.length
+      end
+      j = 0
+      while j < n
+        xx = @x_scale.map(xs[j])
+        yy = @y_scale.map(ys[j])
+        r = @point_radius
+        if @hover_series == si
+          if @hover_index == j
+            r = @point_radius + 3.0
+          end
+        end
+        painter.fill_circle(xx, yy, r, c)
+        if @hover_series == si
+          if @hover_index == j
+            draw_scatter_label(painter, xs[j], ys[j], xx, yy, r)
+          end
+        end
+        j = j + 1
+      end
+    end
+
+    def draw_scatter_label(painter, xv, yv, xx, yy, r)
+      xl = painter.number_to_string(xv)
+      yl = painter.number_to_string(yv)
+      label = "(" + xl + ", " + yl + ")"
+      lw = painter.measure_text_width(label, Kumiki.theme.font_family, 10.0)
+      tc = Kumiki.theme.text_primary
+      painter.draw_text(label, xx - lw / 2.0, yy - r - 4.0, Kumiki.theme.font_family, 10.0, tc)
+    end
+
+    def draw_scatter_legend(painter, px, py)
+      if @show_legend
+        if @series_names.length > 1
+          colors = []
+          si = 0
+          while si < @series_names.length
+            colors << series_color(si)
+            si = si + 1
+          end
+          draw_legend(painter, @series_names, colors, px + 8.0, py - 20.0)
+        end
+      end
+    end
+
+    def update_hover
+      return if @x_scale == nil
+      mx = @mouse_x
+      my = @mouse_y
+      px = plot_x
+      py = plot_y
+      pw = plot_w
+      ph = plot_h
+      if mx < px
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if mx > px + pw
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if my < py
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      if my > py + ph
+        @hover_index = -1
+        @hover_series = -1
+        return
+      end
+      find_nearest_scatter_point(mx, my)
+    end
+
+    def find_nearest_scatter_point(mx, my)
+      best_si = -1
+      best_j = -1
+      best_dist = 999999.0
+      si = 0
+      while si < @num_series
+        xs = @x_data[si]
+        ys = @y_data[si]
+        n = xs.length
+        if ys.length < n
+          n = ys.length
+        end
+        j = 0
+        while j < n
+          xx = @x_scale.map(xs[j])
+          yy = @y_scale.map(ys[j])
+          dx = mx - xx
+          dy = my - yy
+          d = dx * dx + dy * dy
+          if d < best_dist
+            best_dist = d
+            best_si = si
+            best_j = j
+          end
+          j = j + 1
+        end
+        si = si + 1
+      end
+      threshold = (@point_radius + 8.0) * (@point_radius + 8.0)
+      if best_dist < threshold
+        @hover_series = best_si
+        @hover_index = best_j
+      else
+        @hover_series = -1
+        @hover_index = -1
+      end
+    end
+
+    private
+
+    def compute_scatter_range
+      @data_x_min = 0.0
+      @data_x_max = 1.0
+      @data_y_min = 0.0
+      @data_y_max = 1.0
+      first = true
+      si = 0
+      while si < @x_data.length
+        xs = @x_data[si]
+        ys = @y_data[si]
+        n = xs.length
+        if ys.length < n
+          n = ys.length
+        end
+        j = 0
+        while j < n
+          xv = xs[j]
+          yv = ys[j]
+          if first
+            @data_x_min = xv
+            @data_x_max = xv
+            @data_y_min = yv
+            @data_y_max = yv
+            first = false
+          else
+            if xv < @data_x_min
+              @data_x_min = xv
+            end
+            if xv > @data_x_max
+              @data_x_max = xv
+            end
+            if yv < @data_y_min
+              @data_y_min = yv
+            end
+            if yv > @data_y_max
+              @data_y_max = yv
+            end
+          end
+          j = j + 1
+        end
+        si = si + 1
+      end
+      xr = @data_x_max - @data_x_min
+      yr = @data_y_max - @data_y_min
+      if xr > 0.0
+        @data_x_max = @data_x_max + xr * 0.05
+        @data_x_min = @data_x_min - xr * 0.05
+      else
+        @data_x_max = @data_x_max + 1.0
+      end
+      if yr > 0.0
+        @data_y_max = @data_y_max + yr * 0.05
+        @data_y_min = @data_y_min - yr * 0.05
+      else
+        @data_y_max = @data_y_max + 1.0
+      end
+    end
+  end
+
+  def ScatterChart(x_data, y_data, series_names)
+    ScatterChart.new(x_data, y_data, series_names)
+  end
+
+end