public void DisplaySizeInfo(Graphics2D graphics2D, Vector2 widthDisplayCenter, double size) { string displayString = formatString.FormatWith(size); if (measureDisplayImage == null || measureDisplayedString != displayString) { measureDisplayedString = displayString; TypeFacePrinter printer = new TypeFacePrinter(measureDisplayedString, 16); TypeFacePrinter unitPrinter = new TypeFacePrinter(unitsString, 10); Double unitPrinterOffset = 1; BorderDouble margin = new BorderDouble(5); printer.Origin = new Vector2(margin.Left, margin.Bottom); RectangleDouble bounds = printer.LocalBounds; unitPrinter.Origin = new Vector2(bounds.Right + unitPrinterOffset, margin.Bottom); RectangleDouble unitPrinterBounds = unitPrinter.LocalBounds; measureDisplayImage = new ImageBuffer((int)(bounds.Width + margin.Width + unitPrinterBounds.Width + unitPrinterOffset), (int)(bounds.Height + margin.Height)); // make sure the texture has mipmaps (so it can reduce well) ImageGlPlugin glPlugin = ImageGlPlugin.GetImageGlPlugin(measureDisplayImage, true); Graphics2D widthGraphics = measureDisplayImage.NewGraphics2D(); widthGraphics.Clear(new RGBA_Bytes(RGBA_Bytes.White, 128)); printer.Render(widthGraphics, RGBA_Bytes.Black); unitPrinter.Render(widthGraphics, RGBA_Bytes.Black); } widthDisplayCenter -= new Vector2(measureDisplayImage.Width / 2, measureDisplayImage.Height / 2); graphics2D.Render(measureDisplayImage, widthDisplayCenter); }
private double PrintTopOfPage(ImageBuffer plateInventoryImage, Graphics2D plateGraphics) { plateGraphics.Clear(RGBA_Bytes.White); double currentlyPrintingHeightPixels = plateInventoryImage.Height - PageMarginMM.Top * PixelPerMM; string logoPathAndFile = Path.Combine(ApplicationDataStorage.Instance.ApplicationStaticDataPath, "PartSheetLogo.png"); if (File.Exists(logoPathAndFile)) { ImageBuffer logoImage = new ImageBuffer(); ImageBMPIO.LoadImageData(logoPathAndFile, logoImage); currentlyPrintingHeightPixels -= logoImage.Height; plateGraphics.Render(logoImage, (plateInventoryImage.Width - logoImage.Width) / 2, currentlyPrintingHeightPixels); } currentlyPrintingHeightPixels -= PartPaddingPixels; double underlineHeightMM = 1; RectangleDouble lineBounds = new RectangleDouble(0, 0, plateInventoryImage.Width - PageMarginPixels.Left * 2, underlineHeightMM * PixelPerMM); lineBounds.Offset(PageMarginPixels.Left, currentlyPrintingHeightPixels - lineBounds.Height); plateGraphics.FillRectangle(lineBounds, RGBA_Bytes.Black); return(currentlyPrintingHeightPixels - (lineBounds.Height + PartPaddingPixels)); }
void Update() { // update animation counter x += Time.deltaTime; while (x > 1.0f) { x -= 1.0f; } // clear background with white Graphics2D g = buffer.NewGraphics2D(); g.Clear(RGBA_Bytes.White); // draw some lines float w = buffer.Width * x; for (int i = 0; i < 10; i++) { g.Line(x1: 0, y1: buffer.Height * i / 10, x2: w - w * i / 10, y2: 0, color: RGBA_Bytes.Black, strokeWidth: 3); } // draw some text TypeFacePrinter textPrinter = new TypeFacePrinter("Hello World!", 30, justification: Justification.Center); IVertexSource translatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewTranslation(buffer.Width / 2, 5)); g.Render(translatedText, RGBA_Bytes.Blue); // update texture data byte[] pixels = buffer.GetBuffer(); texture.LoadRawTextureData(pixels); texture.Apply(); }
private double PrintTopOfPage(ImageBuffer plateInventoryImage, Graphics2D plateGraphics) { plateGraphics.Clear(Color.White); double currentlyPrintingHeightPixels = plateInventoryImage.Height - PageMarginMM.Top * PixelPerMM; string logoPathAndFile = Path.Combine("Images", "PartSheetLogo.png"); if (StaticData.Instance.FileExists(logoPathAndFile)) { ImageBuffer logoImage = StaticData.Instance.LoadImage(logoPathAndFile); currentlyPrintingHeightPixels -= logoImage.Height; plateGraphics.Render(logoImage, (plateInventoryImage.Width - logoImage.Width) / 2, currentlyPrintingHeightPixels); } currentlyPrintingHeightPixels -= PartPaddingPixels; double underlineHeightMM = 1; var lineBounds = new RectangleDouble(0, 0, plateInventoryImage.Width - PageMarginPixels.Left * 2, underlineHeightMM * PixelPerMM); lineBounds.Offset(PageMarginPixels.Left, currentlyPrintingHeightPixels - lineBounds.Height); plateGraphics.FillRectangle(lineBounds, Color.Black); return(currentlyPrintingHeightPixels - (lineBounds.Height + PartPaddingPixels)); }
public override void Draw(Graphics2D g) { int width = 800; int height = 600; //clear the image to white g.Clear(ColorRGBA.White); // draw a circle Ellipse ellipsePro = new Ellipse(0, 0, 100, 50); for (double angleDegrees = 0; angleDegrees < 180; angleDegrees += 22.5) { var mat = Affine.NewMatix( AffinePlan.Rotate(MathHelper.DegreesToRadians(angleDegrees)), AffinePlan.Translate(width / 2, 150)); VertexStore sp1 = mat.TransformToVxs(ellipsePro.MakeVxs()); g.Render(sp1, ColorRGBA.Yellow); //Stroke ellipseOutline = new Stroke(sp1, 3); g.Render(StrokeHelp.MakeVxs(sp1, 3), ColorRGBA.Blue); } // and a little polygon PathWriter littlePoly = new PathWriter(); littlePoly.MoveTo(50, 50); littlePoly.LineTo(150, 50); littlePoly.LineTo(200, 200); littlePoly.LineTo(50, 150); littlePoly.LineTo(50, 50); g.Render(littlePoly.MakeVertexSnap(), ColorRGBA.Cyan); // draw some text // draw some text var textPrinter = new TextPrinter(); textPrinter.CurrentFont = SvgFontStore.LoadFont(SvgFontStore.DEFAULT_SVG_FONTNAME, 30); //new TypeFacePrinter("Printing from a printer", 30, justification: Justification.Center); VertexStore vxs = textPrinter.CreateVxs("Printing from a printer".ToCharArray()); var affTx = Affine.NewTranslation(width / 2, height / 4 * 3); VertexStore s1 = affTx.TransformToVxs(vxs); g.Render(s1, ColorRGBA.Black); g.Render(StrokeHelp.MakeVxs(s1, 1), ColorRGBA.Red); var aff2 = Affine.NewMatix( AffinePlan.Rotate(MathHelper.DegreesToRadians(90)), AffinePlan.Translate(40, height / 2)); g.Render(aff2.TransformToVertexSnap(vxs), ColorRGBA.Black); }
private void CreateCircularBedGridImage(int linesInX, int linesInY, int increment = 1) { Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY); BedImage = new ImageBuffer(1024, 1024); Graphics2D graphics2D = BedImage.NewGraphics2D(); graphics2D.Clear(bedBaseColor); { double lineDist = BedImage.Width / (double)linesInX; int count = 1; int pointSize = 16; graphics2D.DrawString(count.ToString(), 4, 4, pointSize, color: bedMarkingsColor); double currentRadius = lineDist; Vector2 bedCenter = new Vector2(BedImage.Width / 2, BedImage.Height / 2); for (double linePos = lineDist + BedImage.Width / 2; linePos < BedImage.Width; linePos += lineDist) { int linePosInt = (int)linePos; graphics2D.DrawString((count * increment).ToString(), linePos + 2, BedImage.Height / 2, pointSize, color: bedMarkingsColor); Ellipse circle = new Ellipse(bedCenter, currentRadius); Stroke outline = new Stroke(circle); graphics2D.Render(outline, bedMarkingsColor); currentRadius += lineDist; count++; } graphics2D.Line(0, BedImage.Height / 2, BedImage.Width, BedImage.Height / 2, bedMarkingsColor); graphics2D.Line(BedImage.Width / 2, 0, BedImage.Width / 2, BedImage.Height, bedMarkingsColor); } }
private double PrintTopOfPage(ImageBuffer plateInventoryImage, Graphics2D plateGraphics) { plateGraphics.Clear(RGBA_Bytes.White); double currentlyPrintingHeightPixels = plateInventoryImage.Height - PageMarginMM.Top * PixelPerMM; // TODO: Application should not save data back to StaticDataPath - use application data dir instead string logoPathAndFile = "PartSheetLogo.png"; if (StaticData.Instance.FileExists(logoPathAndFile)) { ImageBuffer logoImage = StaticData.Instance.LoadImage(logoPathAndFile); currentlyPrintingHeightPixels -= logoImage.Height; plateGraphics.Render(logoImage, (plateInventoryImage.Width - logoImage.Width) / 2, currentlyPrintingHeightPixels); } currentlyPrintingHeightPixels -= PartPaddingPixels; double underlineHeightMM = 1; RectangleDouble lineBounds = new RectangleDouble(0, 0, plateInventoryImage.Width - PageMarginPixels.Left * 2, underlineHeightMM * PixelPerMM); lineBounds.Offset(PageMarginPixels.Left, currentlyPrintingHeightPixels - lineBounds.Height); plateGraphics.FillRectangle(lineBounds, RGBA_Bytes.Black); return(currentlyPrintingHeightPixels - (lineBounds.Height + PartPaddingPixels)); }
private void CreateRectangularBedGridImage(Vector3 displayVolumeToBuild, Vector2 bedCenter) { int linesInX = (int)Math.Ceiling(displayVolumeToBuild.x / 10); int linesInY = (int)Math.Ceiling(displayVolumeToBuild.y / 10); lock (lastCreatedBedImage) { Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY); BedImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA()); Graphics2D graphics2D = BedImage.NewGraphics2D(); graphics2D.Clear(bedBaseColor); { double lineDist = BedImage.Width / (displayVolumeToBuild.x / 10.0); double xPositionCm = (-(displayVolume.x / 2.0) + bedCenter.x) / 10.0; int xPositionCmInt = (int)Math.Round(xPositionCm); double fraction = xPositionCm - xPositionCmInt; int pointSize = 20; graphics2D.DrawString(xPositionCmInt.ToString(), 4, 4, pointSize, color: bedMarkingsColor); for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Width; linePos += lineDist) { xPositionCmInt++; int linePosInt = (int)linePos; int lineWidth = 1; if (xPositionCmInt == 0) { lineWidth = 2; } graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor, lineWidth); graphics2D.DrawString(xPositionCmInt.ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor); } } { double lineDist = BedImage.Height / (displayVolumeToBuild.y / 10.0); double yPositionCm = (-(displayVolume.y / 2.0) + bedCenter.y) / 10.0; int yPositionCmInt = (int)Math.Round(yPositionCm); double fraction = yPositionCm - yPositionCmInt; int pointSize = 20; for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Height; linePos += lineDist) { yPositionCmInt++; int linePosInt = (int)linePos; int lineWidth = 1; if (yPositionCmInt == 0) { lineWidth = 2; } graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor, lineWidth); graphics2D.DrawString(yPositionCmInt.ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor); } } lastCreatedBedImage = BedImage; lastLinesCount = new Point2D(linesInX, linesInY); } }
//////////////////////////////////////////////////////////////////////////// //--------------------------------- REVISIONS ------------------------------ // Date Name Tracking # Description // --------- ------------------- ------------- ---------------------- // 21JUN2009 James Shen Initial Creation //////////////////////////////////////////////////////////////////////////// /** * Clear the map canvas with given color. * @param color the color to fill the whole map canvas. */ public override void ClearCanvas(int color) { if (SharedGraphics2D != null) { SharedGraphics2D.Clear(new Color(color)); _mapNameHolder.Clear(); } }
private void drawInternal(Graphics2D graphics) { lock (drawSync) { graphics.Clear(Color4.Black); foreach (var item in drawCommands) { item(graphics); } } }
public void TakePhoto(string imageFileName) { ImageBuffer noCameraImage = new ImageBuffer(640, 480); Graphics2D graphics = noCameraImage.NewGraphics2D(); graphics.Clear(Color.White); graphics.DrawString("No Camera Detected", 320, 240, pointSize: 24, justification: Agg.Font.Justification.Center); graphics.DrawString(DateTime.Now.ToString(), 320, 200, pointSize: 12, justification: Agg.Font.Justification.Center); AggContext.ImageIO.SaveImageData(imageFileName, noCameraImage); PictureTaken?.Invoke(null, null); }
private static void CreateButtonImages(out ImageBuffer togetherBig, out ImageBuffer appartBig) { PathStorage upArrow = new PathStorage(); upArrow.MoveTo(0, 0); upArrow.LineTo(.5, -.5); upArrow.LineTo(.25, -.5); upArrow.LineTo(.25, -1); upArrow.LineTo(-.25, -1); upArrow.LineTo(-.25, -.5); upArrow.LineTo(-.5, -.5); int buttonSize = 32; int arrowSize = buttonSize / 3; togetherBig = new ImageBuffer(buttonSize, buttonSize, 32, new BlenderBGRA()); Graphics2D togetherBigGraphics = togetherBig.NewGraphics2D(); togetherBigGraphics.Clear(RGBA_Bytes.White); int margin = buttonSize / 16; int lineWidth = buttonSize / 16; togetherBigGraphics.FillRectangle(margin, buttonSize / 2 + margin, buttonSize - margin, buttonSize / 2 + margin + lineWidth, RGBA_Bytes.Black); togetherBigGraphics.FillRectangle(margin, buttonSize / 2 - margin, buttonSize - margin, buttonSize / 2 - margin - lineWidth, RGBA_Bytes.Black); appartBig = new ImageBuffer(togetherBig); // point up Affine totalTransform = Affine.NewScaling(arrowSize, arrowSize); totalTransform *= Affine.NewTranslation(buttonSize / 2, buttonSize / 2 - margin - lineWidth); togetherBigGraphics.Render(new VertexSourceApplyTransform(upArrow, totalTransform), RGBA_Bytes.Black); // point down totalTransform = Affine.NewRotation(MathHelper.Tau / 2); totalTransform *= Affine.NewScaling(arrowSize, arrowSize); totalTransform *= Affine.NewTranslation(buttonSize / 2, buttonSize / 2 + margin + lineWidth); togetherBigGraphics.Render(new VertexSourceApplyTransform(upArrow, totalTransform), RGBA_Bytes.Black); Graphics2D appartBigGraphics = appartBig.NewGraphics2D(); // point up totalTransform = Affine.NewScaling(arrowSize, arrowSize); totalTransform *= Affine.NewTranslation(buttonSize / 2, buttonSize / 2 + margin + lineWidth + arrowSize + 1); appartBigGraphics.Render(new VertexSourceApplyTransform(upArrow, totalTransform), RGBA_Bytes.Black); // point down totalTransform = Affine.NewRotation(MathHelper.Tau / 2); totalTransform *= Affine.NewScaling(arrowSize, arrowSize); totalTransform *= Affine.NewTranslation(buttonSize / 2, buttonSize / 2 - margin - lineWidth - arrowSize - 1); appartBigGraphics.Render(new VertexSourceApplyTransform(upArrow, totalTransform), RGBA_Bytes.Black); }
private static ImageBuffer BuildImageFromMeshGroups(IObject3D loadedItem, int width, int height, bool debugNonManifoldEdges = false) { var visibleMeshes = loadedItem.VisibleMeshes().ToList(); if (visibleMeshes?.Count > 0) { var tempImage = new ImageBuffer(width, height); Graphics2D partGraphics2D = tempImage.NewGraphics2D(); partGraphics2D.Clear(new Color()); AxisAlignedBoundingBox aabb = visibleMeshes[0].Mesh.GetAxisAlignedBoundingBox(visibleMeshes[0].WorldMatrix()); for (int i = 1; i < visibleMeshes.Count; i++) { aabb = AxisAlignedBoundingBox.Union(aabb, visibleMeshes[i].Mesh.GetAxisAlignedBoundingBox(visibleMeshes[i].WorldMatrix())); } double maxSize = Math.Max(aabb.XSize, aabb.YSize); double scale = width / (maxSize * 1.2); var bounds2D = new RectangleDouble(aabb.MinXYZ.X, aabb.MinXYZ.Y, aabb.MaxXYZ.X, aabb.MaxXYZ.Y); foreach (var meshGroup in visibleMeshes) { PolygonMesh.Rendering.OrthographicZProjection.DrawTo( partGraphics2D, meshGroup.Mesh, meshGroup.WorldMatrix(), new Vector2( (width / scale - bounds2D.Width) / 2 - bounds2D.Left, (height / scale - bounds2D.Height) / 2 - bounds2D.Bottom), scale, meshGroup.WorldColor()); } if (debugNonManifoldEdges) { foreach (var loadedMesh in visibleMeshes) { throw new NotImplementedException(); //List<MeshEdge> nonManifoldEdges = loadedMesh.Mesh.GetNonManifoldEdges(); //if (nonManifoldEdges.Count > 0) //{ // partGraphics2D.Circle(width / 4, width / 4, width / 8, Color.Red); //} } } // Force to all white and return return(tempImage); } return(null); }
public override void OnDraw(Graphics2D graphics2D) { CameraCalibrationWidget_OnDraw.Start(); graphics2D.Clear(RGBA_Bytes.White); rect_d rect = new rect_d(Width - 40, 10, Width - 10, 40); graphics2D.Rectangle(rect, RGBA_Bytes.Black); Invalidate(rect); base.OnDraw(graphics2D); CameraCalibrationWidget_OnDraw.Stop(); }
private void CreateRectangularBedGridImage(Vector3 displayVolumeToBuild, Vector2 bedCenter, double divisor, double skip) { lock (lastCreatedBedImage) { BedImage = new ImageBuffer(1024, 1024); Graphics2D graphics2D = BedImage.NewGraphics2D(); graphics2D.Clear(bedBaseColor); { double lineDist = BedImage.Width / (displayVolumeToBuild.X / divisor); double xPositionCm = (-(displayVolume.X / 2.0) + bedCenter.X) / divisor; int xPositionCmInt = (int)Math.Round(xPositionCm); double fraction = xPositionCm - xPositionCmInt; int pointSize = 20; graphics2D.DrawString((xPositionCmInt * skip).ToString(), 4, 4, pointSize, color: bedMarkingsColor); for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Width; linePos += lineDist) { xPositionCmInt++; int linePosInt = (int)linePos; int lineWidth = 1; if (xPositionCmInt == 0) { lineWidth = 2; } graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor, lineWidth); graphics2D.DrawString((xPositionCmInt * skip).ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor); } } { double lineDist = BedImage.Height / (displayVolumeToBuild.Y / divisor); double yPositionCm = (-(displayVolume.Y / 2.0) + bedCenter.Y) / divisor; int yPositionCmInt = (int)Math.Round(yPositionCm); double fraction = yPositionCm - yPositionCmInt; int pointSize = 20; for (double linePos = lineDist * (1 - fraction); linePos < BedImage.Height; linePos += lineDist) { yPositionCmInt++; int linePosInt = (int)linePos; int lineWidth = 1; if (yPositionCmInt == 0) { lineWidth = 2; } graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor, lineWidth); graphics2D.DrawString((yPositionCmInt * skip).ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor); } } lastCreatedBedImage = BedImage; } }
public override void OnDraw(Graphics2D graphics2D) { MatterCadWidget_OnDraw.Start(); graphics2D.Clear(RGBA_Bytes.White); rect_d rect = new rect_d(Width - 40, 10, Width - 10, 40); graphics2D.FillRectangle(rect, previewWindowRayTrace.mouseOverColor); graphics2D.Rectangle(rect, RGBA_Bytes.Black); Invalidate(rect); base.OnDraw(graphics2D); MatterCadWidget_OnDraw.Stop(); }
private static ImageBuffer BuildImageFromMeshGroups(List <MeshGroup> loadedMeshGroups, string stlHashCode, Point2D size) { if (loadedMeshGroups != null && loadedMeshGroups.Count > 0 && loadedMeshGroups[0].Meshes != null && loadedMeshGroups[0].Meshes[0] != null) { ImageBuffer tempImage = new ImageBuffer(size.x, size.y); Graphics2D partGraphics2D = tempImage.NewGraphics2D(); partGraphics2D.Clear(new RGBA_Bytes()); AxisAlignedBoundingBox aabb = loadedMeshGroups[0].GetAxisAlignedBoundingBox(); for (int meshGroupIndex = 1; meshGroupIndex < loadedMeshGroups.Count; meshGroupIndex++) { aabb = AxisAlignedBoundingBox.Union(aabb, loadedMeshGroups[meshGroupIndex].GetAxisAlignedBoundingBox()); } double maxSize = Math.Max(aabb.XSize, aabb.YSize); double scale = size.x / (maxSize * 1.2); RectangleDouble bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y); foreach (MeshGroup meshGroup in loadedMeshGroups) { foreach (Mesh loadedMesh in meshGroup.Meshes) { PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh, new Vector2((size.x / scale - bounds2D.Width) / 2 - bounds2D.Left, (size.y / scale - bounds2D.Height) / 2 - bounds2D.Bottom), scale, RGBA_Bytes.White); } } if (File.Exists("RunUnitTests.txt")) { foreach (Mesh loadedMesh in loadedMeshGroups[0].Meshes) { List <MeshEdge> nonManifoldEdges = loadedMesh.GetNonManifoldEdges(); if (nonManifoldEdges.Count > 0) { partGraphics2D.Circle(size.x / 4, size.x / 4, size.x / 8, RGBA_Bytes.Red); } } } tempImage.SetRecieveBlender(new BlenderPreMultBGRA()); AllWhite.DoAllWhite(tempImage); // and give it back return(tempImage); } return(null); }
private void LoadStl_Click(object sender, EventArgs e) { OpenFileDialogParams opeParams = new OpenFileDialogParams("STL Files|*.stl"); FileDialog.OpenFileDialog(opeParams, (openParams) => { var streamToLoadFrom = File.Open(openParams.FileName, FileMode.Open); if (streamToLoadFrom != null) { var loadedFileName = openParams.FileName; meshToRender = StlProcessing.Load(streamToLoadFrom); ImageBuffer plateInventory = new ImageBuffer((int)(300 * 8.5), 300 * 11, 32, new BlenderBGRA()); Graphics2D plateGraphics = plateInventory.NewGraphics2D(); plateGraphics.Clear(RGBA_Bytes.White); double inchesPerMm = 0.0393701; double pixelsPerInch = 300; double pixelsPerMm = inchesPerMm * pixelsPerInch; AxisAlignedBoundingBox aabb = meshToRender.GetAxisAlignedBoundingBox(); Vector2 lowerLeftInMM = new Vector2(-aabb.minXYZ.x, -aabb.minXYZ.y); Vector3 centerInMM = (aabb.maxXYZ - aabb.minXYZ) / 2; Vector2 offsetInMM = new Vector2(20, 30); { RectangleDouble bounds = new RectangleDouble(offsetInMM.x * pixelsPerMm, offsetInMM.y * pixelsPerMm, (offsetInMM.x + aabb.maxXYZ.x - aabb.minXYZ.x) * pixelsPerMm, (offsetInMM.y + aabb.maxXYZ.y - aabb.minXYZ.y) * pixelsPerMm); bounds.Inflate(3 * pixelsPerMm); RoundedRect rect = new RoundedRect(bounds, 3 * pixelsPerMm); plateGraphics.Render(rect, RGBA_Bytes.LightGray); Stroke rectOutline = new Stroke(rect, .5 * pixelsPerMm); plateGraphics.Render(rectOutline, RGBA_Bytes.DarkGray); } OrthographicZProjection.DrawTo(plateGraphics, meshToRender, lowerLeftInMM + offsetInMM, pixelsPerMm); plateGraphics.DrawString(Path.GetFileName(openParams.FileName), (offsetInMM.x + centerInMM.x) * pixelsPerMm, (offsetInMM.y - 10) * pixelsPerMm, 50, Agg.Font.Justification.Center); //ImageBuffer logoImage = new ImageBuffer(); //ImageIO.LoadImageData("Logo.png", logoImage); //plateGraphics.Render(logoImage, (plateInventory.Width - logoImage.Width) / 2, plateInventory.Height - logoImage.Height - 10 * pixelsPerMm); //ImageIO.SaveImageData("plate Inventory.jpeg", plateInventory); } }); }
public override void Draw(Graphics2D g) { // Draw2(g); ////1. //// clear the image to white g.Clear(ColorRGBA.White); //------------------------------------ g.UseSubPixelRendering = true; // draw some text string teststr = "ABCDE abcd 1230 Hello!"; g.DrawString(teststr, 300, 400, 22); g.UseSubPixelRendering = false; g.DrawString(teststr, 300, 422, 22); }
public void CompareToLionTGA() { LionShape lionShape = new LionShape(); ImageBuffer renderedImage = new ImageBuffer(512, 400, 24, new BlenderBGR()); byte alpha = (byte)(.1 * 255); for (int i = 0; i < lionShape.NumPaths; i++) { lionShape.Colors[i].Alpha0To255 = alpha; } Affine transform = Affine.NewIdentity(); transform *= Affine.NewTranslation(-lionShape.Center.x, -lionShape.Center.y); transform *= Affine.NewTranslation(renderedImage.Width / 2, renderedImage.Height / 2); // This code renders the lion: VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(lionShape.Path, transform); Graphics2D renderer = renderedImage.NewGraphics2D(); renderer.Clear(new RGBA_Floats(1.0, 1.0, 1.0, 1.0)); renderer.Render(transformedPathStorage, lionShape.Colors, lionShape.PathIndex, lionShape.NumPaths); ImageTgaIO.Save(renderedImage, "TestOutput.tga"); Stream imageStream = File.Open("LionRenderMaster.tga", FileMode.Open); ImageBuffer masterImage = new ImageBuffer(); ImageTgaIO.LoadImageData(masterImage, imageStream, 24); bool sameWidth = masterImage.Width == renderedImage.Width; bool sameHeight = masterImage.Height == renderedImage.Height; Assert.IsTrue(sameWidth && sameHeight); Assert.IsTrue(masterImage.BitDepth == renderedImage.BitDepth); int unused; byte[] masterBuffer = masterImage.GetBuffer(out unused); byte[] renderedBuffer = renderedImage.GetBuffer(out unused); Assert.IsTrue(masterBuffer.Length == renderedBuffer.Length); for (int i = 0; i < masterBuffer.Length; i++) { if (masterBuffer[i] != renderedBuffer[i]) { Assert.IsTrue(false); } } }
private void CreateRectangularBedGridImage(int linesInX, int linesInY) { using (TimedLock.Lock(lastCreatedBedImage, "CreateRectangularBedGridImage")) { if (linesInX == lastLinesCount.x && linesInY == lastLinesCount.y) { BedImage = lastCreatedBedImage; return; } Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY); BedImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA()); Graphics2D graphics2D = BedImage.NewGraphics2D(); graphics2D.Clear(bedBaseColor); { double lineDist = BedImage.Width / (double)linesInX; int count = 1; int pointSize = 20; graphics2D.DrawString(count.ToString(), 4, 4, pointSize, color: bedMarkingsColor); for (double linePos = lineDist; linePos < BedImage.Width; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor); graphics2D.DrawString(count.ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor); } } { double lineDist = BedImage.Height / (double)linesInY; int count = 1; int pointSize = 16; for (double linePos = lineDist; linePos < BedImage.Height; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor); graphics2D.DrawString(count.ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor); } } lastCreatedBedImage = BedImage; lastLinesCount = new Point2D(linesInX, linesInY); } }
//----------------------------------------------------------------------------- // Drawing //----------------------------------------------------------------------------- // Called every step to draw the game. public void Draw(Graphics2D g) { g.UseIntegerPrecision = true; // Render the game-state stack to a buffer. g.SetRenderTarget(GameData.RenderTargetGame); g.Begin(GameSettings.DRAW_MODE_DEFAULT); g.Clear(Color.Black); gameStateStack.Draw(g); g.End(); // Draw the buffer to the screen scaled. g.SetRenderTarget(null); g.ResetTranslation(); g.Begin(GameSettings.DRAW_MODE_DEFAULT); g.DrawImage(GameData.RenderTargetGame, Vector2F.Zero, Vector2F.Zero, new Vector2F(gameScale, gameScale), 0.0); g.End(); }
private static ImageBuffer BuildImageFromSTL(Mesh loadedMesh, string stlHashCode, Point2D size) { if (loadedMesh != null) { ImageBuffer tempImage = new ImageBuffer(size.x, size.y, 32, new BlenderBGRA()); Graphics2D partGraphics2D = tempImage.NewGraphics2D(); partGraphics2D.Clear(new RGBA_Bytes()); List <MeshEdge> nonManifoldEdges = loadedMesh.GetNonManifoldEdges(); if (nonManifoldEdges.Count > 0) { if (File.Exists("RunUnitTests.txt")) { partGraphics2D.Circle(4, 4, 4, RGBA_Bytes.Red); } } nonManifoldEdges = null; AxisAlignedBoundingBox aabb = loadedMesh.GetAxisAlignedBoundingBox(); double maxSize = Math.Max(aabb.XSize, aabb.YSize); double scale = size.x / (maxSize * 1.2); RectangleDouble bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y); PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh, new Vector2((size.x / scale - bounds2D.Width) / 2 - bounds2D.Left, (size.y / scale - bounds2D.Height) / 2 - bounds2D.Bottom), scale, RGBA_Bytes.White); // and save it to disk string applicationUserDataPath = ApplicationDataStorage.Instance.ApplicationUserDataPath; string folderToSavePrintsTo = Path.Combine(applicationUserDataPath, "data", "temp", "thumbnails"); string tgaFileName = Path.Combine(folderToSavePrintsTo, "{0}_{1}x{2}.tga".FormatWith(stlHashCode, size.x, size.y)); if (!Directory.Exists(folderToSavePrintsTo)) { Directory.CreateDirectory(folderToSavePrintsTo); } ImageTgaIO.SaveImageData(tgaFileName, tempImage); // and give it back return(tempImage); } return(null); }
//----------------------------------------------------------------------------- // Overriden methods //----------------------------------------------------------------------------- protected override void Draw() { Graphics2D g = new Graphics2D(spriteBatch); //g.SetRenderTarget(GameData.RenderTargetGame); g.Begin(GameSettings.DRAW_MODE_DEFAULT); g.Clear(Color.White); g.Translate(new Vector2F(-this.HorizontalScroll.Value, -this.VerticalScroll.Value)); g.DrawImage(Tileset.SpriteSheet.Image.GetVariant(Zone.ImageVariantID), Point2I.Zero); Point2I tilePoint = SelectedTile * (Tileset.SpriteSheet.CellSize + Tileset.SpriteSheet.Spacing); g.DrawRectangle(new Rectangle2I(tilePoint, Tileset.SpriteSheet.CellSize + 1), 1, Color.White); g.DrawRectangle(new Rectangle2I(tilePoint + 1, Tileset.SpriteSheet.CellSize - 1), 1, Color.Black); g.DrawRectangle(new Rectangle2I(tilePoint - 1, Tileset.SpriteSheet.CellSize + 3), 1, Color.Black); g.ResetTranslation(); g.End(); }
public ImageBuffer CreateImage(string pngFileName) { graphics.Clear(Color.White); // draw all the mesh edges foreach (MeshEdge meshEdge in meshToRender.MeshEdges) { // draw the mesh edge DrawMeshEdge(meshEdge); } // draw all the vertices foreach (Vertex vertex in meshToRender.Vertices) { DrawVertex(vertex); } foreach (Face faceToRender in meshToRender.Faces) { Vector2 faceAverageCenter = new Vector2(); int vertexCount = 0; // draw all the vertices foreach (Vertex vertex in faceToRender.Vertices()) { Vector2 imagePosition = GetImagePosition(vertex.Position); faceAverageCenter += imagePosition; vertexCount++; } faceAverageCenter /= vertexCount; foreach (FaceEdge faceEdge in faceToRender.FaceEdges()) { // draw the face edge DrawFaceEdge(faceEdge, faceAverageCenter); } WriteStringAtPos(faceToRender.ID.ToString(), faceAverageCenter, faceColor); DrawRectangle(faceAverageCenter); WriteStringAtPos(faceToRender.firstFaceEdge.ID.ToString(), faceAverageCenter + new Vector2(0, -12), faceEdgeColor); } return(image); }
public void OnDraw(Graphics2D graphics2D) { graphics2D.Clear(ColorRGBA.White); #if true RenderGourand(graphics2D); #else agg.span_allocator span_alloc = new span_allocator(); span_gouraud_rgba span_gen = new span_gouraud_rgba(new rgba8(255, 0, 0, 255), new rgba8(0, 255, 0, 255), new rgba8(0, 0, 255, 255), 320, 220, 100, 100, 200, 100, 0); span_gouraud test_sg = new span_gouraud(new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), new rgba8(0, 0, 0, 255), 320, 220, 100, 100, 200, 100, 0); ras.add_path(test_sg); renderer_scanlines.render_scanlines_aa(ras, sl, ren_base, span_alloc, span_gen); //renderer_scanlines.render_scanlines_aa_solid(ras, sl, ren_base, new rgba8(0, 0, 0, 255)); #endif graphics2D.ScanlineRasterizer.ResetGamma(new GammaNone()); //m_dilation.Render(ras, sl, ren_base); //m_gamma.Render(ras, sl, ren_base); //m_alpha.Render(ras, sl, ren_base); }
public override void OnDraw(Graphics2D graphics2D) { ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect()); IImageByte backBuffer = widgetsSubImage; if (firstTime) { firstTime = false; m_SuperFast = new MatterHackers.Agg.UI.CheckBox(10, 10, "Run Super Fast"); AddChild(m_SuperFast); m_Controller = new CController(backBuffer, 30, 40, .1, .7, .3, 4, 1, 2000); } graphics2D.Clear(new RGBA_Floats(1, 1, 1, 1)); graphics2D.Rasterizer.SetVectorClipBox(0, 0, (int)Width, (int)Height); m_Controller.FastRender(m_SuperFast.Checked); m_Controller.Render(graphics2D); //m_SuperFast.Render(graphics2D); base.OnDraw(graphics2D); }
void CreateBedGridImage(int linesInX, int linesInY) { Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY); bedCentimeterGridImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA()); Graphics2D graphics2D = bedCentimeterGridImage.NewGraphics2D(); graphics2D.Clear(RGBA_Bytes.White); { double lineDist = bedCentimeterGridImage.Width / (double)linesInX; int count = 1; int pointSize = 20; graphics2D.DrawString(count.ToString(), 0, 0, pointSize); for (double linePos = lineDist; linePos < bedCentimeterGridImage.Width; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(linePosInt, 0, linePosInt, bedCentimeterGridImage.Height, RGBA_Bytes.Black); graphics2D.DrawString(count.ToString(), linePos, 0, pointSize); } } { double lineDist = bedCentimeterGridImage.Height / (double)linesInY; int count = 1; int pointSize = 20; for (double linePos = lineDist; linePos < bedCentimeterGridImage.Height; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(0, linePosInt, bedCentimeterGridImage.Height, linePosInt, RGBA_Bytes.Black); graphics2D.DrawString(count.ToString(), 0, linePos, pointSize); } } }
void CreateRectangularBedGridImage(int linesInX, int linesInY) { Vector2 bedImageCentimeters = new Vector2(linesInX, linesInY); BedImage = new ImageBuffer(1024, 1024, 32, new BlenderBGRA()); Graphics2D graphics2D = BedImage.NewGraphics2D(); graphics2D.Clear(bedBaseColor); { double lineDist = BedImage.Width / (double)linesInX; int count = 1; int pointSize = 20; graphics2D.DrawString(count.ToString(), 4, 4, pointSize, color: bedMarkingsColor); for (double linePos = lineDist; linePos < BedImage.Width; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(linePosInt, 0, linePosInt, BedImage.Height, bedMarkingsColor); graphics2D.DrawString(count.ToString(), linePos + 4, 4, pointSize, color: bedMarkingsColor); } } { double lineDist = BedImage.Height / (double)linesInY; int count = 1; int pointSize = 16; for (double linePos = lineDist; linePos < BedImage.Height; linePos += lineDist) { count++; int linePosInt = (int)linePos; graphics2D.Line(0, linePosInt, BedImage.Height, linePosInt, bedMarkingsColor); graphics2D.DrawString(count.ToString(), 4, linePos + 4, pointSize, color: bedMarkingsColor); } } }
private void Initialize(ImageBufferFloat sourceImage, RectangleInt boundsToCopyFrom) { if (sourceImage == this) { throw new Exception("We do not create a temp buffer for this to work. You must have a source distinct from the dest."); } Deallocate(); Allocate(boundsToCopyFrom.Width, boundsToCopyFrom.Height, boundsToCopyFrom.Width * sourceImage.BitDepth / 8, sourceImage.BitDepth); SetRecieveBlender(sourceImage.GetBlender()); if (m_Width != 0 && m_Height != 0) { RectangleInt DestRect = new RectangleInt(0, 0, boundsToCopyFrom.Width, boundsToCopyFrom.Height); RectangleInt AbsoluteSourceRect = boundsToCopyFrom; // The first thing we need to do is make sure the frame is cleared. LBB [3/15/2004] Graphics2D graphics2D = NewGraphics2D(); graphics2D.Clear(new ColorF(0, 0, 0, 0)); int x = -boundsToCopyFrom.Left - (int)sourceImage.OriginOffset.X; int y = -boundsToCopyFrom.Bottom - (int)sourceImage.OriginOffset.Y; graphics2D.Render(sourceImage, x, y, 0, 1, 1); } }
/// <summary> /// Called when we've to draw the image. /// </summary> /// <param name="graphics">The graphics.</param> private void OnDraw(Graphics2D graphics) { if (IsDisposed) { throw new ObjectDisposedException("ImageDataFlowHelper"); } if (this.SyncBuffer == null) { return; } // Change bitmap contents if needed if (this.SyncBufferChanged) { lock (this.SyncBufferLock) { // Recreate bitmap on need if ((this.BitmapSize != this.SyncBufferSize) || (this.Bitmap == null)) { CommonTools.SafeDispose(ref this.Bitmap); this.Bitmap = new WriteableBitmapResource( new Size2(this.SyncBufferSize.Width, this.SyncBufferSize.Height), BitmapFormat.Bgra, AlphaMode.Ignore); this.BitmapSize = this.SyncBufferSize; } // Write data from SyncBuffer to bitmap this.Bitmap.SetBitmapContent( graphics, this.SyncBuffer.Pointer, this.SyncBuffer.Pitch); } } // Draw the bitmap on the screen if ((this.Bitmap != null) && (this.BitmapSize.Width > 0) && (this.BitmapSize.Height > 0)) { graphics.Clear(Color4.Transparent); // Draw the current contents of the stream RectangleF viewBounds = new RectangleF( 0f, 0f, graphics.ScreenSize.Width, graphics.ScreenSize.Height); graphics.DrawBitmap(this.Bitmap, viewBounds); // Draw the stream's name RectangleF titleBounds = new RectangleF( viewBounds.Width / 2f - 100f, 10f, 200f, 30f); graphics.FillRoundedRectangle(titleBounds, 5f, 5f, this.TextBackground); graphics.DrawText( this.StreamName, this.TextFormat, titleBounds, this.TextForeground); } }