Quiero trasplantar el índice de zigzag en MT4 para analizar la forma en SQ

Me gusta el índice de análisis morfológico en zigzag en MT4, quiero trasplantar el índice en zigzag en MT4 para analizar la forma en SQ, pero no hay ningún problema con el código. Parece que hay un problema en el gráfico SQ.

 

paquete SQ.Blocks.Indicators.ZIGZAG;

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

import SQ.Internal.IndicatorBlock;

/**
* Nombre del indicador tal y como se mostrará en la interfaz de usuario, y su tipo de retorno.
* Posibles tipos de retorno:
* ReturnTypes.Price - el indicador se dibuja en el gráfico de precios, como SMA, bandas de Bollinger, etc.
* ReturnTypes.Number - el indicador se dibuja en un gráfico separado, como CCI, RSI, MACD
* ReturnTypes.PriceRange - el indicador es el rango de precios, como ATR.
*/
@BuildingBlock(name="(ZIGZAG) ZIGZAG", display="ZIGZAG(#InpDepth#,#InpDeviation#,#InpBackstep#)[#Shift#]", returnType = ReturnTypes.Price)

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

@Parámetro
public ChartData Gráfico;

@Parámetro(defaultValue="12″)
public int ProfundidadInp;

@Parámetro(defaultValue="5″)
public int DesviaciónInp;

@Parámetro(defaultValue="3″)
public int InpBackstep;

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

@Salida
public DataSeries ExtHighBuffer;
@Salida
public DataSeries ExtLowBuffer;

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

}

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

/**
* Este método es llamado en cada actualización de barra y aquí se calcula el valor del indicador.
*
* Al contrario que en MT4 no se calculan los valores de los indicadores para múltiples barras en un bucle,
* necesita calcular el valor sólo para la última barra (actual).
* El motor de negociación se encargará de llamar a este método para cada barra del gráfico.
*
* La barra actual para la que se calcula el valor del indicador se almacena en la variable CurrentBar.
* Si es 0, significa que es la primera barra del gráfico.
*/
@Override
protected void OnBarUpdate() throws TradingException {

int i;
int counterZ,whatlookfor=0;
int atras,pos,ultimopostealto=0,ultimopostebajo=0;
doble extremidad=0;
double curlow=0.0,curhigh=0.0,lasthigh=0.0,lastlow=0.0;
doble val;
doble Punto1=0,00001;
//Chart.getInstrumentInfo.pointValue;
int límite=0;

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

{

//- bucle principal

//- encontrar el mínimo en la profundidad de las barras

val= Gráfico.Bajo(ProfundidadEntrada+i);

for(int j = ProfundidadEntrada+i-1; j>=i;j-) {
val = Math.min(val, Gráfico.Bajo(j));
}

extremum= val;

//- este mínimo ya ha sido encontrado anteriormente
if(extremum==lastlow)
extremum=0,0;
si no
{
//- nuevo último mínimo
lastlow=extremo;
//- descarta el extremo si el mínimo actual es demasiado alto
if(Gráfico.Bajo(i)-extremo>DesviaciónInp*Punto1)
extremum=0,0;
si no
{
//- borrar extremos anteriores en barras de retroceso
for(atrás=1; atrás<=InpPasoDeVuelta; atrás++)
{
pos=i+back;
if(ExtLowBuffer.get(pos)!=0 && ExtLowBuffer.get(pos)>extremo)
ExtLowBuffer.set(pos,0.0);
}
}
}
//- el extremo encontrado es el mínimo actual
if(Gráfico.Bajo(i)==extremo)

ExtLowBuffer.set(i,extremum);
// ExtLowBuffer[i]=extremo;
si no
ExtLowBuffer.set(i,0.00);

val= Gráfico.Alto(ProfundidadEntrada+i);

for(int j = ProfundidadEntrada+i-1; j>=i;j-){
val = Math.max(val, Gráfico.Alto(j));
}

//- encontrar el máximo en la profundidad de las barras
extremum=val;
//- este máximo ya ha sido encontrado anteriormente
if(extremum==lasthigh)
extremum=0,0;
si no
{
//- nuevo último máximo
lasthigh=extremo;
//- descarta el extremo si el máximo actual es demasiado bajo
if(extremo-Carta.Alto(i)>DesviaciónInp*Punto1)
extremum=0,0;
si no
{
//- borrar extremos anteriores en barras de retroceso
for(atrás=1; atrás<=InpPasoDeVuelta; atrás++)
{
pos=i+back;
if(ExtHighBuffer.get(pos)!=0 && ExtHighBuffer.get(pos)<extremo)
ExtHighBuffer.set(pos,0.00);
//ExtHighBuffe.set(pos,0.0);
}
}
}
//- el extremo encontrado es el máximo actual
if(Gráfico.Alto(i)==extremo)
ExtHighBuffer.set(i,extremum);
si no
// ExtHighBufferr.set(i,0.00);
ExtHighBuffer.set(i,0.00);

}

//- corte final
if(whatlookfor==0)
{
lastlow=0.0;
lasthigh=0,0;
}
si no
{
lastlow=curlow;
lasthigh=curhigh;
}

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

{

switch(quélookpara)
{
caso 0: // buscar pico o césped
if(lastlow==0,0 && lasthigh==0,0)
{
if(ExtHighBuffer.get(i)!=0.0)
{
lasthigh=Chart.High(i);
ultimaposicion=i;
para qué=-1;
ExtZigzagBuffer.set(i,lasthigh);
}
if(ExtLowBuffer.get(i)!=0.0)
{
lastlow=Chart.Low(i);
lastlowpos=i;
whatlookfor=1;
ExtZigzagBuffer.set(i,lastlow);
}
}
romper;
caso 1: // buscar 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);
}
if(ExtHighBuffer.get(i)!=0.0 && ExtLowBuffer.get(i)==0.0)
{
lasthigh=ExtHighBuffer.get(i);
ultimaposicion=i;
ExtZigzagBuffer.set(i,lasthigh);
para qué=-1;
}
romper;
caso -1: // buscar césped
if(ExtHighBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)>lasthigh && ExtLowBuffer.get(i)==0.0)
{
ExtZigzagBuffer.set(lasthighpos,0.0);
ultimaposicion=i;
lasthigh=ExtHighBuffer.get(i);
ExtZigzagBuffer.set(i,lasthigh);
}
if(ExtLowBuffer.get(i)!=0.0 && ExtHighBuffer.get(i)==0.0)
{
lastlow=ExtLowBuffer.get(i);
lastlowpos=i;
ExtZigzagBuffer.set(i,lastlow);
whatlookfor=1;
}
romper;

}
}

}

}