Mouteki-Demark_trend_new

Download script
Author: GreenDog
Mouteki-Demark_trend_new

This script is a specialized technical analysis tool designed for the MetaTrader platform. It operates by identifying specific price structures and patterns based on the "DeMark Theory," which focuses on finding significant pivot points in market data to determine potential trend directions and breakout levels.

Core Functionality and Logic

1. Identification of Pivot Points The script first scans historical price data to find "Demark Points." These are specific peaks (highs) or valleys (lows) that meet a mathematical requirement: a point must be higher than (or lower than) the candles immediately surrounding it on both sides. The script uses a recursive logic to ensure these points are significant, effectively filtering out minor market noise to identify the "true" structural turns in price.

2. Trendline Construction Once these pivot points are identified, the logic automatically draws trendlines based on your preferences:

  • UpTrendLines: Constructed by connecting consecutive lower lows.
  • DownTrendLines: Constructed by connecting consecutive higher highs. The script calculates the slope of these lines to project where the price "should" be moving relative to the established trend.

3. Breakout Analysis and Detection The primary goal of this script is to detect when the market "breaks" out of a current trend.

  • Breakout Detection: It monitors whether current price action has crossed above a falling trendline or below a rising trendline.
  • Verification (Hitches): To avoid "false breakouts" (where the price touches a line but fails to sustain momentum), the script uses a "Qualificator" logic. This checks three specific conditions:
    1. The direction of the previous candle's close.
    2. Whether the candle opened on the correct side of the trendline.
    3. A mathematical calculation involving the candle's midpoint relative to the trendline.

4. Dynamic Visual Aids Beyond just drawing lines, the script provides a comprehensive visual toolkit on the chart:

  • Horizontal Levels: It marks specific price levels where a breakout is officially confirmed.
  • Channel Lines: It can project parallel lines to show the "zone" of market movement.
  • Take Profit Targets: Based on the geometry of the trend break and various Fibonacci-related proportions (like the 1.618 level), the script automatically calculates and displays potential price targets for your trades.

Summary of User Experience

For a user, this means the platform does the heavy lifting of geometry and math. Instead of manually trying to figure out where a trendline ends or how far a price might go after a breakout, the script highlights the "Pivot Points," draws the trendlines, flags confirmed breakouts with visual arrows, and suggests specific horizontal targets for your exits—all while providing a text summary on the chart to keep you informed of the current analysis status.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
Mouteki-Demark_trend_new 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//------------------------------------------------------------------/
// Indicator-advisor based on Demark threory with additions
// Some part of the code was taken from Ind-TD-DeMark-3-1.mq4 [Kara ©]
//------------------------------------------------------------------/
#property copyright "GreenDog" 
#property link      "krot@inbox.ru" // v2.3

#property indicator_chart_window 
#property indicator_buffers 2
#property indicator_color1 Red 
#property indicator_color2 Blue 

extern int showBars=200; // if showBars= 0 so the indicator will be shown for all the chart
extern int LevDP=2; //  Demar Pint Levels; 2 = central bar will be higher (lower) then 2 bars on the left side and 2 bars on the right one.
extern int qSteps=1; // number of steps/ no more than 3
extern int BackStep=0; // number of staps back
extern int startBar=0; // ifstartBar=0 so we have recommendation for the current bar, if 1 - for possible next bar
extern bool TrendLine=true; // false = no trend lines
extern bool HorizontLine=true; // true = break levels
extern bool ChannelLine=false; // true = channels which is parallel with trend lines 
extern bool TakeLines=true; // true = take profit lines
extern bool Comments=true; // true = comments
extern int Trend=0; // 1 = for UpTrendLines only, -1 = for DownTrendLines only, 0 = for all TrendLines

double Buf1[]; 
double Buf2[]; 

string Col[]={"Red","DarkBlue","Coral","DodgerBlue","SaddleBrown","MediumSeaGreen"};
int ColNum[]={Red,DeepSkyBlue,Coral,Aqua,SaddleBrown,MediumSeaGreen};
int qPoint=0; // ïåðåìåííàÿ äëÿ íîðìàëèçàöèè öåíû

