Exemplo n.º 1
0
def export_one_part(modul, variant):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage(
            "Parameters for %s doesn't exist in 'M.all_params', skipping." %
            variant)
        return
    ModelName = modul.all_params[variant].model_name
    FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)
    (pins, body) = modul.generate_part(variant)

    color_attr = body_color + (0, )
    show(body, color_attr)

    color_attr = pins_color + (0, )
    show(pins, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = ModelName + "__body"
    objs[1].Label = ModelName + "__pins"

    restore_Main_Tools()

    out_dir = destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name = destination_dir + os.sep + FileName + '.wrl'

    export_objects = []
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[0],
                             shape_color=body_color_key,
                             face_colors=None))
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[1],
                             shape_color=pins_color_key,
                             face_colors=None))

    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    fusion = FuseObjs_wColors(FreeCAD,
                              FreeCADGui,
                              ModelName,
                              objs[0].Name,
                              objs[1].Name,
                              keepOriginals=True)
    exportSTEP(doc, FileName, out_dir, fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    saveFCdoc(App, Gui, doc, FileName, out_dir)
def export_one_part(params):
    FreeCAD.Console.PrintMessage('\r\n' + params.model_name)
    ModelName = params.model_name
    FileName = params.file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)
    (pins, body) = M.generate_part(params)

    color_attr = body_color + (0, )
    show(body, color_attr)

    color_attr = pins_color + (0, )
    show(pins, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = ModelName + "__body"
    objs[1].Label = ModelName + "__pins"

    restore_Main_Tools()

    out_dir = destination_dir

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name = destination_dir + os.sep + FileName + '.wrl'

    export_objects = []
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[0],
                             shape_color=body_color_key,
                             face_colors=None))
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[1],
                             shape_color=pins_color_key,
                             face_colors=None))

    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    fusion = FuseObjs_wColors(FreeCAD,
                              FreeCADGui,
                              ModelName,
                              objs[0].Name,
                              objs[1].Name,
                              keepOriginals=True)
    exportSTEP(doc, FileName, out_dir, fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    FreeCAD.activeDocument().recompute()
    #FreeCADGui.activateWorkbench("PartWorkbench")
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewAxometric()

    saveFCdoc(App, Gui, doc, FileName, out_dir)
def MakeHeader(n, params):

    name = HeaderName(n, params)

    #having a period '.' character in the model name REALLY messes with things.
    docname = name.replace(".", "")

    newdoc = FreeCAD.newDocument(docname)
    App.setActiveDocument(docname)
    Gui.ActiveDocument = Gui.getDocument(docname)

    pins = MakePinRow(n, params)

    #duplicate pin rows
    if params.rows > 1:
        for i in range(1, params.rows):
            pins = pins.union(
                MakePinRow(n, params).translate((0, i * params.p, 0)))

    base = MakeBase(n, params)

    #assign some colors
    base_color = (50, 50, 50)
    pins_color = (225, 175, 0)

    show(base, base_color + (0, ))
    show(pins, pins_color + (0, ))

    doc = FreeCAD.ActiveDocument

    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = docname
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = docname
    restore_Main_Tools()

    if (params.rot != 0):
        z_RotateObject(doc, params.rot)

    out_dir = "./generated_pinheaders/"

    doc.Label = docname

    #save the STEP file
    exportSTEP(doc, name, out_dir)

    #save the VRML file
    scale = 0.3937001
    exportVRML(doc, name, scale, out_dir)

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name, out_dir)

    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()

    return 0
def MakeHeader(n, params):
    
    name = HeaderName(n,params)
    
    #having a period '.' character in the model name REALLY messes with things.
    docname = name.replace(".","")
    
    newdoc = FreeCAD.newDocument(docname)
    App.setActiveDocument(docname)
    Gui.ActiveDocument=Gui.getDocument(docname)
    
    pins = MakePinRow(n,params)
    
    #duplicate pin rows
    if params.rows > 1:
        for i in range(1,params.rows):
            pins = pins.union(MakePinRow(n,params).translate((0,i*params.p,0)))
    
    base = MakeBase(n,params)
        
    #assign some colors
    base_color = (50,50,50)
    pins_color = (225,175,0)

    show(base,base_color+(0,))
    show(pins,pins_color+(0,))
    
    doc = FreeCAD.ActiveDocument
        
    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui,
                   doc.Name, objs[0].Name, objs[1].Name)
    doc.Label=docname
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=docname
    restore_Main_Tools()

    if (params.rot !=0):
        z_RotateObject(doc, params.rot)
    
    out_dir = "./generated_pinheaders/"
    
    doc.Label = docname
    
    #save the STEP file
    exportSTEP(doc, name, out_dir)

    #save the VRML file
    scale=0.3937001
    exportVRML(doc,name,scale,out_dir)
    
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name,out_dir)

    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()

    return 0
def main(argmodel_to_build, argcolor_pin_mark):
    global color_pin_mark
    global model_to_build
    global excluded_pins_xmirror
    global excluded_pins_x

    color_pin_mark = argcolor_pin_mark
    model_to_build = argmodel_to_build

    if model_to_build == "all":
        variants = all_params.keys()
    else:
        variants = [model_to_build]
    for variant in variants:
        FreeCAD.Console.PrintMessage("\r\n" + variant)
        if not variant in all_params:
            print("Parameters for %s doesn't exist in 'all_params', skipping." % variant)
            continue
        ModelName = all_params[variant].modelName
        Newdoc = FreeCAD.newDocument(ModelName)
        App.setActiveDocument(ModelName)
        Gui.ActiveDocument = Gui.getDocument(ModelName)
        case, pins = make_dip(all_params[variant])
        color_attr = case_color + (0,)
        show(case, color_attr)
        # FreeCAD.Console.PrintMessage(pins_color)
        color_attr = pins_color + (0,)
        # FreeCAD.Console.PrintMessage(color_attr)
        show(pins, color_attr)
        doc = FreeCAD.ActiveDocument
        objs = GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
        doc.Label = ModelName
        objs = GetListOfObjects(FreeCAD, doc)
        objs[0].Label = ModelName
        restore_Main_Tools()
        # rotate if required
        if all_params[variant].rotation != 0:
            rot = all_params[variant].rotation
            z_RotateObject(doc, rot)
        out_dir = destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
        # out_dir="./generated_qfp/"
        # export STEP model
        exportSTEP(doc, ModelName, out_dir)
        # scale and export Vrml model
        scale = 0.3937001
        exportVRML(doc, ModelName, scale, out_dir)
        # Save the doc in Native FC format
        saveFCdoc(App, Gui, doc, ModelName, out_dir)
        # display BBox

        FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
def export_one_part(modul, variant):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage("Parameters for %s doesn't exist in 'M.all_params', skipping." % variant)
        return
    ModelName = modul.all_params[variant].model_name
    FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)
    (pins, body) = modul.generate_part(variant)

    color_attr = body_color + (0,)
    show(body, color_attr)

    color_attr = pins_color + (0,)
    show(pins, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label=ModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = ModelName + "__body"
    objs[1].Label = ModelName + "__pins"

    restore_Main_Tools()

    out_dir=destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name=destination_dir+os.sep+FileName+'.wrl'

    export_objects = []
    export_objects.append(expVRML.exportObject(freecad_object = objs[0],
            shape_color=body_color_key,
            face_colors=None))
    export_objects.append(expVRML.exportObject(freecad_object = objs[1],
            shape_color=pins_color_key,
            face_colors=None))

    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = FuseObjs_wColors(FreeCAD, FreeCADGui,
                    ModelName, objs[0].Name, objs[1].Name, keepOriginals=True)
    exportSTEP(doc,FileName,out_dir,fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    saveFCdoc(App, Gui, doc, FileName,out_dir)
def build_and_save(i):

    ModelName='pinstrip_p254_'+str(i)+'x1'
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)

    FreeCAD.Console.PrintMessage('making all pin headers\r\n')
    case, pins = make_pinheader(i)

    color_attr=case_color+(0,)
    show(case, color_attr)
    #FreeCAD.Console.PrintMessage(pins_color)
    color_attr=pins_color+(0,)
    #FreeCAD.Console.PrintMessage(color_attr)
    show(pins, color_attr)
    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui,
                    doc.Name, objs[0].Name, objs[1].Name)
    doc.Label=ModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=ModelName
    restore_Main_Tools()
    #rotate if required
    if (rotation!=0):
        z_RotateObject(doc, rotation)
    out_dir=destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc,ModelName,out_dir)
    # scale and export Vrml model
    scale=0.3937001
    exportVRML(doc,ModelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, ModelName,out_dir)
    #display BBox

    FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
    #import ImportGui
    #ImportGui.insert(u"C:/Cad/Progetti_K/FreeCAD-models/scripts/3D-models/CadQuery/reference-block.step","mypin")

    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()

    return 0
def build_and_save(i):

    ModelName = 'pinstrip_p254_' + str(i) + 'x1'
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)

    FreeCAD.Console.PrintMessage('making all pin headers\r\n')
    case, pins = make_pinheader(i)

    color_attr = case_color + (0, )
    show(case, color_attr)
    #FreeCAD.Console.PrintMessage(pins_color)
    color_attr = pins_color + (0, )
    #FreeCAD.Console.PrintMessage(color_attr)
    show(pins, color_attr)
    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = ModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = ModelName
    restore_Main_Tools()
    #rotate if required
    if (rotation != 0):
        z_RotateObject(doc, rotation)
    out_dir = destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    # scale and export Vrml model
    scale = 0.3937001
    exportVRML(doc, ModelName, scale, out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, ModelName, out_dir)
    #display BBox

    FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
    #import ImportGui
    #ImportGui.insert(u"C:/Cad/Progetti_K/FreeCAD-models/scripts/3D-models/CadQuery/reference-block.step","mypin")

    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()

    return 0
def export_model(model):
    file_name = model['metadata']['name']
    parts = model['parts']
    parts_list = parts.keys()

    # create document
    safe_name = file_name.replace('-', '_')
    FreeCAD.Console.PrintMessage('Model: {:s}\r\n'.format(file_name))
    FreeCAD.newDocument(safe_name)
    App.setActiveDocument(safe_name)
    App.ActiveDocument = App.getDocument(safe_name)
    Gui.ActiveDocument = Gui.getDocument(safe_name)

    # colour model
    used_colour_keys = []
    for part in parts_list:
        colour_key = parts[part]['colour']
        used_colour_keys.append(colour_key)
        colour = shaderColors.named_colors[colour_key].getDiffuseInt()
        colour_attr = colour + (0, )
        show(parts[part]['name'], colour_attr)

    # label model and parts
    doc = FreeCAD.ActiveDocument
    doc.Label = safe_name
    objects = doc.Objects
    i = 0
    for part in parts_list:
        objects[i].Label = '{n:s}__{p:s}'.format(n=safe_name, p=part)
        i += 1
    restore_Main_Tools()
    doc.recompute()
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewTop()

    # create output folder
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    # export VRML
    export_file_name = '{d:s}{s:s}{n:s}.wrl'.format(d=out_dir,
                                                    s=os.sep,
                                                    n=file_name)
    export_objects = []
    i = 0
    for part in parts_list:
        export_objects.append(
            expVRML.exportObject(freecad_object=objects[i],
                                 shape_color=parts[part]['colour'],
                                 face_colors=None))
        i += 1
    scale = 1 / 2.54
    coloured_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)

    L.LIST_int_license[0] = "Copyright (C) " + datetime.now().strftime(
        "%Y") + ", " + L.STR_int_licAuthor
    expVRML.writeVRMLFile(coloured_meshes, export_file_name, used_colour_keys,
                          L.LIST_int_license)

    # export STEP
    fusion = multiFuseObjs_wColors(FreeCAD,
                                   FreeCADGui,
                                   safe_name,
                                   objects,
                                   keepOriginals=True)
    exportSTEP(doc, file_name, out_dir, fusion)
    L.addLicenseToStep('{d:s}/'.format(d=out_dir),
                       '{n:s}.step'.format(n=file_name), L.LIST_int_license,
                       L.STR_int_licAuthor, L.STR_int_licEmail,
                       L.STR_int_licOrgSys, L.STR_int_licPreProc)

    # save FreeCAD models
    saveFCdoc(App, Gui, doc, file_name, out_dir)
    return
Exemplo n.º 10
0
    def export_one_part(params, mpn, log):
        print('\n##########################################################')

        if LICENCE_Info.LIST_license[0] == "":
            LIST_license = L.LIST_int_license
            # LIST_license.append("")
        else:
            LIST_license = LICENCE_Info.LIST_license

        LIST_license[0] = "Copyright (C) " + datetime.now().strftime(
            "%Y") + ", " + LICENCE_Info.STR_licAuthor

        fp_params = params['footprint']
        mech_params = params['mechanical']
        part_params = params['parts'][mpn]

        if 'id' in mech_params:
            size = str(mech_params['id'])
        elif 'ext_thread' in mech_params:
            size = str(mech_params['ext_thread']['od'])

        if 'M' not in size:
            size = "{}mm".format(size)

        td = ""
        size_prefix = ""
        if 'thread_depth' in part_params:
            td = "_ThreadDepth{}mm".format(part_params['thread_depth'])
        elif 'ext_thread' in mech_params:
            size_prefix = 'External'

        h = part_params['h'] if 'h' in part_params else part_params['h1']

        suffix = ''
        if 'suffix' in params:
            suffix = '_{}'.format(params['suffix'])

        FileName = "Mounting_Wuerth_{series}-{size_prefix}{size}_H{h}mm{td}{suffix}_{mpn}".format(
            size=size,
            h=h,
            mpn=mpn,
            td=td,
            size_prefix=size_prefix,
            series=params['series_prefix'],
            suffix=suffix)

        lib_name = "Mounting_Wuerth"

        ModelName = FileName.replace('.', '').replace('-', '_').replace(
            '(', '').replace(')', '')

        FreeCAD.Console.PrintMessage('\r\n' + FileName + '\r\n')
        #FileName = modul.all_params[variant].file_name
        Newdoc = FreeCAD.newDocument(ModelName)
        print(Newdoc.Label)
        App.setActiveDocument(ModelName)
        App.ActiveDocument = App.getDocument(ModelName)
        Gui.ActiveDocument = Gui.getDocument(ModelName)

        color_keys = ["metal grey pins"]
        colors = [
            shaderColors.named_colors[key].getDiffuseInt()
            for key in color_keys
        ]

        cq_obj_data = generate(id=mech_params.get('id'),
                               od=mech_params['od'],
                               od1=mech_params.get('od1'),
                               h1=mech_params.get('h1',
                                                  part_params.get('h1', 0)),
                               h=part_params.get('h', mech_params.get('h')),
                               td=part_params.get('thread_depth'),
                               dd=part_params.get('drill_depth'),
                               id1=mech_params.get('id1'),
                               t1=mech_params.get('t1', 0),
                               ext_thread=mech_params.get('ext_thread'))

        color_i = colors[0] + (0, )
        show(cq_obj_data, color_i)

        doc = FreeCAD.ActiveDocument
        doc.Label = ModelName
        objs = GetListOfObjects(FreeCAD, doc)

        objs[0].Label = ModelName

        restore_Main_Tools()

        out_dir = '{:s}{:s}.3dshapes'.format(global_3dpath, lib_name)
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        used_color_keys = color_keys
        export_file_name = out_dir + os.sep + FileName + '.wrl'

        export_objects = []
        print('objs')
        print(objs)
        for i in range(len(objs)):
            export_objects.append(
                expVRML.exportObject(freecad_object=objs[i],
                                     shape_color=color_keys[i],
                                     face_colors=None))

        scale = 1 / 2.54
        colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
        expVRML.writeVRMLFile(colored_meshes, export_file_name,
                              used_color_keys, LIST_license)

        exportSTEP(doc, FileName, out_dir, objs[0])

        step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

        L.addLicenseToStep(out_dir, '{:s}.step'.\
            format(FileName), LIST_license,
                LICENCE_Info.STR_licAuthor,
                LICENCE_Info.STR_licEmail,
                LICENCE_Info.STR_licOrgSys,
                LICENCE_Info.STR_licPreProc)

        FreeCAD.activeDocument().recompute()

        saveFCdoc(App, Gui, doc, FileName, out_dir)

        #FreeCADGui.activateWorkbench("PartWorkbench")
        if save_memory == False and check_Model == False:
            FreeCADGui.SendMsgToActiveView("ViewFit")
            FreeCADGui.activeDocument().activeView().viewAxometric()

        if save_memory == True or check_Model == True:
            doc = FreeCAD.ActiveDocument
            FreeCAD.closeDocument(doc.Name)

        if check_Model == True:
            runGeometryCheck(App,
                             Gui,
                             step_path,
                             log,
                             ModelName,
                             save_memory=save_memory)
