rvmFractalsLevel_v3

Download script
Author: Copyright � 2005, Profi_R
rvmFractalsLevel_v3

This script is designed to provide visual support for technical analysis by identifying significant price boundaries and automatically generating structural geometry on a trading chart. It operates by detecting "Fractals"—specific peaks and valleys in price action—and using those data points to project specific mathematical levels.

Core Logic Overview

1. Fractal Identification (Highs and Lows) The primary engine of the script searches for historical price extremes. It looks for "peaks" where a high point is greater than the surrounding candles on both the left and right sides, as well as "valleys" where a low point is lower than its neighbors.

  • Customizable Sensitivity: The user can define how many candles to look at to the left and right (nLeft and nRight) to confirm these peaks. This allows the user to filter out minor market noise to find only significant structural turning points.
  • Filtering Mechanism: It includes a "filter" setting that creates a buffer zone, ensuring that price action must move significantly beyond the previous identified level before a new one is recognized.

2. Dynamic Support and Resistance Levels Once the script identifies these peaks and valleys, it establishes two primary dynamic levels:

  • Upper Level: A tracking line representing the ceiling of the current price movement.
  • Lower Level: A tracking line representing the floor of the current price movement. The script ensures that if a new peak or valley is found, the corresponding level "locks in" and carries forward until the market breaks through it.

3. Mathematical Subdivision Levels Beyond the main high and low levels, the script automatically calculates five additional internal subdivision levels between the ceiling and the floor. These are mathematically derived to represent specific ratios (e.g., 1/6, 1/3, 1/2, 2/3, and 5/6 of the distance between the two boundaries). This helps traders visualize the internal "zones" of a price range.

4. Automated Fibonacci Projection One of the most advanced features of this script is its ability to automatically identify and draw Fibonacci Fans.

  • Swing Detection: The logic scans back through the history to find the most significant recent high and low points (the "swing" points).
  • Fan Generation: It draws two distinct Fibonacci Fans based on these swing points.
    • The first fan is anchored to identify primary trend changes.
    • The second fan utilizes a secondary calculation to project deeper retracement levels.
  • Dynamic Updates: These fans are not static; they automatically reposition themselves as the market creates new significant highs or lows, providing a real-time map of potential support and resistance zones.

Summary of Visual Output

  • Support/Resistance Lines: Clearly marked lines showing the current price boundaries.
  • Subdivision Lines: A series of horizontal indicators showing internal price fractions.
  • Fibonacci Fans: Automatically drawn geometric shapes that highlight trend exhaustion and potential reversal areas based on recent market geometry.
Miscellaneous
Implements a curve of type %1
12 Views
0 Downloads
0 Favorites
rvmFractalsLevel_v3 
//+------------------------------------------------------------------+
//|                                             rvmFractalsLevel.mq4 |
//|                                        Copyright © 2005, Profi_R |
//|                                               rvm_fam@fromru.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, Profi_R"
#property link      "rvm_fam@fromru.com"
//----
#property indicator_chart_window
#property indicator_buffers 7
#property indicator_color1 DeepSkyBlue
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Black
#property indicator_color4 Black
#property indicator_color5 Black
#property indicator_color6 Black
#property indicator_color7 Black
#property indicator_color8 Black
//---- input parameters
extern int nLeft=50;
extern int nRight=50;
extern int filter=10;
//---- buffers
double UpBuffer[];
double DnBuffer[];
double f_2[];
double f_3[];
double f_4[];
double f_5[];
double f_6[];
//----
int draw_begin1=0, draw_begin2=0, d_b3=0;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   double nfUp;
//---- indicators
   IndicatorBuffers(8);
   SetIndexStyle(0,DRAW_LINE,0,3);
   SetIndexStyle(1,DRAW_LINE,0,3);
   SetIndexStyle(2,DRAW_LINE,2);
   SetIndexStyle(3,DRAW_LINE,2);
   SetIndexStyle(4,DRAW_LINE,2);
   SetIndexStyle(5,DRAW_LINE,2);
   SetIndexStyle(6,DRAW_LINE,2);
   SetIndexBuffer(0,UpBuffer);
   SetIndexBuffer(1,DnBuffer);
   SetIndexBuffer(2,f_2);
   SetIndexBuffer(3,f_3);
   SetIndexBuffer(4,f_4);
   SetIndexBuffer(5,f_5);
   SetIndexBuffer(6,f_6);
