Хорошие индикаторы по теории Демарка - страница 4

Авторизуйтесь или зарегистрируйтесь, чтобы добавить комментарий
Forex Trader
114499
Forex Trader  
2 MaXiM, меня тоже заинтересовала реализация теории Демарка. Я переделал индикатор от Владислава, как раз чтобы рисовались цели, без прорыва, если это то что нужно. Одно "но", этот индикатор рисует не 4 лини (как в оригинальном индикаторе), а мин(А) и макс(В).

//+------------------------------------------------------------------+
//|                                        TD_Points&Lines_mgtd1.mq4 |
//|                                           Vladislav Goshkov (VG) |
//|                                                      4vg@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Vladislav Goshkov (VG)"
#property link      "4vg@mail.ru"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Blue
#property indicator_color2 Red
#property indicator_color3 Blue
#property indicator_color4 Red
double TargetUpA[];
double TargetUpB[];
double TargetDnA[];
double TargetDnB[];

extern int MaxStep=100;
extern bool LevelA=True;
extern bool LevelB=True;
extern bool ClosedLevel=False;
/*extern color UpLineColor = Blue;
extern int   UpLnWidth = 1;
extern color DnLineColor = Red;
extern int   DnLnWidth = 1;
extern color MarkColor   = Blue;
extern int   MarkNumber  = 217;
*/
//int Step=0;
bool Qw1=True;
bool Qw2=True;
bool Qw3=True;
int Step=0;
int i=1,NP=0,D=0,j=0,
    iB_Up=0,iB_Dn=0,
    S1=0,
    S2=0,
    UpLev=0,
    DownLev=0,
    iP_Up=0,
    iP_Dn=0,
    value=0,
    CurPeriod=0,
    shift=0;

datetime  nTime=0;

double UpV=0,
       DownV=0,
       iP=0,
       target = 0,
       UpP[2]={0,0},
       DownP[2]={0,0},
       PP1=0,PP2=0,PP3=0,
       Mx=0,Mn=0;

int    DownBT[2]={0,0}, // Bar Time
       UpBT[2]={0,0},
       UpB[2]={0,0},    // Bar Num
       DownB[2]={0,0};
string buff_str = "";
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
//---- indicators
  	SetIndexBuffer(0, TargetUpA);
  	SetIndexLabel(0, "TD Up A");
  	SetIndexBuffer(1, TargetUpB);
  	SetIndexLabel(1, "TD Up B");
  	SetIndexBuffer(2, TargetDnA);
  	SetIndexLabel(2, "TD Dn A");
  	SetIndexBuffer(3, TargetDnB);
  	SetIndexLabel(3, "TD Dn B");
	for(i=0;i<=3;i++)
	{
   	SetIndexStyle(i,DRAW_ARROW);
   	SetIndexArrow(i,159);
   	SetIndexEmptyValue(i,0);
	}
//----
	if(MaxStep==0) MaxStep=Bars-1;
   return(0);
}
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
//Comment(" ");   
//ObjectsDeleteAll();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
int Target_Style[4] = {STYLE_DASH,STYLE_DASH,STYLE_DASH,STYLE_SOLID},
    Target_Color[4] = {DimGray,MediumSpringGreen,SeaGreen,Blue},
    Target_LW[4]    = { 1, 1, 1, 2 };
