/// <summary> /// Calculates the cache bitmap to draw the function. /// </summary> public override void Calc(CalcThread t) { int X, Y; if (Recalc) { Color c; double dzinv = 1 / t.dz; for (Y = 0; Y < t.h; Y++) { if (t.stop) { break; } for (X = 0; X < t.w; X++) { if (t.stop) { break; } try { c = f(t.Graph.Model.x0 + X * t.dx, t.Graph.Model.y0 + Y * t.dy); } catch (ThreadAbortException ex) { throw ex; } catch { c = Color.White; } lock (this) { cache.SetPixel(X, t.h - Y - 1, c); } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Creates a deep copy of the CalcThread. /// </summary> public CalcThread Clone(GraphControl graph) { CalcThread t = new CalcThread(graph); t.CopyFrom(this); return(t); }
/// <summary> /// Caluclates the items <see cref="cache">cache</see> field to draw the function. /// </summary> public override void Calc(CalcThread t) { const float BIG = 1e20F; int X; float F; if (Recalc) { for (X = 0; X < t.w; X++) { if (t.stop) { break; } lock (this) { try { cache[X].X = X; F = (float)(t.h - 1 - (f(t.Graph.Model.x0 + X * t.dx) - t.Graph.Model.y0) / t.dy); if (float.IsInfinity(F) || float.IsNaN(F) || Math.Abs(F) > BIG) { F = 0; } cache[X].Y = F; } catch (ThreadAbortException ex) { throw ex; } catch { cache[X].Y = 0; } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Copies from another GraphControl. /// </summary> /// <param name="graph">The control to copy from.</param> public void CopyFrom(GraphControl graph) { sx = graph.sx; sy = graph.sy; sw = graph.sw; sh = graph.sh; zoomIn = graph.zoomIn; fx = graph.fx; fy = graph.fy; fw = graph.fw; fh = graph.fh; fd = graph.fd; Model = (GraphModel)graph.Model.Clone(); Calc = (CalcThread)graph.Calc.Clone(this); Calc.Step += new CalcStepEventHandler(CalcStep); }
/// <summary> /// Draws the DataItem from the previously calculated cache. /// </summary> /// <param name="g">The Graphics object to draw to.</param> /// <param name="t">The calculating thread.</param> public override void Draw(Graphics g, CalcThread t) { lock (this) { if (cache != null) { g.DrawImage(cache, 0, 0, t.w, t.h); } } }
/// <summary> /// Draws the function. /// </summary> public override void Draw(Graphics g, CalcThread t) { t.pen.Color = color; t.pen.DashStyle = lineStyle; t.pen.Width = lineWidth; lock (this) { try { g.DrawLines(t.pen, cache); } catch {} } }
/// <summary> /// The constructor of the control. /// </summary> public GraphControl() { Model = new GraphModel(); Model.Invalidated += new GraphModel.InvalidateEventHandler(ModelInvalidated); this.Cursor = Cursors.Cross; this.BackColor = Color.White; sx = sy = -1; sw = sh = 0; zoomIn = false; zscale.img = null; Calc = new CalcThread(this); Calc.Step += new CalcStepEventHandler(CalcStep); }
/// <summary> /// Initiates the calculation of the function cache bitmap. /// </summary> public override void StartCalc(CalcThread t) { if (Modified) { Modified = false; Recalc = true; lock (this) { cache = new Bitmap(t.w, t.h, PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(cache); g.Clear(Color.White); } t.maxprogress += t.h; } }
private void CalcStep(CalcThread t) { if (Bar != null) { Bar.Value = t.progress; } t.nt++; if (t.nt >= 20) { Model.Invalidate(); t.nt = 0; } }
/// <summary> /// Initiates the background calculation of the <see cref="cache">cache</see> field. /// </summary> public override void StartCalc(CalcThread t) { if (Modified) { Modified = false; Recalc = true; lock (this) { cache = new PointF[t.w]; for (int x = 0; x < t.w; x++) { cache[x].X = x; cache[x].Y = t.h + 10; } } t.maxprogress += t.w; } }
/// <summary> /// Calculates the cache bitmap to draw the function. /// </summary> public override void Calc(CalcThread t) { int X, Y; double fx, dzinv; Color c; if (Recalc) { dzinv = 1 / t.dz; for (Y = 0; Y < t.h; Y++) { if (t.stop) { break; } for (X = 0; X < t.w; X++) { if (t.stop) { break; } try { fx = (f(t.Graph.Model.x0 + X * t.dx, t.Graph.Model.y0 + Y * t.dy) - t.Graph.Model.z0) * dzinv; } catch (ThreadAbortException ex) { throw ex; } catch { fx = 0; } if (rgb) { c = RGBColor(fx); } else { c = FColor(fx); } lock (this) { cache.SetPixel(X, t.h - Y - 1, c); } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Draws the function. /// </summary> public override void Draw(Graphics g, CalcThread t) { t.pen.Color = color; t.pen.DashStyle = lineStyle; t.pen.Width = lineWidth; lock(this) { try { g.DrawLines(t.pen, cache); } catch {} } }
/// <summary> /// Initiates the background calculation of the <see cref="cache">cache</see> field. /// </summary> public override void StartCalc(CalcThread t) { if (Modified) { Modified = false; Recalc = true; lock(this) { cache = new PointF[t.w]; for (int x = 0; x < t.w; x++) { cache[x].X = x; cache[x].Y = t.h+10; } } t.maxprogress += t.w; } }
/// <summary> /// Caluclates the items <see cref="cache">cache</see> field to draw the function. /// </summary> public override void Calc(CalcThread t) { const float BIG = 1e20F; int X; float F; if (Recalc) { for (X = 0; X < t.w; X++) { if (t.stop) break; lock(this) { try { cache[X].X = X; F = (float)(t.h - 1 - (f(t.Graph.Model.x0 + X*t.dx) - t.Graph.Model.y0)/t.dy); if (float.IsInfinity(F) || float.IsNaN(F) || Math.Abs(F) > BIG) F = 0; cache[X].Y = F; } catch (ThreadAbortException ex) { throw ex; } catch { cache[X].Y = 0; } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Draws the <c>PlotItem</c>. /// </summary> /// <param name="g">A graphics object that is used for drawing.</param> /// <param name="t">The <see cref="CalcThread">CalcThread</see> that calculated the items data.</param> public virtual void Draw(Graphics g, CalcThread t) {}
/// <summary> /// Used internally. Called to initialize the process of calculating the items data. /// </summary> public virtual void StartCalc(CalcThread t) {Modified = false; Recalc = false;}
/// <summary> /// Used internally. Called to initialize the process of calculating the items data. /// </summary> public virtual void StartCalc(CalcThread t) { Modified = false; Recalc = false; }
/// <summary> /// Calculates the image-cache for the data in the background. /// </summary> /// <param name="t">The calculating thread.</param> public override void Calc(CalcThread t) { t.pen.Color = color; PointF[] points = new PointF[Length]; Graphics g; lock (this) { g = Graphics.FromImage(cache); } float X, Y, DX, DY; for (int i = 0; i < Length; i++) { if (t.stop) break; try { X = (float)((x[i] - t.Graph.Model.x0)/t.dx); Y = t.h - 1 - (float)((y[i] - t.Graph.Model.y0)/t.dy); DX = (float)(dx[i]/t.dx)/2; DY = (float)(dy[i]/t.dy)/2; points[i].X = X; points[i].Y = Y; if (marks) { lock (this) { t.pen.DashStyle = DashStyle.Solid; t.pen.Width = lineWidth; if (DX < 3) DX = 5; else { g.DrawLine(t.pen, X-DX, Y-3, X-DX, Y+3); g.DrawLine(t.pen, X+DX, Y-3, X+DX, Y+3); } if (DY < 3) DY = 5; else { g.DrawLine(t.pen, X-3, Y-DY, X+3, Y-DY); g.DrawLine(t.pen, X-3, Y+DY, X+3, Y+DY); } g.DrawLine(t.pen, X-DX, Y, X+DX, Y); g.DrawLine(t.pen, X, Y-DY, X, Y+DY); } } } catch (System.Threading.ThreadAbortException ex) { throw ex; } catch {} t.OnStep(); } if (lines && !t.stop) { t.pen.DashStyle = lineStyle; t.pen.Width = lineWidth; try { lock (this) { g.DrawLines(t.pen, points); } } catch (System.Threading.ThreadAbortException ex) { throw ex; } catch {} } Recalc = t.stop; }
/// <summary> /// Copies from another CalcThread using a deep copy. /// </summary> public void CopyFrom(CalcThread t) { w = t.w; h = t.h; dx = t.dx; dy = t.dy; dz = t.dz; //Step = t.Step; }
/// <summary> /// Draws the <c>PlotItem</c>. /// </summary> /// <param name="g">A graphics object that is used for drawing.</param> /// <param name="t">The <see cref="CalcThread">CalcThread</see> that calculated the items data.</param> public virtual void Draw(Graphics g, CalcThread t) { }
/// <summary> /// Calculates the cache bitmap to draw the function. /// </summary> public override void Calc(CalcThread t) { int X, Y; double fx, dzinv; Color c; if (Recalc) { dzinv = 1/t.dz; for (Y = 0; Y < t.h; Y++) { if (t.stop) break; for (X = 0; X < t.w; X++) { if (t.stop) break; try { fx = (f(t.Graph.Model.x0 + X*t.dx, t.Graph.Model.y0 + Y*t.dy) - t.Graph.Model.z0)*dzinv; } catch (ThreadAbortException ex) { throw ex; } catch { fx = 0; } if (rgb) c = RGBColor(fx); else c = FColor(fx); lock(this) { cache.SetPixel(X, t.h - Y - 1, c); } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Copies from another CalcThread using a deep copy. /// </summary> public void CopyFrom(CalcThread t) { w = t.w; h = t.h; dx = t.dx; dy = t.dy; dz = t.dz; //Step = t.Step; }
/// <summary> /// Calculates the image-cache for the data in the background. /// </summary> /// <param name="t">The calculating thread.</param> public override void Calc(CalcThread t) { t.pen.Color = color; PointF[] points = new PointF[Length]; Graphics g; lock (this) { g = Graphics.FromImage(cache); } float X, Y, DX, DY; for (int i = 0; i < Length; i++) { if (t.stop) { break; } try { X = (float)((x[i] - t.Graph.Model.x0) / t.dx); Y = t.h - 1 - (float)((y[i] - t.Graph.Model.y0) / t.dy); DX = (float)(dx[i] / t.dx) / 2; DY = (float)(dy[i] / t.dy) / 2; points[i].X = X; points[i].Y = Y; if (marks) { lock (this) { t.pen.DashStyle = DashStyle.Solid; t.pen.Width = lineWidth; if (DX < 3) { DX = 5; } else { g.DrawLine(t.pen, X - DX, Y - 3, X - DX, Y + 3); g.DrawLine(t.pen, X + DX, Y - 3, X + DX, Y + 3); } if (DY < 3) { DY = 5; } else { g.DrawLine(t.pen, X - 3, Y - DY, X + 3, Y - DY); g.DrawLine(t.pen, X - 3, Y + DY, X + 3, Y + DY); } g.DrawLine(t.pen, X - DX, Y, X + DX, Y); g.DrawLine(t.pen, X, Y - DY, X, Y + DY); } } } catch (System.Threading.ThreadAbortException ex) { throw ex; } catch {} t.OnStep(); } if (lines && !t.stop) { t.pen.DashStyle = lineStyle; t.pen.Width = lineWidth; try { lock (this) { g.DrawLines(t.pen, points); } } catch (System.Threading.ThreadAbortException ex) { throw ex; } catch {} } Recalc = t.stop; }
/// <summary> /// Used internally. Called by the calculation thread. Calculates the items data in the background. /// </summary> /// <param name="t"></param> public virtual void Calc(CalcThread t) {Recalc = false;}
/// <summary> /// Used internally. Called by the calculation thread. Calculates the items data in the background. /// </summary> /// <param name="t"></param> public virtual void Calc(CalcThread t) { Recalc = false; }
/// <summary> /// Draws the DataItem from the previously calculated cache. /// </summary> /// <param name="g">The Graphics object to draw to.</param> /// <param name="t">The calculating thread.</param> public override void Draw(Graphics g, CalcThread t) { lock (this) { if (cache != null) { g.DrawImage(cache, 0, 0, t.w, t.h); } } }
/// <summary> /// Calculates the cache bitmap to draw the function. /// </summary> public override void Calc(CalcThread t) { int X, Y; if (Recalc) { Color c; double dzinv = 1/t.dz; for (Y = 0; Y < t.h; Y++) { if (t.stop) break; for (X = 0; X < t.w; X++) { if (t.stop) break; try { c = f(t.Graph.Model.x0 + X*t.dx, t.Graph.Model.y0 + Y*t.dy); } catch (ThreadAbortException ex) { throw ex; } catch { c = Color.White; } lock(this) { cache.SetPixel(X, t.h - Y - 1, c); } } t.OnStep(); } Recalc = t.stop; } }
/// <summary> /// Initiates calculation of the DataItem. /// </summary> public override void StartCalc(CalcThread t) { if (Modified) { Modified = false; Recalc = true; lock(this) { cache = new Bitmap(t.w, t.h, PixelFormat.Format32bppArgb); Graphics g = Graphics.FromImage(cache); g.Clear(Color.FromArgb(0, Color.White)); } t.maxprogress += Length/1000; } }
/// <summary> /// Creates a deep copy of the CalcThread. /// </summary> public CalcThread Clone(GraphControl graph) { CalcThread t = new CalcThread(graph); t.CopyFrom(this); return t; }