Exemplo n.º 11
0
def MakeConnector(name, params):

    model_name = name
    full_model_name = name + "-6-0-{}{:02d}_1x{}_P2.50mm_Vertical".format(
        params["pins"], params["pins"], params["pins"])
    expVRML.say(model_name)
    expVRML.say(params)

    out_dir = "../../FCAD_script_generator/_3Dmodels/Connector_Stocko.3dshapes"

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    body_color_key = "grey body"
    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    pin_union_color_key = "metal silver"
    pin_union_color = shaderColors.named_colors[
        pin_union_color_key].getDiffuseFloat()

    newdoc = App.newDocument(model_name)
    App.setActiveDocument(model_name)
    App.ActiveDocument = App.getDocument(model_name)
    Gui.ActiveDocument = Gui.getDocument(model_name)

    body = cq.Workplane("XY").move(-params["outline_x"], 0).box((params["pitch"] * (params["pins"] - 1)) + 2 * params["outline_x"], \
    params["base_w"], params["base_h"], centered = (False,True,False))
    body = body.faces(">Z") \
    .workplane().rect(params["pitch"] * (params["pins"] - 1) + 2 * params["outline_x"] - params["lr_sides_t"], \
    params["base_w"] - params["tb_sides_t"]) \
    .cutBlind(-params["depth"]) \
    .faces(">Z") \
    .edges("not(<X or >X or <Y or >Y)") \
    .chamfer(0.7)
    body = body.edges("|Z and >X").fillet(0.5)
    body = body.edges("|Z and <X").fillet(0.5)
    body = body.faces(">Z").workplane().center(0, -params["base_w"] / 2 + params["base_cutout"] /2).rect( \
    params["pitch"] * (params["pins"] - 1) + 2 * (params["outline_x"] - params["leaf"]), \
    params["base_cutout"]) \
    .cutThruAll()
    if params["top_cutout"]:
        body = body.faces(">Y").workplane().center(0, 6.5).rect(
            params["t_cutout_w"], params["t_cutout_h"]).cutThruAll()
    for x in range(params["pins"]):
        temp = (params["b_cutout_long_w"] - params["b_cutout_short_w"]) / 2
        body = body.faces(">Y").workplane(centerOption='CenterOfBoundBox').center( \
            ((params["pitch"] * (params["pins"] - 1) + 2 * params["outline_x"]) / 2) - params["outline_x"] - (params["b_cutout_long_w"] / 2) - x*params["pitch"], \
            -7).lineTo(params["b_cutout_long_w"], 0).lineTo(params["b_cutout_long_w"] - temp, params["b_cutout_h"]).lineTo(temp, params["b_cutout_h"]).close().cutThruAll()

    total_pin_length = params["pin"]["length_above_board"] + params["pin"][
        "length_below_board"]
    pin = cq.Workplane("XY").workplane(offset=-params["pin"]["length_below_board"]).box(params["pin"]["width"], \
             params["pin"]["width"], total_pin_length, centered = (True,True,False))

    pin = pin.edges("#Z").chamfer(params["pin"]["end_chamfer"])
    pins_union = cq.Workplane("XY").workplane(
        offset=-params["pin"]["length_below_board"])

    for x in range(params["pins"]):
        pins_union = pins_union.union(
            pin.translate((x * params["pitch"], 0, 0)))

    show(body)
    show(pins_union)

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pin_union_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]

    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pin_union_color_key,
    }
    expVRML.say(material_substitutions)

    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)

    doc.Label = model_name
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = model_name
    restore_Main_Tools()

    doc.Label = model_name

    #save the STEP file
    exportSTEP(doc, full_model_name, out_dir)
    global LIST_license
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', full_model_name+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + '/' + full_model_name + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)
Exemplo n.º 12
0
    def makeModel(self,
                  models_dir,
                  genericName,
                  model,
                  keepDocument=True,
                  verbose=False):
        r"""Creates a model by calling an instance of a model generator class and writes out the model files

        .. note:: normally this method will be called by :func:`makeModels` but may be used directly

        :param models_dir:
            directory to write the created step and wrl files
        :type models_dir: ``str``

        :param genericName:
            the generic name from the base parameter list, may be used to create the model name
        :type  genericName: ``str``

        :param model:
            an instance of the model class to use
        :type   model: ``class instance`` inherited from :class:`cq_base_model.PartBase`

        :param keepDocument:
            * True: the FreeCAD document will shown after it is created, optionally with kicadStepUptools activated
            * False: the document window will be closed
        :type  keepDocument: ``boolean``

        """

        global kicadStepUptools

        modelName = model.makeModelName(genericName)

        FreeCAD.Console.PrintMessage('\r\n' + modelName)

        if model.make_me != True:
            FreeCAD.Console.PrintMessage(' - not made')
            return
        CheckedmodelName = modelName.replace('.',
                                             '').replace('-', '_').replace(
                                                 '(', '').replace(')', '')
        FreeCAD.newDocument(CheckedmodelName)
        FreeCAD.setActiveDocument(CheckedmodelName)
        Gui.ActiveDocument = Gui.getDocument(CheckedmodelName)

        model.make()

        doc = FreeCAD.ActiveDocument
        objs = GetListOfObjects(FreeCAD, doc)

        material_substitutions = {}

        for i in range(0, len(objs)):
            Color_Objects(
                Gui, objs[i], shaderColors.named_colors[
                    model.color_keys[i]].getDiffuseFloat())
            material_substitutions[Gui.ActiveDocument.getObject(
                objs[i].Name).DiffuseColor[0][:-1]] = model.color_keys[i]

        if verbose:
            expVRML.say(material_substitutions)
            expVRML.say(model.color_keys)
            expVRML.say(model.offsets)

        doc.Label = CheckedmodelName

        while len(objs) > 1:
            FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                             objs[1].Name)
            del objs
            objs = GetListOfObjects(FreeCAD, doc)

        objs[0].Label = CheckedmodelName
        restore_Main_Tools()

        #rotate if required
        if (model.rotation != 0):
            z_RotateObject(doc, model.rotation)

        s = objs[0].Shape
        shape = s.copy()
        shape.Placement = s.Placement
        shape.translate(model.offsets)
        objs[0].Placement = shape.Placement

        out_dir = models_dir + os.sep + model.destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        # Export STEP model
        exportSTEP(doc, modelName, out_dir)

        license_txt = list(
            add_license.LIST_int_license if self.license is None else
            self.license)  # make a copy to avoid modifying the original
        license_txt.append("")
        license_txt.append("")
        if self.scriptsource != "" and self.script_dir is not None:
            license_txt.append("Generated by script, source at:")
            license_txt.append(self.scriptsource +
                               self.script_dir.split(os.sep)[-1])
            license_txt.append("")

        if verbose:
            expVRML.say("")

        add_license.addLicenseToStep(out_dir + os.sep, modelName + ".step",
                                     license_txt, model.licAuthor,
                                     model.licEmail, model.licOrgSys,
                                     model.licOrg, model.licPreProc)

        # Scale and export Vrml model
        scale = 1.0 / 2.54
        objs = GetListOfObjects(FreeCAD, doc)
        if verbose:
            expVRML.say(
                "######################################################################"
            )
            expVRML.say(objs)
            expVRML.say(
                "######################################################################"
            )
        export_objects, used_color_keys = expVRML.determineColors(
            Gui, objs, material_substitutions)
        export_file_name = out_dir + os.sep + modelName + '.wrl'
        colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
        expVRML.writeVRMLFile(colored_meshes, export_file_name,
                              used_color_keys, license_txt)

        # Save the doc in native FC format
        out_dir = self.models_src_dir + os.sep + model.destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        saveFCdoc(FreeCAD, Gui, doc, modelName, out_dir)

        # Place on footprint for verification
        if keepDocument and model.footprints_dir is not None and self.footprints_dir is not None:

            sys.argv = [
                "fc", "dummy", self.footprints_dir + os.sep +
                model.footprints_dir + os.sep + modelName, "savememory"
            ]

            if verbose:
                expVRML.say('Footprint: ' + sys.argv[2])

            if self.kicadStepUptools is None:
                try:
                    import kicadStepUptools
                    expVRML.say("ksu present!")
                    self.kicadStepUptools = True
                    kicadStepUptools.KSUWidget.close()
                    #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                    #kicadStepUptools.KSUWidget.destroy()
                    #for i in QtGui.qApp.topLevelWidgets():
                    #    if i.objectName() == "kicadStepUp":
                    #        i.deleteLater()
                    #kicadStepUptools.KSUWidget.close()
                except:
                    self.kicadStepUptools = False
                    expVRML.say("ksu not present")

            if not self.kicadStepUptools == False:
                kicadStepUptools.KSUWidget.close()
                reload_lib(kicadStepUptools)
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()

        #display BBox
        if keepDocument:
            Gui.activateWorkbench("PartWorkbench")
            Gui.SendMsgToActiveView("ViewFit")
            Gui.activeDocument().activeView().viewAxometric()
        else:
            doc = FreeCAD.ActiveDocument
            FreeCAD.closeDocument(doc.Name)
Exemplo n.º 13
0
        restore_Main_Tools()
        #rotate if required
        if (all_params[variant].rotation!=0):
            rot= all_params[variant].rotation
            z_RotateObject(doc, rot)
        #out_dir=destination_dir+all_params[variant].dest_dir_prefix+'/'
        script_dir=os.path.dirname(os.path.realpath(__file__))
        ## models_dir=script_dir+"/../_3Dmodels"
        expVRML.say(models_dir)
        out_dir=models_dir+destination_dir
        #out_dir=script_dir+os.sep+destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
        #out_dir="./generated_qfp/"
        # export STEP model
        exportSTEP(doc, ModelName, out_dir)
        if LIST_license[0]=="":
            LIST_license=Lic.LIST_int_license
            LIST_license.append("")
        Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                           STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
        # scale and export Vrml model
        scale=1/2.54
        #exportVRML(doc,ModelName,scale,out_dir)
        objs=GetListOfObjects(FreeCAD, doc)
        expVRML.say("######################################################################")
        expVRML.say(objs)
        expVRML.say("######################################################################")
        export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)

        #export_file_name=destination_dir+os.sep+ModelName+'.wrl'
def make_3D_model(models_dir, variant):
                
    LIST_license = ["",]
    modelName = all_params[variant].modelName
        
    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedmodelName)

    case = make_case(all_params[variant], type, modelName)
    
    if (all_params[variant].type == CASE_THT_TYPE):
        pins = make_pins_tht(all_params[variant], type, modelName)

    if (all_params[variant].type == CASE_SMD_TYPE):
        pins = make_pins_smd(all_params[variant], type, modelName)


        # color_attr=case_color+(0,)
    # show(case, color_attr)
    # #FreeCAD.Console.PrintMessage(pins_color)
    # color_attr=pins_color+(0,)
    # #FreeCAD.Console.PrintMessage(color_attr)
    # show(pins, color_attr)
    #doc = FreeCAD.ActiveDocument
    #objs=GetListOfObjects(FreeCAD, doc)

    show(case)
    show(pins)
    #show(pinmark)
    #stop
    
    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pins_color_key
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    FuseObjs_wColors(FreeCAD, FreeCADGui,
                    doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = CheckedmodelName
    del objs
    #objs=GetListOfObjects(FreeCAD, doc)
    #FuseObjs_wColors(FreeCAD, FreeCADGui,
    #                doc.Name, objs[0].Name, objs[1].Name)
    #doc.Label=modelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    # objs=GetListOfObjects(FreeCAD, doc)
    # objs[0].Label=modelName
    # restore_Main_Tools()
    #rotate if required
    if (all_params[variant].rotation!=0):
        rot= all_params[variant].rotation
        z_RotateObject(doc, rot)
    npins=all_params[variant].npins
    e=all_params[variant].e
    E=all_params[variant].E
    c= 0.254 # lead thickness
    mvY = (npins*e/4-e/2)
    mvX = (E-c)/2
    s = objs[0].Shape
    shape=s.copy()
    shape.Placement=s.Placement;
    shape.translate((+mvX,-mvY,0))
    objs[0].Placement=shape.Placement
    #case = case.translate ((-mvX,-mvY,0))
    #pins = pins.translate ((-mvX,-mvY,0))
    # out_dir=destination_dir
    # if not os.path.exists(out_dir):
    #     os.makedirs(out_dir)
    # #out_dir="./generated_qfp/"
    # # export STEP model
    # exportSTEP(doc,modelName,out_dir)
    script_dir=os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, modelName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', modelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,modelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+modelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    #scale=0.3937001
    #exportVRML(doc,modelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelName,out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
def export_one_part(modul, variant, with_plug=False):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage(
            "Parameters for %s not found - skipping." % variant)
        return
    ModelName = variant
    ModelName = ModelName.replace(".", "_")
    FileName = modul.all_params[variant].file_name

    FreeCAD.Console.PrintMessage("Model name: %s\r\n" % ModelName)
    FreeCAD.Console.PrintMessage("File name: %s\r\n" % FileName)

    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    App.ActiveDocument = App.getDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)
    (pins, body) = modul.generate_part(variant, with_plug)

    color_attr = body_color + (0, )
    show(body, color_attr)

    color_attr = pins_color + (0, )
    show(pins, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = FreeCAD.ActiveDocument.Objects
    FreeCAD.Console.PrintMessage(objs)

    i = 0
    objs[i].Label = ModelName + "__body"
    i += 1
    objs[i].Label = ModelName + "__pins"
    i += 1

    restore_Main_Tools()

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name = out_dir + os.sep + FileName + '.wrl'

    export_objects = []
    i = 0
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[i],
                             shape_color=body_color_key,
                             face_colors=None))
    i += 1
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[i],
                             shape_color=pins_color_key,
                             face_colors=None))
    i += 1

    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)

    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          L.LIST_int_license)

    fusion = multiFuseObjs_wColors(FreeCAD,
                                   FreeCADGui,
                                   ModelName,
                                   objs,
                                   keepOriginals=True)

    exportSTEP(doc, FileName, out_dir, fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", L.LIST_int_license,\
        L.STR_int_licAuthor, L.STR_int_licEmail, L.STR_int_licOrgSys, L.STR_int_licPreProc)

    saveFCdoc(App, Gui, doc, FileName, out_dir)

    FreeCAD.activeDocument().recompute()
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewAxometric()
        export_objects = []
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[0],
                                 shape_color=body_color_key,
                                 face_colors=None))
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[1],
                                 shape_color=pins_color_key,
                                 face_colors=None))

        scale = 1 / 2.54
        colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
        expVRML.writeVRMLFile(colored_meshes, export_file_name,
                              used_color_keys, LIST_license)

        fusion = FuseObjs_wColors(FreeCAD,
                                  FreeCADGui,
                                  ModelName,
                                  objs[0].Name,
                                  objs[1].Name,
                                  keepOriginals=True)
        exportSTEP(doc, FileName, out_dir, fusion)
        L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
            STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

        saveFCdoc(App, Gui, doc, FileName, out_dir)
        Gui.activateWorkbench("PartWorkbench")
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()
Exemplo n.º 17
0
def export_one_part(modul, variant, with_plug=False):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage("Parameters for %s doesn't exist in 'M.all_params', skipping." % variant)
        return

    destination_dir="Connectors_Phoenix.3dshapes"
    if with_plug:
        destination_dir="Connectors_Phoenix__with_plug.3dshapes"
    ModelName = variant
    ModelName = ModelName.replace(".","_")
    FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    App.ActiveDocument=App.getDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)
    #App.setActiveDocument(ModelName)
    #Gui.ActiveDocument=Gui.getDocument(ModelName)
    (pins, body, insert, mount_screw, plug, plug_screws) = modul.generate_part(variant, with_plug)

    color_attr = body_color + (0,)
    show(body, color_attr)

    color_attr = pins_color + (0,)
    show(pins, color_attr)

    if insert is not None:
        color_attr = insert_color + (0,)
        show(insert, color_attr)
    if mount_screw is not None:
        color_attr = screw_color + (0,)
        show(mount_screw, color_attr)
    if plug is not None:
        color_attr = body_color + (0,)
        show(plug, color_attr)

        color_attr = screw_color + (0,)
        show(plug_screws, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label=ModelName
    objs=FreeCAD.ActiveDocument.Objects
    FreeCAD.Console.PrintMessage(objs)

    i=0
    objs[i].Label = ModelName + "__body"
    i+=1
    objs[i].Label = ModelName + "__pins"
    i+=1
    if insert is not None:
        objs[i].Label = ModelName + "__thread_insert"
        i+=1
    if mount_screw is not None:
        objs[i].Label = ModelName + "__mount_screw"
        i+=1
    if plug is not None:
        objs[i].Label = ModelName + "__plug"
        i+=1
        objs[i].Label = ModelName + "__plug_screws"
    restore_Main_Tools()

    out_dir=destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name=destination_dir+os.sep+FileName+'.wrl'

    export_objects = []
    i=0
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=body_color_key,
            face_colors=None))
    i+=1
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=pins_color_key,
            face_colors=None))
    i+=1
    if insert is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=insert_color_key,
                face_colors=None))
        used_color_keys.append(insert_color_key)
        i+=1
    if mount_screw is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=screw_color_key,
                face_colors=None))
        used_color_keys.append(screw_color_key)
        i+=1
    if plug is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=body_color_key,
                face_colors=None))
        i+=1
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=screw_color_key,
                face_colors=None))
    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     ModelName, objs, keepOriginals=True)

    exportSTEP(doc,FileName,out_dir,fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    saveFCdoc(App, Gui, doc, FileName,out_dir)

    FreeCAD.activeDocument().recompute()
    # FreeCADGui.activateWorkbench("PartWorkbench")
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewAxometric()
def generateOneModel(params, log):
    ModelName = params.modelName
    FreeCAD.Console.PrintMessage('\n\n##############  ' +
                                 part_params['code_metric'] +
                                 '  ###############\n')
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedModelName)
    #body, base, mark, pins = make_tantalum_th(params)
    body, pins, pinmark = make_tantalum_th(
        params)  #body, base, mark, pins, top

    show(body)
    show(pins)
    show(pinmark)

    doc = FreeCAD.ActiveDocument
    print(GetListOfObjects(FreeCAD, doc))
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pins_color)
    Color_Objects(Gui, objs[2], marking_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]

    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key,
        col_mark[:-1]: marking_color_key
    }
    expVRML.say(material_substitutions)
    del objs

    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    #stop
    doc.Label = CheckedModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName
    restore_Main_Tools()
    #rotate if required
    objs = GetListOfObjects(FreeCAD, doc)
    FreeCAD.getDocument(doc.Name).getObject(
        objs[0].Name).Placement = FreeCAD.Placement(
            FreeCAD.Vector(params.F / 2, 0, 0),
            FreeCAD.Rotation(FreeCAD.Vector(0, 0, 1), params.rotation))
    #out_dir=destination_dir+params.dest_dir_prefix+'/'
    script_dir = os.path.dirname(os.path.realpath(__file__))

    expVRML.say(script_dir)
    #out_dir=script_dir+os.sep+destination_dir+os.sep+params.dest_dir_prefix

    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model

    exportSTEP(doc, ModelName, out_dir)

    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + ModelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, ModelName, out_dir)
    if save_memory == True:
        doc = FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)
