Wie extrahiert man nur die vom Zickzack-Indikator extrahierten unteren Umkehrpunkte?

tao zemin. 2013.03.21 14:17

Sehr geehrte Damen und Herren, wie kann man den Code ändern, um nur die Tiefpunkte des Zickzack-Indikators anzuzeigen?

Der folgende Code unten kann erfolgreich die Tops extrahieren, die vom Zigzag-Indikator extrahiert werden.tops[] wurde als Indexpuffer in der init() -Funktion angegeben....Aber ist es möglich, nur die Böden des unteren Wendepunkts anzuzeigen, indem der vorletzte Parameter des iCustom-Aufrufs geändert wird? Wenn die Antwort nein ist, was sollte ich dann in der MT4-Plattform tun? Ich habe versucht, 0 und 2 als den vorletzten Parameter zu nehmen, aber das Ergebnis ist nicht i wanted....

Mein Code ist für Ihre Bequemlichkeit beigefügt. Und ich habe es so viel wie ich kann vereinfacht... Vielen Dank für Ihre Zeit und Überlegung.

int start()
{
  int counted_bars=IndicatorCounted();
  int limit=0;
  limit = Bars-counted_bars;
  
  for(int shift=limit-1;shift>=0;shift--)
  {
    tops[shift]=iCustom (NULL,0,"ZigZag", 12,5,3, 1, shift);
    if(tops[shift]>0.1) tops[shift]=tops[shift];
  }
  
  return(0);
}

Dateien:

zztrenddetectorfshowvbottoms.mq4 1 kb

Tjipke de Vries 2013.03.21 15:31 #1

wie der Vergleich

double K = iCustom(Symbol(),0,"zigzag",ExtDepth,ExtDeviation,ExtBackstep,0,i);
if (K==Low[i] && K>0)  //..low zigzag......

tao zemin. 2013.03.22 01:22 #2

deVries,

Vielen Dank für Ihre prompte Antwort. Meinen Sie damit, dass Sie einfach den vorletzten Parameter von iCustom auf 0 ändern? Ich habe dies bereits versucht. und das Ergebnis ist definitiv nicht das, was ich wollte...Um meine Frage klarer zu machen, zeige ich die beiden Abbildungen unten, um meine Frage zu illustrieren....

Abb. 1: Unerwünschte Tops werden angezeigt, obwohl ich nur die Botoms anzeigen möchte! Ich möchte alle unerwünschten Tops herausfiltern, wenn ich nur die Bottoms anzeigen möchte.

FIg2. Die gewünschten Oberteile werden ohne unerwünschte Unterteile angezeigt. Das ist das Ergebnis, das ich haben möchte.

Meine Frage lautet also: Ist es möglich, nur die unteren Punkte anzuzeigen, ohne die Punkte A/B/C/D/E anzuzeigen? Ich hoffe, ich habe meine Frage klar formuliert.....

Vielen Dank für Ihre schnelle Antwort....

Zickzack-Indikatoren [ARCHIV]Alle Fragen von Anfängern, Multi-Timeframe-Indikatoren

Tjipke de Vries 2013.03.22 08:49 #3

//+------------------------------------------------------------------+
//|                                                      Zigzag2.mq4 |
//|                 Copyright © 2005-2007, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, MetaQuotes Software Corp."
#property link      "http://www.metaquotes.net/"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_color2 Magenta
#property indicator_color3 LightSkyBlue


//---- indicator parameters
extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;
//---- indicator buffers
double ZigzagBuffer[];
double HighMapBuffer[];
double LowMapBuffer[];
int level=3; // recounting's depth 
bool downloadhistory=false;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   IndicatorBuffers(3);
//---- drawing settings
   SetIndexStyle(0,DRAW_SECTION);
   SetIndexStyle(1,DRAW_SECTION);   
   SetIndexStyle(2,DRAW_SECTION);   
//---- indicator buffers mapping
   SetIndexBuffer(0,ZigzagBuffer);
   SetIndexBuffer(1,HighMapBuffer);
   SetIndexBuffer(2,LowMapBuffer);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);   
   SetIndexEmptyValue(2,0.0);   

//---- indicator short name
   IndicatorShortName("ZigZag("+ExtDepth+","+ExtDeviation+","+ExtBackstep+")");
