Olá @pedro-henrique-t-de-carvalho!

Quanto à lógica de topos e fundos do indicador nativo, encontrei o seguinte link da Nelogica que explica exatamente o algoritmo (copiei abaixo).

Para implementar esse indicador, considerando o atraso de confirmação, teria que escrever o código novamente, pois reutiliza-se apenas o "esqueleto" do indicador que publicamos. Mas é bem factível e tranquilo de fazer.

Já baseado em Fibonacci a alteração seria talvez mais pontual. Modificando o valor de fVolatilidadeMedia para a amplitude do fundo e máxima atual ou topo e mínimo atual, bastaria configurar o parâmetro de gatilho para o valor de referência desejado.

Podemos trabalhar na geração dessas duas versões...Proponho que tente criar uma delas e postar o código aqui, que vamos ajustando aos poucos.

Abs!

Explicação do Indicador de Topos e Fundos pela Nelógica

"O funcionamento da ferramenta é relativamente simples, o algoritmo seguindo sistematicamente as seguintes regras:

• Considera um período como ponto de referência inicial para a verificação;
• De acordo com o parâmetro de calibração a varredura é iniciada. Por exemplo, se estiver calibrado em dois períodos, ao ocorrerem duas máximas superando a máxima da primeira barra (período de referência inicial), a mínima dela será classificada como fundo. Da mesma forma, se ocorrerem duas mínimas inferiores a mínima daquele primeira período, a máxima dele será considerada um topo;
• Enquanto um topo não é confirmado e vão surgindo máximas superiores, estas novas máximas passam a ser os pontos de referência (elegíveis para o novo topo). Da mesma maneira, enquanto um fundo não é confirmado e vão surgindo mínimas inferiores, estas novas mínimas passam a ser os novos pontos de referência (elegíveis para o novo fundo).

Observações Finais

Quanto menor for o período de calibração do indicador, mais sensível e rápida será a detecção de topos e fundos. De acordo com a volatilidade e o estado do mercado (tendência ou congestão) deve ser definida a calibração de melhor comportamento."

John, boa noite! Tentei aplicar em uma parte a lógica da explicação do indicador nativo, mas não sei se esta correta ou no local correto do código "esqueleto".
Também achei uma lógica similar nesta pagina:

https://smarttbot.com/trader/topos-e-fundos-daytrading/?utm_source=youtube&utm_medium=descricao_video&utm_campaign=20200805_indicadores&utm_content=topos-fundos  

https://www.youtube.com/watch?v=9DsZBI50bow

Será que conseguimos fazer igual este indicador dos links acima? Acrescentei uma imagem em anexo,  para que veja as linhas verde  e vermelha que quero fazer! 

Segue o inicio da construção: 

input
// pGatilhoDeteccao(5.0);
// pQtdePeriodosAnaliseVolat(100);
periodo(5);
// ---------------------------------------------------------------------
// ---------------------- Variáveis globais ----------------------------
// ---------------------------------------------------------------------
var
iIdentUltimaBarraIdentificada : integer;
fMaximoAtual,fMinimoAtual : float;
fVolatilidadeMedia: float;
fTopoFundoConfirmado: float;
Meio: float;
begin
// ---------------------------------------------------------------------
// ------------ Atribuição de variáveis por processamento --------------
// ---------------------------------------------------------------------
// Manutenção de valor da variável entre processamentos da estratégia
// O comportamento de retenção de valor das variáveis tem sofrido alterações não previsiveis
// nas últimas atualizações do Profit
iIdentUltimaBarraIdentificada := iIdentUltimaBarraIdentificada[1];
{ fVolatilidadeMedia := (Summation(High,pQtdePeriodosAnaliseVolat)-Summation(Low,pQtdePeriodosAnaliseVolat))
/pQtdePeriodosAnaliseVolat; }

// ---------------------------------------------------------------------
// --------------------- Cálculo do indicador -------------------------
// OBS: Inserir lógica de cálculo do indicador e caso ele possa ser plo_
// tado, atribuir em algum momento True para variável bPlotIndicador
// ---------------------------------------------------------------------

// Inicialização do algoritmo quando tem dados suficientes
// Inicialização do algoritmo quando tem dados suficientes
{ if CurrentBar = pQtdePeriodosAnaliseVolat then
begin
fMaximoAtual := High[1];
fMinimoAtual := Low[1]; }

//Tentei aplicar a nova lógica aqui abaixo

begin
IF low < low[periodo] then
Begin

fMaximoAtual := High[periodo +1];

IF high > high[1] then
Begin
fMinimoAtual := Low[periodo+1];

