Pattern Recognition_v2

Download script
Author: Copyright � 2005, Jason Robinson (jnrtrading).
Pattern Recognition_v2

Overview

This script is a specialized technical analysis tool designed for the MetaTrader trading platform. Its primary purpose is to automatically scan financial charts to identify specific "candlestick patterns"—visual formations that traders use to predict potential shifts in market direction. Instead of requiring a human to manually inspect every candle, this tool performs that task in real-time.

Core Logic and Functionality

The script operates by constantly monitoring the price action on your chart. It looks back at historical data and current price movements to check for two specific types of market signals: Bearish (potential downward moves) and Bullish (potential upward moves).

Key features include:

  • Automated Pattern Recognition: The tool is programmed with a comprehensive library of classic trading patterns. These include complex formations such as:
    • Bearish Patterns: Engulfing, Dark Cloud Cover, Evening Doji Star, Harami, Three Inside Down, and Three Black Crows.
    • Bullish Patterns: Engulfing, Three Outside Up, Harami, Three Inside Up, Piercing Line, Three White Soldiers, and Morning Doji Star.
  • Visual Identification: When the script identifies a pattern, it provides immediate visual feedback on the chart. It places descriptive text labels (naming the specific pattern) and colored arrows (Red for bearish signals, Blue for bullish signals) to highlight exactly where the occurrence happened.
  • Dynamic Range Calculation: To ensure that the labels and arrows are positioned cleanly on the chart without overlapping the price candles, the script calculates the average "range" of recent price movements. It uses this data to place markers at a consistent distance above or below the action.
  • Real-Time Alerts: Beyond visual cues, the script features an alert system. If a new pattern is detected on the most recent candle, it can trigger a notification. This allows traders to stay informed of potential opportunities immediately, even if they are not actively staring at the screen.
  • Customizable Filtering: The script includes various toggle switches that allow you to choose exactly which patterns you want to see. If you only trade specific signals (for example, only "Engulfing" patterns), you can turn off all other detections to keep your chart clean and focused.

Summary of User Experience

