Esempio n. 1
0
    def DoGCodeCallsForPass(self, finishing_pass):
        failure = self.CheckToolExists()
        if failure: return failure
        tool = Tool.FindTool(self.tool_number)

        depthparams = self.GetDepthParams()
        if not finishing_pass or self.only_finishing_pass:
            SpeedOp.DoGCodeCalls(self)

        if self.auto_roll_on or self.auto_roll_off:
            roll_radius = self.auto_roll_radius / wx.GetApp().program.units
        else:
            roll_radius = None

        depth_params = self.GetDepthParams()
        tool_diameter = tool.CuttingRadius(True) * 2.0
        cutting_edge_angle = tool.cutting_edge_angle

        if finishing_pass:
            feedrate_hv(self.finishing_h_feed_rate / wx.GetApp().program.units,
                        self.vertical_feed_rate / wx.GetApp().program.units)
            flush_nc()
            offset_extra = 0.0
            depth_params.step_down = self.finishing_step_down
            depth_params.z_finish_depth = 0.0
        else:
            offset_extra = self.offset_extra / wx.GetApp().program.units

        cut_mode = self.finishing_cut_mode if finishing_pass else self.cut_mode

        self.DoEachSketch(self.DoGCodeCallsForSketch,
                          (cut_mode, depth_params, tool_diameter, roll_radius,
                           offset_extra, cutting_edge_angle))
Esempio n. 2
0
 def CheckToolExists(self):
     # returns failure message or None for success
     if self.tool_number == 0:
         return 'No tool defined for operation!'
     tool = Tool.FindTool(self.tool_number)
     if tool == None:
         return 'Tool number ' + str(self.tool_number) + ' does not exist'
Esempio n. 3
0
    def SetTool(self, tool_number):
        tool = Tool.FindTool(tool_number)
        if tool != None:
            if self.tool_number != tool_number:
                tool_change( id = tool_number)
                
            if self.attached_to_surface:
                import nc.nc
                nc.nc.creator.set_ocl_cutter(tool.OCLDefinition(self.attached_to_surface))

        self.tool_number = tool_number
Esempio n. 4
0
    def OnGlCommands(self, select, marked, no_color):
        if marked and not select:
            tool = Tool.FindTool(self.tool_number)
            if tool == None:
                return
            radius = tool.CuttingRadius(True)
            global circle_sketch
            global arc1
            global arc2

            # get 3d position from the point objects, sorted by distance from camera
            forwards = wx.GetApp(
            ).frame.graphics_canvas.viewport.view_point.Forwards()
            lens_point = wx.GetApp(
            ).frame.graphics_canvas.viewport.view_point.lens_point
            posns = []
            for point in self.points:
                object = cad.GetObjectFromId(cad.OBJECT_TYPE_POINT, point)
                if object == None:
                    continue
                pos = object.GetStartPoint()
                dotp = (lens_point - pos) * forwards
                posns.append(DotpAndPos(dotp, pos))

            posns = sorted(posns)

            for dotp_and_pos in posns:
                pos = dotp_and_pos.pos
                p0 = pos + geom.Point3D(-radius, 0, 0)
                p1 = pos + geom.Point3D(radius, 0, 0)

                if circle_sketch == None:
                    circle_sketch = cad.NewSketch()
                    arc1 = cad.NewArc(p0, p1, geom.Point3D(0, 0, 1), pos)
                    arc2 = cad.NewArc(p1, p0, geom.Point3D(0, 0, 1), pos)
                    circle_sketch.Add(arc1)
                    circle_sketch.Add(arc2)
                else:
                    arc1.SetStartPoint(p0)
                    arc1.SetEndPoint(p1)
                    arc1.SetCentrePoint(pos)
                    arc2.SetStartPoint(p1)
                    arc2.SetEndPoint(p0)
                    arc2.SetCentrePoint(pos)

                cad.Material(cad.Color(255, 255, 0)).glMaterial(1.0)
                cad.DrawEnableLighting()
                cad.DrawDisableDepthTesting()
                cad.DrawEnableCullFace()
                cad.Sketch.RenderAsExtrusion(circle_sketch, self.start_depth,
                                             self.final_depth)
                cad.DrawDisableCullFace()
                cad.DrawEnableDepthTesting()
                cad.DrawDisableLighting()
Esempio n. 5
0
    def DoGCodeCalls(self):
        failure = self.CheckToolExists()
        if failure: return failure
        tool = Tool.FindTool(self.tool_number)

        depth_params = self.GetDepthParams()
        tool_diameter = tool.CuttingRadius(True) * 2.0
        SpeedOp.DoGCodeCalls(self)

        for point in self.points:
            object = cad.GetObjectFromId(cad.OBJECT_TYPE_POINT, point)
            pos = object.GetEndPoint()
            drill(x=pos.x / wx.GetApp().program.units,
                  y=pos.y / wx.GetApp().program.units,
                  dwell=self.dwell,
                  depthparams=depth_params,
                  retract_mode=self.retract_mode,
                  spindle_mode=self.spindle_mode,
                  internal_coolant_on=self.internal_coolant_on,
                  rapid_to_clearance=self.rapid_to_clearance)

        end_canned_cycle()