int qBars; double qTime=0; // ïåðåìåííûå äëÿ ëèêâèäàöèè ãëþêîâ ïðè çàãðóçêå

int init() 
  {
   qBars=Bars;
   qSteps=MathMin(3,qSteps);
   while (NormalizeDouble(Point,qPoint)==0)qPoint++;
   int code=161; string Rem="DLines © GameOver";
   IndicatorShortName(Rem); 
   SetIndexStyle(0,DRAW_ARROW); 
   SetIndexStyle(1,DRAW_ARROW); 
   SetIndexArrow(0,code); 
   SetIndexArrow(1,code); 
   SetIndexBuffer(0,Buf1); 
   SetIndexBuffer(1,Buf2); 
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexLabel(0,Rem); 
   SetIndexLabel(1,Rem); 
   return(0);
  } 

int deinit() {
   Comment("");
   ArrayInitialize(Buf1,0.0);
   ArrayInitialize(Buf2,0.0);
   for(int i=1;i<=LevDP;i++){
      ObjectDelete("HA_"+i);ObjectDelete("LA_"+i);
      ObjectDelete("HL_"+i);ObjectDelete("LL_"+i);
      ObjectDelete("HHL_"+i);ObjectDelete("HLL_"+i);
      ObjectDelete("HCL_"+i);ObjectDelete("LCL_"+i);
      for(int j=0;j<4;j++) {ObjectDelete("HTL_"+i+j);ObjectDelete("LTL_"+i+j);}
   }
}
  
int start(){
   if (qBars!=Bars){ deinit(); Sleep(1000); qBars=Bars; qTime=0; return(0);}
   if (qTime==Time[0]) return(0); qTime=Time[0]; // çàïóñêàåöà òîêà íà 1ì òèêå
   // çàïîëíèëè è îòîáðàçèëè òî÷êè äåìàðêà
   if (showBars==0) showBars=Bars-LevDP;
   for (int cnt=showBars;cnt>LevDP;cnt--) {
      Buf1[cnt]=DemHigh(cnt,LevDP);
      Buf2[cnt]=DemLow(cnt,LevDP);
   }
   
   string Comm;
   Comm="Trend Line["+On(TrendLine)+"]; Channel ["+On(ChannelLine)+
   "]; Breakout level ["+On(HorizontLine)+"]; Targets ["+On(TakeLines)+"]\n";
   for(cnt=1;cnt<=qSteps;cnt++) Comm=Comm+(TDMain(cnt));
   Comm=Comm+"———— © GameOver ————";
   if (Comments==true) Comment(Comm);
   return(0); 
}