//---- initialization done
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int i, counted_bars = IndicatorCounted();
   int limit,counterZ,whatlookfor;
   int shift,back,lasthighpos,lastlowpos;
   double val,res;
   double curlow,curhigh,lasthigh,lastlow;

   if (counted_bars==0 && downloadhistory) // history was downloaded
     {
      ArrayInitialize(ZigzagBuffer,0.0);
      ArrayInitialize(HighMapBuffer,0.0);
      ArrayInitialize(LowMapBuffer,0.0);
     }
   if (counted_bars==0) 
     {
      limit=Bars-ExtDepth;
      downloadhistory=true;
     }
   if (counted_bars>0) 
     {
      while (counterZ<level && i<100)
        {
         res=ZigzagBuffer[i];
         if (res!=0) counterZ++;
         i++;
        }
      i--;
      limit=i;
      if (LowMapBuffer[i]!=0) 
        {
         curlow=LowMapBuffer[i];
         whatlookfor=1;
        }
      else
        {
         curhigh=HighMapBuffer[i];
         whatlookfor=-1;
        }
      for (i=limit-1;i>=0;i--)  
        {
         ZigzagBuffer[i]=0.0;  
         LowMapBuffer[i]=0.0;
         HighMapBuffer[i]=0.0;
        }
     }
      
   for(shift=limit; shift>=0; shift--)
     {
      val=Low[iLowest(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=LowMapBuffer[shift+back];
               if((res!=0)&&(res>val)) LowMapBuffer[shift+back]=0.0; 
              }
           }
        } 
      if (Low[shift]==val) LowMapBuffer[shift]=val; else LowMapBuffer[shift]=0.0;
      //--- high
      val=High[iHighest(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=HighMapBuffer[shift+back];
               if((res!=0)&&(res<val)) HighMapBuffer[shift+back]=0.0; 
              } 
           }
        }
      if (High[shift]==val) HighMapBuffer[shift]=val; else HighMapBuffer[shift]=0.0;
     }

   // final cutting 
   if (whatlookfor==0)
     {
      lastlow=0;
      lasthigh=0;  
     }
   else
     {
      lastlow=curlow;
      lasthigh=curhigh;
     }
   for (shift=limit;shift>=0;shift--)
     {
      res=0.0;
      switch(whatlookfor)
        {
         case 0: // look for peak or lawn 
            if (lastlow==0 && lasthigh==0)
              {
               if (HighMapBuffer[shift]!=0)
                 {
                  lasthigh=High[shift];
                  lasthighpos=shift;
                  whatlookfor=-1;
                  ZigzagBuffer[shift]=lasthigh;
                  res=1;
                 }
               if (LowMapBuffer[shift]!=0)
                 {
                  lastlow=Low[shift];
                  lastlowpos=shift;
                  whatlookfor=1;
                  ZigzagBuffer[shift]=lastlow;
                  res=1;
                 }
              }
             break;  
         case 1: // look for peak
            if (LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
              {
               ZigzagBuffer[lastlowpos]=0.0;
               lastlowpos=shift;
               lastlow=LowMapBuffer[shift];
               ZigzagBuffer[shift]=lastlow;
               res=1;
              }
            if (HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
              {
               lasthigh=HighMapBuffer[shift];
               lasthighpos=shift;
               ZigzagBuffer[shift]=lasthigh;
               whatlookfor=-1;
               res=1;
              }   
            break;               
         case -1: // look for lawn
            if (HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
              {
               ZigzagBuffer[lasthighpos]=0.0;
               lasthighpos=shift;
               lasthigh=HighMapBuffer[shift];
               ZigzagBuffer[shift]=lasthigh;
              }
            if (LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
              {
               lastlow=LowMapBuffer[shift];
               lastlowpos=shift;
               ZigzagBuffer[shift]=lastlow;
               whatlookfor=1;
              }   
            break;               
         default: return; 
        }
     }

   return(0);
  }
//+------------------------------------------------------------------+

Es war möglich, nur den Zickzack-Puffer anzuzeigen

Zickzack wird neu gemalt

siehe Ergebnis

Ubzen 2013.03.22 09:08 #4

Hier ist, was ich herausgefunden habe. Ich habe deVries Ergebnisse oben nicht überprüft [ich tat dies, als er gepostet hat].

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_width1 1
#property indicator_color2 Yellow
#property indicator_width2 1

double Bottoms[];
double Toppers[];

int init()
{

   IndicatorBuffers(2);

   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,Bottoms);
   SetIndexEmptyValue(0,0.0);

   SetIndexStyle(1,DRAW_SECTION);
   SetIndexBuffer(1,Toppers);
   SetIndexEmptyValue(1,0.0);

  IndicatorShortName("zz show top & bottom");
  return(0);
}

int deinit()
{
  return(0);
}

int start()
{
  int counted_bars=IndicatorCounted();
  int limit=0;
  limit = Bars-counted_bars;
  
  for(int shift=limit-1;shift>=0;shift--)
  {
    int ExtDepth=12; int ExtDeviation=5; int ExtBackstep=3;
    int ZigzagBuffer=0; int HighMapBuffer=1; int LowMapBuffer=2;
    
    Bottoms[shift]=iCustom(
        Symbol(),0,"ZigZag",
        ExtDepth, ExtDeviation, ExtBackstep,
        LowMapBuffer, shift
    );
    
    Toppers[shift]=iCustom(
        Symbol(),0,"ZigZag",
        ExtDepth, ExtDeviation, ExtBackstep,
        HighMapBuffer, shift
    );
    
    if(Bottoms[shift]>0.1) Bottoms[shift]=Bottoms[shift];
    if(Toppers[shift]>0.1) Toppers[shift]=Toppers[shift];
  }
  
  return(0);
}

Tjipke de Vries 2013.03.22 10:02 #5

ubzen:

Hier ist, was ich herausgefunden habe. Ich habe deVries Ergebnisse oben nicht überprüft [ich tat dies, als er gepostet hat].

Nizza ubzen mit Hilfe von Ihrem Code kam ich zu diesem......

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_width1 3
#property indicator_color2 Green
#property indicator_width2 3
#property indicator_color3 Yellow
#property indicator_width3 3


//---- indicator parameters
extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;


double ZigZag[];
double Bottoms[];
double Toppers[];

int init()
{
   IndicatorBuffers(3);

   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,ZigZag);
   SetIndexEmptyValue(0,0.0);
   
   SetIndexStyle(1,DRAW_SECTION);
   SetIndexBuffer(1,Bottoms);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_SECTION);
   SetIndexBuffer(2,Toppers);
   SetIndexEmptyValue(2,0.0);

  IndicatorShortName("zz show top & bottom");
  return(0);
}

