Channel Sun Signals

#property version   "2.00"

#property indicator_chart_window
#property indicator_buffers 7
#property indicator_plots   5

#property indicator_label1  "Mid"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrWhite
#property indicator_style1  STYLE_DOT
#property indicator_width1  1

#property indicator_label2  "Upper"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrOrange
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2

#property indicator_label3  "Lower"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrOrange
#property indicator_style3  STYLE_SOLID
#property indicator_width3  2

#property indicator_label4  "Sell (above)"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_width4  1

#property indicator_label5  "Buy (below)"
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrBlue
#property indicator_width5  1

enum ENUM_ColorChoice
  {
   Color_White,
   Color_Black,
   Color_DimGray,
   Color_Gray,
   Color_Silver,
   Color_Red,
   Color_Maroon,
   Color_OrangeRed,
   Color_Orange,
   Color_Gold,
   Color_Yellow,
   Color_YellowGreen,
   Color_LimeGreen,
   Color_Lime,
   Color_Green,
   Color_DarkGreen,
   Color_Teal,
   Color_Aqua,
   Color_Cyan,
   Color_DeepSkyBlue,
   Color_DodgerBlue,
   Color_Blue,
   Color_Navy,
   Color_SlateBlue,
   Color_Purple,
   Color_Magenta,
   Color_DeepPink,
   Color_Pink,
   Color_Brown,
   Color_Chocolate,
   Color_Turquoise,
   Color_Violet
  };

color ColorFromChoice(ENUM_ColorChoice c)
  {
   switch(c)
     {
      case Color_White:       return clrWhite;
      case Color_Black:       return clrBlack;
      case Color_DimGray:     return clrDimGray;
      case Color_Gray:        return clrGray;
      case Color_Silver:      return clrSilver;
      case Color_Red:         return clrRed;
      case Color_Maroon:      return clrMaroon;
      case Color_OrangeRed:   return clrOrangeRed;
      case Color_Orange:      return clrOrange;
      case Color_Gold:        return clrGold;
      case Color_Yellow:      return clrYellow;
      case Color_YellowGreen: return clrYellowGreen;
      case Color_LimeGreen:   return clrLimeGreen;
      case Color_Lime:        return clrLime;
      case Color_Green:       return clrGreen;
      case Color_DarkGreen:   return clrDarkGreen;
      case Color_Teal:        return clrTeal;
      case Color_Aqua:        return clrAqua;
      case Color_Cyan:        return clrCyan;
      case Color_DeepSkyBlue: return clrDeepSkyBlue;
      case Color_DodgerBlue:  return clrDodgerBlue;
      case Color_Blue:        return clrBlue;
      case Color_Navy:        return clrNavy;
      case Color_SlateBlue:   return clrSlateBlue;
      case Color_Purple:      return clrPurple;
      case Color_Magenta:     return clrMagenta;
      case Color_DeepPink:    return clrDeepPink;
      case Color_Pink:        return clrPink;
      case Color_Brown:       return clrBrown;
      case Color_Chocolate:   return clrChocolate;
      case Color_Turquoise:   return clrTurquoise;
      case Color_Violet:      return clrViolet;
      default:                return clrDimGray;
     }
  }

input ENUM_TIMEFRAMES InpTimeFrame = PERIOD_CURRENT;     // Timeframe (dropdown: current, M1...MN1)
input int    InpHalfLength      = 30;                    // Channel HalfLength (smoothness)
input ENUM_APPLIED_PRICE InpPrice = PRICE_WEIGHTED;       // Applied price
input double InpBandsDeviations = 2.0;                    // Bands deviation multiplier
input bool   InpInterpolate     = true;                   // Interpolate between MTF bars

input group "=== Colors (list, not palette) ==="
input ENUM_ColorChoice InpColorMid       = Color_White;       // Mid line color
input ENUM_ColorChoice InpColorUpper     = Color_Orange;      // Upper band color
input ENUM_ColorChoice InpColorLower     = Color_Orange;      // Lower band color
input ENUM_ColorChoice InpColorDownArrow = Color_Red;         // Sell arrow color
input ENUM_ColorChoice InpColorUpArrow   = Color_Blue;        // Buy arrow color