string TDMain(int Step){
   int H1,H2,L1,L2,qExt,i,col;
   double tmp,qTL,qLevel,HT[4],LT[4];
   bool isHitch;
   string Comm="»—»—» Step "+Step+" of "+qSteps+" (BackStep "+BackStep+")\n",Text,Rem,qp;
   
   // äëÿ DownTrendLines
   if (Trend<=0){
      Comm=Comm+"» "+Col[Step*2-2]+" DownTrendLine ";
      col=ColNum[Step*2-2];
      H1=GetTD(Step+BackStep,Buf1);
      H2=GetNextHighTD(H1);
      qTL=(High[H2]-High[H1])/(H2-H1);
      qExt=Lowest(NULL,0,MODE_LOW,H2-H1-1,H1+1); // ëîêàëüíûé ìèíèìóì ìåæäó òî÷êàìè
      qLevel=High[H2]-qTL*(H2); if (Step+BackStep==1) qLevel=qLevel-qTL*startBar;
      if (H1<0 || H2<0) Comm=Comm+"not enough points on the chart for construction\n";
      else {
         Comm=Comm+"["+DoubleToStr(High[H2],qPoint)+"»"+DoubleToStr(High[H1],qPoint)+"]";
         Comm=Comm+"; Level "+DoubleToStr(qLevel,qPoint);
         if (Step+BackStep==1) {
            if (startBar>0) Comm=Comm+"; Future Bar "+UpHitch(-1,qLevel);
            else Comm=Comm+"; Last Bar "+UpHitch(startBar,qLevel);
         }
         Comm=Comm+"\n";
         // Àíàëèç - áûë ëè ïðîáîé òðåíäîâîé ëèíèè
         i=H1;isHitch=false;Text="";
         while(i>0 && isHitch==false){
            tmp=High[H2]-qTL*(H2-i);
            Rem="HA_"+Step;
            if (High[i]>tmp){
               qp=UpHitch(i,tmp);
               if (qp!=""){
                  isHitch=true;
                  Text=Text+"Source "+DoubleToStr(tmp,qPoint)+" "+qp;
                  ObjectCreate(Rem,OBJ_ARROW,0,0,0,0,0);
                  ObjectSet(Rem,OBJPROP_COLOR,col);
                  ObjectSet(Rem,OBJPROP_PRICE1,Low[i]-Point);
                  ObjectSet(Rem,OBJPROP_TIME1,Time[i]);
                  ObjectSet(Rem,OBJPROP_ARROWCODE,241);
                  while(i>0){ // ïðîáîé îòìåíåí, åñëè ïîñëå ïðîáîÿ áûë íîâûé ëîó èëè çàêðûòèå íèæå
                     i--;
                     if (Low[i]<Low[qExt] || Close[i]<(Low[qExt]+(High[H1]-Low[qExt])*0.236)){
                        Text=Text+" (cancel)";
                        ObjectSet(Rem,OBJPROP_PRICE1,Low[i]-Point);
                        ObjectSet(Rem,OBJPROP_TIME1,Time[i]);
                        ObjectSet(Rem,OBJPROP_ARROWCODE,251);
                        break;
                     }
                  }
               }
               else { Text=Text+"False "+DoubleToStr(tmp,qPoint)+"; "; ObjectDelete(Rem);}
            }
            i--;
         }
         if (Text=="") Text="No breakout";
         Comm=Comm+Text+"\n";
         // end analysis
         Rem="HL_"+Step; // ñîáñíî ëèíèÿ òðåíäà
         if (TrendLine){
            ObjectCreate(Rem,OBJ_TREND,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_TIME1,Time[H2]);ObjectSet(Rem,OBJPROP_TIME2,Time[H1]);
            ObjectSet(Rem,OBJPROP_PRICE1,High[H2]);ObjectSet(Rem,OBJPROP_PRICE2,High[H1]);
            ObjectSet(Rem,OBJPROP_COLOR,col);
            ObjectSet(Rem,OBJPROP_WIDTH,3-MathMin(2,Step));
         }    
         else ObjectDelete(Rem);
         Rem="HHL_"+Step; // óðîâåíü ïðîáîÿ ëèíèè òðåíäà
         if (HorizontLine && (Step+BackStep)==1){
            ObjectCreate(Rem,OBJ_HLINE,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_PRICE1,qLevel);
            ObjectSet(Rem,OBJPROP_COLOR,col);
         }
         else ObjectDelete(Rem);
         Rem="HCL_"+Step; // ëèíèÿ êàíàëà
         if (ChannelLine){
            ObjectCreate(Rem,OBJ_TREND,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_TIME1,Time[qExt]);ObjectSet(Rem,OBJPROP_TIME2,Time[0]);
            ObjectSet(Rem,OBJPROP_PRICE1,Low[qExt]);ObjectSet(Rem,OBJPROP_PRICE2,Low[qExt]-qTL*qExt);
            ObjectSet(Rem,OBJPROP_COLOR,col);
         }
         else ObjectDelete(Rem);
         Rem="HTL_"+Step; // ëèíèè öåëåé
         if (TakeLines){
            HT[3]=Low[qExt]+(High[H1]-Low[qExt])*1.618-qLevel; //  äîï óðîâåíü
            HT[0]=High[H2]-qTL*(H2-qExt)-Low[qExt];
            HT[1]=High[H2]-qTL*(H2-qExt)-Close[qExt];
            qExt=Lowest(NULL,0,MODE_CLOSE,H2-H1,H1);
            HT[2]=High[H2]-qTL*(H2-qExt)-Close[qExt];
            Comm=Comm+"Targets: ";
            for(i=0;i<4;i++){
               qTL=NormalizeDouble(qLevel+HT[i],qPoint);
               ObjectCreate(Rem+i,OBJ_HLINE,0,0,0,0,0);
               ObjectSet(Rem+i,OBJPROP_PRICE1,qTL);
               ObjectSet(Rem+i,OBJPROP_STYLE,STYLE_DOT);
               ObjectSet(Rem+i,OBJPROP_COLOR,col);
               Comm=Comm+DoubleToStr(qTL,qPoint)+" ("+DoubleToStr(HT[i]/Point,0)+"p.) ";
             }
             Comm=Comm+"\n";
         }
         else {
            for(i=0;i<4;i++) ObjectDelete(Rem+i);
         }
      }
   }

   // äëÿ UpTrendLines
   if (Trend>=0){
      Comm=Comm+"» "+Col[Step*2-1]+" UpTrendLine ";
      col=ColNum[Step*2-1];
      L1=GetTD(Step+BackStep,Buf2);
      L2=GetNextLowTD(L1);
      qTL=(Low[L1]-Low[L2])/(L2-L1);
      qExt=Highest(NULL,0,MODE_HIGH,L2-L1-1,L1+1); // ëîêàëüíûé ìèíèìóì ìåæäó òî÷êàìè
      qLevel=Low[L2]+qTL*L2; if (Step+BackStep==1) qLevel=qLevel+qTL*startBar;
      if (L1<0 || L2<0) Comm=Comm+"not enough points on the chart for construction\n";
      else {
         Comm=Comm+"["+DoubleToStr(Low[L2],qPoint)+"»"+DoubleToStr(Low[L1],qPoint)+"]";
         Comm=Comm+"; Level "+DoubleToStr(qLevel,qPoint);
         if (Step+BackStep==1) {
            if (startBar>0) Comm=Comm+"; Future Bar "+DownHitch(-1,qLevel);
            else Comm=Comm+"; Last Bar "+DownHitch(startBar,qLevel);
         }
         Comm=Comm+"\n";
         // Àíàëèç - áûë ëè ïðîáîé òðåíäîâîé ëèíèè
         i=L1;isHitch=false;Text="";
         while(i>0 && isHitch==false){
            tmp=Low[L2]+qTL*(L2-i);
            Rem="LA_"+Step;
            if (Low[i]<tmp){
               qp=DownHitch(i,tmp);
               if (qp!=""){
                  isHitch=true;
                  Text=Text+"Source "+DoubleToStr(tmp,qPoint)+" "+qp;
                  ObjectCreate(Rem,OBJ_ARROW,0,0,0,0,0);
                  ObjectSet(Rem,OBJPROP_COLOR,col);
                  ObjectSet(Rem,OBJPROP_PRICE1,Low[i]-Point);
                  ObjectSet(Rem,OBJPROP_TIME1,Time[i]);
                  ObjectSet(Rem,OBJPROP_ARROWCODE,242);
                  while(i>0){ // ïðîáîé îòìåíåí, åñëè ïîñëå ïðîáîÿ áûë íîâûé õàé èëè çàêðûòèå âûøå
                     i--;
                     if (High[i]>High[qExt] || Close[i]>High[qExt]-(High[qExt]-Low[L1])*0.236){
                        Text=Text+" (cancel)";
                        ObjectSet(Rem,OBJPROP_PRICE1,Low[i]-Point);
                        ObjectSet(Rem,OBJPROP_TIME1,Time[i]);
                        ObjectSet(Rem,OBJPROP_ARROWCODE,251);
                        break;
                     }
                  }
               }
               else { Text=Text+"False "+DoubleToStr(tmp,qPoint)+"; "; ObjectDelete(Rem);}
            }
            i--;
         }
         if (Text=="") Text="No breakout";
         Comm=Comm+Text+"\n";
         // end analysis
         Rem="LL_"+Step; // ñîáñíî ëèíèÿ òðåíäà
         if (TrendLine==1) {
            ObjectCreate(Rem,OBJ_TREND,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_TIME1,Time[L2]);ObjectSet(Rem,OBJPROP_TIME2,Time[L1]);
            ObjectSet(Rem,OBJPROP_PRICE1,Low[L2]);ObjectSet(Rem,OBJPROP_PRICE2,Low[L1]);
            ObjectSet(Rem,OBJPROP_COLOR,col);
            ObjectSet(Rem,OBJPROP_WIDTH,3-MathMin(2,Step));
         }    
         else ObjectDelete(Rem);
         Rem="HLL_"+Step; // óðîâåíü ïðîáîÿ ëèíèè òðåíäà
         if (HorizontLine && (Step+BackStep)==1){
            ObjectCreate(Rem,OBJ_HLINE,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_PRICE1,qLevel);
            ObjectSet(Rem,OBJPROP_COLOR,col);
         }
         else ObjectDelete(Rem);
         Rem="LCL_"+Step; // ëèíèÿ êàíàëà
         if (ChannelLine){
            ObjectCreate(Rem,OBJ_TREND,0,0,0,0,0);
            ObjectSet(Rem,OBJPROP_TIME1,Time[qExt]);ObjectSet(Rem,OBJPROP_TIME2,Time[0]);
            ObjectSet(Rem,OBJPROP_PRICE1,High[qExt]);ObjectSet(Rem,OBJPROP_PRICE2,High[qExt]+qTL*qExt);
            ObjectSet(Rem,OBJPROP_COLOR,col);
         }
         else ObjectDelete(Rem);
         Rem="LTL_"+Step;
         if (TakeLines){ // ëèíèè öåëåé
            LT[3]=qLevel-High[qExt]+(High[qExt]-Low[L1])*1.618; // äîï óðîâåíü
            LT[0]=High[qExt]-qTL*(L2-qExt)-Low[L2];
            LT[1]=Close[qExt]-qTL*(L2-qExt)-Low[L2];
            qExt=Highest(NULL,0,MODE_CLOSE,L2-L1,L1);
            LT[2]=Close[qExt]-qTL*(L2-qExt)-Low[L2];
            Comm=Comm+"Targets: ";
            for(i=0;i<4;i++){
               qTL=NormalizeDouble(qLevel-LT[i],qPoint);
               ObjectCreate(Rem+i,OBJ_HLINE,0,0,0,0,0);
               ObjectSet(Rem+i,OBJPROP_PRICE1,qTL);
               ObjectSet(Rem+i,OBJPROP_STYLE,STYLE_DOT);
               ObjectSet(Rem+i,OBJPROP_COLOR,col);
               Comm=Comm+DoubleToStr(qTL,qPoint)+" ("+DoubleToStr(LT[i]/Point,0)+"p.) ";
             }
            Comm=Comm+"\n";
         }
         else {
            for(i=0;i<4;i++) ObjectDelete(Rem+i);
         }
      }
   }
   return(Comm);
}

