mobinzkr/MobinMQL
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
MobinMQL/Experts/Examples/Correlation Matrix 3D/Correlation Matrix 3D.mq5

1003 lines
76 KiB
MQL5
Raw Permalink Normal View History

Init
2025-07-22 14:48:34 +03:00
<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//| CorrelationMatrix3D.mq5 |
//| Copyright 2000-2025, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2025, MetaQuotes Ltd."
#property link "https://www.mql5.com"
#property version "1.00"
//---
#include <Controls\Picture.mqh>
#include <Canvas\Canvas3D.mqh>
#include <Canvas\DX\DXBox.mqh>
//--- constants
#define BAR_WIDTH 1.25f
#define BAR_HEIGHT 5.0f
//--- input data
input color InpBackground = clrWhiteSmoke; // Background color
input datetime InpStartDate = D'01.01.2015';
input datetime InpFinishDate = D'01.11.2019';
input string InpSymbolsList = "EURUSD,EURGBP,EURCHF,EURJPY,GBPUSD,GBPCHF,GBPJPY,USDCHF,USDJPY,CHFJPY";
//+------------------------------------------------------------------+
//| sSymbolData |
//+------------------------------------------------------------------+
struct sSymbolData
{
string name;
//--- synchronized close prices
MqlRates rates[];
//--- percent of empty bars
double zero_data_percent;
//--- times and returns (in points)
datetime returns_times[];
double returns_prices_points[];
//--- array with current data window
double current_data_array[];
bool synchronized_flag;
datetime history_first_date;
};
//+------------------------------------------------------------------+
//| Application window |
//+------------------------------------------------------------------+
class CCanvas3DWindow
{
protected:
CPicture m_picture;
CCanvas3D m_canvas;
//---
int m_width;
int m_height;
uint m_background_color;
uint m_text_color;
//--- function data
double m_data[];
int m_data_size;
//--- source functions data
CDXBox m_boxes[];
//---
DXVector4 m_labels_x[];
DXVector4 m_labels_z[];
//--- rotation Y
float m_angle_y;
float m_angle_x;
int m_mouse_x_old;
int m_mouse_y_old;
//--- price data for correlations calculations
int m_total_symbols;
string m_symbols_used;
sSymbolData m_symbols_data[];
bool m_data_ready;
ENUM_TIMEFRAMES m_timeframe;
int m_timeframe_minutes;
//---
datetime m_date_start; // start date
datetime m_date_finish; // finish date
//---
datetime m_date_current; // date of data at current index
int m_index_current; // current index
int m_index_boundary1; // inital index for sliding window
int m_index_boundary2; // final index for sliding window
int m_data_count;
bool m_symbol_selected[]; // array with flags to draw symbol
//---
int m_window_size_bars; // window size
int m_index_step_bars; // sliding window
int m_time_format; // time format
public:
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
CCanvas3DWindow(void):m_angle_y(0),m_angle_x(0),m_mouse_x_old(-1),m_mouse_y_old(-1)
{
}
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
~CCanvas3DWindow(void)
{
int count=ArraySize(m_boxes);
for(int i=0; i<count; i++)
m_boxes[i].Shutdown();
}
//+------------------------------------------------------------------+
//| Update boxes |
//+------------------------------------------------------------------+
bool UpdateBoxes()
{
float offset=BAR_WIDTH*(m_data_size-1)/2.0f;
DXMatrix translation;
DXMatrix scale;
DXColor clr;
for(int i=0; i<m_data_size; i++)
for(int j=0; j<m_data_size; j++)
{
int idx=i*m_data_size+j;
float value=(i==j)?0.0f:(float)m_data[idx];
if(fabs(value)<0.001f || (!m_symbol_selected[i] && !m_symbol_selected[j]))
value=0.001f;
//--- check value sign, never use negative scale
if(value>0)
{
DXMatrixTranslation(translation,i*BAR_WIDTH-offset,0.0,j*BAR_WIDTH-offset);
DXMatrixScaling(scale,BAR_WIDTH,value*BAR_HEIGHT,BAR_WIDTH);
}
else
{
DXMatrixTranslation(translation,i*BAR_WIDTH-offset,value*BAR_HEIGHT,j*BAR_WIDTH-offset);
DXMatrixScaling(scale,BAR_WIDTH,-value*BAR_HEIGHT,BAR_WIDTH);
}
//---
DXMatrixMultiply(translation,scale,translation);
m_boxes[idx].TransformMatrixSet(translation);
if(i==j)
clr=DXColor(0.5,0.5,0.5,1.0);
else
DXComputeColorRedToGreen((float)m_data[idx]*0.5f+0.5f,clr);
m_boxes[idx].DiffuseColorSet(clr);
}
//--- prepare to scrren space projection matrix
DXMatrix projection,view;
m_canvas.ViewMatrixGet(view);
m_canvas.ProjectionMatrixGet(projection);
DXMatrixMultiply(projection,view,projection);
for(int j=-1,idx=0; j<=1; j+=2)
for(int i=0; i<m_data_size; i++,idx++)
{
//--- calculate labels positions in screen space
DXVec4Transform(m_labels_x[idx],DXVector4(i*BAR_WIDTH-offset,0.0,j*(BAR_WIDTH+offset),1.0),projection);
if(m_labels_x[idx].w>0)
DXVec4Scale(m_labels_x[idx],m_labels_x[idx],1.0f/m_labels_x[idx].w);
DXVec4Transform(m_labels_z[idx],DXVector4(j*(BAR_WIDTH+offset),0.0,i*BAR_WIDTH-offset,1.0),projection);
if(m_labels_z[idx].w>0)
DXVec4Scale(m_labels_z[idx],m_labels_z[idx],1.0f/m_labels_z[idx].w);
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| Update boxes |
//+------------------------------------------------------------------+
bool UpdateCamera()
{
DXVector4 camera=DXVector4(0.0f,0.0f,-30.0f,1.0f);
DXVector4 light =DXVector4(0.25f,-0.25f,1.0f,0.0f);
DXMatrix rotation;
DXMatrixRotationX(rotation,m_angle_x);
DXVec4Transform(camera,camera,rotation);
DXVec4Transform(light,light,rotation);
DXMatrixRotationY(rotation,m_angle_y);
DXVec4Transform(camera,camera,rotation);
DXVec4Transform(light,light,rotation);
m_canvas.ViewPositionSet(DXVector3(camera));
m_canvas.LightDirectionSet(DXVector3(light));
//---
return(true);
}
//+------------------------------------------------------------------+
//| CopyRatesTimeSynchronized |
//+------------------------------------------------------------------+
bool CopyRatesTimeSynchronized(string symbol,ENUM_TIMEFRAMES timeframe,datetime time1,datetime time2,MqlRates &rates[])
{
//--- check parameters
if(time1>=time2)
{
PrintFormat("Wrong times. Start time=%s, Finish time=%s",TimeToString(time1,TIME_DATE|TIME_MINUTES|TIME_SECONDS),TimeToString(time2,TIME_DATE|TIME_MINUTES|TIME_SECONDS));
return(false);
}
//---
ResetLastError();
MqlRates server_rates[];
ArraySetAsSeries(server_rates,false);
int rates_copied=CopyRates(symbol,timeframe,time1,time2,server_rates);
if(rates_copied==-1)
{
PrintFormat("CopyRates error, rates_copied=%d Error=%d",rates_copied,GetLastError());
return(false);
}
//---
uint time_delta = uint(time2-time1);
int data_needed = int(time_delta/(60*m_timeframe_minutes))+1;
//--- prepare rates with correct continous times data
ArrayResize(rates,data_needed);
ArraySetAsSeries(rates,false);
ZeroMemory(rates);
//--- prepare times data
int data_count=0;
datetime time=time1;
while(time<=time2)
{
rates[data_count].time=time;
data_count++;
time+=m_timeframe_minutes*60;
}
//--- analyze data gaps
int total_gap_bars=0;
int previous_time_index = 0;
int fill_bars_needed=0;
double current_price_close=0;
double previous_price_close=0;
for(int i=0; i<rates_copied; i++)
{
current_price_close=server_rates[i].close;
int time_index = int ((server_rates[i].time-time1)/(60*m_timeframe_minutes));
bool gap_found=((time_index-previous_time_index)>1);
if(gap_found)
{
//--- gap needed to fill with previous close price
if(time_index>=0 || time_index<data_count)
{
fill_bars_needed=time_index-previous_time_index-1;
for(int k=0; k<fill_bars_needed; k++)
{
//rates[previous_time_index+k+1].close=previous_price_close;
rates[previous_time_index+k+1].close=0; // mark gap
total_gap_bars++;
}
//--- current bar
if(rates[time_index].time==server_rates[i].time)
rates[time_index].close=current_price_close;
else
{
PrintFormat("The times are different: %d vs %d",rates[time_index].time,server_rates[i].time);
}
}
}
else
{
//--- no gap, normal set close price
if(time_index>=0 || time_index<data_count)
{
rates[time_index].close=current_price_close;
}
else
{
Print("Error in time_index=%d",time_index);
}
}
//---
previous_time_index = time_index;
previous_price_close = current_price_close;
}
//---
int total_zero_bars=0;
for(int i=0; i<data_count; i++)
{
if(rates[i].close==0)
total_zero_bars++;
}
PrintFormat("Total=%d bars. Symbol=%s, time1=%s, time2=%s. Total gaps filled=%d, Total zero bars=%d",data_count,symbol,
TimeToString(time1,TIME_DATE|TIME_MINUTES|TIME_SECONDS),TimeToString(time2,TIME_DATE|TIME_MINUTES|TIME_SECONDS),
total_gap_bars,total_zero_bars);
//---
return(true);
}
//+------------------------------------------------------------------+
//| FilterNonzeroRates |
//+------------------------------------------------------------------+
bool FilterNonzeroRates(void)
{
if(m_total_symbols==0)
return(false);
if(ArraySize(m_symbols_data)!=m_total_symbols)
return(false);
//---
int rates_count=ArraySize(m_symbols_data[0].rates);
for(int i=0; i<m_total_symbols; i++)
{
if(ArraySize(m_symbols_data[i].rates)!=rates_count)
{
PrintFormat("Symbol: %s Wrong array size=%d vs %d",m_symbols_data[i].name,ArraySize(m_symbols_data[i].rates),rates_count);
DebugBreak();
return(false);
}
}
//---
int total_nonzero_rates=0;
bool rates_flags[];
ArrayResize(rates_flags,rates_count);
ZeroMemory(rates_flags);
for(int i=0; i<rates_count; i++)
{
int counter=0;
for(int k=0; k<m_total_symbols; k++)
{
if(m_symbols_data[k].rates[i].close>0)
counter++;
}
if(counter==m_total_symbols)
{
rates_flags[i]=true;
total_nonzero_rates++;
}
}
//---
total_nonzero_rates=0;
//--- filter nonzero rates
for(int i=0; i<rates_count; i++)
{
if(rates_flags[i]==true)
{
for(int k=0; k<m_total_symbols; k++)
{
m_symbols_data[k].rates[total_nonzero_rates]=m_symbols_data[k].rates[i];
}
total_nonzero_rates++;
}
}
for(int k=0; k<m_total_symbols; k++)
ArrayResize(m_symbols_data[k].rates,total_nonzero_rates);
PrintFormat("rates_count=%d total_nonzero_rates=%d",rates_count,total_nonzero_rates);
//---
return(true);
}
//+------------------------------------------------------------------+
//| PreparePriceReturnsInPoints |
//+------------------------------------------------------------------+
bool PreparePriceReturnsInPoints(int symbol_index)
{
double point_size=SymbolInfoDouble(m_symbols_data[symbol_index].name,SYMBOL_POINT);
if(point_size==0)
{
PrintFormat("Wrong point size =%f for symbol=%s. ",point_size,m_symbols_data[symbol_index].name);
return(false);
}
//---
int data_count=ArraySize(m_symbols_data[symbol_index].rates);
if(data_count==0)
return(false);
//--- prepare price returns in points
int returns_count=data_count-1;
ArrayResize(m_symbols_data[symbol_index].returns_times,returns_count);
ArrayResize(m_symbols_data[symbol_index].returns_prices_points,returns_count);
//---
for(int i=0; i<returns_count; i++)
{
double price1=m_symbols_data[symbol_index].rates[i].close;
double price2=m_symbols_data[symbol_index].rates[i+1].close;
double delta=(price2-price1)/point_size;
if(price1==0 || price2==0)
delta=0;
//---
m_symbols_data[symbol_index].returns_prices_points[i]=delta;
m_symbols_data[symbol_index].returns_times[i]=m_symbols_data[symbol_index].rates[i+1].time;
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| SymbolsDataReady |
//+------------------------------------------------------------------+
bool SymbolsDataReady(datetime start_date)
{
//---
bool all_symbols_synchronized = true;
datetime first_date = start_date;
//---
for(int n_tries=0; n_tries<100 && !IsStopped(); n_tries++, Sleep(50))
{
all_symbols_synchronized=true;
//--- proceed all symbols
for(int i=0; i<m_total_symbols; i++)
{
m_symbols_data[i].synchronized_flag=SeriesInfoInteger(m_symbols_data[i].name,m_timeframe,SERIES_SYNCHRONIZED);
if(m_symbols_data[i].synchronized_flag)
{
if(SeriesInfoInteger(m_symbols_data[i].name,m_timeframe,SERIES_FIRSTDATE,(long&)m_symbols_data[i].history_first_date))
{
if(m_symbols_data[i].history_first_date>first_date)
first_date = m_symbols_data[i].history_first_date;
continue;
}
else
Print("Symbol '",m_symbols_data[i].name,"' first date is not available");
}
else
Print("Symbol '",m_symbols_data[i].name,"' is not synchronized");
//--- try to check
all_symbols_synchronized=false;
datetime tmp[1];
CopyTime(m_symbols_data[i].name,m_timeframe,first_date,1,tmp);
}
//--- all symbols synchonized
if(all_symbols_synchronized)
break;
//---
Print("Try again #",n_tries);
}
//--- check all synchronized
if(!all_symbols_synchronized)
{
Print("Some symbols not ready to use:");
for(int i=0; i<m_total_symbols; i++)
if(!m_symbols_data[i].synchronized_flag)
PrintFormat("%s ",m_symbols_data[i].name);
return(false);
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| PrepareData |
//+------------------------------------------------------------------+
bool PrepareData(string symbols, datetime start_date,datetime finish_date)
{
//--- check dates
if(start_date>finish_date)
{
PrintFormat("Error in dates settings: start date=%s, finish date=%s",TimeToString(start_date,m_time_format),TimeToString(finish_date,m_time_format));
return(false);
}
//---
m_timeframe=PERIOD_D1;
m_timeframe_minutes=GetTimeframeMinutes(m_timeframe);
m_time_format=TIME_DATE;
if(m_timeframe<PERIOD_H6)
m_time_format|=TIME_MINUTES;
//--- check if symbols exists
string symbols_list[]= {};
StringSplit(symbols,',',symbols_list);
m_total_symbols=0;
m_symbols_used="";
for(int i=0; i<ArraySize(symbols_list); i++)
{
PrintFormat("%d %s ",i,symbols_list[i]);
bool is_custom=false;
if(SymbolExist(symbols_list[i],is_custom)==false)
{
PrintFormat("Error. Symbol %s is not found.",symbols_list[i]);
return(false);
}
m_total_symbols++;
m_symbols_used+=" "+symbols_list[i];
}
//---
if(m_total_symbols==0)
{
Print("No symbols.");
return(false);
}
//--- resize selected flags
ArrayResize(m_symbol_selected,m_total_symbols);
ArrayInitialize(m_symbol_selected,true);
//--- prepare structure for symbols
ArrayResize(m_symbols_data,m_total_symbols);
for(int i=0; i<m_total_symbols; i++)
ZeroMemory(m_symbols_data[i]);
for(int i=0; i<m_total_symbols; i++)
{
m_symbols_data[i].name=symbols_list[i];
m_symbols_data[i].synchronized_flag=false;
}
//--- check data
if(!SymbolsDataReady(start_date))
{
PrintFormat("Error. Symbols not synchronized.");
return(false);
}
//---
m_date_start=start_date;
m_date_finish=finish_date;
//--- Pass 1. prepare time synchronized data with gaps marked with rates[k].close=0;
for(int i=0; i<m_total_symbols; i++)
{
if(CopyRatesTimeSynchronized(m_symbols_data[i].name,m_timeframe,m_date_start,m_date_finish,m_symbols_data[i].rates))
{
double point_size=SymbolInfoDouble(m_symbols_data[i].name,SYMBOL_POINT);
if(point_size==0)
{
PrintFormat("Wrong point size =%f for symbol=%s. ",point_size,m_symbols_data[i].name);
return(false);
}
}
else
{
Print("Error in CopyRatesTimeSynchronized for symbol = %s ",m_symbols_data[i].name);
return(false);
}
}
//--- Pass 2. Filter nonzero quotes for all symbols
FilterNonzeroRates();
//--- Pass 3. Calculate return prices in points for all symbol
for(int i=0; i<m_total_symbols; i++)
{
PreparePriceReturnsInPoints(i);
}
m_data_count=ArraySize(m_symbols_data[0].returns_prices_points);
m_window_size_bars = 100;
if(m_data_count<m_window_size_bars)
{
PrintFormat("Window size=%d is too small.",m_window_size_bars);
return(false);
}
m_index_boundary1 = 0;
m_index_boundary2 = m_data_count-1-m_window_size_bars;
m_index_current = 200;
m_index_step_bars = 1;
m_data_size=m_total_symbols;
//---
return(true);
}
//+------------------------------------------------------------------+
//| CorrelationPearson |
//+------------------------------------------------------------------+
double CorrelationPearson(double &X[], double &Y[])
{
int N = ArraySize(X);
double sum_X = 0, sum_Y = 0, sum_XY = 0;
double squareSum_X = 0, squareSum_Y = 0;
for(int i=0; i<N; i++)
{
sum_X += X[i];
sum_Y += Y[i];
sum_XY += X[i]*Y[i];
squareSum_X += X[i]*X[i];
squareSum_Y += Y[i]*Y[i];
}
double multi_sigma=(N*squareSum_X-sum_X*sum_X)*(N*squareSum_Y-sum_Y*sum_Y);
if(multi_sigma==0)
return(0);
double corr = (double)(N*sum_XY-sum_X*sum_Y)/MathSqrt(multi_sigma);
//---
return(corr);
}
//+------------------------------------------------------------------+
//| CopyData |
//+------------------------------------------------------------------+
bool CopyData(double &data_array[],const int index,int count,double &out_data_array[])
{
int size=ArraySize(data_array);
if(size==0)
return(false);
//---
if(index+count>size)
{
PrintFormat("Error in index=%d count=%d ArraySize(data_array)=%d",index,count,ArraySize(data_array));
return(false);
}
//---
ArrayResize(out_data_array,count);
ZeroMemory(out_data_array);
for(int i=0; i<count; i++)
{
out_data_array[i]=data_array[i+index];
}
//---
return(true);
}
//+------------------------------------------------------------------+
//| CalculatePearsonCoefficient |
//+------------------------------------------------------------------+
bool CalculatePearsonCoefficient(double &value,const int ind1,const int ind2, const int data_start_index, const int count)
{
value=0.0;
//--- check parameters
if(ind1<0 || ind1>=m_total_symbols)
return(false);
if(ind2<0 || ind2>=m_total_symbols)
return(false);
//---
bool res1=CopyData(m_symbols_data[ind1].returns_prices_points,data_start_index,count,m_symbols_data[ind1].current_data_array);
bool res2=CopyData(m_symbols_data[ind2].returns_prices_points,data_start_index,count,m_symbols_data[ind2].current_data_array);
//--- check data
int size1=ArraySize(m_symbols_data[ind1].current_data_array);
if(size1==0)
return(false);
//---
if(res1 && res2)
value=CorrelationPearson(m_symbols_data[ind1].current_data_array,m_symbols_data[ind2].current_data_array);
else
return(false);
//---
return(true);
}
//+------------------------------------------------------------------+
//| Prepare box geometry |
//+------------------------------------------------------------------+
virtual bool PrepareBoxes(void)
{
ArrayResize(m_boxes,m_data_size*m_data_size);
//--- create boxes
for(int i=0; i<m_data_size; i++)
for(int j=0; j<m_data_size; j++)
{
int idx=i*m_data_size+j;
m_data[idx]=0;
m_boxes[idx].Create(m_canvas.DXDispatcher(),m_canvas.InputScene(),DXVector3(-0.45f,0.0,-0.45f),DXVector3(0.45f,1.0f,0.45f));
m_boxes[idx].SpecularColorSet(DXColor(1.0f,1.0f,1.0f,0.5f));
m_boxes[idx].SpecularPowerSet(128.0);
m_canvas.ObjectAdd(&m_boxes[idx]);
}
//--- success
return(true);
}
//+------------------------------------------------------------------+
//| Create |
//+------------------------------------------------------------------+
virtual bool Create(const int width,const int height,color background_color)
{
if(m_data_size<1)
{
PrintFormat("No symbols selected.");
return(false);
}
//--- prepare the chart
ChartSetInteger(0,CHART_SHOW,false);
ChartRedraw();
//--- save sizes
m_width=width;
m_height=height;
if(m_width<1)
m_width=1;
if(m_height<1)
m_height=1;
//---
ResetLastError();
if(!m_canvas.CreateBitmapLabel("CorrelationMatrix3D",0,0,m_width,m_height,COLOR_FORMAT_ARGB_NORMALIZE))
{
Print("Error creating canvas: ",GetLastError());
return(false);
}
//--- set colors
m_background_color=ColorToARGB(background_color);
if((GETRGBR(m_background_color)+GETRGBG(m_background_color)+GETRGBB(m_background_color))/3<128)
m_text_color=ColorToARGB(clrWhite);
else
m_text_color=ColorToARGB(clrNavy);
//---
m_canvas.ProjectionMatrixSet((float)M_PI/6,(float)width/height,0.1f,100.0f);
m_canvas.ViewTargetSet(DXVector3(0.0,0.0,0.0));
m_canvas.ViewUpDirectionSet(DXVector3(0.0,1.0,0.0));
m_canvas.LightColorSet(DXColor(1.0f,1.0f,0.9f,0.55f));
m_canvas.AmbientColorSet(DXColor(0.9f,0.9f,1.0f,0.55f));
m_angle_y=DX_PI/12.0f;
m_angle_x=DX_PI/4.0f;
//--- prepare data and boxes
ArrayResize(m_data,m_data_size*m_data_size);
if(!PrepareBoxes())
return(false);
//--- prepare label points
ArrayResize(m_labels_x,2*m_data_size);
ArrayResize(m_labels_z,2*m_data_size);
//--- redraw data
RedrawData();
//--- succeed
return(true);
}
//+------------------------------------------------------------------+
//| Draw labels |
//+------------------------------------------------------------------+
void DrawLabels()
{
int alignment=TA_CENTER|TA_VCENTER;
//--- set font size
int font_size=int(13.0*m_height/600.0+0.5);
if(font_size<8)
font_size=8;
if(font_size>54)
font_size=54;
m_canvas.FontSizeSet(font_size);
m_canvas.FontSet("Arial",font_size,FW_SEMIBOLD);
//--- draw x axis on right side
float dx1=m_labels_x[m_data_size-1].x-m_labels_x[0].x;
float dx2=m_labels_x[m_data_size].x-m_labels_x[2*m_data_size-1].x;
int tx=0,ty=0;
if(dx1>dx2)
{
for(int i=0; i<m_data_size; i++)
{
tx=(int)(m_width*(0.5f+0.5f*m_labels_x[i].x));
ty=(int)(m_height*(0.5f-0.5f*m_labels_x[i].y));
m_canvas.TextOut(tx,ty,m_symbols_data[i].name,m_text_color,alignment);
}
}
else
{
for(int i=0; i<m_data_size; i++)
{
int idx=i+m_data_size;
tx=(int)(m_width*(0.5f+0.5f*m_labels_x[idx].x));
ty=(int)(m_height*(0.5f-0.5f*m_labels_x[idx].y));
m_canvas.TextOut(tx,ty,m_symbols_data[i].name,m_text_color,alignment);
}
}
//--- draw z axis on right side
dx1=m_labels_z[m_data_size-1].x-m_labels_z[0].x;
dx2=m_labels_z[m_data_size].x-m_labels_z[2*m_data_size-1].x;
//--- draw z axis on left side
if(dx2>dx1)
{
for(int i=0; i<m_data_size; i++)
{
tx=(int)(m_width*(0.5f+0.5f*m_labels_z[i].x));
ty=(int)(m_height*(0.5f-0.5f*m_labels_z[i].y));
m_canvas.TextOut(tx,ty,m_symbols_data[i].name,m_text_color,alignment);
}
}
else
{
for(int i=0; i<m_data_size; i++)
{
int idx=i+m_data_size;
tx=(int)(m_width*(0.5f+0.5f*m_labels_z[idx].x));
ty=(int)(m_height*(0.5f-0.5f*m_labels_z[idx].y));
m_canvas.TextOut(tx,ty,m_symbols_data[i].name,m_text_color,alignment);
}
}
}
//+------------------------------------------------------------------+
//| SetSelected |
//+------------------------------------------------------------------+
void SetSelected(int number)
{
if(number<0 || number>=ArraySize(m_symbol_selected))
return;
//---
m_symbol_selected[number]=!m_symbol_selected[number];
}
//+------------------------------------------------------------------+
//| UpdateCorrelationMatrix |
//+------------------------------------------------------------------+
void UpdateCorrelationMatrix()
{
if(ArraySize(m_symbols_data)==0)
return;
//--- calculate matrix of Pearson coefficients
for(int i=0; i<m_data_size; i++)
{
for(int j=i; j<m_data_size; j++)
{
if(i==j)
{
m_data[i*m_data_size+j]=1.0;
}
else
{
double value=0;
if(CalculatePearsonCoefficient(value,i,j,m_index_current,m_window_size_bars))
{
m_data[i*m_data_size+j]=value;
m_data[j*m_data_size+i]=value;
}
}
}
}
}
//+------------------------------------------------------------------+
//| Update frame |
//+------------------------------------------------------------------+
void Redraw()
{
//--- update
m_canvas.Render(DX_CLEAR_COLOR|DX_CLEAR_DEPTH,m_background_color);
string str=TimeToString(m_date_current,m_time_format);
m_canvas.FontSet("Arial",64,FW_BLACK);
m_canvas.TextOut(25,15,str,m_text_color,0);
//--- draw axis labels
DrawLabels();
//---
m_canvas.Update();
}
//+------------------------------------------------------------------+
//| RedrawData |
//+------------------------------------------------------------------+
void RedrawData()
{
UpdateCorrelationMatrix();
UpdateCamera();
UpdateBoxes();
//---
Redraw();
}
//+------------------------------------------------------------------+
//| Process mouse moving event |
//+------------------------------------------------------------------+
void OnMouseEvent(int x,int y,uint flags)
{
if((flags&1)==1)
{
if(m_mouse_x_old!=-1)
{
m_angle_y+=(x-m_mouse_x_old)/300.0f;
m_angle_x+=(y-m_mouse_y_old)/300.0f;
if(m_angle_x<-DX_PI*0.49f)
m_angle_x=-DX_PI*0.49f;
if(m_angle_x>DX_PI*0.49f)
m_angle_x=DX_PI*0.49f;
//---
RedrawData();
}
//---
m_mouse_x_old=x;
m_mouse_y_old=y;
}
else
{
m_mouse_x_old=-1;
m_mouse_y_old=-1;
}
}
//+------------------------------------------------------------------+
//| Process chart change event |
//+------------------------------------------------------------------+
void OnChartChange(void)
{
//--- get current chart window size
int w=(int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
int h=(int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- update size everywhere it needed
if(w!=m_width || h!=m_height)
{
m_width =w;
m_height=h;
if(m_width<1)
m_width=1;
if(m_height<1)
m_height=1;
m_canvas.Resize(w,h);
DXContextSetSize(m_canvas.DXContext(),w,h);
m_canvas.ProjectionMatrixSet((float)M_PI/6,(float)m_width/m_height,0.1f,100.0f);
Redraw();
}
}
//+------------------------------------------------------------------+
//| Timer handler |
//+------------------------------------------------------------------+
void OnTimer(void)
{
//--- update time
m_index_current += m_index_step_bars;
//--- reverse time
if(m_index_current<m_index_boundary1)
{
m_index_step_bars *= -1;
m_index_current=m_index_boundary1;
m_date_current=m_symbols_data[0].returns_times[m_index_current+m_window_size_bars];
PrintFormat("REVERSE TIME %s at index=%d",TimeToString(m_date_current,m_time_format),m_index_current);
}
else
if(m_index_current>m_index_boundary2)
{
m_index_step_bars *= -1;
m_index_current=m_index_boundary2;
m_date_current=m_symbols_data[0].returns_times[m_index_current+m_window_size_bars];
PrintFormat("REVERSE TIME %s at index=%d",TimeToString(m_date_current,m_time_format),m_index_current);
}
m_date_current=m_symbols_data[0].returns_times[m_index_current+m_window_size_bars];
//---
RedrawData();
}
};
CCanvas3DWindow *ExtAppWindow;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,1);
//--- get current chart window size
int width =(int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
int height=(int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
//--- create canvas
ExtAppWindow=new CCanvas3DWindow();
if(!ExtAppWindow.PrepareData(InpSymbolsList,InpStartDate,InpFinishDate))
{
PrintFormat("Error. Rates data is not loaded.");
return(INIT_FAILED);
}
if(!ExtAppWindow.Create(width,height,InpBackground))
{
return(INIT_FAILED);
}
//--- set timer
EventSetMillisecondTimer(10);
//---
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- destroy
delete ExtAppWindow;
//--- revert chart showing mode
ChartSetInteger(0,CHART_SHOW,true);
}
//+------------------------------------------------------------------+
//| OnTick function |
//+------------------------------------------------------------------+
void OnTick()
{
ExtAppWindow.RedrawData();
}
//+------------------------------------------------------------------+
//| ChartEvent function |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam)
{
//---
if(id==CHARTEVENT_KEYDOWN)
{
if(lparam==27)
ExpertRemove();
if(lparam>='0' && lparam<='9')
{
int index=(int)(lparam-'1');
if(index<0)
index=9;
ExtAppWindow.SetSelected(index);
}
}
if(id==CHARTEVENT_CHART_CHANGE)
ExtAppWindow.OnChartChange();
//--- process mouse moving
if(id==CHARTEVENT_MOUSE_MOVE)
ExtAppWindow.OnMouseEvent((int)lparam,(int)dparam,(uint)sparam);
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer()
{
ExtAppWindow.OnTimer();
}
//+------------------------------------------------------------------+
//| GetTimeframeMinutes |
//+------------------------------------------------------------------+
int GetTimeframeMinutes(ENUM_TIMEFRAMES timeframe)
{
switch(timeframe)
{
case PERIOD_M1:
return(1);
case PERIOD_M2:
return(2);
case PERIOD_M3:
return(3);
case PERIOD_M4:
return(4);
case PERIOD_M5:
return(5);
case PERIOD_M6:
return(6);
case PERIOD_M10:
return(10);
case PERIOD_M12:
return(12);
case PERIOD_M15:
return(15);
case PERIOD_M20:
return(20);
case PERIOD_M30:
return(30);
case PERIOD_H1:
return(60);
case PERIOD_H2:
return(2*60);
case PERIOD_H3:
return(3*60);
case PERIOD_H4:
return(4*60);
case PERIOD_H6:
return(6*60);
case PERIOD_H8:
return(8*60);
case PERIOD_H12:
return(12*60);
case PERIOD_D1:
return(24*60);
case PERIOD_W1:
return(7*24*60);
default:
return(0);
}
//---
return(0);
};
//+------------------------------------------------------------------+
Reference in a new issue Copy permalink