Preisgesteuertes CGI-Modell: Erweiterte Datennachbearbeitung und Implementierung

Inhalt:

1. Einführung
2. Arbeitsablauf einrichten
3. Aufbau eines Skriptprogramms für den Preisdatenexport in MQL5
4. Implementierung der Skripte
5. Skript zur Nachbearbeitung von Daten mit Python
6. Implementierung von verfeinerten Daten in Blender 3D
7. Schlussfolgerung 

Einleitung:

Zuvor haben wir im Projekt Preisgesteuertes CGI-Modell Kursdaten aus dem MetaTrader 5 exportiert. Allerdings fehlte uns die Kontrolle über die Datenmerkmale, sodass wir einen Algorithmus zur Datenmanipulation entwickeln mussten, um die Daten mit spezifischen Formeln zu modifizieren oder zu filtern, damit sie unserem Verwendungszweck entsprechen. Trotzdem haben wir die CGI-Figur Price Man erfolgreich eingeführt und als Bild erhalten.

Durch die Verwendung von MQL5 können wir ein Skript entwickeln, um nutzerdefinierte Exporte durchzuführen und die Nachbearbeitung zu vereinfachen. In diesem Artikel werden wir ein Programm zum Exportieren unserer Preisdaten erstellen und die praktische Anwendung der nachbearbeiteten Daten besprechen, um unsere Figur zum Leben zu erwecken.

Am Ende dieses Artikels haben wir folgende Ziele:

1. Erstellen Sie ein nutzerdefiniertes Programm für den Export von Kursdaten aus MetaTrader 5.
2. Normalisieren Sie die Preisdaten für die Verwendung in anderen Softwareprogrammen.
3. Integrieren Sie die normalisierten Preisdaten in Blender 3D.
4. Verstehen, wie die Daten mit Python in Blender 3D weiterverarbeitet werden.

Wenn Sie bis zum Ende lesen, sehen Sie den animierten Editor für lineare Graphen des Price Mans, mit einer Darstellung, die mit nachbearbeiteten Kursdaten von MetaTrader 5 für den Volatility 25 Index erstellt wurden. Hier sehen Sie eine Vorschau des Diagrammeditors:

 

Grafik-Editor: Price Man lineare Animation mit Preisdaten in Blender 3D

In diesem Editor können Sie sehen, wie die nachbearbeiteten Kursdaten aus MetaTrader 5 in eine visuelle Darstellung umgewandelt wurden. So können wir die Daten effektiver analysieren und manipulieren und den Weg für eine weitere Integration und Anwendung in Blender 3D mit Python ebnen. Bleiben Sie dran, wenn wir uns mit diesen spannenden Möglichkeiten näher befassen!

Für dieses Projekt sind drei spezielle Softwareprogramme erforderlich: Python, Blender 3D und vor allem MetaTrader 5, der MetaEditor zum Schreiben unserer MQL5-Programme enthält. Ich werde im nächsten Abschnitt eine kurze Installationsanleitung geben. Sie könnten auch Inkscape für weitere Untersuchungen verwenden, da es beim letzten Mal zur Erstellung unserer Figur verwendet wurde.

Arbeitsablauf einrichten:

Für unser Projekt benötigen Sie die portable Price-Man-Image-Datei, die Sie in den Anhängen des vorherigen Artikels finden. Hier zeige ich Ihnen, wie Sie die Datei in Blender 3D importieren können. Nachfolgend sind die Installations- und Importschritte beschrieben:

•   Installieren Sie MetaTrader 5:

Um MetaTrader 5 auf einem Windows-System zu installieren, besuchen Sie die offizielle Website MetaTrader 5 und laden Sie den MetaTrader 5 Installer herunter. Sobald der Download abgeschlossen ist, suchen Sie die Installationsdatei und doppelklicken Sie darauf, um sie auszuführen. Folgen Sie den Anweisungen auf dem Bildschirm, um die Installation abzuschließen, einschließlich des Akzeptierens der Lizenzvereinbarung und der Auswahl des Installationsverzeichnisses. Starten Sie nach Abschluss der Installation MetaTrader 5 über das Startmenü oder eine Desktop-Verknüpfung und melden Sie sich mit Ihren Zugangsdaten für das Handelskonto an, um die Plattform zu nutzen.

