left, BarSeries series, int lookback, TrendLineConfig config, boolean priceScale) {
+ return new Rule() {
+ @Override
+ public boolean isSatisfied(int index, TradingRecord tradingRecord) {
+ if (index < 1) return false;
+ TrendLineKind kind = TrendLineKind.forCrossDown();
+ double linePrev = TrendLineMath.valueAtEval(
+ series, left, index, index - 1, lookback, config, kind, priceScale);
+ double lineCurr = TrendLineMath.valueAtEval(
+ series, left, index, index, lookback, config, kind, priceScale);
+ if (!Double.isFinite(linePrev) || !Double.isFinite(lineCurr)) return false;
+ Num l0 = left.getValue(index - 1);
+ Num l1 = left.getValue(index);
+ if (l0 == null || l1 == null || l0.isNaN() || l1.isNaN()) return false;
+ Num r0 = series.numFactory().numOf(linePrev);
+ Num r1 = series.numFactory().numOf(lineCurr);
+ return l0.isGreaterThanOrEqual(r0) && l1.isLessThan(r1);
+ }
+ };
+ }
+
+ /** 추세선 — 가격축(OHLC·MA 등) vs 오실레이터 */
+ private static boolean isTrendLinePriceScaleField(String field) {
+ if (field == null || field.isBlank() || "NONE".equalsIgnoreCase(field)) return true;
+ String f = field.toUpperCase();
+ return f.contains("CLOSE") || f.contains("PRICE") || f.contains("HIGH") || f.contains("LOW")
+ || f.contains("OPEN") || f.contains("MA") || f.contains("EMA")
+ || f.contains("UPPER") || f.contains("MIDDLE") || f.contains("LOWER")
+ || f.contains("BAND") || f.contains("DC_") || f.contains("VWAP")
+ || f.contains("CONVERSION") || f.contains("BASE") || f.contains("SPAN")
+ || f.contains("LAGGING") || f.contains("CLOUD");
+ }
+
/**
* CCI_VALUE_20 등 좌측 본선 기간과 신호선(CCI_SIGNAL) 본선 기간을 일치시킨다.
* sidePeriod(우측)는 신호 SMA 길이용 — 본선 CCI/RSI/TRIX 기간으로 쓰지 않는다.
diff --git a/backend/src/main/java/com/goldenchart/service/TrendLineMath.java b/backend/src/main/java/com/goldenchart/service/TrendLineMath.java
new file mode 100644
index 0000000..88b631b
--- /dev/null
+++ b/backend/src/main/java/com/goldenchart/service/TrendLineMath.java
@@ -0,0 +1,294 @@
+package com.goldenchart.service;
+
+import com.goldenchart.dto.TrendLineConfig;
+import com.goldenchart.dto.TrendLineKind;
+import org.ta4j.core.BarSeries;
+import org.ta4j.core.Indicator;
+import org.ta4j.core.num.Num;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * N봉 구간 추세선 — 스윙 피벗(Pivot) 기준.
+ *
+ * fit 구간 [anchor−N, anchor−1] (현재 봉 제외).
+ * 상승 추세선(UP): 스윙 저점 2개(Low, Low₂>Low₁) · 하락 추세선(DOWN): 스윙 고점 2개(High, High₂<High₁).
+ * anchor 봉 i 돌파 판정: 동일 선을 i−1·i 에 extrapolation.
+ * 차트 선분: 피벗 A → anchor(i)까지 연장.
+ */
+public final class TrendLineMath {
+
+ private TrendLineMath() {}
+
+ private record PivotPair(int indexA, double yA, int indexB, double yB) {}
+
+ /** anchor 봉 기준 [anchor−N, anchor−1] 추세선을 evalIndex 에서 평가 */
+ public static double valueAtEval(
+ BarSeries series,
+ Indicator source,
+ int anchorIndex,
+ int evalIndex,
+ int lookback,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ if (series == null || source == null || config == null || kind == null
+ || anchorIndex < 1 || lookback < 2) {
+ return Double.NaN;
+ }
+ int start = anchorIndex - lookback;
+ int end = anchorIndex - 1;
+ if (start < series.getBeginIndex() || end < start) return Double.NaN;
+
+ PivotPair pivots = resolvePivots(series, source, start, end, config, kind, priceScale);
+ if (pivots != null) {
+ return lineAt(pivots, evalIndex);
+ }
+ return fallbackValueAt(series, source, start, end, evalIndex, config, kind, priceScale);
+ }
+
+ /** anchor = index — i 봉 돌파 판정용 */
+ public static double valueAt(
+ BarSeries series,
+ Indicator source,
+ int index,
+ int lookback,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ return valueAtEval(series, source, index, index, lookback, config, kind, priceScale);
+ }
+
+ /** 시그널 차트용 — 피벗 기준 fit 후 index(시그널 봉)까지 연장 */
+ public record Segment(long startTimeSec, double startPrice, long endTimeSec, double endPrice) {}
+
+ public static Segment segmentAt(
+ BarSeries series,
+ Indicator source,
+ int index,
+ int lookback,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ if (series == null || source == null || config == null || kind == null
+ || index < 1 || lookback < 2) {
+ return null;
+ }
+ int start = index - lookback;
+ int end = index - 1;
+ if (start < series.getBeginIndex() || end < start) return null;
+
+ PivotPair pivots = resolvePivots(series, source, start, end, config, kind, priceScale);
+ if (pivots != null) {
+ double yAt = lineAt(pivots, index);
+ if (!Double.isFinite(yAt)) return null;
+ return new Segment(
+ barTimeSec(series, pivots.indexA()), pivots.yA(),
+ barTimeSec(series, index), yAt);
+ }
+ return fallbackSegment(series, source, start, end, index, config, kind, priceScale);
+ }
+
+ // ── 피벗 선정 ───────────────────────────────────────────────────────────
+
+ private static PivotPair resolvePivots(
+ BarSeries series,
+ Indicator source,
+ int start,
+ int end,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ int kLeft = Math.max(0, config.getSwingPrecedingBars());
+ int kRight = Math.max(0, config.getSwingFollowingBars());
+ List swings = collectSwingIndices(series, source, start, end, kLeft, kRight, kind, priceScale);
+ if (swings.size() < 2) return null;
+
+ int swingA = swings.get(0);
+ for (int j = 1; j < swings.size(); j++) {
+ int swingB = swings.get(j);
+ if (swingB <= swingA) continue;
+ double yA = yAtPivot(series, source, swingA, kind, priceScale);
+ double yB = yAtPivot(series, source, swingB, kind, priceScale);
+ if (!Double.isFinite(yA) || !Double.isFinite(yB)) continue;
+ if (kind == TrendLineKind.UP && yB > yA) {
+ return new PivotPair(swingA, yA, swingB, yB);
+ }
+ if (kind == TrendLineKind.DOWN && yB < yA) {
+ return new PivotPair(swingA, yA, swingB, yB);
+ }
+ }
+ return null;
+ }
+
+ private static List collectSwingIndices(
+ BarSeries series,
+ Indicator source,
+ int start,
+ int end,
+ int kLeft,
+ int kRight,
+ TrendLineKind kind,
+ boolean priceScale) {
+ List out = new ArrayList<>();
+ for (int i = start + kLeft; i <= end - kRight; i++) {
+ boolean isSwing = kind == TrendLineKind.UP
+ ? isSwingLow(series, source, i, kLeft, kRight, priceScale)
+ : isSwingHigh(series, source, i, kLeft, kRight, priceScale);
+ if (isSwing) out.add(i);
+ }
+ return out;
+ }
+
+ private static double yAtPivot(
+ BarSeries series, Indicator source, int index, TrendLineKind kind, boolean priceScale) {
+ if (priceScale) {
+ return kind == TrendLineKind.UP
+ ? series.getBar(index).getLowPrice().doubleValue()
+ : series.getBar(index).getHighPrice().doubleValue();
+ }
+ Double v = numAt(source, index);
+ return v != null ? v : Double.NaN;
+ }
+
+ private static boolean isSwingLow(
+ BarSeries series, Indicator source, int i, int prec, int fol, boolean priceScale) {
+ double low = priceScale
+ ? series.getBar(i).getLowPrice().doubleValue()
+ : requireNum(source, i);
+ if (!Double.isFinite(low)) return false;
+ for (int j = i - prec; j <= i + fol; j++) {
+ if (j == i) continue;
+ if (j < series.getBeginIndex() || j > series.getEndIndex()) return false;
+ double v = priceScale
+ ? series.getBar(j).getLowPrice().doubleValue()
+ : requireNum(source, j);
+ if (!Double.isFinite(v) || v < low) return false;
+ }
+ return true;
+ }
+
+ private static boolean isSwingHigh(
+ BarSeries series, Indicator source, int i, int prec, int fol, boolean priceScale) {
+ double high = priceScale
+ ? series.getBar(i).getHighPrice().doubleValue()
+ : requireNum(source, i);
+ if (!Double.isFinite(high)) return false;
+ for (int j = i - prec; j <= i + fol; j++) {
+ if (j == i) continue;
+ if (j < series.getBeginIndex() || j > series.getEndIndex()) return false;
+ double v = priceScale
+ ? series.getBar(j).getHighPrice().doubleValue()
+ : requireNum(source, j);
+ if (!Double.isFinite(v) || v > high) return false;
+ }
+ return true;
+ }
+
+ private static double lineAt(PivotPair p, int evalIndex) {
+ if (p.indexB() == p.indexA()) return p.yA();
+ double t = (evalIndex - p.indexA()) / (double) (p.indexB() - p.indexA());
+ return p.yA() + (p.yB() - p.yA()) * t;
+ }
+
+ // ── 모드별 폴백 (피벗 2개 미충족 시) ─────────────────────────────────────
+
+ private static double fallbackValueAt(
+ BarSeries series,
+ Indicator source,
+ int start,
+ int end,
+ int evalIndex,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ if (TrendLineConfig.MODE_SWING.equals(normalizeMode(config.getMode()))) {
+ return Double.NaN;
+ }
+ if (TrendLineConfig.MODE_REGRESSION.equals(normalizeMode(config.getMode()))) {
+ return regressionAt(series, source, start, end, evalIndex, kind, priceScale);
+ }
+ return twoPointAt(series, source, start, end, evalIndex, kind, priceScale);
+ }
+
+ private static Segment fallbackSegment(
+ BarSeries series,
+ Indicator source,
+ int start,
+ int end,
+ int anchorIndex,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ if (TrendLineConfig.MODE_SWING.equals(normalizeMode(config.getMode()))) {
+ return null;
+ }
+ double y0 = yAtEndpoint(series, source, start, kind, priceScale);
+ if (!Double.isFinite(y0)) return null;
+ double yAt = fallbackValueAt(series, source, start, end, anchorIndex, config, kind, priceScale);
+ if (!Double.isFinite(yAt)) return null;
+ return new Segment(barTimeSec(series, start), y0, barTimeSec(series, anchorIndex), yAt);
+ }
+
+ private static double yAtEndpoint(
+ BarSeries series, Indicator source, int index, TrendLineKind kind, boolean priceScale) {
+ return yAtPivot(series, source, index, kind, priceScale);
+ }
+
+ private static double twoPointAt(
+ BarSeries series, Indicator source, int start, int end, int evalIndex,
+ TrendLineKind kind, boolean priceScale) {
+ double y0 = yAtEndpoint(series, source, start, kind, priceScale);
+ double y1 = yAtEndpoint(series, source, end, kind, priceScale);
+ if (!Double.isFinite(y0) || !Double.isFinite(y1) || end == start) return Double.NaN;
+ double t = (evalIndex - start) / (double) (end - start);
+ return y0 + (y1 - y0) * t;
+ }
+
+ private static double regressionAt(
+ BarSeries series, Indicator source, int start, int end, int evalIndex,
+ TrendLineKind kind, boolean priceScale) {
+ double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+ int count = 0;
+ for (int i = start; i <= end; i++) {
+ double y = yAtEndpoint(series, source, i, kind, priceScale);
+ if (!Double.isFinite(y)) continue;
+ double x = i - start;
+ sumX += x;
+ sumY += y;
+ sumXY += x * y;
+ sumXX += x * x;
+ count++;
+ }
+ if (count < 2) return Double.NaN;
+ double denom = count * sumXX - sumX * sumX;
+ if (Math.abs(denom) < 1e-12) return Double.NaN;
+ double b = (count * sumXY - sumX * sumY) / denom;
+ double a = (sumY - b * sumX) / count;
+ return a + b * (evalIndex - start);
+ }
+
+ private static String normalizeMode(String mode) {
+ if (TrendLineConfig.MODE_REGRESSION.equals(mode)) return TrendLineConfig.MODE_REGRESSION;
+ if (TrendLineConfig.MODE_SWING.equals(mode)) return TrendLineConfig.MODE_SWING;
+ return TrendLineConfig.MODE_TWO_POINT;
+ }
+
+ private static double requireNum(Indicator source, int index) {
+ Double v = numAt(source, index);
+ return v != null ? v : Double.NaN;
+ }
+
+ private static Double numAt(Indicator source, int index) {
+ if (index < 0) return null;
+ Num n = source.getValue(index);
+ if (n == null) return null;
+ double v = n.doubleValue();
+ return Double.isFinite(v) ? v : null;
+ }
+
+ private static long barTimeSec(BarSeries series, int index) {
+ return series.getBar(index).getEndTime().getEpochSecond();
+ }
+}
diff --git a/backend/src/main/java/com/goldenchart/service/TrendLineValueIndicator.java b/backend/src/main/java/com/goldenchart/service/TrendLineValueIndicator.java
new file mode 100644
index 0000000..7ae54d2
--- /dev/null
+++ b/backend/src/main/java/com/goldenchart/service/TrendLineValueIndicator.java
@@ -0,0 +1,51 @@
+package com.goldenchart.service;
+
+import com.goldenchart.dto.TrendLineConfig;
+import com.goldenchart.dto.TrendLineKind;
+import org.ta4j.core.BarSeries;
+import org.ta4j.core.Indicator;
+import org.ta4j.core.indicators.AbstractIndicator;
+import org.ta4j.core.num.Num;
+
+import static org.ta4j.core.num.NaN.NaN;
+
+/** bar index 에서 N봉 추세선 Y값 — left 지표·종가와 CROSS 비교용 */
+public class TrendLineValueIndicator extends AbstractIndicator {
+
+ private final Indicator source;
+ private final BarSeries series;
+ private final int lookback;
+ private final TrendLineConfig config;
+ private final TrendLineKind kind;
+ private final boolean priceScale;
+
+ public TrendLineValueIndicator(
+ Indicator source,
+ BarSeries series,
+ int lookback,
+ TrendLineConfig config,
+ TrendLineKind kind,
+ boolean priceScale) {
+ super(series);
+ this.source = source;
+ this.series = series;
+ this.lookback = Math.max(2, lookback);
+ this.config = config != null ? config : TrendLineConfig.defaults();
+ this.kind = kind != null ? kind : TrendLineKind.DOWN;
+ this.priceScale = priceScale;
+ }
+
+ @Override
+ public Num getValue(int index) {
+ double v = TrendLineMath.valueAt(series, source, index, lookback, config, kind, priceScale);
+ if (!Double.isFinite(v)) {
+ return NaN;
+ }
+ return series.numFactory().numOf(v);
+ }
+
+ @Override
+ public int getCountOfUnstableBars() {
+ return lookback + 1;
+ }
+}
diff --git a/backend/src/main/resources/db/migration/V71__backtest_trend_line_settings.sql b/backend/src/main/resources/db/migration/V71__backtest_trend_line_settings.sql
new file mode 100644
index 0000000..876ef42
--- /dev/null
+++ b/backend/src/main/resources/db/migration/V71__backtest_trend_line_settings.sql
@@ -0,0 +1,7 @@
+-- 추세선 전략 조건 — 백테스트/전략평가 공통 설정
+ALTER TABLE gc_backtest_settings
+ ADD COLUMN trend_line_mode VARCHAR(20) NOT NULL DEFAULT 'TWO_POINT'
+ COMMENT 'TWO_POINT | REGRESSION | SWING',
+ ADD COLUMN trend_line_default_lookback INT NOT NULL DEFAULT 10,
+ ADD COLUMN trend_line_swing_preceding_bars INT NOT NULL DEFAULT 1,
+ ADD COLUMN trend_line_swing_following_bars INT NOT NULL DEFAULT 1;
diff --git a/backend/src/test/java/com/goldenchart/service/TrendLineCrossRuleTest.java b/backend/src/test/java/com/goldenchart/service/TrendLineCrossRuleTest.java
new file mode 100644
index 0000000..85b5583
--- /dev/null
+++ b/backend/src/test/java/com/goldenchart/service/TrendLineCrossRuleTest.java
@@ -0,0 +1,179 @@
+package com.goldenchart.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.goldenchart.dto.TrendLineConfig;
+import com.goldenchart.dto.TrendLineKind;
+import org.junit.jupiter.api.Test;
+import org.ta4j.core.BarSeries;
+import org.ta4j.core.BaseBarSeriesBuilder;
+import org.ta4j.core.Rule;
+import org.ta4j.core.TradingRecord;
+import org.ta4j.core.indicators.helpers.ClosePriceIndicator;
+import org.ta4j.core.num.DecimalNum;
+import org.ta4j.core.num.Num;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/** N봉 추세선 돌파 — 스윙 피벗 (상승 지지 / 하락 저항) */
+class TrendLineCrossRuleTest {
+
+ private final StrategyDslToTa4jAdapter adapter = new StrategyDslToTa4jAdapter();
+ private final ObjectMapper om = new ObjectMapper();
+
+ @Test
+ void trendLineCrossUp_swingPivot_breaksDescendingResistance() throws Exception {
+ BarSeries series = buildDescendingHighsThenBreakUp();
+ Rule rule = buildTrendLineRule(series, "TREND_LINE_CROSS_UP", 8, TrendLineConfig.builder()
+ .mode(TrendLineConfig.MODE_SWING)
+ .defaultLookback(8)
+ .swingPrecedingBars(1)
+ .swingFollowingBars(1)
+ .build());
+
+ int last = series.getEndIndex();
+ assertTrue(rule.isSatisfied(last, null), "저항(하락) 추세선 상향 돌파");
+ assertFalse(rule.isSatisfied(last - 1, null), "직전 봉은 미돌파");
+ }
+
+ @Test
+ void trendLineCrossDown_swingPivot_breaksAscendingSupport() throws Exception {
+ BarSeries series = buildAscendingLowsThenBreakDown();
+ Rule rule = buildTrendLineRule(series, "TREND_LINE_CROSS_DOWN", 8, TrendLineConfig.builder()
+ .mode(TrendLineConfig.MODE_SWING)
+ .defaultLookback(8)
+ .swingPrecedingBars(1)
+ .swingFollowingBars(1)
+ .build());
+
+ int last = series.getEndIndex();
+ assertTrue(rule.isSatisfied(last, null), "지지(상승) 추세선 하향 돌파");
+ }
+
+ @Test
+ void trendLineValueIndicator_matchesMath() {
+ BarSeries series = buildDescendingHighsThenBreakUp();
+ ClosePriceIndicator close = new ClosePriceIndicator(series);
+ TrendLineConfig cfg = TrendLineConfig.builder()
+ .mode(TrendLineConfig.MODE_SWING)
+ .defaultLookback(8)
+ .swingPrecedingBars(1)
+ .swingFollowingBars(1)
+ .build();
+ TrendLineValueIndicator ind = new TrendLineValueIndicator(
+ close, series, 8, cfg, TrendLineKind.DOWN, true);
+ int idx = series.getEndIndex();
+ double expected = TrendLineMath.valueAt(series, close, idx, 8, cfg, TrendLineKind.DOWN, true);
+ Num v = ind.getValue(idx);
+ assertEquals(expected, v.doubleValue(), 1e-9);
+ }
+
+ @Test
+ void trendLineCross_usesFixedWindow_notCurrentBarInFit() {
+ BarSeries series = buildDescendingHighsThenBreakUp();
+ ClosePriceIndicator close = new ClosePriceIndicator(series);
+ TrendLineConfig cfg = TrendLineConfig.builder()
+ .mode(TrendLineConfig.MODE_SWING)
+ .defaultLookback(8)
+ .swingPrecedingBars(1)
+ .swingFollowingBars(1)
+ .build();
+ int idx = series.getEndIndex();
+ TrendLineKind kind = TrendLineKind.DOWN;
+
+ double lineAtPrev = TrendLineMath.valueAtEval(series, close, idx, idx - 1, 8, cfg, kind, true);
+ double lineAtCurr = TrendLineMath.valueAtEval(series, close, idx, idx, 8, cfg, kind, true);
+ assertTrue(Double.isFinite(lineAtPrev));
+ assertTrue(Double.isFinite(lineAtCurr));
+
+ double shiftedWrong = TrendLineMath.valueAtEval(series, close, idx - 1, idx - 1, 8, cfg, kind, true);
+ assertNotEquals(lineAtPrev, shiftedWrong, 1e-6,
+ "i−1·i는 동일 [idx−N, idx−1] 창의 추세선이어야 함");
+ }
+
+ @Test
+ void pivotUp_requiresHigherSecondLow() {
+ BarSeries series = buildInvalidUpTrendFlatLows();
+ ClosePriceIndicator close = new ClosePriceIndicator(series);
+ TrendLineConfig cfg = TrendLineConfig.builder()
+ .mode(TrendLineConfig.MODE_SWING)
+ .defaultLookback(8)
+ .swingPrecedingBars(1)
+ .swingFollowingBars(1)
+ .build();
+ int idx = series.getEndIndex();
+ double v = TrendLineMath.valueAtEval(
+ series, close, idx, idx, 8, cfg, TrendLineKind.UP, true);
+ assertTrue(Double.isNaN(v), "두 번째 저점이 더 높지 않으면 피벗 추세선 없음");
+ }
+
+ private Rule buildTrendLineRule(BarSeries series, String condType, int lookback, TrendLineConfig cfg)
+ throws Exception {
+ String json = """
+ {
+ "type": "CONDITION",
+ "condition": {
+ "indicatorType": "MA",
+ "conditionType": "%s",
+ "leftField": "CLOSE_PRICE",
+ "rightField": "NONE",
+ "lookbackPeriod": %d
+ }
+ }
+ """.formatted(condType, lookback);
+ var dsl = om.readTree(json);
+ var ctx = new StrategyDslToTa4jAdapter.RuleBuildContext(
+ series, Map.of(), Map.of(), null, null, false, Map.of(), cfg);
+ return adapter.toRule(dsl, ctx);
+ }
+
+ /** 하락 저항선(고점↓) — 마지막 봉 종가 상향 돌파 */
+ private static BarSeries buildDescendingHighsThenBreakUp() {
+ double[] highs = {100, 101, 102, 115, 110, 108, 106, 104, 102, 108, 105, 112};
+ double[] closes = {99, 100, 101, 113, 108, 106, 104, 102, 100, 106, 104, 111};
+ return toSeriesFromHighs(highs, closes);
+ }
+
+ /** 상승 지지선(저점↑) — 마지막 봉 종가 하향 돌파 */
+ private static BarSeries buildAscendingLowsThenBreakDown() {
+ double[] lows = {108, 109, 110, 95, 96, 97, 98, 99, 100, 101, 102, 108};
+ double[] closes = {110, 111, 112, 97, 98, 99, 100, 101, 102, 103, 104, 101};
+ return toSeriesFromLows(lows, closes);
+ }
+
+ /** 두 스윙 저점이 같은 높이 — UP 피벗 불성립 */
+ private static BarSeries buildInvalidUpTrendFlatLows() {
+ double[] lows = {98, 98, 98, 95, 95, 95, 95, 95, 95, 95, 95, 94};
+ double[] closes = {100, 100, 100, 97, 97, 97, 97, 97, 97, 97, 97, 96};
+ return toSeriesFromLows(lows, closes);
+ }
+
+ private static BarSeries toSeriesFromHighs(double[] highs, double[] closes) {
+ BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(DecimalNum.class).build();
+ Instant t = Instant.parse("2024-01-01T00:00:00Z");
+ for (int i = 0; i < highs.length; i++) {
+ double c = closes[i];
+ double h = highs[i];
+ double l = Math.min(c, h) - 1;
+ series.addBar(t, t.plus(Duration.ofMinutes(1)), c, h, l, c, 1);
+ t = t.plus(Duration.ofMinutes(1));
+ }
+ return series;
+ }
+
+ private static BarSeries toSeriesFromLows(double[] lows, double[] closes) {
+ BarSeries series = new BaseBarSeriesBuilder().withNumTypeOf(DecimalNum.class).build();
+ Instant t = Instant.parse("2024-01-01T00:00:00Z");
+ for (int i = 0; i < lows.length; i++) {
+ double c = closes[i];
+ double l = lows[i];
+ double h = Math.max(c, l) + 1;
+ series.addBar(t, t.plus(Duration.ofMinutes(1)), c, h, l, c, 1);
+ t = t.plus(Duration.ofMinutes(1));
+ }
+ return series;
+ }
+}
diff --git a/frontend/src/components/SettingsPage.tsx b/frontend/src/components/SettingsPage.tsx
index 1d381c2..cc6025f 100644
--- a/frontend/src/components/SettingsPage.tsx
+++ b/frontend/src/components/SettingsPage.tsx
@@ -6,11 +6,15 @@ import React, { useState, useEffect, useCallback } from 'react';
import type { Theme } from '../types';
import {
loadBacktestSettings,
+ saveBacktestSettings,
saveLiveStrategySettings,
+ type BacktestSettingsDto,
type LiveStrategySettingsDto,
+ DEFAULT_BACKTEST_SETTINGS,
} from '../utils/backendApi';
import { syncStrategyTimeframesFromLayoutIfNeeded } from '../utils/strategyTimeframeSync';
import { BacktestSettingsPanel } from './BacktestSettingsPanel';
+import TrendLineSettingsFields from './TrendLineSettingsFields';
import IndicatorMainDefaultsPanel, {
type IndicatorSaveUiState,
} from './IndicatorMainDefaultsPanel';
@@ -1366,15 +1370,32 @@ const StrategyPanel: React.FC = ({
);
const [liveSaving, setLiveSaving] = useState(false);
const [backtestPositionMode, setBacktestPositionMode] = useState<'LONG_ONLY' | 'SIGNAL_ONLY'>('LONG_ONLY');
+ const [trendLineCfg, setTrendLineCfg] = useState(DEFAULT_BACKTEST_SETTINGS);
+ const [trendLineSaving, setTrendLineSaving] = useState(false);
useEffect(() => {
void loadBacktestSettings().then(s => {
- if (s?.positionMode === 'SIGNAL_ONLY' || s?.positionMode === 'LONG_ONLY') {
- setBacktestPositionMode(s.positionMode);
+ if (s) {
+ setTrendLineCfg(s);
+ if (s.positionMode === 'SIGNAL_ONLY' || s.positionMode === 'LONG_ONLY') {
+ setBacktestPositionMode(s.positionMode);
+ }
}
});
}, []);
+ const persistTrendLine = useCallback(async (patch: Partial) => {
+ const next = { ...trendLineCfg, ...patch };
+ setTrendLineCfg(next);
+ setTrendLineSaving(true);
+ try {
+ const saved = await saveBacktestSettings(next);
+ if (saved) setTrendLineCfg(saved);
+ } finally {
+ setTrendLineSaving(false);
+ }
+ }, [trendLineCfg]);
+
useEffect(() => {
if (liveSettingsProp) setLiveSettings(liveSettingsProp);
}, [liveSettingsProp]);
@@ -1582,6 +1603,19 @@ const StrategyPanel: React.FC = ({
)}
+ {/* ── 추세선 설정 ──────────────────────────────────────────────────── */}
+
+
+ 추세선 돌파 조건에서 이전 N봉 구간 추세선을 계산하는 방식입니다.
+ 2점·회귀·스윙 중 하나로 고정되며, 시그널 발생 봉마다 해당 시점의 선으로 평가합니다.
+ {trendLineSaving && 저장 중…}
+
+ { void persistTrendLine(patch); }}
+ />
+
+
{/* ── 리스크 관리 ──────────────────────────────────────────────────── */}
diff --git a/frontend/src/components/StrategyEditorPage.tsx b/frontend/src/components/StrategyEditorPage.tsx
index 5ce6433..603cc00 100644
--- a/frontend/src/components/StrategyEditorPage.tsx
+++ b/frontend/src/components/StrategyEditorPage.tsx
@@ -48,6 +48,8 @@ import {
import IndicatorPaletteTab from './strategyEditor/IndicatorPaletteTab';
import TemplatePaletteTab, { type TemplatePaletteRow } from './strategyEditor/TemplatePaletteTab';
import SidewaysFilterPaletteTab from './strategyEditor/SidewaysFilterPaletteTab';
+import TrendLinePaletteTab from './strategyEditor/TrendLinePaletteTab';
+import { buildTrendLineConditionNode } from '../utils/trendLinePalette';
import { buildSidewaysFilterNode, loadSidewaysPaletteItems } from '../utils/sidewaysFilterPaletteStorage';
import {
BAND_PALETTE_CHIP_ITEMS,
@@ -319,7 +321,7 @@ export default function StrategyEditorPage({
const [sellCondition, setSellCondition] = useState(null);
const [signalTab, setSignalTab] = useState('buy');
const [rightTab, setRightTab] = useState<'indicators' | 'templates'>('indicators');
- const [indicatorSubTab, setIndicatorSubTab] = useState<'auxiliary' | 'composite' | 'range'>('auxiliary');
+ const [indicatorSubTab, setIndicatorSubTab] = useState<'auxiliary' | 'composite' | 'range' | 'trendline'>('auxiliary');
const [auxiliaryPalette, setAuxiliaryPalette] = useState(() => loadPaletteItems('auxiliary'));
const [compositePalette, setCompositePalette] = useState(() => loadPaletteItems('composite'));
const [sidewaysPalette, setSidewaysPalette] = useState(() => loadSidewaysPaletteItems());
@@ -1436,6 +1438,15 @@ export default function StrategyEditorPage({
scheduleStrategyPersist();
}, [DEF, currentRoot, setCurrentRoot, scheduleStrategyPersist, sidewaysPalette]);
+ const applyTrendLine = useCallback((item: { indicatorType: string; leftField?: string }, lookback: number) => {
+ const newNode = buildTrendLineConditionNode(item, buySellTab(signalTab), DEF, lookback);
+ handleEditorStateChange(prev => {
+ const root = prev.root;
+ if (!root) return updateBranchRoot(prev, START_NODE_ID, newNode);
+ return updateBranchRoot(prev, START_NODE_ID, mergeAtRoot(root, newNode, false));
+ });
+ }, [signalTab, DEF, handleEditorStateChange]);
+
const templateRows = useMemo(
() => buildStrategyTemplatePaletteRows({
def: DEF,
@@ -2487,6 +2498,16 @@ export default function StrategyEditorPage({
>
횡보필터
+
{indicatorSubTab === 'auxiliary' ? (
- ) : (
+ ) : indicatorSubTab === 'range' ? (
+ ) : (
+ setSelectedPaletteKey(id ? paletteKey('trendline', id) : null)}
+ onAddToCanvas={(item, lookback) => {
+ selectPalette('trendline', item.id);
+ applyTrendLine(item, lookback);
+ }}
+ />
)}
)}
diff --git a/frontend/src/components/TrendLineSettingsFields.tsx b/frontend/src/components/TrendLineSettingsFields.tsx
new file mode 100644
index 0000000..82e2e3b
--- /dev/null
+++ b/frontend/src/components/TrendLineSettingsFields.tsx
@@ -0,0 +1,103 @@
+/**
+ * 설정 화면 — 전략 설정 · 추세선 조건
+ */
+import React from 'react';
+import type { BacktestSettingsDto } from '../utils/backendApi';
+
+export const TREND_LINE_MODE_OPTIONS = [
+ {
+ value: 'SWING' as const,
+ label: '스윙 피벗 (권장)',
+ desc: 'N봉 내 스윙 고/저점 2개 — 상승=저점↑·하락=고점↓',
+ },
+ {
+ value: 'TWO_POINT' as const,
+ label: '2점 폴백',
+ desc: '피벗 미충족 시 구간 양端(Low/High) 직선',
+ },
+ {
+ value: 'REGRESSION' as const,
+ label: '회귀 폴백',
+ desc: '피벗 미충족 시 N봉 Low/High OLS',
+ },
+];
+
+interface Props {
+ cfg: BacktestSettingsDto;
+ onChange: (patch: Partial) => void;
+}
+
+export const TrendLineSettingsFields: React.FC = ({ cfg, onChange }) => {
+ const mode = cfg.trendLineMode ?? 'SWING';
+
+ return (
+ <>
+
+
+ 추세선 정의
+
+ 매수(상향 돌파)=하락 저항선(스윙 고점↓) · 매도(하향 돌파)=상승 지지선(스윙 저점↑).
+ 가격축은 Low/High, 오실레이터는 지표값 기준 스윙을 사용합니다.
+
+
+
+
+
+ 기본 lookback (봉)
+
+ [i−N, i−1] 구간에서 피벗을 찾고 i 봉까지 연장합니다. 단기 30~50·중기 100~120 권장.
+
+
+
onChange({ trendLineDefaultLookback: Number(e.target.value) })}
+ />
+
+
+ 스윙 — 좌측 k봉
+
+ 피벗 판정: 해당 봉 Low/High가 좌·우 각 k봉보다 극단적일 때 스윙으로 인정
+
+
+
onChange({ trendLineSwingPrecedingBars: Number(e.target.value) })}
+ />
+
+
+ 스윙 — 우측 k봉
+ 피벗 판정 우측 비교 봉 수 (k)
+
+
onChange({ trendLineSwingFollowingBars: Number(e.target.value) })}
+ />
+
+
+ 추세선 돌파
+
+ {signalType === 'buy' ? '매수: 상향 돌파' : '매도: 하향 돌파'}
+
+
+
+
+ {items.map(item => (
+
onSelectItem(item.id)}
+ onAdd={() => onAddToCanvas(item, defaultLookback)}
+ />
+ ))}
+
+
+ {items.length === 0 && (
+
검색 결과가 없습니다.
+ )}
+