double target[4];
//---- TODO: add your code here
//int    counted_bars=MathMin(20,IndicatorCounted());
int    counted_bars=IndicatorCounted();
if(counted_bars>0) counted_bars--;
int limit=Bars-counted_bars;
for(Step=MathMin(MaxStep,limit);Step>=0;Step--)
{
	//Dn[Step]=0;
	//Up[Step]=0;
   UpP[0] = 0;
   UpP[1] = 0;
   for(i=0;i<4;i++) target[i] = 0;

//=================================================
//******** Поиск опорных точек предложения ********
//=================================================
	for(i=2+Step,D=2,NP=0; (NP<D)&&(i<Bars); i++) 
	{
		if (High[i]!= High[i+1]) 
		{ 
			if( (High[i]>High[i+1] && High[i]>High[i-1] && High[i]>Close[i+2] ) 
					&& High[i]> UpP[0] ) 
			{
				UpB[NP]  = i;
				UpBT[NP] = Time[i];
				UpP[NP]  = High[i];
				NP++;
			}
		}

		if (High[i]== High[i+1])  
		{ 
			if ( (High[i]>High[i+2] && High[i]>High[i-1] && High[i]>Close[i+3] ) && High[i]> UpP[0] ) 
			{
				UpB[NP]  = i;
				UpBT[NP] = Time[i];
				UpP[NP]  = High[i];
				NP++;
			}
		}
		if(i == (Bars-2) ) 
		{
			UpB[NP]  = i;
			UpBT[NP] = Time[i];
			UpP[NP]  = High[i];
			break;
		}
	}//for(i=2+Step,D=2,NP=0; NP<D; ) {//End;

//=================================================
//********** Поиск опорных точек спроса ***********
//=================================================
   DownP[0] = 1000000000;
   DownP[1] = 1000000000;
   for(i=2+Step,D=2,NP=0; (NP<D)&&(i<Bars); i++) 
   {
		if (Low[i]!= Low[i+1])  
		{ 
			if ( (Low[i]<Low[i+1] && Low[i]<Low[i-1] && Low[i]<Close[i+2] ) && Low[i]< DownP[0] )
			{
				DownB[NP] = i;
				DownBT[NP]= Time[i];
				DownP[NP] = Low[i];
				NP++;
			}
			//i++;
		}
		if (Low[i]== Low[i+1])  
		{ 
			if ( (Low[i]<Low[i+2] && Low[i]<Low[i-1] && Low[i]<Close[i+3] ) && Low[i]< DownP[0] )
			{
				DownB[NP] = i;
				DownBT[NP]= Time[i];
				DownP[NP] = Low[i];
				NP++;
			}
  			//i++;
		}
		if (i == (Bars-2) ) 
		{ 
			DownB[NP] = i;
			DownBT[NP]= Time[i];
			DownP[NP] = Low[i];
			break;
		}
	}//End;
     

	if((UpB[0]-UpB[1]==0) || (DownB[0]-DownB[1]==0)) continue;
	UpV = (UpP[1]-UpP[0])/(UpB[0]-UpB[1]);
	DownV = (DownP[1]-DownP[0])/(DownB[0]-DownB[1]);

//=================================================
//****       Рисуем  TD-линии                  ****
//=================================================
/*   buff_str = "TD_Up";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, UpBT[1], UpP[1],UpBT[0], UpP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, UpLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, UpLnWidth);
      }
   else {
      ObjectMove(buff_str, 1, UpBT[0], UpP[0]);
      ObjectMove(buff_str, 2, UpBT[1], UpP[1]);
      }

   buff_str = "TD_Dn";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, DownBT[1], DownP[1],DownBT[0], DownP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, DnLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, DnLnWidth);
      }
   else {
      ObjectMove(buff_str, 1, DownBT[0], DownP[0]);
      ObjectMove(buff_str, 2, DownBT[1], DownP[1]);
      }

   CurPeriod = Period();
   nTime = Time[0];
   }//if (nTime <> Time[0]) {
*/
//----
	for( i=UpB[0]; i>=Step; i--)
	{
   	if( (Close[i]>UpP[0]+UpV*(UpB[0]-i)) && (Close[i+1]<=UpP[0]+UpV*(UpB[0]-(i+1))) ) 
   	{
			iB_Up=i; 
			iP=UpP[0]+UpV*(UpB[0]-i);
			iP_Up = iP; 
			S1=Lowest(NULL,0,MODE_LOW,UpB[1]-i,i);
			S2=Lowest(NULL,0,MODE_CLOSE,UpB[1]-i,i);

			PP1=iP+((UpP[1]+UpV*(UpB[1]-S1))-Low[S1]);
			PP2=iP+((UpP[1]+UpV*(UpB[1]-S2))-Low[S2]);
			PP3=iP+((UpP[1]+UpV*(UpB[1]-S1))-Close[S1]);
//			if((Qw1 && Close[i+2]>Close[i+1])
//					|| (Qw2 && Open[i]> iP)
//					|| (Qw3 && (Close[i+1]+(Close[i+1]-MathMin(Low[i+1],Close[i+2])))<iP) ) 
			{
				target[0] = PP1;
				target[1] = PP2;
				target[2] = PP3;
				target[3] = (PP1+PP2+PP3)/3;
/*             buff_str = "Break_Sig_Up";
             if(ObjectFind(buff_str) == -1) {
                ObjectCreate(buff_str, OBJ_ARROW,0, Time[iB_Up], iP+2*Point );
                ObjectSet(buff_str, OBJPROP_ARROWCODE, 164);
                ObjectSet(buff_str, OBJPROP_COLOR, Red);
                }
             else {
                ObjectMove(buff_str, 0, Time[iB_Up], iP+2*Point );
                }
*/
				//Up[Step]=MathMin(i-Step+1,5);
				Mx=target[0];
				Mn=target[0];
				for(j=1;j<=3;j++)
				{
					if(Mx<target[j]) Mx=target[j];
					if(Mn>target[j]) Mn=target[j];
				}
				if(LevelA && (High[Step]<=Mx || ClosedLevel)) TargetUpB[Step]=Mx;
				if(LevelB && (High[Step]<=Mn || ClosedLevel)) TargetUpA[Step]=Mn;
			}
		}
	}

	for( i=DownB[0]; i>=Step;i--) 
	{
		if( (Close[i]<DownP[0]+DownV*(DownB[0]-i)) && (Close[i+1]>=DownP[0]+DownV*(DownB[0]-(i+1))) ) 
		{
			iB_Dn=i; 
			iP=DownP[0]+DownV*(DownB[0]-i);
			iP_Dn = iP;
			S1=Highest(NULL,0,MODE_HIGH,DownB[1]-i,i);
			S2=Highest(NULL,0,MODE_CLOSE,DownB[1]-i,i);

			PP1=iP-(High[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
			PP2=iP-(High[S2]-(DownP[1]+DownV*(DownB[1]-S2)));
			PP3=iP-(Close[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
//			if((Qw1 && Close[i+2]<Close[i+1] )
//					|| (Qw2 && Open[i] < iP )
//					|| (Qw3 && (Close[i+1]+(Close[i+1]-MathMax(High[i+1],Close[i+2])))>iP) ) 
			{
				target[0] = PP1;
				target[1] = PP2;
				target[2] = PP3;
				target[3] = (PP1+PP2+PP3)/3;
/*             buff_str = "Break_Sig_Dn";
             if(ObjectFind(buff_str) == -1) {
                ObjectCreate(buff_str, OBJ_ARROW,0, Time[iB_Dn], iP+2*Point );
                ObjectSet(buff_str, OBJPROP_ARROWCODE, 164);
                ObjectSet(buff_str, OBJPROP_COLOR, Blue);
                }
             else {
                ObjectMove(buff_str, 0, Time[iB_Dn], iP+2*Point );
                }
*/    		//Dn[Step]=MathMax(-(i-Step+1),-5);
				Mx=target[0];
				Mn=target[0];
				for(j=1;j<=3;j++)
				{
					if(Mx<target[j]) Mx=target[j];
					if(Mn>target[j]) Mn=target[j];
				}
				if(LevelA && (Low[Step]>=Mn || ClosedLevel)) TargetDnB[Step]=Mn;
				if(LevelB && (Low[Step]>=Mx || ClosedLevel)) TargetDnA[Step]=Mx;
			}
		}
	}//for( i=DownB[1]; i>=Step;i--) {
	
}


/*   for(i=3;i>=0;i--) {
      buff_str = "Target"+i;
      if(ObjectFind(buff_str) == -1) {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
         }
      else {
         ObjectMove(buff_str, 0, Time[0], target[i] );
         }
      }
*/

//----
/*string buff_str = "TD_LatestCulcBar";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_ARROW,0, Time[Step], Low[Step]-2*Point );
      ObjectSet(buff_str, OBJPROP_ARROWCODE, MarkNumber);
      ObjectSet(buff_str, OBJPROP_COLOR, MarkColor);
      }
   else {
      ObjectMove(buff_str, 0, Time[Step], Low[Step]-2*Point );
      }
   return(0);
*/  
}
//+------------------------------------------------------------------+
Forex Trader
114499
Forex Trader  
*MaXiM*
Выкладываю последнюю версию моей корректировки...


Не могли бы Вы оформлять код в тегах [ code ] [ / code] (без пробелов)?
Forex Trader
114499
Forex Trader  
Закоментирован код верно, но это было не обязательно, чтобы цели рисовались всегда достаточно флажки для учета квалификаторов установить в нули (фалсе в текущей версии)
 
bool Qw1=False;
bool Qw2=False;
bool Qw3=False;



Вообще то они специально были сделаны внешними, чтобы не перекомпилировать код постоянно.

Удачи.

Forex Trader
114499
Forex Trader  
Закоментирован код верно, но это было не обязательно, чтобы цели рисовались всегда достаточно флажки для учета квалификаторов установить в нули (фалсе в текущей версии)
 
bool Qw1=False;
bool Qw2=False;
bool Qw3=False;



Вообще то они специально были сделаны внешними, чтобы не перекомпилировать код постоянно.

Удачи.



А мне кажется, что если все три переменные будут в false, то уровни гарантировано рисоваться не будут.
Там ведь условие:
			if((Qw1 && Close[i+2]>Close[i+1])
					|| (Qw2 && Open[i]> iP)
					|| (Qw3 && (Close[i+1]+(Close[i+1]-MathMin(Low[i+1],Close[i+2])))<iP) ) 


И если они false, то все условия будут false.

Forex Trader
114499
Forex Trader  
По просьбе Артура..... не знаю, правильно ли я понял? (в тэге

без пробелов..)

//+------------------------------------------------------------------+
//|                                        DMTrendLines&PricesUp.mq4 |
//|                                        Copyright © 2003, Company |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2003, Company"
#property link      "http://www.company.com/"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Blue
double ExtMapBuffer1[];


//---- input parameters
//Variable : shift(0);
//Variable : KUp(0), BUp(0), n(0),MinPrice(0),TargetPriceUp(0);
//Array : TrendPriceUp[2,1](0);
//Arrays : Maximum[2,1](0), TimeofMaximum[2,1](0), shiftofMaximum[2,1](0);
int shift=0;
double   TrendPriceUp[3][2],// ???????? зачем объявлять реально одномерный массив как 2-мерный ?
         KUp = 0.0, 
         BUp = 0.0, 
         MinPrice = 0.0,
         TargetPriceUp = 0.0,
         Maximum[3][2];// ???????? зачем объявлять реально одномерный массив как 2-мерный ?
         //MaxMinPriceimum[2][1];// ???????? зачем объявлять реально одномерный массив как 2-мерный ?
int      n = 0,
         shiftofMaximum[3][2];// ???????? зачем объявлять реально одномерный массив как 2-мерный ?

datetime TimeofMaximum[3][2];// ???????? зачем объявлять реально одномерный массив как 2-мерный ?
//string   buff_str="";

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   
   SetIndexStyle(0,DRAW_LINE);
   SetIndexArrow(0,217);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
  
   
//----
	for(int i=0; i<=2; i++){
   for(int j=0; j<=1; j++){
     TrendPriceUp[i][j]= 0;
     Maximum[i][j]     = 0;
     shiftofMaximum[i][j] = 0;
     TimeofMaximum[i][j]  = 0;
    }
    }
	
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
  Comment(" ");   
ObjectsDeleteAll();
//----
   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
  // int    counted_bars=IndicatorCounted();
//---- 
for( shift = Bars-1; shift>= 1;shift--)  { //For shift = Bars-1 Downto 1 Begin

   TrendPriceUp[1][1] = TrendPriceUp[2][1];

   TrendPriceUp[2][1] = KUp*(shift) + BUp;
   ExtMapBuffer1[shift]     = TrendPriceUp[2][1];//SetIndexValue(shift, TrendPriceUp[2,1]);
   
   if( (High[shift] >  High[shift-1]) //Если точка - максимум, запоминаются ее координаты
    && (High[shift] >= High[shift+1]) 
       ) {
      Maximum[1][1] = Maximum[2][1]; 

      TimeofMaximum[1][1]  = TimeofMaximum[2][1];
      shiftofMaximum[1][1] = shiftofMaximum[2][1];
      shiftofMaximum[2][1] = shift;
      Maximum[2][1]        = High[shift];
      TimeofMaximum[2][1]  = Time[shift];


      KUp = (Maximum[2][1]-Maximum[1][1])/(shiftofMaximum[2][1]-shiftofMaximum[1][1]);
      BUp = Maximum[1][1] - KUp*shiftofMaximum[1][1];

      TrendPriceUp[2][1] = KUp*(shift) + BUp;
          
          if( Maximum[1][1] >= Maximum[2][1]) {  //Если тренд вниз, 

         for( n=shiftofMaximum[1][1];n>= shiftofMaximum[2][1];n--){  //Then {For n = shiftofMaximum[1,1] DownTo shiftofMaximum[2,1] Begin  вычисляется цена по новому тренду, начиная с его начала
             TrendPriceUp[2][1] = KUp*(n) + BUp;
             ExtMapBuffer1[n] = TrendPriceUp[2][1];//SetIndexValue(n, TrendPriceUp[2,1]);
             }
             
          
                 //MoveObject("UpTrend", OBJ_TRENDLINE, TimeofMaximum[1,1], Maximum[1,1], TimeofMaximum[2,1], Maximum[2,1], Blue, 1, STYLE_SOLID);
         //buff_str = "UpTrend";
            ObjectCreate("UpTrend", OBJ_TREND, 0, TimeofMaximum[1][1], Maximum[1][1],TimeofMaximum[2][1], Maximum[2][1]);
            ObjectSet("UpTrend", OBJPROP_STYLE, STYLE_SOLID);
            ObjectSet("UpTrend", OBJPROP_COLOR, Blue);
            ObjectSet("UpTrend", OBJPROP_WIDTH, 1);   //Новый тренд вниз прорисовывается
          
         }//If Maximum[1,1] >= Maximum[2,1]

      }// if High[shift] > High[shift - 1] AND High[shift] >= High[shift + 1]
      
      if( (Close[shift]>TrendPriceUp[2][1]) 
    && (Close[shift+1] <= TrendPriceUp[1][1])    
    && (TrendPriceUp[1][1] >= TrendPriceUp[2][1])  //и тренд направлен вниз, рассчитывается цена прорыва.
      ) {
       MinPrice = Low[Lowest(NULL,0,MODE_LOW, shiftofMaximum[1][1] - shift,shiftofMaximum[1][1])];
       TargetPriceUp = (TrendPriceUp[2][1] - MinPrice) + TrendPriceUp[2][1];
       
 
    
	//MoveObject("TargetPriceUp"+Mod(shift,1), OBJ_HLINE, TimeofMaximum[1,1], TargetPriceUp, TimeofMaximum[2,1], TargetPriceUp, Blue, 1, STYLE_DOT);
         //buff_str = "TargetPriceUp"+DoubleToStr(MathMod(shift,1),5);
            ObjectCreate("TargetPriceUp"+DoubleToStr(MathMod(shift,1),5), OBJ_HLINE, 0, TimeofMaximum[1][1], TargetPriceUp,TimeofMaximum[2][1], TargetPriceUp);
            ObjectSet("TargetPriceUp"+DoubleToStr(MathMod(shift,1),5), OBJPROP_STYLE, STYLE_DOT);
            ObjectSet("TargetPriceUp"+DoubleToStr(MathMod(shift,1),5), OBJPROP_COLOR, Blue);
            ObjectSet("TargetPriceUp"+DoubleToStr(MathMod(shift,1),5), OBJPROP_WIDTH, 1);
         
       }//If Close[shift] > TrendPriceUp[2,1] AND Close[shift+1] <= TrendPriceUp[1,1]

   }//For shift = Bars-1 Downto 1 Begin


         
//----
   return(0);
  }
//+------------------------------------------------------------------+

.





Forex Trader
114499
Forex Trader  
Евгений, я считаю что индикатор Владислава лучше в первоначальном виде, только если без неточностей при переводе и чтобы рисовались цели, без прорыва. Ребята, у меня просьба, выложите такой вид индикатора.

Не знаю, правильно ли я понял. Владислав, ты 3 варианта расчета ценового проектора складываешь и делишь на три. Я считаю, что лучше оставлять все три варианта (прорисовывать 3(6) линии(й) на графике) или 2(4) линии, максимальную и минимальную из трех. Это будет более точно.

Теперь к моей версии. С моей стороны, лучше отталкиваться от нее. Я несколько месяцев исследую ее, т.е. есть основа. Можно конечно корректировать вариант Владислава, но для меня это как с "нуля". Моя версия упрощенная, но математически она ведь также описана? У меня остается просьба правильно переписать и мою версию. Мы можем пойти с двух сторон одновременно, усложняя мою и упрощая Владислава.
Вообще, если переписать мою версию, первое изменение которое я хотел бы внести, это 3 варианта расчета ценового проектора (без учета квалификаторов прорыва) и прорисовка на графике максимальных и минимальных вариантов. Более никаких изменений, сначала нужно будет проанализировать результат. Самая координальная разница у нас в том, что выбор TD-точек я хочу пока у себя оставить таким, как он есть, и определение TD-точки в момент открытия первой свечи после пика, а не второй (т.е. я осознаю, что эта TD-точка может исчезнуть).
Forex Trader
114499
Forex Trader  
Всем привет!
Не знаю, может я не в теме, но давно уже есть работающий индикатор по DeMarky, кстати там можно задействовать опорные точки второго - более позднего порядка (фракталы)...
Давно его пользую, работает не плохо:



//+------------------------------------------------------------------+
//|                                            Ind-TD-DeMark-3-1.mq4 |
//|                            Copyright © 2005, Kara Software Corp. |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, Kara Software Corp."
#property link      ""
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
//---- input parameters
extern int       BackSteps=0;
extern int       ShowingSteps=1;
extern bool      FractalAsTD=false;
extern bool      Commen=true;
extern bool      TD=true;
extern bool      TrendLine=true;
extern bool      HorizontLine=true;
extern bool      TakeProf=true;
//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
//====================================================================
int init()
  {
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,217);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,218);
   SetIndexBuffer(1,ExtMapBuffer2);
   SetIndexEmptyValue(1,0.0);
   for (int i=1;i<=10;i++)
     {
      ObjectDelete("HHL_"+i);ObjectDelete("HL_"+i);
      ObjectDelete("HLL_"+i);ObjectDelete("LL_"+i);
      ObjectDelete("HC1_"+i);
      ObjectDelete("HC2_"+i);
      ObjectDelete("HC3_"+i);
      ObjectDelete("LC1_"+i);
      ObjectDelete("LC2_"+i);
      ObjectDelete("LC3_"+i);
     }
   Comment("");    
   return(0);
  }
