Indicador de força e direção da tendência em barras 3D

Introdução

Pode parecer que não há mais nada novo a descobrir nas velhas velas. Tudo já foi descoberto, calculado, digitalizado. Mas bastou olhar para o mercado de outro ângulo para ele se revelar de uma forma totalmente inesperada.

Imagine que você não está vendo o gráfico como uma imagem plana, mas como um organismo vivo e pulsante. Onde cada barra não é apenas um retângulo com sombras, mas uma estrutura volumétrica, pulsando no ritmo do coração do mercado. Foi assim que nasceu a ideia de barras 3D. No início era apenas um experimento de visualização, pois queria ver os dados de um jeito diferente. Porém, quanto mais eu me aprofundava nas pesquisas, mais claramente surgiam padrões surpreendentes.

Lembro do momento em que vi pela primeira vez o "cluster amarelo". No gráfico tridimensional ele literalmente brilhava, anunciando a reversão da tendência. No começo achei que fosse coincidência. Mas o padrão se repetia, e com uma precisão impressionante indicava os movimentos futuros do preço. Seis meses de pesquisa ininterrupta, centenas de noites sem dormir, milhares de linhas de código. Tudo isso foi se transformando aos poucos em um modelo matemático coerente.

Agora, ao analisar os resultados dos testes, percebo que realmente tocamos em algo importante. Algo que está na própria estrutura do mercado, na sua essência mais profunda. A análise técnica clássica é inútil aqui, pois esses padrões só podem ser vistos pela lente da análise tensora, apenas ao subir acima da superfície do gráfico para a terceira dimensão.

Neste artigo quero compartilhar essa descoberta. Mostrar como dados de mercado comuns, quando vistos sob uma nova perspectiva, podem nos fornecer sinais incrivelmente precisos sobre a força e a direção da tendência. E não depois do fato, mas com antecedência, quando ainda há tempo para entrar na posição e esperar o movimento. Aperte os cintos. Vamos embarcar numa jornada pelo mercado tridimensional.

Estrutura do tensor básico do estado do mercado

Sabe como na infância montávamos o cubo mágico? No início parece um caos total. Mas basta entender o princípio, e todas as faces começam a se encaixar numa imagem só. Aqui é a mesma coisa. Comecei a reunir os dados em uma estrutura tridimensional, um tensor. Parece complicado, mas no fundo é só um jeito de ver como o preço, o volume e o tempo se influenciam.

Os primeiros experimentos foram... digamos assim, pouco impressionantes. A matemática simplesmente não queria se ajustar a uma fórmula bonita, aquele fluxo infinito de números era irritante. E então... então eu simplesmente parei de vê-los como números.

Imagine que cada vela não é apenas um conjunto de valores open-high-low-close, mas um organismo vivo. Ele tem volume, como massa corporal. Tem impulso. Como movimento. E tem uma estrutura interna, como DNA. Quando comecei a olhar para os dados desse jeito, tudo fez sentido.

No final, saiu esse "cubo":

• Uma face que reúne dados de preços clássicos.
• A segunda representa volumes, mas não apenas quantidade de negócios, e sim sua estrutura interna
• A terceira é composta por ciclos temporais, que por muito tempo eu não conseguia captar

O mais surpreendente começou quando executei o primeiro teste desse modelo. O gráfico... ele literalmente ganhou vida. Onde antes eu via apenas linhas, agora surgia uma estrutura volumétrica nítida. E ela se movia! Como se pulsasse no ritmo de algum compasso interno do mercado.

Mas o mais importante é que essa estrutura começou a mostrar padrões estranhos. No início achei que fossem artefatos da visualização. Mas quanto mais dados eu passava pelo modelo, mais clara se tornava a regularidade. Esses padrões apareciam pouco antes de movimentos fortes de preço. Como se o mercado... estivesse avisando suas intenções?

Vamos agora para como eu unifiquei esses dados numa base comum. Isso é outra história, e começou com uma descoberta por acaso nos antigos estudos de Gann...

Normalização de dados pelo método de Gann