iIdentUltimaBarraIdentificada := -1*(CurrentBar-1);
end;

// Algoritmo inicia execução
if CurrentBar > pQtdePeriodosAnaliseVolat then
begin
// Última confirmação do indicador foi um topo
if (iIdentUltimaBarraIdentificada > 0) then
begin
// Verifica se houve retração de preço em relação ao valor mínimo atual maior do que o gatilho do parâmetro de entrada
if (High >= (fMinimoAtual + pGatilhoDeteccao*fVolatilidadeMedia)) then
begin
// Plota o fundo identificado, atualiza o índice da barra de fundo com valor negativo (economia de memória)
// e estabelece um valor inicial para o máximo atual
fTopoFundoConfirmado := Lowest(Low,CurrentBar - Round(Abs(iIdentUltimaBarraIdentificada)) + 1);
// plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := -1*CurrentBar;
fMaximoAtual := High;
//PaintBar(clGreen);
// PlotText(fTopoFundoConfirmado,clGreen,-1,9);
end;
// Atualiza o valor mínimo atual
if Low < fMinimoAtual then fMinimoAtual := Low;
end

// Última confirmação do indicador foi um fundo
else
begin
// Verifica se houve retração de preço em relação ao valor máximo atual maior do que o gatilho do parâmetro de entrada
if (Low <= (fMaximoAtual - pGatilhoDeteccao*fVolatilidadeMedia2)) then
begin
// Plota o topo identificado, atualiza o índice da barra de topo com valor positivo (economia de memória)
// e estabelece um valor inicial para o mínimo atual
fTopoFundoConfirmado := Highest(High,CurrentBar - Round(Abs(iIdentUltimaBarraIdentificada)) + 1);
// plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := CurrentBar;
fMinimoAtual := Low;
//PaintBar(clRed);
// PlotText(fTopoFundoConfirmado,clRed,-1,9);
end;
// Atualiza o valor máximo atual
if High > fMaximoAtual then fMaximoAtual := High;
end;
end;

//
// ---------------------------------------------------------------------
// ------------------ Plota valores do indicador -----------------------
// OBS: A série de confirmação de topo/fundo (1) é plotada na lógica do indicador.
// Abaixo são plotadas as séries de valor máximo e mínimo atual, séries 2 e 3, respectivamente.
// ---------------------------------------------------------------------
// Configura plot do valor de confirmação de topo/fundo
SetPlotWidth(1,2);

// Indicador também calcula as séries de valor máximo e mínimo atual
plot2(fMaximoAtual);
SetPlotColor(2,clRed);
SetPlotWidth(2,2);
SetPlotStyle(2,psDash);
plot3(fMinimoAtual);
SetPlotColor(3,clGreen);
SetPlotWidth(3,2);
SetPlotStyle(3,psDash);

//end;
Meio:= ( fMinimoAtual + fMaximoAtual)/2;
// Meio:= ( fTopoFundoConfirmado +fTopoFundoConfirmado[1])/2;

// Acrescentei um meio para ver se ele ajuda a orientar, mas sem êxito. 
//begin
plot5(meio);

If close > meio then paintbar (cllime);
If close < meio then paintbar (clred);

end;
end;
end;
end;

//--------------------------------------------------------------------------------------------------------

Abraços!

Boa noite @pedro-henrique-t-de-carvalho!

Claro, é possível. Vou trabalhar nesse indicador até o fim dessa semana e posto aqui. Caso ele funcione de forma encapsulada, eu até subo para a Loja de Estratégias com indicador gratuito.

Você percebe que tanto o indicador da Nelogica como da SmartBot são o mesmo indicador!? A diferença é que a Smartbot fez a confirmação no tempo que é possível na vida real.

O Indicador da Nelogica é útil quando queremos, por exemplo, estimar qual seria o maior valor que uma estratégia poderia obter em uma série de dados. Ou seja, comprando exatamente nos fundos e vendendo nos topos. Tem a sua valia para fiz de comparação de desempenho hipotético. Seu uso indiscriminado no backtesting pode levar a conclusões muito otimistas do desempenho de um setup.

Abs!

@admin ok! Fico no aguardo do código e da lógica aqui.

Sei sim que o indicador é atradado e seu uso no backtest é comprometido. 

Abraços

@admin Será que essa Lógica (em python) abaixo ajuda em algo? 

def detect_top(candles, n):

reference = candles[0]

count = 0

for i in range(1, len(candles)):
if candles[i]["low"] < reference["low"]:
count += 1
reference = candles[i]
if count == n:
return reference

return None