def generateOneModel(part_params, log):
    place_pinMark=True ##default =True used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)

    FreeCAD.Console.PrintMessage(
        '\n\n##############  ' +
        part_params['code_metric'] +
        '  ###############\n')
    dim_params = part_params['param_nominal'] if use_nominal_size else part_params['param_max']
    if dim_params == None:
        if show_all:
            if use_nominal_size:
                dim_params = part_params['param_max']
            else:
                dim_params = part_params['param_nominal']
    if dim_params == None:
        FreeCAD.Console.PrintMessage('No params found for current variant. Skipped\n')
        return

    ModelName = model_name_format_str.format(
      prefix=model_name_prefix,
      code_metric=part_params['code_metric'],
      code_letter=part_params['code_letter'],
      old_name=part_params['modelName_old'],
      maui_name=part_params['modelName_maui']
    )
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)
    body, pins, mark = make_tantalum(dim_params)

    show(body)
    show(pins)
    show(mark)
    
    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pins_color)
    Color_Objects(Gui,objs[2],mark_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pins_color_key,
        col_mark[:-1]:mark_color_key
    }
    #expVRML.say(material_substitutions)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    if (color_pin_mark==True) and (place_pinMark==True):
        CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[2].Name)
    else:
        #removing pinMark
        App.getDocument(doc.Name).removeObject(objs[2].Name)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName
    restore_Main_Tools()
    #rotate if required
    if (rotation!=0):
        rot = rotation
        z_RotateObject(doc, rot)
    #out_dir=destination_dir+all_params[variant].dest_dir_prefix+'/'
    script_dir=os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    saveFCdoc(App, Gui, doc, ModelName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        step_path = out_dir + '/' + ModelName + ".step"
        runGeometryCheck(App, Gui, step_path,
            log, ModelName, save_memory=save_memory)
def generateOneModel(params, log):
    ModelName = params.modelName
    FreeCAD.Console.PrintMessage(
        '\n\n##############  ' +
        part_params['code_metric'] +
        '  ###############\n')
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)
    #body, base, mark, pins = make_tantalum_th(params)
    body, pins, pinmark= make_tantalum_th(params) #body, base, mark, pins, top

    show(body)
    show(pins)
    show(pinmark)

    doc = FreeCAD.ActiveDocument
    print(GetListOfObjects(FreeCAD, doc))
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pins_color)
    Color_Objects(Gui,objs[2],marking_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]

    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pins_color_key,
        col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)
    del objs

    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    #stop
    doc.Label = CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName
    restore_Main_Tools()
    #rotate if required
    objs=GetListOfObjects(FreeCAD, doc)
    FreeCAD.getDocument(doc.Name).getObject(objs[0].Name).Placement = FreeCAD.Placement(FreeCAD.Vector(params.F/2,0,0),
    FreeCAD.Rotation(FreeCAD.Vector(0,0,1),params.rotation))
    #out_dir=destination_dir+params.dest_dir_prefix+'/'
    script_dir=os.path.dirname(os.path.realpath(__file__))

    expVRML.say(script_dir)
    #out_dir=script_dir+os.sep+destination_dir+os.sep+params.dest_dir_prefix

    out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model

    exportSTEP(doc, ModelName, out_dir)

    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, ModelName,out_dir)
    if save_memory == True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)
Exemplo n.º 21
0
def export_one_part(module, pincount, configuration, log):
    series_definition = module.series_params

    if module.LICENCE_Info.LIST_license[0] == "":
        LIST_license = L.LIST_int_license
        LIST_license.append("")
    else:
        LIST_license = module.LICENCE_Info.LIST_license

    LIST_license[0] = "Copyright (C) " + datetime.now().strftime(
        "%Y") + ", " + module.LICENCE_Info.STR_licAuthor
    pins_per_row = pincount / series_definition.number_of_rows
    mpn = series_definition.mpn_format_string.format(pincount=pincount,
                                                     pins_per_row=pins_per_row)

    orientation = configuration['orientation_options'][
        series_definition.orientation]
    format_string = getattr(
        series_definition, 'fp_name_format_string',
        configuration[getattr(series_definition, 'fp_name_format',
                              'fp_name_format_string')])
    FileName = format_string.format(man=series_definition.manufacturer,
                                    series=series_definition.series,
                                    mpn=mpn,
                                    num_rows=series_definition.number_of_rows,
                                    pins_per_row=pins_per_row,
                                    pins=pincount,
                                    pitch=series_definition.pitch,
                                    orientation=orientation,
                                    mount_pin=series_definition.mount_pin)
    FileName = FileName.replace('__', '_')

    lib_name = configuration['lib_name_format_string'].format(
        man=series_definition.manufacturer)
    fc_mpn = mpn.replace('.', '').replace('-',
                                          '_').replace('(',
                                                       '').replace(')', '')

    ModelName = '{:s}_{:s}'.format(
        series_definition.manufacturer,
        fc_mpn)  # For some reason the Model name can not start with a number.

    FreeCAD.Console.PrintMessage('\r\n' + FileName + '\r\n')
    #FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    print(Newdoc.Label)
    App.setActiveDocument(ModelName)
    App.ActiveDocument = App.getDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)

    color_keys = series_definition.color_keys
    obj_suffixes = series_definition.obj_suffixes
    colors = [
        shaderColors.named_colors[key].getDiffuseInt() for key in color_keys
    ]

    cq_obj_data = module.generate_part(pincount)

    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0, )
        show(cq_obj_data[i], color_i)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = GetListOfObjects(FreeCAD, doc)

    for i in range(len(objs)):
        objs[i].Label = ModelName + obj_suffixes[i]

    restore_Main_Tools()

    out_dir = '{:s}{:s}.3dshapes'.format(global_3dpath, lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = color_keys
    export_file_name = out_dir + os.sep + FileName + '.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=color_keys[i],
                                 face_colors=None))

    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD,
                                   FreeCADGui,
                                   ModelName,
                                   objs,
                                   keepOriginals=True)
    exportSTEP(doc, FileName, out_dir, fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.\
        format(FileName), LIST_license,
            module.LICENCE_Info.STR_licAuthor,
            module.LICENCE_Info.STR_licEmail,
            module.LICENCE_Info.STR_licOrgSys,
            module.LICENCE_Info.STR_licPreProc)

    FreeCAD.activeDocument().recompute()

    saveFCdoc(App, Gui, doc, FileName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model == False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model == True:
        doc = FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model == True:
        runGeometryCheck(App,
                         Gui,
                         step_path,
                         log,
                         ModelName,
                         save_memory=save_memory)
def export_one_part(params, series_definition, log):
    ModelName = params.modelName
    footprint_dir = series_definition.footprint_dir
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')

    print('\n######################### {:s} ###########################\n'.format(ModelName))

    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    App.ActiveDocument=App.getDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)

    color_keys = [
        series_definition.body_color_key,
        series_definition.pins_color_key,
        series_definition.mark_color_key
    ]
    colors = [shaderColors.named_colors[key].getDiffuseInt() for key in color_keys]

    body, pins, mark = make_gw(params)

    show(body, colors[0]+(0,))
    show(pins, colors[1]+(0,))
    show(mark, colors[2]+(0,))

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:series_definition.body_color_key,
        col_pin[:-1]:series_definition.pins_color_key,
        col_mark[:-1]:series_definition.mark_color_key
    }

    if (color_pin_mark==True) and (place_pinMark==True):
        CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[2].Name)
    else:
        #removing pinMark
        App.getDocument(doc.Name).removeObject(objs[2].Name)

    objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label=CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=CheckedModelName

    restore_Main_Tools()
    #rotate if required
    if (params.rotation!=0):
        rot= params.rotation
        z_RotateObject(doc, rot)

    if no_export:
        return

    out_dir='{:s}{:s}.3dshapes'.format(global_3dpath, series_definition.lib_name)

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                         STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    # Save the doc in Native FC format
    footprint_dir = series_definition.footprint_dir
    if footprint_dir is not None and os.path.isdir(footprint_dir) \
            and not save_memory and not check_Model:
        #expVRML.say (ModelName)
        #stop
        sys.argv = ["fc", "dummy", footprint_dir+os.sep+ModelName, "savememory"]
        #setup = get_setup_file()  # << You need the parentheses
        expVRML.say(sys.argv[2])
        ksu_already_loaded=False
        ksu_present=False
        for i in QtGui.qApp.topLevelWidgets():
            if i.objectName() == "kicadStepUp":
                ksu_already_loaded=True
        ksu_tab = FreeCADGui.getMainWindow().findChild(QtGui.QDockWidget, "kicadStepUp") #"kicad StepUp 3D tools")
        if ksu_tab:
            ksu_already_loaded=True
        if ksu_already_loaded!=True:
            try:
                import kicadStepUptools
                ksu_present=True
                ksu_already_loaded=True
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()
                #for i in QtGui.qApp.topLevelWidgets():
                #    if i.objectName() == "kicadStepUp":
                #        i.deleteLater()
                kicadStepUptools.KSUWidget.close()
            except:
                ksu_present=False
                expVRML.say("ksu not present")
        else:
            kicadStepUptools.KSUWidget.close()
            reload(kicadStepUptools)
            kicadStepUptools.KSUWidget.close()
            #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
            #kicadStepUptools.KSUWidget.destroy()

    saveFCdoc(App, Gui, doc, ModelName,out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, out_dir+'/'+ ModelName+".step",
            log, ModelName, save_memory=save_memory)
        del objs
        objs = GetListOfObjects(FreeCAD, doc)
    doc.Label = CheckedmodelName

    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir = models_dir + os.sep + all_params[variant].dest_dir_prefix
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    exportSTEP(doc, modelfileName, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir + os.sep, modelfileName + ".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc, modelfileName,scale,out_dir)
    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
        out_dir=destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        used_color_keys = [body_color_key, pins_color_key]
        export_file_name=destination_dir+os.sep+FileName+'.wrl'

        export_objects = []
        export_objects.append(expVRML.exportObject(freecad_object = objs[0],
                shape_color=body_color_key,
                face_colors=None))
        export_objects.append(expVRML.exportObject(freecad_object = objs[1],
                shape_color=pins_color_key,
                face_colors=None))

        scale=1/2.54
        colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
        expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

        fusion = FuseObjs_wColors(FreeCAD, FreeCADGui,
                        ModelName, objs[0].Name, objs[1].Name, keepOriginals=True)
        exportSTEP(doc,FileName,out_dir,fusion)
        L.addLicenseToStep(out_dir+'/', FileName+".step", LIST_license,\
            STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

        saveFCdoc(App, Gui, doc, FileName,out_dir)
        Gui.activateWorkbench("PartWorkbench")
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()
        objs[1].Label="Fusion2"
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
        doc.Label=ModelName
        objs=GetListOfObjects(FreeCAD, doc)
        objs[0].Label=ModelName
        restore_Main_Tools()
        #rotate if required
        if (all_params[variant].rotation!=0):
            rot= all_params[variant].rotation
            z_RotateObject(doc, rot)
        script_dir=os.path.dirname(os.path.realpath(__file__))
        out_dir=script_dir+destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
            #out_dir="./generated_qfp/"
        # export STEP model
        exportSTEP(doc,ModelName,out_dir)

        # scale and export Vrml model
        scale=0.3937001
        exportVRML(doc,ModelName,scale,out_dir)

        # Save the doc in Native FC format
        saveFCdoc(App, Gui, doc, ModelName,out_dir)
        #display BBox

        FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True

        ## run()
Exemplo n.º 26
0
def make_3D_model(models_dir, model_class, modelName):
    r"""Creates a 3D model and exports it to STEO and VRML.
    :param models_dir: directory name for STEP and VRML 3D model file export
    :type  models_dir: ``string``
    :param model_class: Class containing functions and parameter to generate the 3D model
    :type  model_class: ``class``
    :param modelName: The KiCad file name of the 3D model. 
    :type  modelName: ``string``

    """
    if not model_class.isValidModel ():
        FreeCAD.Console.PrintMessage("Model: " + modelName + ' has invalid parameter and was skipped.\r\n')
        return

    LIST_license = ["",]

    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedmodelName)
    destination_dir = model_class.get_dest_3D_dir()
    
    material_substitutions = model_class.make_3D_model()
    
    doc = FreeCAD.ActiveDocument
    doc.Label = CheckedmodelName

    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir=models_dir+os.sep+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    exportSTEP(doc, modelName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', modelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,modelName,scale,out_dir)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir + os.sep + modelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    #scale=0.3937001
    #exportVRML(doc,modelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelName,out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
Exemplo n.º 27
0
def MakePart(params, name, n=1):
    global formerDOC
    global LIST_license
    #name = PartName(params, n)

    full_path = os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name = full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir = sub_path + "_3Dmodels"
    script_dir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' character in the model name REALLY messes with things. also '-'
    docname = name.replace(".", "").replace("-", "_")

    newdoc = App.newDocument(docname)
    App.setActiveDocument(docname)
    App.ActiveDocument = App.getDocument(docname)
    Gui.ActiveDocument = Gui.getDocument(docname)

    FreeCAD.Console.PrintMessage(params)
    pins_output = MakeResistorPin(params, n)
    base_output = MakeResistor(params, n)

    show(base_output)
    show(pins_output)

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    # select the color based on shape
    if (params.shape == "power") or (params.shape == "radial") or (params.shape
                                                                   == "shunt"):
        # white colour for power resistors
        chosen_body_color = ceramic_color
        chosen_body_color_key = ceramic_color_key
    elif (params.shape == "bare"):
        # metal/pin colour for bare resistors
        chosen_body_color = pins_color
        chosen_body_color_key = pins_color_key
    else:
        # light brown colour for din/axial/arrays/etc.
        chosen_body_color = body_color
        chosen_body_color_key = body_color_key

    Color_Objects(Gui, objs[0], chosen_body_color)
    Color_Objects(Gui, objs[1], pins_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: chosen_body_color_key,
        col_pin[:-1]: pins_color_key,
    }
    expVRML.say(material_substitutions)

    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = docname
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = docname
    restore_Main_Tools()

    doc.Label = docname

    #save the STEP file
    exportSTEP(doc, name, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', name+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + name + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name, out_dir)
    if save_memory == True:
        closeCurrentDoc(docname)
    return 0
def make_3D_model(models_dir, variant):

    LIST_license = ["",]
    modelName = all_params[variant].modelName

    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedmodelName)

    if (all_params[variant].serie == 'RV_Disc'):
        case = make_case_RV_Disc(all_params[variant])
        pins = make_pins_RV_Disc(all_params[variant])
        show(case)
        show(pins)
    else:
        print("Serie " + all_params[variant].serie + " is not supported")
        FreeCAD.Console.PrintMessage('\r\nSerie ' + all_params[variant].serie + ' is not supported\r\n')
        sys.exit()


    #show(pinmark)
    #stop
    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)
    
    FreeCAD.Console.PrintMessage('#1\r\n')

    body_color_key = all_params[variant].body_color_key
    pin_color_key = all_params[variant].pin_color_key

    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    pin_color = shaderColors.named_colors[pin_color_key].getDiffuseFloat()

    FreeCAD.Console.PrintMessage('#2\r\n')

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pin_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]

    FreeCAD.Console.PrintMessage('#3\r\n')
    
    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pin_color_key
    }

    expVRML.say(material_substitutions)
    while len(objs) > 1:
            FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
            del objs
            objs = GetListOfObjects(FreeCAD, doc)
    doc.Label = CheckedmodelName

    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    exportSTEP(doc, modelName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', modelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    FreeCAD.Console.PrintMessage('#4\r\n')

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,modelName,scale,out_dir)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+modelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    #scale=0.3937001
    #exportVRML(doc,modelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelName,out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
    def makeModel(self, models_dir, genericName, model, keepDocument=True, verbose=False):
        r"""Creates a model by calling an instance of a model generator class and writes out the model files

        .. note:: normally this method will be called by :func:`makeModels` but may be used directly

        :param models_dir:
            directory to write the created step and wrl files
        :type models_dir: ``str``

        :param genericName:
            the generic name from the base parameter list, may be used to create the model name
        :type  genericName: ``str``

        :param model:
            an instance of the model class to use
        :type   model: ``class instance`` inherited from :class:`cq_base_model.PartBase`

        :param keepDocument:
            * True: the FreeCAD document will shown after it is created, optionally with kicadStepUptools activated
            * False: the document window will be closed
        :type  keepDocument: ``boolean``

        """

        global kicadStepUptools

        modelName = model.makeModelName(genericName)

        FreeCAD.Console.PrintMessage('\r\n' + modelName)

        if model.make_me != True:
            FreeCAD.Console.PrintMessage(' - not made')
            return

        CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
        FreeCAD.newDocument(CheckedmodelName)
        FreeCAD.setActiveDocument(CheckedmodelName)
        Gui.ActiveDocument = Gui.getDocument(CheckedmodelName)

        model.make()

        doc = FreeCAD.ActiveDocument
        objs = GetListOfObjects(FreeCAD, doc)

        material_substitutions = {}

        for i in range(0, len(objs)):
            Color_Objects(Gui, objs[i], shaderColors.named_colors[model.color_keys[i]].getDiffuseFloat())
            material_substitutions[Gui.ActiveDocument.getObject(objs[i].Name).DiffuseColor[0][:-1]] = model.color_keys[i]

        if verbose:
            expVRML.say(material_substitutions)
            expVRML.say(model.color_keys)
            expVRML.say(model.offsets)

        doc.Label = CheckedmodelName

        while len(objs) > 1:
            FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
            del objs
            objs = GetListOfObjects(FreeCAD, doc)

        objs[0].Label = CheckedmodelName
        restore_Main_Tools()

        #rotate if required
        if (model.rotation != 0):
            z_RotateObject(doc, model.rotation)

        s = objs[0].Shape
        shape = s.copy()
        shape.Placement = s.Placement;
        shape.translate(model.offsets)
        objs[0].Placement = shape.Placement

        out_dir = models_dir + os.sep + model.destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        # Export STEP model
        exportSTEP(doc, modelName, out_dir)

        license_txt = list(add_license.LIST_int_license if self.license is None else self.license) # make a copy to avoid modifying the original
        license_txt.append("")
        license_txt.append("")
        if self.scriptsource != "" and self.script_dir is not None:
            license_txt.append("Generated by script, source at:")
            license_txt.append(self.scriptsource + self.script_dir.split(os.sep)[-1])
            license_txt.append("")

        if verbose:
            expVRML.say("")

        add_license.addLicenseToStep(out_dir + os.sep, modelName + ".step", license_txt, model.licAuthor, model.licEmail, model.licOrgSys, model.licOrg, model.licPreProc)

        # Scale and export Vrml model
        scale = 1.0 / 2.54
        objs = GetListOfObjects(FreeCAD, doc)
        if verbose:
            expVRML.say("######################################################################")
            expVRML.say(objs)
            expVRML.say("######################################################################")
        export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
        export_file_name = out_dir + os.sep + modelName + '.wrl'
        colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
        expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, license_txt)

        # Save the doc in native FC format
        out_dir = self.models_src_dir + os.sep + model.destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)

        saveFCdoc(FreeCAD, Gui, doc, modelName, out_dir)

        # Place on footprint for verification
        if keepDocument and model.footprints_dir is not None and self.footprints_dir is not None:

            sys.argv = ["fc", "dummy", self.footprints_dir + os.sep + model.footprints_dir + os.sep + modelName, "savememory"]

            if verbose:
                expVRML.say('Footprint: ' + sys.argv[2])

            if self.kicadStepUptools is None:
                try:
                    import kicadStepUptools
                    expVRML.say("ksu present!")
                    self.kicadStepUptools = True
                    kicadStepUptools.KSUWidget.close()
                    #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                    #kicadStepUptools.KSUWidget.destroy()
                    #for i in QtGui.qApp.topLevelWidgets():
                    #    if i.objectName() == "kicadStepUp":
                    #        i.deleteLater()
                    #kicadStepUptools.KSUWidget.close()
                except:
                    self.kicadStepUptools = False
                    expVRML.say("ksu not present")

            if not self.kicadStepUptools == False:
                kicadStepUptools.KSUWidget.close()
                reload(kicadStepUptools)
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()

        #display BBox
        if keepDocument:
            Gui.activateWorkbench("PartWorkbench")
            Gui.SendMsgToActiveView("ViewFit")
            Gui.activeDocument().activeView().viewAxometric()
        else:
            doc=FreeCAD.ActiveDocument
            FreeCAD.closeDocument(doc.Name)
