Exemplo n.º 1
0
 public bool Save(string filename)
 {
     try
     {
         bool      retval = false;
         XmlWriter xw     = XmlWriter.Create(filename);
         m_filename = filename;
         xw.WriteStartDocument();
         xw.WriteStartElement("MachineConfig");
         xw.WriteElementString("FileVersion", FILE_VERSION.ToString());
         xw.WriteElementString("DLP_X_Res", m_XDLPRes.ToString());
         xw.WriteElementString("DLP_Y_Res", m_YDLPRes.ToString());
         xw.WriteElementString("PlatformXSize", m_PlatXSize.ToString());
         xw.WriteElementString("PlatformYSize", m_PlatYSize.ToString());
         xw.WriteElementString("PlatformZSize", m_PlatZSize.ToString());
         xw.WriteElementString("PixPermmX", m_Xpixpermm.ToString());
         xw.WriteElementString("PixPermmY", m_Ypixpermm.ToString());
         xw.WriteElementString("MaxXFeedRate", m_XMaxFeedrate.ToString());
         xw.WriteElementString("MaxYFeedRate", m_YMaxFeedrate.ToString());
         xw.WriteElementString("MaxZFeedRate", m_ZMaxFeedrate.ToString());
         xw.WriteElementString("MonitorID", m_monitorid.ToString());
         if (m_driverconfig.Save(xw))
         {
             retval = true;
         }
         xw.WriteEndElement();
         xw.WriteEndDocument();
         xw.Close();
         return(retval);
     }
     catch (Exception ex)
     {
         DebugLogger.Instance().LogRecord(ex.Message);
         return(false);
     }
 }
        public void SaveGCodes()
        {
            try
            {
                String profilepath = Path.GetDirectoryName(m_filename);
                profilepath += UVDLPApp.m_pathsep;
                profilepath += Path.GetFileNameWithoutExtension(m_filename);
                //create the directory if it doesn't exist
                if (!Directory.Exists(profilepath))
                {
                    Directory.CreateDirectory(profilepath);
                }

                SaveFile(profilepath + UVDLPApp.m_pathsep + "start.gcode", m_headercode);
                SaveFile(profilepath + UVDLPApp.m_pathsep + "end.gcode", m_footercode);
                SaveFile(profilepath + UVDLPApp.m_pathsep + "prelift.gcode", m_preliftcode);
                SaveFile(profilepath + UVDLPApp.m_pathsep + "postlift.gcode", m_postliftcode);
                SaveFile(profilepath + UVDLPApp.m_pathsep + "preslice.gcode", m_preslicecode);
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex.Message);
            }
        }
        /// <summary>
        /// This function will immediately return a bitmap slice at the specified Z-Level
        /// </summary>
        /// <param name="zlev"></param>
        /// <returns></returns>
        public Bitmap SliceImmediate(float curz)
        {
            try
            {
                //first take care of scaling up the output bitmap paramters size, so we can re-sample later
                double scaler = 1.5;             // specify the scale factor
                m_saved.CopyFrom(m_sf.m_config); // save the orginal
                if (m_sf.m_config.antialiasing == true)
                {
                    scaler = m_sf.m_config.aaval;
                    m_sf.m_config.dpmmX *= scaler;
                    m_sf.m_config.dpmmY *= scaler;
                    m_sf.m_config.xres   = (int)(scaler * m_sf.m_config.xres);
                    m_sf.m_config.yres   = (int)(scaler * m_sf.m_config.yres);
                }
                SliceBuildConfig sbf = new SliceBuildConfig(m_sf.m_config);          // save it

                Bitmap   bmp   = new Bitmap(m_sf.m_config.xres, m_sf.m_config.yres); // create a new bitmap on a per-slice basis
                Graphics graph = Graphics.FromImage(bmp);
                graph.Clear(UVDLPApp.Instance().m_appconfig.m_backgroundcolor);      //clear the image for rendering

                //convert all to 2d lines
                Bitmap savebm = null;
                // check for cancelation

                foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                {
                    savebm = bmp;                                                             // need to set this here in case it's not rendered
                    if (curz >= obj.m_min.z && curz <= obj.m_max.z)                           // only slice from the bottom to the top of the objects
                    {
                        List <Polygon>    lstply           = GetZPolys(obj, curz);            //get a list of polygons at this slice z height that potentially intersect
                        List <PolyLine3d> lstintersections = GetZIntersections(lstply, curz); //iterate through all the polygons and generate x/y line segments at this 3d z level
                        Slice             sl = new Slice();                                   //create a new slice
                        sl.m_segments = lstintersections;                                     // Set the list of intersections
                        sl.RenderSlice(m_sf.m_config, ref bmp);
                        savebm = bmp;
                    }
                }

                if (m_sf.m_config.antialiasing == true) // we're using anti-aliasing here, so resize the image
                {
                    savebm = ResizeImage(bmp, new Size(m_saved.xres, m_saved.yres));
                }
                if (m_sf.m_config.m_flipX == true)
                {
                    savebm = ReflectX(savebm);
                }
                if (m_sf.m_config.m_flipY == true)
                {
                    savebm = ReflectY(savebm);
                }
                //restore the original size
                m_sf.m_config.CopyFrom(m_saved);
                return(savebm);
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogRecord(ex.Message);
                return(null);
            }
        }
Exemplo n.º 4
0
        public void DoAppStartup()
        {
            m_dispmgr = DisplayManager.Instance();// initialze the displays
            m_apppath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            //get the path separater
            if (RunningPlatform() == Platform.Windows)
            {
                m_pathsep = "\\";
            }
            else
            {
                m_pathsep = "/";
            }
            // define some default paths
            m_PathMachines = m_apppath + m_pathsep + "Machines";  // use full paths - SHS
            m_PathProfiles = m_apppath + m_pathsep + "Profiles";

            // set up directories if they don't exist
            if (!Directory.Exists(m_PathMachines))
            {
                Utility.CreateDirectory(m_PathMachines);
            }
            if (!Directory.Exists(m_PathProfiles))
            {
                Utility.CreateDirectory(m_PathProfiles);
            }

            if (!m_appconfig.Load(m_apppath + m_pathsep + m_appconfigname))  // use full path - SHS
            {
                m_appconfig.CreateDefault();
                m_appconfig.Save(m_apppath + m_pathsep + m_appconfigname);  // use full path - SHS
            }
            // this will check and make sure the default machines have been created
            CheckAndCreateDefaultMachines();
            //load the current machine configuration file
            if (!m_printerinfo.Load(m_appconfig.m_curmachineeprofilename))
            {
                // m_printerinfo.Save(m_appconfig.m_curmachineeprofilename);
                DebugLogger.Instance().LogError("Cannot Load Machine Profile " + m_appconfig.m_curmachineeprofilename);
            }
            // machine configuration was just loaded here.
            RaiseAppEvent(eAppEvent.eMachineTypeChanged, ""); // notify the gui to set up correctly
            //load the projector command list

            if (!LoadProjectorCommands(m_appconfig.ProjectorCommandsFile))
            {
                SaveProjectorCommands(m_appconfig.ProjectorCommandsFile);
            }
            //load the current slicing profile
            if (!m_buildparms.Load(m_appconfig.m_cursliceprofilename))
            {
                m_buildparms.CreateDefault();
                m_buildparms.Save(m_appconfig.m_cursliceprofilename);
            }
            // set up the drivers
            SetupDriver();
            //SetupDriverProjector();
            // load the support configuration
            if (!LoadSupportConfig(m_appconfig.SupportConfigName))
            {
                SaveSupportConfig(m_appconfig.SupportConfigName);
            }
            //load the license keys
            LoadLicenseKeys();
            //look for plug-ins and validate licensing
            ScanForPlugins();
            // validate those loaded plugins against license keys
            CheckLicensing();
            // initialize the plugins, the main form will send a secondary init after the main app gui is created
            PerformPluginCommand("InitCommand", true);
            m_sc = new ServerContact();
            m_sc.ServerContactEvenet += new ServerContact.Servercontacted(m_sc_ServerContactEvent);
            m_sc.UpdateRegInfo();
            m_undoer.RegisterCallback();
        }
Exemplo n.º 5
0
        //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);
            }
        }
Exemplo n.º 6
0
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
            SetDefaultCulture(System.Globalization.CultureInfo.InvariantCulture);
            Application.SetCompatibleTextRenderingDefault(false);
            //init the app object
            UVDLPApp.Instance().DoAppStartup(); // start the app and load the plug-ins
            //iterate through the plugins
            bool showlicensedialog = false;
            bool nosplash = false;
            //iterate through all plugins,
            // if they are un-licensed and enabled - show licensing dialog.
            foreach (PluginEntry pe in UVDLPApp.Instance().m_plugins)
            {
                if (pe.m_licensed == false && pe.m_enabled == true) // if we don't have a license, and it's marked enabled
                {
                    showlicensedialog = true;
                }
                int options = pe.m_plugin.GetInt("Options");
                if (options != -1 && pe.m_enabled == true) // check to see if this plugin has options
                {
                    if ((options & PluginOptions.OPTION_TIMED_TRIAL) != 0) // check for timed trial bit
                    {
                        // check for trial version
                        //start trial version
                        if (!CheckTrial(pe))
                        {
                            //disable the plug-in
                            pe.m_enabled = false;
                            //exit?
                            Application.Exit();
                            return;

                        }
                    }
                    if ((options & PluginOptions.OPTION_NOSPLASH) != 0)
                    {
                        nosplash = true;
                    }
                }

            }
            if (showlicensedialog == true)
            {
                frmPluginManager pim = new frmPluginManager();
                pim.ShowDialog();
            }
            try
            {
            #if !DEBUG  // no splash screen under debug release
                if (!nosplash)
                {
                    frmSplash splash = new frmSplash(); // should pull from a licensed plug-in if need-be
                    splash.Show();
                }
            #endif
                Application.Run(new frmMain2());
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex);
            }
        }