input group "=== Line width / Arrow size ==="
input int    InpWidthMid        = 1;                      // Mid line width (1-5)
input int    InpWidthUpper      = 2;                      // Upper band width (1-5)
input int    InpWidthLower      = 2;                      // Lower band width (1-5)
input int    InpArrowSizeDown   = 1;                       // Sell arrow size (1-5)
input int    InpArrowSizeUp     = 1;                       // Buy arrow size (1-5)

input group "=== Signals ==="
input bool   InpSignalsClosedBarOnly = false;             // Signal only after bar close (no repainting)

input group "=== Signal filters (optional) ==="
input bool   InpFilterVolatility  = false;                // 1) Filter signals when band is too narrow (no-trend market)
input double InpMinBandWidthPct   = 0.10;                 // Minimum band width (% of price) for a valid signal
input bool   InpFilterVolume      = false;                // 2) Confirm signal with above-average volume
input int    InpVolumeAvgPeriod   = 20;                   // Volume average period (bars prior to the signal bar)
input double InpVolumeMultiplier  = 1.2;                  // Signal bar volume must be >= average * this factor
input int    InpSignalCooldownBars= 0;                    // 3) Minimum bars between two signals (0 = disabled)

input group "=== Alerts ==="
input bool   InpAlertsOn        = false;                  // Enable alerts
input bool   InpAlertsOnCurrent = false;                  // Alerts on current (unclosed) bar
input bool   InpAlertsOnHighLow = true;                   // Alert on High/Low (otherwise on Close)
input bool   InpAlertsMessage   = true;                   // Popup alert
input bool   InpAlertsSound     = false;                  // Sound alert
input bool   InpAlertsEmail     = false;                  // Email alert
input bool   InpAlertsNotify    = false;                  // Push notification alert

double midBuffer[];
double upBuffer[];
double dnBuffer[];
double dnArrowBuf[];   // semnal SELL (sageata rosie, deasupra lumanarii)
double upArrowBuf[];   // semnal BUY  (sageata albastra, sub lumanare)
double wuBuffer[];   // buffer intermediar de calcul (deviatie superioara) - pt. timeframe-ul curent
double wdBuffer[];   // intermediate calculation buffer (lower deviation) - for the current timeframe

double atrArray[];
int    atrHandle = INVALID_HANDLE;

MqlRates htRates[];
double   htMid[];
double   htUpper[];
double   htLower[];
double   htWu[];
double   htWd[];
int      htCount=0;

double   htO[];
double   htH[];
double   htL[];
double   htC[];

datetime gHtLastBarTime=0;
int      gHtLastCopied=-1;

int               halfLength;
double            bandsDeviations;
ENUM_TIMEFRAMES   timeFrame;
bool              useMTF    = false;

double AppliedPriceOf(int i,const double &o[],const double &h[],const double &l[],const double &c[])
  {
   switch(InpPrice)
     {
      case PRICE_OPEN:     return o[i];
      case PRICE_HIGH:     return h[i];
      case PRICE_LOW:      return l[i];
      case PRICE_MEDIAN:   return (h[i]+l[i])/2.0;
      case PRICE_TYPICAL:  return (h[i]+l[i]+c[i])/3.0;
      case PRICE_WEIGHTED: return (h[i]+l[i]+2.0*c[i])/4.0;
      default:             return c[i];
     }
  }

bool IsValidLevel(double v)
  {
   return(v>-1000000.0 && v<1000000.0 && v!=0.0);
  }

string TimeframeToString(ENUM_TIMEFRAMES tf)
  {
   string s=EnumToString(tf);
   StringReplace(s,"PERIOD_","");
   return s;
  }

