Navigation:Home > Content >

Kagi_Ind.mq4

Time: 2012-09-08 | Download file:Kagi_Ind.mq4

//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж
// Kagi_Ind.mq4                                                             Индикатор. 
// Сергей Ковалёв, Днепропетровск, [email protected], ICQ 64015987, http://autograf.dp.ua
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 0 жж
#property copyright "Copyright SK AutoGraf © 2008"
#property link      "http://autograf.dp.ua/"
//================================================================================== 1 ==
#property indicator_chart_window                // Индикаптор в основном окне
#property indicator_buffers 8                   // Количество буферов 8

extern color Color_1 = DodgerBlue;              // Цвет 1
extern color Color_2 = OrangeRed;               // Цвет 2
extern int Delta = 5;                           // Порог для смены тенденции

int Width = 2;                                  // Толщина основной линии

double Gor_B1[];                                // Буфер для гориз. синей   
double Gor_B2[];                                // Буфер для гориз. синей   
double Gor_B3[];                                // Буфер для гориз. синей   
double Gor_S1[];                                // Буфер для гориз. красной 
double Gor_S2[];                                // Буфер для гориз. красной 
double Gor_S3[];                                // Буфер для гориз. красной 
double Ver_B[];                                 // Буфер для вертикальной син/красн
double Ver_S[];                                 // Буфер для вертикальной син/красн

double delta;                                   // Порог для смены тенденции в пунктах
double Revers;                                  // Цена смены тенденции
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 2 жж
int init()
   {
//================================================================================== 3 ==
   SetIndexBuffer(0,Gor_B1);                             // Связь ном буфера с назв. масс
   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,Width,Color_1); // Стиль линии верх синяя
   SetIndexBuffer(1,Gor_B2);                             // Связь ном буфера с назв. масс
   SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,Width,Color_1); // Стиль линии верх синяя
   SetIndexBuffer(2,Gor_B3);                             // Связь ном буфера с назв. масс
   SetIndexStyle(2,DRAW_LINE,STYLE_SOLID,Width,Color_1); // Стиль линии верх синяя

   SetIndexBuffer(3,Gor_S1);                             // Связь ном буфера с назв. масс
   SetIndexStyle(3,DRAW_LINE,STYLE_SOLID,Width,Color_2); // Стиль линии верх красная
   SetIndexBuffer(4,Gor_S2);                             // Связь ном буфера с назв. масс
   SetIndexStyle(4,DRAW_LINE,STYLE_SOLID,Width,Color_2); // Стиль линии верх красная
   SetIndexBuffer(5,Gor_S3);                             // Связь ном буфера с назв. масс
   SetIndexStyle(5,DRAW_LINE,STYLE_SOLID,Width,Color_2); // Стиль линии верх красная
//---------------------------------------------------------------------------------- 4 --
   SetIndexBuffer(6,Ver_B);                              // Связь ном буфера с назв. масс
   SetIndexStyle(6,DRAW_HISTOGRAM,STYLE_SOLID,Width,Color_1);// Стиль линии - верт. синяя
   SetIndexBuffer(7,Ver_S);                              // Связь ном буфера с назв. масс
   SetIndexStyle(7,DRAW_HISTOGRAM,STYLE_SOLID,Width,Color_2);// Стиль линии - верт. красн
//================================================================================== 5 ==
   string short_name="KAGI("+Delta+")";
   IndicatorShortName(short_name);                       // Установка короткого имени
   delta = Delta*Point;                                  // Теперь в пунктах