int deinit()
  {
   for (int i=1;i<=10;i++)
     {
      ObjectDelete("HHL_"+i);ObjectDelete("HL_"+i);
      ObjectDelete("HLL_"+i);ObjectDelete("LL_"+i);
      ObjectDelete("HC1_"+i);
      ObjectDelete("HC2_"+i);
      ObjectDelete("HC3_"+i);
      ObjectDelete("LC1_"+i);
      ObjectDelete("LC2_"+i);
      ObjectDelete("LC3_"+i);
     }
   Comment("");  
   return(0);
  }
//--------------------------------------------------------------------
int SetTDPoint(int B)
{
 int shift;
 if (FractalAsTD==false)
   {
    for (shift=B;shift>1;shift--)
       {
        if (High[shift+1]<High[shift] && High[shift-1]<High[shift] && Close[shift+2]<High[shift])
             ExtMapBuffer1[shift]=High[shift];
        else ExtMapBuffer1[shift]=0;    
        if (Low[shift+1]>Low[shift] && Low[shift-1]>Low[shift] && Close[shift+2]>Low[shift])
            ExtMapBuffer2[shift]=Low[shift];
        else ExtMapBuffer2[shift]=0;    
       }  
    ExtMapBuffer1[0]=0;
    ExtMapBuffer2[0]=0;
    ExtMapBuffer1[1]=0;
    ExtMapBuffer2[1]=0;
   }
 else
   {
    for (shift=B;shift>3;shift--)
       {
        if (High[shift+1]<=High[shift] && High[shift-1]<High[shift] && High[shift+2]<=High[shift] && High[shift-2]<High[shift])
             ExtMapBuffer1[shift]=High[shift];
        else ExtMapBuffer1[shift]=0;    
        if (Low[shift+1]>=Low[shift] && Low[shift-1]>Low[shift] && Low[shift+2]>=Low[shift] && Low[shift-2]>Low[shift])
            ExtMapBuffer2[shift]=Low[shift];
        else ExtMapBuffer2[shift]=0;    
       }  
    ExtMapBuffer1[0]=0;
    ExtMapBuffer2[0]=0;
    ExtMapBuffer1[1]=0;
    ExtMapBuffer2[1]=0;
    ExtMapBuffer1[2]=0;
    ExtMapBuffer2[2]=0;    
   }  
 return(0);
}
//--------------------------------------------------------------------
int GetHighTD(int P)
{
 int i=0,j=0;
 while (j<P)
   {
    i++;
    while(ExtMapBuffer1[i]==0)
      {i++;if(i>Bars-2)return(-1);}
    j++;
   }   
 return (i);         
}
//--------------------------------------------------------------------
int GetNextHighTD(int P)
{ 
 int i=P+1;
 while(ExtMapBuffer1[i]<=High[P]){i++;if(i>Bars-2)return(-1);}
 return (i);
}
//--------------------------------------------------------------------
int GetLowTD(int P)
{
 int i=0,j=0;
 while (j<P)
   {
    i++;
    while(ExtMapBuffer2[i]==0)
      {i++;if(i>Bars-2)return(-1);}
    j++;
   }   
 return (i); 
}
//--------------------------------------------------------------------
int GetNextLowTD(int P)
{
 int i=P+1;
 while(ExtMapBuffer2[i]>=Low[P] || ExtMapBuffer2[i]==0){i++;if(i>Bars-2)return(-1);}
 return (i);
}
//--------------------------------------------------------------------
int TrendLineHighTD(int H1,int H2,int Step,int Col)
{
 ObjectSet("HL_"+Step,OBJPROP_TIME1,Time[H2]);ObjectSet("HL_"+Step,OBJPROP_TIME2,Time[H1]);
 ObjectSet("HL_"+Step,OBJPROP_PRICE1,High[H2]);ObjectSet("HL_"+Step,OBJPROP_PRICE2,High[H1]);
 ObjectSet("HL_"+Step,OBJPROP_COLOR,Col);
 if (Step==1)ObjectSet("HL_"+Step,OBJPROP_WIDTH,2);
 else ObjectSet("HL_"+Step,OBJPROP_WIDTH,1);
 return(0);
}   
//--------------------------------------------------------------------
int TrendLineLowTD(int L1,int L2,int Step,int Col)
{
 ObjectSet("LL_"+Step,OBJPROP_TIME1,Time[L2]);ObjectSet("LL_"+Step,OBJPROP_TIME2,Time[L1]);
 ObjectSet("LL_"+Step,OBJPROP_PRICE1,Low[L2]);ObjectSet("LL_"+Step,OBJPROP_PRICE2,Low[L1]);
 ObjectSet("LL_"+Step,OBJPROP_COLOR,Col);
 if (Step==1)ObjectSet("LL_"+Step,OBJPROP_WIDTH,2);
 else ObjectSet("LL_"+Step,OBJPROP_WIDTH,1);      
 return(0);
}
//--------------------------------------------------------------------
int HorizontLineHighTD(int H1,int H2,int Step,double St,int Col)
{
 ObjectSet("HHL_"+Step,OBJPROP_PRICE1,High[H2]-(High[H2]-High[H1])/(H2-H1)*H2);
 ObjectSet("HHL_"+Step,OBJPROP_STYLE,St);
 ObjectSet("HHL_"+Step,OBJPROP_COLOR,Col);
 return(0); 
}   
//--------------------------------------------------------------------
int HorizontLineLowTD(int L1,int L2,int Step,double St,int Col)
{
 ObjectSet("HLL_"+Step,OBJPROP_PRICE1,Low[L2]+(Low[L1]-Low[L2])/(L2-L1)*L2);
 ObjectSet("HLL_"+Step,OBJPROP_STYLE,St);
 ObjectSet("HLL_"+Step,OBJPROP_COLOR,Col);
 return(0); 
}
//--------------------------------------------------------------------
string TakeProfitHighTD(int H1,int H2,int Step,int Col)
{
 int i,ii,j=0;
 string Comm="";
 double kH,HC1,HC2,HC3,k,St;
 kH=(High[H2]-High[H1])/(H2-H1);
 while (NormalizeDouble(Point,j)==0)j++; 
 k=0;
 for(i=H1;i>0;i--)if(Close[i]>High[H2]-kH*(H2-i)){k=High[H2]-kH*(H2-i);break;}
 if (k>0)
   { 
    Comm=Comm+"UTD_Line ("+DoubleToStr(High[H2]-kH*H2,j)+") пробита в точке "+DoubleToStr(k,j)+", цели вверх:\n";
    ii=Lowest(NULL,0,MODE_LOW,H2-i,i);    
    HC1=High[H2]-kH*(H2-ii)-Low[ii];
    HC2=High[H2]-kH*(H2-ii)-Close[ii];
    ii=Lowest(NULL,0,MODE_CLOSE,H2-i,i);
    HC3=High[H2]-kH*(H2-ii)-Close[ii];
    St=STYLE_SOLID;
   } 
 else
   {
    k=High[H2]-kH*H2;
    Comm=Comm+"UTD_Line ("+DoubleToStr(k,j)+"), при пробитии предполагаемые цели вверху:\n";  
    ii=Lowest(NULL,0,MODE_LOW,H2,0);    
    HC1=High[H2]-kH*(H2-ii)-Low[ii];
    HC2=High[H2]-kH*(H2-ii)-Close[ii];
    ii=Lowest(NULL,0,MODE_CLOSE,H2,0);
    HC3=High[H2]-kH*(H2-ii)-Close[ii];
    St=STYLE_DASHDOT;  
   }
 ObjectSet("HL_"+Step,OBJPROP_STYLE,St);  
 Comm=Comm+"Ц1="+DoubleToStr(HC1+k,j)+" ("+DoubleToStr(HC1/Point,0)+"п.)";
 Comm=Comm+" Ц2="+DoubleToStr(HC2+k,j)+" ("+DoubleToStr(HC2/Point,0)+"п.)";
 Comm=Comm+" Ц3="+DoubleToStr(HC3+k,j)+" ("+DoubleToStr(HC3/Point,0)+"п.)\n";  
 ObjectSet("HC1_"+Step,OBJPROP_TIME1,Time[H1]);ObjectSet("HC1_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("HC1_"+Step,OBJPROP_PRICE1,HC1+k);ObjectSet("HC1_"+Step,OBJPROP_PRICE2,HC1+k);
 ObjectSet("HC1_"+Step,OBJPROP_COLOR,Col);ObjectSet("HC1_"+Step,OBJPROP_STYLE,St);      
 ObjectSet("HC2_"+Step,OBJPROP_TIME1,Time[H1]);ObjectSet("HC2_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("HC2_"+Step,OBJPROP_PRICE1,HC2+k);ObjectSet("HC2_"+Step,OBJPROP_PRICE2,HC2+k);
 ObjectSet("HC2_"+Step,OBJPROP_COLOR,Col);ObjectSet("HC2_"+Step,OBJPROP_STYLE,St);
 ObjectSet("HC3_"+Step,OBJPROP_TIME1,Time[H1]);ObjectSet("HC3_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("HC3_"+Step,OBJPROP_PRICE1,HC3+k);ObjectSet("HC3_"+Step,OBJPROP_PRICE2,HC3+k);
 ObjectSet("HC3_"+Step,OBJPROP_COLOR,Col);ObjectSet("HC3_"+Step,OBJPROP_STYLE,St);   
 if (Step==1)
   {
    ObjectSet("HC1_"+Step,OBJPROP_WIDTH,2);
    ObjectSet("HC2_"+Step,OBJPROP_WIDTH,2);
    ObjectSet("HC3_"+Step,OBJPROP_WIDTH,2);
   } 
 else
   {
    ObjectSet("HC1_"+Step,OBJPROP_WIDTH,1);
    ObjectSet("HC2_"+Step,OBJPROP_WIDTH,1);
    ObjectSet("HC3_"+Step,OBJPROP_WIDTH,1);
   }
 return(Comm); 
}
//--------------------------------------------------------------------
string TakeProfitLowTD(int L1,int L2,int Step,int Col)
{
 int i,ii,j=0;
 string Comm="";
 double kL,LC1,LC2,LC3,k,St;
 kL=(Low[L1]-Low[L2])/(L2-L1);
 while (NormalizeDouble(Point,j)==0)j++; 
 k=0;
 for(i=L1;i>0;i--)if(Close[i]<Low[L2]+kL*(L2-i)){k=Low[L2]+kL*(L2-i);break;}
 if (k>0)
   {
    Comm=Comm+"LTD_Line ("+DoubleToStr(Low[L2]+kL*L2,j)+") пробита в точке "+DoubleToStr(k,j)+", цели вниз:\n";
    ii=Highest(NULL,0,MODE_HIGH,L2-i,i);    
    LC1=High[ii]-(Low[L2]+kL*(L2-ii));
    LC2=Close[ii]-(Low[L2]+kL*(L2-ii));
    i=Highest(NULL,0,MODE_CLOSE,L2-i,i);
    LC3=Close[ii]-(Low[L2]+kL*(L2-ii));
    St=STYLE_SOLID;
   } 
 else
   {
    k=Low[L2]+kL*L2;
    Comm=Comm+"LTD_Line ("+DoubleToStr(k,j)+"), при пробитии предполагаемые цели внизу:\n";        
    ii=Highest(NULL,0,MODE_HIGH,L2,0);    
    LC1=High[ii]-(Low[L2]+kL*(L2-ii));
    LC2=Close[ii]-(Low[L2]+kL*(L2-ii));
    ii=Highest(NULL,0,MODE_CLOSE,L2,0);
    LC3=Close[ii]-(Low[L2]+kL*(L2-ii));
    St=STYLE_DASHDOT;
   }
 ObjectSet("LL_"+Step,OBJPROP_STYLE,St);   
 Comm=Comm+"Ц1="+DoubleToStr(k-LC1,j)+" ("+DoubleToStr(LC1/Point,0)+"п.)";
 Comm=Comm+" Ц2="+DoubleToStr(k-LC2,j)+" ("+DoubleToStr(LC2/Point,0)+"п.)";
 Comm=Comm+" Ц3="+DoubleToStr(k-LC3,j)+" ("+DoubleToStr(LC3/Point,0)+"п.)\n";
 ObjectSet("LC1_"+Step,OBJPROP_TIME1,Time[L1]);ObjectSet("LC1_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("LC1_"+Step,OBJPROP_PRICE1,k-LC1);ObjectSet("LC1_"+Step,OBJPROP_PRICE2,k-LC1);
 ObjectSet("LC1_"+Step,OBJPROP_COLOR,Col);ObjectSet("LC1_"+Step,OBJPROP_STYLE,St);      
 ObjectSet("LC2_"+Step,OBJPROP_TIME1,Time[L1]);ObjectSet("LC2_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("LC2_"+Step,OBJPROP_PRICE1,k-LC2);ObjectSet("LC2_"+Step,OBJPROP_PRICE2,k-LC2);
 ObjectSet("LC2_"+Step,OBJPROP_COLOR,Col);ObjectSet("LC2_"+Step,OBJPROP_STYLE,St);
 ObjectSet("LC3_"+Step,OBJPROP_TIME1,Time[L1]);ObjectSet("LC3_"+Step,OBJPROP_TIME2,Time[0]);
 ObjectSet("LC3_"+Step,OBJPROP_PRICE1,k-LC3);ObjectSet("LC3_"+Step,OBJPROP_PRICE2,k-LC3);
 ObjectSet("LC3_"+Step,OBJPROP_COLOR,Col);ObjectSet("LC3_"+Step,OBJPROP_STYLE,St);   
 if (Step==1)
   {
    ObjectSet("LC1_"+Step,OBJPROP_WIDTH,2);
    ObjectSet("LC2_"+Step,OBJPROP_WIDTH,2);
    ObjectSet("LC3_"+Step,OBJPROP_WIDTH,2);
   } 
 else
   {
    ObjectSet("LC1_"+Step,OBJPROP_WIDTH,1);
    ObjectSet("LC2_"+Step,OBJPROP_WIDTH,1);
    ObjectSet("LC3_"+Step,OBJPROP_WIDTH,1);
   }
 return(Comm);
}
//--------------------------------------------------------------------
string TDMain(int Step)
{
 int H1,H2,L1,L2;
 string Comm="---   ШАГ "+Step+"   --------------------\n";   
 int i,j; while (NormalizeDouble(Point,j)==0)j++;
 double Style;
 double Col[20];Col[0]=Red;Col[2]=Magenta;Col[4]=Chocolate;Col[6]=Goldenrod;Col[8]=SlateBlue;
                Col[1]=Blue;Col[3]=DeepSkyBlue;Col[5]=Green;Col[7]=MediumOrchid;Col[9]=CornflowerBlue;
                Col[10]=Red;Col[12]=Magenta;Col[14]=Chocolate;Col[16]=Goldenrod;Col[18]=SlateBlue;
                Col[11]=Blue;Col[13]=DeepSkyBlue;Col[15]=Green;Col[17]=MediumOrchid;Col[19]=CornflowerBlue;
   Step=Step+BackSteps;  
   H1=GetHighTD(Step);
   H2=GetNextHighTD(H1);
   L1=GetLowTD(Step);
   L2=GetNextLowTD(L1);
   if (H1<0)Comm=Comm+"UTD на графике нет верхней TD точки \n";
   else 
     if (H2<0)Comm=Comm+"UTD на графике нет TD точки выше последней ("+DoubleToStr(High[H1],j)+")\n";
     else Comm=Comm+"UTD "+DoubleToStr(High[H2],j)+"  "+DoubleToStr(High[H1],j)+"\n"; 
   if (L1<0)Comm=Comm+"LTD на графике нет нижней TD точки \n";
   else 
     if (L2<0)Comm=Comm+"LTD на графике нет TD точки ниже последней ("+DoubleToStr(Low[L1],j)+")\n";   
     else Comm=Comm+"LTD  "+DoubleToStr(Low[L2],j)+"  "+DoubleToStr(Low[L1],j)+"\n";
   //-----------------------------------------------------------------------------------
   if (Step==1)Style=STYLE_SOLID;
   else Style=STYLE_DOT;
   if (H1>0 && H2>0)
     {
      if (TrendLine==1)
        {
         ObjectCreate("HL_"+Step,OBJ_TREND,0,0,0,0,0);
         TrendLineHighTD(H1,H2,Step,Col[Step*2-2]);
        } 
      else ObjectDelete("HL_"+Step);
      if (HorizontLine==1 && Step==1)
        {
         ObjectCreate("HHL_"+Step,OBJ_HLINE,0,0,0,0,0);
         HorizontLineHighTD(H1,H2,Step,Style,Col[Step*2-2]);
        } 
      else ObjectDelete("HHL_"+Step);
      if (TakeProf==1)
        {
         ObjectCreate("HC1_"+Step,OBJ_TREND,0,0,0,0,0);
         ObjectCreate("HC2_"+Step,OBJ_TREND,0,0,0,0,0);
         ObjectCreate("HC3_"+Step,OBJ_TREND,0,0,0,0,0);
         Comm=Comm+TakeProfitHighTD(H1,H2,Step,Col[Step*2-2]);
        }
      else
        {
         ObjectDelete("HC1_"+Step);
         ObjectDelete("HC2_"+Step);
         ObjectDelete("HC3_"+Step);   
        }  
     }
     
   //-----------------------------------------------------------------------------------   
   if (L1>0 && L2>0)
     {   
      if (TrendLine==1)
        {
         ObjectCreate("LL_"+Step,OBJ_TREND,0,0,0,0,0);
         TrendLineLowTD(L1,L2,Step,Col[Step*2-1]);
        }    
      else ObjectDelete("LL_"+Step);
      if (HorizontLine==1 && Step==1)
        {
         ObjectCreate("HLL_"+Step,OBJ_HLINE,0,0,0,0,0);
         HorizontLineLowTD(L1,L2,Step,Style,Col[Step*2-1]);
        } 
      else ObjectDelete("HLL_"+Step);
      if (TakeProf==1)
        {
         ObjectCreate("LC1_"+Step,OBJ_TREND,0,0,0,0,0);
         ObjectCreate("LC2_"+Step,OBJ_TREND,0,0,0,0,0);
         ObjectCreate("LC3_"+Step,OBJ_TREND,0,0,0,0,0);
         Comm=Comm+TakeProfitLowTD(L1,L2,Step,Col[Step*2-1]);
        }
      else
        {
         ObjectDelete("LC1_"+Step);
         ObjectDelete("LC2_"+Step);
         ObjectDelete("LC3_"+Step);       
        }
     }
 return(Comm);       
}
//--------------------------------------------------------------------
int start()
{
 string Comm="";       
   SetTDPoint(Bars-1);
   if (TD==1)
     {
      SetIndexArrow(0,217);
      SetIndexArrow(1,218);
     }
   else
     {
      SetIndexArrow(0,160);
      SetIndexArrow(1,160);
     }   
   if (ShowingSteps>10)
    {
     Comment("ShowingSteps значение 0 - 10");  
     return(0);
    } 
   for (int i=1;i<=ShowingSteps;i++)Comm=Comm+TDMain(i);
   Comm=Comm+"------------------------------------\nShowingSteps="+ShowingSteps+"\nBackSteps="+BackSteps;    
   if (FractalAsTD==true)Comm=Comm+"\nFractals";
   else Comm=Comm+"\nTD point";
   if (Commen==1)Comment(Comm);
   else Comment("");
   return(0);
  }
//+------------------------------------------------------------------+



С уважением, Сергей.

Forex Trader
114499
Forex Trader  
Вобщем не знаю насколько правильно я понял, что требуется, но вот как понял - так и выкладываю - цели рисуются постоянно не зависимо от пробоя и без учета квалификаторов, естественно обе сразу и разными цветами сигнал пробоя не рисуется

//+------------------------------------------------------------------+
//|                              TD_Points&Lines_mgtd1.mq4 (Short) |
//|                                           Vladislav Goshkov (VG) |
//|                                                      4vg@mail.ru |
//|ВНИМАНИЕ - ЭТО НЕ СОВСЕМ ИНДИКАТОР ДЕМАРКА
//+------------------------------------------------------------------+
#property copyright "Vladislav Goshkov (VG)"
#property link      "4vg@mail.ru"

#property indicator_chart_window

extern int   StepBack=0;
extern color UpLineColor = Blue;
extern int   UpLnWidth = 1;
extern color DnLineColor = Red;
extern int   DnLnWidth = 1;
extern color MarkColor   = Blue;
extern int   MarkNumber  = 217;

int i=1,NP=0,D=0,
    iB_Up=0,iB_Dn=0,
    S1=0,
    S2=0,
    UpLev=0,
    DownLev=0,
    iP_Up=0,
    iP_Dn=0,
    value=0,
    CurPeriod=0,
    shift=0;

datetime  nTime=0;

double UpV=0,
       DownV=0,
       iP=0,
       target = 0,
       UpP[2]={0,0},
       DownP[2]={0,0},
       PP1=0,PP2=0,PP3=0;

int    DownBT[2]={0,0}, // Bar Time
       UpBT[2]={0,0},
       UpB[2]={0,0},    // Bar Num
       DownB[2]={0,0};
string buff_str = "";
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
Comment(" ");   
ObjectsDeleteAll();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
int Target_Style[4] = {STYLE_DASH,STYLE_DASH,STYLE_DASH,STYLE_SOLID},
    Target_Up_Color[4] = {DimGray,MediumSpringGreen,SeaGreen,Blue},
    Target_Dn_Color[4] = {Magenta,Orange,Yellow,Red},
    Target_LW[4]    = { 1, 1, 1, 2 };
double target_up[4],target_dn[4];
//---- TODO: add your code here
if ( (nTime!=Time[0]) || (CurPeriod!=Period()) ) {
   UpP[0] = 0;
   UpP[1] = 0;

//=================================================
//******** Поиск опорных точек предложения ********
//=================================================
   for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) {//Begin
       if (High[i]!= High[i+1]) { 
          if( (High[i]>High[i+1] && High[i]>High[i-1] && High[i]>Close[i+2] ) 
              && High[i]> UpP[0] ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    NP++;
		    }
		  }

    if (High[i]== High[i+1])  { 
       if ( (High[i]>High[i+2] && High[i]>High[i-1] && High[i]>Close[i+3] ) && High[i]> UpP[0] ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    NP++;
		    }
		  }
     if(i == (Bars-2) ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    break;
		    }
     }//for(i=2+StepBack,D=2,NP=0; NP<D; ) {//End;

//=================================================
//********** Поиск опорных точек спроса ***********
//=================================================
   DownP[0] = 1000000000;
   DownP[1] = 1000000000;
   for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) {//Begin
    if (Low[i]!= Low[i+1])  { 
       if ( (Low[i]<Low[i+1] && Low[i]<Low[i-1] && Low[i]<Close[i+2] ) && Low[i]< DownP[0] ){
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    NP++;
		    }
		  //i++;
		  }
    if (Low[i]== Low[i+1])  { 
       if ( (Low[i]<Low[i+2] && Low[i]<Low[i-1] && Low[i]<Close[i+3] ) && Low[i]< DownP[0] ){
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    NP++;
		    }
		  //i++;
		  }
     if (i == (Bars-2) ) { 
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    break;
		    }
     }//End;
     

UpV   = (UpP[1]-UpP[0])/(UpB[0]-UpB[1]);
DownV = (DownP[1]-DownP[0])/(DownB[0]-DownB[1]);

//=================================================
//****       Рисуем  TD-линии                  ****
//=================================================
   buff_str = "TD_Up";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, UpBT[1], UpP[1],UpBT[0], UpP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, UpLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, UpLnWidth);
      }
   else {
      ObjectMove(buff_str, 1, UpBT[0], UpP[0]);
      ObjectMove(buff_str, 2, UpBT[1], UpP[1]);
      }

   buff_str = "TD_Dn";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, DownBT[1], DownP[1],DownBT[0], DownP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, DnLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, DnLnWidth);
      }
   else {
      ObjectMove(buff_str, 1, DownBT[0], DownP[0]);
      ObjectMove(buff_str, 2, DownBT[1], DownP[1]);
      }

   CurPeriod = Period();
   nTime = Time[0];
   }//if (nTime <> Time[0]) {
