Mouteki-Demark_trend_new_v2

Download script
Author: GreenDog
Mouteki-Demark_trend_new_v2

This script is a specialized technical analysis tool designed for the MetaTrader platform. It automates the identification of price trends and potential breakout points based on DeMark Theory, a trading methodology that focuses on identifying "turning points" in market momentum.

The logic of the script can be broken down into several core functional areas:

1. DeMark Point Identification

The foundation of the script is its ability to identify specific high and low price points (Demark Points). Instead of looking at every single candle, the script uses a recursive logic to scan back through history to find "significant" peaks and valleys. It filters out minor price fluctuations to highlight only the structural highs and lows that define the current market shape.

2. Dynamic Trend Line Construction

Once the key high and low points are identified, the script automatically calculates and draws trend lines on your chart:

  • UpTrend Lines: These are drawn by connecting significant lows to determine the path of upward momentum.
  • DownTrend Lines: These are drawn by connecting significant highs to determine the path of downward momentum.

The script is versatile; it can be configured to show only up-trends, only down-trends, or both simultaneously.

3. Breakout Analysis and Validation

One of the most sophisticated parts of this script is its "Breakout" detection. It doesn't just notify you when a price crosses a line; it analyzes the quality of that breakout:

  • Detection: It calculates the specific level where a trend line is expected to break.
  • Validation (Qualifiers): The script checks if the breakout meets specific conditions (qualifiers) based on price action, such as candle closing patterns and relationship to the previous candle's range.
  • Cancellation Logic: If a breakout appears to be "false" or if the price reverts in a specific way after the break, the script can identify this as a "cancel," helping traders avoid being caught in "fakeouts."

4. Visual Aids and Projections

To help with trade planning, the script provides several visual overlays:

  • Horizontal Levels: It draws clear horizontal lines at predicted breakout points.
  • Channels: It can project parallel lines to create channels, helping visualize the boundaries of price movement.
  • Target Zones (Take Profit): The script calculates potential profit targets based on mathematical ratios (such as the 1.618 Fibonacci level) and price distance from the breakout point. It provides four different target levels to give traders a range of objectives.

5. On-Screen Reporting

In addition to drawing lines and shapes directly on the chart, the script generates a real-time text comment in the corner of your screen. This summary provides a quick "at-a-glance" status of:

  • The current Trend Line status.
  • Specific price levels for breakouts.
  • Breakout qualifiers (the 1, 2, or 3 numerical codes).
  • Calculated target prices and the distance to those targets in pips/points.

Summary for the User

Essentially, this tool acts as an automated "chartist." It scans the history to find the most important structural points, draws the current trend lines for you, predicts exactly where the price might break out of those trends, validates whether that break is "strong" or "weak," and marks your potential profit targets—all in real-time.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
Mouteki-Demark_trend_new_v2 
//+---------------------------------------------------------------------+
//| 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

This indicator identifies DeMark pivots to construct trendlines, detect price breakouts with specific qualifiers, and project potential take-profit 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.

Mouteki-Demark_trend_new

This indicator identifies structural trend lines and breakout levels using DeMark theory to project potential price targets and provide breakout qualifiers.

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.

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.

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.

Demark2

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

Demark

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

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