int GetTD(int P, double Arr[]){
   int i=0,j=0;
   while(j<P){ i++; while(Arr[i]==0){i++;if(i>showBars-2)return(-1);} j++;}
   return (i);         
}
int GetNextHighTD(int P){ 
   int i=P+1;
   while(Buf1[i]<=High[P]){i++;if(i>showBars-2)return(-1);}
   return (i);
}
int GetNextLowTD(int P){
   int i=P+1;
   while(Buf2[i]>=Low[P] || Buf2[i]==0){i++;if(i>showBars-2)return(-1);}
   return (i);
}
// ðåêóðñèâíàÿ ïðîâåðêà íà óñëîâèÿ Äåìàðêà (õàé), âîçâðàùàåò çíà÷åíèå èëè 0
double DemHigh(int cnt, int sh){
   if (High[cnt]>=High[cnt+sh] && High[cnt]>High[cnt-sh]) {
      if (sh>1) return(DemHigh(cnt,sh-1));
      else return(High[cnt]);
   }
   else return(0);
}
// ðåêóðñèâíàÿ ïðîâåðêà íà óñëîâèÿ Äåìàðêà (ëîó), âîçâðàùàåò çíà÷åíèå èëè 0
double DemLow(int cnt, int sh){
   if (Low[cnt]<=Low[cnt+sh] && Low[cnt]<Low[cnt-sh]) {
      if (sh>1) return(DemLow(cnt,sh-1));
      else return(Low[cnt]);
   }
   else return(0);
}
string On(bool On){
   if (On) return("on"); else return("off");
}
string UpHitch(int P, double qLevel){ // îïðåäåëåíèå êâàëèôèêàòîðîâ ïðîðûâà ââåðõ
   string Comm="";
   if (Close[P+1]<Close[P+2]) Comm=Comm+" 1";
   if (P>=0 && Open[P]>qLevel) Comm=Comm+" 2";
   if (2*Close[P+1]-Low[P+1]<qLevel) Comm=Comm+" 3";
   if (Comm!="") Comm="[ Break Qualificator:"+Comm+" ]";
   return(Comm);
}
string DownHitch(int P, double qLevel){ // îïðåäåëåíèå êâàëèôèêàòîðîâ ïðîðûâà âíèç
   string Comm="";
   if (Close[P+1]>Close[P+2]) Comm=Comm+" 1";
   if (P>=0 && Open[P]<qLevel) Comm=Comm+" 2";
   if (2*Close[P+1]-High[P+1]>qLevel) Comm=Comm+" 3";
   if (Comm!="") Comm="[ Break Qualificator:"+Comm+" ]";
   return(Comm);
}

