Pattern_Recognition_Master

//+------------------------------------------------------------------+
//|                                     Pattern Recognition v1.0     |
//|          (complete rewrite and name change of pattern alert)     |
//|                                                                  |
//|                 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 Red

extern bool Show_Alert = true;
extern int  Pointer_Offset = 9;
extern int  High_Offset = 10;

extern bool Display_Bearish_Engulfing = false;
extern bool Show_Bearish_Engulfing_Alert = false;
extern int  Offset_Bearish_Engulfing = 12;

extern bool Display_Three_Outside_Down = false;
extern bool Show_3OD_Alert = false;
extern int  Offset_3OD = 12;

extern bool Display_Three_Inside_Down = false;
extern bool Show_3ID_Alert = false;
extern int  Offset_3ID = 12;

extern bool Display_Dark_Cloud_Cover = false;
extern bool Show_DarkCC_Alert = false;
extern int  Offset_DarkCC = 12;

extern bool Display_Three_Black_Crows = false;
extern bool Show_3BC_Alert = false;
extern int  Offset_3BC = 12;

extern bool Display_Bullish_Engulfing = false;
extern bool Show_Bullish_Engulfing_Alert = false;
extern int  Offset_Bullish_Engulfing = 12;

extern bool Display_Three_Outside_Up = false;
extern bool Show_3OU_Alert = false;
extern int  Offset_3OU = 12;

extern bool Display_Three_Inside_Up = false;
extern bool Show_3IU_Alert = false;
extern int  Offset_3IU = 12;

extern bool Display_Piercing_Line = false;
extern bool Show_Piercing_Line_Alert = false;
extern int  Offset_Piercing_Line = 12;

extern bool Display_Three_White_Soldiers = false;
extern bool Show_3WS_Alert = false;
extern int  Offset_3WS = 12;

extern bool Display_Doji = true;
extern bool Show_Doji_Alert = true;
extern int  Offset_Doji = 12;

extern bool Display_Stars = true;
extern bool Show_Stars_Alert = true;
extern int  Star_Body_Length = 5;
extern int  Offset_Star = 8;

extern bool Display_Harami = false;
extern bool Show_Harami_Alert = false;
extern int  Offset_Harami = 12;

extern bool Display_Trend = false;
extern bool Show_Trend_Alert = false;
extern int  Offset_Trend = 12;

extern bool Display_Hangman = true;
extern bool Show_Hangman_Alert = true;
extern int  Offset_Hangman = 12;

extern bool Display_ShootStar = true;
extern bool Show_ShootStar_Alert = true;
extern int  Offset_ShootStar = 12;

extern bool Display_Hammer = true;
extern bool Show_Hammer_Alert = true;
extern int  Offset_Hammer = 6;

extern bool Display_3_Closes = false;
extern bool Show_3_Closes_Alert = false;
extern int  Offset_3_Closes = 12;

extern double Candle_WickBody_Percent=0.90;
extern int CandleLength=12;

