kumiki 0.1.1

data/lib/kumiki/chart/gauge_chart.rb

@@ -0,0 +1,174 @@
+module Kumiki
+  # GaugeChart - arc gauge with thresholds and center value display
+  # Uses fill_arc/stroke_arc APIs for drawing
+
+  GAUGE_PI = 3.14159265358979323846
+
+  class GaugeChart < BaseChart
+    def initialize(value, min_val, max_val)
+      super()
+      @value = value
+      @min_val = min_val
+      @max_val = max_val
+      @thresholds = nil     # Array of [threshold_value, color] pairs
+      @arc_width = 20.0
+      @show_value = true
+      @value_format = nil
+      @unit_text = ""
+      @bg_arc_color = 0xFF3B4261
+    end
+
+    def thresholds(t)
+      @thresholds = t
+      self
+    end
+
+    def arc_width(w)
+      @arc_width = w
+      self
+    end
+
+    def show_value(v)
+      @show_value = v
+      self
+    end
+
+    def unit(u)
+      @unit_text = u
+      self
+    end
+
+    def set_value(v)
+      @value = v
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      chart_size = pw
+      if ph < pw
+        chart_size = ph
+      end
+      radius = chart_size / 2.0 - @arc_width / 2.0 - 10.0
+      if radius < 30.0
+        radius = 30.0
+      end
+      cx = px + pw / 2.0
+      cy = py + ph / 2.0 + 10.0
+
+      # Background arc (270 degrees, from 135 to 405)
+      start_angle = 135.0
+      sweep_total = 270.0
+      painter.stroke_arc(cx, cy, radius, start_angle, sweep_total, @bg_arc_color, @arc_width)
+
+      # Value arc
+      range = @max_val - @min_val
+      if range <= 0.0
+        range = 1.0
+      end
+      fraction = (@value - @min_val) / range
+      if fraction < 0.0
+        fraction = 0.0
+      end
+      if fraction > 1.0
+        fraction = 1.0
+      end
+      value_sweep = fraction * sweep_total
+      arc_color = get_gauge_color(painter, fraction)
+      painter.stroke_arc(cx, cy, radius, start_angle, value_sweep, arc_color, @arc_width)
+
+      # Draw threshold tick marks
+      draw_gauge_ticks(painter, cx, cy, radius)
+
+      # Center value display
+      if @show_value
+        draw_gauge_value(painter, cx, cy)
+      end
+
+      # Min/Max labels
+      draw_gauge_min_max(painter, cx, cy, radius)
+    end
+
+    def get_gauge_color(painter, fraction)
+      if @thresholds == nil
+        return series_color(0)
+      end
+      # thresholds: [[0.5, green], [0.75, yellow], [1.0, red]]
+      i = 0
+      while i < @thresholds.length
+        threshold_frac = @thresholds[i][0]
+        if fraction <= threshold_frac
+          return @thresholds[i][1]
+        end
+        i = i + 1
+      end
+      # Past all thresholds, use last color
+      if @thresholds.length > 0
+        return @thresholds[@thresholds.length - 1][1]
+      end
+      series_color(0)
+    end
+
+    def draw_gauge_ticks(painter, cx, cy, radius)
+      return if @thresholds == nil
+      start_angle = 135.0
+      sweep_total = 270.0
+      tick_r_inner = radius - @arc_width / 2.0 - 2.0
+      tick_r_outer = radius + @arc_width / 2.0 + 2.0
+      tc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @thresholds.length
+        frac = @thresholds[i][0]
+        if frac < 1.0
+          angle_deg = start_angle + frac * sweep_total
+          angle_rad = angle_deg * GAUGE_PI / 180.0
+          cos_a = painter.math_cos(angle_rad)
+          sin_a = painter.math_sin(angle_rad)
+          x1 = cx + tick_r_inner * cos_a
+          y1 = cy + tick_r_inner * sin_a
+          x2 = cx + tick_r_outer * cos_a
+          y2 = cy + tick_r_outer * sin_a
+          painter.draw_line(x1, y1, x2, y2, tc, 1.0)
+        end
+        i = i + 1
+      end
+    end
+
+    def draw_gauge_value(painter, cx, cy)
+      vl = painter.number_to_string(@value)
+      if @unit_text != ""
+        vl = vl + @unit_text
+      end
+      vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 28.0)
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 28.0)
+      vx = cx - vw / 2.0
+      vy = cy + ascent / 2.0
+      tc = Kumiki.theme.text_primary
+      painter.draw_text(vl, vx, vy, Kumiki.theme.font_family, 28.0, tc)
+    end
+
+    def draw_gauge_min_max(painter, cx, cy, radius)
+      lc = Kumiki.theme.text_secondary
+      r_label = radius + @arc_width / 2.0 + 16.0
+      # Min label at 135 degrees
+      min_angle = 135.0 * GAUGE_PI / 180.0
+      min_label = painter.number_to_string(@min_val)
+      mlw = painter.measure_text_width(min_label, Kumiki.theme.font_family, 11.0)
+      mx = cx + r_label * painter.math_cos(min_angle) - mlw
+      my = cy + r_label * painter.math_sin(min_angle)
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      painter.draw_text(min_label, mx, my + ascent, Kumiki.theme.font_family, 11.0, lc)
+      # Max label at 405 degrees = 45 degrees
+      max_angle = 45.0 * GAUGE_PI / 180.0
+      max_label = painter.number_to_string(@max_val)
+      max_x = cx + r_label * painter.math_cos(max_angle)
+      max_y = cy + r_label * painter.math_sin(max_angle)
+      painter.draw_text(max_label, max_x, max_y + ascent, Kumiki.theme.font_family, 11.0, lc)
+    end
+  end
+
+  def GaugeChart(value, min_val, max_val)
+    GaugeChart.new(value, min_val, max_val)
+  end
+
+end

