public Point2d IntersectY(int ypos) { Point2d pnt = new Point2d(); double minx, maxx; double miny, maxy; double yp = ypos; minx = (double)Math.Min(p1.x, p2.x); maxx = (double)Math.Max(p1.x, p2.x); miny = (double)Math.Min(p1.y, p2.y); maxy = (double)Math.Max(p1.y, p2.y); double yrange = maxy - miny;// the range of the x coord double scale = (double)((yp - miny) / yrange); //pnt.x = (int)LERP(minx, maxx, scale); Point2d pmin, pmax; if (p1.y < p2.y) // find the point with the min y { pmin = p1; pmax = p2; } else { pmin = p2; pmax = p1; } //pnt.x = (int)LERP(p2.x, p1.x, scale); pnt.x = (int)LERP(pmin.x, pmax.x, scale); pnt.y = ypos; return pnt; }
public Line2d() { p1 = new Point2d(); p2 = new Point2d(); }
/// <summary> /// This is the adaptive support generation, it should automatically /// detect overhangs, /// The way that it does this is by generating a closed polyline loop for each layer /// and checking the 2d projection of the current layer with the previous layer /// </summary> public void GenerateAdaptive() { //iterate through all the layers starting from z=0 // check every polyline in the current layer to make sure it is encased or overlaps polylines in the previous layer // generate a list of unsupported polylines // 'check' to see if the polyline can be dropped straight down // this has to do slicing of the scene SliceBuildConfig config = UVDLPApp.Instance().m_buildparms; List <UnsupportedRegions> lstunsup = new List <UnsupportedRegions>(); List <Object3d> lstsupports = new List <Object3d>(); // final list of supports int numslices = UVDLPApp.Instance().m_slicer.GetNumberOfSlices(config); float zlev = 0.0f; Slice curslice = null; Slice prevslice = null; int hxres = config.xres / 2; int hyres = config.yres / 2; for (int c = 0; c < numslices; c++) { if (m_cancel) { RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCancel, "Support Generation Cancelled", null); return; } RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eProgress, "" + c + "/" + numslices, null); Slice sl = UVDLPApp.Instance().m_slicer.GetSliceImmediate(zlev); sl.Optimize();// find loops zlev += (float)config.ZThick; prevslice = curslice; curslice = sl; Bitmap bm = new Bitmap(config.xres, config.yres); if (prevslice != null && curslice != null) { //render current slice curslice.RenderSlice(config, ref bm); //now render the previous slice overtop the current slice in another color Color savecol = UVDLPApp.Instance().m_appconfig.m_foregroundcolor; UVDLPApp.Instance().m_appconfig.m_foregroundcolor = Color.HotPink; //render previous slice over top prevslice.RenderSlice(config, ref bm); UVDLPApp.Instance().m_appconfig.m_foregroundcolor = savecol; // restore the color // create a lock bitmap for faster pixel access LockBitmap lbm = new LockBitmap(bm); lbm.LockBits(); // now, iterate through all optimized polylines in current slice // this approach isn't going to work, we need to iterate through all polyline //segments in a slice at once, each individual segment needs to know 1 thing // 1) the optimized segment it came from foreach (PolyLine3d pln in curslice.m_opsegs) { // each polyline region is checked separately bool plysupported = false; //split this optimized polyline back into 2-point segments for easier use List <PolyLine3d> segments = pln.Split(); List <Line2d> lines2d = Get2dLines(config, segments); // find the x/y min/max MinMax_XY mm = Slice.CalcMinMax_XY(lines2d); // iterate from the ymin to the ymax for (int y = mm.ymin; y < mm.ymax; y++) // this needs to be in scaled value { // get a line of lines that intersect this 2d line List <Line2d> intersecting = Slice.GetIntersecting2dYLines(y, lines2d); // get the list of point intersections List <Point2d> points = Slice.GetIntersectingPoints(y, intersecting); // sort the points in increasing x order points.Sort(); if (points.Count % 2 == 0) // is even { for (int cnt = 0; cnt < points.Count; cnt += 2) // increment by 2 { Point2d p1 = (Point2d)points[cnt]; Point2d p2 = (Point2d)points[cnt + 1]; Point pnt1 = new Point(); // create some points for drawing Point pnt2 = new Point(); pnt1.X = (int)(p1.x + config.XOffset + hxres); pnt1.Y = (int)(p1.y + config.YOffset + hyres); pnt2.X = (int)(p2.x + config.XOffset + hxres); pnt2.Y = (int)(p2.y + config.YOffset + hyres); //iterate from pnt1.X to pnt2.x and check colors for (int xc = pnt1.X; xc < pnt2.X; xc++) { Color checkcol = lbm.GetPixel(xc, pnt1.Y); // need to check the locked BM here for the right color // if the pixel color is the hot pink, then this region has some support // we're going to need to beef this up and probably divide this all into regions on a grid if (checkcol.R == Color.HotPink.R && checkcol.G == Color.HotPink.G && checkcol.B == Color.HotPink.B) { plysupported = true; } } } } else // flag error { DebugLogger.Instance().LogRecord("Row y=" + y + " odd # of points = " + points.Count + " - Model may have holes"); } }// for y = startminY to endY if (plysupported == false) { //generate a support, or mark where a support should be... lstunsup.Add(new UnsupportedRegions(pln)); } else { plysupported = true; } } // for each optimized polyline lbm.UnlockBits(); // unlock the bitmap } // prev and current slice are not null } // iterating through all slices RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCompleted, "Support Generation Completed", lstsupports); m_generating = false; }
//alright, it looks like I'm going to have to code up a 2d scanline fill algorithm // I suppose the first step is to convert all the 3d-ish polyline points in this slice into // 2d polylines, then use those to implement the fill /// <summary> /// This new slicing function renders into a pre-allocated bitmap /// </summary> /// <param name="sp"></param> /// <param name="bmp"></param> public void RenderSlice(SliceBuildConfig sp, ref Bitmap bmp) { try { Graphics graph = Graphics.FromImage(bmp); Point pnt1 = new Point(); // create some points for drawing Point pnt2 = new Point(); Pen pen = new Pen(UVDLPApp.Instance().m_appconfig.m_foregroundcolor, 1); //convert all to 2d lines int hxres = sp.xres / 2; int hyres = sp.yres / 2; List <Line2d> lines2d = Get2dLines(sp, m_segments); if (lines2d.Count == 0) { return; } Render2dlines(graph, lines2d, sp); // find the x/y min/max MinMax_XY mm = CalcMinMax_XY(lines2d); // iterate from the ymin to the ymax for (int y = mm.ymin; y < mm.ymax; y++) // this needs to be in scaled value { // get a line of lines that intersect this 2d line List <Line2d> intersecting = GetIntersecting2dYLines(y, lines2d); // get the list of point intersections List <Point2d> points = GetIntersectingPoints(y, intersecting); // sort the points in increasing x order //SortXIncreasing(points); points.Sort(); SortBackfaces(points); if (UVDLPApp.Instance().m_slicer.m_slicemethod == Slicer.eSliceMethod.eEvenOdd) { // draw the X-Spans (should be even number) // For a given pair of intersectin points // (Xi, Y), (Xj, Y) // −> Fill ceiling(Xi) to floor(Xj) if (points.Count % 2 == 0) // is even { for (int cnt = 0; cnt < points.Count; cnt += 2) // increment by 2 { Point2d p1 = (Point2d)points[cnt]; Point2d p2 = (Point2d)points[cnt + 1]; pnt1.X = (int)(p1.x + sp.XOffset + hxres); pnt1.Y = (int)(p1.y + sp.YOffset + hyres); pnt2.X = (int)(p2.x + sp.XOffset + hxres); pnt2.Y = (int)(p2.y + sp.YOffset + hyres); //graph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; graph.DrawLine(pen, pnt1.X, pnt1.Y, pnt2.X, pnt2.Y); } } else // flag error { DebugLogger.Instance().LogRecord("Row y=" + y + " odd # of points = " + points.Count + " - Model may have holes"); } } else if (UVDLPApp.Instance().m_slicer.m_slicemethod == Slicer.eSliceMethod.eNormalCount) { Point2d p1 = null; Point2d p2 = null; int turncount = 0; if (points.Count != 0) { for (int cnt = 0; cnt < points.Count; cnt++) { if (points[cnt].m_backfacing) { if (turncount == 0) //p1 == null) { p1 = (Point2d)points[cnt]; } turncount++; } else { //if (turncount > 0) turncount--; if ((turncount == 0) && (p1 != null)) { p2 = (Point2d)points[cnt]; pnt1.X = (int)(p1.x + sp.XOffset + hxres); pnt1.Y = (int)(p1.y + sp.YOffset + hyres); pnt2.X = (int)(p2.x + sp.XOffset + hxres); pnt2.Y = (int)(p2.y + sp.YOffset + hyres); //graph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; graph.DrawLine(pen, pnt1.X, pnt1.Y, pnt2.X, pnt2.Y); p1 = p2; p2 = null; } } } if (turncount != 0)// flag error { DebugLogger.Instance().LogRecord("Row y=" + y + " non equal in/outs = " + turncount + " - Model may have holes"); } } } } } catch (Exception ex) { DebugLogger.Instance().LogError(ex.Message); } }
/// <summary> /// This is the adaptive support generation, it should automatically /// detect overhangs, /// The way that it does this is by generating a closed polyline loop for each layer /// and checking the 2d projection of the current layer with the previous layer /// </summary> public void GenerateAdaptive() { //iterate through all the layers starting from z=0 // check every polyline in the current layer to make sure it is encased or overlaps polylines in the previous layer // generate a list of unsupported polylines // 'check' to see if the polyline can be dropped straight down // this has to do slicing of the scene try { SliceBuildConfig config = UVDLPApp.Instance().m_buildparms; config.UpdateFrom(UVDLPApp.Instance().m_printerinfo); // make sure we've got the correct display size and PixPerMM values if (UVDLPApp.Instance().m_slicer.SliceFile == null) { SliceFile sf = new SliceFile(config); sf.m_mode = SliceFile.SFMode.eImmediate; UVDLPApp.Instance().m_slicer.SliceFile = sf; // wasn't set } //create new list for each layer to hold unsupported regions List <UnsupportedRegions> lstunsup = new List <UnsupportedRegions>(); List <Object3d> lstsupports = new List <Object3d>(); // final list of supports int numslices = UVDLPApp.Instance().m_slicer.GetNumberOfSlices(config); float zlev = 0.0f; Slice curslice = null; Slice prevslice = null; int hxres = config.xres / 2; int hyres = config.yres / 2; for (int c = 0; c < numslices; c++) { //bool layerneedssupport = false; if (m_cancel) { RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCancel, "Support Generation Cancelled", null); return; } RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eProgress, "" + c + "/" + numslices, null); Slice sl = UVDLPApp.Instance().m_slicer.GetSliceImmediate(zlev); zlev += (float)config.ZThick; if (sl == null) { continue; } if (sl.m_segments == null) { continue; } if (sl.m_segments.Count == 0) { continue; } sl.Optimize();// find loops //sl.DetermineInteriorExterior(config); // mark the interior/exterior loops prevslice = curslice; curslice = sl; Bitmap bm = new Bitmap(config.xres, config.yres); using (Graphics gfx = Graphics.FromImage(bm)) using (SolidBrush brush = new SolidBrush(Color.Black)) { gfx.FillRectangle(brush, 0, 0, bm.Width, bm.Height); } if (prevslice != null && curslice != null) { //render current slice curslice.RenderSlice(config, ref bm); //now render the previous slice overtop the current slice in another color Color savecol = UVDLPApp.Instance().m_appconfig.m_foregroundcolor; UVDLPApp.Instance().m_appconfig.m_foregroundcolor = Color.HotPink; //render previous slice over top prevslice.RenderSlice(config, ref bm); UVDLPApp.Instance().m_appconfig.m_foregroundcolor = savecol; // restore the color // create a lock bitmap for faster pixel access LockBitmap lbm = new LockBitmap(bm); lbm.LockBits(); // now, iterate through all optimized polylines in current slice // this approach isn't going to work, we need to iterate through all polyline //segments in a slice at once, each individual segment needs to know 1 thing // 1) the optimized segment it came from //iterate through all optimized polygon segments Dictionary <PolyLine3d, bool> supportmap = new Dictionary <PolyLine3d, bool>(); foreach (PolyLine3d pln in curslice.m_opsegs) { bool plysupported = false; List <PolyLine3d> allsegments = new List <PolyLine3d>(); List <PolyLine3d> segments = pln.Split(); // split them, retaining the parent allsegments.AddRange(segments); //add all optimized polyline segments into the supported map supportmap.Add(pln, true); //split this optimized polyline back into 2-point segments for easier use List <Line2d> lines2d = Get2dLines(config, allsegments); if (lines2d.Count == 0) { continue; } // find the x/y min/max MinMax_XY mm = Slice.CalcMinMax_XY(lines2d); // iterate from the ymin to the ymax for (int y = mm.ymin; y < mm.ymax; y++) // this needs to be in scaled value { // get a line of lines that intersect this 2d line List <Line2d> intersecting = Slice.GetIntersecting2dYLines(y, lines2d); // get the list of point intersections List <Point2d> points = Slice.GetIntersectingPoints(y, intersecting); // sort the points in increasing x order points.Sort(); if (points.Count % 2 == 0) // is even { for (int cnt = 0; cnt < points.Count; cnt += 2) // increment by 2 { Point2d p1 = (Point2d)points[cnt]; Point2d p2 = (Point2d)points[cnt + 1]; Point pnt1 = new Point(); // create some points for drawing Point pnt2 = new Point(); pnt1.X = (int)(p1.x + config.XOffset + hxres); pnt1.Y = (int)(p1.y + config.YOffset + hyres); pnt2.X = (int)(p2.x + config.XOffset + hxres); pnt2.Y = (int)(p2.y + config.YOffset + hyres); //iterate from pnt1.X to pnt2.x and check colors for (int xc = pnt1.X; xc < pnt2.X; xc++) { if (xc >= lbm.Width || xc <= 0) { continue; } if (pnt1.Y >= lbm.Height || pnt1.Y <= 0) { continue; } try { Color checkcol = lbm.GetPixel(xc, pnt1.Y); // need to check the locked BM here for the right color // if the pixel color is the hot pink, then this region has some support // we're going to need to beef this up and probably divide this all into regions on a grid if (checkcol.R == Color.HotPink.R && checkcol.G == Color.HotPink.G && checkcol.B == Color.HotPink.B) { plysupported = true; } } catch (Exception ex) { DebugLogger.Instance().LogError(ex); } } } } else // flag error { DebugLogger.Instance().LogRecord("Row y=" + y + " odd # of points = " + points.Count + " - Model may have holes"); } }// for y = startminY to endY if (plysupported == false) { // layerneedssupport = true; supportmap[pln] = false; lstunsup.Add(new UnsupportedRegions(pln)); } } // for each optimized polyline lbm.UnlockBits(); // unlock the bitmap } // prev and current slice are not null //if (layerneedssupport) // SaveBM(bm, c); // uncomment this to see the layers that need support } // iterating through all slices // iterate through all unsupported regions // calculate the center // add a support from that region going down to the ground (or closest intersected) int scnt = 0; foreach (UnsupportedRegions region in lstunsup) { Support s = new Support(); Point3d center = region.Center(); // taking the center of the region is a naive approach float lz = center.z; AddNewSupport(center.x, center.y, center.z, scnt++, null, lstsupports); //region.ply.m_derived. /*s.Create(null,(float)m_sc.fbrad, (float)m_sc.ftrad, (float)m_sc.hbrad, (float)m_sc.htrad, lz * .2f, lz * .6f, lz * .2f, 11); * s.Translate((float)center.x, (float)center.y, 0); * s.Name = "Support " + scnt; * s.SetColor(Color.Yellow); * scnt++; * lstsupports.Add(s); * RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eSupportGenerated, s.Name, s); */ } RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCompleted, "Support Generation Completed", lstsupports); m_generating = false; } catch (Exception ex) { DebugLogger.Instance().LogError(ex); } }