Ejemplo n.º 1
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())
      
    try:         
        Number_of_Edges, Edge_List = m_sel.get_segmentsNames(
            getfrom=["Segments","Curves"])
        if WF.verbose() != 0:
            print_msg("Number_of_Edges = " + str(Number_of_Edges))
            print_msg("Edge_List = " + str(Edge_List))
             
        Number_of_Planes, Plane_List = m_sel.get_planesNames(
            getfrom=["Planes","Objects"])
        if WF.verbose() != 0:      
            print_msg("Number_of_Planes = " + str(Number_of_Planes))
            print_msg("Plane_List = " + str(Plane_List))
            
        if Number_of_Edges == 0 or Number_of_Planes == 0 :
            raise Exception(m_exception_msg)
        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir  = "Set"   
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            if Number_of_Edges > 1 or Number_of_Planes > 1:
                try:
                    m_ob = App.ActiveDocument.getObject(str(m_main_dir)).newObject("App::DocumentObjectGroup", str(m_sub_dir))
                    m_group = m_actDoc.getObject( str(m_ob.Label) )
                except:
                    printError_msg("Could not Create '"+ str(m_sub_dir) +"' Objects Group!")           
                        
            if WF.verbose() != 0:
                print_msg("Group = " + str(m_group.Label))
                
            for i in range( Number_of_Edges ):
                edge = Edge_List[i]
                if WF.verbose() != 0:
                    print_msg("edge = " + str(edge))
                
                for j in range( Number_of_Planes ):
                    plane = Plane_List[j]
                    if WF.verbose() != 0:
                        print_msg("plane = " + str(plane))
                                  
                    App.ActiveDocument.openTransaction("Macro LineFacePoint")
                    selfobj = makeLineFacePointFeature(m_group) 
                    selfobj.Edge           = edge  
                    selfobj.Face           = plane
                    selfobj.Proxy.execute(selfobj)                   
                                                   
        finally:
            App.ActiveDocument.commitTransaction()
            
        

            
    except Exception as err:
        printError_msg(err.message, title="Macro LineFacePoint")
Ejemplo n.º 2
0
def run():
    m_sel, m_act_doc = getSel(WF.verbose())

    try:
        Number_of_Planes, Plane_List = m_sel.get_planesNames(
            getfrom=["Planes", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Planes = " + str(Number_of_Planes))
            print_msg("Plane_List = " + str(Plane_List))

        if Number_of_Planes == 0:
            raise Exception(M_EXCEPTION_MSG)
        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if Number_of_Planes > 1:
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_act_doc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=M_MACRO)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            for i in range(Number_of_Planes):
                plane = Plane_List[i]
                App.ActiveDocument.openTransaction(M_MACRO)
                selfobj = makeCenterFacePointFeature(m_group)
                selfobj.Face = plane
                selfobj.Proxy.execute(selfobj)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=M_MACRO)
Ejemplo n.º 3
0
def run():
    m_sel, _ = getSel(WF.verbose())

    try:
        number_of_edges, edge_list = m_sel.get_segmentsNames(
            getfrom=["Segments", "Curves", "Planes", "Objects"])
        number_of_vertexes, vertex_list = m_sel.get_pointsNames(
            getfrom=["Points", "Curves", "Objects"])

        if WF.verbose() != 0:
            print_msg("number_of_edges = " + str(number_of_edges))
            print_msg("edge_list = " + str(edge_list))
            print_msg("number_of_vertexes = " + str(number_of_vertexes))
            print_msg("vertex_list = " + str(vertex_list))

        if number_of_edges < 1:
            raise Exception(M_EXCEPTION_MSG)
        if number_of_vertexes < 1:
            raise Exception(M_EXCEPTION_MSG)
        try:
            m_main_dir = "WorkPlanes_P"
            m_sub_dir = "Set"
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            # To develop

            if WF.verbose() != 0:
                print_msg("Group = " + str(m_group.Label))

            edge = edge_list[0]
            vertex = vertex_list[0]

            App.ActiveDocument.openTransaction(
                "Macro PerpendicularLinePointPlane")
            selfobj = makePerpendicularLinePointPlaneFeature(m_group)
            selfobj.Edge = edge
            selfobj.Point = vertex
            selfobj.Extension = m_extension
            selfobj.Proxy.execute(selfobj)

        finally:
            App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title="Macro PerpendicularLinePointPlane")
Ejemplo n.º 4
0
def n_points_point_comand():
    m_sel, _ = getSel(WF.verbose())

    points_from = ["Points", "Curves", "Planes", "Shells", "Objects"]
    try:
        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_vertexes < 2:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))

            points = []
            # Case of only 2 points
            if number_of_vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = vertex_list[0]
                vertex2 = vertex_list[1]
                points.append(vertex1)
                points.append(vertex2)

                buildFromPoints(M_MACRO, m_group, points)

            # Case of more than 2 points
            else:
                if WF.verbose():
                    print_msg("Process more than 2 points")
                for i in range(number_of_vertexes):
                    vertex1 = vertex_list[i]
                    points.append(vertex1)

                buildFromPoints(M_MACRO, m_group, points)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 5
