react-native-vroom-chart 0.14.0 → 0.16.0

package/cpp/_core_src/atr.cpp

@@ -0,0 +1,67 @@
+#include "atr.h"
+
+#include <algorithm>  // std::max
+#include <cmath>      // std::fabs, std::nan
+
+#include "ma.h"
+#include "series_ma.h"
+
+namespace vroom::atr {
+
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             int smoothing, std::vector<double>& out) {
+    out.assign(n, std::nan(""));
+    if (!candles || period < 1) return;
+    const std::size_t P = static_cast<std::size_t>(period);
+    if (n < P) return;
+
+    std::vector<double> tr(n);
+    tr[0] = candles[0].high - candles[0].low;  // no previous close to gap from
+    for (std::size_t i = 1; i < n; ++i) {
+        const double prev_close = candles[i - 1].close;
+        tr[i] = std::max({candles[i].high - candles[i].low,
+                          std::fabs(candles[i].high - prev_close),
+                          std::fabs(candles[i].low - prev_close)});
+    }
+
+    if (smoothing == kSma) {
+        vroom::series_ma::smooth(tr, vroom::ma::KIND_SMA, period, out);
+        return;
+    }
+    if (smoothing == kEma) {
+        vroom::series_ma::smooth(tr, vroom::ma::KIND_EMA, period, out);
+        return;
+    }
+
+    // Wilder's RMA: seeded with the simple average of the first P true ranges,
+    // then avg = (prevAvg * (P - 1) + current) / P.
+    double avg = 0.0;
+    for (std::size_t i = 0; i < P; ++i) avg += tr[i];
+    avg /= static_cast<double>(P);
+    out[P - 1] = avg;
+
+    const double pm1 = static_cast<double>(P - 1);
+    const double pd = static_cast<double>(P);
+    for (std::size_t i = P; i < n; ++i) {
+        avg = (avg * pm1 + tr[i]) / pd;
+        out[i] = avg;
+    }
+}
+
+double autoscale(const double* visible, std::size_t n) {
+    double scale = 0.0;
+    if (!visible) return scale;
+    for (std::size_t i = 0; i < n; ++i) {
+        if (std::isfinite(visible[i])) scale = std::max(scale, visible[i]);
+    }
+    return scale;
+}
+
+double band_fraction(double v, double scale, double y_scale) {
+    // Nothing on show yet — everything sits on the baseline rather than
+    // dividing by zero.
+    if (!(scale > 0.0)) return 0.0;
+    return (v / scale) * kBandPadFraction * y_scale;
+}
+
+}  // namespace vroom::atr

package/cpp/_core_src/atr.h

@@ -0,0 +1,44 @@
+// Average True Range — pure computation, no Skia. Kept Skia-free so it builds
+// into the unit-test target.
+//
+// True Range is the widest of the bar's own high-low span and the two gaps from
+// its extremes to the previous close, so an overnight jump the bar's range
+// misses still counts. ATR is that series smoothed over `period` bars.
+
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+namespace vroom::atr {
+
+// How the true-range series is smoothed. kRma is Wilder's original
+// (alpha = 1/period) and the conventional default.
+enum Smoothing { kRma = 0, kSma = 1, kEma = 2 };
+
+// How much of the pane band the curve is allowed to fill, so a peak stops short
+// of the separator above it instead of touching.
+constexpr double kBandPadFraction = 0.85;
+
+// Computes ATR over [candles, candles+n). `period` is clamped to >= 1.
+// Fills `out` (resized to n): out[i] is the ATR at candle i in price units, or
+// NaN before the first defined value. True range exists from bar 0 (which has
+// no previous close, so it falls back to high - low), so the first ATR lands at
+// index period - 1 — one earlier than RSI.
+void compute(const ::VroomCandle* candles, std::size_t n, int period,
+             int smoothing, std::vector<double>& out);
+
+// The value the pane band is fitted to: the largest finite ATR on show, or 0
+// when there is nothing to plot. ATR is strictly positive, so the domain runs
+// from 0 at the band's bottom edge up to this.
+double autoscale(const double* visible, std::size_t n);
+
+// Where a value sits in the pane band, as a fraction of its height — 0 at the
+// bottom edge, 1 at the top. `y_scale` is the user's y-axis zoom (1 = the
+// default fit). Split out of the renderer so the interval-morph capture maps
+// its geometry through the same math the pane draws with.
+double band_fraction(double v, double scale, double y_scale);
+
+}  // namespace vroom::atr

