//+------------------------------------------------------------------+
//|                                                           mladen |
//|                                               mladenfx@gmail.com |
//+------------------------------------------------------------------+
#property copyright "copyright mladen"
#property link      "mladenfx@gmail.com"

#property indicator_separate_window
#property indicator_buffers 7
#property indicator_color1  DarkGray
#property indicator_color2  Orange
#property indicator_color3  Orange
#property indicator_color4  Gold
#property indicator_color5  PaleVioletRed
#property indicator_color6  DimGray
#property indicator_color7  DeepSkyBlue
#property indicator_width1  2
#property indicator_width2  2
#property indicator_width3  2
#property indicator_style5  STYLE_DOT
#property indicator_style6  STYLE_DOT
#property indicator_style7  STYLE_DOT

//
//
//
//
//

#import "dynamicZone.dll"
   double dzBuyP(double& sourceArray[],double probabiltyValue, int lookBack, int bars, int i,double precision);
   double dzSellP(double& sourceArray[],double probabiltyValue, int lookBack, int bars, int i,double precision);
#import

//
//
//
//
//

extern int    LowLimit               = 10;
extern int    HighLimit              = 20;
extern double SmoothLength           = 5;
extern double SmoothPhase            = 0;
extern int    Price                  = 0;
extern double OmaPeriod              = 5;
extern double OmaSpeed               = 3;
extern bool   OmaAdaptive            = true;
extern int    SignalPeriod           = 9;
extern int    SignalMethod           = MODE_EMA;
extern int    CfbNormLength          = 50;
extern int    CfbDepth               = 6;
extern int    CfbPrice               = PRICE_WEIGHTED;
extern int    CfbSmooth              = 8;
extern int    CfbResultSmooth        = 5;
extern double CfbResultPhase         = 0;
extern bool   SmoothDouble           = true;
extern int    DzLookBackBars         = 70;
extern double DzStartBuyProbability  = 0.1;
extern double DzStartSellProbability = 0.1;

extern bool   alertsOn              = false;
extern bool   alertsOnLevelsBreak   = false;
extern bool   alertsOnLevelsRetrace = true;
extern bool   alertsOnZeroBreak     = false;
extern bool   alertsOnSlopeChange   = false;
extern bool   alertsOnSignalCross   = false;
extern bool   alertsOnCurrent       = true;
extern bool   alertsMessage         = true;
extern bool   alertsSound           = false;
extern bool   alertsEmail           = false;

extern bool   arrowsVisible         = false;
extern string arrowsIdentifier      = "velocityAdaptivearrows";
extern bool   arrowsOnLevelsBreak   = true;
extern bool   arrowsOnLevelsRetrace = false;
extern bool   arrowsOnZeroBreak     = false;
extern bool   arrowsOnSignalCross   = false;
extern color  arrowsUpColor         = DeepSkyBlue;
extern color  arrowsDnColor         = Red;
extern color  arrowsZeroUpColor     = DeepSkyBlue;
extern color  arrowsZeroDnColor     = Red;

//
//
//
//
//

double vel[];
double velda[];
double veldb[];
double signal[];
double bli[];
double sli[];
double zli[];
double trends[][6];


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

int init()
{
   IndicatorBuffers(7);
   SetIndexBuffer(0,vel); SetIndexDrawBegin(0,CfbNormLength+3);
   SetIndexBuffer(1,velda); SetIndexDrawBegin(1,CfbNormLength+3);
   SetIndexBuffer(2,veldb); SetIndexDrawBegin(2,CfbNormLength+3);
   SetIndexBuffer(3,signal); 
   SetIndexBuffer(4,bli);
   SetIndexBuffer(5,zli);
   SetIndexBuffer(6,sli);
   IndicatorShortName("velocity cfb adaptive ("+LowLimit+","+HighLimit+","+DoubleToStr(SmoothLength,2)+")");
   return(0);
}


//
//
//
//
//

int deinit()
{
   string lookFor       = arrowsIdentifier+":";
   int    lookForLength = StringLen(lookFor);
   for (int i=ObjectsTotal()-1; i>=0; i--)
   {
      string objectName = ObjectName(i);
         if (StringSubstr(objectName,0,lookForLength) == lookFor) ObjectDelete(objectName);
   }
   return(0);
}


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