0
def line_point_plane_command():
    """ This command use the selected object(s) to try to build a
    LinePointPlane feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    edges_from = ["Segments", "Curves", "Planes", "Objects"]
    points_from = ["Points", "Curves", "Objects"]
    try:
        number_of_edges, edge_list = m_sel.get_segmentsWithNames(
            get_from=edges_from)
        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_edges < 1:
            raise Exception(M_EXCEPTION_MSG)
        if number_of_vertexes < 1:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkPlanes_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            # To develop

            # Case of only 1 point and 1 Edge
            if number_of_edges == 1 and number_of_vertexes == 1:
                edge = edge_list[0]
                vertex = vertex_list[0]

                buildFromPointAndLine(M_MACRO, m_group, vertex, edge,
                                      M_PLANE_EXT)
            else:
                raise Exception(M_EXCEPTION_MSG)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 6
0
def run():
    m_sel, m_act_doc = getSel(WF.verbose())
      
    try: 
        Number_of_Curves, Curve_List = m_sel.get_curvesNames(
            getfrom=["Points","Segments","Curves","Planes","Objects"])
        if WF.verbose() != 0:        
            print_msg("Number_of_Curves = " + str(Number_of_Curves))
            print_msg("Curve_List = " + str(Curve_List))
            
        if Number_of_Curves == 0:
            raise Exception(M_EXCEPTION_MSG)
        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir  = "Set"   
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            if Number_of_Curves > 1 :
                try:
                    m_ob = App.ActiveDocument.getObject(str(m_main_dir)).newObject("App::DocumentObjectGroup", str(m_sub_dir))
                    m_group = m_act_doc.getObject( str(m_ob.Label) )
                except:
                    printError_msg("Could not Create '"+ str(m_sub_dir) +"' Objects Group!")           
            
            if WF.verbose() != 0:
                print_msg("Group = " + str(m_group.Label))
                          
            for i in range( Number_of_Curves ):
                edge = Curve_List[i]            
                App.ActiveDocument.openTransaction("Macro CenterCirclePoint")
                selfobj = makeCenterCirclePointFeature(m_group)    
                selfobj.Edge           = edge
                selfobj.Proxy.execute(selfobj)                   
                                                   
        finally:
            App.ActiveDocument.commitTransaction()
   
    except Exception as err:
        printError_msg(err.args[0], title="Macro CenterCirclePoint")
Ejemplo n.º 7
0
def three_points_plane_command():
    """ This command use the selected object(s) to try to build a
    ThreePointsPlane feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    points_from = ["Points", "Curves", "Objects"]
    try:
        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_vertexes < 3:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkPlanes_P"
            m_sub_dir = "Set000"
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            if number_of_vertexes > 6:
                m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

            # Case of only 3 points
            if number_of_vertexes == 3:
                buildFromThreePoints(M_MACRO, m_group, vertex_list,
                                     M_PLANE_EXT)
            else:
                raise Exception(M_EXCEPTION_MSG)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 8
0
def extrema_line_point_command():
    """ This command use the selected object(s) to try to build a
    ExtremaLinePoint feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    edges_from = ["Segments", "Curves", "Planes", "Shells", "Objects"]
    try:
        number_of_edges, edge_list = m_sel.get_segmentsWithNames(
            get_from=edges_from)

        if number_of_edges == 0:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set000"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            if WF.verbose():
                print_msg("Location = " + str(M_LOCATION))

            # Create a sub group if needed
            if number_of_edges > 1 or M_LOCATION == "Both ends":
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_act_doc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=M_MACRO)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            for i in range(number_of_edges):
                edge = edge_list[i]

                if M_LOCATION in ["Begin", "Both ends"]:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj1 = makeExtremaLinePointFeature(m_group)
                    selfobj1.Edge = edge
                    selfobj1.At = "Begin"
                    selfobj1.Proxy.execute(selfobj1)
                    if str(selfobj1.Parametric) == 'Interactive':
                        selfobj1.Parametric = 'Dynamic'
                        selfobj1.touch()
                        selfobj1.Parametric = 'Interactive'
                    if str(selfobj1.Parametric) == 'Not':
                        selfobj1.Parametric = 'Dynamic'
                        selfobj1.touch()
                        selfobj1.Parametric = 'Not'
                if M_LOCATION in ["End", "Both ends"]:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj2 = makeExtremaLinePointFeature(m_group)
                    selfobj2.Edge = edge
                    selfobj2.At = "End"
                    selfobj2.Proxy.execute(selfobj2)
                    if str(selfobj2.Parametric) == 'Interactive':
                        selfobj2.Parametric = 'Dynamic'
                        selfobj2.touch()
                        selfobj2.Parametric = 'Interactive'
                    if str(selfobj2.Parametric) == 'Not':
                        selfobj2.Parametric = 'Dynamic'
                        selfobj2.touch()
                        selfobj2.Parametric = 'Not'

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 9
0
def center_line_point_command():
    """ This command use the selected object(s) to try to build a
    CenterLinePoint feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    edges_from = ["Segments", "Curves", "Planes", "Shells", "Objects"]
    points_from = ["Points"]
    try:
        number_of_edges, edge_list = m_sel.get_segmentsWithNames(
            get_from=edges_from)
        # number_of_edges, edge_list = m_sel.get_segmentsWithIndex(getfrom=edges_from)

        if number_of_edges == 0:
            # Try to get Edges from points
            number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
                get_from=points_from)

        if number_of_edges == 0 and number_of_vertexes < 2:
            raise Exception(M_EXCEPTION_MSG)

        try:
            if WF.verbose():
                print_msg("Location = " + str(M_LOCATION))

            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set000"
            m_group = createFolders(str(m_main_dir))

            # From Edges
            if number_of_edges != 0:
                # Create a sub group if needed
                if number_of_edges > 1 or M_LOCATION != "Single":
                    m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

                for i in range(number_of_edges):
                    m_edge = edge_list[i]

                    # Check if first point and last point of edge is not the
                    # same
                    vector_a = m_edge[0].Shape.Edges[0].Vertexes[0].Point
                    vector_b = m_edge[0].Shape.Edges[0].Vertexes[-1].Point
                    if isEqualVectors(vector_a, vector_b):
                        continue

                    if M_LOCATION == "Single":
                        buildFromEdge(M_MACRO,
                                      m_group,
                                      m_edge, M_NUMBERLINEPART, M_INDEXPART)
                    else:
                        for m_i_part in range(M_NUMBERLINEPART + 1):
                            buildFromEdge(M_MACRO,
                                          m_group,
                                          m_edge, M_NUMBERLINEPART, m_i_part)

            # From Vertexes
            else:
                if number_of_vertexes > 2:
                    m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

                # Even number of vertexes
                if number_of_vertexes % 2 == 0:
                    if WF.verbose():
                        print_msg("Even number of points")

                    if number_of_vertexes == 2:
                        vertex1 = vertex_list[0]
                        vertex2 = vertex_list[1]

    #                     point1 = vertex1[0].Shape.Vertexes[0].Point
    #                     point2 = vertex2[0].Shape.Vertexes[0].Point
    #                     if isEqualVectors(point1, point2):
    #                         return

                        if M_LOCATION == "Single":
                            buildFromPoints(M_MACRO,
                                            m_group,
                                            (vertex1, vertex2),
                                            M_NUMBERLINEPART, M_INDEXPART)
                        else:
                            for m_i_part in range(M_NUMBERLINEPART + 1):
                                buildFromPoints(M_MACRO,
                                                m_group,
                                                (vertex1, vertex2),
                                                M_NUMBERLINEPART, m_i_part)
                    else:
                        for i in range(0, number_of_vertexes - 2, 2):
                            vertex1 = vertex_list[i]
                            vertex2 = vertex_list[i + 1]

    #                         point1 = vertex1[0].Shape.Vertexes[0].Point
    #                         point2 = vertex2[0].Shape.Vertexes[0].Point
    #                         if isEqualVectors(point1, point2):
    #                             continue

                            if M_LOCATION == "Single":
                                buildFromPoints(M_MACRO,
                                                m_group,
                                                (vertex1, vertex2),
                                                M_NUMBERLINEPART, M_INDEXPART)
                            else:
                                for m_i_part in range(M_NUMBERLINEPART + 1):
                                    buildFromPoints(M_MACRO,
                                                    m_group,
                                                    (vertex1, vertex2),
                                                    M_NUMBERLINEPART, m_i_part)
                # Odd number of vertexes
                else:
                    if WF.verbose():
                        print_msg("Odd number of points")
                    for i in range(number_of_vertexes - 1):
                        vertex1 = vertex_list[i]
                        vertex2 = vertex_list[i + 1]

                        if M_LOCATION == "Single":
                            buildFromPoints(M_MACRO,
                                            m_group,
                                            (vertex1, vertex2),
                                            M_NUMBERLINEPART, M_INDEXPART)
                        else:
                            for m_i_part in range(M_NUMBERLINEPART + 1):
                                buildFromPoints(M_MACRO,
                                                m_group,
                                                (vertex1, vertex2),
                                                M_NUMBERLINEPART, m_i_part)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 10