Topar com os estudos de Gann foi puro acaso. Eu folheava arquivos PDF antigos à procura de outro material, e de repente os olhos pararam em seus gráficos estranhos. Quadrados, ângulos, umas espirais... À primeira impressão, parecia apenas mais um místico de mercado. Mas algo me fez ir mais fundo. Escrevi um artigo sobre os métodos de Gann.

E sabe de uma coisa? Por trás de toda aquela parafernália geométrica havia uma ideia incrivelmente elegante de normalização de dados. Gann, por intuição, encontrou o que eu tentava alcançar matematicamente: o princípio da invariância de escala do mercado.

Passei três semanas mergulhado em suas anotações. Metade delas precisei descartar como pura esotérica. Mas na parte que restava... caramba, havia algo verdadeiro ali! O que mais me chamou atenção foi a abordagem dele para os ciclos temporais. Lembro de pular da cama no meio da noite e correr para o computador, tomado por uma súbita intuição.

Acontece que, ao escalar corretamente os intervalos de tempo, o mercado começava a revelar uma estrutura quase cristalina. É como olhar um floco de neve no microscópio; a cada novo nível de zoom, os mesmos padrões surgiam em outra escala.

Peguei os princípios básicos dele e adaptei para o meu modelo. Em vez dos números "mágicos" de Gann, usei coeficientes dinâmicos calculados com base na volatilidade. Cada parâmetro do tensor agora era normalizado não por uma escala fixa, mas por uma faixa "flutuante", que se ajustava automaticamente ao estado atual do mercado.

Era como afinar um instrumento musical. Sabe aquela sensação quando as cordas finalmente entram em harmonia? Foi mais ou menos isso que senti ao ver os primeiros resultados. O gráfico parou de se desmanchar em partes. Ele passou a respirar como um todo único.

O mais difícil foi encontrar o equilíbrio certo entre a sensibilidade da normalização e a robustez do modelo. Se ajustar demais, o sistema reage ao ruído do mercado. Se ajustar de menos, perde sinais importantes. Passei duas semanas ajustando esses parâmetros até encontrar o ponto ideal.

Mas o verdadeiro avanço veio quando apliquei essa normalização à componente volumétrica da tendência. E foi aí que começou a parte mais interessante...

Cálculo da componente volumétrica da tendência

É aqui que começa a parte mais interessante. Depois da normalização dos dados, me deparei com um problema inesperado, e é que os indicadores clássicos de volume simplesmente "não enxergavam" os momentos-chave de reversão de tendência. Lembro que perdi uma semana tentando modificar OBV e MFI. O resultado foi... mais ou menos.

E então, fuçando o código-fonte de um indicador antigo (o autor nem é mais encontrável), encontrei uma abordagem interessante para calcular o perfil de volume. A ideia era simples e genial: olhar não para os valores absolutos de volume, mas para sua relação com a média móvel. Aqui está meu código:

def _calculate_components(self, df: pd.DataFrame) -> pd.DataFrame:
    # Базовые компоненты
    df['volatility'] = df['close'].pct_change().rolling(20).std()
    df['momentum'] = df['close'].pct_change(5)
    
    # Вот оно, ключевое место - объемный профиль
    df['volume_ma'] = df['tick_volume'].rolling(20).mean()
    df['volume_trend'] = df['tick_volume'] / df['volume_ma']
    
    # Сила тренда как производная трех компонент
    df['trend_force'] = df['volatility'] * df['volume_trend'] * abs(df['momentum'])

Veja o que está acontecendo aqui. Em vez de simplesmente somar os volumes, criamos algo como uma "aceleração de volume". Quando o volume dispara em relação à sua média é o primeiro sinal de alerta. Mas o mais interessante começa quando sobrepomos volatilidade e momentum a isso.

Testei uma porção de períodos para médias móveis. 10, 15, 25... No fim, foram justamente 20 barras que trouxeram o melhor equilíbrio entre sensibilidade e estabilidade dos sinais. 