candles = [{"low": 10}, {"low": 8}, {"low": 7}, {"low": 5}, {"low": 6}]
result = detect_top(candles, 2)

if result:

print("Top detected at candle with low value", result["low"])
else:
print("Top not detected")

Abs!

@admin boa noite! Vc chegou a trabalhar algo do código? Forte abraço. 

@Pedro-henrique-t-de-carvalho, bom dia!

Estou trabalhando no código, mas atrasei devido ao lançament do novo backtesting. Estou retomando hoje o código...eu tinha ficado preso em um problema da lógica...vamos ver se evoluo hoje.

Abs!

@admin Maravilha John! 

Estou procurando uma forma de fazer esse código. Veja essa lógica em Pascal, será que ajuda? Segue:

type
DetectionState = (DETECTING_TOP_AND_BOTTOM, DETECTING_TOP, DETECTING_BOTTOM);

var
N: integer = 5;
state: DetectionState = DETECTING_TOP_AND_BOTTOM;
reference_candle_index: integer = -1;
reference_candle_min, reference_candle_max: Real = 0.0;
num_candles, i, j: integer;
current_candle, next_candle: Real;
num_reductions, num_increases: integer;

begin
for i := 0 to num_candles - 1 do
begin
current_candle := candles[i];

if (state = DETECTING_TOP_AND_BOTTOM) or (state = DETECTING_TOP) then
if (current_candle.max > reference_candle_max) then
begin
reference_candle_index := i;
reference_candle_max := current_candle.max;
reference_candle_min := current_candle.min;
end
else
else if (state = DETECTING_BOTTOM) then
if (current_candle.min < reference_candle_min) then
begin
reference_candle_index := i;
reference_candle_max := current_candle.max;
reference_candle_min := current_candle.min;
end;

num_reductions := 0;
num_increases := 0;

for j := i + 1 to num_candles - 1 do
begin
next_candle := candles[j];

if (state = DETECTING_TOP_AND_BOTTOM) or (state = DETECTING_TOP) then
if (next_candle.min < reference_candle_min) then
begin
num_reductions := num_reductions + 1;
reference_candle_min := next_candle.min;
if (num_reductions = N) then
begin
state := DETECTING_BOTTOM;
Break;
end;
end
else if (state = DETECTING_BOTTOM) then
if (next_candle.max > reference_candle_max) then
begin
num_increases := num_increases + 1;
reference_candle_max := next_candle.max;
if (num_increases = N) then
begin
state := DETECTING_TOP;
Break;
end;
end;
end;
end;
end.

Abraços!

Prezado @pedro-henrique-t-de-carvalho,

       demorei, mas está aí.

       Existe o atraso na confirmação de topo e fundo, mas mais do que isso...ao comparar o indicador da Nelogica com o que criei (apelidei carinhosamente de "Neologica"), vi que a regra apresentada pela Nelogica abaixo não é a mesma do indicador.

       Roda aí para você ver.

Abs!

Explicação do Indicador de Topos e Fundos pela Nelógica

"O funcionamento da ferramenta é relativamente simples, o algoritmo seguindo sistematicamente as seguintes regras:

• Considera um período como ponto de referência inicial para a verificação;
• De acordo com o parâmetro de calibração a varredura é iniciada. Por exemplo, se estiver calibrado em dois períodos, ao ocorrerem duas máximas superando a máxima da primeira barra (período de referência inicial), a mínima dela será classificada como fundo. Da mesma forma, se ocorrerem duas mínimas inferiores a mínima daquele primeira período, a máxima dele será considerada um topo;
• Enquanto um topo não é confirmado e vão surgindo máximas superiores, estas novas máximas passam a ser os pontos de referência (elegíveis para o novo topo). Da mesma maneira, enquanto um fundo não é confirmado e vão surgindo mínimas inferiores, estas novas mínimas passam a ser os novos pontos de referência (elegíveis para o novo fundo).

Observações Finais

Quanto menor for o período de calibração do indicador, mais sensível e rápida será a detecção de topos e fundos. De acordo com a volatilidade e o estado do mercado (tendência ou congestão) deve ser definida a calibração de melhor comportamento."