•   Installieren Sie das neueste Python:

Um Python auf einem Windows-System zu installieren, besuchen Sie die offizielle Python-Website unter python.org und suchen Sie im Abschnitt „Downloads“ nach der neuesten für Windows geeigneten Version. Laden Sie die ausführbare Datei des Installationsprogramms für Ihr System herunter (entweder 32-Bit oder 64-Bit). Sobald der Download abgeschlossen ist, führen Sie das Installationsprogramm aus. Achten Sie darauf, das Kästchen „Add Python to PATH“ zu markieren, und wählen Sie dann je nach Bedarf die Option „Install Now“ oder „Customize Installation“. Nachdem die Installation abgeschlossen ist, können Sie sie überprüfen, indem Sie die Eingabeaufforderung öffnen und python --version eingeben, um zu bestätigen, dass Python korrekt installiert ist

•  Installieren Sie Blender 3D:

Um Blender 3D auf einem Windows-System zu installieren, besuchen Sie die offizielle Blender-Website unter blender.org und laden Sie den empfohlenen Windows-Installer herunter. Führen Sie nach dem Herunterladen das Installationsprogramm aus, folgen Sie den Anweisungen auf dem Bildschirm, um die Lizenzvereinbarung zu akzeptieren, wählen Sie den Installationsort und schließen Sie die Installation ab. Nach der Installation starten Sie Blender über die Desktop-Verknüpfung oder das Startmenü. Vergewissern Sie sich, dass Ihr System die Anforderungen erfüllt und dass Sie die neuesten Grafiktreiber installiert haben, um eine optimale Leistung zu erzielen.

•  Importieren einer CGI-Zeichen in Blender 3D:

Um die Nutzung und Darstellung zu erleichtern, haben wir uns für ein tragbares 2D-Bild entschieden, das eine einfachere Verarbeitung und Berechnung ermöglicht. In Blender 3D können Sie Einstellungen vornehmen, die den Import von Bildern als Ebenen erlauben, ein Plugin, das den Umgang mit Bildern erleichtert. Diese Fähigkeit zeigt die Machbarkeit der Entwicklung von Skripten zur Integration von Preisdaten in Grafiksoftware.

Hier erfährt man, wie du Bilder als Ebenen in Blender 3D importieren kannst:

1. Aktiviere das Add-on:

   • Blender öffnen.
   • Gehe zu Edit > Preferences.
   • Gehe im Fenster Einstellungen auf die Registerkarte Add-ons.
   • Suche nach „Import-Export: Import Images as Planes."
   • Aktiviere das Kästchen neben dem Add-on, um es zu aktivieren.

2. Importieren des Bildes als Ebene:

   • Drücke im 3D-Ansichtsfenster die Tastenkombination Umschalt + A, um das Menü Hinzufügen zu öffnen.
   • Navigiere zum Bild und wählen Sie „Images as Planes“.
   • Es wird ein Dateibrowser angezeigt, in dem das gewünschte Bild ausgewählt werden kann.
   • Sobald das Bild ausgewählt ist, wird es als flache Ebene in die Szene importiert, die am Raster der Szene ausgerichtet ist.

3. Einstellen der Bildebene:

   • Nach dem Importieren können die Position, der Maßstab und die Materialeigenschaften der Bildebene nach Bedarf angepasst werden.
   • Es ist auch wichtig, dass Blender das Material des Objekts anzeigt, sonst sieht man nur ein Mesh

Hier ist die Illustration für den Import der Datei.

Blender 3D-Einstellungen

Erstellen eines Skriptprogramms für den Preisdatenexport in MQL5:

Im vorangegangenen Artikel haben wir uns mit dem manuellen Export von Daten aus dem MetaTrader 5 beschäftigt. Die Merkmale der Daten waren jedoch nicht anpassbar. Es wäre sehr vorteilhaft, ein Programm zu entwickeln, das für die spezifischen Aufgaben, die wir zu bewältigen haben, vollständig optimierbar ist. Indem wir die Programmlogik definieren, können wir alles festlegen, was erforderlich ist, um die gewünschten Ergebnisse zu erzielen.

