Zum Inhalt

Chartobjekte und Zeichnungen

Chartobjekte (Zeichnungen) ermöglichen das Zeichnen von Linien oder geometrischen Formen auf cTrader-Charts. Durch ihre Verwendung können Sie Muster zeichnen oder bestimmte Ereignisse auf Charts basierend auf Ihren cBot- oder Indikatordaten anzeigen.

Chartobjekte verwenden X- und Y-Koordinaten zur Positionierung.

  • Die X-Achse repräsentiert die Chartzeit oder Balkenindizes.
  • Die Y-Achse ist der Symbolkurs.

Alle Chartobjekte werden von der Basisklasse ChartObject abgeleitet, was bedeutet, dass alle von ihnen bestimmte Basisfunktionen erben.

Codebeispiele für Chartobjekte

Innerhalb von Indikatorfenstern zeichnen

Beim Erstellen von Chartobjekten sind Sie nicht auf den Hauptsymbolchart beschränkt. Tatsächlich können Sie Chartobjekte in allen Fenstern zeichnen, die Indikatorausgaben enthalten.

Die Klasse Chart verfügt über die Sammlung IndicatorAreas. Sie enthält alle nicht überlagerten oder separaten Fenster, in denen Indikatoren ihre Ausgaben anzeigen können.

Sie können auch auf Ihren aktuellen Indikatorbereich zugreifen, indem Sie die Eigenschaft IndicatorArea Ihrer Klasse Indicator verwenden.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = false, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            var verticalLine = IndicatorArea.DrawVerticalLine("line", Chart.LastVisibleBarIndex, Color.Red);
        }

        public override void Calculate(int index)
        {
        }
    }
}

Wenn Sie eine Instanz des obigen Indikators ausführen, sollten Sie eine rote Linie in einem separaten Indikatorfenster sehen. Beim Erstellen von Charts in separaten Indikatorbereichen können Sie alle Zeichenmethoden verwenden, da sowohl Chart als auch IndicatorArea von der Basisklasse ChartArea erben.

Statischer Text

Anstatt X- und Y-Koordinaten für die Positionierung zu verwenden, verwendet statischer Text statische horizontale und vertikale Ausrichtungen. Um einen statischen Text anzuzeigen oder zu zeichnen, verwenden Sie die Methode DrawStaticText().

1
var staticText = Chart.DrawStaticText("static", "This is the text that will be shown", VerticalAlignment.Center, HorizontalAlignment.Center, Color.Red);

Wenn Sie dieses Chartobjekt an einen Indikator anhängen und eine Instanz ausführen, sehen Sie den folgenden Text im Hauptchart.

Image title

Vertikale Linie

Verwenden Sie die Methode DrawVerticalLine(), um eine vertikale Linie zu zeichnen.

1
2
3
var verticalLine = Chart.DrawVerticalLine("line", Chart.LastVisibleBarIndex, Color.Red);
// Or
var verticalLine = Chart.DrawVerticalLine("line", Bars.OpenTimes[Chart.LastVisibleBarIndex], Color.Red);

Horizontale Linie

Verwenden Sie die Methode DrawHorizontalLine(), um eine horizontale Linie zu zeichnen.

1
2
3
/* We use the maximum of the high prices
of the last ten bars as the Y coordinate. */ 
var horizontalLine = Chart.DrawHorizontalLine("line", Bars.HighPrices.Maximum(10), Color.Red);

Trendlinie

Eine Trendlinie beginnt an einem bestimmten Punkt im Chart und endet an einem anderen Punkt. Trendlinien sind nützlich zum Erstellen verschiedener Formen oder komplexer Muster.

Um eine Trendlinie zu zeichnen, verwenden Sie die Methode DrawTrendLine().

1
2
3
4
5
6
7
/* We draw a line from the low price
 of the first visible bar to the high price
 of the last visible bar on the chart. */
var trendLine = Chart.DrawTrendLine("line", Chart.FirstVisibleBarIndex, Bars.LowPrices[Chart.FirstVisibleBarIndex], Chart.LastVisibleBarIndex, Bars.HighPrices[Chart.LastVisibleBarIndex], Color.Red);

// Alternatively, consider the following.
var trendLine = Chart.DrawTrendLine("line", Bars.OpenTimes[Chart.FirstVisibleBarIndex], Bars.LowPrices[Chart.FirstVisibleBarIndex], Bars.OpenTimes[Chart.LastVisibleBarIndex], Bars.HighPrices[Chart.LastVisibleBarIndex], Color.Red);