//----
   for(i=0;i<4;i++) {
       target_up[i] = 0;
       target_dn[i] = 0;
       }
	for( i=UpB[0]; i>=StepBack; i--){
		    iB_Up=i; 
		    iP=UpP[0]+UpV*(UpB[0]-i);
		    iP_Up = iP; 
		    S1=Lowest(NULL,0,MODE_LOW,UpB[1]-i,i);
		    S2=Lowest(NULL,0,MODE_CLOSE,UpB[1]-i,i);

	       PP1=iP+((UpP[1]+UpV*(UpB[1]-S1))-Low[S1]);
	       PP2=iP+((UpP[1]+UpV*(UpB[1]-S2))-Low[S2]);
          PP3=iP+((UpP[1]+UpV*(UpB[1]-S1))-Close[S1]);
          target_up[0] = PP1;
          target_up[1] = PP2;
          target_up[2] = PP3;
          target_up[3] = (PP1+PP2+PP3)/3;
	   }

   for( i=DownB[0]; i>=StepBack;i--) {
	       iB_Dn=i; 
		    iP=DownP[0]+DownV*(DownB[0]-i);
		    iP_Dn = iP;
		    S1=Highest(NULL,0,MODE_HIGH,DownB[1]-i,i);
		    S2=Highest(NULL,0,MODE_CLOSE,DownB[1]-i,i);

          PP1=iP-(High[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
	       PP2=iP-(High[S2]-(DownP[1]+DownV*(DownB[1]-S2)));
	       PP3=iP-(Close[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
             target_dn[0] = PP1;
             target_dn[1] = PP2;
             target_dn[2] = PP3;
             target_dn[3] = (PP1+PP2+PP3)/3;
		}//for( i=DownB[1]; i>=StepBack;i--) {

   for(i=3;i>=0;i--) {
      buff_str = "Target_up"+i;
      if(ObjectFind(buff_str) == -1) {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target_up[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Up_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
         }
      else {
         ObjectMove(buff_str, 0, Time[0], target_up[i] );
         }
      }

   for(i=3;i>=0;i--) {
      buff_str = "Target_dn"+i;
      if(ObjectFind(buff_str) == -1) {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target_dn[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Dn_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
         }
      else {
         ObjectMove(buff_str, 0, Time[0], target_dn[i] );
         }
      }


//----
string buff_str = "TD_LatestCulcBar";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_ARROW,0, Time[StepBack], Low[StepBack]-2*Point );
      ObjectSet(buff_str, OBJPROP_ARROWCODE, MarkNumber);
      ObjectSet(buff_str, OBJPROP_COLOR, MarkColor);
      }
   else {
      ObjectMove(buff_str, 0, Time[StepBack], Low[StepBack]-2*Point );
      }
   return(0);
  }
//+------------------------------------------------------------------+

Forex Trader
114499
Forex Trader  
Здравствуй Владислав.
Индикатор рисует трендовыелинии как попало, пока не передернешь, (кстати этот глюк ещё с прошлых разов)...

http://baltimor.narod.ru/picforum/tdvg.gif


С уважением, Сергей.
Forex Trader
114499
Forex Trader  
Здравствуй, Сергей. У меня такого не наблюдается. Правда было на других индюках - с некоторых версий както криво работает функция Перемещения точки - я принял соломоново решение и просто все нафиг удаляю, а потом рисую заново - так работает.

//+------------------------------------------------------------------+
//|                                  TD_Points&Lines_mgtd1.mq4 Short |
//|                                           Vladislav Goshkov (VG) |
//|                                                      4vg@mail.ru |
//|ВНИМАНИЕ - ЭТО НЕ ЕСТЬ ИНДИКАТОР ДЕМАРКА
//+------------------------------------------------------------------+
#property copyright "Vladislav Goshkov (VG)"
#property link      "4vg@mail.ru"

#property indicator_chart_window

extern int   StepBack=0;
extern color UpLineColor = Blue;
extern int   UpLnWidth = 1;
extern color DnLineColor = Red;
extern int   DnLnWidth = 1;
extern color MarkColor   = Blue;
extern int   MarkNumber  = 217;

int i=1,NP=0,D=0,
    iB_Up=0,iB_Dn=0,
    S1=0,
    S2=0,
    UpLev=0,
    DownLev=0,
    iP_Up=0,
    iP_Dn=0,
    value=0,
    CurPeriod=0,
    shift=0;

datetime  nTime=0;

double UpV=0,
       DownV=0,
       iP=0,
       target = 0,
       UpP[2]={0,0},
       DownP[2]={0,0},
       PP1=0,PP2=0,PP3=0;

int    DownBT[2]={0,0}, // Bar Time
       UpBT[2]={0,0},
       UpB[2]={0,0},    // Bar Num
       DownB[2]={0,0};
string buff_str = "";
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- TODO: add your code here
Comment(" ");   
ObjectsDeleteAll();
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
int Target_Style[4] = {STYLE_DASH,STYLE_DASH,STYLE_DASH,STYLE_SOLID},
    Target_Up_Color[4] = {DimGray,MediumSpringGreen,SeaGreen,Blue},
    Target_Dn_Color[4] = {Magenta,Orange,Yellow,Red},
    Target_LW[4]    = { 1, 1, 1, 2 };
double target_up[4],target_dn[4];
//---- TODO: add your code here
if ( (nTime!=Time[0]) || (CurPeriod!=Period()) ) {
   UpP[0] = 0;
   UpP[1] = 0;

//=================================================
//******** Поиск опорных точек предложения ********
//=================================================
   for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) {//Begin
       if (High[i]!= High[i+1]) { 
          if( (High[i]>High[i+1] && High[i]>High[i-1] && High[i]>Close[i+2] ) 
              && High[i]> UpP[0] ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    NP++;
		    }
		  }

    if (High[i]== High[i+1])  { 
       if ( (High[i]>High[i+2] && High[i]>High[i-1] && High[i]>Close[i+3] ) && High[i]> UpP[0] ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    NP++;
		    }
		  }
     if(i == (Bars-2) ) {
	     	 UpB[NP]  = i;
		    UpBT[NP] = Time[i];
		    UpP[NP]  = High[i];
		    break;
		    }
     }//for(i=2+StepBack,D=2,NP=0; NP<D; ) {//End;

//=================================================
//********** Поиск опорных точек спроса ***********
//=================================================
   DownP[0] = 1000000000;
   DownP[1] = 1000000000;
   for(i=2+StepBack,D=2,NP=0; (NP<D)&&(i<Bars); i++) {//Begin
    if (Low[i]!= Low[i+1])  { 
       if ( (Low[i]<Low[i+1] && Low[i]<Low[i-1] && Low[i]<Close[i+2] ) && Low[i]< DownP[0] ){
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    NP++;
		    }
		  //i++;
		  }
    if (Low[i]== Low[i+1])  { 
       if ( (Low[i]<Low[i+2] && Low[i]<Low[i-1] && Low[i]<Close[i+3] ) && Low[i]< DownP[0] ){
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    NP++;
		    }
		  //i++;
		  }
     if (i == (Bars-2) ) { 
	  	    DownB[NP] = i;
		    DownBT[NP]= Time[i];
		    DownP[NP] = Low[i];
		    break;
		    }
     }//End;
     

UpV   = (UpP[1]-UpP[0])/(UpB[0]-UpB[1]);
DownV = (DownP[1]-DownP[0])/(DownB[0]-DownB[1]);

//=================================================
//****       Рисуем  TD-линии                  ****
//=================================================
   buff_str = "TD_Up";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, UpBT[1], UpP[1],UpBT[0], UpP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, UpLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, UpLnWidth);
      }
   else {
      ObjectDelete(buff_str);
      ObjectCreate(buff_str, OBJ_TREND, 0, UpBT[1], UpP[1],UpBT[0], UpP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, UpLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, UpLnWidth);
      }

   buff_str = "TD_Dn";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_TREND, 0, DownBT[1], DownP[1],DownBT[0], DownP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, DnLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, DnLnWidth);
      }
   else {
      ObjectDelete(buff_str);
      ObjectCreate(buff_str, OBJ_TREND, 0, DownBT[1], DownP[1],DownBT[0], DownP[0]);
      ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSet(buff_str, OBJPROP_COLOR, DnLineColor);
      ObjectSet(buff_str, OBJPROP_WIDTH, DnLnWidth);
      }

   CurPeriod = Period();
   nTime = Time[0];
   }//if (nTime <> Time[0]) {
