3_Level_ZZ_Semafor-NUM

Download script
Author: asystem2000
3_Level_ZZ_Semafor-NUM

This script is designed to function as a multi-layered trend identification tool. It visualizes price action on your trading chart by identifying significant "swing" points—specifically the peaks and valleys (highs and lows)—across three different time horizons simultaneously.

Core Functionality

The logic operates by scanning historical price data to find major structural turning points. Instead of showing every minor fluctuation, it filters out "noise" to highlight only the most significant movements. It achieves this through a multi-layered approach:

1. Multi-Timeframe Analysis The script calculates three distinct levels of trend data simultaneously. By allowing different "Periods" for each level, it enables you to see:

  • Short-term fluctuations: Small, immediate price movements.
  • Medium-term trends: The general flow of the current session or day.
  • Long-term structures: The overarching market direction over a larger timeframe.

2. Dynamic Filtering (ZigZag Logic) To ensure that only significant highs and lows are displayed, the script uses a "Deviation" and "Backstep" logic:

  • Deviation: This acts as a price threshold. A new peak or valley is only confirmed if the price moves by a specific minimum amount from the previous point. This prevents the tool from reacting to tiny, insignificant price ticks.
  • Backstep: This ensures that the points identified are "clean." It verifies that a high or low point remains the absolute highest or lowest over a specific number of preceding candles, ensuring the signal is structurally sound before it appears on your chart.

3. Automated Conflict Resolution The logic includes a "final cutting" process. This step compares the identified peaks and valleys to ensure they do not overlap in a way that contradicts the market structure. If a new high is found that supersedes a previous one within the same trend segment, the script automatically clears out the outdated point. This keeps the visual display clean and ensures that only the most relevant price targets are visible.

Visual Representation

The script translates these calculations into specific markers on your chart:

  • Color Coding: Each of the three levels is assigned a unique color (Chocolate, MediumVioletRed, and Yellow), allowing you to distinguish between different timeframes at a glance.
  • Arrow Markers: Highs and lows are represented by specific symbols (arrows) appearing on the chart.
    • Upward arrows indicate confirmed price peaks.
    • Downward arrows indicate confirmed price valleys.

Summary for the User

Essentially, this tool acts as a "structural map" of the market. It automatically filters out the minor "wiggles" of the price and draws lines between the significant mountains (highs) and valleys (lows) of the market. By viewing three levels at once, you can see where the immediate price action is moving relative to the larger, more established market trends.

Miscellaneous
Implements a curve of type %1
12 Views
0 Downloads
0 Favorites
3_Level_ZZ_Semafor-NUM 
//+------------------------------------------------------------------+ 
//|                                        3_Level_ZZ_Semafor.mq4    | 
//+------------------------------------------------------------------+ 
#property copyright "asystem2000" 
#property link      "asystem2000@yandex.ru" 

#property indicator_chart_window 
#property indicator_buffers 6
#property indicator_color1 Chocolate 
#property indicator_color2 Chocolate 
#property indicator_color3 MediumVioletRed
#property indicator_color4 MediumVioletRed
#property indicator_color5 Yellow
#property indicator_color6 Yellow

//---- input parameters 
extern double Period1=5; 
extern double Period2=13; 
extern double Period3=34; 
extern string   Dev_Step_1="1,3";
extern string   Dev_Step_2="8,5";
extern string   Dev_Step_3="13,8";
extern int Symbol_1_Kod=140;
extern int Symbol_2_Kod=141;
extern int Symbol_3_Kod=142;

//---- buffers 
double FP_BuferUp[];
double FP_BuferDn[]; 
double NP_BuferUp[];
double NP_BuferDn[]; 
double HP_BuferUp[];
double HP_BuferDn[]; 

int F_Period;
int N_Period;
int H_Period;
int Dev1;
int Stp1;
int Dev2;
int Stp2;
int Dev3;
int Stp3;