Mas o verdadeiro "efeito uau" aconteceu quando adicionei o coeficiente das sessões de negociação:

# Коэффициенты активности разных сессий
df['session_coef'] = 1.0
hour = df.index.hour
        
df.loc[(hour >= 0) & (hour < 8), 'session_coef'] = 0.7    # Азиатская
df.loc[(hour >= 8) & (hour < 16), 'session_coef'] = 1.0   # Европейская
df.loc[(hour >= 16) & (hour < 24), 'session_coef'] = 0.9  # Американская

O gráfico literalmente ganhou vida. Agora cada pico de volume era analisado no contexto da sessão atual. Sabe como na natureza há marés? Aqui também cada sessão tem seu caráter, sua "força gravitacional".

Mas o mais importante é que essa fórmula começou a revelar o que chamei de "presságios". Algumas barras antes de um movimento forte, o perfil de volume começava a formar um padrão característico. Como se o mercado "tomasse fôlego" antes de saltar.

E então veio a questão de como visualizar tudo isso da forma correta...

Dinâmica de preço em espaço tridimensional

Levei bastante tempo até encontrar a forma certa de visualizar toda essa loucura. As primeiras tentativas de montar um gráfico 3D com MatPlotLib pareciam mais uma árvore de Natal do que algo útil para trading. O Plotly também não colaborou de cara, até porque os gráficos ficavam ou muito carregados ou perdiam detalhes importantes.

E aí, o acaso ajudou. Brincando de montar com minha filha, construíamos algo como uma ponte, e de repente entendi que não precisamos de toda essa parafernália de 3D sofisticado. Basta posicionar bem as projeções! Olha só o que consegui:

def create_visualization(self, df: pd.DataFrame = None):
    if df is None:
        df = self.analyze_market()
    
    df = df.reset_index()
            
    # Три проекции нашего "моста"
    fig = make_subplots(rows=3, cols=1, 
                       shared_xaxes=True,
                       subplot_titles=('Price', 'Trend Force', 'Trend Direction'),
                       row_heights=[0.5, 0.25, 0.25],
                       vertical_spacing=0.05)

    # Основной график - классические свечи
    fig.add_trace(
        go.Candlestick(
            x=df['time'],
            open=df['open'],
            high=df['high'],
            low=df['low'],
            close=df['close'],
            name='OHLC'
        ),
        row=1, col=1
    )

Veja o que acontece, pegamos três projeções do mesmo espaço. A de cima mostra as velas tradicionais, mas isso é só a ponta do iceberg. O mais interessante está na segunda janela:

# Сила тренда - наша основная фишка
    fig.add_trace(
        go.Scatter(
            x=df['time'],
            y=df['trend_force_adjusted'],
            mode='lines',
            line=dict(color='blue', width=2),
            name='Trend Force'
        ),
        row=2, col=1
    )

    # Опорные уровни
    fig.add_hline(y=3, line_dash="dash", line_color="yellow", row=2, col=1)
    fig.add_hline(y=6, line_dash="dash", line_color="green", row=2, col=1)

Esses níveis (3 e 6) foram descobertos por tentativa e erro. Quando a força da tendência ultrapassa o nível 6, quase sempre significa um movimento forte. O nível 3 é como uma zona de turbulência, onde a tendência pode tanto se intensificar quanto se inverter.

Mas a verdadeira mágica acontece na janela inferior:

# Направление тренда как производная силы
    fig.add_trace(
        go.Bar(
            x=df['time'],
            y=df['trend_direction'] * df['trend_force_adjusted'],
            name='Trend Direction',
            marker_color=np.where(df['trend_direction'] > 0, 'green', 'red')
        ),
        row=3, col=1
    )

Aqui não vemos apenas a direção da tendência, mas sua força em dinâmica. Quando os bastões verdes crescem junto com um alto valor de Trend Force é um sinal forte de compra. E o contrário: bastões vermelhos crescendo com força acima de 6 é sinal certo de venda.

Mas vamos voltar à realidade. Depois da visualização, surgiu a questão dos ciclos temporais...