//----
   for(i=0;i<4;i++) {
       target_up[i] = 0;
       target_dn[i] = 0;
       }
	for( i=UpB[0]; i>=StepBack; i--){
		    iB_Up=i; 
		    iP=UpP[0]+UpV*(UpB[0]-i);
		    iP_Up = iP; 
		    S1=Lowest(NULL,0,MODE_LOW,UpB[1]-i,i);
		    S2=Lowest(NULL,0,MODE_CLOSE,UpB[1]-i,i);

	       PP1=iP+((UpP[1]+UpV*(UpB[1]-S1))-Low[S1]);
	       PP2=iP+((UpP[1]+UpV*(UpB[1]-S2))-Low[S2]);
          PP3=iP+((UpP[1]+UpV*(UpB[1]-S1))-Close[S1]);
          target_up[0] = PP1;
          target_up[1] = PP2;
          target_up[2] = PP3;
          target_up[3] = (PP1+PP2+PP3)/3;
	   }

   for( i=DownB[0]; i>=StepBack;i--) {
	       iB_Dn=i; 
		    iP=DownP[0]+DownV*(DownB[0]-i);
		    iP_Dn = iP;
		    S1=Highest(NULL,0,MODE_HIGH,DownB[1]-i,i);
		    S2=Highest(NULL,0,MODE_CLOSE,DownB[1]-i,i);

          PP1=iP-(High[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
	       PP2=iP-(High[S2]-(DownP[1]+DownV*(DownB[1]-S2)));
	       PP3=iP-(Close[S1]-(DownP[1]+DownV*(DownB[1]-S1)));
             target_dn[0] = PP1;
             target_dn[1] = PP2;
             target_dn[2] = PP3;
             target_dn[3] = (PP1+PP2+PP3)/3;
		}//for( i=DownB[1]; i>=StepBack;i--) {

   for(i=3;i>=0;i--) {
      buff_str = "Target_up"+i;
      if(ObjectFind(buff_str) == -1) {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target_up[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Up_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
         }
      else {
         ObjectMove(buff_str, 0, Time[0], target_up[i] );
         }
      }

   for(i=3;i>=0;i--) {
      buff_str = "Target_dn"+i;
      if(ObjectFind(buff_str) == -1) {
         ObjectCreate(buff_str, OBJ_HLINE,0, Time[0], target_dn[i] );
         ObjectSet(buff_str, OBJPROP_STYLE, Target_Style[i]);
         ObjectSet(buff_str, OBJPROP_COLOR, Target_Dn_Color[i]);
         ObjectSet(buff_str, OBJPROP_WIDTH, Target_LW[i]);
         }
      else {
         ObjectMove(buff_str, 0, Time[0], target_dn[i] );
         }
      }


//----
string buff_str = "TD_LatestCulcBar";
   if(ObjectFind(buff_str) == -1) {
      ObjectCreate(buff_str, OBJ_ARROW,0, Time[StepBack], Low[StepBack]-2*Point );
      ObjectSet(buff_str, OBJPROP_ARROWCODE, MarkNumber);
      ObjectSet(buff_str, OBJPROP_COLOR, MarkColor);
      }
   else {
      ObjectMove(buff_str, 0, Time[StepBack], Low[StepBack]-2*Point );
      }
   return(0);
  }
//+------------------------------------------------------------------+



Вот такой вариант, например, может работать лучше.

Удачи.

Авторизуйтесь или зарегистрируйтесь, чтобы добавить комментарий