Garfield
74308b38e7
- MultiSignal Confluence EA v1.11 (stop loss bug fixed) - Harmonic Pattern Finder v2 (optimized) - Candlestick Pattern EA (fixed) - Pivot Fade EA v4 (fixed) - Bot series (10001, 10002, EnhancedEA) Performance: ~19% return in 2 months on 00k account
1979 lines
218 KiB
Plaintext
Executable File
1979 lines
218 KiB
Plaintext
Executable File
//+------------------------------------------------------------------+
|
|
//| HarmonicPatternFinderV2.mq5 |
|
|
//| Copyright 2016, André S. Enger. |
|
|
//| andre_enger@hotmail.com |
|
|
//| Contribs |
|
|
//| David Gadelha |
|
|
//| dgadelha@gmail.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2016, Andre S. Enger."
|
|
#property link "andre_enger@hotmail.com"
|
|
#property version "2.0"
|
|
#property description "Indicator to display existent and emerging harmonic chart patterns."
|
|
|
|
#property indicator_chart_window
|
|
#property indicator_buffers 2
|
|
#property indicator_plots 1
|
|
|
|
#property indicator_label1 "Zig Zag"
|
|
#property indicator_type1 DRAW_ZIGZAG
|
|
#property indicator_color1 clrNONE
|
|
#property indicator_style1 STYLE_SOLID
|
|
#property indicator_width1 1
|
|
//--- Describes patterns
|
|
struct PATTERN_DESCRIPTOR
|
|
{
|
|
double ab2xa_min;
|
|
double ab2xa_max;
|
|
double bc2ab_min;
|
|
double bc2ab_max;
|
|
double cd2bc_min;
|
|
double cd2bc_max;
|
|
double ad2xa_min;
|
|
double ad2xa_max;
|
|
double cd2xc_min;
|
|
double cd2xc_max;
|
|
double xc2xa_min;
|
|
double xc2xa_max;
|
|
double cd2ab_min;
|
|
double cd2ab_max;
|
|
};
|
|
//--- Identifies drawn patterns
|
|
struct PATTERN_INSTANCE
|
|
{
|
|
int patternIndex;
|
|
int patternBufferIndex;
|
|
bool bullish;
|
|
bool overlapping;
|
|
datetime XDateTime;
|
|
datetime ADateTime;
|
|
datetime BDateTime;
|
|
datetime CDateTime;
|
|
datetime DDateTime;
|
|
double X;
|
|
double A;
|
|
double B;
|
|
double C;
|
|
double D;
|
|
double PRZ;
|
|
};
|
|
//--- Number keys of patterns
|
|
enum PATTERN_INDEX
|
|
{
|
|
TRENDLIKE1_ABCD=0,
|
|
TRENDLIKE2_ABCD,
|
|
PERFECT_ABCD,
|
|
IDEAL1_ABCD,
|
|
IDEAL2_ABCD,
|
|
RANGELIKE_ABCD,
|
|
ALT127_TRENDLIKE1_ABCD,
|
|
ALT127_TRENDLIKE2_ABCD,
|
|
ALT127_PERFECT_ABCD,
|
|
ALT127_IDEAL1_ABCD,
|
|
ALT127_IDEAL2_ABCD,
|
|
ALT127_RANGELIKE_ABCD,
|
|
REC_TRENDLIKE1_ABCD,
|
|
REC_TRENDLIKE2_ABCD,
|
|
REC_PERFECT_ABCD,
|
|
REC_IDEAL1_ABCD,
|
|
REC_IDEAL2_ABCD,
|
|
REC_RANGELIKE_ABCD,
|
|
GARTLEY,
|
|
BAT,
|
|
ALTBAT,
|
|
FIVEO,
|
|
BUTTERFLY,
|
|
CRAB,
|
|
DEEPCRAB,
|
|
THREEDRIVES,
|
|
CYPHER,
|
|
SHARK,
|
|
NENSTAR,
|
|
BLACKSWAN,
|
|
WHITESWAN,
|
|
ONE2ONE,
|
|
NEWCYPHER,
|
|
NAVARRO200,
|
|
LEONARDO,
|
|
KANE,
|
|
GARFLY,
|
|
MAXBAT,
|
|
MAXGARTLEY,
|
|
MAXBUTTERFLY,
|
|
GARTLEY113,
|
|
BUTTERFLY113,
|
|
ANTI_GARTLEY,
|
|
ANTI_BAT,
|
|
ANTI_ALTBAT,
|
|
ANTI_FIVEO,
|
|
ANTI_BUTTERFLY,
|
|
ANTI_CRAB,
|
|
ANTI_DEEPCRAB,
|
|
ANTI_THREEDRIVES,
|
|
ANTI_CYPHER,
|
|
ANTI_SHARK,
|
|
ANTI_NENSTAR,
|
|
ANTI_BLACKSWAN,
|
|
ANTI_WHITESWAN,
|
|
ANTI_ONE2ONE,
|
|
ANTI_NEWCYPHER,
|
|
ANTI_NAVARRO200,
|
|
ANTI_LEONARDO,
|
|
ANTI_KANE,
|
|
ANTI_GARFLY,
|
|
ANTI_MAXBAT,
|
|
ANTI_MAXGARTLEY,
|
|
ANTI_MAXBUTTERFLY,
|
|
ANTI_GARTLEY113,
|
|
ANTI_BUTTERFLY113,
|
|
};
|
|
//--- ZigZag selection
|
|
enum ZIGZAGTYPE
|
|
{
|
|
FASTZZ,//Fast ZZ
|
|
ALEXSTAL,//Alexstal ZZ
|
|
SWINGCHART //Swing ZZ
|
|
};
|
|
|
|
//--- Constants and macros
|
|
#define SIZE_PATTERN_BUFFER 10
|
|
#define NUM_PATTERNS 66
|
|
#define NON_EXISTENT_DATETIME D'19.07.1980 12:30:27'
|
|
|
|
const string _identifier="HPF";
|
|
|
|
//--- User Inputs
|
|
input string indicatorSettings="-=Indicator Settings=-"; //-=Indicator Settings=-
|
|
input ZIGZAGTYPE zztype=ALEXSTAL; //ZigZag type
|
|
input int zzperiod=12; //AlexStal ZZ period
|
|
input int zzamplitude=10; //AlexStal ZZ amplitude
|
|
input int zzminmotion=0; //AlexStal ZZ minimum motion
|
|
input int SwingSize=200; //Fast ZZ sensitivity in points
|
|
input int BarsAnalyzed=200; //Max. bars per pattern
|
|
input int History=1000; //Max. history bars to process
|
|
input int MaxSamePoints=2; //Max. shared points per pattern
|
|
input double SlackRange=0.01; //Max. slack for fib ratios (range)
|
|
input double SlackUnary=0.1; //Max. slack for fib ratios (unary)
|
|
input string indicatorColors="-=Display Settings=-"; //-=Display Settings=-
|
|
input color ClrBull=clrLightSkyBlue; //Color for bullish patterns (5 points)
|
|
input color ClrBear=clrSalmon; //Color for bearish patterns (5 points)
|
|
input color ClrBull4P=clrBlue; //Color for bullish patterns (4 points)
|
|
input color ClrBear4P=clrRed; //Color for bearish patterns (4 points)
|
|
input color ClrBullProjection=clrSeaGreen; //Color for projected bullish patterns
|
|
input color ClrBearProjection=clrDarkOrange; //Color for projected bearish patterns
|
|
input color ClrRatio=clrGray; //Color for patterns ratios
|
|
input bool Fill_Patterns=false; //Fill 5 point patterns found
|
|
input bool Show_descriptions=true; //Show pattern descriptions
|
|
input bool Show_PRZ=true; //Show potential reversal zone (PRZ)
|
|
input bool EmergingPatterns=true; //Show emerging patterns
|
|
input bool OneAheadProjection=false; //Show "one-ahead" projections
|
|
input bool showPatternNames=false; //Show comment box
|
|
input int l_width=2; //Pattern line width (5 points)
|
|
input int l_width4p=2; //Patterns line width (4 points)
|
|
input int l_width_proj=2; //Emerging patterns line width
|
|
input int Font_size=08; //Font size
|
|
input ENUM_LINE_STYLE Style_5P=STYLE_SOLID; //Style for 5 points patterns
|
|
input ENUM_LINE_STYLE Style_4P=STYLE_DASH; //Style for 4 points patterns
|
|
input ENUM_LINE_STYLE Style_Proj=STYLE_DASHDOTDOT; //Style for projections
|
|
input ENUM_LINE_STYLE Style_Ratio=STYLE_DOT; //Style for ratio lines
|
|
input ENUM_LINE_STYLE Style_PRZ=STYLE_DASHDOT; //Style for PRZ
|
|
input string indicatorPatternsQuick="-=Patterns Quick=-"; //-=Patterns Quick=-
|
|
input bool Show_abcd=true; //Display AB=CD patterns
|
|
input bool Show_alt127_abcd=true; //Display 1.27 AB=CD patterns
|
|
input bool Show_rec_abcd=true; //Display Rec. AB=CD patterns
|
|
input bool Show_patterns=true; //Display normal 5-point patterns
|
|
input bool Show_antipatterns=false; //Display anti 5-point patterns
|
|
input string indicatorPatternsIndividual="-=Patterns Individual=-"; //-=Patterns Individual=-
|
|
input bool Show_trendlike1_abcd=true; //Display Trendlike AB=CD #1
|
|
input bool Show_trendlike2_abcd=true; //Display Trendlike AB=CD #2
|
|
input bool Show_perfect_abcd=true; //Display Perfect AB=CD
|
|
input bool Show_ideal1_abcd=true; //Display Ideal AB=CD #1
|
|
input bool Show_ideal2_abcd=true; //Display Ideal AB=CD #2
|
|
input bool Show_rangelike_abcd=true; //Display Rangelike AB=CD
|
|
input bool Show_alt127_trendlike1_abcd=true; //Display Trendlike 1.27 AB=CD #1
|
|
input bool Show_alt127_trendlike2_abcd=true; //Display Trendlike 1.27 AB=CD #2
|
|
input bool Show_alt127_perfect_abcd=true; //Display Perfect 1.27 AB=CD
|
|
input bool Show_alt127_ideal1_abcd=true; //Display Ideal 1.27 AB=CD #1
|
|
input bool Show_alt127_ideal2_abcd=true; //Display Ideal 1.27 AB=CD #2
|
|
input bool Show_alt127_rangelike_abcd=true; //Display Rangelike 1.27 AB=CD
|
|
input bool Show_rec_trendlike1_abcd=true; //Display Rec. Trendlike AB=CD #1
|
|
input bool Show_rec_trendlike2_abcd=true; //Display Rec. Trendlike AB=CD #2
|
|
input bool Show_rec_perfect_abcd=true; //Display Rec. Perfect AB=CD
|
|
input bool Show_rec_ideal1_abcd=true; //Display Rec. Ideal AB=CD #1
|
|
input bool Show_rec_ideal2_abcd=true; //Display Rec. Ideal AB=CD #2
|
|
input bool Show_rec_rangelike_abcd=true; //Display Rec. Rangelike AB=CD
|
|
input bool Show_gartley=true; //Display Gartley
|
|
input bool Show_bat=true; //Display Bat
|
|
input bool Show_altbat=true; //Display Alt. Bat
|
|
input bool Show_fiveo=true; //Display 5-0
|
|
input bool Show_butterfly=true; //Display Butterfly
|
|
input bool Show_crab=true; //Display Crab
|
|
input bool Show_deepcrab=true; //Display Deepcrab
|
|
input bool Show_threedrives=true; //Display Three Drives
|
|
input bool Show_cypher=true; //Display Cypher
|
|
input bool Show_shark=true; //Display Shark
|
|
input bool Show_nenstar=true; //Display Nen Star
|
|
input bool Show_blackswan=true; //Display Black Swan
|
|
input bool Show_whiteswan=true; //Display White Swan
|
|
input bool Show_one2one=true; //Display One2One
|
|
input bool Show_newCypher=true; //Display New Cypher
|
|
input bool Show_navarro200=true; //Display Navarro 200
|
|
input bool Show_leonardo=true; //Display Leonardo
|
|
input bool Show_kane=true; //Display Kane
|
|
input bool Show_garfly=true; //Display Garfly
|
|
input bool Show_maxbat=true; //Display Max. Bat
|
|
input bool Show_maxgartley=true; //Display Max. Gartley
|
|
input bool Show_maxbutterfly=true; //Display Max. Butterfly
|
|
input bool Show_gartley113=true; //Display Gartley 113
|
|
input bool Show_butterfly113=true; //Display Butterfly 113
|
|
input bool Show_antigartley=true; //Display Anti Gartley
|
|
input bool Show_antibat=true; //Display Anti Bat
|
|
input bool Show_antialtbat=true; //Display Anti Alt. Bat
|
|
input bool Show_antifiveo=true; //Display Anti 5-0
|
|
input bool Show_antibutterfly=true; //Display Anti Butterfly
|
|
input bool Show_anticrab=true; //Display Anti Crab
|
|
input bool Show_antideepcrab=true; //Display Anti Deepcrab
|
|
input bool Show_antithreedrives=true; //Display Anti Three Drives
|
|
input bool Show_anticypher=true; //Display Anti Cypher
|
|
input bool Show_antishark=true; //Display Anti Shark
|
|
input bool Show_antinenstar=true; //Display Anti Nen Star
|
|
input bool Show_antiblackswan=true; //Display Anti Black Swan
|
|
input bool Show_antiwhiteswan=true; //Display Anti White Swan
|
|
input bool Show_antione2one=true; //Display Anti One2One
|
|
input bool Show_antinewCypher=true; //Display Anti New Cypher
|
|
input bool Show_antinavarro200=true; //Display Anti Navarro 200
|
|
input bool Show_antileonardo=true; //Display Anti Leonardo
|
|
input bool Show_antikane=true; //Display Anti Kane
|
|
input bool Show_antigarfly=true; //Display Anti Garfly
|
|
input bool Show_antimaxbat=true; //Display Anti Max. Bat
|
|
input bool Show_antimaxgartley=true; //Display Anti Max. Gartley
|
|
input bool Show_antimaxbutterfly=true; //Display Anti Max. Butterfly
|
|
input bool Show_antigartley113=true; //Display Anti Gartley 113
|
|
input bool Show_antibutterfly113=true; //Display Anti Butterfly 113
|
|
//--- Indicator buffer arrays
|
|
double peaks[],troughs[];
|
|
|
|
//--- Globals
|
|
bool _lastDirection;
|
|
double _lastPeakValue;
|
|
double _lastTroughValue;
|
|
int _lastPeak;
|
|
int _lastTrough;
|
|
int _patternInstanceCounter;
|
|
int _maxPatternInstances;
|
|
int _projectionInstanceCounter;
|
|
int _maxProjectionInstances;
|
|
int _drawnProjectionInstanceCounter;
|
|
int _maxDrawnProjectionInstances;
|
|
int _zzHandle;
|
|
PATTERN_INSTANCE _patternInstances[];
|
|
PATTERN_INSTANCE _projectionInstances[];
|
|
PATTERN_INSTANCE _drawnProjectionInstances[];
|
|
PATTERN_DESCRIPTOR _patterns[];
|
|
string _patternNames[];
|
|
int _patternCounter[];
|
|
datetime _patternX[][SIZE_PATTERN_BUFFER];
|
|
datetime _patternA[][SIZE_PATTERN_BUFFER];
|
|
datetime _patternB[][SIZE_PATTERN_BUFFER];
|
|
datetime _patternC[][SIZE_PATTERN_BUFFER];
|
|
datetime _patternD[][SIZE_PATTERN_BUFFER];
|
|
string com1="",com2="",com3="",com4="",com5="",com6="",com7="",com8="",com9="";
|
|
int _timeOfInit;
|
|
//+------------------------------------------------------------------+
|
|
//| Indicator initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
//--- indicator buffers mapping
|
|
SetIndexBuffer(0,peaks,INDICATOR_DATA);
|
|
SetIndexBuffer(1,troughs,INDICATOR_DATA);
|
|
IndicatorSetInteger(INDICATOR_DIGITS,Digits());
|
|
PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
|
|
PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
|
|
//--- memory
|
|
switch(zztype)
|
|
{
|
|
case FASTZZ:
|
|
_zzHandle=iCustom(NULL,0,"Downloads\\fastzz",SwingSize);
|
|
break;
|
|
case ALEXSTAL:
|
|
_zzHandle=iCustom(NULL,0,"Downloads\\alexstal_zigzagprof",zzperiod,zzamplitude,zzminmotion,true);
|
|
break;
|
|
case SWINGCHART:
|
|
default:
|
|
_zzHandle=iCustom(NULL,0,"Downloads\\swingchart");
|
|
}
|
|
if(_zzHandle==INVALID_HANDLE)
|
|
{
|
|
printf("Error obtaining handle");
|
|
return(INIT_FAILED);
|
|
}
|
|
MathSrand(GetTickCount());
|
|
_timeOfInit=MathRand();
|
|
for(int i=ObjectsTotal(0,0,-1)-1; i>=0; i--)
|
|
{
|
|
string name=ObjectName(0,i,0,-1);
|
|
if(StringFind(name,"U "+_identifier)!=-1 || StringFind(name,"D "+_identifier)!=-1)
|
|
ObjectDelete(0,name);
|
|
}
|
|
return PopulatePatterns();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Indicator deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
OnReinit();
|
|
Comment("");
|
|
ArrayFree(_patterns);
|
|
ArrayFree(_patternInstances);
|
|
ArrayFree(_projectionInstances);
|
|
ArrayFree(_drawnProjectionInstances);
|
|
ArrayFree(_patternNames);
|
|
ArrayFree(_patternCounter);
|
|
ArrayFree(_patternX);
|
|
ArrayFree(_patternA);
|
|
ArrayFree(_patternB);
|
|
ArrayFree(_patternC);
|
|
ArrayFree(_patternD);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Indicator reinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnReinit()
|
|
{
|
|
//----
|
|
_lastPeak=0;
|
|
_lastTrough=0;
|
|
_lastPeakValue=0;
|
|
_lastTroughValue=0;
|
|
_patternInstanceCounter=0;
|
|
_drawnProjectionInstanceCounter=0;
|
|
ArrayFill(_patternCounter,0,NUM_PATTERNS,0);
|
|
for(int i=0; i<NUM_PATTERNS; i++)
|
|
{
|
|
for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
|
|
{
|
|
_patternX[i][j]=0;
|
|
_patternA[i][j]=0;
|
|
_patternB[i][j]=0;
|
|
_patternC[i][j]=0;
|
|
_patternD[i][j]=0;
|
|
}
|
|
}
|
|
for(int i=ObjectsTotal(0,0,-1)-1; i>=0; i--)
|
|
{
|
|
string name=ObjectName(0,i,0,-1);
|
|
if(StringFind(name,"U "+_identifier+StringFormat("%x",_timeOfInit))!=-1 || StringFind(name,"D "+_identifier+StringFormat("%x",_timeOfInit))!=-1)
|
|
ObjectDelete(0,name);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Indicator iteration function |
|
|
//+------------------------------------------------------------------+
|
|
int OnCalculate(const int rates_total,
|
|
const int prev_calculated,
|
|
const datetime &time[],
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[],
|
|
const long &tick_volume[],
|
|
const long &volume[],
|
|
const int &spread[])
|
|
{
|
|
//---
|
|
int start=0;
|
|
if(prev_calculated>rates_total || prev_calculated<=0)
|
|
OnReinit();
|
|
else
|
|
start=prev_calculated-1;
|
|
start=MathMax(1,start);
|
|
//--- copy data
|
|
if(BarsCalculated(_zzHandle)<rates_total)
|
|
{
|
|
printf("ZigZag not calculated: "+IntegerToString(GetLastError()));
|
|
return 0;
|
|
}
|
|
if(CopyBuffer(_zzHandle,0,0,rates_total,peaks)<=0)
|
|
{
|
|
printf("ZigZag peaks not copied: "+IntegerToString(GetLastError()));
|
|
return 0;
|
|
}
|
|
if(CopyBuffer(_zzHandle,1,0,rates_total,troughs)<=0)
|
|
{
|
|
printf("ZigZag troughs not copied: "+IntegerToString(GetLastError()));
|
|
return 0;
|
|
}
|
|
//--- main loop
|
|
for(int bar=start; bar<rates_total && !IsStopped(); bar++)
|
|
{
|
|
//--- Efficency checks
|
|
if(bar<rates_total-History)
|
|
continue;
|
|
int lastPeak=FirstNonZeroFrom(bar,peaks);
|
|
int lastTrough=FirstNonZeroFrom(bar,troughs);
|
|
if(lastPeak==-1 || lastTrough==-1)
|
|
continue;
|
|
double lastPeakValue=peaks[lastPeak];
|
|
double lastTroughValue=troughs[lastTrough];
|
|
if(lastPeakValue==_lastPeakValue && lastTroughValue==_lastTroughValue)
|
|
continue;
|
|
//--- ZZ assessment
|
|
bool endsInTrough=lastTrough>lastPeak;
|
|
if(lastTrough==lastPeak)
|
|
{
|
|
int zzDirection=ZigZagDirection(lastPeak);
|
|
if(zzDirection==0) continue;
|
|
else if(zzDirection==-1) endsInTrough=true;
|
|
else if(zzDirection==1) endsInTrough=false;
|
|
}
|
|
//--- Remove old projections
|
|
UndisplayProjections();
|
|
//--- Remove old patterns (on ZZ swing continuation) or store them (on new ZZ direction)
|
|
if(_lastDirection==endsInTrough && !(_lastPeak<lastPeak && _lastTrough<lastTrough))
|
|
UndisplayPatterns();
|
|
else for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int k=instance.patternIndex;
|
|
bool bullish=instance.bullish;
|
|
datetime XDateTime=instance.XDateTime;
|
|
datetime ADateTime=instance.ADateTime;
|
|
datetime BDateTime=instance.BDateTime;
|
|
datetime CDateTime=instance.CDateTime;
|
|
datetime DDateTime=instance.DDateTime;
|
|
StoreOverlaps(k,XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
}
|
|
if(Show_PRZ)
|
|
UndisplayPRZs();
|
|
_patternInstanceCounter=0;
|
|
//--- Save most recent peaks/troughs and direction
|
|
_lastPeak=lastPeak;
|
|
_lastTrough=lastTrough;
|
|
_lastPeakValue=lastPeakValue;
|
|
_lastTroughValue=lastTroughValue;
|
|
_lastDirection=endsInTrough;
|
|
//--- Check each pattern for matches
|
|
for(int patternIndex=0; patternIndex<NUM_PATTERNS && !IsStopped(); patternIndex++)
|
|
{
|
|
//--- Check if pattern should be displayed
|
|
if(patternIndex==TRENDLIKE1_ABCD && (!Show_trendlike1_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==TRENDLIKE2_ABCD && (!Show_trendlike2_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==PERFECT_ABCD && (!Show_perfect_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==IDEAL1_ABCD && (!Show_ideal1_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==IDEAL2_ABCD && (!Show_ideal2_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==RANGELIKE_ABCD && (!Show_rangelike_abcd || !Show_abcd)) continue;
|
|
if(patternIndex==ALT127_TRENDLIKE1_ABCD && (!Show_alt127_trendlike1_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==ALT127_TRENDLIKE2_ABCD && (!Show_alt127_trendlike2_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==ALT127_PERFECT_ABCD && (!Show_alt127_perfect_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==ALT127_IDEAL1_ABCD && (!Show_alt127_ideal1_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==ALT127_IDEAL2_ABCD && (!Show_alt127_ideal2_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==ALT127_RANGELIKE_ABCD && (!Show_alt127_rangelike_abcd || !Show_alt127_abcd)) continue;
|
|
if(patternIndex==REC_TRENDLIKE1_ABCD && (!Show_rec_trendlike1_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==REC_TRENDLIKE2_ABCD && (!Show_rec_trendlike2_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==REC_PERFECT_ABCD && (!Show_rec_perfect_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==REC_IDEAL1_ABCD && (!Show_rec_ideal1_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==REC_IDEAL2_ABCD && (!Show_rec_ideal2_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==REC_RANGELIKE_ABCD && (!Show_rec_rangelike_abcd || !Show_rec_abcd)) continue;
|
|
if(patternIndex==GARTLEY && (!Show_gartley || !Show_patterns)) continue;
|
|
if(patternIndex==BAT && (!Show_bat || !Show_patterns)) continue;
|
|
if(patternIndex==ALTBAT && (!Show_altbat || !Show_patterns)) continue;
|
|
if(patternIndex==FIVEO && (!Show_fiveo || !Show_patterns)) continue;
|
|
if(patternIndex==BUTTERFLY && (!Show_butterfly || !Show_patterns)) continue;
|
|
if(patternIndex==CRAB && (!Show_crab || !Show_patterns)) continue;
|
|
if(patternIndex==DEEPCRAB && (!Show_deepcrab || !Show_patterns)) continue;
|
|
if(patternIndex==THREEDRIVES && (!Show_threedrives || !Show_patterns)) continue;
|
|
if(patternIndex==CYPHER && (!Show_cypher || !Show_patterns)) continue;
|
|
if(patternIndex==SHARK && (!Show_shark || !Show_patterns)) continue;
|
|
if(patternIndex==NENSTAR && (!Show_nenstar || !Show_patterns)) continue;
|
|
if(patternIndex==BLACKSWAN && (!Show_blackswan || !Show_patterns)) continue;
|
|
if(patternIndex==WHITESWAN && (!Show_whiteswan || !Show_patterns)) continue;
|
|
if(patternIndex==ONE2ONE && (!Show_one2one || !Show_patterns)) continue;
|
|
if(patternIndex==NEWCYPHER && (!Show_newCypher || !Show_patterns)) continue;
|
|
if(patternIndex==NAVARRO200 && (!Show_navarro200 || !Show_patterns)) continue;
|
|
if(patternIndex==LEONARDO && (!Show_leonardo || !Show_patterns)) continue;
|
|
if(patternIndex==KANE && (!Show_kane || !Show_patterns)) continue;
|
|
if(patternIndex==GARFLY && (!Show_garfly || !Show_patterns)) continue;
|
|
if(patternIndex==MAXBAT && (!Show_maxbat || !Show_patterns)) continue;
|
|
if(patternIndex==MAXGARTLEY && (!Show_maxgartley || !Show_patterns)) continue;
|
|
if(patternIndex==MAXBUTTERFLY && (!Show_maxbutterfly || !Show_patterns)) continue;
|
|
if(patternIndex==GARTLEY113 && (!Show_gartley113 || !Show_patterns)) continue;
|
|
if(patternIndex==BUTTERFLY113 && (!Show_butterfly113 || !Show_patterns)) continue;
|
|
if(patternIndex==ANTI_GARTLEY && (!Show_antigartley || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_BAT && (!Show_antibat || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_ALTBAT && (!Show_antialtbat || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_FIVEO && (!Show_antifiveo || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_BUTTERFLY && (!Show_antibutterfly || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_CRAB && (!Show_anticrab || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_DEEPCRAB && (!Show_antideepcrab || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_THREEDRIVES && (!Show_antithreedrives || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_CYPHER && (!Show_anticypher || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_SHARK && (!Show_antishark || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_NENSTAR && (!Show_antinenstar || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_BLACKSWAN && (!Show_antiblackswan || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_WHITESWAN && (!Show_antiwhiteswan || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_ONE2ONE && (!Show_antione2one || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_NEWCYPHER && (!Show_antinewCypher || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_NAVARRO200 && (!Show_antinavarro200 || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_LEONARDO && (!Show_antileonardo || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_KANE && (!Show_antikane || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_GARFLY && (!Show_antigarfly || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_MAXBAT && (!Show_antimaxbat || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_MAXGARTLEY && (!Show_antimaxgartley || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_MAXBUTTERFLY && (!Show_antimaxbutterfly || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_GARTLEY113 && (!Show_antigartley113 || !Show_antipatterns)) continue;
|
|
if(patternIndex==ANTI_BUTTERFLY113 && (!Show_antibutterfly113 || !Show_antipatterns)) continue;
|
|
PATTERN_DESCRIPTOR pattern=_patterns[patternIndex];
|
|
//--- What constraints does the pattern have?
|
|
bool ab2xaConstraint=pattern.ab2xa_max!=0 && pattern.ab2xa_min!=0;
|
|
bool ad2xaConstraint=pattern.ad2xa_max!=0 && pattern.ad2xa_min!=0;
|
|
bool bc2abConstraint=pattern.bc2ab_max!=0 && pattern.bc2ab_min!=0;
|
|
bool cd2bcConstraint=pattern.cd2bc_max!=0 && pattern.cd2bc_min!=0;
|
|
bool cd2xcConstraint=pattern.cd2xc_max!=0 && pattern.cd2xc_min!=0;
|
|
bool xc2xaConstraint=pattern.xc2xa_max!=0 && pattern.xc2xa_min!=0;
|
|
bool cd2abConstraint=pattern.cd2ab_max!=0 && pattern.cd2ab_min!=0;
|
|
//--- Which constraints are unary vs range?
|
|
double ab2xaSlack=pattern.ab2xa_max==pattern.ab2xa_min ? SlackUnary : SlackRange;
|
|
double ad2xaSlack=pattern.ad2xa_max==pattern.ad2xa_min ? SlackUnary : SlackRange;
|
|
double bc2abSlack=pattern.bc2ab_max==pattern.bc2ab_min ? SlackUnary : SlackRange;
|
|
double cd2bcSlack=pattern.cd2bc_max==pattern.cd2bc_min ? SlackUnary : SlackRange;
|
|
double cd2xcSlack=pattern.cd2xc_max==pattern.cd2xc_min ? SlackUnary : SlackRange;
|
|
double xc2xaSlack=pattern.xc2xa_max==pattern.xc2xa_min ? SlackUnary : SlackRange;
|
|
double cd2abSlack=pattern.cd2ab_max==pattern.cd2ab_min ? SlackUnary : SlackRange;
|
|
//--- Start searching from current bar - 'BarsAnalyzed'
|
|
_projectionInstanceCounter=0;
|
|
bool xFirstRun=true;
|
|
for(int XIndex=bar-BarsAnalyzed; XIndex<=bar && !IsStopped(); XIndex++)
|
|
{
|
|
if(XIndex<=0)
|
|
continue;
|
|
bool isPeak=IsProperValue(peaks[XIndex]);
|
|
bool isTrough=IsProperValue(troughs[XIndex]);
|
|
if(!isPeak && !isTrough)
|
|
continue;
|
|
bool startsInTrough=isTrough;
|
|
bool xVerticalZZ=isPeak && isTrough;
|
|
bool xZZDirection=!startsInTrough;
|
|
if(xVerticalZZ)
|
|
{
|
|
if(xFirstRun)
|
|
startsInTrough=!startsInTrough;
|
|
int zzDirection=ZigZagDirection(XIndex);
|
|
if(zzDirection==0) continue;
|
|
else if(zzDirection==-1) xZZDirection=false;
|
|
else if(zzDirection==1) xZZDirection=true;
|
|
}
|
|
double X=startsInTrough ? troughs[XIndex]: peaks[XIndex];
|
|
double extremeA=startsInTrough ? DBL_MIN : DBL_MAX;
|
|
//--- Skip first AIndex if vertical zz at X and opposite extremum is before X
|
|
int aSkip=0;
|
|
if(xVerticalZZ && ((xZZDirection && !startsInTrough) || (!xZZDirection && startsInTrough))) aSkip=1;
|
|
for(int AIndex=XIndex+aSkip; AIndex<=bar && !IsStopped(); AIndex++)
|
|
{
|
|
//--- Ensure that X is the extremum on [X, A], i.e. there is no lower low (higher high)
|
|
int extremeIndexXA=XIndex==AIndex ? AIndex : AIndex-1;
|
|
if((startsInTrough && IsProperValue(troughs[extremeIndexXA]) && troughs[extremeIndexXA]<X)
|
|
|| (!startsInTrough && IsProperValue(peaks[extremeIndexXA]) && peaks[extremeIndexXA]>X))
|
|
break;
|
|
if((XIndex!=AIndex && IsProperValue(troughs[AIndex]) && IsProperValue(peaks[AIndex]))
|
|
&& ((startsInTrough && ZigZagDirection(AIndex)==1 && troughs[AIndex]<X)
|
|
|| (!startsInTrough && ZigZagDirection(AIndex)==-1 && peaks[AIndex]>X)))
|
|
break;
|
|
//--- Only check increasing (decreasing) A's
|
|
double A=startsInTrough ? peaks[AIndex]: troughs[AIndex];
|
|
if(!IsProperValue(A) || (startsInTrough && A<extremeA) || (!startsInTrough && A>extremeA))
|
|
continue;
|
|
extremeA=A;
|
|
//--- For ratios
|
|
double XA=MathAbs(A-X);
|
|
if(XA==0)
|
|
continue;
|
|
//--- Find B index
|
|
double extremeB=startsInTrough ? DBL_MAX : DBL_MIN;
|
|
//--- Skip first BIndex if vertical zz at X and both X and A is on it
|
|
int bSkip=0;
|
|
if(XIndex==AIndex) bSkip=1;
|
|
for(int BIndex=AIndex+bSkip; BIndex<=bar && !IsStopped(); BIndex++)
|
|
{
|
|
//--- Ensure that A is the extremum on [A, B], i.e. there is no higher high (lower low)
|
|
int extremeIndexAB=AIndex==BIndex ? BIndex : BIndex-1;
|
|
if((!startsInTrough && IsProperValue(troughs[extremeIndexAB]) && troughs[extremeIndexAB]<A)
|
|
|| (startsInTrough && IsProperValue(peaks[extremeIndexAB]) && peaks[extremeIndexAB]>A))
|
|
break;
|
|
if((AIndex!=BIndex && IsProperValue(troughs[BIndex]) && IsProperValue(peaks[BIndex]))
|
|
&& ((!startsInTrough && ZigZagDirection(BIndex)==1 && troughs[BIndex]<A)
|
|
|| (startsInTrough && ZigZagDirection(BIndex)==-1 && peaks[BIndex]>A)))
|
|
break;
|
|
//--- Only check decreasing (increasing) B's
|
|
double B=startsInTrough ? troughs[BIndex]: peaks[BIndex];
|
|
if(!IsProperValue(B) || (startsInTrough && B>extremeB) || (!startsInTrough && B<extremeB))
|
|
continue;
|
|
extremeB=B;
|
|
//--- Second check for vertical ZZ at AB leg and B comes before A
|
|
if(AIndex==BIndex)
|
|
{
|
|
int zzDirection=ZigZagDirection(AIndex);
|
|
if(zzDirection==0) continue;
|
|
else if(zzDirection==-1 && !startsInTrough) continue;
|
|
else if(zzDirection==1 && startsInTrough) continue;
|
|
}
|
|
//--- Ratios
|
|
double AB=MathAbs(A-B);
|
|
if(AB==0)
|
|
continue;
|
|
double ab2xaRatio=AB/XA;
|
|
//--- Possible analytical continue: B does not extend far enough evidenced by 'ab2xaRatio' being too short
|
|
bool ab2xaContinue=ab2xaConstraint;
|
|
ab2xaContinue&=ab2xaRatio<pattern.ab2xa_min-ab2xaSlack;
|
|
if(ab2xaContinue)
|
|
continue;
|
|
//--- Possible analytical cutoff: B extends too far evidenced by 'ab2xaRatio' being too large
|
|
bool ab2xaCutoff=ab2xaConstraint;
|
|
ab2xaCutoff&=ab2xaRatio>pattern.ab2xa_max+ab2xaSlack;
|
|
if(ab2xaCutoff)
|
|
break;
|
|
//--- Find C
|
|
double extremeC=startsInTrough ? DBL_MIN : DBL_MAX;
|
|
//--- Skip first CIndex if vertical zz at B and both A and B is on it
|
|
int cSkip=0;
|
|
if(AIndex==BIndex) cSkip = 1;
|
|
for(int CIndex=BIndex+cSkip; CIndex<=bar && !IsStopped(); CIndex++)
|
|
{
|
|
//--- Ensure that B is the extremum on [B, C], i.e. there is no lower low (higher high)
|
|
int extremeIndexBC=BIndex==CIndex ? CIndex : CIndex-1;
|
|
if((startsInTrough && IsProperValue(troughs[extremeIndexBC]) && troughs[extremeIndexBC]<B)
|
|
|| (!startsInTrough && IsProperValue(peaks[extremeIndexBC]) && peaks[extremeIndexBC]>B))
|
|
break;
|
|
if((BIndex!=CIndex && IsProperValue(troughs[CIndex]) && IsProperValue(peaks[CIndex]))
|
|
&& ((startsInTrough && ZigZagDirection(CIndex)==1 && troughs[CIndex]<B)
|
|
|| (!startsInTrough && ZigZagDirection(CIndex)==-1 && peaks[CIndex]>B)))
|
|
break;
|
|
//--- Only check increasing (decreasing) C's
|
|
double C=startsInTrough ? peaks[CIndex]: troughs[CIndex];
|
|
if(!IsProperValue(C))
|
|
continue;
|
|
if((startsInTrough && C<extremeC) || (!startsInTrough && C>extremeC))
|
|
continue;
|
|
extremeC=C;
|
|
//--- Second check for vertical ZZ at BC leg and C comes before B
|
|
if(BIndex==CIndex)
|
|
{
|
|
int zzDirection=ZigZagDirection(BIndex);
|
|
if(zzDirection==0) continue;
|
|
else if(zzDirection==-1 && startsInTrough) continue;
|
|
else if(zzDirection==1 && !startsInTrough) continue;
|
|
}
|
|
//--- Ratios
|
|
double BC=MathAbs(C-B);
|
|
double XC=MathAbs(X-C);
|
|
if(BC==0) continue;
|
|
if(XC==0) continue;
|
|
double bc2abRatio=BC/AB;
|
|
double xc2xaRatio=XC/XA;
|
|
//--- Analytical continue: C not far enough by short 'bc2abRatio' or 'xc2xaRatio'
|
|
bool bc2abContinue=bc2abConstraint;
|
|
bool xc2xaContinue=xc2xaConstraint;
|
|
bc2abContinue&=bc2abRatio<pattern.bc2ab_min-bc2abSlack;
|
|
xc2xaContinue&=xc2xaRatio<pattern.xc2xa_min-xc2xaSlack;
|
|
if(bc2abContinue || xc2xaContinue)
|
|
continue;
|
|
//--- Analytical cutoff: C too far by long 'bc2abRatio' or 'xc2xaRatio'
|
|
bool bc2abCutoff=bc2abConstraint;
|
|
bool xc2xaCutoff=xc2xaConstraint;
|
|
bc2abCutoff&=bc2abRatio>pattern.bc2ab_max+bc2abSlack;
|
|
xc2xaCutoff&=xc2xaRatio>pattern.xc2xa_max+xc2xaSlack;
|
|
if(bc2abCutoff || xc2xaCutoff)
|
|
break;
|
|
//--- Check if C is the extreme until end-of-search, only then it should be used to project
|
|
bool lastExtremeC=true;
|
|
for(int i=CIndex+1; i<=bar; i++)
|
|
{
|
|
if((startsInTrough && IsProperValue(peaks[i]) && peaks[i]>C)
|
|
|| (!startsInTrough && IsProperValue(troughs[i]) && troughs[i]<C))
|
|
{
|
|
lastExtremeC=false;
|
|
break;
|
|
}
|
|
}
|
|
//--- Find D
|
|
double extremeD=startsInTrough ? DBL_MAX : DBL_MIN;
|
|
//--- Skip first DIndex if vertical zz at C and both B and C is on it
|
|
int dSkip=0;
|
|
if(BIndex==CIndex) dSkip = 1;
|
|
for(int DIndex=CIndex+dSkip; DIndex<=bar && !IsStopped(); DIndex++)
|
|
{
|
|
//--- Ensure that C is the extremum on [C, D], i.e. there is no higher high (lower low)
|
|
int extremeIndexCD=CIndex==DIndex ? DIndex : DIndex-1;
|
|
if((!startsInTrough && IsProperValue(troughs[extremeIndexCD]) && troughs[extremeIndexCD]<C)
|
|
|| (startsInTrough && IsProperValue(peaks[extremeIndexCD]) && peaks[extremeIndexCD]>C))
|
|
break;
|
|
if((CIndex!=DIndex && IsProperValue(troughs[DIndex]) && IsProperValue(peaks[DIndex]))
|
|
&& ((!startsInTrough && ZigZagDirection(DIndex)==1 && troughs[DIndex]<C)
|
|
|| (startsInTrough && ZigZagDirection(DIndex)==-1 && peaks[DIndex]>C)))
|
|
break;
|
|
//--- If CIndex is last, use imaginary D for projections
|
|
bool imaginaryD=((startsInTrough && CIndex==lastPeak && lastTrough<=lastPeak)
|
|
|| (!startsInTrough && CIndex==lastTrough && lastPeak<=lastTrough));
|
|
if(imaginaryD && lastPeak==lastTrough)
|
|
imaginaryD &=(startsInTrough && ZigZagDirection(lastPeak)==1)
|
|
|| (!startsInTrough && ZigZagDirection(lastPeak)==-1);
|
|
//--- Only check decreasing (increasing) D's
|
|
double D=startsInTrough ? troughs[DIndex]: peaks[DIndex];
|
|
if(!imaginaryD && (!IsProperValue(D) || (startsInTrough && D>extremeD) || (!startsInTrough && D<extremeD)))
|
|
continue;
|
|
extremeD=D;
|
|
//--- Second check for vertical ZZ at CD leg and D comes before C
|
|
if(!imaginaryD && CIndex==DIndex)
|
|
{
|
|
int zzDirection=ZigZagDirection(CIndex);
|
|
if(zzDirection==0) continue;
|
|
else if(zzDirection==-1 && !startsInTrough) continue;
|
|
else if(zzDirection==1 && startsInTrough) continue;
|
|
}
|
|
//--- Check if D is the extreme until end-of-search, only then it should be used to project
|
|
bool lastExtremeD=true;
|
|
if(!imaginaryD)
|
|
{
|
|
for(int i=DIndex+1; i<=bar; i++)
|
|
{
|
|
if((!startsInTrough && IsProperValue(peaks[i]) && peaks[i]>D)
|
|
|| (startsInTrough && IsProperValue(troughs[i]) && troughs[i]<D))
|
|
{
|
|
lastExtremeD=false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//--- Check if potential pattern is on active swing (rightmost on chart)
|
|
bool activeSwing=((endsInTrough && startsInTrough && DIndex==lastTrough) || (!endsInTrough && !startsInTrough && DIndex==lastPeak));
|
|
//--- Analytical solution to harmonic window
|
|
double nearD_cd2bc;
|
|
double nearD_ad2xa;
|
|
double nearD_cd2xc;
|
|
double nearD_cd2ab;
|
|
double farD_cd2bc;
|
|
double farD_ad2xa;
|
|
double farD_cd2xc;
|
|
double farD_cd2ab;
|
|
if(startsInTrough)
|
|
{
|
|
nearD_cd2bc=C-(pattern.cd2bc_min-cd2bcSlack)*BC;
|
|
nearD_ad2xa=A-(pattern.ad2xa_min-ad2xaSlack)*XA;
|
|
nearD_cd2xc=C-(pattern.cd2xc_min-cd2xcSlack)*XC;
|
|
nearD_cd2ab=C-(pattern.cd2ab_min-cd2abSlack)*AB;
|
|
farD_cd2bc=C-(pattern.cd2bc_max+cd2bcSlack)*BC;
|
|
farD_ad2xa=A-(pattern.ad2xa_max+ad2xaSlack)*XA;
|
|
farD_cd2xc=C-(pattern.cd2xc_max+cd2xcSlack)*XC;
|
|
farD_cd2ab=C-(pattern.cd2ab_max+cd2abSlack)*AB;
|
|
}
|
|
else
|
|
{
|
|
nearD_cd2bc=C+(pattern.cd2bc_min-cd2bcSlack)*BC;
|
|
nearD_ad2xa=A+(pattern.ad2xa_min-ad2xaSlack)*XA;
|
|
nearD_cd2xc=C+(pattern.cd2xc_min-cd2xcSlack)*XC;
|
|
nearD_cd2ab=C+(pattern.cd2ab_min-cd2abSlack)*AB;
|
|
farD_cd2bc=C+(pattern.cd2bc_max+cd2bcSlack)*BC;
|
|
farD_ad2xa=A+(pattern.ad2xa_max+ad2xaSlack)*XA;
|
|
farD_cd2xc=C+(pattern.cd2xc_max+cd2xcSlack)*XC;
|
|
farD_cd2ab=C+(pattern.cd2ab_max+cd2abSlack)*AB;
|
|
}
|
|
double nearD=startsInTrough ? DBL_MAX : DBL_MIN;
|
|
double farD=startsInTrough ? DBL_MIN : DBL_MAX;
|
|
if(cd2bcConstraint)
|
|
{
|
|
nearD=startsInTrough ? MathMin(nearD,nearD_cd2bc) : MathMax(nearD,nearD_cd2bc);
|
|
farD=startsInTrough ? MathMax(farD,farD_cd2bc) : MathMin(farD,farD_cd2bc);
|
|
}
|
|
if(ad2xaConstraint)
|
|
{
|
|
nearD=startsInTrough ? MathMin(nearD,nearD_ad2xa) : MathMax(nearD,nearD_ad2xa);
|
|
farD=startsInTrough ? MathMax(farD,farD_ad2xa) : MathMin(farD,farD_ad2xa);
|
|
}
|
|
if(cd2xcConstraint)
|
|
{
|
|
nearD=startsInTrough ? MathMin(nearD,nearD_cd2xc) : MathMax(nearD,nearD_cd2xc);
|
|
farD=startsInTrough ? MathMax(farD,farD_cd2xc) : MathMin(farD,farD_cd2xc);
|
|
}
|
|
if(cd2abConstraint)
|
|
{
|
|
nearD=startsInTrough ? MathMin(nearD,nearD_cd2ab) : MathMax(nearD,nearD_cd2ab);
|
|
farD=startsInTrough ? MathMax(farD,farD_cd2ab) : MathMin(farD,farD_cd2ab);
|
|
}
|
|
//--- Imaginary D only used when no further D's can exist
|
|
if(imaginaryD && !OneAheadProjection)
|
|
break;
|
|
//--- Continue/Pattern undershot
|
|
else if(imaginaryD || (startsInTrough && D>nearD) || (!startsInTrough && D<nearD))
|
|
{
|
|
//--- The XABC are such that no D can satisfy the pattern
|
|
if((startsInTrough && farD>nearD) || (!startsInTrough && farD<nearD))
|
|
break;
|
|
//--- In these two cases, a match or overshot pattern can occur later
|
|
if(!lastExtremeC || !lastExtremeD)
|
|
continue;
|
|
if(!EmergingPatterns)
|
|
break;
|
|
//--- 4-point
|
|
if(Is4PointPattern(patternIndex))
|
|
StoreProjection(patternIndex,startsInTrough,0,0,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[bar],nearD,farD);
|
|
//--- 5-point
|
|
else
|
|
StoreProjection(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[bar],nearD,farD);
|
|
break;
|
|
}
|
|
//--- Cutoff
|
|
else if((startsInTrough && D<farD) || (!startsInTrough && D>farD))
|
|
break;
|
|
//--- Match
|
|
else
|
|
{
|
|
//--- Invalidate if overlapping
|
|
if(Overlaps(patternIndex,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]))
|
|
continue;
|
|
//--- 4-point
|
|
if(Is4PointPattern(patternIndex))
|
|
{
|
|
DisplayPattern(patternIndex,startsInTrough,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[DIndex],D);
|
|
if(activeSwing)
|
|
{
|
|
StorePattern(patternIndex,startsInTrough,0,time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
|
|
if(Show_PRZ)
|
|
DisplayPRZ(patternIndex,startsInTrough,time[AIndex],A,time[BIndex],time[CIndex],C,time[DIndex],D,farD);
|
|
}
|
|
else
|
|
StoreOverlaps(patternIndex,0,time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
|
|
}
|
|
//--- 5-point
|
|
else
|
|
{
|
|
DisplayPattern(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],B,time[CIndex],C,time[DIndex],D);
|
|
if(activeSwing)
|
|
{
|
|
StorePattern(patternIndex,startsInTrough,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
|
|
if(Show_PRZ)
|
|
DisplayPRZ(patternIndex,startsInTrough,time[XIndex],X,time[AIndex],A,time[BIndex],time[CIndex],C,time[DIndex],D,farD);
|
|
}
|
|
else
|
|
StoreOverlaps(patternIndex,time[XIndex],time[AIndex],time[BIndex],time[CIndex],time[DIndex]);
|
|
}
|
|
}
|
|
} //--- End DIndex-loop
|
|
} //--- End CIndex-loop
|
|
} //--- End BIndex-loop
|
|
} //--- End AIndex-loop
|
|
//--- Run same XIndex twice if ZigZag is vertical
|
|
if(xVerticalZZ)
|
|
{
|
|
if(xFirstRun)
|
|
{
|
|
XIndex--;
|
|
xFirstRun=false;
|
|
}
|
|
else
|
|
xFirstRun=true;
|
|
}
|
|
} //--- End XIndex-loop
|
|
//--- Sort projections
|
|
for(int i=1; i<_projectionInstanceCounter; i++)
|
|
{
|
|
_projectionInstances[i].overlapping=false;
|
|
int j=i;
|
|
while(j>0 && _projectionInstances[j-1].D>_projectionInstances[j].D)
|
|
{
|
|
PATTERN_INSTANCE tmp=_projectionInstances[j];
|
|
_projectionInstances[j]=_projectionInstances[j-1];
|
|
_projectionInstances[j-1]=tmp;
|
|
j--;
|
|
}
|
|
}
|
|
_projectionInstances[0].overlapping=false;
|
|
//--- Display projections
|
|
bool forward=true;
|
|
int i=0;
|
|
while(_projectionInstanceCounter!=0)
|
|
{
|
|
bool bullish=_projectionInstances[i].bullish;
|
|
if((forward && !bullish) || (!forward && bullish))
|
|
{
|
|
datetime XDateTime=_projectionInstances[i].XDateTime;
|
|
datetime ADateTime=_projectionInstances[i].ADateTime;
|
|
datetime BDateTime=_projectionInstances[i].BDateTime;
|
|
datetime CDateTime=_projectionInstances[i].CDateTime;
|
|
datetime DDateTime=_projectionInstances[i].DDateTime;
|
|
double X=_projectionInstances[i].X;
|
|
double A=_projectionInstances[i].A;
|
|
double B=_projectionInstances[i].B;
|
|
double C=_projectionInstances[i].C;
|
|
double D=_projectionInstances[i].D;
|
|
double farD=_projectionInstances[i].PRZ;
|
|
//--- Invalidate projection if overlapping other patterns
|
|
if(Overlaps(patternIndex,XDateTime,ADateTime,BDateTime,CDateTime,NON_EXISTENT_DATETIME))
|
|
_projectionInstances[i].overlapping=true;
|
|
//--- Invalidate projection if overlapping other projections
|
|
int j=i;
|
|
while(true)
|
|
{
|
|
//--- Loop condition
|
|
if(forward)
|
|
{
|
|
if(j==0) break;
|
|
else j--;
|
|
}
|
|
else
|
|
{
|
|
if(j==_projectionInstanceCounter-1) break;
|
|
else j++;
|
|
}
|
|
//--- Overlap check
|
|
if(!_projectionInstances[j].overlapping && _projectionInstances[j].bullish==bullish)
|
|
{
|
|
datetime XDateTimeActive=_projectionInstances[j].XDateTime;
|
|
datetime ADateTimeActive=_projectionInstances[j].ADateTime;
|
|
datetime BDateTimeActive=_projectionInstances[j].BDateTime;
|
|
datetime CDateTimeActive=_projectionInstances[j].CDateTime;
|
|
datetime DDateTimeActive=_projectionInstances[j].DDateTime;
|
|
int numMatches=0;
|
|
if(!Is4PointPattern(patternIndex) && XDateTime==XDateTimeActive) numMatches++;
|
|
if(ADateTime==ADateTimeActive) numMatches++;
|
|
if(BDateTime==BDateTimeActive) numMatches++;
|
|
if(CDateTime==CDateTimeActive) numMatches++;
|
|
//if(DDateTime==DDateTimeActive) numMatches++;
|
|
if(numMatches>MaxSamePoints)
|
|
{
|
|
_projectionInstances[i].overlapping=true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//--- Display projection
|
|
if(!_projectionInstances[i].overlapping)
|
|
{
|
|
if(Is4PointPattern(patternIndex))
|
|
DisplayProjection(patternIndex,bullish,ADateTime,A,BDateTime,B,CDateTime,C,DDateTime,D);
|
|
else
|
|
DisplayProjection(patternIndex,bullish,XDateTime,X,ADateTime,A,BDateTime,B,CDateTime,C,DDateTime,D);
|
|
_drawnProjectionInstances[_drawnProjectionInstanceCounter]=_projectionInstances[i];
|
|
_drawnProjectionInstanceCounter++;
|
|
if(_drawnProjectionInstanceCounter>=_maxDrawnProjectionInstances)
|
|
{
|
|
_maxDrawnProjectionInstances*=2;
|
|
if(ArrayResize(_drawnProjectionInstances,_maxDrawnProjectionInstances)<_maxDrawnProjectionInstances)
|
|
printf("Error allocating array");
|
|
}
|
|
}
|
|
}
|
|
//--- Loop condition
|
|
if(forward)
|
|
{
|
|
if(i==_projectionInstanceCounter-1) forward=false;
|
|
else i++;
|
|
}
|
|
else
|
|
{
|
|
if(i==0) break;
|
|
else i--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--- return value of prev_calculated for next call
|
|
return(rates_total);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method determines 4 point patterns |
|
|
//+------------------------------------------------------------------+
|
|
bool Is4PointPattern(int patternIndex)
|
|
{
|
|
if(patternIndex == TRENDLIKE1_ABCD) return true;
|
|
if(patternIndex == TRENDLIKE2_ABCD) return true;
|
|
if(patternIndex == PERFECT_ABCD) return true;
|
|
if(patternIndex == IDEAL1_ABCD) return true;
|
|
if(patternIndex == IDEAL2_ABCD) return true;
|
|
if(patternIndex == RANGELIKE_ABCD) return true;
|
|
if(patternIndex == ALT127_TRENDLIKE1_ABCD) return true;
|
|
if(patternIndex == ALT127_TRENDLIKE2_ABCD) return true;
|
|
if(patternIndex == ALT127_PERFECT_ABCD) return true;
|
|
if(patternIndex == ALT127_IDEAL1_ABCD) return true;
|
|
if(patternIndex == ALT127_IDEAL2_ABCD) return true;
|
|
if(patternIndex == ALT127_RANGELIKE_ABCD) return true;
|
|
if(patternIndex == REC_TRENDLIKE1_ABCD) return true;
|
|
if(patternIndex == REC_TRENDLIKE2_ABCD) return true;
|
|
if(patternIndex == REC_PERFECT_ABCD) return true;
|
|
if(patternIndex == REC_IDEAL1_ABCD) return true;
|
|
if(patternIndex == REC_IDEAL2_ABCD) return true;
|
|
if(patternIndex == REC_RANGELIKE_ABCD) return true;
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method finds ZigZag direction in before index |
|
|
//+------------------------------------------------------------------+
|
|
int ZigZagDirection(int index)
|
|
{
|
|
int lastPeakBefore=FirstNonZeroFrom(index-1,peaks);
|
|
int lastTroughBefore=FirstNonZeroFrom(index-1,troughs);
|
|
while(lastPeakBefore==lastTroughBefore)
|
|
{
|
|
lastPeakBefore=FirstNonZeroFrom(lastPeakBefore-1,peaks);
|
|
lastTroughBefore=FirstNonZeroFrom(lastTroughBefore-1,troughs);
|
|
if(lastPeakBefore==-1 || lastTroughBefore==-1) return 0;
|
|
}
|
|
if(lastPeakBefore==-1 || lastTroughBefore==-1) return 0;
|
|
else if(lastPeakBefore<lastTroughBefore) return -1;
|
|
else return 1;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method finds first proper value from start |
|
|
//+------------------------------------------------------------------+
|
|
int FirstNonZeroFrom(int start,double &array[])
|
|
{
|
|
for(int j=start; j>=0; j--)
|
|
if(IsProperValue(array[j]))
|
|
return j;
|
|
return -1;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method determines proper value |
|
|
//+------------------------------------------------------------------+
|
|
bool IsProperValue(double value)
|
|
{
|
|
return (value!=0 && value!=EMPTY_VALUE);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Comment |
|
|
//+------------------------------------------------------------------+
|
|
void ShowComment(string sComment)
|
|
{
|
|
if(sComment!="")
|
|
{
|
|
com9=com8; //--- discards last comment line
|
|
com8=com7; //--- and shifts
|
|
com7=com6;
|
|
com6=com5;
|
|
com5=com4;
|
|
com4=com3;
|
|
com3=com2;
|
|
com2=com1;
|
|
com1=sComment;
|
|
}
|
|
Comment("HarmonicPatternFinderV2 © 2016","\n","\n",com1,"\n",com2,"\n",com3,"\n",com4,"\n",com5,"\n",com6,"\n",com7,"\n",com8,"\n",com9,"\n");
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method checks if pattern overlaps |
|
|
//+------------------------------------------------------------------+
|
|
bool Overlaps(int k,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
|
|
{
|
|
bool overlaps=false;
|
|
//--- Check old patterns in fixed size ring buffer
|
|
for(int i=0; i<SIZE_PATTERN_BUFFER; i++)
|
|
{
|
|
int numMatches=0;
|
|
if(!Is4PointPattern(k) && XDateTime==_patternX[k][i]) numMatches++;
|
|
if(ADateTime==_patternA[k][i]) numMatches++;
|
|
if(BDateTime==_patternB[k][i]) numMatches++;
|
|
if(CDateTime==_patternC[k][i]) numMatches++;
|
|
if(DDateTime==_patternD[k][i]) numMatches++;
|
|
if(numMatches>MaxSamePoints)
|
|
return true;
|
|
}
|
|
//--- Check active patterns in unlimited size array
|
|
for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int patternIndexActive=_patternInstances[i].patternIndex;
|
|
if(patternIndexActive!=k)
|
|
continue;
|
|
bool bullish=instance.bullish;
|
|
datetime XDateTimeActive=instance.XDateTime;
|
|
datetime ADateTimeActive=instance.ADateTime;
|
|
datetime BDateTimeActive=instance.BDateTime;
|
|
datetime CDateTimeActive=instance.CDateTime;
|
|
datetime DDateTimeActive=instance.DDateTime;
|
|
int numMatches=0;
|
|
if(!Is4PointPattern(k) && XDateTime==XDateTimeActive) numMatches++;
|
|
if(ADateTime==ADateTimeActive) numMatches++;
|
|
if(BDateTime==BDateTimeActive) numMatches++;
|
|
if(CDateTime==CDateTimeActive) numMatches++;
|
|
if(DDateTime==DDateTimeActive) numMatches++;
|
|
if(numMatches>MaxSamePoints)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method stores if pattern overlaps |
|
|
//+------------------------------------------------------------------+
|
|
void StoreOverlaps(int k,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
|
|
{
|
|
int index=_patternCounter[k];
|
|
_patternCounter[k]=(index+1)%SIZE_PATTERN_BUFFER;
|
|
_patternX[k][index]=XDateTime;
|
|
_patternA[k][index]=ADateTime;
|
|
_patternB[k][index]=BDateTime;
|
|
_patternC[k][index]=CDateTime;
|
|
_patternD[k][index]=DDateTime;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method stores patterns |
|
|
//+------------------------------------------------------------------+
|
|
void StorePattern(int k,bool bullish,datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
|
|
{
|
|
_patternInstances[_patternInstanceCounter].patternIndex=k;
|
|
_patternInstances[_patternInstanceCounter].bullish=bullish;
|
|
_patternInstances[_patternInstanceCounter].XDateTime=XDateTime;
|
|
_patternInstances[_patternInstanceCounter].ADateTime=ADateTime;
|
|
_patternInstances[_patternInstanceCounter].BDateTime=BDateTime;
|
|
_patternInstances[_patternInstanceCounter].CDateTime=CDateTime;
|
|
_patternInstances[_patternInstanceCounter].DDateTime=DDateTime;
|
|
_patternInstanceCounter++;
|
|
if(_patternInstanceCounter>=_maxPatternInstances)
|
|
{
|
|
_maxPatternInstances*=2;
|
|
if(ArrayResize(_patternInstances,_maxPatternInstances)<_maxPatternInstances)
|
|
printf("Error allocating array");
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method stores projections |
|
|
//+------------------------------------------------------------------+
|
|
void StoreProjection(int k,bool bullish,
|
|
datetime XDateTime,double X,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,double B,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D,
|
|
double farD)
|
|
{
|
|
_projectionInstances[_projectionInstanceCounter].patternIndex=k;
|
|
_projectionInstances[_projectionInstanceCounter].bullish=bullish;
|
|
_projectionInstances[_projectionInstanceCounter].XDateTime=XDateTime;
|
|
_projectionInstances[_projectionInstanceCounter].ADateTime=ADateTime;
|
|
_projectionInstances[_projectionInstanceCounter].BDateTime=BDateTime;
|
|
_projectionInstances[_projectionInstanceCounter].CDateTime=CDateTime;
|
|
_projectionInstances[_projectionInstanceCounter].DDateTime=DDateTime;
|
|
_projectionInstances[_projectionInstanceCounter].X=X;
|
|
_projectionInstances[_projectionInstanceCounter].A=A;
|
|
_projectionInstances[_projectionInstanceCounter].B=B;
|
|
_projectionInstances[_projectionInstanceCounter].C=C;
|
|
_projectionInstances[_projectionInstanceCounter].D=D;
|
|
_projectionInstances[_projectionInstanceCounter].PRZ=farD;
|
|
_projectionInstanceCounter++;
|
|
if(_projectionInstanceCounter>=_maxProjectionInstances)
|
|
{
|
|
_maxProjectionInstances*=2;
|
|
if(ArrayResize(_projectionInstances,_maxProjectionInstances)<_maxProjectionInstances)
|
|
printf("Error allocating array");
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 4-point PRZ |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayPRZ(int k,bool bullish,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D,
|
|
double farD)
|
|
{
|
|
string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Bullish " : "Bearish ");
|
|
string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string name=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
|
|
ObjectCreate(0,name,OBJ_TREND,0,DDateTime-1,farD,DDateTime,farD);
|
|
ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,true);
|
|
ObjectSetInteger(0,name,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetInteger(0,name,OBJPROP_STYLE,Style_PRZ);
|
|
ObjectSetString(0,name,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PRZ stop "+DoubleToString(farD));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 5-point PRZ |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayPRZ(int k,bool bullish,
|
|
datetime XDateTime,double X,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D,
|
|
double farD)
|
|
{
|
|
string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Bullish " : "Bearish ");
|
|
string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string name=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
|
|
ObjectCreate(0,name,OBJ_TREND,0,DDateTime-1,farD,DDateTime,farD);
|
|
ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,true);
|
|
ObjectSetInteger(0,name,OBJPROP_COLOR,bullish ? ClrBull: ClrBear);
|
|
ObjectSetInteger(0,name,OBJPROP_STYLE,Style_PRZ);
|
|
ObjectSetString(0,name,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PRZ stop "+DoubleToString(farD));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 4-point patterns |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayPattern(int k,bool bullish,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,double B,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D)
|
|
{
|
|
string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Bullish " : "Bearish ");
|
|
string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
//--- Create lines on the chart
|
|
ObjectCreate(0,name0,OBJ_TREND,0,ADateTime,A,BDateTime,B);
|
|
ObjectCreate(0,name1,OBJ_TREND,0,BDateTime,B,CDateTime,C);
|
|
ObjectCreate(0,name2,OBJ_ARROWED_LINE,0,CDateTime,C,DDateTime,D);
|
|
ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width4p);
|
|
ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width4p);
|
|
ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width4p);
|
|
ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_4P);
|
|
ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_4P);
|
|
ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_4P);
|
|
ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
|
|
ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
|
|
ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
|
|
if(Show_descriptions)
|
|
{
|
|
int numOverlapping=0;
|
|
for(int i=0; i<NUM_PATTERNS; i++)
|
|
{
|
|
for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
|
|
{
|
|
if(ADateTime==_patternX[i][j]) numOverlapping++;
|
|
if(Is4PointPattern(i) && ADateTime==_patternA[i][j]) numOverlapping++;
|
|
}
|
|
}
|
|
for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int patternIndexActive=_patternInstances[i].patternIndex;
|
|
datetime XDateTimeActive=instance.XDateTime;
|
|
datetime ADateTimeActive=instance.ADateTime;
|
|
if(ADateTime==XDateTimeActive) numOverlapping++;
|
|
if(Is4PointPattern(patternIndexActive) && ADateTime==ADateTimeActive) numOverlapping++;
|
|
}
|
|
int x1=0;
|
|
int y1=0;
|
|
int x2=0;
|
|
int y2=0;
|
|
ChartTimePriceToXY(0,0,ADateTime,A,x1,y1);
|
|
ChartTimePriceToXY(0,0,ADateTime,A+1,x2,y2);
|
|
double pixelsPerPrice=MathAbs(y1-y2);
|
|
double change=pixelsPerPrice!=0 ? numOverlapping*(Font_size)/pixelsPerPrice : 0;
|
|
double price=(bullish ? A+change : A-change);
|
|
ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,price);
|
|
ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
|
|
ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
|
|
ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
|
|
ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
|
|
ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
|
|
ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
|
|
ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
|
|
ObjectSetString(0,pointA,OBJPROP_TEXT,"A "+prefix+_patternNames[k]);
|
|
ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,08);
|
|
ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
|
|
ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,08);
|
|
ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
|
|
ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,08);
|
|
ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
|
|
ObjectSetString(0,pointD,OBJPROP_TEXT,"D");
|
|
ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,08);
|
|
ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBull4P : ClrBear4P);
|
|
}
|
|
if(showPatternNames)
|
|
ShowComment(prefix+_patternNames[k]+" @ "+TimeToString(DDateTime));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 5-point patterns |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayPattern(int k,bool bullish,
|
|
datetime XDateTime,double X,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,double B,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D)
|
|
{
|
|
string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Bullish " : "Bearish ");
|
|
string prefixName=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
|
|
string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name3=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string name4=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
|
|
string name5=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
|
|
string name6=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
|
|
string name7=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
|
|
string triangle_XB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XB"+unique;
|
|
string triangle_BD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BD"+unique;
|
|
string pointX=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
|
|
string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
string xab=IntegerToString((int) MathRound(100*MathAbs(A-B)/MathAbs(X-A)));
|
|
string xad=IntegerToString((int) MathRound(100*MathAbs(D-A)/MathAbs(X-A)));
|
|
string abc=IntegerToString((int) MathRound(100*MathAbs(C-B)/MathAbs(B-A)));
|
|
if(k==CYPHER || k==NENSTAR || k==NEWCYPHER)
|
|
abc=IntegerToString((int) MathRound(100*MathAbs(X-C)/MathAbs(X-A)));
|
|
string bcd=IntegerToString((int) MathRound(100*MathAbs(C-D)/MathAbs(B-C)));
|
|
ObjectCreate(0,name0,OBJ_TREND,0,XDateTime,X,ADateTime,A);
|
|
ObjectCreate(0,name1,OBJ_TREND,0,ADateTime,A,BDateTime,B);
|
|
ObjectCreate(0,name2,OBJ_TREND,0,BDateTime,B,CDateTime,C);
|
|
ObjectCreate(0,name3,(!Fill_Patterns || (k==THREEDRIVES) || (k==FIVEO)) ? OBJ_ARROWED_LINE : OBJ_TREND,0,CDateTime,C,DDateTime,D); //Arrowed lines if not triangles
|
|
ObjectCreate(0,name4,OBJ_TREND,0,XDateTime,X,BDateTime,B);
|
|
//--- Point labels
|
|
if(Show_descriptions)
|
|
{
|
|
int numOverlapping=0;
|
|
for(int i=0; i<NUM_PATTERNS; i++)
|
|
{
|
|
for(int j=0; j<SIZE_PATTERN_BUFFER; j++)
|
|
{
|
|
if(XDateTime==_patternX[i][j]) numOverlapping++;
|
|
if(Is4PointPattern(i) && XDateTime==_patternA[i][j]) numOverlapping++;
|
|
}
|
|
}
|
|
for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int patternIndexActive=_patternInstances[i].patternIndex;
|
|
datetime XDateTimeActive=instance.XDateTime;
|
|
datetime ADateTimeActive=instance.ADateTime;
|
|
if(XDateTime==XDateTimeActive) numOverlapping++;
|
|
if(Is4PointPattern(patternIndexActive) && XDateTime==ADateTimeActive) numOverlapping++;
|
|
}
|
|
int x1=0;
|
|
int y1=0;
|
|
int x2=0;
|
|
int y2=0;
|
|
ChartTimePriceToXY(0,0,XDateTime,X,x1,y1);
|
|
ChartTimePriceToXY(0,0,XDateTime,X+1,x2,y2);
|
|
double pixelsPerPrice=MathAbs(y1-y2);
|
|
double change=pixelsPerPrice!=0 ? numOverlapping*(Font_size)/pixelsPerPrice : 0;
|
|
double price=(bullish ? X-change : X+change);
|
|
ObjectCreate(0,pointX,OBJ_TEXT,0,XDateTime,price);
|
|
ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
|
|
ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
|
|
ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
|
|
ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
|
|
ObjectSetString(0,pointX,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PX");
|
|
ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
|
|
ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
|
|
ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
|
|
ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
|
|
ObjectSetString(0,pointX,OBJPROP_TEXT,"X "+prefix+_patternNames[k]);
|
|
ObjectSetString(0,pointX,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointX,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointX,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
|
|
ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
|
|
ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
|
|
ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetString(0,pointD,OBJPROP_TEXT,"D");
|
|
ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
}
|
|
//--- No X-D for 5-0
|
|
if(k!=FIVEO) ObjectCreate(0,name5,OBJ_TREND,0,XDateTime,X,DDateTime,D);
|
|
ObjectCreate(0,name6,OBJ_TREND,0,ADateTime,A,CDateTime,C);
|
|
ObjectCreate(0,name7,OBJ_TREND,0,BDateTime,B,DDateTime,D);
|
|
ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,name3,OBJPROP_COLOR, bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_5P);
|
|
ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_5P);
|
|
ObjectSetInteger(0,name3,OBJPROP_STYLE,Style_5P);
|
|
ObjectSetInteger(0,name4,OBJPROP_COLOR,ClrRatio);
|
|
if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name6,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name7,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name4,OBJPROP_STYLE,Style_Ratio);
|
|
if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name6,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name7,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name3,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name4,OBJPROP_SELECTABLE,true);
|
|
if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name6,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name7,OBJPROP_SELECTABLE,true);
|
|
ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XA");
|
|
ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
|
|
ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
|
|
ObjectSetString(0,name3,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
|
|
ObjectSetString(0,name4,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAB="+xab);
|
|
if(k!=FIVEO) ObjectSetString(0,name5,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAD="+xad);
|
|
ObjectSetString(0,name6,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" ABC="+abc);
|
|
ObjectSetString(0,name7,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BCD="+bcd);
|
|
ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width);
|
|
ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width);
|
|
ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width);
|
|
ObjectSetInteger(0,name3,OBJPROP_WIDTH,l_width);
|
|
if(Fill_Patterns && (k!=FIVEO && k!=THREEDRIVES))
|
|
{
|
|
ObjectCreate(0,triangle_XB,OBJ_TRIANGLE,0,XDateTime,X,ADateTime,A,BDateTime,B);
|
|
ObjectCreate(0,triangle_BD,OBJ_TRIANGLE,0,BDateTime,B,CDateTime,C,DDateTime,D);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_STYLE,STYLE_SOLID);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_FILL,true);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_BACK,true);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,triangle_XB,OBJPROP_SELECTED,false);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_COLOR,bullish ? ClrBull : ClrBear);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_STYLE,STYLE_SOLID);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_FILL,true);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_BACK,true);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,triangle_BD,OBJPROP_SELECTED,false);
|
|
}
|
|
if(showPatternNames)
|
|
ShowComment(prefix+_patternNames[k]+" @ "+TimeToString(DDateTime));
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 4-point projections |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayProjection(int k,bool bullish,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,double B,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D)
|
|
{
|
|
string unique=UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Projected Bullish " : "Projected Bearish ");
|
|
string prefixName=(bullish ? "PU "+_identifier : "PD "+_identifier);
|
|
string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
ObjectCreate(0,name0,OBJ_TREND,0,ADateTime,A,BDateTime,B);
|
|
ObjectCreate(0,name1,OBJ_TREND,0,BDateTime,B,CDateTime,C);
|
|
ObjectCreate(0,name2,OBJ_TREND,0,CDateTime,C,DDateTime,D);
|
|
ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
|
|
ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
|
|
ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
|
|
ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
|
|
ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_Proj);
|
|
if(Show_descriptions)
|
|
{
|
|
ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
|
|
ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
|
|
ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
|
|
ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
|
|
ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
|
|
ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
|
|
ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
|
|
ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
|
|
ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
|
|
ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
|
|
ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
|
|
ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointD,OBJPROP_TEXT," D "+prefix+_patternNames[k]);
|
|
ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method displays 5-point projections |
|
|
//+------------------------------------------------------------------+
|
|
void DisplayProjection(int k,bool bullish,
|
|
datetime XDateTime,double X,
|
|
datetime ADateTime,double A,
|
|
datetime BDateTime,double B,
|
|
datetime CDateTime,double C,
|
|
datetime DDateTime,double D)
|
|
{
|
|
string unique=UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "Projected Bullish " : "Projected Bearish ");
|
|
string prefixName=(bullish ? "PU "+_identifier : "PD "+_identifier);
|
|
string name0=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
|
|
string name1=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name2=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name3=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string name4=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
|
|
string name5=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
|
|
string name6=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
|
|
string name7=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
|
|
string pointX=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
|
|
string pointA=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefixName+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
string xab=IntegerToString((int) MathRound(100*MathAbs(A-B)/MathAbs(X-A)));
|
|
string xad=IntegerToString((int) MathRound(100*MathAbs(D-A)/MathAbs(X-A)));
|
|
string abc=IntegerToString((int) MathRound(100*MathAbs(C-B)/MathAbs(B-A)));
|
|
//--- Cypher and Nen Start have the A-C top as XC/XA instead of CB/BA
|
|
if(k==CYPHER || k==NENSTAR || k==NEWCYPHER)
|
|
abc=IntegerToString((int) MathRound(100*MathAbs(X-C)/MathAbs(X-A)));
|
|
string bcd=IntegerToString((int) MathRound(100*MathAbs(C-D)/MathAbs(B-C)));
|
|
ObjectCreate(0,name0,OBJ_TREND,0,XDateTime,X,ADateTime,A);
|
|
ObjectCreate(0,name1,OBJ_TREND,0,ADateTime,A,BDateTime,B);
|
|
ObjectCreate(0,name2,OBJ_TREND,0,BDateTime,B,CDateTime,C);
|
|
ObjectCreate(0,name3,OBJ_TREND,0,CDateTime,C,DDateTime,D);
|
|
ObjectCreate(0,name4,OBJ_TREND,0,XDateTime,X,BDateTime,B);
|
|
if(k!=FIVEO) ObjectCreate(0,name5,OBJ_TREND,0,XDateTime,X,DDateTime,D);
|
|
ObjectCreate(0,name6,OBJ_TREND,0,ADateTime,A,CDateTime,C);
|
|
ObjectCreate(0,name7,OBJ_TREND,0,BDateTime,B,DDateTime,D);
|
|
ObjectSetInteger(0,name0,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name1,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name2,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name3,OBJPROP_COLOR, bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetInteger(0,name4,OBJPROP_COLOR,ClrRatio);
|
|
if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name6,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name7,OBJPROP_COLOR,ClrRatio);
|
|
ObjectSetInteger(0,name0,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name1,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name2,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name3,OBJPROP_STYLE,Style_Proj);
|
|
ObjectSetInteger(0,name4,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name5,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name6,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name7,OBJPROP_STYLE,Style_Ratio);
|
|
ObjectSetInteger(0,name0,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name1,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name2,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name3,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name4,OBJPROP_SELECTABLE,true);
|
|
if(k!=FIVEO) ObjectSetInteger(0,name5,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name6,OBJPROP_SELECTABLE,true);
|
|
ObjectSetInteger(0,name7,OBJPROP_SELECTABLE,true);
|
|
ObjectSetString(0,name0,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XA");
|
|
ObjectSetString(0,name1,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" AB");
|
|
ObjectSetString(0,name2,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BC");
|
|
ObjectSetString(0,name3,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" CD");
|
|
ObjectSetString(0,name4,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAB="+xab);
|
|
if(k!=FIVEO) ObjectSetString(0,name5,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" XAD="+xad);
|
|
ObjectSetString(0,name6,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" ABC="+abc);
|
|
ObjectSetString(0,name7,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" BCD="+bcd);
|
|
if(Show_descriptions)
|
|
{
|
|
ObjectCreate(0,pointX,OBJ_TEXT,0,XDateTime,X);
|
|
ObjectCreate(0,pointA,OBJ_TEXT,0,ADateTime,A);
|
|
ObjectCreate(0,pointB,OBJ_TEXT,0,BDateTime,B);
|
|
ObjectCreate(0,pointC,OBJ_TEXT,0,CDateTime,C);
|
|
ObjectCreate(0,pointD,OBJ_TEXT,0,DDateTime,D);
|
|
ObjectSetString(0,pointX,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PX");
|
|
ObjectSetString(0,pointA,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PA");
|
|
ObjectSetString(0,pointB,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PB");
|
|
ObjectSetString(0,pointC,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PC");
|
|
ObjectSetString(0,pointD,OBJPROP_TOOLTIP,prefix+_patternNames[k]+" PD");
|
|
ObjectSetInteger(0,name0,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name1,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name2,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetInteger(0,name3,OBJPROP_WIDTH,l_width_proj);
|
|
ObjectSetString(0,pointX,OBJPROP_TEXT,"X");
|
|
ObjectSetString(0,pointX,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointX,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointX,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointA,OBJPROP_TEXT,"A");
|
|
ObjectSetString(0,pointA,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointA,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointA,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointB,OBJPROP_TEXT,"B");
|
|
ObjectSetString(0,pointB,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointB,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointB,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointC,OBJPROP_TEXT,"C");
|
|
ObjectSetString(0,pointC,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointC,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointC,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
ObjectSetString(0,pointD,OBJPROP_TEXT," D "+prefix+_patternNames[k]);
|
|
ObjectSetString(0,pointD,OBJPROP_FONT,"Arial");
|
|
ObjectSetInteger(0,pointD,OBJPROP_FONTSIZE,Font_size);
|
|
ObjectSetInteger(0,pointD,OBJPROP_COLOR,bullish ? ClrBullProjection : ClrBearProjection);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method undisplays projections |
|
|
//+------------------------------------------------------------------+
|
|
void UndisplayProjections()
|
|
{
|
|
for(int i=0; i<_drawnProjectionInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_drawnProjectionInstances[i];
|
|
int k=instance.patternIndex;
|
|
bool bullish=instance.bullish;
|
|
datetime XDateTime=instance.XDateTime;
|
|
datetime ADateTime=instance.ADateTime;
|
|
datetime BDateTime=instance.BDateTime;
|
|
datetime CDateTime=instance.CDateTime;
|
|
datetime DDateTime=instance.DDateTime;
|
|
//--- Delete pattern from chart
|
|
string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "PU "+_identifier : "PD "+_identifier);
|
|
string name0=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
|
|
string name1=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name2=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name3=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string name4=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
|
|
string name5=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
|
|
string name6=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
|
|
string name7=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
|
|
string pointX=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
|
|
string pointA=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
ObjectDelete(0,name0);
|
|
ObjectDelete(0,name1);
|
|
ObjectDelete(0,name2);
|
|
ObjectDelete(0,name3);
|
|
ObjectDelete(0,name4);
|
|
ObjectDelete(0,name5);
|
|
ObjectDelete(0,name6);
|
|
ObjectDelete(0,name7);
|
|
ObjectDelete(0,pointX);
|
|
ObjectDelete(0,pointA);
|
|
ObjectDelete(0,pointB);
|
|
ObjectDelete(0,pointC);
|
|
ObjectDelete(0,pointD);
|
|
}
|
|
_drawnProjectionInstanceCounter=0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method undisplays recently drawn patterns |
|
|
//+------------------------------------------------------------------+
|
|
void UndisplayPatterns()
|
|
{
|
|
for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int k=instance.patternIndex;
|
|
bool bullish=instance.bullish;
|
|
datetime XDateTime=instance.XDateTime;
|
|
datetime ADateTime=instance.ADateTime;
|
|
datetime BDateTime=instance.BDateTime;
|
|
datetime CDateTime=instance.CDateTime;
|
|
datetime DDateTime=instance.DDateTime;
|
|
//--- Delete pattern from chart
|
|
string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string name0=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XA"+unique;
|
|
string name1=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" AB"+unique;
|
|
string name2=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BC"+unique;
|
|
string name3=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" CD"+unique;
|
|
string name4=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAB"+unique;
|
|
string name5=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XAD"+unique;
|
|
string name6=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" ABC"+unique;
|
|
string name7=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BCD"+unique;
|
|
string triangle_XB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" XB"+unique;
|
|
string triangle_BD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" BD"+unique;
|
|
string pointX=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PX"+unique;
|
|
string pointA=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PA"+unique;
|
|
string pointB=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PB"+unique;
|
|
string pointC=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PC"+unique;
|
|
string pointD=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PD"+unique;
|
|
ObjectDelete(0,name0);
|
|
ObjectDelete(0,name1);
|
|
ObjectDelete(0,name2);
|
|
ObjectDelete(0,name3);
|
|
ObjectDelete(0,name4);
|
|
ObjectDelete(0,name5);
|
|
ObjectDelete(0,name6);
|
|
ObjectDelete(0,name7);
|
|
ObjectDelete(0,triangle_XB);
|
|
ObjectDelete(0,triangle_BD);
|
|
ObjectDelete(0,pointX);
|
|
ObjectDelete(0,pointA);
|
|
ObjectDelete(0,pointB);
|
|
ObjectDelete(0,pointC);
|
|
ObjectDelete(0,pointD);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method undisplays recently drawn PRZ |
|
|
//+------------------------------------------------------------------+
|
|
void UndisplayPRZs()
|
|
{
|
|
for(int i=0; i<_patternInstanceCounter; i++)
|
|
{
|
|
PATTERN_INSTANCE instance=_patternInstances[i];
|
|
int k=instance.patternIndex;
|
|
bool bullish=instance.bullish;
|
|
datetime XDateTime=instance.XDateTime;
|
|
datetime ADateTime=instance.ADateTime;
|
|
datetime BDateTime=instance.BDateTime;
|
|
datetime CDateTime=instance.CDateTime;
|
|
datetime DDateTime=instance.DDateTime;
|
|
//--- Delete pattern from chart
|
|
string unique=Is4PointPattern(k)?UniqueIdentifier(ADateTime,BDateTime,CDateTime,DDateTime) : UniqueIdentifier(XDateTime,ADateTime,BDateTime,CDateTime,DDateTime);
|
|
string prefix=(bullish ? "U "+_identifier : "D "+_identifier);
|
|
string linePRZ=prefix+StringFormat("%x",_timeOfInit)+IntegerToString(k)+" PRZ"+unique;
|
|
ObjectDelete(0,linePRZ);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method populates pattern arrays |
|
|
//+------------------------------------------------------------------+
|
|
int PopulatePatterns()
|
|
{
|
|
//--- Create pattern descriptor structs with relevant ratios
|
|
PATTERN_DESCRIPTOR trendlike1_abcd= {0,0,0.382,0.382,2.618,2.618,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR trendlike2_abcd= {0,0,0.5,0.5,2.0,2.0,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR perfect_abcd= {0,0,0.618,0.618,1.618,1.618,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR ideal1_abcd= {0,0,0.707,0.707,1.41,1.41,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR ideal2_abcd= {0,0,0.786,0.786,1.27,1.27,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rangelike_abcd= {0,0,0.886,0.886,1.13,1.13,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR alt127_trendlike1_abcd= {0,0,0.382,0.382,2.618,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR alt127_trendlike2_abcd= {0,0,0.5,0.5,2.0,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR alt127_perfect_abcd= {0,0,0.618,0.618,1.618,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR alt127_ideal1_abcd= {0,0,0.707,0.707,1.41,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR alt127_ideal2_abcd= {0,0,0.786,0.786,1.27,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR alt127_rangelike_abcd= {0,0,0.886,0.886,1.13,3.618,0,0,0,0,0,0,1.272,1.272};
|
|
PATTERN_DESCRIPTOR rec_trendlike1_abcd= {0,0,2.618,2.618,0.382,0.382,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rec_trendlike2_abcd= {0,0,2.0,2.0,0.5,0.5,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rec_perfect_abcd= {0,0,1.618,1.618,0.618,0.618,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rec_ideal1_abcd= {0,0,1.41,1.41,0.707,0.707,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rec_ideal2_abcd= {0,0,1.27,1.27,0.786,0.786,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR rec_rangelike_abcd= {0,0,1.13,1.13,0.886,0.886,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR gartley= {0.618,0.618,0.382,0.886,1.272,1.618,0.786,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR bat= {0.382,0.5,0.382,0.886,1.618,2.618,0.886,0.886,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR altbat= {0.382,0.382,0.382,0.886,2.0,3.618,1.13,1.13,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR fiveo= {1.13,1.618,1.618,2.24,0.5,0.5,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR butterfly= {0.786,0.786,0.382,0.886,1.618,2.618,1.272,1.618,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR crab= {0.382,0.618,0.382,0.886,2.24,3.618,1.618,1.618,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR deepcrab= {0.886,0.886,0.382,0.886,2.0,3.618,1.618,1.618,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR threedrives= {1.272,1.618,0.618,0.786,1.272,1.618,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR shark= {0,0,1.13,1.618,1.618,2.24,0,0,0.886,1.13,0,0,0,0};
|
|
PATTERN_DESCRIPTOR cypher= {0.382,0.618,0,0,0,0,0,0,0.786,0.786,1.13,1.414,0,0};
|
|
PATTERN_DESCRIPTOR nenstar= {0.382,0.618,0,0,0,0,0,0,1.272,1.272,1.13,1.414,0,0};
|
|
PATTERN_DESCRIPTOR blackswan= {1.382,2.618,0.236,0.5,1.128,2,1.128,2.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR whiteswan= {0.382,0.724,2,4.237,0.5,0.886,0.382,0.886,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR one2one= {0.5,0.786,1.128,3.618,0.382,0.786,0.382,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR newcypher= {0.382,0.618,0,0,0,0,0,0,0.786,0.786,1.414,2.14,0,0};
|
|
PATTERN_DESCRIPTOR navarro200= {0.382,0.786,0.886,1.128,0.886,3.618,0.886,1.128,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR leonardo= {0.5,0.5,0.382,0.886,1.128,2.618,0.786,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR kane= {0.685,0.685,0.382,0.886,0,0,1.460,1.460,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR garfly= {0.618,0.618,0.382,0.886,1.618,2.24,1.272,1.272,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR maxbat= {0.382,0.618,0.382,0.886,1.272,2.618,0.886,0.886,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR maxgartley= {0.382,0.618,0.382,0.886,1.128,2.236,0.618,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR maxbutterfly= {0.618,0.886,0.382,0.886,1.272,2.618,1.272,1.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR gartley113= {0.618,0.618,0.382,0.886,1.13,1.13,0.786,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR butterfly113= {0.786,1,0.618,1,1.128,1.618,1.128,1.128,0,0,0,0,0,0 };
|
|
PATTERN_DESCRIPTOR anti_gartley= {0.618,0.786,1.129,2.618,1.618,1.618,1.272,1.272,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_bat= {0.382,0.618,1.129,2.618,2.000,2.618,1.129,1.129,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_altbat= {0.276,0.500,1.129,2.618,2.618,2.618,0.885,0.885,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_fiveo= {2.000,2.000,0.446,0.618,0.618,0.885,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_butterfly= {0.382,0.618,1.129,2.618,1.272,1.272,0.618,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_crab= {0.276,0.446,1.129,2.618,1.618,2.618,0.618,0.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_deepcrab= {0.276,0.500,1.129,2.618,1.129,1.129,0.618,0.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_threedrives= {0.618,0.786,1.272,1.618,0.618,0.786,0,0,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_shark= {0.446,0.618,0.618,0.885,0,0,0,0,0.885,1.129,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_cypher= {0,0,0,0,1.618,2.618,0,0,1.272,1.272,0.707,0.885,0,0};
|
|
PATTERN_DESCRIPTOR anti_nenstar= {0,0,0,0,1.618,2.618,0,0,0.786,0.786,0.707,0.885,0,0};
|
|
PATTERN_DESCRIPTOR anti_blackswan= {0.500,0.887,2.000,4.237,0.382,0.724,0.382,0.887,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_whiteswan= {1.129,2.000,0.236,0.500,1.381,2.618,1.129,2.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_one2one= {1.272,2.618,0.276,0.887,1.272,2.000,1.272,2.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_newcypher= {0,0,0,0,1.618,2.618,0,0,1.272,1.272,0.467,0.707,0,0};
|
|
PATTERN_DESCRIPTOR anti_navarro200= {0.276,1.129,0.887,1.129,1.272,2.618,0.887,1.129,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_leonardo= {0.382,0.887,1.129,2.618,2.000,2.000,1.272,1.272,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_kane= {0,0,1.129,2.618,1.460,1.460,0.685,0.685,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_garfly= {0.446,0.618,1.129,2.618,1.618,1.618,0.786,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_maxbat= {0.382,0.786,1.129,2.618,1.618,2.618,1.129,1.129,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_maxgartley= {0.447,0.887,1.129,2.618,1.618,2.618,1.272,1.618,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_maxbutterfly= {0.382,0.786,1.129,2.618,1.129,1.618,0.618,0.786,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_gartley113= {0.885,0.885,1.129,2.618,1.618,1.618,1.272,1.272,0,0,0,0,0,0};
|
|
PATTERN_DESCRIPTOR anti_butterfly113= {0.618,0.887,1.000,1.618,1.000,1.272,0.887,0.887,0,0,0,0,0,0};
|
|
|
|
//--- Initialize arrays
|
|
_maxProjectionInstances=4;
|
|
_maxPatternInstances=NUM_PATTERNS*SIZE_PATTERN_BUFFER;
|
|
_maxDrawnProjectionInstances=4;
|
|
if(ArrayResize(_patterns,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternNames,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternX,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternA,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternB,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternC,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternD,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternCounter,NUM_PATTERNS)<NUM_PATTERNS)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_patternInstances,_maxPatternInstances)<_maxPatternInstances)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_projectionInstances,_maxProjectionInstances)<_maxProjectionInstances)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
if(ArrayResize(_drawnProjectionInstances,_maxDrawnProjectionInstances)<_maxDrawnProjectionInstances)
|
|
{
|
|
printf("Error allocating array: "+IntegerToString(GetLastError()));
|
|
return INIT_FAILED;
|
|
}
|
|
ArrayFill(_patternCounter,0,NUM_PATTERNS,0);
|
|
//--- Fill in the pattern arrays
|
|
_patterns[TRENDLIKE1_ABCD]=trendlike1_abcd; _patternNames[TRENDLIKE1_ABCD]="Trendlike AB=CD #1";
|
|
_patterns[TRENDLIKE2_ABCD]=trendlike2_abcd; _patternNames[TRENDLIKE2_ABCD]="Trendlike AB=CD #2";
|
|
_patterns[PERFECT_ABCD]=perfect_abcd; _patternNames[PERFECT_ABCD]="Perfect AB=CD";
|
|
_patterns[IDEAL1_ABCD]=ideal1_abcd; _patternNames[IDEAL1_ABCD]="Ideal AB=CD #1";
|
|
_patterns[IDEAL2_ABCD]=ideal2_abcd; _patternNames[IDEAL2_ABCD]="Ideal AB=CD #2";
|
|
_patterns[RANGELIKE_ABCD]=rangelike_abcd; _patternNames[RANGELIKE_ABCD]="Rangelike AB=CD";
|
|
_patterns[ALT127_TRENDLIKE1_ABCD]=alt127_trendlike1_abcd; _patternNames[ALT127_TRENDLIKE1_ABCD]="Trendlike 1.27 AB=CD #1";
|
|
_patterns[ALT127_TRENDLIKE2_ABCD]=alt127_trendlike2_abcd; _patternNames[ALT127_TRENDLIKE2_ABCD]="Trendlike 1.27 AB=CD #2";
|
|
_patterns[ALT127_PERFECT_ABCD]=alt127_perfect_abcd; _patternNames[ALT127_PERFECT_ABCD]="Perfect 1.27 AB=CD";
|
|
_patterns[ALT127_IDEAL1_ABCD]=alt127_ideal1_abcd; _patternNames[ALT127_IDEAL1_ABCD]="Ideal 1.27 AB=CD #1";
|
|
_patterns[ALT127_IDEAL2_ABCD]=alt127_ideal2_abcd; _patternNames[ALT127_IDEAL2_ABCD]="Ideal 1.27 AB=CD #2";
|
|
_patterns[ALT127_RANGELIKE_ABCD]=alt127_rangelike_abcd; _patternNames[ALT127_RANGELIKE_ABCD]="Rangelike 1.27 AB=CD";
|
|
_patterns[REC_TRENDLIKE1_ABCD]=rec_trendlike1_abcd; _patternNames[REC_TRENDLIKE1_ABCD]="Rec. Trendlike AB=CD #1";
|
|
_patterns[REC_TRENDLIKE2_ABCD]=rec_trendlike2_abcd; _patternNames[REC_TRENDLIKE2_ABCD]="Rec. Trendlike AB=CD #2";
|
|
_patterns[REC_PERFECT_ABCD]=rec_perfect_abcd; _patternNames[REC_PERFECT_ABCD]="Rec. Perfect AB=CD";
|
|
_patterns[REC_IDEAL1_ABCD]=rec_ideal1_abcd; _patternNames[REC_IDEAL1_ABCD]="Rec. Ideal AB=CD #1";
|
|
_patterns[REC_IDEAL2_ABCD]=rec_ideal2_abcd; _patternNames[REC_IDEAL2_ABCD]="Rec. Ideal AB=CD #2";
|
|
_patterns[REC_RANGELIKE_ABCD]=rec_rangelike_abcd; _patternNames[REC_RANGELIKE_ABCD]="Rec. Rangelike AB=CD";
|
|
_patterns[GARTLEY]=gartley; _patternNames[GARTLEY]="Gartley";
|
|
_patterns[BAT]=bat; _patternNames[BAT]="Bat";
|
|
_patterns[ALTBAT]=altbat; _patternNames[ALTBAT]="Alt. Bat";
|
|
_patterns[FIVEO]=fiveo; _patternNames[FIVEO]="5-0";
|
|
_patterns[BUTTERFLY]=butterfly; _patternNames[BUTTERFLY]="Butterfly";
|
|
_patterns[CRAB]=crab; _patternNames[CRAB]="Crab";
|
|
_patterns[DEEPCRAB]=deepcrab; _patternNames[DEEPCRAB]="Deep Crab";
|
|
_patterns[THREEDRIVES]=threedrives; _patternNames[THREEDRIVES]="Three Drives";
|
|
_patterns[CYPHER]=cypher; _patternNames[CYPHER]="Cypher";
|
|
_patterns[SHARK]=shark; _patternNames[SHARK]="Shark";
|
|
_patterns[NENSTAR]=nenstar; _patternNames[NENSTAR]="Nen Star";
|
|
_patterns[BLACKSWAN]=blackswan; _patternNames[BLACKSWAN]="Black Swan";
|
|
_patterns[WHITESWAN]=whiteswan; _patternNames[WHITESWAN]="White Swan";
|
|
_patterns[ONE2ONE]=one2one; _patternNames[ONE2ONE]="One2One";
|
|
_patterns[NEWCYPHER]=newcypher; _patternNames[NEWCYPHER]="New Cypher";
|
|
_patterns[NAVARRO200]=navarro200; _patternNames[NAVARRO200]="Navarro 200";
|
|
_patterns[LEONARDO]=leonardo; _patternNames[LEONARDO]="Leonardo";
|
|
_patterns[KANE]=kane; _patternNames[KANE]="Kane";
|
|
_patterns[GARFLY]=garfly; _patternNames[GARFLY]="Garfly";
|
|
_patterns[MAXBAT]=maxbat; _patternNames[MAXBAT]="Max. Bat";
|
|
_patterns[MAXGARTLEY]=maxgartley; _patternNames[MAXGARTLEY]="Max. Gartley";
|
|
_patterns[MAXBUTTERFLY]=maxbutterfly; _patternNames[MAXBUTTERFLY]="Max. Butterfly";
|
|
_patterns[GARTLEY113]=gartley113; _patternNames[GARTLEY113]="Gartley 113";
|
|
_patterns[BUTTERFLY113]=butterfly113; _patternNames[BUTTERFLY113]="Butterfly 113";
|
|
_patterns[ANTI_GARTLEY]=anti_gartley; _patternNames[ANTI_GARTLEY]="Anti Gartley";
|
|
_patterns[ANTI_BAT]=anti_bat; _patternNames[ANTI_BAT]="Anti Bat";
|
|
_patterns[ANTI_ALTBAT]=anti_altbat; _patternNames[ANTI_ALTBAT]="Anti Alt. Bat";
|
|
_patterns[ANTI_FIVEO]=anti_fiveo; _patternNames[ANTI_FIVEO]="Anti 5-0";
|
|
_patterns[ANTI_BUTTERFLY]=anti_butterfly; _patternNames[ANTI_BUTTERFLY]="Anti Butterfly";
|
|
_patterns[ANTI_CRAB]=anti_crab; _patternNames[ANTI_CRAB]="Anti Crab";
|
|
_patterns[ANTI_DEEPCRAB]=anti_deepcrab; _patternNames[ANTI_DEEPCRAB]="Anti Deep Crab";
|
|
_patterns[ANTI_THREEDRIVES]=anti_threedrives; _patternNames[ANTI_THREEDRIVES]="Anti Three Drives";
|
|
_patterns[ANTI_CYPHER]=anti_cypher; _patternNames[ANTI_CYPHER]="Anti Cypher";
|
|
_patterns[ANTI_SHARK]=anti_shark; _patternNames[ANTI_SHARK]="Anti Shark";
|
|
_patterns[ANTI_NENSTAR]=anti_nenstar; _patternNames[ANTI_NENSTAR]="Anti Nen Star";
|
|
_patterns[ANTI_BLACKSWAN]=anti_blackswan; _patternNames[ANTI_BLACKSWAN]="Anti Black Swan";
|
|
_patterns[ANTI_WHITESWAN]=anti_whiteswan; _patternNames[ANTI_WHITESWAN]="Anti White Swan";
|
|
_patterns[ANTI_ONE2ONE]=anti_one2one; _patternNames[ANTI_ONE2ONE]="Anti One2One";
|
|
_patterns[ANTI_NEWCYPHER]=anti_newcypher; _patternNames[ANTI_NEWCYPHER]="Anti New Cypher";
|
|
_patterns[ANTI_NAVARRO200]=anti_navarro200; _patternNames[ANTI_NAVARRO200]="Anti Navarro 200";
|
|
_patterns[ANTI_LEONARDO]=anti_leonardo; _patternNames[ANTI_LEONARDO]="Anti Leonardo";
|
|
_patterns[ANTI_KANE]=anti_kane; _patternNames[ANTI_KANE]="Anti Kane";
|
|
_patterns[ANTI_GARFLY]=anti_garfly; _patternNames[ANTI_GARFLY]="Anti Garfly";
|
|
_patterns[ANTI_MAXBAT]=anti_maxbat; _patternNames[ANTI_MAXBAT]="Anti Max. Bat";
|
|
_patterns[ANTI_MAXGARTLEY]=anti_maxgartley; _patternNames[ANTI_MAXGARTLEY]="Anti Max. Gartley";
|
|
_patterns[ANTI_MAXBUTTERFLY]=anti_maxbutterfly; _patternNames[ANTI_MAXBUTTERFLY]="Anti Max. Butterfly";
|
|
_patterns[ANTI_GARTLEY113]=anti_gartley113; _patternNames[ANTI_GARTLEY113]="Anti Gartley 113";
|
|
_patterns[ANTI_BUTTERFLY113]=anti_butterfly113; _patternNames[ANTI_BUTTERFLY113]="Anti Butterfly 113";
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method creates hexadecimal encoding of datetimes |
|
|
//+------------------------------------------------------------------+
|
|
string UniqueIdentifier(datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
|
|
{
|
|
return " "+StringFormat("%x",ADateTime)+StringFormat("%x",BDateTime)+StringFormat("%x",CDateTime)+StringFormat("%x",DDateTime);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Helper method creates hexadecimal encoding of datetimes |
|
|
//+------------------------------------------------------------------+
|
|
string UniqueIdentifier(datetime XDateTime,datetime ADateTime,datetime BDateTime,datetime CDateTime,datetime DDateTime)
|
|
{
|
|
return " "+StringFormat("%x",XDateTime)+StringFormat("%x",ADateTime)+StringFormat("%x",BDateTime)+StringFormat("%x",CDateTime)+StringFormat("%x",DDateTime);
|
|
}
|
|
//+------------------------------------------------------------------+
|