Harici Kütüphaneler Kullanmadan 3D Görselleştirme: MetaTrader 5, MQL5 + DX11 ile Optimizasyon Sonuçlarını Nasıl Gösteriyor?

Güzel bir resimden çalışan bir araca

Strateji parametrelerinin sayısı 10'u aştığında ve sınayıcının raporu sayısal serilerden oluşan çok sayfalı bir tabloya dönüştüğünde, yatırımcılar ve geliştiriciler bir sorunla karşı karşıya kalır: yararlı sinyal gürültüde kaybolur. Düz grafikler ve iki boyutlu ısı haritaları belirli bir noktaya kadar etkilidir, ancak bunun ötesinde, verilerin çok boyutluluğu nedeniyle insan beyni kaçınılmaz olarak zorlanmaya başlar. Gösterge periyodu, Zararı Durdur, volatilite ve maksimum düşüş arasındaki korelasyonu aklımızda tutmaya çalışırız, ancak bilişsel yük bilginin yararlılığından daha hızlı artar. 

MetaTrader 5'teki 3D görselleştirme ve etkileşimli arayüzler, işlem terminalini bir oyun motoruna dönüştürme girişimi değildir. Bu, bilişsel sürtünmeyi azaltmayı amaçlayan bir tekniktir. Yüksekliğin beklenen değere karşılık geldiği ve renk gradyanının düşüşe karşı dayanıklılığı yansıttığı bir 3D yüzey, "istikrar platosunu" vurgulamamıza ve "aşırı uyum iğnelerini" saniyeler içinde ayıklamamıza olanak tanır. Tablo formatında saatler süren bir karşılaştırma gerektiren şey, üç boyutlu uzayda bir formasyon olarak okunur: düzlem eğimleri, yükseklik değişiklikleri, platolar/iğneler ve kontrast bölgeleri.

MetaTrader 5, bu görev için hazır bir teknolojik temel sağlar. Yerel DirectX 11 desteği, yerleşik gölgelendirici veri hattı ve CDXCanvas/CChartObjectDX sınıfları doğrudan MQL5 ortamına entegre edilmiştir. Geliştiricinin harici grafik kütüphanelerine bağlanması, C++'da sarmalayıcılar yazması veya bağımlılıklarla uğraşması gerekmez: aygıt oluşturmadan kare çıktısına kadar tüm döngüye standart 3D API aracılığıyla erişilebilir ve gölgelendiriciler ve dokular doğrudan Files\DX\ klasöründen yüklenir.

Bu makalede, optimizasyon sonuç dizilerinin, küme hacimlerinin ve senaryo modellerinin yönetilebilir 3D görüntülere nasıl dönüştürüleceğini inceleyeceğiz. Uygunluk kriterlerini tanımlayacağız: 3D grafiklerin ne zaman sinyal analizi yetenekleri sağladığı ve ne zaman görsel gürültü oluşturduğu. Daha sonra DX veri hattının mimarisine geçerek başlatma, ölçütleri köşe arabelleklerine bağlama, kamera mekaniği ve kullanıcı arayüzü panellerini inceleyecek ve son olarak ortamın teknolojik sınırlamalarını değerlendireceğiz.

Şekil 1. Metin vs görselleştirme

3D ve etkileşim ne zaman gerçekten faydalı olur?

Bir yatırımcı ve strateji geliştiricisinin elinde güçlü, ancak genellikle hafife alınan bir araç vardır: görsel algı. Rapor tabloları, ölçüt listeleri ve düz grafikler sonuçları belgelemek için iyi bir iş çıkarır. Ancak konu karmaşık ilişkileri anlamaya geldiğinde, insan beyni farklı bir moda geçer: görüntüler, hacim ve bağlam biçimindeki örüntüleri arar. İşte bu noktada 3D görselleştirme ve etkileşim dekorasyon olmaktan çıkıp analitik bir araç haline gelir.

Verilerde net bir analitik hipotez olduğunda üçüncü bir eksen eklemek mantıklıdır. Örneğin, sabit bir risk seviyesinde beklenen değerin sistemin iki temel parametresine bağımlılığı. Bu durumda, 3D yüzey soyut koordinatları bir araziye dönüştürür; burada yeşil "dağlar" istikrarlı kar alanlarını, kırmızı "dipler" ise düşüşleri gösterir. 3D temsil bir filtre görevi görür: gürültüyü filtreler ve yalnızca anlamlı olan kombinasyonları bırakır.

Estetik için değil, analitik değer için

Dekoratif grafiklerden değil, optimizasyon raporu satırlarında neyin gizli olduğunu doğrudan ortaya çıkaran görsel katmanlardan bahsediyoruz. Düz bir tablo şu soruyu yanıtlar: "Bu parametre kombinasyonunun sonucu nedir?"

3D bir yüzey ise şu soruyu yanıtlar: "İki parametredeki yumuşak değişikliklerle sonuç nasıl değişiyor ve istikrar bölgeleri nerede?" Bu, strateji analizinin temelde farklı bir seviyesidir. Dış bağlam değiştiğinde sonucun istikrarlı olması, herhangi bir fikri test ederken elde edilmesi gereken en önemli şeydir. Diğer her şey ikincildir.

3D görselleştirmenin avantaj sağladığı en az üç senaryo vardır:

1. Optimizasyon görünümü

İki parametre seçtiğinizi düşünün: hareketli ortalama periyodu ve Zararı Durdur boyutu. Tabloda, Kar ve Düşüş değerlerini içeren 100 satır görürsünüz. Renk gradyanlı bir 3D yüzeyde, şunları anında göreceksiniz:

• Sağlamlık platoları, stratejinin değişen parametrelerle bile sürekli olarak karlı olduğu geniş yeşil bölgelerdir;
• Keskin tepeler, genellikle aşırı uyumun bir işareti olan dar yerel maksimumlardır;
• Dik eğimler, bir parametrede küçük bir değişikliğin düşüşte keskin bir artışa neden olduğu alanlardır.

Bu 3D yüzey, maksimum kara değil, sağlamlığa dayalı olarak çalışan bir parametre seti seçme konusunda bilinçli kararlar verilmesine olanak tanır.

2. Çok boyutlu bir uzay olarak piyasa koşulları

Piyasa rejimlerinin (trend, yatay hareket, artmış volatilite) belirlenmesi genellikle üçten fazla göstergenin aynı anda analiz edilmesini gerektirir. Burada 3D görselleştirme şunları mümkün kılar:

• Her bir piyasa durumunu özellik uzayında bir nokta olarak gösterme;
• Stratejinin bu moddaki (bu noktadaki) etkinliğini renkle kodlama;
• Gizli gruplanmaları ortaya çıkarmak için nokta bulutunu etkileşimli olarak döndürme.

Bu, özellikle parametreleri uyarlamalı olarak ayarlarken kullanışlıdır: stratejinin hangi koşullar altında başarısız olduğunu ve nerede sağlam performans gösterdiğini görebilirsiniz.

3. Senaryo modelleme ve stres testi

Stratejiyi çeşitli sentetik senaryolar üzerinde çalıştırırken (Monte Carlo yöntemi, fiyat yolu oluşturma, volatilite %30 artarsa ne olur? gibi sorular), 3. boyut şunları görüntüleyebilir:

• X ekseni - strateji parametresi;
• Y ekseni - piyasa stres seviyesi (volatilite, boşluklar);
• Z ekseni/renk - nihai ölçüt (düzelme faktörü, beklenen değer).

Sonuç olarak, sadece en kötü durum senaryosunu değil, kötüleşen piyasa koşullarında stratejinin sağlamlığının sınırını gözlemliyoruz.

Seçim kriterleri: 3D ne zaman aşırıya kaçar?

Bir kural formüle edelim: Bir sonucun iki veya daha fazla sürekli değişkene bağımlılığını araştırırken ve bu bağımlılığın geometrisini görmek sizin için önemli olduğunda, 3D kullanılması yerinde olur.

Saatlerce süren rapor tarama işlemini sezgisel görsel analizle değiştirmeyi denemeye hazırsanız, render veri hattıyla başlayalım.

MQL5'te temel DX veri hattı: Başlatma aşamasından ilk kareye kadar

MetaTrader 5'te 3D grafikler oluşturmak, her aşamanın kendi amacına sahip olduğu sıralı bir süreçtir. DirectX nesnelerinin mimarisini ve render döngüsünü anlamak, büyük miktarda veriyle çalışırken bellek sızıntıları, titreyen grafikler ve performans düşüşü gibi sık karşılaşılan sorunlardan kaçınmamızı sağlar.

MQL5'te DirectX nesne mimarisi

MQL5'teki 3D grafiklerin temeli, DirectX 11 ile çalışmanın tüm karmaşıklığını kapsayan CCanvas3D sınıfıdır. Geliştiriciye üst düzey bir API sağlayarak aygıt, bağlam ve arabellek oluşturmanın alt düzey ayrıntılarını gizler.

Nesne hiyerarşisi:

• CCanvas3D - sahneyi, kamerayı ve render işlemini yöneten bir sınıf
• CDXMesh ve alt sınıfları (CDXBox, CDXSphere, CDXTorus) - geometrik nesneler
• DXVertex - koordinatları, normalleri, doku koordinatlarını ve rengi içeren köşe (vertex) yapısı

struct DXVertex
  {
   DXVector4  position;   // vertex coordinates
   DXVector4  normal;     // normal vector
   DXVector2  tcoord;     // texture coordinates
   DXColor    vcolor;     // color
  };

Bu yapı standart köşe gölgelendirici ile uyumludur ve temel görevler için özel gölgelendiriciler yazma ihtiyacını ortadan kaldırır. Karmaşık projeler için, MQL5\Include\Canvas\DX\DXUtils.mqh dosyasında sunulan metotlar ve yardımcı araçları kullanmanızı öneririz.

Şekil 2. MQL5'te 3D grafiklerin hiyerarşisi

Tüm kaynaklar (gölgelendiriciler, dokular, arabellekler) DXDispatcher aracılığıyla yönetilir. Oluşturulan her nesne yıkıcıdaki Destroy() veya Shutdown() aracılığıyla açıkça yok edilmelidir. MetaTrader 5, DirectX kaynakları için bir çöp toplayıcıya sahip değildir ve terminal yeniden başlatılana kadar bellek sızıntıları birikir.

Veri hattı başlatma

İlk adım bir tuval oluşturmak ve projeksiyon matrisini ayarlamaktır:

//+------------------------------------------------------------------+
//+ canvas creation and projection matrix setup                      |
//+------------------------------------------------------------------+
virtual bool Create(const int width, const int height)
  {
//--- save canvas dimensions
   m_width = width;
   m_height = height;
   
//--- create a canvas to render a 3D scene
   ResetLastError();
   if(!m_canvas.CreateBitmapLabel("3D Sample_1", 0, 0, m_width, m_height, COLOR_FORMAT_ARGB_NORMALIZE))
     {
      Print("Error creating canvas: ", GetLastError());
      return(false);
     }
   
//--- set the projection matrix parameters
   m_canvas.ProjectionMatrixSet((float)M_PI/6, (float)m_width/m_height, 0.1f, 100.0f);
   
//--- create a 3D object
   if(!m_box.Create(m_canvas.DXDispatcher(), m_canvas.InputScene(),DXVector3(-1.0, -1.0, -1.0), DXVector3(1.0, 1.0, 1.0)))
     {
      m_canvas.Destroy();
      return(false);
     }
   
//--- add a cube to the scene
   m_canvas.ObjectAdd(&m_box);
   
   Redraw();
   return(true);
  }

Ana projeksiyon parametreleri:

• Görüş alanı (FOV) - 30 derece (M_PI/6), perspektif ve bozulma arasında denge;
• En-boy oranı - genişliğin yüksekliğe oranı (m_width/m_height), bu oranın korunması yükseklik/genişlikte esnemeyi önler;
• Kırpma düzlemleri - 0.1f (en yakın) ve 100.0f (en uzak), bu sınırların dışındaki nesneler render edilmez.

Bu parametreler görünürlük piramidini tanımlar: yalnızca iki sanal duvar arasında ve yatay görüş açısı içinde bulunan nesneler projeksiyon matrisine dahil edilir.

Gölgelendirici derleme - standart temel şekiller için gölgelendiriciler otomatik olarak derlenir. Özel efektler uygularsanız, hata işleme ile birlikte DXCompileShader() kullanın:

string error_log;
if(!DXCompileShader("shader.hlsl", "vs_main", "vs_5_0", shader_blob, error_log))
  {
   Print("Shader compilation failed: ", error_log);
   return(false);
  }

Veri → Köşeler → Kare

Başlatma aşamasından sonra render döngüsü başlar. Her kare bir dönüşüm veri hattından geçer:

Nesne modeli - Üç boyutlu model, çokgenlerden oluşan bir ağ ile tanımlanır. Pratikte üçgenleme kullanılır: bir üçgen uzaydaki bir düzlemi benzersiz bir şekilde tanımladığından, her çokgen üçgenlere bölünür. Örneğin bir küpün 8 köşesi vardır, ancak doğru ışıklandırma için 24 köşe oluşturulur (benzersiz normallere sahip her yüz için 4).

Topoloji ve indeksler - Köşeler bir indeks arabelleği aracılığıyla temel şekillere bağlanır. Bu bellek tasarrufu sağlar: bir köşe birkaç üçgende kullanılabilir.

//--- preparing vertices and indices for the sphere
DXVertex vertices[];
uint indices[];
if(!DXComputeSphere(0.3f, 50, vertices, indices))
   return(false);

//--- create the sphere object
if(!m_sphere.Create(m_canvas.DXDispatcher(), m_canvas.InputScene(), vertices, indices))
  {
   m_canvas.Destroy();
   return(false);
  }

Dönüşümler - Her nesne matrislerden geçer:

• Model matrisi - yerel koordinatlar → dünya (döndürme, ölçeklendirme, yeniden yerleştirme);
• Görünüm matrisi - dünya koordinatları → kamera koordinatları;
• Projeksiyon matrisi - kamera koordinatları → ekran koordinatları.

//--- calculate the cube position and the transfer matrix
DXMatrix rotation, translation;