0
def two_points_line_command():
    """ This command use the selected object(s) to try to build a
    TwoPointsLine feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    points_from = ["Points", "Curves", "Objects"]
    try:
        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_vertexes < 2:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkAxis_P"
            m_sub_dir = "Set000"
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            if number_of_vertexes > 2:
                m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

            # Case of only 2 points
            if number_of_vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = vertex_list[0]
                vertex2 = vertex_list[1]

                buildFromPoints(M_MACRO, m_group, vertex1, vertex2, M_LINE_EXT)

            # Case of more than 2 points
            else:
                if M_BYPAIR:
                    if WF.verbose():
                        print_msg("Process points by pair")
                    # even
                    if (number_of_vertexes % 2 == 0):
                        if WF.verbose():
                            print_msg("Even number of points")
                        for i in range(0, number_of_vertexes - 1, 2):
                            vertex1 = vertex_list[i]
                            vertex2 = vertex_list[i + 1]

                            buildFromPoints(M_MACRO, m_group, vertex1, vertex2,
                                            M_LINE_EXT)
                    # odd
                    else:
                        if WF.verbose():
                            print_msg("Odd number of points")
                        for i in range(0, number_of_vertexes - 2, 2):
                            vertex1 = vertex_list[i]
                            vertex2 = vertex_list[i + 1]

                            buildFromPoints(M_MACRO, m_group, vertex1, vertex2,
                                            M_LINE_EXT)

                        if WF.closePolyline():
                            vertex1 = vertex_list[-1]
                            vertex2 = vertex_list[0]

                            buildFromPoints(M_MACRO, m_group, vertex1, vertex2,
                                            M_LINE_EXT)
                else:
                    if WF.verbose():
                        print_msg("Process points as list")
                    for i in range(number_of_vertexes - 1):
                        vertex1 = vertex_list[i]
                        vertex2 = vertex_list[i + 1]

                        buildFromPoints(M_MACRO, m_group, vertex1, vertex2,
                                        M_LINE_EXT)

                    if WF.closePolyline():
                        vertex1 = vertex_list[-1]
                        vertex2 = vertex_list[0]

                        buildFromPoints(M_MACRO, m_group, vertex1, vertex2,
                                        M_LINE_EXT)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 11
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    try:
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points", "Curves", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Vertexes < 3:
            raise Exception(m_exception_msg)

        try:
            m_main_dir = "WorkPlanes_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if Number_of_Vertexes > 6:
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_actDoc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=m_macro)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            # Case of only 3 points
            if Number_of_Vertexes == 3:
                if WF.verbose():
                    print_msg("Process only 3 points")

                vertex1 = Vertex_List[0]
                vertex2 = Vertex_List[1]
                vertex3 = Vertex_List[2]

                if WF.verbose():
                    print_msg("vertex1 = " + str(vertex1))
                    print_msg("vertex2 = " + str(vertex2))
                    print_msg("vertex3 = " + str(vertex3))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj = makeThreePointsPlaneFeature(m_group)
                selfobj.Point1 = vertex1
                selfobj.Point2 = vertex2
                selfobj.Point3 = vertex3
                selfobj.Extension = m_extension
                selfobj.Proxy.execute(selfobj)
            else:
                raise Exception(m_exception_msg)

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 12
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    try:
        Number_of_Edges, Edge_List = m_sel.get_segmentsNames(
            getfrom=["Segments", "Curves", "Planes", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Edges = " + str(Number_of_Edges))
            print_msg("Edge_List = " + str(Edge_List))

        if Number_of_Edges == 0:
            raise Exception(m_exception_msg)
        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if Number_of_Edges > 1 or m_location == "Both ends":
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_actDoc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=m_macro)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            for i in range(Number_of_Edges):
                edge = Edge_List[i]

                if WF.verbose():
                    print_msg("Location = " + str(m_location))

                if m_location in ["Begin", "Both ends"]:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj1 = makeExtremaLinePointFeature(m_group)
                    selfobj1.Edge = edge
                    selfobj1.At = "Begin"
                    selfobj1.Proxy.execute(selfobj1)
                    if str(selfobj1.Parametric) == 'Interactive':
                        selfobj1.Parametric = 'Dynamic'
                        selfobj1.touch()
                        selfobj1.Parametric = 'Interactive'
                    if str(selfobj1.Parametric) == 'Not':
                        selfobj1.Parametric = 'Dynamic'
                        selfobj1.touch()
                        selfobj1.Parametric = 'Not'
                if m_location in ["End", "Both ends"]:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj2 = makeExtremaLinePointFeature(m_group)
                    selfobj2.Edge = edge
                    selfobj2.At = "End"
                    selfobj2.Proxy.execute(selfobj2)
                    if str(selfobj2.Parametric) == 'Interactive':
                        selfobj2.Parametric = 'Dynamic'
                        selfobj2.touch()
                        selfobj2.Parametric = 'Interactive'
                    if str(selfobj2.Parametric) == 'Not':
                        selfobj2.Parametric = 'Dynamic'
                        selfobj2.touch()
                        selfobj2.Parametric = 'Not'

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 13
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    try:
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points",
                     "Curves",
                     "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Vertexes < 2:
            raise Exception(m_exception_msg)
        try:
            m_main_dir = "WorkAxis_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if Number_of_Vertexes > 2:
                try:
                    m_ob = App.ActiveDocument.getObject(str(m_main_dir)).newObject("App::DocumentObjectGroup", str(m_sub_dir))
                    m_group = m_actDoc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=m_macro)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            # Case of only 2 points
            if Number_of_Vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = Vertex_List[0]
                vertex2 = Vertex_List[1]

                if WF.verbose():
                    print_msg("vertex1 = " + str(vertex1))
                    print_msg("vertex2 = " + str(vertex2))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj = makeTwoPointsLineFeature(m_group)
                selfobj.Point1 = vertex1
                selfobj.Point2 = vertex2
                selfobj.Extension = m_line_ext
                selfobj.Proxy.execute(selfobj)
            # Case of more than 2 points
            else:
                if m_byPair:
                    if WF.verbose():
                        print_msg("Process points by pair")
                    # even
                    if (Number_of_Vertexes % 2 == 0):
                        if WF.verbose():
                            print_msg("Even number of points")
                        for i in range(0, Number_of_Vertexes - 1, 2):
                            vertex1 = Vertex_List[i]
                            vertex2 = Vertex_List[i + 1]

                            if WF.verbose():
                                print_msg("vertex1 = " + str(vertex1))
                                print_msg("vertex2 = " + str(vertex2))

                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeTwoPointsLineFeature(m_group)
                            selfobj.Point1 = vertex1
                            selfobj.Point2 = vertex2
                            selfobj.Extension = m_line_ext
                            selfobj.Proxy.execute(selfobj)
                    # odd
                    else:
                        if WF.verbose():
                            print_msg("Odd number of points")
                        for i in range(0, Number_of_Vertexes - 2, 2):
                            vertex1 = Vertex_List[i]
                            vertex2 = Vertex_List[i + 1]

                            if WF.verbose():
                                print_msg("vertex1 = " + str(vertex1))
                                print_msg("vertex2 = " + str(vertex2))

                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeTwoPointsLineFeature(m_group)
                            selfobj.Point1 = vertex1
                            selfobj.Point2 = vertex2
                            selfobj.Extension = m_line_ext
                            selfobj.Proxy.execute(selfobj)
                        if WF.closePolyline():
                            vertex1 = Vertex_List[-1]
                            vertex2 = Vertex_List[0]

                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeTwoPointsLineFeature(m_group)
                            selfobj.Point1 = vertex1
                            selfobj.Point2 = vertex2
                            selfobj.Extension = m_line_ext
                            selfobj.Proxy.execute(selfobj)
                else:
                    if WF.verbose():
                        print_msg("Process points as list")
                    for i in range(Number_of_Vertexes - 1):
                        vertex1 = Vertex_List[i]
                        vertex2 = Vertex_List[i + 1]

                        if WF.verbose():
                            print_msg("vertex1 = " + str(vertex1))
                            print_msg("vertex2 = " + str(vertex2))

                        App.ActiveDocument.openTransaction(m_macro)
                        selfobj = makeTwoPointsLineFeature(m_group)
                        selfobj.Point1 = vertex1
                        selfobj.Point2 = vertex2
                        selfobj.Extension = m_line_ext
                        selfobj.Proxy.execute(selfobj)

                    if WF.closePolyline():
                        vertex1 = Vertex_List[-1]
                        vertex2 = Vertex_List[0]

                        if WF.verbose():
                            print_msg("vertex1 = " + str(vertex1))
                            print_msg("vertex2 = " + str(vertex2))

                        App.ActiveDocument.openTransaction(m_macro)
                        selfobj = makeTwoPointsLineFeature(m_group)
                        selfobj.Point1 = vertex1
                        selfobj.Point2 = vertex2
                        selfobj.Extension = m_line_ext
                        selfobj.Proxy.execute(selfobj)

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 14
0
def run():
    global m_group
    m_sel, m_actDoc = getSel(WF.verbose())

    def touch(selfobj):
        if str(selfobj.Parametric) == 'Interactive':
            selfobj.Parametric = 'Dynamic'
            selfobj.touch()
            selfobj.Parametric = 'Interactive'
        if str(selfobj.Parametric) == 'Not':
            selfobj.Parametric = 'Dynamic'
            selfobj.touch()
            selfobj.Parametric = 'Not'

    try:
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points", "Segments", "Curves", "Planes", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Vertexes < 1:
            raise Exception(m_exception_msg)

        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if Number_of_Vertexes > 1 or m_sel_plane in m_sel_multi or m_proj_line:
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_actDoc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=m_macro)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            for point in Vertex_List:
                if WF.verbose():
                    print_msg("Selected plane" + str(m_sel_plane))

                # Possible selections
                # "XY plane",
                # "YZ plane",
                # "XZ plane",
                # "XY, YZ planes",
                # "XY, XZ planes",
                # "YZ, XZ planes",
                # "XY, YZ, XZ planes"
                # "Already Selected planes",

                if m_sel_plane in [
                        "XY plane", "XY, YZ planes", "XY, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeProjectedPointFeature(m_group)
                    selfobj.Point = point
                    selfobj.At = "XY plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)

                if m_sel_plane in [
                        "YZ plane", "XY, YZ planes", "YZ, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeProjectedPointFeature(m_group)
                    selfobj.Point = point
                    selfobj.At = "YZ plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)
                if m_sel_plane in [
                        "XZ plane", "XY, XZ planes", "YZ, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeProjectedPointFeature(m_group)
                    selfobj.Point = point
                    selfobj.At = "XZ plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)
        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 15
0
def run():
    m_sel, _ = getSel(WF.verbose())

    try:
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points", "Curves", "Planes", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Vertexes < 2:
            raise Exception(m_exception_msg)

        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            points = []
            # Case of only 2 points
            if Number_of_Vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = Vertex_List[0]
                vertex2 = Vertex_List[1]
                points.append(vertex1)
                points.append(vertex2)

                if WF.verbose():
                    print_msg("vertex1 = " + str(vertex1))
                    print_msg("vertex2 = " + str(vertex2))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj, m_inst = makeNPointsPointFeature(m_group)
                if m_debug:
                    print("selfobj : " + str(selfobj))
                m_inst.addSubobjects(selfobj, points)
                selfobj.Proxy.execute(selfobj)
            # Case of more than 2 points
            else:
                if WF.verbose():
                    print_msg("Process more than 2 points")
                for i in range(Number_of_Vertexes):
                    vertex1 = Vertex_List[i]
                    points.append(vertex1)
                    if WF.verbose():
                        print_msg("vertex1 = " + str(vertex1))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj, m_inst = makeNPointsPointFeature(m_group)
                if m_debug:
                    print("selfobj : " + str(selfobj))
                m_inst.addSubobjects(selfobj, points)
        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 16
0
def run():
    m_sel, _ = getSel(WF.verbose())

    try:
        Number_of_Edges, Edge_List = m_sel.get_segmentsNames(
            getfrom=["Segments",
                     "Curves",
                     "Planes",
                     "Objects"])
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points",
                     "Curves",
                     "Objects"])

        if WF.verbose():
            print_msg("Number_of_Edges = " + str(Number_of_Edges))
            print_msg("Edge_List = " + str(Edge_List))
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Edges < 1:
            raise Exception(m_exception_msg)
        if Number_of_Vertexes < 1:
            raise Exception(m_exception_msg)

        try:
            m_main_dir = "WorkPlanes_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            # To develop

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            # Case of only 1 point and 1 Edge
            if Number_of_Edges == 1 and Number_of_Vertexes == 1:
                edge = Edge_List[0]
                vertex = Vertex_List[0]

                if WF.verbose():
                    print_msg("edge = " + str(edge))
                    print_msg("vertex = " + str(vertex))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj = makeLinePointPlaneFeature(m_group)
                selfobj.Edge = edge
                selfobj.Point = vertex
                selfobj.Extension = m_extension
                selfobj.Proxy.execute(selfobj)
            else:
                raise Exception(m_exception_msg)

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 17
0
def along_line_point_command():
    """ This command use the selected object(s) to try to build a
    AlongLinePoint feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    edges_from = ["Segments", "Curves"]
    points_from = ["Points"]
    try:
        if m_sel.numberOfEntities == 1:
            number_of_edges, edge_list = m_sel.get_segmentsWithNames(
                get_from=edges_from)
        else:
            number_of_edges, edge_list = m_sel.get_segmentsWithNames(
                get_from=edges_from)

        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_edges == 0:
            raise Exception(M_EXCEPTION_MSG)
        else:
            if number_of_edges == 1 and number_of_vertexes == 0:
                raise Exception(M_EXCEPTION_MSG)

        m_main_dir = "WorkPoints_P"
        m_sub_dir = "Set000"
        m_group = createFolders(str(m_main_dir))

        m_distance = getDistanceLinePoint()

        # Selection of : One Edge and One or several Point(s)
        if number_of_edges == 1 and number_of_vertexes > 0:
            try:
                # Create a sub group if needed
                if number_of_vertexes > 1:
                    m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

                edge = edge_list[0]
                for j in range(number_of_vertexes):
                    point = vertex_list[j]
                    buildFromEdgeAndPoint(M_MACRO,
                                          m_group,
                                          edge, point, m_distance)

            except Exception as err:
                printError_msg(err.args[0], title=M_MACRO)

        # Selection of : One Edge and One or several Edge(s)
        elif number_of_edges > 1 and number_of_vertexes == 0:
            try:
                # Create a sub group if needed
                if number_of_edges > 2:
                    m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

                edge = edge_list[0]
                for other_edge in edge_list[1:]:
                    buildFromEdges(M_MACRO,
                                   m_group,
                                   edge, other_edge, m_distance)

            except Exception as err:
                printError_msg(err.args[0], title=M_MACRO)

        # Selection of : several Edges and Points with
        # same number of Edges and Points
        elif number_of_edges > 1 and number_of_vertexes == number_of_edges:
            try:
                # Create a sub group if needed
                m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

                for edge, point in zip(edge_list, vertex_list):
                    buildFromEdgeAndPoint(M_MACRO,
                                          m_group,
                                          edge, point, m_distance)

            except Exception as err:
                printError_msg(err.args[0], title=M_MACRO)

        else:
            printError_msg("Bad selection !", title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 18
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    try:
        Number_of_Edges, Edge_List = m_sel.get_segmentsNames(
            getfrom=["Segments",
                     "Curves",
                     "Planes",
                     "Objects"])
        if WF.verbose():
            print_msg("Number_of_Edges = " + str(Number_of_Edges))
            print_msg("Edge_List = " + str(Edge_List))

        if Number_of_Edges == 0:
            Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
                getfrom=["Points",
                         ])
            if WF.verbose():
                print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
                print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Edges == 0 and Number_of_Vertexes < 2:
            raise Exception(m_exception_msg)
        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # From Edges
            if Number_of_Edges != 0:
                # Create a sub group if needed
                if Number_of_Edges > 1 or m_location != "Single":
                    try:
                        m_ob = App.ActiveDocument.getObject(
                            str(m_main_dir)).newObject(
                            "App::DocumentObjectGroup", str(m_sub_dir))
                        m_group = m_actDoc.getObject(str(m_ob.Label))
                    except Exception as err:
                        printError_msg(err.args[0], title=m_macro)
                        printError_msg(m_error_msg)

                if WF.verbose():
                    print_msg("Group = " + str(m_group.Label))

                for i in range(Number_of_Edges):
                    edge = Edge_List[i]

                    if WF.verbose():
                        print_msg("Location = " + str(m_location))

                    if m_location == "Single":
                        App.ActiveDocument.openTransaction(m_macro)
                        selfobj = makeCenterLinePointFeature(m_group)
                        selfobj.Edge = edge
                        selfobj.Point1 = None
                        selfobj.Point2 = None
                        selfobj.NumberLinePart = m_numberLinePart
                        selfobj.IndexPart = m_indexPart
                        selfobj.Proxy.execute(selfobj)
                        WF.touch(selfobj)
                    else:
                        for m_iPart in range(m_numberLinePart + 1):
                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeCenterLinePointFeature(m_group)
                            selfobj.Edge = edge
                            selfobj.Point1 = None
                            selfobj.Point2 = None
                            selfobj.NumberLinePart = m_numberLinePart
                            selfobj.IndexPart = m_iPart
                            selfobj.Proxy.execute(selfobj)
                            WF.touch(selfobj)

            # From Vertexes
            else:
                if Number_of_Vertexes > 2:
                    try:
                        m_ob = App.ActiveDocument.getObject(
                            str(m_main_dir)).newObject(
                            "App::DocumentObjectGroup", str(m_sub_dir))
                        m_group = m_actDoc.getObject(str(m_ob.Label))
                    except Exception as err:
                        printError_msg(err.args[0], title=m_macro)
                        printError_msg(m_error_msg)

                # Even number of vertexes
                if (Number_of_Vertexes % 2 == 0):
                    if WF.verbose():
                        print_msg("Even number of points")

                    if Number_of_Vertexes == 2:
                        vertex1 = Vertex_List[0]
                        vertex2 = Vertex_List[1]

                        if WF.verbose():
                            print_msg("vertex1 = " + str(vertex1))
                            print_msg("vertex2 = " + str(vertex2))

                        if m_location == "Single":
                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeCenterLinePointFeature(m_group)
                            selfobj.Edge = None
                            selfobj.Point1 = vertex1
                            selfobj.Point2 = vertex2
                            selfobj.NumberLinePart = m_numberLinePart
                            selfobj.IndexPart = m_indexPart
                            selfobj.Proxy.execute(selfobj)
                        else:
                            for m_iPart in range(m_numberLinePart + 1):
                                App.ActiveDocument.openTransaction(m_macro)
                                selfobj = makeCenterLinePointFeature(m_group)
                                selfobj.Edge = None
                                selfobj.Point1 = vertex1
                                selfobj.Point2 = vertex2
                                selfobj.NumberLinePart = m_numberLinePart
                                selfobj.IndexPart = m_iPart
                                selfobj.Proxy.execute(selfobj)
                    else:
                        for i in range(0, Number_of_Vertexes - 2, 2):
                            vertex1 = Vertex_List[i]
                            vertex2 = Vertex_List[i + 1]

                            if WF.verbose():
                                print_msg("vertex1 = " + str(vertex1))
                                print_msg("vertex2 = " + str(vertex2))

                            if m_location == "Single":
                                App.ActiveDocument.openTransaction(m_macro)
                                selfobj = makeCenterLinePointFeature(m_group)
                                selfobj.Edge = None
                                selfobj.Point1 = vertex1
                                selfobj.Point2 = vertex2
                                selfobj.NumberLinePart = m_numberLinePart
                                selfobj.IndexPart = m_indexPart
                                selfobj.Proxy.execute(selfobj)
                            else:
                                for m_iPart in range(m_numberLinePart + 1):
                                    App.ActiveDocument.openTransaction(m_macro)
                                    selfobj = makeCenterLinePointFeature(
                                        m_group)
                                    selfobj.Edge = None
                                    selfobj.Point1 = vertex1
                                    selfobj.Point2 = vertex2
                                    selfobj.NumberLinePart = m_numberLinePart
                                    selfobj.IndexPart = m_iPart
                                    selfobj.Proxy.execute(selfobj)
                # Odd number of vertexes
                else:
                    if WF.verbose():
                        print_msg("Odd number of points")
                    for i in range(Number_of_Vertexes - 1):
                        vertex1 = Vertex_List[i]
                        vertex2 = Vertex_List[i + 1]

                        if WF.verbose():
                            print_msg("vertex1 = " + str(vertex1))
                            print_msg("vertex2 = " + str(vertex2))

                        if m_location == "Single":
                            App.ActiveDocument.openTransaction(m_macro)
                            selfobj = makeCenterLinePointFeature(m_group)
                            selfobj.Edge = None
                            selfobj.Point1 = vertex1
                            selfobj.Point2 = vertex2
                            selfobj.NumberLinePart = m_numberLinePart
                            selfobj.IndexPart = m_indexPart
                            selfobj.Proxy.execute(selfobj)
                        else:
                            for m_iPart in range(m_numberLinePart + 1):
                                App.ActiveDocument.openTransaction(m_macro)
                                selfobj = makeCenterLinePointFeature(m_group)
                                selfobj.Edge = None
                                selfobj.Point1 = vertex1
                                selfobj.Point2 = vertex2
                                selfobj.NumberLinePart = m_numberLinePart
                                selfobj.IndexPart = m_iPart
                                selfobj.Proxy.execute(selfobj)

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 19
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    if WF.verbose():
        print_msg("m_sel = " + str(m_sel))

    def createSubGroup(main_dir,
                       sub_dir,
                       error_msg):
        try:
            m_ob_dir = App.ActiveDocument.getObject(main_dir)
            m_ob = m_ob_dir.newObject("App::DocumentObjectGroup",
                                      str(sub_dir))
            m_group = m_actDoc.getObject(str(m_ob.Label))
        except Exception as err:
            printError_msg(err.message, title=m_macro)
            printError_msg(error_msg)
        return m_group

    try:
        Number_of_Edges, Edge_List = m_sel.get_segmentsNames(
            getfrom=["Segments", "Curves"])
        if WF.verbose():
            print_msg("Number_of_Edges = " + str(Number_of_Edges))
            print_msg("Edge_List = " + str(Edge_List))

        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points", "Segments", "Curves", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Edges == 0:
            raise Exception(m_exception_msg)
        else:
            if Number_of_Edges == 1 and Number_of_Vertexes == 0:
                raise Exception(m_exception_msg)

        m_main_dir = "WorkPoints_P"
        m_sub_dir = "Set"
        m_group = createFolders(str(m_main_dir))
        m_error_msg = "Could not Create '"
        m_error_msg += str(m_sub_dir) + "' Objects Group!"

        # Selection of : One Edge and One or several Point(s)
        if Number_of_Edges == 1 and Number_of_Vertexes > 0:
            try:
                # Create a sub group if needed
                if Number_of_Vertexes > 1:
                    m_group = createSubGroup(m_main_dir,
                                             m_sub_dir,
                                             m_error_msg)

                if WF.verbose():
                    print_msg("Group = " + str(m_group.Label))

                edge = Edge_List[0]
                if WF.verbose():
                    print_msg("edge = " + str(edge))

                for j in range(Number_of_Vertexes):
                    point = Vertex_List[j]
                    if WF.verbose():
                        print_msg("point = " + str(point))

                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeAlongLinePointFeature(m_group)
                    selfobj.AlongEdge = edge
                    selfobj.Point = point
                    selfobj.Edge = None
                    selfobj.Distance = m_distanceLinePoint
                    selfobj.Proxy.execute(selfobj)

            except Exception as err:
                printError_msg(err.message, title=m_macro)

            App.ActiveDocument.commitTransaction()

        # Selection of : One Edge and One or several Edge(s)
        elif Number_of_Edges > 1 and Number_of_Vertexes == 0:
            try:
                # Create a sub group if needed
                if Number_of_Edges > 2:
                    m_group = createSubGroup(m_main_dir,
                                             m_sub_dir,
                                             m_error_msg)

                if WF.verbose():
                    print_msg("Group = " + str(m_group.Label))

                edge = Edge_List[0]
                if WF.verbose():
                    print_msg("edge = " + str(edge))

                for other_edge in Edge_List[1:]:
                    if WF.verbose():
                        print_msg("other_edge = " + str(other_edge))

                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeAlongLinePointFeature(m_group)
                    selfobj.AlongEdge = edge
                    selfobj.Point = None
                    selfobj.Edge = other_edge
                    selfobj.Distance = m_distanceLinePoint
                    selfobj.Proxy.execute(selfobj)

            except Exception as err:
                printError_msg(err.message, title=m_macro)

            App.ActiveDocument.commitTransaction()

        # Selection of : several Edges and Points with
        # same number of Edges and Points
        elif Number_of_Edges > 1 and Number_of_Vertexes == Number_of_Edges:
            try:
                # Create a sub group if needed
                m_group = createSubGroup(m_main_dir,
                                         m_sub_dir,
                                         m_error_msg)

                if WF.verbose():
                    print_msg("Group = " + str(m_group.Label))

                for edge, point in zip(Edge_List, Vertex_List):
                    if WF.verbose():
                        print_msg("edge = " + str(edge))
                        print_msg("point = " + str(point))

                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj = makeAlongLinePointFeature(m_group)
                    selfobj.AlongEdge = edge
                    selfobj.Point = point
                    selfobj.Edge = None
                    selfobj.Distance = m_distanceLinePoint
                    selfobj.Proxy.execute(selfobj)

            except Exception as err:
                printError_msg(err.message, title=m_macro)

            App.ActiveDocument.commitTransaction()
        else:
            printError_msg("Bad selection !", title=m_macro)
    except Exception as err:
        printError_msg(err.message, title=m_macro)
