| //+------------------------------------------------------------------+
|
| //| OMV Panel.mqh |
|
| //| Copyright 2026, Allan Munene Mutiiria. |
|
| //| https://t.me/Forex_Algo_Trader |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, Allan Munene Mutiiria."
|
| #property link "https://t.me/Forex_Algo_Trader"
|
|
|
| #ifndef OMV_PANEL_MQH
|
| #define OMV_PANEL_MQH
|
|
|
| #include "OMV Canvas.mqh"
|
| #include "OMV Model.mqh"
|
| #include "OMV Features.mqh"
|
|
|
| //+------------------------------------------------------------------+
|
| //| Panel size bounds |
|
| //+------------------------------------------------------------------+
|
| #define OP_W 660 // Default panel width
|
| #define OP_H 440 // Default panel height
|
| #define OP_W_MIN 480 // Narrowest the panel may be dragged
|
| #define OP_W_MAX 1100 // Widest the panel may be dragged
|
| #define OP_H_MIN 320 // Shortest the panel may be dragged
|
| #define OP_H_MAX 800 // Tallest the panel may be dragged
|
|
|
| //+------------------------------------------------------------------+
|
| //| Band heights |
|
| //+------------------------------------------------------------------+
|
| #define OP_HEADER_H 44 // Header band holding the title and icons
|
| #define OP_STAT_H 48 // Statistics strip under the header
|
| #define OP_FOOT_H 34 // Footer band holding the view controls
|
| #define OP_GRIP 14 // Side of the square resize grip
|
| #define OP_ICON 24 // Square a header or footer icon occupies
|
| #define OP_GLYPH 0.26 // Reach of a diagonal glyph across its icon
|
| #define OP_BAR_R 0.28 // Reach of a straight glyph across its icon
|
| #define OP_FRAME_MS 16 // Shortest gap between two repaints
|
|
|
| //+------------------------------------------------------------------+
|
| //| Inspector and scrollbars |
|
| //+------------------------------------------------------------------+
|
| #define OP_INSPECT_W 230 // Width the inspector occupies when open
|
| #define OP_NAME_W 72 // Width of the name column beside a value
|
| #define OP_VAL_PAD 5 // Padding inside a value box
|
| #define OP_VAL_H 20 // Height of a single line value box
|
| #define OP_VAL_GAP 3 // Space between two value boxes
|
| #define OP_MAX_ROWS 64 // Value rows the inspector may hold
|
| #define OP_MAX_LINES 400 // Lines one row may add when it is opened
|
| #define OP_WRAP_MAX 4 // Lines a single value may wrap onto
|
| #define OP_BAR 8 // Thickness of a scrollbar
|
| #define OP_WHEEL 40 // Pixels one wheel notch moves the graph
|
| #define OP_RADIUS 10 // Corner radius of the panel itself
|
| #define OP_BTN_R 6 // Corner radius of a button
|
| #define OP_PAD 14 // Breathing room around the graph inside its area
|
| #define OP_FEED_BARS 600 // Bars pulled to build the model's numbers from
|
| #define OP_ZOOM_MIN 0.30 // Smallest scale the graph is drawn at
|
| #define OP_ZOOM_MAX 2.00 // Largest scale the graph is drawn at
|
|
|
| //+------------------------------------------------------------------+
|
| //| Hit targets |
|
| //+------------------------------------------------------------------+
|
| enum OMV_HIT
|
| {
|
| OH_NONE = 0, // Pointer is over nothing clickable
|
| OH_HEADER, // Header band, starts a move
|
| OH_THEME, // Light and dark toggle
|
| OH_MIN, // Collapse to the header band
|
| OH_RESTORE, // Expand back to the full panel
|
| OH_CLOSE, // Remove the panel
|
| OH_FIT, // Scale the graph to the canvas
|
| OH_VIEW, // Swap between the graph and the neurons
|
| OH_CELL, // A single neuron in the neuron view
|
| OH_ZOOM_OUT, // Step the zoom down
|
| OH_ZOOM_IN, // Step the zoom up
|
| OH_INSPECT_X, // Close the inspector column
|
| OH_GRIP, // Bottom right grip, starts a resize
|
| OH_BAR_V, // Vertical scrollbar thumb
|
| OH_BAR_H, // Horizontal scrollbar thumb
|
| OH_CANVAS, // Graph area, starts a pan
|
| OH_NODE, // A drawn node box
|
| OH_ROW, // A tensor row inside a node box
|
| OH_LINK, // A drawn connection
|
| OH_INFO, // An expandable row of the inspector
|
| OH_INFO_BAR // The inspector scrollbar thumb
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| One laid out row of the inspector |
|
| //+------------------------------------------------------------------+
|
| struct OmvRow
|
| {
|
| // Name the row carries on its left
|
| string name;
|
| // Print the value inside the box
|
| string value;
|
| // Print these lines once the row is expanded
|
| string extra[OP_MAX_LINES];
|
| // Count the lines the row adds when opened
|
| int extraCount;
|
| // Count the lines the value itself wrapped onto
|
| int wraps;
|
| // Mark a row that can be expanded
|
| bool canOpen;
|
| // Mark a row that is currently expanded
|
| bool isOpen;
|
| // Mark a heading rather than a value
|
| bool isHead;
|
| // Name the value in the graph this row points at
|
| string linkName;
|
| // Place the box top edge
|
| int y;
|
| // Measure the box height
|
| int h;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| What the inspector is describing |
|
| //+------------------------------------------------------------------+
|
| enum OMV_PICK
|
| {
|
| OP_PICK_NONE = 0, // Nothing chosen
|
| OP_PICK_NODE, // A layer of the graph
|
| OP_PICK_TENSOR, // A stored weight tensor
|
| OP_PICK_LINK, // A connection between two layers
|
| OP_PICK_GRAPH, // The graph as a whole
|
| OP_PICK_MODEL // The file as a whole
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Display mode |
|
| //+------------------------------------------------------------------+
|
| enum OMV_MODE
|
| {
|
| OM_FULL = 0, // Whole panel
|
| OM_MIN // Header band only
|
| };
|
| //+------------------------------------------------------------------+
|
| //| Resolved theme colors |
|
| //+------------------------------------------------------------------+
|
| struct OmvTheme
|
| {
|
| // Color the panel body
|
| uint panel;
|
| // Color the header and footer bands
|
| uint chrome;
|
| // Color the panel outline
|
| uint border;
|
| // Color the band separators
|
| uint divider;
|
| // Color the faint canvas grid
|
| uint grid;
|
| // Color the primary text
|
| uint text;
|
| // Color the secondary text
|
| uint muted;
|
| // Color the accent used for the active control
|
| uint accent;
|
| // Color the compute node fill
|
| uint computeFill;
|
| // Color the compute node edge
|
| uint computeEdge;
|
| // Color the activation node fill
|
| uint activateFill;
|
| // Color the activation node edge
|
| uint activateEdge;
|
| // Color the structural node fill
|
| uint shapeFill;
|
| // Color the structural node edge
|
| uint shapeEdge;
|
| // Color the output node fill
|
| uint outputFill;
|
| // Color the output node edge
|
| uint outputEdge;
|
| // Color a connection carrying a positive weight
|
| uint linkUp;
|
| // Color a connection carrying a negative weight
|
| uint linkDown;
|
| // Color a neuron circle
|
| uint cell;
|
| // Color the plain node fill
|
| uint plainFill;
|
| // Color the plain node edge
|
| uint plainEdge;
|
| // Color a button face
|
| uint btnFace;
|
| // Color a button edge
|
| uint btnEdge;
|
| // Color a hovered button face
|
| uint hoverFace;
|
| // Color a hovered button edge
|
| uint hoverEdge;
|
|
|
| void Apply(const bool dark);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Resolve every color for the requested theme |
|
| //+------------------------------------------------------------------+
|
| void OmvTheme::Apply(const bool dark)
|
| {
|
| //--- Resolve the dark palette
|
| if(dark)
|
| {
|
| panel = ColorToARGB(C'24,24,27', 255);
|
| chrome = ColorToARGB(C'32,32,36', 255);
|
| border = ColorToARGB(C'58,58,64', 255);
|
| divider = ColorToARGB(C'48,48,53', 255);
|
| grid = ColorToARGB(C'38,38,42', 255);
|
| text = ColorToARGB(C'232,232,236', 255);
|
| muted = ColorToARGB(C'138,138,146', 255);
|
| accent = ColorToARGB(C'163,155,242', 255);
|
| computeFill = ColorToARGB(C'22,44,68', 255);
|
| computeEdge = ColorToARGB(C'88,150,214', 255);
|
| activateFill = ColorToARGB(C'62,32,22', 255);
|
| activateEdge = ColorToARGB(C'214,120,88', 255);
|
| shapeFill = ColorToARGB(C'62,28,44', 255);
|
| shapeEdge = ColorToARGB(C'214,110,150', 255);
|
| outputFill = ColorToARGB(C'20,54,44', 255);
|
| outputEdge = ColorToARGB(C'80,190,152', 255);
|
| linkUp = ColorToARGB(C'80,190,152', 255);
|
| linkDown = ColorToARGB(C'232,110,110', 255);
|
| cell = ColorToARGB(C'150,170,195', 255);
|
| plainFill = ColorToARGB(C'42,42,46', 255);
|
| plainEdge = ColorToARGB(C'110,110,118', 255);
|
| btnFace = ColorToARGB(C'40,40,45', 255);
|
| btnEdge = ColorToARGB(C'62,62,68', 255);
|
| hoverFace = ColorToARGB(C'52,52,58', 255);
|
| hoverEdge = ColorToARGB(C'92,92,100', 255);
|
| return;
|
| }
|
| //--- Resolve the light palette
|
| panel = ColorToARGB(C'255,255,255', 255);
|
| chrome = ColorToARGB(C'247,246,243', 255);
|
| border = ColorToARGB(C'208,206,196', 255);
|
| divider = ColorToARGB(C'228,226,219', 255);
|
| grid = ColorToARGB(C'241,239,232', 255);
|
| text = ColorToARGB(C'44,44,42', 255);
|
| muted = ColorToARGB(C'126,124,118', 255);
|
| accent = ColorToARGB(C'127,119,221', 255);
|
| computeFill = ColorToARGB(C'230,241,251', 255);
|
| computeEdge = ColorToARGB(C'55,138,221', 255);
|
| activateFill = ColorToARGB(C'250,236,231', 255);
|
| activateEdge = ColorToARGB(C'216,90,48', 255);
|
| shapeFill = ColorToARGB(C'251,234,240', 255);
|
| shapeEdge = ColorToARGB(C'212,83,126', 255);
|
| outputFill = ColorToARGB(C'225,245,238', 255);
|
| outputEdge = ColorToARGB(C'29,158,117', 255);
|
| linkUp = ColorToARGB(C'29,158,117', 255);
|
| linkDown = ColorToARGB(C'201,58,58', 255);
|
| cell = ColorToARGB(C'92,110,132', 255);
|
| plainFill = ColorToARGB(C'241,239,232', 255);
|
| plainEdge = ColorToARGB(C'180,178,169', 255);
|
| btnFace = ColorToARGB(C'255,255,255', 255);
|
| btnEdge = ColorToARGB(C'211,209,199', 255);
|
| hoverFace = ColorToARGB(C'247,246,243', 255);
|
| hoverEdge = ColorToARGB(C'180,178,169', 255);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Box geometry |
|
| //+------------------------------------------------------------------+
|
| #define OL_BOX_W 76 // Width of one node box
|
| #define OL_HEAD_H 17 // Height of the header strip naming the operator
|
| #define OL_ROW_H 13 // Height of one listed weight row
|
| #define OL_ROW_PAD 3 // Margin around the listed rows on every side
|
| #define OL_BOX_S 19 // Height of a node box carrying a title only
|
| #define OL_MAX_ROWS 16 // Weight rows one box may list
|
| #define OL_GAP_X 22 // Horizontal space between neighbors on a rank
|
| #define OL_GAP_Y 26 // Vertical space where a connection carries a label
|
| #define OL_GAP_S 14 // Vertical space where the connections carry none
|
|
|
| //+------------------------------------------------------------------+
|
| //| Node roles used for coloring |
|
| //+------------------------------------------------------------------+
|
| #define OL_ROLE_COMPUTE 0 // Layers holding weights
|
| #define OL_ROLE_ACTIVATE 1 // Elementwise activations
|
| #define OL_ROLE_SHAPE 2 // Structural operators
|
| #define OL_ROLE_OUTPUT 3 // Terminal operators
|
| #define OL_ROLE_PLAIN 4 // Anything else
|
| #define OL_ROLE_PORT 5 // A graph input or output
|
|
|
| //+------------------------------------------------------------------+
|
| //| Placed graph node |
|
| //+------------------------------------------------------------------+
|
| struct OmvBox
|
| {
|
| // Index the node this box was placed for, or a negative for a port
|
| int node;
|
| // Name a port box, empty on a layer box
|
| string portName;
|
| // Place the left edge in graph space
|
| int x;
|
| // Place the top edge in graph space
|
| int y;
|
| // Measure the box width
|
| int w;
|
| // Measure the box height
|
| int h;
|
| // Depth this box sits at
|
| int rank;
|
| // Role that decides the box coloring
|
| int role;
|
| // Letter the operator calls each listed input
|
| string rowLabel[OL_MAX_ROWS];
|
| // Shape text drawn beside each listed input
|
| string rowText[OL_MAX_ROWS];
|
| // Index the tensor each listed input names
|
| int rowTensor[OL_MAX_ROWS];
|
| // Name the value each listed input reads
|
| string rowName[OL_MAX_ROWS];
|
| // Count the rows this box lists
|
| int rowCount;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Drawn connection between two boxes |
|
| //+------------------------------------------------------------------+
|
| struct OmvEdge
|
| {
|
| // Index the box the edge leaves
|
| int from;
|
| // Index the box the edge enters
|
| int to;
|
| // Name the value the connection carries
|
| string label;
|
| // Shape text drawn beside the connection
|
| string shape;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Runner limits |
|
| //+------------------------------------------------------------------+
|
| #define OR_OUTPUTS 3 // Answers the model chooses between
|
| #define OR_AGREE 1e-4 // Largest gap allowed between the two ways of running
|
|
|
| //+------------------------------------------------------------------+
|
| //| Model held open and fed live bars |
|
| //+------------------------------------------------------------------+
|
| class COmvRunner
|
| {
|
| private:
|
| // Hold the model the terminal opened
|
| long m_handle;
|
| // Center each input the way the training script did
|
| double m_mean[OF_INPUTS];
|
| // Spread each input the way the training script did
|
| double m_std[OF_INPUTS];
|
| // Keep the numbers last fed in, already centered and spread
|
| float m_fed[OF_INPUTS];
|
| // Keep what the model last answered
|
| double m_said[OR_OUTPUTS];
|
| // Stamp the bar those answers belong to
|
| datetime m_when;
|
| // Report whether the scaling was read
|
| bool m_scaled;
|
| // Explain why the last step failed
|
| string m_error;
|
|
|
| public:
|
| COmvRunner(void);
|
| ~COmvRunner(void);
|
| bool Open(const uchar &bytes[], const string scaleFile);
|
| void Close(void);
|
| bool Feed(const OmvFeatures &raw);
|
| bool Run(void);
|
|
|
| bool Ready(void) const { return m_handle != INVALID_HANDLE && m_scaled; }
|
| string Error(void) const { return m_error; }
|
| datetime When(void) const { return m_when; }
|
| double SaidAt(const int i) const { return (i >= 0 && i < OR_OUTPUTS) ? m_said[i] : 0.0; }
|
| int Best(void) const;
|
| string Verdict(void) const;
|
| void FedTo(double &out[]) const;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Construct a runner holding nothing |
|
| //+------------------------------------------------------------------+
|
| COmvRunner::COmvRunner(void)
|
| {
|
| //--- Start with no model and no scaling
|
| m_handle = INVALID_HANDLE;
|
| m_scaled = false;
|
| m_when = 0;
|
| m_error = "";
|
| ArrayInitialize(m_mean, 0.0);
|
| ArrayInitialize(m_std, 1.0);
|
| ArrayInitialize(m_said, 0.0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Release the model when the runner goes away |
|
| //+------------------------------------------------------------------+
|
| COmvRunner::~COmvRunner(void)
|
| {
|
| //--- Hand the model back to the terminal
|
| Close();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Give the model back to the terminal |
|
| //+------------------------------------------------------------------+
|
| void COmvRunner::Close(void)
|
| {
|
| //--- Release the handle only once
|
| if(m_handle != INVALID_HANDLE)
|
| {
|
| OnnxRelease(m_handle);
|
| m_handle = INVALID_HANDLE;
|
| }
|
| m_scaled = false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Open the model and the scaling that belongs with it |
|
| //+------------------------------------------------------------------+
|
| bool COmvRunner::Open(const uchar &bytes[], const string scaleFile)
|
| {
|
| //--- Drop whatever was held before
|
| Close();
|
| //--- Require the parsed model bytes to run
|
| if(ArraySize(bytes) <= 0)
|
| {
|
| m_error = "the model holds no bytes to run";
|
| return false;
|
| }
|
| m_handle = OnnxCreateFromBuffer(bytes, ONNX_DEFAULT);
|
| if(m_handle == INVALID_HANDLE)
|
| {
|
| m_error = "the terminal refused the model, error " + IntegerToString(GetLastError());
|
| return false;
|
| }
|
| //--- Fix the shapes, since the model was exported for one bar at a time
|
| const ulong inShape[] = {1, OF_INPUTS};
|
| const ulong outShape[] = {1, OR_OUTPUTS};
|
| if(!OnnxSetInputShape(m_handle, 0, inShape) || !OnnxSetOutputShape(m_handle, 0, outShape))
|
| {
|
| m_error = "the model does not take " + IntegerToString(OF_INPUTS) +
|
| " numbers and return " + IntegerToString(OR_OUTPUTS);
|
| Close();
|
| return false;
|
| }
|
| //--- Read the centering and spread the training script wrote beside the model
|
| const int handle = FileOpen(scaleFile, FILE_READ | FILE_TXT | FILE_ANSI | FILE_COMMON);
|
| if(handle == INVALID_HANDLE)
|
| {
|
| m_error = "cannot open " + scaleFile + ", which holds the scaling";
|
| Close();
|
| return false;
|
| }
|
| //--- Take the two lines, one for the center and one for the spread
|
| string lines[2];
|
| for(int i = 0; i < 2; i++)
|
| lines[i] = FileIsEnding(handle) ? "" : FileReadString(handle);
|
| FileClose(handle);
|
| //--- Break each line into the numbers it holds
|
| string a[], b[];
|
| if(StringSplit(lines[0], ' ', a) != OF_INPUTS || StringSplit(lines[1], ' ', b) != OF_INPUTS)
|
| {
|
| m_error = scaleFile + " does not hold two rows of " + IntegerToString(OF_INPUTS);
|
| Close();
|
| return false;
|
| }
|
| //--- Store them, refusing a spread of nothing since it would divide by zero
|
| for(int i = 0; i < OF_INPUTS; i++)
|
| {
|
| //--- Take this input's center and spread
|
| m_mean[i] = StringToDouble(a[i]);
|
| m_std[i] = StringToDouble(b[i]);
|
| if(MathAbs(m_std[i]) < 1e-12)
|
| m_std[i] = 1.0;
|
| }
|
| m_scaled = true;
|
| m_error = "";
|
| //--- Report that the model is open and the scaling is known
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Center and spread one bar's numbers ready for the model |
|
| //+------------------------------------------------------------------+
|
| bool COmvRunner::Feed(const OmvFeatures &raw)
|
| {
|
| //--- Refuse numbers that were never built
|
| if(!raw.ready)
|
| {
|
| m_error = "the bar produced no usable numbers";
|
| return false;
|
| }
|
| //--- Apply the same centering and spread the training script used
|
| for(int i = 0; i < OF_INPUTS; i++)
|
| m_fed[i] = (float)((raw.value[i] - m_mean[i]) / m_std[i]);
|
| m_when = raw.when;
|
| m_error = "";
|
| //--- Report the numbers as ready to run
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Push the fed numbers through the model |
|
| //+------------------------------------------------------------------+
|
| bool COmvRunner::Run(void)
|
| {
|
| //--- Refuse to run without a model and its scaling
|
| if(!Ready())
|
| {
|
| m_error = "no model is open";
|
| return false;
|
| }
|
| //--- Lay the numbers out the way the model expects them
|
| float in[1][OF_INPUTS];
|
| for(int i = 0; i < OF_INPUTS; i++)
|
| in[0][i] = m_fed[i];
|
| //--- Take the answer back
|
| float out[1][OR_OUTPUTS];
|
| if(!OnnxRun(m_handle, ONNX_NO_CONVERSION, in, out))
|
| {
|
| m_error = "the model refused to run, error " + IntegerToString(GetLastError());
|
| return false;
|
| }
|
| //--- Keep what it said
|
| for(int i = 0; i < OR_OUTPUTS; i++)
|
| m_said[i] = (double)out[0][i];
|
| m_error = "";
|
| //--- Report that the answer is fresh
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name which answer the model leaned towards |
|
| //+------------------------------------------------------------------+
|
| int COmvRunner::Best(void) const
|
| {
|
| //--- Take the strongest of the three
|
| int at = 0;
|
| for(int i = 1; i < OR_OUTPUTS; i++)
|
| if(m_said[i] > m_said[at])
|
| at = i;
|
| return at;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Say what the model called, and how strongly |
|
| //+------------------------------------------------------------------+
|
| string COmvRunner::Verdict(void) const
|
| {
|
| //--- Nothing to say before the model has run
|
| if(m_when == 0)
|
| return "waiting for a bar";
|
| //--- Name the answer and the share it carries
|
| const string names[OR_OUTPUTS] = {"down", "flat", "up"};
|
| const int at = Best();
|
| return names[at] + " " + DoubleToString(m_said[at] * 100.0, 1) + "%";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Hand back the numbers last fed in |
|
| //+------------------------------------------------------------------+
|
| void COmvRunner::FedTo(double &out[]) const
|
| {
|
| //--- Copy them out at full width, since the panel works in doubles
|
| ArrayResize(out, OF_INPUTS);
|
| for(int i = 0; i < OF_INPUTS; i++)
|
| out[i] = (double)m_fed[i];
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Neuron view limits |
|
| //+------------------------------------------------------------------+
|
| #define ON_MAX_BANDS 32 // Neuron rows the view may stack
|
| #define ON_MAX_WIDE 512 // Neurons one row may hold and light up
|
| #define ON_MAX_NEURONS 4096 // Circles the view may draw in total
|
| #define ON_MAX_LINES 20000 // Connections the view may draw before thinning
|
| #define ON_BAND_GAP 88 // Vertical space between one row and the next
|
| #define ON_DOT 11 // Diameter of one neuron at full zoom
|
| #define ON_DOT_GAP 8 // Space between two neurons on the same row
|
| #define ON_TOP_PAD 24 // Room above the first row for its caption
|
| #define ON_FOOT_PAD 34 // Room below the last row for its neuron names
|
| #define ON_SIDE_PAD 28 // Room either side for a caption wider than its row
|
| #define ON_RANK_GAP 52 // Space between two rows sharing a depth
|
| #define ON_ALPHA_MIN 40 // Opacity of the faintest connection drawn
|
| #define ON_ALPHA_SPAN 175 // Opacity added between the faintest and the strongest connection
|
| #define ON_FIRE_MIN 60 // Opacity of a neuron that barely fired
|
| #define ON_FIRE_SPAN 195 // Opacity added up to the loudest neuron on its row
|
| #define ON_HALO_MIN 20 // Opacity of the faintest halo
|
| #define ON_HALO_SPAN 55 // Opacity added to the halo of the loudest neuron
|
| #define ON_PULSE_MS 60 // Milliseconds between one pulse step and the next
|
| #define ON_PULSE_STEPS 26 // Steps a pulse takes to cross one gap
|
| #define ON_PULSE_DOT 3.0 // Radius of a travelling pulse at full zoom
|
|
|
| //+------------------------------------------------------------------+
|
| //| One row of neurons the view draws |
|
| //+------------------------------------------------------------------+
|
| struct OmvBand
|
| {
|
| // Count the neurons standing on this row
|
| int count;
|
| // Name what produced the row and what was applied to it
|
| string label;
|
| // Place the row across the arrangement
|
| int x;
|
| // Place the row down the arrangement
|
| int y;
|
| // Measure how wide the row of circles runs
|
| int w;
|
| // Record how far the row sits from the graph input
|
| int rank;
|
| // Name the function applied after the weights, or nothing
|
| string act;
|
| // Hold what each neuron produced on the last bar the model was run for
|
| double fired[ON_MAX_WIDE];
|
| // Report whether those numbers mean anything yet
|
| bool live;
|
| // Name each neuron, where the row stands for something a reader knows
|
| bool named;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| One run of connections between two rows |
|
| //+------------------------------------------------------------------+
|
| struct OmvWeb
|
| {
|
| // Name the row the connections leave
|
| int from;
|
| // Name the row the connections arrive at
|
| int to;
|
| // Index the tensor holding the weights, or a negative when structural
|
| int tensor;
|
| // Offset the arriving row when several runs share it
|
| int offset;
|
| // Mark a weight matrix the operator stores the other way round
|
| bool transposed;
|
| // Index the tensor holding the bias, or a negative when there is none
|
| int bias;
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Neuron arrangement built from the dense layers |
|
| //+------------------------------------------------------------------+
|
| class COmvNeurons
|
| {
|
| private:
|
| // Store the rows of neurons
|
| OmvBand m_band[];
|
| // Store the runs of connections
|
| OmvWeb m_web[];
|
| // Count the rows held
|
| int m_bands;
|
| // Count the runs held
|
| int m_webs;
|
| // Measure the arrangement width
|
| int m_width;
|
| // Measure the arrangement height
|
| int m_height;
|
| // Explain why the view cannot be drawn
|
| string m_reason;
|
| // Report whether the arrangement is drawable
|
| bool m_ready;
|
| // Report whether the rows hold numbers from a real bar
|
| bool m_live;
|
|
|
| int BandOf(const string name, const string &names[], const int &bands[],
|
| const int count) const;
|
| int WidthOf(COmvModel &model, const string name) const;
|
| int TensorNamed(COmvModel &model, const string name) const;
|
| bool IsDense(const string op) const;
|
| bool IsUnary(const string op) const;
|
| bool IsBinary(const string op) const;
|
| bool IsShape(const string op) const;
|
| int AddBand(const int count, const string label);
|
| double Shape(const string act, const double v) const;
|
|
|
| public:
|
| COmvNeurons(void);
|
| bool Build(COmvModel &model);
|
| bool Run(COmvModel &model, const double &feed[], const int count);
|
| void Clear(void);
|
|
|
| int Bands(void) const { return m_bands; }
|
| int Webs(void) const { return m_webs; }
|
| int Width(void) const { return m_width; }
|
| int Height(void) const { return m_height; }
|
| string Reason(void) const { return m_reason; }
|
| bool Ready(void) const { return m_ready; }
|
| bool Live(void) const { return m_live; }
|
|
|
| void BandAt(const int i, OmvBand &out) const { if(i >= 0 && i < m_bands) out = m_band[i]; }
|
| string NeuronName(const int band, const int at) const;
|
| void WebAt(const int i, OmvWeb &out) const { if(i >= 0 && i < m_webs) out = m_web[i]; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Arranges a parsed model into boxes and edges |
|
| //+------------------------------------------------------------------+
|
| class COmvLayout
|
| {
|
| private:
|
| // Store the placed boxes
|
| OmvBox m_box[];
|
| // Store the drawn edges
|
| OmvEdge m_edge[];
|
| // Count the boxes placed
|
| int m_boxes;
|
| // Count the edges drawn
|
| int m_edges;
|
| // Measure the arrangement width
|
| int m_width;
|
| // Measure the arrangement height
|
| int m_height;
|
|
|
| int RoleOf(const string op) const;
|
| int ProducerOf(COmvModel &model, const string name) const;
|
| bool HasNodeParent(COmvModel &model, const OmvNode &node) const;
|
| int ShallowestConsumer(COmvModel &model, const int index, const int &rank[]) const;
|
| bool IsWeight(COmvModel &model, const string name) const;
|
| void RowsOf(COmvModel &model, const OmvNode &node, OmvBox &box) const;
|
| void AddPortBox(const string name, const int rank);
|
| void AddEdge(const int from, const int to, const string label,
|
| const string shape);
|
| string ShapeOf(COmvModel &model, const string name) const;
|
|
|
| public:
|
| COmvLayout(void);
|
| void Clear(void);
|
| bool Build(COmvModel &model);
|
|
|
| int Boxes(void) const { return m_boxes; }
|
| int Edges(void) const { return m_edges; }
|
| int Width(void) const { return m_width; }
|
| int Height(void) const { return m_height; }
|
| void BoxAt(const int i, OmvBox &out) const { if(i >= 0 && i < m_boxes) out = m_box[i]; }
|
| void EdgeAt(const int i, OmvEdge &out) const { if(i >= 0 && i < m_edges) out = m_edge[i]; }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Construct an empty neuron arrangement |
|
| //+------------------------------------------------------------------+
|
| COmvNeurons::COmvNeurons(void)
|
| {
|
| //--- Start with nothing placed
|
| Clear();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Drop the arrangement built for a previous model |
|
| //+------------------------------------------------------------------+
|
| void COmvNeurons::Clear(void)
|
| {
|
| //--- Zero the counts that bound both arrays
|
| m_bands = 0;
|
| m_webs = 0;
|
| //--- Release the stored rows and runs
|
| ArrayResize(m_band, 0);
|
| ArrayResize(m_web, 0);
|
| //--- Clear the measurements and the verdict
|
| m_width = 0;
|
| m_height = 0;
|
| m_reason = "";
|
| m_ready = false;
|
| m_live = false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether an operator multiplies by a weight matrix |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::IsDense(const string op) const
|
| {
|
| //--- Only these two carry a two dimensional weight between neuron rows
|
| return (op == "Gemm" || op == "MatMul");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether an operator works on one value in place |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::IsUnary(const string op) const
|
| {
|
| //--- These change the values on a row without changing how many there are
|
| return (op == "Relu" || op == "Tanh" || op == "Sigmoid" || op == "Softmax" ||
|
| op == "LeakyRelu" || op == "Elu" || op == "Sqrt" || op == "Abs" ||
|
| op == "Cast" || op == "Identity" || op == "Clip" || op == "Erf");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether an operator pairs a value with a constant |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::IsBinary(const string op) const
|
| {
|
| //--- These scale or shift a row, leaving its neuron count alone
|
| return (op == "Mul" || op == "Add" || op == "Sub" || op == "Div" || op == "Pow");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether an operator only rearranges a value |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::IsShape(const string op) const
|
| {
|
| //--- These move the numbers around without creating or destroying any
|
| return (op == "Reshape" || op == "Transpose" || op == "Flatten" ||
|
| op == "Squeeze" || op == "Unsqueeze");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the row a named value stands on |
|
| //+------------------------------------------------------------------+
|
| int COmvNeurons::BandOf(const string name, const string &names[], const int &bands[],
|
| const int count) const
|
| {
|
| //--- Scan the names already placed for a match
|
| for(int i = 0; i < count; i++)
|
| if(names[i] == name)
|
| return bands[i];
|
| //--- Report that the value stands on no row
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Take how many numbers a named value carries |
|
| //+------------------------------------------------------------------+
|
| int COmvNeurons::WidthOf(COmvModel &model, const string name) const
|
| {
|
| //--- A graph input announces its own shape
|
| for(int i = 0; i < model.Inputs(); i++)
|
| {
|
| //--- Fetch this graph input
|
| OmvPort port;
|
| model.InputAt(i, port);
|
| //--- Take the last axis, which is the count of numbers
|
| if(port.name == name && port.dims > 0)
|
| return port.dim[port.dims - 1];
|
| }
|
| //--- A value passing between layers announces its shape when the file says so
|
| for(int i = 0; i < model.Inners(); i++)
|
| {
|
| //--- Fetch this inner value
|
| OmvPort port;
|
| model.InnerAt(i, port);
|
| //--- Take the last axis, which is the count of numbers
|
| if(port.name == name && port.dims > 0)
|
| return port.dim[port.dims - 1];
|
| }
|
| //--- A graph output announces its own shape
|
| for(int i = 0; i < model.Outputs(); i++)
|
| {
|
| //--- Fetch this graph output
|
| OmvPort port;
|
| model.OutputAt(i, port);
|
| //--- Take the last axis, which is the count of numbers
|
| if(port.name == name && port.dims > 0)
|
| return port.dim[port.dims - 1];
|
| }
|
| //--- Report nothing for a value the file never shapes
|
| return 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the tensor a name belongs to |
|
| //+------------------------------------------------------------------+
|
| int COmvNeurons::TensorNamed(COmvModel &model, const string name) const
|
| {
|
| //--- Scan every stored tensor for a matching name
|
| for(int i = 0; i < model.Tensors(); i++)
|
| {
|
| //--- Fetch this tensor
|
| OmvTensor tensor;
|
| model.TensorAt(i, tensor);
|
| //--- Report the one that carries the name
|
| if(tensor.name == name)
|
| return i;
|
| }
|
| //--- Report that no tensor carries it
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Open a new row of neurons |
|
| //+------------------------------------------------------------------+
|
| int COmvNeurons::AddBand(const int count, const string label)
|
| {
|
| //--- Reject a row that overflows the view or the store
|
| if(m_bands >= ON_MAX_BANDS || count <= 0 || count > ON_MAX_WIDE)
|
| return -1;
|
| //--- Describe the row
|
| OmvBand band;
|
| band.count = count;
|
| band.label = label;
|
| band.x = 0;
|
| band.y = 0;
|
| band.w = 0;
|
| band.rank = 0;
|
| band.act = "";
|
| band.live = false;
|
| band.named = false;
|
| ArrayInitialize(band.fired, 0.0);
|
| //--- Append it to the arrangement
|
| ArrayResize(m_band, m_bands + 1);
|
| m_band[m_bands++] = band;
|
| return m_bands - 1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name one neuron on a row that stands for something |
|
| //+------------------------------------------------------------------+
|
| string COmvNeurons::NeuronName(const int band, const int at) const
|
| {
|
| //--- Only the two ends carry meaning a reader can use
|
| if(band < 0 || band >= m_bands || !m_band[band].named)
|
| return "";
|
| //--- The first row is the numbers the model was fed
|
| if(band == 0)
|
| return OmvFeatureName(at);
|
| //--- The last row is the answer it chose between
|
| const string picks[3] = {"down", "flat", "up"};
|
| return (at >= 0 && at < 3) ? picks[at] : "";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply the function a row shapes its numbers with |
|
| //+------------------------------------------------------------------+
|
| double COmvNeurons::Shape(const string act, const double v) const
|
| {
|
| //--- Match the functions a dense network normally applies
|
| if(act == "Relu")
|
| return (v > 0.0) ? v : 0.0;
|
| if(act == "Tanh")
|
| return MathTanh(v);
|
| if(act == "Sigmoid")
|
| return 1.0 / (1.0 + MathExp(-v));
|
| if(act == "LeakyRelu")
|
| return (v > 0.0) ? v : v * 0.01;
|
| //--- Anything else passes the number through untouched
|
| return v;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Push one bar's numbers through every row in turn |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::Run(COmvModel &model, const double &feed[], const int count)
|
| {
|
| //--- Refuse to run an arrangement that was never built
|
| if(!m_ready || m_bands <= 0)
|
| return false;
|
| //--- Refuse a feed that does not match the row it enters
|
| if(count != m_band[0].count || count > ON_MAX_WIDE)
|
| return false;
|
| //--- Clear whatever the previous bar produced
|
| for(int i = 0; i < m_bands; i++)
|
| {
|
| //--- A row holds nothing until something reaches it
|
| ArrayInitialize(m_band[i].fired, 0.0);
|
| m_band[i].live = false;
|
| }
|
| //--- Seat the incoming numbers on the first row
|
| for(int i = 0; i < count; i++)
|
| m_band[0].fired[i] = feed[i];
|
| m_band[0].live = true;
|
| //--- Work the rows in the order the walk laid them out
|
| for(int w = 0; w < m_webs; w++)
|
| {
|
| //--- Take this run and the two rows it joins
|
| const int from = m_web[w].from, to = m_web[w].to;
|
| if(from < 0 || to < 0 || from >= m_bands || to >= m_bands)
|
| continue;
|
| //--- A source that never fired cannot feed anything
|
| if(!m_band[from].live)
|
| continue;
|
| //--- A structural run carries its numbers across unchanged
|
| if(m_web[w].tensor < 0)
|
| {
|
| //--- Copy each neuron into the place it lands on the joined row
|
| for(int i = 0; i < m_band[from].count; i++)
|
| {
|
| //--- Stay inside the row being written
|
| const int at = m_web[w].offset + i;
|
| if(at >= 0 && at < m_band[to].count)
|
| m_band[to].fired[at] = m_band[from].fired[i];
|
| }
|
| m_band[to].live = true;
|
| continue;
|
| }
|
| //--- Take the weights and the bias this run applies
|
| OmvTensor weight, carry;
|
| model.TensorAt(m_web[w].tensor, weight);
|
| const bool hasBias = (m_web[w].bias >= 0);
|
| if(hasBias)
|
| model.TensorAt(m_web[w].bias, carry);
|
| //--- Multiply the source row by the weights into the target row
|
| for(int c = 0; c < m_band[to].count; c++)
|
| {
|
| //--- Add every source neuron scaled by the weight joining the pair
|
| double total = 0.0;
|
| for(int r = 0; r < m_band[from].count; r++)
|
| {
|
| //--- Reach the pair whichever way the matrix was stored
|
| const int at = m_web[w].transposed
|
| ? c * m_band[from].count + r
|
| : r * m_band[to].count + c;
|
| if(at >= 0 && at < weight.kept)
|
| total += m_band[from].fired[r] * weight.val[at];
|
| }
|
| //--- Add what the operator carries, then shape the result
|
| if(hasBias && c < carry.kept)
|
| total += carry.val[c];
|
| m_band[to].fired[c] = Shape(m_band[to].act, total);
|
| }
|
| m_band[to].live = true;
|
| }
|
| //--- Report that every row now holds a number
|
| m_live = true;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Follow the value names into rows of neurons |
|
| //+------------------------------------------------------------------+
|
| bool COmvNeurons::Build(COmvModel &model)
|
| {
|
| //--- Drop whatever a previous model left behind
|
| Clear();
|
| //--- Refuse a graph that exposes nothing to start from
|
| if(model.Inputs() <= 0)
|
| {
|
| m_reason = "the graph exposes no input";
|
| return false;
|
| }
|
| //--- Track which row each value name stands on
|
| string names[];
|
| int bands[];
|
| int named = 0;
|
| ArrayResize(names, OMV_MAX_NODES * 2);
|
| ArrayResize(bands, OMV_MAX_NODES * 2);
|
| //--- Open the first row from the graph input
|
| OmvPort first;
|
| model.InputAt(0, first);
|
| const int firstWide = WidthOf(model, first.name);
|
| if(firstWide <= 0)
|
| {
|
| m_reason = "the graph input carries no shape";
|
| return false;
|
| }
|
| names[named] = first.name;
|
| bands[named] = AddBand(firstWide, first.name);
|
| named++;
|
| //--- Walk the layers in file order, opening a row wherever weights appear
|
| for(int i = 0; i < model.Nodes(); i++)
|
| {
|
| //--- Fetch this layer
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Find which of its inputs already stand on a row
|
| int fed[8];
|
| int feds = 0;
|
| for(int j = 0; j < node.feedCount && feds < 8; j++)
|
| {
|
| //--- Keep only the names a previous layer produced
|
| const int b = BandOf(node.feeds[j], names, bands, named);
|
| if(b >= 0)
|
| fed[feds++] = b;
|
| }
|
| //--- Find a two dimensional weight among its inputs
|
| int weight = -1;
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Take the first stored tensor carrying two axes
|
| const int k = TensorNamed(model, node.feeds[j]);
|
| if(k < 0)
|
| continue;
|
| OmvTensor probe;
|
| model.TensorAt(k, probe);
|
| if(probe.dims == 2)
|
| {
|
| weight = k;
|
| break;
|
| }
|
| }
|
| //--- A dense layer opens a row and connects to it through its weights
|
| if(IsDense(node.op) && feds > 0 && weight >= 0)
|
| {
|
| //--- Take whether the operator stores its weights the other way round
|
| bool flipped = false;
|
| for(int a = 0; a < node.attrCount; a++)
|
| if(node.attrName[a] == "transB" && node.attrValue[a] == "1")
|
| flipped = true;
|
| //--- Find the one dimensional tensor the operator adds after the weights
|
| int carry = -1;
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Take the first stored tensor with a single axis
|
| const int k = TensorNamed(model, node.feeds[j]);
|
| if(k < 0)
|
| continue;
|
| OmvTensor probe;
|
| model.TensorAt(k, probe);
|
| if(probe.dims == 1)
|
| {
|
| carry = k;
|
| break;
|
| }
|
| }
|
| //--- Take both widths from whichever axes the storage implies
|
| OmvTensor w;
|
| model.TensorAt(weight, w);
|
| const int outWide = flipped ? w.dim[0] : w.dim[1];
|
| const int inWide = flipped ? w.dim[1] : w.dim[0];
|
| //--- Refuse a weight matrix with an empty axis
|
| if(outWide <= 0 || inWide <= 0)
|
| {
|
| m_reason = node.op + " carries a weight matrix with an empty axis";
|
| return false;
|
| }
|
| //--- Refuse a weight matrix whose input axis does not match the row feeding it
|
| if(inWide != m_band[fed[0]].count)
|
| {
|
| m_reason = node.op + " expects " + IntegerToString(inWide) + " inputs, but the row feeding it holds "
|
| + IntegerToString(m_band[fed[0]].count);
|
| return false;
|
| }
|
| const int made = AddBand(outWide, node.op);
|
| if(made < 0)
|
| {
|
| m_reason = "a layer is wider than " + IntegerToString(ON_MAX_WIDE) +
|
| " neurons, or the model has more layers than the view can stack";
|
| return false;
|
| }
|
| //--- Record the run of connections the weight describes
|
| OmvWeb web;
|
| web.from = fed[0];
|
| web.to = made;
|
| web.tensor = weight;
|
| web.offset = 0;
|
| web.transposed = flipped;
|
| web.bias = carry;
|
| ArrayResize(m_web, m_webs + 1);
|
| m_web[m_webs++] = web;
|
| //--- Stand the produced name on the new row
|
| if(node.emitCount > 0 && named < ArraySize(names))
|
| {
|
| names[named] = node.emits[0];
|
| bands[named] = made;
|
| named++;
|
| }
|
| continue;
|
| }
|
| //--- A joining layer opens a row that its sources feed positionally
|
| if(node.op == "Concat" && feds >= 2)
|
| {
|
| //--- Add the widths of every row arriving here
|
| int total = 0;
|
| for(int j = 0; j < feds; j++)
|
| total += m_band[fed[j]].count;
|
| const int made = AddBand(total, "Concat");
|
| if(made < 0)
|
| {
|
| m_reason = "a joined row is wider than " + IntegerToString(ON_MAX_WIDE) +
|
| " neurons, or the model has more layers than the view can stack";
|
| return false;
|
| }
|
| //--- Record one structural run per source, each at its own offset
|
| int at = 0;
|
| for(int j = 0; j < feds; j++)
|
| {
|
| //--- Note where this source lands on the joined row
|
| OmvWeb web;
|
| web.from = fed[j];
|
| web.to = made;
|
| web.tensor = -1;
|
| web.offset = at;
|
| web.transposed = false;
|
| web.bias = -1;
|
| ArrayResize(m_web, m_webs + 1);
|
| m_web[m_webs++] = web;
|
| at += m_band[fed[j]].count;
|
| }
|
| //--- Stand the produced name on the new row
|
| if(node.emitCount > 0 && named < ArraySize(names))
|
| {
|
| names[named] = node.emits[0];
|
| bands[named] = made;
|
| named++;
|
| }
|
| continue;
|
| }
|
| //--- These change the numbers on a row without changing how many there are
|
| if((IsUnary(node.op) || IsBinary(node.op) || IsShape(node.op)) && feds > 0)
|
| {
|
| //--- Stand the produced name on the same row and note what was applied
|
| if(node.emitCount > 0 && named < ArraySize(names))
|
| {
|
| names[named] = node.emits[0];
|
| bands[named] = fed[0];
|
| named++;
|
| }
|
| if(IsUnary(node.op) || IsBinary(node.op))
|
| {
|
| m_band[fed[0]].label += " + " + node.op;
|
| //--- Remember the last shaping function, which is what the row applies
|
| if(IsUnary(node.op))
|
| m_band[fed[0]].act = node.op;
|
| }
|
| continue;
|
| }
|
| //--- A layer reading only stored tensors touches no row at all
|
| if(feds == 0)
|
| continue;
|
| //--- A dense layer whose weights are computed rather than stored
|
| if(IsDense(node.op))
|
| {
|
| m_reason = node.op + " takes its weights from another layer, not from a stored tensor";
|
| return false;
|
| }
|
| //--- Anything else has no neurons to draw, so the view cannot be honest
|
| m_reason = "the model uses " + node.op + ", which has no neuron pairs to draw";
|
| return false;
|
| }
|
| //--- Refuse a graph that produced no weighted connection at all
|
| if(m_webs <= 0 || m_bands < 2)
|
| {
|
| m_reason = "the model has no dense layers";
|
| return false;
|
| }
|
| //--- Count what the arrangement would cost to draw
|
| int neurons = 0;
|
| for(int i = 0; i < m_bands; i++)
|
| neurons += m_band[i].count;
|
| if(neurons > ON_MAX_NEURONS)
|
| {
|
| m_reason = "the model has " + IntegerToString(neurons) + " neurons to draw";
|
| return false;
|
| }
|
| //--- Take how deep each row sits by walking the runs until nothing moves
|
| for(int pass = 0; pass < m_bands; pass++)
|
| {
|
| //--- Push every target one step deeper than the source that feeds it
|
| bool moved = false;
|
| for(int i = 0; i < m_webs; i++)
|
| {
|
| //--- Deepen the target only when the source now sits deeper
|
| const int want = m_band[m_web[i].from].rank + 1;
|
| if(m_band[m_web[i].to].rank < want)
|
| {
|
| m_band[m_web[i].to].rank = want;
|
| moved = true;
|
| }
|
| }
|
| //--- Stop as soon as a whole pass changes nothing
|
| if(!moved)
|
| break;
|
| }
|
| //--- Measure every row and find how deep the arrangement runs
|
| int deepest = 0;
|
| for(int i = 0; i < m_bands; i++)
|
| {
|
| //--- Take the width the circles occupy on this row
|
| m_band[i].w = m_band[i].count * ON_DOT + (m_band[i].count - 1) * ON_DOT_GAP;
|
| if(m_band[i].rank > deepest)
|
| deepest = m_band[i].rank;
|
| }
|
| //--- Lay every rank across, so rows sharing a depth sit side by side
|
| int widest = 0;
|
| for(int r = 0; r <= deepest; r++)
|
| {
|
| //--- Add the widths of every row at this depth
|
| int across = 0, seen = 0;
|
| for(int i = 0; i < m_bands; i++)
|
| if(m_band[i].rank == r)
|
| {
|
| across += m_band[i].w;
|
| seen++;
|
| }
|
| if(seen > 1)
|
| across += (seen - 1) * ON_RANK_GAP;
|
| if(across > widest)
|
| widest = across;
|
| }
|
| //--- Place each row against the widest rank, centered as a group
|
| for(int r = 0; r <= deepest; r++)
|
| {
|
| //--- Measure this rank again to know where the group starts
|
| int across = 0, seen = 0;
|
| for(int i = 0; i < m_bands; i++)
|
| if(m_band[i].rank == r)
|
| {
|
| across += m_band[i].w;
|
| seen++;
|
| }
|
| if(seen > 1)
|
| across += (seen - 1) * ON_RANK_GAP;
|
| //--- Walk the rank left to right from that starting point
|
| int at = (widest - across) / 2;
|
| for(int i = 0; i < m_bands; i++)
|
| {
|
| //--- Place only the rows sitting at this depth
|
| if(m_band[i].rank != r)
|
| continue;
|
| m_band[i].x = at + ON_SIDE_PAD;
|
| m_band[i].y = ON_TOP_PAD + r * ON_BAND_GAP;
|
| at += m_band[i].w + ON_RANK_GAP;
|
| }
|
| }
|
| m_height = ON_TOP_PAD + deepest * ON_BAND_GAP + ON_DOT + ON_FOOT_PAD;
|
| //--- Mark the input and output rows as named
|
| if(m_bands > 0 && m_band[0].count == OF_INPUTS)
|
| m_band[0].named = true;
|
| if(m_bands > 1 && m_band[m_bands - 1].count == 3)
|
| m_band[m_bands - 1].named = true;
|
| m_width = widest + ON_SIDE_PAD * 2;
|
| m_ready = true;
|
| //--- Report the arrangement as built
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Construct an empty layout |
|
| //+------------------------------------------------------------------+
|
| COmvLayout::COmvLayout(void)
|
| {
|
| //--- Clear every field so a query before building reports empty
|
| Clear();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Drop everything the previous build produced |
|
| //+------------------------------------------------------------------+
|
| void COmvLayout::Clear(void)
|
| {
|
| //--- Zero the counts that bound both arrays
|
| m_boxes = 0;
|
| m_edges = 0;
|
| //--- Release the stored geometry
|
| ArrayResize(m_box, 0);
|
| ArrayResize(m_edge, 0);
|
| //--- Zero the overall size
|
| m_width = 0;
|
| m_height = 0;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Classify an operator into a coloring role |
|
| //+------------------------------------------------------------------+
|
| int COmvLayout::RoleOf(const string op) const
|
| {
|
| //--- Group the operators that carry weight matrices
|
| if(op == "Gemm" || op == "MatMul" || op == "Conv" || op == "ConvTranspose")
|
| return OL_ROLE_COMPUTE;
|
| //--- Group the elementwise activations
|
| if(op == "Tanh" || op == "Relu" || op == "Sigmoid" || op == "LeakyRelu" || op == "Elu")
|
| return OL_ROLE_ACTIVATE;
|
| //--- Group the operators that rearrange rather than compute
|
| if(op == "Concat" || op == "Reshape" || op == "Transpose" || op == "Split" || op == "Slice")
|
| return OL_ROLE_SHAPE;
|
| //--- Group the operators that normally end a graph
|
| if(op == "Softmax" || op == "LogSoftmax" || op == "Sigmoid")
|
| return OL_ROLE_OUTPUT;
|
| //--- Leave everything else plain
|
| return OL_ROLE_PLAIN;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the node that emits a given name |
|
| //+------------------------------------------------------------------+
|
| int COmvLayout::ProducerOf(COmvModel &model, const string name) const
|
| {
|
| //--- Scan every node for one that emits this name
|
| for(int i = 0; i < model.Nodes(); i++)
|
| {
|
| //--- Fetch this node
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Compare every name it produces
|
| for(int j = 0; j < node.emitCount; j++)
|
| if(node.emits[j] == name)
|
| return i;
|
| }
|
| //--- Report that no node produces it
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether a name belongs to a stored weight tensor |
|
| //+------------------------------------------------------------------+
|
| bool COmvLayout::IsWeight(COmvModel &model, const string name) const
|
| {
|
| //--- Scan every tensor for a matching name
|
| for(int i = 0; i < model.Tensors(); i++)
|
| {
|
| //--- Fetch this tensor
|
| OmvTensor tensor;
|
| model.TensorAt(i, tensor);
|
| //--- Report a match
|
| if(tensor.name == name)
|
| return true;
|
| }
|
| //--- Report that no tensor carries this name
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether any name feeding a node comes from a node |
|
| //+------------------------------------------------------------------+
|
| bool COmvLayout::HasNodeParent(COmvModel &model, const OmvNode &node) const
|
| {
|
| //--- Test every name feeding this node
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Skip names that are weights rather than node outputs
|
| if(IsWeight(model, node.feeds[j]))
|
| continue;
|
| //--- Report a name that another node produces
|
| if(ProducerOf(model, node.feeds[j]) >= 0)
|
| return true;
|
| }
|
| //--- Report that nothing upstream feeds this node
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the shallowest rank among a node's consumers |
|
| //+------------------------------------------------------------------+
|
| int COmvLayout::ShallowestConsumer(COmvModel &model, const int index, const int &rank[]) const
|
| {
|
| //--- Fetch the node whose consumers are wanted
|
| OmvNode source;
|
| model.NodeAt(index, source);
|
| //--- Start above every possible rank
|
| int shallowest = -1;
|
| //--- Scan every node for one that reads a name this node emits
|
| for(int k = 0; k < model.Nodes(); k++)
|
| {
|
| //--- Fetch the candidate consumer
|
| OmvNode target;
|
| model.NodeAt(k, target);
|
| //--- Compare every name feeding the candidate
|
| for(int j = 0; j < target.feedCount; j++)
|
| {
|
| //--- Skip names that are weights rather than node outputs
|
| if(IsWeight(model, target.feeds[j]))
|
| continue;
|
| //--- Skip names this node does not emit
|
| if(ProducerOf(model, target.feeds[j]) != index)
|
| continue;
|
| //--- Track the shallowest consumer found so far
|
| if(shallowest < 0 || rank[k] < shallowest)
|
| shallowest = rank[k];
|
| }
|
| }
|
| //--- Report the shallowest rank, or a negative when nothing consumes it
|
| return shallowest;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report the shape a named value carries |
|
| //+------------------------------------------------------------------+
|
| string COmvLayout::ShapeOf(COmvModel &model, const string name) const
|
| {
|
| //--- A graph input announces its own shape
|
| for(int i = 0; i < model.Inputs(); i++)
|
| {
|
| //--- Fetch this graph input
|
| OmvPort port;
|
| model.InputAt(i, port);
|
| //--- Report the shape when the name matches
|
| if(port.name == name)
|
| return model.DimsText(port.dim, port.dims);
|
| }
|
| //--- A graph output announces its own shape
|
| for(int i = 0; i < model.Outputs(); i++)
|
| {
|
| //--- Fetch this graph output
|
| OmvPort port;
|
| model.OutputAt(i, port);
|
| //--- Report the shape when the name matches
|
| if(port.name == name)
|
| return model.DimsText(port.dim, port.dims);
|
| }
|
| //--- A value passing between layers announces its shape when the file says so
|
| for(int i = 0; i < model.Inners(); i++)
|
| {
|
| //--- Fetch this inner value
|
| OmvPort port;
|
| model.InnerAt(i, port);
|
| //--- Report the shape when the name matches
|
| if(port.name == name)
|
| return model.DimsText(port.dim, port.dims);
|
| }
|
| //--- A stored tensor announces its own shape
|
| for(int i = 0; i < model.Tensors(); i++)
|
| {
|
| //--- Fetch this tensor
|
| OmvTensor tensor;
|
| model.TensorAt(i, tensor);
|
| //--- Report the shape when the name matches
|
| if(tensor.name == name)
|
| return model.DimsText(tensor.dim, tensor.dims);
|
| }
|
| //--- Report nothing for a value the file never shapes
|
| return "";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Place a box standing for a value the graph exposes |
|
| //+------------------------------------------------------------------+
|
| void COmvLayout::AddPortBox(const string name, const int rank)
|
| {
|
| //--- Refuse a box beyond what the arrangement may hold
|
| if(m_boxes >= OMV_MAX_NODES)
|
| return;
|
| //--- Describe the box, which carries a name rather than a layer
|
| OmvBox box;
|
| box.node = -1;
|
| box.portName = name;
|
| box.rank = rank;
|
| box.role = OL_ROLE_PORT;
|
| box.rowCount = 0;
|
| box.w = OL_BOX_W;
|
| box.h = OL_BOX_S;
|
| box.x = (m_width - OL_BOX_W) / 2;
|
| box.y = 0;
|
| //--- Append it to the arrangement
|
| ArrayResize(m_box, m_boxes + 1);
|
| m_box[m_boxes++] = box;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Record one connection between two placed boxes |
|
| //+------------------------------------------------------------------+
|
| void COmvLayout::AddEdge(const int from, const int to, const string label, const string shape)
|
| {
|
| //--- Refuse a connection between boxes that were never placed
|
| if(from < 0 || to < 0 || from >= m_boxes || to >= m_boxes)
|
| return;
|
| //--- Describe the connection and the value it carries
|
| OmvEdge edge;
|
| edge.from = from;
|
| edge.to = to;
|
| edge.label = label;
|
| edge.shape = shape;
|
| //--- Append it to the arrangement
|
| ArrayResize(m_edge, m_edges + 1);
|
| m_edge[m_edges++] = edge;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| List every stored weight an operator reads |
|
| //+------------------------------------------------------------------+
|
| void COmvLayout::RowsOf(COmvModel &model, const OmvNode &node, OmvBox &box) const
|
| {
|
| //--- Start with an empty listing
|
| box.rowCount = 0;
|
| //--- The operator calls its inputs A, B, C and so on in order
|
| const string letters = "ABCDEFGH";
|
| //--- Walk the names feeding this node
|
| for(int j = 0; j < node.feedCount && box.rowCount < OL_MAX_ROWS; j++)
|
| {
|
| //--- Look for a stored tensor carrying this name
|
| for(int i = 0; i < model.Tensors(); i++)
|
| {
|
| //--- Fetch this tensor
|
| OmvTensor tensor;
|
| model.TensorAt(i, tensor);
|
| //--- Skip anything that is not the name being looked up
|
| if(tensor.name != node.feeds[j])
|
| continue;
|
| //--- Name the input by its position on the operator
|
| box.rowLabel[box.rowCount] = StringSubstr(letters, j, 1);
|
| //--- Print the shape the way the operator reports it
|
| box.rowText[box.rowCount] = model.DimsText(tensor.dim, tensor.dims);
|
| box.rowTensor[box.rowCount] = i;
|
| box.rowName[box.rowCount] = tensor.name;
|
| box.rowCount++;
|
| break;
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Arrange every node into ranks and connect them |
|
| //+------------------------------------------------------------------+
|
| bool COmvLayout::Build(COmvModel &model)
|
| {
|
| //--- Drop any arrangement held from a previous model
|
| Clear();
|
| //--- Abort when the model holds no nodes
|
| const int total = model.Nodes();
|
| if(total <= 0)
|
| return false;
|
| //--- Start every node at an unknown depth
|
| int rank[];
|
| ArrayResize(rank, total);
|
| ArrayInitialize(rank, -1);
|
| //--- Settle depths by repeated passes so parents always come first
|
| for(int pass = 0; pass < total; pass++)
|
| {
|
| //--- Track whether this pass moved anything
|
| bool moved = false;
|
| //--- Visit every node
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Take the deepest producer feeding it
|
| int deepest = -1;
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Skip names that are weights rather than node outputs
|
| if(IsWeight(model, node.feeds[j]))
|
| continue;
|
| //--- Find the node emitting this name
|
| const int producer = ProducerOf(model, node.feeds[j]);
|
| //--- Track the deepest one settled so far
|
| if(producer >= 0 && rank[producer] > deepest)
|
| deepest = rank[producer];
|
| }
|
| //--- Sit one level below the deepest producer
|
| const int want = deepest + 1;
|
| //--- Push the node down when this pass found it deeper
|
| if(want > rank[i])
|
| {
|
| rank[i] = want;
|
| moved = true;
|
| }
|
| }
|
| //--- Stop once a pass changes nothing
|
| if(!moved)
|
| break;
|
| }
|
| //--- Sink a node with no upstream parent to just above its consumer
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Leave a node that something upstream already feeds
|
| if(HasNodeParent(model, node))
|
| continue;
|
| //--- Find where its shallowest consumer sits
|
| const int consumer = ShallowestConsumer(model, i, rank);
|
| //--- Drop the node to one rank above that consumer
|
| if(consumer > 0 && consumer - 1 > rank[i])
|
| rank[i] = consumer - 1;
|
| }
|
| //--- Count how many nodes sit on each rank
|
| int depth = 0;
|
| for(int i = 0; i < total; i++)
|
| if(rank[i] > depth)
|
| depth = rank[i];
|
| int perRank[];
|
| ArrayResize(perRank, depth + 1);
|
| ArrayInitialize(perRank, 0);
|
| for(int i = 0; i < total; i++)
|
| perRank[rank[i]]++;
|
| //--- Find the widest rank so every rank can be centered against it
|
| int widest = 1;
|
| for(int r = 0; r <= depth; r++)
|
| if(perRank[r] > widest)
|
| widest = perRank[r];
|
| m_width = widest * OL_BOX_W + (widest - 1) * OL_GAP_X;
|
| //--- Track how many boxes each rank has already placed
|
| int placed[];
|
| ArrayResize(placed, depth + 1);
|
| ArrayInitialize(placed, 0);
|
| //--- Find which ranks are entered by a connection that carries a label
|
| bool wideGap[];
|
| ArrayResize(wideGap, depth + 2);
|
| ArrayInitialize(wideGap, false);
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node to read the names it takes in
|
| OmvNode probe;
|
| model.NodeAt(i, probe);
|
| //--- Test every name that is not a stored weight
|
| for(int j = 0; j < probe.feedCount; j++)
|
| {
|
| //--- Skip a name the file never shaped, it draws no label
|
| if(IsWeight(model, probe.feeds[j]))
|
| continue;
|
| if(StringLen(ShapeOf(model, probe.feeds[j])) == 0)
|
| continue;
|
| //--- Widen the gap above the rank this node sits on
|
| wideGap[rank[i]] = true;
|
| }
|
| }
|
| //--- A graph output is always entered by a labelled connection
|
| if(model.Outputs() > 0)
|
| wideGap[depth + 1] = true;
|
| //--- Measure the tallest box on every rank so ranks never overlap
|
| int rowHigh[];
|
| ArrayResize(rowHigh, depth + 1);
|
| ArrayInitialize(rowHigh, OL_BOX_S);
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node to size the box it will get
|
| OmvNode probe;
|
| model.NodeAt(i, probe);
|
| OmvBox sizing;
|
| RowsOf(model, probe, sizing);
|
| //--- Take the taller of what this rank already holds and this box
|
| const int high = (sizing.rowCount > 0)
|
| ? OL_HEAD_H + OL_ROW_PAD * 2 + sizing.rowCount * OL_ROW_H : OL_BOX_S;
|
| if(high > rowHigh[rank[i]])
|
| rowHigh[rank[i]] = high;
|
| }
|
| //--- Place one box per node
|
| ArrayResize(m_box, total);
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Describe the box
|
| OmvBox box;
|
| box.node = i;
|
| box.rank = rank[i];
|
| box.role = RoleOf(node.op);
|
| RowsOf(model, node, box);
|
| box.w = OL_BOX_W;
|
| //--- Size the box to the header plus however many rows it lists
|
| box.h = (box.rowCount > 0)
|
| ? OL_HEAD_H + OL_ROW_PAD * 2 + box.rowCount * OL_ROW_H : OL_BOX_S;
|
| //--- Center this rank inside the widest one
|
| const int count = perRank[rank[i]];
|
| const int span = count * OL_BOX_W + (count - 1) * OL_GAP_X;
|
| const int left = (m_width - span) / 2;
|
| //--- Step across the rank by however many boxes it already holds
|
| box.x = left + placed[rank[i]] * (OL_BOX_W + OL_GAP_X);
|
| box.y = 0;
|
| //--- Stack this rank below every taller rank above it
|
| for(int r = 0; r < rank[i]; r++)
|
| box.y += rowHigh[r] + (wideGap[r + 1] ? OL_GAP_Y : OL_GAP_S);
|
| placed[rank[i]]++;
|
| //--- Store the placed box
|
| m_box[m_boxes++] = box;
|
| }
|
| //--- Give every graph input a box on a rank of its own above the graph
|
| for(int p = 0; p < model.Inputs(); p++)
|
| {
|
| //--- Fetch this graph input
|
| OmvPort port;
|
| model.InputAt(p, port);
|
| //--- Skip a name that a stored tensor already covers
|
| if(IsWeight(model, port.name))
|
| continue;
|
| AddPortBox(port.name, -1);
|
| }
|
| //--- Give every graph output a box on a rank of its own below the graph
|
| for(int p = 0; p < model.Outputs(); p++)
|
| {
|
| //--- Fetch this graph output
|
| OmvPort port;
|
| model.OutputAt(p, port);
|
| AddPortBox(port.name, depth + 1);
|
| }
|
| //--- Shift every layer box down to leave the input rank its room
|
| const int inputGap = wideGap[0] ? OL_GAP_Y : OL_GAP_S;
|
| for(int i = 0; i < m_boxes; i++)
|
| if(m_box[i].rank >= 0)
|
| m_box[i].y += OL_BOX_S + inputGap;
|
| //--- Place the output boxes under the deepest rank
|
| int deepestY = 0;
|
| for(int i = 0; i < m_boxes; i++)
|
| if(m_box[i].rank >= 0 && m_box[i].y + m_box[i].h > deepestY)
|
| deepestY = m_box[i].y + m_box[i].h;
|
| const int outputGap = wideGap[depth + 1] ? OL_GAP_Y : OL_GAP_S;
|
| for(int i = 0; i < m_boxes; i++)
|
| if(m_box[i].rank > depth)
|
| m_box[i].y = deepestY + outputGap;
|
| //--- Measure the whole arrangement from the boxes it actually holds
|
| m_height = 0;
|
| for(int i = 0; i < m_boxes; i++)
|
| if(m_box[i].y + m_box[i].h > m_height)
|
| m_height = m_box[i].y + m_box[i].h;
|
| //--- Connect every graph input box to the layers that read it
|
| for(int i = 0; i < m_boxes; i++)
|
| {
|
| //--- Take only the boxes standing for a graph input
|
| if(m_box[i].rank != -1)
|
| continue;
|
| //--- Find every layer reading that name
|
| for(int k = 0; k < total; k++)
|
| {
|
| //--- Fetch the candidate layer
|
| OmvNode target;
|
| model.NodeAt(k, target);
|
| //--- Compare every name feeding it
|
| for(int j = 0; j < target.feedCount; j++)
|
| {
|
| //--- Skip a name that is not this port
|
| if(target.feeds[j] != m_box[i].portName)
|
| continue;
|
| //--- Find the box the layer was placed in
|
| for(int b = 0; b < m_boxes; b++)
|
| {
|
| //--- Store the connection once the box is found
|
| if(m_box[b].node != k)
|
| continue;
|
| AddEdge(i, b, m_box[i].portName, ShapeOf(model, m_box[i].portName));
|
| break;
|
| }
|
| }
|
| }
|
| }
|
| //--- Connect the layer that writes each graph output to its box
|
| for(int i = 0; i < m_boxes; i++)
|
| {
|
| //--- Take only the boxes standing for a graph output
|
| if(m_box[i].rank <= depth)
|
| continue;
|
| //--- Find the layer emitting that name
|
| const int producer = ProducerOf(model, m_box[i].portName);
|
| if(producer < 0)
|
| continue;
|
| //--- Find the box the layer was placed in
|
| for(int b = 0; b < m_boxes; b++)
|
| {
|
| //--- Store the connection once the box is found
|
| if(m_box[b].node != producer)
|
| continue;
|
| AddEdge(b, i, m_box[i].portName, ShapeOf(model, m_box[i].portName));
|
| break;
|
| }
|
| }
|
| //--- Connect every node to the nodes feeding it
|
| for(int i = 0; i < total; i++)
|
| {
|
| //--- Fetch this node
|
| OmvNode node;
|
| model.NodeAt(i, node);
|
| //--- Draw one edge per producing name
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Skip names that are weights rather than node outputs
|
| if(IsWeight(model, node.feeds[j]))
|
| continue;
|
| //--- Find the node emitting this name
|
| const int producer = ProducerOf(model, node.feeds[j]);
|
| //--- Skip a name no node produces
|
| if(producer < 0)
|
| continue;
|
| //--- Find the boxes the two layers were placed in
|
| int fromBox = -1, toBox = -1;
|
| for(int b = 0; b < m_boxes; b++)
|
| {
|
| //--- Match each end to its box
|
| if(m_box[b].node == producer)
|
| fromBox = b;
|
| if(m_box[b].node == i)
|
| toBox = b;
|
| }
|
| //--- Skip a pair that was never placed
|
| if(fromBox < 0 || toBox < 0)
|
| continue;
|
| //--- Store the connection and the name it carries
|
| AddEdge(fromBox, toBox, node.feeds[j], ShapeOf(model, node.feeds[j]));
|
| }
|
| }
|
| //--- Report success
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Chart panel showing a parsed model |
|
| //+------------------------------------------------------------------+
|
| class COmvPanel
|
| {
|
| private:
|
| // Draw everything through one canvas
|
| COmvCanvas m_cv;
|
| // Hold the parsed model
|
| COmvModel m_model;
|
| // Hold the arranged geometry
|
| COmvLayout m_layout;
|
| // Hold the neuron arrangement
|
| COmvNeurons m_cells;
|
| // Hold the model the terminal runs on each bar
|
| COmvRunner m_runner;
|
| // Build the numbers the model reads from live bars
|
| COmvFeatures m_feed;
|
| // Remember the bar the model last answered for
|
| datetime m_lastBar;
|
| // Name the symbol the model was trained on
|
| string m_feedSymbol;
|
| // Name the timeframe the model was trained on
|
| ENUM_TIMEFRAMES m_feedPeriod;
|
| // Report how far our own pass sat from what the model returned
|
| double m_agree;
|
| // Track how far the signal has travelled since the bar closed, or a negative
|
| int m_pulse;
|
| // Name the row the pointer rests on, or a negative
|
| int m_hoverBand;
|
| // Name the neuron the pointer rests on, or a negative
|
| int m_hoverCell;
|
| // Show the neuron view in place of the graph
|
| bool m_neuronView;
|
| // Start on the neurons rather than the graph
|
| bool m_openNeurons;
|
| // Bound the control that switches between the two views
|
| int m_rView[4];
|
| // Resolve the active theme colors
|
| OmvTheme m_th;
|
|
|
| // Identify the chart the panel lives on
|
| long m_chartId;
|
| // Name the bitmap object
|
| string m_name;
|
| // Name the running program
|
| string m_title;
|
| // Track whether the canvas exists
|
| bool m_created;
|
| // Track whether teardown has run
|
| bool m_destroyed;
|
|
|
| // Place the panel left edge
|
| int m_x;
|
| // Place the panel top edge
|
| int m_y;
|
| // Measure the panel width
|
| int m_w;
|
| // Measure the panel height
|
| int m_h;
|
| // Remember the height before collapsing
|
| int m_fullH;
|
| // Select the full or collapsed mode
|
| int m_mode;
|
| // Track whether the dark theme is active
|
| bool m_dark;
|
| // Track whether the inspector column is open
|
| bool m_inspect;
|
|
|
| // Scale the graph inside its canvas
|
| double m_zoom;
|
| // Offset the graph horizontally inside its canvas
|
| int m_panX;
|
| // Offset the graph vertically inside its canvas
|
| int m_panY;
|
| // Index the node the inspector describes
|
| int m_selected;
|
| // Index the node under the pointer
|
| int m_hoverNode;
|
| // Name what kind of thing the inspector describes
|
| int m_pickKind;
|
| // Index the tensor the inspector describes
|
| int m_pickTensor;
|
| // Index the connection the inspector describes
|
| int m_pickLink;
|
| // Index the tensor row under the pointer
|
| int m_hoverRow;
|
| // Index the connection under the pointer
|
| int m_hoverLink;
|
| // Bound every drawn tensor row
|
| int m_rowRect[][4];
|
| // Name the tensor each drawn row belongs to
|
| int m_rowTensor[];
|
| // Count the rows drawn this frame
|
| int m_rows;
|
| // Remember the route every drawn connection took
|
| int m_linkPts[][12];
|
| // Count the points each drawn route holds
|
| int m_linkCount[];
|
| // Name the connection each drawn route belongs to
|
| int m_linkEdge[];
|
| // Count the connections drawn this frame
|
| int m_links;
|
| // Hold the rows the inspector lays out
|
| OmvRow m_info[];
|
| // Count the rows the inspector holds
|
| int m_infos;
|
| // Remember which row names the user has opened
|
| string m_opened[];
|
| // Count the names held open
|
| int m_openCount;
|
| // Offset the inspector when its rows run past the column
|
| int m_infoScroll;
|
| // Measure how tall the laid out rows are
|
| int m_infoHigh;
|
| // Index the row under the pointer
|
| int m_infoHover;
|
| // Name the value the pointer is lighting up in the graph
|
| string m_litName;
|
| // Track whether the pointer sits on a row's expander rather than its body
|
| bool m_onExpander;
|
| // Bound the inspector scrollbar thumb
|
| int m_rInfoBar[4];
|
|
|
| // Identify the control under the pointer
|
| int m_hover;
|
| // Identify the control the press began on
|
| int m_press;
|
| // Track a header drag
|
| bool m_dragging;
|
| // Track a grip drag
|
| bool m_resizing;
|
| // Track a canvas drag
|
| bool m_panning;
|
| // Track a scrollbar drag
|
| int m_barDrag;
|
| // Track whether the vertical bar is showing
|
| bool m_barV;
|
| // Track whether the horizontal bar is showing
|
| bool m_barH;
|
| // Remember the previous mouse button state
|
| bool m_lmbPrev;
|
| // Track whether chart scrolling is suppressed
|
| bool m_scrollLocked;
|
| // Remember whether the chart reported pointer moves before the panel asked
|
| bool m_hadMouse;
|
| // Remember whether the chart reported wheel turns before the panel asked
|
| bool m_hadWheel;
|
| // Offset the pointer inside the header at press
|
| int m_dragOffX;
|
| // Offset the pointer inside the header at press
|
| int m_dragOffY;
|
| // Offset the grip from the panel corner at press
|
| int m_gripOffX;
|
| // Offset the grip from the panel corner at press
|
| int m_gripOffY;
|
| // Remember where a canvas press began, to tell a click from a pan
|
| int m_pressX;
|
| // Remember where a canvas press began, to tell a click from a pan
|
| int m_pressY;
|
| // Remember the pointer position at a drag press
|
| int m_fromX;
|
| // Remember the pointer position at a drag press
|
| int m_fromY;
|
| // Remember the pan offset at a scrollbar press
|
| int m_barFrom;
|
| // Stamp the last repaint for the frame cap
|
| uint m_lastFrameMs;
|
| // Hold the chrome that does not change between frames
|
| uint m_bg[];
|
| // Track whether the cached chrome still matches the panel
|
| bool m_bgValid;
|
| // Keep the drawn view so a hover does not redraw every connection
|
| uint m_scene[];
|
| // Remember what the kept scene was drawn for
|
| string m_sceneSig;
|
| // Track whether the kept scene still matches the view
|
| bool m_sceneValid;
|
| // Track a frame the cap skipped
|
| bool m_dirty;
|
| // Describe everything the cached chrome depends on
|
| string m_bgSig;
|
| // Remember which tooltip the object currently carries
|
| string m_tipShown;
|
|
|
| // Bound the theme button
|
| int m_rTheme[4];
|
| // Bound the minimize button
|
| int m_rMin[4];
|
| // Bound the close button
|
| int m_rClose[4];
|
| // Bound the fit button
|
| int m_rFit[4];
|
| // Bound the zoom out button
|
| int m_rZoomOut[4];
|
| // Bound the zoom in button
|
| int m_rZoomIn[4];
|
| // Bound the inspector close button
|
| int m_rInspectX[4];
|
| // Bound the resize grip
|
| int m_rGrip[4];
|
| // Bound the vertical scrollbar thumb
|
| int m_rBarV[4];
|
| // Bound the horizontal scrollbar thumb
|
| int m_rBarH[4];
|
|
|
| void InitDefaults(void);
|
| void ComputeLayout(void);
|
| bool CreateCanvas(void);
|
| bool ApplyMode(void);
|
| void LockChartScroll(const bool lock);
|
| int CanvasLeft(void) const { return 1; }
|
| int CanvasTop(void) const { return OP_HEADER_H + OP_STAT_H + 1; }
|
| int CanvasRight(void) const { return m_inspect ? m_w - OP_INSPECT_W : m_w - 1; }
|
| int CanvasBottom(void) const { return m_h - OP_FOOT_H; }
|
| int ViewW(void) const { return CanvasRight() - CanvasLeft() - (m_barV ? OP_BAR : 0); }
|
| int ViewH(void) const { return CanvasBottom() - CanvasTop() - (m_barH ? OP_BAR : 0); }
|
| int ViewWide(void) const { return m_neuronView ? m_cells.Width() : m_layout.Width(); }
|
| int ViewHigh(void) const { return m_neuronView ? m_cells.Height() : m_layout.Height(); }
|
| int ScaledW(void) const { return (int)(ViewWide() * m_zoom); }
|
| int ScaledH(void) const { return (int)(ViewHigh() * m_zoom); }
|
| bool InRect(const int &r[], const int mx, const int my) const
|
| { return (r[2] > 0 && mx >= r[0] && mx < r[0] + r[2] && my >= r[1] && my < r[1] + r[3]); }
|
| int HitTest(const int mx, const int my);
|
| int NodeAtPoint(const int mx, const int my);
|
| int RowAtPoint(const int mx, const int my);
|
| int LinkAtPoint(const int mx, const int my);
|
| int TensorNamed(const string name) const;
|
| string TensorNameAt(const int index) const;
|
| string Measure(const double value) const;
|
| string ArgIn(const string op, const int slot) const;
|
| string ArgOut(const string op) const;
|
| void AddEndpoint(const string side, const int boxIndex);
|
| void FitGraph(void);
|
| void SetZoom(const double zoom);
|
| void OnWheel(const int mx, const int my, const int delta);
|
| void ClampPan(void);
|
| uint FillForRole(const int role) const;
|
| uint EdgeForRole(const int role) const;
|
| string TipFor(const int id) const;
|
| void SetTooltip(const string words);
|
|
|
| string ChromeSignature(void);
|
| string SceneSignature(void);
|
| void DrawChrome(void);
|
| void DrawShell(void);
|
| void DrawHeader(void);
|
| void DrawStats(void);
|
| void DrawGraph(void);
|
| void DrawNeurons(void);
|
| bool RunModel(void);
|
| void SizeBars(void);
|
| void DrawBars(void);
|
| void AddRow(const string name, const string value,
|
| const bool isHead, const string linkName = "");
|
| void AddLine(const string line);
|
| void AddValueLines(const string name);
|
| void AddTensorValues(const OmvTensor &tensor);
|
| void BuildInfo(void);
|
| void ToggleRow(const string key);
|
| int InfoAtPoint(const int mx, const int my);
|
| bool OnExpander(const int mx, const int row) const;
|
| int LinkNamed(const string name) const;
|
| void DrawInspector(void);
|
| void DrawFooterChrome(void);
|
| void DrawFooter(void);
|
| void DrawViewSwitch(void);
|
| void DrawButton(const int &r[], const int id, const string label);
|
| void DrawIcon(const int &r[], const int id, const int which);
|
| void PaintCapped(void);
|
|
|
| public:
|
| COmvPanel(void) { m_created = false; m_destroyed = false; m_scrollLocked = false; m_hadMouse = false; m_hadWheel = false; }
|
| bool Init(const long chartId, const string path, const string scale,
|
| const string symbol, const ENUM_TIMEFRAMES period,
|
| const bool startOnNeurons);
|
| void Destroy(void);
|
| void Render(void);
|
| void OnBar(void);
|
| void OnPulse(void);
|
| bool CellAtPoint(const int mx, const int my, int &band, int &cell) const;
|
| void CellSpan(double &dot, double &pitch) const;
|
| void CellOrigin(const OmvBand &band, double &x, double &y) const;
|
| void OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Reset every member to a safe starting value |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::InitDefaults(void)
|
| {
|
| //--- Clear the chart identity
|
| m_chartId = 0;
|
| m_name = "OMV_Panel";
|
| m_title = "";
|
| m_created = false;
|
| m_destroyed = false;
|
| //--- Anchor the panel and size it for full mode
|
| m_x = 20;
|
| m_y = 34;
|
| m_w = OP_W;
|
| m_h = OP_H;
|
| m_fullH = OP_H;
|
| m_mode = OM_FULL;
|
| //--- Start light with the inspector closed until a node is picked
|
| m_dark = false;
|
| m_inspect = false;
|
| //--- Start the graph unscaled and unshifted
|
| m_zoom = 1.0;
|
| m_panX = 0;
|
| m_panY = 0;
|
| m_selected = -1;
|
| m_hoverNode = -1;
|
| m_neuronView = false;
|
| m_openNeurons = false;
|
| m_lastBar = 0;
|
| m_agree = -1.0;
|
| m_pulse = -1;
|
| m_hoverBand = -1;
|
| m_hoverCell = -1;
|
| m_feedSymbol = "";
|
| m_feedPeriod = PERIOD_CURRENT;
|
| m_pickKind = OP_PICK_NONE;
|
| m_pickTensor = -1;
|
| m_pickLink = -1;
|
| m_hoverRow = -1;
|
| m_hoverLink = -1;
|
| m_rows = 0;
|
| m_links = 0;
|
| m_infos = 0;
|
| m_openCount = 0;
|
| m_litName = "";
|
| m_onExpander = false;
|
| m_infoScroll = 0;
|
| m_infoHigh = 0;
|
| m_infoHover = -1;
|
| //--- Clear the interaction state
|
| m_hover = OH_NONE;
|
| m_press = OH_NONE;
|
| m_dragging = false;
|
| m_resizing = false;
|
| m_panning = false;
|
| m_barDrag = OH_NONE;
|
| m_barV = false;
|
| m_barH = false;
|
| m_lmbPrev = false;
|
| m_scrollLocked = false;
|
| m_dragOffX = 0;
|
| m_dragOffY = 0;
|
| m_gripOffX = 0;
|
| m_gripOffY = 0;
|
| m_pressX = 0;
|
| m_pressY = 0;
|
| m_fromX = 0;
|
| m_fromY = 0;
|
| m_barFrom = 0;
|
| m_lastFrameMs = 0;
|
| m_bgValid = false;
|
| m_dirty = false;
|
| m_bgSig = "";
|
| m_sceneValid = false;
|
| m_sceneSig = "";
|
| m_tipShown = "";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Place every control against the current panel size |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::ComputeLayout(void)
|
| {
|
| //--- Sit the three header icons against the right edge
|
| const int iconY = (OP_HEADER_H - OP_ICON) / 2;
|
| m_rClose[0] = m_w - 40;
|
| m_rClose[1] = iconY;
|
| m_rClose[2] = OP_ICON;
|
| m_rClose[3] = OP_ICON;
|
| m_rMin[0] = m_w - 72;
|
| m_rMin[1] = iconY;
|
| m_rMin[2] = OP_ICON;
|
| m_rMin[3] = OP_ICON;
|
| m_rTheme[0] = m_w - 104;
|
| m_rTheme[1] = iconY;
|
| m_rTheme[2] = OP_ICON;
|
| m_rTheme[3] = OP_ICON;
|
| //--- Sit the view controls along the footer
|
| const int footY = m_h - OP_FOOT_H + (OP_FOOT_H - 22) / 2;
|
| m_rFit[0] = 14;
|
| m_rFit[1] = footY;
|
| m_rFit[2] = 36;
|
| m_rFit[3] = 22;
|
| m_rZoomOut[0] = 58;
|
| m_rZoomOut[1] = footY;
|
| m_rZoomOut[2] = 22;
|
| m_rZoomOut[3] = 22;
|
| m_rZoomIn[0] = 84;
|
| m_rZoomIn[1] = footY;
|
| m_rZoomIn[2] = 22;
|
| m_rZoomIn[3] = 22;
|
| //--- Sit the view switch to the right of the zoom readout
|
| m_rView[0] = 152;
|
| m_rView[1] = footY;
|
| m_rView[2] = 62;
|
| m_rView[3] = 22;
|
| //--- Sit the inspector close button in its top right corner
|
| m_rInspectX[0] = m_inspect ? m_w - 30 : 0;
|
| m_rInspectX[1] = CanvasTop() + 8;
|
| m_rInspectX[2] = m_inspect ? OP_ICON : 0;
|
| m_rInspectX[3] = OP_ICON;
|
| //--- Sit the grip in the bottom right corner
|
| m_rGrip[0] = m_w - OP_GRIP - 2;
|
| m_rGrip[1] = m_h - OP_GRIP - 2;
|
| m_rGrip[2] = OP_GRIP;
|
| m_rGrip[3] = OP_GRIP;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Create the bitmap the panel draws into |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::CreateCanvas(void)
|
| {
|
| //--- Build the bitmap once at its largest, so its size never changes again
|
| if(!m_cv.CreateBitmapLabel(m_chartId, 0, m_name, m_x, m_y,
|
| OP_W_MAX, OP_H_MAX, COLOR_FORMAT_ARGB_NORMALIZE))
|
| return false;
|
| //--- Pin it to the top left corner of the chart
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_BACK, false);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_SELECTABLE, false);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_HIDDEN, true);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_ZORDER, 0);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
|
| ObjectSetString(m_chartId, m_name, OBJPROP_TOOLTIP, "\n");
|
| //--- Size the chrome cache to the bitmap, which never changes again
|
| ArrayResize(m_bg, m_cv.PixelCount());
|
| ArrayResize(m_scene, m_cv.PixelCount());
|
| m_bgValid = false;
|
| m_sceneValid = false;
|
| //--- Report that the canvas exists
|
| m_created = true;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Resize the bitmap to match the current mode |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::ApplyMode(void)
|
| {
|
| //--- Take the height the mode calls for, the bitmap itself never changes
|
| m_h = (m_mode == OM_MIN) ? OP_HEADER_H : m_fullH;
|
| ComputeLayout();
|
| m_bgValid = false;
|
| //--- Report success
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Suppress chart scrolling while the pointer works the panel |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::LockChartScroll(const bool lock)
|
| {
|
| //--- Skip the call when the state already matches
|
| if(lock == m_scrollLocked)
|
| return;
|
| //--- Toggle scrolling and remember the new state
|
| ChartSetInteger(m_chartId, CHART_MOUSE_SCROLL, !lock);
|
| m_scrollLocked = lock;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Pick the fill color for a node role |
|
| //+------------------------------------------------------------------+
|
| uint COmvPanel::FillForRole(const int role) const
|
| {
|
| //--- Match the role to its fill
|
| switch(role)
|
| {
|
| case OL_ROLE_COMPUTE:
|
| return m_th.computeFill;
|
| case OL_ROLE_ACTIVATE:
|
| return m_th.activateFill;
|
| case OL_ROLE_SHAPE:
|
| return m_th.shapeFill;
|
| case OL_ROLE_OUTPUT:
|
| return m_th.outputFill;
|
| case OL_ROLE_PORT:
|
| return m_th.chrome;
|
| }
|
| //--- Fall back to the plain fill
|
| return m_th.plainFill;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Pick the edge color for a node role |
|
| //+------------------------------------------------------------------+
|
| uint COmvPanel::EdgeForRole(const int role) const
|
| {
|
| //--- Match the role to its edge
|
| switch(role)
|
| {
|
| case OL_ROLE_COMPUTE:
|
| return m_th.computeEdge;
|
| case OL_ROLE_ACTIVATE:
|
| return m_th.activateEdge;
|
| case OL_ROLE_SHAPE:
|
| return m_th.shapeEdge;
|
| case OL_ROLE_OUTPUT:
|
| return m_th.outputEdge;
|
| case OL_ROLE_PORT:
|
| return m_th.text;
|
| }
|
| //--- Fall back to the plain edge
|
| return m_th.plainEdge;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name what a control does for its tooltip |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::TipFor(const int id) const
|
| {
|
| //--- Match the control to the words describing it
|
| switch(id)
|
| {
|
| case OH_HEADER:
|
| return "Drag to move";
|
| case OH_THEME:
|
| return m_dark ? "Switch to light" : "Switch to dark";
|
| case OH_MIN:
|
| return "Collapse";
|
| case OH_RESTORE:
|
| return "Expand";
|
| case OH_CLOSE:
|
| return "Remove panel";
|
| case OH_FIT:
|
| return m_neuronView ? "Fit neurons" : "Fit graph";
|
| case OH_VIEW:
|
| //--- Say why the control cannot be used rather than leaving it silent
|
| if(!m_neuronView && !m_cells.Ready())
|
| return "Neuron view unavailable: " + m_cells.Reason();
|
| return m_neuronView ? "Back to the graph" : "Show the neurons";
|
| case OH_ZOOM_OUT:
|
| return "Zoom out";
|
| case OH_ZOOM_IN:
|
| return "Zoom in";
|
| case OH_INSPECT_X:
|
| return "Close inspector";
|
| case OH_GRIP:
|
| return "Drag to resize";
|
| case OH_BAR_V:
|
| return "Scroll vertically";
|
| case OH_BAR_H:
|
| return "Scroll horizontally";
|
| case OH_CELL:
|
| {
|
| //--- Name the neuron under the pointer and what it last produced
|
| if(m_hoverBand < 0 || m_hoverCell < 0)
|
| return "";
|
| OmvBand row;
|
| m_cells.BandAt(m_hoverBand, row);
|
| string tag = m_cells.NeuronName(m_hoverBand, m_hoverCell);
|
| if(StringLen(tag) == 0)
|
| tag = row.label + " neuron " + IntegerToString(m_hoverCell + 1);
|
| //--- A row that has not run yet has no number to report
|
| if(!row.live || m_hoverCell >= ON_MAX_WIDE)
|
| return tag;
|
| return tag + " fired " + DoubleToString(row.fired[m_hoverCell], 4);
|
| }
|
| case OH_CANVAS:
|
| return "Drag to pan, click for model properties";
|
| case OH_ROW:
|
| return "Tensor properties";
|
| case OH_LINK:
|
| return "Connection properties";
|
| case OH_INFO:
|
| //--- Name the half of the row the pointer is actually on
|
| if(m_infoHover < 0 || m_infoHover >= m_infos)
|
| return "";
|
| if(m_onExpander)
|
| return m_info[m_infoHover].isOpen ? "Click to collapse" : "Click to expand";
|
| if(StringLen(m_info[m_infoHover].linkName) > 0)
|
| return "Show in graph";
|
| return m_info[m_infoHover].canOpen ? "Click to expand" : "";
|
| case OH_INFO_BAR:
|
| return "Scroll properties";
|
| case OH_NODE:
|
| return "Node properties";
|
| }
|
| //--- Report nothing for anything without a tooltip
|
| return "";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Publish the tooltip the terminal shows over the panel |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::SetTooltip(const string words)
|
| {
|
| //--- A single newline is how the terminal is told to show nothing
|
| const string shown = (StringLen(words) > 0) ? words : "\n";
|
| //--- Skip the call when the object already carries this text
|
| if(shown == m_tipShown)
|
| return;
|
| //--- Hand the text to the object the terminal draws the tooltip for
|
| ObjectSetString(m_chartId, m_name, OBJPROP_TOOLTIP, shown);
|
| m_tipShown = shown;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Hold the pan offsets inside what the graph allows |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::ClampPan(void)
|
| {
|
| //--- Settle which bars are showing before the view is measured
|
| SizeBars();
|
| //--- Measure the view and the scaled graph
|
| const int viewW = ViewW(), viewH = ViewH();
|
| const int fullW = ScaledW(), fullH = ScaledH();
|
| //--- Center the graph when it fits, otherwise hold it against its margin
|
| if(fullW <= viewW - OP_PAD * 2)
|
| m_panX = (viewW - fullW) / 2;
|
| else
|
| {
|
| //--- Never pull the graph past the margin on either side
|
| if(m_panX > OP_PAD)
|
| m_panX = OP_PAD;
|
| if(m_panX < viewW - fullW - OP_PAD)
|
| m_panX = viewW - fullW - OP_PAD;
|
| }
|
| //--- Apply the same rule vertically
|
| if(fullH <= viewH - OP_PAD * 2)
|
| m_panY = (viewH - fullH) / 2;
|
| else
|
| {
|
| //--- Never pull the graph past the margin above or below
|
| if(m_panY > OP_PAD)
|
| m_panY = OP_PAD;
|
| if(m_panY < viewH - fullH - OP_PAD)
|
| m_panY = viewH - fullH - OP_PAD;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Scale and center the graph inside the canvas |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::FitGraph(void)
|
| {
|
| //--- Measure the room the canvas offers once the margin is taken out
|
| const int roomW = ViewW() - OP_PAD * 2;
|
| const int roomH = ViewH() - OP_PAD * 2;
|
| //--- Abort when the canvas or the graph has no size
|
| if(roomW <= 0 || roomH <= 0 || ViewWide() <= 0 || ViewHigh() <= 0)
|
| return;
|
| //--- Take the tighter of the two ratios so nothing overflows
|
| const double byWidth = (double)roomW / ViewWide();
|
| const double byHeight = (double)roomH / ViewHigh();
|
| double zoom = MathMin(byWidth, byHeight);
|
| //--- Let the neurons fill the canvas, but never enlarge the lettered boxes
|
| const double ceiling = m_neuronView ? OP_ZOOM_MAX : 1.0;
|
| if(zoom > ceiling)
|
| zoom = ceiling;
|
| if(zoom < OP_ZOOM_MIN)
|
| zoom = OP_ZOOM_MIN;
|
| m_zoom = zoom;
|
| //--- Center what the zoom produced
|
| ClampPan();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Apply a zoom level within the allowed range |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::SetZoom(const double zoom)
|
| {
|
| //--- Remember where the view center sits in graph space
|
| const double cx = (ViewW() * 0.5 - m_panX) / m_zoom;
|
| const double cy = (ViewH() * 0.5 - m_panY) / m_zoom;
|
| //--- Clamp the request to the readable range
|
| double next = zoom;
|
| if(next < OP_ZOOM_MIN)
|
| next = OP_ZOOM_MIN;
|
| if(next > OP_ZOOM_MAX)
|
| next = OP_ZOOM_MAX;
|
| m_zoom = next;
|
| //--- Put the same graph point back under the view center
|
| m_panX = (int)(ViewW() * 0.5 - cx * m_zoom);
|
| m_panY = (int)(ViewH() * 0.5 - cy * m_zoom);
|
| ClampPan();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Handle a wheel turn over the graph |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::OnWheel(const int mx, const int my, const int delta)
|
| {
|
| //--- Scroll the inspector when the pointer sits over its column
|
| if(m_inspect && mx > CanvasRight() && my >= CanvasTop() && my < CanvasBottom())
|
| {
|
| //--- Step the listing by one notch
|
| m_infoScroll += (delta > 0) ? -OP_WHEEL : OP_WHEEL;
|
| //--- Hold the new offset inside the listing before it is drawn
|
| if(m_infoScroll < 0)
|
| m_infoScroll = 0;
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Ignore a turn that lands outside the graph area
|
| if(mx < CanvasLeft() || mx >= CanvasRight() || my < CanvasTop() || my >= CanvasBottom())
|
| return;
|
| //--- Step one notch per event, taking only the sign so fine wheels still work
|
| const int step = (delta > 0) ? OP_WHEEL : -OP_WHEEL;
|
| //--- Scroll the axis that actually has somewhere to go
|
| if(m_barV)
|
| m_panY += step;
|
| else
|
| m_panX += step;
|
| ClampPan();
|
| PaintCapped();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Write the endpoint line a connection reports |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::AddEndpoint(const string side, const int boxIndex)
|
| {
|
| //--- Refuse an index no box answers to
|
| if(boxIndex < 0 || boxIndex >= m_layout.Boxes())
|
| return;
|
| //--- Fetch the box the connection reaches
|
| OmvBox box;
|
| m_layout.BoxAt(boxIndex, box);
|
| //--- A graph port is a value, so it reports its own name and nothing more
|
| if(box.node < 0)
|
| {
|
| AddRow(side, "name: " + box.portName, false, box.portName);
|
| return;
|
| }
|
| //--- A layer reports the operator, then the name it was given
|
| OmvNode node;
|
| m_model.NodeAt(box.node, node);
|
| AddRow(side, "node: " + node.op, false);
|
| AddLine("name: " + node.name);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Print a number without letting a small one read as zero |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::Measure(const double value) const
|
| {
|
| //--- Print an exact zero plainly
|
| if(value == 0.0)
|
| return "0";
|
| //--- Fall back to scientific notation where fixed digits would round to zero
|
| if(MathAbs(value) < 0.0000001)
|
| return DoubleToString(value, -8);
|
| //--- Print anything larger at a width the column can hold
|
| return DoubleToString(value, 8);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name the input an operator gives a position |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::ArgIn(const string op, const int slot) const
|
| {
|
| //--- The general matrix operator names its three operands
|
| if(op == "Gemm" || op == "MatMul")
|
| return StringSubstr("ABC", slot, 1);
|
| //--- These operators name their single operand X
|
| if(op == "Relu" || op == "Sigmoid" || op == "LeakyRelu" || op == "Elu" || op == "Sqrt")
|
| return "X";
|
| //--- Elementwise pairs name their two operands A and B
|
| if(op == "Mul" || op == "Add" || op == "Sub" || op == "Div" || op == "Pow")
|
| return StringSubstr("AB", slot, 1);
|
| //--- Concat takes a list rather than numbered operands
|
| if(op == "Concat")
|
| return "inputs";
|
| //--- Everything else names its operand for what it is
|
| return "input";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name the output an operator gives a position |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::ArgOut(const string op) const
|
| {
|
| //--- The general matrix operator names its result Y
|
| if(op == "Gemm" || op == "MatMul" || op == "Relu" || op == "Sigmoid" ||
|
| op == "LeakyRelu" || op == "Elu" || op == "Sqrt")
|
| return "Y";
|
| //--- Elementwise pairs name their result C
|
| if(op == "Mul" || op == "Add" || op == "Sub" || op == "Div" || op == "Pow")
|
| return "C";
|
| //--- Concat names its result for what it built
|
| if(op == "Concat")
|
| return "concat_result";
|
| //--- Everything else names its result for what it is
|
| return "output";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name the tensor an index points at |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::TensorNameAt(const int index) const
|
| {
|
| //--- Refuse an index no tensor answers to
|
| if(index < 0 || index >= m_model.Tensors())
|
| return "";
|
| //--- Fetch the tensor and report its name
|
| OmvTensor tensor;
|
| m_model.TensorAt(index, tensor);
|
| return tensor.name;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Report whether a point sits on a row's expander |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::OnExpander(const int mx, const int row) const
|
| {
|
| //--- Refuse a row that carries no expander
|
| if(row < 0 || row >= m_infos || !m_info[row].canOpen)
|
| return false;
|
| //--- The expander occupies the right end of the value box
|
| const int right = m_w - 16 - ((m_infoHigh > (CanvasBottom() - 8) - (CanvasTop() + 44))
|
| ? OP_BAR + 2 : 0);
|
| return (mx >= right - 22);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the first connection carrying a named value |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::LinkNamed(const string name) const
|
| {
|
| //--- Scan every connection for the one carrying this value
|
| for(int i = 0; i < m_layout.Edges(); i++)
|
| {
|
| //--- Fetch this connection
|
| OmvEdge edge;
|
| m_layout.EdgeAt(i, edge);
|
| //--- Report it once the name matches
|
| if(edge.label == name)
|
| return i;
|
| }
|
| //--- Report that nothing carries it
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the tensor a name belongs to |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::TensorNamed(const string name) const
|
| {
|
| //--- Scan every stored tensor for a matching name
|
| for(int i = 0; i < m_model.Tensors(); i++)
|
| {
|
| //--- Fetch this tensor
|
| OmvTensor tensor;
|
| m_model.TensorAt(i, tensor);
|
| //--- Report the one that carries the name
|
| if(tensor.name == name)
|
| return i;
|
| }
|
| //--- Report that no tensor carries it
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the tensor row under a panel point |
|
| //+------------------------------------------------------------------+
|
| //| Find the tensor row under a panel point |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::RowAtPoint(const int mx, const int my)
|
| {
|
| //--- Test every row drawn on the last frame
|
| for(int i = 0; i < m_rows; i++)
|
| if(mx >= m_rowRect[i][0] && mx < m_rowRect[i][0] + m_rowRect[i][2] &&
|
| my >= m_rowRect[i][1] && my < m_rowRect[i][1] + m_rowRect[i][3])
|
| return i;
|
| //--- Report that no row holds the point
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the connection under a panel point |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::LinkAtPoint(const int mx, const int my)
|
| {
|
| //--- Take the closest route, so crossing connections cannot be confused
|
| int best = -1;
|
| double nearest = 6.0;
|
| //--- Measure the pointer against every route drawn on the last frame
|
| for(int i = 0; i < m_links; i++)
|
| {
|
| //--- Walk the segments the route was built from
|
| for(int s = 0; s + 1 < m_linkCount[i]; s++)
|
| {
|
| //--- Take this segment
|
| const double ax = m_linkPts[i][s * 2], ay = m_linkPts[i][s * 2 + 1];
|
| const double bx = m_linkPts[i][s * 2 + 2], by = m_linkPts[i][s * 2 + 3];
|
| //--- Project the pointer onto it
|
| const double dx = bx - ax, dy = by - ay;
|
| const double len2 = dx * dx + dy * dy;
|
| double along = (len2 > 1e-9) ? ((mx - ax) * dx + (my - ay) * dy) / len2 : 0.0;
|
| //--- Clamp the projection to the segment ends
|
| if(along < 0.0)
|
| along = 0.0;
|
| if(along > 1.0)
|
| along = 1.0;
|
| //--- Measure how far the pointer sits from the segment
|
| const double ox = mx - (ax + dx * along), oy = my - (ay + dy * along);
|
| const double dist = MathSqrt(ox * ox + oy * oy);
|
| //--- Keep the nearest route within reach
|
| if(dist < nearest)
|
| {
|
| nearest = dist;
|
| best = i;
|
| }
|
| }
|
| }
|
| //--- Report the connection the closest route belongs to
|
| return (best >= 0) ? m_linkEdge[best] : -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the node box under a panel point |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::NodeAtPoint(const int mx, const int my)
|
| {
|
| //--- Convert the point out of canvas space into graph space
|
| const double gx = (mx - CanvasLeft() - m_panX) / m_zoom;
|
| const double gy = (my - CanvasTop() - m_panY) / m_zoom;
|
| //--- Test every placed box
|
| for(int i = 0; i < m_layout.Boxes(); i++)
|
| {
|
| //--- Fetch this box
|
| OmvBox box;
|
| m_layout.BoxAt(i, box);
|
| //--- Report the box that contains the point
|
| if(gx >= box.x && gx < box.x + box.w && gy >= box.y && gy < box.y + box.h)
|
| return i;
|
| }
|
| //--- Report that no box holds the point
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Identify the control under a panel point |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::HitTest(const int mx, const int my)
|
| {
|
| //--- Test the header icons before the band behind them
|
| if(InRect(m_rTheme, mx, my))
|
| return OH_THEME;
|
| if(InRect(m_rMin, mx, my))
|
| return (m_mode == OM_MIN) ? OH_RESTORE : OH_MIN;
|
| if(InRect(m_rClose, mx, my))
|
| return OH_CLOSE;
|
| //--- Report the header band itself
|
| if(my < OP_HEADER_H)
|
| return OH_HEADER;
|
| //--- Report nothing else while collapsed
|
| if(m_mode == OM_MIN)
|
| return OH_NONE;
|
| //--- Test the grip before the footer behind it
|
| if(InRect(m_rGrip, mx, my))
|
| return OH_GRIP;
|
| //--- Test the footer controls
|
| if(InRect(m_rFit, mx, my))
|
| return OH_FIT;
|
| if(InRect(m_rView, mx, my))
|
| return OH_VIEW;
|
| if(InRect(m_rZoomOut, mx, my))
|
| return OH_ZOOM_OUT;
|
| if(InRect(m_rZoomIn, mx, my))
|
| return OH_ZOOM_IN;
|
| //--- Test the inspector close button
|
| if(InRect(m_rInspectX, mx, my))
|
| return OH_INSPECT_X;
|
| //--- Test the inspector scrollbar before the rows behind it
|
| if(InRect(m_rInfoBar, mx, my))
|
| return OH_INFO_BAR;
|
| //--- Test the inspector rows, ignoring any that lead nowhere
|
| const int infoRow = InfoAtPoint(mx, my);
|
| if(infoRow >= 0 && (m_info[infoRow].canOpen || StringLen(m_info[infoRow].linkName) > 0))
|
| return OH_INFO;
|
| //--- Test both scrollbar thumbs
|
| if(InRect(m_rBarV, mx, my))
|
| return OH_BAR_V;
|
| if(InRect(m_rBarH, mx, my))
|
| return OH_BAR_H;
|
| //--- Test the graph area last, smallest target first
|
| if(mx >= CanvasLeft() && mx < CanvasRight() && my >= CanvasTop() && my < CanvasBottom())
|
| {
|
| //--- The neuron view has no boxes, but its neurons can be pointed at
|
| if(m_neuronView)
|
| {
|
| //--- Report a neuron when the pointer rests on one
|
| int band = -1, cell = -1;
|
| const bool on = CellAtPoint(mx, my, band, cell);
|
| return on ? OH_CELL : OH_CANVAS;
|
| }
|
| //--- A tensor row sits inside a node, so it wins over the node
|
| if(RowAtPoint(mx, my) >= 0)
|
| return OH_ROW;
|
| //--- A node wins over the empty canvas
|
| if(NodeAtPoint(mx, my) >= 0)
|
| return OH_NODE;
|
| //--- A connection is the last thing that can be grabbed
|
| if(LinkAtPoint(mx, my) >= 0)
|
| return OH_LINK;
|
| return OH_CANVAS;
|
| }
|
| //--- Report nothing clickable
|
| return OH_NONE;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw a labeled button |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawButton(const int &r[], const int id, const string label)
|
| {
|
| //--- Light the button when the pointer sits over it
|
| const bool lit = (m_hover == id || m_press == id);
|
| //--- Fill and outline the button face
|
| m_cv.RoundFill(r[0], r[1], r[2], r[3], OP_BTN_R, lit ? m_th.hoverFace : m_th.btnFace);
|
| m_cv.RoundStroke(r[0], r[1], r[2], r[3], OP_BTN_R, 1, lit ? m_th.hoverEdge : m_th.btnEdge);
|
| //--- Measure the label, then center it inside the button
|
| m_cv.Font(8);
|
| const int labelH = m_cv.TextHigh(label);
|
| m_cv.TxtC(r[0] + r[2] / 2, r[1] + (r[3] - labelH) / 2, label, m_th.text);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw an icon button |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawIcon(const int &r[], const int id, const int which)
|
| {
|
| //--- Skip a control the current mode hides
|
| if(r[2] <= 0)
|
| return;
|
| //--- Light the button when the pointer sits over it
|
| const bool lit = (m_hover == id || m_press == id);
|
| //--- Fill the face only while lit so the chrome stays clean
|
| if(lit)
|
| {
|
| m_cv.RoundFill(r[0], r[1], r[2], r[3], OP_BTN_R, m_th.hoverFace);
|
| m_cv.RoundStroke(r[0], r[1], r[2], r[3], OP_BTN_R, 1, m_th.hoverEdge);
|
| }
|
| //--- Find the middle of the button and the box the glyph fits
|
| const int cx = r[0] + r[2] / 2;
|
| const int cy = r[1] + r[3] / 2;
|
| const double sz = (double)MathMin(r[2], r[3]) - 4.0;
|
| const uint ink = lit ? m_th.text : m_th.muted;
|
| //--- Draw the sun that offers the light theme
|
| if(which == 0)
|
| {
|
| //--- Fill the core then lay eight spokes around it
|
| m_cv.DiscAA(cx, cy, (int)MathRound(sz * 0.24), ink);
|
| for(int i = 0; i < 8; i++)
|
| {
|
| //--- Step around the circle one eighth at a time
|
| const double ang = i * (M_PI / 4.0);
|
| const double cs = MathCos(ang), sn = MathSin(ang);
|
| m_cv.StrokeAA(cx + cs * sz * 0.36, cy + sn * sz * 0.36,
|
| cx + cs * sz * 0.52, cy + sn * sz * 0.52, 2, ink);
|
| }
|
| return;
|
| }
|
| //--- Draw the moon that offers the dark theme
|
| if(which == 7)
|
| {
|
| //--- Draw the crescent as one shape so no background bleeds into its rim
|
| const double moonR = sz * 0.42;
|
| m_cv.CrescentAA(cx, cy, moonR, moonR * 0.58, -moonR * 0.44, moonR * 0.90, ink);
|
| return;
|
| }
|
| //--- Draw the bar that collapses the panel or steps the zoom down
|
| if(which == 1 || which == 3)
|
| {
|
| m_cv.StrokeAA(cx - sz * OP_BAR_R, cy, cx + sz * OP_BAR_R, cy, 2, ink);
|
| return;
|
| }
|
| //--- Draw the cross that removes the panel or closes the inspector
|
| if(which == 2 || which == 5)
|
| {
|
| m_cv.StrokeAA(cx - sz * OP_GLYPH, cy - sz * OP_GLYPH,
|
| cx + sz * OP_GLYPH, cy + sz * OP_GLYPH, 2, ink);
|
| m_cv.StrokeAA(cx + sz * OP_GLYPH, cy - sz * OP_GLYPH,
|
| cx - sz * OP_GLYPH, cy + sz * OP_GLYPH, 2, ink);
|
| return;
|
| }
|
| //--- Draw the plus that steps the zoom up
|
| if(which == 4)
|
| {
|
| m_cv.StrokeAA(cx - sz * OP_BAR_R, cy, cx + sz * OP_BAR_R, cy, 2, ink);
|
| m_cv.StrokeAA(cx, cy - sz * OP_BAR_R, cx, cy + sz * OP_BAR_R, 2, ink);
|
| return;
|
| }
|
| //--- Draw the box that restores the panel
|
| m_cv.RoundStroke(cx - (int)(sz * OP_GLYPH), cy - (int)(sz * 0.22),
|
| (int)(sz * OP_GLYPH * 2), (int)(sz * 0.44), 2, 1, ink);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Name what the kept scene was drawn for |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::SceneSignature(void)
|
| {
|
| //--- Any change here means the drawn view no longer matches the panel
|
| return StringFormat("%s|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%s", ChromeSignature(),
|
| m_panX, m_panY, (int)(m_zoom * 1000),
|
| m_selected, m_pickKind, m_hoverNode, m_hoverRow,
|
| m_pickTensor, m_pickLink, m_pulse, m_litName);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Describe everything the cached chrome depends on |
|
| //+------------------------------------------------------------------+
|
| string COmvPanel::ChromeSignature(void)
|
| {
|
| //--- Any change here means the cached chrome no longer matches the panel
|
| return StringFormat("%d|%d|%d|%d|%d|%d|%d|%d|%d", m_w, m_h, m_mode,
|
| (int)m_dark, (int)m_inspect, (int)m_neuronView,
|
| m_model.Nodes(), m_model.Tensors(), m_model.Parameters());
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw every band that does not change between frames |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawChrome(void)
|
| {
|
| //--- Lay the body down first
|
| DrawShell();
|
| //--- Draw the bands that never move
|
| if(m_mode == OM_FULL)
|
| {
|
| DrawStats();
|
| DrawFooterChrome();
|
| }
|
| //--- Fill the header band under the icons
|
| m_cv.RoundFillSel(0, 0, m_w, OP_HEADER_H, OP_RADIUS, m_th.chrome,
|
| true, true, m_mode == OM_MIN, m_mode == OM_MIN);
|
| //--- Rule the band off only when something sits below it
|
| if(m_mode != OM_MIN)
|
| m_cv.HRule(1, m_w - 2, OP_HEADER_H - 1, m_th.divider);
|
| //--- Outline the whole panel so no band overwrites the edge
|
| m_cv.RoundStroke(0, 0, m_w, m_h, OP_RADIUS, 1, m_th.border);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the panel body and its outline |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawShell(void)
|
| {
|
| //--- Clear the whole bitmap, so whatever the panel no longer covers is clear
|
| m_cv.NoClip();
|
| m_cv.Erase(0);
|
| //--- Fill the body with every corner smoothed
|
| m_cv.RoundFill(0, 0, m_w, m_h, OP_RADIUS, m_th.panel);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the header title and icons |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawHeader(void)
|
| {
|
| //--- Draw the eye mark that identifies the viewer
|
| m_cv.DiscAA(30, 22, 8, m_th.accent);
|
| m_cv.DiscAA(30, 22, 6, m_th.chrome);
|
| m_cv.DiscAA(30, 22, 3, m_th.accent);
|
| //--- Name the program
|
| m_cv.Font(11, true);
|
| const int titleRoom = m_rTheme[0] - 48 - 12;
|
| string head[];
|
| if(titleRoom > 0 && m_cv.WrapText(m_title, titleRoom, head, 1) > 0)
|
| m_cv.TxtL(48, 10, head[0], m_th.text);
|
| //--- Describe the loaded file under the name
|
| m_cv.Font(8);
|
| string subtitle = m_model.GraphName();
|
| if(StringLen(subtitle) == 0)
|
| subtitle = "no graph";
|
| string tail[];
|
| const string line = subtitle + " opset " + IntegerToString(m_model.Opset());
|
| if(titleRoom > 0 && m_cv.WrapText(line, titleRoom, tail, 1) > 0)
|
| m_cv.TxtL(48, 27, tail[0], m_th.muted);
|
| //--- Draw the three header icons
|
| DrawIcon(m_rTheme, OH_THEME, m_dark ? 0 : 7);
|
| DrawIcon(m_rMin, (m_mode == OM_MIN) ? OH_RESTORE : OH_MIN, (m_mode == OM_MIN) ? 6 : 1);
|
| DrawIcon(m_rClose, OH_CLOSE, 2);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the statistics strip |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawStats(void)
|
| {
|
| //--- Fill the strip inside the outline so the graph cannot show through
|
| m_cv.FillRect(1, OP_HEADER_H, m_w - 2, OP_HEADER_H + OP_STAT_H, m_th.panel);
|
| m_cv.HRule(1, m_w - 2, OP_HEADER_H + OP_STAT_H, m_th.divider);
|
| //--- Split the strip into five equal columns
|
| const int columns = 5;
|
| const int span = m_w / columns;
|
| const int top = OP_HEADER_H;
|
| //--- Name every column
|
| string label[5];
|
| label[0] = "nodes";
|
| label[1] = "parameters";
|
| label[2] = "tensors";
|
| label[3] = "input";
|
| label[4] = "output";
|
| //--- Read the value for every column
|
| string shown[5];
|
| shown[0] = IntegerToString(m_model.Nodes());
|
| shown[1] = IntegerToString(m_model.Parameters());
|
| shown[2] = IntegerToString(m_model.Tensors());
|
| //--- Take the first graph input shape
|
| OmvPort port;
|
| m_model.InputAt(0, port);
|
| shown[3] = (m_model.Inputs() > 0) ? m_model.DimsText(port.dim, port.dims) : "-";
|
| //--- Take the first graph output shape
|
| m_model.OutputAt(0, port);
|
| shown[4] = (m_model.Outputs() > 0) ? m_model.DimsText(port.dim, port.dims) : "-";
|
| //--- Draw every column and the rule between them
|
| for(int i = 0; i < columns; i++)
|
| {
|
| //--- Center the caption and the value in this column
|
| const int cx = span * i + span / 2;
|
| m_cv.Font(8);
|
| m_cv.TxtC(cx, top + 10, label[i], m_th.muted);
|
| m_cv.Font(12, true);
|
| m_cv.TxtC(cx, top + 24, shown[i], m_th.text);
|
| //--- Rule between this column and the previous one
|
| if(i > 0)
|
| m_cv.VRule(span * i, top + 10, top + OP_STAT_H - 10, m_th.divider);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Place one row of neurons against the pan and the zoom |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::CellSpan(double &dot, double &pitch) const
|
| {
|
| //--- The spacing depends only on the zoom, so every row shares it
|
| dot = MathMax(2.0, ON_DOT * m_zoom);
|
| pitch = (ON_DOT + ON_DOT_GAP) * m_zoom;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Place one row against the pan and the zoom |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::CellOrigin(const OmvBand &band, double &x, double &y) const
|
| {
|
| //--- Place the row origin using the pan and zoom
|
| x = CanvasLeft() + m_panX + band.x * m_zoom;
|
| y = CanvasTop() + m_panY + band.y * m_zoom;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the neuron the pointer is resting on |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::CellAtPoint(const int mx, const int my, int &band, int &cell) const
|
| {
|
| //--- Start with nothing found
|
| band = -1;
|
| cell = -1;
|
| if(!m_neuronView || !m_cells.Ready())
|
| return false;
|
| //--- Test every row for a neuron under the pointer
|
| for(int i = 0; i < m_cells.Bands(); i++)
|
| {
|
| //--- Place this row exactly where the drawing placed it
|
| OmvBand row;
|
| m_cells.BandAt(i, row);
|
| double x, y, dot, pitch;
|
| CellSpan(dot, pitch);
|
| CellOrigin(row, x, y);
|
| if(my < y - 2 || my > y + dot + 2)
|
| continue;
|
| //--- Work out which neuron along the row the pointer sits over
|
| const int at = (int)MathFloor((mx - x) / MathMax(pitch, 1e-9));
|
| if(at < 0 || at >= row.count)
|
| continue;
|
| //--- Accept it only while the pointer is on the circle itself
|
| const double cx = x + at * pitch + dot * 0.5;
|
| if(MathAbs(mx - cx) > dot * 0.5 + 2)
|
| continue;
|
| band = i;
|
| cell = at;
|
| return true;
|
| }
|
| //--- Report that the pointer rests on no neuron
|
| return false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Step the signal one place further along the rows |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::OnPulse(void)
|
| {
|
| //--- Do nothing without a canvas or after teardown
|
| if(m_destroyed || !m_created)
|
| return;
|
| //--- Nothing travels once the run has finished, or once the view has changed
|
| if(m_pulse < 0 || !m_neuronView)
|
| {
|
| m_pulse = -1;
|
| EventKillTimer();
|
| return;
|
| }
|
| //--- Take how many gaps the signal has to cross
|
| const int gaps = MathMax(m_cells.Bands() - 1, 1);
|
| m_pulse++;
|
| //--- Stop once it has reached the last row, and leave the picture standing
|
| if(m_pulse > gaps * ON_PULSE_STEPS)
|
| {
|
| m_pulse = -1;
|
| EventKillTimer();
|
| }
|
| //--- Repaint the panel
|
| PaintCapped();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Answer for a bar that has closed since the last look |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::OnBar(void)
|
| {
|
| //--- Do nothing without a canvas or after teardown
|
| if(m_destroyed || !m_created)
|
| return;
|
| //--- Run only when a new bar has actually closed, since a tick is not a bar
|
| if(!RunModel())
|
| return;
|
| //--- Show what the model made of it
|
| PaintCapped();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Run the model for the newest closed bar |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::RunModel(void)
|
| {
|
| //--- Nothing to do until the model and its scaling are open
|
| if(!m_runner.Ready())
|
| return false;
|
| //--- Skip the fetch while the last closed bar is the one already answered
|
| const datetime closed = iTime(m_feedSymbol, m_feedPeriod, 1);
|
| if(closed != 0 && closed == m_lastBar)
|
| return false;
|
| //--- Take the bars the numbers are built from
|
| if(!m_feed.Load(m_feedSymbol, m_feedPeriod, OP_FEED_BARS))
|
| return false;
|
| //--- Work on the last closed bar, since the forming one keeps changing
|
| const int at = m_feed.Bars() - 2;
|
| if(at < OF_WARMUP)
|
| return false;
|
| //--- Skip the work when this bar has already been answered
|
| if(m_feed.TimeAt(at) == m_lastBar)
|
| return false;
|
| //--- Build the sixteen numbers and center them the way training did
|
| OmvFeatures bar;
|
| if(!m_feed.Build(at, bar) || !m_runner.Feed(bar))
|
| return false;
|
| //--- Ask the model itself
|
| if(!m_runner.Run())
|
| return false;
|
| //--- Only walking the parsed weights shows what the middle rows are doing
|
| double fed[];
|
| m_runner.FedTo(fed);
|
| if(m_cells.Ready())
|
| m_cells.Run(m_model, fed, OF_INPUTS);
|
| //--- Compare the two, since a quiet disagreement would mean the picture lies
|
| m_agree = -1.0;
|
| if(m_cells.Live() && m_cells.Bands() > 1)
|
| {
|
| //--- Take the last row, which holds what our own pass produced
|
| OmvBand last;
|
| m_cells.BandAt(m_cells.Bands() - 1, last);
|
| if(last.count == OR_OUTPUTS)
|
| {
|
| //--- The model applies Softmax, so ours is compared after the same
|
| double sum = 0.0, soft[OR_OUTPUTS];
|
| for(int i = 0; i < OR_OUTPUTS; i++)
|
| {
|
| //--- Turn the scores into shares that add to one
|
| soft[i] = MathExp(last.fired[i]);
|
| sum += soft[i];
|
| }
|
| double worst = 0.0;
|
| for(int i = 0; i < OR_OUTPUTS; i++)
|
| {
|
| //--- Measure how far our share sits from the model's own
|
| const double gap = MathAbs(soft[i] / MathMax(sum, 1e-12) - m_runner.SaidAt(i));
|
| if(gap > worst)
|
| worst = gap;
|
| }
|
| m_agree = worst;
|
| }
|
| }
|
| //--- Remember which bar this answer belongs to
|
| m_lastBar = m_feed.TimeAt(at);
|
| //--- Send one pulse through the rows on the closed bar
|
| if(m_neuronView && m_cells.Ready())
|
| {
|
| m_pulse = 0;
|
| EventSetMillisecondTimer(ON_PULSE_MS);
|
| }
|
| //--- Redraw, since every neuron now holds a different number
|
| m_sceneValid = false;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the neurons and the weights joining them |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawNeurons(void)
|
| {
|
| //--- Measure the area the arrangement is drawn inside
|
| const int left = CanvasLeft(), top = CanvasTop();
|
| const int right = CanvasRight(), bottom = CanvasBottom();
|
| //--- Hold every later stroke inside that area less its margin
|
| m_cv.SetClip(left + OP_PAD, top + OP_PAD,
|
| right - 1 - (m_barV ? OP_BAR : 0) - OP_PAD,
|
| bottom - 1 - (m_barH ? OP_BAR : 0) - OP_PAD);
|
| //--- Say why the view is empty when the model cannot be drawn
|
| if(!m_cells.Ready())
|
| {
|
| //--- Print the reason in the middle of the area
|
| m_cv.Font(9);
|
| string why[];
|
| const int room = right - left - OP_PAD * 4;
|
| if(room > 0 && m_cv.WrapText("Neuron view unavailable: " + m_cells.Reason(),
|
| room, why, 1) > 0)
|
| m_cv.TxtM((left + right) / 2, (top + bottom) / 2, why[0], m_th.muted);
|
| m_cv.NoClip();
|
| return;
|
| }
|
| //--- Count drawn and omitted links
|
| int drawnLinks = 0, allLinks = 0;
|
| //--- Take the spacing once, from the same routine the pointer uses
|
| double dot, pitch;
|
| CellSpan(dot, pitch);
|
| //--- Draw every run of connections under the neurons themselves
|
| for(int i = 0; i < m_cells.Webs(); i++)
|
| {
|
| //--- Fetch this run and the two rows it joins
|
| OmvWeb web;
|
| m_cells.WebAt(i, web);
|
| OmvBand a, b;
|
| m_cells.BandAt(web.from, a);
|
| m_cells.BandAt(web.to, b);
|
| //--- Place both rows against the current pan and zoom
|
| const double ay = top + m_panY + (a.y + ON_DOT) * m_zoom;
|
| const double by = top + m_panY + b.y * m_zoom;
|
| const double ax = left + m_panX + a.x * m_zoom + dot * 0.5;
|
| const double bx = left + m_panX + b.x * m_zoom + dot * 0.5;
|
| //--- Draw a structural run as one line per neuron, carrying no weight
|
| if(web.tensor < 0)
|
| {
|
| //--- Join each source neuron to the place it lands on the joined row
|
| for(int j = 0; j < a.count; j++)
|
| m_cv.WireAA(ax + j * pitch, ay,
|
| bx + (web.offset + j) * pitch, by, m_th.divider);
|
| continue;
|
| }
|
| //--- Fetch the weights this run draws
|
| OmvTensor w;
|
| m_model.TensorAt(web.tensor, w);
|
| //--- Scale the color and thickness against the largest weight held
|
| const double span = MathMax(MathAbs(w.minValue), MathAbs(w.maxValue));
|
| if(span <= 0.0 || w.kept <= 0)
|
| continue;
|
| //--- Thin the run by taking every nth link when too many
|
| const int lines = a.count * b.count;
|
| allLinks += lines;
|
| const int stride = (lines > ON_MAX_LINES) ? (lines / ON_MAX_LINES) + 1 : 1;
|
| //--- Draw one line per weight, from each source neuron to each target
|
| for(int r = 0; r < a.count; r++)
|
| for(int c = 0; c < b.count; c++)
|
| {
|
| //--- Take the weight joining this pair, whichever way it is stored
|
| const int at = web.transposed ? c * a.count + r : r * b.count + c;
|
| if(at >= w.kept)
|
| continue;
|
| const double v = w.val[at];
|
| //--- Take every nth connection when the run had to be thinned
|
| if(stride > 1 && (at % stride) != 0)
|
| continue;
|
| drawnLinks++;
|
| //--- Fade the line by how strong the weight is against the largest
|
| const double strength = MathAbs(v) / span;
|
| const uint ink = (v >= 0.0) ? m_th.linkUp : m_th.linkDown;
|
| const uchar alpha = (uchar)(ON_ALPHA_MIN + ON_ALPHA_SPAN * strength);
|
| //--- Join the two neurons at the color the weight implies
|
| m_cv.WireAA(ax + r * pitch, ay, bx + c * pitch, by,
|
| (ink & 0x00FFFFFF) | ((uint)alpha << 24));
|
| }
|
| }
|
| //--- Draw every neuron over the connections that reach it
|
| for(int i = 0; i < m_cells.Bands(); i++)
|
| {
|
| //--- Fetch this row
|
| OmvBand band;
|
| m_cells.BandAt(i, band);
|
| //--- Place it against the current pan and zoom
|
| double x, y;
|
| CellOrigin(band, x, y);
|
| //--- Take the strongest thing this row produced, to draw the rest against
|
| double peak = 0.0;
|
| if(band.live)
|
| for(int j = 0; j < band.count && j < ON_MAX_WIDE; j++)
|
| if(MathAbs(band.fired[j]) > peak)
|
| peak = MathAbs(band.fired[j]);
|
| //--- Draw one filled circle per neuron, lit by what it fired
|
| for(int j = 0; j < band.count; j++)
|
| {
|
| //--- Place this neuron
|
| const int px = (int)(x + j * pitch + dot * 0.5);
|
| const int py = (int)(y + dot * 0.5);
|
| const int rad = (int)MathMax(1.0, dot * 0.5);
|
| //--- A row that never ran is drawn plain
|
| if(!band.live || peak <= 0.0 || j >= ON_MAX_WIDE)
|
| {
|
| m_cv.DiscAA(px, py, rad, m_th.cell);
|
| continue;
|
| }
|
| //--- Take how hard this neuron fired against the rest of its row
|
| const double v = band.fired[j];
|
| const double strength = MathAbs(v) / peak;
|
| const uint tone = (v >= 0.0) ? m_th.linkUp : m_th.linkDown;
|
| //--- Lay a halo behind the strong neurons
|
| if(strength > 0.05)
|
| {
|
| //--- Grow the halo with the strength and fade it as it spreads
|
| const int halo = rad + (int)(strength * rad * 1.6) + 2;
|
| const uchar mist = (uchar)(ON_HALO_MIN + ON_HALO_SPAN * strength);
|
| m_cv.DiscAA(px, py, halo, (tone & 0x00FFFFFF) | ((uint)mist << 24));
|
| }
|
| //--- Draw the neuron itself over its own halo
|
| const uchar alpha = (uchar)(ON_FIRE_MIN + ON_FIRE_SPAN * strength);
|
| m_cv.DiscAA(px, py, rad, (tone & 0x00FFFFFF) | ((uint)alpha << 24));
|
| }
|
| //--- Name each neuron only where the label fits
|
| if(band.named)
|
| {
|
| //--- Track the right edge each placed name reaches
|
| m_cv.Font((int)MathMax(1.0, MathRound(7 * m_zoom)));
|
| const int high = m_cv.TextHigh("Ag");
|
| int lastRight = -100000;
|
| for(int j = 0; j < band.count; j++)
|
| {
|
| //--- Take what this neuron stands for
|
| const string tag = m_cells.NeuronName(i, j);
|
| if(StringLen(tag) == 0)
|
| continue;
|
| //--- Leave it off rather than overlap the neighbour beside it
|
| const int wide = m_cv.TextWide(tag);
|
| if(wide > pitch * 2.0 - 4)
|
| continue;
|
| //--- Place it under its own neuron, stepping down on a clash
|
| const int nx = (int)(x + j * pitch + dot * 0.5);
|
| const bool clash = (nx - wide / 2) <= lastRight;
|
| const int ny = (int)(y + dot + 4 * m_zoom) + (clash ? high + 2 : 0);
|
| if(!clash)
|
| lastRight = nx + wide / 2 + 2;
|
| if(m_cv.InClip(nx - wide / 2, ny, nx + wide / 2, ny + high))
|
| m_cv.TxtC(nx, ny, tag, m_th.muted);
|
| }
|
| }
|
| //--- Name the row over its own centre, so two rows never collide
|
| m_cv.Font((int)MathMax(1.0, MathRound(8 * m_zoom)));
|
| const string caption = band.label + " " + IntegerToString(band.count);
|
| const int high = m_cv.TextHigh(caption);
|
| const int wide = m_cv.TextWide(caption);
|
| const int padX = (int)MathMax(2.0, 4 * m_zoom);
|
| //--- Centre the plate on the row it names
|
| const int plateW = wide + padX * 2;
|
| const int plateX = (int)(x + (band.w * m_zoom - plateW) / 2);
|
| //--- Sit the caption above the row, or below it where there is no room
|
| int capY = (int)(y - high - padX * 2);
|
| if(capY - padX < CanvasTop() + OP_PAD)
|
| capY = (int)(y + dot + padX * 2);
|
| //--- Draw the caption while its own plate still sits inside the view
|
| if(m_cv.InClip(plateX, capY - padX / 2, plateX + plateW, capY + high + padX / 2))
|
| {
|
| //--- Tint the plate rather than hiding what runs behind it
|
| const int radius = (int)MathMax(1.0, 3 * m_zoom);
|
| m_cv.RoundFill(plateX, capY - padX / 2, plateW, high + padX, radius,
|
| (m_th.panel & 0x00FFFFFF) | 0x80000000);
|
| m_cv.RoundStroke(plateX, capY - padX / 2, plateW, high + padX, radius, 1, m_th.divider);
|
| m_cv.TxtM(plateX + plateW / 2, capY + high / 2, caption, m_th.text);
|
| }
|
| }
|
| //--- Draw the signal where it has reached, if a bar has just sent one
|
| if(m_pulse >= 0 && m_cells.Bands() > 1)
|
| {
|
| //--- Take which gap it is crossing and how far into that gap it sits
|
| const int gap = MathMin(m_pulse / ON_PULSE_STEPS, m_cells.Bands() - 2);
|
| const double part = (double)(m_pulse % ON_PULSE_STEPS) / ON_PULSE_STEPS;
|
| //--- Walk every run that leaves a row at the depth the signal has reached
|
| for(int i = 0; i < m_cells.Webs(); i++)
|
| {
|
| //--- Take this run and the two rows it joins
|
| OmvWeb web;
|
| m_cells.WebAt(i, web);
|
| OmvBand a, b;
|
| m_cells.BandAt(web.from, a);
|
| m_cells.BandAt(web.to, b);
|
| //--- Only the runs leaving the current depth carry the signal now
|
| if(a.rank != gap)
|
| continue;
|
| //--- Place both rows against the pan and zoom
|
| const double ay = top + m_panY + (a.y + ON_DOT) * m_zoom;
|
| const double by = top + m_panY + b.y * m_zoom;
|
| const double ax = left + m_panX + a.x * m_zoom + dot * 0.5;
|
| const double bx = left + m_panX + b.x * m_zoom + dot * 0.5;
|
| //--- Send one dot per source neuron, staggered
|
| for(int r = 0; r < a.count && r < ON_MAX_WIDE; r++)
|
| {
|
| //--- Let each source start a little after the one before it
|
| const double lead = (a.count > 1) ? 0.3 * r / (a.count - 1) : 0.0;
|
| const double p = (part - lead) / MathMax(1.0 - 0.3, 1e-9);
|
| if(p <= 0.0 || p >= 1.0)
|
| continue;
|
| //--- Carry the colour of what this neuron actually fired
|
| const double v = a.live ? a.fired[r] : 0.0;
|
| const uint tone = (v >= 0.0) ? m_th.linkUp : m_th.linkDown;
|
| //--- Send it to the neuron this source feeds hardest
|
| int target = MathMin(web.offset + r, b.count - 1);
|
| if(web.tensor >= 0)
|
| {
|
| //--- Fetch the weights this run applies
|
| OmvTensor w;
|
| m_model.TensorAt(web.tensor, w);
|
| //--- Walk the row for the strongest weight leaving this neuron
|
| double strongest = -1.0;
|
| target = 0;
|
| for(int c = 0; c < b.count; c++)
|
| {
|
| //--- Reach the pair whichever way the matrix was stored
|
| const int at = web.transposed ? c * a.count + r : r * b.count + c;
|
| if(at < 0 || at >= w.kept)
|
| continue;
|
| const double mag = MathAbs(w.val[at]);
|
| if(mag > strongest)
|
| {
|
| strongest = mag;
|
| target = c;
|
| }
|
| }
|
| }
|
| const double sx = ax + r * pitch, sy = ay;
|
| const double tx = bx + target * pitch, ty = by;
|
| //--- Fade the dot in and out so it reads as travelling
|
| const double lit = 1.0 - MathAbs(p - 0.5) * 1.4;
|
| const uchar alpha = (uchar)(90.0 + 165.0 * MathMax(lit, 0.0));
|
| m_cv.DiscAA((int)(sx + (tx - sx) * p), (int)(sy + (ty - sy) * p),
|
| (int)MathMax(1.0, ON_PULSE_DOT * m_zoom),
|
| (tone & 0x00FFFFFF) | ((uint)alpha << 24));
|
| }
|
| }
|
| }
|
| //--- Say plainly when the picture is not showing every connection
|
| if(drawnLinks < allLinks && allLinks > 0)
|
| {
|
| //--- Print the count at the foot of the arrangement, inside the view
|
| m_cv.Font(8);
|
| const string note = "showing " + IntegerToString(drawnLinks) + " of " +
|
| IntegerToString(allLinks) + " connections, evenly sampled";
|
| const int noteY = bottom - OP_PAD - m_cv.TextHigh(note) - 2;
|
| m_cv.TxtL(left + OP_PAD + 2, noteY, note, m_th.linkDown);
|
| }
|
| //--- Open the clip again for whatever draws next
|
| m_cv.NoClip();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the graph inside its canvas area |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawGraph(void)
|
| {
|
| //--- Measure the area the graph may occupy
|
| const int left = CanvasLeft();
|
| const int top = CanvasTop();
|
| const int right = CanvasRight();
|
| const int bottom = CanvasBottom();
|
| //--- Hold every later stroke inside the area less its margin
|
| m_cv.SetClip(left + OP_PAD, top + OP_PAD,
|
| right - 1 - (m_barV ? OP_BAR : 0) - OP_PAD,
|
| bottom - 1 - (m_barH ? OP_BAR : 0) - OP_PAD);
|
| //--- Start the pickable lists empty for this frame
|
| m_rows = 0;
|
| m_links = 0;
|
| //--- Report an empty graph rather than drawing nothing
|
| if(m_layout.Boxes() <= 0)
|
| {
|
| m_cv.Font(9);
|
| m_cv.TxtC((left + right) / 2, (top + bottom) / 2, "no graph to show", m_th.muted);
|
| return;
|
| }
|
| //--- Draw every edge under the boxes it connects
|
| for(int i = 0; i < m_layout.Edges(); i++)
|
| {
|
| //--- Fetch this edge
|
| OmvEdge edge;
|
| m_layout.EdgeAt(i, edge);
|
| //--- Fetch the two boxes it joins
|
| OmvBox a, b;
|
| m_layout.BoxAt(edge.from, a);
|
| m_layout.BoxAt(edge.to, b);
|
| //--- Count how many edges enter the target and which one this is
|
| int arrives = 0, ordinal = 0;
|
| for(int k = 0; k < m_layout.Edges(); k++)
|
| {
|
| //--- Fetch the candidate edge
|
| OmvEdge other;
|
| m_layout.EdgeAt(k, other);
|
| //--- Count only the ones landing on the same box
|
| if(other.to != edge.to)
|
| continue;
|
| if(k == i)
|
| ordinal = arrives;
|
| arrives++;
|
| }
|
| //--- Count how many edges leave the source and which one this is
|
| int departs = 0, place = 0;
|
| for(int k = 0; k < m_layout.Edges(); k++)
|
| {
|
| //--- Fetch the candidate edge
|
| OmvEdge other;
|
| m_layout.EdgeAt(k, other);
|
| //--- Count only the ones leaving the same box
|
| if(other.from != edge.from)
|
| continue;
|
| if(k == i)
|
| place = departs;
|
| departs++;
|
| }
|
| //--- Spread both ends so no two routes can share a point
|
| const double leaveAt = (double)(place + 1) / (departs + 1);
|
| const double share = (double)(ordinal + 1) / (arrives + 1);
|
| //--- Leave the bottom of the source box at this edge's own share of it
|
| const double x1 = left + m_panX + (a.x + a.w * leaveAt) * m_zoom;
|
| const double y1 = top + m_panY + (a.y + a.h) * m_zoom;
|
| //--- Enter the top of the target box at this edge's own share of it
|
| const double x2 = left + m_panX + (b.x + b.w * share) * m_zoom;
|
| const double y2 = top + m_panY + b.y * m_zoom;
|
| //--- Skip an edge that falls wholly outside the visible area
|
| if(MathMax(y1, y2) < top || MathMin(y1, y2) > bottom)
|
| continue;
|
| if(MathMax(x1, x2) < left || MathMin(x1, x2) > right)
|
| continue;
|
| //--- Measure the room each entry point has before the head is sized
|
| const double gap = (b.w * m_zoom) / (arrives + 1);
|
| //--- Scale the head with the zoom, yielding only where entry points crowd
|
| const double head = MathMin(5.0 * m_zoom, gap - 1.0);
|
| //--- Only the bend follows the zoom, so the route keeps its shape
|
| const double bend = MathMax(4.0, 10.0 * m_zoom);
|
| //--- Light every connection carrying the value the pointer is on
|
| bool hot = (StringLen(m_litName) > 0 && edge.label == m_litName);
|
| //--- Light every connection carrying the value the inspector describes
|
| if(!hot && m_pickKind == OP_PICK_LINK && m_pickLink >= 0)
|
| {
|
| //--- Fetch the chosen connection to read the value it carries
|
| OmvEdge chosen;
|
| m_layout.EdgeAt(m_pickLink, chosen);
|
| hot = (edge.label == chosen.label);
|
| }
|
| //--- Draw a bent connector so crossings read cleanly
|
| m_cv.Elbow(x1, y1, x2, y2, bend, head, hot ? m_th.accent : m_th.muted);
|
| //--- Remember the route itself so the pointer can pick the right one
|
| ArrayResize(m_linkPts, m_links + 1);
|
| ArrayResize(m_linkCount, m_links + 1);
|
| ArrayResize(m_linkEdge, m_links + 1);
|
| //--- Tie the route to its connection, since skipped edges shift the slots
|
| m_linkEdge[m_links] = i;
|
| const double midY = (y1 + (y2 - head)) * 0.5;
|
| m_linkPts[m_links][0] = (int)x1;
|
| m_linkPts[m_links][1] = (int)y1;
|
| m_linkPts[m_links][2] = (int)x1;
|
| m_linkPts[m_links][3] = (int)midY;
|
| m_linkPts[m_links][4] = (int)x2;
|
| m_linkPts[m_links][5] = (int)midY;
|
| m_linkPts[m_links][6] = (int)x2;
|
| m_linkPts[m_links][7] = (int)y2;
|
| m_linkCount[m_links] = 4;
|
| m_links++;
|
| //--- Print the shape the connection carries beside its drop
|
| if(StringLen(edge.shape) == 0)
|
| continue;
|
| //--- Give the label the same room a weight row gets, so both scale alike
|
| const int labelH = (int)MathMax(1.0, OL_ROW_H * m_zoom) - 1;
|
| const int labelW = (int)MathMax(1.0, OL_BOX_W * m_zoom);
|
| m_cv.FitFont(edge.shape, labelW, labelH, 8, 1, false);
|
| const int lw = m_cv.TextWide(edge.shape);
|
| const int lh = m_cv.TextHigh(edge.shape);
|
| const int lx = (int)x1 + 5;
|
| const int ly = (int)(y1 + (y2 - y1) * 0.25);
|
| //--- Draw it while its own glyphs still sit inside the view
|
| if(m_cv.InClip(lx, ly - lh / 2, lx + lw, ly + lh / 2))
|
| m_cv.TxtL(lx, ly - lh / 2, edge.shape, m_th.muted);
|
| }
|
| //--- Draw every box over the edges
|
| for(int i = 0; i < m_layout.Boxes(); i++)
|
| {
|
| //--- Fetch this box
|
| OmvBox box;
|
| m_layout.BoxAt(i, box);
|
| //--- Convert it out of graph space into canvas space
|
| const int bx = left + m_panX + (int)(box.x * m_zoom);
|
| const int by = top + m_panY + (int)(box.y * m_zoom);
|
| const int bw = (int)(box.w * m_zoom);
|
| const int bh = (int)(box.h * m_zoom);
|
| //--- Skip a box that falls outside the visible area
|
| if(bx + bw < left || bx > right || by + bh < top || by > bottom)
|
| continue;
|
| //--- Take the caption from the node, or from the port for a port box
|
| OmvNode node;
|
| string caption = box.portName;
|
| if(box.node >= 0)
|
| {
|
| m_model.NodeAt(box.node, node);
|
| caption = node.op;
|
| }
|
| //--- Fill the box in its role color
|
| m_cv.RoundFill(bx, by, bw, bh, 4, FillForRole(box.role));
|
| //--- Give a node holding weights a header strip over a listing body
|
| const int headH = (box.rowCount > 0) ? (int)(OL_HEAD_H * m_zoom) : bh;
|
| if(box.rowCount > 0)
|
| m_cv.RoundFillSel(bx, by, bw, headH, 4, EdgeForRole(box.role), true, true, false, false);
|
| //--- A box reads as chosen only while the inspector describes a box
|
| const bool chosen = (i == m_selected) &&
|
| (m_pickKind == OP_PICK_NODE || m_pickKind == OP_PICK_GRAPH);
|
| //--- Thicken the outline instead of ringing a marked box
|
| const bool marked = (chosen || i == m_hoverNode);
|
| m_cv.RoundStroke(bx, by, bw, bh, 4, marked ? 2 : 1,
|
| marked ? m_th.accent : EdgeForRole(box.role));
|
| //--- Pick the largest type the header can hold
|
| m_cv.FitFont(caption, bw - 6, headH - 2, 11, 1, true);
|
| const int titleH = m_cv.TextHigh(caption);
|
| //--- Name the operator, light on the strip or in the role color without one
|
| const uint titleInk = (box.rowCount > 0) ? FillForRole(box.role) : EdgeForRole(box.role);
|
| const int midY = by + headH / 2;
|
| const int halfW = m_cv.TextWide(caption) / 2 + 1;
|
| //--- Draw the title while its own glyphs still sit inside the view
|
| if(m_cv.InClip(bx + bw / 2 - halfW, midY - titleH / 2, bx + bw / 2 + halfW, midY + titleH / 2))
|
| m_cv.TxtM(bx + bw / 2, midY, caption, titleInk);
|
| //--- List every weight the node reads, one row each
|
| const int rowH = (int)(OL_ROW_H * m_zoom);
|
| const int pad = (int)MathMax(1.0, OL_ROW_PAD * m_zoom);
|
| for(int r = 0; r < box.rowCount && rowH >= 1; r++)
|
| {
|
| //--- Place this row inside the body, clear of the header and the floor
|
| const int ry = by + headH + pad + r * rowH;
|
| if(ry + rowH > by + bh)
|
| break;
|
| //--- Inset the row by the same margin on every side
|
| const int rowX = bx + pad;
|
| const int rowW = bw - pad * 2;
|
| //--- Remember it so the pointer can pick it
|
| ArrayResize(m_rowRect, m_rows + 1);
|
| ArrayResize(m_rowTensor, m_rows + 1);
|
| m_rowRect[m_rows][0] = rowX;
|
| m_rowRect[m_rows][1] = ry;
|
| m_rowRect[m_rows][2] = rowW;
|
| m_rowRect[m_rows][3] = rowH;
|
| m_rowTensor[m_rows] = box.rowTensor[r];
|
| //--- Mark a row the pointer sits on or the inspector describes
|
| const bool hot = (m_hoverRow == m_rows) ||
|
| (m_pickKind == OP_PICK_TENSOR && m_pickTensor == box.rowTensor[r]) ||
|
| (StringLen(m_litName) > 0 && box.rowName[r] == m_litName);
|
| m_rows++;
|
| if(hot)
|
| m_cv.RoundStroke(rowX, ry, rowW, rowH, 3, 1, m_th.accent);
|
| //--- Print the letter the operator calls this input
|
| m_cv.FitFont(box.rowText[r], rowW - 8, rowH - 1, 8, 1, false);
|
| const int rowTH = m_cv.TextHigh(box.rowText[r]);
|
| //--- Draw the row while its own glyphs still sit inside the view
|
| if(m_cv.InClip(rowX, ry, rowX + rowW, ry + rowH))
|
| {
|
| m_cv.TxtL(rowX + 4, ry + (rowH - rowTH) / 2, box.rowLabel[r], m_th.text);
|
| m_cv.TxtR(rowX + rowW - 4, ry + (rowH - rowTH) / 2, box.rowText[r], m_th.muted);
|
| }
|
| }
|
| }
|
| //--- Open the clip again for whatever draws next
|
| m_cv.NoClip();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Decide which scrollbars the graph currently needs |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::SizeBars(void)
|
| {
|
| //--- Measure the view as though neither bar were present
|
| const int roomW = CanvasRight() - CanvasLeft();
|
| const int roomH = CanvasBottom() - CanvasTop();
|
| //--- Take the graph at the current zoom
|
| const int fullW = ScaledW(), fullH = ScaledH();
|
| //--- Decide each bar, allowing for the gutter the other one takes
|
| m_barV = (fullH > roomH - OP_PAD * 2);
|
| m_barH = (fullW > roomW - OP_PAD * 2 - (m_barV ? OP_BAR : 0));
|
| m_barV = (fullH > roomH - OP_PAD * 2 - (m_barH ? OP_BAR : 0));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw whichever scrollbars the graph needs |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawBars(void)
|
| {
|
| //--- Measure the view and the scaled graph
|
| const int viewW = ViewW(), viewH = ViewH();
|
| const int fullW = ScaledW(), fullH = ScaledH();
|
| const int left = CanvasLeft(), top = CanvasTop();
|
| //--- Draw the vertical bar only when the graph is taller than the view
|
| if(!m_barV || viewH <= 0)
|
| {
|
| m_rBarV[2] = 0;
|
| m_rBarV[3] = 0;
|
| }
|
| else
|
| {
|
| //--- Lay the track down the right edge of the view
|
| const int trackX = CanvasRight() - OP_BAR;
|
| m_cv.RoundFill(trackX, top, OP_BAR, viewH, OP_BAR / 2, m_th.grid);
|
| //--- Size the thumb by how much of the graph is visible
|
| int thumbH = (int)((double)viewH * viewH / (fullH + OP_PAD * 2));
|
| if(thumbH < 20)
|
| thumbH = 20;
|
| if(thumbH > viewH)
|
| thumbH = viewH;
|
| //--- Map the whole pan range, margin included, onto the track
|
| const int span = fullH - viewH + OP_PAD * 2;
|
| double frac = (span > 0) ? (double)(OP_PAD - m_panY) / span : 0.0;
|
| if(frac < 0.0)
|
| frac = 0.0;
|
| if(frac > 1.0)
|
| frac = 1.0;
|
| //--- Place the thumb inside the track it was given
|
| const int thumbY = top + (int)((viewH - thumbH) * frac);
|
| //--- Store the thumb so the pointer can grab it
|
| m_rBarV[0] = trackX;
|
| m_rBarV[1] = thumbY;
|
| m_rBarV[2] = OP_BAR;
|
| m_rBarV[3] = thumbH;
|
| //--- Draw the thumb, lit while the pointer works it
|
| const bool lit = (m_hover == OH_BAR_V || m_barDrag == OH_BAR_V);
|
| m_cv.RoundFill(trackX, thumbY, OP_BAR, thumbH, OP_BAR / 2, lit ? m_th.accent : m_th.muted);
|
| }
|
| //--- Draw the horizontal bar only when the graph is wider than the view
|
| if(!m_barH || viewW <= 0)
|
| {
|
| m_rBarH[2] = 0;
|
| m_rBarH[3] = 0;
|
| return;
|
| }
|
| //--- Lay the track along the bottom edge of the view
|
| const int trackY = CanvasBottom() - OP_BAR;
|
| m_cv.RoundFill(left, trackY, viewW, OP_BAR, OP_BAR / 2, m_th.grid);
|
| //--- Size the thumb by how much of the graph is visible
|
| int thumbW = (int)((double)viewW * viewW / (fullW + OP_PAD * 2));
|
| if(thumbW < 20)
|
| thumbW = 20;
|
| if(thumbW > viewW)
|
| thumbW = viewW;
|
| //--- Map the whole pan range, margin included, onto the track
|
| const int span = fullW - viewW + OP_PAD * 2;
|
| double frac = (span > 0) ? (double)(OP_PAD - m_panX) / span : 0.0;
|
| if(frac < 0.0)
|
| frac = 0.0;
|
| if(frac > 1.0)
|
| frac = 1.0;
|
| //--- Place the thumb inside the track it was given
|
| const int thumbX = left + (int)((viewW - thumbW) * frac);
|
| //--- Store the thumb so the pointer can grab it
|
| m_rBarH[0] = thumbX;
|
| m_rBarH[1] = trackY;
|
| m_rBarH[2] = thumbW;
|
| m_rBarH[3] = OP_BAR;
|
| //--- Draw the thumb, lit while the pointer works it
|
| const bool lit = (m_hover == OH_BAR_H || m_barDrag == OH_BAR_H);
|
| m_cv.RoundFill(thumbX, trackY, thumbW, OP_BAR, OP_BAR / 2, lit ? m_th.accent : m_th.muted);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Remember or forget that a row is open |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::ToggleRow(const string key)
|
| {
|
| //--- Forget the key when it is already held open
|
| for(int i = 0; i < m_openCount; i++)
|
| {
|
| //--- Drop it by pulling the last entry into its place
|
| if(m_opened[i] != key)
|
| continue;
|
| m_opened[i] = m_opened[m_openCount - 1];
|
| m_openCount--;
|
| ArrayResize(m_opened, m_openCount);
|
| return;
|
| }
|
| //--- Hold the key open when it was not already
|
| ArrayResize(m_opened, m_openCount + 1);
|
| m_opened[m_openCount++] = key;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Append one row to the inspector listing |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::AddRow(const string name, const string value,
|
| const bool isHead, const string linkName)
|
| {
|
| //--- Refuse a row beyond what the listing may hold
|
| if(m_infos >= OP_MAX_ROWS)
|
| return;
|
| //--- Keep a row open across a rebuild by looking its name up
|
| bool wasOpen = false;
|
| for(int i = 0; i < m_openCount; i++)
|
| if(m_opened[i] == name + "|" + value)
|
| {
|
| wasOpen = true;
|
| break;
|
| }
|
| //--- Describe the row
|
| ArrayResize(m_info, m_infos + 1);
|
| m_info[m_infos].name = name;
|
| m_info[m_infos].value = value;
|
| m_info[m_infos].extraCount = 0;
|
| m_info[m_infos].wraps = 1;
|
| m_info[m_infos].canOpen = false;
|
| m_info[m_infos].isOpen = wasOpen;
|
| m_info[m_infos].isHead = isHead;
|
| m_info[m_infos].linkName = linkName;
|
| m_info[m_infos].y = 0;
|
| m_info[m_infos].h = 0;
|
| m_infos++;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Add one line to the row most recently started |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::AddLine(const string line)
|
| {
|
| //--- Refuse a line before any row has been started
|
| if(m_infos <= 0)
|
| return;
|
| //--- Refuse a line beyond what the row may hold
|
| const int last = m_infos - 1;
|
| if(m_info[last].extraCount >= OP_MAX_LINES)
|
| return;
|
| //--- Append the line and mark the row as something that opens
|
| m_info[last].extra[m_info[last].extraCount++] = line;
|
| m_info[last].canOpen = true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Add the lines a named value opens to |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::AddValueLines(const string name)
|
| {
|
| //--- A stored weight reports its category before anything else
|
| const int k = TensorNamed(name);
|
| if(k >= 0)
|
| {
|
| //--- Fetch the tensor being reported
|
| OmvTensor tensor;
|
| m_model.TensorAt(k, tensor);
|
| AddLine("category: " + tensor.category);
|
| AddLine("tensor: " + m_model.TypeName(tensor.dataType) +
|
| m_model.DimsList(tensor.dim, tensor.dims));
|
| //--- Say so when the values live outside the file rather than showing none
|
| if(tensor.location != "default")
|
| AddLine("location: " + tensor.location);
|
| //--- Print the weights themselves, wrapped on the last axis
|
| AddTensorValues(tensor);
|
| return;
|
| }
|
| //--- A graph port reports the type the graph declares for it
|
| for(int p = 0; p < m_model.Inputs(); p++)
|
| {
|
| //--- Fetch this graph input
|
| OmvPort port;
|
| m_model.InputAt(p, port);
|
| //--- Report its type once the name matches
|
| if(port.name != name)
|
| continue;
|
| AddLine("tensor: " + m_model.TypeName(port.elemType) +
|
| m_model.DimsList(port.dim, port.dims));
|
| return;
|
| }
|
| //--- A value passing between layers reports its type when the file says so
|
| for(int p = 0; p < m_model.Inners(); p++)
|
| {
|
| //--- Fetch this inner value
|
| OmvPort port;
|
| m_model.InnerAt(p, port);
|
| //--- Report its type once the name matches
|
| if(port.name != name)
|
| continue;
|
| AddLine("tensor: " + m_model.TypeName(port.elemType) +
|
| m_model.DimsList(port.dim, port.dims));
|
| return;
|
| }
|
| //--- A graph output reports its type the same way
|
| for(int p = 0; p < m_model.Outputs(); p++)
|
| {
|
| //--- Fetch this graph output
|
| OmvPort port;
|
| m_model.OutputAt(p, port);
|
| //--- Report its type once the name matches
|
| if(port.name != name)
|
| continue;
|
| AddLine("tensor: " + m_model.TypeName(port.elemType) +
|
| m_model.DimsList(port.dim, port.dims));
|
| return;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Print a tensor's weights, wrapped on its last axis |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::AddTensorValues(const OmvTensor &tensor)
|
| {
|
| //--- Print the strings when the tensor holds text rather than numbers
|
| if(tensor.texts > 0)
|
| {
|
| //--- Open the bracket and list one string to a line
|
| AddLine("[");
|
| for(int s = 0; s < tensor.texts; s++)
|
| AddLine(" " + tensor.text[s] + ((s + 1 < tensor.texts) ? "," : ""));
|
| AddLine("]");
|
| return;
|
| }
|
| //--- Nothing to print when the file carried no weights
|
| if(tensor.kept <= 0)
|
| return;
|
| //--- Take the last axis as the length of an innermost run
|
| const int inner = (tensor.dims > 0) ? tensor.dim[tensor.dims - 1] : tensor.kept;
|
| if(inner <= 0)
|
| return;
|
| //--- Open the outermost bracket
|
| AddLine("[");
|
| //--- A one axis tensor is a single run with no nesting
|
| const bool nested = (tensor.dims > 1);
|
| const string pad = nested ? " " : " ";
|
| //--- Walk the weights, one to a line, closing each run as it ends
|
| for(int i = 0; i < tensor.kept; i++)
|
| {
|
| //--- Open a run whenever one begins
|
| if(nested && i % inner == 0)
|
| AddLine(" [");
|
| //--- Print this weight, with a comma unless it ends its run
|
| const bool lastInRun = ((i + 1) % inner == 0) || (i + 1 == tensor.kept);
|
| AddLine(pad + DoubleToString(tensor.val[i], 8) + (lastInRun ? "" : ","));
|
| //--- Close a run whenever one ends
|
| if(nested && lastInRun)
|
| AddLine((i + 1 == tensor.kept) ? " ]" : " ],");
|
| }
|
| //--- Say so when the tensor held more than the display keeps
|
| if(tensor.values > tensor.kept)
|
| AddLine(" ... " + IntegerToString(tensor.values - tensor.kept) + " more");
|
| //--- Close the outermost bracket
|
| AddLine("]");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Add the lines a named value opens to |
|
| //+------------------------------------------------------------------+
|
| //| Turn the current selection into inspector rows |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::BuildInfo(void)
|
| {
|
| //--- Start a fresh listing
|
| const int held = m_infos;
|
| m_infos = 0;
|
| //--- Describe a chosen weight tensor
|
| if(m_pickKind == OP_PICK_TENSOR && m_pickTensor >= 0)
|
| {
|
| //--- Fetch the tensor being described
|
| OmvTensor tensor;
|
| m_model.TensorAt(m_pickTensor, tensor);
|
| AddRow("name", tensor.name, false);
|
| AddRow("category", tensor.category, false);
|
| AddRow("type", m_model.TypeName(tensor.dataType), false);
|
| AddRow("shape", m_model.DimsBare(tensor.dim, tensor.dims), false);
|
| //--- Say so when the file keeps the values somewhere else
|
| if(tensor.location != "default")
|
| AddRow("location", tensor.location, false);
|
| //--- Say so when the file stored this tensor in pieces
|
| if(tensor.segmented)
|
| AddRow("segment", "present", false);
|
| AddRow("value", IntegerToString(tensor.values), false);
|
| AddTensorValues(tensor);
|
| AddRow("METRICS", "", true);
|
| //--- Each metric reports the type it was measured in
|
| const string metricType = m_model.TypeName(tensor.dataType);
|
| AddRow("min", Measure(tensor.minValue), false);
|
| AddLine("type: " + metricType);
|
| AddRow("max", Measure(tensor.maxValue), false);
|
| AddLine("type: " + metricType);
|
| AddRow("mean", Measure(tensor.meanValue), false);
|
| AddLine("type: " + metricType);
|
| //--- The spread declares no type, so it carries no opened line
|
| AddRow("std", Measure(tensor.stdValue), false);
|
| AddRow("sparsity", DoubleToString(tensor.sparsity * 100.0, 1) + "%", false);
|
| AddLine("type: percentage");
|
| return;
|
| }
|
| //--- Describe a chosen connection
|
| if(m_pickKind == OP_PICK_LINK && m_pickLink >= 0)
|
| {
|
| //--- Fetch the connection being described
|
| OmvEdge edge;
|
| m_layout.EdgeAt(m_pickLink, edge);
|
| //--- Name the value and report what it opens to
|
| AddRow("name", edge.label, false);
|
| AddRow("type", "name: " + edge.label, false, edge.label);
|
| AddValueLines(edge.label);
|
| //--- List every box that writes the value
|
| int writers = 0;
|
| for(int e = 0; e < m_layout.Edges(); e++)
|
| {
|
| //--- Take only the connections carrying the same value
|
| OmvEdge other;
|
| m_layout.EdgeAt(e, other);
|
| if(other.label != edge.label)
|
| continue;
|
| //--- Report each source once, heading the section first
|
| if(writers == 0)
|
| AddRow("INPUTS", "", true);
|
| writers++;
|
| AddEndpoint("from", other.from);
|
| break;
|
| }
|
| //--- List every box that reads the value
|
| int readers = 0;
|
| for(int e = 0; e < m_layout.Edges(); e++)
|
| {
|
| //--- Take only the connections carrying the same value
|
| OmvEdge other;
|
| m_layout.EdgeAt(e, other);
|
| if(other.label != edge.label)
|
| continue;
|
| //--- Report each target, heading the section before the first
|
| if(readers == 0)
|
| AddRow("OUTPUTS", "", true);
|
| readers++;
|
| AddEndpoint("to", other.to);
|
| }
|
| return;
|
| }
|
| //--- Describe the file as a whole
|
| if(m_pickKind == OP_PICK_MODEL)
|
| {
|
| //--- Report the format the file announces
|
| AddRow("format", "ONNX v" + IntegerToString(m_model.IrVersion()), false);
|
| //--- Report the tool that wrote it, with its version when it gave one
|
| if(StringLen(m_model.Producer()) > 0)
|
| {
|
| string who = m_model.Producer();
|
| if(StringLen(m_model.ProducerVersion()) > 0)
|
| who += " " + m_model.ProducerVersion();
|
| AddRow("producer", who, false);
|
| }
|
| //--- Report the revision the model gives itself
|
| AddRow("version", IntegerToString(m_model.ModelVersion()), false);
|
| //--- Report whatever the file says about itself
|
| if(StringLen(m_model.DocString()) > 0)
|
| AddRow("description", m_model.DocString(), false);
|
| //--- Report the domain the model belongs to
|
| if(StringLen(m_model.Domain()) > 0)
|
| AddRow("domain", m_model.Domain(), false);
|
| //--- Report the operator set it imports
|
| AddRow("imports", "ai.onnx v" + IntegerToString(m_model.Opset()), false);
|
| //--- Report whether the file carries training state beside the model
|
| if(m_model.HasTraining())
|
| AddRow("training", "present", false);
|
| //--- List every operator the file defines for itself
|
| if(m_model.Funcs() > 0)
|
| {
|
| AddRow("FUNCTIONS", "", true);
|
| for(int i = 0; i < m_model.Funcs(); i++)
|
| {
|
| //--- Name the definition, then say what it holds
|
| AddRow(m_model.FuncName(i), m_model.FuncDetail(i), false);
|
| }
|
| }
|
| //--- List every key and value pair the file attached to the model
|
| if(m_model.Metas() > 0)
|
| {
|
| AddRow("METADATA", "", true);
|
| for(int i = 0; i < m_model.Metas(); i++)
|
| AddRow(m_model.MetaKey(i), m_model.MetaValue(i), false);
|
| }
|
| return;
|
| }
|
| //--- Describe the graph as a whole
|
| if(m_pickKind == OP_PICK_GRAPH)
|
| {
|
| //--- Name the graph
|
| AddRow("name", m_model.GraphName(), false);
|
| //--- Report whatever the file says about the graph
|
| if(StringLen(m_model.GraphDoc()) > 0)
|
| AddRow("description", m_model.GraphDoc(), false);
|
| //--- List every value the graph takes in
|
| if(m_model.Inputs() > 0)
|
| AddRow("INPUTS", "", true);
|
| for(int p = 0; p < m_model.Inputs(); p++)
|
| {
|
| //--- Fetch this graph input
|
| OmvPort port;
|
| m_model.InputAt(p, port);
|
| //--- Report it with its tensor on the open line
|
| AddRow(port.name, "name: " + port.name, false, port.name);
|
| AddValueLines(port.name);
|
| }
|
| //--- List every value the graph gives back
|
| if(m_model.Outputs() > 0)
|
| AddRow("OUTPUTS", "", true);
|
| for(int p = 0; p < m_model.Outputs(); p++)
|
| {
|
| //--- Fetch this graph output
|
| OmvPort port;
|
| m_model.OutputAt(p, port);
|
| //--- Report it with its tensor on the open line
|
| AddRow(port.name, "name: " + port.name, false, port.name);
|
| AddValueLines(port.name);
|
| }
|
| //--- Report what the graph weighs
|
| AddRow("METRICS", "", true);
|
| AddRow("parameters", IntegerToString(m_model.Parameters()), false);
|
| //--- Report how many values the graph annotates for quantization
|
| if(m_model.Quants() > 0)
|
| AddRow("quantized", IntegerToString(m_model.Quants()), false);
|
| //--- List every key and value pair the file attached to the graph
|
| if(m_model.GraphMetas() > 0)
|
| {
|
| AddRow("METADATA", "", true);
|
| for(int i = 0; i < m_model.GraphMetas(); i++)
|
| AddRow(m_model.GraphMetaKey(i), m_model.GraphMetaValue(i), false);
|
| }
|
| return;
|
| }
|
| //--- Describe a chosen layer
|
| if(m_pickKind == OP_PICK_NODE && m_selected >= 0 && m_selected < m_layout.Boxes())
|
| {
|
| //--- Fetch the box the selection points at
|
| OmvBox box;
|
| m_layout.BoxAt(m_selected, box);
|
| //--- Fetch the node the box was placed for
|
| OmvNode node;
|
| m_model.NodeAt(box.node, node);
|
| AddRow("type", node.op, false);
|
| //--- An empty domain means the operator comes from the default set
|
| const string domain = (StringLen(node.domain) > 0) ? node.domain : "ai.onnx";
|
| AddRow("module", domain + " v" + IntegerToString(m_model.Opset()), false);
|
| AddRow("name", node.name, false);
|
| //--- Report the overload the operator was resolved to
|
| if(StringLen(node.overload) > 0)
|
| AddRow("overload", node.overload, false);
|
| //--- Report whatever the file says about this layer
|
| if(StringLen(node.docString) > 0)
|
| AddRow("description", node.docString, false);
|
| //--- Report whatever the operator was configured with
|
| if(node.attrCount > 0)
|
| {
|
| AddRow("ATTRIBUTES", "", true);
|
| for(int a = 0; a < node.attrCount; a++)
|
| {
|
| //--- The Cast target names a type rather than carrying a number
|
| const bool isType = (node.op == "Cast" && node.attrName[a] == "to");
|
| const string shown = isType
|
| ? m_model.TypeName((int)StringToInteger(node.attrValue[a]))
|
| : node.attrValue[a];
|
| //--- Report the value, then the type it opens to
|
| AddRow(node.attrName[a], shown, false);
|
| AddLine("type: " + (isType ? "DataType" : m_model.AttrType(node.attrKind[a])));
|
| }
|
| }
|
| AddRow("INPUTS", "", true);
|
| //--- Name every input the way the operator names it
|
| for(int j = 0; j < node.feedCount; j++)
|
| {
|
| //--- Report the name, then whatever the value opens to
|
| AddRow(ArgIn(node.op, j), "name: " + node.feeds[j], false, node.feeds[j]);
|
| AddValueLines(node.feeds[j]);
|
| }
|
| AddRow("OUTPUTS", "", true);
|
| //--- List every name the node writes
|
| for(int j = 0; j < node.emitCount; j++)
|
| {
|
| //--- Report the name, then whatever the value opens to
|
| AddRow(ArgOut(node.op), "name: " + node.emits[j], false, node.emits[j]);
|
| AddValueLines(node.emits[j]);
|
| }
|
| return;
|
| }
|
| //--- Leave the listing empty when nothing is chosen
|
| if(held > 0)
|
| ArrayResize(m_info, 0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the inspector for the selected node |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawInspector(void)
|
| {
|
| //--- Skip the column entirely while it is closed
|
| if(!m_inspect)
|
| return;
|
| //--- Fill the column edge to edge so the graph can never show through it
|
| const int colX = CanvasRight();
|
| m_cv.FillRect(colX + 1, CanvasTop(), m_w - 2, CanvasBottom() - 1, m_th.panel);
|
| m_cv.VRule(colX, CanvasTop(), CanvasBottom() - 1, m_th.divider);
|
| //--- Measure the column and the band the rows scroll inside
|
| const int left = colX + 16;
|
| const int right = m_w - 16;
|
| const int top = CanvasTop() + 44;
|
| const int bottom = CanvasBottom() - 8;
|
| //--- Offer to close the column
|
| DrawIcon(m_rInspectX, OH_INSPECT_X, 5);
|
| //--- Title the column after whatever it is describing
|
| m_cv.Font(8, true);
|
| string heading = "PROPERTIES";
|
| if(m_pickKind == OP_PICK_NODE)
|
| heading = "NODE PROPERTIES";
|
| else
|
| if(m_pickKind == OP_PICK_TENSOR)
|
| heading = "TENSOR PROPERTIES";
|
| else
|
| if(m_pickKind == OP_PICK_LINK)
|
| heading = "CONNECTION PROPERTIES";
|
| else
|
| if(m_pickKind == OP_PICK_GRAPH)
|
| heading = "GRAPH PROPERTIES";
|
| else
|
| if(m_pickKind == OP_PICK_MODEL)
|
| heading = "MODEL PROPERTIES";
|
| m_cv.TxtL(left, CanvasTop() + 14, heading, m_th.muted);
|
| //--- Lay the rows out for whatever is chosen
|
| BuildInfo();
|
| //--- Invite a selection when the listing came back empty
|
| if(m_infos <= 0)
|
| {
|
| m_cv.Font(9);
|
| m_cv.TxtL(left, top, "select a node", m_th.muted);
|
| m_rInfoBar[2] = 0;
|
| m_rInfoBar[3] = 0;
|
| return;
|
| }
|
| //--- Measure every row and stack them
|
| m_cv.Font(8);
|
| const int lineH = m_cv.TextHigh("Ag");
|
| //--- Assume the scrollbar is present so the width cannot change under us
|
| const int valX = left + OP_NAME_W;
|
| const int valW = right - valX - OP_BAR - 2 - OP_VAL_PAD * 2;
|
| int cursor = 0;
|
| for(int i = 0; i < m_infos; i++)
|
| {
|
| //--- A heading takes a line of its own with space above it
|
| if(m_info[i].isHead)
|
| {
|
| m_info[i].y = cursor + 10;
|
| m_info[i].h = lineH + 4;
|
| m_info[i].wraps = 1;
|
| }
|
| else
|
| {
|
| //--- Take how many lines this value needs at the width it is given
|
| string lines[];
|
| m_info[i].wraps = MathMax(1, m_cv.WrapText(m_info[i].value, valW, lines, OP_WRAP_MAX));
|
| //--- Grow the box by every line past the first, and again once opened
|
| m_info[i].y = cursor;
|
| m_info[i].h = OP_VAL_H + (m_info[i].wraps - 1) * lineH +
|
| (m_info[i].isOpen ? m_info[i].extraCount * (lineH + 2) + OP_VAL_PAD : 0);
|
| }
|
| cursor = m_info[i].y + m_info[i].h + OP_VAL_GAP;
|
| }
|
| m_infoHigh = cursor;
|
| //--- Hold the scroll inside what the rows actually need
|
| const int band = bottom - top;
|
| if(m_infoHigh <= band)
|
| m_infoScroll = 0;
|
| else
|
| {
|
| //--- Never scroll past either end of the listing
|
| if(m_infoScroll < 0)
|
| m_infoScroll = 0;
|
| if(m_infoScroll > m_infoHigh - band)
|
| m_infoScroll = m_infoHigh - band;
|
| }
|
| //--- Hold every row inside the band it scrolls in
|
| const bool bar = (m_infoHigh > band);
|
| m_cv.SetClip(colX + 1, top, right + (bar ? 0 : 8), bottom);
|
| //--- Draw every row that falls inside the band
|
| for(int i = 0; i < m_infos; i++)
|
| {
|
| //--- Place this row against the current scroll
|
| const int ry = top + m_info[i].y - m_infoScroll;
|
| if(ry + m_info[i].h < top || ry > bottom)
|
| continue;
|
| //--- Print a heading and move on
|
| if(m_info[i].isHead)
|
| {
|
| //--- Text ignores the clip, so keep it inside the band by hand
|
| if(ry >= top && ry + lineH <= bottom)
|
| {
|
| m_cv.Font(8, true);
|
| m_cv.TxtL(left, ry, m_info[i].name, m_th.muted);
|
| }
|
| continue;
|
| }
|
| //--- Light a row the pointer is on, or one naming the value being lit
|
| const bool hot = (m_infoHover == i) ||
|
| (StringLen(m_litName) > 0 && m_info[i].linkName == m_litName);
|
| m_cv.RoundFill(valX, ry, right - valX - (bar ? OP_BAR + 2 : 0), m_info[i].h, 2,
|
| hot ? m_th.hoverFace : m_th.grid);
|
| //--- Outline the box while the pointer sits on a row that leads somewhere
|
| if(hot && (m_info[i].canOpen || StringLen(m_info[i].linkName) > 0))
|
| m_cv.RoundStroke(valX, ry, right - valX - (bar ? OP_BAR + 2 : 0), m_info[i].h, 2, 1,
|
| m_th.accent);
|
| //--- Take the baseline the name and the first line share
|
| const int firstY = ry + (OP_VAL_H - lineH) / 2;
|
| const int valRight = right - (bar ? OP_BAR + 2 : 0) - OP_VAL_PAD;
|
| //--- Text ignores the clip, so keep the first line inside the band by hand
|
| if(firstY >= top && firstY + lineH <= bottom)
|
| {
|
| //--- Name the row beside its box
|
| m_cv.Font(8);
|
| string tag[];
|
| if(m_cv.WrapText(m_info[i].name, OP_NAME_W - 10, tag, 1) > 0)
|
| m_cv.TxtR(valX - 8, firstY, tag[0], m_th.muted);
|
| }
|
| //--- Print the value as the lines it wrapped onto
|
| m_cv.Font(8);
|
| string shown[];
|
| const int rows = m_cv.WrapText(m_info[i].value, valW, shown, OP_WRAP_MAX);
|
| for(int k = 0; k < rows; k++)
|
| {
|
| //--- Place this line and test it against the band itself
|
| const int ly = firstY + k * lineH;
|
| if(ly < top || ly + lineH > bottom)
|
| continue;
|
| m_cv.TxtL(valX + OP_VAL_PAD, ly, shown[k], m_th.text);
|
| }
|
| //--- Offer the expander on a row that carries a second line
|
| if(m_info[i].canOpen && firstY >= top && firstY + lineH <= bottom)
|
| {
|
| //--- Light the glyph only while the pointer is on it
|
| const bool onPlus = (hot && m_onExpander);
|
| m_cv.Font(8, true);
|
| m_cv.TxtR(valRight, firstY, m_info[i].isOpen ? "-" : "+",
|
| onPlus ? m_th.accent : m_th.muted);
|
| }
|
| //--- Print every line the row carries once it is open
|
| if(m_info[i].isOpen && m_info[i].extraCount > 0)
|
| {
|
| //--- Rule the opened lines off below whatever the value took
|
| const int ruleY = ry + OP_VAL_H + (m_info[i].wraps - 1) * lineH;
|
| if(ruleY >= top && ruleY <= bottom)
|
| m_cv.HRule(valX + 1, valRight, ruleY, m_th.divider);
|
| m_cv.Font(8);
|
| //--- Stack the lines under the rule, skipping any outside the band
|
| for(int e = 0; e < m_info[i].extraCount; e++)
|
| {
|
| //--- Place this line and test it against the band itself
|
| const int ey = ry + OP_VAL_H + (m_info[i].wraps - 1) * lineH
|
| + OP_VAL_PAD / 2 + e * (lineH + 2);
|
| if(ey < top || ey + lineH > bottom)
|
| continue;
|
| //--- Hold the line inside the box, marking it when it will not fit
|
| string cut[];
|
| if(m_cv.WrapText(m_info[i].extra[e], valW, cut, 1) > 0)
|
| m_cv.TxtL(valX + OP_VAL_PAD, ey, cut[0], m_th.muted);
|
| }
|
| }
|
| }
|
| m_cv.NoClip();
|
| //--- Hide the scrollbar while every row already fits
|
| if(!bar)
|
| {
|
| m_rInfoBar[2] = 0;
|
| m_rInfoBar[3] = 0;
|
| return;
|
| }
|
| //--- Lay the track down the right edge of the column
|
| const int trackX = right - OP_BAR;
|
| m_cv.RoundFill(trackX, top, OP_BAR, band, OP_BAR / 2, m_th.grid);
|
| //--- Size the thumb by how much of the listing is visible
|
| int thumbH = (int)((double)band * band / m_infoHigh);
|
| if(thumbH < 20)
|
| thumbH = 20;
|
| //--- Place the thumb by how far the listing has been scrolled
|
| const double frac = (double)m_infoScroll / (m_infoHigh - band);
|
| const int thumbY = top + (int)((band - thumbH) * frac);
|
| //--- Store the thumb so the pointer can grab it
|
| m_rInfoBar[0] = trackX;
|
| m_rInfoBar[1] = thumbY;
|
| m_rInfoBar[2] = OP_BAR;
|
| m_rInfoBar[3] = thumbH;
|
| //--- Draw the thumb, lit while the pointer works it
|
| const bool lit = (m_hover == OH_INFO_BAR || m_barDrag == OH_INFO_BAR);
|
| m_cv.RoundFill(trackX, thumbY, OP_BAR, thumbH, OP_BAR / 2, lit ? m_th.accent : m_th.muted);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Find the inspector row under a panel point |
|
| //+------------------------------------------------------------------+
|
| int COmvPanel::InfoAtPoint(const int mx, const int my)
|
| {
|
| //--- Ignore anything outside the column
|
| if(!m_inspect || mx <= CanvasRight())
|
| return -1;
|
| //--- Measure the band the rows scroll inside
|
| const int top = CanvasTop() + 44;
|
| const int bottom = CanvasBottom() - 8;
|
| if(my < top || my > bottom)
|
| return -1;
|
| //--- Test every laid out row against the current scroll
|
| for(int i = 0; i < m_infos; i++)
|
| {
|
| //--- Skip a heading, it cannot be picked
|
| if(m_info[i].isHead)
|
| continue;
|
| //--- Report the row that holds the point
|
| const int ry = top + m_info[i].y - m_infoScroll;
|
| if(my >= ry && my < ry + m_info[i].h)
|
| return i;
|
| }
|
| //--- Report that no row holds the point
|
| return -1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the footer band that does not change between frames |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawFooterChrome(void)
|
| {
|
| //--- Fill the band, rounding only the two corners it owns
|
| const int top = m_h - OP_FOOT_H;
|
| m_cv.RoundFillSel(0, top, m_w, OP_FOOT_H, OP_RADIUS, m_th.chrome,
|
| false, false, true, true);
|
| m_cv.HRule(1, m_w - 2, top, m_th.divider);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the control that swaps between the two views |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawViewSwitch(void)
|
| {
|
| //--- Name the view the control would take us to
|
| const string label = m_neuronView ? "Graph" : "Neurons";
|
| //--- Take whether the control can be used at all
|
| const bool live = m_neuronView || m_cells.Ready();
|
| //--- Light the face while the pointer rests on a control that works
|
| const bool hot = (m_hover == OH_VIEW && live);
|
| m_cv.RoundFill(m_rView[0], m_rView[1], m_rView[2], m_rView[3], 4,
|
| hot ? m_th.hoverFace : m_th.btnFace);
|
| m_cv.RoundStroke(m_rView[0], m_rView[1], m_rView[2], m_rView[3], 4, 1,
|
| live ? m_th.btnEdge : m_th.divider);
|
| //--- Name it, in the muted ink when the model cannot be drawn as neurons
|
| m_cv.Font(8);
|
| m_cv.TxtM(m_rView[0] + m_rView[2] / 2, m_rView[1] + m_rView[3] / 2,
|
| label, live ? m_th.text : m_th.divider);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Draw the footer controls and readouts |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::DrawFooter(void)
|
| {
|
| //--- Take the top of the band every control sits in
|
| const int top = m_h - OP_FOOT_H;
|
| //--- Draw the three view controls
|
| DrawButton(m_rFit, OH_FIT, "Fit");
|
| DrawIcon(m_rZoomOut, OH_ZOOM_OUT, 3);
|
| DrawIcon(m_rZoomIn, OH_ZOOM_IN, 4);
|
| //--- Offer the other view, dimmed when this model has no neurons to draw
|
| DrawViewSwitch();
|
| //--- Measure the type once so every footer readout shares a baseline
|
| m_cv.Font(8);
|
| const int textY = top + OP_FOOT_H / 2;
|
| //--- Report the panel size beside the grip, which fixes the right hand edge
|
| const string size = IntegerToString(m_w) + " x " + IntegerToString(m_h);
|
| m_cv.TxtR(m_w - 26, textY - m_cv.TextHigh(size) / 2, size, m_th.muted);
|
| //--- Print the zoom just after the controls it belongs to
|
| const int afterZoom = m_rZoomIn[0] + m_rZoomIn[2] + 8;
|
| m_cv.TxtL(afterZoom, textY - m_cv.TextHigh("100%") / 2,
|
| IntegerToString((int)MathRound(m_zoom * 100)) + "%", m_th.muted);
|
| //--- Say what the model made of the last bar, since that is why it is running
|
| const int from = m_rView[0] + m_rView[2] + 14;
|
| const int room = m_w - 26 - m_cv.TextWide(size) - 14 - from;
|
| string shown = "";
|
| if(m_runner.Ready() && m_runner.When() > 0)
|
| {
|
| //--- Name the call, and flag it when our own pass disagrees with the model
|
| shown = m_runner.Verdict();
|
| if(m_agree >= 0.0 && m_agree > OR_AGREE)
|
| shown += " drawn pass differs by " + DoubleToString(m_agree, 5);
|
| }
|
| else
|
| if(m_selected >= 0 && m_selected < m_layout.Boxes())
|
| {
|
| //--- With no model running, name whatever the user picked instead
|
| OmvBox box;
|
| m_layout.BoxAt(m_selected, box);
|
| shown = box.portName;
|
| if(box.node >= 0)
|
| {
|
| OmvNode node;
|
| m_model.NodeAt(box.node, node);
|
| shown = node.op + " " + node.name;
|
| }
|
| }
|
| //--- Sit it between the view switch and the size readout, never over either
|
| string cut[];
|
| if(StringLen(shown) > 0 && room > 0 && m_cv.WrapText(shown, room, cut, 1) > 0)
|
| m_cv.TxtL(from, textY - m_cv.TextHigh(cut[0]) / 2, cut[0], m_th.muted);
|
| //--- Draw the three diagonals that mark the grip
|
| const bool lit = (m_hover == OH_GRIP || m_resizing);
|
| const uint ink = lit ? m_th.accent : m_th.muted;
|
| const int gx = m_rGrip[0] + m_rGrip[2];
|
| const int gy = m_rGrip[1] + m_rGrip[3];
|
| m_cv.StrokeAA(gx - 3, gy - 12, gx - 12, gy - 3, lit ? 2 : 1, ink);
|
| m_cv.StrokeAA(gx - 3, gy - 8, gx - 8, gy - 3, lit ? 2 : 1, ink);
|
| m_cv.StrokeAA(gx - 3, gy - 4, gx - 4, gy - 3, lit ? 2 : 1, ink);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Paint every band in order and publish the bitmap |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::Render(void)
|
| {
|
| //--- Do nothing without a canvas or after teardown
|
| if(m_destroyed || !m_created)
|
| return;
|
| //--- Rebuild the cached chrome only when something structural moved
|
| const string sig = ChromeSignature();
|
| if(sig != m_bgSig)
|
| {
|
| m_bgSig = sig;
|
| m_bgValid = false;
|
| }
|
| //--- Rebuild the cached scene only when the view itself moved
|
| const string scene = SceneSignature();
|
| if(scene != m_sceneSig)
|
| {
|
| m_sceneSig = scene;
|
| m_sceneValid = false;
|
| }
|
| //--- Put back the whole scene when nothing under the pointer changed it
|
| if(m_sceneValid && m_mode == OM_FULL)
|
| m_cv.RestoreFrom(m_scene);
|
| else
|
| {
|
| //--- Draw the chrome once and keep it, or put the kept copy back
|
| if(!m_bgValid)
|
| {
|
| DrawChrome();
|
| m_cv.SaveTo(m_bg);
|
| m_bgValid = true;
|
| }
|
| else
|
| m_cv.RestoreFrom(m_bg);
|
| //--- Draw the view the panel is showing over the cached chrome
|
| if(m_mode == OM_FULL)
|
| {
|
| //--- Keep the finished scene so a hover does not redraw it
|
| if(m_neuronView)
|
| DrawNeurons();
|
| else
|
| DrawGraph();
|
| m_cv.SaveTo(m_scene);
|
| m_sceneValid = true;
|
| }
|
| }
|
| //--- Draw everything that answers to the pointer on top of the scene
|
| if(m_mode == OM_FULL)
|
| {
|
| DrawBars();
|
| DrawInspector();
|
| DrawFooter();
|
| }
|
| //--- Draw the header icons over the cached band
|
| DrawHeader();
|
| //--- Publish the finished bitmap
|
| m_cv.Update();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Repaint no faster than the frame cap allows |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::PaintCapped(void)
|
| {
|
| //--- Read the clock once for this decision
|
| const uint now = GetTickCount();
|
| //--- Remember a skipped frame so the next event still lands it
|
| if(now - m_lastFrameMs < OP_FRAME_MS)
|
| {
|
| m_dirty = true;
|
| return;
|
| }
|
| //--- Stamp this frame and paint it
|
| m_lastFrameMs = now;
|
| m_dirty = false;
|
| Render();
|
| ChartRedraw(m_chartId);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Build the panel and load the model |
|
| //+------------------------------------------------------------------+
|
| bool COmvPanel::Init(const long chartId, const string path, const string scale,
|
| const string symbol, const ENUM_TIMEFRAMES period,
|
| const bool startOnNeurons)
|
| {
|
| //--- Reset every member before touching the chart
|
| InitDefaults();
|
| m_openNeurons = startOnNeurons;
|
| m_chartId = chartId;
|
| //--- Take the header title from the running program
|
| m_title = MQLInfoString(MQL_PROGRAM_NAME);
|
| if(StringLen(m_title) == 0)
|
| m_title = "ONNX Model Viewer";
|
| //--- Name the bitmap after the program so parts never clash
|
| m_name = "OMV_" + m_title;
|
| //--- Resolve the starting theme
|
| m_th.Apply(m_dark);
|
| //--- Read the model before anything is drawn
|
| if(!m_model.Load(path))
|
| {
|
| Print(m_title, ": ", m_model.Error());
|
| return false;
|
| }
|
| //--- Arrange what was read
|
| m_layout.Build(m_model);
|
| //--- Work out whether this model can also be shown as neurons
|
| m_cells.Build(m_model);
|
| //--- Remember which bars the model expects to be fed
|
| m_feedSymbol = (StringLen(symbol) > 0) ? symbol : Symbol();
|
| m_feedPeriod = period;
|
| //--- Open on whichever view the user asked for, where the model allows it
|
| if(m_openNeurons && m_cells.Ready())
|
| m_neuronView = true;
|
| //--- Open the same file again through the terminal, which can run it
|
| uchar bytes[];
|
| m_model.RawTo(bytes);
|
| if(!m_runner.Open(bytes, scale))
|
| Print(m_title, ": the model will be drawn but not run, ", m_runner.Error());
|
| else
|
| {
|
| //--- Answer for the newest closed bar right away, so the view is not blank
|
| if(RunModel())
|
| PrintFormat("%s: running on %s %s, last bar %s said %s", m_title,
|
| m_feedSymbol, EnumToString(m_feedPeriod),
|
| TimeToString(m_runner.When(), TIME_DATE | TIME_MINUTES),
|
| m_runner.Verdict());
|
| else
|
| Print(m_title, ": the model is open but no bar could be fed to it yet");
|
| //--- Flag a disagreement, since a drawn pass that differs would mislead
|
| if(m_agree > OR_AGREE)
|
| PrintFormat("%s: the drawn pass differs from the model by %.6f",
|
| m_title, m_agree);
|
| }
|
| //--- Place every control and build the bitmap
|
| ComputeLayout();
|
| if(!CreateCanvas())
|
| return false;
|
| //--- Scale the graph to the canvas it now has
|
| FitGraph();
|
| //--- Remember how the chart was set before the panel changes it
|
| m_hadMouse = (bool)ChartGetInteger(m_chartId, CHART_EVENT_MOUSE_MOVE);
|
| m_hadWheel = (bool)ChartGetInteger(m_chartId, CHART_EVENT_MOUSE_WHEEL);
|
| //--- Follow the pointer so the panel can be worked
|
| ChartSetInteger(m_chartId, CHART_EVENT_MOUSE_MOVE, true);
|
| ChartSetInteger(m_chartId, CHART_EVENT_MOUSE_WHEEL, true);
|
| //--- Show the first frame
|
| Render();
|
| ChartRedraw(m_chartId);
|
| //--- Report what was loaded
|
| Print(m_title, ": ", path, " -> ", m_model.Nodes(), " nodes, ",
|
| m_model.Tensors(), " tensors, ", m_model.Parameters(), " parameters");
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Remove the canvas and restore the chart |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::Destroy(void)
|
| {
|
| //--- Run the teardown only once
|
| if(m_destroyed)
|
| return;
|
| m_destroyed = true;
|
| //--- Stop any signal still travelling
|
| EventKillTimer();
|
| //--- Give scrolling back to the chart
|
| LockChartScroll(false);
|
| //--- Put the chart's own mouse settings back the way they were found
|
| ChartSetInteger(m_chartId, CHART_EVENT_MOUSE_MOVE, m_hadMouse);
|
| ChartSetInteger(m_chartId, CHART_EVENT_MOUSE_WHEEL, m_hadWheel);
|
| //--- Clear any tooltip left on the object
|
| if(m_created)
|
| ObjectSetString(m_chartId, m_name, OBJPROP_TOOLTIP, "\n");
|
| //--- Release the bitmap
|
| if(m_created)
|
| {
|
| m_cv.Destroy();
|
| m_created = false;
|
| }
|
| //--- Release the chrome cache
|
| ArrayFree(m_bg);
|
| ArrayFree(m_scene);
|
| m_bgValid = false;
|
| m_sceneValid = false;
|
| //--- Release the parsed structures
|
| m_layout.Clear();
|
| m_cells.Clear();
|
| m_model.Clear();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Route pointer events into the panel |
|
| //+------------------------------------------------------------------+
|
| void COmvPanel::OnEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
|
| {
|
| //--- Ignore events after teardown or before the canvas exists
|
| if(m_destroyed || !m_created)
|
| return;
|
| //--- Route a wheel turn before anything else looks at the pointer
|
| if(id == CHARTEVENT_MOUSE_WHEEL)
|
| {
|
| //--- The position packs into the low and high halves of lparam
|
| const int wx = (int)(short)(lparam & 0xFFFF) - m_x;
|
| const int wy = (int)(short)((lparam >> 16) & 0xFFFF) - m_y;
|
| //--- The terminal hands the wheel delta through dparam unpacked
|
| OnWheel(wx, wy, (int)dparam);
|
| return;
|
| }
|
| //--- Handle pointer events only
|
| if(id != CHARTEVENT_MOUSE_MOVE)
|
| return;
|
| //--- Convert the pointer into panel space
|
| const int mx = (int)lparam - m_x;
|
| const int my = (int)dparam - m_y;
|
| const bool down = ((int)StringToInteger(sparam) & 1) == 1;
|
| //--- Hold the scroll lock for the whole gesture
|
| const bool over = (mx >= 0 && mx < m_w && my >= 0 && my < m_h);
|
| LockChartScroll(over || m_dragging || m_resizing || m_panning || m_barDrag != OH_NONE);
|
| //--- Identify what sits under the pointer
|
| const int hit = over ? HitTest(mx, my) : OH_NONE;
|
| //--- Move the panel while a header drag is active
|
| if(m_dragging)
|
| {
|
| //--- End the drag on release
|
| if(!down)
|
| {
|
| m_dragging = false;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| return;
|
| }
|
| //--- Follow the pointer by the offset captured at press
|
| m_x = (int)lparam - m_dragOffX;
|
| m_y = (int)dparam - m_dragOffY;
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_XDISTANCE, m_x);
|
| ObjectSetInteger(m_chartId, m_name, OBJPROP_YDISTANCE, m_y);
|
| ChartRedraw(m_chartId);
|
| return;
|
| }
|
| //--- Resize the panel while a grip drag is active
|
| if(m_resizing)
|
| {
|
| //--- End the resize on release
|
| if(!down)
|
| {
|
| m_resizing = false;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| //--- Land whatever frame the cap skipped
|
| m_lastFrameMs = 0;
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Take the size the pointer implies through the captured offset
|
| int nw = (int)lparam - m_x + m_gripOffX;
|
| int nh = (int)dparam - m_y + m_gripOffY;
|
| //--- Clamp both sides to the allowed bounds
|
| if(nw < OP_W_MIN)
|
| nw = OP_W_MIN;
|
| if(nw > OP_W_MAX)
|
| nw = OP_W_MAX;
|
| if(nh < OP_H_MIN)
|
| nh = OP_H_MIN;
|
| if(nh > OP_H_MAX)
|
| nh = OP_H_MAX;
|
| //--- Skip everything when the size did not actually change
|
| if(nw == m_w && nh == m_h)
|
| return;
|
| //--- Take the new size at once, the bitmap behind it never changes
|
| m_w = nw;
|
| m_h = nh;
|
| m_fullH = nh;
|
| m_bgValid = false;
|
| ComputeLayout();
|
| ClampPan();
|
| //--- Paint through the cap so dragging stays responsive
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Drag the vertical scrollbar while its thumb is held
|
| if(m_barDrag == OH_BAR_V)
|
| {
|
| //--- End the drag on release
|
| if(!down)
|
| {
|
| m_barDrag = OH_NONE;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| //--- Land whatever frame the cap skipped
|
| m_lastFrameMs = 0;
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Convert the pointer travel into graph travel
|
| const int viewH = ViewH(), fullH = ScaledH();
|
| const int span = fullH - viewH + OP_PAD * 2;
|
| if(span > 0 && m_rBarV[3] > 0 && viewH > m_rBarV[3])
|
| {
|
| //--- Move the graph by the same fraction the thumb travelled
|
| m_panY = m_barFrom - (int)((double)(my - m_fromY) * span / (viewH - m_rBarV[3]));
|
| const int wanted = m_panY;
|
| ClampPan();
|
| //--- Anchor the drag again wherever the clamp bit
|
| if(m_panY != wanted)
|
| {
|
| m_barFrom = m_panY;
|
| m_fromY = my;
|
| }
|
| PaintCapped();
|
| }
|
| return;
|
| }
|
| //--- Drag the horizontal scrollbar while its thumb is held
|
| if(m_barDrag == OH_BAR_H)
|
| {
|
| //--- End the drag on release
|
| if(!down)
|
| {
|
| m_barDrag = OH_NONE;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| //--- Land whatever frame the cap skipped
|
| m_lastFrameMs = 0;
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Convert the pointer travel into graph travel
|
| const int viewW = ViewW(), fullW = ScaledW();
|
| const int span = fullW - viewW + OP_PAD * 2;
|
| if(span > 0 && m_rBarH[2] > 0 && viewW > m_rBarH[2])
|
| {
|
| //--- Move the graph by the same fraction the thumb travelled
|
| m_panX = m_barFrom - (int)((double)(mx - m_fromX) * span / (viewW - m_rBarH[2]));
|
| const int wanted = m_panX;
|
| ClampPan();
|
| //--- Anchor the drag again wherever the clamp bit
|
| if(m_panX != wanted)
|
| {
|
| m_barFrom = m_panX;
|
| m_fromX = mx;
|
| }
|
| PaintCapped();
|
| }
|
| return;
|
| }
|
| //--- Scroll the inspector while its thumb is held
|
| if(m_barDrag == OH_INFO_BAR)
|
| {
|
| //--- End the drag on release
|
| if(!down)
|
| {
|
| m_barDrag = OH_NONE;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| return;
|
| }
|
| //--- Move the listing by the same fraction the thumb travelled
|
| const int band = (CanvasBottom() - 8) - (CanvasTop() + 44);
|
| if(m_infoHigh > band && m_rInfoBar[3] > 0 && band > m_rInfoBar[3])
|
| {
|
| //--- Scale the movement by how much taller the listing is
|
| m_infoScroll = m_barFrom +
|
| (int)((double)(my - m_fromY) * (m_infoHigh - band) / (band - m_rInfoBar[3]));
|
| PaintCapped();
|
| }
|
| return;
|
| }
|
| //--- Pan the graph while a canvas drag is active
|
| if(m_panning)
|
| {
|
| //--- End the pan on release
|
| if(!down)
|
| {
|
| m_panning = false;
|
| m_lmbPrev = false;
|
| m_press = OH_NONE;
|
| LockChartScroll(over);
|
| //--- A press that never moved is a click on the background
|
| if(MathAbs(mx - m_pressX) < 3 && MathAbs(my - m_pressY) < 3)
|
| {
|
| m_pickKind = OP_PICK_MODEL;
|
| m_selected = -1;
|
| m_inspect = true;
|
| ComputeLayout();
|
| ClampPan();
|
| }
|
| //--- Land whatever frame the cap skipped
|
| m_lastFrameMs = 0;
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Shift the graph by however far the pointer moved
|
| m_panX += mx - m_fromX;
|
| m_panY += my - m_fromY;
|
| m_fromX = mx;
|
| m_fromY = my;
|
| ClampPan();
|
| PaintCapped();
|
| return;
|
| }
|
| //--- Track whatever sits under the pointer so it can be highlighted
|
| const int overNode = (hit == OH_NODE) ? NodeAtPoint(mx, my) : -1;
|
| const int overRow = (hit == OH_ROW) ? RowAtPoint(mx, my) : -1;
|
| //--- Take the value a hovered box row lists, so its sidebar row lights too
|
| string overRowName = "";
|
| if(overRow >= 0 && overRow < m_rows)
|
| overRowName = TensorNameAt(m_rowTensor[overRow]);
|
| const int overLink = (hit == OH_LINK) ? LinkAtPoint(mx, my) : -1;
|
| //--- Take the value a hovered connection carries, so its siblings light too
|
| string overEdgeName = "";
|
| if(overLink >= 0 && overLink < m_layout.Edges())
|
| {
|
| //--- Fetch the connection under the pointer
|
| OmvEdge lit;
|
| m_layout.EdgeAt(overLink, lit);
|
| overEdgeName = lit.label;
|
| }
|
| const int overInfo = (hit == OH_INFO) ? InfoAtPoint(mx, my) : -1;
|
| //--- Take the value the hovered row points at, and where on the row we are
|
| string overName = (overInfo >= 0) ? m_info[overInfo].linkName : "";
|
| //--- A hovered connection lights by name just as a hovered row does
|
| if(StringLen(overName) == 0)
|
| overName = overEdgeName;
|
| //--- So does a hovered weight row inside a box
|
| if(StringLen(overName) == 0)
|
| overName = overRowName;
|
| const bool overPlus = (overInfo >= 0) && OnExpander(mx, overInfo);
|
| //--- Take which neuron the pointer rests on, so the tooltip can name it
|
| int overBand = -1, overCell = -1;
|
| CellAtPoint(mx, my, overBand, overCell);
|
| //--- Repaint on any hover change, capped to one frame
|
| if(hit != m_hover || overNode != m_hoverNode ||
|
| overRow != m_hoverRow || overLink != m_hoverLink || overInfo != m_infoHover ||
|
| overName != m_litName || overPlus != m_onExpander ||
|
| overBand != m_hoverBand || overCell != m_hoverCell)
|
| {
|
| m_hover = hit;
|
| m_hoverBand = overBand;
|
| m_hoverCell = overCell;
|
| m_hoverNode = overNode;
|
| m_hoverRow = overRow;
|
| m_hoverLink = overLink;
|
| m_infoHover = overInfo;
|
| m_litName = overName;
|
| m_onExpander = overPlus;
|
| //--- Let the terminal draw the tooltip for whatever is hovered
|
| SetTooltip(TipFor(hit));
|
| PaintCapped();
|
| }
|
| //--- React to the press edge
|
| if(down && !m_lmbPrev)
|
| {
|
| //--- Remember where the press began
|
| m_press = hit;
|
| //--- Start a header drag
|
| if(hit == OH_HEADER)
|
| {
|
| m_dragging = true;
|
| m_dragOffX = (int)lparam - m_x;
|
| m_dragOffY = (int)dparam - m_y;
|
| }
|
| //--- Start a grip drag, keeping the grip under the pointer
|
| else
|
| if(hit == OH_GRIP)
|
| {
|
| m_resizing = true;
|
| m_gripOffX = (m_x + m_w) - (int)lparam;
|
| m_gripOffY = (m_y + m_h) - (int)dparam;
|
| }
|
| //--- Start a scrollbar drag from where the thumb sits now
|
| else
|
| if(hit == OH_BAR_V || hit == OH_BAR_H)
|
| {
|
| m_barDrag = hit;
|
| m_fromX = mx;
|
| m_fromY = my;
|
| m_barFrom = (hit == OH_BAR_V) ? m_panY : m_panX;
|
| }
|
| //--- Start an inspector scroll from where its thumb sits now
|
| else
|
| if(hit == OH_INFO_BAR)
|
| {
|
| m_barDrag = OH_INFO_BAR;
|
| m_fromY = my;
|
| m_barFrom = m_infoScroll;
|
| }
|
| //--- Start a canvas pan, remembering where it began
|
| else
|
| if(hit == OH_CANVAS)
|
| {
|
| m_panning = true;
|
| m_fromX = mx;
|
| m_fromY = my;
|
| m_pressX = mx;
|
| m_pressY = my;
|
| }
|
| //--- Select the box that was pressed and open the inspector for it
|
| else
|
| if(hit == OH_NODE)
|
| {
|
| m_selected = NodeAtPoint(mx, my);
|
| //--- A graph port belongs to the graph, so it opens the graph panel
|
| OmvBox picked;
|
| m_layout.BoxAt(m_selected, picked);
|
| m_pickKind = (picked.node < 0) ? OP_PICK_GRAPH : OP_PICK_NODE;
|
| m_inspect = true;
|
| ComputeLayout();
|
| ClampPan();
|
| PaintCapped();
|
| }
|
| //--- Select the weight row that was pressed
|
| else
|
| if(hit == OH_ROW)
|
| {
|
| //--- Take the tensor the row names
|
| const int row = RowAtPoint(mx, my);
|
| if(row >= 0)
|
| {
|
| m_pickTensor = m_rowTensor[row];
|
| m_pickKind = OP_PICK_TENSOR;
|
| m_selected = -1;
|
| m_inspect = true;
|
| ComputeLayout();
|
| ClampPan();
|
| }
|
| PaintCapped();
|
| }
|
| //--- Select the connection that was pressed
|
| else
|
| if(hit == OH_LINK)
|
| {
|
| m_pickLink = LinkAtPoint(mx, my);
|
| m_pickKind = OP_PICK_LINK;
|
| m_selected = -1;
|
| m_inspect = true;
|
| ComputeLayout();
|
| ClampPan();
|
| PaintCapped();
|
| }
|
| //--- Light the pressed control
|
| else
|
| if(hit != OH_NONE)
|
| PaintCapped();
|
| }
|
| //--- React to the release edge and run the action
|
| else
|
| if(!down && m_lmbPrev)
|
| {
|
| //--- Act only when the release lands where the press began
|
| const int act = (m_press == hit) ? hit : OH_NONE;
|
| m_press = OH_NONE;
|
| //--- Swap the theme
|
| if(act == OH_THEME)
|
| {
|
| m_dark = !m_dark;
|
| m_th.Apply(m_dark);
|
| m_bgValid = false;
|
| }
|
| //--- Swap the view, but only where the other one can be drawn
|
| else
|
| if(act == OH_VIEW)
|
| {
|
| //--- Refuse to leave the graph when the model has no neurons to show
|
| if(m_neuronView || m_cells.Ready())
|
| {
|
| m_neuronView = !m_neuronView;
|
| //--- A signal in flight belongs to the view it was sent through
|
| m_pulse = -1;
|
| EventKillTimer();
|
| //--- The neuron view has nothing selectable, so drop what the graph chose
|
| if(m_neuronView)
|
| {
|
| m_selected = -1;
|
| m_pickKind = OP_PICK_NONE;
|
| m_hoverNode = -1;
|
| m_hoverRow = -1;
|
| m_hoverLink = -1;
|
| m_litName = "";
|
| }
|
| //--- The two arrangements differ in size, so refit rather than keep the pan
|
| FitGraph();
|
| m_bgValid = false;
|
| }
|
| }
|
| //--- Scale the graph back into the canvas
|
| else
|
| if(act == OH_FIT)
|
| FitGraph();
|
| //--- Step the zoom down
|
| else
|
| if(act == OH_ZOOM_OUT)
|
| SetZoom(m_zoom / 1.25);
|
| //--- Step the zoom up
|
| else
|
| if(act == OH_ZOOM_IN)
|
| SetZoom(m_zoom * 1.25);
|
| //--- Act on the row that was pressed
|
| else
|
| if(act == OH_INFO)
|
| {
|
| //--- Take the row and decide which half of it was hit
|
| const int row = InfoAtPoint(mx, my);
|
| if(row >= 0 && m_info[row].canOpen && OnExpander(mx, row))
|
| ToggleRow(m_info[row].name + "|" + m_info[row].value);
|
| else
|
| if(row >= 0 && StringLen(m_info[row].linkName) > 0)
|
| {
|
| //--- Open the connection the row points at
|
| const int link = LinkNamed(m_info[row].linkName);
|
| if(link >= 0)
|
| {
|
| m_pickLink = link;
|
| m_pickKind = OP_PICK_LINK;
|
| m_selected = -1;
|
| m_litName = "";
|
| }
|
| }
|
| else
|
| if(row >= 0 && m_info[row].canOpen)
|
| ToggleRow(m_info[row].name + "|" + m_info[row].value);
|
| }
|
| //--- Close the inspector and give its width back to the graph
|
| else
|
| if(act == OH_INSPECT_X)
|
| {
|
| m_inspect = false;
|
| m_selected = -1;
|
| m_pickKind = OP_PICK_NONE;
|
| m_pickTensor = -1;
|
| m_pickLink = -1;
|
| ComputeLayout();
|
| ClampPan();
|
| }
|
| //--- Collapse or restore the panel
|
| else
|
| if(act == OH_MIN || act == OH_RESTORE)
|
| {
|
| m_mode = (act == OH_MIN) ? OM_MIN : OM_FULL;
|
| m_hover = OH_NONE;
|
| ApplyMode();
|
| }
|
| //--- Remove the panel
|
| else
|
| if(act == OH_CLOSE)
|
| {
|
| Destroy();
|
| ChartRedraw(m_chartId);
|
| return;
|
| }
|
| //--- Repaint whenever an action ran
|
| if(act != OH_NONE)
|
| {
|
| m_lastFrameMs = 0;
|
| PaintCapped();
|
| }
|
| }
|
| //--- Land a frame the cap skipped once enough time has passed
|
| if(m_dirty && GetTickCount() - m_lastFrameMs >= OP_FRAME_MS)
|
| PaintCapped();
|
| //--- Remember the button state for the next event
|
| m_lmbPrev = down;
|
| }
|
|
|
| #endif // OMV_PANEL_MQH
|
| //+------------------------------------------------------------------+ |