Componente temporal e sessões de negociação

Sabe o que sempre me surpreendeu na análise técnica clássica? O quanto é fácil todos esquecerem do tempo. Sim, do tempo, no sentido mais básico! Olham os gráficos, calculam indicadores, mas ignoram o simples fato de que o mercado vive em diferentes fusos horários.

O primeiro sinal de alerta apareceu quando notei uma regularidade estranha, meus sinais funcionavam muito melhor na sessão europeia. No começo considerei que fosse coincidência. Mas então comecei a investigar mais a fundo, e veja o que descobri:

# Смотрите, как просто оказалось учесть влияние сессий
hour = df.index.hour

# Азиатская сессия - самая спокойная
asian_mask = (hour >= 0) & (hour < 8)
df.loc[asian_mask, 'session_coef'] = 0.7    

# Европа - пик активности
european_mask = (hour >= 8) & (hour < 16)
df.loc[european_mask, 'session_coef'] = 1.0  

# Америка - всё ещё активно, но уже не так сильно
american_mask = (hour >= 16) & (hour < 24)
df.loc[american_mask, 'session_coef'] = 0.9

Esses coeficientes eu ajustei literalmente "no chute", testando várias possibilidades. Lembro de passar a noite inteira rodando backtests com diferentes valores. Minha esposa já me chamava para dormir, e eu não conseguia largar o monitor, pois os resultados eram fascinantes demais.

Mas o mais interessante aconteceu quando apliquei esses coeficientes ao perfil de volume. De repente, tudo fez sentido! Descobri que o mesmo volume, em sessões diferentes, tem "peso" completamente distinto:

• Na sessão asiática, até um pequeno pico de volume pode ser significativo
• Na europeia, são necessárias variações bem mais intensas
• E na transição entre sessões... algo totalmente diferente acontece

Mas o verdadeiro avanço veio quando adicionei mais um componente, nomeadamente as "transições entre sessões". Percebi que, cerca de 30 a 40 minutos antes da abertura de uma nova sessão, o indicador começava a se comportar... de forma estranha. Como se o mercado estivesse se preparando para a chegada de novos participantes. E foi aí que...

Indicador integral de força da tendência

Às vezes, as descobertas mais importantes vêm de erros bobos. No meu caso, tudo começou com um bug no código. Acabei multiplicando as variáveis erradas, e o gráfico mostrou uma anomalia maluca. A primeira reação foi reescrever tudo, mas algo me fez olhar com mais atenção...

Descobri que, sem querer, tinha criado o que depois chamei de "indicador integral". Veja só:

def _calculate_components(self, df: pd.DataFrame) -> pd.DataFrame:
    # Вот она, та самая "ошибка" - перемножение трех компонент
    df['trend_force'] = df['volatility'] * df['volume_trend'] * abs(df['momentum'])
    
    # Нормализация результата в диапазон от 3 до 9
    df['trend_force_norm'] = self.scaler.fit_transform(
        df['trend_force'].values.reshape(-1, 1)
    ).flatten()
    
    # Финальная корректировка с учетом сессий
    df['trend_force_adjusted'] = df['trend_force_norm'] * df['session_coef']

Sabe o que está acontecendo aqui? Volatilidade multiplicada pela tendência de volume e pelo valor absoluto do momentum. Na teoria, isso devia virar um caos total. Na prática... Na prática surgiu um indicador surpreendentemente claro de força da tendência!

Lembro do meu espanto ao testar essa fórmula com dados históricos. O gráfico mostrava picos exatos nos momentos em que começavam movimentos fortes. E não depois do fato, mas algumas barras antes de o movimento começar!

A coisa ficou ainda mais interessante quando apliquei a normalização com MinMaxScaler. Escolhi o intervalo de 3 a 9 quase aleatoriamente, já que só achei que assim o gráfico ficaria mais legível. E de repente percebi que esses números formavam níveis quase perfeitos para tomar decisões:

• Abaixo de 3, o mercado está "adormecido"
• Entre 3 e 6, o movimento está começando
• Acima de 6, a tendência atingiu força total