double work[][2];
#define _cfb   0
#define _slope 1
int start()
{
   int counted_bars=IndicatorCounted();
   int i,r,limit;

   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
         limit = MathMin(Bars-counted_bars,Bars-1);
         if (ArrayRange(trends,0) != Bars) ArrayResize(trends,Bars);
         if (ArrayRange(work  ,0) != Bars) ArrayResize(work  ,Bars);

   //
   //
   //
   //
   //
   
   if (work[Bars-limit-1][_slope]==-1) CleanPoint(limit,velda,veldb);
   for(i=limit, r=Bars-i-1; i>=0; i--, r++)
   {
      
      work[r][_cfb] = iDSmooth(iCfb(Bars,iMA(NULL,0,1,0,MODE_SMA,CfbPrice,i),CfbDepth,CfbSmooth,r),CfbResultSmooth,CfbResultPhase,i);
    
      //
      //
      //
      //
      //
         double cfbMax = work[r][_cfb];
         double cfbMin = work[r][_cfb];
         for (int k=1; k<CfbNormLength && (i+k)<Bars; k++ )
            {
               cfbMax = MathMax(work[r-k][_cfb],cfbMax);
               cfbMin = MathMin(work[r-k][_cfb],cfbMin);
            }
            double denominator = cfbMax-cfbMin;
               if (denominator> 0)
                  double ratio = (work[r][_cfb]-cfbMin)/denominator;
               else      ratio = 0.5;                 
      //
      //
      //
      //
      //

      double length = MathCeil(LowLimit+ratio*(HighLimit-LowLimit));
      double price = iOma(iMA(NULL,0,1,0,MODE_SMA,Price,i),OmaPeriod,OmaSpeed,OmaAdaptive,i);
      vel[i]    = iDSmooth(iVEL(price,length,i),SmoothLength,SmoothPhase,i,20);
      work[r][_slope] = work[r-1][_slope];
         if (vel[i]>vel[i+1]) work[r][_slope] =  1;
         if (vel[i]<vel[i+1]) work[r][_slope] = -1;
         if (work[r][_slope]==-1) PlotPoint(i,velda,veldb,vel);
      bli[i] = dzBuyP (vel,DzStartBuyProbability,  DzLookBackBars, Bars, i, 0.0001);
      sli[i] = dzSellP(vel,DzStartSellProbability, DzLookBackBars, Bars, i, 0.0001);
      zli[i] = dzSellP(vel,0.5                   , DzLookBackBars, Bars, i, 0.0001);
      
      //
      //
      //
      //
      //
    
      setTrends(bli,1,i);
      setTrends(sli,2,i);
      setTrends(zli,0,i);
      trends[r][3] = work[r][_slope];
   }            
   for(i=limit, r=Bars-i-1; i>=0; i--, r++)
   {
      signal[i] = iMAOnArray(vel,0,SignalPeriod,0,SignalMethod,i);
      trends[r][4] = trends[r-1][4];
      if (vel[i]>signal[i]) trends[r][4] =  1;
      if (vel[i]<signal[i]) trends[r][4] = -1;
      manageArrow(i);
   }
   manageAlerts();
   return(0);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

void setTrends(double& array[], int forTrend, int i)
{
   int r = Bars-i-1;
      trends[r][forTrend] = trends[r-1][forTrend];
         if (vel[i]>array[i]) trends[r][forTrend] =  1;
         if (vel[i]<array[i]) trends[r][forTrend] = -1;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

void manageArrow(int i)
{
   int r = Bars-i-1;
   if (arrowsVisible)
   {
      deleteArrow(Time[i]);
      if (arrowsOnZeroBreak && trends[r][0]!=trends[r-1][0])
      {
         if (trends[r][0] ==  1) drawArrow(i,arrowsZeroUpColor,241,false);
         if (trends[r][0] == -1) drawArrow(i,arrowsZeroDnColor,242,true);
      }
      if (trends[r][1]!=trends[r-1][1])
      {
         if (arrowsOnLevelsRetrace && trends[r][1] ==  1) drawArrow(i,arrowsUpColor,241,false);
         if (arrowsOnLevelsBreak   && trends[r][1] == -1) drawArrow(i,arrowsDnColor,242,true);
      }
      if (trends[r][2]!=trends[r-1][2])
      {
         if (arrowsOnLevelsBreak   && trends[r][2] ==  1) drawArrow(i,arrowsUpColor,241,false);
         if (arrowsOnLevelsRetrace && trends[r][2] == -1) drawArrow(i,arrowsDnColor,242,true);
      }
      if (arrowsOnSignalCross && trends[r][4]!=trends[r-1][4])
      {
         if (trends[r][4] ==  1) drawArrow(i,arrowsUpColor,241,false);
         if (trends[r][4] == -1) drawArrow(i,arrowsDnColor,242,true);
      }
   }
}               

//
//
//
//
//

void drawArrow(int i,color theColor,int theCode,bool up)
{
   string name = arrowsIdentifier+":"+Time[i];
   double gap  = iATR(NULL,0,20,i);   
   
      //
      //
      //
      //
      //
      
      ObjectCreate(name,OBJ_ARROW,0,Time[i],0);
         ObjectSet(name,OBJPROP_ARROWCODE,theCode);
         ObjectSet(name,OBJPROP_COLOR,theColor);
         if (up)
               ObjectSet(name,OBJPROP_PRICE1,High[i]+gap*2);
         else  ObjectSet(name,OBJPROP_PRICE1,Low[i] -gap);
}

//
//
//
//
//

void deleteArrow(datetime time)
{
   string lookFor = arrowsIdentifier+":"+time; ObjectDelete(lookFor);
}

//+-------------------------------------------------------------------
//|                                                                  
//+-------------------------------------------------------------------
//
//
//
//
//

void manageAlerts()
{
   if (alertsOn)
   {
      if (alertsOnCurrent)
           int whichBar = 0;
      else     whichBar = 1; int forBar = Bars-whichBar-1;
      
      //
      //
      //
      //
      //
      
      if (alertsOnZeroBreak)
      {
         static datetime time1 = 0;
         static string   mess1 = "";
            if (alertsOnZeroBreak && trends[forBar][0] ==  1 && trends[forBar-1][0] !=  1) doAlert(time1,mess1,whichBar,"zero line up");
            if (alertsOnZeroBreak && trends[forBar][0] == -1 && trends[forBar-1][0] != -1) doAlert(time1,mess1,whichBar,"zero line down");
      }
      if (alertsOnLevelsBreak || alertsOnLevelsRetrace)
      {
         static datetime time2 = 0;
         static string   mess2 = "";
            if (alertsOnLevelsRetrace && trends[forBar][1] ==  1 && trends[forBar-1][1] !=  1) doAlert(time2,mess2,whichBar,"retraced "+DoubleToStr(bli[whichBar],5)+" level up","up");
            if (alertsOnLevelsBreak   && trends[forBar][1] == -1 && trends[forBar-1][1] != -1) doAlert(time2,mess2,whichBar,"broke "+DoubleToStr(bli[whichBar],5)+" level down","down");
         static datetime time3 = 0;
         static string   mess3 = "";
            if (alertsOnLevelsRetrace && trends[forBar][2] == -1 && trends[forBar-1][2] != -1) doAlert(time3,mess3,whichBar,"retraced "+DoubleToStr(sli[whichBar],5)+" level down","down");
            if (alertsOnLevelsBreak   && trends[forBar][2] ==  1 && trends[forBar-1][2] !=  1) doAlert(time3,mess3,whichBar,"broke "+DoubleToStr(sli[whichBar],5)+" level up","up");
      }            
      if (alertsOnSlopeChange)
      {
         static datetime time4 = 0;
         static string   mess4 = "";
            if (trends[forBar][3] ==  1 && trends[forBar-1][3] !=  1) doAlert(time4,mess4,whichBar,"slope changed up");
            if (trends[forBar][3] == -1 && trends[forBar-1][3] != -1) doAlert(time4,mess4,whichBar,"slope changed down");
      }
      if (alertsOnSignalCross)
      {
         static datetime time5 = 0;
         static string   mess5 = "";
            if (trends[forBar][4] ==  1 && trends[forBar-1][4] !=  1) doAlert(time5,mess5,whichBar,"signal line crossed up");
            if (trends[forBar][4] == -1 && trends[forBar-1][4] != -1) doAlert(time5,mess5,whichBar,"signal line crossed down");
      }
   }
}

//
//
//
//
//

void doAlert(datetime& previousTime, string& previousAlert,  int forBar, string doWhat, string realMess="")
{
   string message;
   string compare=doWhat; if(realMess!="") compare=realMess;
   
   if (previousAlert != realMess || previousTime != Time[0]) {
       previousAlert  = realMess;
       previousTime   = Time[0];

       //
       //
       //
       //
       //

       message =  StringConcatenate(Symbol()," at ",TimeToStr(TimeLocal(),TIME_SECONDS)," DZ veocity ",doWhat);
          if (alertsMessage) Alert(message);
          if (alertsEmail)   SendMail(StringConcatenate(Symbol(),"DZ veocity"),message);
          if (alertsSound)   PlaySound("alert2.wav");
   }
}
  
//+------------------------------------------------------------------
//|                                                                 
//+------------------------------------------------------------------
//
//
//
//
//

double prices[];
double iVEL(double price,double length,int i)
{
   if (ArrayRange(prices,0) != Bars) ArrayResize(prices,Bars);
   static int vellength = -1;
          if (vellength != length)
          {
              vellength = length;
                  static double coeff0; coeff0 = length + 1;
                  static double coeff1; coeff1 = coeff0 * (    coeff0+1.0)/2.0;
                  static double coeff2; coeff2 = coeff1 * (2.0*coeff0+1.0)/3.0;
                  static double coeff3; coeff3 = coeff1 * coeff1 * coeff1 - coeff2 * coeff2; 
          }
   
   //
   //
   //
   //
   //

   i = Bars-i-1;
   prices[i] = price;
   double suma = 0.0;
   double sumb = 0.0;
      for(int l=0; l<=length; l++)
      {
         suma += prices[i-l] * (coeff0-l);
         sumb += prices[i-l] * (coeff0-l) * (coeff0-l);
      }
   double tvel = (sumb*coeff1 - suma*coeff2) / (coeff3*Point); 
   return(tvel);
}


//+------------------------------------------------------------------
//|                                                                 
//+------------------------------------------------------------------
//
//
//
//
//

int    Depths[] = {2,3,4,6,8,12,16,24,32,48,64,96,128,192};
double workCfb[][28];

//
//
//
//
//

double iCfb(int totalBars, double price, int depth, int smooth, int i)
{
   if (ArrayRange(workCfb,0) != totalBars) ArrayResize(workCfb,totalBars);
         
   //
   //
   //
   //
   //

   double suma     = 0;
   double sumb     = 0;
   double cfb      = 0;
   double evenCoef = 1;
   double oddCoef  = 1;
   double avg      = 0;
         
      if (i>=smooth)
         for (int k=depth-1; k>=0; k--)
         {
            workCfb[i][k]    = iCfbFunc(totalBars,price,i,Depths[k],k);
            workCfb[i][k+14] = workCfb[i-1][k+14] + (workCfb[i][k]-workCfb[i-smooth][k])/smooth;

                  if ((k%2)==0)
                        { avg = oddCoef  * workCfb[i][k+14]; oddCoef  = oddCoef  * (1 - avg); }
                  else  { avg = evenCoef * workCfb[i][k+14]; evenCoef = evenCoef * (1 - avg); }
               
               suma += avg*avg*Depths[k];
               sumb += avg;
         }
      else for (k=depth-1; k>=0; k--) { workCfb[i][k] = 0; workCfb[i][k+14] = 0; }            

   //
   //
   //
   //
   //

   if (sumb != 0) cfb = suma/sumb;
   return(cfb);
}

//+------------------------------------------------------------------
//|                                                                  
//+------------------------------------------------------------------
//
//
//
//
//

double  workCfbFunc[][70];
#define _prices 0
#define _roc    1
#define _value1 2
#define _value2 3
#define _value3 4

//
//
//
//

double iCfbFunc(int totalBars, double price, int r, int depth, int k)
{
   k *= 5;
      if (ArrayRange(workCfbFunc,0) != totalBars) ArrayResize(workCfbFunc,totalBars);
      if (r<=(depth+1))
      {
         workCfbFunc[r][k+_prices] = 0;
         workCfbFunc[r][k+_roc]    = 0;
         workCfbFunc[r][k+_value1] = 0;
         workCfbFunc[r][k+_value2] = 0;
         workCfbFunc[r][k+_value3] = 0;
         return(0);
      }         
      workCfbFunc[r][k+_prices] = price; 

   //
   //
   //
   //
   //

      workCfbFunc[r][k+_roc]    = MathAbs(workCfbFunc[r][k+_prices] - workCfbFunc[r-1][k+_prices]);
      workCfbFunc[r][k+_value1] = workCfbFunc[r-1][k+_value1] - workCfbFunc[r-depth][k+_roc] + workCfbFunc[r][k+_roc];
      workCfbFunc[r][k+_value2] = workCfbFunc[r-1][k+_value2] - workCfbFunc[r-1][k+_value1] + workCfbFunc[r][k+_roc]*depth;
      workCfbFunc[r][k+_value3] = workCfbFunc[r-1][k+_value3] - workCfbFunc[r-1-depth][k+_prices] + workCfbFunc[r-1][k+_prices];
   
      double dividend = MathAbs(depth*workCfbFunc[r][k+_prices]-workCfbFunc[r][k+_value3]);

      //
      //
      //
      //
      //
         
   if (workCfbFunc[r][k+_value2] != 0)
         return( dividend / workCfbFunc[r][k+_value2]);
   else  return(0.00);            
}

//+------------------------------------------------------------------
//|                                                                  
//+------------------------------------------------------------------
//
//
//
//
//

double wrk[][40];

#define bsmax  5
#define bsmin  6
#define volty  7
#define vsum   8
#define avolty 9

//
//
//
//
//

double iDSmooth(double price, double length, double phase, int i, int s=0)
{
   if (SmoothDouble)
         return (iSmooth(iSmooth(price,MathSqrt(length),phase,i,s),MathSqrt(length),phase,i,s+10));
   else  return (iSmooth(price,length,phase,i,s));
}

//
//
//
//
//

double iSmooth(double price, double length, double phase, int i, int s=0)
{
   if (length <=1) return(price);
   if (ArrayRange(wrk,0) != Bars) ArrayResize(wrk,Bars);
   
   int r = Bars-i-1; 
      if (r==0) { for(int k=0; k<7; k++) wrk[r][k+s]=price; for(; k<10; k++) wrk[r][k+s]=0; return(price); }

   //
   //
   //
   //
   //
   
      double len1   = MathMax(MathLog(MathSqrt(0.5*(length-1)))/MathLog(2.0)+2.0,0);
      double pow1   = MathMax(len1-2.0,0.5);
      double del1   = price - wrk[r-1][bsmax+s];
      double del2   = price - wrk[r-1][bsmin+s];
      double div    = 1.0/(10.0+10.0*(MathMin(MathMax(length-10,0),100))/100);
      int    forBar = MathMin(r,10);
	
         wrk[r][volty+s] = 0;
               if(MathAbs(del1) > MathAbs(del2)) wrk[r][volty+s] = MathAbs(del1); 
               if(MathAbs(del1) < MathAbs(del2)) wrk[r][volty+s] = MathAbs(del2); 
         wrk[r][vsum+s] =	wrk[r-1][vsum+s] + (wrk[r][volty+s]-wrk[r-forBar][volty+s])*div;
         
         //
         //
         //
         //
         //
   
         wrk[r][avolty+s] = wrk[r-1][avolty+s]+(2.0/(MathMax(4.0*length,30)+1.0))*(wrk[r][vsum+s]-wrk[r-1][avolty+s]);
            if (wrk[r][avolty+s] > 0)
               double dVolty = wrk[r][volty+s]/wrk[r][avolty+s]; else dVolty = 0;   
	               if (dVolty > MathPow(len1,1.0/pow1)) dVolty = MathPow(len1,1.0/pow1);
                  if (dVolty < 1)                      dVolty = 1.0;

      //
      //
      //
      //
      //
	        
   	double pow2 = MathPow(dVolty, pow1);
      double len2 = MathSqrt(0.5*(length-1))*len1;
      double Kv   = MathPow(len2/(len2+1), MathSqrt(pow2));

         if (del1 > 0) wrk[r][bsmax+s] = price; else wrk[r][bsmax+s] = price - Kv*del1;
         if (del2 < 0) wrk[r][bsmin+s] = price; else wrk[r][bsmin+s] = price - Kv*del2;
	
   //
   //
   //
   //
   //
      
      double R     = MathMax(MathMin(phase,100),-100)/100.0 + 1.5;
      double beta  = 0.45*(length-1)/(0.45*(length-1)+2);
      double alpha = MathPow(beta,pow2);

         wrk[r][0+s] = price + alpha*(wrk[r-1][0+s]-price);
         wrk[r][1+s] = (price - wrk[r][0+s])*(1-beta) + beta*wrk[r-1][1+s];
         wrk[r][2+s] = (wrk[r][0+s] + R*wrk[r][1+s]);
         wrk[r][3+s] = (wrk[r][2+s] - wrk[r-1][4+s])*MathPow((1-alpha),2) + MathPow(alpha,2)*wrk[r-1][3+s];
         wrk[r][4+s] = (wrk[r-1][4+s] + wrk[r][3+s]); 

   //
   //
   //
   //
   //

   return(wrk[r][4+s]);
}  

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

double workOma[][7];
#define F01 0
#define F02 1
#define F03 2
#define F04 3
#define F05 4
#define F06 5
#define prc 6

//
//
//
//
//

double iOma(double price, double averagePeriod, double constant, bool adaptive, int r, int s=0)
{
   if (averagePeriod <=1) return(price);
   if (ArrayRange(workOma,0) != Bars) ArrayResize(workOma,Bars); r=Bars-r-1; s *=7;
   if (r<=1) 
   {
      for (int i=0; i<6; i++) workOma[r][i  +s] = 0;
                              workOma[r][prc+s] = price;
                              return(price);
   }      
   double f01=workOma[r-1][F01+s];  double f02=workOma[r-1][F02+s];
   double f03=workOma[r-1][F03+s];  double f04=workOma[r-1][F04+s];
   double f05=workOma[r-1][F05+s];  double f06=workOma[r-1][F06+s];

   //
   //
   //
   //
   //

      if (adaptive && (averagePeriod > 1))
      {
         double minPeriod = MathMin(averagePeriod,r)/2.0;
         double maxPeriod = MathMin(minPeriod*5.0,r);
         int    endPeriod = (int)MathCeil(maxPeriod);
         double tsignal   = MathAbs((price-workOma[r-endPeriod][prc+s]));
         double noise     = 0.00000000001;

            for(i=1; i<endPeriod; i++) noise=noise+MathAbs(price-workOma[r-i][prc+s]);

         averagePeriod = ((tsignal/noise)*(maxPeriod-minPeriod))+minPeriod;
      }
      
      //
      //
      //
      //
      //
      
      double Kg = (2.0+constant)/(1.0+constant+averagePeriod);
      double Hg = 1.0-Kg;

      f01 = Kg * price + Hg * f01; f02 = Kg * f01 + Hg * f02; double v01 = 1.5 * f01 - 0.5 * f02;
      f03 = Kg * v01   + Hg * f03; f04 = Kg * f03 + Hg * f04; double v02 = 1.5 * f03 - 0.5 * f04;
      f05 = Kg * v02   + Hg * f05; f06 = Kg * f05 + Hg * f06; double v03 = 1.5 * f05 - 0.5 * f06;

   //
   //
   //
   //
   //

   workOma[r][F01+s] = f01;  workOma[r][F02+s] = f02;
   workOma[r][F03+s] = f03;  workOma[r][F04+s] = f04;
   workOma[r][F05+s] = f05;  workOma[r][F06+s] = f06;
   workOma[r][prc+s] = price;
   return(v03);
}

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

void CleanPoint(int i,double& first[],double& second[])
{
   if ((second[i]  != EMPTY_VALUE) && (second[i+1] != EMPTY_VALUE))
        second[i+1] = EMPTY_VALUE;
   else
      if ((first[i] != EMPTY_VALUE) && (first[i+1] != EMPTY_VALUE) && (first[i+2] == EMPTY_VALUE))
          first[i+1] = EMPTY_VALUE;
}

//
//
//
//
//

void PlotPoint(int i,double& first[],double& second[],double& from[])
{
   if (first[i+1] == EMPTY_VALUE)
      {
         if (first[i+2] == EMPTY_VALUE) {
                first[i]   = from[i];
                first[i+1] = from[i+1];
                second[i]  = EMPTY_VALUE;
            }
         else {
                second[i]   =  from[i];
                second[i+1] =  from[i+1];
                first[i]    = EMPTY_VALUE;
            }
      }
   else
      {
         first[i]  = from[i];
         second[i] = EMPTY_VALUE;
      }
}