cleanup and refocused workspace for using on XCATBEA Projects ...
This commit is contained in:
@@ -0,0 +1,955 @@
|
||||
|
||||
//
|
||||
// Detect Trigger Block ...
|
||||
bool DetectTriggerBlock(
|
||||
//
|
||||
string symbol,
|
||||
ENUM_TIMEFRAMES period,
|
||||
//
|
||||
XTriggerBlock &tb,
|
||||
//
|
||||
XCBarAnalyser *barAnalyser,
|
||||
//
|
||||
// Required Buffers ...
|
||||
const double &_atrBuffer[],
|
||||
const double &_rsiBuffer[],
|
||||
const double &_adxBuffer[],
|
||||
const double &_adxpBuffer[],
|
||||
const double &_adxnBuffer[],
|
||||
const double &_peakBuffer[],
|
||||
const double &_valeBuffer[],
|
||||
const double &_deltaBuffer[],
|
||||
const double &_sarBuffer[],
|
||||
const double &_sarStateBuffer[],
|
||||
const double &_trendBuffer[],
|
||||
const double &_trendStateBuffer[],
|
||||
const double &_atrUpperBuffer[],
|
||||
const double &_atrLowerBuffer[],
|
||||
const double &_sBarOpenSBuffer[],
|
||||
const double &_sBarCloseBuffer[],
|
||||
const double &_hkSBarOpenBuffer[],
|
||||
const double &_hkSBarCloseBuffer[],
|
||||
const double &_peakGoldenBuffer[],
|
||||
const double &_valeGoldenBuffer[],
|
||||
const double &_deltaSignalBuffer[],
|
||||
const double &_bullishVolumeSignalBuffer[],
|
||||
const double &_bearishVolumeSignalBuffer[],
|
||||
//
|
||||
int barIndex,
|
||||
//
|
||||
int _r2r,
|
||||
double _slAtrMultiplier,
|
||||
//
|
||||
// Configs ...
|
||||
double _rsiOBLevel,
|
||||
double _rsiOSLevel,
|
||||
double _adxThreshold,
|
||||
//
|
||||
// Validators ...
|
||||
//
|
||||
bool _forceOBBarType = false,
|
||||
bool _forceFVGBarType = false,
|
||||
bool _forceHasSwing = false,
|
||||
bool _forceHasFLiquidity = false,
|
||||
bool _forceHasRLiquidity = false,
|
||||
bool _validateGapSequence = false,
|
||||
bool _validateBlockEdgeBreakout = false,
|
||||
//
|
||||
// Filters ...
|
||||
bool _filterBasedOnPV = false,
|
||||
bool _filterBasedOnSar = false,
|
||||
bool _filterBasedOnRSI = false,
|
||||
bool _filterBasedOnADX = false,
|
||||
bool _filterBasedOnATR = false,
|
||||
bool _filterBasedOnTrend = false,
|
||||
bool _filterBasedOnDelta = false,
|
||||
bool _filterBasedOnVolume = false,
|
||||
bool _filterBasedOnSignalBar = false,
|
||||
bool _filterBasedOnHKSignalBar = false //
|
||||
)
|
||||
{
|
||||
//
|
||||
bool result = false;
|
||||
|
||||
//
|
||||
// Custom Configs ...
|
||||
|
||||
// //
|
||||
// _r2r = 2;
|
||||
// _slAtrMultiplier = 1;
|
||||
|
||||
// //
|
||||
// // Validators ...
|
||||
// _forceHasSwing = true;
|
||||
// _forceOBBarType = true;
|
||||
// _forceFVGBarType = true;
|
||||
// _validateGapSequence = true;
|
||||
|
||||
// //
|
||||
// _forceHasFLiquidity = false;
|
||||
// _forceHasRLiquidity = false;
|
||||
// _validateBlockEdgeBreakout = true;
|
||||
|
||||
// //
|
||||
// // Filters ...
|
||||
// _filterBasedOnPV = true;
|
||||
// _filterBasedOnATR = true;
|
||||
// _filterBasedOnDelta = true;
|
||||
// _filterBasedOnVolume = true;
|
||||
|
||||
// //
|
||||
// _filterBasedOnSar = true;
|
||||
// _filterBasedOnRSI = false;
|
||||
// _filterBasedOnADX = false;
|
||||
// _filterBasedOnTrend = false;
|
||||
// _filterBasedOnSignalBar = true;
|
||||
// _filterBasedOnHKSignalBar = true;
|
||||
|
||||
//
|
||||
tb.Clean();
|
||||
|
||||
//
|
||||
result = barAnalyser != NULL;
|
||||
if (!result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
//
|
||||
int zIDX = 0;
|
||||
bool has = false;
|
||||
bool isDone = false;
|
||||
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
|
||||
|
||||
//
|
||||
// Retrieve Required Bars ...
|
||||
|
||||
//
|
||||
XOHCL iBar;
|
||||
XOHCL zBar; // Current Start Checking Bar (Usually Used for Triggering) ...
|
||||
has = zBar.Init(
|
||||
symbol,
|
||||
period,
|
||||
barIndex //
|
||||
);
|
||||
|
||||
//
|
||||
// Detect Based Order Block ...
|
||||
has =
|
||||
has &&
|
||||
barAnalyser.IsOB(
|
||||
zBar,
|
||||
tb.ob,
|
||||
_forceFVGBarType, // Force FVG Bar Type ...
|
||||
_forceOBBarType // Force Block Two Bar Checking ...
|
||||
);
|
||||
|
||||
//
|
||||
// Detect Based Fair Value Gap ...
|
||||
has =
|
||||
has &&
|
||||
barAnalyser.IsFVG(
|
||||
zBar,
|
||||
tb.fvg,
|
||||
_forceFVGBarType // Force FVG Bar Type ...
|
||||
);
|
||||
|
||||
//
|
||||
// Clone Trigger Block ...
|
||||
if (has)
|
||||
{
|
||||
//
|
||||
tb.trigger = tb.ob;
|
||||
tb.trigger.type = "XTRGB";
|
||||
}
|
||||
|
||||
//
|
||||
bool isBullish =
|
||||
has &&
|
||||
tb.IsBullish();
|
||||
|
||||
//
|
||||
bool isBearish =
|
||||
has &&
|
||||
tb.IsBearish();
|
||||
|
||||
//
|
||||
int toIDX = tb.ToIndex();
|
||||
int fromIDX = tb.FromIndex();
|
||||
|
||||
//
|
||||
// Verifications and Filters ...
|
||||
|
||||
//
|
||||
int loopback = 144;
|
||||
|
||||
//
|
||||
// Forces ...
|
||||
|
||||
//
|
||||
// Force Has Proper Swing ...
|
||||
if (has &&
|
||||
_forceHasSwing)
|
||||
{
|
||||
//
|
||||
XOHCL iPBar;
|
||||
XOHCL iP2Bar;
|
||||
toIDX = tb.ToIndex();
|
||||
fromIDX = tb.FromIndex();
|
||||
for (int i = toIDX; i <= fromIDX; i++)
|
||||
{
|
||||
//
|
||||
// Initialize iBar ...
|
||||
isDone = iBar.Init(
|
||||
zBar.symbol,
|
||||
zBar.period,
|
||||
i //
|
||||
);
|
||||
isDone =
|
||||
isDone &&
|
||||
iBar.GetPreviousBar(iPBar);
|
||||
isDone =
|
||||
isDone &&
|
||||
iPBar.GetPreviousBar(iP2Bar);
|
||||
isDone =
|
||||
isDone &&
|
||||
barAnalyser.IsSimpleSwing(
|
||||
iBar,
|
||||
iDir //
|
||||
) &&
|
||||
iDir == tb.GetDirection();
|
||||
if (isDone)
|
||||
{
|
||||
//
|
||||
bool canSet =
|
||||
!tb.swingBar.IsValid()
|
||||
? true
|
||||
: (isBullish
|
||||
? tb.swingBar.low > iP2Bar.low
|
||||
: tb.swingBar.high < iP2Bar.high);
|
||||
if (canSet)
|
||||
{
|
||||
tb.swingBar = iP2Bar;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
iBar.Clean();
|
||||
iPBar.Clean();
|
||||
iP2Bar.Clean();
|
||||
}
|
||||
|
||||
//
|
||||
has = tb.swingBar.IsValid();
|
||||
}
|
||||
|
||||
//
|
||||
// Force Has Liquidity ...
|
||||
// TODO: Add Validation based on Liquidities
|
||||
// if necessary ...
|
||||
if (has &&
|
||||
(_forceHasFLiquidity ||
|
||||
_forceHasRLiquidity))
|
||||
{
|
||||
//
|
||||
toIDX = tb.ToIndex();
|
||||
fromIDX = tb.FromIndex();
|
||||
for (int i = toIDX; i < fromIDX + loopback; i++)
|
||||
{
|
||||
//
|
||||
// Initialize iBar ...
|
||||
isDone = iBar.Init(
|
||||
zBar.symbol,
|
||||
zBar.period,
|
||||
i //
|
||||
);
|
||||
|
||||
//
|
||||
bool isRejected =
|
||||
isDone &&
|
||||
barAnalyser.IsRejected(
|
||||
iBar,
|
||||
iDir,
|
||||
false, // Force Bar Type ...
|
||||
true // Force Fibo Pressure ...
|
||||
);
|
||||
|
||||
//
|
||||
// Following Liquidity ...
|
||||
bool isFLiq =
|
||||
isDone &&
|
||||
isRejected &&
|
||||
iDir == tb.GetDirection() &&
|
||||
(isBullish
|
||||
? iBar.low < tb.trigger.lower
|
||||
: iBar.high > tb.trigger.upper);
|
||||
if (isFLiq &&
|
||||
_forceHasFLiquidity &&
|
||||
!tb.fLiquidity.IsValid())
|
||||
{
|
||||
//
|
||||
FillLiquidity(
|
||||
iBar,
|
||||
iDir,
|
||||
tb.fLiquidity,
|
||||
tb.trigger.to //
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
// Reversal Liquidity ...
|
||||
bool isRLiq =
|
||||
isDone &&
|
||||
isRejected &&
|
||||
Opposit(iDir) == tb.GetDirection() &&
|
||||
(isBullish
|
||||
? iBar.low > tb.trigger.upper
|
||||
: iBar.high < tb.trigger.lower);
|
||||
if (isRLiq &&
|
||||
_forceHasRLiquidity &&
|
||||
!tb.rLiquidity.IsValid())
|
||||
{
|
||||
//
|
||||
FillLiquidity(
|
||||
iBar,
|
||||
iDir,
|
||||
tb.rLiquidity,
|
||||
tb.trigger.to //
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
// Checking Conditions ...
|
||||
isDone =
|
||||
(!_forceHasFLiquidity
|
||||
? true
|
||||
: tb.fLiquidity.IsValid()) &&
|
||||
(!_forceHasRLiquidity
|
||||
? true
|
||||
: tb.rLiquidity.IsValid());
|
||||
if (isDone)
|
||||
{
|
||||
//
|
||||
iBar.Clean();
|
||||
break;
|
||||
}
|
||||
|
||||
//
|
||||
iBar.Clean();
|
||||
}
|
||||
|
||||
//
|
||||
// Checking Conditions ...
|
||||
has =
|
||||
(!_forceHasFLiquidity
|
||||
? true
|
||||
: tb.fLiquidity.IsValid()) &&
|
||||
(!_forceHasRLiquidity
|
||||
? true
|
||||
: tb.rLiquidity.IsValid());
|
||||
}
|
||||
|
||||
//
|
||||
// Validations ...
|
||||
|
||||
//
|
||||
// Validating Gap Sequence means
|
||||
// Gap Bars must Follow each Other ...
|
||||
if (has &&
|
||||
_validateGapSequence)
|
||||
{
|
||||
//
|
||||
XOHCL iPBar;
|
||||
toIDX = tb.fvg.ToIndex();
|
||||
fromIDX = tb.fvg.FromIndex();
|
||||
|
||||
//
|
||||
for (int i = toIDX; i < fromIDX - 1; i++)
|
||||
{
|
||||
//
|
||||
// Initialize iBar ...
|
||||
has = iBar.Init(
|
||||
zBar.symbol,
|
||||
zBar.period,
|
||||
i //
|
||||
);
|
||||
has =
|
||||
has &&
|
||||
iBar.GetPreviousBar(iPBar);
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? iBar.low > iPBar.low
|
||||
: iBar.high < iPBar.high);
|
||||
if (!has)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
iBar.Clean();
|
||||
iPBar.Clean();
|
||||
}
|
||||
|
||||
//
|
||||
// Validate Block Edge Breakout ...
|
||||
if (has &&
|
||||
_validateBlockEdgeBreakout)
|
||||
{
|
||||
//
|
||||
has = tb.fvg.ToBar(iBar);
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? (iBar.GetDown() < tb.ob.upper &&
|
||||
iBar.GetUp() > tb.ob.upper)
|
||||
: (iBar.GetDown() < tb.ob.lower &&
|
||||
iBar.GetUp() > tb.ob.lower));
|
||||
|
||||
//
|
||||
iBar.Clean();
|
||||
}
|
||||
|
||||
//
|
||||
// Filters ...
|
||||
|
||||
//
|
||||
// PV ...
|
||||
if (has &&
|
||||
_filterBasedOnPV)
|
||||
{
|
||||
//
|
||||
double iPeak = _peakBuffer[barIndex];
|
||||
double iPPeak = _peakBuffer[barIndex + 1];
|
||||
double iP2Peak = _peakBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
double iPeakGolden = _peakGoldenBuffer[barIndex];
|
||||
double iPPeakGolden = _peakGoldenBuffer[barIndex + 1];
|
||||
double iP2PeakGolden = _peakGoldenBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
double iVale = _valeBuffer[barIndex];
|
||||
double iPVale = _valeBuffer[barIndex + 1];
|
||||
double iP2Vale = _valeBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
double iValeGolden = _valeGoldenBuffer[barIndex];
|
||||
double iPValeGolden = _valeGoldenBuffer[barIndex + 1];
|
||||
double iP2ValeGolden = _valeGoldenBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
// TODO: Fix this ...
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? (tb.trigger.lower <= iVale &&
|
||||
tb.trigger.upper < iPeak
|
||||
// || tb.trigger.lower <= iValeGolden
|
||||
)
|
||||
: (tb.trigger.upper >= iPeak &&
|
||||
tb.trigger.lower > iVale
|
||||
// || tb.trigger.upper >= iPeakGolden
|
||||
));
|
||||
}
|
||||
|
||||
//
|
||||
// SAR ...
|
||||
if (has &&
|
||||
_filterBasedOnSar)
|
||||
{
|
||||
//
|
||||
double iSarState = _sarStateBuffer[barIndex];
|
||||
double iPSarState = _sarStateBuffer[barIndex + 1];
|
||||
double iP2SarState = _sarStateBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
bool isSarBullish = iSarState > 0;
|
||||
bool isPSarBullish = iPSarState > 0;
|
||||
bool isP2SarBullish = iP2SarState > 0;
|
||||
|
||||
//
|
||||
bool isSarBearish = iSarState < 0;
|
||||
bool isPSarBearish = iPSarState < 0;
|
||||
bool isP2SarBearish = iP2SarState < 0;
|
||||
|
||||
//
|
||||
bool isSarSwitchedToBullish =
|
||||
isSarBullish &&
|
||||
!isPSarBullish;
|
||||
|
||||
//
|
||||
bool isSarSwitchedToBearish =
|
||||
isSarBearish &&
|
||||
!isPSarBearish;
|
||||
|
||||
//
|
||||
bool isSarPSwitchedToBullish =
|
||||
isPSarBullish &&
|
||||
!isP2SarBullish;
|
||||
|
||||
//
|
||||
bool isSarPSwitchedToBearish =
|
||||
isPSarBearish &&
|
||||
!isP2SarBearish;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? (isSarSwitchedToBullish ||
|
||||
isSarPSwitchedToBullish)
|
||||
: (isSarSwitchedToBearish ||
|
||||
isSarPSwitchedToBearish));
|
||||
}
|
||||
|
||||
//
|
||||
// RSI ...
|
||||
if (has &&
|
||||
_filterBasedOnRSI)
|
||||
{
|
||||
//
|
||||
double rsiTrend = (_rsiOBLevel + _rsiOSLevel) / 2;
|
||||
|
||||
//
|
||||
double iRSI = _rsiBuffer[barIndex];
|
||||
double iPRSI = _rsiBuffer[barIndex + 1];
|
||||
double iP2RSI = _rsiBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
bool isRSICrossedOverOS =
|
||||
iRSI > _rsiOSLevel &&
|
||||
iPRSI <= _rsiOSLevel;
|
||||
|
||||
//
|
||||
bool isRSICrossedUnderOB =
|
||||
iRSI < _rsiOBLevel &&
|
||||
iPRSI >= _rsiOBLevel;
|
||||
|
||||
//
|
||||
bool isPRSICrossedOverOS =
|
||||
iPRSI > _rsiOSLevel &&
|
||||
iP2RSI <= _rsiOSLevel;
|
||||
|
||||
//
|
||||
bool isPRSICrossedUnderOB =
|
||||
iPRSI < _rsiOBLevel &&
|
||||
iP2RSI >= _rsiOBLevel;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? (isRSICrossedOverOS ||
|
||||
isPRSICrossedOverOS)
|
||||
: (isRSICrossedUnderOB ||
|
||||
isPRSICrossedUnderOB));
|
||||
}
|
||||
|
||||
//
|
||||
// ADX ...
|
||||
if (has &&
|
||||
_filterBasedOnADX)
|
||||
{
|
||||
//
|
||||
// ADX ...
|
||||
double iADX = _adxBuffer[barIndex];
|
||||
double iPADX = _adxBuffer[barIndex + 1];
|
||||
double iP2ADX = _adxBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
// ADX +DI ...
|
||||
double iADXP = _adxpBuffer[barIndex];
|
||||
double iPADXP = _adxpBuffer[barIndex + 1];
|
||||
double iP2ADXP = _adxpBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
// ADX -DI ...
|
||||
double iADXN = _adxnBuffer[barIndex];
|
||||
double iPADXN = _adxnBuffer[barIndex + 1];
|
||||
double iP2ADXN = _adxnBuffer[barIndex + 2];
|
||||
|
||||
//
|
||||
// Preparing Conditions ...
|
||||
|
||||
//
|
||||
bool isADXBullish = iADX > _adxThreshold;
|
||||
bool isADXBearish = iADX < _adxThreshold;
|
||||
|
||||
//
|
||||
bool isPADXBullish = iPADX > _adxThreshold;
|
||||
bool isPADXBearish = iPADX < _adxThreshold;
|
||||
|
||||
//
|
||||
bool isP2ADXBullish = iP2ADX > _adxThreshold;
|
||||
bool isP2ADXBearish = iP2ADX < _adxThreshold;
|
||||
|
||||
//
|
||||
bool isADXSwitchedToBullish =
|
||||
isADXBullish &&
|
||||
!isPADXBullish;
|
||||
|
||||
//
|
||||
bool isADXSwitchedToBearish =
|
||||
isADXBearish &&
|
||||
!isPADXBearish;
|
||||
|
||||
//
|
||||
bool isPADXSwitchedToBullish =
|
||||
isPADXBullish &&
|
||||
!isP2ADXBullish;
|
||||
|
||||
//
|
||||
bool isPADXSwitchedToBearish =
|
||||
isPADXBearish &&
|
||||
!isP2ADXBearish;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? (isADXSwitchedToBullish ||
|
||||
isPADXSwitchedToBullish)
|
||||
: (isADXSwitchedToBearish ||
|
||||
isPADXSwitchedToBearish));
|
||||
}
|
||||
|
||||
//
|
||||
// ATR ...
|
||||
if (has &&
|
||||
_filterBasedOnATR)
|
||||
{
|
||||
//
|
||||
fromIDX = tb.FromIndex();
|
||||
double iATRUpper = _atrUpperBuffer[fromIDX];
|
||||
double iATRLower = _atrLowerBuffer[fromIDX];
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? tb.trigger.lower < iATRLower
|
||||
: tb.trigger.upper > iATRUpper);
|
||||
}
|
||||
|
||||
//
|
||||
// TREND ...
|
||||
if (has &&
|
||||
_filterBasedOnTrend)
|
||||
{
|
||||
//
|
||||
double iTrendState = _trendStateBuffer[barIndex];
|
||||
double iPTrendState = _trendStateBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isTrendBullish = iTrendState > 0;
|
||||
bool isPTrendBullish = iPTrendState > 0;
|
||||
|
||||
//
|
||||
bool isTrendBearish = iTrendState < 0;
|
||||
bool isPTrendBearish = iPTrendState < 0;
|
||||
|
||||
//
|
||||
double trends[];
|
||||
int toIDX = tb.ToIndex();
|
||||
int fromIDX = tb.FromIndex();
|
||||
double iTrend = _trendBuffer[toIDX];
|
||||
for (int i = toIDX; i <= fromIDX; i++)
|
||||
{
|
||||
//
|
||||
Add(
|
||||
_trendBuffer[i],
|
||||
trends //
|
||||
);
|
||||
}
|
||||
double trendsMin = GetMin(trends);
|
||||
double trendsMax = GetMax(trends);
|
||||
double trendsAVG = GetAverage(trends);
|
||||
|
||||
//
|
||||
bool isTrendUp =
|
||||
iTrend > trendsMin &&
|
||||
iTrend >= trendsAVG;
|
||||
|
||||
//
|
||||
bool isTrendDown =
|
||||
iTrend < trendsMax &&
|
||||
iTrend <= trendsAVG;
|
||||
|
||||
//
|
||||
bool isTrendSwitchedToBullish =
|
||||
isTrendUp &&
|
||||
isTrendBullish &&
|
||||
!isPTrendBullish;
|
||||
|
||||
//
|
||||
bool isTrendSwitchedToBearish =
|
||||
isTrendDown &&
|
||||
isTrendBearish &&
|
||||
!isPTrendBearish;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? isTrendSwitchedToBullish
|
||||
: isTrendSwitchedToBearish);
|
||||
}
|
||||
|
||||
//
|
||||
// DELTA ...
|
||||
if (has &&
|
||||
_filterBasedOnDelta)
|
||||
{
|
||||
//
|
||||
double iDelta = _deltaBuffer[barIndex];
|
||||
double iPDelta = _deltaBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isDeltaUp = iDelta > iPDelta;
|
||||
bool isDeltaDown = iDelta < iPDelta;
|
||||
|
||||
//
|
||||
double iDeltaSignal = _deltaSignalBuffer[barIndex];
|
||||
double iPDeltaSignal = _deltaSignalBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isDeltaSignalUp = iDeltaSignal > iPDeltaSignal;
|
||||
bool isDeltaSignalDown = iDeltaSignal < iPDeltaSignal;
|
||||
|
||||
//
|
||||
bool isDeltaSwitchedToBullish =
|
||||
isDeltaUp &&
|
||||
isDeltaSignalUp &&
|
||||
iDelta > iDeltaSignal &&
|
||||
iPDelta < iPDeltaSignal;
|
||||
|
||||
//
|
||||
bool isDeltaSwitchedToBearish =
|
||||
isDeltaDown &&
|
||||
isDeltaSignalDown &&
|
||||
iDelta < iDeltaSignal &&
|
||||
iPDelta > iPDeltaSignal;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? isDeltaSwitchedToBullish
|
||||
: isDeltaSwitchedToBearish);
|
||||
}
|
||||
|
||||
//
|
||||
// VOLUME ...
|
||||
if (has &&
|
||||
_filterBasedOnVolume)
|
||||
{
|
||||
//
|
||||
double iBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex];
|
||||
double iPBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isBullishVolumeSignalUp = iBullishVolumeSignal > iPBullishVolumeSignal;
|
||||
bool isBullishVolumeSignalDown = iBullishVolumeSignal < iPBullishVolumeSignal;
|
||||
|
||||
//
|
||||
double iBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex];
|
||||
double iPBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isBearishVolumeSignalUp = iBearishVolumeSignal > iPBearishVolumeSignal;
|
||||
bool isBearishVolumeSignalDown = iBearishVolumeSignal < iPBearishVolumeSignal;
|
||||
|
||||
//
|
||||
bool isVolumeSwitchdToBullish =
|
||||
isBullishVolumeSignalUp &&
|
||||
!isBearishVolumeSignalUp &&
|
||||
iBullishVolumeSignal > iBearishVolumeSignal &&
|
||||
iPBullishVolumeSignal < iPBearishVolumeSignal;
|
||||
|
||||
//
|
||||
bool isVolumeSwitchdToBearish =
|
||||
isBearishVolumeSignalUp &&
|
||||
!isBullishVolumeSignalUp &&
|
||||
iBearishVolumeSignal > iBullishVolumeSignal &&
|
||||
iPBearishVolumeSignal < iPBullishVolumeSignal;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? isVolumeSwitchdToBullish
|
||||
: isVolumeSwitchdToBearish);
|
||||
}
|
||||
|
||||
//
|
||||
// SIGNAL Bar ...
|
||||
if (has &&
|
||||
_filterBasedOnSignalBar)
|
||||
{
|
||||
//
|
||||
double iSignalOpen = _sBarOpenSBuffer[barIndex];
|
||||
double iPSignalOpen = _sBarOpenSBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
double iSignalClose = _sBarCloseBuffer[barIndex];
|
||||
double iPSignalClose = _sBarCloseBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isSignalBarBullish = iSignalOpen < iSignalClose;
|
||||
bool isPSignalBarBullish = iPSignalOpen < iPSignalClose;
|
||||
|
||||
//
|
||||
bool isSignalBarBearish = iSignalOpen > iSignalClose;
|
||||
bool isPSignalBarBearish = iPSignalOpen > iPSignalClose;
|
||||
|
||||
//
|
||||
bool isSignalBarSwitchedToBullish =
|
||||
isSignalBarBullish &&
|
||||
!isPSignalBarBullish;
|
||||
|
||||
//
|
||||
bool isSignalBarSwitchedToBearish =
|
||||
isSignalBarBearish &&
|
||||
!isPSignalBarBearish;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? isSignalBarSwitchedToBullish
|
||||
: isSignalBarSwitchedToBearish);
|
||||
}
|
||||
|
||||
//
|
||||
// HK SIGNAL Bar ...
|
||||
if (has &&
|
||||
_filterBasedOnHKSignalBar)
|
||||
{
|
||||
//
|
||||
double iHKSignalOpen = _hkSBarOpenBuffer[barIndex];
|
||||
double iPHKSignalOpen = _hkSBarOpenBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
double iHKSignalClose = _hkSBarCloseBuffer[barIndex];
|
||||
double iPHKSignalClose = _hkSBarCloseBuffer[barIndex + 1];
|
||||
|
||||
//
|
||||
bool isHKSignalBarBullish = iHKSignalOpen < iHKSignalClose;
|
||||
bool isPHKSignalBarBullish = iPHKSignalOpen < iPHKSignalClose;
|
||||
|
||||
//
|
||||
bool isHKSignalBarBearish = iHKSignalOpen > iHKSignalClose;
|
||||
bool isPHKSignalBarBearish = iPHKSignalOpen > iPHKSignalClose;
|
||||
|
||||
//
|
||||
bool isHKSignalBarSwitchedToBullish =
|
||||
isHKSignalBarBullish &&
|
||||
!isPHKSignalBarBullish;
|
||||
|
||||
//
|
||||
bool isHKSignalBarSwitchedToBearish =
|
||||
isHKSignalBarBearish &&
|
||||
!isPHKSignalBarBearish;
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? isHKSignalBarSwitchedToBullish
|
||||
: isHKSignalBarSwitchedToBearish);
|
||||
}
|
||||
|
||||
//
|
||||
// Valdating Directional Trending ...
|
||||
bool _filterBasedOnDirection = false;
|
||||
if (has &&
|
||||
_filterBasedOnDirection)
|
||||
{
|
||||
//
|
||||
iBar.Clean();
|
||||
fromIDX = tb.FromIndex();
|
||||
int loopbackForValidating = 30;
|
||||
for (int i = fromIDX; i < fromIDX + loopbackForValidating; i++)
|
||||
{
|
||||
//
|
||||
// Initialize iBar ...
|
||||
iBar.Clean();
|
||||
has = iBar.Init(
|
||||
symbol,
|
||||
period,
|
||||
i //
|
||||
);
|
||||
|
||||
//
|
||||
has =
|
||||
has &&
|
||||
(isBullish
|
||||
? iBar.high < tb.trigger.upper
|
||||
: iBar.low > tb.trigger.lower);
|
||||
if (!has)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Update Trigger Block ...
|
||||
if (has)
|
||||
{
|
||||
tb.trigger.from = iBar.time;
|
||||
}
|
||||
|
||||
//
|
||||
iBar.Clean();
|
||||
}
|
||||
|
||||
//
|
||||
// Preparing Signal ...
|
||||
if (has)
|
||||
{
|
||||
//
|
||||
// CArrayObj *tbObjects = new CArrayObj();
|
||||
// DrawTriggerBlock(
|
||||
// tb,
|
||||
// drawer,
|
||||
// tbObjects,
|
||||
// NULL //
|
||||
// );
|
||||
|
||||
//
|
||||
double targets[];
|
||||
for (int i = 1; i <= _r2r; i++)
|
||||
{
|
||||
//
|
||||
Add(
|
||||
(double)i,
|
||||
targets //
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
double iATR = 0;
|
||||
if (barIndex > 0 &&
|
||||
barIndex < ArraySize(_atrBuffer))
|
||||
{
|
||||
iATR = _atrBuffer[barIndex];
|
||||
}
|
||||
double slAdditional = _slAtrMultiplier * iATR;
|
||||
|
||||
//
|
||||
has = ToSignal(
|
||||
tb.trigger,
|
||||
tb.signal,
|
||||
targets,
|
||||
slAdditional //
|
||||
);
|
||||
}
|
||||
|
||||
//
|
||||
result = has;
|
||||
|
||||
//
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user