// #######################################################################
// #######################################################################
// #######################################################################
// ######                            O                             #######
// ######                        ____|____                         #######
// ######                      _|         |_                       #######
// ######                     (_|  O   O  |_)                      #######
// ######                       |_________|                        #######
// ######                                                          #######
// ###### ____        __        ____________           ________    #######
// ###### | | \       | |       | |_________|         /  ____  \   #######
// ###### | |\ \      | |       | |                  /  /    \  \  #######
// ###### | | \ \     | |       | |____             |  |      |  | #######
// ###### | |  \ \    | |       | |____|            |  |      |  | #######
// ###### | |   \ \   | |       | |____|            |  |      |  | #######
// ###### | |    \ \  | |       | |                 |  |      |  | #######
// ###### | |     \ \ | |       | |_________         \  \____/  /  #######
// ###### |_|      \_\|_|       |_|_________|         \________/   #######
// ######                                                          #######
// ###### _______  __          __   ____  __   ___    __  _______  #######
// ######    |    |  \   /\   |  \ |     |  \ |   \  /  \    |     #######
// ######    |    |__/  /__\  |   ||__   |__/ |___/ |    |   |     #######
// ######    |    |\   /    \ |   ||     |\   |   \ |    |   |     #######
// ######    |    | \ /      \|__/ |____ | \  |___/  \__/    |     #######
// ######                                                          #######
// ######  Comunidade aberta de automatização de estratégias para  #######
// ######                    negociação de ativos                  #######
// ######                                                          #######
// ######                    www.NeoTraderBot.com                  #######
// #######################################################################
// #######################################################################
// #######################################################################
//
// -----------------------------------------------------------------------
// ---------------------- DADOS DA ESTRATÉGIA ----------------------------
// -----------------------------------------------------------------------
//
// NOME DA ESTRATÉGIA: NeoTraderBot_TopBottomDetector_Neologica
//   DESENVOLVIDA POR: Johnathas Carvalho
//    DATA DE CRIAÇÃO: 14/02/2023
//             VERSÃO: 1.0
//      ATUALIZADA EM: 15/12/2022
// TIPO DE ESTRATÉGIA: (X) Indicador  (X) Coloração ( ) Execução
//                     ( ) Screening  (X) Texto     ( ) Alarme
//
// DESCRIÇÃO DA ESTRATÉGIA:
//    Este é um indicador inspirado na lógica do indicador nativo do Profit
// Chart para detecção de topos e fundos que se baseia no rompimento da máxima
// ou mínima de um candle de referência.
// A estratégia possui 3 saídas. Linha 1 apresenta valor diferente de zero 
// quando há uma confirmação de topo/fundo. Linha 2 é o valor de topo atual 
// e linha 3 é o valor de fundo atual.


// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
//
// ######################### FIM DO CABEÇALHO ############################
//


//
// ---------------------------------------------------------------------
// -------------------------- Parâmetros -------------------------------
// OBS: Segue abaixo a descriação de cada parâmetro
// 1) pQtdeRompimentos -> Refere-se a quantidade de rompimentos necessários
// para confirmar um topo ou fundo. Ex: se o candle de referência de um 
// possível topo tem o valor de mínima igual a X. Somente após ocorrem pQtdeRompimentos
// barras com valor de mínimo menor que X é que o candle de referência será
// confirmado como topo.
// Como o valor mínimo dos candles subsequentes podem ficar abaixo do último
// topo identificado antes dessa condição. O candle de referência também será
// confirmado como topo se a condição de rompimento não for atendida e o valor
// mínimo do candle atual for menor que o último fundo.
//
// 2) pModoPlot -> Configura se e como as séries de confirmação, topo e fundo serão plotadas
//    pModoPlot = 0: Não realiza plots de topo/fundo, apenas confirmação        
//    pModoPlot = 1: Plota o útimo topo/fundo confirmado, bem como topo/fundo em detecção
//    pModoPlot = 2: Plota apenas o topo/fundo a ser confirmado
//                   
// 3) pExibirTextoConfirmacao -> Configura exibição de texto de confirmação de topo/fundo 
// ---------------------------------------------------------------------

input
  pQtdeRompimentos(5);
  pModoPlot(1);
  pExibirTextoConfirmacao(false); 
  // ---------------------------------------------------------------------
  // ---------------------- Variáveis globais ----------------------------
  // ---------------------------------------------------------------------
var
  iIdentUltimaBarraIdentificada : integer;
  fMaximoAtual,fMinimoAtual : float;
  iMaximoAtual, iMinimoAtual: integer;
  fVolatilidadeMedia: float;
  fTopoFundoConfirmado: float;
  iContadorRompimentos: integer;
  Curr: integer;
  teste : float;
