Indicateur zig zag sur MT5

bonjour a tous, je bosse depuis pas mal de temps sur une stratégie que je voudrais automatiser. Malheureusement je suis 00 en programmation. j'ai besoin de vos lumières amis programmeurs

question: est il possible de programmer un algo avec l'indicateur ZIGZAGNN sur Mql 5??
je met le code si dessous.

j'utilise plusieurs valeurs qui correspondent a différents time frame ensuite je met en corrélation les différentes valeurs (assez élaboré)… il s'en suit un bon management et des prises de positions basé sur la volatilité…

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots 2
//---- plot Zigzag
#property indicator_label1 "Extremums"
#property indicator_type1 DRAW_ARROW
#property indicator_color1 Red

#property indicator_label2 "Zigzag"
#property indicator_type2 DRAW_SECTION
#property indicator_color2 Red
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//--- input parameters
input int ExtDepth=12;
input int ExtDeviation=5;
input int ExtBackstep=3;
//--- indicator buffers
double Extremums[]; // extremum buffer
double ZigzagBuffer[]; // main buffer
double HighMapBuffer[]; // highs
double LowMapBuffer[]; // lows
int level=3; // recounting depth
double deviation; // deviation in points
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
SetIndexBuffer(0,Extremums,INDICATOR_DATA);
SetIndexBuffer(1,ZigzagBuffer,INDICATOR_DATA);
SetIndexBuffer(2,HighMapBuffer,INDICATOR_CALCULATIONS);
SetIndexBuffer(3,LowMapBuffer,INDICATOR_CALCULATIONS);

PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
PlotIndexSetInteger(0,PLOT_ARROW,119);