//---- name for DataWindow and indicator subwindow label
   string short_name; //îáÿâëåíèå ïåðåìåííîé short_name òèïà "ñòðîêîâûé"
   //ïåðåìåííîé short_name ïðèñâàèâàåì ñòðîêîâîå çíà÷åíèå ðàâíîå âûðàæåíèþ
   short_name="rvmFractalsLevel("+nLeft+","+nRight+","+filter+")";
   IndicatorShortName(short_name); //äëÿ îòîáðàæåíèÿ íà ãðàôèêå ïðèñâîèì èíäèêàòîðó êðàòêîå
   //íàèìåíîâàíèå
   //äëÿ îòîáðàæåíèÿ íà ãðàôèêå ïðèñâîèì ìåòêå îòîáðàæàþùåé çíà÷åíèÿ 0 áóôåðà èìÿ Up Channel
   SetIndexLabel(0,"Up Level ("+nLeft+","+nRight+","+filter+")");
   //äëÿ îòîáðàæåíèÿ íà ãðàôèêå ïðèñâîèì ìåòêå îòîáðàæàþùåé çíà÷åíèÿ 1 áóôåðà èìÿ Down Channel
   SetIndexLabel(1,"Down Level ("+nLeft+","+nRight+","+filter+")");
   SetIndexLabel(2,"f_2 ("+nLeft+","+nRight+","+filter+")");
   SetIndexLabel(3,"f_3 ("+nLeft+","+nRight+","+filter+")");
   SetIndexLabel(4,"f_4 ("+nLeft+","+nRight+","+filter+")");
   SetIndexLabel(5,"f_5 ("+nLeft+","+nRight+","+filter+")");
   SetIndexLabel(6,"f_6 ("+nLeft+","+nRight+","+filter+")");
//---- Çäåñü îïðåäåëèì íà÷àëüíûå òî÷êè äëÿ ïðîðèñîâêè èíäèêàòîðà
   int n,k,i,Range=nLeft+nRight+1;
   //ïåðåáåðåì ñâå÷êè îò (âñåãî ñâå÷åê ìèíóñ ìèíèìóì ñâå÷åê ñëåâà) äî (ìèíèìóì ñâå÷åê ñïðàâà)
   for(n=Bars-1-nLeft;n>=nRight;n--)
     {
      //âåðõíèå ôðàêòàëû
      //åñëè íà÷àëî îòðèñîâêè âåðõíåãî óðîâíÿ íå îïðåäåëåíî
      if(draw_begin1==0)
        {
         //òåêóùàÿ ñâå÷à ìàêñèìóì íà ëîêàëüíîì ïðîìåæóòêå?
         if(High[n]>=High[Highest(NULL,0,MODE_HIGH,Range,n-nRight)])
           {
            int fRange=nvnLeft(n,nLeft)+nvnRight(n,nRight)+1;
            //åñëè îíà æå - ôðàêòàë
            if(High[n]>=High[Highest(NULL,0,MODE_HIGH,fRange,n-nvnRight(n,nRight))])
              {
               draw_begin1=Bars-n;//íà÷àëî îòðèñîâêè âåðõíåãî óðîâíÿ îïðåäåëåíî
               for(i=Bars-1;i>draw_begin1;i--)
                 {
                  UpBuffer[i]=High[Bars-draw_begin1];
                 }
              }
           }//êîíåö äåéñòâèé åñëè if(High[n]>=High[Highest(NULL,0,MODE_HIGH,Range,n-nRight)]=èñòèíà
        }//êîíåö óñëîâèÿ if(draw_begin1==0)
      //íèæíèå ôðàêòàëû
      //åñëè íà÷àëî îòðèñîâêè íèæíåãî óðîâíÿ íå îïðåäåëåíî
      if(draw_begin2==0)
        {
         //òåêóùàÿ ñâå÷à ìèíèìóì íà ëîêàëüíîì ïðîìåæóòêå?
         if(Low[n]<=Low[Lowest(NULL,0,MODE_LOW,Range,n-nRight)])
           {
            fRange=nvnLeft(n,nLeft)+nvnRight(n,nRight)+1;
            //åñëè îíà æå - ôðàêòàë
            if(Low[n]<=Low[Lowest(NULL,0,MODE_HIGH,fRange,n-nvnRight(n,nRight))])
              {
               draw_begin2=Bars-n;//íà÷àëî îòðèñîâêè íèæíåãî óðîâíÿ îïðåäåëåíî
               for(i=Bars-1;i>draw_begin2;i--)
                 {
                  DnBuffer[i]=Low[Bars-draw_begin2];
                 }
              }
           }//êîíåö óñëîâèÿ if(Low[n]<=Low[Lowest(NULL,0,MODE_LOW,Range,n-nRight)])=true
        }//êîíåö óñëîâèÿ if(draw_begin2==0)
      //åñëè îáà íà÷àëà îòðèñîâêè óðîâíåé îïðåäåëåíû, âûõîäèì èç öèêëà for(n=Bars-1-nLeft;n>=nRight;n--)
      if(draw_begin1>0&&draw_begin2>0) break;
     }//êîíåö öèêëà for(n=Bars-1-nLeft;n>=nRight;n--)
