Example #1
0
def importVtk(
    filename,
    object_name=None,
    object_type=None
):
    if not object_type:
        vtkinout_prefs = FreeCAD.ParamGet(
            "User parameter:BaseApp/Preferences/Mod/Fem/InOutVtk"
        )
        object_type = vtkinout_prefs.GetInt("ImportObject", 0)
    if not object_name:
        object_name = os.path.splitext(os.path.basename(filename))[0]
    if object_type == 0:
        # vtk result object
        importVtkVtkResult(filename, object_name)
    elif object_type == 1:
        # FEM mesh object
        importVtkFemMesh(filename, object_name)
    elif object_type == 2:
        # FreeCAD result object
        importVtkFCResult(filename, object_name)
    else:
        Console.PrintError(
            "Error, wrong parameter in VTK import pref: {}\n"
            .format(object_type)
        )
Example #2
0
    def render(self, context):
        Console.PrintMessage("render\n")

        self.width = context.width
        self.depth = context.depth
        self.height = context.height

        self.hole_style = context.hole_style
        self.holes_offset = context.holes_offset

        self.doc = context.doc
        self.brick = context.brick

        self.top_datum_plane = context.top_datum_plane
        self.top_inside_datum_plane = context.top_inside_datum_plane
        self.front_inside_datum_plane = context.front_inside_datum_plane
        self.back_inside_datum_plane = context.back_inside_datum_plane
        self.left_inside_datum_plane = context.left_inside_datum_plane
        self.right_inside_datum_plane = context.right_inside_datum_plane
        self.xy_plane = context.xy_plane

        body_pad_sketch = self._render_body_pad_and_fillets()

        # TODO: support side rib variation for modern 2x1 tile and technic bricks with non-offset holes
        # TODO: 0.25 fillet on inner corners
        self._render_body_pocket(body_pad_sketch)

        # TODO: determine a replacement for internal ribs if side studs exist with holes
        self._render_tubes_or_sticks(body_pad_sketch)
    def render(self, context):
        Console.PrintMessage("render\n")

        self.doc = context.doc
        self.brick = context.brick

        self.width = context.width
        self.depth = context.depth
        self.style = context.top_studs_style
        self.width_count = context.top_studs_width_count
        self.depth_count = context.top_studs_depth_count

        self.top_datum_plane = context.top_datum_plane
        self.top_inside_datum_plane = context.top_inside_datum_plane

        initial_width_offset = (self.width -
                                self.width_count) * DIMS_STUD_SPACING / 2
        initial_depth_offset = (self.depth -
                                self.depth_count) * DIMS_STUD_SPACING / 2

        self._render_top_studs_outside(initial_width_offset,
                                       initial_depth_offset)

        # Only render inner pocket if closed studs AND studs are not offset
        if self.style == TopStudStyle.CLOSED and initial_width_offset == 0 and initial_depth_offset == 0:
            self._render_top_studs_inside(initial_width_offset,
                                          initial_depth_offset)
Example #4
0
 def accept(self):
     # Verify the active document
     actDoc = FreeCAD.ActiveDocument
     if not actDoc:
         self.errorBox("No Open Document\n")
         return False
     Console.PrintMessage("Accepted" + '\n')
     docName = actDoc.Label
     docDir = FreeCAD.ActiveDocument.FileName.replace(
         docName + ".fcstd", "")
     partList = FreeCADGui.Selection.getSelection()
     # Verify at least one part is selected
     if not partList:
         self.errorBox("Select at Least One Part Object")
         return False
     stlParts = docDir + docName + ".stl"
     Mesh.export(partList, stlParts)
     self.pos = self.GetXYZPos(partList)
     #Console.PrintMessage(str(self.pos) + '\n')
     retVal = self.sliceParts(self.Vars.readMisc("CuraPath"), stlParts)
     if retVal is True:
         self.errorBox("Slice Failed!\n Check log file\n" + logFile)
         return False
     else:
         return True
Example #5
0
def Enable():
    global observer
    observer = selObserver3DView();
    # add the listener, 0 forces to resolve the links
    Gui.Selection.addObserver(observer, 0)
    #print("3D view link selection mode is now enabled")
    FCC.PrintMessage("3D view link selection mode is now ENABLED\n")
