//+------------------------------------------------------------------+
//|                                                      forAnna.mq4 |
//+------------------------------------------------------------------+
//| Version 01. Mxx. 07.10.10                                        |
//+------------------------------------------------------------------+
#property copyright ""
#property link      ""

#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1  Blue
#property indicator_color2  Red
#property indicator_width1  1
#property indicator_width2  1

extern  int    prmBars   = 1000;
extern  int    prmLength = 5;
extern double  width=1;

///////////////////////////////////////////////////////////
double MarkNord[];
double MarkZuid[];
double Mark[];
double m[];
double m2[];

void init()
{
    IndicatorDigits(Digits);

    SetIndexStyle (0, DRAW_ARROW);  SetIndexArrow(0, 163);
    SetIndexBuffer(0, MarkNord);
    SetIndexStyle (1, DRAW_ARROW);  SetIndexArrow(1, 163);
    SetIndexBuffer(1, MarkZuid);
   // SetIndexStyle (2, 12);  SetIndexArrow(2, 12);
   // SetIndexBuffer(2, Mark);
    SetIndexStyle (3, 12);  SetIndexArrow(3, 12);
    SetIndexBuffer(3, m);  
    
    SetIndexStyle (4, 12);  SetIndexArrow(4, 12);
    SetIndexBuffer(4, m2); 

    IndicatorShortName("Frct:"+prmLength);
    SetIndexLabel(0,   "top:"+prmLength);
    SetIndexLabel(1,   "bot");
}
//=========================================================

