1797 lines
47 KiB
Plaintext
1797 lines
47 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class
|
|
// -------------------------------------------------
|
|
// Name: XCXFIMASignaller ...
|
|
// Description: XFIMA Signaller Class ...
|
|
//
|
|
//
|
|
// 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 XFIMA Signaller Class"
|
|
#property strict
|
|
|
|
//
|
|
// Imports ...
|
|
#include "../../Classes/x-saherelm.x-signaller.class.mq5"
|
|
#include "../../Helpers/x-saherelm.xfima.helper.mq5"
|
|
#include "../Classes/x-saherelm.xfima.x-poi.detector.class.mq5"
|
|
#include "../Classes/x-saherelm.xfima.x-poi.drawer.class.mq5"
|
|
|
|
//
|
|
// Implementation ...
|
|
|
|
//
|
|
// Base XFIMA base Signaller ...
|
|
class XCXFIMABaseSignaller : public XCBaseSignaller
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
bool ignoreTargets; // Ignore Signal Targets ...
|
|
CArrayObj drawnObjects; // Drawing Objects Holder ...
|
|
XFIMAInputs fimaInputs; // XFIMA Inputs ...
|
|
XCXFIMAHelper *fimaHelper; // XFIMA Indicator Helper ...
|
|
XCXFIMAPOIDrawer *poiDrawer; // XFIMA POI Drawer ...
|
|
XCXFIMAPOIDetector *poiDetector; // XFIMA POI Detector ...
|
|
XPatternAnalysisConfig patternAnalyserConfig; // Bar Pattern Analyser Config ...
|
|
XPatternAnalysisDrawConfig patternAnalyserDrawConfig; // Bar Pattern Analysis Drawer Config ...
|
|
|
|
//
|
|
// Constructor ...
|
|
XCXFIMABaseSignaller(
|
|
string _name, // Name ...
|
|
string _symbol, // Symbol ...
|
|
ENUM_TIMEFRAMES _period, // Period ...
|
|
XFIMAInputs &_fimaInputs, // XFIMAInputs ...
|
|
bool _processAllTicks = false, // Process All Ticks ...
|
|
double _defaultSignalR2R = 1.5, // Default Signal Risk To Reward Ratio ...
|
|
double _defaultSignalRiskInPoint = 50, // Default Signal Risk In Point ...
|
|
double _defaultSignalVolume = 0.01 // Default Signal Volume ...
|
|
) : XCBaseSignaller(_name,
|
|
_symbol,
|
|
_period,
|
|
_processAllTicks,
|
|
_defaultSignalR2R,
|
|
_defaultSignalRiskInPoint,
|
|
_defaultSignalVolume //
|
|
)
|
|
{
|
|
//
|
|
// Instantiating XFIMA Indicator Helper Class ...
|
|
if (_fimaInputs.IsValid())
|
|
{
|
|
//
|
|
fimaHelper = new XCXFIMAHelper();
|
|
bool isInited = fimaHelper.Init(
|
|
_symbol,
|
|
_period,
|
|
_fimaInputs //
|
|
);
|
|
if (isInited)
|
|
{
|
|
fimaInputs = _fimaInputs;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
delete fimaHelper;
|
|
ZeroMemory(fimaHelper);
|
|
}
|
|
}
|
|
|
|
//
|
|
poiDrawer = new XCXFIMAPOIDrawer();
|
|
poiDetector = new XCXFIMAPOIDetector(fimaHelper);
|
|
|
|
//
|
|
// Configure ...
|
|
|
|
//
|
|
patternAnalyserConfig.Clean();
|
|
patternAnalyserConfig.Default();
|
|
patternAnalyserConfig.FullPattern();
|
|
|
|
//
|
|
patternAnalyserDrawConfig.Clean();
|
|
patternAnalyserDrawConfig.Default();
|
|
patternAnalyserDrawConfig.FullDraw();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XCXFIMABaseSignaller()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Destroy ...
|
|
*/
|
|
void Destroy()
|
|
{
|
|
//
|
|
BeforeDestroy();
|
|
|
|
//
|
|
fimaInputs.Clean();
|
|
|
|
//
|
|
delete fimaHelper;
|
|
ZeroMemory(fimaHelper);
|
|
|
|
//
|
|
delete poiDrawer;
|
|
ZeroMemory(poiDrawer);
|
|
|
|
//
|
|
delete poiDetector;
|
|
ZeroMemory(poiDetector);
|
|
|
|
//
|
|
// analyserConfig.Clean();
|
|
patternAnalyserConfig.Clean();
|
|
patternAnalyserDrawConfig.Clean();
|
|
}
|
|
|
|
//
|
|
// Virtuals ...
|
|
|
|
/**
|
|
* Before Destroy ...
|
|
*/
|
|
void virtual BeforeDestroy()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Processing Tick ...
|
|
*
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
*/
|
|
virtual void ProcessTick(int barIndex = 0)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Processing New Bar ...
|
|
*
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
*/
|
|
virtual void ProcessNewBar(int barIndex = 0)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Check Guards Based on MarketConditions ...
|
|
*
|
|
* @param guards: XGuard, reference collection to holds result ...
|
|
* @param positions: XPosition, reference collection to provides positions ...
|
|
* @param barIndex: int
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int virtual CheckForGuard(
|
|
XGuard &guards[],
|
|
XPosition &positions[],
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
SpecifiedClean(guards);
|
|
|
|
//
|
|
result = ArraySize(guards);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check Additional Validations on Childs Instances ...
|
|
*
|
|
* @return ( bool virtual )
|
|
*/
|
|
bool virtual CheckAdditionslSignallerValidations()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Fima Helper Requirements ...
|
|
result = fimaInputs.IsValid() &&
|
|
fimaHelper != NULL &&
|
|
poiDetector != NULL;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Normalizing Signal by Signaller Custom Props ...
|
|
*
|
|
* @param signal: XSignal ...
|
|
*/
|
|
void virtual NormalizeSignal(XSignal &signal)
|
|
{
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
|
|
//
|
|
// Protected Actions ...
|
|
|
|
//
|
|
// Drawer Functions ...
|
|
|
|
/**
|
|
* Draw Specified Pattern Pivot ...
|
|
*
|
|
* @param _pivot: XPivot, reference to Specified Pivot ...
|
|
* @param config: XPatternAnalysisDrawConfig, Darwing Configuration ...
|
|
* @param thresholdMultiplier: int, pivot point threshold ...
|
|
*/
|
|
void DrawPivot(
|
|
XPivot &_pivot,
|
|
XPatternAnalysisDrawConfig &config,
|
|
int thresholdMultiplier = 0 //
|
|
)
|
|
{
|
|
//
|
|
// Normalize ...
|
|
thresholdMultiplier = NormalizeInt(thresholdMultiplier, 1);
|
|
|
|
//
|
|
int arrowThreshold = config.arrowsThreshold * thresholdMultiplier;
|
|
arrowThreshold = NormalizeInt(arrowThreshold, 1);
|
|
|
|
//
|
|
// Validate ...
|
|
bool has =
|
|
poiDrawer != NULL &&
|
|
_pivot.IsValid();
|
|
if (!has)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XOHCL _bar;
|
|
has = _pivot.GetBar(_bar);
|
|
if (!has)
|
|
{
|
|
//
|
|
_bar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
XCBarArrowObject *iObj;
|
|
has = poiDrawer.DrawBarArrow(
|
|
_bar,
|
|
iObj,
|
|
_pivot.IsPeak()
|
|
? config.arrowPeakPriceType
|
|
: config.arrowValePriceType,
|
|
_pivot.IsBullish()
|
|
? config.bullishArrow
|
|
: config.bearishArrow,
|
|
_pivot.IsBullish()
|
|
? config.bullishColor
|
|
: config.bearishColor,
|
|
config.arrowsWidth,
|
|
_pivot.IsBullish()
|
|
? ANCHOR_TOP
|
|
: ANCHOR_BOTTOM,
|
|
_pivot.prefix + "_Pivot_" + ToXString(TimeToSeconds(_pivot.time)),
|
|
true, // Ignore Bar Tag ...
|
|
arrowThreshold // Threshold ...
|
|
);
|
|
if (has)
|
|
{
|
|
drawnObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
ZeroMemory(iObj);
|
|
}
|
|
|
|
/**
|
|
* Draw Specified Pattern Zone ...
|
|
*
|
|
* @param _zone: XBozxZone, reference to Specified Zone ...
|
|
* @param config: XPatternAnalysisDrawConfig, Darwing Configuration ...
|
|
*/
|
|
void DrawZone(
|
|
XBoxZone &_zone,
|
|
XPatternAnalysisDrawConfig &config //
|
|
)
|
|
{
|
|
//
|
|
// Validate ...
|
|
bool has =
|
|
poiDrawer != NULL &&
|
|
_zone.IsValid();
|
|
if (!has)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XCBoxObject *iObj;
|
|
has = poiDrawer.DrawBox(
|
|
_zone,
|
|
iObj,
|
|
config.ignoreZonesAt,
|
|
_zone.type + "_Zone_" + ToXString(TimeToSeconds(_zone.from)) //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
XPOIStyle iStyle;
|
|
poiDrawer.GetBoxStyle(
|
|
iStyle,
|
|
_zone.dir //
|
|
);
|
|
|
|
//
|
|
iStyle.clr =
|
|
_zone.IsBullish()
|
|
? config.bullishColor
|
|
: config.bearishColor;
|
|
iStyle.width = config.zonesWidth;
|
|
iStyle.style = config.zonesStyle;
|
|
|
|
//
|
|
poiDrawer.ApplyBoxStyle(
|
|
iObj,
|
|
iStyle //
|
|
);
|
|
|
|
//
|
|
drawnObjects.Add(iObj);
|
|
|
|
//
|
|
iStyle.Clean();
|
|
}
|
|
|
|
//
|
|
ZeroMemory(iObj);
|
|
}
|
|
|
|
/**
|
|
* Draw Specified Pattern info ...
|
|
*
|
|
* @param _bar: XOHCL, reference to Pattern's Bar ...
|
|
* @param _pivot: XPivot, reference to Pattern's Pivot ...
|
|
* @param _zone: XBoxZone, reference to Pattern's Zone ...
|
|
* @param _pattern: ENUM_X_BAR_PATTERN, Specified Bar Pattern ...
|
|
* @param _patternDir: ENUM_X_DIRECTION, Specified Bar Pattern's Direction ...
|
|
* @param thresholdMultiplier: int, pivot point threshold ...
|
|
* @param ignorePermissions: bool, force to Check Permissions from Config ...
|
|
*/
|
|
void DrawPattern(
|
|
XOHCL &_bar,
|
|
XPivot &_pivot,
|
|
XBoxZone &_zone,
|
|
ENUM_X_BAR_PATTERN _pattern,
|
|
ENUM_X_DIRECTION _patternDir,
|
|
int thresholdMultiplier = 0,
|
|
bool ignorePermissions = true //
|
|
)
|
|
{
|
|
//
|
|
// Validate ...
|
|
bool has =
|
|
poiDrawer != NULL &&
|
|
_bar.IsValid() &&
|
|
IsXValid(_pattern) &&
|
|
HasDirection(_patternDir);
|
|
if (!has)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Handle Draws ...
|
|
|
|
//
|
|
// Draw OHCL Bar ...
|
|
|
|
//
|
|
// Draw Pivot ...
|
|
has =
|
|
ignorePermissions
|
|
? true
|
|
: patternAnalyserDrawConfig.CanDrawPivot(_pattern);
|
|
if (has)
|
|
{
|
|
DrawPivot(_pivot, patternAnalyserDrawConfig, thresholdMultiplier);
|
|
}
|
|
|
|
//
|
|
// Draw Zone ...
|
|
has =
|
|
ignorePermissions
|
|
? true
|
|
: patternAnalyserDrawConfig.CanDrawZone(_pattern);
|
|
if (has)
|
|
{
|
|
DrawZone(_zone, patternAnalyserDrawConfig);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draw Specified Bar Pattern Analysis ...
|
|
*
|
|
* @param barAnalysis: XPatternAnalysis, reference to Specified Bar Pattern Analysis ...
|
|
*/
|
|
void DrawBarPatternAnalysis(
|
|
XPatternAnalysis &barAnalysis,
|
|
XPatternAnalysisDrawConfig &config //
|
|
)
|
|
{
|
|
//
|
|
bool has =
|
|
poiDrawer != NULL &&
|
|
barAnalysis.IsValid();
|
|
if (!has)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool canDraw;
|
|
bool isBullish;
|
|
bool isBearish;
|
|
XOHCL patternBar;
|
|
bool canDrawZone;
|
|
bool canDrawPivot;
|
|
XPivot patternPivot;
|
|
XBoxZone patternBox;
|
|
ENUM_X_BAR_PATTERN pattern;
|
|
ENUM_X_DIRECTION patternDir;
|
|
|
|
//
|
|
int patternsPivotThresholdMultiplier = 0;
|
|
|
|
//
|
|
// Support and Resistance ...
|
|
|
|
//
|
|
// Support ...
|
|
isBearish = false;
|
|
isBullish = barAnalysis.IsSupport();
|
|
has = isBullish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_SUPPORT;
|
|
patternDir = X_DIRECTION_BULLISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Resistance ...
|
|
isBullish = false;
|
|
isBearish = barAnalysis.IsResistance();
|
|
has = isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_RESISTANCE;
|
|
patternDir = X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// PV: High and Low ...
|
|
|
|
//
|
|
// Low ...
|
|
isBearish = false;
|
|
isBullish = barAnalysis.IsLow();
|
|
has = isBullish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_LOW;
|
|
patternDir = X_DIRECTION_BULLISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// High ...
|
|
isBullish = false;
|
|
isBearish = barAnalysis.IsHigh();
|
|
has = isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_HIGH;
|
|
patternDir = X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// OB ...
|
|
isBullish = barAnalysis.IsOB(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsOB(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_OB;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// FVG ...
|
|
isBullish = barAnalysis.IsFVG(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsFVG(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_FVG;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Momentum ...
|
|
isBullish = barAnalysis.IsMomentum(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsMomentum(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_MOMENTUM;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Engulfed ...
|
|
isBullish = barAnalysis.IsEngulfed(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsEngulfed(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_ENGULFED;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Pinned ...
|
|
isBullish = barAnalysis.IsPinned(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsPinned(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_PINNED;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// TrueGaped ...
|
|
isBullish = barAnalysis.IsTrueGaped(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsTrueGaped(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_TRUE_GAPED;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Star ...
|
|
isBullish = barAnalysis.IsStar(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsStar(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_STAR;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Piercing ...
|
|
isBullish = barAnalysis.IsPiercing(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsPiercing(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_PIERCING;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Rising ...
|
|
isBullish = barAnalysis.IsRising(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsRising(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_RISING;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Flag ...
|
|
isBullish = barAnalysis.IsFlag(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsFlag(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_FLAG;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// SignalKey ...
|
|
isBullish = barAnalysis.IsSignalKey(X_DIRECTION_BULLISH);
|
|
isBearish = barAnalysis.IsSignalKey(X_DIRECTION_BEARISH);
|
|
has = isBullish || isBearish;
|
|
if (has)
|
|
{
|
|
//
|
|
pattern = X_BAR_PATTERN_SIGNALKEY;
|
|
patternDir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
canDraw = config.CanDraw(pattern);
|
|
if (canDraw)
|
|
{
|
|
//
|
|
has = barAnalysis.GetPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
canDrawZone = config.CanDrawZone(pattern);
|
|
if (!canDrawZone)
|
|
{
|
|
patternBox.Clean();
|
|
}
|
|
|
|
//
|
|
canDrawPivot = config.CanDrawPivot(pattern);
|
|
if (!canDrawPivot)
|
|
{
|
|
patternPivot.Clean();
|
|
}
|
|
else
|
|
{
|
|
patternsPivotThresholdMultiplier++;
|
|
}
|
|
|
|
//
|
|
DrawPattern(
|
|
patternBar,
|
|
patternPivot,
|
|
patternBox,
|
|
pattern,
|
|
patternDir,
|
|
patternsPivotThresholdMultiplier //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
patternBar.Clean();
|
|
patternBox.Clean();
|
|
patternPivot.Clean();
|
|
}
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
};
|
|
|
|
//
|
|
// XFIMA Strategy 2 Signaller Class ...
|
|
class XCXFIMAStrategy1Signaller : public XCXFIMABaseSignaller
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
// XFIMAPatternDetectorConfig analyserConfig;
|
|
|
|
//
|
|
// Constructor ...
|
|
XCXFIMAStrategy1Signaller(
|
|
string _symbol, // Symbol ...
|
|
ENUM_TIMEFRAMES _period, // Period ...
|
|
XFIMAInputs &_fimaInputs, // XFIMAInputs ...
|
|
bool _processAllTicks = false, // Process All Ticks ...
|
|
double _defaultSignalR2R = 1.5, // Default Signal Risk To Reward Ratio ...
|
|
double _defaultSignalRiskInPoint = 50, // Default Signal Risk In Point ...
|
|
double _defaultSignalVolume = 0.01 // Default Signal Volume ...
|
|
) : XCXFIMABaseSignaller("XFIMA1",
|
|
_symbol,
|
|
_period,
|
|
_fimaInputs,
|
|
_processAllTicks,
|
|
_defaultSignalR2R,
|
|
_defaultSignalRiskInPoint,
|
|
_defaultSignalVolume //
|
|
)
|
|
{
|
|
//
|
|
// Configures ...
|
|
|
|
//
|
|
patternAnalyserConfig.Clean();
|
|
patternAnalyserConfig.Default();
|
|
patternAnalyserConfig.FullPattern();
|
|
|
|
//
|
|
patternAnalyserDrawConfig.Clean();
|
|
patternAnalyserDrawConfig.Default();
|
|
patternAnalyserDrawConfig.FullDraw();
|
|
|
|
//
|
|
// Ignore Signal Targets ...
|
|
ignoreTargets = true;
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XCXFIMAStrategy1Signaller()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
/**
|
|
* Processing Tick ...
|
|
*
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
*/
|
|
virtual void ProcessTick(int barIndex = 0)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Processing New Bar ...
|
|
*
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
*/
|
|
virtual void ProcessNewBar(int barIndex = 0)
|
|
{
|
|
//
|
|
// Normalize ...
|
|
barIndex = NormalizeInt(barIndex, 0);
|
|
|
|
//
|
|
XOHCL iBar;
|
|
int count = 0;
|
|
XBoxZone iZone;
|
|
XSignal iSignal;
|
|
bool has = false;
|
|
XTarget iTargets[];
|
|
string iName = NULL;
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
XPatternAnalysis iBarAnalysis;
|
|
XFIMAConditions iFIMAConditions;
|
|
XFIMAMarketStructure iStructure;
|
|
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
// Initialize Bar as CBar ...
|
|
has = iBar.Init(
|
|
symbol,
|
|
period,
|
|
barIndex //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Retrieve Conditions ...
|
|
has = fimaHelper.GetConditions(
|
|
iFIMAConditions,
|
|
barIndex,
|
|
10 // Loopback ...
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
iFIMAConditions.Clean();
|
|
|
|
//
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Analyse Market ...
|
|
// poiDetector.AnalyseMarket(
|
|
// iBar,
|
|
// iStructure,
|
|
// analyserConfig //
|
|
// );
|
|
|
|
//
|
|
// Bar Pattern Analysis Detection Test ...
|
|
// has = poiDetector.AnalyseBarPatterns(
|
|
// iBar,
|
|
// iBarAnalysis,
|
|
// patternAnalyserConfig //
|
|
// );
|
|
// DrawBarPatternAnalysis(iBarAnalysis, patternAnalyserDrawConfig);
|
|
|
|
//
|
|
has = fimaHelper.HasBoundarySwitch(
|
|
iDir,
|
|
iBar.Index() //
|
|
);
|
|
if (has)
|
|
{
|
|
Print("Hot Place Detected");
|
|
}
|
|
|
|
//
|
|
// Disable Signallers ...
|
|
has = false;
|
|
iDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
// Strategy 1 ...
|
|
// Works on Support or Resistances Areas ...
|
|
// has = Strategy1HasSignal(
|
|
// iBar,
|
|
// iZone,
|
|
// iTargets,
|
|
// iDir,
|
|
// iFIMAConditions,
|
|
// iStructure //
|
|
// );
|
|
|
|
//
|
|
// Strategy 2 ...
|
|
// Works on MA Crosses ...
|
|
if (!has)
|
|
{
|
|
//
|
|
// has = Strategy2HasSignal(
|
|
// iBar,
|
|
// iZone,
|
|
// iTargets,
|
|
// iDir,
|
|
// iFIMAConditions,
|
|
// iStructure //
|
|
// );
|
|
}
|
|
|
|
//
|
|
has = HasDirection(iDir);
|
|
if (has)
|
|
{
|
|
//
|
|
isBullish = IsXBullish(iDir);
|
|
isBearish = IsXBearish(iDir);
|
|
|
|
//
|
|
// TODO: Provided SL ...
|
|
double _point = GetPoints(iBar.symbol);
|
|
double slAddition = 5 * _point;
|
|
double slPrice =
|
|
isBullish
|
|
? iZone.lower - slAddition
|
|
: iZone.upper + slAddition;
|
|
|
|
//
|
|
// Prepare Founded Signal ...
|
|
|
|
//
|
|
// Handle Signal Targets ...
|
|
if (ignoreTargets)
|
|
{
|
|
XClean(iTargets);
|
|
}
|
|
|
|
//
|
|
has = PrepareSignal(
|
|
iSignal,
|
|
iDir,
|
|
iTargets,
|
|
0, // Use Default R2R ...
|
|
slPrice, // Provided Price for SL ...
|
|
0 // Specified Risk in Point ....
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
// Notify On Signal Event ...
|
|
NotifySignalEventListeners(iSignal);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
iBar.Clean();
|
|
iZone.Clean();
|
|
iSignal.Clean();
|
|
iStructure.Clean();
|
|
iBarAnalysis.Clean();
|
|
iFIMAConditions.Clean();
|
|
SpecifiedClean(iTargets);
|
|
}
|
|
|
|
/**
|
|
* Check Guards Based on MarketConditions ...
|
|
*
|
|
* @param guards: XGuard, reference collection to holds result ...
|
|
* @param positions: XPosition, reference collection to provides positions ...
|
|
* @param barIndex: int
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int virtual CheckForGuard(
|
|
XGuard &guards[],
|
|
XPosition &positions[],
|
|
int barIndex = 0 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
SpecifiedClean(guards);
|
|
|
|
//
|
|
result = ArraySize(guards);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Implementing Strategies ...
|
|
|
|
/**
|
|
* Check Bar Has Signal Based on Strategy 1 ...
|
|
*
|
|
* @param bar: XOHCL, reference to Bar ...
|
|
* @param zone: XBoxZone, reference to holds affected zone ...
|
|
* @param targets: XTarget, reference to detected Signal's Targets collections ...
|
|
* @param dir: ENUM_X_DIRECTION, detected Signal's direction ...
|
|
* @param conditions: XFIMAConditions, reference to Bar Specified XFIMA Conditions ...
|
|
* @param structure: XFIMAMarketStructure, refrence to Provides Market Structure ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Strategy1HasSignal(
|
|
XOHCL &bar,
|
|
XBoxZone &zone,
|
|
XTarget &targets[],
|
|
ENUM_X_DIRECTION &dir,
|
|
XFIMAConditions &conditions,
|
|
XFIMAMarketStructure &structure //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Prepare ...
|
|
zone.Clean();
|
|
XClean(targets);
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
// Validate ...
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Prepare zone ...
|
|
if (result)
|
|
{
|
|
//
|
|
zone.to = bar.time;
|
|
zone.from = GetBarTime(
|
|
bar.symbol,
|
|
bar.period,
|
|
bar.Index() + 2 //
|
|
);
|
|
zone.symbol = bar.symbol;
|
|
zone.period = bar.period;
|
|
// zone.dir = structure.maCrossDir;
|
|
zone.lower = bar.FindLowest(2, MODE_LOW);
|
|
zone.upper = bar.FindHighest(2, MODE_HIGH);
|
|
// zone.type = name + "_" + ToXString(structure.maCrossDir);
|
|
|
|
//
|
|
result = zone.IsValid();
|
|
}
|
|
|
|
//
|
|
// Check Result ...
|
|
if (result)
|
|
{
|
|
//
|
|
// dir = structure.maCrossDir;
|
|
|
|
//
|
|
// Handle Targets Detection ...
|
|
}
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
if (!result)
|
|
{
|
|
//
|
|
zone.Clean();
|
|
XClean(targets);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check Bar Has Signal Based on Strategy 1 ...
|
|
*
|
|
* @param bar: XOHCL, reference to Bar ...
|
|
* @param zone: XBoxZone, reference to holds affected zone ...
|
|
* @param targets: XTarget, reference to detected Signal's Targets collections ...
|
|
* @param dir: ENUM_X_DIRECTION, detected Signal's direction ...
|
|
* @param conditions: XFIMAConditions, reference to Bar Specified XFIMA Conditions ...
|
|
* @param structure: XFIMAMarketStructure, refrence to Provides Market Structure ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Strategy2HasSignal(
|
|
XOHCL &bar,
|
|
XBoxZone &zone,
|
|
XTarget &targets[],
|
|
ENUM_X_DIRECTION &dir,
|
|
XFIMAConditions &conditions,
|
|
XFIMAMarketStructure &structure //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Prepare ...
|
|
zone.Clean();
|
|
XClean(targets);
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
// Validate ...
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Specified MA Cross ...
|
|
// result = HasDirection(structure.maCrossDir);
|
|
|
|
//
|
|
// Prepare zone ...
|
|
if (result)
|
|
{
|
|
//
|
|
zone.to = bar.time;
|
|
zone.from = GetBarTime(
|
|
bar.symbol,
|
|
bar.period,
|
|
bar.Index() + 2 //
|
|
);
|
|
zone.symbol = bar.symbol;
|
|
zone.period = bar.period;
|
|
// zone.dir = structure.maCrossDir;
|
|
zone.lower = bar.FindLowest(2, MODE_LOW);
|
|
zone.upper = bar.FindHighest(2, MODE_HIGH);
|
|
// zone.type = name + "_" + ToXString(structure.maCrossDir);
|
|
|
|
//
|
|
result = zone.IsValid();
|
|
}
|
|
|
|
//
|
|
// Check Result ...
|
|
if (result)
|
|
{
|
|
//
|
|
// dir = structure.maCrossDir;
|
|
|
|
//
|
|
// Handle Targets Detection ...
|
|
}
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
if (!result)
|
|
{
|
|
//
|
|
zone.Clean();
|
|
XClean(targets);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
// |