MT4经典之字形通道指标 Channel_ZZ.mq4

Channel_ZZ指标创建之字形通道并提升相关形态。

1. //+------------------------------------------------------------------+
   
2. //|                                                    Channel_ZZ.mq4|
   
3. //|                                        Copyright @2008, Tinytjan |
   
4. //+------------------------------------------------------------------+
   
5. #property copyright "Copyright @2008, Tinytjan"
   
6. #property link      "http://www.eazhijia.com/"
   
7. 
   
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;
    
18. 
    
19. #property indicator_chart_window
    
20. #property indicator_buffers 3
    
21. 
    
22. #property indicator_color1 LightGray
    
23. #property indicator_width1 3
    
24. 
    
25. #property indicator_color2 Orange
    
26. #property indicator_color3 Orange
    
27. 
    
28. double ZZ[];
    
29. double UpChannel[];
    
30. double DownChannel[];
    
31. 
    
32. double SmoothedMaxValues[];
    
33. double SmoothedMinValues[];
    
34. 
    
35. string symbol;
    
36. 
    
37. #define UP 1
    
38. #define DN -1
    
39. #define NONE 0
    
40. 
    
41. int Direction;
    
42. 
    
43. datetime StartMax;
    
44. datetime EndMax;
    
45. datetime StartMin;
    
46. datetime EndMin;
    
47. 
    
48. datetime StartDraw;
    
49. datetime EndDraw;
    
50. double StartDrawValue;
    
51. double EndDrawValue;
    
52. 
    
53. datetime StartChannel;
    
54. datetime EndChannel;
    
55. double StartChannelValue;
    
56. double EndChannelValue;
    
57. 
    
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>=-");
    
67. 
    
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;
    
84. 
    
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. }
    
95. 
    
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. //+------------------------------------------------------------------+
     
144. 
     
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;
     
188. 
     
189.          StartDraw = StartMin;
     
190.          EndDraw = EndMin;
     
191.          StartDrawValue = minValue;
     
192.          EndDrawValue = nowMin;
     
193. 
     
194.          StartChannel = StartMin;
     
195.          EndChannel = EndMin;
     
196.          StartChannelValue = minValue;
     
197.          EndChannelValue = nowMin;
     
198. 
     
199.          Length = NormalizeDouble((minValue - nowMin)/Point, 0);
     
200. 
     
201.          RePaint();
     
202.       }
     
203.    }
     
204. }
     
205. 
     
206. void CheckUp(int offset)
     
207. {
     
208.    int startIndex = iBarShift(symbol, 0, StartMax);
     
209.    int endIndex = iBarShift(symbol, 0, EndMax);
     
210. 
     
211.    double endMaxValue = SmoothedMaxValues[endIndex];
     
212.       
     
213.    if (endMaxValue < SmoothedMaxValues[offset])
     
214.    {
     
215.       endMaxValue = SmoothedMaxValues[offset];
     
216.       EndMax = Time[offset];
     
217. 
     
218.       EndDraw = EndMax;
     
219.       EndDrawValue = endMaxValue;
     
220. 
     
221.       EndChannel = EndMax;
     
222.       EndChannelValue = endMaxValue;
     
223.       
     
224.       double endMinValue = SmoothedMinValues[iBarShift(symbol, 0, EndMin)];
     
225.       Length = NormalizeDouble((endMaxValue - endMinValue)/Point, 0);
     
226. 
     
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.       }
     
239. 
     
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;
     
249. 
     
250.             StartDraw = EndMax;
     
251.             EndDraw = EndMin;
     
252.             StartDrawValue = endMaxValue;
     
253.             EndDrawValue = nowMinValue;
     
254. 
     
255.             StartChannel = EndMin;
     
256.             EndChannel = EndMin;
     
257.             StartChannelValue = nowMinValue;
     
258.             EndChannelValue = nowMinValue;
     
259. 
     
260.             Counter++;
     
261. 
     
262.             LastLength = Length;
     
263.             Length = NormalizeDouble((endMaxValue - nowMinValue)/Point, 0);
     
264. 
     
265.             RePaint();
     
266.          }
     
267.       }
     
268.    }
     
269. }
     
270. 
     
271. void CheckDown(int offset)
     
272. {
     
273.    int startIndex = iBarShift(symbol, 0, StartMin);
     
274.    int endIndex = iBarShift(symbol, 0, EndMin);
     
275. 
     
276.    double endMinValue = SmoothedMinValues[endIndex];
     
277.       
     
278.    if (endMinValue > SmoothedMinValues[offset])
     
279.    {
     
280.       endMinValue = SmoothedMinValues[offset];
     
281.       EndMin = Time[offset];
     
282. 
     
283.       EndDraw = EndMin;
     
284.       EndDrawValue = endMinValue;
     
285. 
     
286.       EndChannel = EndMin;
     
287.       EndChannelValue = endMinValue;
     
288. 
     
289.       double endMaxValue = SmoothedMaxValues[iBarShift(symbol, 0, EndMax)];
     
290.       Length = NormalizeDouble((endMaxValue - endMinValue)/Point, 0);
     
291. 
     
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.       }
     
304. 
     
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;
     
314. 
     
315.             StartDraw = EndMin;
     
316.             EndDraw = EndMax;
     
317.             StartDrawValue = endMinValue;
     
318.             EndDrawValue = nowMaxValue;
     
319. 
     
320.             StartChannel = EndMax;
     
321.             EndChannel = EndMax;
     
322.             StartChannelValue = nowMaxValue;
     
323.             EndChannelValue = nowMaxValue;
     
324. 
     
325.             Counter++;
     
326. 
     
327.             LastLength = Length;
     
328.             Length = NormalizeDouble((nowMaxValue - endMinValue)/Point, 0);
     
329. 
     
330.             RePaint();
     
331.          }
     
332.       }
     
333.    }
     
334. }
     
335. 
     
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.    }
     
353. 
     
354.    ObjectMove(id, 0, EndDraw, pos);
     
355.    ObjectSetText(id, text, FontSize, FontName);
     
356. 
     
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. }
     
373. 
     
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);
     
404. 
     
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. }

复制代码

Channel_ZZ.mq4

2018-3-2 12:04

点击文件名下载附件

LZ真是人才

我是来刷分的，嘿嘿

看帖回帖是美德！:lol

学习了，不错

学习了，不错

帮你顶下哈！！

学习了，不错

帮你顶下哈！！

谢谢楼主分享