/// <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;
        }
        /// <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++)
            {
                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);
                sl.Optimize();// find loops
                //sl.DetermineInteriorExterior(config); // mark the interior/exterior loops
                zlev += (float)config.ZThick;
                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);
                        // 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)
                        {

                            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);
            } // iterating through all slices
            RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCompleted, "Support Generation Completed", lstsupports);
            m_generating = false;
        }
Beispiel #3
0
        /// <summary>
        /// NOT CURRENTLY USED
        /// 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      = (float)(config.ZThick / 2.0);
                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;
                    lz += .65f;                       // why is this offset needed?
                    AddNewSupport(center.x, center.y, center.z, scnt++, null, lstsupports);
                }
                RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCompleted, "Support Generation Completed", lstsupports);
                m_generating = false;
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex);
            }
        }