react-native-vroom-chart 0.15.0 → 0.17.0

package/cpp/_core_src/macd_pane.cpp

@@ -20,6 +20,9 @@
 
 #include "chart.h"
 #include "fonts.h"
+#include "line_morph.h"
+#include "macd.h"
+#include "pane_series.h"
 #include "style_inherit.h"
 #include "theme.h"
 #include "viewport.h"
@@ -34,7 +37,6 @@ constexpr SkColor kMacdLine = 0xff2962ff;    // blue MACD line
 constexpr SkColor kSignalLine = 0xffff6d00;  // orange signal line
 constexpr SkColor kZeroLine = 0xff484f58;    // zero reference
 constexpr SkColor kDivider = 0xff21262d;     // pane separator
-constexpr float kPadFrac = 0.85f;            // keep curves off the band edges
 constexpr float kLineWidth = 1.5f;           // default stroke for both lines
 constexpr float kFadedAlpha = 0.5f;          // easing histogram bars
 
@@ -58,34 +60,42 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom) {
-    if (!canvas || n == 0 || candle_right <= 0.f) return;
+          float pane_bottom,
+          const vroom::LineMorph* macd_from,
+          const vroom::LineMorph* signal_from,
+          const vroom::LineMorph* hist_from,
+          float morph_t) {
+    if (!canvas || candle_right <= 0.f) return;
     const float band_h = pane_bottom - pane_top;
     if (band_h <= 0.f) return;
+    morph_t = std::clamp(morph_t, 0.f, 1.f);
+    // A fade's outgoing half has no new data at all, so the captures are the
+    // whole frame. Nothing on either side means nothing to paint, shell
+    // included.
+    const std::size_t hist_slots =
+        vroom::pane_series::slots(n, hist_from, morph_t);
+    if (n == 0 && hist_slots == 0 &&
+        vroom::morph_line_count(macd_from, morph_t) == 0 &&
+        vroom::morph_line_count(signal_from, morph_t) == 0) {
+        return;
+    }
 
     const VroomMACD& cfg = chart.macd;
     const float mid = (pane_top + pane_bottom) * 0.5f;
-    // User y-zoom scales the amplitude about the zero line (mid). 1.0 = the
-    // default auto-fit; >1 zooms in, <1 zooms out.
-    const float half =
-        band_h * 0.5f * kPadFrac * static_cast<float>(chart.macd_y_scale);
 
     // Auto-scale symmetric about zero across the finite values on show, so
-    // hiding a series lets the rest fill the pane.
-    double scale = 0.0;
-    auto track = [&](const double* s, bool shown) {
-        if (!s || !shown) return;
-        for (std::size_t i = 0; i < n; ++i) {
-            if (std::isfinite(s[i])) scale = std::max(scale, std::abs(s[i]));
-        }
-    };
-    track(macd_visible, cfg.line_visible != 0);
-    track(signal_visible, cfg.signal_visible != 0);
-    track(hist_visible, cfg.hist_visible != 0);
+    // hiding a series lets the rest fill the pane. User y-zoom scales the
+    // amplitude about the zero line; 1.0 is the default auto-fit.
+    const double scale = vroom::macd::autoscale(
+        cfg.line_visible ? macd_visible : nullptr,
+        cfg.signal_visible ? signal_visible : nullptr,
+        cfg.hist_visible ? hist_visible : nullptr, n);
 
     auto y_for = [&](double v) -> float {
-        if (scale <= 0.0) return mid;
-        return mid - static_cast<float>(v / scale) * half;
+        return pane_bottom -
+               static_cast<float>(
+                   vroom::macd::band_fraction(v, scale, chart.macd_y_scale)) *
+                   band_h;
     };
 
     // Mask the band (candles can overflow below the shortened price pane).
@@ -115,7 +125,9 @@ void draw(SkCanvas* canvas,
     // Histogram bars: from the zero line to y_for(hist), 4-color — above or
     // below zero, each in a building and an easing shade. A bar is building
     // while it grows away from zero and easing while it falls back toward it.
-    if (hist_visible && cfg.hist_visible) {
+    if ((hist_visible || hist_from) && cfg.hist_visible) {
+        // The new resolution's width from the first frame, matching how
+        // candles::draw widens its bodies while their positions still slide.
         const float body_w =
             vroom::candle_body_width(lay, window_ms, candle_duration_ms);
         const float half_body = body_w * 0.5f;
@@ -126,68 +138,65 @@ void draw(SkCanvas* canvas,
             color_or(cfg.hist_down_color, chart.theme.colors[VROOM_COLOR_ACCENT_BEAR]);
         const SkColor up_easing = faded_or(cfg.hist_up_fading_color, up);
         const SkColor down_easing = faded_or(cfg.hist_down_fading_color, down);
-        for (std::size_t i = 0; i < n; ++i) {
-            const double h = hist_visible[i];
-            if (!std::isfinite(h)) continue;
-            const bool have_prev = i > 0 && std::isfinite(hist_visible[i - 1]);
-            const double prev = have_prev ? hist_visible[i - 1] : h;
-            bool building = true;
-            if (have_prev) {
-                building = h >= 0.0 ? h >= prev : h <= prev;
+        const std::size_t hist_from_count =
+            vroom::morph_line_count(hist_from, morph_t);
+        // Bars read their sign and direction off the drawn geometry rather than
+        // the values: mid-morph a top is a blend of two resolutions' numbers,
+        // and only where it ended up says which side of zero it is on. y grows
+        // downward, so above zero is the smaller y.
+        MorphVertex prev;
+        for (std::size_t j = 0; j < hist_slots; ++j) {
+            const MorphVertex p = vroom::pane_series::vertex(
+                lay, visible, n, hist_visible, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, hist_from,
+                hist_from_count, morph_t, hist_slots - 1 - j, y_for);
+            if (!p.valid) {
+                prev = MorphVertex{};
+                continue;
             }
+            const bool above = p.y <= zero_y;
+            // Building while the bar grows away from zero, easing while it
+            // falls back toward it.
+            const bool building =
+                !prev.valid || (above ? p.y <= prev.y : p.y >= prev.y);
             SkPaint bar;
             bar.setAntiAlias(true);
-            if (h >= 0.0) {
+            if (above) {
                 bar.setColor(building ? up : up_easing);
             } else {
                 bar.setColor(building ? down : down_easing);
             }
-            const float cx = vroom::candle_center_x(
-                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
-                window_ms);
-            const float vy = y_for(h);
-            const float top = std::min(zero_y, vy);
-            const float bot = std::max(zero_y, vy);
-            canvas->drawRect(
-                SkRect::MakeLTRB(cx - half_body, top, cx + half_body, bot), bar);
+            canvas->drawRect(SkRect::MakeLTRB(p.x - half_body,
+                                              std::min(zero_y, p.y),
+                                              p.x + half_body,
+                                              std::max(zero_y, p.y)),
+                             bar);
+            prev = p;
         }
     }
 
     // MACD + signal lines.
-    auto stroke_series = [&](const double* series, SkColor color, float width) {
-        if (!series) return;
-        SkPathBuilder path;
-        bool pen_down = false;
-        for (std::size_t i = 0; i < n; ++i) {
-            const double v = series[i];
-            if (!std::isfinite(v)) {
-                pen_down = false;
-                continue;
-            }
-            const float x = vroom::candle_center_x(
-                lay, visible[i].time_ms, candle_duration_ms, visible_start_ms,
-                window_ms);
-            const float y = y_for(v);
-            if (pen_down) {
-                path.lineTo(x, y);
-            } else {
-                path.moveTo(x, y);
-                pen_down = true;
-            }
-        }
+    auto stroke_series = [&](const double* series, const vroom::LineMorph* from,
+                             SkColor color, float width) {
+        if (!series && !from) return;
         SkPaint line;
         line.setAntiAlias(true);
         line.setColor(color);
         line.setStyle(SkPaint::kStroke_Style);
         line.setStrokeWidth(width);
-        canvas->drawPath(path.detach(), line);
+        canvas->drawPath(
+            vroom::pane_series::build_path(
+                lay, visible, n, series, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, from, morph_t, y_for),
+            line);
     };
     if (cfg.signal_visible) {
-        stroke_series(signal_visible, color_or(cfg.signal_color, kSignalLine),
+        stroke_series(signal_visible, signal_from,
+                      color_or(cfg.signal_color, kSignalLine),
                       width_or(cfg.signal_width, kLineWidth));
     }
     if (cfg.line_visible) {  // MACD over signal
-        stroke_series(macd_visible, color_or(cfg.line_color, kMacdLine),
+        stroke_series(macd_visible, macd_from, color_or(cfg.line_color, kMacdLine),
                       width_or(cfg.line_width, kLineWidth));
     }
 

package/cpp/_core_src/macd_pane.h

@@ -13,6 +13,7 @@ class SkCanvas;
 
 namespace vroom {
 struct Layout;
+struct LineMorph;
 }  // namespace vroom
 
 struct VroomChart;
@@ -23,6 +24,13 @@ namespace vroom::macd_pane {
 // series are aligned with `visible` (NaN where undefined). The vertical scale
 // auto-fits the visible values symmetrically about zero; shares the candles'
 // horizontal mapping (candle_center_x) so it scrolls in lock-step.
+//
+// The three `*_from` captures plus `morph_t` are the interval morph: each holds
+// its series' outgoing shape in fractions of the band, indexed from the right
+// (slot 0 = newest), so the pane can re-fit across the switch without the shape
+// moving. Histogram bars reshape the way candle bodies do — their tops slide
+// while the zero line, which is fixed to the band center, stays put. A fade's
+// outgoing half passes n = 0 with morph_t = 0, painting the captures alone.
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
           const Layout& lay,
@@ -36,6 +44,10 @@ void draw(SkCanvas* canvas,
           int64_t candle_duration_ms,
           float candle_right,
           float pane_top,
-          float pane_bottom);
+          float pane_bottom,
+          const LineMorph* macd_from = nullptr,
+          const LineMorph* signal_from = nullptr,
+          const LineMorph* hist_from = nullptr,
+          float morph_t = 1.f);
 
 }  // namespace vroom::macd_pane

package/cpp/_core_src/pane_series.h

@@ -0,0 +1,169 @@
+// Polyline plotting shared by the indicator panes (RSI, MACD, ATR), including
+// the interval morph.
+//
+// Each pane maps values into its own band with its own auto-fit, so it hands
+// over its y mapping and everything from the slot pairing down is identical
+// across the three. The capture holds band *fractions* rather than values,
+// which is what lets a pane re-fit across a timeframe switch without its
+// outgoing shape moving.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#pragma clang diagnostic pop
+
+#include "line_morph.h"
+#include "viewport.h"
+#include "vroom/vroom_chart.h"
+
+namespace vroom::pane_series {
+
+// Slot `k` of a pane series in screen pixels, blended from the capture toward
+// the new value. Slot 0 is the rightmost vertex on both sides — the pairing a
+// timeframe switch preserves, the same one candles::draw uses.
+template <typename YFor>
+MorphVertex vertex(const Layout& lay,
+                   const ::VroomCandle* visible,
+                   std::size_t n,
+                   const double* values,
+                   int64_t window_ms,
+                   int64_t visible_start_ms,
+                   int64_t candle_duration_ms,
+                   float pane_top,
+                   float pane_bottom,
+                   const LineMorph* from,
+                   std::size_t from_count,
+                   float morph_t,
+                   std::size_t k,
+                   YFor&& y_for) {
+    MorphVertex to;
+    if (values && k < n) {
+        const std::size_t i = n - 1 - k;
+        const double v = values[i];
+        if (std::isfinite(v)) {
+            to = MorphVertex{
+                vroom::candle_center_x(lay, visible[i].time_ms,
+                                       candle_duration_ms, visible_start_ms,
+                                       window_ms),
+                y_for(v), true};
+        }
+    }
+    MorphVertex frm;
+    if (k < from_count) {
+        const LineSnapshot& s = from->pts[k];
+        if (s.valid) {
+            frm = MorphVertex{s.x * vroom::candle_area_width(lay),
+                              pane_bottom - s.y * (pane_bottom - pane_top),
+                              true};
+        }
+    }
+    return vroom::morph_vertex(to, frm, morph_t);
+}
+
+// How many vertices a morphing series spans: the new slice and the capture can
+// disagree on length, and every slot either defines has to be walked.
+inline std::size_t slots(std::size_t n, const LineMorph* from, float morph_t) {
+    return std::max(n, vroom::morph_line_count(from, morph_t));
+}
+
+// The series as a polyline, walked left to right. A slot neither side defines
+// lifts the pen, which is what leaves the warmup gap open.
+template <typename YFor>
+SkPath build_path(const Layout& lay,
+                  const ::VroomCandle* visible,
+                  std::size_t n,
+                  const double* values,
+                  int64_t window_ms,
+                  int64_t visible_start_ms,
+                  int64_t candle_duration_ms,
+                  float pane_top,
+                  float pane_bottom,
+                  const LineMorph* from,
+                  float morph_t,
+                  YFor&& y_for) {
+    const std::size_t from_count = vroom::morph_line_count(from, morph_t);
+    const std::size_t count = std::max(n, from_count);
+    SkPathBuilder path;
+    bool pen_down = false;
+    for (std::size_t j = 0; j < count; ++j) {
+        const MorphVertex p =
+            vertex(lay, visible, n, values, window_ms, visible_start_ms,
+                   candle_duration_ms, pane_top, pane_bottom, from, from_count,
+                   morph_t, count - 1 - j, y_for);
+        if (!p.valid) {
+            pen_down = false;
+            continue;
+        }
+        if (pen_down) {
+            path.lineTo(p.x, p.y);
+        } else {
+            path.moveTo(p.x, p.y);
+            pen_down = true;
+        }
+    }
+    return path.detach();
+}
+
+// The region between the series and a horizontal rule at `y_band`, as the
+// closed counterpart to build_path. Callers clip to one side of the rule to keep
+// only the stretches that reach past it, which puts the crossings exactly where
+// Skia cuts the geometry rather than anywhere this has to solve for.
+//
+// Each run of vertices gets its own contour, tied down to the rule at both
+// ends. One contour spanning the whole series would close a warmup gap by
+// running straight through it, filling a span the line never drew.
+template <typename YFor>
+SkPath build_band_area(const Layout& lay,
+                       const ::VroomCandle* visible,
+                       std::size_t n,
+                       const double* values,
+                       int64_t window_ms,
+                       int64_t visible_start_ms,
+                       int64_t candle_duration_ms,
+                       float pane_top,
+                       float pane_bottom,
+                       const LineMorph* from,
+                       float morph_t,
+                       float y_band,
+                       YFor&& y_for) {
+    const std::size_t from_count = vroom::morph_line_count(from, morph_t);
+    const std::size_t count = std::max(n, from_count);
+    SkPathBuilder path;
+    bool open = false;
+    float last_x = 0.f;
+    for (std::size_t j = 0; j < count; ++j) {
+        const MorphVertex p =
+            vertex(lay, visible, n, values, window_ms, visible_start_ms,
+                   candle_duration_ms, pane_top, pane_bottom, from, from_count,
+                   morph_t, count - 1 - j, y_for);
+        if (!p.valid) {
+            if (open) {
+                path.lineTo(last_x, y_band);
+                path.close();
+                open = false;
+            }
+            continue;
+        }
+        if (!open) {
+            path.moveTo(p.x, y_band);
+            open = true;
+        }
+        path.lineTo(p.x, p.y);
+        last_x = p.x;
+    }
+    if (open) {
+        path.lineTo(last_x, y_band);
+        path.close();
+    }
+    return path.detach();
+}
+
+}  // namespace vroom::pane_series

package/cpp/_core_src/price_indicator.cpp

@@ -17,8 +17,10 @@
 #include <cstring>
 
 #include "chart.h"
+#include "color_lerp.h"
 #include "fonts.h"
 #include "price_format.h"
+#include "price_indicator_anim.h"
 #include "theme.h"
 #include "ticks.h"
 #include "viewport.h"
@@ -37,17 +39,29 @@ void draw(SkCanvas* canvas,
           const Layout& lay,
           const PriceBounds& bounds,
           float candle_right,
-          float candle_area_h) {
+          float candle_area_h,
+          const vroom::CandleSnapshot* morph_from,
+          float morph_t) {
     if (!canvas || chart.candles.empty()) return;
 
     // The "current price" is the latest period's close, regardless of whether
-    // that candle is horizontally in view.
+    // that candle is horizontally in view. Mid-morph it is wherever that close
+    // has eased to, so the badge stays on the candle's close edge.
     const ::VroomCandle& last = chart.candles.back();
     const bool bull = last.close >= last.open;
-    const SkColor color =
-        chart.theme.colors[bull ? VROOM_COLOR_ACCENT_BULL : VROOM_COLOR_ACCENT_BEAR];
-
-    const float y = vroom::price_to_y(lay, bounds, last.close);
+    const auto level = vroom::price_indicator_anim::level_at(
+        lay, bounds, last.close, bull, morph_from, chart.morph_from_bounds,
+        morph_t);
+
+    // Blended rather than switched, so a candle that changes direction under a
+    // tick carries the indicator's color with it instead of snapping — the same
+    // cross-fade the body itself does.
+    const SkColor color = static_cast<SkColor>(vroom::lerp_argb(
+        chart.theme.colors[bull ? VROOM_COLOR_ACCENT_BEAR : VROOM_COLOR_ACCENT_BULL],
+        chart.theme.colors[bull ? VROOM_COLOR_ACCENT_BULL : VROOM_COLOR_ACCENT_BEAR],
+        level.bull_t));
+
+    const float y = level.y;
     if (y < 0.f || y > candle_area_h) return;  // price scrolled off-range
 
     // Dotted line from the left edge to the y-axis separator.
@@ -73,7 +87,7 @@ void draw(SkCanvas* canvas,
     const vroom::PriceFormat fmt = vroom::with_tick_guard(
         chart.price_fmt,
         vroom::pick_price_interval(bounds.max - bounds.min, candle_area_h));
-    vroom::format_price(buf, sizeof(buf), last.close, fmt);
+    vroom::format_price(buf, sizeof(buf), level.price, fmt);
     const size_t len = std::strlen(buf);
 
     // Measure the tight glyph bounds (origin at the baseline) so we can center

package/cpp/_core_src/price_indicator.h

@@ -10,6 +10,7 @@ class SkCanvas;
 struct VroomChart;
 
 namespace vroom {
+struct CandleSnapshot;
 struct Layout;
 struct PriceBounds;
 }  // namespace vroom
@@ -19,11 +20,20 @@ namespace vroom::price_indicator {
 // Draws the line across [0, candle_right] at the latest close's y, plus the
 // price box in the y-axis strip. `candle_area_h` is the y of the x-axis
 // separator; the indicator is skipped if the close maps outside [0, candle_area_h].
+//
+// `morph_from` is the newest candle's outgoing capture (slot 0 of
+// VroomChart::morph_from), or null to draw the settled close. When present the
+// level eases across `morph_t` on the same clock as the candle it marks, so the
+// badge tracks the bar instead of jumping ahead of it — see
+// price_indicator_anim.h. Callers must only pass a capture that pairs with the
+// newest candle (tip_anchor.h).
 void draw(SkCanvas* canvas,
           const VroomChart& chart,
           const Layout& lay,
           const PriceBounds& bounds,
           float candle_right,
-          float candle_area_h);
+          float candle_area_h,
+          const CandleSnapshot* morph_from = nullptr,
+          float morph_t = 1.f);
 
 }  // namespace vroom::price_indicator

package/cpp/_core_src/price_indicator_anim.h

@@ -0,0 +1,81 @@
+// Where the current-price indicator sits mid-morph (see price_indicator.cpp).
+//
+// The indicator marks the latest close, so every tick moves it. Drawing it
+// straight from that close makes it jump while the candle it belongs to eases
+// into place, which reads as the badge coming loose from the chart. Instead it
+// rides the same capture the candles do: morph_from[0] is the newest candle's
+// outgoing geometry and interval_morph_t is the host's eased clock, so the
+// indicator lands on the candle's close edge on every frame rather than only at
+// the two ends.
+//
+// The y is deliberately the same expression close_vertex uses for slot 0
+// (ma_overlay.cpp). Matching it by construction, rather than by giving the two
+// the same duration, is what keeps the badge glued to the line chart's tip.
+//
+// Skia-free and header-only so the unit tests can cover it; see
+// tests/test_price_indicator_anim.cpp.
+
+#pragma once
+
+#include <algorithm>
+
+#include "viewport.h"
+
+namespace vroom::price_indicator_anim {
+
+// One frame of the indicator.
+struct Level {
+    float y;       // pixels, on the candle's close edge
+    double price;  // what the badge should read
+    float bull_t;  // 0 = the captured direction's color, 1 = the new one
+};
+
+namespace detail {
+inline float lerp(float a, float b, float t) { return a + (b - a) * t; }
+
+// The price a captured band fraction stood for. The capture stores fractions so
+// it survives a resize or a rescale, so recovering the price it came from needs
+// the band it was measured against — which is why morph_from_bounds is kept.
+inline double price_at_fraction(const PriceBounds& b, double frac) {
+    return b.min + frac * (b.max - b.min);
+}
+}  // namespace detail
+
+// `from` is the newest candle's capture, or null when nothing is morphing or
+// the capture doesn't pair with the newest candle (panned into history — see
+// tip_anchor.h, which the caller shares the pairing rule with). A null capture
+// gives the settled values, which is what the indicator drew before it
+// animated at all.
+//
+// `from_bounds` is the price band `from` was captured against
+// (VroomChart::morph_from_bounds).
+inline Level level_at(const Layout& lay,
+                      const PriceBounds& bounds,
+                      double close_new,
+                      bool bull_new,
+                      const CandleSnapshot* from,
+                      const PriceBounds& from_bounds,
+                      float morph_t) {
+    const float to_y = vroom::price_to_y(lay, bounds, close_new);
+    if (!from) return Level{to_y, close_new, 1.f};
+
+    const float t = std::clamp(morph_t, 0.f, 1.f);
+
+    // Two different spaces on purpose. The y interpolates in band fractions,
+    // because that is the space the capture is in and the space the candles
+    // move through — anything else would start the indicator off the pixel the
+    // close occupied last frame. The price interpolates in price space, so both
+    // ends read exactly the close they belong to even when this tick set a new
+    // extreme and rescaled the band underneath. The two agree whenever the band
+    // holds still, which is the overwhelmingly common case: y_at_fraction is
+    // affine, so a fraction lerp and a price lerp are then the same function.
+    const float y =
+        detail::lerp(vroom::y_at_fraction(lay, from->close), to_y, t);
+    const double close_old =
+        detail::price_at_fraction(from_bounds, from->close);
+
+    return Level{y, close_old + (close_new - close_old) * static_cast<double>(t),
+                 from->bull == bull_new ? 1.f : t};
+}
+
+}  // namespace vroom::price_indicator_anim

package/cpp/_core_src/rsi.cpp

@@ -53,4 +53,8 @@ void compute_ma(const std::vector<double>& rsi, int ma_period, int kind,
     vroom::series_ma::smooth(rsi, kind, ma_period, out);
 }
 
+double band_fraction(double v, double y_scale) {
+    return 0.5 + ((v - 50.0) / 100.0) * y_scale;
+}
+
 }  // namespace vroom::rsi

package/cpp/_core_src/rsi.h

@@ -29,4 +29,11 @@ void compute(const ::VroomCandle* candles, std::size_t n, int period,
 void compute_ma(const std::vector<double>& rsi, int ma_period, int kind,
                 std::vector<double>& out);
 
+// Where an RSI value sits in the pane band, as a fraction of its height — 0 at
+// the bottom edge, 1 at the top. The fixed 0..100 domain maps about the band
+// center so the user's y-axis zoom (`y_scale`, 1 = the default fit) stretches
+// symmetrically around 50. Split out of the renderer so the interval-morph
+// capture maps its geometry through the same math.
+double band_fraction(double v, double y_scale);
+
 }  // namespace vroom::rsi