package/cpp/_core_src/atr_pane.cpp

@@ -0,0 +1,162 @@
+#include "atr_pane.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkTypeface.h"
+#pragma clang diagnostic pop
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+
+#include "atr.h"
+#include "chart.h"
+#include "fonts.h"
+#include "line_morph.h"
+#include "pane_series.h"
+#include "price_format.h"
+#include "style_inherit.h"
+#include "theme.h"
+#include "viewport.h"
+
+namespace vroom::atr_pane {
+
+namespace {
+using vroom::style::color_or;
+using vroom::style::width_or;
+
+constexpr SkColor kAtrLine = 0xff26a69a;  // teal
+constexpr SkColor kDivider = 0xff21262d;  // pane separator
+constexpr float kLineWidth = 1.5f;
+}  // namespace
+
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* atr_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom,
+          const vroom::LineMorph* 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 capture is the whole
+    // frame. Nothing on either side means nothing to paint, shell included.
+    if (n == 0 && vroom::morph_line_count(from, morph_t) == 0) return;
+
+    const VroomATR& cfg = chart.atr;
+
+    // ATR is strictly positive, so the domain runs 0..peak off the bottom edge.
+    // User y-zoom stretches it from there; 1.0 is the default fit.
+    const double scale = vroom::atr::autoscale(atr_visible, n);
+    auto y_for = [&](double v) -> float {
+        return pane_bottom -
+               static_cast<float>(
+                   vroom::atr::band_fraction(v, scale, chart.atr_y_scale)) *
+                   band_h;
+    };
+
+    // The peak the label reports. Mid-morph it eases out of the fit the capture
+    // was taken against, so the number tracks the curve instead of jumping to
+    // the new resolution's peak on the first frame.
+    const double label_scale =
+        (from && morph_t < 1.f)
+            ? from->scale + (scale - from->scale) * static_cast<double>(morph_t)
+            : scale;
+
+    // Mask the band (candles can overflow below the shortened price pane).
+    SkPaint bg;
+    bg.setColor(chart.theme.colors[VROOM_COLOR_BACKGROUND]);
+    canvas->drawRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom),
+                     bg);
+
+    // Pane separator (top edge).
+    SkPaint divider;
+    divider.setColor(kDivider);
+    divider.setStrokeWidth(1.f);
+    canvas->drawLine(0.f, pane_top, candle_right, pane_top, divider);
+
+    canvas->save();
+    canvas->clipRect(SkRect::MakeLTRB(0.f, pane_top, candle_right, pane_bottom));
+
+    if (atr_visible || from) {
+        SkPaint line;
+        line.setAntiAlias(true);
+        line.setColor(color_or(cfg.line_color, kAtrLine));
+        line.setStyle(SkPaint::kStroke_Style);
+        line.setStrokeWidth(width_or(cfg.line_width, kLineWidth));
+        canvas->drawPath(
+            vroom::pane_series::build_path(
+                lay, visible, n, atr_visible, window_ms, visible_start_ms,
+                candle_duration_ms, pane_top, pane_bottom, from, morph_t, y_for),
+            line);
+    }
+
+    // Caption, top-left of the pane.
+    auto tf = vroom::axis_typeface();
+    if (tf) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        char caption[24];
+        std::snprintf(caption, sizeof(caption), "ATR %d", cfg.period);
+        SkRect cb;
+        font.measureText(caption, std::strlen(caption), SkTextEncoding::kUTF8,
+                         &cb);
+        SkPaint cap_paint;
+        cap_paint.setAntiAlias(true);
+        cap_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        canvas->drawString(caption, 6.f, pane_top + 4.f - cb.fTop, font,
+                           cap_paint);
+    }
+    canvas->restore();
+
+    // Peak label in the y-axis strip — ATR is in price units, so it shares the
+    // price axis's formatting. Hidden with that strip.
+    if (tf && label_scale > 0.0 && lay.y_axis_opacity > 0.f) {
+        SkFont font(tf, chart.theme.floats[VROOM_FLOAT_AXIS_FONT_SIZE_PX]);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
+        SkPaint text_paint;
+        text_paint.setAntiAlias(true);
+        text_paint.setColor(chart.theme.colors[VROOM_COLOR_AXIS_TEXT]);
+        text_paint.setAlphaf(text_paint.getAlphaf() * lay.y_axis_opacity);
+        char label[48];
+        vroom::format_price(label, sizeof(label), label_scale, chart.price_fmt);
+        SkRect tb;
+        const float tw = font.measureText(label, std::strlen(label),
+                                          SkTextEncoding::kUTF8, &tb);
+        const float axis_center_x = lay.width_px - lay.y_axis_width_px * 0.5f;
+        const float text_x = axis_center_x - tw * 0.5f;
+        // A series' own peak lands at the top of the padded band whatever the
+        // fit is, so the label's height doesn't move as the morph re-scales —
+        // only the number it reports does. Clamped into the band so a zoomed-in
+        // peak doesn't label another pane.
+        const float half_text = (tb.fBottom - tb.fTop) * 0.5f;
+        const float peak_y = std::clamp(
+            pane_bottom - static_cast<float>(vroom::atr::band_fraction(
+                              label_scale, label_scale, chart.atr_y_scale)) *
+                              band_h,
+            pane_top + half_text, pane_bottom - half_text);
+        const float baseline_y = peak_y - (tb.fTop + tb.fBottom) * 0.5f;
+        canvas->drawString(label, text_x, baseline_y, font, text_paint);
+    }
+}
+
+}  // namespace vroom::atr_pane