Erwartungen an das Programm:

• Es muss in der Lage sein, Preisdaten zu exportieren und sie an einem bestimmten Speicherort zu speichern.
• Es muss den Eröffnungs- und Schlusskurs für jeden Balken enthalten.
• Der Zeitbereich für die Balken muss anpassbar sein.
• Der Zeitrahmen für die Balken muss anpassbar sein.

Mit den obigen Ausführungen haben wir eine Grundlage für die Entwicklung geschaffen. Lassen Sie uns nun den Code strukturieren und besprechen, wie alles zusammengefügt wird.

Beginnen wir mit unseren Eigenschaften. Zur Verdeutlichung habe ich neben jeder Codezeile Kommentare eingefügt.

#property indicator_chart_window //So that the program works on the main chart and does not create another window.
#property copyright "Copyright 2024, Clemence Benjamin" 
#property link      "https://www.mql5.com/en/users/billionaire2024/seller" 
#property version   "1.0" 
#property description "Price Data Exporter"
#property strict // #property strict: Enforces strict type-checking rules in the script to prevent potential coding errors.
#property script_show_inputs //#property script_show_inputs: Ensures that input variables are visible in the script's input dialog.

Um unsere Programmfunktionen besser anpassbar zu machen, haben wir eine Eingabelogik entwickelt, die es uns ermöglicht, die von uns benötigten speziellen Werte zu optimieren. Nach jeder Codezeile folgt ein Kommentar, in dem die Funktion erläutert wird. Durch die Erstellung dieses speziellen Skripts sollen die Daten so gefiltert werden, dass nur die benötigten Fachinformationen erfasst werden.

Wir haben zum Beispiel einen Zeitfaktor eingebaut, um eine schnelle Wiederholung zu ermöglichen. Dies ermöglicht es uns, die Auswirkungen von Preisänderungen auf unsere CGI-Figur in einem verkürzten Zeitrahmen zu visualisieren. So können wir beispielsweise eine Bewegung, die 3 Stunden gedauert haben könnte, in nur 36 Sekunden simulieren, indem wir die entsprechende Berechnungslogik anwenden.

input string ExportFileName = "PriceData.csv";       // Name of the file
input datetime StartTime = D'2023.01.01 00:00';       // Start time for data export
input datetime EndTime = D'2023.12.31 23:59';         // End time for data export
input ENUM_TIMEFRAMES TimeFrame = PERIOD_D1;          // Timeframe for data export
input double TimeScaleFactor = 60.0;                  // Timescale factor (e.g., 60 for 1 minute to 1 second)

Die OnStart-Funktion ist die Standard- und Hauptfunktion eines jeden Skripts. In unserem Programm ruft es alle Eingaben unter der Funktion Preisdaten exportieren auf. Dadurch wird sichergestellt, dass alle angegebenen Einstellungen und Parameter bei der Ausführung des Skripts angewendet werden.

void OnStart()
  {
   ExportPriceData(ExportFileName, StartTime, EndTime, TimeFrame, TimeScaleFactor);
  }

Die Funktion Preisdaten exportieren schließlich übernimmt die gesamte Exportlogik im Programm. Nachfolgend werden die einzelnen Prozesse kurz erläutert, wobei weitere Einzelheiten auch in den Kommentaren innerhalb des Programms zu finden sind.

void ExportPriceData(string filename, datetime startTime, datetime endTime, ENUM_TIMEFRAMES timeframe, double timescale)
  {
   int handle = FileOpen(filename, FILE_WRITE|FILE_CSV, ',', CP_ACP);
   
   if(handle == INVALID_HANDLE)
     {
      Print("Error opening file: ", filename);
      return;
     }
   
   // Write the header
   FileWrite(handle, "Open", "Close", "Change", "Duration");
   
   // Get the total number of bars in the specified time frame
   int totalBars = iBars(_Symbol, timeframe);
   
   // Loop through the bars and collect data within the specified time range
   for(int i = totalBars - 1; i > 0; i--)
     {
      datetime time = iTime(_Symbol, timeframe, i);
      datetime nextTime = iTime(_Symbol, timeframe, i - 1); // Time of the next bar
      
      // Check if the bar's time is within the specified range
      if(time >= startTime && time <= endTime)
        {
         double open = iOpen(_Symbol, timeframe, i);
         double close = iClose(_Symbol, timeframe, i);
         double change = close - open;
         
         // Calculate duration in seconds and apply timescale factor
         double duration = (nextTime - time) / timescale;
         
         // Write data to file
         FileWrite(handle, open, close, change, duration);
        }
     }
   
   FileClose(handle);
   Print("Export completed. File: ", filename);
  }