//--- rotate the cube sequentially along the X, Y and Z axes
DXMatrixRotationYawPitchRoll(rotation, (float)M_PI/4, (float)M_PI/3, (float)M_PI/6);

//--- shift the cube to the right-down-into the depth
DXMatrixTranslation(translation, 1.0, -2.0, 5.0);

//--- get the transformation matrix as a product of rotation and transfer
DXMatrix transform;
DXMatrixMultiply(transform, rotation, translation);

//--- set the transformation matrix
m_box.TransformMatrixSet(transform);

Işıklandırma (Phong modeli) - gerçekçi bir görüntü üç ışıklandırma bileşeninin hesaplanmasını gerektirir:

• Ambient (arka plan) - yayılmış ışığı simüle eden sabit bir bileşen;
• Diffuse (dağılmış) - ışığın yüzeye geliş açısına bağlıdır;
• Specular (ayna) - parlayan bir etki yaratan vurgular.

//--- set the source color to yellow and direct it from top to bottom
m_canvas.LightColorSet(DXColor(1.0, 1.0, 0.0, 0.8f));
m_canvas.LightDirectionSet(DXVector3(0.0, -1.0, 0.0));

//--- set the blue color for the ambient light
m_canvas.AmbientColorSet(DXColor(0.0, 0.0, 1.0, 0.4f));

//--- set the cube color to white with a green glow
m_box.DiffuseColorSet(DXColor(1.0, 1.0, 1.0, 1.0));
m_box.EmissionColorSet(DXColor(0.0, 1.0, 0.0, 0.2f));

Tuvali render etme ve güncelleme - tüm işlemler Render() metodunda gerçekleştirilir. Ardından, görüntü Update() aracılığıyla tuvale aktarılır:

//--- calculate the 3D scene
m_canvas.Render(DX_CLEAR_COLOR | DX_CLEAR_DEPTH, ColorToARGB(clrBlack));
   
//--- update the picture on the canvas in accordance with the current scene
m_canvas.Update();

Bellek yönetimi - her DX nesnesi video belleği tüketir. Dinamik sahneler oluştururken (örneğin, optimizasyon yüzeyini güncellerken), şunları yapmak gerekir:

• Yenilerini oluşturmadan önce eski arabellekleri temizleme;
• Kaynakları açıkça serbest bırakmak için DXResourceRelease() fonksiyonunu kullanma;
• Köşe sayısını kontrol etme: statik nesneler için binlerce, animasyonlu nesneler için yüzlerce çokgene izin verilir (kesin sayılar bilgisayarın performansına bağlıdır).

Tanılama ve hata kontrolü - her zaman geri dönüş değerlerini kontrol edin ve hata oluştuğunda tanılama için GetLastError() fonksiyonunu kullanın:

if(!m_canvas.CreateBitmapLabel(...))
  {
   int err = GetLastError();
   Print("DX Error code: ", err);
   
//--- typical errors:
//--- 1: device does not support DX11
//--- 2: insufficient video memory
//--- 3: shader compilation error
  }

Donanım hızlandırma veya yazılımla render:

MT5, ekran kartınızın özelliklerini otomatik olarak algılar. DirectX 11 mevcut değilse, grafikler görüntülenmeyecektir. Gereksinimleri kontrol edin:

• DX11 ve gölgelendirici sürümü 5.0 desteği olan ekran kartı;
• İlgili sürücüler (eski sürümler görüntü bozukluklarına neden olabilir);
• Terminal ayarlarında donanım hızlandırmanın etkinleştirilmesi.

Hangi DirectX sürümünün yüklü olduğunu öğrenmek için aşağıdaki adımları uygulayın:

• Windows araç çubuğundaki Arama kutusuna "dxdiag" yazın. Ardından sonuç listesinden "dxdiag" öğesini seçin;
• DirectX Tanı Aracı'nda Sistem sekmesini seçin - DirectX sürümü en az 11 olmalıdır.

Şekil 3. DirectX sürümünü kontrol etme

Not:

DirectX Tanı Aracı'nı ilk kez kullandığınızda, sürücülerinizdeki dijital imzaları kontrol etmeniz istenebilir. Sürücülerinizin, orijinalliğini doğrulamış bir yayıncı tarafından imzalandığından emin olmak için Evet seçeneğini seçmeniz önerilir.

Render döngüsü için bilgisayar kaynak tüketimini optimize etme:

• OnTimer() veya OnChartEvent() - statik sahneler için, Redraw() fonksiyonunu her tikte değil, yalnızca veriler değiştiğinde çağırın;
• Ayrıntı düzeyi (LOD) - kamera uzaklaştıkça nesnelerin ayrıntısını azaltın;
• Örnekleme - birden fazla aynı nesne (kümeler, işaretleyiciler) için farklı dönüşüm matrislerine sahip tek bir ağ kullanın.

Temel veri hattı hazır. Bir tuval oluşturduk, bir projeksiyon ayarladık, köşelerle ve normallerle nesneleri tanımladık, dönüşümler ve ışıklandırma uyguladık. Bir sonraki adım, bu çerçeveyi analitik içerikle doldurmaktır: optimizasyon sonuçlarını 3D yüzeylere, likidite kümelerini hacimsel yapılara ve senaryo modellerini etkileşimli raporlara dönüştürme.

Karmaşık verileri görselleştirme - yüzeyler, kümeler, senaryolar

Temel DX veri hattı kurulduktan sonra, verileri görselleştirmeye hazır boş bir uzayımız olur. Bir sonraki görev, sınayıcının raporundaki sayıları insan gözünün anlayabileceği geometrik şekillere dönüştürmektir. Ham matrislerden görsel sunumlara geçiyoruz.

Bir 3D optimizasyon yüzeyi oluşturmak, muhtemelen alım-satımda 3D'yi kullanmanın en yararlı yoludur. Strateji sınayıcı, satırların çalıştırmalar ve sütunların parametreler ve ölçütler olduğu bir tablo üretir. Optimizasyon sonuçlarını 3D olarak görselleştirmek bu tabloyu bir araziye dönüştürür.

Basit görselleştirme matematiği: X ve Z eksenleri strateji parametreleri (örneğin, hareketli ortalama periyodu ve durma seviyesi boyutu) ve Y ekseni (yükseklik) amaç fonksiyonu (örneğin, düzelme faktörü, beklenen değer) haline gelir. Böyle bir yüzey oluşturmak için, sonuç dizisine dayalı bir üçgen ağ (mesh) oluşturmamız gerekir.

Oluşturma algoritması:

• Veri toplama - optimizasyon sonuçları dizisini gözden geçirme, gerekli verileri seçme ve yapılandırma;
• Normalleştirme - grafiğin düz görünmemesi için parametre değerlerini ortak bir ölçeğe normalleştirme;
• Köşe oluşturma - her veri noktası için DXVertex köşesi oluşturuyoruz;
• Üçgenleme - bitişik köşeleri indekslerle üçgenlere bağlama.