Rechteck

Verwenden Sie die Methode DrawRectangle(), um ein Rechteck zu zeichnen.

1
2
3
4
5
6
7
var rectangle = Chart.DrawRectangle("rectangle", Chart.FirstVisibleBarIndex + 1, Bars.LowPrices[Chart.FirstVisibleBarIndex + 1], Chart.LastVisibleBarIndex, Bars.HighPrices[Chart.LastVisibleBarIndex], Color.Red);

/* We fill the rectangle with a transparent color.
By using its current color, we only change the alpha
channel. */
rectangle.IsFilled = true;
rectangle.Color = Color.FromArgb(80, rectangle.Color);

Dreieck

Verwenden Sie die Methode DrawTriangle(), um ein Dreieck zu zeichnen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
var middleX = Chart.FirstVisibleBarIndex + (Chart.LastVisibleBarIndex - Chart.FirstVisibleBarIndex) / 2;
var middleY = Bars.LowPrices[Chart.FirstVisibleBarIndex] + (Bars.HighPrices[Chart.LastVisibleBarIndex] - Bars.LowPrices[Chart.FirstVisibleBarIndex]) / 2;

var triangle = Chart.DrawTriangle("triangle", Chart.FirstVisibleBarIndex, Bars.LowPrices[Chart.FirstVisibleBarIndex], middleX, middleY, Chart.LastVisibleBarIndex, Bars.LowPrices[Chart.FirstVisibleBarIndex], Color.Red);

// We fill the triangle with a transparent color
// by using it's current color, we change only the alpha channel

/* We fill the triangle with a transparent color.
By using its current color, we only change the alpha
channel. */
triangle.IsFilled = true;
triangle.Color = Color.FromArgb(80, triangle.Color);

Andere Chartobjekte

Der Kürze halber haben wir in den obigen Codeausschnitten mehrere andere Chartobjekte nicht erwähnt. Zu diesen Objekten gehören unter anderem die folgenden:

  • Ellipse
  • Icon
  • Andrews Pitchfork
  • Equidistant Channel
  • Fibonacci Expansion
  • Fibonacci Fan
  • Fibonacci Retracement

Alle diese Objekte können mit ähnlich benannten Methoden Draw...() gezeichnet werden, die ähnliche Parameter akzeptieren.

Chance-Risiko-Verhältnis

Die Schnittstelle ChartRiskReward bietet Typen, mit denen Sie Chance-Risiko-Verhältnis-Objekte programmgesteuert auf Charts erstellen und verwalten können.

Der folgende Code zeigt Ihnen, wie Sie einen Indikator erstellen, der ein Chance-Risiko-Verhältnis-Objekt zeichnet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
using System;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo
{
    [Indicator(AccessRights = AccessRights.None, IsOverlay = true)]
    public class SimpleRiskReward : Indicator
    {
        protected override void Initialize()
        {
            var type = new ChartRiskRewardFixedRiskType(
                ChartRiskRewardAmountType.BalancePercentage, 
                1                                            
            );
            var tradeType = TradeType.Buy;
            var orderType = OrderType.Market;

            var entryPrice = Chart.Bars.LastBar.Close;
            var time1 = Chart.LastVisibleBarIndex - 20; 
            var time2 = Chart.LastVisibleBarIndex;      

            var rr = Chart.DrawRiskReward(
                "SimpleRR",     
                time1,           
                time2,            
                entryPrice,       
                orderType,        
                tradeType,        
                type              
            );

            rr.IsInteractive = true;

            rr.RiskColor = Color.Yellow;
            rr.RiskLineStyle = LineStyle.DotsRare;
            rr.RiskThickness = 3;

            rr.RewardColor = Color.Blue;
            rr.RewardLineStyle = LineStyle.LinesDots;
            rr.RewardThickness = 2;

            PrintRRInfo(rr);
        }

        private void PrintRRInfo(ChartRiskReward rr)
        {
            Print($"Name: {rr.Name} | Type: {rr.Type.GetType().Name} | Order Type: {rr.OrderType} | Trade Type: {rr.TradeType} | Time 1: {rr.Time1:o} | Time 2: {rr.Time2:o} | Entry: {rr.EntryPrice} | SL: {rr.StopLossPrice} | TP: {rr.TakeProfitPrice} | RR: {rr.RiskRewardRatio} | Volume: {rr.VolumeInUnits}");
        }

        public override void Calculate(int index)
        {
        }
    }
}