E quando sobrepus os coeficientes das sessões a isso... Foi aí que a festa começou de verdade! Os sinais ficaram tão precisos que até meu vizinho trader, sempre cético, assobiou ao ver os backtests.

Mas a maior descoberta ainda estava por vir. Descobri que esse indicador não só mede a força da tendência. Ele pode prever reversões...

Determinação da direção do movimento futuro

Depois de descobrir o indicador integral, fiquei literalmente obcecado por encontrar padrões de reversão. Passei semanas colado ao monitor, rodando os gráficos para frente e para trás. Minha esposa já estava ficando preocupada, até porque eu até esquecia de comer quando encontrava algo interessante.

E foi numa dessas noites (por que todas as descobertas importantes acontecem de madrugada?) que notei uma regularidade estranha. Antes de fortes reversões de tendência, o indicador de força começava a... não, não a cair, como se poderia imaginar. Ele começava a oscilar de um jeito específico:

# Определение направления тренда
df['trend_direction'] = np.sign(df['momentum'])

# Тут магия и начинается
df['direction_strength'] = df['trend_direction'] * df['trend_force_adjusted']

# Ищем паттерны разворота
df['reversal_pattern'] = np.where(
    (df['trend_force_adjusted'] > 6) &  # Сильный тренд
    (df['direction_strength'].diff().rolling(3).std() > 1.5),  # Нестабильность направления
    1, 0
)

Veja o que acontece: quando a força da tendência ultrapassa o nível 6 (lembra da nossa normalização?), mas a direção se torna instável, o que quase sempre antecipa uma reversão!

Passei duas semanas verificando essa observação em diferentes timeframes e ativos. Funcionava em todos, mas especialmente bem nos H1 e H4. Como se fosse nesses períodos que o mercado "pensasse" de forma mais racional.

Mas o verdadeiro insight veio quando sobrepus o perfil de volume:

df['volume_confirmation'] = np.where(
    (df['reversal_pattern'] == 1) &
    (df['volume_trend'] > df['volume_trend'].rolling(20).mean() * 1.5),
    'Strong',
    'Weak'
)

Aí tudo fez sentido! Descobri que nem toda reversão é igual. Quando o padrão coincide com um volume fortemente acima da média é quase uma reversão garantida. Mas se o volume não acompanha, provavelmente é só uma correção.

Lembro quando mostrei esses resultados para meu antigo professor de estatística. Ele ficou um tempo encarando as fórmulas, depois levantou os olhos e perguntou: "Você testou isso com dados anteriores a 2020?" Assenti com a cabeça. "E posteriores?" De novo, assenti. "Hm... Sabe, tem algo aí. Isso contradiz o passeio aleatório, mas... é assustadoramente convincente!"

Claro, nem tudo era perfeito, pois havia sinais falsos. Mas para isso eu já tinha um sistema de filtragem pronto...

Visualização dos sinais no gráfico

Quando todos os componentes do indicador estavam prontos, surgiu a pergunta: como mostrar isso para o trader? Nem todo mundo quer (ou consegue) entender fórmulas e tabelas. Lutei bastante com isso até que surgiu a ideia da visualização em três camadas.

As primeiras tentativas só com MatPlotLib foram... digamos, difíceis. Era preciso forçar os olhos para entender onde estava o sinal. Experimentei umas dez bibliotecas até decidir pelo Plotly. E aqui está o resultado final:

def create_visualization(self, df: pd.DataFrame = None):
    if df is None:
        df = self.analyze_market()
    
    fig = make_subplots(rows=3, cols=1, 
                       shared_xaxes=True,
                       subplot_titles=('Price', 'Trend Force', 'Trend Direction'),
                       row_heights=[0.5, 0.25, 0.25],
                       vertical_spacing=0.05)

    # Основной график - свечи с подсветкой сигналов
    fig.add_trace(
        go.Candlestick(
            x=df['time'],
            open=df['open'],
            high=df['high'],
            low=df['low'],
            close=df['close'],
            name='OHLC',
            hoverlabel=dict(
                bgcolor='white',
                font=dict(size=12)
            )
        ),
        row=1, col=1
    )