Exemplo n.º 30
0
def MakeHeader(n, isAngled, log, highDetail=False):
    global LIST_license
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")

    LIST_license[0] = "Copyright (C) "+datetime.now().strftime("%Y")+", " + STR_licAuthor

    name = HeaderName(n, isAngled)
    print('\n############ ' + name + ' #############\n')

    lib_name='Connector_IDC'


    full_path=os.path.realpath(__file__)
    sub_dir_name =full_path.split(os.sep)[-2]
    sub_path = full_path.split(sub_dir_name)[0]
    models_dir=sub_path+"_3Dmodels"+os.sep
    #models_dir=script_dir+"/../_3Dmodels"

    out_dir=models_dir+'{:s}.3dshapes'.format(lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' or '-' character in the model name REALLY messes with things.
    docname = name.replace(".","").replace("-","_").replace('(', '').replace(')', '')

    Newdoc = FreeCAD.newDocument(docname)
    App.setActiveDocument(docname)
    App.ActiveDocument=App.getDocument(docname)
    Gui.ActiveDocument=Gui.getDocument(docname)

    base = MakeBase(n, highDetail)

    if (isAngled):
        pins = MakeAnglePinRow(n, -3, 5.94, 12.38, highDetail)
        pins = pins.union(MakeAnglePinRow(n, -3, 3.40, 9.84, highDetail).translate((2.54,0,0)))
        # rotate the base into the angled position
        base = base.rotate((0,0,0),(0,1,0),90).translate((4.13,0,5.94))
    else:
        pins = MakePinRow(n, -3.0, 8.0)
        pins = pins.union(MakePinRow(n, -3.0, 8.0).translate((2.54,0,0)))


    colors = [shaderColors.named_colors[key].getDiffuseInt() for key in color_keys]

    cq_obj_data = [base, pins]
    obj_suffixes = ['__base', '__pins']


    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0,)
        show(cq_obj_data[i], color_i)


    doc = FreeCAD.ActiveDocument
    doc.Label = docname
    objs=GetListOfObjects(FreeCAD, doc)

    for i in range(len(objs)):
        objs[i].Label = docname + obj_suffixes[i]

    restore_Main_Tools()

    used_color_keys = color_keys
    export_file_name=out_dir+os.sep+name+'.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=color_keys[i],
                face_colors=None))

    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     doc.Label, objs, keepOriginals=True)
    exportSTEP(doc,name,out_dir,fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=name)

    Lic.addLicenseToStep(out_dir, '{:s}.step'.\
        format(name), LIST_license,
            STR_licAuthor,
            STR_licEmail,
            STR_licOrgSys,
            STR_licPreProc)

    FreeCAD.activeDocument().recompute()
    print("Safe to: {}".format(out_dir))
    saveFCdoc(App, Gui, doc, name, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        print("closing: {}".format(doc.Name))
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, step_path,
            log, name, save_memory=save_memory)
def export_one_part(module, pincount, configuration, log):
    series_definition = module.series_params

    if module.LICENCE_Info.LIST_license[0]=="":
        LIST_license=L.LIST_int_license
        LIST_license.append("")
    else:
        LIST_license=module.LICENCE_Info.LIST_license

    LIST_license[0] = "Copyright (C) "+datetime.now().strftime("%Y")+", " + module.LICENCE_Info.STR_licAuthor
    pins_per_row = pincount/series_definition.number_of_rows
    mpn = series_definition.mpn_format_string.format(pincount=pincount, pins_per_row=pins_per_row)


    orientation = configuration['orientation_options'][series_definition.orientation]
    format_string = getattr(series_definition, 'fp_name_format_string',
        configuration[getattr(series_definition, 'fp_name_format', 'fp_name_format_string')])
    FileName = format_string.format(man=series_definition.manufacturer,
            series=series_definition.series,
            mpn=mpn, num_rows=series_definition.number_of_rows, pins_per_row=pins_per_row,
            pins=pincount, pitch=series_definition.pitch, orientation=orientation,
            mount_pin=series_definition.mount_pin)
    FileName = FileName.replace('__', '_')

    lib_name = configuration['lib_name_format_string'].format(man=series_definition.manufacturer)
    fc_mpn = mpn.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')

    ModelName = '{:s}_{:s}'.format(series_definition.manufacturer, fc_mpn) # For some reason the Model name can not start with a number.

    FreeCAD.Console.PrintMessage('\r\n'+FileName+'\r\n')
    #FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    print(Newdoc.Label)
    App.setActiveDocument(ModelName)
    App.ActiveDocument=App.getDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)

    color_keys = series_definition.color_keys
    obj_suffixes = series_definition.obj_suffixes
    colors = [shaderColors.named_colors[key].getDiffuseInt() for key in color_keys]

    cq_obj_data = module.generate_part(pincount)


    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0,)
        show(cq_obj_data[i], color_i)


    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs=GetListOfObjects(FreeCAD, doc)


    for i in range(len(objs)):
        objs[i].Label = ModelName + obj_suffixes[i]


    restore_Main_Tools()

    out_dir='{:s}{:s}.3dshapes'.format(global_3dpath, lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = color_keys
    export_file_name=out_dir+os.sep+FileName+'.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=color_keys[i],
                face_colors=None))

    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     ModelName, objs, keepOriginals=True)
    exportSTEP(doc,FileName,out_dir,fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.\
        format(FileName), LIST_license,
            module.LICENCE_Info.STR_licAuthor,
            module.LICENCE_Info.STR_licEmail,
            module.LICENCE_Info.STR_licOrgSys,
            module.LICENCE_Info.STR_licPreProc)

    FreeCAD.activeDocument().recompute()

    saveFCdoc(App, Gui, doc, FileName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, step_path,
            log, ModelName, save_memory=save_memory)
Exemplo n.º 32
0
def MakeHeader(n, model, all_params):
    global formerDOC
    global LIST_license
    ModelName = model.replace('yy', "{n:02}".format(n=n))

    full_path=os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name =full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir=sub_path+"_3Dmodels"
    script_dir=os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir=models_dir+all_params[model]['output_directory']
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
   
    newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    App.ActiveDocument=App.getDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)
    
    header_type = all_params[model]['type']
    pitch = all_params[model]['pitch']
    rows = all_params[model]['rows']
    base_width = all_params[model]['base_width']
    base_height = all_params[model]['base_height']
    base_chamfer = all_params[model]['base_chamfer']
    pin_width = all_params[model]['pin_width']
    pin_length_above_base = all_params[model]['pin_length_above_base']
    
    pin_end_chamfer = all_params[model]['pin_end_chamfer']
    rotation = all_params[model]['rotation']
    
    if base_chamfer == 'auto':
        base_chamfer = pitch/10.

    if pin_end_chamfer == 'auto':
        pin_end_chamfer = pin_width/4.

    if header_type == 'Vertical_THT':
        pin_length_below_board = all_params[model]['pin_length_below_board']
        base = make_Vertical_THT_base(n, pitch, rows, base_width, base_height, base_chamfer)
        pins = make_Vertical_THT_pins(n, pitch, rows, pin_length_above_base, pin_length_below_board, base_height, pin_width, pin_end_chamfer)
    elif header_type == 'Horizontal_THT':
        pin_length_below_board = all_params[model]['pin_length_below_board']
        base_x_offset = all_params[model]['base_x_offset']
        base = make_Horizontal_THT_base(n, pitch, rows, base_width, base_height, base_x_offset, base_chamfer)
        pins = make_Horizontal_THT_pins(n, pitch, rows, pin_length_above_base, pin_length_below_board, base_height, base_width, pin_width, pin_end_chamfer, base_x_offset)
    elif header_type == 'Vertical_SMD':
        pin_length_horizontal = all_params[model]['pin_length_horizontal']
        base_z_offset = all_params[model]['base_z_offset']
        if rows == 1:
            pin_1_start = all_params[model]['pin_1_start']
        else:
            pin_1_start = None
        pins = make_Vertical_SMD_pins(n, pitch, rows, pin_length_above_base, pin_length_horizontal, base_height, base_width, pin_width, pin_end_chamfer, base_z_offset, pin_1_start)
        base = make_Vertical_SMD_base(n, pitch, base_width, base_height, base_chamfer, base_z_offset)
    else:
        print 'Header type: '
        print header_type
        print ' is not recognized, please check parameters'
        stop

    show(base)
    show(pins)

    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)
    
    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pins_color_key,
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    #objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui,
                   doc.Name, objs[0].Name, objs[1].Name)
    doc.Label=CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=CheckedModelName
    restore_Main_Tools()

    if (rotation !=0):
        z_RotateObject(doc, rotation)
    
    #out_dir = models_dir+"/generated_pinheaders"
    
    doc.Label = CheckedModelName
    
    #save the STEP file
    exportSTEP(doc, ModelName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
    
    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    #save the VRML file
    #scale=0.3937001
    #exportVRML(doc,name,scale,out_dir)
    
    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format 
    saveFCdoc(App, Gui, doc, ModelName, out_dir, False) 
    
    check_Model=True
    if save_memory == True or check_Model==True:
        closeCurrentDoc(CheckedModelName)
    step_path=os.path.join(out_dir,ModelName+u'.step')
    if check_Model==True:
        #ImportGui.insert(step_path,ModelName)
        ImportGui.open(step_path)
        docu = FreeCAD.ActiveDocument
        if cq_cad_tools.checkUnion(docu) == True:
            FreeCAD.Console.PrintMessage('step file is correctly Unioned\n')
        else:
            FreeCAD.Console.PrintError('step file is NOT Unioned\n')
            stop
        FC_majorV=int(FreeCAD.Version()[0])
        FC_minorV=int(FreeCAD.Version()[1])
        if FC_majorV == 0 and FC_minorV >= 17:
            for o in docu.Objects:
                if hasattr(o,'Shape'):
                    chks=cq_cad_tools.checkBOP(o.Shape)
                    print 'chks ',chks
                    print cq_cad_tools.mk_string(o.Label)
                    if chks != True:
                        msg='shape \''+o.Name+'\' \''+cq_cad_tools.mk_string(o.Label)+'\' is INVALID!\n'
                        FreeCAD.Console.PrintError(msg)
                        FreeCAD.Console.PrintWarning(chks[0])
                        stop
                    else:
                        msg='shape \''+o.Name+'\' \''+cq_cad_tools.mk_string(o.Label)+'\' is valid\n'
                        FreeCAD.Console.PrintMessage(msg)
        else:
            FreeCAD.Console.PrintError('BOP check requires FC 0.17+\n')
            # Save the doc in Native FC format
        saveFCdoc(App, Gui, docu, ModelName,out_dir, False)
        closeCurrentDoc(docu.Label)
        
    return 0
Exemplo n.º 33
0
def export_one_part(modul, variant, configuration, log, with_plug=False):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage(
            "Parameters for %s doesn't exist in 'M.all_params', skipping." %
            variant)
        return
    LIST_license[0] = "Copyright (C) " + datetime.now().strftime(
        "%Y") + ", " + STR_licAuthor

    params = modul.all_params[variant]
    series_params = modul.seriesParams
    series = series_params.series_name

    subseries, connector_style = params.series_name.split('-')
    pitch_mpn = '-{:g}'.format(params.pin_pitch)
    if series[0] == 'MSTB':
        pitch_mpn = ''
        if params.pin_pitch == 5.08:
            pitch_mpn = '-5,08'
        elif params.pin_pitch == 7.62:
            pitch_mpn = '-7,62'
    lib_name = configuration['lib_name_format_str'].format(
        series=series[0], style=series[1], pitch=params.pin_pitch)
    mpn = configuration['mpn_format_string'].format(subseries=subseries,
                                                    style=connector_style,
                                                    rating=series[1],
                                                    num_pins=params.num_pins,
                                                    pitch=pitch_mpn)
    FileName = configuration['fp_name_format_string'].format(
        man=configuration['manufacturer'],
        series=series[0],
        mpn=mpn,
        num_rows=1,
        num_pins=params.num_pins,
        pitch=params.pin_pitch,
        orientation=configuration['orientation_str'][1]
        if params.angled else configuration['orientation_str'][0],
        flanged=configuration['flanged_str'][1]
        if params.flanged else configuration['flanged_str'][0],
        mount_hole=configuration['mount_hole_str'][1]
        if params.mount_hole else configuration['mount_hole_str'][0])

    destination_dir = global_3dpath + lib_name
    if with_plug:
        destination_dir += "__with_plug"
    destination_dir += ".3dshapes"

    ModelName = variant
    ModelName = ModelName.replace(".", "_")
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    App.ActiveDocument = App.getDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)
    #App.setActiveDocument(ModelName)
    #Gui.ActiveDocument=Gui.getDocument(ModelName)
    (pins, body, insert, mount_screw, plug,
     plug_screws) = modul.generate_part(variant, with_plug)

    color_attr = body_color + (0, )
    show(body, color_attr)

    color_attr = pins_color + (0, )
    show(pins, color_attr)

    if insert is not None:
        color_attr = insert_color + (0, )
        show(insert, color_attr)
    if mount_screw is not None:
        color_attr = screw_color + (0, )
        show(mount_screw, color_attr)
    if plug is not None:
        color_attr = body_color + (0, )
        show(plug, color_attr)

        color_attr = screw_color + (0, )
        show(plug_screws, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = FreeCAD.ActiveDocument.Objects
    FreeCAD.Console.PrintMessage(objs)

    i = 0
    objs[i].Label = ModelName + "__body"
    i += 1
    objs[i].Label = ModelName + "__pins"
    i += 1
    if insert is not None:
        objs[i].Label = ModelName + "__thread_insert"
        i += 1
    if mount_screw is not None:
        objs[i].Label = ModelName + "__mount_screw"
        i += 1
    if plug is not None:
        objs[i].Label = ModelName + "__plug"
        i += 1
        objs[i].Label = ModelName + "__plug_screws"
    restore_Main_Tools()

    out_dir = destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name = destination_dir + os.sep + FileName + '.wrl'

    export_objects = []
    i = 0
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[i],
                             shape_color=body_color_key,
                             face_colors=None))
    i += 1
    export_objects.append(
        expVRML.exportObject(freecad_object=objs[i],
                             shape_color=pins_color_key,
                             face_colors=None))
    i += 1
    if insert is not None:
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=insert_color_key,
                                 face_colors=None))
        used_color_keys.append(insert_color_key)
        i += 1
    if mount_screw is not None:
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=screw_color_key,
                                 face_colors=None))
        used_color_keys.append(screw_color_key)
        i += 1
    if plug is not None:
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=body_color_key,
                                 face_colors=None))
        i += 1
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=screw_color_key,
                                 face_colors=None))
    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD,
                                   FreeCADGui,
                                   ModelName,
                                   objs,
                                   keepOriginals=True)

    exportSTEP(doc, FileName, out_dir, fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.format(FileName), LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    FreeCAD.activeDocument().recompute()
    # FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, FileName, out_dir)
    if save_memory == True or check_Model == True:
        closeCurrentDoc(ModelName)

    if check_Model == True:
        runGeometryCheck(App,
                         Gui,
                         step_path,
                         log,
                         ModelName,
                         save_memory=save_memory)
def export_model(model):
    file_name = model['metadata']['name']
    parts = model['parts']
    parts_list = parts.keys()

    # create document
    safe_name = file_name.replace('-', '_')
    FreeCAD.Console.PrintMessage('Model: {:s}\r\n'.format(file_name))
    FreeCAD.newDocument(safe_name)
    App.setActiveDocument(safe_name)
    App.ActiveDocument = App.getDocument(safe_name)
    Gui.ActiveDocument = Gui.getDocument(safe_name)

    # colour model
    used_colour_keys = []
    for part in parts_list:
        colour_key = parts[part]['colour']
        used_colour_keys.append(colour_key)
        colour = shaderColors.named_colors[colour_key].getDiffuseInt()
        colour_attr = colour + (0,)
        show(parts[part]['name'], colour_attr)

    # label model and parts
    doc = FreeCAD.ActiveDocument
    doc.Label=safe_name
    objects=doc.Objects
    i = 0
    for part in parts_list:
        objects[i].Label = '{n:s}__{p:s}'.format(n=safe_name, p=part)
        i += 1
    restore_Main_Tools()
    doc.recompute()
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewTop()

    # create output folder
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    # export VRML
    export_file_name = '{d:s}{s:s}{n:s}.wrl'.format(d=out_dir, s=os.sep, n=file_name)
    export_objects = []
    i = 0
    for part in parts_list:
        export_objects.append(expVRML.exportObject(freecad_object=objects[i],
                              shape_color=parts[part]['colour'],
                              face_colors=None))
        i += 1
    scale = 1 / 2.54
    coloured_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)

    L.LIST_int_license[0] = "Copyright (C) " + datetime.now().strftime("%Y") + ", " + L.STR_int_licAuthor
    expVRML.writeVRMLFile(coloured_meshes, export_file_name, used_colour_keys, L.LIST_int_license)

    # export STEP
    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui, safe_name, objects, keepOriginals=True)
    exportSTEP(doc, file_name, out_dir, fusion)
    L.addLicenseToStep('{d:s}/'.format(d=out_dir), '{n:s}.step'.format(n=file_name), L.LIST_int_license,
                       L.STR_int_licAuthor, L.STR_int_licEmail, L.STR_int_licOrgSys, L.STR_int_licPreProc)

    # save FreeCAD models
    saveFCdoc(App, Gui, doc, file_name, out_dir)
    return