Wichtige Objekteinstellungen

Benennung von Chartobjekten

Immer wenn Sie versuchen, ein Chartobjekt zu zeichnen, müssen Sie dessen Namen als Argument für die Zeichenmethode angeben.

Alle Chartobjektnamen müssen eindeutig sein. Wenn diese Anforderung nicht erfüllt ist, riskieren Sie, dass Chartobjekte andere Chartobjekte mit denselben Namen überschreiben, abhängig von deren Ausführungszeiten. Sie können den aktuellen Balkenindexwert oder die aktuelle Zeit verwenden, um eindeutige Namen für jedes Objekt zu generieren.

Zugriff auf Chartobjekte

Alle Chartobjekte sind in der Sammlung Objects enthalten. Diese Sammlung umfasst vom Benutzer gezeichnete Objekte. Daher kann auf die Sammlung Objects zugegriffen werden, um Objekte aus Charts zu entfernen oder deren Eigenschaften zu ändern.

Das folgende Beispiel greift auf die Mitglieder der Sammlung Objects zu:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
using cAlgo.API;
using System.Linq;
namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            foreach (var chartObject in Chart.Objects)
            {
                /* If the object is a trend line 
                we change its Y1/2 properties */
                if (chartObject is ChartTrendLine trendLine)
                {
                    trendLine.Y1 = Chart.BottomY;
                    trendLine.Y2 = Chart.TopY;
                }
            }

            /* Here, we filter all objects of the 'ChartRectangle'
            type. */
            var rectangles = from chartObject in Chart.Objects
                             where chartObject is ChartRectangle
                             select chartObject as ChartRectangle;

            /* We select only the chart objects with a name that
            begins with "MyObjects". */
            var myObjects = from chartObject in Chart.Objects
                            where chartObject.Name.StartsWith("MyObjects", System.StringComparison.OrdinalIgnoreCase)
                            select chartObject;

            /* We select only interactive objects. If an object
            is interactive, it will not be removed when the 
            indicator is removed or reloaded. */
            var interactiveObjects = from chartObject in Chart.Objects
                                     where chartObject.IsInteractive
                                     select chartObject;

            /* We remove all objects with a name 
            that begins with "ToRemove". */
            var chartObjectsCopy = Chart.Objects.ToArray();

            foreach (var chartObject in chartObjectsCopy)
            {
                if (chartObject.Name.StartsWith("ToRemove", System.StringComparison.OrdinalIgnoreCase))
                {
                    /* Chart 'RemoveObject' gets the object name
                    as a parameter. */
                    Chart.RemoveObject(chartObject.Name);
                }

            }
        }

        public override void Calculate(int index)
        {
        }
    }
}

Ereignisse

Chartobjekte verfügen über mehrere Ereignisse, mit denen Sie erfahren können, welche Objekte gezeichnet, aktualisiert oder entfernt werden:

  • ObjectsAdded – wird ausgelöst, wenn ein oder mehrere Chartobjekte zu einem Chart hinzugefügt werden.
  • ObjectsRemoved – wird ausgelöst, wenn ein oder mehrere Chartobjekte aus einem Chart entfernt werden.
  • ObjectsUpdated – wird ausgelöst, wenn ein oder mehrere Chartobjekte aktualisiert werden (eine ihrer Eigenschaften wird vom Benutzer oder dem aktiven Indikator oder cBot geändert).
  • ObjectsSelectionChanged – wird ausgelöst, wenn ein oder mehrere Chartobjekte vom Benutzer ausgewählt werden.
  • ObjectHoverChanged – wird ausgelöst, wenn der Mauszeiger über ein Chartobjekt schwebt.

