Author Topic: Plotting NEO Waves  (Read 5025 times)

aniruddha2907

  • Newbie
  • *
  • Posts: 2
    • View Profile
Plotting NEO Waves
« on: July 09, 2013, 05:35:05 am »
Can someone help with plotting neowaves on amibroker chart.

For clarification a neowave chart consists only of 2 variables daily high and low, the catch is we have to check whether the high came first or the low in intraday chart, and accordingly plot the high or low first whichever occurred first.

Thus data pount for a chart for five days should be something like this,

Day 1
H - 5960
L - 5900

Day 2
L - 5875
H - 5900

Day 3
H - 5910
L - 5820

Day 4
L - 5775
H - 5830

Day 5
H - 5840
L - 5800

Thus the chart should look like the one attached.
I would be grateful if someone could help me.

aniruddha2907

  • Newbie
  • *
  • Posts: 2
    • View Profile
Re: Plotting NEO Waves
« Reply #1 on: August 08, 2013, 09:47:09 am »
Below is the code for mt4 if anyone can convert it to afl that would be really nice, thanks in advance.



//+------------------------------------------------------------------+
//|                                          FX5_NellyElliotWave.mq4 |
//|                                            FX5, Copyright © 2007 |
//|                                                    hazem@uk2.net |
//+------------------------------------------------------------------+
#property copyright "FX5, Copyright © 2007"
#property link      "hazem@uk2.net"
 
#property indicator_chart_window
#property indicator_buffers 8
 
#define Sunday 0
#define Monday 1
 