void start()
{
    int nMax = prmBars;               //количество бар
    if (nMax < 10 || nMax > Bars)
        nMax = Bars;
    ObjectsDeleteAll(); 
    int nRight  = (prmLength-1)/2;
    int prevTop = nMax+prmLength;          //количество бар перед верхним фракталом
    int prevBot = nMax+prmLength;          //количество бар перед нижним фракталом
    int nOffset = prmLength/2;
    if (prmLength%2 == 0)
        nOffset--;
        
    int shift=iTime(NULL,0,prmBars);
    string t=TimeToStr(shift,TIME_DATE|TIME_SECONDS);
    Print("shift of bar with open time ",t," is ",shift);

    //int mmm[];
    ArrayResize(Mark, prmBars);
    ///////////////////////////////////////////////////////
    int len = 0, a = 0, b = 0, c = -1;
    for (int k = nMax-prmLength/2; nRight <= k; k--) {

        if (nOffset < prevTop-k && true == GetTopFrac(k, prmLength)) {
            MarkNord[k] = High[k]; //EMPTY_VALUE
                
           if (MarkNord[k] > 0){
                   c++;
                   a++;
                   Mark[c] = MarkNord[k];
           }
            prevTop = k;
         }
        
        if (nOffset < prevBot-k && true == GetBotFrac(k, prmLength)) {
            MarkZuid[k] = Low[k];
            if (MarkZuid[k] > 0){
                c++;
                Mark[c] = MarkZuid[k];
                b++;
            }
            prevBot = k;
        }                       
    }
    len = a + b;   
    Print("Length: ", len);
  
///////////////////////////////////////Вывод горизонтальных зон//////////////////////////////////////////////////////////////////////////////////////

    double  av=0, p=0, s=0, p2=0;                   //av-ср арифм-кое  р,р2-цена 1фрактала зоны
    int max = 0, h = 0,tmp = 0, max2 = 0,i,j;   //max,max2-макс кол-во фракталов в зоне

    for (i = 0; i < prmBars; i++){   
		av += MathAbs(Mark[i]);
		if (Mark[i] > 0) //continue;
				
		for (j = 0; j < prmBars; j++){		   
			if (  ((Mark[i] + width) > Mark[j]) && ((Mark[i] - width) < Mark[j]) && (Mark[j] > 0) && (i != j)){			
					if ( (MathCeil(Mark[j]/5)*5) - Mark[j] <=0.5 ) {
						b = Mark[j];
					//	Print("b: ", b);
					}
					m[h] = Mark[j];
					Mark[j] *= -1;
					h++;
			}
		}	
		if(h>0)
	//	Print("----------------------", h);	
				
		if ((h > max) || (h > max2) ) {
		    if (max < h){
		      ArrayCopy(m2, m);
		      max2 = max;
			 max = h;
			 p = MathAbs(Mark[i]);
			}
			else{
			 max2 = h;
			 p2 = MathAbs(Mark[i]);
			}
		}
		h = 0;
	//	printf("-------\n");
	}  
	Print("Average: ", av / prmBars);
	Print("max: ",max);
	Print("max2: ", max2);
    Print("P:", p);
    Print("P2: ", p2);  
	
//////////////////////////рисуем горизонтальные зоны//////////////////////////////////////////////////////////////////  
    ObjectCreate("str", OBJ_RECTANGLE, 0, Time[1000], p+width, Time[0],  p-width);  
    ObjectSet("str", OBJPROP_COLOR, Gold);  
    ObjectCreate("str2", OBJ_RECTANGLE, 0, Time[1000], p2+width, Time[0],  p2-width);
    ObjectSet("str2", OBJPROP_COLOR, Orange); 	

//////////////////////////Вывод наклонных зон/////////////////////////////////////////////////////////////////////////

    //int mmm[];
    //ArrayResize(mmm, len+1);
     
  double  cen=0, l=0, cen2=0, cen1=0, eps=0;                   //v, v2-цена 1фрактала зоны
    int mak = 0, u, tm = 0, mak2 = 0;   //max, max2-макс кол-во фракталов в зоне
    int tt, t1;
    int ab,cd,ks;
    double ugol, e, angle, ta;                         //угол
    double w, r;
    int count = 0, _max = 0,  ind = 0, _max2 = 0;    
    
   /* int timet=StrToTime(DoubleToStr(prmBars,2));
    Print("timet: ",timet,  "  tt: ", DoubleToStr(prmBars,2), " ", prmBars);
    Print("timet: ",StrToTime(DoubleToStr(prmBars-1,2)),  "  tt: ", DoubleToStr(prmBars-1,2), " ", prmBars-1);
    Print("timet: ",StrToTime(DoubleToStr(0,2)),  "  tt: ", DoubleToStr(0,2), " ", 0);*/

    for(i= prmBars; i>=0; i--){
        if (Mark[i] < 0)  Mark[i] *= -1; 
    }
    //Print("Len = ", len);
    
    FileDelete("test");

    int hFile = FileOpen("test", FILE_READ | FILE_WRITE, ';'); 
 

   for (ab = 0;  ab < prmBars; ab++){
  // Print(ab);
        
       // Print(ab," ",cd);
       int mx = 0;
       for(ks=-85; ks<=85; ks+=5, count = 0){        
            e = MathTan(ks * 0.017453292);
            //Print("E = ", e);
//          Print(ab," ",cd," ",e);              
            for(cd=1; cd < prmBars; cd++){
                r=Mark[ab]+(MathAbs(ab-cd))*e;
                //Print("T = ", Time[ab-cd], " ", (ab-cd), " ", TimeToStr(MathAbs(Time[ab-cd]),TIME_DATE), " ", StrToDouble(TimeToStr(MathAbs(Time[ab-cd]),TIME_DATE)));
                //Print("r: ",r-Mark[cd]);
                //Print("ab-cd = ",MathAbs(ab-cd), "  ",e, " ", MathAbs(ab-cd)*e);
                if(MathAbs(r-Mark[cd])<=10 && Mark[cd] > 0){
                    Mark[cd] *= 1;    
                    count++;                                    
                    FileWrite(hFile,ab,cd,ks, r, r-Mark[cd],count);
                }                  
               // if (count>=10){
                    if (count > max){		          
			             max = count;
			             mak = MathAbs(Mark[ab]);
			             //Print("mak = ",mak);
			             }
			    
		          string st = "Obj_"+mak;
		        //  Print(Time[ab]," ",   Mark[ab], " ",  Time[cd], " ", r);
                  ObjectCreate(st, OBJ_TRENDBYANGLE, 0, Time[ab], Mark[ab]);
                  ObjectSet(st,OBJPROP_WIDTH,15);
                  ObjectSet(st, OBJPROP_ANGLE, ks);
                  ObjectSet(st, OBJPROP_COLOR, Pink);
                  ObjectSet(st,OBJPROP_BACK,true);
                  ObjectSet(st,OBJPROP_WIDTH,15);
              //  }	            
           }
           
        /*   if (mx < count){
              mx = count; 
              ta = ks;
           }*/
        }   
      //  Print(mx);
       // Print("нашли: ",Mark[i]);
      /* 	if(count>0){
       	    Print("count = ",count);
		    if (count > max){		          
			     max = count;
			     mak = MathAbs(Mark[ab]);
			    Print("mak = ",mak);
			    }*/
		
	
    } //ab
    
    
    
       
    FileClose(hFile);
        
/////////////рисуем диагональные зоны///////////////////////    
   /* for(ab = 0;  ab < len; ab++){          
        string st = "Obj_"+ab;
        ObjectCreate(st, OBJ_TREND, 0, Time[ab], Mark[ab], Time[ab-1], Mark[ab-1]);  //188.22
        ObjectSet(st, OBJPROP_COLOR, Pink);
        ObjectSet(st,OBJPROP_WIDTH,8);
    }
    */
/*    for (i = 0; i < len; i++){ 
        if (Mark[i] < 0)  Mark[i] *= -1; 
    //for (tt = 0; tt < prmBars; tt++){
       // if (Mark[j] < 0)  Mark[j] *= -1; 
       // Print("Mark[", i, "] = ", Mark[i]);
        for (int ang = 85; ang >= -85; ang-=5, count = 0){        
            e = MathTan(ang * 0.017453292);
            //for(int y=0; y<len; y++)
            for (int g = 0; g < len; g++){                
                Mark[g] = Mark[i] + e*(Mark[g] - Mark[i]);            
                if ((MathAbs(Mark[g] - Mark[i]) < width ) && Mark[g] > 0){
                    count ++;
                  //  Mark[g] *= -1;
                }
            }
        //    if(count>0)
       //Print(" Count = ", count);
            //Print("Angle = ", ang ," Count = ", count);
        }
  // }   
    /*   if ((_max < count) || (_max2 < count)){
            _max = count;
            ind = i;
       }				
	/*	if ((count > _max) || (count > _max2) ) {
		    if (_max < count){
		      _max2 = _max;
			 _max = count;
			}
			else{
			 _max2 = count;
			}
		}		
	*/
	   
    
  
 //  Print("Max point: ", MathAbs(Mark[ind]) ," Count = ", count, " Count2 = ", _max2);   
  //  ObjectSet("St", OBJPROP_ANGLE, ang * 0.017453292);
       
        /**    
        for(ugol=85; ugol>=-85; ugol--){
            e=MathTan(ugol*0.017453292);
            for(cen1=0;cen1<=len;cen1++){    
                if (Mark[i] < 0) continue; 
                for(cen=0;cen<=len;cen++){       
                    cen=cen1+e*(tt-t1);
                    cen2=cen1+e*(t2-t1);
                    eps=MathAbs(cen2-cen);
                    if(eps<=width && eps>=-width){
              //      M[u] = Mars[x];
		              Mark[u] *= -1;
		              u++;
                    }
                }
            }
        }
        **/
}    
  /* for(e=85;e>=-85;e--){
    for (int z = 0; z < len; z++){
		//av += MathAbs(Mark[i]);
		if (Mars[i] < 0) continue;				
		for (int x = 0; x < len; x++){
			if (  ((Mars[z] + width) > Mars[x]) && ((Mars[z] - width) < Mars[x]) && (Mars[x] > 0) && (z != x)){	
					if ( (MathCeil(Mark[j]/5)*5) - Mark[j] <=0.5 ) {
						b = Mars[u];
						Print("b: ", b);
					}
					M[u] = Mars[x];
					Mars[u] *= -1;
					u++;
			}
		}	
		if(u>0)
		Print("----------------------", u);	
*/				
/*		if ((u > mak) || (u > mak2) ) {
		    if (mak < u){
		      ArrayCopy(M1, M);
		      mak2 = mak;
			 mak = u;
			v = MathAbs(Mars[z]);
			}
			else{
			 mak2 = u;
			 v2 = MathAbs(Mars[z]);
			}
		}
		u = 0;
*/	//	printf("-------\n");
   //} 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