def generateOneModel(params, log):
    excluded_pins_x = ()  ##no pin excluded
    excluded_pins_xmirror = ()  ##no pin excluded
    place_pinMark = True  ##default =True used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)

    ModelName = params.modelName
    FreeCAD.Console.PrintMessage('\n\n##############  ' + ModelName +
                                 '  ###############\n')
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedModelName)
    #case, pins, pinmark = make_case(params)
    case_bot, case, pins, pinmark = make_case(params)

    if case_bot is not None:
        show(case_bot)
    show(case)
    show(pins)
    show(pinmark)
    #stop

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    if case_bot is not None:
        Color_Objects(Gui, objs[0], body_bot_color)
        Color_Objects(Gui, objs[1], body_color)
        Color_Objects(Gui, objs[2], pins_color)
        Color_Objects(Gui, objs[3], marking_color)

        col_body_bot = Gui.ActiveDocument.getObject(
            objs[0].Name).DiffuseColor[0]
        col_body = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
        col_pin = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
        col_mark = Gui.ActiveDocument.getObject(objs[3].Name).DiffuseColor[0]
        material_substitutions = {
            col_body_bot[:-1]: body_bot_color_key,
            col_body[:-1]: body_color_key,
            col_pin[:-1]: pins_color_key,
            col_mark[:-1]: marking_color_key
        }
        expVRML.say(material_substitutions)
        if (color_pin_mark == True) and (place_pinMark == True):
            CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[1].Name,
                            objs[3].Name)
        else:
            #removing pinMark
            App.getDocument(doc.Name).removeObject(objs[3].Name)
        ###
        #sleep
        del objs
        objs = GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                         objs[1].Name)
        objs = GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                         objs[1].Name)
    else:
        Color_Objects(Gui, objs[0], body_color)
        Color_Objects(Gui, objs[1], pins_color)
        Color_Objects(Gui, objs[2], marking_color)

        col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
        col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
        col_mark = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
        material_substitutions = {
            col_body[:-1]: body_color_key,
            col_pin[:-1]: pins_color_key,
            col_mark[:-1]: marking_color_key
        }
        #expVRML.say(material_substitutions)
        if (color_pin_mark == True) and (place_pinMark == True):
            CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                            objs[2].Name)
        else:
            #removing pinMark
            App.getDocument(doc.Name).removeObject(objs[2].Name)
        ###
        #sleep
        del objs
        objs = GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                         objs[1].Name)
    ## objs[0].Label='body'
    ## objs[1].Label='pins'
    ## objs[2].Label='mark'
    ###
    ## print objs[0].Name, objs[1].Name, objs[2].Name

    ## sleep
    doc.Label = CheckedModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName
    restore_Main_Tools()
    #rotate if required
    if (params.rotation != 0):
        rot = params.rotation
        z_RotateObject(doc, rot)
    #out_dir=destination_dir+params.dest_dir_prefix+'/'
    script_dir = os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    #expVRML.say(models_dir)
    if len(params.dest_dir_prefix) >= 1:
        out_dir = models_dir + destination_dir + os.sep + params.dest_dir_prefix
    else:
        out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)

    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + ModelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    #expVRML.writeVRMLFile added creaeAngle
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license, 0.9)
    # Save the doc in Native FC format
    #saveFCdoc(App, Gui, doc, ModelName,out_dir)
    #display BBox
    #FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
    if footprints_dir is not None and os.path.isdir(
            footprints_dir
    ) and not save_memory and not check_Model:  #it doesn't make sense to import the footprint right before we close the file.
        #expVRML.say (ModelName)
        #stop
        sys.argv = [
            "fc", "dummy", footprints_dir + os.sep + ModelName, "savememory"
        ]
        #setup = get_setup_file()  # << You need the parentheses
        expVRML.say(sys.argv[2])
        if not ksu_present:
            try:
                import kicadStepUptools
                ksu_present = True
                expVRML.say("ksu present!")
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()
                #for i in QtGui.qApp.topLevelWidgets():
                #    if i.objectName() == "kicadStepUp":
                #        i.deleteLater()
                kicadStepUptools.KSUWidget.close()
            except:
                ksu_present = False
                expVRML.say("ksu not present")
        else:
            kicadStepUptools.KSUWidget.close()
            reload_lib(kicadStepUptools)
            kicadStepUptools.KSUWidget.close()
            #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
            #kicadStepUptools.KSUWidget.destroy()

    #FreeCADGui.insert(u"C:\Temp\FCAD_sg\QFN_packages\QFN-12-1EP_3x3mm_Pitch0_5mm.kicad_mod")
    #FreeCADGui.insert(script_dir+os.sep+"ModelName.kicad_mod")
    if save_memory == False:
        Gui.activateWorkbench("PartWorkbench")
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewBottom()
        #Gui.activeDocument().activeView().viewAxometric()
    saveFCdoc(App, Gui, doc, ModelName, out_dir)

    if save_memory == True or check_Model == True:
        doc = FreeCAD.ActiveDocument
        print("closing: {}".format(doc.Name))
        FreeCAD.closeDocument(doc.Name)

    if check_Model == True:
        step_path = out_dir + '/' + ModelName + ".step"
        runGeometryCheck(App,
                         Gui,
                         step_path,
                         log,
                         ModelName,
                         save_memory=save_memory)
def export_one_part(modul, variant):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage("Parameters for %s not found - skipping." % variant)
        return
    ModelName = variant
    ModelName = ModelName.replace(".","_")
    FileName = modul.all_params[variant].file_name

    FreeCAD.Console.PrintMessage(FileName)

    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    App.ActiveDocument=App.getDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)

    # Model details
    #################################################################################################

    (pins, body, contacts) = modul.generate_part(variant)

    color_attr = body_color + (0,)
    show(body, color_attr)

    color_attr = pins_color + (0,)
    show(pins, color_attr)

    color_attr = contacts_color + (0,)
    show(contacts, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label=ModelName
    objs=FreeCAD.ActiveDocument.Objects
    FreeCAD.Console.PrintMessage(objs)

    i=0
    objs[i].Label = ModelName + "__body"
    i+=1
    objs[i].Label = ModelName + "__pins"
    i+=1
    objs[i].Label = ModelName + "__contacts"
    i+=1

    restore_Main_Tools()

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key, contacts_color_key]
    export_file_name=out_dir+os.sep+FileName+'.wrl'

    export_objects = []
    i=0
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=body_color_key,
            face_colors=None))
    i+=1
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=pins_color_key,
            face_colors=None))
    i+=1
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=contacts_color_key,
            face_colors=None))
    i+=1

    #################################################################################################


    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)

    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, L.LIST_int_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     ModelName, objs, keepOriginals=True)

    exportSTEP(doc,FileName,out_dir,fusion)
    L.addLicenseToStep(out_dir+'/', FileName+".step", L.LIST_int_license,\
        L.STR_int_licAuthor, L.STR_int_licEmail, L.STR_int_licOrgSys, L.STR_int_licPreProc)

    saveFCdoc(App, Gui, doc, FileName,out_dir)

    FreeCAD.activeDocument().recompute()
    FreeCADGui.SendMsgToActiveView("ViewFit")
    FreeCADGui.activeDocument().activeView().viewAxometric()
def MakePart(params, name, n=1):
    global formerDOC
    global LIST_license
    #name = PartName(params, n)

    full_path=os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name =full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir=sub_path+"_3Dmodels"
    script_dir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' character in the model name REALLY messes with things. also '-'
    docname = name.replace(".","").replace("-","_")
   
    newdoc = App.newDocument(docname)
    App.setActiveDocument(docname)
    App.ActiveDocument=App.getDocument(docname)
    Gui.ActiveDocument=Gui.getDocument(docname)
    
    FreeCAD.Console.PrintMessage(params)
    pins_output = MakeResistorPin(params, n)
    base_output = MakeResistor(params, n)
    marking_output = MakeMarking(params, n)
    
    show(base_output)
    show(pins_output)
    if not (marking_output == 0):
        show(marking_output)

    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)
    
    # select the color based on shape
    if (params.shape == "power") or (params.shape == "radial") or (params.shape == "shunt"):
        # white colour for power resistors
        chosen_body_color = ceramic_color
        chosen_body_color_key = ceramic_color_key
    elif (params.shape == "bare"):
        # metal/pin colour for bare resistors
        chosen_body_color = pins_color
        chosen_body_color_key = pins_color_key   
    else:
        # light brown colour for din/axial/arrays/etc.
        chosen_body_color = body_color
        chosen_body_color_key = body_color_key  
    
    # body and pin colours
    Color_Objects(Gui,objs[0],chosen_body_color)
    Color_Objects(Gui,objs[1],pins_color)
    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:chosen_body_color_key,
        col_pin[:-1]:pins_color_key
    }
    
    # optional marking bodies
    if (len(objs) >= 3):
        Color_Objects(Gui,objs[2],marking_color)
        col_marking=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
        material_substitutions[col_marking[:-1]] = marking_color_key
        
    expVRML.say(material_substitutions)

    # fuse everything
    while len(objs) > 1:
        FreeCAD.Console.PrintMessage(len(objs))
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                   doc.Name, objs[0].Name, objs[1].Name)
        objs = GetListOfObjects(FreeCAD, doc)

    doc.Label=docname
    #objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=docname
    restore_Main_Tools()

    doc.Label = docname
    
    #save the STEP file
    exportSTEP(doc, name, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', name+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
    
    # scale and export Vrml model
    scale=1/2.54
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+name+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    
    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()
    
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name,out_dir)
    if save_memory == True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    return 0
def MakeHeader(n, model, all_params):
    global formerDOC
    global LIST_license
    ModelName = model.replace('yy', "{n:02}".format(n=n))

    full_path=os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name =full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir=sub_path+"_3Dmodels"
    script_dir=os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir=models_dir+all_params[model]['output_directory']
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
   
    newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    App.ActiveDocument=App.getDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)
    
    header_type = all_params[model]['type']
    pitch = all_params[model]['pitch']
    rows = all_params[model]['rows']
    base_width = all_params[model]['base_width']
    base_height = all_params[model]['base_height']
    base_chamfer = all_params[model]['base_chamfer']
    pin_width = all_params[model]['pin_width']
    pin_length_above_base = all_params[model]['pin_length_above_base']
    
    pin_end_chamfer = all_params[model]['pin_end_chamfer']
    rotation = all_params[model]['rotation']
    
    if base_chamfer == 'auto':
        base_chamfer = pitch/10.

    if pin_end_chamfer == 'auto':
        pin_end_chamfer = pin_width/4.

    if header_type == 'Vertical_THT':
        pin_length_below_board = all_params[model]['pin_length_below_board']
        base = make_Vertical_THT_base(n, pitch, rows, base_width, base_height, base_chamfer)
        pins = make_Vertical_THT_pins(n, pitch, rows, pin_length_above_base, pin_length_below_board, base_height, pin_width, pin_end_chamfer)
    elif header_type == 'Horizontal_THT':
        pin_length_below_board = all_params[model]['pin_length_below_board']
        base_x_offset = all_params[model]['base_x_offset']
        base = make_Horizontal_THT_base(n, pitch, rows, base_width, base_height, base_x_offset, base_chamfer)
        pins = make_Horizontal_THT_pins(n, pitch, rows, pin_length_above_base, pin_length_below_board, base_height, base_width, pin_width, pin_end_chamfer, base_x_offset)
    elif header_type == 'Vertical_SMD':
        pin_length_horizontal = all_params[model]['pin_length_horizontal']
        base_z_offset = all_params[model]['base_z_offset']
        if rows == 1:
            pin_1_start = all_params[model]['pin_1_start']
        else:
            pin_1_start = None
        pins = make_Vertical_SMD_pins(n, pitch, rows, pin_length_above_base, pin_length_horizontal, base_height, base_width, pin_width, pin_end_chamfer, base_z_offset, pin_1_start)
        base = make_Vertical_SMD_base(n, pitch, base_width, base_height, base_chamfer, base_z_offset)
    else:
        print 'Header type: '
        print header_type
        print ' is not recognized, please check parameters'
        stop

    show(base)
    show(pins)

    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)
    
    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pins_color_key,
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    #objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui,
                   doc.Name, objs[0].Name, objs[1].Name)
    doc.Label=CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=CheckedModelName
    restore_Main_Tools()

    if (rotation !=0):
        z_RotateObject(doc, rotation)
    
    #out_dir = models_dir+"/generated_pinheaders"
    
    doc.Label = CheckedModelName
    
    #save the STEP file
    exportSTEP(doc, ModelName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
    
    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    #save the VRML file
    #scale=0.3937001
    #exportVRML(doc,name,scale,out_dir)
    
    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format 
    saveFCdoc(App, Gui, doc, ModelName, out_dir, False) 
    
    check_Model=True
    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)
    step_path=os.path.join(out_dir,ModelName+u'.step')
    if check_Model==True:
        #ImportGui.insert(step_path,ModelName)
        ImportGui.open(step_path)
        docu = FreeCAD.ActiveDocument
        if cq_cad_tools.checkUnion(docu) == True:
            FreeCAD.Console.PrintMessage('step file is correctly Unioned\n')
        else:
            FreeCAD.Console.PrintError('step file is NOT Unioned\n')
            stop
        FC_majorV=int(FreeCAD.Version()[0])
        FC_minorV=int(FreeCAD.Version()[1])
        if FC_majorV == 0 and FC_minorV >= 17:
            for o in docu.Objects:
                if hasattr(o,'Shape'):
                    chks=cq_cad_tools.checkBOP(o.Shape)
                    print 'chks ',chks
                    print cq_cad_tools.mk_string(o.Label)
                    if chks != True:
                        msg='shape \''+o.Name+'\' \''+cq_cad_tools.mk_string(o.Label)+'\' is INVALID!\n'
                        FreeCAD.Console.PrintError(msg)
                        FreeCAD.Console.PrintWarning(chks[0])
                        stop
                    else:
                        msg='shape \''+o.Name+'\' \''+cq_cad_tools.mk_string(o.Label)+'\' is valid\n'
                        FreeCAD.Console.PrintMessage(msg)
        else:
            FreeCAD.Console.PrintError('BOP check requires FC 0.17+\n')
            # Save the doc in Native FC format
        saveFCdoc(App, Gui, docu, ModelName,out_dir, False)
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)
        
    return 0
