SHK Professional Heikin Ashi Signals

#property version   "1.02"
#property description "Professional Heikin Ashi candle engine with HA color change plus MACD divergence confirmed BUY/SELL arrows. Closed bar, EA integration friendly."
#property strict

#property indicator_chart_window
#property indicator_buffers 10
#property indicator_plots   5

enum CandleColorMode
{
   COLOR_STANDARD       = 0,
   COLOR_TREND_BASED    = 1,
   COLOR_MOMENTUM_BASED = 2
};

input int    MaxBarsToCalculate       = 3000;
input bool   ShowHeikinAshiCandles    = true;
input bool   ShowOriginalCandlesFaint = false;
input bool   EnableSignals            = true;
input bool   UseClosedBarsOnly        = true;
input CandleColorMode CandleMode      = COLOR_STANDARD;
input color  BullColor                = clrLime;
input color  BearColor                = clrRed;
input color  StrongBullColor          = clrDodgerBlue;
input color  StrongBearColor          = clrOrange;
input color  NeutralColor             = clrGray;
input int    ConfirmationCandles      = 1;       // 1 to 10
input int    SignalLookbackBars       = 1000;
input double MinBodyPercent           = 0.0;
input bool   SignalOnHAColorChange    = true;
input bool   RequireMACDDivergenceConfirmation = true;
input int    MACDFastEMA              = 12;
input int    MACDSlowEMA              = 26;
input int    MACDSignalEMA            = 5;
input int    DivergencePivotLookback  = 2;
input int    DivergenceSearchBars     = 200;
input int    DivergenceConfirmWindow  = 30;
input bool   RequireStrongCandleForCircle = false;
input bool   CancelSignalOnOppositeHA = true;
input bool   ConfirmByCloseBreak      = true;
input double ArrowOffsetATR           = 0.25;
input double CircleOffsetATR          = 0.15;
input int    VisualATRPeriod          = 14;
input bool   EnablePopupAlert         = true;
input bool   EnablePushAlert          = false;
input bool   EnableEmailAlert         = false;
input bool   EnableSoundAlert         = false;
input string BuySoundFile             = "alert.wav";
input string SellSoundFile            = "alert2.wav";
input int    AlertCooldownSeconds     = 120;
input bool   AlertOnlyRealtime        = true;

double HAOpen[];
double HAHigh[];
double HALow[];
double HAClose[];
double HAColor[];
double BuyCircle[];
double SellCircle[];
double BuyArrow[];
double SellArrow[];
double ATRBuf[];

double MacdFastBuf[];
double MacdSlowBuf[];
double MacdSignalBuf[];
double MacdHistBuf[];
bool   BullDivConfirmed[];
bool   BearDivConfirmed[];

#define COL_BULL          0
#define COL_BEAR          1
#define COL_STRONG_BULL   2
#define COL_STRONG_BEAR   3
#define COL_NEUTRAL       4

#define MOM_BODY_WINDOW   14
#define STRONG_WICK_FRAC  0.10
#define CIRCLE_WICK_FRAC  0.15
#define ARROW_BUY_CODE    233
#define ARROW_SELL_CODE   234
#define CIRCLE_CODE       108

int      g_firstBar       = 1;
int      g_confCandles    = 3;

bool     g_buyPending     = false;
double   g_buyRefHigh      = 0.0;
int      g_buyBarsLeft     = 0;

bool     g_sellPending    = false;
double   g_sellRefLow      = 0.0;
int      g_sellBarsLeft    = 0;

datetime g_lastClosedTime = 0;

datetime g_lastAlertTime  = 0;
int      g_lastAlertDir    = 0;
datetime g_lastAlertWall   = 0;

bool IsBullishHA(const int i)
{
   return(HAClose[i] > HAOpen[i]);
}

bool IsBearishHA(const int i)
{
   return(HAClose[i] < HAOpen[i]);
}

double GetBodyPercent(const int i)
{
   double range = HAHigh[i] - HALow[i];
   if(range <= 0.0)
      return(0.0);
   return(MathAbs(HAClose[i] - HAOpen[i]) / range * 100.0);
}

double AvgHABody(const int i, const int win, const int firstBar)
{
   int st = i - win;
   if(st < firstBar)
      return(0.0);
   double s = 0.0;
   int    c = 0;
   for(int k = st; k < i; k++)
   {
      s += MathAbs(HAClose[k] - HAOpen[k]);
      c++;
   }
   return(c > 0 ? s / c : 0.0);
}