//+------------------------------------------------------------------+
//| example of creating a surface from a data array                  |
//+------------------------------------------------------------------+
void CreateOptimizationSurface(const double &data[],const int width,const int height)
  {
   DXVertex vertices[];
   uint indices[];
   int v_count = 0;
   int i_count = 0;
   
//--- allocate memory for vertices (width*height of points)
   ArrayResize(vertices,width*height);
   
   for(int y=0;y<height;y++)
     {
      for(int x=0;x<width;x++)
        {
         int idx=y*width+x;
         //--- X and Z are the coordinates of the parameters, Y is the value of the metric (profit)
         vertices[idx].position=DXVector3(x, data[idx], y); 
         vertices[idx].normal=DXVector3(0, 1, 0); // simplified normal
         vertices[idx].vcolor=ColorToVector4(ColorFromValue(data[idx])); // color depends on value
         vertices[idx].tcoord=DXVector2((float)x/width, (float)y/height);
        }
     }
   
//--- next, we form an array of indices for triangles and create an object using m_mesh.Create(...)
  }

Böyle bir yüzeyde, parametreler değiştiğinde stratejinin nispeten istikrarlı bir şekilde çalıştığı geniş bölgeler olan "platolar" hemen görülebilir. Tersine, aşırı uyuma işaret eden dar kar pikleri (iğnelere benzer) açıkça görülebilir. Böyle bir "iğneyi" görsel olarak ayıklamak, 1000 satırlık bir tabloda fark etmekten çok daha kolaydır, çünkü çok boyutlu bağımlılıklar tablo biçiminde zayıf bir şekilde görülebilir.

Uzayda küme analizi

Piyasa verileri sadece fiyat ve zamanı değil, aynı zamanda hacmi de içerir. 2D'de genellikle ekranın altına bir hacim histogramı çizeriz, ancak 3D'de hacim tam teşekküllü bir boyut haline gelir. Düz çubuklar yerine, yüksekliği ve kalınlığı işlem hacmine veya küme yoğunluğuna bağlı olan hacim blokları (vokseller) veya silindirler kullanabiliriz:

• X ekseni - Zaman;
• Z ekseni - Fiyat;
• Y ekseni - Hacim / İşlem sayısı (voksel yarıçapı).

Likidite görselleştirme - DXComputeSphere veya özel ağlar kullanarak, büyük işlem kümelerini değişen büyüklüklerde ve şeffaflıkta küreler olarak çizebilirsiniz. Üst üste bindiklerinde, yatırımcının "boşluklar" (fiyatın hızla hareket ettiği bölgeler) ve "yoğunlaşmalar" (destek/direnç seviyeleri) gördüğü bir likidite bulutu oluştururlar.

//--- setting color based on volume (heatmap effect)
//--- the larger the volume, the redder the color (from blue to red)
color cluster_color=ColorInterpolate(clrBlue,clrRed,volume_ratio);
m_cluster.MeshColorSet(ColorToVector4(cluster_color,0.7)); // 0.7 - transparency

DXComputeSurface() aracılığıyla yüzey oluşturma

İki boyutlu verilerin (ısı haritaları, optimizasyon sonuçları, korelasyon matrisleri) görselleştirilmesine yönelik tipik görevler için DirectX MQL5 kütüphanesi DXComputeSurface() hazır şablon fonksiyonunu sağlar. Fonksiyon DXUtils.mqh dosyasında yer almaktadır.

Bildirme:

//+------------------------------------------------------------------+
//| Surface                                                          |
//| TVertex must have                                                |
//| DXVector4 position, DXVector4 normal and DXVector2 tcoord members|
//+------------------------------------------------------------------+
template <typename TVertex>
bool DXComputeSurface(double &data[],uint data_width,uint data_height,double data_range,
                      const DXVector3 &from,const DXVector3 &to,DXVector2 &texture_size,
                      bool two_sided,bool use_normals,
                      TVertex &vertices[],uint &indices[])

Amaç:

2D veri dizisine dayalı olarak 3D yüzey için otomatik olarak köşeler ve indeksler oluşturur. Fonksiyon, geliştiriciyi koordinatları, ağ üçgenlemeyi ve normalleri manuel olarak hesaplama ihtiyacından kurtarır.

Girdiler:

Parametre	Tür	Açıklama
[in] data[]	double&	Tek boyutlu yükseklik değerleri dizisi (optimizasyon verileri, korelasyonlar vb.)
[in] data_width	uint	Orijinal veri matrisinin genişliği (sütun sayısı)
[in] data_height	uint	Orijinal veri matrisinin yüksekliği (satır sayısı)
[in] data_range	double	Z ekseni (yükseklik) boyunca değerler için ölçeklendirme aralığı
[in] from	const DXVector3&	3D uzayda yüzeyin sol alt köşesinin koordinatları
[in] to	const DXVector3&	3D uzayda yüzeyin sağ üst köşesinin koordinatları
[in] texture_size	DXVector2&	Doku koordinat büyüklüğü (doku eşleme veya gradyanlar için)
[in] two_sided	bool	Çift taraflı render bayrağı (şeffaf yüzeyler için kullanışlıdır)
[in] use_normals	bool	Doğru ışıklandırma için normal hesaplama bayrağı
[out] vertices[]	TVertex&	Çıktı köşe dizisi (fonksiyon tarafından doldurulur)
[out] indices[]	uint&	Üçgenleme için indekslerin çıktı dizisi (fonksiyon tarafından doldurulur)

TVertex türü gereksinimleri - TVertex şablon parametresi en az üç alan içeren bir yapı olmalıdır:

struct MyVertex
  {
   DXVector4 position;  // vertex coordinates (x,y,z,w)
   DXVector4 normal;    // normal vector (nx,ny,nz,0)
   DXVector2 tcoord;    // texture coordinates (u,v)
   // additional fields as needed: color, binormal, etc.
  };

Geri dönüş değeri:

• true - yüzey başarıyla oluşturuldu;
• false - hata (dizi büyüklüklerini ve girdi verilerinin geçerliliğini kontrol edin).

Örnek kullanım:

Diyelim ki strateji optimizasyonunun sonuçlarını 20x20 matris şeklinde elde ettik, burada her bir değer bir işlemin beklenen değeridir. Bu verileri 3 boyutlu bir yüzey olarak görselleştirmek istiyoruz.

//+------------------------------------------------------------------+
//| Generate optimization surface via DXComputeSurface               |
//+------------------------------------------------------------------+
void BuildOptimizationSurface(double &optimization_data[],uint width,uint height)
  {
//--- define the vertex type with an additional color field
   struct SVertex
     {
      DXVector4 position;
      DXVector4 normal;
      DXVector2 tcoord;
      DXColor   vcolor;  // vertex color for gradient
     };
   
   SVertex vertices[];
   uint    indices[];
   
//--- surface parameters
   DXVector3 from(-10.0,-5.0,0.0);   // lower left corner
   DXVector3 to(10.0,5.0,1.0);       // upper right corner
   DXVector2 texture_size(1.0,1.0);  // full coverage of texture coordinates
   double    data_range=2.0;         // height scaling
   
//--- generate geometry
   if(!DXComputeSurface(optimization_data,width,height,data_range,
                        from,to,texture_size,
                        false,true,  // one-sided, with normals
                        vertices,indices))
     {
      Print("surface generation error: ",GetLastError());
      return;
     }
   
//--- color the vertices by height (gradient: red → green)
   for(uint i=0;i<ArraySize(vertices);i++)
     {
      double t=MathMax(0.0,MathMin(1.0,vertices[i].position.z/data_range));
      vertices[i].vcolor=DXColor(1.0f-(float)t,(float)t,0.2f,1.0f);
     }
   
//--- create a mesh and add it to the scene
   if(!mesh.Create(canvas.DXDispatcher(),canvas.InputScene(),vertices,indices))
      Print("error creating mesh: ",GetLastError());
   
   mesh.DiffuseColorSet(DXColor(1.0f,1.0f,1.0f,1.0f));
   canvas.ObjectAdd(&mesh);
  }