package/cpp/_core_src/atr_pane.h

@@ -0,0 +1,48 @@
+// ATR indicator pane — draws the Average True Range line, its caption, and a
+// peak label in the band below the candles. Its own module alongside
+// rsi_pane / macd_pane so the chart orchestrator stays thin.
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "vroom/vroom_chart.h"  // ::VroomCandle
+
+class SkCanvas;
+
+namespace vroom {
+struct Layout;
+struct LineMorph;
+}  // namespace vroom
+
+struct VroomChart;
+
+namespace vroom::atr_pane {
+
+// Draws the ATR pane spanning vertically [pane_top, pane_bottom]. `atr_visible`
+// is the cached ATR series aligned with `visible` (NaN where undefined). ATR is
+// strictly positive and unbounded, so the pane fits 0..peak anchored at its
+// bottom edge rather than centering on a reference level.
+//
+// `from` / `morph_t` are the interval morph: the capture holds the curve's
+// outgoing shape indexed from the right (slot 0 = newest), in fractions of the
+// band, so the pane is free to re-fit across the switch without the shape
+// moving. The peak label eases between the two fits. A fade's outgoing half
+// passes n = 0 with morph_t = 0, which paints the capture alone.
+void draw(SkCanvas* canvas,
+          const VroomChart& chart,
+          const Layout& lay,
+          const ::VroomCandle* visible,
+          std::size_t n,
+          const double* atr_visible,
+          int64_t window_ms,
+          int64_t visible_start_ms,
+          int64_t candle_duration_ms,
+          float candle_right,
+          float pane_top,
+          float pane_bottom,
+          const LineMorph* from = nullptr,
+          float morph_t = 1.f);
+
+}  // namespace vroom::atr_pane