int GetCandleColorIndex(const int i)
{
   double range = HAHigh[i] - HALow[i];
   bool   bull  = IsBullishHA(i);
   bool   bear  = IsBearishHA(i);

   if(!bull && !bear)
      return(COL_NEUTRAL);

   if(CandleMode == COLOR_STANDARD)
      return(bull ? COL_BULL : COL_BEAR);

   if(CandleMode == COLOR_TREND_BASED)
   {
      if(range <= 0.0)
         return(bull ? COL_BULL : COL_BEAR);
      double lowerWick = MathMin(HAOpen[i], HAClose[i]) - HALow[i];
      double upperWick = HAHigh[i] - MathMax(HAOpen[i], HAClose[i]);
      if(bull)
         return((lowerWick <= STRONG_WICK_FRAC * range) ? COL_STRONG_BULL : COL_BULL);
      else
         return((upperWick <= STRONG_WICK_FRAC * range) ? COL_STRONG_BEAR : COL_BEAR);
   }

   double body    = MathAbs(HAClose[i] - HAOpen[i]);
   double avgBody = AvgHABody(i, MOM_BODY_WINDOW, g_firstBar);
   if(avgBody > 0.0 && body >= 1.2 * avgBody)
      return(bull ? COL_STRONG_BULL : COL_STRONG_BEAR);
   return(bull ? COL_BULL : COL_BEAR);
}

void ComputeHABar(const int i,
                  const double &open[], const double &high[],
                  const double &low[],  const double &close[])
{
   double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
   double haOpen  = (HAOpen[i - 1] + HAClose[i - 1]) / 2.0;
   double haHigh  = MathMax(high[i], MathMax(haOpen, haClose));
   double haLow   = MathMin(low[i],  MathMin(haOpen, haClose));

   HAOpen[i]  = haOpen;
   HAClose[i] = haClose;
   HAHigh[i]  = haHigh;
   HALow[i]   = haLow;
}

void InitHASeed(const int firstBar,
                const double &open[], const double &high[],
                const double &low[],  const double &close[])
{
   double haClose = (open[firstBar] + high[firstBar] + low[firstBar] + close[firstBar]) / 4.0;
   double haOpen  = (open[firstBar] + close[firstBar]) / 2.0;
   HAClose[firstBar] = haClose;
   HAOpen[firstBar]  = haOpen;
   HAHigh[firstBar]  = MathMax(high[firstBar], MathMax(haOpen, haClose));
   HALow[firstBar]   = MathMin(low[firstBar],  MathMin(haOpen, haClose));
}

double GetVisualATR(const int i,
                    const double &high[], const double &low[], const double &close[],
                    const int firstBar)
{
   int p = VisualATRPeriod;
   if(p < 1) p = 1;
   int st = i - p + 1;
   if(st < firstBar) st = firstBar;
   if(st < 1)        st = 1;

   double sum = 0.0;
   int    n   = 0;
   for(int k = st; k <= i; k++)
   {
      double tr = high[k] - low[k];
      double a  = MathAbs(high[k] - close[k - 1]);
      double b  = MathAbs(low[k]  - close[k - 1]);
      if(a > tr) tr = a;
      if(b > tr) tr = b;
      sum += tr;
      n++;
   }
   double atr = (n > 0) ? sum / n : (high[i] - low[i]);
   ATRBuf[i] = atr;
   return(atr);
}

bool IsMacdPeak(const int i, const int lookback, const int firstBar, const int lastBar)
{
   if(i - lookback < firstBar || i + lookback > lastBar)
      return(false);

   for(int k = 1; k <= lookback; k++)
   {
      if(MacdHistBuf[i] <= MacdHistBuf[i - k] || MacdHistBuf[i] <= MacdHistBuf[i + k])
         return(false);
   }
   return(true);
}

bool IsMacdTrough(const int i, const int lookback, const int firstBar, const int lastBar)
{
   if(i - lookback < firstBar || i + lookback > lastBar)
      return(false);

   for(int k = 1; k <= lookback; k++)
   {
      if(MacdHistBuf[i] >= MacdHistBuf[i - k] || MacdHistBuf[i] >= MacdHistBuf[i + k])
         return(false);
   }
   return(true);
}