begin
  

  // ---------------------------------------------------------------------
  // ------------ Atribuição de variáveis por processamento --------------
  // ---------------------------------------------------------------------
  // Manutenção de valor da variável entre processamentos da estratégia
  // O comportamento de retenção de valor das variáveis tem sofrido alterações não previsiveis
  // nas últimas atualizações do Profit
  fMaximoAtual := fMaximoAtual[1];
  fMinimoAtual := fMinimoAtual[1];
  iContadorRompimentos := iContadorRompimentos[1];
  fTopoFundoConfirmado := fTopoFundoConfirmado[1];
  iIdentUltimaBarraIdentificada := iIdentUltimaBarraIdentificada[1];

  // ---------------------------------------------------------------------
  // --------------------- Cálculo do indicador  -------------------------
  // OBS: Inserir lógica de cálculo do indicador e caso ele possa ser plo_
  // tado, atribuir em algum momento True para variável bPlotIndicador
  // ---------------------------------------------------------------------

  // Inicialização do algoritmo quando tem dados suficientes
  if CurrentBar = 1 then
    begin
      fMaximoAtual := High[1];
      fMinimoAtual := Low[1];
      iMaximoAtual := CurrentBar;
      iMinimoAtual := CurrentBar;
      iIdentUltimaBarraIdentificada := -1*(CurrentBar-1);
    end;

  // Algoritmo inicia execução
  // Última confirmação do indicador foi um topo
  if (iIdentUltimaBarraIdentificada > 0) then
    begin
      // Atualiza o valor mínimo atual
      if Low < fMinimoAtual then 
      begin
        fMinimoAtual := Low;  
        iMinimoAtual := CurrentBar;
        iContadorRompimentos := 0;
      end;

      if High > High[CurrentBar-iMinimoAtual] then iContadorRompimentos := iContadorRompimentos + 1;

      // Verifica se houve pQtdeRompimentos do valor máximo da barra de referencia
      // A barra de referência é aquela com o menor valor mínimo até o momento
      if (iContadorRompimentos = pQtdeRompimentos) 
      // Ou volatilidade da barra excedeu o range anterior entre topos e fundos
      or (High > fMaximoAtual)
      then
      begin
        // Plota o fundo identificado, atualiza o índice da barra de fundo com valor negativo (economia de memória)
        // e estabelece um valor inicial para o máximo atual
        fTopoFundoConfirmado := fMinimoAtual;
        plot(fTopoFundoConfirmado);
        iIdentUltimaBarraIdentificada := -1*CurrentBar;
        fMaximoAtual := High;
        iMaximoAtual := CurrentBar;
        //PaintBar(clGreen);
        if pExibirTextoConfirmacao then PlotText(fTopoFundoConfirmado,clGreen,-1,9);
        iContadorRompimentos := 0;
      end;
    end

  // Última confirmação do indicador foi um fundo
  else
  begin
    // Atualiza o valor máximo atual
    if High > fMaximoAtual then 
    begin
      fMaximoAtual := High;
      iMaximoAtual := CurrentBar;
      iContadorRompimentos := 0;
    end;

    if Low < Low[CurrentBar-iMaximoAtual] then iContadorRompimentos := iContadorRompimentos + 1;

    // Verifica se houve pQtdeRompimentos do valor máximo da barra de referencia
    // A barra de referência é aquela com o menor valor mínimo até o momento      
    if (iContadorRompimentos = pQtdeRompimentos) 
    // Ou volatilidade da barra excedeu o range anterior entre topos e fundos
    or (Low < fMinimoAtual)
    then
    begin                                                          
      // Plota o topo identificado, atualiza o índice da barra de topo com valor positivo (economia de memória)
      // e estabelece um valor inicial para o mínimo atual
      fTopoFundoConfirmado := fMaximoAtual;
      plot(fTopoFundoConfirmado);
      iIdentUltimaBarraIdentificada := CurrentBar;
      fMinimoAtual := Low;
      iMinimoAtual := CurrentBar;
      //PaintBar(clRed);
      if pExibirTextoConfirmacao then PlotText(fTopoFundoConfirmado,clRed,-1,9);
      iContadorRompimentos := 0;
    end;
  end;


  //
  // ---------------------------------------------------------------------
  // ------------------ Plota valores do indicador -----------------------
  // OBS: A série de confirmação de topo/fundo (1) é plotada na lógica do indicador.
  // Abaixo são plotadas as séries de valor máximo e mínimo atual, séries 2 e 3, respectivamente.
  // ---------------------------------------------------------------------
  plot2(fMaximoAtual);
  plot3(fMinimoAtual);

  // Configura estilo dos plots 
  SetPlotWidth(1,2);
  SetPlotWidth(2,2);
  SetPlotWidth(3,2);
  SetPlotColor(2,clRed);
  SetPlotColor(3,clGreen);
  SetPlotStyle(2,psDash);
  SetPlotStyle(3,psDash);

  //Modo de uso para chamada em NTSL a partir de outras estratégias
  //Não plota nenhuma série no gráfico
  if pModoPlot = 0 then
  begin
    NoPlot(2);
    NoPlot(3);
  end;  
 
  //Plota topo/fundo confirmado e em detecção
  if pModoPlot = 1 then NoPlot(1);

  //Plota apenas o topo/fundo que está em detecção no momento, não plota confirmação
  if pModoPlot = 2 then
  begin
    NoPlot(1);
    //Buscando confirmação de fundo
    if iIdentUltimaBarraIdentificada > 0 then NoPlot(2)
    else NoPlot(3);
  end;