//---- buffers
double upArrow[];
double downArrow[];
string PatternText[10000];


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init() {

//---- indicators
   
   SetIndexStyle(0,DRAW_ARROW, EMPTY);
   SetIndexArrow(0,72);
   SetIndexBuffer(0, downArrow);
      
   SetIndexStyle(1,DRAW_ARROW, EMPTY);
   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;
   int shift4;
   string pattern, period;
   int setPattern = 0;
   int alert = 0;
   int arrowShift;
   int textShift;
   double O, O1, O2, C, C1, C2, C3, L, L1, L2, L3, H, H1, H2, H3;
   double CL, CLmin, CL1, CL2, BL, BLa, BL90, BL1, BL2, UW, UWa, UW1, UW2, LW, LWa, LW1, LW2, BodyHigh, BodyLow;
   BodyHigh = 0;
   BodyLow = 0;
     
   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;
      shift4 = shift + 4;
      
      
      O = Open[shift1];
      O1 = Open[shift2];
      O2 = Open[shift3];
      H = High[shift1];
      H1 = High[shift2];
      H2 = High[shift3];
      H3 = High[shift4];
      L = Low[shift1];
      L1 = Low[shift2];
      L2 = Low[shift3];
      L3 = Low[shift4];
      C = Close[shift1];
      C1 = Close[shift2];
      C2 = Close[shift3];
      C3 = Close[shift4];
      if (O>C) {
         BodyHigh = O;
         BodyLow = C;  }
      else {
         BodyHigh = C;
         BodyLow = O; }
      CL = High[shift1]-Low[shift1];
      CL1 = High[shift2]-Low[shift2];
      CL2 = High[shift3]-Low[shift3];
      BL = Open[shift1]-Close[shift1];
      UW = High[shift1]-BodyHigh;
      LW = BodyLow-Low[shift1];
      BLa = MathAbs(BL);
      BL90 = BLa*Candle_WickBody_Percent;
            
         
   // Bearish Patterns  
/*   
      // Check for Bearish 3 Closes Lower   
      if ((C>C1)&&(C1>C2)&&(C2>C3))  {
         if (Display_3_Closes == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_3_Closes+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "3CH", 7, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_3_Closes_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bearish 3 Closes Higher Pattern";
            setalert = 1;
         }
         }
      }
*/   
     // Check for Bearish Shooting Star
      if ((H>=H1)&&(H>H2)&&(H>H3))  {
         if (((UW/2)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(L>L1)&&(L>L2)*/)  {
         if (Display_ShootStar == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_ShootStar+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "SS 2", 7, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         }
         if (Show_ShootStar_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Shooting Star 2";
            setalert = 1;
         }
         }
      }
      
      // Check for Bearish Shooting Star
      if ((H>=H1)&&(H>H2)&&(H>H3))  {
         if (((UW/3)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(L>L1)&&(L>L2)*/)  {
         if (Display_ShootStar == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_ShootStar+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "SS 3", 7, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         }
         if (Show_ShootStar_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Shooting Star 3";
            setalert = 1;
         }
         }
      }
      
      // Check for Bearish Shooting Star
      if ((H>=H1)&&(H>H2)&&(H>H3))  {
         if (((UW/4)>LW)&&(UW>(2*BL90))&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(L>L1)&&(L>L2)*/)  {
         if (Display_ShootStar == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_ShootStar+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "SS 4", 7, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         }
         if (Show_ShootStar_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Shooting Star 4";
            setalert = 1;
         }
         }
      }
/*      
      // Check for Bearish Trend pattern
      if ((H>=H1)&&(H>H2)&&(UW>(2*LW))&&(UW>=BLa))  {
         if (Display_Trend == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_Trend+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "MT", 7, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_Trend_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bearish Major Trend Pattern";
            setalert = 1;
         }
         }
      }
      
      // 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] + (Pointer_Offset+Offset_Bearish_Engulfing+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "SE", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_Bearish_Engulfing_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bearish Engulfing SE 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] - (Pointer_Offset+Offset_3OD+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "3OD", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_3OD_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern="Three Oustide Down 3OD 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] + (Pointer_Offset+Offset_DarkCC+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "DCC", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_DarkCC_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern="Dark Cloud Cover Pattern";
            setalert = 1;
         }
         }
      }
*/    
 // Check for Evening Star pattern
      if ((H>=H1)&&(H1>H2)&&(H2>H3))  {
         if ((L>O1)&&(BLa<(Star_Body_Length*Point))/*&&(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] + (Pointer_Offset+Offset_Star+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "Star", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         }
         if (Show_Stars_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern="Evening Star Pattern";
            setalert = 1;
         }
         }
      }  
      // Check for Evening Doji Star pattern
      if ((H>=H1)&&(H1>H2)&&(H2>H3))  {
         if ((L>O1)&&(BLa==0)&&((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_Doji == true) {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], High[shift1] + (Pointer_Offset+Offset_Doji+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "Doji", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         }
         if (Show_Doji_Alert) {
         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] + (Pointer_Offset+Offset_Harami+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "SH", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_Harami_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Bearish Harami SH 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] + (Pointer_Offset+Offset_3ID+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "3ID", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_3ID_Alert) {
         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] + (Pointer_Offset+Offset_3BC+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "3BC", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_3BC_Alert) {
         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] + (Pointer_Offset+Offset_Star+High_Offset)*Point);
            ObjectSetText(PatternText[shift], "Evening Star", 9, "Times New Roman", Red);
            downArrow[shift1] = High[shift1] + (Pointer_Offset*Point);
         }
         if (Show_Stars_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern = "Evening Star Pattern";
            setalert = 1;
         }
         }
      }
            
   // End of Bearish Patterns
   
   // Bullish Patterns
   
       // Check for Bullish 3 Closes Lower   
      if ((C<C1)&&(C1<C2)&&(C2<C3))  {
         if (Display_3_Closes == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_3_Closes)*Point);
            ObjectSetText(PatternText[shift], "3CL", 7, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_3_Closes_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bullish 3 Closes Lower Pattern";
            setalert = 1;
         }
         }
      }
*/   
       // Check for Bullish Hammer   
      if ((L<=L1)&&(L<L2)&&(L<L3))  {
      if (((LW/2)>UW)&&(LW>BL90)&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(H<H1)&&(H<H2)*/)  {
         if (Display_Hammer == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_Hammer)*Point);
            ObjectSetText(PatternText[shift], "HMR 2", 7, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         }
         if (Show_Hammer_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bullish Hammer 2";
            setalert = 1;
         }
         }
      }
      
      // Check for Bullish Hammer   
      if ((L<=L1)&&(L<L2)&&(L<L3))  {
         if (((LW/3)>UW)&&(LW>BL90)&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(H<H1)&&(H<H2)*/)  {
         if (Display_Hammer == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_Hammer)*Point);
            ObjectSetText(PatternText[shift], "HMR 3", 7, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         }
         if (Show_Hammer_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bullish Hammer 3";
            setalert = 1;
         }
         }
      }
      
      // Check for Bullish Hammer   
      if ((L<=L1)&&(L<L2)&&(L<L3))  {
         if (((LW/4)>UW)&&(LW>BL90)&&(CL>=(CandleLength*Point))&&(O!=C)/*&&(H<H1)&&(H<H2)*/)  {
         if (Display_Hammer == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_Hammer)*Point);
            ObjectSetText(PatternText[shift], "HMR 4", 7, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         }
         if (Show_Hammer_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bullish Hammer 4";
            setalert = 1;
         }
         }
      }
/*   
      // Check for Bullish Trend pattern
      if ((L<=L1)&&(L<L2)&&(LW>(2*UW))&&(LW>=BLa))  {
         if (Display_Trend == true)  {
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_Trend)*Point);
            ObjectSetText(PatternText[shift], "MT", 7, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_Trend_Alert) {
         if (setalert == 0 && Show_Alert == true) {
            pattern = "Bullish Major Trend Pattern";
            setalert = 1;
         }
         }
      }
   
      // 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] - (Pointer_Offset+Offset_Bullish_Engulfing)*Point);
            ObjectSetText(PatternText[shift], "LE", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_Bullish_Engulfing_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Bullish Engulfing LE 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] - (Pointer_Offset+Offset_3OU)*Point);
            ObjectSetText(PatternText[shift], "3OU", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_3OU_Alert) {
         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] - (Pointer_Offset+Offset_Harami)*Point);
            ObjectSetText(PatternText[shift], "LH", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_Harami_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Bullish Harami LH 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] - (Pointer_Offset+Offset_3IU)*Point);
            ObjectSetText(PatternText[shift], "3IU", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_3IU_Alert) {
         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] - (Pointer_Offset+Offset_Piercing_Line)*Point);
            ObjectSetText(PatternText[shift], "Piercing Line", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_Piercing_Line_Alert) {
         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] - (Pointer_Offset+Offset_3WS)*Point);
            ObjectSetText(PatternText[shift], "3WS", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         if (Show_3WS_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Three White Soldiers Pattern";
            setalert = 1;
         }
         }
      }
*/      

      // Check for Morning Star
      
      if ((L<=L1)&&(L<L2)&&(L<L3))  {
      if ((H1<(BL/2))&&(BLa<(Star_Body_Length*Point)))/*((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] - (Pointer_Offset+Offset_Star)*Point);
            ObjectSetText(PatternText[shift], "Star", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         }
         if (Show_Stars_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Morning Star Pattern";
            setalert = 1;
         }
         }
      }

      // Check for Morning Doji Star
      
      if ((L<=L1)&&(L<L2)&&(L<L3))  {
      if ((H1<(BL/2))&&(BLa==0))/*((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_Doji == true) {   
            ObjectCreate(PatternText[shift], OBJ_TEXT, 0, Time[shift1], Low[shift1] - (Pointer_Offset+Offset_Doji)*Point);
            ObjectSetText(PatternText[shift], "Doji", 9, "Times New Roman", Red);
            upArrow[shift1] = Low[shift1] - (Pointer_Offset*Point);
         }
         }
         if (Show_Doji_Alert) {
         if (shift == 0 && Show_Alert == true) {
            pattern="Morning Doji Pattern";
            setalert = 1;
         }
         }
      }
      
           
      if (setalert == 1 && shift == 0) {
         Alert(Symbol(), " ", period, " ", pattern);
         setalert = 0;
      }
   } // End of for loop
     
   
      
   return(0);
}
//+------------------------------------------------------------------+