Example #6
0
def convertToDwg(dxffilename, dwgfilename):
    """Convert a DXF file to a DWG file.

    If the converter is found it is used, otherwise the conversion fails.

    Parameters
    ----------
    dxffilename : str
        The input DXF file
    dwgfilename : str
        The output DWG file

    Returns
    -------
    str
        The same `dwgfilename` file path.
    """
    import os, subprocess
    teigha = getTeighaConverter()
    if teigha:
        indir = os.path.dirname(dxffilename)
        outdir = os.path.dirname(dwgfilename)
        basename = os.path.basename(dxffilename)
        cmdline = ('"%s" "%s" "%s" "ACAD2000" "DWG" "0" "1" "%s"'
                   % (teigha, indir, outdir, basename))
        FCC.PrintMessage(translate("ImportDWG", "Converting: ")
                         + cmdline + "\n")
        subprocess.call(cmdline, shell=True)  # os.system(cmdline)
        return dwgfilename
    return None
def createConfig(name, description):
    group = getConfGroup()
    if not group:
        # create a group Configurations to store various config tables
        assy = Asm4.getAssembly()
        if assy:
            group = assy.newObject('App::DocumentObjectGroup',
                                   'Configurations')
        else:
            FCC.PrintWarnin('No assembly container here, quitting\n')
            return
    # Create the document
    conf = group.newObject('Spreadsheet::Sheet', name)
    headerRow = str(int(OBJECTS_START_ROW) - 1)
    #conf.set(HEADER_CELL,           'Assembly4 configuration table')
    conf.set(HEADER_CELL, ASM4_CONFIG_TYPE)
    conf.set(DESCRIPTION_CELL, str(description))
    conf.set(OBJECT_NAME_COL + headerRow, 'ObjectName')
    conf.set(OBJECT_VISIBLE_COL + headerRow, 'Visible')
    conf.set(OBJECT_ASM_TYPE_COL + headerRow, 'Assembly Type')
    conf.set(OFFSET_POS_X_COL + headerRow, 'Pos. X')
    conf.set(OFFSET_POS_Y_COL + headerRow, 'Pos. Y')
    conf.set(OFFSET_POS_Z_COL + headerRow, 'Pos. Z')
    conf.set(OFFSET_ROT_YAW_COL + headerRow, 'Rot. Yaw')
    conf.set(OFFSET_ROT_PITCH_COL + headerRow, 'Rot. Pitch')
    conf.set(OFFSET_ROT_ROLL_COL + headerRow, 'Rot. Roll')
    return conf
Example #8
0
 def Activated(self):
     #Handle single selected App::Link
     selectedLink = None
     parentAssembly = None
     selection = Asm4.getSelectedLink()
     if not selection:
         # This shouldn't happen
         FCC.PrintWarning(
             "This is not an error message you are supposed to see, something went wrong\n"
         )
         return
     else:
         parent = selection.getParentGeoFeatureGroup()
         # only handle if the parent is at the root of the document:
         if parent and parent.TypeId == 'App::Part' and parent.getParentGeoFeatureGroup(
         ) is None:
             # only accept Asm4 Models as assemblies
             # this is self-imposed, works also without an Asm4 Model
             if parent.Name == 'Model':
                 # launch the UI in the task panel
                 Gui.Control.showDialog(placeLinkUI())
             else:
                 Asm4.warningBox(
                     'Please select a link in the assembly Model')
         else:
             Asm4.warningBox('Please select a link in the assembly Model.')
     return