Exemplo n.º 7
0
        public void DoAppStartup()
        {
            m_dispmgr = DisplayManager.Instance();// initialze the displays
            m_apppath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
            //get the path separater
            if (RunningPlatform() == Platform.Windows)
            {
                m_pathsep = "\\";
            }
            else
            {
                m_pathsep = "/";
            }
            // define some default paths
            m_PathMachines = m_apppath + m_pathsep + "Machines";  // use full paths - SHS
            m_PathProfiles = m_apppath + m_pathsep + "Profiles";

            // set up directories if they don't exist
            if (!Directory.Exists(m_PathMachines))
            {
                Utility.CreateDirectory(m_PathMachines);
            }
            if (!Directory.Exists(m_PathProfiles))
            {
                Utility.CreateDirectory(m_PathProfiles);
            }

            if (!m_appconfig.Load(m_apppath + m_pathsep + m_appconfigname))  // use full path - SHS
            {
                m_appconfig.CreateDefault();
                m_appconfig.Save(m_apppath + m_pathsep + m_appconfigname);  // use full path - SHS
            }
            // this will check and make sure the default machines have been created
            CheckAndCreateDefaultMachines();
            //load the current machine configuration file
            if (!m_printerinfo.Load(m_appconfig.m_curmachineeprofilename))
            {
                // m_printerinfo.Save(m_appconfig.m_curmachineeprofilename);
                DebugLogger.Instance().LogError("Cannot Load Machine Profile " + m_appconfig.m_curmachineeprofilename);
            }
            // machine configuration was just loaded here.
            RaiseAppEvent(eAppEvent.eMachineTypeChanged, ""); // notify the gui to set up correctly
            //load the projector command list

            if (!LoadProjectorCommands(m_appconfig.ProjectorCommandsFile))
            {
                SaveProjectorCommands(m_appconfig.ProjectorCommandsFile);
            }
            //load the current slicing profile
            if (!m_buildparms.Load(m_appconfig.m_cursliceprofilename))
            {
                m_buildparms.CreateDefault();
                m_buildparms.Save(m_appconfig.m_cursliceprofilename);
            }
            else
            {
                m_buildparms.CreateDefault();
                m_buildparms.Load(m_appconfig.m_cursliceprofilename);
            }
            // set up the drivers
            SetupDriver();
            //SetupDriverProjector();
            // load the support configuration
            if (!LoadSupportConfig(m_appconfig.SupportConfigName))
            {
                SaveSupportConfig(m_appconfig.SupportConfigName);
            }
            //load the license keys
            LoadLicenseKeys();
            //look for plug-ins and validate licensing
            ScanForPlugins();
            //look for 'lite' plugins
            ScanForPluginsLite();
            // validate those loaded plugins against license keys
            CheckLicensing();
            // initialize the plugins, the main form will send a secondary init after the main app gui is created
            PerformPluginCommand("InitCommand", true);
            m_sc = new ServerContact();
            m_sc.ServerContactEvenet += new ServerContact.Servercontacted(m_sc_ServerContactEvent);

            //contacting Server twise?? commenting this out for now
            //m_sc.UpdateRegInfo();
            m_undoer.RegisterCallback();
            // pack all 2d gl images
            //m_2d_graphics.GenereteUserTexture();


            //load Rsource files

            //this is not good way to load resource files. but the problem is visual studio cant generate auto-generation code for names with dot "."

            resman = new ResourceManager("UV_DLP_3D_Printer.Resource.en", typeof(UVDLPApp).Assembly);
            cul    = CultureInfo.CreateSpecificCulture("");

            if (UVDLPApp.Instance().m_appconfig.m_Selected_Language == "es")
            {
                resman = new ResourceManager("UV_DLP_3D_Printer.Resource.es", typeof(UVDLPApp).Assembly);
                cul    = CultureInfo.CreateSpecificCulture("");
            }
            else if (UVDLPApp.Instance().m_appconfig.m_Selected_Language == "en")
            {
                resman = new ResourceManager("UV_DLP_3D_Printer.Resource.en", typeof(UVDLPApp).Assembly);
                cul    = CultureInfo.CreateSpecificCulture("");
            }
            else
            {
                resman = new ResourceManager("UV_DLP_3D_Printer.Resource.en", typeof(UVDLPApp).Assembly);
                cul    = CultureInfo.CreateSpecificCulture("");
            }
        }
        /*
         * This is the thread that controls the build process
         * it needs to read the lines of gcode, one by one
         * send them to the printer interface,
         * wait for the printer to respond,
         * and also wait for the layer interval timer
         */
        void BuildThread()
        {
            int now = GetTimerValue();
            int nextlayertime = 0;
            int sltime = -1, bltime = -1;

            while (m_running)
            {
                try
                {
                    //Thread.Sleep(1); //  sleep for 1 ms max
                    Thread.Sleep(0); //  sleep for 1 ms max
                    switch (m_state)
                    {
                    case BuildManager.STATE_START:
                        //start things off, reset some variables
                        RaiseStatusEvent(eBuildStatus.eBuildStarted, "Build Started");
                        m_state          = BuildManager.STATE_DO_NEXT_LAYER; // go to the first layer
                        m_gcodeline      = 0;                                // set the start line
                        m_curlayer       = 0;
                        m_printstarttime = new DateTime();
                        break;

                    case BuildManager.STATE_WAITING_FOR_LAYER:
                        //check time var
                        if (GetTimerValue() >= nextlayertime)
                        {
                            //   DebugLogger.Instance().LogInfo("elapsed Layer time: " + GetTimerValue().ToString());
                            //   DebugLogger.Instance().LogInfo("Diff = " + (GetTimerValue() - nextlayertime).ToString());
                            m_state = BuildManager.STATE_DO_NEXT_LAYER;     // move onto next layer
                        }
                        break;

                    case BuildManager.STATE_IDLE:
                        // do nothing
                        break;

                    case BuildManager.STATE_DO_NEXT_LAYER:
                        //check for done
                        if (m_gcodeline >= m_gcode.Lines.Length)
                        {
                            //we're done..
                            m_state = BuildManager.STATE_DONE;
                            continue;
                        }
                        string line = "";
                        // if the driver reports we're ready for the next command, or
                        // if we choose to ignore the driver ready status
                        if (UVDLPApp.Instance().m_deviceinterface.ReadyForCommand() || (UVDLPApp.Instance().m_appconfig.m_ignoreGCrsp == true))
                        {
                            // go through the gcode, line by line
                            line = m_gcode.Lines[m_gcodeline++];
                        }
                        else
                        {
                            continue;     // device is not ready
                        }
                        line = line.Trim();
                        if (line.Length > 0)     // if the line is not blank
                        {
                            // send  the line, whether or not it's a comment
                            // should check to see if the firmware is ready for another line

                            UVDLPApp.Instance().m_deviceinterface.SendCommandToDevice(line + "\r\n");
                            // if the line is a comment, parse it to see if we need to take action
                            if (line.Contains("<Delay> "))    // get the delay
                            {
                                nextlayertime = GetTimerValue() + getvarfromline(line);
                                //DebugLogger.Instance().LogInfo("Next Layer time: " + nextlayertime.ToString());
                                m_state = STATE_WAITING_FOR_LAYER;
                                continue;
                            }
                            else if (line.Contains("<DispCmd>"))      // display command
                            {
                                PerformDisplayCommand(line);
                            }
                            else if (line.Contains("<Slice> "))    //get the slice number
                            {
                                int    layer   = getvarfromline(line);
                                int    curtype = BuildManager.SLICE_NORMAL;  // assume it's a normal image to begin with
                                Bitmap bmp     = null;

                                if (layer == SLICE_BLANK)
                                {
                                    if (m_blankimage == null)      // blank image is null, create it
                                    {
                                        MakeBlank(m_sf.XRes, m_sf.YRes);
                                    }
                                    bmp     = m_blankimage;
                                    curtype = BuildManager.SLICE_BLANK;
                                    bltime  = GetTimerValue();
                                    //DebugLogger.Instance().LogInfo("Showing Blank image at :" + bltime.ToString());
                                    if (sltime != -1 && bltime != -1)
                                    {
                                        DebugLogger.Instance().LogInfo("Time between Blank and Slice :" + (bltime - sltime).ToString());
                                    }
                                }
                                else if (layer == SLICE_SPECIAL)     // plugins can override special images by named resource
                                {
                                    // get the special image from the plugin (no caching for now..)
                                    string special = GetSpecialName(line);
                                    bmp = UVDLPApp.Instance().GetPluginImage(special);
                                    if (bmp == null)              // no special image, even though it's specified..
                                    {
                                        if (m_blankimage == null) // blank image is null, create it
                                        {
                                            MakeBlank(m_sf.XRes, m_sf.YRes);
                                        }
                                        bmp = m_blankimage;
                                    }
                                    curtype = BuildManager.SLICE_BLANK;
                                }
                                else
                                {
                                    m_curlayer = layer;
                                    bmp        = m_sf.GetSliceImage(m_curlayer); // get the rendered image slice or load it if already rendered
                                    if (bmp == null)
                                    {
                                        DebugLogger.Instance().LogError("Buildmanager bitmap is null layer = " + m_curlayer + " ");
                                    }
                                    sltime = GetTimerValue();
                                    //DebugLogger.Instance().LogInfo("Showing Slice image at :" + sltime.ToString());
                                    if (sltime != -1 && bltime != -1)
                                    {
                                        DebugLogger.Instance().LogInfo("Time between slice and blank :" + (sltime - bltime).ToString());
                                    }
                                }

                                //raise a delegate so the main form can catch it and display layer information.
                                if (PrintLayer != null)
                                {
                                    PrintLayer(bmp, m_curlayer, curtype);
                                }
                            }
                        }
                        break;

                    case BuildManager.STATE_DONE:
                        try
                        {
                            m_running = false;
                            m_state   = BuildManager.STATE_IDLE;
                            StopBuildTimer();
                            DateTime endtime      = new DateTime();
                            double   totalminutes = (endtime - m_printstarttime).TotalMinutes;

                            m_printing = false;     // mark printing doe
                            //raise done message
                            RaiseStatusEvent(eBuildStatus.eBuildStatusUpdate, "Build 100% Completed");
                            RaiseStatusEvent(eBuildStatus.eBuildCompleted, "Build Completed");
                        }
                        catch (Exception ex)
                        {
                            DebugLogger.Instance().LogError(ex.StackTrace);
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    DebugLogger.Instance().LogError(ex.StackTrace);
                }
            }
        }
Exemplo n.º 9
0
        /*
         * This is the thread that controls the build process
         * it needs to read the lines of gcode, one by one
         * send them to the printer interface,
         * wait for the printer to respond,
         * and also wait for the layer interval timer
         */
        void BuildThread()
        {
            int now = GetTimerValue();
            int nextlayertime = 0;
            int sltime = -1, bltime = -1;

            while (m_running)
            {
                try
                {
                    Thread.Sleep(0); //  sleep for 1 ms max
                    switch (m_state)
                    {
                    case BuildManager.STATE_START:
                        //start things off, reset some variables
                        RaiseStatusEvent(eBuildStatus.eBuildStarted, "Build Started");
                        m_state = BuildManager.STATE_DO_NEXT_COMMAND;         // go to the first layer
                        UVDLPApp.Instance().m_deviceinterface.SetReady(true); // say we're ready
                        m_gcodeline      = 0;                                 // set the start line
                        m_curlayer       = 0;
                        m_printstarttime = new DateTime();
                        break;

                    case BuildManager.STATE_WAITING_FOR_DELAY:     // general delay statement
                        //check time var
                        if (GetTimerValue() >= nextlayertime)
                        {
                            m_state = BuildManager.STATE_DO_NEXT_COMMAND;     // move onto next layer
                        }
                        else
                        {
                            Thread.Sleep(1);     //  sleep for 1 ms to eliminate unnecessary cpu usage.
                        }
                        break;

                    case BuildManager.STATE_IDLE:
                        // do nothing
                        break;

                    case BuildManager.STATE_WAIT_DISPLAY:
                        // we're waiting on the display to tell us we're done
                        // this is used in the LaserSLA plugin, the normal DLP mode uses just a simple <Delay> command
                        //do nothing
                        break;

                    case BuildManager.STATE_DO_NEXT_COMMAND:
                        //check for done
                        if (m_gcodeline >= m_gcode.Lines.Length)
                        {
                            //we're done..
                            m_state = BuildManager.STATE_DONE;
                            continue;
                        }
                        string line = "";
                        // if the driver reports we're ready for the next command, or
                        // if we choose to ignore the driver ready status
                        if (UVDLPApp.Instance().m_deviceinterface.ReadyForCommand() || (UVDLPApp.Instance().m_appconfig.m_ignore_response == true))
                        {
                            // go through the gcode, line by line
                            line = m_gcode.Lines[m_gcodeline++];
#if (DEBUG)
                            DebugLogger.Instance().LogInfo("Building : " + line);
#endif
                        }
                        else
                        {
                            continue;     // device is not ready
                        }
                        line = line.Trim();
                        if (line.Length > 0)     // if the line is not blank
                        {
                            // send  the line, whether or not it's a comment - this is for a reason....
                            // should check to see if the firmware is ready for another line

                            UVDLPApp.Instance().m_deviceinterface.SendCommandToDevice(line + "\r\n");
                            // if the line is a comment, parse it to see if we need to take action
                            if (line.ToLower().Contains("<delay> "))    // get the delay
                            {
                                nextlayertime = GetTimerValue() + getvarfromline(line);
                                m_state       = STATE_WAITING_FOR_DELAY;
                                continue;
                            }
                            else if (line.ToLower().Contains("<dispcmd>"))      // display command
                            {
                                PerformDisplayCommand(line);
                            }
                            else if (line.ToLower().Contains("<waitfordisplay>"))      // wait for display to be done
                            {
                                m_state = BuildManager.STATE_WAIT_DISPLAY;
                            }
                            else if (line.ToLower().Contains("<auxcmd>"))     //auxillary command to run a pre-defined sequence
                            {
                                PerformAuxCommand(line);
                            }
                            else if (line.ToLower().Contains("<slice> "))    //get the slice number
                            {
                                int    layer     = getvarfromline(line);
                                int    curtype   = BuildManager.SLICE_NORMAL; // assume it's a normal image to begin with
                                Bitmap bmp       = null;
                                bool   isoutline = false;
                                if (layer == SLICE_BLANK)
                                {
                                    MakeBlank(m_sf.XRes, m_sf.YRes);
                                    bmp     = m_blankimage;
                                    curtype = BuildManager.SLICE_BLANK;
                                    bltime  = GetTimerValue();
                                }
                                else if (layer == SLICE_SPECIAL)     // plugins can override special images by named resource
                                {
                                    // get the special image from the plugin (no caching for now..)
                                    string special = GetSpecialName(line);
                                    bmp     = UVDLPApp.Instance().GetPluginImage(special);
                                    bmp.Tag = BuildManager.SLICE_SPECIAL;
                                    if (bmp == null)     // no special image, even though it's specified..
                                    {
                                        MakeBlank(m_sf.XRes, m_sf.YRes);
                                        bmp = m_blankimage;
                                    }
                                    curtype = BuildManager.SLICE_BLANK;
                                }
                                else if (layer == SLICE_OUTLINE)
                                {
                                    isoutline = true;
                                    // we're rendering the layer in an outline image
                                    // get the curlayer from the line
                                    m_curlayer = outlinelayer;
                                    if (m_sf != null)
                                    {
                                        bmp = m_sf.GetSliceImage(m_curlayer, true);    // get the rendered image slice or load it if already rendered
                                        if (bmp == null)
                                        {
                                            DebugLogger.Instance().LogError("Buildmanager bitmap is null layer = " + m_curlayer + " ");
                                        }
                                        else                                     // not null
                                        {
                                            bmp.Tag = BuildManager.SLICE_NORMAL; // set the tag to normal so it is destroyed
                                        }
                                    }
                                    else
                                    {
                                        DebugLogger.Instance().LogWarning("Slice File is null during build and slice image is specified");
                                    }
                                    sltime = GetTimerValue();
                                }
                                else
                                {
                                    m_curlayer = layer;
                                    if (m_sf != null)
                                    {
                                        bmp = m_sf.GetSliceImage(m_curlayer);     // get the rendered image slice or load it if already rendered
                                        if (bmp == null)
                                        {
                                            DebugLogger.Instance().LogError("Buildmanager bitmap is null layer = " + m_curlayer + " ");
                                        }
                                        else     // not null
                                        {
                                            bmp.Tag = BuildManager.SLICE_NORMAL;
                                        }
                                    }
                                    else
                                    {
                                        DebugLogger.Instance().LogWarning("Slice File is null during build and slice image is specified");
                                    }
                                    sltime = GetTimerValue();
                                }
                                // if a pause is requested, stop here...
                                if (m_pause_request == true)
                                {
                                    m_pause_request = false;
                                    ImplementPause();
                                    // if the slice is blank, continue on to display it
                                    // if it's a new image slice (non-blank) continue the loop to go to the next state
                                    if (curtype != BuildManager.SLICE_BLANK)
                                    {
                                        continue;
                                    }
                                }

                                //raise a delegate so the main form can catch it and display layer information.
                                if (PrintLayer != null)
                                {
                                    PrintLayer(bmp, m_curlayer, curtype);
                                }

                                // make sure we raise this event only once
                                if (!isoutline)
                                {
                                    RaiseStatusEvent(eBuildStatus.eLayerCompleted, "Completed Layer");
                                }
                            }
                        }
                        break;

                    case BuildManager.STATE_DONE:
                        try
                        {
                            m_running = false;
                            m_state   = BuildManager.STATE_IDLE;
                            StopBuildTimer();
                            DateTime endtime      = new DateTime();
                            double   totalminutes = (endtime - m_printstarttime).TotalMinutes;

                            m_printing = false;     // mark printing doe
                            //raise done message
                            RaiseStatusEvent(eBuildStatus.eBuildStatusUpdate, "Build 100% Completed");
                            RaiseStatusEvent(eBuildStatus.eBuildCompleted, "Build Completed");
                        }
                        catch (Exception ex)
                        {
                            DebugLogger.Instance().LogError(ex.StackTrace);
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    DebugLogger.Instance().LogError(ex.StackTrace);
                }
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// This is the adaptive support generation, it should automatically
        /// detect overhangs and generate supports acordingly
        /// </summary>
        public void GenerateAdaptive2()
        {
            // iterate through all the layers starting from z=0
            // slice all layers
            // split each layer into non overlapping polygons
            // check each polygon to see if it is completely overhangs in the air, or partially
            //   supported by previous layers.
            // for complete overhangs always create supports
            // for partialy supported polygons, generate supports only if there is no other
            //   support in the vicinity
            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 new supports
                List <Object3d>        lstsupports = new List <Object3d>();        // final list of supports
                List <SupportLocation> supLocs     = new List <SupportLocation>(); // temporary list of support locations.

                int    numslices = UVDLPApp.Instance().m_slicer.GetNumberOfSlices(config);
                float  zlev      = (float)(config.ZThick + 0.5);
                int    hxres     = config.xres / 2;
                int    hyres     = config.yres / 2;
                int    npix      = config.xres * config.yres;
                int[]  lbm       = new int[npix];  // current slice
                int[]  lbmz      = new int[npix];  // z buffer
                bool[] lbms      = new bool[npix]; // support map
                int    p;
                for (p = 0; p < npix; p++)
                {
                    lbmz[p] = 0;
                    lbms[p] = false;
                }

                Bitmap bm      = new Bitmap(config.xres, config.yres, System.Drawing.Imaging.PixelFormat.Format32bppArgb); // working bitmap
                Color  savecol = UVDLPApp.Instance().m_appconfig.m_foregroundcolor;
                m_supportgap = (int)(m_sc.mingap * config.dpmmX);

                m_asp.lbm       = lbm;
                m_asp.lbms      = lbms;
                m_asp.lbmz      = lbmz;
                m_asp.searchmap = new int[npix];
                m_asp.xres      = config.xres;
                m_asp.yres      = config.yres;
                m_asp.mingap    = m_supportgap;

                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) || (sl.m_segments == null) || (sl.m_segments.Count == 0))
                    {
                        continue;
                    }
                    sl.Optimize();// find loops
                    using (Graphics gfx = Graphics.FromImage(bm))
                        gfx.Clear(Color.Transparent);

                    //render current slice
                    UVDLPApp.Instance().m_appconfig.m_foregroundcolor = Color.FromArgb((0xFF << 24) | c);
                    sl.RenderSlice(config, ref bm);
                    BitmapData data = bm.LockBits(new Rectangle(0, 0, bm.Width, bm.Height),
                                                  ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
                    Marshal.Copy(data.Scan0, lbm, 0, lbm.Length);
                    for (p = 0; p < npix; p++)
                    {
                        lbm[p] &= 0xFFFFFF;
                    }
                    bm.UnlockBits(data);
                    if (c > 0)
                    {
                        if (m_sc.eSupType == SupportConfig.eAUTOSUPPORTTYPE.eADAPTIVE)
                        {
                            ProcessSlice(lbm, lbmz, lbms, config.xres, config.yres, supLocs);
                        }
                        else
                        {
                            ProcessSlice2(supLocs);
                        }
                    }

                    // add slice to zbuffer bitmap
                    for (p = 0; p < npix; p++)
                    {
                        if (lbm[p] != 0)
                        {
                            lbmz[p] = lbm[p];
                        }
                    }
                }
                UVDLPApp.Instance().m_appconfig.m_foregroundcolor = savecol;

                int scnt = 0;
                foreach (SupportLocation spl in supLocs)
                {
                    float px = (float)(spl.x - hxres) / (float)config.dpmmX;
                    float py = (float)(spl.y - hyres) / (float)config.dpmmY;
                    float pz = (float)(spl.ztop) * (float)config.ZThick;
                    pz += .650f; // wtf?
                    AddNewSupport(px, py, pz, scnt++, GetSupportParrent(px, py, pz), lstsupports);
                }
                RaiseSupportEvent(UV_DLP_3D_Printer.SupportEvent.eCompleted, "Support Generation Completed", lstsupports);
                m_generating = false;
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex);
            }
        }
Exemplo n.º 11
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);
            }
        }
