last ...

2026-01-06 11:48:16 +03:30
parent fb03a1c88a
commit e6165f44f2
4 changed files with 1308 additions and 566 deletions
@@ -2391,7 +2391,7 @@ class XCX121XKIPOIDetector : public XCMarketPatternDetector
        //
        return result;
    }
-    
+
    bool HasOrderFlow(
        XBoxZone &flow[],
        int barIndex = 0,
@@ -2567,6 +2567,10 @@ class XCX121XKIPOIDetector : public XCMarketPatternDetector

        //
        result = HasChild(flow);
+        if (result)
+        {
+            Sort(flow);
+        }

        //
        return result;
@@ -2675,6 +2679,84 @@ class XCX121XKIPOIDetector : public XCMarketPatternDetector
    // #endregion

    // #region Bar Patterns ...
+    void FillStrategy1Patterns(
+        ENUM_X_BAR_PATTERN &patterns[],
+        ENUM_X_DIRECTION &dirs[],
+        ENUM_X_DIRECTION forDir = X_DIRECTION_NONE,
+        string forSymbol = NULL,
+        ENUM_TIMEFRAMES forPeriod = NULL //
+    )
+    {
+        //
+        XClean(dirs);
+        XClean(patterns);
+
+        //
+        if (!IsXValid(forSymbol))
+        {
+            forSymbol = symbol;
+        }
+        if (!IsXValid(forPeriod))
+        {
+            forPeriod = period;
+        }
+
+        //
+        GetAllBarPatters(patterns, dirs);
+
+        //
+        // Add(X_BAR_PATTERN_FVG, patterns);
+        // Add(forDir, dirs);
+    }
+
+    void RefactorStrategy1OperationalZone(XBoxZone &zone)
+    {
+
+        //
+        if (!zone.IsValid())
+        {
+            return;
+        }
+
+        //
+        // Refine Zone ...
+        RefineZone(zone);
+
+        //
+        // SL Refactoring ...
+
+        //
+        XOHCL toBar;
+        if (zone.ToBar(toBar))
+        {
+            //
+            int to = zone.ToIndex();
+            int from = zone.FromIndex();
+            int length = from - to;
+            double iValue =
+                zone.IsBullish()
+                    ? toBar.FindLowest(length, MODE_LOW)
+                : zone.IsBearish()
+                    ? toBar.FindHighest(length, MODE_HIGH)
+                    : EMPTY_VALUE;
+            if (NotEmptyZero(iValue))
+            {
+                //
+                if (zone.IsBullish())
+                {
+                    zone.lower = MathMin(zone.lower, iValue);
+                }
+
+                //
+                if (zone.IsBearish())
+                {
+                    zone.upper = MathMax(zone.upper, iValue);
+                }
+            }
+        }
+        toBar.Clean();
+    }
+
    /*
     * Check Recently Pattern Zone is Touched or not ...
     *
@@ -2871,6 +2953,182 @@ class XCX121XKIPOIDetector : public XCMarketPatternDetector
        //
        return result;
    }
+
+    /*
+     * Check Recently Pattern Zone is Rejected or not ...
+     *
+     * @param  zone: XBoxZone, Touched Zone ...
+     * @param  patterns: ENUM_X_BAR_PATTERN, Allowed to Check Patterns ...
+     * @param  patternsDir: ENUM_X_DIRECTION, Allowed Directions ...
+     * @param  price: double, a Price to Check Toch or Reject ...
+     * @param  barIndex: int, Bar Index to Start Checking ...
+     * @param  loopback: int, Loopback for Pattern Formations ...
+     * @param  forPeriod: ENUM_TIMEFRAMES, Time Frame to Check Patterns ...
+     * @param  forDir: ENUM_X_DIRECTION, Directions for Pattern's Formation Check ...
+     *
+     * @return ( bool )
+     */
+    bool HasRecentPatternRejected(
+        XBoxZone &zone,
+        ENUM_X_BAR_PATTERN &patterns[],
+        ENUM_X_DIRECTION &patternsDir[],
+        int barIndex = 0,
+        int loopback = 5,
+        ENUM_TIMEFRAMES forPeriod = NULL,
+        ENUM_X_DIRECTION forDir = X_DIRECTION_NONE //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        zone.Clean();
+
+        //
+        // Validate ...
+        result =
+            HasChild(patterns) &&
+            HasChild(patternsDir) &&
+            ArraySize(patterns) == ArraySize(patternsDir);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        // Normalize ...
+        loopback = NormalizeInt(loopback, 2);
+        barIndex = kiParser.NormalizeBarIndex(barIndex);
+        if (IsXValid(forPeriod))
+        {
+            forPeriod = period;
+        }
+
+        //
+        XOHCL bar;
+        result = bar.Init(symbol, forPeriod, barIndex);
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        XOHCL iBar;
+        bool has = false;
+        int iBullishIDX = -1;
+        int iBearishIDX = -1;
+        bool isBullish = false;
+        bool isBearish = false;
+        XBoxZone iBullishZones[];
+        XBoxZone iBearishZones[];
+        XPatternAnalysis iAnalysis;
+        XPatternAnalysisConfig iConfig;
+
+        //
+        // Preparing Pattern Analysis Config ...
+        iConfig.Default();
+
+        //
+        Copy(
+            patterns,
+            iConfig.allowedPatterns //
+        );
+        Copy(
+            patternsDir,
+            iConfig.allowedDirs //
+        );
+
+        //
+        // Looping Back ...
+        for (int i = barIndex; i < barIndex + loopback; i++)
+        {
+            //
+            // Initialize Bar ...
+            has = iBar.Init(symbol, forPeriod, i);
+            if (!has)
+            {
+                continue;
+            }
+
+            //
+            // Analyse Patterns ...
+            has = AnalyseBarPatterns(iBar, iAnalysis, iConfig);
+            if (!has)
+            {
+                //
+                iBar.Clean();
+                continue;
+            }
+
+            //
+            // Bullish ...
+            has = iAnalysis.Count(X_DIRECTION_BULLISH) > 0;
+            if (has)
+            {
+                //
+                iAnalysis.GetPatterns(iBullishZones, X_DIRECTION_BULLISH);
+                isBullish =
+                    HasChild(iBullishZones) &&
+                    HasRejected(iBullishIDX, bar, iBullishZones);
+            }
+
+            //
+            // Bearish ...
+            has = iAnalysis.Count(X_DIRECTION_BEARISH) > 0;
+            if (has)
+            {
+                //
+                iAnalysis.GetPatterns(iBearishZones, X_DIRECTION_BEARISH);
+                isBearish =
+                    HasChild(iBearishZones) &&
+                    HasRejected(iBearishIDX, bar, iBearishZones);
+            }
+
+            //
+            // Summarizing Result ...
+            has =
+                HasDirection(forDir)
+                    ? (isBullish && !isBearish && IsXBullish(forDir)) ||
+                          (isBearish && !isBullish && IsXBearish(forDir))
+                    : (isBullish && !isBearish) || (isBearish && !isBullish);
+            if (has)
+            {
+                //
+                // Fill Zones ...
+                if (isBullish)
+                {
+                    zone = iBullishZones[iBullishIDX];
+                }
+                else
+                {
+                    zone = iBearishZones[iBearishIDX];
+                }
+                break;
+            }
+
+            //
+            // Cleanup Resource ...
+            iBar.Clean();
+            iAnalysis.Clean();
+            XClean(iBullishZones);
+            XClean(iBearishZones);
+        }
+
+        //
+        // Cleanup Resources ...
+        bar.Clean();
+        iBar.Clean();
+        iConfig.Clean();
+        iAnalysis.Clean();
+        XClean(iBullishZones);
+        XClean(iBearishZones);
+
+        //
+        result = zone.IsValid();
+
+        //
+        return result;
+    }
    // #endregion

    //