private void Draw(BitmapBuffer writeableBmp) { if (this.points != null) { ReloadRandomPoints(); // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block using (writeableBmp.GetBitmapContext()) { writeableBmp.Clear(); DrawPoints(writeableBmp); //DrawBeziers(writeableBmp); // DrawCardinal(writeableBmp); //if (ChkShowPoints.IsChecked.Value) //{ // DrawPoints(); //} //if (RBBezier.IsChecked.Value) //{ // DrawBeziers(); //} //else if (RBCardinal.IsChecked.Value) //{ // DrawCardinal(); //} } } }
/// <summary> /// Draws random shapes. /// </summary> private void DrawShapes(BitmapBuffer 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 w2 = w >> 1; int h2 = h >> 1; // Clear writeableBmp.Clear(); // Fill Shapes for (int i = 0; i < shapeCount; i++) { // Random polygon int[] p = new int[rand.Next(5, 10) * 2]; for (int j = 0; j < p.Length; j += 2) { p[j] = rand.Next(w); p[j + 1] = rand.Next(h); } writeableBmp.FillPolygon(p, GetRandomColor()); } // Invalidates on exit of Using block } }
private void button3_Click(object sender, EventArgs e) { using (Bitmap src = new Bitmap("d:\\WImageTest\\L01.png")) using (LockBmp srcLock = src.Lock()) using (Bitmap dest = new Bitmap(400, 500)) using (LockBmp dstLock = dest.Lock()) { BitmapBuffer dstWb = dstLock.CreateNewBitmapBuffer(); BitmapBuffer srcWb = srcLock.CreateNewBitmapBuffer(); int y = 0; dstWb.Clear(BitmapBufferEx.ColorInt.FromArgb(255, 255, 255, 255)); dstWb.Blit(new RectD(10, 10, src.Width, src.Height), srcWb, new RectD(0, 0, src.Width, src.Height), BitmapBufferExtensions.BlendMode.None ); dstWb.Blit(new RectD(100, 100, src.Width * 2, src.Height * 2), srcWb, new RectD(0, 0, src.Width, src.Height), BitmapBufferExtensions.BlendMode.None ); dstLock.WriteAndUnlock(); dest.Save("d:\\WImageTest\\a0004.png"); } }
/// <summary> /// Draws circles that decrease in size to build a flower that is animated /// </summary> private void DrawEllipsesFlower(BitmapBuffer writeableBmp) { // 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; BitmapBufferEx.ColorInt color_brown = BitmapBufferEx.ColorInt.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 } }
public void Draw(BitmapBuffer writeableBmp) { // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block using (writeableBmp.GetBitmapContext()) { writeableBmp.Clear(); Draw(writeableBmp, this.Root); #if SILVERLIGHT writeableBmp.Invalidate(); #endif } }
private void button6_Click(object sender, EventArgs e) { BitmapBuffer unmodifiedBmp = LoadBitmapAsReadonly("../../02.jpg"); BitmapBuffer flipImg = unmodifiedBmp.RotateFree(20, false); using (LockBmp bmplock = destBmp.Lock()) { BitmapBuffer wb = bmplock.CreateNewBitmapBuffer(); wb.Clear(Colors.White); wb.Blit(new RectD(0, 0, flipImg.PixelWidth, flipImg.PixelHeight), flipImg, new RectD(0, 0, flipImg.PixelWidth, flipImg.PixelHeight)); bmplock.WriteAndUnlock(); g.Clear(System.Drawing.Color.White); g.DrawImage(destBmp, 0, 0); } }
private void button4_Click(object sender, EventArgs e) { BitmapBuffer unmodifiedBmp = LoadBitmapAsReadonly("../../02.jpg"); BitmapBuffer rotateBmp = unmodifiedBmp.Rotate(BitmapBufferExtensions.FastRotateAngle.Rotate270); using (LockBmp bmplock = destBmp.Lock()) { BitmapBuffer wb = bmplock.CreateNewBitmapBuffer(); wb.Clear(Colors.White); wb.Blit(new RectD(0, 0, rotateBmp.PixelWidth, rotateBmp.PixelHeight), rotateBmp, new RectD(0, 0, rotateBmp.PixelWidth, rotateBmp.PixelHeight)); bmplock.WriteAndUnlock(); g.Clear(System.Drawing.Color.White); g.DrawImage(destBmp, 0, 0); } }
private void button2_Click(object sender, EventArgs e) { BitmapBuffer unmodifiedBmp = LoadBitmapAsReadonly("../../02.jpg"); BitmapBuffer sticker = LoadBitmapAsReadonly("../../01.jpg"); BitmapBuffer overlayResult = Overlay(unmodifiedBmp, sticker, new BitmapBufferEx.PointD(10, 10)); using (LockBmp bmplock = destBmp.Lock()) { BitmapBuffer wb = bmplock.CreateNewBitmapBuffer(); wb.Clear(Colors.Black); wb.Blit(new RectD(0, 0, overlayResult.PixelWidth, overlayResult.PixelHeight), overlayResult, new RectD(0, 0, overlayResult.PixelWidth, overlayResult.PixelHeight)); bmplock.WriteAndUnlock(); g.Clear(System.Drawing.Color.White); g.DrawImage(destBmp, 0, 0); } }
void UpdateRenderFrame() { // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block // NOTE: This is not strictly necessary for the SL version as this is a WPF feature, however we include it here for completeness and to show // a similar API to WPF //render! using (LockBmp bmplock = destBmp.Lock()) { BitmapBuffer wb = bmplock.CreateNewBitmapBuffer(); emitter.TargetBitmap = wb; emitter.ParticleBitmap = particleBmp; wb.Clear(Colors.Black); double elapsed = (DateTime.Now - lastUpdate).TotalSeconds; lastUpdate = DateTime.Now; emitter.Update(elapsed); // bmp.Blit(new Point(100, 150), circleBmp, new Rect(0, 0, 200, 200), Colors.Red, BlendMode.Additive); // bmp.Blit(new Point(160, 55), circleBmp, new Rect(0, 0, 200, 200), Color.FromArgb(255, 0, 255, 0), BlendMode.Additive); // bmp.Blit(new Point(220, 150), circleBmp, new Rect(0, 0, 200, 200), Colors.Blue, BlendMode.Additive); //double timeNow = _stopwatch.ElapsedMilliseconds; //double elapsedMilliseconds = timeNow - _lastTime; //_lowestFrameTime = Math.Min(_lowestFrameTime, elapsedMilliseconds); //// FpsCounter.Text = string.Format("FPS: {0:0.0} / Max: {1:0.0}", 1000.0 / elapsedMilliseconds, 1000.0 / _lowestFrameTime); //_lastTime = timeNow; // bmplock.WriteAndUnlock(); // g.Clear(System.Drawing.Color.White); g.DrawImage(destBmp, 0, 0); } }
/// <summary> /// Draws random ellipses /// </summary> private void DrawEllipses(BitmapBuffer writeableBmp) { // Init some size vars int w = writeableBmp.PixelWidth - 2; int h = writeableBmp.PixelHeight - 2; int wh = w >> 1; int hh = h >> 1; // Wrap updates in a GetContext call, to prevent invalidation and nested locking/unlocking during this block using (writeableBmp.GetBitmapContext()) { // Clear writeableBmp.Clear(); // Draw Ellipses for (int i = 0; i < shapeCount; i++) { writeableBmp.DrawEllipse(rand.Next(wh), rand.Next(hh), rand.Next(wh, w), rand.Next(hh, h), GetRandomColor()); } // Invalidates on exit of using block } }
/// <summary> /// Draws the different types of shapes. /// </summary> private void DrawStaticShapes(BitmapBuffer 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 } }
/// <summary> /// Draws the different types of shapes. /// </summary> private void DrawStaticShapes(BitmapBuffer writeableBmp) { // HideShapeCountText(); // 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; int h = writeableBmp.PixelHeight; int w3 = w / 3; int h3 = h / 3; int w6 = w3 >> 1; int h6 = h3 >> 1; int w12 = w6 >> 1; int h12 = h6 >> 1; // Clear writeableBmp.Clear(); // Fill closed concave polygon var p = new int[] { w12 >> 1, h12, w6, h3 - (h12 >> 1), w3 - (w12 >> 1), h12, w6 + w12, h12, w6, h6 + h12, w12, h12, w12 >> 1, h12, }; writeableBmp.FillPolygonsEvenOdd(new[] { p }, GetRandomColor()); // Fill closed convex polygon p = new int[] { w3 + w6, h12 >> 1, w3 + w6 + w12, h12, w3 + w6 + w12, h6 + h12, w3 + w6, h6 + h12 + (h12 >> 1), w3 + w12, h6 + h12, w3 + w12, h12, w3 + w6, h12 >> 1, }; writeableBmp.FillPolygon(p, GetRandomColor()); // Fill Triangle + Quad writeableBmp.FillTriangle(2 * w3 + w6, h12 >> 1, 2 * w3 + w6 + w12, h6 + h12, 2 * w3 + w12, h6 + h12, GetRandomColor()); writeableBmp.FillQuad(w6, h3 + (h12 >> 1), w6 + w12, h3 + h6, w6, h3 + h6 + h12 + (h12 >> 1), w12, h3 + h6, GetRandomColor()); // Fill Ellipses writeableBmp.FillEllipse(rand.Next(w3, w3 + w6), rand.Next(h3, h3 + h6), rand.Next(w3 + w6, 2 * w3), rand.Next(h3 + h6, 2 * h3), GetRandomColor()); writeableBmp.FillEllipseCentered(2 * w3 + w6, h3 + h6, w12, h12, GetRandomColor()); // Fill closed Cardinal Spline curve p = new int[] { w12 >> 1, 2 * h3 + h12, w6, h - (h12 >> 1), w3 - (w12 >> 1), 2 * h3 + h12, w6 + w12, 2 * h3 + h12, w6, 2 * h3 + (h12 >> 1), w12, 2 * h3 + h12, }; writeableBmp.FillCurveClosed(p, 0.5f, GetRandomColor()); // Fill closed Beziér curve p = new int[] { w3 + w12, 2 * h3 + h6 + h12, w3 + w6 + (w12 >> 1), 2 * h3, w3 + w6 + w12 + (w12 >> 1), 2 * h3, w3 + w6 + w12, 2 * h3 + h6 + h12, }; writeableBmp.FillBeziers(p, GetRandomColor()); // Fill Rectangle writeableBmp.FillRectangle(rand.Next(2 * w3, 2 * w3 + w6), rand.Next(2 * h3, 2 * h3 + h6), rand.Next(2 * w3 + w6, w), rand.Next(2 * h3 + h6, h), GetRandomColor()); // Fill another rectangle with alpha blending writeableBmp.FillRectangle(rand.Next(2 * w3, 2 * w3 + w6), rand.Next(2 * h3, 2 * h3 + h6), rand.Next(2 * w3 + w6, w), rand.Next(2 * h3 + h6, h), GetRandomColor(), true); BitmapBufferEx.ColorInt black = BitmapBufferEx.ColorInt.FromArgb(255, 0, 0, 0); // Draw Grid writeableBmp.DrawLine(0, h3, w, h3, Colors.Black); writeableBmp.DrawLine(0, 2 * h3, w, 2 * h3, Colors.Black); writeableBmp.DrawLine(w3, 0, w3, h, Colors.Black); writeableBmp.DrawLine(2 * w3, 0, 2 * w3, h, Colors.Black); // Invalidates on exit of Using block } }
private void DrawFillDemo(BitmapBuffer 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 w2 = w >> 1; int h2 = h >> 1; int w4 = w2 >> 1; int h4 = h2 >> 1; int w8 = w4 >> 1; int h8 = h4 >> 1; // Clear writeableBmp.Clear(); // Add circles const float startTimeFixed = 1; const float endTimeFixed = startTimeFixed + timeStep; const float startTimeRandom = 3; const float endTimeCurve = 9.7f; const int intervalRandom = 2; const int maxCircles = 30; // Spread fixed position and color circles if (time > startTimeFixed && time < endTimeFixed) { unchecked { circles.Add(new Circle { X = w8, Y = h8, Radius = 10f, Velocity = 1, Color = (int)0xFFC88717 }); circles.Add(new Circle { X = w8, Y = h - h8, Radius = 10f, Velocity = 1, Color = (int)0xFFFB522B }); circles.Add(new Circle { X = w - w8, Y = h8, Radius = 10f, Velocity = 1, Color = (int)0xFFDB6126 }); circles.Add(new Circle { X = w - w8, Y = h - h8, Radius = 10f, Velocity = 1, Color = (int)0xFFFFCE25 }); } } // Spread random position and color circles if (time > startTimeRandom && (int)time % intervalRandom == 0) { unchecked { circles.Add(new Circle { X = rand.Next(w), Y = rand.Next(h), Radius = 1f, Velocity = rand.Next(1, 5), Color = rand.Next((int)0xFFFF0000, (int)0xFFFFFFFF), }); } } // Render and update circles foreach (var circle in circles) { var r = (int)circle.Radius; writeableBmp.FillEllipseCentered(circle.X, circle.Y, r, r, circle.Color); circle.Update(); } if (circles.Count > maxCircles) { circles.RemoveAt(0); } // Fill closed Cardinal Spline curve if (time < endTimeCurve) { var p = new int[] { w4, h2, w2, h2 + h4, w2 + w4, h2, w2, h4, }; writeableBmp.FillCurveClosed(p, (float)Math.Sin(time) * 7, Colors.Black); } // Update time time += timeStep; // Invalidates on exit of Using block } }