void CalculateChannelGeneric(int limit,int total,
                              const double &o[],const double &h[],const double &l[],const double &c[],
                              double &midOut[],double &upOut[],double &dnOut[],double &wuOut[],double &wdOut[])
  {
   double fullLength=2.0*halfLength+1.0;
   int seedIndex=total-halfLength-1;
   if(seedIndex<0) seedIndex=total-1;

   for(int i=limit; i>=0; i--)
     {
      double sum =(halfLength+1)*AppliedPriceOf(i,o,h,l,c);
      double sumw=(halfLength+1);

      for(int j=1,k=halfLength; j<=halfLength; j++,k--)
        {
         int idxNewer=i-j;
         int idxOlder=i+j;

         if(idxNewer>=0)
           {
            sum +=k*AppliedPriceOf(idxNewer,o,h,l,c);
            sumw+=k;
           }
         if(idxOlder<total)
           {
            sum +=k*AppliedPriceOf(idxOlder,o,h,l,c);
            sumw+=k;
           }
        }
      midOut[i]=sum/sumw;

      double diff=AppliedPriceOf(i,o,h,l,c)-midOut[i];

      if(i>seedIndex) continue;
      if(i==seedIndex)
        {
         upOut[i]=midOut[i];
         dnOut[i]=midOut[i];
         if(diff>=0) { wuOut[i]=diff*diff; wdOut[i]=0; }
         else        { wdOut[i]=diff*diff; wuOut[i]=0; }
         continue;
        }

      if(diff>=0)
        {
         wuOut[i]=(wuOut[i+1]*(fullLength-1)+diff*diff)/fullLength;
         wdOut[i]= wdOut[i+1]*(fullLength-1)/fullLength;
        }
      else
        {
         wdOut[i]=(wdOut[i+1]*(fullLength-1)+diff*diff)/fullLength;
         wuOut[i]= wuOut[i+1]*(fullLength-1)/fullLength;
        }

      upOut[i]=midOut[i]+bandsDeviations*MathSqrt(MathMax(wuOut[i],0.0));
      dnOut[i]=midOut[i]-bandsDeviations*MathSqrt(MathMax(wdOut[i],0.0));

      if(!MathIsValidNumber(midOut[i]) || !MathIsValidNumber(upOut[i]) || !MathIsValidNumber(dnOut[i]))
        {
         double fallback=AppliedPriceOf(i,o,h,l,c);
         midOut[i]=fallback; upOut[i]=fallback; dnOut[i]=fallback;
         wuOut[i]=0; wdOut[i]=0;
        }
     }
  }

void CalculateSignals(int limit,int rates_total,
                       const double &open[],const double &high[],const double &low[],const double &close[],
                       const long &tick_volume[])
  {
   int atrCount=limit+2;
   if(atrCount>rates_total) atrCount=rates_total;
   bool haveAtr=false;
   if(atrHandle!=INVALID_HANDLE && atrCount>0)
     {
      if(ArraySize(atrArray)<atrCount)
        {
         if(ArrayResize(atrArray,atrCount,1000)<atrCount) atrCount=0; // esec la resize -> renuntam sigur la offset ATR
        }
      if(atrCount>0)
        {
         ArraySetAsSeries(atrArray,true);
         haveAtr=(CopyBuffer(atrHandle,0,0,atrCount,atrArray)>0);
        }
     }

   int startIdx=(InpSignalsClosedBarOnly ? 1 : 0);
   for(int i=limit; i>=0; i--)
     {
      dnArrowBuf[i]=EMPTY_VALUE;
      upArrowBuf[i]=EMPTY_VALUE;

      if(i<startIdx) continue;            // bara 0 (in formare) - sarita daca vrem doar bare inchise
      if(i+1>=rates_total) continue;

      double atrVal=0;
      if(haveAtr && i<ArraySize(atrArray)) atrVal=atrArray[i];

      bool rawSell=(IsValidLevel(upBuffer[i+1]) && high[i+1]>upBuffer[i+1] && close[i+1]>open[i+1] && close[i]<open[i]);
      bool rawBuy =(IsValidLevel(dnBuffer[i+1]) && low[

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