For a non-technical user, this tool acts as an automated "scout." It continuously watches the market for complex price structures that are often difficult to spot quickly by eye. By highlighting these patterns with text and arrows—and providing alerts when they occur—it simplifies the process of identifying potential trading signals across different timeframes (from 1-minute charts up to monthly views).

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
10 Views
0 Downloads
0 Favorites
Pattern Recognition_v2
//+------------------------------------------------------------------+
//|                                     Pattern Recognition v1.0     |
//|          (complete rewrite and name change of pattern alert)     |
//+------------------------------------------------------------------+
//|                                         Pattern Recognition.mq4  |
//|                                Copyright © 2005, Jason Robinson  |
//|                                  (jasonrobinsonuk,  jnrtrading)  |
//|                                     http://www.jnrtrading.co.uk  |
//|      This is still work in progress and needs LOTS of testing    |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, Jason Robinson (jnrtrading)."
#property link      "http://www.jnrtrading.co.uk"

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
//----
extern bool Show_Alert = true;
extern bool Display_Bearish_Engulfing = true;
extern bool Display_Three_Outside_Down = true;
extern bool Display_Three_Inside_Down = true;
extern bool Display_Dark_Cloud_Cover = true;
extern bool Display_Three_Black_Crows = true;
extern bool Display_Bullish_Engulfing = true;
extern bool Display_Three_Outside_Up = true;
extern bool Display_Three_Inside_Up = true;
extern bool Display_Piercing_Line = true;
extern bool Display_Three_White_Soldiers = true;
extern bool Display_Stars = true;
extern bool Display_Harami = true;
//---- buffers
double upArrow[];
double downArrow[];
string PatternText[5000];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init() 
  {
   SetIndexStyle(0, DRAW_ARROW, 0, 1);
   SetIndexArrow(0, 72);
   SetIndexBuffer(0, downArrow);      
//----
   SetIndexStyle(1, DRAW_ARROW, 0, 1);
   SetIndexArrow(1, 71);
   SetIndexBuffer(1, upArrow);
      
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit() 
  {
   ObjectsDeleteAll(0, OBJ_TEXT);
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   double Range, AvgRange;
   int counter, setalert;
   static datetime prevtime = 0;
   int shift;
   int shift1;
   int shift2;
   int shift3;
   string pattern, period;
   int setPattern = 0;
   int alert = 0;
   int arrowShift;
   int textShift;
   double O, O1, O2, C, C1, C2, L, L1, L2, H, H1, H2;     
//----
   if(prevtime == Time[0]) 
     {
       return(0);
     }
   prevtime = Time[0];   
//----
   switch(Period()) 
     {
       case 1:     period = "M1";  break;
       case 5:     period = "M5";  break;
       case 15:    period = "M15"; break;
       case 30:    period = "M30"; break;      
       case 60:    period = "H1";  break;
       case 240:   period = "H4";  break;
       case 1440:  period = "D1";  break;
       case 10080: period = "W1";  break;
       case 43200: period = "MN";  break;
     }
//----
   for(int j = 0; j < Bars; j++) 
     { 
       PatternText[j] = "pattern-" + j;
     }
//----
   for(shift = 0; shift < Bars; shift++) 
     {
       setalert = 0;
       counter = shift;
       Range = 0;
       AvgRange = 0;
       for(counter = shift; counter <= shift + 9; counter++) 
         {
           AvgRange = AvgRange + MathAbs(High[counter] - Low[counter]);
         }
       Range = AvgRange / 10;
       shift1 = shift + 1;
       shift2 = shift + 2;
       shift3 = shift + 3;      
       O = Open[shift1];
       O1 = Open[shift2];
       O2 = Open[shift3];
       H = High[shift1];
       H1 = High[shift2];
       H2 = High[shift3];
       L = Low[shift1];
       L1 = Low[shift2];
       L2 = Low[shift3];
       C = Close[shift1];
       C1 = Close[shift2];
       C2 = Close[shift3];         
       // Bearish Patterns   
       // Check for Bearish Engulfing pattern
       if((C1 > O1) && (O > C) && (O >= C1) && (O1 >= C) && ((O - C) > (C1 - O1))) 
         {
           if(Display_Bearish_Engulfing == true) 
             {
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Bearish Engulfing", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           if(setalert == 0 && Show_Alert == true) 
             {
               pattern = "Bearish Engulfing Pattern";
               setalert = 1;
             }
         }
       // Check for a Three Outside Down pattern
       if((C2 > O2) && (O1 > C1) && (O1 >= C2) && (O2 >= C1) && ((O1 - C1) > (C2 - O2)) && 
          (O > C) && (C < C1)) 
         {
           if(Display_Three_Outside_Down == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Three Outside Down", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(setalert == 0 && Show_Alert == true) 
             {
               pattern = "Three Oustide Down Pattern";
               setalert = 1;
             }
         }
       // Check for a Dark Cloud Cover pattern
       if((C1 > O1) && (((C1 + O1) / 2) > C) && (O > C) && (O > C1) && (C > O1) && 
          ((O - C) / (0.001 + (H - L)) > 0.6)) 
         {
           if(Display_Dark_Cloud_Cover == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Dark Cloud Cover", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           //----
           if(setalert == 0 && Show_Alert == true) 
             {
               pattern = "Dark Cloud Cover Pattern";
               setalert = 1;
             }
         }     
       // Check for Evening Doji Star pattern
       if((C2 > O2) && ((C2 - O2) / (0.001 + H2 - L2) > 0.6) && (C2 < O1) && (C1 > O1) && 
          ((H1-L1) > (3*(C1 - O1))) && (O > C) && (O < O1)) 
         {
           if(Display_Stars == true) 
             {
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Evening Doji Star", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           //----
           if(setalert == 0 && Show_Alert == true) 
             {
               pattern = "Evening Doji Star Pattern";
               setalert = 1;
             }
         }     
       // Check for Bearish Harami pattern
       if((C1 > O1) && (O > C) && (O <= C1) && (O1 <= C) && ((O - C) < (C1 - O1))) 
         {
           if(Display_Harami == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Bearish Harami", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern="Bearish Harami Pattern";
               setalert = 1;
             }
         }
       // Check for Three Inside Down pattern
       if((C2 > O2) && (O1 > C1) && (O1 <= C2) && (O2 <= C1) && ((O1 - C1) < (C2 - O2)) && 
          (O > C) && (C < C1) && (O < O1)) 
         {
           if(Display_Three_Inside_Down == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Three Inside Down", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Three Inside Down Pattern";
               setalert = 1;
             }
         }   
       // Check for Three Black Crows pattern
       if((O > C*1.01) && (O1 > C1*1.01) && (O2 > C2*1.01) && (C < C1) && (C1 < C2) && 
          (O > C1) && (O < O1) && (O1 > C2) && (O1 < O2) && (((C - L) / (H - L)) < 0.2) && 
          (((C1 - L1) / (H1 - L1)) < 0.2) && (((C2 - L2) / (H2 - L2)) < 0.2))
         {
           if(Display_Three_Black_Crows == true)
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Three Black Crows", 10, 
                             "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           //----
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Three Black Crows Pattern";
               setalert = 1;
             }
         }
       //Check for Evening Star Pattern
       if((C2 > O2) && ((C2 - O2) / (0.001 + H2 - L2) > 0.6) && (C2 < O1) && (C1 > O1) && 
          ((H1 - L1) > (3*(C1 - O1))) && (O > C) && (O < O1)) 
         {
           if(Display_Stars == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            High[shift1] + Range*1.5);
               ObjectSetText(PatternText[shift], "Evening Star", 10, "Times New Roman", Red);
               downArrow[shift1] = High[shift1] + Range*0.5;
             }
           //----
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Evening Star Pattern";
               setalert = 1;
             }
         }
       // End of Bearish Patterns
       // Bullish Patterns
       // Check for Bullish Engulfing pattern
       if((O1 > C1) && (C > O) && (C >= O1) && (C1 >= O) && ((C - O) > (O1 - C1))) 
         {
           if(Display_Bullish_Engulfing) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Bullish Engulfing", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Bullish Engulfing Pattern";
               setalert = 1;
             }
         }
       // Check for Three Outside Up pattern
       if((O2 > C2) && (C1 > O1) && (C1 >= O2) && (C2 >= O1) && ((C1 - O1) > (O2 - C2)) && 
          (C > O) && (C > C1)) 
         {
           if(Display_Three_Outside_Up == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Three Outside Up", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Three Outside Up Pattern";
               setalert = 1;
             }
         }
       // Check for Bullish Harami pattern
       if((O1 > C1) && (C > O) && (C <= O1) && (C1 <= O) && ((C - O) < (O1 - C1))) 
         {
           if(Display_Harami == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Bullish Harami", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Bullish Harami Pattern";
               setalert = 1;
             } 
         }
       // Check for Three Inside Up pattern
       if((O2 > C2) && (C1 > O1) && (C1 <= O2) && (C2 <= O1) && ((C1 - O1) < (O2 - C2)) && 
          (C > O) && (C > C1) && (O > O1)) 
         {
           if(Display_Three_Inside_Up == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Three Inside Up", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Three Inside Up Pattern";
               setalert = 1;
             }
         }      
       // Check for Piercing Line pattern
       if((C1 < O1) && (((O1 + C1) / 2) < C) && (O < C) && (O < C1) && (C < O1) && 
          ((C - O) / (0.001 + (H - L)) > 0.6)) 
         {
           if(Display_Piercing_Line == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Piercing Line", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Piercing Line Pattern";
               setalert = 1;
             }
         }      
       // Check for Three White Soldiers pattern
       if((C > O*1.01) && (C1 > O1*1.01) && (C2 > O2*1.01) && (C > C1) && (C1 > C2) && 
          (O < C1) && (O > O1) && (O1 < C2) && (O1 > O2) && (((H - C) / (H - L)) < 0.2) && 
          (((H1 - C1) / (H1 - L1)) < 0.2) && (((H2 - C2) / (H2 - L2)) < 0.2)) 
         {
           if(Display_Three_White_Soldiers == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Three White Soldiers", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Three White Soldiers Pattern";
               setalert = 1;
             }
         }     
       // Check for Morning Doji Star
       if((O2 > C2) && ((O2 - C2) / (0.001 + H2 - L2) > 0.6) && (C2 > O1) && (O1 > C1) && 
          ((H1 - L1) > (3*(C1 - O1))) && (C > O) && (O > O1)) 
         {
           if(Display_Stars == true) 
             {   
               ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], 
                            Low[shift1] - Range*1.5);
               ObjectSetText(PatternText[shift], "Morning Doji Star", 10, 
                             "Times New Roman", Blue);
               upArrow[shift1] = Low[shift1] - Range*0.5;
             }
           if(shift == 0 && Show_Alert == true) 
             {
               pattern = "Morning Doji Star Pattern";
               setalert = 1;
             }
         }
       if(setalert == 1 && shift == 0) 
         {
           Alert(Symbol(), " ", period, " ", pattern);
           setalert = 0;
         }
     } // End of for loop
   return(0);
  }
//+------------------------------------------------------------------+

Comments