/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Indicator // ------------------------------------------------- // Name: XCXCAEAPOIDetector ... // Description: Class for XCAEA POI Detector ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://saherelm.ir" #property version "1.00" #property description "SaherElm Class for XCAEA POI Detector" #property strict // // Imports ... #include "../../Classes/x-saherelm.x-bar.analyser.class.mq5" #include "../../Classes/x-saherelm.x-poi.drawer.class.mq5" #include "../Helpers/xcaea.helper.mq5" // // Definitions ... // enum ENUM_XCA_PIVOTS { XCA_NONE, // None XCA_LL, // LowestLow XCA_HH, // HighestHigh XCA_KI, // KI XCA_SWL, // SWL XCA_SWH, // SWH XCA_VALE, // VALE XCA_PEAK, // PEAK XCA_FVG_BULL, // FVGBull XCA_FVG_BEAR, // FVGBear XCA_RSI_COOS, // RSICOOS XCA_RSI_CUOB, // RSICUOB XCA_RSI_PEAK, // RSIPeak XCA_RSI_VALE, // RSIVale XCA_CCI_COOS, // CCICOOS XCA_CCI_CUOB, // CCICUOB XCA_CCI_PEAK, // CCIPeak XCA_CCI_VALE, // CCIVale XCA_KI_BULL, // KIBull XCA_KI_BEAR, // KIBear XCA_TKI_BULL, // TKIBull XCA_TKI_BEAR, // TKIBear XCA_PEAKSWHRES, // PeakSWHRes XCA_VALESWLSUP, // ValeSWLSup XCA_TREND_BULL, // TrendBull XCA_TREND_BEAR, // TrendBear XCA_TKITRND_BULL, // TKITRNDBull XCA_TKITRND_BEAR, // TKITRNDBear }; // bool IsValid(ENUM_XCA_PIVOTS value) { // bool result = false; // result = value != XCA_NONE; // return result; } // string ToString(ENUM_XCA_PIVOTS value) { // string result = NULL; // result = EnumToString(value); // return result; } // struct XCAPivot { // // Props ... datetime to; double value; string symbol; datetime from; double reserve; ENUM_XCA_PIVOTS type; ENUM_TIMEFRAMES period; // double values[]; // // Constructor ... XCAPivot() { Clean(); } // // Tools ... /** * Cleanup ... */ void Clean() { // value = 0; to = NULL; reserve = 0; from = NULL; symbol = NULL; period = NULL; type = XCA_NONE; // Clean(values); // ZeroMemory(this); } /** * Validate ... * * @return ( bool ) */ bool IsValid() { // bool result = false; // result = from < to && value != 0 && IsValid(to) && IsValid(from) && IsValid(type) && IsValid(symbol) && IsValid(period); // return result; } /** * Check a Model is Same as this or not ... * * @param pivot: XCAPivot ... * * @return ( bool ) */ bool IsSameAs(XCAPivot &pivot) { // bool result = false; // result = IsValid() && pivot.IsValid(); if (!result) { return result; } // result = to == pivot.to && from == pivot.from && type == pivot.type && value == pivot.value && symbol == pivot.symbol && period == pivot.period; // return result; } /** * Retrieve To Index ... * * @param forPeriod: ENUM_TIMEFRAMES, Specified Period ... * * @return ( int ) */ int ToIndex( ENUM_TIMEFRAMES forPeriod = NULL // ) { // int result = -1; // if (!IsValid()) { return result; } // if (!IsValid(forPeriod)) { forPeriod = period; } // result = GetBarIndex( symbol, forPeriod, to // ); // return result; } /** * Retrieve From Index ... * * @param forPeriod: ENUM_TIMEFRAMES, Specified Period ... * * @return ( int ) */ int FromIndex( ENUM_TIMEFRAMES forPeriod = NULL // ) { // int result = -1; // if (!IsValid()) { return result; } // if (!IsValid(forPeriod)) { forPeriod = period; } // result = GetBarIndex( symbol, forPeriod, from // ); // return result; } /** * Retrieve Age of Pivot ... * * @param forPeriod: ENUM_TIMEFRAMES, Specified Period ... * * @return ( int ) */ int GetAge( ENUM_TIMEFRAMES forPeriod = NULL // ) { // int result = 0; // if (!IsValid()) { return result; } // if (!IsValid(forPeriod)) { forPeriod = period; } // int toIDX = ToIndex(forPeriod); int fromIDX = FromIndex(forPeriod); // result = fromIDX - toIDX; // return result; } /** * Converts Pivot to Box ... * * @param box: XBoxZone instance reference ... * * @return ( bool ) */ bool AsBox( XBoxZone &box // ) { // bool result = false; // box.Clean(); // result = IsValid(); if (!result) { return result; } // ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; switch (type) { // case XCA_LL: case XCA_SWL: case XCA_VALE: case XCA_KI_BULL: case XCA_FVG_BULL: case XCA_RSI_COOS: case XCA_RSI_VALE: case XCA_CCI_COOS: case XCA_CCI_VALE: case XCA_TKI_BULL: case XCA_TREND_BULL: case XCA_VALESWLSUP: case XCA_TKITRND_BULL: iDir = X_DIRECTION_BULLISH; break; // case XCA_HH: case XCA_SWH: case XCA_PEAK: case XCA_KI_BEAR: case XCA_FVG_BEAR: case XCA_RSI_CUOB: case XCA_RSI_PEAK: case XCA_CCI_CUOB: case XCA_CCI_PEAK: case XCA_TKI_BEAR: case XCA_TREND_BEAR: case XCA_PEAKSWHRES: case XCA_TKITRND_BEAR: iDir = X_DIRECTION_BEARISH; break; } // result = HasDirection(iDir); if (!result) { return result; } // bool isBullish = IsBullish(iDir) && value < reserve; // bool isBearish = IsBearish(iDir) && value > reserve; // result = isBullish || isBearish; if (!result) { return result; } // box.to = to; box.dir = iDir; box.from = from; box.symbol = symbol; box.period = period; // string typeStr = ToString(type); if (type == XCA_KI_BULL || type == XCA_KI_BEAR) { // typeStr = "XCA_KI"; } else if (type == XCA_FVG_BULL || type == XCA_FVG_BEAR) { // typeStr = "XCA_FVG"; } else if (type == XCA_RSI_COOS || type == XCA_RSI_CUOB) { // typeStr = "XCA_RSI"; } else if (type == XCA_CCI_COOS || type == XCA_CCI_CUOB) { // typeStr = "XCA_CCI"; } else if (type == XCA_TKI_BULL || type == XCA_TKI_BEAR) { // typeStr = "XCA_TKI"; } else if (type == XCA_TREND_BULL || type == XCA_TREND_BEAR) { // typeStr = "XCA_TREND"; } else if (type == XCA_TKITRND_BULL || type == XCA_TKITRND_BEAR) { // typeStr = "XCA_TKITRND"; } box.type = typeStr; // box.upper = isBullish ? reserve : value; box.lower = isBullish ? value : reserve; // result = box.IsValid(); if (!result) { box.Clean(); } // return result; } // }; // struct XCAPVFVG { // double value; XBoxZone fvgs[]; ENUM_X_DIRECTION dir; // XCAPVFVG() { Clean(); } // // Tools ... // void Clean() { // value = 0; Clean(fvgs); dir = X_DIRECTION_NONE; } // bool IsValid() { // bool result = false; // result = value > 0 && HasChild(fvgs) && HasDirection(dir); // return result; } // void AddFVG(XBoxZone &fvg) { // bool has = fvg.IsValid() && fvg.dir == dir; if (!has) { return; } // int idx = -1; has = FindBoxIndex( idx, fvg, fvgs // ); if (has) { return; } // AddRef( fvg, fvgs // ); } // bool IsBullish() { return IsValid() && IsBullish(dir); } // bool IsBearish() { return IsValid() && IsBearish(dir); } // bool GetSelectedFVG(XBoxZone &fvg) { // bool result = false; // fvg.Clean(); // result = IsValid(); if (!result) { return result; } // int idx = -1; if (IsBullish()) { idx = GetLowest(fvgs); } else if (IsBearish()) { idx = GetHighest(fvgs); } result = IsValidIndex(idx); if (!result) { return result; } // fvg = fvgs[idx]; // result = fvg.IsValid(); // return result; } // }; // // Implementations ... class XCXCAEAPOIDetector : public XCBase { // // Public ... public: // // Props ... // // Pivot Verifications and Max Allowed Holding Items ... int maxAllowedPivots; // Max Allowed Holding Pibots ... int pivotVerifications; // Pivots Verifications ... int pivotDetectionLoopbac; // Pivots Detection Loopback ... double ticksDividerInPoints; // Ticks and Volume Detection Divider in Point ... ENUM_TIMEFRAMES ticksDetectionPerid; // Ticks and Volume Detection Loopback ... // // TREND ... XBoxZone trendPivotP; // Prev Pivot of Market Trend ... XBoxZone trendPivotC; // Current Pivot of Market Trend ... ENUM_X_DIRECTION trendDir; // Trend Direction ... // // TICK Pivots ... // bool detectTickPivots; XBoxZone tickPivots[]; // // VOLUME Pivots ... // bool detectVolumePivots; XBoxZone volumePivots[]; // // RSI Peak Pivot ... // XCAPivot rsiPeakPivot; bool detectRSIPeakPivots; XBoxZone rsiPeakPivots[]; bool newRSIPeakPivotDetected; // // RSI Vale Pivot ... // XCAPivot rsiValePivot; bool detectRSIValePivots; XBoxZone rsiValePivots[]; bool newRSIValePivotDetected; // // CCI Peak Pivot ... // XCAPivot cciPeakPivot; bool detectCCIPeakPivots; XBoxZone cciPeakPivots[]; bool newCCIPeakPivotDetected; // // CCI Vale Pivot ... // XCAPivot cciValePivot; bool detectCCIValePivots; XBoxZone cciValePivots[]; bool newCCIValePivotDetected; // // FVG Bullish Pivots ... // bool detectFVGBullishPivots; XBoxZone fvgBullishPivots[]; bool newFVGBullishPivotDetected; // // FVG Bearish Pivots ... // bool detectFVGBearishPivots; XBoxZone fvgBearishPivots[]; bool newFVGBearishPivotDetected; // // VALE Pivot Support Swing Low ... // XCAPivot valeSupSWLPivot; bool detectValeSupSWLPivots; XBoxZone valeSupSWLPivots[]; bool newValeSupSWLPivotDetected; // // PEAK Pivot Resistance Swing High ... // XCAPivot peakResSWHPivot; bool detectPeakResSWHPivots; XBoxZone peakResSWHPivots[]; bool newPeakResSWHPivotDetected; // // XPVFVG Bullish ... // bool detectPVFVGBullishPivots; XCAPVFVG pvFVGBullishPivots[]; bool newPVFVGBullishPivotDetected; // // XPVFVG Bearish ... // bool detectPVFVGBearishPivots; XCAPVFVG pvFVGBearishPivots[]; bool newPVFVGBearishPivotDetected; // // Constructors ... XCXCAEAPOIDetector( XCXCAEAHelper *_helper // ) { // helper = _helper; drawer = new XCPOIDrawer(); barAnalyser = new XCBarAnalyser(); // Default(); } // // De Constructors ... ~XCXCAEAPOIDetector() { // rsiPeakPivot.Clean(); rsiValePivot.Clean(); cciPeakPivot.Clean(); cciValePivot.Clean(); valeSupSWLPivot.Clean(); peakResSWHPivot.Clean(); // trendPivotP.Clean(); trendPivotC.Clean(); trendDir = X_DIRECTION_NONE; // CleanPivots(); // ZeroMemory(helper); ZeroMemory(drawer); ZeroMemory(barAnalyser); } // // Properties ... // // Tools ... // virtual void Default() { // maxAllowedPivots = 50; pivotVerifications = 5; ticksDividerInPoints = 15; pivotDetectionLoopbac = 100; ticksDetectionPerid = PERIOD_D1; // detectTickPivots = true; detectVolumePivots = true; detectRSIPeakPivots = true; detectRSIValePivots = true; detectCCIPeakPivots = true; detectCCIValePivots = true; detectFVGBullishPivots = true; detectFVGBearishPivots = true; detectValeSupSWLPivots = true; detectPeakResSWHPivots = true; detectPVFVGBullishPivots = true; detectPVFVGBearishPivots = true; // trendDir = X_DIRECTION_NONE; } // void Update( int barIndex = 0 // ) { // if (barIndex < 0) { barIndex = 0; } // int loopback = pivotDetectionLoopbac; loopback = NormalizeInt(loopback, 50); // int idx = -1; int count = 0; bool has = false; // newRSIPeakPivotDetected = false; newRSIValePivotDetected = false; newCCIPeakPivotDetected = false; newCCIValePivotDetected = false; newFVGBullishPivotDetected = false; newFVGBearishPivotDetected = false; newValeSupSWLPivotDetected = false; newPeakResSWHPivotDetected = false; newPVFVGBullishPivotDetected = false; newPVFVGBearishPivotDetected = false; // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int p2IDX = pIDX + 1; int p3IDX = p2IDX + 1; // int index = barIndex; int start = index; int end = index + loopback; while (start < end) { // // Retrieve Conditions ... XCAEAConditions conditions; has = helper.GetConditions( conditions, start, 5 // ); // // Retrieve Bars ... XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL p2Bar; has = zBar.Init( conditions.symbol, conditions.period, start // ); has = has && zBar.GetPreviousBar(cBar); has = has && cBar.GetPreviousBar(pBar); has = has && pBar.GetPreviousBar(p2Bar); if (!has) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); p2Bar.Clean(); conditions.Clean(); // continue; } // // Bars Conditions ... // // Bars Conditions ... // ENUM_X_DIRECTION cBarDir; // // Hammer ... bool isCBarHammer = helper .barAnalyser .IsHammer( cBar, cBarDir // ); bool isCBarBullishHammer = isCBarHammer && IsBullish(cBarDir); bool isCBarBearishHammer = isCBarHammer && IsBearish(cBarDir); // // Rejected ... bool isCBarRejected = helper .barAnalyser .IsRejected( cBar, cBarDir, false, // Force Type ... true // Force Fibo Pressure ... ); bool isCBarBullishRejected = isCBarRejected && IsBullish(cBarDir); bool isCBarBearishRejected = isCBarRejected && IsBearish(cBarDir); // // Engulfed ... bool isCBarEngulfed = helper .barAnalyser .IsEngulfed( cBar, cBarDir // ); bool isCBarBullishEngulfed = isCBarEngulfed && IsBullish(cBarDir); bool isCBarBearishEngulfed = isCBarEngulfed && IsBearish(cBarDir); // // Momentum ... bool isCBarMomentum = helper .barAnalyser .IsMomentum( cBar, cBarDir, 1 // ); bool isCBarBullishMomentum = isCBarMomentum && IsBullish(cBarDir); bool isCBarBearishMomentum = isCBarMomentum && IsBearish(cBarDir); // // FVG ... // XBoxZone fvgBox; bool isFVG = barAnalyser.IsFVG( cBar, fvgBox // ); bool isBullishFVG = isFVG && fvgBox.IsBullish(); bool isBearishFVG = isFVG && fvgBox.IsBearish(); // bool isCBarHasBullishPower = isBullishFVG || isCBarBullishRejected || isCBarBullishEngulfed || isCBarBullishMomentum; // bool isCBarHasBearishPower = isBearishFVG || isCBarBearishRejected || isCBarBearishEngulfed || isCBarBearishMomentum; // // Reading Values from Conditions and // Create Customized Conditions if required ... // // PEAK ... double zPeak = conditions.peakBuffer[zIDX]; double cPeak = conditions.peakBuffer[cIDX]; double pPeak = conditions.peakBuffer[pIDX]; double p2Peak = conditions.peakBuffer[p2IDX]; // // VALE ... double zVale = conditions.valeBuffer[zIDX]; double cVale = conditions.valeBuffer[cIDX]; double pVale = conditions.valeBuffer[pIDX]; double p2Vale = conditions.valeBuffer[p2IDX]; // // RSI ... // double zRSI = conditions.rsiBuffer[zIDX]; double cRSI = conditions.rsiBuffer[cIDX]; double pRSI = conditions.rsiBuffer[pIDX]; double p2RSI = conditions.rsiBuffer[p2IDX]; // bool isRSIPeak = pRSI > cRSI && pRSI > p2RSI && pRSI > zRSI; // bool isRSIVale = pRSI < cRSI && pRSI < p2RSI && pRSI < zRSI; // // CCI ... // double zCCI = conditions.cciBuffer[zIDX]; double cCCI = conditions.cciBuffer[cIDX]; double pCCI = conditions.cciBuffer[pIDX]; double p2CCI = conditions.cciBuffer[p2IDX]; // bool isCCIPeak = pCCI > cCCI && pCCI > p2CCI && pCCI > zCCI; // bool isCCIVale = pCCI < cCCI && pCCI < p2CCI && pCCI < zCCI; // // Checking Pivots ... // // Detect TICK and VOLUME Pivots ... if (detectTickPivots || detectVolumePivots) { // XOHCL ticksToBar; XOHCL ticksFromBar; XCTicksZone *ticksZone = NULL; // datetime ticksTo = GetPeriodStartTime( zBar.symbol, ticksDetectionPerid, zBar.time // ); bool isTicksBarInited = ticksToBar.Init( zBar.symbol, zBar.period, ticksTo // ); datetime ticksFrom = ticksTo - PeriodSeconds(ticksDetectionPerid); isTicksBarInited = isTicksBarInited && ticksFromBar.Init( zBar.symbol, zBar.period, ticksFrom // ); bool hasValidTicksTimeRange = IsValid(ticksTo) && isTicksBarInited && IsValid(ticksFrom) && ticksFrom < ticksTo; // bool isTickPivotExists = hasValidTicksTimeRange && IsExistsTickPivot( ticksTo, ticksFrom // ); // bool isVolumePivotExists = hasValidTicksTimeRange && IsExistsVolumePivot( ticksTo, ticksFrom // ); // bool isInitializedZone = !isTickPivotExists || !isVolumePivotExists; if (isInitializedZone) { // isInitializedZone = InitializeTicksZone( ticksZone, ticksToBar, ticksFromBar // ); } // // TICK Pivots ... if (detectTickPivots) { // // Check Current Zone Exists or Not ... if (isInitializedZone && !isTickPivotExists) { // XBoxZone iBox; XCTickZone *iZone; has = ticksZone.GetMaxTickZone(iZone); if (has) { // // Try to Converts a Tick Zone to XBoxZone ... iBox.to = ticksTo; iBox.from = ticksFrom; iBox.lower = iZone.low; iBox.upper = iZone.high; iBox.symbol = iZone.symbol; iBox.period = iZone.period; iBox.type = "XCA_MAX_TICK"; iBox.dir = X_DIRECTION_BULLISH; // Temparory ... // has = iBox.IsValid(); if (has) { // AddBox( iBox, tickPivots // ); } } // iBox.Clean(); ZeroMemory(iZone); } } // // VOLUME Pivots ... if (detectVolumePivots) { // // Check Current Zone Exists or Not ... if (isInitializedZone && !isVolumePivotExists) { // XBoxZone iBox; XCTickZone *iZone; has = ticksZone.GetMaxVolumeZone(iZone); if (has) { // // Try to Converts a Tick Zone to XBoxZone ... iBox.to = ticksTo; iBox.from = ticksFrom; iBox.lower = iZone.low; iBox.upper = iZone.high; iBox.symbol = iZone.symbol; iBox.period = iZone.period; iBox.type = "XCA_MAX_VOLUME"; iBox.dir = X_DIRECTION_BULLISH; // Temparory ... // has = iBox.IsValid(); if (has) { // AddBox( iBox, volumePivots // ); } } // iBox.Clean(); ZeroMemory(iZone); } } // ticksToBar.Clean(); ticksFromBar.Clean(); ZeroMemory(ticksZone); // } // // RSI Peak Pivot ... if (detectRSIPeakPivots) { // bool checkingCondition = isRSIPeak && isCBarHasBearishPower // && // conditions.isRSICrossedUnderOB ; // if (checkingCondition) { // XCAPivot iPivot; // iPivot.to = cBar.time; iPivot.from = p2Bar.time; iPivot.value = pBar.high; iPivot.type = XCA_RSI_PEAK; iPivot.symbol = cBar.symbol; iPivot.period = cBar.period; // Add( cBar.high, iPivot.values // ); Add( pBar.high, iPivot.values // ); Add( p2Bar.high, iPivot.values // ); Add( cBar.close, iPivot.values // ); Add( pBar.close, iPivot.values // ); Add( p2Bar.close, iPivot.values // ); // iPivot.reserve = GetMin(iPivot.values); // XBoxZone iBox; has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newRSIPeakPivotDetected = AddBox( iBox, rsiPeakPivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // RSI Vale Pivot ... if (detectRSIValePivots) { // bool checkingCondition = isRSIVale && isCBarHasBullishPower // && // conditions.isRSICrossedOverOS ; // if (checkingCondition) { // XCAPivot iPivot; // iPivot.to = cBar.time; iPivot.from = p2Bar.time; iPivot.value = pBar.low; iPivot.type = XCA_RSI_VALE; iPivot.symbol = cBar.symbol; iPivot.period = cBar.period; // Add( cBar.low, iPivot.values // ); Add( pBar.low, iPivot.values // ); Add( p2Bar.low, iPivot.values // ); Add( cBar.close, iPivot.values // ); Add( pBar.close, iPivot.values // ); Add( p2Bar.close, iPivot.values // ); // iPivot.reserve = GetMax(iPivot.values); // XBoxZone iBox; has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newRSIValePivotDetected = AddBox( iBox, rsiValePivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // CCI Peak Pivot ... if (detectCCIPeakPivots) { // bool checkingCondition = isCCIPeak && isCBarHasBearishPower // && // conditions.isCCICrossedUnderOB ; // if (checkingCondition) { // XCAPivot iPivot; // iPivot.to = cBar.time; iPivot.from = p2Bar.time; iPivot.value = pBar.high; iPivot.type = XCA_CCI_PEAK; iPivot.symbol = cBar.symbol; iPivot.period = cBar.period; // Add( cBar.high, iPivot.values // ); Add( pBar.high, iPivot.values // ); Add( p2Bar.high, iPivot.values // ); Add( cBar.close, iPivot.values // ); Add( pBar.close, iPivot.values // ); Add( p2Bar.close, iPivot.values // ); // iPivot.reserve = GetMin(iPivot.values); // XBoxZone iBox; has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newCCIPeakPivotDetected = AddBox( iBox, cciPeakPivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // CCI Vale Pivot ... if (detectCCIValePivots) { // bool checkingCondition = isCCIVale && isCBarHasBullishPower // && // conditions.isCCICrossedOverOS ; // if (checkingCondition) { // XCAPivot iPivot; // iPivot.to = cBar.time; iPivot.from = p2Bar.time; iPivot.value = pBar.low; iPivot.type = XCA_CCI_VALE; iPivot.symbol = cBar.symbol; iPivot.period = cBar.period; // Add( cBar.low, iPivot.values // ); Add( pBar.low, iPivot.values // ); Add( p2Bar.low, iPivot.values // ); Add( cBar.close, iPivot.values // ); Add( pBar.close, iPivot.values // ); Add( p2Bar.close, iPivot.values // ); // iPivot.reserve = GetMax(iPivot.values); // XBoxZone iBox; has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newCCIValePivotDetected = AddBox( iBox, cciValePivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // FVG Bullish ... if (detectFVGBullishPivots) { // if (isBullishFVG) { // XBoxZone iBox; XCAPivot iPivot; // iPivot.to = fvgBox.to; iPivot.from = fvgBox.from; iPivot.type = XCA_FVG_BULL; iPivot.value = fvgBox.lower; iPivot.reserve = fvgBox.upper; iPivot.symbol = fvgBox.symbol; iPivot.period = fvgBox.period; // has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newFVGBullishPivotDetected = AddBox( iBox, fvgBullishPivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // FVG Bearish ... if (detectFVGBearishPivots) { // if (isBearishFVG) { // XBoxZone iBox; XCAPivot iPivot; // iPivot.to = fvgBox.to; iPivot.from = fvgBox.from; iPivot.type = XCA_FVG_BEAR; iPivot.value = fvgBox.upper; iPivot.reserve = fvgBox.lower; iPivot.symbol = fvgBox.symbol; iPivot.period = fvgBox.period; // has = iPivot.IsValid(); if (has) { // has = iPivot.AsBox(iBox); if (has) { // newFVGBearishPivotDetected = AddBox( iBox, fvgBearishPivots // ); } } // iBox.Clean(); iPivot.Clean(); } } // // VALE Pivot Support Swing Low ... if (detectValeSupSWLPivots) { // if (conditions.isValeFinishedFromPivot) { // valeSupSWLPivot.Clean(); // valeSupSWLPivot.type = XCA_VALESWLSUP; valeSupSWLPivot.symbol = conditions.symbol; valeSupSWLPivot.period = conditions.period; // valeSupSWLPivot.to = pBar.time; valeSupSWLPivot.from = pBar.time; valeSupSWLPivot.value = conditions.valeBuffer[pIDX]; valeSupSWLPivot.reserve = conditions.valeGoldenBuffer[pIDX]; } // if (conditions.isValeIsPivot) { // valeSupSWLPivot.from = pBar.time; // valeSupSWLPivot.reserve = valeSupSWLPivot.reserve == 0 ? conditions.valeGoldenBuffer[cIDX] : MathMin(valeSupSWLPivot.reserve, conditions.valeGoldenBuffer[cIDX]); } // if (conditions.isValeSwitchedToPivot) { // has = valeSupSWLPivot.IsValid() && valeSupSWLPivot.GetAge() >= pivotVerifications; if (has) { // XBoxZone iBox; has = valeSupSWLPivot.AsBox(iBox); if (has) { // newValeSupSWLPivotDetected = AddBox( iBox, valeSupSWLPivots // ); } // iBox.Clean(); } // valeSupSWLPivot.Clean(); } } // // PEAK Pivot Resistance Swing High ... if (detectPeakResSWHPivots) { // if (conditions.isPeakFinishedFromPivot) { // peakResSWHPivot.Clean(); // peakResSWHPivot.type = XCA_PEAKSWHRES; peakResSWHPivot.symbol = conditions.symbol; peakResSWHPivot.period = conditions.period; // peakResSWHPivot.to = pBar.time; peakResSWHPivot.from = pBar.time; peakResSWHPivot.value = conditions.peakBuffer[pIDX]; peakResSWHPivot.reserve = conditions.peakGoldenBuffer[pIDX]; } // if (conditions.isPeakIsPivot) { // peakResSWHPivot.from = pBar.time; // peakResSWHPivot.reserve = peakResSWHPivot.reserve == 0 ? conditions.peakGoldenBuffer[cIDX] : MathMax(peakResSWHPivot.reserve, conditions.peakGoldenBuffer[cIDX]); } // if (conditions.isPeakSwitchedToPivot) { // has = peakResSWHPivot.IsValid() && peakResSWHPivot.GetAge() >= pivotVerifications; if (has) { // XBoxZone iBox; has = peakResSWHPivot.AsBox(iBox); if (has) { // newPeakResSWHPivotDetected = AddBox( iBox, peakResSWHPivots // ); } // iBox.Clean(); } // peakResSWHPivot.Clean(); } } // // PVFVG Bullish ... if (detectPVFVGBullishPivots) { // if (conditions.isValeIsPivot && isBullishFVG) { // idx = -1; has = HasPVFVGBullishPivots(); if (has) { // count = CountPVFVGBullishPivots(); for (int i = 0; i < count; i++) { // XCAPVFVG iPVFVG = pvFVGBullishPivots[i]; // if (iPVFVG.value == cVale && iPVFVG.IsBullish()) { // idx = i; iPVFVG.Clean(); // break; } // iPVFVG.Clean(); } } // has = IsValidIndex(idx); if (has) { // // Add FVG to Exists PVFVG ... // XBoxZone iFVG = fvgBox; iFVG.type = "XCA_FVG"; // pvFVGBullishPivots[idx].AddFVG(iFVG); } else { // // Add New PVFVG ... // newPVFVGBullishPivotDetected = true; // XCAPVFVG iPVFVG; XBoxZone iFVG = fvgBox; iFVG.type = "XCA_FVG"; // iPVFVG.value = cVale; iPVFVG.dir = X_DIRECTION_BULLISH; // iPVFVG.AddFVG(iFVG); // has = iPVFVG.IsValid(); if (has) { // AddRef( iPVFVG, pvFVGBullishPivots // ); } // iFVG.Clean(); iPVFVG.Clean(); } } } // // PVFVG Bearish ... if (detectPVFVGBearishPivots) { // if (conditions.isPeakIsPivot && isBearishFVG) { // idx = -1; has = HasPVFVGBearishPivots(); if (has) { // count = CountPVFVGBearishPivots(); for (int i = 0; i < count; i++) { // XCAPVFVG iPVFVG = pvFVGBearishPivots[i]; // if (iPVFVG.value == cPeak && iPVFVG.IsBearish()) { // idx = i; iPVFVG.Clean(); // break; } // iPVFVG.Clean(); } } // has = IsValidIndex(idx); if (has) { // // Add FVG to Exists PVFVG ... // XBoxZone iFVG = fvgBox; iFVG.type = "XCA_FVG"; // pvFVGBearishPivots[idx].AddFVG(iFVG); } else { // // Add New PVFVG ... // newPVFVGBearishPivotDetected = true; // XCAPVFVG iPVFVG; XBoxZone iFVG = fvgBox; iFVG.type = "XCA_FVG"; // iPVFVG.value = cPeak; iPVFVG.dir = X_DIRECTION_BEARISH; // iPVFVG.AddFVG(iFVG); // has = iPVFVG.IsValid(); if (has) { // AddRef( iPVFVG, pvFVGBearishPivots // ); } // iFVG.Clean(); iPVFVG.Clean(); } } } // start++; // zBar.Clean(); cBar.Clean(); pBar.Clean(); p2Bar.Clean(); fvgBox.Clean(); conditions.Clean(); } // // Detect Market Trend ... DetectMarketTrend(); } // void Validate( XBoxZone &unAvailableBoxes[], int barIndex = 0 // ) { // // Do All Pivots Validation ... // if (barIndex < 0) { barIndex = 0; } // XBoxZone tmp[]; bool has = false; // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int p2IDX = pIDX + 1; // // Implement Validation Senarios ... // // TICK Pivots ... // // TODO: Complete this ... has = HasTickPivots(); if (has) { // } // // VOLUME Pivots ... // // TODO: Complete this ... has = HasVolumePivots(); if (has) { // } // // RSI Peak Pivot ... // has = HasRSIPeakPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( rsiPeakPivots, tmp // ); Clean(rsiPeakPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, rsiPeakPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // RSI Vale Pivot ... // has = HasRSIValePivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( rsiValePivots, tmp // ); Clean(rsiValePivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, rsiValePivots // ); } // iBox.Clean(); } // Clean(tmp); } // // CCI Peak Pivot ... // has = HasCCIPeakPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( cciPeakPivots, tmp // ); Clean(cciPeakPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, cciPeakPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // CCI Vale Pivot ... // has = HasCCIValePivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( cciValePivots, tmp // ); Clean(cciValePivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, cciValePivots // ); } // iBox.Clean(); } // Clean(tmp); } // // FVG Bullish ... // has = HasFVGBullishPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( fvgBullishPivots, tmp // ); Clean(fvgBullishPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, fvgBullishPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // FVG Bearish ... // has = HasFVGBearishPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( fvgBearishPivots, tmp // ); Clean(fvgBearishPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, fvgBearishPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // VALE Pivot Support Swing Low ... // has = HasValeSupSWLPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( valeSupSWLPivots, tmp // ); Clean(valeSupSWLPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, valeSupSWLPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // PEAK Pivot Resistance Swing High ... // has = HasPeakResSWHPivots(); if (has) { // // Copy Items and Cleanup Collection ... Copy( peakResSWHPivots, tmp // ); Clean(peakResSWHPivots); // // Do Validation ... while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, peakResSWHPivots // ); } // iBox.Clean(); } // Clean(tmp); } // // PVFVG Bullish ... // has = HasPVFVGBullishPivots(); if (has) { // XCAPVFVG tmpPVFVG[]; // // Copy Items and Cleanup Collection ... Copy( pvFVGBullishPivots, tmpPVFVG // ); Clean(pvFVGBullishPivots); // // Do Validation ... while (HasChild(tmpPVFVG)) { // XCAPVFVG iPVFVG = tmpPVFVG[0]; ArrayRemove( tmpPVFVG, 0, 1 // ); Copy( iPVFVG.fvgs, tmp // ); Clean(iPVFVG.fvgs); while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, iPVFVG.fvgs // ); } // iBox.Clean(); } // if (iPVFVG.IsValid()) { // AddRef( iPVFVG, pvFVGBullishPivots // ); } } // Clean(tmp); Clean(tmpPVFVG); } // // PVFVG Bearish ... // has = HasPVFVGBearishPivots(); if (has) { // XCAPVFVG tmpPVFVG[]; // // Copy Items and Cleanup Collection ... Copy( pvFVGBearishPivots, tmpPVFVG // ); Clean(pvFVGBearishPivots); // // Do Validation ... while (HasChild(tmpPVFVG)) { // XCAPVFVG iPVFVG = tmpPVFVG[0]; ArrayRemove( tmpPVFVG, 0, 1 // ); Copy( iPVFVG.fvgs, tmp // ); Clean(iPVFVG.fvgs); while (HasChild(tmp)) { // XBoxZone iBox = tmp[0]; ArrayRemove( tmp, 0, 1 // ); // has = ValidateBox( iBox, unAvailableBoxes, barIndex // ); if (has) { // AddRef( iBox, iPVFVG.fvgs // ); } // iBox.Clean(); } // if (iPVFVG.IsValid()) { // AddRef( iPVFVG, pvFVGBearishPivots // ); } } // Clean(tmp); Clean(tmpPVFVG); } // Clean(tmp); // ReversePivots(); // // Detect Market Trend ... DetectMarketTrend(); } // int FillPivots( XBoxZone &pivots[], ENUM_X_DIRECTION forDir = X_DIRECTION_ALL // ) { // int result = 0; // Clean(pivots); // if (forDir == X_DIRECTION_NONE) { return result; } // int count = 0; bool has = false; // bool canFillBullish = forDir == X_DIRECTION_ALL || forDir == X_DIRECTION_BULLISH; // bool canFillBearish = forDir == X_DIRECTION_ALL || forDir == X_DIRECTION_BEARISH; // // Bullish ... if (canFillBullish) { // Copy( rsiValePivots, pivots, false // ); // Copy( cciValePivots, pivots, false // ); // Copy( fvgBullishPivots, pivots, false // ); // Copy( valeSupSWLPivots, pivots, false // ); // has = HasPVFVGBullishPivots(); if (has) { // count = CountPVFVGBullishPivots(); for (int i = 0; i < count; i++) { // XBoxZone iBox; has = pvFVGBullishPivots[i].GetSelectedFVG(iBox); if (has) { // AddRef( iBox, pivots // ); } // iBox.Clean(); } } } // // Bearish ... if (canFillBearish) { // Copy( rsiPeakPivots, pivots, false // ); // Copy( cciPeakPivots, pivots, false // ); // Copy( fvgBearishPivots, pivots, false // ); // Copy( peakResSWHPivots, pivots, false // ); // has = HasPVFVGBearishPivots(); if (has) { // count = CountPVFVGBearishPivots(); for (int i = 0; i < count; i++) { // XBoxZone iBox; has = pvFVGBearishPivots[i].GetSelectedFVG(iBox); if (has) { // AddRef( iBox, pivots // ); } // iBox.Clean(); } } } // result = ArraySize(pivots); // return result; } // bool MarketTrend(ENUM_X_DIRECTION &trend) { // bool result = false; // // Update Market Trend ... DetectMarketTrend(); // trend = trendDir; result = HasDirection(trend); // return result; } // // Counters ... // // TICK Pivot ... // bool HasTickPivots() { return HasChild(tickPivots); } // int CountTickPivots() { return ArraySize(tickPivots); } // // VOLUME Pivots ... // bool HasVolumePivots() { return HasChild(volumePivots); } // int CountVolumePivots() { return ArraySize(volumePivots); } // // RSI Peak Pivot ... // bool HasRSIPeakPivots() { return HasChild(rsiPeakPivots); } // int CountRSIPeakPivots() { return ArraySize(rsiPeakPivots); } // // RSI Vale Pivot ... // bool HasRSIValePivots() { return HasChild(rsiValePivots); } // int CountRSIValePivots() { return ArraySize(rsiValePivots); } // // CCI Peak Pivot ... // bool HasCCIPeakPivots() { return HasChild(cciPeakPivots); } // int CountCCIPeakPivots() { return ArraySize(cciPeakPivots); } // // CCI Vale Pivot ... // bool HasCCIValePivots() { return HasChild(cciValePivots); } // int CountCCIValePivots() { return ArraySize(cciValePivots); } // // FVG Bullish ... // bool HasFVGBullishPivots() { return HasChild(fvgBullishPivots); } // int CountFVGBullishPivots() { return ArraySize(fvgBullishPivots); } // // FVG Bearish ... // bool HasFVGBearishPivots() { return HasChild(fvgBearishPivots); } // int CountFVGBearishPivots() { return ArraySize(fvgBearishPivots); } // // VALE Pivot Support Swing Low ... // bool HasValeSupSWLPivots() { return HasChild(valeSupSWLPivots); } // int CountValeSupSWLPivots() { return ArraySize(valeSupSWLPivots); } // // PEAK Pivot Resistance Swing High ... // bool HasPeakResSWHPivots() { return HasChild(peakResSWHPivots); } // int CountPeakResSWHPivots() { return ArraySize(peakResSWHPivots); } // // PVFVG Bullish ... // bool HasPVFVGBullishPivots() { return HasChild(pvFVGBullishPivots); } // int CountPVFVGBullishPivots() { return ArraySize(pvFVGBullishPivots); } // // PVFVG Bearish ... // bool HasPVFVGBearishPivots() { return HasChild(pvFVGBearishPivots); } // int CountPVFVGBearishPivots() { return ArraySize(pvFVGBearishPivots); } // // Protected ... protected: // // Props ... // // Prrivate ... private: // // Props ... // XCPOIDrawer *drawer; XCXCAEAHelper *helper; XCBarAnalyser *barAnalyser; // bool AddBox( XBoxZone &box, XBoxZone &boxes[], int maxAllowed = 0 // ) { // bool result = false; // if (maxAllowed <= 0) { maxAllowed = maxAllowedPivots; } // result = box.IsValid(); if (!result) { return result; } // int idx = -1; bool isExists = FindBoxIndex( idx, box, boxes // ); result = !isExists; if (!result) { return result; } // int before = ArraySize(boxes); if (IsValidSize(before)) { ArrayReverse(boxes); } // AddRef( box, boxes // ); int after = ArraySize(boxes); // result = after > before; if (result) { // ArrayReverse(boxes); // CleanupArray( boxes, maxAllowed // ); } // return result; } // bool ValidateBox( XBoxZone &box, XBoxZone &unAvailableBoxes[], int barIndex = 0 // ) { // bool result = false; // // Normalize Bar Index ... barIndex = NormalizeInt(barIndex, 0); // // Ceck Input Box is Valid ... result = box.IsValid(); if (!result) { return result; } // // Check Input Box is Available ... bool canCheckUnAvailableBoxes = HasChild(unAvailableBoxes); if (canCheckUnAvailableBoxes) { // int idx = -1; bool isUnAvailable = FindBoxIndex( idx, box, unAvailableBoxes // ); result = isUnAvailable; if (!result) { return !result; } } // // Check Input Box is Breaked or not ... // // Check Bar Index must after Box To Index ... int toIDX = box.ToIndex(); int fromIDX = box.FromIndex(); result = toIDX > barIndex && fromIDX > barIndex && fromIDX > toIDX; if (!result) { return result; } // // Detect Box Applied Boundary Price ... // For Checking Break of Box ... bool isBullish = box.IsBullish(); double boundary = isBullish ? box.lower : box.upper; // // for validating Box Break we have to wait At Least 3 Bars Close // out of Box Boundary ... int barsLength = 3; // // Calculate Start Checking Bar Index ... int startCheckBreaktionBarIndex = toIDX - barsLength; bool isBarIndexValid = startCheckBreaktionBarIndex > 0 && barIndex < startCheckBreaktionBarIndex; result = isBarIndexValid; if (!result) { // // Assume Box is Valid if Bar Index not Valid for Checking ... result = true; return result; } // // Try to Check Box Validation if Everything is OK ... XOHCL cBar; XOHCL pBar; XOHCL p2Bar; bool isValid = false; bool isBreaked = false; for (int i = barIndex; i < startCheckBreaktionBarIndex; i++) { // // Initialize Bars ... isValid = cBar.Init( box.symbol, box.period, i + 1 // ); isValid = result && cBar.GetPreviousBar(pBar); isValid = result && pBar.GetPreviousBar(p2Bar); if (!isValid) { // cBar.Clean(); pBar.Clean(); p2Bar.Clean(); // result = false; // break; } // // Preparing Conditions ... // bool isBullishBreaked = isBullish && cBar.close < boundary && pBar.close < boundary && p2Bar.close < boundary; // bool isBearishBreaked = !isBullish && cBar.close > boundary && pBar.close > boundary && p2Bar.close > boundary; // // Calculate Result ... isBreaked = isBullishBreaked || isBearishBreaked; if (isBreaked) { // cBar.Clean(); pBar.Clean(); p2Bar.Clean(); // result = false; // break; } // cBar.Clean(); pBar.Clean(); p2Bar.Clean(); } // result = isValid && !isBreaked; // // Cleanup Resource ... // cBar.Clean(); pBar.Clean(); p2Bar.Clean(); // return result; } // void CleanPivots() { // Clean(tickPivots); Clean(volumePivots); Clean(rsiPeakPivots); Clean(rsiValePivots); Clean(cciPeakPivots); Clean(cciValePivots); Clean(fvgBullishPivots); Clean(fvgBearishPivots); Clean(valeSupSWLPivots); Clean(peakResSWHPivots); Clean(pvFVGBullishPivots); Clean(pvFVGBearishPivots); } // void ReversePivots() { // ArrayReverse(tickPivots); ArrayReverse(volumePivots); ArrayReverse(rsiPeakPivots); ArrayReverse(rsiValePivots); ArrayReverse(cciPeakPivots); ArrayReverse(cciValePivots); ArrayReverse(fvgBullishPivots); ArrayReverse(fvgBearishPivots); ArrayReverse(valeSupSWLPivots); ArrayReverse(peakResSWHPivots); ArrayReverse(pvFVGBullishPivots); ArrayReverse(pvFVGBearishPivots); } // // bool IsExistsTickPivot( datetime to, datetime from // ) { // bool result = false; // // Validate Args ... result = IsValid(to) && IsValid(from) && to > from; if (!result) { return result; } // result = HasTickPivots(); if (!result) { return result; } // int idx = -1; int count = CountTickPivots(); for (int i = 0; i < count; i++) { // XBoxZone iBox = tickPivots[i]; // result = iBox.to == to && iBox.from == from; if (result) { // idx = i; iBox.Clean(); // break; } // iBox.Clean(); } // result = IsValidIndex(idx); // return result; } // bool IsExistsVolumePivot( datetime to, datetime from // ) { // bool result = false; // // Validate Args ... result = IsValid(to) && IsValid(from) && to > from; if (!result) { return result; } // result = HasVolumePivots(); if (!result) { return result; } // int idx = -1; int count = CountVolumePivots(); for (int i = 0; i < count; i++) { // XBoxZone iBox = volumePivots[i]; // result = iBox.to == to && iBox.from == from; if (result) { // idx = i; iBox.Clean(); // break; } // iBox.Clean(); } // result = IsValidIndex(idx); // return result; } // bool InitializeTicksZone( XCTicksZone *&zone, XOHCL &toBar, XOHCL &fromBar // ) { // bool result = false; // result = zone == NULL; if (!result) { return result; } // int toIDX = toBar.Index(); int fromIDX = fromBar.Index(); int rangeLength = fromIDX - toIDX; double rangeDivider = ticksDividerInPoints * GetPoints(toBar.symbol); double rangeL = toBar.FindLowest(rangeLength, MODE_LOW); double rangeH = toBar.FindHighest(rangeLength, MODE_HIGH); double rangeDiff = (rangeH - rangeL); int zoneLevels = (int)(rangeDiff / rangeDivider); // zone = new XCTicksZone(); zone.Levels(zoneLevels); // result = zone.Init( fromBar, toBar // ); if (!result) { ZeroMemory(zone); } // return result; } // void DetectMarketTrend() { // int idx = -1; int count = 0; bool has = false; // XBoxZone tmp[]; count = FillPivots(tmp); has = HasChild(tmp); if (!has) { return; } // XBoxZone cPivot; XBoxZone pPivot; ENUM_X_DIRECTION dir = X_DIRECTION_NONE; while (HasChild(tmp)) { // XBoxZone iPivot; idx = GetYoungest(tmp); has = IsValidIndex(idx); if (!has) { // iPivot.Clean(); break; } // ArrayRemove( tmp, idx, 1 // ); // // Check Pivot Type is Peak or Vale ... has = Contains( "XCA_PEAKSWHRES", iPivot.type // ) || Contains( "XCA_VALESWLSUP", iPivot.type // ); if (!has) { // iPivot.Clean(); break; } // // Check Can Set CPivot ... bool canSetCPivot = !cPivot.IsValid() ? true : cPivot.from < iPivot.from; if (canSetCPivot) { // if (cPivot.IsValid()) { pPivot = cPivot; } // cPivot = iPivot; } // // Check Can Set PPivot ... bool canSetPPivot = !cPivot.IsValid() ? false : iPivot.from < cPivot.from ? !pPivot.IsValid() ? true : cPivot.from < iPivot.from : false; if (canSetPPivot) { pPivot = iPivot; } // has = cPivot.IsValid() && pPivot.IsValid(); if (has) { // iPivot.Clean(); break; } // iPivot.Clean(); } // // Check Resources for Detecting Conditions ... bool hasTrend = // cPivot.IsValid() && pPivot.IsValid() && cPivot.dir == pPivot.dir && cPivot.from > pPivot.from && (IsBullish(cPivot.dir) ? cPivot.lower > pPivot.lower : cPivot.upper < pPivot.upper); // ; if (hasTrend) { // trendPivotC = cPivot; trendPivotP = pPivot; trendDir = cPivot.dir; } // Clean(tmp); cPivot.Clean(); pPivot.Clean(); // } // }; //