Ejemplo n.º 20
0
def run():
    m_sel, m_actDoc = getSel(WF.verbose())

    try:
        Number_of_Vertexes, Vertex_List = m_sel.get_pointsNames(
            getfrom=["Points", "Curves", "Objects"])
        if WF.verbose():
            print_msg("Number_of_Vertexes = " + str(Number_of_Vertexes))
            print_msg("Vertex_List = " + str(Vertex_List))

        if Number_of_Vertexes < 2:
            raise Exception(m_exception_msg)

        try:
            m_main_dir = "WorkAxis_P"
            m_sub_dir = "Set001"
            m_group = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if m_svd_flag:
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    m_group = m_actDoc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=m_macro)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(m_group.Label))

            points = []
            # Case of only 2 points
            if Number_of_Vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = Vertex_List[0]
                vertex2 = Vertex_List[1]
                points.append(vertex1)
                points.append(vertex2)

                if WF.verbose():
                    print_msg("vertex1 = " + str(vertex1))
                    print_msg("vertex2 = " + str(vertex2))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj, m_inst = makeNPointsLineFeature(m_group)
                if m_debug:
                    print("selfobj : " + str(selfobj))
                m_inst.addSubobjects(selfobj, points)
                selfobj.VectorIndex = '1'
                selfobj.Proxy.execute(selfobj)

                if m_svd_flag:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '2'
                    selfobj.Proxy.execute(selfobj)

                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '3'
                    selfobj.Proxy.execute(selfobj)
            # Case of more than 2 points
            else:
                if WF.verbose():
                    print_msg("Process more than 2 points")
                for i in range(Number_of_Vertexes):
                    vertex = Vertex_List[i]
                    points.append(vertex)
                    if WF.verbose():
                        print_msg("vertex = " + str(vertex))

                App.ActiveDocument.openTransaction(m_macro)
                selfobj, m_inst = makeNPointsLineFeature(m_group)
                if m_debug:
                    print("selfobj : " + str(selfobj))
                m_inst.addSubobjects(selfobj, points)
                selfobj.VectorIndex = '1'
                selfobj.Proxy.execute(selfobj)

                if m_svd_flag:
                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '2'
                    selfobj.Proxy.execute(selfobj)

                    App.ActiveDocument.openTransaction(m_macro)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '3'
                    selfobj.Proxy.execute(selfobj)

        except Exception as err:
            printError_msg(err.args[0], title=m_macro)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=m_macro)