end;

@admin John, Incrível! 

Ficou extraordinário.
Com seu código agora posso desenvolver as "1400" lógicas que tinha antes, mas com o indicador nativo.
O fato de vermos a condição de topos e fundos sendo criada no momento, mesmo que com atraso nos dá um 'time' de antecipação, por incrível que pareça.
Que trabalho fantástico. Você não tem ideia de como me ajudou. 

Como posso retribuir? 

Forte abraço!

Que bom que vai te ajudar!

Quando idealizei essa Comunidade foi justamente com esse propósito. Estou ainda trabalhando em uma modificação para colocar esse indicador na Loja de Estratégias do Profit. Observe que o código considera o rompimento do candle de referência X vezes. Vou colocar uma alteração para toda vez que o candle de referência for rompido, o novo valor de referencia de rompimento seja do candle que rompeu. Será um parâmetro a mais na estratégia.

Só de você acompanhar e participar aqui do Projeto já está contribuindo. Mas se no futuro, precisar comprar uma camiseta para fazer atividade física ou para o dia a dia, considere apoiar a NeoTraderBot dessa forma, doando e ganhando de brinde uma camiseta! (Sem obrigação nenhuma...fique a vontade..se e quando quiser!)

Grande abs!

@admin John, Já tentei fazer isso... acredito que consegui (não vi se há alguma inconsistência na lógica que apliquei).

Veja até onde cheguei, se houver algo errado, me deixe saber, por gentileza. Segue: 

input
pQtdeRompimentos(5);
pModoPlot(2);
pExibirTextoConfirmacao(false);
var
iIdentUltimaBarraIdentificada : integer;
fMaximoAtual,fMinimoAtual : float;
iMaximoAtual, iMinimoAtual: integer;
fTopoFundoConfirmado: float;
iContadorRompimentos: integer;
Curr: integer;

Meio, meio2, teste : float;
begin

fMaximoAtual := fMaximoAtual[1];
fMinimoAtual := fMinimoAtual[1];
iContadorRompimentos := iContadorRompimentos[1];
fTopoFundoConfirmado := fTopoFundoConfirmado[1];
iIdentUltimaBarraIdentificada := iIdentUltimaBarraIdentificada[1];

if CurrentBar = 1 then
begin
fMaximoAtual := High[1];
fMinimoAtual := Low[1];
iMaximoAtual := CurrentBar;
iMinimoAtual := CurrentBar;
iIdentUltimaBarraIdentificada := -1*(CurrentBar-1);
end;

if (iIdentUltimaBarraIdentificada > 0) then
begin
if Low < fMinimoAtual then
begin
fMinimoAtual := Low;
iMinimoAtual := CurrentBar;
iContadorRompimentos := 0;
end;

if High > High[CurrentBar-iMinimoAtual] then
begin
fMaximoAtual := High;
iMaximoAtual := CurrentBar;
iContadorRompimentos := iContadorRompimentos + 1;
end;

if (iContadorRompimentos = pQtdeRompimentos)
or (High > fMaximoAtual)
then
begin
fTopoFundoConfirmado := fMinimoAtual;
plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := -1*CurrentBar;
PaintBar(clGreen);
if pExibirTextoConfirmacao then PlotText(fTopoFundoConfirmado,clGreen,-1,9);
iContadorRompimentos := 0;
end;
end
else
begin
if High > fMaximoAtual then
begin
fMaximoAtual := High;
iMaximoAtual := CurrentBar;
iContadorRompimentos := 0;
end;

if Low < Low[CurrentBar-iMaximoAtual] then
begin
fMinimoAtual := Low;
iMinimoAtual := CurrentBar;
iContadorRompimentos := iContadorRompimentos + 1;
end;

if (iContadorRompimentos = pQtdeRompimentos)
or (Low < fMinimoAtual)
then
begin
fTopoFundoConfirmado := fMaximoAtual;
plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := CurrentBar;
PaintBar(clRed);
if pExibirTextoConfirmacao then PlotText(fTopoFundoConfirmado,clRed,-1,9);
iContadorRompimentos := 0;
end;
end;