//================================================================================== 6 ==
   return;
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 7 жж
int start()
   {
//================================================================================== 8 ==
   static int Vector;                           // Направление вертикали
   static int Tip;                              // Тип линии (красная/синяя)
   static int Last_V;                           // Самый правый индекс последн. горизонта
   static double Last_G;                        // Цена последнего горизонта
   
   int 
   Qnt,                                         // Количество баров для анализа
   Ind,                                         // Индекс экстремального Close
   counted_bars,                                // Количество неизменённых баров
   i,n;                                         // Технические переменные
//================================================================================== 9 ==
   counted_bars=IndicatorCounted();             // Количество неизменённых баров
   i=Bars-counted_bars-1;                       // Индекс последнего непосчитанного бара

   if (counted_bars == 0)                       // При самом первом включении start()
      {
      Last_V = i;                               // Индекс последней вертикали
      if (Close[i]>Open[i])                     // Повышающая свеча
         {
         Tip = 0;                               // Тип горизонта = синий, тенденция Buy
         Last_G=MathMin(Close[i]-delta,Open[i]);// Цена горизонта 
         Vector = 1;                            // Направление - вверх
         }
      else                                      // Понижающая свеча
         {
         Tip = 1;                               // Тип горизонта = красн, тенденция Sell
         Last_G=MathMax(Close[i]+delta,Open[i]);// Цена горизонта 
         Vector = -1;                           // Направление - вниз
         }
      Vert(i, Last_G, Close[i], Tip);           // Проводим первую вертикаль
      }
//================================================================================= 10 ==
   while(i>=1)                                  // Цикл для вычисления буферов
      {
      static int First=0;                       // Не было вычислений на 1м баре
      if (i==1)                                 // Если это 1й бар
         {
         if (First==1)                          // Это не первый расчёт на 1м баре
            Last_V++;                           // Увеличиваем индекс последн вертик на 1
         First=1;                               // Будем помнить: это не первый расчёт
         }
      Qnt = Last_V-i+1;                         // Количество элементов для поиска
      switch(Tip)                               // По типу последн горизонта 
         {
//================================================================================= 11 ==
         case 0:                                         // Тенденция синяя
            switch(Vector)                               // По направлению
               {
//--------------------------------------------------------------------------------- 12 --
               case 1:                                   // Вверх (в направлении типа)
                  Ind = ArrayMaximum(Close,Qnt,i);       // Индекс минимального Close
                  Vert(Last_V,Last_G,Close[Ind],Tip);    // Вертикаль от гориз. до Close
                  Revers = Last_G;                       // Цена смены тенденции
                  if (NormalizeDouble(Close[i]-(Close[Ind]-delta),Digits)<=0.0)
                     {
                     Vector = -1;                        // Направление - вниз
                     Last_G = Close[Ind];                // Новая цена горизонта
                     Gorz(Last_V,i,Last_G,0);            // Горизонталь по максим. Close
                     Last_V = i;                         // Индекс последней вертикали
                     if (NormalizeDouble(Close[i]-Revers,Digits)<0.0)
                        {
                        Tip = 1;                         // Тенденция меняется на красную
                        Vert_Obj(Time[i],Last_G,Revers,0);//Вертикаль на i баре синяя ОО
                        }
                     Vert(Last_V,Last_G,Close[i],Tip);   // Вертикаль на i баре красная
                     }   
                  break;
//--------------------------------------------------------------------------------- 13 --
               case -1:                                  // Вниз
                  Ind = ArrayMinimum(Close,Qnt,i);       // Индекс максимального Close
                  if (NormalizeDouble(Close[Ind]-Revers,Digits)<0.0)// Ниже реверса
                     {   
                     Tip = 1;                            // Тенденция меняется на красную
                     Vert_Obj(Time[Last_V],Last_G,Revers,0);// Вертикаль синяя ОО
                     Revers = Last_G;                    // Цена смены тенденции
                     }      
                  Vert(Last_V,Last_G,Close[Ind],Tip);    // Вертикаль от гориз. до Close
                  if (NormalizeDouble(Close[i]-(Close[Ind]+delta),Digits)>=0.0)//Разв.
                     {
                     Vector = 1;                         // Направление - вверх
                     Last_G = Close[Ind];                // Новая цена горизонта
                     Gorz(Last_V,i,Last_G,Tip);          // Горизонталь по максим. Close
                     Last_V = i;                         // Индекс последней вертикали
                     if (Tip == 0)
                        Revers = Last_G;                 // Цена смены тенденции
                     Vert(Last_V,Last_G,Close[i],Tip);   // Вертикаль на i баре по типу
                     }
                  break;
//--------------------------------------------------------------------------------- 14 --
               }
            break;
//================================================================================= 15 ==
         case 1:                                         // Тенденция красная
            switch(Vector)                               // По направлению
               {
//--------------------------------------------------------------------------------- 16 --
               case -1:                                  // Вниз (в направлении типа)
                  Ind = ArrayMinimum(Close,Qnt,i);       // Индекс минимального Close
                  Vert(Last_V,Last_G,Close[Ind],Tip);    // Вертикаль от гориз. до Close
                  Revers = Last_G;                       // Цена смены тенденции
                  if (NormalizeDouble(Close[i]-(Close[Ind]+delta),Digits)>=0.0)//Разворот
                     {
                     Vector = 1;                         // Направление - вверх
                     Last_G = Close[Ind];                // Новая цена горизонта
                     Gorz(Last_V,i,Last_G,1);            // Горизонталь по миним. Close
                     Last_V = i;                         // Индекс последней вертикали
                     if (NormalizeDouble(Close[i]-Revers,Digits)>0.0)
                        {
                        Tip = 0;                         // Тенденция меняется на синюю
                        Vert_Obj(Time[i],Last_G,Revers,1);//Вертикаль на i баре красн ОО
                        }
                     Vert(Last_V,Last_G,Close[i],Tip);   // Вертикаль на i баре по типу
                     }   
                  break;
//--------------------------------------------------------------------------------- 17 --
               case 1:                                   // Вверх
                  Ind = ArrayMaximum(Close,Qnt,i);       // Индекс максимального Close
                  if (NormalizeDouble(Close[Ind]-Revers,Digits)>0.0)// Выше реверса
                     {   
                     Tip = 0;                            // Тенденция меняется на синюю
                     Vert_Obj(Time[Last_V],Last_G,Revers,1);// Вертикаль красн ОО
                     Revers = Last_G;                    // Цена смены тенденции
                     }      
                  Vert(Last_V,Last_G,Close[Ind],Tip);    // Вертикаль от гориз. до Close
                  if (NormalizeDouble(Close[i]-(Close[Ind]-delta),Digits)<=0.0)//Разв.
                     {
                     Vector = -1;                        // Направление - вниз
                     Last_G = Close[Ind];                // Новая цена горизонта
                     Gorz(Last_V,i,Last_G,Tip);          // Горизонталь по максим. Close
                     Last_V = i;                         // Индекс последней вертикали
                     if (Tip == 1)
                        Revers = Last_G;                 // Цена смены тенденции
                     Vert(Last_V,Last_G,Close[i],Tip);   // Вертикаль на i баре по типу
                     }
                  break;
//--------------------------------------------------------------------------------- 18 --
               }
            break;
//================================================================================= 19 ==
         }
      i--;
      }
   return;
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 20 жж
int deinit()
   {
   int Qnt_Obj_Del = 0;                         // Пока нет объектов к удалению
   int Kol_Objects = ObjectsTotal();            // Общее количество объектов
   string Mas_Name_Del[1];                      // Объявление массива
   ArrayResize(Mas_Name_Del, Kol_Objects);      // Устанавливаем размер массива
//--------------------------------------------------------------------------------- 21 --
   for (int k=0; k < Kol_Objects; k++)          // По количеству объектов
      {
      string Obj_Name = ObjectName(k);          // Запрашиваем имя объекта
      string Bebin = StringSubstr(Obj_Name,0,8);// Извлекаем первые 8 символов из строки
      if (Bebin == "Kagi_SK_")                  // Если найден объект, имя которого ..
         {                                      // .. начинается с искомой подстроки
         Qnt_Obj_Del=Qnt_Obj_Del+1;             // Количество имён объектов к удалению
         Mas_Name_Del[Qnt_Obj_Del]=Obj_Name;    // Накапливаем массивчик  
         }
      }
//--------------------------------------------------------------------------------- 22 --
   for (int i=1; i<=Qnt_Obj_Del; i++)           // По именам объектов в массиве
      ObjectDelete(Mas_Name_Del[i]);            // Удаляем 
   WindowRedraw();                              // Для моментального отображения
   return;
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 23 жж
int Vert_Obj(int TT, double Price_1, double Price_2, int Tip)
   {                                                  // Рисуем вертикальн. линии-объекты
//================================================================================= 24 ==
   string Line_Name = "Kagi_SK_" + TT;                // Название объекта
   ObjectCreate (Line_Name, OBJ_TREND, 0, 0, 0, 0, 0);// Установка объекта
   ObjectSet    (Line_Name, OBJPROP_TIME1, TT);       // Координата времени
   ObjectSet    (Line_Name, OBJPROP_TIME2, TT);       // Координата времени
   ObjectSet    (Line_Name, OBJPROP_PRICE1, Price_1); // Координата цены
   ObjectSet    (Line_Name, OBJPROP_PRICE2, Price_2); // Координата цены
   ObjectSet    (Line_Name, OBJPROP_RAY, false);      // Не луч
   ObjectSet    (Line_Name, OBJPROP_STYLE, 0 );       // Стиль - простая линия
   ObjectSet    (Line_Name, OBJPROP_WIDTH, Width+1);  // Толщина линии
   if (Tip == 0)                                      // Синяя
      ObjectSet (Line_Name, OBJPROP_COLOR, Color_1);  // Расцветка объекта
   else
      ObjectSet (Line_Name, OBJPROP_COLOR, Color_2);  // Расцветка объекта
//================================================================================= 25 ==
   return;
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 26 жж
int Vert(int i, double Price_1, double Price_2, int Tip)
   {                                         // Рисуем вертикальные красные и синие линии
//================================================================================= 27 ==
   double max = MathMax(Price_1, Price_2) ;  // Определяем макс и мин. значения цены
   double min = MathMin(Price_1, Price_2) ;
//================================================================================== 9 ==
   if (Tip == 0)                             // Синяя
      {
      Ver_B[i]= max;
      Ver_S[i]= min;
      }
//--------------------------------------------------------------------------------- 28 --
    else                                     // Красная
      {
      Ver_B[i]= min;
      Ver_S[i]= max;
      }  
   return;
//================================================================================= 29 ==
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 30 жж
int Gorz(int ind_1, int ind_2, double Price, int Tip)
   {                                            // Рисуем горизонт. красные и синие линии
//================================================================================= 31 ==
   double ind_max = MathMax(ind_1, ind_2) ;     // Определяем максим. и миним. индексы
   double ind_min = MathMin(ind_1, ind_2) ;
   static int Buf = 0;
   Buf++;
   if (Buf==4)Buf=1;
//================================================================================= 32 ==
   for (int n=ind_min; n<=ind_max; n++)
      {
//--------------------------------------------------------------------------------- 33 --
      if (Tip == 0)                             // Для синих линий
         {
         switch(Buf)                            // Чередование горизонтальных синих
            {
            case 1: Gor_B1[n]= Price; break;
            case 2: Gor_B2[n]= Price; break;
            case 3: Gor_B3[n]= Price; 
            }
         }   
//--------------------------------------------------------------------------------- 34 --
      else                                      // Для красных линий
         {
         switch(Buf)                            // Чередование горизонтальных красных
            {
            case 1: Gor_S1[n]= Price; break;
            case 2: Gor_S2[n]= Price; break;
            case 3: Gor_S3[n]= Price; 
            }
         }   
//--------------------------------------------------------------------------------- 35 --
      }
   return;
//================================================================================= 36 ==
   }
//жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж Конец модуля жжжжжжжжжжжжжжжжжжжжжжжжжжжжжжж 37 жж

Recommend