//----
   if(draw_begin1>draw_begin2)
     {
      d_b3=draw_begin1;
     }
   else
     {
      d_b3=draw_begin2;
     }
   SetIndexDrawBegin(0,draw_begin1); //óñòàíîâêà íà÷àëüíîé òî÷êè ïðîðèñîâêè äëÿ 0 áóôåðà
   SetIndexDrawBegin(1,draw_begin2); //óñòàíîâêà íà÷àëüíîé òî÷êè ïðîðèñîâêè äëÿ 1 áóôåðà
   SetIndexDrawBegin(2,d_b3);
   SetIndexDrawBegin(3,d_b3);
   SetIndexDrawBegin(4,d_b3);
   SetIndexDrawBegin(5,d_b3);
   SetIndexDrawBegin(6,d_b3);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   double UpStage=0.0,DnStage=0.0;
   int i,j,fRange,Range=nLeft+nRight+1;
   int counted_bars=IndicatorCounted();
//---- 
   //ïåðåáèðàåì ñâå÷êè îò (Bars-counted_bars-nLeft) äî (nRight) âêëþ÷èòåëüíî
   for(i=Bars-1-counted_bars-nLeft;i>=nRight;i--)
     {
      //åñëè ñâå÷à ëîêàëüíûé ìàêñèìóì
      if(High[i]>=High[Highest(NULL,0,MODE_HIGH,Range,i-nRight)])
        {
         //Print(TimeToStr(Time[i]), "******Ëîêàëüíûé ìàêñèìóì");
         fRange=nvnLeft(i,nLeft)+nvnRight(i,nRight)+1;
         //åñëè îíà æå - ôðàêòàë
         if(High[i]>=High[Highest(NULL,0,MODE_HIGH,fRange,i-nvnRight(i,nRight))])
           {
            UpStage=High[i];
            //Print("    îíà æå ôðàêòàë");
           }
         else
           {
            if(High[i]<=UpBuffer[i+1])
              {
               UpStage=UpBuffer[i+1];
               //Print("    íå ôðàêòàë, íî íèæå ïðåäûäóùåãî óðîâíÿ");
              }
            else
              {
               UpStage=nfUp(i);
               //Print("    íå ôðàêòàë, âûøå ïðåäûäóùåãî óðîâíÿ");
              }
           }
        }
      else
        {
         //Print(TimeToStr(Time[i]), "******íå ëîêàëüíûé ìàêñèìóì");
         if(High[i]<=UpBuffer[i+1])
           {
            UpStage=UpBuffer[i+1];
            //Print("    íèæå ïðåäûäóùåãî óðîâíÿ");
           }
         else
           {
            UpStage=nfUp(i);
            //Print("    âûøå ïðåäûäóùåãî óðîâíÿ");
           }
        }
      //åñëè ñâå÷à ëîêàëüíûé ìèíèìóì
      if(Low[i]<=Low[Lowest(NULL,0,MODE_LOW,Range,i-nRight)])
        {
         fRange=nvnLeft(i,nLeft)+nvnRight(i,nRight)+1;
         //Print(TimeToStr(Time[i])," ",nvnLeft(i,nLeft)," ",nvnRight(i,nRight)+1);
         //åñëè îíà æå - ôðàêòàë
         if(Low[i]<=Low[Lowest(NULL,0,MODE_HIGH,fRange,i-nvnRight(i,nRight))])
           {
            DnStage=Low[i];
           }
         else
           {
            if(Low[i]>=DnBuffer[i+1])
              {
               DnStage=DnBuffer[i+1];
              }
            else
              {
               DnStage=nfDn(i);
              }
           }
        }
      else
        {
         if(Low[i]>=DnBuffer[i+1])
           {
            DnStage=DnBuffer[i+1];
           }
         else
           {
            DnStage=nfDn(i);
           }
        }
      UpBuffer[i]=UpStage;
      DnBuffer[i]=DnStage;
      //---- ðàñ÷åò îñòàëüíûõ áóôåðîâ
      f_2[i]=NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/6,4);
      f_3[i]=NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/3,4);
      f_4[i]=NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/2,4);
      f_5[i]=NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])*2/3,4);
      f_6[i]=NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])*5/6,4);
     }
     //êîíåö öèêëà for(i=Bars-counted_bars-nLeft;i>=nRight;i--)
   for(i=nRight-1;i>=0;i--)
     {
      if(High[i]<=UpBuffer[i+1])
        {
         UpStage=UpBuffer[i+1];
        }
      else
        {
         UpStage=nfUp(i);
        }
      if(Low[i]>=DnBuffer[i+1])
        {
         DnStage=DnBuffer[i+1];
        }
      else
        {
         DnStage=nfDn(i);
        }
      UpBuffer[i]=UpStage;
      DnBuffer[i]=DnStage;
      //---- ðàñ÷åò îñòàëüíûõ áóôåðîâ
      f_2[i] =NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/6,4);
      f_3[i] =NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/3,4);
      f_4[i] =NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])/2,4);
      f_5[i] =NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])*2/3,4);
      f_6[i] =NormalizeDouble(DnBuffer[i]+(UpBuffer[i]-DnBuffer[i])*5/6,4);
     }