def MakeHeader(n, params):
    global formerDOC
    global LIST_license
    name = HeaderName(n, params)

    # destination_dir="/Pin_Headers"

    full_path = os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name = full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir = sub_path + "_3Dmodels"
    script_dir = os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' character in the model name REALLY messes with things.
    docname = name.replace(".", "")

    newdoc = App.newDocument(docname)
    App.setActiveDocument(docname)
    App.ActiveDocument = App.getDocument(docname)
    Gui.ActiveDocument = Gui.getDocument(docname)

    baseblock = cq.Workplane("XY").rect(params.p, params.w).extrude(
        params.h).edges("|Z").chamfer(params.p / 10).translate(
            (0, 0, params.hb))
    base = baseblock
    for blocks in range(1, n):
        baseblock = baseblock.translate((params.p, 0, 0))
        base = base.union(baseblock)
        #move the base to the 'middle'
    if params.rows > 1:
        offset = params.p * (params.rows - 1) / 2.0
        base = base.translate((0, offset, 0))

    Inner_point = params.pw / sqrt(2)
    Outer_point = (params.pw * 2) / sqrt(2)
    single_pin = cq.Workplane("YZ", (0,0,0,)). \
    moveTo(params.pw/2,params.pa).line(0,-(params.pa-2*params.pw)).threePointArc((-(params.pw*1.5)+Outer_point,params.pw*2-Outer_point),(-(params.pw*1.5), 0)). \
    line(-(params.ph-2*params.pw),0).line(0,params.pw).line((params.ph-2*params.pw),0).threePointArc((-(params.pw*1.5)+Inner_point,params.pw*2-Inner_point), (-(params.pw/2), params.pw*2)). \
    line(0,params.pa-2*params.pw).close().extrude(params.pw).translate((-params.pw/2,0,0))
    single_pin = single_pin.faces(">Z").chamfer(params.pw / 4)
    single_pin = single_pin.faces("<Y").chamfer(params.pw / 4)
    pins = []
    if params.type:
        if params.type == 'Pin1Left':
            single_pin = single_pin.rotate((0, 0, 0), (0, 0, 1), 180)
        for pincount in range(0, n):
            single_pin = single_pin.rotate((0, 0, 0), (0, 0, 1), 180)
            pin = single_pin.translate((params.p * pincount, 0, 0))
            pins.append(pin)
    else:
        for pincount in range(0, n):
            pin = single_pin.translate((params.p * pincount, 0, 0))
            pins.append(pin)
        single_pin = single_pin.rotate((0, 0, 0), (0, 0, 1), 180)
        for pincount in range(0, n):
            pin = single_pin.translate((params.p * pincount, params.p, 0))
            pins.append(pin)

    merged_pins = pins[0]
    for p in pins[1:]:
        merged_pins = merged_pins.union(p)
    pins = merged_pins
    if params.rows > 1:
        row_offset = -params.p / 2
    else:
        row_offset = 0
    pins = pins.translate((-params.p * (n - 1) / 2, row_offset, 0))
    base = base.translate((-params.p * (n - 1) / 2, row_offset, 0))

    show(base)
    show(pins)

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key,
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    ##assign some colors
    #base_color = (50,50,50)
    #pins_color = (225,175,0)
    #
    #show(base,base_color+(0,))
    #show(pins,pins_color+(0,))

    #objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = docname
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = docname
    restore_Main_Tools()

    if (params.rot != 0):
        z_RotateObject(doc, params.rot)

    #out_dir = models_dir+"/generated_pinheaders"

    doc.Label = docname

    #save the STEP file
    exportSTEP(doc, name, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', name+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + name + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    #save the VRML file
    #scale=0.3937001
    #exportVRML(doc,name,scale,out_dir)

    if save_memory == False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name, out_dir)
    if save_memory == True:
        closeCurrentDoc(docname)
    return 0
Exemplo n.º 40
0
def make_3D_model(models_dir, variant):

    LIST_license = ["",]
    modelName = all_params[variant].modelName

    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedmodelName)

    case = make_case(all_params[variant])
    casetop = make_case_top(all_params[variant])
    pins = make_pins(all_params[variant])

    show(case)
    show(casetop)
    show(pins)
    #show(pinmark)
    #stop
    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)

    body_color_key = all_params[variant].body_color_key
    body_top_color_key = all_params[variant].body_top_color_key
    pin_color_key = all_params[variant].pin_color_key


    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    body_top_color = shaderColors.named_colors[body_top_color_key].getDiffuseFloat()
    pin_color = shaderColors.named_colors[pin_color_key].getDiffuseFloat()

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],body_top_color)
    Color_Objects(Gui,objs[2],pin_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_body_top=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]

    material_substitutions={
        col_body[:-1]:body_color_key,
        col_body_top[:-1]:body_top_color_key,
        col_pin[:-1]:pin_color_key
    }

    expVRML.say(material_substitutions)
    while len(objs) > 1:
            FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
            del objs
            objs = GetListOfObjects(FreeCAD, doc)
    doc.Label = CheckedmodelName

    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir=models_dir+os.sep+all_params[variant].dest_dir_prefix

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=modelName)
    exportSTEP(doc, modelName, out_dir)


    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")

    Lic.addLicenseToStep(out_dir, '{:s}.step'.format(modelName),
            LIST_license,
            cq_parameters.LICENCE_Info.STR_licAuthor,
            cq_parameters.LICENCE_Info.STR_licEmail,
            cq_parameters.LICENCE_Info.STR_licOrgSys,
            cq_parameters.LICENCE_Info.STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,modelName,scale,out_dir)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+modelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    # expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    # Save the doc in Native FC format
    doc.recompute()
    saveFCdoc(App, Gui, doc, modelName, out_dir)


    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        FreeCAD.closeDocument(doc.Name)
        os.remove (out_dir+os.sep+modelName+'.FCStd')

    if check_Model==True:
        with open(out_dir+os.sep+check_log_file, 'a+') as log:
            log.write('# Check report for Molex 3d model genration\n')
            runGeometryCheck(App, Gui, step_path, log, modelName, save_memory=save_memory)
            log.close()
def make_3D_model(models_dir, variant):

    LIST_license = ["",]

    FreeCAD.Console.PrintMessage("\r\nMaking %s\r\n" % variant)
    modelName = variant
    modelfileName = ''
    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedmodelName)

    case = None
    pins = None

    if all_params[variant].modeltype == 'BX0036':
        case = make_case_BX0036(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif all_params[variant].modeltype == 'Button1':
        case = make_case_Button1(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif all_params[variant].modeltype == 'Button2':
        case = make_case_Button2(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif all_params[variant].modeltype == 'Button3':
        case = make_case_Button3(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif all_params[variant].modeltype == 'Button4':
        case = make_case_Button4(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif all_params[variant].modeltype == 'Cylinder1':
        case = make_case_Cylinder1(all_params[variant])
        pins = make_pins(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif variant == 'Seiko_MS621F':
        case = make_case_Seiko_MS621F(all_params[variant])
        pins = make_pins_Seiko_MS621F(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    elif variant == 'Keystone_2993':
        case = make_case_Keystone_2993(all_params[variant])
        pins = make_pins_Keystone_2993(all_params[variant])
        show(case)
        show(pins)
        modelfileName = make_modelfileName_Common(all_params[variant])
        #
        #
    else:
        FreeCAD.Console.PrintMessage("\r\nSerie %s does not exist, skipping'\r\n" % all_params[variant].serie)
        return

    #show(pinmark)
    #stop
    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)

    body_color_key = all_params[variant].body_color_key
    pin_color_key = all_params[variant].pin_color_key

    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    pin_color = shaderColors.named_colors[pin_color_key].getDiffuseFloat()

    Color_Objects(Gui,objs[0],body_color)
    Color_Objects(Gui,objs[1],pin_color)

    col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]

    material_substitutions={
        col_body[:-1]:body_color_key,
        col_pin[:-1]:pin_color_key
    }

    expVRML.say(material_substitutions)
    while len(objs) > 1:
            FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
            del objs
            objs = GetListOfObjects(FreeCAD, doc)
    doc.Label = CheckedmodelName

    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir=os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir=models_dir + os.sep +  all_params[variant].dest_dir_prefix
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    exportSTEP(doc, modelfileName, out_dir)
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir + os.sep, modelfileName + ".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc, modelfileName,scale,out_dir)
    del objs
    objs=GetListOfObjects(FreeCAD, doc)
    expVRML.say("######################################################################")
    expVRML.say(objs)
    expVRML.say("######################################################################")
    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir + os.sep + modelfileName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)
    #scale=0.3937001
    #exportVRML(doc, modelfileName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelfileName, out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
Exemplo n.º 42
0
def export_one_part(params, series_definition, log):
    ModelName = params.modelName
    footprint_dir = series_definition.footprint_dir
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')

    print('\n######################### {:s} ###########################\n'.
          format(ModelName))

    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    App.ActiveDocument = App.getDocument(CheckedModelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedModelName)

    color_keys = [
        series_definition.body_color_key, series_definition.pins_color_key,
        series_definition.mark_color_key
    ]
    colors = [
        shaderColors.named_colors[key].getDiffuseInt() for key in color_keys
    ]

    body, pins, mark = make_gw(params)

    show(body, colors[0] + (0, ))
    show(pins, colors[1] + (0, ))
    show(mark, colors[2] + (0, ))

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: series_definition.body_color_key,
        col_pin[:-1]: series_definition.pins_color_key,
        col_mark[:-1]: series_definition.mark_color_key
    }

    if (color_pin_mark == True) and (place_pinMark == True):
        CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                        objs[2].Name)
    else:
        #removing pinMark
        App.getDocument(doc.Name).removeObject(objs[2].Name)

    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = CheckedModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName

    restore_Main_Tools()
    #rotate if required
    if (params.rotation != 0):
        rot = params.rotation
        z_RotateObject(doc, rot)

    if no_export:
        return

    out_dir = '{:s}{:s}.3dshapes'.format(global_3dpath,
                                         series_definition.lib_name)

    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                         STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)
    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + ModelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)
    # Save the doc in Native FC format
    footprint_dir = series_definition.footprint_dir
    if footprint_dir is not None and os.path.isdir(footprint_dir) \
            and not save_memory and not check_Model:
        #expVRML.say (ModelName)
        #stop
        sys.argv = [
            "fc", "dummy", footprint_dir + os.sep + ModelName, "savememory"
        ]
        #setup = get_setup_file()  # << You need the parentheses
        expVRML.say(sys.argv[2])
        ksu_already_loaded = False
        ksu_present = False
        for i in QtGui.qApp.topLevelWidgets():
            if i.objectName() == "kicadStepUp":
                ksu_already_loaded = True
        ksu_tab = FreeCADGui.getMainWindow().findChild(
            QtGui.QDockWidget, "kicadStepUp")  #"kicad StepUp 3D tools")
        if ksu_tab:
            ksu_already_loaded = True
        if ksu_already_loaded != True:
            try:
                import kicadStepUptools
                ksu_present = True
                ksu_already_loaded = True
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()
                #for i in QtGui.qApp.topLevelWidgets():
                #    if i.objectName() == "kicadStepUp":
                #        i.deleteLater()
                kicadStepUptools.KSUWidget.close()
            except:
                ksu_present = False
                expVRML.say("ksu not present")
        else:
            kicadStepUptools.KSUWidget.close()
            reload(kicadStepUptools)
            kicadStepUptools.KSUWidget.close()
            #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
            #kicadStepUptools.KSUWidget.destroy()

    saveFCdoc(App, Gui, doc, ModelName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model == False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model == True:
        doc = FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model == True:
        runGeometryCheck(App,
                         Gui,
                         out_dir + '/' + ModelName + ".step",
                         log,
                         ModelName,
                         save_memory=save_memory)
Exemplo n.º 43
0
def make_3D_model(models_dir, variant):

    LIST_license = [
        "",
    ]
    modelName = all_params[variant].modelName

    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedmodelName)

    case = make_case(all_params[variant], type, modelName)

    if (all_params[variant].type == CASE_THT_TYPE):
        pins = make_pins_tht(all_params[variant], type, modelName)

    if (all_params[variant].type == CASE_SMD_TYPE):
        pins = make_pins_smd(all_params[variant], type, modelName)

        # color_attr=case_color+(0,)
    # show(case, color_attr)
    # #FreeCAD.Console.PrintMessage(pins_color)
    # color_attr=pins_color+(0,)
    # #FreeCAD.Console.PrintMessage(color_attr)
    # show(pins, color_attr)
    #doc = FreeCAD.ActiveDocument
    #objs=GetListOfObjects(FreeCAD, doc)

    show(case)
    show(pins)
    #show(pinmark)
    #stop

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = CheckedmodelName
    del objs
    #objs=GetListOfObjects(FreeCAD, doc)
    #FuseObjs_wColors(FreeCAD, FreeCADGui,
    #                doc.Name, objs[0].Name, objs[1].Name)
    #doc.Label=modelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    # objs=GetListOfObjects(FreeCAD, doc)
    # objs[0].Label=modelName
    # restore_Main_Tools()
    #rotate if required
    if (all_params[variant].rotation != 0):
        rot = all_params[variant].rotation
        z_RotateObject(doc, rot)
    npins = all_params[variant].npins
    e = all_params[variant].e
    E = all_params[variant].E
    c = 0.254  # lead thickness
    mvY = (npins * e / 4 - e / 2)
    mvX = (E - c) / 2
    s = objs[0].Shape
    shape = s.copy()
    shape.Placement = s.Placement
    shape.translate((+mvX, -mvY, 0))
    objs[0].Placement = shape.Placement
    #case = case.translate ((-mvX,-mvY,0))
    #pins = pins.translate ((-mvX,-mvY,0))
    # out_dir=destination_dir
    # if not os.path.exists(out_dir):
    #     os.makedirs(out_dir)
    # #out_dir="./generated_qfp/"
    # # export STEP model
    # exportSTEP(doc,modelName,out_dir)
    script_dir = os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, modelName, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', modelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,modelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + modelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)
    #scale=0.3937001
    #exportVRML(doc,modelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelName, out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
Exemplo n.º 44
0
def generateOneModel(part_params, log):
    place_pinMark = True  ##default =True used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)

    FreeCAD.Console.PrintMessage('\n\n##############  ' +
                                 part_params['code_metric'] +
                                 '  ###############\n')
    dim_params = part_params[
        'param_nominal'] if use_nominal_size else part_params['param_max']
    if dim_params == None:
        if show_all:
            if use_nominal_size:
                dim_params = part_params['param_max']
            else:
                dim_params = part_params['param_nominal']
    if dim_params == None:
        FreeCAD.Console.PrintMessage(
            'No params found for current variant. Skipped\n')
        return

    ModelName = model_name_format_str.format(
        prefix=model_name_prefix,
        code_metric=part_params['code_metric'],
        code_letter=part_params['code_letter'],
        old_name=part_params['modelName_old'],
        maui_name=part_params['modelName_maui'])
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedModelName)
    body, pins, mark = make_tantalum(dim_params)

    show(body)
    show(pins)
    show(mark)

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pins_color)
    Color_Objects(Gui, objs[2], mark_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_mark = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key,
        col_mark[:-1]: mark_color_key
    }
    #expVRML.say(material_substitutions)
    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    if (color_pin_mark == True) and (place_pinMark == True):
        CutObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                        objs[2].Name)
    else:
        #removing pinMark
        App.getDocument(doc.Name).removeObject(objs[2].Name)
    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = CheckedModelName
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedModelName
    restore_Main_Tools()
    #rotate if required
    if (rotation != 0):
        rot = rotation
        z_RotateObject(doc, rot)
    #out_dir=destination_dir+all_params[variant].dest_dir_prefix+'/'
    script_dir = os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + ModelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    saveFCdoc(App, Gui, doc, ModelName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model == False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model == True:
        doc = FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model == True:
        step_path = out_dir + '/' + ModelName + ".step"
        runGeometryCheck(App,
                         Gui,
                         step_path,
                         log,
                         ModelName,
                         save_memory=save_memory)
Exemplo n.º 45
0
def make_3D_model(models_dir, variant):

    LIST_license = [
        "",
    ]
    modelName = all_params[variant].modelName

    CheckedmodelName = modelName.replace('.', '').replace('-', '_').replace(
        '(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedmodelName)
    App.setActiveDocument(CheckedmodelName)
    Gui.ActiveDocument = Gui.getDocument(CheckedmodelName)

    case = make_case(all_params[variant])
    casetop = make_case_top(all_params[variant])

    if (all_params[variant].pintype == CASE_THT_TYPE):
        pins = make_pins_tht(all_params[variant])

    if (all_params[variant].pintype == CASE_THT_N_TYPE):
        pins = make_pins_tht_n(all_params[variant])

    if (all_params[variant].pintype == CASE_SMD_TYPE):
        pins = make_pins_smd(all_params[variant])

    show(case)
    show(casetop)
    show(pins)
    #show(pinmark)
    #stop
    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    body_color_key = all_params[variant].body_color_key
    body_top_color_key = all_params[variant].body_top_color_key
    pin_color_key = all_params[variant].pin_color_key

    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    body_top_color = shaderColors.named_colors[
        body_top_color_key].getDiffuseFloat()
    pin_color = shaderColors.named_colors[pin_color_key].getDiffuseFloat()

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], body_top_color)
    Color_Objects(Gui, objs[2], pin_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_body_top = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]

    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_body_top[:-1]: body_top_color_key,
        col_pin[:-1]: pin_color_key
    }

    expVRML.say(material_substitutions)
    while len(objs) > 1:
        FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name,
                         objs[1].Name)
        del objs
        objs = GetListOfObjects(FreeCAD, doc)
    doc.Label = CheckedmodelName

    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = CheckedmodelName
    restore_Main_Tools()

    script_dir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    exportSTEP(doc, modelName, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', modelName+".step", LIST_license,\
           STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,modelName,scale,out_dir)
    del objs
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + modelName + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    #expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys)# , LIST_license
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)
    #scale=0.3937001
    #exportVRML(doc,modelName,scale,out_dir)
    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, modelName, out_dir)
    #display BBox
    Gui.activateWorkbench("PartWorkbench")
    Gui.SendMsgToActiveView("ViewFit")
    Gui.activeDocument().activeView().viewAxometric()