DXComputeSurface() avantajları:

• Geliştirme hızı - üçgenleme ve normal hesaplama döngülerini manuel olarak yazmaya gerek yoktur;
• Optimizasyon - dahili uygulama verimli ağ oluşturma algoritmaları kullanır;
• Esneklik - şablon köşe türü, herhangi bir ek özellik (renk, doku, özel veri) eklenmesine izin verir.

DXComputeSurface() sınırlamaları:

• Yalnızca düzgün ızgaralar - fonksiyon, verilerin dikdörtgen bir matris olduğunu varsayar. Düzensiz nokta bulutları veya keyfi topoloji için manuel oluşturma gerekecektir;
• Varsayılan interpolasyon - köşe yükseklikleri ızgara düğümleri arasında doğrusal olarak interpole edilir. Pürüzlü yüzeyleri yumuşatmak için verilerin ön filtrelenmesi gerekebilir;
• Bellek - fonksiyon köşe ve indeks dizilerini dinamik olarak tahsis eder. Büyük matrislerle çalışırken (örn. 100x100 ve daha büyük), bellek tüketimini ve yüzey yeniden oluşturma sıklığını izlediğinizden emin olun.

Etkileşimli kontrol ile entegrasyon:

DXComputeSurface() statik geometri oluşturduğundan, dinamik güncellemeler (örneğin optimizasyon parametrelerini gerçek zamanlı olarak değiştirirken) şunları gerektirir:

1. CDXMesh nesnesine bir referans kaydedin,
2. Veri değiştiğinde, eski arabellekleri boşaltmak için mesh.Shutdown() fonksiyonunu çağırın,
3. DXComputeSurface() ve mesh.Create() fonksiyonlarını yeni verilerle yeniden çağırın,
4. Değişiklikleri görüntülemek için RedrawScene() fonksiyonunu çağırın.

Sorunsuz animasyon için, DX_OptimizationSurface Uzman Danışmanında yapıldığı gibi ağır işlemlerin OnTimer işleyicisine taşınması önerilir (aşağıdaki açıklamaya bakın). Birçok tipik durumda DXComputeSurface() kullanmak, tipik yüzeyleri oluştururken kod miktarını %30-40 oranında azaltır ve düşük seviyeli grafikler yerine analitik mantığa odaklanmamızı sağlar.

Senaryo modelleme ve etkileşimli raporlar

DirectX'in MQL5'teki avantajlarından biri, göstergeyi yeniden yüklemeden sahneyi dinamik olarak güncelleme yeteneğidir. Bu da "ya şöyle olsaydı?" senaryolarının modellenmesinin yolunu açar. Örneğin, "Volatilite" veya "Komisyon" etiketli kaydırıcıyı hareket ettirdiğiniz panel. Data[] dizisi gerçek zamanlı olarak yeniden hesaplanır ve VertexSet() köşe arabelleği güncelleme fonksiyonu 3D yüzeyi dinamik olarak değiştirir.

//+------------------------------------------------------------------+
//| dynamic update example                                           |
//+------------------------------------------------------------------+
void OnSliderChange(const double new_vol)
  {
//--- recalculate the strategy metrics with the new volatility
   RecalculateStrategyMetrics(new_vol);
   
//--- update only the Y-coordinate of the vertices (height), without recreating the mesh
   for(int i=0;i<ArraySize(m_vertices);i++)
     {
      m_vertices[i].position.y=m_new_metrics[i];
      //--- recalculate normals for correct lighting
      m_vertices[i].normal=CalculateNormal(i); 
     }
   
//--- send updated data to video memory
   m_mesh.VertexSet(m_vertices);
   Redraw();
 }

Bu, yatırımcının stratejinin sürdürülebilirliğini görmesini sağlar - volatilitedeki küçük bir değişiklik karlı bir grafiği kaybedilen bir grafiğe dönüştürürse, stratejinin uzun vadede uygulanabilir olması pek olası değildir.

Analitik bir filtre olarak gölgelendiriciler

MetaTrader 5 standart gölgelendiricileri ışıklandırmadan sorumludur (Phong modeli). Ancak analiz için verilerle çalışan gölgelendiricilere ihtiyacımız var. Filtre görevi görecek basit bir Piksel Gölgelendirici yazabiliriz.

Örneğin, 3D grafikte yalnızca düşüşün %20'yi aştığı veya kar faktörünün 1'den az olduğu bölgeleri vurgulamanız gerekiyor:

//+------------------------------------------------------------------+
//| example of logic in HLSL shader                                  |
//+------------------------------------------------------------------+
float4 PS_Main(PS_INPUT input) : SV_TARGET
  {
//--- input.color contains the metric information encoded in the vertex
   float profit=input.color.r; 
   
//--- if the profit is below the threshold, make the object transparent
   if(profit<threshold)
      return float4(0.5,0.5,0.5,0.2); // gray and transparent
   else
      return float4(0.0,1.0,0.0,1.0); // bright green
  }

Gölgelendiricide, bir köşe özelliğinin değerini (yükseklik veya iletilen renk gibi) kontrol ederiz ve kriterleri karşılamıyorsa, pikseli saydam veya gri yaparız. Bu yaklaşım, grafikten “gürültüyü” çıkarmamıza ve yalnızca önemli alanları bırakmamıza olanak tanır. Bu, büyük optimizasyon verileri dizilerini analiz ederken önemlidir.

Etkileşim - fare, düğmeler ve kamera kontrolü

Statik bir 3D görüntü güzeldir, ancak onu döndüremez, yakınlaştıramaz veya filtreleyemezseniz alım-satımda çok az işe yarar. DirectX'in MQL5'teki gerçek faydası, verileri aktif olarak keşfetme fırsatı bulduğumuzda ortaya çıkıyor. Fare ve klavye olaylarını kamera matematiğiyle ilişkilendirerek bir sahneyi nasıl hayata geçireceğimize bakalım.

MQL5'te olay işleme - tuvali hayata geçirme

Varsayılan olarak, tuval (CDXCanvas) imlece yanıt vermeyen basit bir raster görüntüdür. Kullanıcıyla etkileşime girmesini sağlamak için grafik olaylarına abone olmanız gerekir. Bu, OnInit() fonksiyonundaki CHART_EVENT_MOUSE_... değiştiricileri aracılığıyla yapılır:

//+------------------------------------------------------------------+
//| subscribe to mouse events                                        |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- enable receiving mouse events
   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,1);
   ChartSetInteger(0,CHART_EVENT_MOUSE_WHEEL,1);
   
