返回
外汇指标
MT4经典之字形通道指标 Channel
回复:0  浏览:272
  • 楼主admin 圈主
  • 2019-05-05 05:06
Channel_ZZ指标创建之字形通道并提升相关形态。

QQ截图20180302120214.png

  1. //+------------------------------------------------------------------+
  2. //|                                                    Channel_ZZ.mq4|
  3. //|                                        Copyright @2008, Tinytjan |
  4. //+------------------------------------------------------------------+
  5. #property copyright "Copyright @2008, Tinytjan"
  6. #property link      "http://www.eazhijia.com/"

  8. extern string _1 = "1";
  9. extern int SmoothPeriod = 1;
  10. extern string _2 = "2";
  11. extern int ChannelWidth = 150;
  12. extern string _3 = "3";
  13. extern int FontSize = 10;
  14. extern string _4 = "4";
  15. extern string FontName = "Arial Black";
  16. extern string _5 = "4";
  17. extern bool DrawChannel = true;

  19. #property indicator_chart_window
  20. #property indicator_buffers 3

  22. #property indicator_color1 LightGray
  23. #property indicator_width1 3

  25. #property indicator_color2 Orange
  26. #property indicator_color3 Orange

  28. double ZZ[];
  29. double UpChannel[];
  30. double DownChannel[];

  32. double SmoothedMaxValues[];
  33. double SmoothedMinValues[];

  35. string symbol;

  37. #define UP 1
  38. #define DN -1
  39. #define NONE 0

  41. int Direction;

  43. datetime StartMax;
  44. datetime EndMax;
  45. datetime StartMin;
  46. datetime EndMin;

  48. datetime StartDraw;
  49. datetime EndDraw;
  50. double StartDrawValue;
  51. double EndDrawValue;

  53. datetime StartChannel;
  54. datetime EndChannel;
  55. double StartChannelValue;
  56. double EndChannelValue;

  58. int Counter;
  59. int Length;
  60. int LastLength;
  61. //+------------------------------------------------------------------+
  62. //| Custom indicator initialization function                         |
  63. //+------------------------------------------------------------------+
  64. int onInit(void)
  65.   {
  66.    IndicatorShortName("-=<Channel ZZ>=-");

  68.    IndicatorBuffers(5);
  69.    
  70.    SetIndexBuffer(0, ZZ);
  71.    SetIndexBuffer(1, UpChannel);
  72.    SetIndexBuffer(2, DownChannel);
  73.    SetIndexBuffer(3, SmoothedMaxValues);
  74.    SetIndexBuffer(4, SmoothedMinValues);
  75.    
  76.    SetIndexStyle(0, DRAW_LINE);
  77.    SetIndexStyle(1, DRAW_LINE, STYLE_DASH);
  78.    SetIndexStyle(2, DRAW_LINE, STYLE_DASH);
  79.    
  80.    symbol = Symbol();
  81.    
  82.    Direction = NONE;
  83.    Counter = 0;

  85.    StartMax = 0;
  86.    EndMax = 0;
  87.    StartMin = 0;
  88.    EndMin = 0;
  89.    
  90.    Length = 0;
  91.    LastLength = EMPTY_VALUE;
  92.    Comment("www.eazhijia.com");
  93.    return(INIT_SUCCEEDED);
  94. }

  96.    void onDeinit(const int reason)
  97. {
  98.    for (int i = 0; i <= Counter; i++)
  99.    {
  100.       ObjectDelete("Stats" + i);
  101.    }
  102. }
  103. //+------------------------------------------------------------------+
  104. //| Custom indicator iteration function                              |
  105. //+------------------------------------------------------------------+
  106. int onCalculate(const int rates_total,
  107.                 const int prev_calculated,
  108.                 const datetime &time[],
  109.                 const double &open[],
  110.                 const double &high[],
  111.                 const double &low[],
  112.                 const double &close[],
  113.                 const long &tick_volume[],
  114.                 const long &volume[],
  115.                 const int &spread[])
  116.   {
  117.    int ToCount = Bars - IndicatorCounted();
  118.    
  119.    for (int i = ToCount - 1; i >= 0; i--)
  120.    {
  121.       SmoothedMaxValues[i] = iMA(symbol, 0, SmoothPeriod, 0, MODE_EMA, PRICE_HIGH, i);
  122.       SmoothedMinValues[i] = iMA(symbol, 0, SmoothPeriod, 0, MODE_EMA, PRICE_LOW, i);
  123.       
  124.       RePaintChannels(i);
  125.       
  126.       if (Direction == NONE)
  127.       {
  128.          CheckInit(i);
  129.          continue;
  130.       }
  131.       
  132.       if (Direction == UP)      
  133.       {
  134.          CheckUp(i);
  135.       }
  136.       else
  137.       {
  138.          CheckDown(i);
  139.       }
  140.    }
  141.    return(0);
  142. }
  143. //+------------------------------------------------------------------+

  145. void CheckInit(int offset)
  146. {
  147.    if (StartMax == 0 || StartMin == 0)
  148.    {
  149.       if (StartMax == 0) StartMax = Time[offset];
  150.       if (StartMin == 0) StartMin = Time[offset];
  151.       
  152.       return;
  153.    }
  154.    
  155.    if (Direction == NONE)
  156.    {
  157.       double maxValue = SmoothedMaxValues[iBarShift(symbol, 0, StartMax)];
  158.       double minValue = SmoothedMinValues[iBarShift(symbol, 0, StartMin)];
  159.       
  160.       double nowMax = SmoothedMaxValues[offset];
  161.       double nowMin = SmoothedMaxValues[offset];
  162.       
  163.       if (nowMax > maxValue && Time[offset] > StartMax)
  164.       {
  165.          EndMax = Time[offset];
  166.          StartMin = Time[offset];
  167.          Direction = UP;
  168.          
  169.          StartDraw = StartMax;
  170.          EndDraw = EndMax;
  171.          StartDrawValue = maxValue;
  172.          EndDrawValue = nowMax;
  173.          
  174.          StartChannel = StartMax;
  175.          EndChannel = EndMax;
  176.          StartChannelValue = maxValue;
  177.          EndChannelValue = nowMax;
  178.          
  179.          Length = NormalizeDouble((nowMax - maxValue)/Point, 0);
  180.          
  181.          RePaint();
  182.       }
  183.       else if (nowMin > minValue && Time[offset] > StartMin)
  184.       {
  185.          EndMin = Time[offset];
  186.          StartMax = Time[offset];
  187.          Direction = DN;

  189.          StartDraw = StartMin;
  190.          EndDraw = EndMin;
  191.          StartDrawValue = minValue;
  192.          EndDrawValue = nowMin;

  194.          StartChannel = StartMin;
  195.          EndChannel = EndMin;
  196.          StartChannelValue = minValue;
  197.          EndChannelValue = nowMin;

  199.          Length = NormalizeDouble((minValue - nowMin)/Point, 0);

  201.          RePaint();
  202.       }
  203.    }
  204. }

  206. void CheckUp(int offset)
  207. {
  208.    int startIndex = iBarShift(symbol, 0, StartMax);
  209.    int endIndex = iBarShift(symbol, 0, EndMax);

  211.    double endMaxValue = SmoothedMaxValues[endIndex];
  212.       
  213.    if (endMaxValue < SmoothedMaxValues[offset])
  214.    {
  215.       endMaxValue = SmoothedMaxValues[offset];
  216.       EndMax = Time[offset];

  218.       EndDraw = EndMax;
  219.       EndDrawValue = endMaxValue;

  221.       EndChannel = EndMax;
  222.       EndChannelValue = endMaxValue;
  223.       
  224.       double endMinValue = SmoothedMinValues[iBarShift(symbol, 0, EndMin)];
  225.       Length = NormalizeDouble((endMaxValue - endMinValue)/Point, 0);

  227.       RePaint();
  228.    }
  229.    else
  230.    {  
  231.       double startMaxValue = SmoothedMaxValues[startIndex];
  232.       double startMinValue = SmoothedMinValues[iBarShift(symbol, 0, StartMin)];
  233.       
  234.       double nowMaxValue = endMaxValue;
  235.       if (startIndex - endIndex != 0)
  236.       {
  237.          nowMaxValue += (endMaxValue - startMaxValue)/(startIndex - endIndex)*(endIndex - offset);
  238.       }

  240.       double nowMinValue = SmoothedMinValues[offset];
  241.       
  242.       if (nowMaxValue - nowMinValue > ChannelWidth*Point)
  243.       {
  244.          if (EndMax != offset)
  245.          {
  246.             StartMin = Time[offset];
  247.             EndMin = Time[offset];
  248.             Direction = DN;

  250.             StartDraw = EndMax;
  251.             EndDraw = EndMin;
  252.             StartDrawValue = endMaxValue;
  253.             EndDrawValue = nowMinValue;

  255.             StartChannel = EndMin;
  256.             EndChannel = EndMin;
  257.             StartChannelValue = nowMinValue;
  258.             EndChannelValue = nowMinValue;

  260.             Counter++;

  262.             LastLength = Length;
  263.             Length = NormalizeDouble((endMaxValue - nowMinValue)/Point, 0);

  265.             RePaint();
  266.          }
  267.       }
  268.    }
  269. }

  271. void CheckDown(int offset)
  272. {
  273.    int startIndex = iBarShift(symbol, 0, StartMin);
  274.    int endIndex = iBarShift(symbol, 0, EndMin);

  276.    double endMinValue = SmoothedMinValues[endIndex];
  277.       
  278.    if (endMinValue > SmoothedMinValues[offset])
  279.    {
  280.       endMinValue = SmoothedMinValues[offset];
  281.       EndMin = Time[offset];

  283.       EndDraw = EndMin;
  284.       EndDrawValue = endMinValue;

  286.       EndChannel = EndMin;
  287.       EndChannelValue = endMinValue;

  289.       double endMaxValue = SmoothedMaxValues[iBarShift(symbol, 0, EndMax)];
  290.       Length = NormalizeDouble((endMaxValue - endMinValue)/Point, 0);

  292.       RePaint();
  293.    }
  294.    else
  295.    {  
  296.       double startMinValue = SmoothedMinValues[startIndex];
  297.       double startMaxValue = SmoothedMaxValues[iBarShift(symbol, 0, StartMax)];
  298.       
  299.       double nowMinValue = endMinValue;
  300.       if (startIndex - endIndex != 0)
  301.       {
  302.          nowMinValue += (endMinValue - startMinValue)/(startIndex - endIndex)*(endIndex - offset);
  303.       }

  305.       double nowMaxValue = SmoothedMaxValues[offset];
  306.       
  307.       if (nowMaxValue - nowMinValue > ChannelWidth*Point)
  308.       {
  309.          if (EndMin != offset)
  310.          {
  311.             EndMax = Time[offset];
  312.             StartMax = Time[offset];
  313.             Direction = UP;

  315.             StartDraw = EndMin;
  316.             EndDraw = EndMax;
  317.             StartDrawValue = endMinValue;
  318.             EndDrawValue = nowMaxValue;

  320.             StartChannel = EndMax;
  321.             EndChannel = EndMax;
  322.             StartChannelValue = nowMaxValue;
  323.             EndChannelValue = nowMaxValue;

  325.             Counter++;

  327.             LastLength = Length;
  328.             Length = NormalizeDouble((nowMaxValue - endMinValue)/Point, 0);

  330.             RePaint();
  331.          }
  332.       }
  333.    }
  334. }

  336. void RePaint()
  337. {
  338.    double pos = EndDrawValue;
  339.    if (Direction == UP) pos += 15*Point;
  340.    
  341.    string id = "Stats" + Counter;
  342.    
  343.    string text;
  344.    if (LastLength != 0)
  345.       text = text + DoubleToStr((0.0001 + Length)/(0.0001 + LastLength), 2);
  346.    text = text + "(" + Length + ")";
  347.    
  348.    if (ObjectFind(id) == -1)
  349.    {
  350.       ObjectCreate(id, OBJ_TEXT, 0, EndDraw, pos);
  351.       ObjectSet(id, OBJPROP_COLOR, Yellow);
  352.    }

  354.    ObjectMove(id, 0, EndDraw, pos);
  355.    ObjectSetText(id, text, FontSize, FontName);

  357.    int start = iBarShift(symbol, 0, StartDraw);
  358.    int end = iBarShift(symbol, 0, EndDraw);
  359.    
  360.    if (start == end)
  361.    {
  362.       ZZ[end] = EndDrawValue;
  363.       return;
  364.    }
  365.    
  366.    double prevalue = (EndDrawValue - StartDrawValue)/(end - start);
  367.    
  368.    for (int i = start; i >= end; i--)
  369.    {
  370.       ZZ[i] = StartDrawValue + prevalue*(i - start);
  371.    }
  372. }

  374. void RePaintChannels(int offset)
  375. {
  376.    if (Direction == NONE) return;
  377.    if (!DrawChannel) return;
  378.    
  379.    int start = iBarShift(symbol, 0, StartChannel);
  380.    int end = iBarShift(symbol, 0, EndChannel);
  381.    
  382.    if (start == end)
  383.    {
  384.       if (Direction == UP)
  385.       {
  386.          UpChannel[start] = StartChannelValue;
  387.          DownChannel[start] = StartChannelValue - ChannelWidth*Point;
  388.       }
  389.       else
  390.       {
  391.          DownChannel[start] = StartChannelValue;
  392.          UpChannel[start] = StartChannelValue + ChannelWidth*Point;
  393.       }
  394.       
  395.       for(int i = start - 1; i >= offset; i--)
  396.       {
  397.          DownChannel[i] = DownChannel[i + 1];
  398.          UpChannel[i] = UpChannel[i + 1];
  399.       }
  400.       return;
  401.    }
  402.    
  403.    double prevalue = (EndChannelValue - StartChannelValue)/(end - start);

  405.    if (Direction == UP)
  406.    {
  407.       for (i = start - 1; i >= offset; i--)
  408.       {
  409.          UpChannel[i] = StartChannelValue + prevalue*(i - start);
  410.          DownChannel[i] = UpChannel[i] - ChannelWidth*Point;
  411.       }
  412.    }
  413.    else if (Direction == DN)
  414.    {
  415.       for (i = start; i >= offset; i--)
  416.       {
  417.          DownChannel[i] = StartChannelValue + prevalue*(i - start);
  418.          UpChannel[i] = DownChannel[i] + ChannelWidth*Point;
  419.       }
  420.    }
  421. }
打赏