Wie oben im Code hervorgehoben, geht es folgendermaßen vor sich:

FileOpen: Öffnet die Datei zum Schreiben im CSV-Format. Sie gibt ein Dateihandle zurück.

FileWrite: Schreibt die Daten in die geöffnete Datei.

In diesem Projekt habe ich einige mathematische Operationen für verschiedene Spalten als Teil der erweiterten Nachbearbeitung vorgeschlagen. Auf diese Weise wird sichergestellt, dass unsere Daten in einem einheitlichen Format exportiert werden, wodurch sich der Aufwand für die spätere Normalisierung verringert.

• Ich habe die speziellen Spalten, die die Daten verarbeiten, eingefügt und auch die einfache Mathematik für die Berechnung der Preisänderungen hinzugefügt. Das kann eine negative oder eine positive Veränderung sein.

Hier ist die Formel:

Kursänderung = Schlusskurs - Eröffnungskurs

• Eine weitere Berechnung betrifft die Dauer, die in Sekunden angegeben wird, um die Wiedergabe von Kursänderungen zu beschleunigen, die normalerweise sehr lange dauern würden. Wir verwenden einfach ein Verhältnis von 1 Minute zu 1 Sekunde.

In dieser skizzierten Erklärung ist zu beachten, dass das Präfix „i“ vor den Begriffen anzeigt, dass die Funktion gemäß der MQL5-Syntax Daten zu technischen Indikatoren oder Marktpreisen abruft.

• iBars: Ruft die Gesamtzahl der Balken im angegebenen Zeitrahmen ab.
• iTime: Gibt die Öffnungszeit eines bestimmten Balkens zurück.
• iOpen: Gibt den Eröffnungskurs eines bestimmten Balkens zurück.
• iClose: Gibt den Schlusskurs eines bestimmten Balkens zurück.

FileClose: Schließt die Datei nach Abschluss des Schreibvorgangs.

Print: Gibt eine Meldung an das Terminal aus, die den Status des Exportvorgangs angibt

Das gesamte Programm ist folgendermaßen aufgebaut:

//+------------------------------------------------------------------+
//|                                                 CSV_Exporter.mq5 |
//|                                Copyright 2024, Clemence Benjamin |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

#property indicator_chart_window
#property copyright "Copyright 2024, Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.0"
#property description "Price Data Exporter"
#property strict
#property script_show_inputs

// Input parameters
input string ExportFileName = "PriceData.csv";       // Name of the file
input datetime StartTime = D'2023.01.01 00:00';       // Start time for data export
input datetime EndTime = D'2023.12.31 23:59';         // End time for data export
input ENUM_TIMEFRAMES TimeFrame = PERIOD_D1;          // Timeframe for data export
input double TimeScaleFactor = 60.0;                  // Timescale factor (e.g., 60 for 1 minute to 1 second)

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   string finalFileName = GenerateUniqueFileName(ExportFileName);
   ExportPriceData(finalFileName, StartTime, EndTime, TimeFrame, TimeScaleFactor);
  }
//+------------------------------------------------------------------+
//| Generate a unique file name if one already exists                |
//+------------------------------------------------------------------+
string GenerateUniqueFileName(string filename)
  {
   string name = filename;
   int counter = 1;
   
   while(FileIsExist(name))
     {
      name = StringFormat("%s_%d.csv", StringSubstr(filename, 0, StringFind(filename, ".csv")), counter);
      counter++;
     }
   
   return name;
  }