PlotIndexSetString(1,PLOT_LABEL,"ZigZag("+(string)ExtDepth+","+(string)ExtDeviation+","+(string)ExtBackstep+")");
IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
deviation=ExtDeviation*_Point;
return(0);
}
//+------------------------------------------------------------------+
//| searching index of the highest bar |
//+------------------------------------------------------------------+
int iHighest(const double &array[],
int depth,
int startPos)
{
int index=startPos;
//--- start index validation
if(startPos<0)
{
Print("Invalid parameter in the function iHighest, startPos =",startPos);
return 0;
}
int size=ArraySize(array);
//--- depth correction if need
if(startPos-depth<0) depth=startPos;
double max=array[startPos];
//--- start searching
for(int i=startPos;i>startPos-depth;i--)
{
if(array>max)
{
index=i;
max=array;
}
}
//--- return index of the highest bar
return(index);
}
//+------------------------------------------------------------------+
//| searching index of the lowest bar |
//+------------------------------------------------------------------+
int iLowest(const double &array[],
int depth,
int startPos)
{
int index=startPos;
//--- start index validation
if(startPos<0)
{
Print("Invalid parameter in the function iLowest, startPos =",startPos);
return 0;
}
int size=ArraySize(array);
//--- depth correction if need
if(startPos-depth<0) depth=startPos;
double min=array[startPos];
//--- start searching
for(int i=startPos;i>startPos-depth;i--)
{
if(array<min)
{
index=i;
min=array;
}
}
//--- return index of the lowest bar
return(index);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int Calc (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 i=0;
int limit=0,counterZ=0,whatlookfor=0;
int shift=0,back=0,lasthighpos=0,lastlowpos=0;
double val=0,res=0;
double curlow=0,curhigh=0,lasthigh=0,lastlow=0;
//--- auxiliary enumeration
enum looling_for
{
Pike=1, // searching for next high
Sill=-1 // searching for next low
};
//--- initializing
if(prev_calculated==0)
{
ArrayInitialize(ZigzagBuffer,0.0);
ArrayInitialize(HighMapBuffer,0.0);
ArrayInitialize(LowMapBuffer,0.0);
}
//--- set start position for calculations
if(prev_calculated==0) limit=ExtDepth;

//--- ZigZag was already counted before
if(prev_calculated>0)
{
i=rates_total-1;
//--- searching third extremum from the last uncompleted bar
while(counterZ<level && i>rates_total-100)
{
res=ZigzagBuffer;
if(res!=0) counterZ++;
i--;
}
i++;
limit=i;

//--- what type of exremum we are going to find
if(LowMapBuffer!=0)
{
curlow=LowMapBuffer;
whatlookfor=Pike;
}
else
{
curhigh=HighMapBuffer;
whatlookfor=Sill;
}
//--- chipping
for(i=limit+1;i<rates_total;i++)
{
ZigzagBuffer=0.0;
LowMapBuffer=0.0;
HighMapBuffer[i]=0.0;
}
}

//--- searching High and Low
for(shift=limit;shift<rates_total;shift++)
{
val=low[iLowest(low,ExtDepth,shift)];
if(val==lastlow) val=0.0;
else
{
lastlow=val;
if((low[shift]-val)>deviation) val=0.0;
else
{
for(back=1;back<=ExtBackstep;back++)
{
res=LowMapBuffer[shift-back];
if((res!=0) && (res>val)) LowMapBuffer[shift-back]=0.0;
}
}
}
if(low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;
//--- high
val=high[iHighest(high,ExtDepth,shift)];
if(val==lasthigh) val=0.0;
else
{
lasthigh=val;
if((val-high[shift])>deviation) val=0.0;
else
{
for(back=1;back<=ExtBackstep;back++)
{
res=HighMapBuffer[shift-back];
if((res!=0) && (res<val)) HighMapBuffer[shift-back]=0.0;
}
}
}
if(high[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
}

//--- last preparation
if(whatlookfor==0)// uncertain quantity
{
lastlow=0;
lasthigh=0;
}
else
{
lastlow=curlow;
lasthigh=curhigh;
}

//--- final rejection
for(shift=limit;shift<rates_total;shift++)
{
res=0.0;
switch(whatlookfor)
{
case 0: // search for peak or lawn
if(lastlow==0 && lasthigh==0)
{
if(HighMapBuffer[shift]!=0)
{
lasthigh=high[shift];
lasthighpos=shift;
whatlookfor=Sill;
ZigzagBuffer[shift]=lasthigh;
res=1;
}
if(LowMapBuffer[shift]!=0)
{
lastlow=low[shift];
lastlowpos=shift;
whatlookfor=Pike;
ZigzagBuffer[shift]=lastlow;
res=1;
}
}
break;
case Pike: // search for peak
if(LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
{
ZigzagBuffer[lastlowpos]=0.0;
lastlowpos=shift;
lastlow=LowMapBuffer[shift];
ZigzagBuffer[shift]=lastlow;
res=1;
}
if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
{
lasthigh=HighMapBuffer[shift];
lasthighpos=shift;
ZigzagBuffer[shift]=lasthigh;
whatlookfor=Sill;
res=1;
}
break;
case Sill: // search for lawn
if(HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
{
ZigzagBuffer[lasthighpos]=0.0;
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
}
if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
{
lastlow=LowMapBuffer[shift];
lastlowpos=shift;
ZigzagBuffer[shift]=lastlow;
whatlookfor=Pike;
}
break;
default: return(rates_total);
}
}

//--- return value of prev_calculated for next call
return(rates_total);
}
//+------------------------------------------------------------------+

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[])
{

for (int i=(prev_calculated>100 ? prev_calculated : 100); i<=rates_total; i++) {
Calc(i,(i<=100 ? 0 : i),time,open,high,low,close,tick_volume,volume,spread);
Extremums[i-1]=ZigzagBuffer[i-1];
}
return(rates_total);
}

Comme indiqué dans l’émail de bienvenue que tu dois lire

Merci de mettre un titre explicite

Help me !!! N’est pas un titre explicite.

J’ai du rééditer ton poste pour changer le titre

Merci

oui sans problème faite comme bon vous semble

Et lis le message de bienvenue Thom, c'est indispensable.