//+------------------------------------------------------------------+ 
//| Custom indicator initialization function                         | 
//+------------------------------------------------------------------+ 
int init() 
  { 
// --------- Êîððåêòèðóåì ïåðèîäû äëÿ ïîñòðîåíèÿ ÇèãÇàãîâ
   if (Period1>0) F_Period=MathCeil(Period1*Period()); else F_Period=0; 
   if (Period2>0) N_Period=MathCeil(Period2*Period()); else N_Period=0; 
   if (Period3>0) H_Period=MathCeil(Period3*Period()); else H_Period=0; 
   
//---- Îáðàáàòûâàåì 1 áóôåð 
   if (Period1>0)
   {
   SetIndexStyle(0,DRAW_ARROW,0,1); 
   SetIndexArrow(0,Symbol_1_Kod); 
   SetIndexBuffer(0,FP_BuferUp); 
   SetIndexEmptyValue(0,0.0); 
   
   SetIndexStyle(1,DRAW_ARROW,0,1); 
   SetIndexArrow(1,Symbol_1_Kod); 
   SetIndexBuffer(1,FP_BuferDn); 
   SetIndexEmptyValue(1,0.0); 
   }
   
//---- Îáðàáàòûâàåì 2 áóôåð 
   if (Period2>0)
   {
   SetIndexStyle(2,DRAW_ARROW,0,2); 
   SetIndexArrow(2,Symbol_2_Kod); 
   SetIndexBuffer(2,NP_BuferUp); 
   SetIndexEmptyValue(2,0.0); 
   
   SetIndexStyle(3,DRAW_ARROW,0,2); 
   SetIndexArrow(3,Symbol_2_Kod); 
   SetIndexBuffer(3,NP_BuferDn); 
   SetIndexEmptyValue(3,0.0); 
   }
//---- Îáðàáàòûâàåì 3 áóôåð 
   if (Period3>0)
   {
   SetIndexStyle(4,DRAW_ARROW,0,4); 
   SetIndexArrow(4,Symbol_3_Kod); 
   SetIndexBuffer(4,HP_BuferUp); 
   SetIndexEmptyValue(4,0.0); 

   SetIndexStyle(5,DRAW_ARROW,0,4); 
   SetIndexArrow(5,Symbol_3_Kod); 
   SetIndexBuffer(5,HP_BuferDn); 
   SetIndexEmptyValue(5,0.0); 
   }
// Îáðàáàòûâàåì çíà÷åíèÿ äåâèàöèé è øàãîâ
   int CDev=0;
   int CSt=0;
   int Mass[]; 
   int C=0;  
   if (IntFromStr(Dev_Step_1,C, Mass)==1) 
      {
        Stp1=Mass[1];
        Dev1=Mass[0];
      }
   
   if (IntFromStr(Dev_Step_2,C, Mass)==1)
      {
        Stp2=Mass[1];
        Dev2=Mass[0];
      }      
   
   
   if (IntFromStr(Dev_Step_3,C, Mass)==1)
      {
        Stp3=Mass[1];
        Dev3=Mass[0];
      }      
   return(0); 
  } 
//+------------------------------------------------------------------+ 
//| Custor indicator deinitialization function                       | 
//+------------------------------------------------------------------+ 
int deinit() 
  { 
//---- 
    
//---- 
   return(0); 
  } 

//+------------------------------------------------------------------+ 
//| Custom indicator iteration function                              | 
//+------------------------------------------------------------------+ 
int start() 
  { 
   if (Period1>0) CountZZ(FP_BuferUp,FP_BuferDn,Period1,Dev1,Stp1);
   if (Period2>0) CountZZ(NP_BuferUp,NP_BuferDn,Period2,Dev2,Stp2);
   if (Period3>0) CountZZ(HP_BuferUp,HP_BuferDn,Period3,Dev3,Stp3);
   return(0); 
  } 
//+------------------------------------------------------------------+ 
// äîïîëíèòåëüíûå ôóíêöèè
//int Take