def export_one_part(module, params, configuration, log):
    series_definition = module.series_params

    if module.LICENCE_Info.LIST_license[0] == "":
        LIST_license = L.LIST_int_license
        LIST_license.append("")
    else:
        LIST_license = module.LICENCE_Info.LIST_license

    LIST_license[0] = "Copyright (C) " + datetime.now().strftime(
        "%Y") + ", " + module.LICENCE_Info.STR_licAuthor

    lib_name = configuration['lib_name_format_string'].format(
        suffix=lib_suffix)

    FileName = module.getName(params, configuration)
    ModelName = FileName.replace('.',
                                 '').replace('-',
                                             '_').replace('(',
                                                          '').replace(')', '')

    FreeCAD.Console.PrintMessage('\r\n' + FileName + '\r\n')
    #FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    print(Newdoc.Label)
    App.setActiveDocument(ModelName)
    App.ActiveDocument = App.getDocument(ModelName)
    Gui.ActiveDocument = Gui.getDocument(ModelName)

    if hasattr(params, 'color_keys'):
        color_keys = params.color_keys
    else:
        color_keys = series_definition.color_keys
    obj_suffixes = series_definition.obj_suffixes
    colors = [
        shaderColors.named_colors[key].getDiffuseInt() for key in color_keys
    ]

    cq_obj_data = module.generate_part(params)

    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0, )
        show(cq_obj_data[i], color_i)

    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs = GetListOfObjects(FreeCAD, doc)

    for i in range(len(objs)):
        objs[i].Label = ModelName + obj_suffixes[i]

    restore_Main_Tools()

    if stop_after_coloring:
        return

    out_dir = '{:s}{:s}.3dshapes'.format(global_3dpath, lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = color_keys
    export_file_name = out_dir + os.sep + FileName + '.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(
            expVRML.exportObject(freecad_object=objs[i],
                                 shape_color=color_keys[i],
                                 face_colors=None))

    scale = 1 / 2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale,
                                            mesh_deviation)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD,
                                   FreeCADGui,
                                   ModelName,
                                   objs,
                                   keepOriginals=True)
    exportSTEP(doc, FileName, out_dir, fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.\
        format(FileName), LIST_license,
            module.LICENCE_Info.STR_licAuthor,
            module.LICENCE_Info.STR_licEmail,
            module.LICENCE_Info.STR_licOrgSys,
            module.LICENCE_Info.STR_licPreProc)

    FreeCAD.activeDocument().recompute()

    saveFCdoc(App, Gui, doc, FileName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model == False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model == True:
        docu = FreeCAD.ActiveDocument
        FreeCAD.Console.PrintMessage('close document {}\r\n'.format(docu.Name))
        FreeCAD.closeDocument(docu.Name)

    if check_Model == True:
        runGeometryCheck(App,
                         Gui,
                         step_path,
                         log,
                         ModelName,
                         save_memory=save_memory)
def main(arg_model_to_build='AKA',arg_color_pin_mark=True):
    FreeCAD.Console.PrintMessage('\r\nRunning...\r\n')
    model_to_build=arg_model_to_build
    color_pin_mark=arg_color_pin_mark
    global excluded_pins_xmirror
    global excluded_pins_x
## maui     run()
#    ## if (not "modelName" in all_params['AKA']):
#    ##     ModelName = "newModel" # "LQFP64_p05_h12"
#    ## else:
#    ##     ModelName = all_params.modelName
#    color_pin_mark=True
#    if len(sys.argv) < 3:
#        FreeCAD.Console.PrintMessage('No variant name is given! building AKA')
#        model_to_build='AKA'
#    else:
#        model_to_build=sys.argv[2]
#        if len(sys.argv)==4:
#            FreeCAD.Console.PrintMessage(sys.argv[3]+'\r\n')
#            if (sys.argv[3].find('no-pinmark-color')!=-1):
#                color_pin_mark=False
#            else:
#                color_pin_mark=True
#++++++++++++++++++++++++++++++++




#-----------------------

    #FreeCAD.Console.PrintMessage(str(color_pin_mark)+'\r\n')
    #FreeCAD.Console.PrintMessage(str(sys.argv[3].find('no-pinmark-color')))
    
    if model_to_build == "all":
        variants = all_params.keys()
    else:
        variants = [model_to_build]

    for variant in variants:
        if variant == 'SOT23_3' or variant == 'SC70_3':
            excluded_pins_x=(1,) ##used to build sot23-3; sc70 (asimmetrical pins, no pinmark)
            excluded_pins_xmirror=(0,2,)
            place_pinMark=False ##used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)
        elif variant == 'SOT23_5':
            excluded_pins_x=() ##used to build sot23-3; sc70 (asimmetrical pins, no pinmark)
            excluded_pins_xmirror=(1,)
            place_pinMark=False ##used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)
        else:
            excluded_pins_x=() ##no pin excluded
            excluded_pins_xmirror=() ##no pin excluded
            place_pinMark=True ##default =True used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)
        
        FreeCAD.Console.PrintMessage('\r\n'+variant)
        if not variant in all_params:
            print("Parameters for %s doesn't exist in 'all_params', skipping." % variant)
            continue
        ModelName = all_params[variant].modelName
        Newdoc = FreeCAD.newDocument(ModelName)
        App.setActiveDocument(ModelName)
        Gui.ActiveDocument=Gui.getDocument(ModelName)
        case, pins, pinmark = make_gw(all_params[variant])

        color_attr=case_color+(0,)
        show(case, color_attr)
        color_attr=pins_color+(0,)
        show(pins, color_attr)
        color_attr=mark_color+(0,)
        show(pinmark, color_attr)

        doc = FreeCAD.ActiveDocument
        objs=GetListOfObjects(FreeCAD, doc)
        ## objs[0].Label='body'
        ## objs[1].Label='pins'
        ## objs[2].Label='mark'
        ###
        ## print objs[0].Name, objs[1].Name, objs[2].Name

        ## sleep
        #if place_pinMark==True:
        if (color_pin_mark==True) and (place_pinMark==True):
            CutObjs_wColors(FreeCAD, FreeCADGui,
                           doc.Name, objs[0].Name, objs[2].Name)
        else:
            #removing pinMark
            App.getDocument(doc.Name).removeObject(objs[2].Name)
        ###
        #sleep
        del objs
        objs=GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
        doc.Label=ModelName
        objs=GetListOfObjects(FreeCAD, doc)
        objs[0].Label=ModelName
        restore_Main_Tools()
        #rotate if required
        if (all_params[variant].rotation!=0):
            rot= all_params[variant].rotation
            z_RotateObject(doc, rot)
        #out_dir=destination_dir+all_params[variant].dest_dir_prefix+'/'
        script_dir=os.path.dirname(os.path.realpath(__file__))
        out_dir=script_dir+destination_dir+all_params[variant].dest_dir_prefix+'/'
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
        #out_dir="./generated_qfp/"
        # export STEP model
        exportSTEP(doc,ModelName,out_dir)
        # scale and export Vrml model
        scale=0.3937001
        exportVRML(doc,ModelName,scale,out_dir)
        # Save the doc in Native FC format
        saveFCdoc(App, Gui, doc, ModelName,out_dir)
        #display BBox
        FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()
def export_one_part(modul, variant, configuration, log, with_plug=False):
    if not variant in modul.all_params:
        FreeCAD.Console.PrintMessage("Parameters for %s doesn't exist in 'M.all_params', skipping." % variant)
        return
    LIST_license[0] = "Copyright (C) "+datetime.now().strftime("%Y")+", " + STR_licAuthor

    params = modul.all_params[variant]
    series_params = modul.seriesParams
    series = series_params.series_name

    subseries, connector_style = params.series_name.split('-')
    pitch_mpn = '-{:g}'.format(params.pin_pitch)
    if series[0] == 'MSTB':
        pitch_mpn = ''
        if params.pin_pitch == 5.08:
            pitch_mpn = '-5,08'
        elif params.pin_pitch == 7.62:
            pitch_mpn = '-7,62'
    lib_name = configuration['lib_name_format_str'].format(series=series[0], style=series[1], pitch=params.pin_pitch)
    mpn = configuration['mpn_format_string'].format(subseries=subseries, style = connector_style,
        rating=series[1], num_pins=params.num_pins, pitch=pitch_mpn)
    FileName = configuration['fp_name_format_string'].format(man = configuration['manufacturer'],
        series = series[0], mpn = mpn, num_rows = 1,
        num_pins = params.num_pins, pitch = params.pin_pitch,
        orientation = configuration['orientation_str'][1] if params.angled else configuration['orientation_str'][0],
        flanged = configuration['flanged_str'][1] if params.flanged else configuration['flanged_str'][0],
        mount_hole = configuration['mount_hole_str'][1] if params.mount_hole else configuration['mount_hole_str'][0])

    destination_dir=global_3dpath+lib_name
    if with_plug:
        destination_dir += "__with_plug"
    destination_dir+=".3dshapes"

    ModelName = variant
    ModelName = ModelName.replace(".","_")
    Newdoc = FreeCAD.newDocument(ModelName)
    App.setActiveDocument(ModelName)
    App.ActiveDocument=App.getDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)
    #App.setActiveDocument(ModelName)
    #Gui.ActiveDocument=Gui.getDocument(ModelName)
    (pins, body, insert, mount_screw, plug, plug_screws) = modul.generate_part(variant, with_plug)

    color_attr = body_color + (0,)
    show(body, color_attr)

    color_attr = pins_color + (0,)
    show(pins, color_attr)

    if insert is not None:
        color_attr = insert_color + (0,)
        show(insert, color_attr)
    if mount_screw is not None:
        color_attr = screw_color + (0,)
        show(mount_screw, color_attr)
    if plug is not None:
        color_attr = body_color + (0,)
        show(plug, color_attr)

        color_attr = screw_color + (0,)
        show(plug_screws, color_attr)

    doc = FreeCAD.ActiveDocument
    doc.Label=ModelName
    objs=FreeCAD.ActiveDocument.Objects
    FreeCAD.Console.PrintMessage(objs)

    i=0
    objs[i].Label = ModelName + "__body"
    i+=1
    objs[i].Label = ModelName + "__pins"
    i+=1
    if insert is not None:
        objs[i].Label = ModelName + "__thread_insert"
        i+=1
    if mount_screw is not None:
        objs[i].Label = ModelName + "__mount_screw"
        i+=1
    if plug is not None:
        objs[i].Label = ModelName + "__plug"
        i+=1
        objs[i].Label = ModelName + "__plug_screws"
    restore_Main_Tools()

    out_dir=destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = [body_color_key, pins_color_key]
    export_file_name=destination_dir+os.sep+FileName+'.wrl'

    export_objects = []
    i=0
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=body_color_key,
            face_colors=None))
    i+=1
    export_objects.append(expVRML.exportObject(freecad_object = objs[i],
            shape_color=pins_color_key,
            face_colors=None))
    i+=1
    if insert is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=insert_color_key,
                face_colors=None))
        used_color_keys.append(insert_color_key)
        i+=1
    if mount_screw is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=screw_color_key,
                face_colors=None))
        used_color_keys.append(screw_color_key)
        i+=1
    if plug is not None:
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=body_color_key,
                face_colors=None))
        i+=1
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=screw_color_key,
                face_colors=None))
    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     ModelName, objs, keepOriginals=True)

    exportSTEP(doc,FileName,out_dir,fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.format(FileName), LIST_license,\
        STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licPreProc)

    FreeCAD.activeDocument().recompute()
    # FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()


    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, FileName, out_dir)
    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, step_path,
            log, ModelName, save_memory=save_memory)
Exemplo n.º 49
0
def generate_package3d(params, part_params, mpn):

    # License information
    if LICENCE_Info.LIST_license[0] == "":
        LIST_license = add_license.LIST_int_license
    else:
        LIST_license = LICENCE_Info.LIST_license
    LIST_license[0] = "Copyright (C) " + datetime.datetime.now().strftime(
        "%Y") + ", " + LICENCE_Info.STR_licAuthor

    # Build model name
    model_name = "Connector_Wuerth_{series_prefix}_{type}_{rows}x{pins:02d}_P{pitch}_{orientation}_{mpn}".format(
        series_prefix=params['series_prefix'],
        type=params['type'],
        rows=part_params['rows'],
        pins=part_params['pins'] // 2,
        pitch=params['pitch'],
        orientation=params['orientation'],
        mpn=mpn)
    FreeCAD.Console.PrintMessage('\r\nGenerate: ' + model_name + '\r\n')

    # Create new document
    doc = FreeCAD.newDocument("doc")
    App.setActiveDocument("doc")
    App.ActiveDocument = App.getDocument("doc")
    Gui.ActiveDocument = Gui.getDocument("doc")

    # Generate body
    body_color_key = "black body"
    body_color = shaderColors.named_colors[body_color_key].getDiffuseFloat()
    body = generate_body(params, part_params)
    show(body, body_color + (0, ))

    # Generate pins
    pins_color_key = "gold pins"
    pins_color = shaderColors.named_colors[pins_color_key].getDiffuseFloat()
    pins = generate_pins(params, part_params)
    show(pins, pins_color + (0, ))

    # Finalize
    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)
    restore_Main_Tools()
    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key
    }
    expVRML.say(material_substitutions)

    # Create output directory
    output_dir = 'Connector_Wuerth_{series_prefix}_Bottom-Entry.3dshapes/'.format(
        series_prefix=params['series_prefix'])
    if not os.path.isdir(output_dir):
        os.makedirs(output_dir)
    filename = '{output_dir:s}{model_name:s}.wrl'.format(output_dir=output_dir,
                                                         model_name=model_name)

    # Export wrl file
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, 1 / 2.54)
    expVRML.writeVRMLFile(colored_meshes, filename, used_color_keys,
                          LIST_license)

    # Export step file
    exportSTEP(doc, model_name, output_dir, objs[0])
    add_license.addLicenseToStep(
        output_dir, '{model_name}.step'.format(model_name=model_name),
        LIST_license, LICENCE_Info.STR_licAuthor, LICENCE_Info.STR_licEmail,
        LICENCE_Info.STR_licOrgSys, LICENCE_Info.STR_licPreProc)

    # Force recompute
    FreeCAD.activeDocument().recompute()

    # Save FCStd document
    saveFCdoc(App, Gui, doc, model_name, output_dir)

    # Close document
    doc = FreeCAD.ActiveDocument
    FreeCAD.closeDocument(doc.Name)
def main(arg_model_to_build):
    FreeCAD.Console.PrintMessage('\r\nRunning...\r\n')
    model_to_build=arg_model_to_build

    if model_to_build == "all":
        variants = all_params.keys()
        FreeCAD.Console.PrintMessage(variants)
        FreeCAD.Console.PrintMessage('\r\n')
    else:
        variants = [model_to_build]
    for variant in variants:
        FreeCAD.Console.PrintMessage('\r\n'+variant)
        if not variant in all_params:
            print("Parameters for %s doesn't exist in 'all_params', skipping." % variant)
            continue
        ModelName = all_params[variant].modelName
        Newdoc = FreeCAD.newDocument(ModelName)
        App.setActiveDocument(ModelName)
        Gui.ActiveDocument=Gui.getDocument(ModelName)
        case, top, pins = make_chip(all_params[variant])
        color_attr=case_color+(0,)
        show(case, color_attr)
        #FreeCAD.Console.PrintMessage(pins_color)

        color_attr=top_color+(0,)
        show(top, color_attr)

        color_attr=pins_color+(0,)
        #FreeCAD.Console.PrintMessage(color_attr)
        show(pins, color_attr)
        doc = FreeCAD.ActiveDocument
        objs=GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
        doc = FreeCAD.ActiveDocument
        objs=GetListOfObjects(FreeCAD, doc)
        objs[1].Label="Fusion2"
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
        doc.Label=ModelName
        objs=GetListOfObjects(FreeCAD, doc)
        objs[0].Label=ModelName
        restore_Main_Tools()
        #rotate if required
        if (all_params[variant].rotation!=0):
            rot= all_params[variant].rotation
            z_RotateObject(doc, rot)
        script_dir=os.path.dirname(os.path.realpath(__file__))
        out_dir=script_dir+destination_dir
        if not os.path.exists(out_dir):
            os.makedirs(out_dir)
            #out_dir="./generated_qfp/"
        # export STEP model
        exportSTEP(doc,ModelName,out_dir)

        # scale and export Vrml model
        scale=0.3937001
        exportVRML(doc,ModelName,scale,out_dir)

        # Save the doc in Native FC format
        saveFCdoc(App, Gui, doc, ModelName,out_dir)
        #display BBox

        FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
