/// <summary> /// Draws the different types of shapes. /// </summary> private void DrawStaticShapes() { // Init some size vars int w = this.writeableBmp.PixelWidth - 2; int h = this.writeableBmp.PixelHeight - 2; int w3rd = w / 3; int h3rd = h / 3; int w6th = w3rd >> 1; int h6th = h3rd >> 1; // Clear writeableBmp.Clear(); // Draw some points for (int i = 0; i < 200; i++) { writeableBmp.SetPixel(rand.Next(w3rd), rand.Next(h3rd), GetRandomColor()); } // Draw Standard shapes writeableBmp.DrawLine(rand.Next(w3rd, w3rd * 2), rand.Next(h3rd), rand.Next(w3rd, w3rd * 2), rand.Next(h3rd), GetRandomColor()); writeableBmp.DrawTriangle(rand.Next(w3rd * 2, w - w6th), rand.Next(h6th), rand.Next(w3rd * 2, w), rand.Next(h6th, h3rd), rand.Next(w - w6th, w), rand.Next(h3rd), GetRandomColor()); writeableBmp.DrawQuad(rand.Next(0, w6th), rand.Next(h3rd, h3rd + h6th), rand.Next(w6th, w3rd), rand.Next(h3rd, h3rd + h6th), rand.Next(w6th, w3rd), rand.Next(h3rd + h6th, 2 * h3rd), rand.Next(0, w6th), rand.Next(h3rd + h6th, 2 * h3rd), GetRandomColor()); writeableBmp.DrawRectangle(rand.Next(w3rd, w3rd + w6th), rand.Next(h3rd, h3rd + h6th), rand.Next(w3rd + w6th, w3rd * 2), rand.Next(h3rd + h6th, 2 * h3rd), GetRandomColor()); // Random polyline int[] p = new int[rand.Next(7, 10) * 2]; for (int j = 0; j < p.Length; j += 2) { p[j] = rand.Next(w3rd * 2, w); p[j + 1] = rand.Next(h3rd, 2 * h3rd); } writeableBmp.DrawPolyline(p, GetRandomColor()); // Random closed polyline p = new int[rand.Next(6, 9) * 2]; for (int j = 0; j < p.Length - 2; j += 2) { p[j] = rand.Next(w3rd); p[j + 1] = rand.Next(2 * h3rd, h); } p[p.Length - 2] = p[0]; p[p.Length - 1] = p[1]; writeableBmp.DrawPolyline(p, GetRandomColor()); // Ellipses writeableBmp.DrawEllipse(rand.Next(w3rd, w3rd + w6th), rand.Next(h3rd * 2, h - h6th), rand.Next(w3rd + w6th, w3rd * 2), rand.Next(h - h6th, h), GetRandomColor()); writeableBmp.DrawEllipseCentered(w - w6th, h - h6th, w6th >> 1, h6th >> 1, GetRandomColor()); // Draw Grid writeableBmp.DrawLine(0, h3rd, w, h3rd, Colors.Black); writeableBmp.DrawLine(0, 2 * h3rd, w, 2 * h3rd, Colors.Black); writeableBmp.DrawLine(w3rd, 0, w3rd, h, Colors.Black); writeableBmp.DrawLine(2 * w3rd, 0, 2 * w3rd, h, Colors.Black); // Invalidate writeableBmp.Invalidate(); }
private void drawPointerMM(double x, double y, Color color) { int xi = fwdXi(x); int yi = fwdYi(y); writeableBitmap.DrawLine(xi - 20, yi, xi - 5, yi, color); writeableBitmap.DrawLine(xi + 20, yi, xi + 5, yi, color); writeableBitmap.DrawLine(xi, yi - 20, xi, yi - 5, color); writeableBitmap.DrawLine(xi, yi + 20, xi, yi + 5, color); writeableBitmap.DrawEllipseCentered(xi, yi, 15, 15, color); writeableBitmap.DrawEllipseCentered(xi, yi, 10, 10, color); }
internal static void Transform(WriteableBitmap context, sb.Geometry <sb.Point> original, sb.Point location, int border, int fill) { if (original.Geometries != null) { foreach (var geometry in original.Geometries) { Transform(context, geometry, location, border, fill); } } else { if (original.NumberOfPoints < 1) { return; } var firstPoint = original.Points[0]; if (original.Type == sb.GeometryType.Point) { context.DrawEllipseCentered(border, (int)(firstPoint.X + location.X), (int)(firstPoint.Y + location.Y), pointSize, pointSize); } else if (original.Type == IRI.Msh.Common.Primitives.GeometryType.LineString) { AddLineString(context, original, location, border, fill); } } }
private void DrawPolarGrid(WriteableBitmap bitmap) { var markProvider = new PolarAxisMarkProvider { MinStep = 20, MinMajorStep = 100 }; //{ MinStep = 5, MinMajorStep = 25 }; markProvider.IterateRadiusGrid(Viewport.HorizontalAxis, Viewport.VerticalAxis, (x0, y0, x, y) => bitmap.DrawLine((int)x0, (int)y0, (int)x, (int)y, _minorGridColor), false); markProvider.IterateEllipseGrid(Viewport.HorizontalAxis, Viewport.VerticalAxis, (x0, y0, x, y) => bitmap.DrawEllipseCentered((int)x0, (int)y0, (int)x, (int)y, _minorGridColor), false); markProvider.IterateRadiusGrid(Viewport.HorizontalAxis, Viewport.VerticalAxis, (x0, y0, x, y) => bitmap.DrawLine((int)x0, (int)y0, (int)x, (int)y, _majorGridColor), true); markProvider.IterateEllipseGrid(Viewport.HorizontalAxis, Viewport.VerticalAxis, (x0, y0, x, y) => bitmap.DrawEllipseCentered((int)x0, (int)y0, (int)x, (int)y, _majorGridColor), true); }
public void PaintCircle_Rect(WriteableBitmap bmp, Point position, int size, Color color) { //g.DrawEllipse(pen, position.X, position.Y, size, size); //g.DrawRectangle(pen, position.X + size / 4, position.Y + size / 4, size / 2, size / 2); bmp.DrawEllipseCentered((int)position.X, (int)position.Y, size, size, color); bmp.DrawRectangle((int)position.X + size / 4, (int)position.Y + size / 4, size / 2, size / 2, color); }
public void PaintCircle_Point(WriteableBitmap bmp, Point position, int size, Color color) { //g.DrawEllipse(pen, position.X, position.Y, size, size); //g.FillEllipse(brush, position.X + size / 8 * 3, position.Y + size / 8 * 3, size / 4, size / 4); bmp.DrawEllipseCentered((int)position.X, (int)position.Y, size, size, color); bmp.FillEllipseCentered((int)position.X, (int)position.Y, size / 2, size / 2, color); }
public void DrawEllipseCentered(double startX, double startY, double endX, double endY, Color color, int thickness) { int count = (int)(thickness * Scale); if (count < 1) { count = 1; } if (count == 1) { startX = Offset.X + startX * Scale; startY = Offset.Y + startY * Scale; endX = Offset.X + endX * Scale; endY = Offset.Y + endY * Scale; double cx = (startX + endX) / 2.0; double cy = (startY + endY) / 2.0; double xr = Math.Abs(startX - endX) / 2.0; double yr = Math.Abs(startY - endY) / 2.0; bmp.DrawEllipseCentered((int)cx, (int)cy, (int)xr, (int)yr, color); } else { if (count % 2 == 0) { count++; } double step = thickness * Scale / count; double half = thickness * Scale / 2.0; startX = Offset.X + startX * Scale; startY = Offset.Y + startY * Scale; endX = Offset.X + endX * Scale; endY = Offset.Y + endY * Scale; int cx = (int)((startX + endX) / 2.0); int cy = (int)((startY + endY) / 2.0); int minRad = (int)(Math.Abs(startX - endX) / 2.0 - half); int maxRad = (int)(Math.Abs(startX - endX) / 2.0 + half); for (int i = minRad; i <= maxRad; i++) { bmp.DrawEllipseCentered((int)cx, (int)cy, (int)i, (int)i, color); } } }
private void CompositionTarget_Rendering(object sender, EventArgs e) { writeableBitmap.DrawEllipseCentered( random.Next(width), random.Next(height), 20, 20, Color.FromRgb((byte)random.Next(255), (byte)random.Next(255), (byte)random.Next(255))); }
/// <summary> /// A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf /// x2 has to be greater than x1 and y2 has to be greater than y1. /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="x1">The x-coordinate of the bounding rectangle's left side.</param> /// <param name="y1">The y-coordinate of the bounding rectangle's top side.</param> /// <param name="x2">The x-coordinate of the bounding rectangle's right side.</param> /// <param name="y2">The y-coordinate of the bounding rectangle's bottom side.</param> /// <param name="color">The color for the line.</param> public static void DrawEllipse(this WriteableBitmap bmp, int x1, int y1, int x2, int y2, int color) { // Calc center and radius int xr = (x2 - x1) >> 1; int yr = (y2 - y1) >> 1; int xc = x1 + xr; int yc = y1 + yr; bmp.DrawEllipseCentered(xc, yc, xr, yr, color); }
/// <summary> /// A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf /// Uses a different parameter representation than DrawEllipse(). /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="xc">The x-coordinate of the ellipses center.</param> /// <param name="yc">The y-coordinate of the ellipses center.</param> /// <param name="xr">The radius of the ellipse in x-direction.</param> /// <param name="yr">The radius of the ellipse in y-direction.</param> /// <param name="color">The color for the line.</param> public static void DrawEllipseCentered(this WriteableBitmap bmp, int xc, int yc, int xr, int yr, Color color) { // Add one to use mul and cheap bit shift for multiplicaltion int a = color.A + 1; int col = (color.A << 24) | ((byte)((color.R * a) >> 8) << 16) | ((byte)((color.G * a) >> 8) << 8) | ((byte)((color.B * a) >> 8)); bmp.DrawEllipseCentered(xc, yc, xr, yr, col); }
public void DrawMaskData() { if (mViewModel.MaskDataList != null && mViewModel.MaskDataList.Count > 0) { var maskDataArr = getMaskDataPointArr(); mWriteableBmpForSpectrumChart.DrawPolylineAa(maskDataArr, Colors.GreenYellow); int r = 6; for (int i = 0; i < maskDataArr.Length / 2; i++) { int X = maskDataArr[2 * i]; int Y = maskDataArr[2 * i + 1]; mWriteableBmpForSpectrumChart.DrawEllipseCentered(X, Y, r, r, Colors.White); } } }
private void AddPoint(WriteableBitmap context, SqlGeometry point, Func <Point, Point> transform, int border, int fill, ImageSource imageSymbol, sb.Primitives.Geometry <sb.Primitives.Point> geometrySymbol) { var center = transform(point.AsWpfPoint()).AsPoint(); if (geometrySymbol != null) { GeometryHelper.Transform(context, geometrySymbol, center, border, fill); } else if (imageSymbol != null) { throw new NotImplementedException(); } else { context.DrawEllipseCentered((int)center.X, (int)center.Y, pointSize, pointSize, border); } }
public WriteableBitmap Process(WriteableBitmap bmp) { if (bmp == null) { return(null); } // Filter var skin = _skinColorFilter.Process(bmp); var erode = _erodeFilter.Process(skin); var dilate = _dilateFilter.Process(erode); dilate = _dilateFilter.Process(dilate); dilate = _dilateFilter.Process(dilate); // Segment var histogram = Histogram.FromWriteabelBitmap(dilate); _segmentator.Histogram = histogram; _segmentator.ThresholdLuminance = histogram.Max * 0.1f; var foundSegments = _segmentator.Process(dilate); // Visualize _histogramViz.Histogram = histogram; _histogramViz.Visualize(dilate); var result = new WriteableBitmap(bmp.PixelWidth, bmp.PixelHeight); foreach (var s in foundSegments) { // Uses the segment's center and half width, height var c = s.Center; result.DrawEllipseCentered(c.X, c.Y, s.Width >> 1, s.Height >> 1, Colors.Red); } return(result); }
/// <summary> /// Draws the different types of shapes. /// </summary> private void DrawStaticShapes(WriteableBitmap writeableBmp) { // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block using (writeableBmp.GetBitmapContext()) { // Init some size vars int w = writeableBmp.PixelWidth - 2; int h = writeableBmp.PixelHeight - 2; int w3rd = w / 3; int h3rd = h / 3; int w6th = w3rd >> 1; int h6th = h3rd >> 1; // Clear writeableBmp.Clear(); // Draw some points for (int i = 0; i < 200; i++) { writeableBmp.SetPixel(rand.Next(w3rd), rand.Next(h3rd), GetRandomColor()); } // Draw Standard shapes writeableBmp.DrawLine(rand.Next(w3rd, w3rd * 2), rand.Next(h3rd), rand.Next(w3rd, w3rd * 2), rand.Next(h3rd), GetRandomColor()); writeableBmp.DrawTriangle(rand.Next(w3rd * 2, w - w6th), rand.Next(h6th), rand.Next(w3rd * 2, w), rand.Next(h6th, h3rd), rand.Next(w - w6th, w), rand.Next(h3rd), GetRandomColor()); writeableBmp.DrawQuad(rand.Next(0, w6th), rand.Next(h3rd, h3rd + h6th), rand.Next(w6th, w3rd), rand.Next(h3rd, h3rd + h6th), rand.Next(w6th, w3rd), rand.Next(h3rd + h6th, 2 * h3rd), rand.Next(0, w6th), rand.Next(h3rd + h6th, 2 * h3rd), GetRandomColor()); writeableBmp.DrawRectangle(rand.Next(w3rd, w3rd + w6th), rand.Next(h3rd, h3rd + h6th), rand.Next(w3rd + w6th, w3rd * 2), rand.Next(h3rd + h6th, 2 * h3rd), GetRandomColor()); // Random polyline int[] p = new int[rand.Next(7, 10) * 2]; for (int j = 0; j < p.Length; j += 2) { p[j] = rand.Next(w3rd * 2, w); p[j + 1] = rand.Next(h3rd, 2 * h3rd); } writeableBmp.DrawPolyline(p, GetRandomColor()); // Random closed polyline p = new int[rand.Next(6, 9) * 2]; for (int j = 0; j < p.Length - 2; j += 2) { p[j] = rand.Next(w3rd); p[j + 1] = rand.Next(2 * h3rd, h); } p[p.Length - 2] = p[0]; p[p.Length - 1] = p[1]; writeableBmp.DrawPolyline(p, GetRandomColor()); // Ellipses writeableBmp.DrawEllipse(rand.Next(w3rd, w3rd + w6th), rand.Next(h3rd * 2, h - h6th), rand.Next(w3rd + w6th, w3rd * 2), rand.Next(h - h6th, h), GetRandomColor()); writeableBmp.DrawEllipseCentered(w - w6th, h - h6th, w6th >> 1, h6th >> 1, GetRandomColor()); // Draw Grid writeableBmp.DrawLine(0, h3rd, w, h3rd, Colors.Black); writeableBmp.DrawLine(0, 2 * h3rd, w, 2 * h3rd, Colors.Black); writeableBmp.DrawLine(w3rd, 0, w3rd, h, Colors.Black); writeableBmp.DrawLine(2 * w3rd, 0, 2 * w3rd, h, Colors.Black); // Invalidates on exit of using block } }
public void DrawEllipse(double x0, double y0, double radiusX, double radiusY, DicomColor color) { _bitmap.DrawEllipseCentered(transxi(x0), transyi(y0), transxi(radiusX / 2), transyi(radiusY / 2), DicomColorConverter.FromDicomColor(color)); }
/// <summary> /// A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf /// Uses a different parameter representation than DrawEllipse(). /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="xc">The x-coordinate of the ellipses center.</param> /// <param name="yc">The y-coordinate of the ellipses center.</param> /// <param name="xr">The radius of the ellipse in x-direction.</param> /// <param name="yr">The radius of the ellipse in y-direction.</param> /// <param name="color">The color for the line.</param> public static void DrawEllipseCentered(this WriteableBitmap bmp, int xc, int yc, int xr, int yr, Color color) { var col = ConvertColor(color); bmp.DrawEllipseCentered(xc, yc, xr, yr, col); }
public void PaintHollowCircle(WriteableBitmap bmp, Point position, int size, Color color) { bmp.DrawEllipseCentered((int)position.X, (int)position.Y, size, size, color); }
public void Draw(WriteableBitmap bitmap) { bitmap.Clear(Colors.White); double width = bitmap.Width; double halfWidth = width / 2; width -= 1; double height = bitmap.Height; double uParam = P.FirstParamLimit; double vParam = P.SecondParamLimit; double sParam = Q.FirstParamLimit; double tParam = Q.SecondParamLimit; using (bitmap.GetBitmapContext()) { if (QtestSet != null) { var uStep = Q.FirstParamLimit / (QtestSet.GetLength(1) - 1.0); var vStep = Q.SecondParamLimit / (QtestSet.GetLength(0) - 1.0); for (int i = 0; i < QtestSet.GetLength(1); i++) { for (int j = 0; j < QtestSet.GetLength(0); j++) { bitmap.DrawEllipseCentered((int)(i * uStep / sParam * (halfWidth - 3) + halfWidth), (int)(j * vStep / tParam * height), 1, 1, QtestSet[j, i] ? Colors.LightGray : Colors.LightBlue); } } } if (pPolygon != null) { var minSize = System.Math.Min(P.FirstParamLimit, P.SecondParamLimit) * 0.8; for (int i = 0; i < pPolygon.Count - 1 + (cyclic ? 1 : 0); i++) { var item1 = pPolygon[i]; var item2 = pPolygon[(i + 1) % pPolygon.Count]; if (System.Math.Abs(item1.X - item2.X) < minSize && System.Math.Abs(item1.Y - item2.Y) < minSize) { bitmap.DrawLineDDA((int)(item1.X / uParam * halfWidth), (int)(item1.Y / vParam * height), (int)(item2.X / uParam * halfWidth), (int)(item2.Y / vParam * height), Colors.BlueViolet); } } } if (IsIntersectableP) { if (pPolygonBoundary != null) { foreach (var tuple in pPolygonBoundary) { bitmap.DrawLineDDA((int)(tuple.Item1.X / uParam * halfWidth), (int)(tuple.Item1.Y / vParam * height), (int)(tuple.Item2.X / uParam * halfWidth), (int)(tuple.Item2.Y / vParam * height), Colors.BlueViolet); } } } if (qPolygon != null) { var minSize = System.Math.Min(Q.FirstParamLimit, Q.SecondParamLimit) * 0.8; for (int i = 0; i < qPolygon.Count - 1 + (cyclic ? 1 : 0); i++) { var item1 = qPolygon[i]; var item2 = qPolygon[(i + 1) % qPolygon.Count]; if (System.Math.Abs(item1.X - item2.X) < minSize && System.Math.Abs(item1.Y - item2.Y) < minSize) { bitmap.DrawLineDDA((int)(item1.X / sParam * (halfWidth - 3) + halfWidth), (int)(item1.Y / tParam * height), (int)(item2.X / sParam * (halfWidth - 3) + halfWidth), (int)(item2.Y / tParam * height), Colors.DarkViolet); } } } if (IsIntersectableQ) { if (qPolygonBoundary != null) { foreach (var tuple in qPolygonBoundary) { bitmap.DrawLineDDA((int)(tuple.Item1.X / sParam * (halfWidth - 3) + halfWidth), (int)(tuple.Item1.Y / tParam * height), (int)(tuple.Item2.X / sParam * (halfWidth - 3) + halfWidth), (int)(tuple.Item2.Y / tParam * height), Colors.DarkViolet); } } } //if (PtestSet != null) //{ // var uStep = P.FirstParamLimit / (PtestSet.GetLength(1) - 1.0); // var vStep = P.SecondParamLimit / (PtestSet.GetLength(0) - 1.0); // for (int i = 0; i < PtestSet.GetLength(1); i++) // for (int j = 0; j < PtestSet.GetLength(0); j++) // { // bitmap.DrawEllipseCentered((int)(i * uStep / uParam * halfWidth), (int)(j * vStep / vParam * height), 1, 1, PtestSet[j, i] ? Colors.Green : Colors.Red); // } //} } }
/// <summary> /// A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf /// It uses a different parameter representation than DrawEllipse(). /// </summary> /// <param name="bmp">The WriteableBitmap.</param> /// <param name="xc">The x-coordinate of the ellipses center.</param> /// <param name="yc">The y-coordinate of the ellipses center.</param> /// <param name="xr">The radius of the ellipse in x-direction.</param> /// <param name="yr">The radius of the ellipse in y-direction.</param> /// <param name="color">The color for the line.</param> public static void DrawEllipseCentered(this WriteableBitmap bmp, int xc, int yc, int xr, int yr, Color color) { bmp.DrawEllipseCentered(xc, yc, xr, yr, (color.A << 24) | (color.R << 16) | (color.G << 8) | color.B); }
private void ViewPort_Loaded(object sender, RoutedEventArgs e) { width = (int)this.ViewPortContainer.ActualWidth; height = (int)this.ViewPortContainer.ActualHeight; frame = BitmapFactory.New(width, height); ViewPort.Source = frame; List <Branch> Branches = new List <Branch>(); Branch bottom = new Branch((width / 2), height, 0, 50, 200); Branches.Add(bottom); frame.DrawLine(bottom.posX, bottom.posY, bottom.posX, height - bottom.length, Branch.color); bottom.setEndPoint(bottom.posX, height - bottom.length); //System.Diagnostics.Debug.WriteLine(Math.Sin(60.0* Math.PI / 180)); //System.Diagnostics.Debug.WriteLine(bottom.posX+ " " + bottom.posY + " " + bottom.posX + " " + (bottom.posY + bottom.length)); int counter = 0; int branchesCount; List <Branch> newBranches; int numToRemove; int index; while (Branches.Count > 0 && counter < 4) { branchesCount = Branches.Count; newBranches = new List <Branch>(); if (branchesCount > 4) { index = 0; numToRemove = (branchesCount / 2); for (int i = 0; i <= numToRemove; i++) { index = new Random().Next(0, (branchesCount - 1)); for (int x = 0; x < 6; x++) { frame.DrawEllipseCentered(Branches.ElementAt(index).posX, Branches.ElementAt(index).posY, x, x, Colors.Green); } Branches.RemoveAt(index); branchesCount--; } } foreach (var b in Branches) { for (int i = 0; i < (branchesCount * 2); i++) { newBranches.Add(new Branch(b.posX, b.posY)); } } Branches = newBranches; branchesCount = Branches.Count; foreach (var b in Branches) { int oldX = b.posX; int oldY = b.posY; b.setEndPoint(); int newX = b.posX; int newY = b.posY; frame.DrawLine(oldX, oldY, newX, newY, Branch.color); } counter++; } index = 0; foreach (var b in Branches) { for (int i = 0; i < 6; i++) { frame.DrawEllipseCentered(Branches.ElementAt(index).posX, Branches.ElementAt(index).posY, i, i, Colors.Green); } index++; } }
/// <summary> /// Draws circles that decrease in size to build a flower that is animated /// </summary> private void DrawEllipsesFlower(WriteableBitmap writeableBmp) { if (writeableBmp == null) { return; } // Init some size vars int w = writeableBmp.PixelWidth - 2; int h = writeableBmp.PixelHeight - 2; // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block using (writeableBmp.GetBitmapContext()) { // Increment frame counter if (++frameCounter >= int.MaxValue || frameCounter < 1) { frameCounter = 1; } double s = Math.Sin(frameCounter * 0.01); if (s < 0) { s *= -1; } // Clear writeableBmp.Clear(); // Draw center circle int xc = w >> 1; int yc = h >> 1; // Animate base size with sine int r0 = (int)((w + h) * 0.07 * s) + 10; System.Windows.Media.Imaging.Color color_brown = System.Windows.Media.Imaging.Color.FromArgb( 255, System.Drawing.Color.Brown.R, System.Drawing.Color.Brown.G, System.Drawing.Color.Brown.B); writeableBmp.DrawEllipseCentered(xc, yc, r0, r0, color_brown); // Draw outer circles int dec = (int)((w + h) * 0.0045f); int r = (int)((w + h) * 0.025f); int offset = r0 + r; for (int i = 1; i < 6 && r > 1; i++) { for (double f = 1; f < 7; f += 0.7) { // Calc postion based on unit circle int xc2 = (int)(Math.Sin(frameCounter * 0.002 * i + f) * offset + xc); int yc2 = (int)(Math.Cos(frameCounter * 0.002 * i + f) * offset + yc); int col = (int)(0xFFFF0000 | (uint)(0x1A * i) << 8 | (uint)(0x20 * f)); writeableBmp.DrawEllipseCentered(xc2, yc2, r, r, col); } // Next ring offset += r; r -= dec; offset += r; } // Invalidates on exit of using block } }