Mas o destaque ficou por conta da interatividade. Ao passar o cursor sobre a vela, aparecem todos os parâmetros: força da tendência, volumes, direção. E a paleta de cores... Passei uma semana escolhendo tons para não cansar os olhos:

fig.add_trace(
        go.Scatter(
            x=df['time'],
            y=df['trend_force_adjusted'],
            mode='lines',
            line=dict(color='blue', width=2),
            name='Trend Force',
            hovertemplate="<br>".join([
                "Time: %{x}",
                "Force: %{y:.2f}",
                "<extra></extra>"
            ])
        ),
        row=2, col=1
    )

Uma parte separada era a visualização da direção da tendência. Fiz em forma de barras, onde a altura mostra a força e a cor, a direção:

fig.add_trace(
        go.Bar(
            x=df['time'],
            y=df['trend_direction'] * df['trend_force_adjusted'],
            name='Trend Direction',
            marker_color=np.where(df['trend_direction'] > 0, 'green', 'red'),
        ),
        row=3, col=1
    )

Lembro da reação de um amigo trader quando mostrei a versão final. Ficou uns cinco minutos clicando no gráfico em silêncio, depois disse: "Cara, até um iniciante agora consegue entender para onde o mercado vai!"

Mas o mais gratificante foi quando começaram a chegar os feedbacks de usuários reais. Teve gente dizendo que finalmente parou de se confundir com os sinais. Teve quem agradeceu por conseguir operar sem ficar grudado na tela por horas...

Vamos tentar implementar o indicador de força da tendência no MetaTrader 5

Depois do sucesso com a versão em Python, surgiu a pergunta lógica: como portar isso para o MetaTrader 5?

A tarefa se mostrou... interessante. O MQL5 é sim uma linguagem poderosa, mas sem pandas nem numpy, tive que improvisar bastante. Olha só o que consegui:

//+------------------------------------------------------------------+
//|                                          TrendForceIndicator.mq5 |
//+------------------------------------------------------------------+
#property copyright "Your Name"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 3
#property indicator_plots   3

// Буферы для отрисовки
double TrendForceBuffer[];
double DirectionBuffer[];
double SignalBuffer[];