Ejemplo n.º 21
0
def n_points_line_command():
    """ This command use the selected object(s) to try to build a
    NPointsLine feature object.
    """
    m_sel, m_act_doc = getSel(WF.verbose())

    points_from = ["Points", "Curves", "Objects"]
    try:
        number_of_vertexes, vertex_list = m_sel.get_pointsWithNames(
            get_from=points_from)

        if number_of_vertexes < 2:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkAxis_P"
            m_sub_dir = "Set000"
            m_group = createFolders(str(m_main_dir))

            # Create a sub group if needed
            if M_SVD_FLAG:
                m_group = createSubGroup(m_act_doc, m_main_dir, m_sub_dir)

            points = []
            # Case of only 2 points
            if number_of_vertexes == 2:
                if WF.verbose():
                    print_msg("Process only 2 points")
                vertex1 = vertex_list[0]
                vertex2 = vertex_list[1]
                points.append(vertex1)
                points.append(vertex2)

                if WF.verbose():
                    print_msg("vertex1 = " + str(vertex1))
                    print_msg("vertex2 = " + str(vertex2))

                App.ActiveDocument.openTransaction(M_MACRO)
                selfobj, m_inst = makeNPointsLineFeature(m_group)
                m_inst.addSubobjects(selfobj, points)
                selfobj.VectorIndex = '1'
                selfobj.Proxy.execute(selfobj)

                if M_SVD_FLAG:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '2'
                    selfobj.Proxy.execute(selfobj)

                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '3'
                    selfobj.Proxy.execute(selfobj)
            # Case of more than 2 points
            else:
                if WF.verbose():
                    print_msg("Process more than 2 points")
                for i in range(number_of_vertexes):
                    vertex = vertex_list[i]
                    points.append(vertex)
                    if WF.verbose():
                        print_msg("vertex = " + str(vertex))

                App.ActiveDocument.openTransaction(M_MACRO)
                selfobj, m_inst = makeNPointsLineFeature(m_group)
                m_inst.addSubobjects(selfobj, points)
                selfobj.VectorIndex = '1'
                selfobj.Proxy.execute(selfobj)

                if M_SVD_FLAG:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '2'
                    selfobj.Proxy.execute(selfobj)

                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj, m_inst = makeNPointsLineFeature(m_group)
                    m_inst.addSubobjects(selfobj, points)
                    selfobj.VectorIndex = '3'
                    selfobj.Proxy.execute(selfobj)

        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

    except Exception as err:
        printError_msgWithTimer(err.args[0], title=M_MACRO)

    App.ActiveDocument.commitTransaction()
    App.activeDocument().recompute()
