Voglio trapiantare l'indice zigzag in MT4 per analizzare la forma in SQ

Mi piace l'indice di analisi morfologica a zigzag in MT4, voglio trapiantare l'indice a zigzag in MT4 per analizzare la forma in SQ, ma non c'è alcun problema con il codice. Sembra che ci sia un problema nel grafico SQ.

 

pacchetto SQ.Blocks.Indicators.ZIGZAG;

importare SQ.Calculators.HighestCalculator;
importare SQ.Calculators.LowestCalculator;
importare com.strategyquant.lib.*;
importare com.strategyquant.datalib.*;
importare com.strategyquant.tradinglib.*;

importare SQ.Internal.IndicatorBlock;

/**
* Nome dell'indicatore come verrà visualizzato nell'interfaccia utente e tipo di ritorno.
* Tipi di ritorno possibili:
* ReturnTypes.Price - l'indicatore viene disegnato sul grafico del prezzo, come SMA, Bande di Bollinger ecc.
* ReturnTypes.Number - l'indicatore è disegnato su un grafico separato, come CCI, RSI, MACD.
* ReturnTypes.PriceRange - l'indicatore è un intervallo di prezzi, come l'ATR.
*/
@BuildingBlock(name="(ZIGZAG) ZIGZAG", display="ZIGZAG(#InpDepth#,#InpDeviation#,#InpBackstep#)[#Shift#]", returnType = ReturnTypes.Price)

@Help(“ZIGZAG help text”)
classe pubblica ZIGZAG estende IndicatorBlock {

@Parametro
public ChartData Chart;

@Parametro(defaultValue="12″)
pubblico int InpDepth;

@Parametro(defaultValue="5″)
public int InpDeviation;

@Parametro(defaultValue="3″)
pubblico int InpBackstep;

@Output(name = "ExtZigzagBuffer", color = Colors.Green)
public DataSeries ExtZigzagBuffer;

@Output
public DataSeries ExtHighBuffer;
@Output
public DataSeries ExtLowBuffer;

@Override
protected void OnInit() throws TradingException {
ExtZigzagBuffer.set(0,0);
ExtHighBuffer.set(0,0.00);
ExtLowBuffer.set(0,0.00);

}

//————————————————————————
//————————————————————————
//————————————————————————

/**
* Questo metodo viene chiamato ad ogni aggiornamento della barra e qui viene calcolato il valore dell'indicatore.
*
* A differenza di MT4, non si calcolano i valori degli indicatori per più barre in un ciclo,
* È necessario calcolare il valore solo per l'ultima barra (corrente).
* Il motore di trading si occuperà di richiamare questo metodo per ogni barra del grafico.
*
* La barra effettiva per la quale viene calcolato il valore dell'indicatore è memorizzata nella variabile CurrentBar.
* Se 0, significa che è la prima barra del grafico.
*/
@Override
protected void OnBarUpdate() throws TradingException {

int i;
int counterZ,whatlookfor=0;
int back,pos,lasthighpos=0,lastlowpos=0;
doppio estremo=0;
double curlow=0.0,curhigh=0.0,lasthigh=0.0,lastlow=0.0;
doppio val;
double Point1=0,00001;
//Chart.getInstrumentInfo.pointValue;
int limit=0;

for(i=limite; i>=0; i-)

{

//- ciclo principale

//- trovare il minimo in profondità delle barre

val= Chart.Low(InpDepth+i);

for(int j = InpDepth+i-1; j>=i;j-) {
val = Math.min(val, Chart.Low(j));
}

estremo= val;

//- questo minimo è stato trovato in precedenza
se(extremum==lastlow)
extremum=0,0;
altro
{
//- nuovo ultimo minimo
lastlow=extremum;
//- scartare l'estremo se il minimo attuale è troppo alto
se(Chart.Low(i)-extremum>InpDeviation*Point1)
extremum=0,0;
altro
{
//- cancellare gli estremi precedenti nelle barre di backstep
for(back=1; back<=InpBackstep; back++)
{
pos=i+back;
if(ExtLowBuffer.get(pos)!=0 && ExtLowBuffer.get(pos)>extremum)
ExtLowBuffer.set(pos,0.0);
}
}
}
//- l'estremo trovato è il minimo attuale
se(Chart.Low(i)==estremo)

ExtLowBuffer.set(i,extremum);
// ExtLowBuffer[i]=extremum;
altro
ExtLowBuffer.set(i,0.00);

val= Chart.High(InpDepth+i);

for(int j = InpDepth+i-1; j>=i;j-){
val = Math.max(val, Chart.High(j));
}

//- trovare il massimo della profondità delle barre
extremum=val;
//- questo massimo è stato trovato in precedenza
se(estremo==coscia)
extremum=0,0;
altro
{
//- nuovo ultimo massimo
lasthigh=estremo;
//- scartare l'estremo se il massimo attuale è troppo basso
se(extremum-Chart.High(i)>InpDeviation*Point1)
extremum=0,0;
altro
{
//- cancellare gli estremi precedenti nelle barre di backstep
for(back=1; back<=InpBackstep; back++)
{
pos=i+back;
if(ExtHighBuffer.get(pos)!=0 && ExtHighBuffer.get(pos)<extremum)
ExtHighBuffer.set(pos,0.00);
//ExtHighBuffe.set(pos,0.0);
}
}
}
//- l'estremo trovato è il massimo attuale
se(Chart.High(i)==estremo)
ExtHighBuffer.set(i,extremum);
altro
// ExtHighBufferr.set(i,0.00);
ExtHighBuffer.set(i,0.00);

}

//- taglio finale
if(whatlookfor==0)
{
lastlow=0.0;
lasthigh=0,0;
}
altro
{
lastlow=curlow;
lasthigh=curhigh;
}

for(i=limite; i>=0; i-)

{

switch(whatlookfor)
{
caso 0: // cerca il picco o il prato
se(lastlow==0.0 && lasthigh==0.0)
{
se(ExtHighBuffer.get(i)!=0.0)
{
lasthigh=Chart.High(i);
lasthighpos=i;
whatlookfor=-1;
ExtZigzagBuffer.set(i,lastthigh);
}
se(ExtLowBuffer.get(i)!=0.0)
{
lastlow=Chart.Low(i);
lastlowpos=i;
whatlookfor=1;
ExtZigzagBuffer.set(i,lastlow);
}
}
pausa;
caso 1: // cerca il picco
if(ExtLowBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)<lastlow && ExtHighBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lastlowpos,0.0);
lastlowpos=i;
lastlow=ExtLowBuffer.get(i);
ExtZigzagBuffer.set(i,lastlow);
}
if(ExtHighBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)==0.0)
{
lasthigh=ExtHighBuffer.get(i);
lasthighpos=i;
ExtZigzagBuffer.set(i,lastthigh);
whatlookfor=-1;
}
pausa;
caso -1: // cerca il prato
if(ExtHighBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)>lasthigh && ExtLowBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lasthighpos,0.0);
lasthighpos=i;
lasthigh=ExtHighBuffer.get(i);
ExtZigzagBuffer.set(i,lastthigh);
}
if(ExtLowBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)==0.0)
{
lastlow=ExtLowBuffer.get(i);
lastlowpos=i;
ExtZigzagBuffer.set(i,lastlow);
whatlookfor=1;
}
pausa;

}
}

}

}