int deinit()
{
  return(0);
}

int start()
{
  int counted_bars=IndicatorCounted();
  int limit=0;
  limit = Bars-counted_bars;
  
  for(int shift=limit-1;shift>=0;shift--)
  {
    ZigZag[shift]=iCustom(
        Symbol(),0,"ZigZag",
        ExtDepth, ExtDeviation, ExtBackstep,
        0, shift
    );

    if(ZigZag[shift]>0.1 && Low[shift]==ZigZag[shift]) Bottoms[shift]=ZigZag[shift];
    if(ZigZag[shift]>0.1 && High[shift]==ZigZag[shift]) Toppers[shift]=ZigZag[shift];
  }
  
  return(0);
}

Dies ist das Ergebnis

jetzt stimmen unten und oben alle mit Zickzack überein

Ubzen 2013.03.22 10:22 #6

deVries: Niceubzen mit Hilfe Ihres Codes kam ich zu diesem...... Dies gibt als Ergebnis

Gute ArbeitdeVries.

tao zemin. 2013.03.24 02:35 #7

Liebe alle, mit eurer Hilfe und Freundlichkeit, besonders von deVries und Ubzen, hat mein Indikator erfolgreich das Bild gezeichnet, das die vom Zickzack-Indikator extrahierten Bodenumkehrpunkte in diesem fröhlichen Vorfrühling verbindet....:)

jackprobe 2013.10.19 08:47 #8

deVries:

Nice ubzen mit Hilfe Ihres Codes kam ich zu diesem......

Das gibt als Ergebnis

jetzt passen unten und oben alle mit Zickzack

Hallo deVries,