Similar scripts

Demark_trend_alert_and_mail_v1

This advisor identifies structural trend shifts by calculating DeMark pivot levels and projecting automated trendlines, breakout qualifiers, and Fibonacci-based price targets.

_2523DeMark

This indicator identifies structural trendlines and pivot points using DeMark theory to detect price breakouts, provide dynamic channel projections, and calculate Fibonacci-based profit targets.

DeMark lines_v1

This indicator identifies key pivot points using DeMark theory to construct trendlines, breakout levels, and dynamic target zones for precise market structure analysis.

Demark_trend_alert_and_mail

This indicator identifies DeMark pivots to construct trendlines, detect price breakouts with specific qualifiers, and project potential take-profit targets.

DeMark lines_001

This indicator identifies structural price pivots using DeMark theory to project dynamic trendlines, breakout levels, and Fibonacci-based target zones.

DeMark lines

This indicator identifies DeMark high/low pivot points to construct trendlines and automatically detects structural breakouts with specific price target levels and visual alerts.

Mouteki-Demark_trend_new_v2

This indicator identifies trend reversals and breakout opportunities by projecting linear price trajectories from Demark pivots, complete with automatic target levels and breakout qualificators.

Demark

This indicator identifies DeMark pivot points to project dynamic trendlines, breakout levels, and Fibonacci-based target zones while monitoring structural breaches.

Demark2

This indicator dynamically identifies Demark pivot points to project trendlines, violation levels, and Fibonacci-based take-profit zones with automated hitch detection.

Demark_trend_new

This indicator identifies DeMark high and low pivots to project trendlines, breakout levels, and dynamic trading channels based on Fibonacci-inspired price action.

Mouteki-Demark_trend_new_v1

This indicator identifies structural trend reversals by calculating DeMark pivot points and detecting high-probability breakout 'hitches' against dynamic trendlines.

Comments