// Входные параметры
input int    InpMAPeriod = 20;     // Период сглаживания
input int    InpMomentumPeriod = 5; // Период для моментума
input double InpSignalLevel = 6.0;  // Уровень сигнала

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
    // Настройка индикатора
    SetIndexBuffer(0, TrendForceBuffer, INDICATOR_DATA);
    SetIndexBuffer(1, DirectionBuffer, INDICATOR_DATA);
    SetIndexBuffer(2, SignalBuffer, INDICATOR_DATA);
    
    // Стили отрисовки
    PlotIndexSetString(0, PLOT_LABEL, "Trend Force");
    PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(0, PLOT_LINE_COLOR, clrBlue);
    
    PlotIndexSetString(1, PLOT_LABEL, "Direction");
    PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_HISTOGRAM);
    
    PlotIndexSetString(2, PLOT_LABEL, "Signal");
    PlotIndexSetInteger(2, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(2, PLOT_LINE_COLOR, clrRed);
    
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
{
    // Проверка на достаточность данных
    if(rates_total < InpMAPeriod) return(0);
    
    // Расчет компонентов
    int start = (prev_calculated > 0) ? prev_calculated - 1 : 0;
    
    for(int i = start; i < rates_total; i++)
    {
        // Волатильность
        double volatility = 0.0;
        if(i >= InpMAPeriod)
        {
            double sum = 0.0;
            for(int j = 0; j < InpMAPeriod; j++)
            {
                double change = (close[i-j] - close[i-j-1]) / close[i-j-1];
                sum += change * change;
            }
            volatility = MathSqrt(sum / InpMAPeriod);
        }
        
        // Моментум
        double momentum = 0.0;
        if(i >= InpMomentumPeriod)
        {
            momentum = (close[i] - close[i-InpMomentumPeriod]) / close[i-InpMomentumPeriod];
        }
        
        // Объемный тренд
        double volume_ma = 0.0;
        if(i >= InpMAPeriod)
        {
            for(int j = 0; j < InpMAPeriod; j++)
            {
                volume_ma += tick_volume[i-j];
            }
            volume_ma /= InpMAPeriod;
        }
        
        double volume_trend = volume_ma != 0 ? (double)tick_volume[i] / volume_ma : 0;
        
        // Сессионный коэффициент
        MqlDateTime dt;
        TimeToStruct(time[i], dt);
        double session_coef = GetSessionCoefficient(dt.hour);
        
        // Расчет силы тренда
        TrendForceBuffer[i] = NormalizeTrendForce(volatility * MathAbs(momentum) * volume_trend) * session_coef;
        DirectionBuffer[i] = momentum > 0 ? TrendForceBuffer[i] : -TrendForceBuffer[i];
        
        // Сигнальная линия
        SignalBuffer[i] = InpSignalLevel;
    }
    
    return(rates_total);
}

//+------------------------------------------------------------------+
//| Получение коэффициента сессии                                    |
//+------------------------------------------------------------------+
double GetSessionCoefficient(int hour)
{
    if(hour >= 0 && hour < 8)   return 0.7;  // Азиатская сессия
    if(hour >= 8 && hour < 16)  return 1.0;  // Европейская сессия
    if(hour >= 16 && hour < 24) return 0.9;  // Американская сессия
    return 1.0;
}

//+------------------------------------------------------------------+
//| Нормализация показателя силы тренда                              |
//+------------------------------------------------------------------+
double NormalizeTrendForce(double force)
{
    // Простая нормализация в диапазон [3, 9]
    double max_force = 0.01;  // Подобрано эмпирически
    return 3.0 + 6.0 * (MathMin(force, max_force) / max_force);
}

A parte mais difícil foi replicar o comportamento do `rolling` do pandas. No MQL5, tudo precisa ser calculado com laços, mas a performance é maior, e o indicador funciona visivelmente mais rápido que a versão em Python.

Considerações finais

No final dessa longa jornada de pesquisa, quero compartilhar algumas observações importantes. Migrar o algoritmo do Python para o MQL5 abriu oportunidades inesperadas de otimização. O que parecia uma limitação (a ausência de bibliotecas familiares) acabou virando uma vantagem, pois o código passou a rodar mais rápido e de forma mais eficiente.

O mais difícil foi encontrar o equilíbrio entre a precisão dos sinais e a velocidade de execução do indicador. Cada parâmetro adicional, cada verificação nova representa carga extra no sistema. Mas no fim, conseguimos alcançar a proporção ideal: o indicador processa dados de ticks praticamente em tempo real, mantendo alta precisão nos sinais.

Vale destacar a reação dos traders na prática. Quando comecei esse projeto, a ideia era criar algo novo e interessante para mim mesmo. Mas, à medida que outros traders começaram a usar o indicador, veio a percepção de que realmente havíamos descoberto algo importante. Foi especialmente gratificante receber feedbacks de traders experientes dizendo que o indicador os ajudou a ver o mercado com novos olhos.

Claro, não é o Santo Graal. Como qualquer ferramenta de análise técnica, nosso indicador exige entendimento e uso correto. Mas sua principal vantagem é permitir enxergar aspectos da dinâmica do mercado que normalmente passam despercebidos na análise clássica.

Ainda há muito a fazer. Quero adicionar ajustes adaptativos de parâmetros, melhorar o sistema de filtragem de sinais, talvez até incluir elementos de aprendizado de máquina. Mas já agora, olhando para os resultados, sei que esse caminho valeu a pena.

E o mais importante: confirmei que mesmo em uma área tão estudada como a análise técnica, ainda há espaço para inovação. Só é preciso não ter medo de olhar para as coisas conhecidas com um novo olhar e estar aberto a descobertas inesperadas.