Exemplo n.º 12
0
        private void slicefunc()
        {
            try
            {
                MinMax mm        = UVDLPApp.Instance().Engine3D.CalcSceneExtents();
                int    numslices = CalcNumSlices(mm.m_max, m_sf.m_config.ZThick);
                float  curz      = (float)(m_sf.m_config.ZThick / 2.0); // start at half slice thickness
                int    c         = 0;
                string scenename = UVDLPApp.Instance().SceneFileName;
                // a little housework here...
                foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                {
                    obj.FindMinMax();
                }

                m_sf.NumSlices = numslices;
                SliceStarted(scenename, numslices);
                DebugLogger.Instance().LogRecord("Slicing started");

                if (m_sf.m_config.export == false)
                {
                    // if we're not actually exporting slices right now, then
                    // raise the completed event and exit
                    SliceCompleted(scenename, 0, numslices);
                    //m_sf.m_config.CopyFrom(m_saved);
                    isslicing = false;
                    return; // exit slicing, nothing more to do...
                }

                // if we're actually exporting something here, iterate through slices
                for (c = 0; c < numslices; c++)
                {
                    List <PolyLine3d> lstintersections = null;
                    if (m_sf.m_config.exportsvg != 0)
                    {
                        lstintersections = new List <PolyLine3d>();
                    }
                    Bitmap savebm    = SliceImmediate(curz, lstintersections);
                    Bitmap outlinebm = null;
                    //check to see if we're rendering the outline BM too
                    if (m_sf.m_config.m_createoutlines == true)
                    {
                        outlinebm = SliceImmediate(curz, lstintersections, true);
                    }
                    if (m_cancel || (savebm == null))
                    {
                        isslicing = false;
                        m_cancel  = false;
                        //restore the original sizes
                        //m_sf.m_config.CopyFrom(m_saved);
                        RaiseSliceEvent(eSliceEvent.eSliceCancelled, c, numslices);
                        return;
                    }
                    curz += (float)m_sf.m_config.ZThick;// move the slice for the next layer
                    //raise an event to say we've finished a slice
                    LayerSliced(scenename, c, numslices, savebm, lstintersections);
                    if (m_sf.m_config.m_createoutlines == true) // make sure we export the slice too
                    {
                        LayerSliced(scenename, c, numslices, outlinebm, lstintersections, true);
                    }
                }
                // restore the original
                m_sf.m_config.CopyFrom(m_saved);
                SliceCompleted(scenename, c, numslices);
                DebugLogger.Instance().LogRecord("Slicing Completed");
                isslicing = false;
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogRecord(ex.Message);
                //RaiseSliceEvent(eSliceEvent.eSliceCancelled,0,0);
                m_cancel = true;
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// This function trys to join together the short line segments into
        /// a set of longer 3d polyines
        /// The goal here is to determine the interior and exterior lines
        /// This is going to help us do several things:
        /// 1) import/export SVG/CLI files
        /// 2) determine overlapping boundaries for better self-intersecting models
        /// 3) determine overhangs - by detemining if polylines from other layers intersect vertically or are encapsulated.
        ///
        /// The first pass of this algorithm may have to be N^2 search, I'll try
        /// to change it to log(N) or N as I go along
        /// </summary>
        ///

        public void Optimize()
        {
            try
            {
                // copy all the polylines in segments into a list
                List <PolyLine3d> allseg = new List <PolyLine3d>();
                //create the final optimize segment list
                m_opsegs = new List <PolyLine3d>();

                // copy the list and clone the polyline segments
                foreach (PolyLine3d pl in m_segments)
                {
                    allseg.Add(new PolyLine3d(pl));
                }
                // gotta keep track of lines to remove
                List <PolyLine3d> removelist = new List <PolyLine3d>();
                bool done = false;
                // matchcount is a counter that tracks how many endpoints we've matched this trip around
                int matchcount = 0;
                while (!done)
                {
                    // set the current line to be the first polyline segement
                    PolyLine3d curline = allseg[0];
                    //iterate through all the line segments in allsegs
                    for (int cnt = 0; cnt < allseg.Count; cnt++)
                    {
                        PolyLine3d pl = allseg[cnt];
                        if (cnt != 0) // the first polyline is the one we're always trying to match
                        {
                            // if the last point in the current polyline matches the first point
                            // in the line we're testing, add the second point of the line we're testing
                            // to the end of the current line
                            if (curline.m_points[curline.m_points.Count - 1].Matches(pl.m_points[0])) // case 2
                            {
                                //if ((curline.m_derived.SharesEdge(pl.m_derived)))
                                {
                                    curline.m_points.AddRange(pl.m_points);
                                    removelist.Add(pl); // add the test line to the list of lines to remove, now that we've used it
                                    matchcount++;
                                }
                            }
                            else if (curline.m_points[curline.m_points.Count - 1].Matches(pl.m_points[pl.m_points.Count - 1])) // case 4 last point matches last
                            {
                                // && (curline.m_derived.SharesEdge(pl.m_derived))
                                pl.m_points.Reverse();
                                curline.m_points.AddRange(pl.m_points);
                                removelist.Add(pl);
                                matchcount++;
                            }
                            else if (curline.m_points[0].Matches(pl.m_points[pl.m_points.Count - 1])) //case 1
                            {
                                curline.m_points.Reverse();
                                pl.m_points.Reverse();
                                curline.m_points.AddRange(pl.m_points);
                                removelist.Add(pl);
                                matchcount++;
                            }
                            else if (curline.m_points[0].Matches(pl.m_points[0])) // case 3
                            {
                                curline.m_points.Reverse();
                                curline.m_points.AddRange(pl.m_points);
                                removelist.Add(pl);
                                matchcount++;
                            }
                        }
                    }
                    // now remove all the matched segments from all segment list
                    foreach (PolyLine3d seg in removelist)
                    {
                        allseg.Remove(seg);
                    }
                    removelist.Clear();

                    if (matchcount > 0)
                    {
                        matchcount = 0; // reset the match counter
                    }
                    else
                    {
                        // the current segment is not longer matching
                        // add it to the final list of optimized segments
                        m_opsegs.Add(curline);
                        //and remove it from the list of all segments
                        allseg.Remove(curline);
                        //check for end condition
                        if (allseg.Count == 0)
                        {
                            done = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex.Message);
            }
            RemoveDoublePoints(); // make really clean
        }
Exemplo n.º 14
0
        void BuildStatus(eBuildStatus printstat, string mess)
        {
            // displays the print status
            if (InvokeRequired)
            {
                BeginInvoke(new MethodInvoker(delegate() { BuildStatus(printstat, mess); }));
            }
            else
            {
                String message = "";
                switch (printstat)
                {
                case eBuildStatus.eBuildPaused:
                    message = "Print Paused";
                    SetButtonStatuses();
                    SetMainMessage(message);
                    DebugLogger.Instance().LogRecord(message);

                    break;

                case eBuildStatus.eBuildResumed:
                    message = "Print Resumed";
                    SetButtonStatuses();
                    SetMainMessage(message);
                    DebugLogger.Instance().LogRecord(message);

                    break;

                case eBuildStatus.eBuildCancelled:
                    message = "Print Cancelled";
                    SetButtonStatuses();
                    ctlMachineControl1.BuildStopped();
                    SetMainMessage(message);
                    DebugLogger.Instance().LogRecord(message);

                    break;

                case eBuildStatus.eLayerCompleted:
                    message = "Layer Completed";
                    break;

                case eBuildStatus.eBuildCompleted:
                    message = "Print Completed";
                    SetButtonStatuses();
                    ctlMachineControl1.BuildStopped();
                    MessageBox.Show("Build Completed");
                    SetMainMessage(message);
                    DebugLogger.Instance().LogRecord(message);
                    break;

                case eBuildStatus.eBuildStarted:
                    message = "Print Started";
                    SetButtonStatuses();
                    ctlMachineControl1.BuildStarted();
                    // if the current machine type is a UVDLP printer, make sure we can show the screen
                    if (UVDLPApp.Instance().m_printerinfo.m_machinetype == MachineConfig.eMachineType.UV_DLP)
                    {
                        if (!m_frmdlp.ShowDLPScreen())
                        {
                            MessageBox.Show("Monitor " + UVDLPApp.Instance().m_printerinfo.m_monitorconfig.Monitorid + " not found, cancelling build", "Error");
                            UVDLPApp.Instance().m_buildmgr.CancelPrint();
                        }
                    }
                    SetMainMessage(message);
                    DebugLogger.Instance().LogRecord(message);
                    break;

                case eBuildStatus.eBuildStatusUpdate:
                    // a message from the build manager has arrived
                    this.SetTimeMessage(mess);
                    break;
                }
            }
        }
Exemplo n.º 15
0
        /*
         * This handles specific events triggered by the app
         */
        private void AppEventDel(eAppEvent ev, String Message)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new MethodInvoker(delegate() { AppEventDel(ev, Message); }));
            }
            else
            {
                switch (ev)
                {
                case eAppEvent.eModelNotLoaded:
                    DebugLogger.Instance().LogRecord(Message);
                    break;

                case eAppEvent.eModelRemoved:
                    //the current model was removed
                    DebugLogger.Instance().LogRecord(Message);
                    UpdateSceneInfo();
                    UVDLPApp.Instance().m_engine3d.UpdateLists();
                    ctl3DView1.UpdateView();
                    //DisplayFunc();
                    break;

                case eAppEvent.eSlicedLoaded:     // update the gui to view
                    DebugLogger.Instance().LogRecord(Message);
                    int totallayers = UVDLPApp.Instance().m_slicefile.NumSlices;
                    ctl3DView1.SetNumLayers(totallayers);
                    ctlSliceView1.SetNumLayers(totallayers);
                    //show the slice in the slice view
                    ViewLayer(0, null, BuildManager.SLICE_NORMAL);
                    break;

                case eAppEvent.eGCodeLoaded:
                    DebugLogger.Instance().LogRecord(Message);
                    ctlGcodeView1.Text = UVDLPApp.Instance().m_gcode.RawGCode;
                    break;

                case eAppEvent.eGCodeSaved:
                    DebugLogger.Instance().LogRecord(Message);
                    break;

                case eAppEvent.eModelAdded:
                    UpdateSceneInfo();
                    UVDLPApp.Instance().m_engine3d.UpdateLists();
                    //DisplayFunc();
                    ctl3DView1.UpdateView();
                    DebugLogger.Instance().LogRecord(Message);
                    break;

                case eAppEvent.eSliceProfileChanged:
                    SetTitle();
                    break;

                case eAppEvent.eMachineTypeChanged:
                    // FIXFIX : activate SetupForMachineType on 3dview control
                    SetupForMachineType();
                    SetTitle();
                    break;

                case eAppEvent.eShowBlank:
                    showBlankDLP();
                    break;

                case eAppEvent.eShowCalib:
                    showCalibrationToolStripMenuItem_Click(null, null);
                    break;

                case eAppEvent.eShowDLP:
                    m_frmdlp.ShowDLPScreen();
                    break;

                case eAppEvent.eHideDLP:
                    m_frmdlp.HideDLPScreen();
                    break;

                case eAppEvent.eReDraw:     // redraw the 3d display
                    //DisplayFunc();
                    ctl3DView1.UpdateView();
                    UpdateSceneInfo();
                    break;

                case eAppEvent.eMachineConnected:
                    showBlankDLP();
                    break;

                case eAppEvent.eMachineDisconnected:
                    break;
                }
            }
            Refresh();
        }
Exemplo n.º 16
0
        bool Load(XmlHelper xh)
        {
            bool retval = false;

            XmlNode mc = xh.m_toplevel;

            m_PlatXSize          = xh.GetDouble(mc, "PlatformXSize", 102.0);
            m_PlatYSize          = xh.GetDouble(mc, "PlatformYSize", 77.0);
            m_PlatZSize          = xh.GetDouble(mc, "PlatformZSize", 100.0);
            m_XMaxFeedrate       = xh.GetDouble(mc, "MaxXFeedRate", 100.0);
            m_YMaxFeedrate       = xh.GetDouble(mc, "MaxYFeedRate", 100.0);
            m_ZMaxFeedrate       = xh.GetDouble(mc, "MaxZFeedRate", 100.0);
            XRenderSize          = xh.GetInt(mc, "XRenderSize", 1024);
            YRenderSize          = xh.GetInt(mc, "YRenderSize", 768);
            m_OverrideRenderSize = xh.GetBool(mc, "OverrideRenderSize", false);

            MachineControls = xh.GetString(mc, "DisplayedControls", "XYZPG");
            m_machinetype   = (eMachineType)xh.GetEnum(mc, "MachineType", typeof(eMachineType), eMachineType.UV_DLP);
            m_multimontype  = (eMultiMonType)xh.GetEnum(mc, "MultiMonType", typeof(eMultiMonType), eMultiMonType.eHorizontal);
            m_ip            = xh.GetString(mc, "ip", "192.168.1.6");
            var ComPortnodes = xh.FindAllChildElement(mc, "ComPortSettings");

            foreach (XmlNode node in ComPortnodes)
            {
                serialComPort  = xh.GetString(node, "PortName", "COM1");
                serialBaudRate = xh.GetString(node, "Speed", "9600");
                serialDataBits = xh.GetString(node, "Databits", "8");
                serialParity   = xh.GetString(node, "Parity", "0");
                serialStopBits = xh.GetString(node, "Stopbits", "1");
            }
            if (m_driverconfig.Load(xh, mc))
            {
                retval = true;
            }

            //m_monitorconfig.Load(xh, mc);
            List <XmlNode> monitornodes = xh.FindAllChildElement(mc, "MonitorDriverConfig");

            m_lstMonitorconfigs = new List <MonitorConfig>();
            foreach (XmlNode node in monitornodes)
            {
                MonitorConfig monc = new MonitorConfig();
                monc.Load(xh, node);
                m_lstMonitorconfigs.Add(monc);
            }
            if (m_lstMonitorconfigs.Count > 0)
            {
                // we need at least 1 monitor
                //m_monitorconfig = m_lstMonitorconfigs[0];
            }
            else
            {
                DebugLogger.Instance().LogError("No monitor configurations found!");
            }

            CalcPixPerMM();
            //if we have a special render size, don't wipe it out...
            if (m_OverrideRenderSize == false)
            {
                CorrectMonitorConfig();
            }
            userParams = new UserParameterList();
            xh.LoadUserParamList(userParams);
            return(retval);
        }
Exemplo n.º 17
0
        /// <summary>
        /// This function will immediately return a bitmap slice at the specified Z-Level
        /// If lstPoly is not null, a list of vector polylines representing the slice is returned
        /// </summary>
        /// <param name="zlev"></param>
        /// <param name="lstPoly"></param>
        /// <returns></returns>
        //public Bitmap SliceImmediate(float curz, List<PolyLine3d> lstPoly = null)
        public Bitmap SliceImmediate(float curz, List <PolyLine3d> allIntersections, bool outline = true, bool bottomLayers = false)
        {
            outline = true;
            try
            {
                //first take care of scaling up the output bitmap paramters size, so we can re-sample later
                double scaler = 1.5;             // specify the scale factor
                m_saved.CopyFrom(m_sf.m_config); // save the orginal
                if (m_sf.m_config.antialiasing == true)
                {
                    scaler = m_sf.m_config.aaval;
                    m_sf.m_config.dpmmX *= scaler;
                    m_sf.m_config.dpmmY *= scaler;
                    m_sf.m_config.xres   = (int)(scaler * m_sf.m_config.xres);
                    m_sf.m_config.yres   = (int)(scaler * m_sf.m_config.yres);
                }
                SliceBuildConfig sbf = new SliceBuildConfig(m_sf.m_config);      // save it

                Bitmap bmp = new Bitmap(m_sf.m_config.xres, m_sf.m_config.yres); // create a new bitmap on a per-slice basis
                using (Graphics graph = Graphics.FromImage(bmp))
                {
                    graph.Clear(UVDLPApp.Instance().m_appconfig.m_backgroundcolor);
                    graph.DrawRectangle(new Pen(new SolidBrush(UVDLPApp.Instance().m_appconfig.m_foregroundcolor), (float)m_sf.m_config.m_wall_thickness), new Rectangle(0, 0, m_sf.m_config.xres, m_sf.m_config.yres));
                    //graph.DrawString("omid", new Font(new FontFamily("Tahoma"), 10 ,FontStyle.Bold), new SolidBrush(Color.Red), new PointF(2, 299));
                    //clear the image for rendering
                    if (bottomLayers)
                    {
                        graph.Clear(UVDLPApp.Instance().m_appconfig.m_backgroundcolor);
                    }
                }
                //convert all to 2d lines
                Bitmap savebm = null;
                // check for cancelation

                foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                {
                    savebm = bmp;                                                             // need to set this here in case it's not rendered
                    if (curz >= obj.m_min.z && curz <= obj.m_max.z)                           // only slice from the bottom to the top of the objects
                    {
                        List <Polygon>    lstply           = GetZPolys(obj, curz);            //get a list of polygons at this slice z height that potentially intersect
                        List <PolyLine3d> lstintersections = GetZIntersections(lstply, curz); //iterate through all the polygons and generate x/y line segments at this 3d z level
                        Slice             sl = new Slice();                                   //create a new slice
                        sl.m_segments = lstintersections;                                     // Set the list of intersections
                        sl.RenderSlice(m_sf.m_config, ref bmp, outline);
                        if (allIntersections != null)
                        {
                            allIntersections.AddRange(lstintersections);
                        }

                        savebm = bmp;
                    }
                }
                if (m_sf.m_config.antialiasing == true) // we're using anti-aliasing here, so resize the image
                {
                    savebm = ResizeImage(bmp, new Size(m_saved.xres, m_saved.yres));
                }
                if (m_sf.m_config.m_flipX == true)
                {
                    savebm = ReflectX(savebm);
                }
                if (m_sf.m_config.m_flipY == true)
                {
                    savebm = ReflectY(savebm);
                }
                //restore the original size
                m_sf.m_config.CopyFrom(m_saved);

                return(savebm);
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogError(ex);
                return(null);
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// This function sends commands to the projector(s)
        /// The format is <DispCmd> MonitorID , cmdname
        /// Monitor ID can be any monitor on the system, or ALL
        /// </summary>
        /// <param name="line"></param>
        private void PerformDisplayCommand(string line)
        {
            try
            {
                line = line.Replace(';', ' '); // remove comments
                line = line.Replace(')', ' '); // remove comments
                int bidx = line.IndexOf('>');
                if (bidx == -1)
                {
                    DebugLogger.Instance().LogError("Improperly formated display command");
                    return;
                }
                string   ss1   = line.Substring(bidx + 1);
                string[] lines = ss1.Split(',');
                if (lines.Length != 2)
                {
                    DebugLogger.Instance().LogError("Improperly formated display command");
                    return;
                }
                string monname = lines[0].Trim();
                string cmdname = lines[1].Trim();
                //get the command name
                ProjectorCommand pc = null;
                pc = UVDLPApp.Instance().m_proj_cmd_lst.FindByName(cmdname);
                if (pc == null)
                {
                    DebugLogger.Instance().LogError("Could not find Display Command " + cmdname);
                    return;
                }
                // get the monitor ID
                if (monname.Equals("All"))
                {
                    //iterate through all configured monitors in machine monitor list
                    foreach (MonitorConfig mc in UVDLPApp.Instance().m_printerinfo.m_lstMonitorconfigs)
                    {
                        SendProjCmd(mc, pc);
                    }
                }
                else
                {
                    MonitorConfig mc = UVDLPApp.Instance().m_printerinfo.FindMonitorByName(monname);
                    if (mc != null)
                    {
                        SendProjCmd(mc, pc);
                    }
                    else
                    {
                        DebugLogger.Instance().LogError("Monitor ID " + monname + " not found");
                        return;
                    }
                }

                // get the commands name
                //find the command in the projector command list
                // make sure the com port for the projector is open
                //send the command to the projector over serial
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex);
            }
        }
Exemplo n.º 19
0
        private void slicefunc()
        {
            try
            {
                m_cancel  = false;
                isslicing = true;
                MinMax mm        = UVDLPApp.Instance().Engine3D.CalcSceneExtents();
                int    numslices = CalcNumSlices(mm.m_max, m_sf.m_config.ZThick);
                float  curz      = (float)(m_sf.m_config.ZThick / 2.0); // start at half slice thickness
                //int c = 0;
                string scenename = UVDLPApp.Instance().SceneFileName;
                // a little housework here...
                foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                {
                    obj.FindMinMax();
                }

                m_sf.NumSlices = numslices;
                SliceStarted(scenename, numslices);
                DebugLogger.Instance().LogRecord("Slicing started");

                if (m_sf.m_config.export == false)
                {
                    // if we're not actually exporting slices right now, then
                    // raise the completed event and exit
                    SliceCompleted(scenename, 0, numslices + (int)m_sf.m_config.m_bottom_layers);
                    //m_sf.m_config.CopyFrom(m_saved);
                    isslicing = false;
                    return; // exit slicing, nothing more to do...
                }

                // if we're actually exporting something here, iterate through slices
                var t1 = DateTime.Now;

                for (int c = 0; c < numslices + m_sf.m_config.m_bottom_layers; c++)
                {
                    if (!isslicing)
                    {
                        return;
                    }
                    if (m_cancel)
                    {
                        isslicing = false;
                        m_cancel  = false;
                        RaiseSliceEvent(eSliceEvent.eSliceCancelled, c, numslices);
                        return;
                    }
                    curz = (float)((m_sf.m_config.ZThick / 2.0) + c * m_sf.m_config.ZThick);
                    List <PolyLine3d> lstintersections = null;
                    if (m_sf.m_config.exportsvg != 0)
                    {
                        lstintersections = new List <PolyLine3d>();
                    }
                    // where is this memory for the allocated bitmap being freed?
                    using (Bitmap savebm = SliceImmediate(curz, lstintersections, c <= m_sf.m_config.m_bottom_layers))
                    {
                        // check for cancel or error
                        if (m_cancel || (savebm == null))
                        {
                            isslicing = false;
                            m_cancel  = false;
                            //restore the original sizes
                            RaiseSliceEvent(eSliceEvent.eSliceCancelled, c, numslices);
                            return;
                        }

                        //raise an event to say we've finished a main filled slice
                        LayerSliced(scenename, c, numslices, savebm, lstintersections);

                        //check to see if we're rendering the outline BM too
                        if (m_sf.m_config.m_createoutlines == true)
                        {
                            //make sure to manage the memory
                            using (Bitmap outlinebm = SliceImmediate(curz, lstintersections, true))
                            {
                                if (outlinebm != null)
                                {
                                    LayerSliced(scenename, c, numslices, outlinebm, lstintersections, true);
                                }
                                else
                                {
                                    //Error rendering the outline bitmap?
                                    DebugLogger.Instance().LogError("Error rendering outline slice");
                                }
                            }
                        }
                        // move the slice for the next layer
                    }
                }



                //for (c = 0; c < numslices; c++)
                //{

                //}

                var t2 = DateTime.Now - t1;

                // restore the original
                m_sf.m_config.CopyFrom(m_saved);
                SliceCompleted(scenename, numslices - 1, numslices);
                DebugLogger.Instance().LogRecord("Slicing Completed");
                isslicing = false;
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogRecord(ex.Message);
                //RaiseSliceEvent(eSliceEvent.eSliceCancelled,0,0);
                m_cancel = true;
            }
        }
        public override string Export(Stream stream, string filename)
        {
            m_stream = stream;
            if ((m_name == null) || (m_name.Length == 0))
            {
                m_name = Path.GetFileNameWithoutExtension(filename);
            }
            if ((m_description == null) || (m_description.Length == 0))
            {
                m_description = m_name;
            }
            try
            {
                ReportStart();
                SliceBuildConfig config = UVDLPApp.Instance().m_buildparms;
                config.UpdateFrom(UVDLPApp.Instance().m_printerinfo); // make sure we've got the correct display size and PixPerMM values

                // write header
                WriteString("1");              // version
                WriteString(m_name);           // scene name
                WriteString(m_description);    // scene description
                WriteDouble(1 / config.dpmmX); // pixel size in mm
                WriteDouble(config.ZThick);    // slice thickness
                WriteInt32(0);                 // base standoff layers (?)
                WriteInt32(0);                 // Number of base offset layers where extents are filled (?)
                WriteString("Reserved3");
                WriteString("Reserved2");
                WriteString("Reserved1");

                // write slices
                int numslices = UVDLPApp.Instance().m_slicer.GetNumberOfSlices(config);
                WriteInt32(numslices);

                float zlev = (float)(config.ZThick * 0.5);
                int   npix = config.xres * config.yres;
                int[] lbm  = new int[npix]; // current slice
                int   p;

                //Bitmap bm = new Bitmap(config.xres, config.yres, System.Drawing.Imaging.PixelFormat.Format32bppArgb); // working bitmap
                //Color savecol = UVDLPApp.Instance().m_appconfig.m_foregroundcolor;

                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
                }

                for (int c = 0; c < numslices; c++)
                {
                    //bool layerneedssupport = false;
                    if (CancelExport)
                    {
                        return("Info|Export operation canceled");
                    }
                    ReportProgress(c * 100 / numslices);

                    /*Slice sl = UVDLPApp.Instance().m_slicer.GetSliceImmediate(zlev);
                     * zlev += (float)config.ZThick;
                     *
                     * if ((sl == null) || (sl.m_segments == null) || (sl.m_segments.Count == 0))
                     *  continue;
                     * sl.Optimize();// find loops
                     * using (Graphics gfx = Graphics.FromImage(bm))
                     *  gfx.Clear(Color.Transparent);
                     *
                     * //render current slice
                     * UVDLPApp.Instance().m_appconfig.m_foregroundcolor = Color.White;
                     * sl.RenderSlice(config, ref bm);*/

                    Bitmap bm = UVDLPApp.Instance().m_slicer.SliceImmediate(zlev);
                    zlev += (float)config.ZThick;
                    BitmapData data = bm.LockBits(new Rectangle(0, 0, bm.Width, bm.Height),
                                                  ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
                    Marshal.Copy(data.Scan0, lbm, 0, lbm.Length);
                    for (p = 0; p < npix; p++)
                    {
                        lbm[p] &= 0xFFFFFF;
                    }
                    bm.UnlockBits(data);
                    CrushSlice(lbm, config.xres, config.yres);
                }

                // write supports (currently not handled)
                WriteInt32(0); // zero supports
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex);
                return("Error|Export terminated unexpectedly");
            }

            return("Export|Export completed successfully");
        }
Exemplo n.º 21
0
        private void SliceStarted(string scenename, int numslices)
        {
            if (m_sf.m_config.export == true)  // if we're exporting
            {
                //exporting to cws file
                //get the name oif the scene file
                if (UVDLPApp.Instance().SceneFileName.Length == 0)
                {
                    //MessageBox.Show("Please Save the Scene First Before Exporting Slices");

                    if (MessageBox.Show("The Scene must be saved before exporting slices", "Please Save Scene", MessageBoxButtons.OKCancel) == DialogResult.OK)
                    {
                        UVDLPApp.Instance().m_mainform.SaveScene(null, null);
                    }

                    //MessageBox.Show(en.Slicer_SliceStarted_Please_Save_the_Scene_First_Before_Exporting_Slices);

                    CancelSlicing();
                    return;
                }
                if (m_sf.m_config.exportpng == true)
                {
                    // if we're exporting png slices to disk as well, then make sure we have a directory to export them into
                    try
                    {
                        string exportdirname = SliceFile.GetSliceFilePath(UVDLPApp.Instance().SceneFileName);
                        if (!Directory.Exists(exportdirname))  // if the directory does not exist
                        {
                            //create the directory to export images into
                            Directory.CreateDirectory(exportdirname);
                            //create the /preview directory here?
                        }
                    }
                    catch (Exception ex)
                    {
                        DebugLogger.Instance().LogError(ex);
                    }
                }
                //if (!string.IsNullOrWhiteSpace(UVDLPApp.Instance().SceneFileName)) // check again to make sure we've really got a name
                if (UVDLPApp.Instance().SceneFileName != null && UVDLPApp.Instance().SceneFileName.Length > 0) // check again to make sure we've really got a name
                {
                    //remove all the previous images first
                    //remove the png slices
                    SceneFile.Instance().RemoveResourcesFromFile(UVDLPApp.Instance().SceneFileName, "Slices", ".png");
                    SceneFile.Instance().RemoveResourcesBySection(UVDLPApp.Instance().SceneFileName, "Slices");
                    //remove the vector slices
                    SceneFile.Instance().RemoveResourcesFromFile(UVDLPApp.Instance().SceneFileName, "VectorSlices", ".svg");
                    //remove any slice profile in the scene file
                    SceneFile.Instance().RemoveResourcesFromFile(UVDLPApp.Instance().SceneFileName, "SliceProfile", ".slicing");
                    //create a memory stream to hold the slicing profile in memory
                    MemoryStream ms = new MemoryStream();
                    //serialize the slciing profile into the memory stream
                    string sliceprofilename = Path.GetFileNameWithoutExtension(UVDLPApp.Instance().m_buildparms.m_filename) + ".slicing";
                    UVDLPApp.Instance().m_buildparms.Save(ms, sliceprofilename);
                    ms.Seek(0, SeekOrigin.Begin); // rewind
                    //save the stream to the scene cws zip file
                    SceneFile.Instance().AddSliceProfileToFile(UVDLPApp.Instance().SceneFileName, ms, sliceprofilename);
                    // if we've saved this scene before, then we can save the images into it. Open it up for add
                }
                else
                {
                    //no name? cancel slicing
                    CancelSlicing();
                }
            }
            RaiseSliceEvent(eSliceEvent.eSliceStarted, 0, numslices);
        }
        /// <summary>
        /// Loads a model, adds it to the 3d engine to be shown, and raises an app event
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public bool LoadModel(String filename)
        {
            try
            {
                ModelLoader ml = new ModelLoader();
                if (SceneFileName.Length == 0)
                {
                    SceneFileName = filename; // set it to be the first file loaded
                }
                List <Object3d> objs = ml.Load(filename);
                if (objs != null)
                {
                    foreach (Object3d obj in objs)
                    {
                        obj.CenterOnPlatform();
                        m_engine3d.AddObject(obj);
                        m_undoer.SaveAddition(obj);
                        SelectedObject = obj;
                    }
                    UVDLPApp.Instance().m_engine3d.UpdateLists();
                    m_slicefile = null; // the slice file is not longer current
                    RaiseAppEvent(eAppEvent.eModelAdded, "Model Loaded " + filename);

                    /*
                     * //now try to load the gcode file
                     * String gcodefile = Path.GetFileNameWithoutExtension(filename) + ".gcode";
                     * String gcodepath = SliceFile.GetSliceFilePath(filename);
                     *
                     * String gpath = gcodepath + UVDLPApp.m_pathsep + gcodefile;
                     * if (File.Exists(gpath))
                     * {
                     *  LoadGCode(gpath);
                     * }
                     * else // read the gcode from the zip file
                     * {
                     *  String zpath = gcodepath + ".zip";
                     *  if(File.Exists(zpath)) // make sure the file exists before we try to read it
                     *  {
                     *      Stream s = Utility.ReadFromZip(zpath, gcodefile);
                     *      if(s  != null)
                     *      {
                     *          s.Seek(0, 0); // go to the beginning of the stream
                     *          byte []array = Utility.ReadFully(s);
                     *          string gc = System.Text.Encoding.ASCII.GetString(array);
                     *          m_gcode = new GCodeFile(gc);
                     *          RaiseAppEvent(eAppEvent.eGCodeLoaded, "GCode Loaded " + gcodefile);
                     *      }
                     *      else
                     *      {
                     *          DebugLogger.Instance().LogError("Could not load GCode from Zip " + zpath);
                     *      }
                     *  }
                     *
                     * }
                     * if(m_gcode !=null)
                     * {
                     *  int xres, yres, numslices;
                     *  xres = m_gcode.GetVar("Projector X Res");
                     *  yres = m_gcode.GetVar("Projector Y Res");
                     *  numslices = m_gcode.GetVar("Number of Slices");
                     *  m_slicefile = new SliceFile(xres,yres,numslices);
                     *  m_slicefile.modelname = SelectedObject.m_fullname;
                     *  m_slicefile.m_config = null; //this can be null if we're loading it...
                     *  RaiseAppEvent(eAppEvent.eSlicedLoaded, "SliceFile Created");
                     * }
                     * */
                }
                else
                {
                    RaiseAppEvent(eAppEvent.eModelNotLoaded, "Model " + filename + " Failed to load");
                }

                return(objs != null);
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogRecord(ex.Message);
                return(false);
            }
        }
Exemplo n.º 23
0
        /// <summary>
        /// This will be called when we're exporting
        /// </summary>
        /// <param name="scenename"></param>
        /// <param name="layer"></param>
        /// <param name="numslices"></param>
        /// <param name="bmp"></param>
        /// <param name="lstPoly"></param>
        private void LayerSliced(string scenename, int layer, int numslices, Bitmap bmp, List <PolyLine3d> lstintersections, bool outline = false)
        {
            string path = "";

            try
            {
                // if (m_buildparms.exportimages)
                {
                    // get the model name
                    String modelname   = scenename;
                    String outlinename = "";
                    // strip off the file extension
                    path = SliceFile.GetSliceFilePath(modelname);
                    if (outline)
                    {
                        outlinename = "_outline";
                    }
                    String imname    = Path.GetFileNameWithoutExtension(modelname) + outlinename + String.Format("{0:0000}", layer) + ".bmp";
                    String imagename = path + UVDLPApp.m_pathsep + imname;
                    // create a memory stream for this to save into
                    bmp.Tag = BuildManager.SLICE_NORMAL; // mark it as normal
                    MemoryStream ms = new MemoryStream();
                    bmp.Save(ms, ImageFormat.Bmp);
                    ms.Seek(0, SeekOrigin.Begin); // seek back to beginning
                    if (!m_cancel)                // if we're not in the process of cancelling
                    {
                        SceneFile.Instance().AddSlice(UVDLPApp.Instance().SceneFileName, ms, imname);
                    }

                    if (m_sf.m_config.exportpng)
                    {
                        //imagename
                        var img = (Image)bmp;
                        img.Save(imagename, ImageFormat.Bmp);
                        //bmp.Save(imagename);
                    }
                    if (lstintersections != null)
                    {
                        StreamWriter sw;
                        imname    = Path.GetFileNameWithoutExtension(modelname) + String.Format("{0:0000}", layer) + ".svg";
                        imagename = path + UVDLPApp.m_pathsep + imname;
                        if (m_sf.m_config.exportsvg < 3)
                        {
                            Path2D vectorPath = new Path2D(lstintersections);
                            sw = vectorPath.GenerateSVG(UVDLPApp.Instance().m_printerinfo.m_PlatXSize,
                                                        UVDLPApp.Instance().m_printerinfo.m_PlatYSize, m_sf.m_config.exportsvg == 2);
                        }
                        else
                        {
                            Slice sl = new Slice();
                            sl.m_segments = lstintersections;
                            sl.Optimize();
                            sw = GenerateSVG(sl.m_opsegs, m_sf.m_config.exportsvg == 4);
                        }
                        if (!m_cancel)
                        {
                            SceneFile.Instance().AddVectorSlice(UVDLPApp.Instance().SceneFileName, (MemoryStream)sw.BaseStream, imname);
                        }
                    }

                    RaiseSliceEvent(eSliceEvent.eLayerSliced, layer, numslices);
                }
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogError(ex.Message);
            }
        }
Exemplo n.º 24
0
        /// <summary>
        /// This function will iterate through the optimized loops
        /// and determine if they are interior or exterior and tag them appropriately
        /// </summary>

        /*
         * public void DetermineInteriorExterior(SliceBuildConfig config)
         * {
         *  List<PolyLine3d> allsegments = new List<PolyLine3d>();
         *  foreach (PolyLine3d pln in m_opsegs)
         *  {
         *      pln.tag = PolyLine3d.TAG_INTERIOR; // mark it as interior
         *      List<PolyLine3d> segments = pln.Split(); // split them, retaining the parent
         *      allsegments.AddRange(segments);
         *  }
         *  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
         *          {
         *              // the first point is always an exterior - really? why?
         *              Point2d p1 = (Point2d)points[cnt];
         *              if (p1.m_parent != null)
         *              {
         *                  p1.m_parent.tag = PolyLine3d.TAG_EXTERIOR; // mark as exterior
         *              }
         *              // the second point could be an exterior or interior
         *              Point2d p2 = (Point2d)points[cnt + 1];
         *          }
         *      }
         *      else  // flag error
         *      {
         *          DebugLogger.Instance().LogRecord("Row y=" + y + " odd # of points = " + points.Count + " - Model may have holes");
         *      }
         *  }// for y = startminY to endY
         * }
         */
        /// <summary>
        /// This function trys to join together the short line segments into
        /// a set of longer 3d polyines
        /// The goal here is to determine the interior and exterior lines
        /// This is going to help us do several things:
        /// 1) import/export SVG/CLI files
        /// 2) determine overlapping boundaries for better self-intersecting models
        /// 3) determine overhangs - by detemining if polylines from other layers intersect vertically or are encapsulated.
        ///
        /// The first pass of this algorithm may have to be N^2 search, I'll try
        /// to change it to log(N) or N as I go along
        /// </summary>
        ///

        public void Optimize()
        {
            try
            {
                // copy all the polylines in segments into a list
                List <PolyLine3d> allseg = new List <PolyLine3d>();
                //create the final optimize segment list
                m_opsegs = new List <PolyLine3d>();

                // copy the list and clone the polyline segments
                foreach (PolyLine3d pl in m_segments)
                {
                    if (!pl.m_points[0].Matches(pl.m_points[pl.m_points.Count - 1])) // discard sements with same beginning and end
                    {
                        allseg.Add(new PolyLine3d(pl));
                    }
                }
                // gotta keep track of lines to remove
                List <PolyLine3d> removelist = new List <PolyLine3d>();
                bool done = false;
                // matchcount is a counter that tracks how many endpoints we've matched this trip around
                int matchcount = 0;
                while (!done)
                {
                    // set the current line to be the first polyline segement
                    PolyLine3d curline = allseg[0];
                    //iterate through all the line segments in allsegs
                    for (int cnt = 0; cnt < allseg.Count; cnt++)
                    {
                        PolyLine3d pl = allseg[cnt];
                        if (cnt != 0) // the first polyline is the one we're always trying to match
                        {
                            // if the last point in the current polyline matches the first point
                            // in the line we're testing, add the second point of the line we're testing
                            // to the end of the current line
                            if (curline.m_points[curline.m_points.Count - 1].Matches(pl.m_points[0])) // case 2
                            {
                                //if ((curline.m_derived.SharesEdge(pl.m_derived)))
                                {
                                    for (int i = 1; i < pl.m_points.Count; i++)
                                    {
                                        curline.m_points.Add(pl.m_points[i]);
                                    }
                                    removelist.Add(pl); // add the test line to the list of lines to remove, now that we've used it
                                    matchcount++;
                                }
                            }
                            else if (curline.m_points[curline.m_points.Count - 1].Matches(pl.m_points[pl.m_points.Count - 1])) // case 4 last point matches last
                            {
                                // && (curline.m_derived.SharesEdge(pl.m_derived))
                                pl.m_points.Reverse();
                                for (int i = 1; i < pl.m_points.Count; i++)
                                {
                                    curline.m_points.Add(pl.m_points[i]);
                                }
                                removelist.Add(pl);
                                matchcount++;
                            }

                            /* -- SHS: case 1 and case 3 will change the first segment
                             *  I need it to calculate correct path direction
                             * else if (curline.m_points[0].Matches(pl.m_points[pl.m_points.Count - 1])) //case 1
                             * {
                             * curline.m_points.Reverse();
                             * pl.m_points.Reverse();
                             * for (int i=1; i<pl.m_points.Count; i++)
                             *  curline.m_points.Add(pl.m_points[i]);
                             * removelist.Add(pl);
                             * matchcount++;
                             * }
                             * else if (curline.m_points[0].Matches(pl.m_points[0])) // case 3
                             * {
                             * curline.m_points.Reverse();
                             * for (int i = 1; i < pl.m_points.Count; i++)
                             *  curline.m_points.Add(pl.m_points[i]);
                             * removelist.Add(pl);
                             * matchcount++;
                             * }*/
                        }
                    }
                    // now remove all the matched segments from all segment list
                    foreach (PolyLine3d seg in removelist)
                    {
                        allseg.Remove(seg);
                    }
                    removelist.Clear();

                    if (matchcount > 0)
                    {
                        matchcount = 0; // reset the match counter
                    }
                    else
                    {
                        // the current segment is not longer matching
                        // match curve direction based on normal such that the right side is inside the object.
                        double curveDir  = Math.Atan2(curline.m_points[1].y - curline.m_points[0].y, curline.m_points[1].x - curline.m_points[0].x);
                        double normalDir = Math.Atan2(curline.m_derived.m_normal.y, curline.m_derived.m_normal.x);
                        double dirDiff   = curveDir - normalDir;
                        if (dirDiff < 0)
                        {
                            dirDiff += 2 * Math.PI; // handle negative result
                        }
                        if ((dirDiff > 0) && (dirDiff < Math.PI))
                        {
                            curline.m_points.Reverse(); // reverse curve direction to match normal
                        }
                        // add it to the final list of optimized segments
                        m_opsegs.Add(curline);
                        //and remove it from the list of all segments
                        allseg.Remove(curline);
                        //check for end condition
                        if (allseg.Count == 0)
                        {
                            done = true;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogError(ex.Message);
            }
            RemoveDoublePoints(); // make really clean
        }
        /// <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;
        }
Exemplo n.º 26
0
        //licenses can be in a few states:
        // licensed and enabled - load the plugin and use it
        // licensed and disabled - do not use the plugin, do not initialize
        // un-licensed and enabled - prompt the user for license key, do not initialize it
        // un-licensed and disabled - ignore this plugin, keep entry for it, do not initialize
        public void ScanForPlugins()
        {
            // load the list of plugin states
            string picn = m_apppath + m_pathsep + "pluginconfig.cfg"; // plugin configuration name

            m_pluginstates.Load(picn);

            // get a list of dll's in this current directory
            // try to register them as a plug-in
            string[] filePaths = Directory.GetFiles(m_apppath, "*.dll");
            foreach (String pluginname in filePaths)
            {
                string args = Path.GetFileNameWithoutExtension(pluginname);
                if (args.ToLower().StartsWith("pl"))
                {
                    // located a dll that is a potential plugin
                    Type ObjType = null;
                    try
                    {
                        // load it
                        Assembly ass = null;
                        //string args = Path.GetFileNameWithoutExtension(pluginname);
                        ass = Assembly.Load(args);
                        if (ass != null)
                        {
                            ObjType = ass.GetType(args + ".PlugIn"); // look for the plugin interface
                            // OK Lets create the object as we have the Report Type
                            if (ObjType != null)
                            {
                                // create an instance of the plugin
                                IPlugin plug = (IPlugin)Activator.CreateInstance(ObjType);
                                // create an entry for the plugin
                                PluginEntry pe = new PluginEntry(plug, args);
                                //add the entry to the list of plugins
                                m_plugins.Add(pe);
                                //mark the plugin as enabled by default
                                pe.m_enabled = true;
                                if (m_pluginstates.InList(args))
                                {
                                    // this plugin is listed in the disabled list.
                                    DebugLogger.Instance().LogInfo("Plugin " + args + " marked disabled");
                                    pe.m_enabled = false;
                                }

                                //get the vendor id of the newly loaded plugin
                                int vid = plug.GetInt("VendorID");
                                //look for the license key for this plugin
                                LicenseKey lk = KeyRing.Instance().Find(vid);
                                // if we found it, mark it as licensed
                                if (lk != null)
                                {
                                    //initialize the plugin by setting the host.
                                    if (pe.m_enabled)
                                    {
                                        plug.Host = this; // this will initialize the plugin - the plugin's init function will be called
                                        DebugLogger.Instance().LogInfo("Loaded licensed plugin " + args);
                                    }
                                }

                                /*
                                 * if (pe.m_enabled && pe.m_licensed)
                                 * {
                                 *  DebugLogger.Instance().LogInfo("Loaded licensed plugin " + args);
                                 * }else if (pe.m_enabled && )
                                 * */
                                DebugLogger.Instance().LogInfo("Loaded plugin " + args);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        DebugLogger.Instance().LogError(ex.Message);
                    }
                }
            }
        }
Exemplo n.º 27
0
        public Bitmap RenderSlice(SliceBuildConfig sp)
        {
            // create a new bitmap that will be used to draw into
            //Bitmap bmp = new Bitmap(sp.xres, sp.yres);

            double scaler = 1.5; // specofy the scale factor

            if (sp.antialiasing == true)
            {
                scaler = sp.aaval;
            }
            else
            {
                scaler = 1.0;         // no scaling
            }
            double sdpmmx = sp.dpmmX; // save the original dots per mm
            double sdpmmy = sp.dpmmY;

            sp.dpmmX *= scaler;//  scaler them up.
            sp.dpmmY *= scaler;

            //Re-sample to a higher resolution so we can smooth later
            int ox, oy;

            ox = sp.xres; // save the original resolution
            oy = sp.yres;
            double xs, ys;

            xs      = ((double)sp.xres) * scaler; // scale them up
            ys      = ((double)sp.yres) * scaler;
            sp.xres = (int)xs;
            sp.yres = (int)ys;
            Bitmap bmp = new Bitmap(sp.xres, sp.yres);
            //Bitmap bmp = new Bitmap((int)xs,(int)ys);

            Graphics graph = Graphics.FromImage(bmp);
            Point    pnt1  = new Point(); // create some points for drawing
            Point    pnt2  = new Point();
            Pen      pen   = new Pen(Color.White, 1);

            graph.Clear(Color.Black);
            //convert all to 2d lines
            int hxres = sp.xres / 2;
            int hyres = sp.yres / 2;

            ArrayList lines2d = Get2dLines(sp);

            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
                ArrayList intersecting = GetIntersecting2dYLines(y, lines2d);
                //      get the list of point intersections
                ArrayList points = GetIntersectingPoints(y, intersecting);
                // sort the points in increasing x order
                //SortXIncreasing(points);
                points.Sort();
                //      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");
                }
            }
            //Rescale the image to re-sample it from a higher res to soften the lines with bicubic interpolation.
            sp.dpmmX = sdpmmx;
            sp.dpmmY = sdpmmy;
            sp.xres  = ox;
            sp.yres  = oy;

            if (sp.antialiasing == true) // we're using anti-aliasing here, so resize the image
            {
                return(ReflectY(ResizeImage(bmp, new Size(ox, oy))));
            }
            else
            {
                return(ReflectY(bmp));
            }

            //return bmp;
        }
Exemplo n.º 28
0
 /// <summary>
 /// Gets the instance to the File Logger, creates if necessary
 /// </summary>
 /// <returns>Instance of this object</returns>
 public static DebugLogger Instance()
 {
     if (_instance == null)
         _instance = new DebugLogger();
     return _instance;
 }
Exemplo n.º 29
0
        void SliceEv(Slicer.eSliceEvent ev, int layer, int totallayers)
        {
            String path = "";

            switch (ev)
            {
            case Slicer.eSliceEvent.eSliceStarted:
                // if we're exporting images
                if (m_buildparms.exportimages)
                {
                    // get the model name
                    String modelname = m_obj.m_fullname;
                    // strip off the file extension
                    path  = Path.GetDirectoryName(modelname);
                    path += UVDLPApp.m_pathsep;
                    path += Path.GetFileNameWithoutExtension(modelname); // strip off the file extension
                    if (!Directory.Exists(path))                         // check and see if a directory of that name exists,
                    {
                        Directory.CreateDirectory(path);                 // if not, create it
                    }
                }
                break;

            case Slicer.eSliceEvent.eLayerSliced:
                //save the rendered image slice
                //render the slice

                if (m_buildparms.exportimages)
                {
                    // get the model name
                    String modelname = m_obj.m_fullname;
                    // strip off the file extension
                    path  = Path.GetDirectoryName(modelname);
                    path += UVDLPApp.m_pathsep;
                    path += Path.GetFileNameWithoutExtension(modelname);    // strip off the file extension
                    Bitmap bmp       = null;
                    String imagename = path + m_pathsep + Path.GetFileNameWithoutExtension(modelname) + String.Format("{0:0000}", layer) + ".png";
                    bmp = UVDLPApp.Instance().m_slicefile.RenderSlice(layer);
                    bmp.Save(imagename);
                }
                break;

            case Slicer.eSliceEvent.eSliceCompleted:
                m_gcode = GCodeGenerator.Generate(m_slicefile, m_printerinfo);

                /*
                 * //get the path of the current object file
                 * path = Path.GetDirectoryName(m_obj.m_fullname);
                 * string fn = Path.GetFileNameWithoutExtension(m_obj.m_fullname);
                 * if (!UVDLPApp.Instance().m_gcode.Save(path + UVDLPApp.m_pathsep + fn + ".gcode"))
                 * {
                 *  DebugLogger.Instance().LogRecord("Cannot save GCode File " + path + m_pathsep + fn + ".gcode");
                 * }
                 * */
                SaveGCode();
                break;

            case Slicer.eSliceEvent.eSliceCancelled:
                DebugLogger.Instance().LogRecord("Slicing Cancelled");
                break;
            }
        }
Exemplo n.º 30
0
        private void slicefunc()
        {
            try
            {
                //first take care of scaling up the output bitmap paramters size, so we can re-sample later
                double scaler = 1.5;             // specify the scale factor
                m_saved.CopyFrom(m_sf.m_config); // save the original
                if (m_sf.m_config.antialiasing == true)
                {
                    scaler = m_sf.m_config.aaval;
                    //  scale them up.
                    m_sf.m_config.dpmmX *= scaler;
                    m_sf.m_config.dpmmY *= scaler;
                    m_sf.m_config.xres   = (int)(m_sf.m_config.xres * scaler);
                    m_sf.m_config.yres   = (int)(m_sf.m_config.yres * scaler);
                }
                else
                {
                    scaler = 1.0; // no scaling
                }

                //determine the number of slices
                //UVDLPApp.Instance().Scene.FindMinMax();

                MinMax mm = UVDLPApp.Instance().Engine3D.CalcSceneExtents();
                //int numslices = (int)((mm.m_max - mm.m_min) / m_sf.m_config.ZThick);
                int numslices = (int)((mm.m_max) / m_sf.m_config.ZThick);
                //int numslices = (int)((UVDLPApp.Instance().Scene.m_max.z) / m_sf.m_config.ZThick);
                // I should start slicing at Wz 0, not Oz 0
                float curz = 0; // start at Wz0

                // an alternative here is to slice the scene from wZ 0, therefore, all object geometry beneath the ground plane won't be slice;
                //double curz = (double)0.0;// start at the ground


                int    c         = 0;
                string scenename = "";
                // a little housework here...
                foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                {
                    obj.CalcMinMaxes();
                    if (c == 0)
                    {
                        //get the first objects' name
                        scenename      = obj.m_fullname;
                        m_sf.modelname = obj.m_fullname;
                    }
                    c++;
                }
                m_sf.NumSlices = numslices;
                SliceStarted(scenename, numslices);
                DebugLogger.Instance().LogRecord("Slicing started");

                if (m_sf.m_config.export == false)
                {
                    // if we're not actually exporting slices right now, then
                    // raise the completed event and exit
                    SliceCompleted(scenename, 0, numslices);
                    m_sf.m_config.CopyFrom(m_saved);
                    isslicing = false;
                    return; // exit slicing, nothing more to do...
                }
                for (c = 0; c < numslices; c++)
                {
                    Bitmap bmp = new Bitmap(m_sf.m_config.xres, m_sf.m_config.yres); // create a new bitmap on a per-slice basis
                    //clear the image for rendering
                    Graphics graph = Graphics.FromImage(bmp);
                    graph.Clear(UVDLPApp.Instance().m_appconfig.m_backgroundcolor);

                    //convert all to 2d lines
                    Bitmap savebm = null;
                    // check for cancelation
                    if (m_cancel)
                    {
                        isslicing = false;
                        m_cancel  = false;
                        //restore the original sizes
                        m_sf.m_config.CopyFrom(m_saved);
                        RaiseSliceEvent(eSliceEvent.eSliceCancelled, c, numslices);
                        return;
                    }

                    foreach (Object3d obj in UVDLPApp.Instance().Engine3D.m_objects)
                    {
                        savebm = bmp;                                   // need to set this here in case it's not rendered
                        if (curz >= obj.m_min.z && curz <= obj.m_max.z) // only slice from the bottom to the top of the objects
                        {
                            //obj.ClearCached();
                            List <Polygon>    lstply           = GetZPolys(obj, curz);            //get a list of polygons at this slice z height that potentially intersect
                            List <PolyLine3d> lstintersections = GetZIntersections(lstply, curz); //iterate through all the polygons and generate x/y line segments at this 3d z level

                            Slice sl = new Slice();                                               //create a new slice
                            sl.m_segments = lstintersections;                                     // Set the list of intersections
                            // m_sf.m_slices.Add(sl);// add the slice to slicefile
                            // now render the slice into the scaled, pre-allocated bitmap
                            sl.RenderSlice(m_sf.m_config, ref bmp);
                            savebm = bmp;
                        }
                    }

                    if (m_sf.m_config.antialiasing == true) // we're using anti-aliasing here, so resize the image
                    {
                        savebm = ResizeImage(bmp, new Size(m_saved.xres, m_saved.yres));
                    }
                    if (m_sf.m_config.m_flipX == true)
                    {
                        savebm = ReflectX(savebm);
                    }
                    if (m_sf.m_config.m_flipY == true)
                    {
                        savebm = ReflectY(savebm);
                    }
                    curz += (float)m_sf.m_config.ZThick;// move the slice for the next layer
                    //raise an event to say we've finished a slice
                    LayerSliced(scenename, c, numslices, savebm);
                }
                // restore the original
                m_sf.m_config.CopyFrom(m_saved);
                SliceCompleted(scenename, c, numslices);
                DebugLogger.Instance().LogRecord("Slicing Completed");
                isslicing = false;
            }
            catch (Exception ex)
            {
                string s = ex.StackTrace;
                DebugLogger.Instance().LogRecord(ex.Message);
                //RaiseSliceEvent(eSliceEvent.eSliceCancelled,0,0);
                m_cancel = true;
            }
        }
Exemplo n.º 31
0
 public void SetupDriver()
 {
     DebugLogger.Instance().LogRecord("Changing driver type to " + m_printerinfo.m_driverconfig.m_drivertype.ToString());
     m_deviceinterface.Driver = DriverFactory.Create(m_printerinfo.m_driverconfig.m_drivertype);
 }