void ComputeMACDDivergence(const int rates_total,
                           const int firstBar,
                           const int lastClosed,
                           const double &high[],
                           const double &low[],
                           const double &close[])
{
   ArrayResize(MacdFastBuf, rates_total);
   ArrayResize(MacdSlowBuf, rates_total);
   ArrayResize(MacdSignalBuf, rates_total);
   ArrayResize(MacdHistBuf, rates_total);
   ArrayResize(BullDivConfirmed, rates_total);
   ArrayResize(BearDivConfirmed, rates_total);

   for(int i = 0; i < rates_total; i++)
   {
      MacdFastBuf[i]       = 0.0;
      MacdSlowBuf[i]       = 0.0;
      MacdSignalBuf[i]     = 0.0;
      MacdHistBuf[i]       = 0.0;
      BullDivConfirmed[i]  = false;
      BearDivConfirmed[i]  = false;
   }

   if(!RequireMACDDivergenceConfirmation)
      return;

   int fast = MACDFastEMA;
   int slow = MACDSlowEMA;
   int signal = MACDSignalEMA;
   int pivotLookback = DivergencePivotLookback;
   int searchBars = DivergenceSearchBars;

   if(fast < 1) fast = 1;
   if(slow < 1) slow = 1;
   if(signal < 1) signal = 1;
   if(pivotLookback < 1) pivotLookback = 1;
   if(searchBars < 1) searchBars = 1;

   if(lastClosed < firstBar + pivotLookback * 2 + 2)
      return;

   double fastAlpha = 2.0 / ((double)fast + 1.0);
   double slowAlpha = 2.0 / ((double)slow + 1.0);
   double signalAlpha = 2.0 / ((double)signal + 1.0);

   for(int i = firstBar; i <= lastClosed; i++)
   {
      double price = close[i];
      if(i == firstBar)
      {
         MacdFastBuf[i] = price;
         MacdSlowBuf[i] = price;
         MacdSignalBuf[i] = 0.0;
         MacdHistBuf[i] = 0.0;
         continue;
      }

      MacdFastBuf[i] = fastAlpha * price + (1.0 - fastAlpha) * MacdFastBuf[i - 1];
      MacdSlowBuf[i] = slowAlpha * price + (1.0 - slowAlpha) * MacdSlowBuf[i - 1];
      double macdMain = MacdFastBuf[i] - MacdSlowBuf[i];
      MacdSignalBuf[i] = signalAlpha * macdMain + (1.0 - signalAlpha) * MacdSignalBuf[i - 1];
      MacdHistBuf[i] = macdMain - MacdSignalBuf[i];
   }

   int lastPivot = lastClosed - pivotLookback;
   for(int i = firstBar + pivotLookback; i <= lastPivot; i++)
   {
      if(IsMacdTrough(i, pivotLookback, firstBar, lastClosed))
      {
         int prevTrough = -1;
         int oldest = i - searchBars;
         if(oldest < firstBar + pivotLookback)
            oldest = firstBar + pivotLookback;

         for(int j = i - 1; j >= oldest; j--)
         {
            if(IsMacdTrough(j, pivotLookback, firstBar, lastClosed))
            {
               prevTrough = j;
               break;
            }
         }

         if(prevTrough >= 0 && low[i] < low[prevTrough] && MacdHistBuf[i] > MacdHistBuf[prevTrough])
            BullDivConfirmed[i + pivotLookback] = true;
      }

      if(IsMacdPeak(i, pivotLookback, firstBar, lastClosed))
      {
         int prevPeak = -1;
         int oldest = i - searchBars;
         if(oldest < firstBar + pivotLookback)
            oldest = firstBar + pivotLookback;

         for(int j = i - 1; j >= oldest; j--)
         {
            if(IsMacdPeak(j, pivotLookback, firstBar, lastClosed))
            {
               prevPeak = j;
               break;
            }
         }

         if(prevPeak >= 0 && high[i] > high[prevPeak] && MacdHistBuf[i] < MacdHistBuf[prevPeak])
            BearDivConfirmed[i + pivotLookback] = true;
      }
   }
}

bool RecentMACDDivergenceConfirmed(const int i, const bool bullish)
{
   if(!RequireMACDDivergenceConfirmation)
      return(true);

   int window = DivergenceConfirmWindow;
   if(window < 0)
      window = 0;

   int first = i - window;
   if(first < g_firstBar)
      first = g_firstBar;

   for(int k = i; k >= first; k--)
   {
      if(bullish && BullDivConfirmed[k])
         return(true);
      if(!bullish && BearDivConfirmed[k])
         return(true);
   }
   return(false);
}

void ClearSignalBuffers(const int from, const int to)
{
   for(int i = from; i <= to; i++)
   {
      BuyCircle[i]  = EMPTY_VALUE;
      SellCircle[i] = EMPTY_VALUE;
      BuyArrow[i]   = EMPTY_VALUE;
      SellArrow[i]  = EMPTY_VALUE;
   }
}

void ClearAllBuffers(const int total)
{
   for(int i = 0; i < total; i++)
   {
      HAOpen[i]     = EMPTY_VALUE;
      HAHigh[i]     = EMPTY_VALUE;
      HALow[i]      = EMPTY_VALUE;
      HAClose[i]    = EMPTY_VALUE;
      HAColor[i]    = 0.0;
      ATRBuf[i]     = 0.0;
      BuyCircle[i]  = EMPTY_VALUE;
      SellCircle[i] = EMPTY_VALUE;
      BuyArrow[i]   = EMPTY_VALUE;
      SellArrow[i]  = EMPTY_VALUE;
   }
}

void ResetSignalState()
{
   g_buyPending  = false;
   g_buyRefHigh   = 0.0;
   g_buyBarsLeft  = 0;
   g_sellPending = false;
   g_sellRefLow   = 0.0;
   g_sellBarsLeft = 0;
}

void FireAlert(const int dir, const string typeText,
          

Показано первые 50% кода (символов: 17485)