Das folgende Beispiel verwendet alle fünf Ereignistypen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            Chart.ObjectsAdded += Chart_ObjectsAdded;
            Chart.ObjectsRemoved += Chart_ObjectsRemoved;
            Chart.ObjectsUpdated += Chart_ObjectsUpdated;
            Chart.ObjectsSelectionChanged += Chart_ObjectsSelectionChanged;
            Chart.ObjectHoverChanged += Chart_ObjectHoverChanged;
        }

        private void Chart_ObjectHoverChanged(ChartObjectHoverChangedEventArgs obj) => throw new System.NotImplementedException();

        private void Chart_ObjectsSelectionChanged(ChartObjectsSelectionChangedEventArgs obj) => throw new System.NotImplementedException();

        private void Chart_ObjectsUpdated(ChartObjectsUpdatedEventArgs obj) => throw new System.NotImplementedException();

        private void Chart_ObjectsRemoved(ChartObjectsRemovedEventArgs obj) => throw new System.NotImplementedException();

        private void Chart_ObjectsAdded(ChartObjectsAddedEventArgs obj) => throw new System.NotImplementedException();

        public override void Calculate(int index)
        {
        }
    }
}

Interaktive und nicht interaktive Objekte

Bei der Arbeit mit interaktiven Objekten können Benutzer deren Eigenschaften wie Objektposition, Farbe, Kommentar usw. ändern. Alle vom Benutzer gezeichneten Objekte sind standardmäßig interaktiv.

Hinweis

Die Eigenschaft ChartStaticText kann nicht geändert werden, unabhängig davon, ob das zugehörige Objekt interaktiv ist.

Um ein Objekt interaktiv zu machen, setzen Sie dessen Eigenschaft IsInteractive auf true, wie unten gezeigt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            var verticalLine = Chart.DrawVerticalLine("line", Chart.LastVisibleBarIndex, Color.Red);

            verticalLine.IsInteractive = true;
        }

        public override void Calculate(int index)
        {
        }
    }
}

Alle Chartobjekte verfügen über die Eigenschaft IsInteractive. Ihr Standardwert ist false.

Wenn ein Chartobjekt interaktiv ist, wird es nicht entfernt, wenn eine Indikator- oder cBot-Instanz entfernt oder gestoppt wird. Im Gegensatz dazu werden nicht interaktive Objekte automatisch entfernt, wenn ein Indikator oder cBot nicht mehr funktioniert.

Um Unordnung zu vermeiden, stellen Sie sicher, dass Sie interaktive Objekte nach dem Entfernen der zugehörigen Instanz bereinigen, indem Sie die Methode Destroy des Indikators oder die Methode OnStop des cBots verwenden.

Wenn ein Chartobjekt nicht interaktiv ist, ist es auch in Listen und Sammlungen von Chartobjekten unsichtbar.

Gesperrte und entsperrte Objekte

Das Sperren eines Chartobjekts verhindert, dass der Benutzer es ändert oder aktualisiert. Sie können dies über das Feld „Trader" (Chart-Eigenschaften) tun oder indem Sie die Eigenschaft IsLocked auf true setzen. Der Standardwert ist false.

Sie können die Sperrung verwenden, um ein Objekt interaktiv zu machen, aber gleichzeitig zu verhindern, dass der Benutzer es aktualisiert. Das folgende Beispiel sperrt ein vertikales Linienobjekt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            var verticalLine = Chart.DrawVerticalLine("line", Chart.LastVisibleBarIndex, Color.Red);

            verticalLine.IsLocked = true;
        }

        public override void Calculate(int index)
        {
        }
    }
}

Anzeigen und Ausblenden

Sie können ein Objekt auf dem Chart zeichnen und es anschließend ausblenden. Während das Objekt weiterhin auf dem Chart vorhanden ist, wird es vollständig unsichtbar sein.

Setzen Sie dazu die Eigenschaft IsHidden auf true.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            var verticalLine = Chart.DrawVerticalLine("line", Chart.LastVisibleBarIndex, Color.Red);

            verticalLine.IsHidden = true;
        }

        public override void Calculate(int index)
        {
        }
    }
}

Die Ressourcennutzung ist die primäre Überlegung für die Verwendung dieser Funktion. Wenn es ein Objekt gibt, das häufig im Chart erscheinen sollte (aber nicht die ganze Zeit), ist es besser, es zu verbergen, anstatt es jedes Mal zu entfernen und neu zu zeichnen, wenn es benötigt wird.

Objektauswahl und Erscheinungsindex (ZIndex)

Natürlich kann es Fälle geben, in denen sich mehrere Objekte in einem Chart überschneiden, wodurch die Auswahl eines bestimmten Objekts schwierig oder geradezu unmöglich wird. Nur das Objekt, das zuletzt gezeichnet wurde, kann ausgewählt werden, wenn Sie Ihren Mauszeiger über eine Gruppe sich überschneidender Chartobjekte bewegen.