//--- timer for animation
   EventSetMillisecondTimer(16); 
   
   return(INIT_SUCCEEDED);
  }

Sonrasında, tüm imleç hareketleri OnChartEvent() işleyicisi tarafından işlenecektir. Bir sonraki görev, gerekli ID'leri (CHARTEVENT_MOUSE_MOVE, CHARTEVENT_MOUSE_WHEEL) filtrelemek ve koordinatları kodun render bölümüne aktarmaktır.

Notlar:

OnDeinit() içinde, bu olayları devre dışı bıraktığınızdan emin olun (ChartSetInteger(..., 0)'ı çağırarak), aksi takdirde göstergeyi sildikten sonra terminal bunları oluşturmaya devam edecek ve ekstra bir yük oluşturacaktır.

Kamera kontrolü - yörünge ve yakınlaştırma

3D grafiklerle etkileşim kurmanın en yaygın kullanılan yolu bir nesnenin etrafında dönmek (yörünge) ve yakınlaştırmak/uzaklaştırmaktır. DirectX'te bu, nesnenin kendisini döndürerek değil, kamerayı sahnenin merkezi etrafında bir küre üzerinde hareket ettirerek gerçekleştirilir.

CCanvas3D'de kamerayı kontrol etmek için birbiriyle ilişkili üç metot kullanılır:

• ViewPositionSet() - gözlemcinin gözünün konumunu ayarlar (kamera koordinatları);
• ViewTargetSet() - gözlemcinin nereye baktığını ayarlar (genellikle sahnenin merkezi 0,0,0'dır);
• ViewUpDirectionSet() - karenin üst kısmının yönünü ayarlar (böylece kamera ters dönmez).

Döndürmenin uygulanması

Döndürme işlemi, farenin sol düğmesini basılı tutarken fare imlecini hareket ettirerek gerçekleştirilir. Sahneyi döndürmek için imleç hareket deltasını takip ederiz: mevcut ve önceki konum arasındaki fark. Bu deltayı X ve Y eksenleri etrafında dönme açılarına dönüştürürüz.

//+------------------------------------------------------------------+
//| mouse movement event handler                                     |
//+------------------------------------------------------------------+
void OnMouseMove(int x, int y, uint flags)
  {
//--- check that the left mouse button is pressed
   if((flags&1)==1) 
     {
      //--- calculate the change in angles based on the mouse offset
      //--- divide by the coefficient (for example, 300.0f) for sensitivity
      m_camera_angles.y+=(x-m_mouse_x)/300.0f;
      m_camera_angles.x+=(y-m_mouse_y)/300.0f;
      //--- limit the vertical angle
      if(m_camera_angles.x<-DX_PI*0.49f)
         m_camera_angles.x=-DX_PI*0.49f;
      if(m_camera_angles.x>DX_PI*0.49f)
         m_camera_angles.x=DX_PI*0.49f;
      //--- recalculate the camera position
      UpdateCameraPosition();
      Redraw();
     }
//--- save the current coordinates for the next step
   m_mouse_x=x;
   m_mouse_y=y;
  }

UpdateCameraPosition() fonksiyonunda, kameranın yön vektörünü döndürmek ve uzaydaki konumunu güncellemek için DXMatrixRotationX ve DXMatrixRotationY döndürme matrislerini kullanırız.

Yakınlaştırma uygulaması

Fare tekerleğini döndürmek kameradan sahnenin merkezine olan mesafeyi (m_camera_distance) değiştirir.

//+------------------------------------------------------------------+
//| mouse wheel rotation event handler                               |
//+------------------------------------------------------------------+
void OnMouseWheel(double delta)
  {
//--- decrease or increase the distance
   m_camera_distance*=1.0-delta*0.001;
   
//--- limit the zoom to reasonable values
   if(m_camera_distance>50.0)
      m_camera_distance=50.0;
   if(m_camera_distance<3.0)
      m_camera_distance=3.0;

   UpdateCameraPosition();
   Redraw();
  }

3D sahnenin üstünde kullanıcı arayüzü paneli

3D grafikler verileri görüntülemekten sorumludur, ancak parametreleri kontrol etmek için standart ve tanıdık MQL5 arayüz öğelerine ihtiyacımız vardır. Tekerleği yeniden icat etmekten kaçınmak için, MQL5 standart kontrol kütüphanesinin grafik tuvalinin üstüne veya yanına çizilen sınıflarını (CAppDialog, CSlider, CComboBox vb.) kullanın. Arayüzü oluşturmak için başka sınıflar da kullanabilirsiniz.

Kaydırıcı değeri değiştiğinde (örneğin, "Kar Eşiği"), köşe arabelleğindeki verileri güncelleyen veya gölgelendirici değişkenlerini değiştiren bir fonksiyon çağrılır ve ardından Redraw() fonksiyon çağrılır. Bu, tam teşekküllü bir analitik araç oluşturmamızı sağlar. Örneğin: solda optimizasyon sonuçlarını gösteren etkileşimli bir 3D görüntü, sağda ise filtrelerin yer aldığı bir kontrol paneli bulunabilir.

Etkileşimli döngüyü optimize etme

Etkileşim, terminalin ve bir bütün olarak bilgisayarın performansını önemli ölçüde düşürmemelidir. Düğmeyi basılı tutmadan farenin her mikro hareketinde Redraw() fonksiyonunu çağırırsanız, terminal arayüzü yavaşlamaya başlayacaktır.

Etkileşimi optimize etmek için temel kuralları formüle edelim:

• Redraw() fonksiyonunu yalnızca gerekli olduğunda çağırın - sahneyi yalnızca kontrol bloklarının içinde yeniden çizin: if((flags & 1) == 1) (düğmeye basıldığında kontrol edin) veya kullanıcı arayüzü parametrelerini değiştirirken;
• Gereksiz olayları filtreleyin - yeniden çizim için veriler çok sık geliyorsa (örneğin, OnTick() işleyicisindeki tiklerden), köşe arabelleğini saniyede 10-15 kereden fazla güncellemeyin;
• Ağır hesaplamaların asenkronizasyonu - bir parametrenin değiştirilmesi binlerce köşenin yeniden hesaplanmasını gerektiriyorsa (örneğin, tüm optimizasyon yüzeyinin yeniden oluşturulması), arayüzün donmasını önlemek için bunu OnTimer() zamanlayıcı olay işleyicisinde yapın veya DLL aracılığıyla ayrı bir iş parçacığına taşıyın.

3D teknolojilerini doğrulamak için test Uzman Danışmanı

Açıklanan 3D teknolojilerini uygulayan bir Uzman Danışman geliştireceğiz. Uzman Danışman, MetaTrader 5 işlem terminalinde analitik verilerin üç boyutlu görselleştirilmesi için bir araçtır. Temel amaç, alım-satım stratejisi optimizasyonunun sayısal sonuçlarını üç boyutlu yüzeylere dönüştürerek yatırımcının ve/veya geliştiricinin stratejinin kalitesini ve istikrarını hızlı bir şekilde değerlendirmesini sağlamaktır.

Uzman Danışman aşağıdaki problemleri çözer:

• Optimizasyon yüzeyini görselleştirme - amaç fonksiyonunun (kar, beklenen değer, Sharpe oranı) optimize edilen iki strateji parametresine olan bağımlılığını üç boyutlu bir görüntü şeklinde gösterme.
• Strateji istikrar analizi - "istikrar platolarının" (sonuçlarda yumuşak değişikliklerin olduğu alanlar) ve "aşırı uyum iğnelerinin" (geçmiş verilere aşırı uyumu gösteren izole tepeler) belirlenmesi.
• Etkileşimli veri keşfi - fare ile yüzeyi döndürme, yakınlaştırma ve ayrıntılı olarak keşfetme olanağı sağlar.
• Mod karşılaştırması - optimizasyon kalitesini değerlendirmek için farklı ekran modları (örn. kar ve gürültü) arasında geçiş yapılabilir.

Özellikler:

3D görselleştirme - Uzman Danışman, grafik üzerinde 640×480 piksel boyutunda etkileşimli bir 3D tuval oluşturur; bu tuvalde, analitik fonksiyona dayalı olarak oluşturulan bir yüzey görüntülenir. Yüzey, doğru görüntüleme için üçgenleştirilmiş 25x25 köşeli bir ağdır.

Renk kodlaması - aşağıdaki renk şeması uygulanmıştır:

• Tepe (maksimum değerler) - yeşil;
• Taban (minimum değerler) - kırmızı;
• Ara değerler, sarı-turuncu tonları arasında geçiş gösteren bir gradyandır.

Bu kodlama, maksimum kar bölgelerini (yeşil "pikler") ve zarar bölgelerini (kırmızı "dipler") güvenle belirlememizi sağlar.

Kamera kontrolü - bakış açısının tam kontrolü uygulanmıştır:

• Döndürme - sol fare düğmesini basılı tutarak imleci hareket ettirmek kamerayı sahnenin merkezi etrafında küresel bir yörüngede döndürür;
• Yakınlaştırma - fare tekerleğinin kaydırılması kamerayı yakınlaştırır veya uzaklaştırır (5.0 ila 40.0 birim mesafe);
• Sınırlamalar - kameranın ters dönmesini önlemek için dikey açı ±0.9×π/2 ile sınırlandırılmıştır.

Etkileşimli kontrol

Tuval üzerinde bir mod değiştirme düğmesi bulunur:

• Kar modu - düzgün bir Gauss eğrisi yüzeyi görüntüler (istikrarlı bir stratejiyi simüle eder);
• Gürültü modu - rastgele gürültü eklenmiş bir yüzey görüntüler (aşırı optimize edilmiş bir stratejiyi simüle eder).

Modlar arasında geçiş yaparken düğme metni otomatik olarak güncellenir.

Işıklandırma ve materyaller

Gerçekçi bir hacimsel görüntü oluşturmak için üç bileşenli bir Phong ışıklandırma modeli kullanılmıştır:

• Yönlü ışık kaynağı - sarı renk (1.0, 0.95, 0.8), yön (0.5, -0.8, 0.3);
• Ortam ışıklandırması - gölge alanların daha iyi görülebilmesi için yoğunluğu artırılmış gri renk (0.55, 0.55, 0.55);
• Dağınık materyal - köşe renkleriyle doğru karıştırma için beyaz renk (1.0, 1.0, 1.0, 1.0).

Uygulama özellikleri

Eşzamansız olay işleme:

• Fare imleci hareketlerine ve tekerlek dönüşüne tepki - program OnChartEvent() fonksiyon çağrısını alır ve hemen işler (3D modelin yönü, boyutları vb. değiştirilir). Karmaşık hesaplamalar söz konusu değildir.
• Mod değiştirme düğmesine basılmasına tepki - program OnChartEvent() fonksiyon çağrısını alır ve need_rebuild bayrağını ayarlar. Eski ağın yok edilmesinden, yeni bir 3D yüzey oluşturulmasından ve render işleminden sorumlu BuildSurface() fonksiyonu, her 50 ms'de bir need_rebuild bayrağının durumunu kontrol eden OnTimer() işleyici fonksiyonunun içinde çağrılır.

Bu yaklaşım, 3D modelin yeniden hesaplanması CPU kaynaklarını kullansa bile terminal grafiğinin ve kontrollerin tamamen yanıt verebilir durumda kalmasını sağlar.

MQL5\Include\Canvas\DX\DXMath.mqh kütüphanesi ışıklandırma ve kamera yönünü doğru hesaplamak için kullanılır:

• Normaller - yüzeyin her bir köşesi için normal vektör, DXVec3Cross() vektör çarpımı fonksiyonu kullanılarak hesaplanır. Bu, yüzeyin hacimli olması ve ışık kaynağına tepki vererek gerçekçi gölgeler ve vurgular oluşturması için gereklidir.
• Kamera - gözlemcinin konumu küresel koordinatlar kullanılarak hesaplanır, bu da kameranın ters dönmesi etkisi olmadan (dikey açı sınırlanarak) bir nesnenin etrafında sezgisel dönüşe ("yörünge") olanak sağlar.

Uzman Danışmanın tam kodu makaleye ekli DX_OptimizationSurface.mq5 dosyasında yer almaktadır.

Uzman Danışmanın farklı modlardaki çalışmalarına ilişkin örnekler aşağıdaki şekillerde gösterilmiştir:

Şekil 4. Kar modu

Şekil 5. Gürültü modu

Artık tam bir araç setine sahibiz: bir sahne oluşturabilir, onu optimizasyon verileriyle doldurabilir ve kullanıcıya bu verileri döndürme ve yakınlaştırma yoluyla keşfetme olanağı sunabiliriz. Ancak 3D'yi mümkün olan her yere uygulamak için acele etmeden önce, bu teknolojinin nerede gereksiz olduğuna ve geleneksel grafiklere bağlı kalmanın daha iyi olduğu yerlere bakalım.

Normal grafiklere bağlı kalmak ne zaman daha iyidir?

Bir araç, ancak kendisinden önceki yönteme göre bir sorunu daha hızlı ve daha doğru çözdüğünde faydalıdır. DX veri hattı mimarisini keşfettik, yüzeylerin nasıl oluşturulacağını ve kameranın nasıl kontrol edileceğini öğrendik. Bununla birlikte, alım-satımda, yararlı analitik görselleştirme ile görsel gürültü kaosu arasında ayrım yapılmalıdır. 3D grafikleri MetaTrader 5'e entegre etmek kendi başına bir amaç değil, sorunları çözmenin bir yoludur. Klasik 2D lehine 3D'den vazgeçmenin teknik ve ekonomik olarak haklı olacağı durumları ele alalım.

Veri boyutluluk kuralı

3D görselleştirmenin gerekliliği için bir kural formüle edelim: üçüncü boyut benzersiz bilgi taşımalıdır:

• 3D şu durumda işe yaramaz - eğer bir zaman serisini (Fiyat/Zaman) 3D uzayda görüntülemeye çalışıyorsanız. Fiyatı veya zamanı çoğaltan bir Z ekseni eklemek yalnızca algıyı karmaşıklaştıracak ve yatırımcıyı normal trend çizgisini görmek için sahneyi döndürmeye zorlayacaktır.
• Optimizasyon sonuçları analiz edilirken 3D gereklidir. Burada iki bağımsız girdimiz (örneğin, hareketli ortalama periyodu ve durma seviyesi boyutu) ve bir çıktı ölçütümüz (kar veya kar faktörü) vardır. 3D yüzey olmadan, yalnızca bir dizi nokta göreceğiz. 3D, iki değişken ve sonuç arasındaki ilişkiyi görmemizi sağlar.

Veri kümeniz koordinat çiftlerinden oluşuyorsa, normal bir 2D grafik (DRAW_LINE, DRAW_HISTOGRAM) daha verimli olacaktır.

Donanım sınırlamaları ve VPS

MQL5'teki 3D grafikler DirectX 11 tabanlıdır. Bunun için Shader Model 5.0 desteği ve belirli bir düzeyde CPU/GPU performansı gerekir.

Çoğu profesyonel geliştirici Uzman Danışmanlarını sanal özel sunucularda (VPS) çalıştırır. Birçok standart VPS yapılandırmasında güçlü grafik kartları veya DirectX donanım hızlandırması bulunmaz. Bu tür ortamlarda CreateBitmapLabel() çağrısı bir Uzman Danışman hatasına ve/veya çökmeye neden olabilir.

Bu nedenle, programınız "kör" modda, yani grafiksiz veya ucuz bir sunucuda çalışacak şekilde tasarlanmışsa, 3D modülü devre dışı bırakılmalı veya bir dosyaya/veritabanına kaydetme ile değiştirilmelidir. 2D grafikler, ekran kartı olmadan bile CPU tarafından kolayca oluşturulabilir.

Algılama hızı - Isı haritasına karşı 3D yüzey

3D yüzeye ana alternatiflerden biri iki boyutlu ısı haritasıdır. Aralarındaki temel farklar aşağıdaki gibidir:

• 3D - yüksekliği (Z) fiziksel yükseklik olarak gösterir. Tüm kenarları ve gizli eğimleri doğru bir şekilde analiz etmek için döndürme gerektirir.
• Isı haritası - (Z) değerini (X, Y) düzlemindeki bir hücrenin rengi olarak gösterir.

Amaç maksimum optimizasyonu (en yeşil bölge) hızlı bir şekilde bulmaksa, ısı haritası daha hızlı çalışacak ve daha az kod gerektirecektir.

Etkileşim vs izleme

Etkileşimli 3D sahneler (DX_OptimizationSurface Uzman Danışmanımız gibi) aktif insan katılımı gerektirir. Farenizi üzerine getirmeniz, düğmeyi basılı tutmanız ve döndürmeniz gerekir.

Grafiğin amacı izleme ise (durumun arka planda takip edilmesi), etkileşimli 3D grafikler dikkat dağıtıcı olabilir ve süreci yavaşlatabilir.

Amaç bir stratejiyi başlatmadan önce bir sunum veya derinlemesine analiz ise, 3D vazgeçilmezdir.

Sonuç: 

3D'yi yalnızca veri hacmi veya yapısı 2D'de analizi imkansız hale getirdiğinde kullanın. Amacınız bir optimizasyon tablosundaki maksimum değeri hızlı bir şekilde bulmaksa, bir ısı haritası işinizi daha iyi görecektir. Sadece değeri değil, ilişkinin biçimini de görmeniz gereken yerlerde 3D gereklidir.

Diğer durumlarda, standart MQL5 sınıfları (2D veya grafiksel nesneler için CCanvas) daha basit bir çözüm olacaktır.

Sonuç

3D grafik ihtiyacını teorik olarak gerekçelendirmekten başlayıp, tam teşekküllü bir etkileşimli Uzman Danışmanın oluşturulmasına ilerledik. DX_OptimizationSurface Uzman Danışmanı, MetaTrader 5'in yalnızca emir gerçekleştirme için bir terminal değil, aynı zamanda görsel veri analizi için güçlü bir platform olduğunu göstermektedir.

Önemli bulgular:

• Bilişsel verimlilik - 3D görselleştirme, sonsuz sayı dizilerini görsel sunumlara dönüştürmemizi sağlar. Bu, yatırımcı üzerindeki bilişsel yükü azaltarak, istikrarlı kar platolarını tehlikeli aşırı uyum iğnelerinden görsel olarak ayırt etmesini sağlar.
• Teknolojik erişilebilirlik - yerleşik DirectX 11 desteği ve yerel CCanvas3D ve CDXMesh sınıfları, geliştiricilere alım-satım problemlerini çözmeleri için araçlar sağlar. C++ kodu yazmaya veya harici kütüphaneleri dahil etmeye gerek yoktur - her şey zaten MQL5'in içindedir. Geriye sadece bundan yararlanmak kalıyor.
• Mimarinin önemi - gördüğümüz gibi, grafikleri entegre etmek kaynak yaşam döngülerine ve eşzamansızlığa dikkat etmeyi gerektiriyor. Hesaplama işlemlerinin bir zamanlayıcıya taşınması ve belleğin uygun şekilde temizlenmesi, terminal performansında sorun yaşanmayacağının garantisidir.

Görselleştirme bir mercektir, dekorasyon değil. Belirli bir analitik soruya cevap vermelidir.

Bu aracı bir dış etki için değil, karar alma sürecini hızlandırmak için oluşturduk. 3D grafikler bir stratejinin davranışını hızlı bir şekilde anlamanıza ve uygun olmayan seçenekleri filtrelemenize yardımcı oluyorsa, o zaman amacına hizmet etmiştir. Eğer bu sadece dikkat dağıtıcı bir şeyse, kanıtlanmış 2D yöntemlere geri dönmekten çekinmeyin. Bir araç nasıl göründüğü için değil, hızlandırmaya yardımcı olduğu kararlar nedeniyle değerlidir.

Sonraki adımlar - konuyu daha derinlemesine incelemek isteyenler için aşağıdakileri öneriyoruz:

• Kuaterniyonlar ve karmaşık dönüşümlerle çalışmak için DXMath kütüphanesini keşfetme.
• Benzersiz render efektleri oluşturmak için özel gölgelendiriciler (HLSL) geliştirme.
• Terminalde görselleştirmeden önce verileri önceden işlemek için MetaTrader 5 aracılığıyla Python ile entegrasyon.

MetaTrader 5 teknolojik temeli sağlar. Bunun üzerine inşa edeceğiniz analitik araçlar yalnızca hayal gücünüze ve sonsuz piyasa verilerinde "inciler" arama ihtiyacınıza bağlıdır.

MetaTrader 5'te DirectX ile nasıl çalışılacağını öğrenmek için önerilen kaynaklar:

• MetaEditor DirectX yardımı,
• MetaTrader 5'te DirectX’i kullanarak 3D grafikler nasıl oluşturulur?,
• DirectX Kılavuzu (Bölüm I): İlk üçgeni çizme,
• MetaTrader 5 Sınayıcısında Bir Stratejiyi Görselleştirme.

Makaleye ekli dosyaların listesi:

Dosya adı	Açıklama
DX_OptimizationSurface.mq5	Etkileşimli 3D görselleştirmeye sahip bir test Uzman Danışmanının kodunu içeren dosya