public spline_ctrl(Vector2 location, Vector2 size, int num_pnt)
: base(location, false)
{
LocalBounds = new RectangleDouble(0, 0, size.x, size.y);
m_curve_pnt = new PathStorage();
m_curve_poly = new Stroke(m_curve_pnt);
m_ellipse = new Ellipse();
m_background_color = new RGBA_Bytes(1.0, 1.0, 0.9);
m_border_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_curve_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_inactive_pnt_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_active_pnt_color = new RGBA_Bytes(1.0, 0.0, 0.0);
m_num_pnt = (num_pnt);
m_border_width = (1.0);
m_border_extra = (0.0);
m_curve_width = (1.0);
m_point_size = (3.0);
m_curve_poly = new Stroke(m_curve_pnt);
m_idx = (0);
m_vertex = (0);
m_active_pnt = (-1);
m_move_pnt = (-1);
m_pdx = (0.0);
m_pdy = (0.0);
if (m_num_pnt < 4) m_num_pnt = 4;
if (m_num_pnt > 32) m_num_pnt = 32;
for (int i = 0; i < m_num_pnt; i++)
{
m_xp[i] = (double)(i) / (double)(m_num_pnt - 1);
m_yp[i] = 0.5;
}
calc_spline_box();
update_spline();
{
m_spline.init((int)m_num_pnt, m_xp, m_yp);
for (int i = 0; i < 256; i++)
{
m_spline_values[i] = m_spline.get((double)(i) / 255.0);
if (m_spline_values[i] < 0.0) m_spline_values[i] = 0.0;
if (m_spline_values[i] > 1.0) m_spline_values[i] = 1.0;
m_spline_values8[i] = (byte)(m_spline_values[i] * 255.0);
}
}
}
public bezier_ctrl_impl()
: base(new Vector2(0, 0))
{
m_stroke = new Stroke(m_curve);
m_poly = new polygon_ctrl_impl(4, 5.0);
m_idx = (0);
m_ellipse = new MatterHackers.Agg.VertexSource.Ellipse();
m_poly.in_polygon_check(false);
m_poly.SetXN(0, 100.0);
m_poly.SetYN(0, 0.0);
m_poly.SetXN(1, 100.0);
m_poly.SetYN(1, 50.0);
m_poly.SetXN(2, 50.0);
m_poly.SetYN(2, 100.0);
m_poly.SetXN(3, 0.0);
m_poly.SetYN(3, 100.0);
}
public override void OnDraw(Graphics2D graphics2D)
{
GammaLookUpTable gamma = new GammaLookUpTable(gammaSlider.Value);
IRecieveBlenderByte NormalBlender = new BlenderBGR();
IRecieveBlenderByte GammaBlender = new BlenderGammaBGR(gamma);
ImageBuffer rasterNormal = new ImageBuffer();
rasterNormal.Attach(graphics2D.DestImage, NormalBlender);
ImageBuffer rasterGamma = new ImageBuffer();
rasterGamma.Attach(graphics2D.DestImage, GammaBlender);
ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(rasterNormal);
ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma);
clippingProxyNormal.clear(new RGBA_Floats(1, 1, 1));
ScanlineRasterizer ras = new ScanlineRasterizer();
scanline_unpacked_8 sl = new scanline_unpacked_8();
int size_mul = (int)pixelSizeSlider.Value;
renderer_enlarged ren_en = new renderer_enlarged(size_mul);
StyledTypeFace type = new StyledTypeFace(LiberationSansFont.Instance, 12);
IVertexSource character = type.GetGlyphForCharacter('E');
character.rewind(0);
ras.reset();
ras.add_path(character);
ren_en.RenderSolid(clippingProxyGamma, ras, sl, RGBA_Bytes.Black);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(clippingProxyGamma, ras, sl, RGBA_Bytes.Black);
ras.gamma(new gamma_none());
PathStorage ps = new PathStorage();
Stroke pg = new Stroke(ps);
pg.width(2);
DrawBigA(graphics2D);
base.OnDraw(graphics2D);
}
public FloodFillDemo()
{
BackgroundColor = RGBA_Bytes.White;
imageToFillOn = new ImageBuffer(400, 300, 32, new BlenderBGRA());
Graphics2D imageToFillGraphics = imageToFillOn.NewGraphics2D();
imageToFillGraphics.Clear(RGBA_Bytes.White);
imageToFillGraphics.DrawString("Click to fill", 20, 30);
imageToFillGraphics.Circle(new Vector2(200, 150), 35, RGBA_Bytes.Black);
imageToFillGraphics.Circle(new Vector2(200, 150), 30, RGBA_Bytes.Green);
imageToFillGraphics.Rectangle(20, 50, 210, 280, RGBA_Bytes.Black);
imageToFillGraphics.Rectangle(imageToFillOn.GetBounds(), RGBA_Bytes.Blue);
Random rand = new Random();
for (int i = 0; i < 20; i++)
{
Ellipse elipse = new Ellipse(rand.Next(imageToFillOn.Width), rand.Next(imageToFillOn.Height), rand.Next(10, 60), rand.Next(10, 60));
Stroke outline = new Stroke(elipse);
imageToFillGraphics.Render(outline, RGBA_Bytes.Black);
}
m_slider1 = new Slider(new Vector2(80, 10), 510);
m_slider2 = new Slider(new Vector2(80, 10 + 20), 510);
m_slider1.ValueChanged += new EventHandler(NeedsRedraw);
m_slider2.ValueChanged += new EventHandler(NeedsRedraw);
AddChild(m_slider1);
AddChild(m_slider2);
m_slider1.Text = "Pixel size={0:F3}";
m_slider1.SetRange(8, 100);
m_slider1.NumTicks = 23;
m_slider1.Value = 32;
m_slider2.Text = "gamma={0:F3}";
m_slider2.SetRange(0.0, 3.0);
m_slider2.Value = 1.0;
}
public override void OnDraw(Graphics2D graphics2D)
{
//Trigger thumbnail generation if neeeded
if (!thumbNailHasBeenCreated && !processingThumbnail)
{
if (SetImageFast())
{
thumbNailHasBeenCreated = true;
OnDoneRendering();
}
else
{
Task.Run(() => LoadOrCreateThumbnail());
}
}
if (this.FirstWidgetUnderMouse)
{
RoundedRect rectBorder = new RoundedRect(this.LocalBounds, 0);
//graphics2D.Render(rectBorder, this.HoverBackgroundColor);
}
graphics2D.Render(thumbnailImage, Width / 2 - thumbnailImage.Width / 2, Height / 2 - thumbnailImage.Height / 2);
base.OnDraw(graphics2D);
if (HoverBorderColor.Alpha0To255 > 0)
{
RectangleDouble Bounds = LocalBounds;
RoundedRect borderRect = new RoundedRect(this.LocalBounds, this.borderRadius);
Stroke strokeRect = new Stroke(borderRect, BorderWidth);
graphics2D.Render(strokeRect, HoverBorderColor);
}
}
public override void OnDraw(Graphics2D graphics2D)
{
double fontHeight = internalTextWidget.Printer.TypeFaceStyle.EmSizeInPixels;
if (Selecting
&& SelectionIndexToStartBefore != CharIndexToInsertBefore)
{
Vector2 selectPosition = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(SelectionIndexToStartBefore);
// for each selected line draw a rect for the chars of that line
if (selectPosition.y == InsertBarPosition.y)
{
RectangleDouble bar = new RectangleDouble(Math.Ceiling(selectPosition.x),
Math.Ceiling(internalTextWidget.Height + selectPosition.y),
Math.Ceiling(InsertBarPosition.x + 1),
Math.Ceiling(internalTextWidget.Height + InsertBarPosition.y - fontHeight));
RoundedRect selectCursorRect = new RoundedRect(bar, 0);
graphics2D.Render(selectCursorRect, this.highlightColor);
}
else
{
int firstCharToHighlight = Math.Min(CharIndexToInsertBefore, SelectionIndexToStartBefore);
int lastCharToHighlight = Math.Max(CharIndexToInsertBefore, SelectionIndexToStartBefore);
int lineStart = firstCharToHighlight;
Vector2 lineStartPos = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(lineStart);
int lineEnd = lineStart + 1;
Vector2 lineEndPos = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(lineEnd);
if (lineEndPos.y != lineStartPos.y)
{
// we are starting on a '\n', adjust so we will show the cr at the end of the line
lineEndPos = lineStartPos;
}
bool firstCharOfLine = false;
for (int i = lineEnd; i < lastCharToHighlight + 1; i++)
{
Vector2 nextPos = internalTextWidget.Printer.GetOffsetLeftOfCharacterIndex(i);
if (firstCharOfLine)
{
if (lineEndPos.y != lineStartPos.y)
{
// we are starting on a '\n', adjust so we will show the cr at the end of the line
lineEndPos = lineStartPos;
}
firstCharOfLine = false;
}
if (nextPos.y != lineStartPos.y)
{
if (lineEndPos.x == lineStartPos.x)
{
lineEndPos.x += Printer.TypeFaceStyle.GetAdvanceForCharacter(' ');
}
RectangleDouble bar = new RectangleDouble(Math.Ceiling(lineStartPos.x),
Math.Ceiling(internalTextWidget.Height + lineStartPos.y),
Math.Ceiling(lineEndPos.x + 1),
Math.Ceiling(internalTextWidget.Height + lineEndPos.y - fontHeight));
RoundedRect selectCursorRect = new RoundedRect(bar, 0);
graphics2D.Render(selectCursorRect, this.highlightColor);
lineStartPos = nextPos;
firstCharOfLine = true;
}
else
{
lineEndPos = nextPos;
}
}
if (lineEndPos.x != lineStartPos.x)
{
RectangleDouble bar = new RectangleDouble(Math.Ceiling(lineStartPos.x),
Math.Ceiling(internalTextWidget.Height + lineStartPos.y),
Math.Ceiling(lineEndPos.x + 1),
Math.Ceiling(internalTextWidget.Height + lineEndPos.y - fontHeight));
RoundedRect selectCursorRect = new RoundedRect(bar, 0);
graphics2D.Render(selectCursorRect, this.highlightColor);
}
}
}
if (this.Focused && BarIsShowing)
{
double xFraction = graphics2D.GetTransform().tx;
xFraction = xFraction - (int)xFraction;
RectangleDouble bar2 = new RectangleDouble(Math.Ceiling(InsertBarPosition.x) - xFraction,
Math.Ceiling(internalTextWidget.Height + InsertBarPosition.y - fontHeight),
Math.Ceiling(InsertBarPosition.x + 1) - xFraction,
Math.Ceiling(internalTextWidget.Height + InsertBarPosition.y));
RoundedRect cursorRect = new RoundedRect(bar2, 0);
graphics2D.Render(cursorRect, this.cursorColor);
}
RectangleDouble boundsPlusPoint5 = LocalBounds;
boundsPlusPoint5.Inflate(-.5);
RoundedRect borderRect = new RoundedRect(boundsPlusPoint5, 0);
Stroke borderLine = new Stroke(borderRect);
base.OnDraw(graphics2D);
}
public override void OnDraw(Graphics2D graphics2D)
{
if (loadedGCode != null)
{
Affine transform = TotalTransform;
CreateGrid(transform);
double gridLineWidths = 0.2 * layerScale;
Stroke stroke = new Stroke(grid, gridLineWidths);
if (RenderGrid)
{
graphics2D.Render(stroke, new RGBA_Bytes(190, 190, 190, 255));
}
RenderType renderType = RenderType.Extrusions;
if (RenderMoves)
{
renderType |= RenderType.Moves;
}
if (RenderRetractions)
{
renderType |= RenderType.Retractions;
}
if (RenderSpeeds)
{
renderType |= RenderType.SpeedColors;
}
if (SimulateExtrusion)
{
renderType |= RenderType.SimulateExtrusion;
}
if (HideExtruderOffsets)
{
renderType |= RenderType.HideExtruderOffsets;
}
GCodeRenderInfo renderInfo = new GCodeRenderInfo(activeLayerIndex, activeLayerIndex, transform, layerScale, renderType,
FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1,
new Vector2[] { ActiveSliceSettings.Instance.GetOffset(0), ActiveSliceSettings.Instance.GetOffset(1) });
gCodeRenderer.Render(graphics2D, renderInfo);
}
base.OnDraw(graphics2D);
}
public gamma_ctrl(Vector2 position, Vector2 size)
: base(position, false)
{
Vector2 location = position;// Vector2.Zero;
LocalBounds = new RectangleDouble(0, 0, size.x, size.y);
m_border_width = (2.0);
m_border_extra = (0.0);
m_curve_width = (2.0);
m_grid_width = (0.2);
m_text_thickness = (1.5);
m_point_size = (5.0);
m_text_height = (9.0);
double x2 = location.x + size.x;
double y2 = location.y + size.y;
m_xc1 = location.x;
m_yc1 = location.y;
m_xc2 = (x2);
m_yc2 = (y2 - m_text_height * 2.0);
m_xt1 = location.x;
m_yt1 = (y2 - m_text_height * 2.0);
m_xt2 = (x2);
m_yt2 = (y2);
m_curve_poly = new Stroke(m_gamma_spline);
m_text_poly = new Stroke(m_text);
m_idx = (0);
m_vertex = (0);
m_p1_active = (true);
m_mouse_point = (0);
m_pdx = (0.0);
m_pdy = (0.0);
calc_spline_box();
m_background_color = new RGBA_Bytes(1.0, 1.0, 0.9);
m_border_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_curve_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_grid_color = new RGBA_Bytes(0.2, 0.2, 0.0);
m_inactive_pnt_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_active_pnt_color = new RGBA_Bytes(1.0, 0.0, 0.0);
m_text_color = new RGBA_Bytes(0.0, 0.0, 0.0);
m_colors[0] = m_curve_color;
m_colors[1] = m_grid_color;
m_colors[2] = m_inactive_pnt_color;
m_colors[3] = m_active_pnt_color;
m_colors[4] = m_text_color;
}
private void render_gpc(Graphics2D graphics2D)
{
switch (m_polygons.SelectedIndex)
{
case 0:
{
//------------------------------------
// Two simple paths
//
PathStorage ps1 = new PathStorage();
PathStorage ps2 = new PathStorage();
double x = m_x - Width / 2 + 100;
double y = m_y - Height / 2 + 100;
ps1.MoveTo(x + 140, y + 145);
ps1.LineTo(x + 225, y + 44);
ps1.LineTo(x + 296, y + 219);
ps1.ClosePolygon();
ps1.LineTo(x + 226, y + 289);
ps1.LineTo(x + 82, y + 292);
ps1.MoveTo(x + 220, y + 222);
ps1.LineTo(x + 363, y + 249);
ps1.LineTo(x + 265, y + 331);
ps1.MoveTo(x + 242, y + 243);
ps1.LineTo(x + 268, y + 309);
ps1.LineTo(x + 325, y + 261);
ps1.MoveTo(x + 259, y + 259);
ps1.LineTo(x + 273, y + 288);
ps1.LineTo(x + 298, y + 266);
ps2.MoveTo(100 + 32, 100 + 77);
ps2.LineTo(100 + 473, 100 + 263);
ps2.LineTo(100 + 351, 100 + 290);
ps2.LineTo(100 + 354, 100 + 374);
graphics2D.Render(ps1, new RGBA_Floats(0, 0, 0, 0.1).GetAsRGBA_Bytes());
graphics2D.Render(ps2, new RGBA_Floats(0, 0.6, 0, 0.1).GetAsRGBA_Bytes());
CreateAndRenderCombined(graphics2D, ps1, ps2);
}
break;
case 1:
{
//------------------------------------
// Closed stroke
//
PathStorage ps1 = new PathStorage();
PathStorage ps2 = new PathStorage();
Stroke stroke = new Stroke(ps2);
stroke.width(10.0);
double x = m_x - Width / 2 + 100;
double y = m_y - Height / 2 + 100;
ps1.MoveTo(x + 140, y + 145);
ps1.LineTo(x + 225, y + 44);
ps1.LineTo(x + 296, y + 219);
ps1.ClosePolygon();
ps1.LineTo(x + 226, y + 289);
ps1.LineTo(x + 82, y + 292);
ps1.MoveTo(x + 220 - 50, y + 222);
ps1.LineTo(x + 265 - 50, y + 331);
ps1.LineTo(x + 363 - 50, y + 249);
ps1.close_polygon(ShapePath.FlagsAndCommand.FlagCCW);
ps2.MoveTo(100 + 32, 100 + 77);
ps2.LineTo(100 + 473, 100 + 263);
ps2.LineTo(100 + 351, 100 + 290);
ps2.LineTo(100 + 354, 100 + 374);
ps2.ClosePolygon();
graphics2D.Render(ps1, new RGBA_Floats(0, 0, 0, 0.1).GetAsRGBA_Bytes());
graphics2D.Render(stroke, new RGBA_Floats(0, 0.6, 0, 0.1).GetAsRGBA_Bytes());
CreateAndRenderCombined(graphics2D, ps1, stroke);
}
break;
case 2:
{
//------------------------------------
// Great Britain and Arrows
//
PathStorage gb_poly = new PathStorage();
PathStorage arrows = new PathStorage();
GreatBritanPathStorage.Make(gb_poly);
make_arrows(arrows);
Affine mtx1 = Affine.NewIdentity();
Affine mtx2 = Affine.NewIdentity();
mtx1 *= Affine.NewTranslation(-1150, -1150);
mtx1 *= Affine.NewScaling(2.0);
mtx2 = mtx1;
mtx2 *= Affine.NewTranslation(m_x - Width / 2, m_y - Height / 2);
VertexSourceApplyTransform trans_gb_poly = new VertexSourceApplyTransform(gb_poly, mtx1);
VertexSourceApplyTransform trans_arrows = new VertexSourceApplyTransform(arrows, mtx2);
graphics2D.Render(trans_gb_poly, new RGBA_Floats(0.5, 0.5, 0, 0.1).GetAsRGBA_Bytes());
Stroke stroke_gb_poly = new Stroke(trans_gb_poly);
stroke_gb_poly.Width = 0.1;
graphics2D.Render(stroke_gb_poly, new RGBA_Floats(0, 0, 0).GetAsRGBA_Bytes());
graphics2D.Render(trans_arrows, new RGBA_Floats(0.0, 0.5, 0.5, 0.1).GetAsRGBA_Bytes());
CreateAndRenderCombined(graphics2D, trans_gb_poly, trans_arrows);
}
break;
case 3:
{
//------------------------------------
// Great Britain and a Spiral
//
spiral sp = new spiral(m_x, m_y, 10, 150, 30, 0.0);
Stroke stroke = new Stroke(sp);
stroke.width(15.0);
PathStorage gb_poly = new PathStorage();
GreatBritanPathStorage.Make(gb_poly);
Affine mtx = Affine.NewIdentity(); ;
mtx *= Affine.NewTranslation(-1150, -1150);
mtx *= Affine.NewScaling(2.0);
VertexSourceApplyTransform trans_gb_poly = new VertexSourceApplyTransform(gb_poly, mtx);
graphics2D.Render(trans_gb_poly, new RGBA_Floats(0.5, 0.5, 0, 0.1).GetAsRGBA_Bytes());
Stroke stroke_gb_poly = new Stroke(trans_gb_poly);
stroke_gb_poly.width(0.1);
graphics2D.Render(stroke_gb_poly, new RGBA_Floats(0, 0, 0).GetAsRGBA_Bytes());
graphics2D.Render(stroke, new RGBA_Floats(0.0, 0.5, 0.5, 0.1).GetAsRGBA_Bytes());
CreateAndRenderCombined(graphics2D, trans_gb_poly, stroke);
}
break;
case 4:
{
//------------------------------------
// Spiral and glyph
//
spiral sp = new spiral(m_x, m_y, 10, 150, 30, 0.0);
Stroke stroke = new Stroke(sp);
stroke.width(15.0);
PathStorage glyph = new PathStorage();
glyph.MoveTo(28.47, 6.45);
glyph.curve3(21.58, 1.12, 19.82, 0.29);
glyph.curve3(17.19, -0.93, 14.21, -0.93);
glyph.curve3(9.57, -0.93, 6.57, 2.25);
glyph.curve3(3.56, 5.42, 3.56, 10.60);
glyph.curve3(3.56, 13.87, 5.03, 16.26);
glyph.curve3(7.03, 19.58, 11.99, 22.51);
glyph.curve3(16.94, 25.44, 28.47, 29.64);
glyph.LineTo(28.47, 31.40);
glyph.curve3(28.47, 38.09, 26.34, 40.58);
glyph.curve3(24.22, 43.07, 20.17, 43.07);
glyph.curve3(17.09, 43.07, 15.28, 41.41);
glyph.curve3(13.43, 39.75, 13.43, 37.60);
glyph.LineTo(13.53, 34.77);
glyph.curve3(13.53, 32.52, 12.38, 31.30);
glyph.curve3(11.23, 30.08, 9.38, 30.08);
glyph.curve3(7.57, 30.08, 6.42, 31.35);
glyph.curve3(5.27, 32.62, 5.27, 34.81);
glyph.curve3(5.27, 39.01, 9.57, 42.53);
glyph.curve3(13.87, 46.04, 21.63, 46.04);
glyph.curve3(27.59, 46.04, 31.40, 44.04);
glyph.curve3(34.28, 42.53, 35.64, 39.31);
glyph.curve3(36.52, 37.21, 36.52, 30.71);
glyph.LineTo(36.52, 15.53);
glyph.curve3(36.52, 9.13, 36.77, 7.69);
glyph.curve3(37.01, 6.25, 37.57, 5.76);
glyph.curve3(38.13, 5.27, 38.87, 5.27);
glyph.curve3(39.65, 5.27, 40.23, 5.62);
glyph.curve3(41.26, 6.25, 44.19, 9.18);
glyph.LineTo(44.19, 6.45);
glyph.curve3(38.72, -0.88, 33.74, -0.88);
glyph.curve3(31.35, -0.88, 29.93, 0.78);
glyph.curve3(28.52, 2.44, 28.47, 6.45);
glyph.ClosePolygon();
glyph.MoveTo(28.47, 9.62);
glyph.LineTo(28.47, 26.66);
glyph.curve3(21.09, 23.73, 18.95, 22.51);
glyph.curve3(15.09, 20.36, 13.43, 18.02);
glyph.curve3(11.77, 15.67, 11.77, 12.89);
glyph.curve3(11.77, 9.38, 13.87, 7.06);
glyph.curve3(15.97, 4.74, 18.70, 4.74);
glyph.curve3(22.41, 4.74, 28.47, 9.62);
glyph.ClosePolygon();
Affine mtx = Affine.NewIdentity();
mtx *= Affine.NewScaling(4.0);
mtx *= Affine.NewTranslation(220, 200);
VertexSourceApplyTransform trans = new VertexSourceApplyTransform(glyph, mtx);
FlattenCurves curve = new FlattenCurves(trans);
CreateAndRenderCombined(graphics2D, stroke, curve);
graphics2D.Render(stroke, new RGBA_Floats(0, 0, 0, 0.1).GetAsRGBA_Bytes());
graphics2D.Render(curve, new RGBA_Floats(0, 0.6, 0, 0.1).GetAsRGBA_Bytes());
}
break;
}
}
public override void Render(Graphics2D graphics2D, Affine transform, double layerScale, RenderType renderType)
{
if ((renderType & RenderType.Extrusions) == RenderType.Extrusions)
{
double extrusionLineWidths = 0.2 * layerScale;
RGBA_Bytes extrusionColor = RGBA_Bytes.Black;
//extrusionColor = color;
PathStorage pathStorage = new PathStorage();
VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, transform);
Stroke stroke = new Stroke(transformedPathStorage, extrusionLineWidths);
stroke.line_cap(LineCap.Round);
stroke.line_join(LineJoin.Round);
pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.CommandMoveTo);
pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.CommandLineTo);
graphics2D.Render(stroke, 0, extrusionColor);
}
}
public override void Rectangle(double left, double bottom, double right, double top, RGBA_Bytes color, double strokeWidth)
{
RoundedRect rect = new RoundedRect(left + .5, bottom + .5, right - .5, top - .5, 0);
Stroke rectOutline = new Stroke(rect, strokeWidth);
Render(rectOutline, color);
}
private void CreateCircularBedGridImage(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 = 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.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);
}
}
public override void Render(Graphics2D graphics2D, Affine transform, double layerScale, RenderType renderType)
{
if ((renderType & RenderType.Moves) == RenderType.Moves)
{
double movementLineWidth = 0.35 * layerScale;
RGBA_Bytes movementColor = new RGBA_Bytes(10, 190, 15);
PathStorage pathStorage = new PathStorage();
VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, transform);
Stroke stroke = new Stroke(transformedPathStorage, movementLineWidth);
stroke.line_cap(LineCap.Round);
stroke.line_join(LineJoin.Round);
pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.CommandMoveTo);
if (end.x != start.x || end.y != start.y)
{
pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.CommandLineTo);
}
else
{
pathStorage.Add(end.x + .01, end.y, ShapePath.FlagsAndCommand.CommandLineTo);
}
graphics2D.Render(stroke, 0, movementColor);
}
}
public void StrokedShape()
{
ImageBuffer testImage = new ImageBuffer(100, 100, 32, new BlenderBGRA());
RoundedRect rect = new RoundedRect(20, 20, 80, 80, 5);
Stroke rectOutline = new Stroke(rect, 1);
testImage.NewGraphics2D().Render(rectOutline, RGBA_Bytes.White);
CheckTestAgainstControl(testImage, "DrawStroked");
CheckTestAgainstControl(rectOutline, "ShapeStroked");
}
public override void OnDraw(Graphics2D graphics2D)
{
if (loadedGCode != null)
{
//using (new PerformanceTimer("GCode Timer", "Total"))
{
Affine transform = TotalTransform;
if (RenderGrid)
{
//using (new PerformanceTimer("GCode Timer", "Render Grid"))
{
double gridLineWidths = 0.2 * layerScale;
Graphics2DOpenGL graphics2DGl = graphics2D as Graphics2DOpenGL;
if (graphics2DGl != null)
{
GlRenderGrid(graphics2DGl, transform, gridLineWidths);
}
else
{
CreateGrid(transform);
Stroke stroke = new Stroke(grid, gridLineWidths);
graphics2D.Render(stroke, gridColor);
}
}
}
RenderType renderType = RenderType.Extrusions;
if (RenderMoves)
{
renderType |= RenderType.Moves;
}
if (RenderRetractions)
{
renderType |= RenderType.Retractions;
}
if (RenderSpeeds)
{
renderType |= RenderType.SpeedColors;
}
if (SimulateExtrusion)
{
renderType |= RenderType.SimulateExtrusion;
}
if (HideExtruderOffsets)
{
renderType |= RenderType.HideExtruderOffsets;
}
GCodeRenderInfo renderInfo = new GCodeRenderInfo(activeLayerIndex, activeLayerIndex, transform, layerScale, renderType,
FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1,
new Vector2[] { ActiveSliceSettings.Instance.GetOffset(0), ActiveSliceSettings.Instance.GetOffset(1) });
//using (new PerformanceTimer("GCode Timer", "Render"))
{
gCodeRenderer.Render(graphics2D, renderInfo);
}
}
}
base.OnDraw(graphics2D);
}
public override void OnDraw(Graphics2D graphics2D)
{
if (loadedGCode != null)
{
Affine transform = TotalTransform;
CreateGrid(transform);
double gridLineWidths = 0.2 * layerScale;
Stroke stroke = new Stroke(grid, gridLineWidths);
if (RenderGrid)
{
graphics2D.Render(stroke, RGBA_Bytes.DarkGray);
}
RenderType renderType = RenderType.Extrusions;
if (RenderMoves)
{
renderType |= RenderType.Moves;
}
if (RenderRetractions)
{
renderType |= RenderType.Retractions;
}
GCodeRenderInfo renderInfo = new GCodeRenderInfo(activeLayerIndex, activeLayerIndex, transform, layerScale, renderType,
FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1, null);
gCodeRenderer.Render(graphics2D, renderInfo);
}
base.OnDraw(graphics2D);
}
public polygon_ctrl_impl(int np, double point_radius)
: base(new Vector2())
{
m_ellipse = new MatterHackers.Agg.VertexSource.Ellipse();
m_polygon = new ArrayPOD<double>(np * 2);
m_num_points = (np);
m_node = (-1);
m_edge = (-1);
m_vs = new simple_polygon_vertex_source(m_polygon.Array, m_num_points, false);
m_stroke = new Stroke(m_vs);
m_point_radius = (point_radius);
m_status = (0);
m_dx = (0.0);
m_dy = (0.0);
m_in_polygon_check = (true);
m_stroke.width(1.0);
}
public static CCSprite CreateLine(
int width, int height,
CCColor4B stroke,
double strokeThickness = 1
)
{
ImageBuffer buffer = new ImageBuffer(width, height, 32, new BlenderRGBA());
Graphics2D g = buffer.NewGraphics2D();
if (stroke.A > 0)
{
//g.Line没有厚度
PathStorage linesToDraw = new PathStorage();
linesToDraw.remove_all();
linesToDraw.MoveTo(0, 0);
linesToDraw.LineTo(width, height);
Stroke StrockedLineToDraw = new Stroke(linesToDraw, strokeThickness);
g.Render(StrockedLineToDraw, new RGBA_Bytes(stroke.R, stroke.G, stroke.B, stroke.A));
}
Texture2D xnaTexture = XnaTexture((int)width, (int)height);
xnaTexture.SetData<byte>(buffer.GetBuffer());
CCTexture2D ccTexture = new CCTexture2D();
ccTexture.InitWithTexture(xnaTexture);
return new CCSprite(ccTexture);
}
public override void OnDraw(Graphics2D graphics2D)
{
base.OnDraw(graphics2D);
RectangleDouble Bounds = LocalBounds;
RoundedRect borderRect = new RoundedRect(this.LocalBounds, 0);
Stroke strokeRect = new Stroke(borderRect, borderWidth);
graphics2D.Render(strokeRect, borderColor);
}
//直线
public UIGraphic AddLine(float x1, float y1, float x2, float y2, CCColor4B stroke, double strokeThickness = 1)
{
if (stroke.A > 0)
{
//g.Line没有厚度
PathStorage linesToDraw = new PathStorage();
linesToDraw.remove_all();
linesToDraw.MoveTo(x1, y1);
linesToDraw.LineTo(x2, y2);
Stroke StrockedLineToDraw = new Stroke(linesToDraw, strokeThickness);
this.graphics2D.Render(StrockedLineToDraw, new RGBA_Bytes(stroke.R, stroke.G, stroke.B, stroke.A));
}
return this;
}
private void DrawBorder(Graphics2D graphics2D)
{
RectangleDouble Bounds = LocalBounds;
RoundedRect borderRect = new RoundedRect(this.LocalBounds, 0);
Stroke strokeRect = new Stroke(borderRect, borderWidth);
graphics2D.Render(strokeRect, borderColor);
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
GammaLookUpTable gamma = new GammaLookUpTable(gammaSlider.Value);
IRecieveBlenderByte NormalBlender = new BlenderBGRA();
IRecieveBlenderByte GammaBlender = new BlenderGammaBGRA(gamma);
ImageBuffer rasterGamma = new ImageBuffer();
rasterGamma.Attach(widgetsSubImage, GammaBlender);
ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(widgetsSubImage);
ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma);
clippingProxyNormal.clear(new RGBA_Floats(1, 1, 1));
ScanlineRasterizer rasterizer = new ScanlineRasterizer();
scanline_unpacked_8 sl = new scanline_unpacked_8();
int size_mul = (int)pixelSizeSlider.Value;
renderer_enlarged ren_en = new renderer_enlarged(size_mul);
rasterizer.reset();
rasterizer.move_to_d(m_x[0] / size_mul, m_y[0] / size_mul);
rasterizer.line_to_d(m_x[1] / size_mul, m_y[1] / size_mul);
rasterizer.line_to_d(m_x[2] / size_mul, m_y[2] / size_mul);
ren_en.RenderSolid(clippingProxyGamma, rasterizer, sl, RGBA_Bytes.Black);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.RenderSolid(clippingProxyGamma, rasterizer, sl, RGBA_Bytes.Black);
rasterizer.gamma(new gamma_none());
PathStorage ps = new PathStorage();
Stroke pg = new Stroke(ps);
pg.width(2);
ps.remove_all();
ps.MoveTo(m_x[0], m_y[0]);
ps.LineTo(m_x[1], m_y[1]);
ps.LineTo(m_x[2], m_y[2]);
ps.LineTo(m_x[0], m_y[0]);
rasterizer.add_path(pg);
scanlineRenderer.RenderSolid(clippingProxyNormal, rasterizer, sl, new RGBA_Bytes(0, 150, 160, 200));
base.OnDraw(graphics2D);
}
public void Line(double x1, double y1, double x2, double y2, RGBA_Bytes color, double strokeWidth = 1)
{
PathStorage m_LinesToDraw = new PathStorage();
m_LinesToDraw.remove_all();
m_LinesToDraw.MoveTo(x1, y1);
m_LinesToDraw.LineTo(x2, y2);
Stroke StrockedLineToDraw = new Stroke(m_LinesToDraw, strokeWidth);
Render(StrockedLineToDraw, color);
}
public override void OnDraw(Graphics2D graphics2D)
{
if (loadedGCode != null)
{
Affine transform = TotalTransform;
CreateGrid(transform);
double gridLineWidths = 0.2 * layerScale;
Stroke stroke = new Stroke(grid, gridLineWidths);
if (RenderGrid)
{
graphics2D.Render(stroke, new RGBA_Bytes(190, 190, 190, 255));
}
RenderType renderType = RenderType.Extrusions;
if (RenderMoves)
{
renderType |= RenderType.Moves;
}
if (RenderRetractions)
{
renderType |= RenderType.Retractions;
}
if (RenderSpeeds)
{
renderType |= RenderType.SpeedColors;
}
if (SimulateExtrusion)
{
renderType |= RenderType.SimulateExtrusion;
}
gCodeRenderer.Render(graphics2D, activeLayerIndex, transform, layerScale, renderType,
FeatureToStartOnRatio0To1, FeatureToEndOnRatio0To1);
}
base.OnDraw(graphics2D);
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
if (!didInit)
{
didInit = true;
OnInitialize();
}
if (m_gamma.Value != m_old_gamma)
{
m_gamma_lut.SetGamma(m_gamma.Value);
ImageIO.LoadImageData("spheres.bmp", m_SourceImage);
//m_SourceImage.apply_gamma_dir(m_gamma_lut);
m_old_gamma = m_gamma.Value;
}
ImageBuffer pixf = new ImageBuffer();
switch (widgetsSubImage.BitDepth)
{
case 24:
pixf.Attach(widgetsSubImage, new BlenderBGR());
break;
case 32:
pixf.Attach(widgetsSubImage, new BlenderBGRA());
break;
default:
throw new NotImplementedException();
}
ImageClippingProxy clippingProxy = new ImageClippingProxy(pixf);
clippingProxy.clear(new RGBA_Floats(1, 1, 1));
if (m_trans_type.SelectedIndex < 2)
{
// For the affine parallelogram transformations we
// calculate the 4-th (implicit) point of the parallelogram
m_quad.SetXN(3, m_quad.GetXN(0) + (m_quad.GetXN(2) - m_quad.GetXN(1)));
m_quad.SetYN(3, m_quad.GetYN(0) + (m_quad.GetYN(2) - m_quad.GetYN(1)));
}
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
// draw a background to show how the alpha is working
int RectWidth = 70;
int xoffset = 50;
int yoffset = 50;
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 7; j++)
{
if ((i + j) % 2 != 0)
{
VertexSource.RoundedRect rect = new VertexSource.RoundedRect(i * RectWidth + xoffset, j * RectWidth + yoffset,
(i + 1) * RectWidth + xoffset, (j + 1) * RectWidth + yoffset, 2);
rect.normalize_radius();
g_rasterizer.add_path(rect);
scanlineRenderer.RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(.2, .2, .2));
}
}
}
//--------------------------
// Render the "quad" tool and controls
g_rasterizer.add_path(m_quad);
scanlineRenderer.RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0.3, 0.5, 0.1));
// Prepare the polygon to rasterize. Here we need to fill
// the destination (transformed) polygon.
g_rasterizer.SetVectorClipBox(0, 0, Width, Height);
g_rasterizer.reset();
int b = 0;
g_rasterizer.move_to_d(m_quad.GetXN(0) - b, m_quad.GetYN(0) - b);
g_rasterizer.line_to_d(m_quad.GetXN(1) + b, m_quad.GetYN(1) - b);
g_rasterizer.line_to_d(m_quad.GetXN(2) + b, m_quad.GetYN(2) + b);
g_rasterizer.line_to_d(m_quad.GetXN(3) - b, m_quad.GetYN(3) + b);
//typedef agg::span_allocator<color_type> span_alloc_type;
span_allocator sa = new span_allocator();
image_filter_bilinear filter_kernel = new image_filter_bilinear();
ImageFilterLookUpTable filter = new ImageFilterLookUpTable(filter_kernel, true);
ImageBufferAccessorClamp source = new ImageBufferAccessorClamp(m_SourceImage);
stopwatch.Restart();
switch (m_trans_type.SelectedIndex)
{
case 0:
{
/*
agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
interpolator_type interpolator(tr);
typedef image_filter_2x2_type<source_type,
interpolator_type> span_gen_type;
span_gen_type sg(source, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 1:
{
/*
agg::trans_affine tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
typedef agg::span_interpolator_linear<agg::trans_affine> interpolator_type;
typedef image_resample_affine_type<source_type> span_gen_type;
interpolator_type interpolator(tr);
span_gen_type sg(source, interpolator, filter);
sg.blur(m_blur.Value);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
*/
break;
}
case 2:
{
/*
agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
if(tr.is_valid())
{
typedef agg::span_interpolator_linear_subdiv<agg::trans_perspective> interpolator_type;
interpolator_type interpolator(tr);
typedef image_filter_2x2_type<source_type,
interpolator_type> span_gen_type;
span_gen_type sg(source, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
}
*/
break;
}
case 3:
{
/*
agg::trans_perspective tr(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
if(tr.is_valid())
{
typedef agg::span_interpolator_trans<agg::trans_perspective> interpolator_type;
interpolator_type interpolator(tr);
typedef image_filter_2x2_type<source_type,
interpolator_type> span_gen_type;
span_gen_type sg(source, interpolator, filter);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
}
*/
break;
}
case 4:
{
//typedef agg::span_interpolator_persp_lerp<> interpolator_type;
//typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
span_interpolator_persp_lerp interpolator = new span_interpolator_persp_lerp(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
span_subdiv_adaptor subdiv_adaptor = new span_subdiv_adaptor(interpolator);
span_image_resample sg = null;
if (interpolator.is_valid())
{
switch (source.SourceImage.BitDepth)
{
case 24:
sg = new span_image_resample_rgb(source, subdiv_adaptor, filter);
break;
case 32:
sg = new span_image_resample_rgba(source, subdiv_adaptor, filter);
break;
}
sg.blur(m_blur.Value);
scanlineRenderer.GenerateAndRender(g_rasterizer, g_scanline, clippingProxy, sa, sg);
}
break;
}
case 5:
{
/*
typedef agg::span_interpolator_persp_exact<> interpolator_type;
typedef agg::span_subdiv_adaptor<interpolator_type> subdiv_adaptor_type;
interpolator_type interpolator(m_quad.polygon(), g_x1, g_y1, g_x2, g_y2);
subdiv_adaptor_type subdiv_adaptor(interpolator);
if(interpolator.is_valid())
{
typedef image_resample_type<source_type,
subdiv_adaptor_type> span_gen_type;
span_gen_type sg(source, subdiv_adaptor, filter);
sg.blur(m_blur.Value);
agg::render_scanlines_aa(g_rasterizer, g_scanline, rb_pre, sa, sg);
}
*/
break;
}
}
double tm = stopwatch.ElapsedMilliseconds;
//pixf.apply_gamma_inv(m_gamma_lut);
gsv_text t = new gsv_text();
t.SetFontSize(10.0);
Stroke pt = new Stroke(t);
pt.width(1.5);
string buf = string.Format("{0:F2} ms", tm);
t.start_point(10.0, 70.0);
t.text(buf);
g_rasterizer.add_path(pt);
scanlineRenderer.RenderSolid(clippingProxy, g_rasterizer, g_scanline, new RGBA_Bytes(0, 0, 0));
//--------------------------
//m_trans_type.Render(g_rasterizer, g_scanline, clippingProxy);
//m_gamma.Render(g_rasterizer, g_scanline, clippingProxy);
//m_blur.Render(g_rasterizer, g_scanline, clippingProxy);
base.OnDraw(graphics2D);
}
public override void Rectangle(double left, double bottom, double right, double top, RGBA_Bytes color, double strokeWidth)
{
#if true
// This only works for translation. If we have a rotation or scale in the transform this will have some problems.
Affine transform = GetTransform();
double fastLeft = left;
double fastBottom = bottom;
double fastRight = right;
double fastTop = top;
transform.transform(ref fastLeft, ref fastBottom);
transform.transform(ref fastRight, ref fastTop);
if (fastLeft == (int)fastLeft
&& fastBottom == (int)fastBottom
&& fastRight == (int)fastRight
&& fastTop == (int)fastTop)
{
// FillRectangle will do the traslation so use the original variables
FillRectangle(left, bottom, right, bottom + 1, color);
FillRectangle(left, top, right, top - 1, color);
FillRectangle(left, bottom, left + 1, top, color);
FillRectangle(right - 1, bottom, right, top, color);
}
else
#endif
{
RoundedRect rect = new RoundedRect(left + .5, bottom + .5, right - .5, top - .5, 0);
Stroke rectOutline = new Stroke(rect, strokeWidth);
Render(rectOutline, color);
}
}
public void SavingFunction()
{
currentlySaving = true;
countThatHaveBeenSaved = 0;
// first create images for all the parts
foreach (FileNameAndPresentationName stlFileNames in stlFilesToPrint)
{
Mesh loadedMesh = StlProcessing.Load(stlFileNames.fileName);
if (loadedMesh != null)
{
AxisAlignedBoundingBox aabb = loadedMesh.GetAxisAlignedBoundingBox();
RectangleDouble bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y);
double widthInMM = bounds2D.Width + PartMarginMM * 2;
double textSpaceMM = 5;
double heightMM = textSpaceMM + bounds2D.Height + PartMarginMM * 2;
TypeFacePrinter typeFacePrinter = new TypeFacePrinter(stlFileNames.presentationName, 28, Vector2.Zero, Justification.Center, Baseline.BoundsCenter);
double sizeOfNameX = typeFacePrinter.GetSize().x + PartMarginPixels * 2;
Vector2 sizeOfRender = new Vector2(widthInMM * PixelPerMM, heightMM * PixelPerMM);
ImageBuffer imageOfPart = new ImageBuffer((int)(Math.Max(sizeOfNameX, sizeOfRender.x)), (int)(sizeOfRender.y), 32, new BlenderBGRA());
typeFacePrinter.Origin = new Vector2(imageOfPart.Width / 2, (textSpaceMM / 2) * PixelPerMM);
Graphics2D partGraphics2D = imageOfPart.NewGraphics2D();
RectangleDouble rectBounds = new RectangleDouble(0, 0, imageOfPart.Width, imageOfPart.Height);
double strokeWidth = .5 * PixelPerMM;
rectBounds.Inflate(-strokeWidth / 2);
RoundedRect rect = new RoundedRect(rectBounds, PartMarginMM * PixelPerMM);
partGraphics2D.Render(rect, RGBA_Bytes.LightGray);
Stroke rectOutline = new Stroke(rect, strokeWidth);
partGraphics2D.Render(rectOutline, RGBA_Bytes.DarkGray);
PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh, new Vector2(-bounds2D.Left + PartMarginMM, -bounds2D.Bottom + textSpaceMM + PartMarginMM), PixelPerMM, RGBA_Bytes.Black);
partGraphics2D.Render(typeFacePrinter, RGBA_Bytes.Black);
partImagesToPrint.Add(new PartImage(imageOfPart));
}
countThatHaveBeenSaved++;
if (UpdateRemainingItems != null)
{
UpdateRemainingItems(this, new StringEventArgs(Path.GetFileName(stlFileNames.presentationName)));
}
}
partImagesToPrint.Sort(BiggestToLittlestImages);
PdfDocument document = new PdfDocument();
document.Info.Title = "MatterHackers Parts Sheet";
document.Info.Author = "MatterHackers Inc.";
document.Info.Subject = "This is a list of the parts that are in a queue from MatterControl.";
document.Info.Keywords = "MatterControl, STL, 3D Printing";
int nextPartToPrintIndex = 0;
int plateNumber = 1;
bool done = false;
while (!done && nextPartToPrintIndex < partImagesToPrint.Count)
{
PdfPage pdfPage = document.AddPage();
CreateOnePage(plateNumber++, ref nextPartToPrintIndex, pdfPage);
}
try
{
// save the final document
document.Save(pathAndFileToSaveTo);
// Now try and open the document. This will lanch whatever PDF viewer is on the system and ask it
// to show the file (at least on Windows).
Process.Start(pathAndFileToSaveTo);
}
catch (Exception)
{
}
OnDoneSaving();
currentlySaving = false;
}
public override void OnDraw(Graphics2D graphics2D)
{
ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());
IImageByte backBuffer = widgetsSubImage;
GammaLookUpTable gamma = new GammaLookUpTable(m_gamma.Value);
IRecieveBlenderByte NormalBlender = new BlenderBGRA();
IRecieveBlenderByte GammaBlender = new BlenderGammaBGRA(gamma);
ImageBuffer rasterNormal = new ImageBuffer();
rasterNormal.Attach(backBuffer, NormalBlender);
ImageBuffer rasterGamma = new ImageBuffer();
rasterGamma.Attach(backBuffer, GammaBlender);
ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(rasterNormal);
ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma);
clippingProxyNormal.clear(m_white_on_black.Checked ? new RGBA_Floats(0, 0, 0) : new RGBA_Floats(1, 1, 1));
ScanlineRasterizer ras = new ScanlineRasterizer();
ScanlineCachePacked8 sl = new ScanlineCachePacked8();
VertexSource.Ellipse e = new VertexSource.Ellipse();
// TODO: If you drag the control circles below the bottom of the window we get an exception. This does not happen in AGG.
// It needs to be debugged. Turning on clipping fixes it. But standard agg works without clipping. Could be a bigger problem than this.
//ras.clip_box(0, 0, width(), height());
// Render two "control" circles
e.init(m_x[0], m_y[0], 3, 3, 16);
ras.add_path(e);
ScanlineRenderer scanlineRenderer = new ScanlineRenderer();
scanlineRenderer.render_scanlines_aa_solid(clippingProxyNormal, ras, sl, new RGBA_Bytes(127, 127, 127));
e.init(m_x[1], m_y[1], 3, 3, 16);
ras.add_path(e);
scanlineRenderer.render_scanlines_aa_solid(clippingProxyNormal, ras, sl, new RGBA_Bytes(127, 127, 127));
double d = m_offset.Value;
// Creating a rounded rectangle
VertexSource.RoundedRect r = new VertexSource.RoundedRect(m_x[0] + d, m_y[0] + d, m_x[1] + d, m_y[1] + d, m_radius.Value);
r.normalize_radius();
// Drawing as an outline
if (!m_DrawAsOutlineCheckBox.Checked)
{
Stroke p = new Stroke(r);
p.width(1.0);
ras.add_path(p);
}
else
{
ras.add_path(r);
}
scanlineRenderer.render_scanlines_aa_solid(clippingProxyGamma, ras, sl, m_white_on_black.Checked ? new RGBA_Bytes(255, 255, 255) : new RGBA_Bytes(0, 0, 0));
base.OnDraw(graphics2D);
}
public static void Main(string[] args)
{
// first we will show how to use the simple drawing functions in graphics 2D
{
ImageBuffer simpleImage = new ImageBuffer(640, 480, 32, new BlenderBGRA());
Graphics2D simpleImageGraphics2D = simpleImage.NewGraphics2D();
// clear the image to white
simpleImageGraphics2D.Clear(RGBA_Bytes.White);
// draw a circle
simpleImageGraphics2D.Circle(50, 50, 30, RGBA_Bytes.Blue);
// draw a line
simpleImageGraphics2D.Line(10, 100, 520, 50, new RGBA_Bytes(20, 200, 200));
// draw a filled box
simpleImageGraphics2D.FillRectangle(60, 260, 200, 280, RGBA_Bytes.Yellow);
// and an outline around it
simpleImageGraphics2D.Rectangle(60, 260, 200, 280, RGBA_Bytes.Magenta);
// draw some text
simpleImageGraphics2D.DrawString("A Simple Example", 300, 400, 20);
// and save this image out
ImageTgaIO.Save(simpleImage, "SimpleDrawAndSave.tga");
}
// now we will we will show how to use the render function to draw more complex things
{
ImageBuffer lessSimpleImage = new ImageBuffer(640, 480, 32, new BlenderBGRA());
Graphics2D lessSimpleImageGraphics2D = lessSimpleImage.NewGraphics2D();
// clear the image to white
lessSimpleImageGraphics2D.Clear(RGBA_Bytes.White);
// draw a circle
Ellipse ellipseTest = new Ellipse(0, 0, 100, 50);
for (double angleDegrees = 0; angleDegrees < 180; angleDegrees += 22.5)
{
VertexSourceApplyTransform rotatedTransform = new VertexSourceApplyTransform(ellipseTest, Affine.NewRotation(MathHelper.DegreesToRadians(angleDegrees)));
VertexSourceApplyTransform rotatedAndTranslatedTransform = new VertexSourceApplyTransform(rotatedTransform, Affine.NewTranslation(lessSimpleImage.Width / 2, 150));
lessSimpleImageGraphics2D.Render(rotatedAndTranslatedTransform, RGBA_Bytes.Yellow);
Stroke ellipseOutline = new Stroke(rotatedAndTranslatedTransform, 3);
lessSimpleImageGraphics2D.Render(ellipseOutline, RGBA_Bytes.Blue);
}
// and a little polygon
PathStorage littlePoly = new PathStorage();
littlePoly.MoveTo(50, 50);
littlePoly.LineTo(150, 50);
littlePoly.LineTo(200, 200);
littlePoly.LineTo(50, 150);
littlePoly.LineTo(50, 50);
lessSimpleImageGraphics2D.Render(littlePoly, RGBA_Bytes.Cyan);
// draw some text
TypeFacePrinter textPrinter = new TypeFacePrinter("Printing from a printer", 30, justification: Justification.Center);
IVertexSource translatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewTranslation(new Vector2(lessSimpleImage.Width / 2, lessSimpleImage.Height / 4 * 3)));
lessSimpleImageGraphics2D.Render(translatedText, RGBA_Bytes.Red);
Stroke strokedText = new Stroke(translatedText);
lessSimpleImageGraphics2D.Render(strokedText, RGBA_Bytes.Black);
IVertexSource rotatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewRotation(MathHelper.DegreesToRadians(90)));
IVertexSource rotatedTranslatedText = new VertexSourceApplyTransform(rotatedText, Affine.NewTranslation(new Vector2(40, lessSimpleImage.Height / 2)));
lessSimpleImageGraphics2D.Render(rotatedTranslatedText, RGBA_Bytes.Black);
// and save this image out
ImageTgaIO.Save(lessSimpleImage, "LessSimpleDrawAndSave.tga");
}
}
private void DrawBorder(Graphics2D graphics2D)
{
RectangleDouble Bounds = LocalBounds;
if (BorderWidth > 0)
{
if (BorderWidth == 1)
{
graphics2D.Rectangle(Bounds, BorderColor);
}
else
{
RoundedRect borderRect = new RoundedRect(this.LocalBounds, 0);
Stroke strokeRect = new Stroke(borderRect, BorderWidth);
graphics2D.Render(strokeRect, BorderColor);
}
}
}