//---- ïîñòðîåíèå âååðà Ôèáîíà÷÷è
   double LastUp, LastDn, st_h, st_l, st_3, y1, y2, y3;
   int tmp, x1=0, x2=0, x3=0, cb, dn_x, up_x;
   string fibo="Fibo 1", fibo2="Fibo 2";
   LastDn=DnBuffer[0];
   for(cb=1;cb<=Bars-1;cb++)
     {
      if(tmp!=1 && LastDn>DnBuffer[cb])
        {
         tmp=1;
         continue;
        }
      if(tmp==1 && DnBuffer[cb]>DnBuffer[cb-1])
        {
         tmp=0;
         dn_x=cb-1;
         break;
        }
     }
   LastUp=UpBuffer[0];
   for(cb=1;cb<=Bars-1;cb++)
     {
      if(tmp!=1 && LastUp<UpBuffer[cb])
        {
         tmp=1;
         continue;
        }
      if(tmp==1 && UpBuffer[cb]<UpBuffer[cb-1])
        {
         tmp=0;
         up_x=cb-1;
         break;
        }
     }
   st_h=High[Highest(NULL,0,MODE_HIGH,MathMax(dn_x,up_x),0)];
   st_l=Low[Lowest(NULL,0,MODE_LOW,MathMax(dn_x,up_x),0)];
   //y1=MathMin(Open[x1],Close[x1]);
   //y1=MathMax(Open[x1],Close[x1]);
   for(cb=MathMax(dn_x,up_x)-1;cb>=0;cb--)
     {
      if(High[cb]==st_h || Low[cb]==st_l)
        {
         if(High[cb]==st_h && (x1==0 || x2==0) )
           {
            if(x1==0)
              {
               x1=cb;
               y1=High[x1];
               continue;
              }
            else
              {
               x2=cb;
               y2=High[x2];
               break;
              }
           }
         else
           {
            if(x1==0)
              {
               x1=cb;
               y1=Low[x1];
               continue;
              }
            else
              {
               x2=cb;
               y2=Low[x2];
               break;
              }
           }
        }
     }
   //Print("x1="+x1+" y1="+y1+" x2="+x2+" y2="+y2);
   if(ObjectFind(fibo)!=-1 )
     {
      ObjectSet(fibo,OBJPROP_TIME1,Time[x1]);
      ObjectSet(fibo,OBJPROP_PRICE1,y1);
      ObjectSet(fibo,OBJPROP_TIME2,Time[x2]);
      ObjectSet(fibo,OBJPROP_PRICE2,y2);
     }
   else
     {
      ObjectCreate(fibo,OBJ_FIBOFAN,0,Time[x1],y1,Time[x2],y2);
      ObjectSet(fibo,OBJPROP_COLOR,DodgerBlue);
      ObjectSet(fibo,OBJPROP_STYLE,STYLE_DOT);
     }