bool GetTopFrac (int shift, int nLength)
//  Bерхние фракталы
{
    int j, nVl, nVr;
    //  Левая часть
    for (j = nLength/2; j > 0; j--) {
        nVl = 0.5 + High[shift+j  ]/Point;
        nVr = 0.5 + High[shift+j-1]/Point;
        if (nVr >= nVl) {
        }
        else
            return(false);
    }
    //  Правая часть
    int nRight = (nLength-1)/2;
    for (j = 1; j <= nRight; j++) {
        nVl = 0.5 + High[shift-j+1]/Point;
        nVr = 0.5 + High[shift-j  ]/Point;
        if (nVl >= nVr) {
        }
        else
            return(false);
    }
    return(true);
}
//=========================================================

bool GetBotFrac (int shift, int nLength)
//  Нижние фракталы
{
    int j, nVl, nVr;
    //  Левая часть
    for (j = nLength/2; j > 0; j--) {
        nVl = 0.5 + Low[shift+j  ]/Point;
        nVr = 0.5 + Low[shift+j-1]/Point;
        if (nVr <= nVl) {
        }
        else
            return(false);
    }
    //  Правая часть
    int nRight = (nLength-1)/2;
    for (j = 1; j <= nRight; j++) {
        nVl = 0.5 + Low[shift-j+1]/Point;
        nVr = 0.5 + Low[shift-j  ]/Point;
        if (nVl <= nVr) {
        }
        else
            return(false);
    }
    return(true);
}
//=========================================================