public ILDXGraphSurf3D(ILDXPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(sourceArray, clippingContainer) { m_localClipping = new ILClippingData(); if (!sourceArray.IsMatrix) { throw new ILArgumentException("source arrray must be matrix!"); } if (!sourceArray.IsNumeric) { throw new ILArgumentException("source arrray must be numeric!"); } m_dxPanel = panel; m_dxPanel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(m_dxPanel_GraphicsDeviceReset); m_cols = m_sourceArray.Dimensions[0]; m_rows = m_sourceArray.Dimensions[1]; m_Vertcount = m_rows * m_cols; m_primitiveType = PrimitiveType.TriangleList; m_vertexReady = false; m_indexReady = false; m_rowsInChunk = 1; // primitives per chunk m_primsInChunk = m_cols * 2 * m_rowsInChunk; updateClipping(); Configure(); }
/// <summary> /// draw all markers (graph / legend) /// </summary> /// <param name="marker">the marker object (for properties)</param> /// <param name="vertices">coords, interleaved</param> /// <param name="vertcount">number of coords, special: -1 for legend rendering</param> /// <remarks>This function is reused for both: drawing in world coords (graph) and drawing in /// screen coords (legend). Latter case requires vertcount to be -1, vertices must contain /// at least 2 float values than!</remarks> internal override void Draw(ILRenderProperties p, ILMarker marker, C4bV3f[] vertices, int startID, int vertcount) { if (vertcount > 0) { int inc = Math.Max(1, (vertcount / m_maxLabelsDrawn)); m_renderer.Begin(p); for (int i = 0; i < vertcount; i += inc) { #region draw textured points (slow version: textured quads) string expr = m_expression.Replace("\\index", i.ToString()); expr = expr.Replace("\\xvalue", vertices[i].XPosition.ToString(m_valueFormat)); expr = expr.Replace("\\yvalue", vertices[i].YPosition.ToString(m_valueFormat)); ILRenderQueue queue = m_interpreter.Transform(expr, m_font, marker.Color, m_renderer); #region determine size for markers in world coords (graph limits) float w, h; ILClippingData clip = m_panel.Limits; float s05x; float s05y; s05x = Math.Abs(queue.Size.Width * clip.WidthF / 2 / (m_panel.ClientSize.Width)); s05y = Math.Abs(queue.Size.Height * clip.HeightF / 2 / (m_panel.ClientSize.Height)); #endregion // this is slow! Todo: replace by point sprites! w = vertices[i].XPosition; h = vertices[i].YPosition; if (m_panel.ClipViewData && (w < clip.XMin || w > clip.XMax || h < clip.YMin || h > clip.YMax)) { continue; } m_renderer.Draw(queue, w - s05x, h + s05y, vertices[i].ZPosition, w + s05x, h - s05y, vertices[i].ZPosition, marker.Color); #endregion } m_renderer.End(p); } else if (vertcount == -1) { #region render for legend m_renderer.Begin(p); string expr = m_expression.Replace("\\index", "0"); expr = expr.Replace("\\xvalue", "0.2"); expr = expr.Replace("\\yvalue", "0.4"); ILRenderQueue queue = m_interpreter.Transform(expr, m_font, marker.Color, m_renderer); #region determine size for markers in SCREEN COORDS float w, h; ILClippingData clip = m_panel.Limits; float s05x; float s05y; s05x = Math.Abs(queue.Size.Width / 2); s05y = Math.Abs(queue.Size.Height / 2); #endregion // this is slow! Todo: replace by point sprites! w = vertices[0].XPosition; h = vertices[0].YPosition; m_renderer.Draw(queue, w - s05x, h - s05y, 0, w + s05x, h + s05y, 0, marker.Color); m_renderer.End(p); #endregion } }
/// <summary> /// Create new ILGraphCollection /// </summary> /// <param name="panel">Output panel </param> /// <param name="clippingData"></param> internal ILGraphCollection(IILCreationFactory vPainterFact) : base() { m_graphFact = vPainterFact; m_clippingData = new ILClippingData(); m_unsortedCache = new List <ILGraph>(); m_graphComparer = new ILGraphComparer(); }
internal ILOGLAxis (AxisNames name, ILClippingData clippingView, ILLayoutData layoutData, ILOGLPanel panel) : base (name,clippingView,layoutData,panel) { m_invalidated = true; panel.GraphicsDeviceCreated += new ILGraphicsDeviceCreatedEvent(initialize); panel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(configure); }
public ILOGLSurfaceGraph(ILOGLPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel, X, Y, Z, C, clippingContainer) { m_indexReady = false; m_vertexReady = false; }
public ILDXAxis(AxisNames name, ILClippingData clippingView, ILLayoutData layoutData, ILDXPanel panel) : base(name, clippingView, layoutData) { m_dxPanel = panel; m_dxPanel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(recreateVertexBuffer); m_dxPanel.GraphicsDeviceCreated += new ILGraphicsDeviceCreatedEvent(initialize); }
/// <summary> /// register clipping range object as source for range and its changes /// </summary> /// <param name="clipping">clipping data object</param> /// <returns>true, if the source was registered successfully</returns> public bool RegisterRangeSource(ILClippingData clipping) { if (object.Equals(clipping, null)) { return(false); } clipping.Changed += new ILClippingDataChangedEvent(clipping_Changed); return(true); }
internal ILOGLAxis(AxisNames name, ILClippingData clippingView, ILLayoutData layoutData, ILOGLPanel panel) : base(name, clippingView, layoutData, panel) { m_invalidated = true; panel.GraphicsDeviceCreated += new ILGraphicsDeviceCreatedEvent(initialize); panel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(configure); }
public ILDXGraphPlot2D(ILDXPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(sourceArray, clippingContainer) { m_dxPanel = panel; m_graphType = GraphType.Plot2D; m_dxPanel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(m_dxPanel_GraphicsDeviceReset); create(); }
/// <summary> /// construct new surface graph, provide all 3 coordinates /// </summary> /// <param name="panel">panel this graph is to be hosted in</param> /// <param name="X">X coordinates</param> /// <param name="Y">Y coordinates</param> /// <param name="Z">Z coordinates</param> /// <param name="C">Color values</param> /// <param name="clippingContainer"></param> public ILSurfaceGraph (ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base (panel, X,Y,Z,C, clippingContainer) { m_graphType = GraphType.Surf; m_wireLines.Width = 1; m_wireLines.Antialiasing = false; m_wireLines.Color = System.Drawing.Color.Blue; m_opacity = 0.84f; }
/// <summary> /// (internal) create new scene graph /// </summary> /// <param name="panel">panel hosting the scene</param> /// <param name="clipping">clipping data object, usually member of the panel</param> internal ILSceneGraph(ILPanel panel, ILClippingData clipping) : base(panel, clipping) { m_root = new ILSceneGraphRoot(panel); m_root.Invalidated += new EventHandler(m_root_Invalidated); m_root.SizeChanged += new EventHandler(m_root_SizeChanged); m_root.NodeAdded += new SceneGraphNodeHandler(m_root_NodeAdded); m_root.NodeRemoved += new SceneGraphNodeHandler(m_root_NodeRemoved); m_graphType = GraphType.SceneGraph; }
/// <summary> /// construct new surface graph, provide all 3 coordinates /// </summary> /// <param name="panel">panel this graph is to be hosted in</param> /// <param name="X">X coordinates</param> /// <param name="Y">Y coordinates</param> /// <param name="Z">Z coordinates</param> /// <param name="C">Color values</param> /// <param name="clippingContainer"></param> public ILSurfaceGraph(ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel, X, Y, Z, C, clippingContainer) { m_graphType = GraphType.Surf; m_wireLines.Width = 1; m_wireLines.Antialiasing = false; m_wireLines.Color = System.Drawing.Color.Blue; m_opacity = 0.84f; }
public ILImageSCGraph (ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z,ILBaseArray C, ILClippingData clippingContainer) : base (panel, X,Y,Z,C, clippingContainer) { m_cols = m_sourceArray.Dimensions[1]+1; m_rows = m_sourceArray.Dimensions[0]+1; m_Vertcount = m_rows * m_cols; // defaults m_zPosition = float.NegativeInfinity; }
public ILImageSCGraph(ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel, X, Y, Z, C, clippingContainer) { m_cols = m_sourceArray.Dimensions[1] + 1; m_rows = m_sourceArray.Dimensions[0] + 1; m_Vertcount = m_rows * m_cols; // defaults m_zPosition = float.NegativeInfinity; }
/// <summary> /// [internal] constructor - do not use this! Use ILPanel.Graphs.Add...() instead! /// </summary> /// <param name="panel">panel hosting the scene</param> /// <param name="XData">x data array</param> /// <param name="YData">y data array</param> /// <param name="clippingContainer">hosting panels clipping data</param> public ILPlot2DGraph(ILPanel panel, ILBaseArray XData, ILBaseArray YData, ILClippingData clippingContainer) : base(panel, clippingContainer) { if (!XData.IsVector) { throw new ILArgumentException("Plot2D: supplied data must be a real vector!"); } if (!YData.IsVector) { throw new ILArgumentException("Plot2D: XData and YData must be real vectors!"); } if (YData.Length != XData.Length) { throw new ILArgumentException("Plot2D: XData and YData must have the same length!"); } int pos = 0; ILArray <float> dataX, dataY; C4bV3f vert = new C4bV3f(); if (XData is ILArray <float> ) { dataX = (ILArray <float>)XData; } else { dataX = ILMath.tosingle(XData); } if (YData is ILArray <float> ) { dataY = (ILArray <float>)YData; } else { dataY = ILMath.tosingle(YData); } m_vertices = new C4bV3f[dataX.Length + 1]; m_vertexCount = m_vertices.Length; m_startID = m_vertexCount - 1; m_updateCount = 0; m_properties = new ILLineProperties(); m_properties.Color = Color.DarkBlue; m_properties.Changed += new EventHandler(m_properties_Changed); foreach (float val in dataX.Values) { vert.Position = new ILPoint3Df(val, dataY.GetValue(pos), 0); vert.Color = m_properties.Color; m_vertices[pos++] = vert; } m_marker = new ILMarker(panel); m_marker.Changed += new EventHandler(m_marker_Changed); m_graphType = GraphType.Plot2D; updateClipping(); }
public ILOGLImageSCGraph (ILOGLPanel panel, ILBaseArray X, ILBaseArray Y,ILBaseArray Z,ILBaseArray C, ILClippingData clippingContainer) : base(panel,X,Y,Z,C, clippingContainer) { m_panel = panel; m_localClipping.ZMax = 0; m_localClipping.ZMin = 0; m_localClipping.XMax = (float)m_cols+0.5f; m_localClipping.XMin = -0.5f; m_localClipping.YMax = (float)m_rows+0.5f; m_localClipping.YMin = -0.5f; }
/// <summary> /// create new ILAxisCollection /// </summary> public ILAxisCollection(ILClippingData clippingView, IILCreationFactory factory) { m_axes = new ILAxis[3]; m_axes[0] = factory.CreateAxis(AxisNames.XAxis, clippingView); m_axes[1] = factory.CreateAxis(AxisNames.YAxis, clippingView); m_axes[2] = factory.CreateAxis(AxisNames.ZAxis, clippingView); EventHandler handler = new EventHandler(Axis_Changed); m_axes[0].Changed += handler; m_axes[1].Changed += handler; m_axes[2].Changed += handler; }
public ILOGLImageSCGraph(ILOGLPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel, X, Y, Z, C, clippingContainer) { m_panel = panel; m_localClipping.ZMax = 0; m_localClipping.ZMin = 0; m_localClipping.XMax = (float)m_cols + 0.5f; m_localClipping.XMin = -0.5f; m_localClipping.YMax = (float)m_rows + 0.5f; m_localClipping.YMin = -0.5f; }
internal ILGraph(ILPanel panel, ILClippingData clippingContainer) { m_panel = panel; m_localClipping = new ILClippingData(); m_localClipping.Changed += new ILClippingDataChangedEvent(m_localClipping_Changed); m_globalClipping = clippingContainer; m_globalClipping.Changed += new ILClippingDataChangedEvent(m_globalClipping_Changed); // store incoming data arrays as ILArray<float> //m_sourceArray = sourceArray.CreateReference(); m_label = new ILLabel(m_panel); m_label.Color = Color.Black; m_label.Changed += new EventHandler(m_label_Changed); m_isReady = false; }
/// <summary> /// Create Axis (device dependent) /// </summary> /// <param name="name">specfies axis name (X,Y,ZAxis)</param> /// <param name="clippingView">the global clipping view object for the axis</param> /// <param name="parameters">user defined parameters (implementation dependent)</param> /// <returns>ILAXis object</returns> public ILAxis CreateAxis(AxisNames name, ILClippingData clippingView, params object[] parameters) { switch (name) { case AxisNames.XAxis: return(new ILOGLXAxis(clippingView, m_layoutData, this)); break; case AxisNames.YAxis: return(new ILOGLYAxis(clippingView, m_layoutData, this)); break; default: return(new ILOGLZAxis(clippingView, m_layoutData, this)); break; } }
public ILDXGraphSurf3D ( ILDXPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(sourceArray,clippingContainer) { m_localClipping = new ILClippingData(); if (!sourceArray.IsMatrix) throw new ILArgumentException ("source arrray must be matrix!"); if (!sourceArray.IsNumeric) throw new ILArgumentException ("source arrray must be numeric!"); m_dxPanel = panel; m_dxPanel.GraphicsDeviceReset += new ILGraphicsDeviceResetEvent(m_dxPanel_GraphicsDeviceReset); m_cols = m_sourceArray.Dimensions[0]; m_rows = m_sourceArray.Dimensions[1]; m_Vertcount = m_rows * m_cols; m_primitiveType = PrimitiveType.TriangleList; m_vertexReady = false; m_indexReady = false; m_rowsInChunk = 1; // primitives per chunk m_primsInChunk = m_cols * 2 * m_rowsInChunk; updateClipping(); Configure(); }
/// <summary> /// [internal] constructor - do not use this! Use ILPanel.Graphs.Add...() instead! /// </summary> /// <param name="panel">panel hosting the scene</param> /// <param name="sourceArray">data array</param> /// <param name="clippingContainer">hosting panels clipping data</param> public ILPlot2DGraph(ILPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(panel, clippingContainer) { if (object.Equals(sourceArray, null) || !sourceArray.IsVector || !sourceArray.IsNumeric) { throw new ILArgumentException("Plot2D: supplied data must be numeric (real valued) vector!"); } int pos = 0; ILArray <float> data; C4bV3f vert = new C4bV3f(); if (sourceArray is ILArray <float> ) { data = (ILArray <float>)sourceArray; } else { data = ILMath.tosingle(sourceArray); } m_vertices = new C4bV3f[data.Length + 1]; m_vertexCount = m_vertices.Length; m_updateCount = 0; m_startID = 0; m_properties = new ILLineProperties(); m_properties.Color = Color.DarkBlue; m_properties.Changed += new EventHandler(m_properties_Changed); foreach (float val in data.Values) { vert.Position = new ILPoint3Df(pos, val, 0); vert.Color = Color.Red; m_vertices[pos++] = vert; } m_marker = new ILMarker(panel); m_marker.Changed += new EventHandler(m_properties_Changed); m_graphType = GraphType.Plot2D; m_localClipping.Set(new ILPoint3Df(0, data.MinValue, 0), new ILPoint3Df(data.Length - 1, data.MaxValue, 0)); }
internal ILOGLPlot2DGraph ( ILPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(panel, sourceArray,clippingContainer) { }
/// <summary> /// create device dependent axis object (Direct3D) /// </summary> /// <param name="name">axis type: XAxis,YAxis,ZAxis</param> /// <param name="parameters">not used</param> /// <returns>ILDXAxis object for use with ILDXPanel (Direct3D)</returns> public override ILAxis CreateAxis(AxisNames name, ILClippingData clippingView, params object[] parameters) { return(new ILDXAxis(name, clippingView, m_layoutData, this)); }
/// <summary> /// Create Axis (device dependent) /// </summary> /// <param name="name">specfies axis name (X,Y,ZAxis)</param> /// <param name="clippingView">the global clipping view object for the axis</param> /// <param name="parameters">user defined parameters (implementation dependent)</param> /// <returns>ILAXis object</returns> public ILAxis CreateAxis(AxisNames name, ILClippingData clippingView, params object[] parameters) { switch (name) { case AxisNames.XAxis: return new ILOGLXAxis(clippingView, m_layoutData, this); break; case AxisNames.YAxis: return new ILOGLYAxis(clippingView, m_layoutData, this); break; default: return new ILOGLZAxis(clippingView, m_layoutData, this); break; } }
/// <summary> /// (internal) create new scene graph /// </summary> /// <param name="panel">panel hosting the scene</param> /// <param name="clipping">clipping data object, usually member of the panel</param> internal ILSceneGraph (ILPanel panel, ILClippingData clipping) : base(panel,clipping) { m_root = new ILSceneGraphRoot(panel); m_root.Invalidated += new EventHandler(m_root_Invalidated); m_root.SizeChanged += new EventHandler(m_root_SizeChanged); m_root.NodeAdded += new SceneGraphNodeHandler(m_root_NodeAdded); m_root.NodeRemoved += new SceneGraphNodeHandler(m_root_NodeRemoved); m_graphType = GraphType.SceneGraph; }
internal ILOGLPlot2DGraph(ILPanel panel, ILBaseArray sourceArray, ILClippingData clippingContainer) : base(panel, sourceArray, clippingContainer) { }
internal ILOGLPlot2DGraph ( ILPanel panel, ILBaseArray xData, ILBaseArray yData, ILClippingData clippingContainer) : base(panel, xData, yData, clippingContainer) { }
/// <summary> /// create device dependent axis object (Direct3D) /// </summary> /// <param name="name">axis type: XAxis,YAxis,ZAxis</param> /// <param name="parameters">not used</param> /// <returns>ILDXAxis object for use with ILDXPanel (Direct3D)</returns> public override ILAxis CreateAxis(AxisNames name, ILClippingData clippingView, params object[] parameters) { return new ILDXAxis(name,clippingView,m_layoutData,this); }
/// <summary> /// Constructor - this class should be created only from within ILNumerics assemblies! /// </summary> /// <param name="clippingView">panels clipping view</param> /// <param name="layout">instance with layout informations</param> /// <param name="panel">the panel containing the axis</param> internal ILOGLZAxis (ILClippingData clippingView, ILLayoutData layout, ILOGLPanel panel) : base (AxisNames.ZAxis,clippingView,layout,panel) { }
/// <summary> /// construct new filled graph /// </summary> /// <param name="panel">panel hosting the graph</param> /// <param name="X">X coords, if null, range 0..[cols of Z] will be created</param> /// <param name="Y">Y coords, if null, range 0..[rows of Z] will be created</param> /// <param name="Z">Z coords (heights)</param> /// <param name="C">Colors for Z</param> /// <param name="clippingContainer">gloabal limits of panel</param> public ILFilledGraph (ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base (panel, clippingContainer) { #region argument checking m_localClipping.EventingSuspend(); if (Z == null || !Z.IsMatrix) throw new ILArgumentException ("ILFilledGraph: Z must be matrix!"); if (!Z.IsNumeric) throw new ILArgumentException ("ILFilledGraph: Z must be numeric!"); m_sourceArray = ILMath.tosingle(Z); m_rows = m_sourceArray.Dimensions[0]; m_cols = m_sourceArray.Dimensions[1]; ILArray<float> tmp; if (!object.Equals (X,null) && !X.IsEmpty) { if (!X.IsMatrix || !X.IsNumeric) { throw new ILArgumentException ("ILFilledGraph: X must be numeric matrix!"); } if (X.Dimensions.IsSameSize(Z.Dimensions)) { tmp = ILMath.tosingle(X); tmp.ExportValues(ref m_xCoords); m_localClipping.XMax = tmp.MaxValue; m_localClipping.XMin = tmp.MinValue; } else { throw new ILArgumentException ("ILFilledGraph: X must be of same size than Z!"); } } else { ILMath.tosingle(ILMath.repmat(ILMath.counter(0.0,1.0,1,m_cols),m_rows,1)).ExportValues(ref m_xCoords); m_localClipping.XMin = 0; m_localClipping.XMax = m_cols-1; } if (!object.Equals(Y,null) && !Y.IsEmpty) { if (!Y.IsMatrix || !Y.IsNumeric) { throw new ILArgumentException ("ILFilledGraph: Y must be numeric matrix!"); } if (Y.Dimensions.IsSameSize(Z.Dimensions)) { tmp = ILMath.tosingle(Y); tmp.ExportValues(ref m_yCoords); m_localClipping.YMax = tmp.MaxValue; m_localClipping.YMin = tmp.MinValue; } else { throw new ILArgumentException ("ILFilledGraph: Y must be same size than Z!"); } } else { ILMath.tosingle(ILMath.repmat(ILMath.counter(0.0,1.0,m_rows,1),1,m_cols)).ExportValues(ref m_yCoords); m_localClipping.YMax = m_rows-1; m_localClipping.YMin = 0; } if (object.Equals(C,null) || C.IsEmpty) { m_colors = null; } else { m_colors = ILMath.tosingle(C); } m_localClipping.ZMax = m_sourceArray.MaxValue; m_localClipping.ZMin = m_sourceArray.MinValue; #endregion m_Vertcount = m_rows * m_cols; m_vertexReady = false; m_indexReady = false; // default view properties m_opacity = 1.0f; m_wireLines = new ILLineProperties(); m_wireLines.Changed += new EventHandler(m_wireLines_Changed); m_filled = true; m_localClipping.EventingResume(); }
/// <summary> /// register clipping range object as source for range and its changes /// </summary> /// <param name="clipping">clipping data object</param> /// <returns>true, if the source was registered successfully</returns> public bool RegisterRangeSource(ILClippingData clipping) { if (object.Equals(clipping,null)) return false; clipping.Changed += new ILClippingDataChangedEvent(clipping_Changed); return true; }
internal override void Draw(ILRenderProperties p, ILMarker marker, C4bV3f[] vertices, int startID, int vertCount) { if (vertCount == 0 && vertCount != -1) { return; } string texKey = Hash(); ILTextureData texData; if (!m_panel.TextureManager.Exists(texKey)) { storeBitmap(m_bitmap); } texData = m_panel.TextureManager.GetTextureItem(texKey, true); System.Diagnostics.Debug.Assert(texData != null, "The texture key for the bitmap was expected to exist in texture storage, but it was not found!"); // prepare for plotting GL.Color3(marker.Color); GL.PushAttrib(AttribMask.AllAttribBits); GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); GL.Disable(EnableCap.DepthTest); RectangleF rectF = texData.TextureRectangle; float w, h; if (vertCount > 0) { #region draw textured points (slow version: textured quads) #region determine size for markers in world coords (graph limits) ILClippingData clip = m_panel.Limits; float s05x; float s05y; //if (m_marker.) s05x = Math.Abs(marker.Size * clip.WidthF / (m_panel.ClientSize.Width)); s05y = Math.Abs(marker.Size * clip.HeightF / (m_panel.ClientSize.Height)); #endregion // draw all markers using quads. // this is slow! Todo: replace by point sprites! GL.Begin(BeginMode.Quads); for (int i = 0; i < vertCount; i++) { w = vertices[i].Position.X; h = vertices[i].Position.Y; if (m_panel.ClipViewData && (w < clip.XMin || w > clip.XMax || h < clip.YMin || h > clip.YMax)) { continue; } w -= s05x; h -= s05y; GL.TexCoord2(rectF.Left, rectF.Bottom); GL.Vertex2(w, h); // ul GL.TexCoord2(rectF.Left, rectF.Top); GL.Vertex2(w, h + 2 * s05y); // bl w += 2 * s05x; GL.TexCoord2(rectF.Right, rectF.Top); GL.Vertex2(w, h + 2 * s05y); // br GL.TexCoord2(rectF.Right, rectF.Bottom); GL.Vertex2(w, h); // tr } GL.End(); #endregion } else if (vertCount == -1) { #region render to legend // draw all markers using quads. // this is slow! Todo: replace by point sprites! GL.Begin(BeginMode.Quads); w = vertices[0].XPosition - m_bitmap.Width / 2; h = vertices[0].YPosition - m_bitmap.Height / 2; GL.TexCoord2(rectF.Left, rectF.Top); GL.Vertex2(w, h); // ul GL.TexCoord2(rectF.Left, rectF.Bottom); GL.Vertex2(w, h + m_bitmap.Height); // bl w += m_bitmap.Width; GL.TexCoord2(rectF.Right, rectF.Bottom); GL.Vertex2(w, h + m_bitmap.Height); // br GL.TexCoord2(rectF.Right, rectF.Top); GL.Vertex2(w, h); // tr GL.End(); #endregion } GL.PopAttrib(); }
/// <summary> /// construct new filled graph /// </summary> /// <param name="panel">panel hosting the graph</param> /// <param name="X">X coords, if null, range 0..[cols of Z] will be created</param> /// <param name="Y">Y coords, if null, range 0..[rows of Z] will be created</param> /// <param name="Z">Z coords (heights)</param> /// <param name="C">Colors for Z</param> /// <param name="clippingContainer">gloabal limits of panel</param> public ILFilledGraph(ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel, clippingContainer) { #region argument checking m_localClipping.EventingSuspend(); if (Z == null || !Z.IsMatrix) { throw new ILArgumentException("ILFilledGraph: Z must be matrix!"); } if (!Z.IsNumeric) { throw new ILArgumentException("ILFilledGraph: Z must be numeric!"); } m_sourceArray = ILMath.tosingle(Z); m_rows = m_sourceArray.Dimensions[0]; m_cols = m_sourceArray.Dimensions[1]; ILArray <float> tmp; if (!object.Equals(X, null) && !X.IsEmpty) { if (!X.IsMatrix || !X.IsNumeric) { throw new ILArgumentException("ILFilledGraph: X must be numeric matrix!"); } if (X.Dimensions.IsSameSize(Z.Dimensions)) { tmp = ILMath.tosingle(X); tmp.ExportValues(ref m_xCoords); m_localClipping.XMax = tmp.MaxValue; m_localClipping.XMin = tmp.MinValue; } else { throw new ILArgumentException("ILFilledGraph: X must be of same size than Z!"); } } else { ILMath.tosingle(ILMath.repmat(ILMath.counter(0.0, 1.0, 1, m_cols), m_rows, 1)).ExportValues(ref m_xCoords); m_localClipping.XMin = 0; m_localClipping.XMax = m_cols - 1; } if (!object.Equals(Y, null) && !Y.IsEmpty) { if (!Y.IsMatrix || !Y.IsNumeric) { throw new ILArgumentException("ILFilledGraph: Y must be numeric matrix!"); } if (Y.Dimensions.IsSameSize(Z.Dimensions)) { tmp = ILMath.tosingle(Y); tmp.ExportValues(ref m_yCoords); m_localClipping.YMax = tmp.MaxValue; m_localClipping.YMin = tmp.MinValue; } else { throw new ILArgumentException("ILFilledGraph: Y must be same size than Z!"); } } else { ILMath.tosingle(ILMath.repmat(ILMath.counter(0.0, 1.0, m_rows, 1), 1, m_cols)).ExportValues(ref m_yCoords); m_localClipping.YMax = m_rows - 1; m_localClipping.YMin = 0; } if (object.Equals(C, null) || C.IsEmpty) { m_colors = null; } else { m_colors = ILMath.tosingle(C); } m_localClipping.ZMax = m_sourceArray.MaxValue; m_localClipping.ZMin = m_sourceArray.MinValue; #endregion m_Vertcount = m_rows * m_cols; m_vertexReady = false; m_indexReady = false; // default view properties m_opacity = 1.0f; m_wireLines = new ILLineProperties(); m_wireLines.Changed += new EventHandler(m_wireLines_Changed); m_filled = true; m_localClipping.EventingResume(); }
public ILOGLSurfaceGraph ( ILOGLPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILBaseArray C, ILClippingData clippingContainer) : base(panel,X,Y,Z,C,clippingContainer) { m_indexReady = false; m_vertexReady = false; }
/// <summary> /// Constructor - this class should be created only from within ILNumerics assemblies! /// </summary> /// <param name="clippingView">panels clipping view</param> /// <param name="layoutData">instance with layout informations</param> /// <param name="panel">the panel containing the axis</param> internal ILOGLYAxis(ILClippingData clippingView, ILLayoutData layoutData, ILOGLPanel panel) : base(AxisNames.YAxis, clippingView, layoutData, panel) { }
/// <summary> /// create new ILAxisCollection /// </summary> public ILAxisCollection(ILClippingData clippingView, IILCreationFactory factory) { m_axes = new ILAxis[3]; m_axes[0] = factory.CreateAxis(AxisNames.XAxis,clippingView); m_axes[1] = factory.CreateAxis(AxisNames.YAxis,clippingView); m_axes[2] = factory.CreateAxis(AxisNames.ZAxis,clippingView); EventHandler handler = new EventHandler(Axis_Changed); m_axes[0].Changed += handler; m_axes[1].Changed += handler; m_axes[2].Changed += handler; }
internal override void Draw(ILRenderProperties p, ILMarker marker, C4bV3f[] vertices, int startID, int vertCount) { // some implementations need to know we are drawing in // screen coords, vertcount give the signal: -1 if (vertCount == 0 || vertCount < -1) { return; } if (m_style != MarkerStyle.None) { if (m_style == MarkerStyle.Dot || m_style == MarkerStyle.Square) { SetupMarkerStyle(marker); unsafe { fixed(C4bV3f *pVertArr = vertices) { //GL.TexCoord2(0.5,0.5); GL.InterleavedArrays(InterleavedArrayFormat.V2f, 0, (IntPtr)pVertArr); GL.DrawArrays(BeginMode.Points, 0, Math.Abs(vertCount)); } } } else { #region draw textured points (slow version: textured quads) string markerTexKey = Hash(); ILTextureData texData; if (!m_panel.TextureManager.Exists(markerTexKey)) { CacheMarkerBitmap(); } texData = m_panel.TextureManager.GetTextureItem(markerTexKey, true); System.Diagnostics.Debug.Assert(texData != null, "The texture for marker was expected to exist in texture storage, but it was not found!"); // prepare for plotting GL.Color3(marker.Color); GL.PushAttrib(AttribMask.AllAttribBits); GL.Enable(EnableCap.Texture2D); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha); GL.Disable(EnableCap.DepthTest); RectangleF rectF = texData.TextureRectangle; float w, h; if (vertCount > 0) { #region determine size for markers in world coords (graph limits) ILClippingData clip = m_panel.Limits; float s05x; float s05y; //if (m_marker.) s05x = Math.Abs(marker.Size * clip.WidthF / (m_panel.ClientSize.Width)); s05y = Math.Abs(marker.Size * clip.HeightF / (m_panel.ClientSize.Height)); #endregion // draw all markers using quads. // this is slow! Todo: replace by point sprites! GL.Begin(BeginMode.Quads); for (int i = 0; i < vertCount; i++) { w = vertices[i].XPosition; h = vertices[i].YPosition; if (m_panel.ClipViewData && (w < clip.XMin || w > clip.XMax || h < clip.YMin || h > clip.YMax)) { continue; } w -= s05x; h -= s05y; GL.TexCoord2(rectF.Left, rectF.Bottom); GL.Vertex2(w, h); // ul GL.TexCoord2(rectF.Left, rectF.Top); GL.Vertex2(w, h + 2 * s05y); // bl w += 2 * s05x; GL.TexCoord2(rectF.Right, rectF.Top); GL.Vertex2(w, h + 2 * s05y); // br GL.TexCoord2(rectF.Right, rectF.Bottom); GL.Vertex2(w, h); // tr } GL.End(); } else if (vertCount == -1) { GL.Begin(BeginMode.Quads); w = vertices[0].XPosition - marker.Size / 2; h = vertices[0].XPosition - marker.Size / 2; GL.TexCoord2(rectF.Left, rectF.Top); GL.Vertex2(w, h); // ul GL.TexCoord2(rectF.Left, rectF.Bottom); GL.Vertex2(w, h + marker.Size); // bl w += marker.Size; GL.TexCoord2(rectF.Right, rectF.Bottom); GL.Vertex2(w, h + marker.Size); // br GL.TexCoord2(rectF.Right, rectF.Top); GL.Vertex2(w, h); // tr GL.End(); } GL.PopAttrib(); #endregion } } }
internal ILOGLPlot2DGraph(ILPanel panel, ILBaseArray xData, ILBaseArray yData, ILClippingData clippingContainer) : base(panel, xData, yData, clippingContainer) { }