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 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;
}
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)
{
}