plot2(fMaximoAtual);
plot3(fMinimoAtual);

Meio:= (fTopoFundoConfirmado+fTopoFundoConfirmado)/2;
PLot4 (meio);
Meio2:= (fMaximoAtual+fMinimoAtual)/2;
// PLot5 (vmasimple(2,meio2));
// Configura estilo dos plots
SetPlotWidth(1,2);
SetPlotWidth(2,2);
SetPlotWidth(3,2);
SetPlotColor(2,clRed);
SetPlotColor(3,clGreen);
SetPlotStyle(2,psDash);
SetPlotStyle(3,psDash);

//Modo de uso para chamada em NTSL a partir de outras estratégias
//Não plota nenhuma série no gráfico
if pModoPlot = 0 then
begin
NoPlot(2);
NoPlot(3);
end;

//Plota topo/fundo confirmado e em detecção
if pModoPlot = 1 then NoPlot(1);

//Plota apenas o topo/fundo que está em detecção no momento, não plota confirmação
if pModoPlot = 2 then
begin
NoPlot(1);
//Buscando confirmação de fundo
if iIdentUltimaBarraIdentificada > 0 then NoPlot(2)
else NoPlot(3);
end;
End;

Abs!

Prezados Pedro Henrique e John

Conheci esse indicador lá no Youtube. De lá fiquei curioso e cheguei aqui no fórum, achando essa conversa de vocês. Caramba, vocês fizeram um indicador muito top. Parabéns pelo trabalho dos dois. Ficou muito bom mesmo. Uma pena que não conheci esse trabalho antes. 

Eu trabalho com renko e venho, a algum tempo, desenvolvendo uma biblioteca de padrões de renko que até o momento estão me dando uma boa lucratividade. Essa não é minha atividade principal, pois tenho 2 empresas e, nos momentos "livres", principalmente entre 10 e 14hs, paro para operar na bolsa usando essa minha estratégia de padrões.

Contudo, a algum tempo venho buscando formas de implementar a ideia de topo/fundo previsto para melhorar meus padrões. Infelizmente o indicador da Nelogica é atrasado, de acordo com a configuração. Esse indicador desenvolvido por vocês já faz um excelente trabalho, diminuindo esse atraso. Contudo, para adiciona-lo ao meu setup, ele precisaria de algumas modificações, que cito a seguir:

1. Descontinuidade dos valores de fMaximoAtual / fMinimoAtual - a ideia aqui seria indicar que, quando o fMaximoAtual estivesse ativo, o fMinimoAtual seria nulo, e vice-versa. Desse modo teríamos apenas linhas continuas limitando o mínimo e o máximo atual.

2. Configuração de seleção da resposta de interesse - a ideia seria chamar o indicador em outro, onde seria realizada a chamada por variável especifica, semelhante ao que acontece com com a variável fMACD := MACD(26, 12, 9)|1|, que recebe o valor do histograma, indicado pelo |1|, e não o valor da linha, que é indicada pelo |0|.

Será que existe alguma forma de implementar essas ideias?

E John, assim como o Pedro falou, nada mais justo que um usuário que se beneficia dos conhecimentos adquiridos no fórum, encontrar uma maneira de recompensar o site e/ou a comunidade. Independente da resposta a esse meu comentário, só pelo conhecimento já adquirido, também vou retribuir para ganhar uma camiseta. Mas quero dar outra contribuição: Porque você não produz uma pequena quantidade de camisetas e disponibiliza na shopee? Para aqueles que quiserem comprar avulso, vai lá e realiza a compra. Para aqueles que querem contribuir, faz o pix no valor de R$ 75,00 ou mais. Uma vez confirmado, você gera um cupom para o contribuinte e ele fará a "compra" na shopee. O cupom dará a gratuidade da camiseta e, juntamente com isso, o frete também ficará gratuito para o usuário.. Assim todos ganham... entende? O que vc acha?

Postado por: @pedro-henrique-t-de-carvalho

↑

input
// pGatilhoDeteccao(5.0);
// pQtdePeriodosAnaliseVolat(100);
periodo(5);
// ---------------------------------------------------------------------
// ---------------------- Variáveis globais ----------------------------
// ---------------------------------------------------------------------
var
iIdentUltimaBarraIdentificada : integer;
fMaximoAtual,fMinimoAtual : float;
fVolatilidadeMedia: float;
fTopoFundoConfirmado: float;
Meio: float;
begin
// ---------------------------------------------------------------------
// ------------ Atribuição de variáveis por processamento --------------
// ---------------------------------------------------------------------
// Manutenção de valor da variável entre processamentos da estratégia
// O comportamento de retenção de valor das variáveis tem sofrido alterações não previsiveis
// nas últimas atualizações do Profit
iIdentUltimaBarraIdentificada := iIdentUltimaBarraIdentificada[1];
{ fVolatilidadeMedia := (Summation(High,pQtdePeriodosAnaliseVolat)-Summation(Low,pQtdePeriodosAnaliseVolat))
/pQtdePeriodosAnaliseVolat; }