//+------------------------------------------------------------------+
//| Export price data to CSV file                                    |
//+------------------------------------------------------------------+
void ExportPriceData(string filename, datetime startTime, datetime endTime, ENUM_TIMEFRAMES timeframe, double timescale)
  {
   int handle = FileOpen(filename, FILE_WRITE|FILE_CSV, ',', CP_ACP);
   
   if(handle == INVALID_HANDLE)
     {
      Print("Error opening file: ", filename);
      return;
     }
   
   // Write the header
   FileWrite(handle, "Open", "Close", "Change", "Duration");
   
   // Get the total number of bars in the specified time frame
   int totalBars = iBars(_Symbol, timeframe);
   
   // Loop through the bars and collect data within the specified time range
   for(int i = totalBars - 1; i > 0; i--)
     {
      datetime time = iTime(_Symbol, timeframe, i);
      datetime nextTime = iTime(_Symbol, timeframe, i - 1); // Time of the next bar
      
      // Check if the bar's time is within the specified range
      if(time >= startTime && time <= endTime)
        {
         double open = iOpen(_Symbol, timeframe, i);
         double close = iClose(_Symbol, timeframe, i);
         double change = close - open;
         change = NormalizeDouble(change, 3);  // Round to 3 decimal places
         
         // Calculate duration in seconds and apply timescale factor
         double duration = (nextTime - time) / timescale;
         
         // Write data to file
         FileWrite(handle, open, close, change, duration);
        }
     }
   
   FileClose(handle);
   Print("Export completed. File: ", filename);
  }
//+------------------------------------------------------------------+

Implementierung der Skripte:

Unser Programm wurde erfolgreich kompiliert. Obwohl wir während der anfänglichen Entwicklung mit einigen Herausforderungen konfrontiert waren, haben wir alle Probleme gelöst und eine fehlerfreie Version erstellt, die für die Leser leicht verständlich ist. Das bedeutet, dass bei Bedarf weitere Anpassungen und Änderungen für andere Projekte vorgenommen werden können.

Das Programmprofiling war sehr erfolgreich. Das Programm erstellte zunächst eine Preisdatendatei, konnte aber später bei weiteren Datenexportversuchen keine neuen Dateien mehr erstellen. Wir haben den Code angepasst, um sicherzustellen, dass jede neue Datei eine eindeutige Zahlenerweiterung hat, damit nicht dieselbe Datei überschrieben wird.

Schauen wir uns die Bilder unten an, um zu sehen, wie es sich entwickelt hat.

Für dieses Projekt habe ich den Volatility 25 Index verwendet, mit Kursdaten vom 31/07/24 00:00 Uhr bis 31/07/24 03:00 Uhr

Volatilität 25 Index 

Wir demonstrierten, wie das Skript funktioniert und wie es für den von uns gewünschten Zeitbereich - nur 3 Stunden ab Tagesbeginn - angepasst wurde.

Volatilität 25 Index: Exportieren von Preisdaten mit den MQL5-Skripten

Gehen Sie wie folgt vor, um über MetaTrader 5 zum MQL5-Datenordner zu navigieren und den Ordner der Datei zu finden, in dem die exportierten Daten sicher gespeichert sind:

• Öffne im MetaTrader 5:
• Starte die Anwendung MetaTrader 5 auf dem Computer.

Rufe den Datenordner auf:

• Klicke im MetaTrader 5 im oberen Menü auf Datei.
• Wähle „Dateiordner öffnen“ (Ctrl+Shift+D) aus dem Dropdown-Menü. Dadurch wird der MQL5-Dateiordner in dem Datei-Explorer geöffnet.

Suche den Ordner „Files“:

• Öffne im MQL5-Dateiordner den Ordner „Files“. Hier werden Ihre exportierten Dateien sicher gespeichert.

.

Zugriff auf die exportierte Dateien

Zugriff auf die exportierten Dateien

Skript zur Nachbearbeitung von Daten mit Python:

Um eine weitere Feinabstimmung unserer Daten zu erreichen, müssen wir den Status der Datei Price Data_7 auf der Grundlage des erfolgten Exports untersuchen. Klappen wir die Darstellung der Preisdaten_7 nach dem Export auf:

Volatilität 25 Index, M5: Rohdaten

Schlüsselfakten aus dem Bild:

• Die Daten sind durch Kommata getrennt, wie das Format schon sagt: CSV.
• Es ist recht schwierig, die Daten aufgrund der Darstellung mit dem Auge zu analysieren.
• Seine Spalten sind nicht gut ausgerichtet.

Jetzt können wir unser Skript zur Datennormalisierung in Python auf der Grundlage der obigen Informationen erstellen.

Hier ist unser sauberer Code, nachdem wir alle Fehler behoben haben. Ich werde sie im Folgenden kurz erläutern. Für weitere Informationen über die Pandas-Bibliothek lesen Sie bitte die vorherige Version dieses Artikels

import pandas as pd

def process_csv(input_file, output_file, encoding='utf-16'):
    # Define the column names (assuming the order in the CSV is consistent)
    column_names = ['Open', 'Close', 'Change', 'Duration']
    
    try:
        # Read the CSV file without headers using UTF-16 encoding
        df = pd.read_csv(input_file, header=None, names=column_names, encoding=encoding)
        
        # Strip leading/trailing whitespace from column data
        df = df.applymap(lambda x: x.strip() if isinstance(x, str) else x)
        
        # Remove any rows that are duplicates of the header (e.g., if it appears twice)
        df = df[df['Open'] != 'Open']
        
        # Display the processed data
        print("Processed Data:")
        print(df.head())
        
        # Save the processed data to a new CSV file with column names
        df.to_csv(output_file, index=False)
        print(f"Processed data saved to {output_file}")
    
    except UnicodeDecodeError as e:
        print(f"Error reading the file: {e}")
        print("Try using a different encoding like 'ISO-8859-1' or 'windows-1252'.")
    except pd.errors.EmptyDataError as e:
        print(f"No data: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

# Prompt the user for input and output file names and encoding
input_file = input("Enter the input CSV file name (e.g., 'PriceData.csv'): ")
output_file = input("Enter the desired output CSV file name (e.g., 'ProcessedPriceData.csv'): ")
encoding = input("Enter the file encoding (default is 'utf-16'): ") or 'utf-16'

# Call the function with the provided file names and encoding
process_csv(input_file, output_file, encoding)

Dieses Programm ist recht ansprechend, da es den Nutzer auffordert, die für die Nachbearbeitung vorgesehene Datei und den Namen der gewünschten Ausgabedatei einzugeben. Es wird auch nach der Kodierung gefragt, die bei der Bearbeitung verschiedener Datenformate wichtig ist. In diesem Fall verwenden wir den Standardwert utf-16, aber andere Beispiele sind ISO-8859-1 und Windows-1252. Wenn Sie die Kodierung nicht richtig berücksichtigen, können erhebliche Fehler auftreten.

Die beiden wichtigsten Prozesse, die das Programm durchführt, sind:

• Spaltennamen festlegen: Das Skript definiert eine Liste namens column_names, die die erwarteten Spaltennamen in der CSV-Datei angibt: ['Open', 'Close', 'Change', 'Duration'].

• Bereinigung der Daten: Das Skript verwendet apply map(), um führende oder nachgestellte Leerzeichen aus den Zeichenkettendaten im DataFrame zu entfernen. Dies gewährleistet saubere Daten. Anschließend werden alle Zeilen entfernt, in denen die Spalte „Open“ den Wert „Open“ hat, was auf eine wiederholte Kopfzeile hindeuten könnte.

Um das Programm auszuführen, habe ich Notepad++ als Editor verwendet und es unter einem eindeutigen Namen gespeichert. Der Einfachheit halber habe ich dafür gesorgt, dass das Programm im gleichen Ordner wie die CSV-Dateien gespeichert wird. Ich habe dann die Windows-Eingabeaufforderung in diesem Ordner gestartet. Dies lässt sich leicht mit Notepad++ bewerkstelligen; siehe das folgende Bild als Referenz

Starten der Windows-Eingabeaufforderung aus Notepad++

Wenn Sie die oben genannten Schritte ausgeführt haben, starten Sie das Programm, indem Sie den folgenden Befehl in der Windows-Eingabeaufforderung ausführen:

python Data_processor.py 

Dadurch wird Ihr Skript gestartet, und Sie werden aufgefordert, die zu verarbeitende Datei anzugeben.

So sah es bei mir aus, wobei der Text in der Windows-Eingabeaufforderung hervorgehoben war

Ausführen des Programms in der Windows-Eingabeaufforderung

Nach erfolgreicher Ausführung haben wir unsere verarbeiteten Daten fertig und speichern sie als ProcessedDataFile.csv.

Hier ist die endgültige Darstellung der Daten:

Sie können nach oben blättern, um die verarbeiteten Daten mit den Rohdaten zu vergleichen, und es ist ein deutlicher Unterschied zu erkennen. Die aufbereiteten Daten sind aussagekräftiger geworden und ermöglichen eine einfachere Analyse und Rückschlüsse auf den Markt, indem die Spalten untersucht werden. Wir werden die Werte in der Spalte „Veränderung“ als Referenz für die lineare Animation in Blender 3D verwenden. Weitere Informationen finden Sie im folgenden Abschnitt.

Implementierung von verfeinerten Daten in Blender 3D:

Wie bereits erläutert, haben wir unsere CGI-Figur, Price Man, in Blender 3D importiert. Wir haben auch Referenzbilder importiert, die wir bei der Durchführung der Animation verwenden. In der Animation verwenden wir Schlüsselbilder, um neue Werte gegen die Zeit zu markieren. In diesem Fall haben wir zwölf Datenzeilen aus der Spalte „Veränderung“ verwendet. Wir haben die Daten so, wie sie sind, eingegeben, ohne sie weiter zu verarbeiten, um Faktoren wie den Maßstab zu ändern. Mit dem Grafikeditor in der Animationssoftware können wir die wichtigsten Punkte während der Wiedergabe leicht erkennen. Wir haben die Animation auf 12 Bilder pro Sekunde eingestellt. Für weiteres und detailliertes Wissen über Blender 3D empfehle ich die Nutzung von YouTube-Tutorials.

Blender 3D: Price Man Animierte Simulation

Schlussfolgerung:

In diesem Artikel haben wir erfolgreich den gesamten Arbeitsablauf zur Erstellung eines preisgesteuerten CGI-Modells erforscht, indem wir Kursdaten aus dem MetaTrader 5 mit fortgeschrittenen Nachbearbeitungstechniken unter Verwendung von Python integriert und diese verfeinerten Daten dann in Blender 3D implementiert haben. Durch die Entwicklung eines nutzerdefinierten MQL5-Skripts für den Export von Preisdaten erhielten wir eine bessere Kontrolle über unsere Datenmanipulation, was eine bessere Anpassung unseres CGI-Modells ermöglichte.

 Durch die Implementierung eines Python-Skripts wurde die Normalisierung und Verarbeitung der Daten weiter optimiert, sodass sie nahtlos mit Blender kompatibel sind. Durch manuelle Anpassungen und die Verwendung der Bildimportfunktionen von Blender erweckten wir die Figur des Price Man zum Leben und zeigten das Potenzial der Verschmelzung von Finanzdaten und künstlerischer Visualisierung.

Dieses Projekt zeigt nicht nur den innovativen Einsatz von datengesteuerten Ansätzen in der CGI, sondern unterstreicht auch die Bedeutung der Integration verschiedener Softwaretools zur Optimierung von Kreativität und Funktionalität. Wenn wir diese Technologien weiter erforschen, sind die Möglichkeiten zur Erstellung dynamischer und überzeugender visueller Darstellungen von Daten praktisch unbegrenzt.

Der Tabelle sind Dateien beigefügt, die Sie für weitere Nachforschungen nutzen können. Vielen Dank und viel Spaß beim Entwickeln!

Datei Name	Beschreibung
Price Exporter.mq5	MQL5-Skriptprogramm zum Exportieren von kundenspezifischen Preisdaten.
Price Data_7.csv:	CSV-Datei mit rohen exportierten Kursdaten aus MetaTrader 5.
Data_processor.py,	Spezielle Daten-Normalisierungssoftware.
ProcessedDatafile.csv	Verfeinerte Preisdatendatei.
PDCGIM2.zip	Enthält die PDCGIM2.blend mit der Animation.