//----- à ýòî îòðèñîâêà âñïîìîãàòåëüíîãî âååðà ôèáîíà÷÷è
   if(y2>y1)
     {
      st_3=Low[Lowest(NULL,0,MODE_LOW,x2,0)];
     }
   else
     {
      st_3=High[Highest(NULL,0,MODE_HIGH,x2,0)];
     }
   for(cb=0;cb<x2;cb++)
     {
      if(y2>y1 && Low[cb]==st_3)
        {
         x3=cb;
         y3=Low[cb];
         break;
        }
      else
        {
         if(y2<y1 && High[cb]==st_3)
           {
            x3=cb;
            y3=High[cb];
            break;
           }
        }
     }
   if(ObjectFind(fibo2)!=-1 )
     {
      ObjectSet(fibo2,OBJPROP_TIME1,Time[x2]);
      ObjectSet(fibo2,OBJPROP_PRICE1,y2);
      ObjectSet(fibo2,OBJPROP_TIME2,Time[x3]);
      ObjectSet(fibo2,OBJPROP_PRICE2,y3);
     }
   else
     {
      ObjectCreate(fibo2,OBJ_FIBOFAN,0,Time[x2],y2,Time[x3],y3);
      ObjectSet(fibo2,OBJPROP_COLOR,Yellow);
      ObjectSet(fibo2,OBJPROP_STYLE,STYLE_DOT);
     }
//----
   return(0);
  }
// Ôóíêöèÿ nfUp âîçâðàùàåò áëèæàéøåå ñëåâà ê ïåðåäàííîé ñâå÷å çíà÷åíèå áóôåðà 
// èíäèêàòîðà, áîëüøåå èëè ðàâíîå çíà÷åíèþ High(Close) äëÿ ïåðåäàííîé ñâå÷è   
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double nfUp(int i)
  {
   int l,flag=0;
   double Price=0.0;
//----------
   for(l=i+1;l<Bars-draw_begin1-1;l++)
     {
      if(filter>0)
        {
         if(Close[i]<=UpBuffer[l]+(UpBuffer[l]-DnBuffer[l])*filter/100)
           {
            Price=UpBuffer[l];
            flag=1;
            //Print(TimeToStr(Time[i])," ",l," ",Bars," ",Price," ",UpBuffer[l]);
           }
        }
      else
        {
         if(High[i]<=UpBuffer[l])
           {
            Price=UpBuffer[l];
            flag=1;
           }
        }
      if(Price>0) break;
     }
   if(flag==0) Price=High[i];
//----------
   return(Price);
  }