vielen Dank für Ihren Code. Wenn ich wissen möchte, wie weit das Fibonacci Retracement des letzten Zickzackschenkels im Vergleich zum vorherigen Zickzackschenkel ist. Wie kann man das machen?

Ich möchte wie das Bild zu tun, aber der Code unten, dass ich versuchte, machte es nicht ...

Danke!

Buchse

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Red
#property indicator_width1 3
#property indicator_color2 Green
#property indicator_width2 3
#property indicator_color3 Yellow
#property indicator_width3 3


//---- indicator parameters
extern int ExtDepth=12;
extern int ExtDeviation=5;
extern int ExtBackstep=3;


double ZigZag[];
double Bottoms[];
double Toppers[];
double resBuffer[][];

//---
int init() {
   IndicatorBuffers(3);

   SetIndexStyle(0,DRAW_SECTION);
   SetIndexBuffer(0,ZigZag);
   SetIndexEmptyValue(0,0.0);
   
   SetIndexStyle(1,DRAW_SECTION);
   SetIndexBuffer(1,Bottoms);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_SECTION);
   SetIndexBuffer(2,Toppers);
   SetIndexEmptyValue(2,0.0);

  IndicatorShortName("zz show top & bottom");
  return(0);
}

int deinit()
{
  ObjectDelete("myFibo");
  return(0);
}

int start()
{
  int counted_bars=IndicatorCounted();
  int limit=0;
  limit = Bars-counted_bars;
  int k=0, m=0;
  int candle1=0, candle2=0;
  double prc1=0, prc2=0;
  
  for(int shift=limit-1;shift>=0;shift--) {
    ZigZag[shift]=iCustom(
        Symbol(),0,"ZigZag",
        ExtDepth, ExtDeviation, ExtBackstep,
        0, shift
    );

    if(ZigZag[shift]>0.1 && Low[shift]==ZigZag[shift]) {
      Bottoms[shift]=ZigZag[shift];
      resBuffer[k][0] = Bottoms[shift];
      resBuffer[k][1] = shift;
      k++;
    }
    if(ZigZag[shift]>0.1 && High[shift]==ZigZag[shift]) {
      Toppers[shift]=ZigZag[shift];
      resBuffer[k][0] = Toppers[shift];
      resBuffer[k][1] = shift;
      k++;
    }
  } // ende for
  
  //---
  for(m=k;m>=0;m--) {
   candle1 = resBuffer[m][1];
   prc1 = resBuffer[m][0];
   candle2 = resBuffer[m-1][1];
   prc2 = resBuffer[m-1][0];
   //---
         ObjectDelete("myFibo");
         ObjectCreate("myFibo", OBJ_FIBO, 0, Time[candle1], prc2, Time[candle2], prc1);
 
  } // ende for
          
  return(0);
}

Hilfe bei der Codierung Besteht ein Bedarf an Wie programmiert man?

Tjipke de Vries 2013.10.19 09:29 #9

jackprobe:

Hallo deVries,

vielen Dank für Ihren Code. Wenn ich wissen möchte, wie weit das Fibonacci Retracement des letzten Zickzackbeines im Vergleich zum vorherigen Zickzackbein ist. Wie kann man das machen?

Danke!

jack

Zeichnen Sie Fibonacci auf diese Weise finden Sie die beiden Punkte mit Zickzack-Indikator iCustom

0.0 1.6154

100.0 1.6168

Differenz 0,0014

letzter Höchststand = 1,6169

Differenz mit 0.0 0.0015 in% 0.0015/0.0014 * 100% = 107% im Abstand + 0.0001

Ist es das, was Sie meinen?

How to extract only Zickzack-Indikatoren Korrekte Berechnung von Währungsindizes.

jackprobe 2013.10.19 09:50 #10

Hallo deVries,

vielen Dank. Ja, es ist wie das Bild, das du geschickt hast. Aber ich möchte wissen, wie man es codiert. Es muss jedes vorherige Zigzag Bein berechnen, und dann das Fibonacci Level zeichnen, damit wir wissen, wie weit das aktuelle / letzte Zigzag geht.

edit: Ich habe den Code im vorherigen Posting gesendet. Es würde nicht zeichnen die Fibo-Linie ...

Danke

Elite-Indikatoren :) Wie programmiert man? Multi-Timeframe-Indikatoren

1 2 3

Neuer Kommentar