//---- input parameters
extern string    segment_0 = "*** Daily Close Settings ***";
extern bool      enableCustomDailyClose = false;
extern string    dailyCloseTime = "00:00";
extern string    segment_1 = "*** Waves Display Setting ***";
extern bool      showMonthlyWaves = true;
extern bool      showWeeklyWaves = true;
extern bool      showDailyWaves = true;
extern bool      showQuarterDailyWaves = true;
extern string    segment_2 = "*** Waves Color Settings ***";
extern color     monthlyWavesColor = BlueViolet;
extern color     weeklyWavesColor = Green;
extern color     dailyWavesColor = Blue;
extern color     quarterDailyWavesColor = Yellow;
extern string    segment_3 = "*** SwingPoints Color Settings ***";
extern color     monthlySwingColor = Yellow;
extern color     weeklySwingColor = FireBrick;
extern color     dailySwingColor = Red;
extern color     quarterDailySwingColor = Chocolate;
//---- buffers
double monthlyWaves[];
double monthlySwings[];
double weeklyWaves[];
double weeklySwings[];
double dailyWaves[];
double dailySwings[];
double quarterDailyWaves[];
double quarterDailySwings[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   datetime time = StrToTime(dailyCloseTime);
   dailyCloseTime = TimeToStr(time, TIME_MINUTES);
   
//---- indicators
   int timeFrame = Period();
   
   int monthlyWidth = 2;
   int weeklyWidth = 2;
   int dailyWidth = 2;
   int quarterDailyWidth = 1;
   
   if (timeFrame >= PERIOD_D1)
      weeklyWidth = 1;
   if (timeFrame >= PERIOD_H4)
      dailyWidth = 1;
 
   SetIndexStyle(0, DRAW_SECTION, STYLE_SOLID, monthlyWidth, monthlyWavesColor);
   SetIndexStyle(2, DRAW_SECTION, STYLE_SOLID, weeklyWidth, weeklyWavesColor);
   SetIndexStyle(4, DRAW_SECTION, STYLE_SOLID, dailyWidth, dailyWavesColor);
   SetIndexStyle(6, DRAW_SECTION, STYLE_SOLID, quarterDailyWidth, quarterDailyWavesColor);
   
   SetIndexStyle(1, DRAW_ARROW, EMPTY, monthlyWidth, monthlySwingColor);
   SetIndexStyle(3, DRAW_ARROW, EMPTY, weeklyWidth, weeklySwingColor);
   SetIndexStyle(5, DRAW_ARROW, EMPTY, dailyWidth, dailySwingColor);
   SetIndexStyle(7, DRAW_ARROW, EMPTY, quarterDailyWidth, quarterDailySwingColor);
   
   SetIndexArrow(1, 159);
   SetIndexArrow(3, 159);
   SetIndexArrow(5, 159);
   SetIndexArrow(7, 159);
   
   SetIndexBuffer(0, monthlyWaves);
   SetIndexBuffer(1, monthlySwings);
   SetIndexBuffer(2, weeklyWaves);
   SetIndexBuffer(3, weeklySwings);
   SetIndexBuffer(4, dailyWaves);
   SetIndexBuffer(5, dailySwings);
   SetIndexBuffer(6, quarterDailyWaves);
   SetIndexBuffer(7, quarterDailySwings);
 
   SetIndexEmptyValue(0, 0);
   SetIndexEmptyValue(1, 0);
   SetIndexEmptyValue(2, 0);
   SetIndexEmptyValue(3, 0);
   SetIndexEmptyValue(4, 0);
   SetIndexEmptyValue(5, 0);
   SetIndexEmptyValue(6, 0);
   SetIndexEmptyValue(7, 0);
     
   IndicatorDigits(Digits);
//----
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
   Comment("");
   
   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   Comment("Designed & Prgramed By: FX5\n", "***hazem@uk2.net***");
   int countedBars = IndicatorCounted();
   if (countedBars < 0)
      countedBars = 0;
 
   int timeFrame = Period();
   
   if (showMonthlyWaves)
   {
      if (timeFrame == PERIOD_D1 || timeFrame == PERIOD_H4)
         IdentifyMonthlyWaves(countedBars);
   }   
 
   if (showWeeklyWaves)
   {
      if (timeFrame == PERIOD_D1 || timeFrame == PERIOD_H4 ||
          timeFrame == PERIOD_H1)
         IdentifyWeeklyWaves(countedBars);
   }
   if (showDailyWaves)
   {
      if (timeFrame == PERIOD_H4 || timeFrame == PERIOD_H1 ||
          timeFrame == PERIOD_M30 ||timeFrame == PERIOD_M15 ||
          timeFrame == PERIOD_M5 || timeFrame == PERIOD_M1)
         IdentifyDailyWaves(countedBars);
   }
   if (showQuarterDailyWaves)
   {   
      if (timeFrame == PERIOD_H1 || timeFrame == PERIOD_M30 ||
          timeFrame == PERIOD_M15 || timeFrame == PERIOD_M5 ||
          timeFrame == PERIOD_M1)
         IdentifyQuarterDailyWaves(countedBars);
   }
   
   return(0);
}
//+------------------------------------------------------------------+
void IdentifyMonthlyWaves(int countedBars)
{
   int lastShift = -1;
   
   for (int i = Bars - countedBars; i >= 0; i--)
   {
      int lastClose = GetLastMonthlyClose(i);
     
      if (lastShift == lastClose)
         continue;
      else
         lastShift = lastClose;
     
      int lastOpen = GetLastMonthlyClose(lastClose);
           
      if (lastClose == -1 || lastOpen == -1)
         continue;       
                   
      int highShift = GetHighestHighShift(lastClose + 1, lastOpen - lastClose);
      int lowShift = GetLowestLowShift(lastClose + 1, lastOpen - lastClose);
       
      double highPrice = High[highShift];
      double lowPrice = Low[lowShift];
     
      if (highShift > lowShift)
      {
         monthlyWaves[lastOpen] = highPrice;
         int middleShift = lastClose + MathCeil((lastOpen - lastClose + 1) / 2);
         monthlyWaves[middleShift] = lowPrice;
      }
      else
      {
         monthlyWaves[lastOpen] = lowPrice;
         middleShift = lastClose + MathCeil((lastOpen - lastClose + 1) / 2);
         monthlyWaves[middleShift] = highPrice;
      }
     
      int swing_0 = GetLastMonthlySwing(i);
      int swing_1 = GetLastMonthlySwing(swing_0);
      int swing_2 = GetLastMonthlySwing(swing_1);
      int swing_3 = GetLastMonthlySwing(swing_2);
           
      if (monthlyWaves[swing_1] > monthlyWaves[swing_0] && monthlyWaves[swing_1] > monthlyWaves[swing_2])
         monthlySwings[swing_1] = monthlyWaves[swing_1];
         
      if (monthlyWaves[swing_1] < monthlyWaves[swing_0] && monthlyWaves[swing_1] < monthlyWaves[swing_2])
         monthlySwings[swing_1] = monthlyWaves[swing_1];
         
      if (monthlyWaves[swing_2] > monthlyWaves[swing_1] && monthlyWaves[swing_2] > monthlyWaves[swing_3])
         monthlySwings[swing_2] = monthlyWaves[swing_2];
         
      if (monthlyWaves[swing_2] < monthlyWaves[swing_1] && monthlyWaves[swing_2] < monthlyWaves[swing_3])
         monthlySwings[swing_2] = monthlyWaves[swing_2];         
   }
}
//+------------------------------------------------------------------+
void IdentifyWeeklyWaves(int countedBars)
{
   int lastShift = -1;
   
   for (int i = Bars - countedBars; i >= 0; i--)
   {
      int lastWeekClose = GetLastWeeklyClose(i);
     
      if (lastShift == lastWeekClose)
         continue;
      else
         lastShift = lastWeekClose;
         
      int lastWeekOpen = GetLastWeeklyClose(lastWeekClose);
           
      if (lastWeekClose == -1 || lastWeekOpen == -1)
         continue;         
                   
      int weekHighShift = GetHighestHighShift(lastWeekClose + 1, lastWeekOpen - lastWeekClose);
      int weekLowShift = GetLowestLowShift(lastWeekClose + 1, lastWeekOpen - lastWeekClose);
       
      double weekHighPrice = High[weekHighShift];
      double weekLowPrice = Low[weekLowShift];
     
      if (weekHighShift > weekLowShift)
      {
         weeklyWaves[lastWeekOpen] = weekHighPrice;
         int middleWeekShift = lastWeekClose + MathCeil((lastWeekOpen - lastWeekClose + 1) / 2);
         weeklyWaves[middleWeekShift] = weekLowPrice;
      }
      else
      {
         weeklyWaves[lastWeekOpen] = weekLowPrice;
         middleWeekShift = lastWeekClose + MathCeil((lastWeekOpen - lastWeekClose + 1) / 2);
         weeklyWaves[middleWeekShift] = weekHighPrice;
      }
     
      int swing_0 = GetLastWeeklySwing(i);
      int swing_1 = GetLastWeeklySwing(swing_0);
      int swing_2 = GetLastWeeklySwing(swing_1);
      int swing_3 = GetLastWeeklySwing(swing_2);
           
      if (weeklyWaves[swing_1] > weeklyWaves[swing_0] && weeklyWaves[swing_1] > weeklyWaves[swing_2])
         weeklySwings[swing_1] = weeklyWaves[swing_1];
         
      if (weeklyWaves[swing_1] < weeklyWaves[swing_0] && weeklyWaves[swing_1] < weeklyWaves[swing_2])
         weeklySwings[swing_1] = weeklyWaves[swing_1];
         
      if (weeklyWaves[swing_2] > weeklyWaves[swing_1] && weeklyWaves[swing_2] > weeklyWaves[swing_3])
         weeklySwings[swing_2] = weeklyWaves[swing_2];
         
      if (weeklyWaves[swing_2] < weeklyWaves[swing_1] && weeklyWaves[swing_2] < weeklyWaves[swing_3])
         weeklySwings[swing_2] = weeklyWaves[swing_2];         
   }
}
//+------------------------------------------------------------------+
void IdentifyDailyWaves(int countedBars)
{
   int lastShift = -1;
   
   for (int i = Bars - countedBars; i >= 0; i--)
   {
      int lastDayClose = GetLastDailyClose(i);
     
      if (lastShift == lastDayClose)
         continue;
      else
         lastShift = lastDayClose;       
     
      int lastDayOpen = GetLastDailyClose(lastDayClose);
     
      if (lastDayClose == -1 || lastDayOpen == -1)
         continue;         
                   
      int dayHighShift = GetHighestHighShift(lastDayClose + 1, lastDayOpen - lastDayClose);
      int dayLowShift = GetLowestLowShift(lastDayClose + 1, lastDayOpen - lastDayClose);
       
      double dayHighPrice = High[dayHighShift];
      double dayLowPrice = Low[dayLowShift];
     
      if (dayHighShift > dayLowShift)
      {
         dailyWaves[lastDayOpen] = dayHighPrice;
         int middleDayShift = lastDayClose + MathCeil((lastDayOpen - lastDayClose + 1) / 2);
         dailyWaves[middleDayShift] = dayLowPrice;
      }
      else
      {
         dailyWaves[lastDayOpen] = dayLowPrice;
         middleDayShift = lastDayClose + MathCeil((lastDayOpen - lastDayClose + 1) / 2);
         dailyWaves[middleDayShift] = dayHighPrice;
      }
     
      int swing_0 = GetLastDailySwing(i);
      int swing_1 = GetLastDailySwing(swing_0);
      int swing_2 = GetLastDailySwing(swing_1);
      int swing_3 = GetLastDailySwing(swing_2);
           
      if (dailyWaves[swing_1] > dailyWaves[swing_0] && dailyWaves[swing_1] > dailyWaves[swing_2])
         dailySwings[swing_1] = dailyWaves[swing_1];
         
      if (dailyWaves[swing_1] < dailyWaves[swing_0] && dailyWaves[swing_1] < dailyWaves[swing_2])
         dailySwings[swing_1] = dailyWaves[swing_1];
         
      if (dailyWaves[swing_2] > dailyWaves[swing_1] && dailyWaves[swing_2] > dailyWaves[swing_3])
         dailySwings[swing_2] = dailyWaves[swing_2];
         
      if (dailyWaves[swing_2] < dailyWaves[swing_1] && dailyWaves[swing_2] < dailyWaves[swing_3])
         dailySwings[swing_2] = dailyWaves[swing_2];         
   }
}
//+------------------------------------------------------------------+
void IdentifyQuarterDailyWaves(int countedBars)
{
   int lastShift = -1;
   
   for (int i = Bars - countedBars; i >= 0; i--)
   {
      int lastClose = GetLastQuarterDailyClose(i);
     
      if (lastShift == lastClose)
         continue;
      else
         lastShift = lastClose;
     
      int lastOpen = GetLastQuarterDailyClose(lastClose);
           
      if (lastClose == -1 || lastOpen == -1)
         continue;       
                   
      int highShift = GetHighestHighShift(lastClose + 1, lastOpen - lastClose);
      int lowShift = GetLowestLowShift(lastClose + 1, lastOpen - lastClose);
       
      double highPrice = High[highShift];
      double lowPrice = Low[lowShift];
     
      if (highShift > lowShift)
      {
         quarterDailyWaves[lastOpen] = highPrice;
         int middleShift = lastClose + MathCeil((lastOpen - lastClose + 1) / 2);
         quarterDailyWaves[middleShift] = lowPrice;
      }
      else
      {
         quarterDailyWaves[lastOpen] = lowPrice;
         middleShift = lastClose + MathCeil((lastOpen - lastClose + 1) / 2);
         quarterDailyWaves[middleShift] = highPrice;
      }
     
      int swing_0 = GetLastQuarterDailySwing(i);
      int swing_1 = GetLastQuarterDailySwing(swing_0);
      int swing_2 = GetLastQuarterDailySwing(swing_1);
      int swing_3 = GetLastQuarterDailySwing(swing_2);
           
      if (quarterDailyWaves[swing_1] > quarterDailyWaves[swing_0] && quarterDailyWaves[swing_1] > quarterDailyWaves[swing_2])
         quarterDailySwings[swing_1] = quarterDailyWaves[swing_1];
         
      if (quarterDailyWaves[swing_1] < quarterDailyWaves[swing_0] && quarterDailyWaves[swing_1] < quarterDailyWaves[swing_2])
         quarterDailySwings[swing_1] = quarterDailyWaves[swing_1];
         
      if (quarterDailyWaves[swing_2] > quarterDailyWaves[swing_1] && quarterDailyWaves[swing_2] > quarterDailyWaves[swing_3])
         quarterDailySwings[swing_2] = quarterDailyWaves[swing_2];
         
      if (quarterDailyWaves[swing_2] < quarterDailyWaves[swing_1] && quarterDailyWaves[swing_2] < quarterDailyWaves[swing_3])
         quarterDailySwings[swing_2] = quarterDailyWaves[swing_2];         
   }
}
//+------------------------------------------------------------------+
int GetLastMonthlySwing(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {
      if (monthlyWaves != 0)
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastWeeklySwing(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {
      if (weeklyWaves != 0)
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastDailySwing(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {
      if (dailyWaves != 0)
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastQuarterDailySwing(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {
      if (quarterDailyWaves != 0)
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastMonthlyClose(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {       
      if (TimeDay(Time) < TimeDay(Time[i+1]))
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastWeeklyClose(int shift)
{
   for (int i = shift + 1; i < Bars; i++)
   {       
      if (TimeDayOfWeek(Time) < TimeDayOfWeek(Time[i+1]))
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastDailyClose(int shift)
{
   if (enableCustomDailyClose)
   {
      for (int i = shift + 1; i < Bars; i++)
      {
         string candleDateString = TimeToStr(Time, TIME_DATE);
         datetime closeTime = StrToTime(candleDateString + " " + dailyCloseTime);
     
         if (closeTime < Time[shift] && closeTime >= Time)
            return(i);
      }   
   }
   else
   {
      for (i = shift + 1; i < Bars; i++)
      {
         if (TimeDayOfWeek(Time) != TimeDayOfWeek(Time[i+1]) &&
             TimeDayOfWeek(Time) !=  Monday && TimeDayOfWeek(Time[i+1]) != Sunday)
            return(i);
      }
   }
   return(-1);
}
//+------------------------------------------------------------------+
int GetLastQuarterDailyClose(int shift)
{
   if (enableCustomDailyClose)
   {
      int colonIndex = StringFind(dailyCloseTime, ":", 0);
      if (colonIndex == -1)
         return(-1);
     
      string closeHourString = StringSubstr(dailyCloseTime, 0, colonIndex);
      int closeHour = StrToInteger(closeHourString);
   }
   else
      closeHour = 0;
       
   for (int i = shift + 1; i < Bars; i++)
   {
      string candleDateString = TimeToStr(Time, TIME_DATE);
     
      int quarterHour = HourSum(closeHour, 0);     
      datetime closeTime = StrToTime(candleDateString + " " + DoubleToStr(quarterHour, 0) + ":00");     
      if (closeTime < Time[shift] && closeTime >= Time)
         return(i);
 
      quarterHour = HourSum(closeHour, 6);             
      closeTime = StrToTime(candleDateString + " " + DoubleToStr(quarterHour, 0) + ":00");     
      if (closeTime < Time[shift] && closeTime >= Time)
         return(i);
 
      quarterHour = HourSum(closeHour, 12);             
      closeTime = StrToTime(candleDateString + " " + DoubleToStr(quarterHour, 0) + ":00");             
      if (closeTime < Time[shift] && closeTime >= Time)
         return(i);
 
      quarterHour = HourSum(closeHour, 18);             
      closeTime = StrToTime(candleDateString + " " + DoubleToStr(quarterHour, 0) + ":00");
      if (closeTime < Time[shift] && closeTime >= Time)
         return(i);
   }
   return(-1);
}
//+------------------------------------------------------------------+
int HourSum(int firstHour, int secondHour)
{
   int sum = firstHour + secondHour;
   if (sum >= 24)
      sum -= 24;
     
   return(sum);
}
//+------------------------------------------------------------------+
int GetHighestHighShift(int start, int count)
{
   int highestShift = -1;
   double highestPrice = -1;
   for (int i = start; i < start + count; i++)
   {
      if (High > highestPrice)
      {
         highestShift = i;
         highestPrice = High;
      }
   }
   return(highestShift);
}
//+------------------------------------------------------------------+
int GetLowestLowShift(int start, int count)
{
   int lowestShift = -1;
   double lowestPrice = 9999999;
   for (int i = start; i < start + count; i++)
   {
      if (Low < lowestPrice)
      {
         lowestShift = i;
         lowestPrice = Low;
      }
   }
   return(lowestShift);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+