// Ôóíêöèÿ nfDn âîçâðàùàåò áëèæàéøåå ñëåâà ê ïåðåäàííîé ñâå÷å çíà÷åíèå áóôåðà
// èíäèêàòîðà, ìåíüøåå èëè ðàâíîå çíà÷åíèþ Low(Close) äëÿ ïåðåäàííîé ñâå÷è   
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double nfDn(int i)
  {
   int l,flag=0;
   double Price=0.0;
//----------
   for(l=i+1;l<Bars-draw_begin2-1;l++)
     {
      if(filter>0)
        {
         if(Close[i]>=DnBuffer[l]-(UpBuffer[l]-DnBuffer[l])*filter/100)
           {
            Price=DnBuffer[l];
            flag=1;
           }
        }
      else
        {
         if(Low[i]>=DnBuffer[l])
           {
            Price=DnBuffer[l];
            flag=1;
           }
        }
      if(Price>0) break;
     }
   if(flag==0) Price=Low[i];
//----------
   return(Price);
  }
// Ôóíêöèÿ âîçâðàùàåò äëÿ ïåðåäàííîé åé ñâå÷è, ìèíèìàëüíîå êîëè÷åñòâî ñâå÷åé ñëåâà         
// âêëþ÷àÿ "âíóòðåííèå", äëÿ òîãî, ÷òîáû ÷èñëî íå âíóòðåííèõ ñâå÷åé â ïîëó÷åííîì äèàïàçîíå 
// áûëî íå ìåíüøå, ÷åì óêàçàíî âî âòîðîì ïàðàìåòðå                                         
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int nvnLeft(int i,int n)
  {
   int k=0,l;
   for(l=i+1;l<=Bars-1;l++)
     {
      if(High[l]<High[l+1]&&Low[l]>Low[l+1]) continue;
      k++;
      if(k==n)
        {
         k=l-i;
         break;
        }
     }
//----------
   return(k);
  }
// Ôóíêöèÿ âîçâðàùàåò äëÿ ïåðåäàííîé åé ñâå÷è, ìèíèìàëüíîå êîëè÷åñòâî ñâå÷åé ñïðàâà        
// âêëþ÷àÿ "âíóòðåííèå", äëÿ òîãî, ÷òîáû ÷èñëî íå âíóòðåííèõ ñâå÷åé â ïîëó÷åííîì äèàïàçîíå 
// áûëî íå ìåíüøå, ÷åì óêàçàíî âî âòîðîì ïàðàìåòðå                                         
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int nvnRight(int i,int n)
  {
   int k=0,l;
   for(l=i-1;l>=0;l--)
     {
      if(High[l]<High[l+1]&&Low[l]>Low[l+1]) continue;
      k++;
      if(k==n)
        {
         k=i-l;
         break;
        }
     }
//----------
   return(k);
  }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   string fibo="Fibo 1", fibo2="Fibo 2";
   ObjectDelete(fibo);
   ObjectDelete(fibo2);
//----
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

rvmFractalsLevel_v1

This indicator identifies structural local extrema to project automated Fibonacci fan zones and dynamic supply-demand boundary levels based on price rejection mechanics.

FiboRetracement3_v1

This indicator identifies local structural extremes using fractal logic to dynamically plot overlapping Fibonacci retracement zones and multiple price level offsets.

FiboRetracement3

This indicator automatically identifies significant structural pivot points and plots dynamic Fibonacci retracement zones based on multi-fractal price extremes.

rvmFractalsLevel_v2

This indicator dynamically projects multi-level Fibonacci projection fans by identifying local fractal extremes and calculating harmonic price subdivisions.

FiboRetracement3_v2

This indicator identifies significant local extrema via fractal logic to automatically project multi-layered Fibonacci retracement levels based on dynamic price action pivots.

FiboRetracement3_002

This indicator identifies local price extremes using fractal logic to dynamically plot and update multi-stage Fibonacci retracement levels and support zones.

tradechannel

This indicator identifies dynamic support and resistance boundaries by detecting recursive fractal extrema and projecting segmented Fibonacci projection zones.

FIBONACCI RETRACMENT

The indicator identifies local price extremes using a fractal detection algorithm to dynamically project nested Fibonacci retracement zones and multi-stage price buffers.

tradechannel_v4

rvmFractalsLevel

This indicator identifies structural price extremes via recursive fractal analysis and automatically projects nested Fibonacci fans based on the most recent significant trend expansion.

FiboRetracement3_003

Comments