Example #9
0
    def run_gmsh_with_geo(self):
        comandlist = [self.gmsh_bin, "-", self.temp_file_geo]
        # print(comandlist)
        try:
            p = subprocess.Popen(comandlist,
                                 shell=False,
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
            output, error = p.communicate()
            if sys.version_info.major >= 3:
                # output = output.decode("utf-8")
                error = error.decode("utf-8")
            # stdout is still cut at some point
            # but the warnings are in stderr and thus printed :-)
            # print(output)
            # print(error)
        except Exception:
            error = "Error executing: {}\n".format(" ".join(comandlist))
            Console.PrintError(error)
            self.error = True

        # workaround
        # filter useless gmsh warning in the regard of unknown element MSH type 15
        # https://forum.freecadweb.org/viewtopic.php?f=18&t=33946
        useless_warning = ("Warning : Unknown element type for UNV export "
                           "(MSH type 15) - output file might be invalid")
        new_err = error.replace(useless_warning, "")
        # remove empty lines, https://stackoverflow.com/a/1140967
        new_err = "".join(
            [s for s in new_err.splitlines(True) if s.strip("\r\n")])

        return new_err
Example #10
0
 def accept(self):
     if self.Apply():
         # highlight in the 3D window the object we placed
         self.finish()
     else:
         FCC.PrintWarning("Problem in selections\n")
         return
Example #11
0
 def accept(self):
     if self.onApply():
         if self.selectedDatum:
             self.selectedDatum.ViewObject.ShowLabel = False
         self.finish()
     else:
         FCC.PrintWarning("Problem in selections\n")
Example #12
0
def get_FemMeshObjectOrder(
    fem_mesh_obj
):
    """
        Gets element order. Element order counting based on number of nodes on
        edges. Edge with 2 nodes -> linear elements, Edge with 3 nodes ->
        quadratic elements, and so on. No edges in mesh -> not determined.
        (Is this possible? Seems to be a very degenerate case.)
        If there are edges with different number of nodes appearing, return
        list of orders.
    """
    presumable_order = None

    edges = fem_mesh_obj.FemMesh.Edges

    if edges != ():
        edges_length_set = list({len(fem_mesh_obj.FemMesh.getElementNodes(e)) for e in edges})
        # only need set to eliminate double entries

        if len(edges_length_set) == 1:
            presumable_order = edges_length_set[0] - 1
        else:
            presumable_order = [el - 1 for el in edges_length_set]
    else:
        Console.PrintMessage(
            "Found no edges in mesh: Element order determination does not work without them.\n"
        )

    return presumable_order
Example #13
0
def decodeName(name):
    """Decode encoded name.

    Parameters
    ----------
    name : str
        The string to decode.

    Returns
    -------
    tuple
    (string)
        A tuple containing the decoded `name` in 'utf8', otherwise in 'latin1'.
        If it fails it returns the original `name`.
    """
    try:
        decodedName = (name.decode("utf8"))
    except UnicodeDecodeError:
        try:
            decodedName = (name.decode("latin1"))
        except UnicodeDecodeError:
            FCC.PrintError(
                translate(
                    "importOCA", "OCA error: "
                    "couldn't determine character encoding") + "\n")
            decodedName = name
    return decodedName
Example #14
0
def RestoreObject(doc, obj):
    # parse App::Part containers, and only those
    if obj.TypeId == 'App::Part':
        SaveSubObjects(conf, obj)

    parentObj, objFullName = obj.Parents[0]
    #objName = App.ActiveDocument.Name + '.' + parentObj.Name + '.' + objFullName
    objName = parentObj.Name + '.' + objFullName

    row = GetObjectRow(doc, objName)
    if row is None:
        FCC.PrintMessage('No data for object "' + objName + '" in configuration "' + doc.Name + '"\n')
        return

    vis   = doc.get( OBJECT_VISIBLE_COL   + row )
    obj.ViewObject.Visibility = vis
    asm   = str(doc.get( OBJECT_ASM_TYPE_COL  + row ))
    if asm == 'Asm4EE':
        x     = doc.get( OFFSET_POS_X_COL     + row )
        y     = doc.get( OFFSET_POS_Y_COL     + row )
        z     = doc.get( OFFSET_POS_Z_COL     + row )
        yaw   = doc.get( OFFSET_ROT_YAW_COL   + row )
        pitch = doc.get( OFFSET_ROT_PITCH_COL + row )
        roll  = doc.get( OFFSET_ROT_ROLL_COL  + row )
        position = App.Vector(x, y, z)
        rotation = App.Rotation(yaw, pitch, roll)
        offset = App.Placement(position, rotation)
        obj.AttachmentOffset = offset
Example #15
0
    def onApply(self):
        # get the name of the part to attach to:
        # it's either the top level part name ('Model')
        # or the provided link's name.
        if self.parentList.currentText() == 'Parent Assembly':
            a_Link = 'Parent Assembly'
            a_Part = None
        elif self.parentList.currentIndex() > 1:
            parent = self.parentTable[ self.parentList.currentIndex() ]
            a_Link = parent.Name
            a_Part = parent.LinkedObject.Document.Name
        else:
            a_Link = None
            a_Part = None

        # the attachment LCS's name in the parent
        # check that something is selected in the QlistWidget
        if self.attLCSlist.selectedItems():
            a_LCS = self.attLCStable[ self.attLCSlist.currentRow() ].Name
        else:
            a_LCS = None

        # check that all of them have something in
        if a_Link and a_LCS :
            # <<LinkName>>.Placement.multiply( <<LinkName>>.<<LCS.>>.Placement )
            # expr = '<<'+ a_Part +'>>.Placement.multiply( <<'+ a_Part +'>>.<<'+ a_LCS +'.>>.Placement )'
            
            Asm4.placeObjectToLCS(self.selectedFastener, a_Link, a_Part, a_LCS)
            
            # highlight the selected fastener in its new position
            Gui.Selection.clearSelection()
            Gui.Selection.addSelection( self.activeDoc.Name, 'Model', self.selectedFastener.Name +'.')
        else:
            FCC.PrintWarning("Problem in selections\n")
        return
Example #16
0
def export(objectslist, filename):
    "called when freecad exports a file"
    if len(objectslist) != 1:
        Console.PrintError("This exporter can only export one object.\n")
        return
    obj = objectslist[0]
    if not obj.isDerivedFrom("Fem::FemMeshObject"):
        Console.PrintError("No FEM mesh object selected.\n")
        return
    femnodes_mesh = obj.FemMesh.Nodes
    femelement_table = meshtools.get_femelement_table(obj.FemMesh)
    z88_element_type = get_z88_element_type(obj.FemMesh, femelement_table)
    f = pyopen(filename, "w")
    write_z88_mesh_to_file(femnodes_mesh, femelement_table, z88_element_type,
                           f)
    f.close()
    def _render_side_studs_inside(self, label, plane, count, inverted):
        Console.PrintMessage("render_side_studs_inside({},{})\n".format(label, count))

        # side studs pocket

        side_studs_inside_pocket_sketch = self.brick.newObject("Sketcher::SketchObject",
                                                               label + "_side_studs_inside_pocket_sketch")
        side_studs_inside_pocket_sketch.Support = (plane, '')
        side_studs_inside_pocket_sketch.MapMode = 'FlatFace'

        add_inner_circle_with_flats_to_sketch(side_studs_inside_pocket_sketch, DIMS_STUD_OUTER_RADIUS,
                                              DIMS_STUD_INNER_RADIUS, DIMS_STUD_FLAT_THICKNESS,
                                              0, DIMS_SIDE_STUD_CENTRE_HEIGHT)
        self.doc.recompute()

        # create array if needed
        if count > 1:
            geometry_indices = [range(0, len(side_studs_inside_pocket_sketch.Geometry) - 1)]
            side_studs_inside_pocket_sketch.addRectangularArray(geometry_indices,
                                                                Vector(DIMS_STUD_SPACING, 0, 0), False,
                                                                count, 1, True)
        self.doc.recompute()

        side_studs_inside_pocket = self.brick.newObject("PartDesign::Pocket", label + "_side_studs_inside_pocket")
        side_studs_inside_pocket.Type = POCKET_TYPE_DIMENSION
        side_studs_inside_pocket.Profile = side_studs_inside_pocket_sketch
        side_studs_inside_pocket.Reversed = inverted
        side_studs_inside_pocket.Length = DIMS_RIBBED_SIDE_THICKNESS + DIMS_STUD_INSIDE_HOLE_TOP_OFFSET

        self.doc.recompute()
        side_studs_inside_pocket_sketch.ViewObject.Visibility = False
Example #18
0
def readResult(dat_input):
    Console.PrintMessage(
        "Read ccx results from dat file: {}\n".format(dat_input))
    dat_file = pyopen(dat_input, "r")
    eigenvalue_output_section_found = False
    mode_reading = False
    results = []

    for line in dat_file:
        if EIGENVALUE_OUTPUT_SECTION in line:
            # Found EIGENVALUE_OUTPUT_SECTION
            eigenvalue_output_section_found = True
        if eigenvalue_output_section_found:
            try:
                mode = int(line[0:7])
                mode_frequency = float(line[39:55])
                m = {}
                m["eigenmode"] = mode
                m["frequency"] = mode_frequency
                results.append(m)
                mode_reading = True
            except Exception:
                if mode_reading:
                    # Conversion error after mode reading started, so it's the end of section
                    eigenvalue_output_section_found = False
                    mode_reading = False

    dat_file.close()
    return results
Example #19
0
 def get_gmsh_command(self):
     from platform import system
     gmsh_std_location = FreeCAD.ParamGet(
         "User parameter:BaseApp/Preferences/Mod/Fem/Gmsh").GetBool(
             "UseStandardGmshLocation")
     if gmsh_std_location:
         if system() == "Windows":
             gmsh_path = FreeCAD.getHomePath() + "bin/gmsh.exe"
             FreeCAD.ParamGet(
                 "User parameter:BaseApp/Preferences/Mod/Fem/Gmsh"
             ).SetString("gmshBinaryPath", gmsh_path)
             self.gmsh_bin = gmsh_path
         elif system() == "Linux":
             p1 = subprocess.Popen(["which", "gmsh"],
                                   stdout=subprocess.PIPE)
             if p1.wait() == 0:
                 output = p1.stdout.read()
                 if sys.version_info.major >= 3:
                     output = output.decode("utf-8")
                 gmsh_path = output.split("\n")[0]
             elif p1.wait() == 1:
                 error_message = (
                     "Gmsh binary gmsh not found in standard system binary path. "
                     "Please install Gmsh or set path to binary "
                     "in FEM preferences tab Gmsh.\n")
                 Console.PrintError(error_message)
                 raise GmshError(error_message)
             self.gmsh_bin = gmsh_path
         else:
             error_message = (
                 "No standard location implemented for your operating system. "
                 "Set GMHS binary path in FEM preferences.\n")
             Console.PrintError(error_message)
             raise GmshError(error_message)
     else:
         if not self.gmsh_bin:
             self.gmsh_bin = FreeCAD.ParamGet(
                 "User parameter:BaseApp/Preferences/Mod/Fem/Gmsh"
             ).GetString("gmshBinaryPath", "")
         if not self.gmsh_bin:  # in prefs not set, we will try to use something reasonable
             if system() == "Linux":
                 self.gmsh_bin = "gmsh"
             elif system() == "Windows":
                 self.gmsh_bin = FreeCAD.getHomePath() + "bin/gmsh.exe"
             else:
                 self.gmsh_bin = "gmsh"
     Console.PrintMessage("  " + self.gmsh_bin + "\n")
Example #20
0
    def _parse_side_studs(self, side_studs):

        style = side_studs["style"]

        if style not in (SideStudStyle.NONE, SideStudStyle.OPEN,
                         SideStudStyle.HOLE):
            raise Exception(
                "side_studs[\"style\"] must be: "
                "SideStudStyle.NONE|SideStudStyle.OPEN|SideStudStyle.HOLE")

        if style != SideStudStyle.NONE and self.height < 3:
            Console.PrintMessage(
                "side_studs[\"style\"] set to SideStudStyle.NONE as "
                "dimensions[\"width\"] < 3\n")
            style = SideStudStyle.NONE

        front = bool(side_studs["front"])
        back = bool(side_studs["back"])
        left = bool(side_studs["left"])
        right = bool(side_studs["right"])

        if style != SideStudStyle.NONE and not front and not back and not left and not right:

            Console.PrintMessage(
                "side_studs[\"style\"] set to SideStudStyle.NONE as "
                "none of Front, Back, Left, Right are True\n")
            style = SideStudStyle.NONE

        self.side_studs_style = style

        if self.side_studs_style == SideStudStyle.NONE:

            Console.PrintMessage("Side Studs: NONE\n")

        else:

            self.side_studs_front = front
            self.side_studs_back = back
            self.side_studs_left = left
            self.side_studs_right = right

            Console.PrintMessage("Side Studs: {0} {1}{2}{3}{4}\n".format(
                "OPEN" if self.side_studs_style == SideStudStyle.OPEN else
                "HOLE", "FRONT " if self.side_studs_front else "",
                "BACK" if self.side_studs_back else "",
                "LEFT " if self.side_studs_left else "",
                "RIGHT " if self.side_studs_right else ""))
def calculate_global_placement(child: object,
                               placements: Placement = []) -> Placement:
    placements.append(child.Placement)
    in_list = child.InList
    num_in = len(in_list)
    if num_in == 0:
        global_placement = Placement()
        placements.reverse()  # Reverse list in order of parent to child.
        for placement in placements:
            global_placement *= placement
        return global_placement
    if num_in > 1:
        Console.PrintWarning(
            f'{child.Label} has more than 1 parent. Choosing 1st.\n')
    parent = in_list[0]
    Console.PrintMessage(f'{parent.Label} ({parent.TypeId})\n')
    return calculate_global_placement(parent, placements)
def observerDisable():
    global Asm4_3DselObserver
    Gui.Selection.removeObserver(Asm4_3DselObserver) 
    setButton(3,False)
    # only print to Console if the Asm4_3DselObserver was there
    if Asm4_3DselObserver:
        FCC.PrintMessage("Asm4 3D view selection mode is now DISABLED\n")
    Asm4_3DselObserver = None
Example #23
0
    def render(self):

        context = BrickContext()

        try:
            context.width = self.width
            context.depth = self.depth
            context.height = self.height

            context.top_studs_style = self.top_studs_style
            if self.top_studs_style != TopStudStyle.NONE:
                context.top_studs_width_count = self.top_studs_width_count
                context.top_studs_depth_count = self.top_studs_depth_count

            context.side_studs_style = self.side_studs_style
            if self.side_studs_style != SideStudStyle.NONE:
                context.side_studs_front = self.side_studs_front
                context.side_studs_back = self.side_studs_back
                context.side_studs_left = self.side_studs_left
                context.side_studs_right = self.side_studs_right

            context.pins_style = self.pins_style
            if self.pins_style != PinStyle.NONE:
                context.pins_front = self.pins_front
                context.pins_back = self.pins_back
                context.pins_left = self.pins_left
                context.pins_right = self.pins_right
                context.pins_offset = self.pins_offset

            context.hole_style = self.hole_style
            if self.hole_style != HoleStyle.NONE:
                context.holes_offset = self.holes_offset

            context.doc = activeDocument()
            context.brick = context.doc.addObject("PartDesign::Body", "brick")

            self._create_datum_planes(context)

            BodyRenderer().render(context)

            if self.top_studs_style != TopStudStyle.NONE:
                TopStudsRenderer().render(context)

            if self.side_studs_style != SideStudStyle.NONE:
                SideStudsRenderer().render(context)

            if self.pins_style != PinStyle.NONE:
                PinsRenderer().render(context)

            if self.hole_style != HoleStyle.NONE:
                HolesRenderer().render(context)

            context.brick.Tip.ViewObject.Visibility = True

        except Exception as inst:
            Console.PrintError(inst)
        finally:
            del context
def get_heated_bed_creation_kwargs():
    selection_objects = Gui.Selection.getSelectionEx()
    try:
        frame, axis = find_frame_and_axis_in_selection(selection_objects)
        return get_heated_bed_frame_axis_attachment_kwargs(frame, axis)
    except AttachmentError as reason:
        log_message_template = '{}. Placing heated bed in default position.\n'
        Console.PrintMessage(log_message_template.format(reason))
        return {}
def observerEnable():
    # remove any selection filters
    Gui.Selection.removeSelectionGate()
    global Asm4_3DselObserver
    Asm4_3DselObserver = selObserver3DView();
    # add the listener, 0 forces to resolve the links
    Gui.Selection.addObserver(Asm4_3DselObserver, 0)
    setButton(3,True)
    FCC.PrintMessage("Asm4 3D view selection mode is now ENABLED\n")
def _get_axis_creation_kwargs(axis_orientation):
    selection_objects = Gui.Selection.getSelectionEx()
    try:
        frame, face = find_frame_and_face_in_selection(selection_objects)
        return get_axis_frame_attachment_kwargs(frame, face, axis_orientation)
    except AttachmentError as reason:
        log_message_template = '{}. Placing axis in default position.\n'
        Console.PrintMessage(log_message_template.format(reason))
        return get_default_axis_creation_kwargs(axis_orientation)
Example #27
0
def write_dict_list_to_csv(dict_list, columns, filename):
    try:
        with open(filename, 'w') as csv_file:
            writer = csv.DictWriter(csv_file, fieldnames=columns)
            writer.writeheader()
            for row in dict_list:
                writer.writerow(row)
    except IOError as e:
        Console.PrintError(str(e))
def get_extruder_creation_kwargs():
    selection_objects = Gui.Selection.getSelectionEx()
    try:
        axis, face = find_axis_and_face_in_selection(selection_objects)
        return get_extruder_axis_attachment_kwargs(axis, face)
    except AttachmentError as reason:
        log_message_template = '{}. Placing extruder in default position.\n'
        Console.PrintMessage(log_message_template.format(reason))
        return {}
Example #29
0
 def writeMisc(self, key, val):
     grp = FreeCAD.ParamGet(
         "User parameter:BaseApp/Preferences/Mod/CuraEngine")
     pt = self.getParamType(key)
     if pt is "string":
         grp.SetString(key, val)
     elif pt is "float":
         grp.SetFloat(key, val)
     Console.PrintMessage("Setting " + key + " to " + str(val) + '\n')
 def accept(self):
     """
     Executed upon clicking "OK" button in FreeCAD Tasks panel.
     """
     Console.PrintMessage('Saving cut list as "{}".\n'.format(
         self.save_file_name))
     write_dict_list_to_csv(self.cut_list_table_rows, self.columns,
                            self.save_file_name)
     FreeCADGui.Control.closeDialog()