Exemple #1
0
 def Execute(cls, job, path, dialog=None):
     root = xml.Element('PathJobTemplate')
     jobAttributes = job.Proxy.templateAttrs(job)
     if dialog and not dialog.includePostProcessing():
         jobAttributes.pop(PathJob.JobTemplate.PostProcessor, None)
         jobAttributes.pob(PathJob.JobTemplate.PostProcessorArgs, None)
         jobAttributes.pob(PathJob.JobTemplate.PostProcessorOutputFile,
                           None)
     xml.SubElement(root, PathJob.JobTemplate.Job, jobAttributes)
     tcs = dialog.includeToolControllers() if dialog else job.ToolController
     for tc in tcs:
         element = xml.SubElement(root, PathJob.JobTemplate.ToolController,
                                  tc.Proxy.templateAttrs(tc))
         element.append(xml.fromstring(tc.Tool.Content))
     if dialog:
         if dialog.includeStock():
             xml.SubElement(
                 root, PathJob.JobTemplate.Stock,
                 PathStock.TemplateAttributes(
                     job.Stock, dialog.includeStockExtent(),
                     dialog.includeStockPlacement()))
     else:
         xml.SubElement(root, PathJob.JobTemplate.Stock,
                        PathStock.TemplateAttributes(job.Stock))
     xml.ElementTree(root).write(path)
    def test11(self):
        """Verify FromTemplate cylinder creation."""
        radius = 7
        height = 12
        placement = FreeCAD.Placement(
            FreeCAD.Vector(99, 88, 77), FreeCAD.Vector(1, 1, 1), 123
        )
        orig = PathStock.CreateCylinder(self.job, radius, height, placement)

        # full template
        template = PathStock.TemplateAttributes(orig)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateCylinder, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(orig.Radius, stock.Radius)
        self.assertEqual(orig.Height, stock.Height)
        self.assertPlacement(orig.Placement, stock.Placement)

        # no extent in template
        template = PathStock.TemplateAttributes(orig, False, True)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateCylinder, PathStock.StockType.FromStock(stock)
        )
        self.assertRoughly(R, stock.Radius.Value)
        self.assertEqual(300, stock.Height)
        self.assertPlacement(orig.Placement, stock.Placement)

        # no placement template - and no base
        template = PathStock.TemplateAttributes(orig, True, False)
        stock = PathStock.CreateFromTemplate(None, template)

        self.assertEqual(
            PathStock.StockType.CreateCylinder, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(orig.Radius, stock.Radius)
        self.assertEqual(orig.Height, stock.Height)
        self.assertPlacement(FreeCAD.Placement(), stock.Placement)

        # no placement template - but base
        template = PathStock.TemplateAttributes(orig, True, False)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateCylinder, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(orig.Radius, stock.Radius)
        self.assertEqual(orig.Height, stock.Height)
        self.assertPlacement(
            FreeCAD.Placement(FreeCAD.Vector(50, 100, 0), FreeCAD.Rotation()),
            stock.Placement,
        )
Exemple #3
0
    def Execute(cls, job, path, dialog=None):
        attrs = job.Proxy.templateAttrs(job)

        # post processor settings
        if dialog and not dialog.includePostProcessing():
            attrs.pop(PathJob.JobTemplate.PostProcessor, None)
            attrs.pop(PathJob.JobTemplate.PostProcessorArgs, None)
            attrs.pop(PathJob.JobTemplate.PostProcessorOutputFile, None)

        # tool controller settings
        toolControllers = dialog.includeToolControllers(
        ) if dialog else job.Tools.Group
        if toolControllers:
            tcAttrs = [tc.Proxy.templateAttrs(tc) for tc in toolControllers]
            attrs[PathJob.JobTemplate.ToolController] = tcAttrs

        # stock settings
        stockAttrs = None
        if dialog:
            if dialog.includeStock():
                stockAttrs = PathStock.TemplateAttributes(
                    job.Stock,
                    dialog.includeStockExtent(),
                    dialog.includeStockPlacement(),
                )
        else:
            stockAttrs = PathStock.TemplateAttributes(job.Stock)
        if stockAttrs:
            attrs[PathJob.JobTemplate.Stock] = stockAttrs

        # setup sheet
        setupSheetAttrs = None
        if dialog:
            setupSheetAttrs = job.Proxy.setupSheet.templateAttributes(
                dialog.includeSettingToolRapid(),
                dialog.includeSettingCoolant(),
                dialog.includeSettingOperationHeights(),
                dialog.includeSettingOperationDepths(),
                dialog.includeSettingOpsSettings(),
            )
        else:
            setupSheetAttrs = job.Proxy.setupSheet.templateAttributes(
                True, True, True)
        if setupSheetAttrs:
            attrs[PathJob.JobTemplate.SetupSheet] = setupSheetAttrs

        encoded = job.Proxy.setupSheet.encodeTemplateAttributes(attrs)
        # write template
        with open(PathUtil.toUnicode(path), "w") as fp:
            json.dump(encoded, fp, sort_keys=True, indent=2)
Exemple #4
0
    def test12(self):
        '''Verify FromTemplate from Base creation.'''
        neg = FreeCAD.Vector(1, 2, 3)
        pos = FreeCAD.Vector(9, 8, 7)
        orig = PathStock.CreateFromBase(self.job, neg, pos)

        # Make sure we have a different base object for the creation
        self.base.Length = 11
        self.base.Width = 12
        self.base.Height = 13

        # full template
        template = PathStock.TemplateAttributes(orig)
        stock = PathStock.CreateFromTemplate(self.job, template)
        self.assertEqual(PathStock.StockType.FromBase,
                         PathStock.StockType.FromStock(stock))
        self.assertEqual(orig.ExtXneg, stock.ExtXneg)
        self.assertEqual(orig.ExtXpos, stock.ExtXpos)
        self.assertEqual(orig.ExtYneg, stock.ExtYneg)
        self.assertEqual(orig.ExtYpos, stock.ExtYpos)
        self.assertEqual(orig.ExtZneg, stock.ExtZneg)
        self.assertEqual(orig.ExtZpos, stock.ExtZpos)

        bb = stock.Shape.BoundBox
        self.assertEqual(neg.x + pos.x + 11, bb.XLength)
        self.assertEqual(neg.y + pos.y + 12, bb.YLength)
        self.assertEqual(neg.z + pos.z + 13, bb.ZLength)
    def test10(self):
        """Verify FromTemplate box creation."""

        extent = FreeCAD.Vector(17, 13, 77)
        placement = FreeCAD.Placement(
            FreeCAD.Vector(3, 8, -4), FreeCAD.Vector(0, 0, 1), -90
        )
        orig = PathStock.CreateBox(self.job, extent, placement)

        # collect full template
        template = PathStock.TemplateAttributes(orig)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateBox, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(orig.Length, stock.Length)
        self.assertEqual(orig.Width, stock.Width)
        self.assertEqual(orig.Height, stock.Height)
        self.assertPlacement(orig.Placement, stock.Placement)

        # don't store extent in template
        template = PathStock.TemplateAttributes(orig, False, True)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateBox, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(100, stock.Length)
        self.assertEqual(200, stock.Width)
        self.assertEqual(300, stock.Height)
        self.assertPlacement(orig.Placement, stock.Placement)

        # don't store placement in template
        template = PathStock.TemplateAttributes(orig, True, False)
        stock = PathStock.CreateFromTemplate(self.job, template)

        self.assertEqual(
            PathStock.StockType.CreateBox, PathStock.StockType.FromStock(stock)
        )
        self.assertEqual(orig.Length, stock.Length)
        self.assertEqual(orig.Width, stock.Width)
        self.assertEqual(orig.Height, stock.Height)
        self.assertPlacement(FreeCAD.Placement(), stock.Placement)
 def Execute(cls, job, path, dialog=None):
     attrs = job.Proxy.templateAttrs(job)
     if dialog and not dialog.includePostProcessing():
         attrs.pop(PathJob.JobTemplate.PostProcessor, None)
         attrs.pob(PathJob.JobTemplate.PostProcessorArgs, None)
         attrs.pob(PathJob.JobTemplate.PostProcessorOutputFile, None)
     toolControllers = dialog.includeToolControllers(
     ) if dialog else job.ToolController
     if toolControllers:
         tcAttrs = [tc.Proxy.templateAttrs(tc) for tc in toolControllers]
         attrs[PathJob.JobTemplate.ToolController] = tcAttrs
     stockAttrs = None
     if dialog:
         if dialog.includeStock():
             stockAttrs = PathStock.TemplateAttributes(
                 job.Stock, dialog.includeStockExtent(),
                 dialog.includeStockPlacement())
     else:
         stockAttrs = PathStock.TemplateAttributes(job.Stock)
     if stockAttrs:
         attrs[PathJob.JobTemplate.Stock] = stockAttrs
     with open(unicode(path), 'wb') as fp:
         json.dump(attrs, fp, sort_keys=True, indent=2)