Um dieses Verhalten zu ändern, können Sie die Eigenschaft ZIndex verwenden. Sie kann hilfreich sein, wenn Sie versuchen, komplexe Muster von Chartobjekten anzuzeigen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        protected override void Initialize()
        {
            var firstVerticalLine = Chart.DrawVerticalLine("line1", Chart.LastVisibleBarIndex, Color.Red);

            firstVerticalLine.IsInteractive = true;

            var secondVerticalLine = Chart.DrawVerticalLine("line2", Chart.LastVisibleBarIndex, Color.Yellow);

            secondVerticalLine.IsInteractive = true;

            firstVerticalLine.ZIndex = secondVerticalLine.ZIndex + 1;
        }

        public override void Calculate(int index)
        {
        }
    }
}

Sobald der obige Indikator an ein Chart angehängt wird, zeigt er eine rote vertikale Linie anstelle einer gelben an. Da der Wert der Eigenschaft ZIndex der ersten Linie höher ist als der entsprechende Wert der zweiten Linie, hat sie Vorrang vor der zweiten (gelben) Linie.

Mit anderen Worten: Die Eigenschaft ZIndex bestimmt, welche Chartobjekte zuerst angezeigt werden, wenn sie sich überlappen. Allen gezeichneten Chartobjekten wird automatisch ein bestimmter Wert für die Eigenschaft ZIndex zugewiesen.

Wissen, ob ein Objekt entfernt wurde

Alle Chartobjekte erben die Eigenschaft IsAlive von der Basisklasse ChartObject. Der Wert dieser Eigenschaft ist true, solange ein Objekt im Chart vorhanden ist (unabhängig davon, ob es sichtbar oder unsichtbar ist). Der Wert wird auf false gesetzt, sobald ein Objekt aus dem Chart entfernt wird.

Wenn Sie eine Referenz zu einem Chartobjekt speichern und dieses Objekt vom Benutzer entfernt wird, können Sie die Eigenschaft IsAlive überprüfen, um festzustellen, ob ein Objekt aktiv oder inaktiv ist.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using cAlgo.API;

namespace NewIndicator
{
    [Indicator(IsOverlay = true, AccessRights = AccessRights.None)]
    public class NewIndicator : Indicator
    {
        private ChartVerticalLine _verticalLine;

        protected override void Initialize()
        {
            _verticalLine = Chart.DrawVerticalLine("line1", Chart.LastVisibleBarIndex, Color.Red);
            _verticalLine.IsInteractive = true;

            Chart.ObjectsRemoved += Chart_ObjectsRemoved;

            Print(_verticalLine.IsAlive);
        }

        private void Chart_ObjectsRemoved(ChartObjectsRemovedEventArgs obj)
        {
            Print(_verticalLine.IsAlive);

            /* If the object is removed, we should rid of its
            reference. Otherwise, it will remain in memory. */
            if (_verticalLine.IsAlive is false)
            {
                _verticalLine = null;

                Print("Object reference removed");
            }
        }

        public override void Calculate(int index)
        {
        }
    }
}

Wenn Sie eine Instanz dieses Indikators ausführen, klicken Sie mit der rechten Maustaste auf die rote Linie und entfernen Sie sie. Das Protokoll sollte dann die Meldung "Object reference removed" ausgeben.

Wenn Sie eine Referenz zu einem (inaktiven) Chartobjekt behalten, tritt ein Speicherleck auf. Während der Garbage Collection wird Ihr Objekt weiterhin als aktiv betrachtet, was bedeutet, dass es den Sammlungsprozess überlebt.

Um dieses Problem zu vermeiden, verwenden Sie das Ereignis ObjectsRemoved in Kombination mit der Eigenschaft IsAlive.

Balkenindex oder Zeit

Beim Codieren von Chartobjekten können Sie entweder die Chartzeit oder den Balkenindex für die X-Achse verwenden.

Unserer Meinung nach ist die Chartzeit die bessere Option. Bei Verwendung von Balkenindizes können Sie keine zukünftigen Werte planen (da die erforderlichen Indizes noch nicht existieren) und keine Abstände zwischen Balken berücksichtigen. Balkenindizes können jedoch einfacher zu verwenden sein, insbesondere bei relativ einfachen Chartobjekten.

Alle Methoden Chart.Draw haben unterschiedliche Überladungen für Balkenindizes und Chartzeit.