//+------------------------------------------------------------------+ 
//| Ôóíêö ôîðìèðîâàíèÿ ÇèãÇàãà                        | 
//+------------------------------------------------------------------+  
int CountZZ( double& ExtMapBuffer[], double& ExtMapBuffer2[], int ExtDepth, int ExtDeviation, int ExtBackstep )
  {
   int    shift, back,lasthighpos,lastlowpos;
   double val,res;
   double curlow,curhigh,lasthigh,lastlow;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      val=Low[Lowest(NULL,0,MODE_LOW,ExtDepth,shift)];
      if(val==lastlow) val=0.0;
      else 
        { 
         lastlow=val; 
         if((Low[shift]-val)>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=ExtMapBuffer[shift+back];
               if((res!=0)&&(res>val)) ExtMapBuffer[shift+back]=0.0; 
              }
           }
        } 
        
          ExtMapBuffer[shift]=val;
      //--- high
      val=High[Highest(NULL,0,MODE_HIGH,ExtDepth,shift)];
      if(val==lasthigh) val=0.0;
      else 
        {
         lasthigh=val;
         if((val-High[shift])>(ExtDeviation*Point)) val=0.0;
         else
           {
            for(back=1; back<=ExtBackstep; back++)
              {
               res=ExtMapBuffer2[shift+back];
               if((res!=0)&&(res<val)) ExtMapBuffer2[shift+back]=0.0; 
              } 
           }
        }
      ExtMapBuffer2[shift]=val;
     }
   // final cutting 
   lasthigh=-1; lasthighpos=-1;
   lastlow=-1;  lastlowpos=-1;

   for(shift=Bars-ExtDepth; shift>=0; shift--)
     {
      curlow=ExtMapBuffer[shift];
      curhigh=ExtMapBuffer2[shift];
      if((curlow==0)&&(curhigh==0)) continue;
      //---
      if(curhigh!=0)
        {
         if(lasthigh>0) 
           {
            if(lasthigh<curhigh) ExtMapBuffer2[lasthighpos]=0;
            else ExtMapBuffer2[shift]=0;
           }
         //---
         if(lasthigh<curhigh || lasthigh<0)
           {
            lasthigh=curhigh;
            lasthighpos=shift;
           }
         lastlow=-1;
        }
      //----
      if(curlow!=0)
        {
         if(lastlow>0)
           {
            if(lastlow>curlow) ExtMapBuffer[lastlowpos]=0;
            else ExtMapBuffer[shift]=0;
           }
         //---
         if((curlow<lastlow)||(lastlow<0))
           {
            lastlow=curlow;
            lastlowpos=shift;
           } 
         lasthigh=-1;
        }
     }
  
   for(shift=Bars-1; shift>=0; shift--)
     {
      if(shift>=Bars-ExtDepth) ExtMapBuffer[shift]=0.0;
      else
        {
         res=ExtMapBuffer2[shift];
         if(res!=0.0) ExtMapBuffer2[shift]=res;
        }
     }
 }
  
int Str2Massive(string VStr, int& M_Count, int& VMass[])
  {
    int val=StrToInteger( VStr);
    if (val>0)
       {
         M_Count++;
         int mc=ArrayResize(VMass,M_Count);
         if (mc==0)return(-1);
          VMass[M_Count-1]=val;
         return(1);
       }
    else return(0);    
  } 
  
  
int IntFromStr(string ValStr,int& M_Count, int& VMass[])
  {
    
    if (StringLen(ValStr)==0) return(-1);
    string SS=ValStr;
    int NP=0; 
    string CS;
    M_Count=0;
    ArrayResize(VMass,M_Count);
    while (StringLen(SS)>0)
      {
            NP=StringFind(SS,",");
            if (NP>0)
               {
                 CS=StringSubstr(SS,0,NP);
                 SS=StringSubstr(SS,NP+1,StringLen(SS));  
               }
               else
               {
                 if (StringLen(SS)>0)
                    {
                      CS=SS;
                      SS="";
                    }
               }
            if (Str2Massive(CS,M_Count,VMass)==0) 
               {
                 return(-2);
               }
      }
    return(1);    
  }

Similar scripts

3_Level_ZZ_Semafor

This indicator identifies multi-layered price extremes by simultaneously calculating three distinct Fractal zones with independent deviation and backstep parameters to map structural pivot points.

3_Level_ZZ_Semafor_005

This indicator projects three independent fractal-based ZigZag paths with varying sensitivities to identify multi-layered structural price swings and trend reversals.

3_Level_ZZ_Semafor_008

This indicator identifies three distinct layers of market structural extremes by calculating multi-period fractal pivot points with dynamic deviation filtering.

3_Level_ZZ_Semafor_001

This indicator identifies multi-layered price action structures by overlaying three distinct fractal zones with variable deviation and backstep sensitivity to highlight structural shifts.

3_Level_ZZ_Semafor_011

This indicator identifies multi-layered fractal structural extremes by calculating three distinct levels of support and resistance zones based on variable depth, deviation, and backstep parameters.

3_Level_Semafor_V2

3_Level_ZZ_Semafor_AlertsS

3_Level_ZZ_Semafor_AlertsSM

3_Level_ZZ_Semafor_Alert

3_Level_ZZ_Semafor_TRO_MODIFIED_VERSION_fixed

3_Level_ZZ_Semafor_mod_of_tro_mod_Alert

Comments