Quero transplantar o índice ziguezague no MT4 para analisar o formulário no SQ

Gosto do índice de análise morfológica em ziguezague no MT4, quero transplantar o índice em ziguezague no MT4 para analisar a forma no SQ, mas não há problema com o código. Parece que há um problema no gráfico SQ.

 

pacote SQ.Blocks.Indicators.ZIGZAG;

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

importar SQ.Internal.IndicatorBlock;

/**
* Nome do indicador, conforme será exibido na interface do usuário, e seu tipo de retorno.
* Tipos de retorno possíveis:
* ReturnTypes.Price - o indicador é desenhado no gráfico de preços, como SMA, Bandas de Bollinger etc.
* ReturnTypes.Number - o indicador é desenhado em um gráfico separado, como CCI, RSI, MACD
* ReturnTypes.PriceRange - o indicador é a faixa de preço, como o ATR.
*/
@BuildingBlock(name="(ZIGZAG) ZIGZAG", display="ZIGZAG(#InpDepth#,#InpDeviation#,#InpBackstep#)[#Shift#]", returnType = ReturnTypes.Price)

@Help(“ZIGZAG help text”)
public class ZIGZAG extends IndicatorBlock {

@Parameter
public ChartData Chart;

@Parameter(defaultValue="12″)
public int InpDepth;

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

@Parameter(defaultValue="3″)
public int InpBackstep;

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

@Output
public DataSeries ExtHighBuffer;
@Output
público DataSeries ExtLowBuffer;

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

}

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

/**
* Esse método é chamado em cada atualização de barra e aqui o valor do indicador é calculado.
*
* Ao contrário do MT4, você não calcula os valores do indicador para várias barras em um loop,
* Você precisa calcular o valor somente para a barra mais recente (atual).
* O mecanismo de negociação se encarregará de chamar esse método para cada barra do gráfico.
*
* A barra real para a qual o valor do indicador é calculado é armazenada na variável CurrentBar.
* Se for 0, significa que é a primeira barra do gráfico.
*/
@Override
protected void OnBarUpdate() throws TradingException {

int i;
int counterZ,whatlookfor=0;
int back,pos,lastthighpos=0,lastlowpos=0;
extremo duplo=0;
double curlow=0.0,curhigh=0.0,lastthigh=0.0,lastlow=0.0;
double val;
double Point1=0,00001;
//Chart.getInstrumentInfo.pointValue;
int limit=0;

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

{

//- loop principal

//- encontrar o mínimo mais baixo na profundidade das barras

val= Chart.Low(InpDepth+i);

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

extremum= val;

//- esse mínimo já foi encontrado anteriormente
se(extremum==lastlow)
extremum=0,0;
mais
{
//- nova última mínima
lastlow=extremum;
//- descartar o extremo se o mínimo atual for muito alto
se(Chart.Low(i)-extremum>InpDeviation*Point1)
extremum=0,0;
mais
{
//- limpar os extremos anteriores nas barras de retrocesso
for(back=1; back<=InpBackstep; back++)
{
pos=i+back;
se(ExtLowBuffer.get(pos)!=0 && ExtLowBuffer.get(pos)>extremum)
ExtLowBuffer.set(pos,0.0);
}
}
}
//- o extremo encontrado é o mínimo atual
se (Chart.Low(i)==extremum)

ExtLowBuffer.set(i,extremum);
// ExtLowBuffer[i]=extremum;
mais
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));
}

//- encontrar a maior altura na profundidade das barras
extremum=val;
//- esse valor mais alto já foi encontrado anteriormente
se(extremum==lasthigh)
extremum=0,0;
mais
{
//- nova última alta
última coxa=extremum;
//- descartar o extremo se a máxima atual for muito baixa
Se (extremum-Chart.High(i)>InpDeviation*Point1)
extremum=0,0;
mais
{
//- limpar os extremos anteriores nas barras de retrocesso
for(back=1; back<=InpBackstep; back++)
{
pos=i+back;
se(ExtHighBuffer.get(pos)!=0 && ExtHighBuffer.get(pos)<extremum)
ExtHighBuffer.set(pos,0.00);
//ExtHighBuffe.set(pos,0.0);
}
}
}
//- o extremo encontrado é o máximo atual
se(Chart.High(i)==extremum)
ExtHighBuffer.set(i,extremum);
mais
// ExtHighBufferr.set(i,0.00);
ExtHighBuffer.set(i,0.00);

}

//- corte final
se(whatlookfor==0)
{
lastlow=0.0;
lastthigh=0.0;
}
mais
{
lastlow=curlow;
lastthigh=curhigh;
}

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

{

switch(whatlookfor)
{
case 0: // procura por pico ou gramado
if(lastlow==0.0 && lasthigh==0.0)
{
se(ExtHighBuffer.get(i)!=0.0)
{
lasthigh=Chart.High(i);
lastthighpos=i;
whatlookfor=-1;
ExtZigzagBuffer.set(i,lasthigh);
}
Se(ExtLowBuffer.get(i)!=0.0)
{
lastlow=Chart.Low(i);
lastlowpos=i;
whatlookfor=1;
ExtZigzagBuffer.set(i,lastlow);
}
}
pausa;
case 1: // procura o pico
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);
}
se(ExtHighBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)==0.0)
{
lastthigh=ExtHighBuffer.get(i);
lastthighpos=i;
ExtZigzagBuffer.set(i,lasthigh);
whatlookfor=-1;
}
pausa;
case -1: // procura por gramado
if(ExtHighBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)>lasthigh && ExtLowBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lasthighpos,0.0);
lastthighpos=i;
lastthigh=ExtHighBuffer.get(i);
ExtZigzagBuffer.set(i,lasthigh);
}
se(ExtLowBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)==0.0)
{
lastlow=ExtLowBuffer.get(i);
lastlowpos=i;
ExtZigzagBuffer.set(i,lastlow);
whatlookfor=1;
}
pausa;

}
}

}

}