// ---------------------------------------------------------------------
// --------------------- Cálculo do indicador -------------------------
// OBS: Inserir lógica de cálculo do indicador e caso ele possa ser plo_
// tado, atribuir em algum momento True para variável bPlotIndicador
// ---------------------------------------------------------------------

// Inicialização do algoritmo quando tem dados suficientes
// Inicialização do algoritmo quando tem dados suficientes
{ if CurrentBar = pQtdePeriodosAnaliseVolat then
begin
fMaximoAtual := High[1];
fMinimoAtual := Low[1]; }

//Tentei aplicar a nova lógica aqui abaixo

begin
IF low < low[periodo] then
Begin

fMaximoAtual := High[periodo +1];

IF high > high[1] then
Begin
fMinimoAtual := Low[periodo+1];

iIdentUltimaBarraIdentificada := -1*(CurrentBar-1);
end;

// Algoritmo inicia execução
if CurrentBar > pQtdePeriodosAnaliseVolat then
begin
// Última confirmação do indicador foi um topo
if (iIdentUltimaBarraIdentificada > 0) then
begin
// Verifica se houve retração de preço em relação ao valor mínimo atual maior do que o gatilho do parâmetro de entrada
if (High >= (fMinimoAtual + pGatilhoDeteccao*fVolatilidadeMedia)) then
begin
// Plota o fundo identificado, atualiza o índice da barra de fundo com valor negativo (economia de memória)
// e estabelece um valor inicial para o máximo atual
fTopoFundoConfirmado := Lowest(Low,CurrentBar - Round(Abs(iIdentUltimaBarraIdentificada)) + 1);
// plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := -1*CurrentBar;
fMaximoAtual := High;
//PaintBar(clGreen);
// PlotText(fTopoFundoConfirmado,clGreen,-1,9);
end;
// Atualiza o valor mínimo atual
if Low < fMinimoAtual then fMinimoAtual := Low;
end

// Última confirmação do indicador foi um fundo
else
begin
// Verifica se houve retração de preço em relação ao valor máximo atual maior do que o gatilho do parâmetro de entrada
if (Low <= (fMaximoAtual - pGatilhoDeteccao*fVolatilidadeMedia2)) then
begin
// Plota o topo identificado, atualiza o índice da barra de topo com valor positivo (economia de memória)
// e estabelece um valor inicial para o mínimo atual
fTopoFundoConfirmado := Highest(High,CurrentBar - Round(Abs(iIdentUltimaBarraIdentificada)) + 1);
// plot(fTopoFundoConfirmado);
iIdentUltimaBarraIdentificada := CurrentBar;
fMinimoAtual := Low;
//PaintBar(clRed);
// PlotText(fTopoFundoConfirmado,clRed,-1,9);
end;
// Atualiza o valor máximo atual
if High > fMaximoAtual then fMaximoAtual := High;
end;
end;

//
// ---------------------------------------------------------------------
// ------------------ Plota valores do indicador -----------------------
// OBS: A série de confirmação de topo/fundo (1) é plotada na lógica do indicador.
// Abaixo são plotadas as séries de valor máximo e mínimo atual, séries 2 e 3, respectivamente.
// ---------------------------------------------------------------------
// Configura plot do valor de confirmação de topo/fundo
SetPlotWidth(1,2);

// Indicador também calcula as séries de valor máximo e mínimo atual
plot2(fMaximoAtual);
SetPlotColor(2,clRed);
SetPlotWidth(2,2);
SetPlotStyle(2,psDash);
plot3(fMinimoAtual);
SetPlotColor(3,clGreen);
SetPlotWidth(3,2);
SetPlotStyle(3,psDash);

//end;
Meio:= ( fMinimoAtual + fMaximoAtual)/2;
// Meio:= ( fTopoFundoConfirmado +fTopoFundoConfirmado[1])/2;

// Acrescentei um meio para ver se ele ajuda a orientar, mas sem êxito. 
//begin
plot5(meio);

If close > meio then paintbar (cllime);
If close < meio then paintbar (clred);

end;
end;
end;
end;