def generateOneModel(params, log):
    excluded_pins_x=() ##no pin excluded
    excluded_pins_xmirror=() ##no pin excluded
    place_pinMark=True ##default =True used to exclude pin mark to build sot23-3; sot23-5; sc70 (asimmetrical pins, no pinmark)


    ModelName = params.modelName
    FreeCAD.Console.PrintMessage(
        '\n\n##############  ' +
        ModelName +
        '  ###############\n')
    CheckedModelName = ModelName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')
    Newdoc = App.newDocument(CheckedModelName)
    App.setActiveDocument(CheckedModelName)
    Gui.ActiveDocument=Gui.getDocument(CheckedModelName)
    #case, pins, pinmark = make_case(params)
    case_bot, case, pins, pinmark = make_case(params)

    if case_bot is not None:
        show(case_bot)
    show(case)
    show(pins)
    show(pinmark)
    #stop

    doc = FreeCAD.ActiveDocument
    objs=GetListOfObjects(FreeCAD, doc)

    if case_bot is not None:
        Color_Objects(Gui,objs[0],body_bot_color)
        Color_Objects(Gui,objs[1],body_color)
        Color_Objects(Gui,objs[2],pins_color)
        Color_Objects(Gui,objs[3],marking_color)

        col_body_bot=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
        col_body=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
        col_pin=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
        col_mark=Gui.ActiveDocument.getObject(objs[3].Name).DiffuseColor[0]
        material_substitutions={
            col_body_bot[:-1]:body_bot_color_key,
            col_body[:-1]:body_color_key,
            col_pin[:-1]:pins_color_key,
            col_mark[:-1]:marking_color_key
        }
        expVRML.say(material_substitutions)
        if (color_pin_mark==True) and (place_pinMark==True):
            CutObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[1].Name, objs[3].Name)
        else:
            #removing pinMark
            App.getDocument(doc.Name).removeObject(objs[3].Name)
        ###
        #sleep
        del objs
        objs=GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
        objs=GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
    else:
        Color_Objects(Gui,objs[0],body_color)
        Color_Objects(Gui,objs[1],pins_color)
        Color_Objects(Gui,objs[2],marking_color)

        col_body=Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
        col_pin=Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
        col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
        material_substitutions={
            col_body[:-1]:body_color_key,
            col_pin[:-1]:pins_color_key,
            col_mark[:-1]:marking_color_key
        }
        #expVRML.say(material_substitutions)
        if (color_pin_mark==True) and (place_pinMark==True):
            CutObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[2].Name)
        else:
            #removing pinMark
            App.getDocument(doc.Name).removeObject(objs[2].Name)
        ###
        #sleep
        del objs
        objs=GetListOfObjects(FreeCAD, doc)
        FuseObjs_wColors(FreeCAD, FreeCADGui,
                        doc.Name, objs[0].Name, objs[1].Name)
    ## objs[0].Label='body'
    ## objs[1].Label='pins'
    ## objs[2].Label='mark'
    ###
    ## print objs[0].Name, objs[1].Name, objs[2].Name

    ## sleep
    doc.Label=CheckedModelName
    objs=GetListOfObjects(FreeCAD, doc)
    objs[0].Label=CheckedModelName
    restore_Main_Tools()
    #rotate if required
    if (params.rotation!=0):
        rot= params.rotation
        z_RotateObject(doc, rot)
    #out_dir=destination_dir+params.dest_dir_prefix+'/'
    script_dir=os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    #expVRML.say(models_dir)
    if len(params.dest_dir_prefix)>=1:
        out_dir=models_dir+destination_dir+os.sep+params.dest_dir_prefix
    else:
        out_dir=models_dir+destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)
    #out_dir="./generated_qfp/"
    # export STEP model
    exportSTEP(doc, ModelName, out_dir)
    global LIST_license
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', ModelName+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale=1/2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs=GetListOfObjects(FreeCAD, doc)

    export_objects, used_color_keys = expVRML.determineColors(Gui, objs, material_substitutions)
    export_file_name=out_dir+os.sep+ModelName+'.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    #expVRML.writeVRMLFile added creaeAngle
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license, 0.9)
    # Save the doc in Native FC format
    #saveFCdoc(App, Gui, doc, ModelName,out_dir)
    #display BBox
    #FreeCADGui.ActiveDocument.getObject("Part__Feature").BoundingBox = True
    if footprints_dir is not None and os.path.isdir(footprints_dir) and not save_memory and not check_Model: #it doesn't make sense to import the footprint right before we close the file.
        #expVRML.say (ModelName)
        #stop
        sys.argv = ["fc", "dummy", footprints_dir+os.sep+ModelName, "savememory"]
        #setup = get_setup_file()  # << You need the parentheses
        expVRML.say(sys.argv[2])
        if not ksu_present:
            try:
                import kicadStepUptools
                ksu_present=True
                expVRML.say("ksu present!")
                kicadStepUptools.KSUWidget.close()
                #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
                #kicadStepUptools.KSUWidget.destroy()
                #for i in QtGui.qApp.topLevelWidgets():
                #    if i.objectName() == "kicadStepUp":
                #        i.deleteLater()
                kicadStepUptools.KSUWidget.close()
            except:
                ksu_present=False
                expVRML.say("ksu not present")
        else:
            kicadStepUptools.KSUWidget.close()
            reload(kicadStepUptools)
            kicadStepUptools.KSUWidget.close()
            #kicadStepUptools.KSUWidget.setWindowState(QtCore.Qt.WindowMinimized)
            #kicadStepUptools.KSUWidget.destroy()

    #FreeCADGui.insert(u"C:\Temp\FCAD_sg\QFN_packages\QFN-12-1EP_3x3mm_Pitch0_5mm.kicad_mod")
    #FreeCADGui.insert(script_dir+os.sep+"ModelName.kicad_mod")
    if save_memory == False:
        Gui.activateWorkbench("PartWorkbench")
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewBottom()
        #Gui.activeDocument().activeView().viewAxometric()
    saveFCdoc(App, Gui, doc, ModelName,out_dir)

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        print("closing: {}".format(doc.Name))
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        step_path = out_dir + '/' + ModelName + ".step"
        runGeometryCheck(App, Gui, step_path,
            log, ModelName, save_memory=save_memory)
def export_one_part(module, params, configuration, log):
    series_definition = module.series_params

    if module.LICENCE_Info.LIST_license[0]=="":
        LIST_license=L.LIST_int_license
        LIST_license.append("")
    else:
        LIST_license=module.LICENCE_Info.LIST_license

    LIST_license[0] = "Copyright (C) "+datetime.now().strftime("%Y")+", " + module.LICENCE_Info.STR_licAuthor

    lib_name = configuration['lib_name_format_string'].format(suffix=lib_suffix)


    FileName = module.getName(params, configuration)
    ModelName = FileName.replace('.', '').replace('-', '_').replace('(', '').replace(')', '')

    FreeCAD.Console.PrintMessage('\r\n'+FileName+'\r\n')
    #FileName = modul.all_params[variant].file_name
    Newdoc = FreeCAD.newDocument(ModelName)
    print(Newdoc.Label)
    App.setActiveDocument(ModelName)
    App.ActiveDocument=App.getDocument(ModelName)
    Gui.ActiveDocument=Gui.getDocument(ModelName)

    if hasattr(params, 'color_keys'):
        color_keys = params.color_keys
    else:
        color_keys = series_definition.color_keys
    obj_suffixes = series_definition.obj_suffixes
    colors = [shaderColors.named_colors[key].getDiffuseInt() for key in color_keys]

    cq_obj_data = module.generate_part(params)


    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0,)
        show(cq_obj_data[i], color_i)


    doc = FreeCAD.ActiveDocument
    doc.Label = ModelName
    objs=GetListOfObjects(FreeCAD, doc)


    for i in range(len(objs)):
        objs[i].Label = ModelName + obj_suffixes[i]


    restore_Main_Tools()

    if stop_after_coloring:
        return

    out_dir='{:s}{:s}.3dshapes'.format(global_3dpath, lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    used_color_keys = color_keys
    export_file_name=out_dir+os.sep+FileName+'.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=color_keys[i],
                face_colors=None))

    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale, mesh_deviation)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     ModelName, objs, keepOriginals=True)
    exportSTEP(doc,FileName,out_dir,fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=FileName)

    L.addLicenseToStep(out_dir, '{:s}.step'.\
        format(FileName), LIST_license,
            module.LICENCE_Info.STR_licAuthor,
            module.LICENCE_Info.STR_licEmail,
            module.LICENCE_Info.STR_licOrgSys,
            module.LICENCE_Info.STR_licPreProc)

    FreeCAD.activeDocument().recompute()

    saveFCdoc(App, Gui, doc, FileName, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        docu = FreeCAD.ActiveDocument
        FreeCAD.Console.PrintMessage('close document {}\r\n'.format(docu.Name))
        FreeCAD.closeDocument(docu.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, step_path,
            log, ModelName, save_memory=save_memory)
Exemplo n.º 53
0
def MakeHeader(n):

    global LIST_license, docname
    name = HeaderName(n)

    destination_dir = "/Box_Headers"

    full_path = os.path.realpath(__file__)
    expVRML.say(full_path)
    scriptdir = os.path.dirname(os.path.realpath(__file__))
    expVRML.say(scriptdir)
    sub_path = full_path.split(scriptdir)
    expVRML.say(sub_path)
    sub_dir_name = full_path.split(os.sep)[-2]
    expVRML.say(sub_dir_name)
    sub_path = full_path.split(sub_dir_name)[0]
    expVRML.say(sub_path)
    models_dir = sub_path + "_3Dmodels"
    script_dir = os.path.dirname(os.path.realpath(__file__))
    #models_dir=script_dir+"/../_3Dmodels"
    expVRML.say(models_dir)
    out_dir = models_dir + destination_dir
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' character in the model name REALLY messes with things.
    docname = name.replace(".", "")

    newdoc = App.newDocument(docname)
    App.setActiveDocument(docname)
    a_doc = Gui.ActiveDocument
    Gui.ActiveDocument = Gui.getDocument(docname)

    pins = MakePinRow(n)
    pins = pins.union(MakePinRow(n).translate((0, 2.54, 0)))

    base = MakeBase(n)

    ##assign some colors
    #base_color = (50,50,50)
    #pins_color = (225,175,0)
    #
    #show(base,base_color+(0,))
    #show(pins,pins_color+(0,))
    show(base)
    show(pins)

    doc = FreeCAD.ActiveDocument
    objs = GetListOfObjects(FreeCAD, doc)

    Color_Objects(Gui, objs[0], body_color)
    Color_Objects(Gui, objs[1], pins_color)
    #Color_Objects(Gui,objs[2],marking_color)

    col_body = Gui.ActiveDocument.getObject(objs[0].Name).DiffuseColor[0]
    col_pin = Gui.ActiveDocument.getObject(objs[1].Name).DiffuseColor[0]
    #col_mark=Gui.ActiveDocument.getObject(objs[2].Name).DiffuseColor[0]
    material_substitutions = {
        col_body[:-1]: body_color_key,
        col_pin[:-1]: pins_color_key,
        #col_mark[:-1]:marking_color_key
    }
    expVRML.say(material_substitutions)

    #objs=GetListOfObjects(FreeCAD, doc)
    FuseObjs_wColors(FreeCAD, FreeCADGui, doc.Name, objs[0].Name, objs[1].Name)
    doc.Label = docname
    objs = GetListOfObjects(FreeCAD, doc)
    objs[0].Label = docname
    restore_Main_Tools()

    #out_dir = "./generated_pinheaders/"

    doc.Label = docname

    #save the STEP file
    exportSTEP(doc, name, out_dir)
    if LIST_license[0] == "":
        LIST_license = Lic.LIST_int_license
        LIST_license.append("")
    Lic.addLicenseToStep(out_dir+'/', name+".step", LIST_license,\
                       STR_licAuthor, STR_licEmail, STR_licOrgSys, STR_licOrg, STR_licPreProc)

    # scale and export Vrml model
    scale = 1 / 2.54
    #exportVRML(doc,ModelName,scale,out_dir)
    objs = GetListOfObjects(FreeCAD, doc)
    expVRML.say(
        "######################################################################"
    )
    expVRML.say(objs)
    expVRML.say(
        "######################################################################"
    )
    export_objects, used_color_keys = expVRML.determineColors(
        Gui, objs, material_substitutions)
    export_file_name = out_dir + os.sep + name + '.wrl'
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects, scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys,
                          LIST_license)

    ###save the VRML file
    ##scale=0.3937001
    ##exportVRML(doc,name,scale,out_dir)

    # Save the doc in Native FC format
    saveFCdoc(App, Gui, doc, name, out_dir)

    if close_doc != True:  # avoid operations for memory leak
        Gui.SendMsgToActiveView("ViewFit")
        Gui.activeDocument().activeView().viewAxometric()

    return 0
def MakeHeader(n, isAngled, log, highDetail=False):
    global LIST_license
    if LIST_license[0]=="":
        LIST_license=Lic.LIST_int_license
        LIST_license.append("")

    LIST_license[0] = "Copyright (C) "+datetime.now().strftime("%Y")+", " + STR_licAuthor

    name = HeaderName(n, isAngled)
    print('\n############ ' + name + ' #############\n')

    lib_name='Connector_IDC'


    full_path=os.path.realpath(__file__)
    sub_dir_name =full_path.split(os.sep)[-2]
    sub_path = full_path.split(sub_dir_name)[0]
    models_dir=sub_path+"_3Dmodels"+os.sep
    #models_dir=script_dir+"/../_3Dmodels"

    out_dir=models_dir+'{:s}.3dshapes'.format(lib_name)
    if not os.path.exists(out_dir):
        os.makedirs(out_dir)

    #having a period '.' or '-' character in the model name REALLY messes with things.
    docname = name.replace(".","").replace("-","_").replace('(', '').replace(')', '')

    Newdoc = FreeCAD.newDocument(docname)
    App.setActiveDocument(docname)
    App.ActiveDocument=App.getDocument(docname)
    Gui.ActiveDocument=Gui.getDocument(docname)

    base = MakeBase(n, highDetail)

    if (isAngled):
        pins = MakeAnglePinRow(n, -3, 5.94, 12.38, highDetail)
        pins = pins.union(MakeAnglePinRow(n, -3, 3.40, 9.84, highDetail).translate((2.54,0,0)))
        # rotate the base into the angled position
        base = base.rotate((0,0,0),(0,1,0),90).translate((4.13,0,5.94))
    else:
        pins = MakePinRow(n, -3.0, 8.0)
        pins = pins.union(MakePinRow(n, -3.0, 8.0).translate((2.54,0,0)))


    colors = [shaderColors.named_colors[key].getDiffuseInt() for key in color_keys]

    cq_obj_data = [base, pins]
    obj_suffixes = ['__base', '__pins']


    for i in range(len(cq_obj_data)):
        color_i = colors[i] + (0,)
        show(cq_obj_data[i], color_i)


    doc = FreeCAD.ActiveDocument
    doc.Label = docname
    objs=GetListOfObjects(FreeCAD, doc)

    for i in range(len(objs)):
        objs[i].Label = docname + obj_suffixes[i]

    restore_Main_Tools()

    used_color_keys = color_keys
    export_file_name=out_dir+os.sep+name+'.wrl'

    export_objects = []
    for i in range(len(objs)):
        export_objects.append(expVRML.exportObject(freecad_object = objs[i],
                shape_color=color_keys[i],
                face_colors=None))

    scale=1/2.54
    colored_meshes = expVRML.getColoredMesh(Gui, export_objects , scale)
    expVRML.writeVRMLFile(colored_meshes, export_file_name, used_color_keys, LIST_license)

    fusion = multiFuseObjs_wColors(FreeCAD, FreeCADGui,
                     doc.Label, objs, keepOriginals=True)
    exportSTEP(doc,name,out_dir,fusion)

    step_path = '{dir:s}/{name:s}.step'.format(dir=out_dir, name=name)

    Lic.addLicenseToStep(out_dir, '{:s}.step'.\
        format(name), LIST_license,
            STR_licAuthor,
            STR_licEmail,
            STR_licOrgSys,
            STR_licPreProc)

    FreeCAD.activeDocument().recompute()
    print("Safe to: {}".format(out_dir))
    saveFCdoc(App, Gui, doc, name, out_dir)

    #FreeCADGui.activateWorkbench("PartWorkbench")
    if save_memory == False and check_Model==False:
        FreeCADGui.SendMsgToActiveView("ViewFit")
        FreeCADGui.activeDocument().activeView().viewAxometric()

    if save_memory == True or check_Model==True:
        doc=FreeCAD.ActiveDocument
        print("closing: {}".format(doc.Name))
        FreeCAD.closeDocument(doc.Name)

    if check_Model==True:
        runGeometryCheck(App, Gui, step_path,
            log, name, save_memory=save_memory)