462 lines
20 KiB
MQL5
462 lines
20 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| GexMap.mq5 |
| |||
//| MMQ — Muhammad Minhas Qamar |
| |||
//| www.mql5.com/en/articles/23410 |
| |||
//+------------------------------------------------------------------+
| |||
#property copyright "MMQ — Muhammad Minhas Qamar"
| |||
#property link "https://www.mql5.com/en/articles/23410"
| |||
#property version "1.10"
| |||
#property description "Dealer gamma-exposure (GEX) map: per-strike exposure, call/put walls, and the zero-gamma flip, drawn on the price chart at real strike levels."
| |||
#property indicator_chart_window
| |||
#property indicator_plots 0
| |||
#property indicator_buffers 0
| |||
| |||
#include <Canvas/Canvas.mqh>
| |||
#include <GEX/GexData.mqh>
| |||
#include <GEX/GexProviderNative.mqh>
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Inputs |
| |||
//+------------------------------------------------------------------+
| |||
enum ENUM_GEX_SOURCE
| |||
{
| |||
GEX_SOURCE_CSV = 0, // read a chain CSV from MQL5\Files
| |||
GEX_SOURCE_NATIVE = 1 // read the broker's native option symbols
| |||
};
| |||
| |||
enum ENUM_GEX_THEME
| |||
{
| |||
GEX_THEME_DARK = 0, // dark labels/bars (for a dark chart)
| |||
GEX_THEME_LIGHT = 1 // light labels/bars (for a light chart)
| |||
};
| |||
| |||
enum ENUM_GEX_SCALE
| |||
{
| |||
GEX_SCALE_OWN = 0, // self-contained band: always visible on any chart
| |||
GEX_SCALE_SNAP = 1 // snap to the chart's real price axis (same-underlying only)
| |||
};
| |||
| |||
input ENUM_GEX_SOURCE InpSource = GEX_SOURCE_CSV; // data source
| |||
input string InpCsvFile = "GEX\\gex_chain_sample.csv"; // CSV chain (in MQL5\Files)
| |||
input string InpUnderlying = ""; // native: base symbol (empty = chart symbol)
| |||
input double InpRiskFree = 0.045; // risk-free rate for the inversion
| |||
input double InpMultiplier = 100.0; // contract multiplier (100 = US equity options)
| |||
input int InpRefreshSec = 0; // native re-poll seconds (0 = manual, press R)
| |||
input int InpProfileW = 260; // profile width in pixels (right margin)
| |||
input ENUM_GEX_SCALE InpScaleMode = GEX_SCALE_OWN; // vertical scale: own band, or snap to price axis
| |||
input double InpFillPct = 0.80; // own scale: fraction of chart height to fill
| |||
input ENUM_GEX_THEME InpTheme = GEX_THEME_DARK; // label/bar theme
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Globals |
| |||
//+------------------------------------------------------------------+
| |||
CCanvas g_canvas;
| |||
CGexProfile g_profile;
| |||
string g_objName = "";
| |||
datetime g_lastRefresh = 0;
| |||
bool g_haveData = false;
| |||
int g_lastW = -1, g_lastH = -1; // last canvas pixel size, to detect real resizes
| |||
| |||
//--- own-scale band (price -> y), recomputed each draw from the strike range
| |||
double g_bandLo = 0, g_bandHi = 0; // price bounds of the profile band
| |||
int g_bandTop = 0, g_bandBot = 0; // pixel bounds of the profile band
| |||
| |||
//--- resolved palette (set in OnInit from the theme)
| |||
uint g_panel, g_grid, g_text, g_textDim, g_pos, g_neg, g_flip, g_spot, g_wall;
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Resolve the theme into a small ARGB palette once, so every draw |
| |||
//| call pulls from the same consistent set of colours. The bar and |
| |||
//| line colours read the same on either chart theme; only the panel |
| |||
//| fill and the text swap. |
| |||
//+------------------------------------------------------------------+
| |||
void ResolvePalette(void)
| |||
{
| |||
if(InpTheme == GEX_THEME_LIGHT)
| |||
{
| |||
g_panel = ColorToARGB(clrWhiteSmoke, 220); // near-opaque card
| |||
g_grid = ColorToARGB(clrSilver);
| |||
g_text = ColorToARGB(clrBlack);
| |||
g_textDim = ColorToARGB(clrDimGray);
| |||
}
| |||
else
| |||
{
| |||
g_panel = ColorToARGB(C'22,24,30', 225); // near-opaque card
| |||
g_grid = ColorToARGB(C'70,74,86');
| |||
g_text = ColorToARGB(clrWhiteSmoke);
| |||
g_textDim = ColorToARGB(clrSilver);
| |||
}
| |||
g_pos = ColorToARGB(C'38,166,91', 235); // long-gamma (positive) green
| |||
g_neg = ColorToARGB(C'207,64,64', 235); // short-gamma (negative) red
| |||
g_flip = ColorToARGB(clrGold); // zero-gamma flip line
| |||
g_spot = ColorToARGB(clrDeepSkyBlue); // current spot line
| |||
g_wall = ColorToARGB(clrOrange); // call/put wall markers
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| (Re)load the chosen data source and rebuild the profile. |
| |||
//+------------------------------------------------------------------+
| |||
bool Reload(void)
| |||
{
| |||
OptionQuote quotes[];
| |||
bool ok = false;
| |||
if(InpSource == GEX_SOURCE_CSV)
| |||
{
| |||
CGexProviderCSV csv;
| |||
ok = csv.Load(InpCsvFile, quotes);
| |||
}
| |||
else
| |||
{
| |||
string under = (InpUnderlying == "") ? _Symbol : InpUnderlying;
| |||
CGexProviderNative nat;
| |||
ok = nat.Load(under, InpRiskFree, quotes);
| |||
}
| |||
if(!ok)
| |||
return(false);
| |||
| |||
g_profile.Multiplier(InpMultiplier);
| |||
g_haveData = g_profile.Build(quotes);
| |||
return(g_haveData);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Set up the own-scale band: map the strike range onto a centred |
| |||
//| vertical span covering InpFillPct of the chart height. Padded a |
| |||
//| little beyond the strikes so spot/flip lines that sit just |
| |||
//| outside the outermost strikes still land inside the band. Called |
| |||
//| once per draw before any PriceY() query in own-scale mode. |
| |||
//+------------------------------------------------------------------+
| |||
void SetupBand(void)
| |||
{
| |||
int H = g_canvas.Height();
| |||
int nk = g_profile.NStrikes();
| |||
double lo = g_profile.Strike(0);
| |||
double hi = g_profile.Strike(nk - 1);
| |||
double pad = 0.06 * (hi - lo);
| |||
g_bandLo = lo - pad;
| |||
g_bandHi = hi + pad;
| |||
| |||
double fill = MathMax(0.3, MathMin(0.95, InpFillPct));
| |||
int span = (int)(H * fill);
| |||
g_bandTop = (H - span) / 2; // centred vertically
| |||
g_bandBot = g_bandTop + span;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Map a price to a y pixel, either by snapping to the chart's real |
| |||
//| price axis (SNAP mode, for a same-underlying chart) or across |
| |||
//| the tool's own centred band (OWN mode, which is always visible |
| |||
//| regardless of the chart symbol). Returns false when the price |
| |||
//| falls off-screen so callers simply skip that level. |
| |||
//+------------------------------------------------------------------+
| |||
bool PriceY(const double price, int &y)
| |||
{
| |||
if(InpScaleMode == GEX_SCALE_SNAP)
| |||
{
| |||
int x = 0, sub = 0;
| |||
datetime t = TimeCurrent(); // any visible time works; only y is used
| |||
if(!ChartTimePriceToXY(0, sub, t, price, x, y))
| |||
return(false);
| |||
int h = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, 0);
| |||
if(y < -50 || y > h + 50)
| |||
return(false); // well off-screen: don't draw it
| |||
return(true);
| |||
}
| |||
| |||
//--- own scale: linear map of the strike band onto [g_bandTop, g_bandBot]
| |||
if(g_bandHi <= g_bandLo)
| |||
return(false);
| |||
double f = (price - g_bandLo) / (g_bandHi - g_bandLo); // 0 at bandLo, 1 at bandHi
| |||
if(f < -0.02 || f > 1.02)
| |||
return(false); // outside the padded band
| |||
y = (int)MathRound(g_bandBot - f * (g_bandBot - g_bandTop));
| |||
return(true);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Draw the GEX profile in the right margin, each bar sitting at its|
| |||
//| strike's price level. In SNAP mode that level is the chart's own |
| |||
//| price axis; in OWN mode it is the tool's centred band, so the |
| |||
//| profile is visible on any chart. Bars grow leftward from the |
| |||
//| right edge; positive (dealer long gamma) is green, negative |
| |||
//| (short gamma) is red. Walls, spot and the flip are marked lines. |
| |||
//+------------------------------------------------------------------+
| |||
void DrawMap(void)
| |||
{
| |||
int W = g_canvas.Width();
| |||
int H = g_canvas.Height();
| |||
g_canvas.Erase(0); // fully transparent: the chart shows through
| |||
| |||
if(!g_haveData || g_profile.NStrikes() < 2)
| |||
{
| |||
DrawTitle(W, "GEX: no data. Check CSV path / source. Press R.");
| |||
g_canvas.Update(true);
| |||
return;
| |||
}
| |||
| |||
//--- own-scale mode maps the strike range onto a centred band
| |||
if(InpScaleMode == GEX_SCALE_OWN)
| |||
SetupBand();
| |||
| |||
//--- right-margin geometry
| |||
int rightPad = 8;
| |||
int baseX = W - rightPad; // bars anchor here and grow left
| |||
int maxLen = MathMax(60, InpProfileW); // longest bar
| |||
int labelX = baseX - maxLen - 10; // strike labels sit left of the bars
| |||
| |||
//--- in own-scale mode, back the band with a faint panel so it reads as a
| |||
//--- self-contained gauge rather than floating bars over the candles
| |||
if(InpScaleMode == GEX_SCALE_OWN)
| |||
{
| |||
int px0 = labelX - 52;
| |||
g_canvas.FillRectangle(px0, g_bandTop - 10, baseX + rightPad, g_bandBot + 10, g_panel);
| |||
g_canvas.Rectangle(px0, g_bandTop - 10, baseX + rightPad, g_bandBot + 10, g_grid);
| |||
g_canvas.LineVertical(baseX, g_bandTop - 10, g_bandBot + 10, g_grid); // zero line bars grow from
| |||
}
| |||
| |||
int nk = g_profile.NStrikes();
| |||
double maxAbs = 1e-30;
| |||
for(int i = 0; i < nk; i++)
| |||
maxAbs = MathMax(maxAbs, MathAbs(g_profile.Gex(i)));
| |||
| |||
//--- bar half-height from the on-screen spacing of adjacent strikes
| |||
int yA, yB;
| |||
int barH = 8;
| |||
if(PriceY(g_profile.Strike(0), yA) && PriceY(g_profile.Strike(1), yB))
| |||
barH = MathMax(3, (int)(MathAbs(yB - yA) * 0.42));
| |||
| |||
//--- per-strike bars at real price levels
| |||
g_canvas.FontSet("Segoe UI", 14);
| |||
for(int i = 0; i < nk; i++)
| |||
{
| |||
int y;
| |||
if(!PriceY(g_profile.Strike(i), y))
| |||
continue;
| |||
double gex = g_profile.Gex(i);
| |||
int len = (int)MathRound(maxLen * (MathAbs(gex) / maxAbs));
| |||
uint clr = (gex >= 0.0) ? g_pos : g_neg;
| |||
g_canvas.FillRectangle(baseX - len, y - barH, baseX, y + barH, clr);
| |||
//--- strike label just left of the profile
| |||
g_canvas.TextOut(labelX, y - 10, StringFormat("%.0f", g_profile.Strike(i)), g_textDim, TA_RIGHT);
| |||
}
| |||
| |||
//--- reference lines drawn across the profile band at their true prices
| |||
//--- (unlabelled: the colour key in the title card identifies them)
| |||
int lineX0 = labelX - 40;
| |||
DrawLevel(g_profile.Spot(), lineX0, baseX, g_spot);
| |||
if(g_profile.Flip() > 0.0)
| |||
DrawLevel(g_profile.Flip(), lineX0, baseX, g_flip);
| |||
DrawLevel(g_profile.CallWall(), lineX0, baseX, g_wall);
| |||
DrawLevel(g_profile.PutWall(), lineX0, baseX, g_wall);
| |||
| |||
//--- title / regime card, top-left
| |||
double net = g_profile.NetGex();
| |||
string underName = (InpSource == GEX_SOURCE_NATIVE && InpUnderlying != "") ? InpUnderlying : _Symbol;
| |||
string line1 = StringFormat("Gamma Exposure - %s - exp %s",
| |||
underName, TimeToString(g_profile.Expiry(), TIME_DATE));
| |||
string regime = (net >= 0.0) ? "NET LONG GAMMA (mean-reverting)" : "NET SHORT GAMMA (trending)";
| |||
string line2 = StringFormat("%s net GEX %.3g flip %s",
| |||
regime, net,
| |||
(g_profile.Flip() > 0.0 ? StringFormat("%.2f", g_profile.Flip()) : "none"));
| |||
DrawTitleTwo(line1, line2, (net >= 0.0) ? g_pos : g_neg);
| |||
| |||
g_canvas.Update(true);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Draw one reference level (spot / flip / wall) as a plain line |
| |||
//| across the profile band. No caption: the lines are kept clean |
| |||
//| and the colour key in the title card names them, so they do not |
| |||
//| clutter the profile. |
| |||
//+------------------------------------------------------------------+
| |||
void DrawLevel(const double price, const int x0, const int x1, const uint clr)
| |||
{
| |||
int y;
| |||
if(!PriceY(price, y))
| |||
return;
| |||
g_canvas.LineHorizontal(x0, x1, y, clr);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Single-line title card (used only for the "no data" message). |
| |||
//+------------------------------------------------------------------+
| |||
void DrawTitle(const int W, const string text)
| |||
{
| |||
g_canvas.FontSet("Segoe UI", 15, FW_BOLD);
| |||
int w = g_canvas.TextWidth(text) + 36;
| |||
g_canvas.FillRectangle(8, 8, 8 + w, 8 + 38, g_panel);
| |||
g_canvas.Rectangle(8, 8, 8 + w, 8 + 38, g_grid);
| |||
g_canvas.TextOut(22, 16, text, g_text, TA_LEFT);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Small colour swatch + label, used to build the reference-line |
| |||
//| key. Returns the x just past the label so keys chain left to |
| |||
//| right. |
| |||
//+------------------------------------------------------------------+
| |||
int KeyItem(const int x, const int y, const uint clr, const string label)
| |||
{
| |||
g_canvas.FillRectangle(x, y + 3, x + 16, y + 17, clr);
| |||
g_canvas.FontSet("Segoe UI", 13);
| |||
g_canvas.TextOut(x + 22, y, label, g_textDim, TA_LEFT);
| |||
return(x + 22 + g_canvas.TextWidth(label) + 20);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Title / regime card, top-left, on an opaque panel so it stays |
| |||
//| readable over any candles behind it. Three rows: the heading, |
| |||
//| the net-GEX regime verdict, and a colour key that names the |
| |||
//| reference lines so they can stay unlabelled on the profile. |
| |||
//+------------------------------------------------------------------+
| |||
void DrawTitleTwo(const string line1, const string line2, const uint regimeClr)
| |||
{
| |||
g_canvas.FontSet("Segoe UI", 18, FW_BOLD);
| |||
int w1 = g_canvas.TextWidth(line1);
| |||
g_canvas.FontSet("Segoe UI", 15, FW_BOLD);
| |||
int w2 = g_canvas.TextWidth(line2);
| |||
int cardW = MathMax(w1, w2) + 36;
| |||
cardW = MathMax(cardW, 360);
| |||
int cardH = 104;
| |||
| |||
g_canvas.FillRectangle(8, 8, 8 + cardW, 8 + cardH, g_panel);
| |||
g_canvas.Rectangle(8, 8, 8 + cardW, 8 + cardH, g_grid);
| |||
g_canvas.FontSet("Segoe UI", 18, FW_BOLD);
| |||
g_canvas.TextOut(22, 16, line1, g_text, TA_LEFT);
| |||
g_canvas.FontSet("Segoe UI", 15, FW_BOLD);
| |||
g_canvas.TextOut(22, 46, line2, regimeClr, TA_LEFT);
| |||
| |||
//--- reference-line colour key
| |||
int kx = 22, ky = 76;
| |||
kx = KeyItem(kx, ky, g_spot, "spot");
| |||
kx = KeyItem(kx, ky, g_flip, "flip");
| |||
kx = KeyItem(kx, ky, g_wall, "walls");
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Create (or recreate) a full-chart bitmap the size of the chart. |
| |||
//+------------------------------------------------------------------+
| |||
bool BuildCanvas(void)
| |||
{
| |||
int w = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, 0);
| |||
int h = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, 0);
| |||
if(w <= 0)
| |||
w = 1200;
| |||
if(h <= 0)
| |||
h = 600;
| |||
| |||
g_canvas.Destroy();
| |||
if(g_objName != "")
| |||
ObjectDelete(0, g_objName);
| |||
| |||
g_objName = "GexMapCanvas_" + IntegerToString(ChartID());
| |||
if(!g_canvas.CreateBitmapLabel(0, 0, g_objName, 0, 0, w, h, COLOR_FORMAT_ARGB_NORMALIZE))
| |||
{
| |||
PrintFormat("GexMap: CreateBitmapLabel failed (err %d)", GetLastError());
| |||
return(false);
| |||
}
| |||
ObjectSetInteger(0, g_objName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
| |||
ObjectSetInteger(0, g_objName, OBJPROP_XDISTANCE, 0);
| |||
ObjectSetInteger(0, g_objName, OBJPROP_YDISTANCE, 0);
| |||
ObjectSetInteger(0, g_objName, OBJPROP_BACK, false); // draw over the candles
| |||
g_lastW = w;
| |||
g_lastH = h;
| |||
return(true);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Rebuild the bitmap only when the chart pixel size actually |
| |||
//| changed. A scroll or a scale change keeps the same canvas and |
| |||
//| only needs a redraw, which is far cheaper than a rebuild. |
| |||
//+------------------------------------------------------------------+
| |||
bool RebuildIfResized(void)
| |||
{
| |||
int w = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, 0);
| |||
int h = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, 0);
| |||
if(w <= 0 || h <= 0)
| |||
return(false);
| |||
if(w == g_lastW && h == g_lastH)
| |||
return(false);
| |||
return(BuildCanvas());
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Initialization |
| |||
//+------------------------------------------------------------------+
| |||
int OnInit(void)
| |||
{
| |||
IndicatorSetString(INDICATOR_SHORTNAME, "GEX Map");
| |||
ResolvePalette();
| |||
| |||
if(!BuildCanvas())
| |||
return(INIT_FAILED);
| |||
| |||
Reload();
| |||
DrawMap();
| |||
| |||
EventSetTimer(1);
| |||
g_lastRefresh = TimeCurrent();
| |||
return(INIT_SUCCEEDED);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Timer: re-poll the native source on its interval and redraw when |
| |||
//| fresh data arrived. The profile is static between reloads, so |
| |||
//| the timer alone does not force redraws. |
| |||
//+------------------------------------------------------------------+
| |||
void OnTimer(void)
| |||
{
| |||
if(InpSource == GEX_SOURCE_NATIVE && InpRefreshSec > 0 &&
| |||
TimeCurrent() - g_lastRefresh >= InpRefreshSec)
| |||
{
| |||
Reload();
| |||
g_lastRefresh = TimeCurrent();
| |||
DrawMap();
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Indicator calculation: this tool draws from the option chain, |
| |||
//| not the price series, so it does no per-bar work. We keep the |
| |||
//| required return contract only. |
| |||
//+------------------------------------------------------------------+
| |||
int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
| |||
{
| |||
return(rates_total);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Chart events: R reloads the data. Because the profile is pinned |
| |||
//| to the real price axis, any chart change (scroll, zoom, scale) |
| |||
//| shifts the price-to-pixel mapping, so we rebuild-if-resized and |
| |||
//| always redraw to keep the bars locked to their strikes. |
| |||
//+------------------------------------------------------------------+
| |||
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
| |||
{
| |||
if(id == CHARTEVENT_KEYDOWN)
| |||
{
| |||
if((int)lparam == 'R' || (int)lparam == 'r')
| |||
{
| |||
Reload();
| |||
DrawMap();
| |||
}
| |||
}
| |||
else
| |||
if(id == CHARTEVENT_CHART_CHANGE)
| |||
{
| |||
RebuildIfResized(); // only rebuilds the bitmap on a real size change
| |||
DrawMap(); // always redraw: the price axis may have moved
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Cleanup |
| |||
//+------------------------------------------------------------------+
| |||
void OnDeinit(const int reason)
| |||
{
| |||
EventKillTimer();
| |||
g_canvas.Destroy();
| |||
if(g_objName != "")
| |||
ObjectDelete(0, g_objName);
| |||
ChartRedraw(0);
| |||
}
| |||
//+------------------------------------------------------------------+
|