data/lib/kumiki/chart/heatmap_chart.rb

@@ -0,0 +1,223 @@
+module Kumiki
+  # HeatmapChart - 2D grid heatmap with color interpolation
+  # Supports axis labels, value display, color scale legend
+
+  class HeatmapChart < BaseChart
+    def initialize(x_labels, y_labels, data_2d)
+      super()
+      @x_labels = x_labels      # Array of String (column headers)
+      @y_labels = y_labels      # Array of String (row headers)
+      @data_2d = data_2d        # Array of Array[Float] (rows x cols)
+      @show_cell_values = true
+      @color_low = 0xFF1A1B26     # Dark blue/black
+      @color_high = 0xFF7AA2F7    # Bright blue
+      @cell_padding = 2.0
+      @data_min = 0.0
+      @data_max = 1.0
+      @chart_px = 0.0
+      @chart_py = 0.0
+      @chart_pw = 0.0
+      @chart_ph = 0.0
+      @num_rows = 0
+      @num_cols = 0
+      compute_heatmap_range
+    end
+
+    def show_cell_values(v)
+      @show_cell_values = v
+      self
+    end
+
+    def color_range(low, high)
+      @color_low = low
+      @color_high = high
+      self
+    end
+
+    def cell_padding(p)
+      @cell_padding = p
+      self
+    end
+
+    def set_data(x_labels, y_labels, data_2d)
+      @x_labels = x_labels
+      @y_labels = y_labels
+      @data_2d = data_2d
+      compute_heatmap_range
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      return if @x_labels.length == 0
+      return if @y_labels.length == 0
+      @chart_px = px
+      @chart_py = py
+      @chart_pw = pw
+      @chart_ph = ph
+      @num_rows = @y_labels.length
+      @num_cols = @x_labels.length
+      draw_heatmap_cells(painter)
+      draw_heatmap_x_labels(painter)
+      draw_heatmap_y_labels(painter)
+      draw_heatmap_color_legend(painter)
+    end
+
+    def draw_heatmap_cells(painter)
+      cell_w = @chart_pw / (@num_cols * 1.0)
+      cell_h = (@chart_ph - 20.0) / (@num_rows * 1.0)
+      range = @data_max - @data_min
+      if range <= 0.0
+        range = 1.0
+      end
+      ri = 0
+      while ri < @num_rows
+        ci = 0
+        while ci < @num_cols
+          draw_heatmap_cell(painter, ri, ci, cell_w, cell_h, range)
+          ci = ci + 1
+        end
+        ri = ri + 1
+      end
+    end
+
+    def draw_heatmap_cell(painter, ri, ci, cell_w, cell_h, range)
+      val = 0.0
+      if ri < @data_2d.length
+        if ci < @data_2d[ri].length
+          val = @data_2d[ri][ci]
+        end
+      end
+      t = (val - @data_min) / range
+      if t < 0.0
+        t = 0.0
+      end
+      if t > 1.0
+        t = 1.0
+      end
+      c = painter.interpolate_color(@color_low, @color_high, t)
+      cx = @chart_px + ci * 1.0 * cell_w + @cell_padding
+      cy = @chart_py + ri * 1.0 * cell_h + @cell_padding
+      cw = cell_w - @cell_padding * 2.0
+      ch = cell_h - @cell_padding * 2.0
+      painter.fill_round_rect(cx, cy, cw, ch, 3.0, c)
+
+      # Hover highlight
+      if @hover_series == ri
+        if @hover_index == ci
+          hc = painter.with_alpha(4294967295, 60)
+          painter.stroke_rect(cx, cy, cw, ch, hc, 2.0)
+        end
+      end
+
+      if @show_cell_values
+        vl = painter.number_to_string(val)
+        vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 10.0)
+        ascent = painter.get_text_ascent(Kumiki.theme.font_family, 10.0)
+        vx = cx + cw / 2.0 - vw / 2.0
+        vy = cy + ch / 2.0 + ascent / 2.0
+        # Use white text on dark cells, dark on light cells
+        text_c = 4294967295
+        if t > 0.6
+          text_c = 4278190080
+        end
+        painter.draw_text(vl, vx, vy, Kumiki.theme.font_family, 10.0, text_c)
+      end
+    end
+
+    def draw_heatmap_x_labels(painter)
+      cell_w = @chart_pw / (@num_cols * 1.0)
+      lc = Kumiki.theme.text_secondary
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      label_y = @chart_py + @chart_ph - 20.0 + 14.0 + ascent
+      i = 0
+      while i < @num_cols
+        label = @x_labels[i]
+        lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+        lx = @chart_px + i * 1.0 * cell_w + cell_w / 2.0 - lw / 2.0
+        painter.draw_text(label, lx, label_y, Kumiki.theme.font_family, 11.0, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_heatmap_y_labels(painter)
+      cell_h = (@chart_ph - 20.0) / (@num_rows * 1.0)
+      lc = Kumiki.theme.text_secondary
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 11.0)
+      i = 0
+      while i < @num_rows
+        label = @y_labels[i]
+        lw = painter.measure_text_width(label, Kumiki.theme.font_family, 11.0)
+        lx = @chart_px - lw - 6.0
+        ly = @chart_py + i * 1.0 * cell_h + cell_h / 2.0 + ascent / 2.0
+        painter.draw_text(label, lx, ly, Kumiki.theme.font_family, 11.0, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_heatmap_color_legend(painter)
+      # Draw a small gradient bar at the right side
+      lg_w = 16.0
+      lg_h = @chart_ph - 20.0
+      lg_x = @chart_px + @chart_pw + 8.0
+      lg_y = @chart_py
+      steps = 20
+      step_h = lg_h / (steps * 1.0)
+      i = 0
+      while i < steps
+        t = 1.0 - (i * 1.0 / (steps * 1.0))
+        c = painter.interpolate_color(@color_low, @color_high, t)
+        sy = lg_y + i * 1.0 * step_h
+        painter.fill_rect(lg_x, sy, lg_w, step_h + 1.0, c)
+        i = i + 1
+      end
+      # Labels
+      lc = Kumiki.theme.text_secondary
+      ascent = painter.get_text_ascent(Kumiki.theme.font_family, 9.0)
+      max_label = painter.number_to_string(@data_max)
+      min_label = painter.number_to_string(@data_min)
+      painter.draw_text(max_label, lg_x + lg_w + 4.0, lg_y + ascent, Kumiki.theme.font_family, 9.0, lc)
+      painter.draw_text(min_label, lg_x + lg_w + 4.0, lg_y + lg_h, Kumiki.theme.font_family, 9.0, lc)
+    end
+
+    def update_hover
+    end
+
+    private
+
+    def compute_heatmap_range
+      @data_min = 0.0
+      @data_max = 1.0
+      first = true
+      ri = 0
+      while ri < @data_2d.length
+        ci = 0
+        while ci < @data_2d[ri].length
+          v = @data_2d[ri][ci]
+          if first
+            @data_min = v
+            @data_max = v
+            first = false
+          else
+            if v < @data_min
+              @data_min = v
+            end
+            if v > @data_max
+              @data_max = v
+            end
+          end
+          ci = ci + 1
+        end
+        ri = ri + 1
+      end
+      if @data_min == @data_max
+        @data_max = @data_min + 1.0
+      end
+    end
+  end
+
+  def HeatmapChart(x_labels, y_labels, data_2d)
+    HeatmapChart.new(x_labels, y_labels, data_2d)
+  end
+
+end

data/lib/kumiki/chart/line_chart.rb

@@ -0,0 +1,292 @@
+module Kumiki
+  # LineChart - line chart with point markers
+  # Supports multiple series, grid, hover detection
+
+  class LineChart < BaseChart
+    def initialize(x_labels, series_data, series_names)
+      super()
+      @x_labels = x_labels
+      @series_data = series_data
+      @series_names = series_names
+      @show_points = true
+      @point_radius = 4.0
+      @line_width = 2.0
+      @show_grid = true
+      @data_min = 0.0
+      @data_max = 0.0
+      # Computed per-frame
+      @y_scale = nil
+      @y_ticks = nil
+      @x_step = 0.0
+      @num_points = 0
+      @num_series = 0
+      @y_range_min = 0.0
+      @y_range_max = 1.0
+      @chart_px = 0.0
+      @chart_py = 0.0
+      @chart_pw = 0.0
+      @chart_ph = 0.0
+      compute_data_range
+    end
+
+    def show_points(v)
+      @show_points = v
+      self
+    end
+
+    def point_radius(r)
+      @point_radius = r
+      self
+    end
+
+    def line_width(w)
+      @line_width = w
+      self
+    end
+
+    def show_grid(v)
+      @show_grid = v
+      self
+    end
+
+    def set_data(x_labels, series_data, series_names)
+      @x_labels = x_labels
+      @series_data = series_data
+      @series_names = series_names
+      compute_data_range
+      mark_dirty
+      update
+    end
+
+    def render_chart(painter, px, py, pw, ph)
+      return if @x_labels.length == 0
+      return if @series_data.length == 0
+      @chart_px = px
+      @chart_py = py
+      @chart_pw = pw
+      @chart_ph = ph
+      setup_line_counts
+      setup_line_ticks
+      setup_line_y_scale
+      setup_line_x_step
+      draw_y_axis(painter, px, py, pw, ph, @y_ticks, @y_scale)
+      draw_x_axis_line(painter, px, py, pw, ph)
+      draw_x_labels(painter)
+      draw_hover_line(painter)
+      draw_all_series(painter)
+      draw_line_legend(painter, px, py)
+    end
+
+    def setup_line_counts
+      @num_points = @x_labels.length
+      @num_series = @series_data.length
+    end
+
+    def setup_line_ticks
+      @y_ticks = compute_ticks(@data_min, @data_max, 5)
+      @y_range_min = @data_min
+      @y_range_max = @data_max
+      if @y_ticks.length > 0
+        @y_range_min = @y_ticks[0]
+        @y_range_max = @y_ticks[@y_ticks.length - 1]
+      end
+    end
+
+    def setup_line_y_scale
+      bottom = @chart_py + @chart_ph
+      @y_scale = LinearScale.new(@y_range_min, @y_range_max, bottom, @chart_py)
+    end
+
+    def setup_line_x_step
+      @x_step = 0.0
+      if @num_points > 1
+        divisor = (@num_points - 1) * 1.0
+        @x_step = @chart_pw / divisor
+      end
+    end
+
+    def draw_x_labels(painter)
+      lc = Kumiki.theme.text_secondary
+      i = 0
+      while i < @num_points
+        draw_one_x_label(painter, i, lc)
+        i = i + 1
+      end
+    end
+
+    def draw_one_x_label(painter, i, lc)
+      i_f = i * 1.0
+      xx = @chart_px + i_f * @x_step
+      label = @x_labels[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)
+    end
+
+    def draw_hover_line(painter)
+      if @hover_index >= 0
+        if @hover_index < @num_points
+          hi_f = @hover_index * 1.0
+          hx = @chart_px + hi_f * @x_step
+          hc = painter.with_alpha(Kumiki.theme.accent, 80)
+          bottom = @chart_py + @chart_ph
+          painter.draw_line(hx, @chart_py, hx, bottom, hc, 1.0)
+        end
+      end
+    end
+
+    def draw_all_series(painter)
+      si = 0
+      while si < @num_series
+        c = series_color(si)
+        data = @series_data[si]
+        draw_series_lines(painter, data, c)
+        if @show_points
+          draw_series_points(painter, data, c)
+        end
+        si = si + 1
+      end
+    end
+
+    def draw_series_lines(painter, data, c)
+      j = 0
+      while j < @num_points - 1
+        j_f = j * 1.0
+        x1 = @chart_px + j_f * @x_step
+        y1 = @y_scale.map(data[j])
+        j1_f = (j + 1) * 1.0
+        x2 = @chart_px + j1_f * @x_step
+        y2 = @y_scale.map(data[j + 1])
+        painter.draw_line(x1, y1, x2, y2, c, @line_width)
+        j = j + 1
+      end
+    end
+
+    def draw_series_points(painter, data, c)
+      j = 0
+      while j < @num_points
+        draw_one_point(painter, data, j, c)
+        j = j + 1
+      end
+    end
+
+    def draw_one_point(painter, data, j, c)
+      j_f = j * 1.0
+      xx = @chart_px + j_f * @x_step
+      yy = @y_scale.map(data[j])
+      r = @point_radius
+      if @hover_index == j
+        r = @point_radius + 2.0
+      end
+      painter.fill_circle(xx, yy, r, c)
+      if @hover_index == j
+        draw_point_label(painter, data[j], xx, yy, r)
+      end
+    end
+
+    def draw_point_label(painter, val, xx, yy, r)
+      vl = format_axis_value(painter, val)
+      vw = painter.measure_text_width(vl, Kumiki.theme.font_family, 10.0)
+      tc = Kumiki.theme.text_primary
+      painter.draw_text(vl, xx - vw / 2.0, yy - r - 4.0, Kumiki.theme.font_family, 10.0, tc)
+    end
+
+    def draw_line_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 @y_scale == nil
+      if @num_points <= 1
+        @hover_index = -1
+        return
+      end
+      mx = @mouse_x
+      px = plot_x
+      pw = plot_w
+      left_bound = px - @x_step / 2.0
+      right_bound = px + pw + @x_step / 2.0
+      if mx < left_bound
+        @hover_index = -1
+        return
+      end
+      if mx > right_bound
+        @hover_index = -1
+        return
+      end
+      find_nearest_point(mx, px)
+    end
+
+    def find_nearest_point(mx, px)
+      best = -1
+      best_dist = 999999.0
+      i = 0
+      while i < @num_points
+        i_f = i * 1.0
+        xx = px + i_f * @x_step
+        d = mx - xx
+        if d < 0.0
+          d = 0.0 - d
+        end
+        if d < best_dist
+          best_dist = d
+          best = i
+        end
+        i = i + 1
+      end
+      @hover_index = best
+    end
+
+    private
+
+    def compute_data_range
+      @data_min = 0.0
+      @data_max = 1.0
+      first = true
+      si = 0
+      while si < @series_data.length
+        ci = 0
+        while ci < @series_data[si].length
+          v = @series_data[si][ci]
+          if first
+            @data_min = v
+            @data_max = v
+            first = false
+          else
+            if v > @data_max
+              @data_max = v
+            end
+            if v < @data_min
+              @data_min = v
+            end
+          end
+          ci = ci + 1
+        end
+        si = si + 1
+      end
+      range = @data_max - @data_min
+      if range > 0.0
+        @data_max = @data_max + range * 0.1
+        @data_min = @data_min - range * 0.05
+      else
+        @data_max = @data_max + 1.0
+      end
+    end
+  end
+
+  def LineChart(x_labels, series_data, series_names)
+    LineChart.new(x_labels, series_data, series_names)
+  end
+
+end