Ejemplo n.º 22
0
def projected_point_command():
    global M_GROUP
    m_sel, m_act_doc = getSel(WF.verbose())

    def touch(selfobj):
        if str(selfobj.Parametric) == 'Interactive':
            selfobj.Parametric = 'Dynamic'
            selfobj.touch()
            selfobj.Parametric = 'Interactive'
        if str(selfobj.Parametric) == 'Not':
            selfobj.Parametric = 'Dynamic'
            selfobj.touch()
            selfobj.Parametric = 'Not'

    try:
        number_of_vertexes, vertex_list = m_sel.get_pointsNames(
            getfrom=["Points", "Segments", "Curves", "Planes", "Objects"])
        if WF.verbose():
            print_msg("number_of_vertexes = " + str(number_of_vertexes))
            print_msg("vertex_list = " + str(vertex_list))

        if number_of_vertexes < 1:
            raise Exception(M_EXCEPTION_MSG)

        try:
            m_main_dir = "WorkPoints_P"
            m_sub_dir = "Set001"
            M_GROUP = createFolders(str(m_main_dir))
            m_error_msg = "Could not Create '"
            m_error_msg += str(m_sub_dir) + "' Objects Group!"

            # Create a sub group if needed
            if number_of_vertexes > 1 or M_SEL_PLANE in M_SEL_MULTI or M_PROJ_LINE:
                try:
                    m_ob = App.ActiveDocument.getObject(
                        str(m_main_dir)).newObject("App::DocumentObjectGroup",
                                                   str(m_sub_dir))
                    M_GROUP = m_act_doc.getObject(str(m_ob.Label))
                except Exception as err:
                    printError_msg(err.args[0], title=M_MACRO)
                    printError_msg(m_error_msg)

            if WF.verbose():
                print_msg("Group = " + str(M_GROUP.Label))

            for point in vertex_list:
                if WF.verbose():
                    print_msg("Selected plane" + str(M_SEL_PLANE))

                # Possible selections
                # "XY plane",
                # "YZ plane",
                # "XZ plane",
                # "XY, YZ planes",
                # "XY, XZ planes",
                # "YZ, XZ planes",
                # "XY, YZ, XZ planes"
                # "Already Selected planes",

                if M_SEL_PLANE in [
                        "XY plane", "XY, YZ planes", "XY, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj = makeProjectedPointFeature(M_GROUP)
                    selfobj.Point = point
                    selfobj.At = "XY plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)

                if M_SEL_PLANE in [
                        "YZ plane", "XY, YZ planes", "YZ, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj = makeProjectedPointFeature(M_GROUP)
                    selfobj.Point = point
                    selfobj.At = "YZ plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)
                if M_SEL_PLANE in [
                        "XZ plane", "XY, XZ planes", "YZ, XZ planes",
                        "XY, YZ, XZ planes"
                ]:
                    App.ActiveDocument.openTransaction(M_MACRO)
                    selfobj = makeProjectedPointFeature(M_GROUP)
                    selfobj.Point = point
                    selfobj.At = "XZ plane"
                    selfobj.Proxy.execute(selfobj)
                    WF.touch(selfobj)
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)

        App.ActiveDocument.commitTransaction()

    except Exception as err:
        printError_msg(err.args[0], title=M_MACRO)