Example #1
0
    def onChanged(self, selfobj, prop):
        """ Run when a proterty change.
        """
        if M_DEBUG:
            print("running CenterLinePoint.onChanged !")
            print("Change property : " + str(prop))

        WF_Point.onChanged(self, selfobj, prop)

        if prop == "Parametric":
            if 'Parametric' in selfobj.PropertiesList:
                if selfobj.Parametric == 'Not':
                    selfobj.setEditorMode("NumberLinePart", 1)
                    selfobj.setEditorMode("IndexPart", 1)
                else:
                    selfobj.setEditorMode("NumberLinePart", 0)
                    selfobj.setEditorMode("IndexPart", 0)
            propertiesPoint(selfobj.Label, self.color)

        if prop == "IndexPart":
            selfobj.Proxy.execute(selfobj)

        if prop == 'NumberLinePart':
            if selfobj.NumberLinePart <= 1:
                selfobj.NumberLinePart = 2
            elif selfobj.NumberLinePart > 100:
                selfobj.NumberLinePart = 100
            selfobj.Proxy.execute(selfobj)
Example #2
0
    def execute_2018(self, selfobj):
        """ Doing a old recomputation.
        """
        if M_DEBUG:
            print("Recompute Python CenterLinePoint feature (old manner)\n")

        if 'Edge' not in selfobj.PropertiesList:
            return
        if 'IndexPart' not in selfobj.PropertiesList:
            return
        if 'NumberLinePart' not in selfobj.PropertiesList:
            return

#         n = eval(selfobj.Edge[1][0].lstrip('Edge'))
        m_int = re.sub('[^0-9]', '', selfobj.Edge[1][0])
        n = int(m_int)
        if WF.verbose():
            print_msg("n = " + str(n))

        try:
            vector_point = alongLinePoint(selfobj.Edge[0].Shape.Edges[n - 1],
                                          selfobj.IndexPart,
                                          selfobj.NumberLinePart)

            point = Part.Point(vector_point)
            selfobj.Shape = point.toShape()
            propertiesPoint(selfobj.Label)
            selfobj.X = float(vector_point.x)
            selfobj.Y = float(vector_point.y)
            selfobj.Z = float(vector_point.z)
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)
    def execute(self, selfobj):
        """ Doing a recomputation.
        """
        m_properties_list = [
            'Edge',
            'At',
        ]
        for m_property in m_properties_list:
            if m_property not in selfobj.PropertiesList:
                return

        if M_DEBUG:
            print("running ExtremaLinePoint.execute !")

        # To be compatible with previous version > 2019
        if 'Parametric' in selfobj.PropertiesList:
            # Create the object the first time regardless
            # the parametric behavior
            if selfobj.Parametric == 'Not' and self.created:
                return
            if selfobj.Parametric == 'Interactive' and self.created:
                return

        try:
            vector_point = None
            m_n = re.sub('[^0-9]', '', selfobj.Edge[1][0])
            m_n = int(m_n)
            if M_DEBUG:
                print_msg(str(selfobj.Edge))
                print_msg("m_n = " + str(m_n))

            if not selfobj.Edge[0].Shape.Edges:
                return

            if selfobj.At == "Begin":
                vector_point = selfobj.Edge[0].Shape.Edges[m_n -
                                                           1].Vertexes[0].Point
            else:
                vector_point = selfobj.Edge[0].Shape.Edges[
                    m_n - 1].Vertexes[-1].Point

            if vector_point is not None:
                point = Part.Point(vector_point)
                selfobj.Shape = point.toShape()
                propertiesPoint(selfobj.Label, self.color)
                selfobj.X = float(vector_point.x)
                selfobj.Y = float(vector_point.y)
                selfobj.Z = float(vector_point.z)
                # To be compatible with previous version 2018
                if 'Parametric' in selfobj.PropertiesList:
                    self.created = True
        except AttributeError as err:
            print("AttributeError" + str(err))
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)
    def execute(self, selfobj):
        """ Doing a recomputation.
        """
        m_properties_list = ['Points',
                             ]
        for m_property in m_properties_list:
            if m_property not in selfobj.PropertiesList:
                return

        if M_DEBUG:
            print("running NPointsPoint.execute !")

        # To be compatible with previous version > 2019
        if 'Parametric' in selfobj.PropertiesList:
            # Create the object the first time regardless
            # the parametric behavior
            if selfobj.Parametric == 'Not' and self.created:
                return
            if selfobj.Parametric == 'Interactive' and self.created:
                return

        try:
            vector_point = None
            if selfobj.Points is not None:
                m_points = []
                for p in linkSubList_convertToOldStyle(selfobj.Points):
                    # n = eval(p[1].lstrip('Vertex'))
                    m_n = re.sub('[^0-9]', '', p[1])
                    m_n = int(m_n)
                    if M_DEBUG:
                        print("p " + str(p))
                        print_msg("m_n = " + str(m_n))

                    m_points.append(p[0].Shape.Vertexes[m_n - 1].Point)

            vector_point = meanVectorsPoint(m_points)

            if vector_point is not None:
                point = Part.Point(vector_point)
                selfobj.Shape = point.toShape()
                propertiesPoint(selfobj.Label, self.color)
                selfobj.X = float(vector_point.x)
                selfobj.Y = float(vector_point.y)
                selfobj.Z = float(vector_point.z)
                # To be compatible with previous version 2018
                if 'Parametric' in selfobj.PropertiesList:
                    self.created = True
        except AttributeError as err:
            print("AttributeError" + str(err))
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)
Example #5
0
    def onChanged(self, selfobj, prop):
        """ Run when a proterty change.
        """
        if M_DEBUG:
            print("running CenterLinePoint.onChanged !")
            print("Change property : " + str(prop))

        WF_Point.onChanged(self, selfobj, prop)

        if prop == "Parametric":
            if 'Parametric' in selfobj.PropertiesList:
                if selfobj.Parametric == 'Not':
                    selfobj.setEditorMode("Distance", 1)
                else:
                    selfobj.setEditorMode("Distance", 0)
            propertiesPoint(selfobj.Label, self.color)

        if prop == "Distance":
            selfobj.Proxy.execute(selfobj)
Example #6
0
    def execute(self, selfobj):
        """ Doing a recomputation.
        """
        m_properties_list = ["Distance",
                             'AlongEdge',
                             'Edge',
                             'Point'
                             ]
        for m_property in m_properties_list:
            if m_property not in selfobj.PropertiesList:
                return

        if M_DEBUG:
            print("running AlongLinePoint.execute !")

        # To be compatible with previous version > 2019
        if 'Parametric' in selfobj.PropertiesList:
            # Create the object the first time regardless
            # the parametric behavior
            if selfobj.Parametric == 'Not' and self.created:
                return
            if selfobj.Parametric == 'Interactive' and self.created:
                return

        if selfobj.AlongEdge is None:
            return

        if selfobj.Edge is None and selfobj.Point is None:
            return

        try:
            vector_point = None
            m_distance = selfobj.Distance

            # m_n1 = eval(selfobj.AlongEdge[1][0].lstrip('Edge'))
            m_n1 = re.sub('[^0-9]', '', selfobj.AlongEdge[1][0])
            m_n1 = int(m_n1)

            if selfobj.Edge is not None:
                # m_n2 = eval(selfobj.Edge[1][0].lstrip('Edge'))
                m_n2 = re.sub('[^0-9]', '', selfobj.Edge[1][0])
                m_n2 = int(m_n2)
            else:
                if selfobj.Point != selfobj.AlongEdge:
                    # m_n3 = eval(selfobj.Point[1][0].lstrip('Vertex'))
                    m_n3 = re.sub('[^0-9]', '', selfobj.Point[1][0])
                else:
                    # m_n3 = eval(selfobj.Point[1][0].lstrip('Edge'))
                    m_n3 = re.sub('[^0-9]', '', selfobj.Point[1][0])
                m_n3 = int(m_n3)

            if M_DEBUG:
                print_msg("m_n1 = " + str(m_n1))
                if selfobj.Edge is not None:
                    print_msg("m_n2 = " + str(m_n2))
                else:
                    print_msg("m_n3 = " + str(m_n3))
                print_msg("m_distance = " + str(m_distance))

            m_alongedge = selfobj.AlongEdge[0].Shape.Edges[m_n1 - 1]
            if selfobj.Edge is not None:
                m_edge = selfobj.Edge[0].Shape.Edges[m_n2 - 1]
            else:
                m_point = selfobj.Point[0].Shape.Vertexes[m_n3 - 1].Point

            vector_a = m_alongedge.valueAt(0.0)
            vector_b = m_alongedge.valueAt(m_alongedge.Length)

            if isEqualVectors(vector_a, vector_b):
                return

            if selfobj.Edge is not None:
                m_dist = m_alongedge.distToShape(m_edge)
                vector_c = m_dist[1][0][0]
            else:
                vector_c = m_point

            # Calculate intersection Point
            vector_t, _, _ = intersectPerpendicularLine(vector_a,
                                                        vector_b,
                                                        vector_c,)
            if M_DEBUG:
                print_msg("m_alongedge = " + str(m_alongedge))
                if selfobj.Edge is not None:
                    print_msg("m_edge = " + str(m_edge))
                else:
                    print_msg("m_point = " + str(m_point))
                print_msg("vector_a = " + str(vector_a))
                print_msg("vector_b = " + str(vector_b))
                print_msg("vector_c = " + str(vector_c))
                print_msg("vector_t = " + str(vector_t))

            vector_translate = (vector_b - vector_a)
            if m_distance != 0.0:
                vector_translate = vector_translate.normalize() * m_distance
                vector_point = vector_t + vector_translate
            else:
                vector_point = vector_t

            if vector_point is not None:
                point = Part.Point(vector_point)
                selfobj.Shape = point.toShape()
                propertiesPoint(selfobj.Label, self.color)
                selfobj.X = float(vector_point.x)
                selfobj.Y = float(vector_point.y)
                selfobj.Z = float(vector_point.z)
                # To be compatible with previous version 2018
                if 'Parametric' in selfobj.PropertiesList:
                    self.created = True
        except AttributeError as err:
            print("AttributeError" + str(err))
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)
Example #7
0
    def execute(self, selfobj):
        """ Doing a recomputation.
        """
        m_properties_list = ['Edge',
                             'Point1',
                             'Point2',
                             'IndexPart',
                             'NumberLinePart'
                             ]
        for m_property in m_properties_list:
            if m_property not in selfobj.PropertiesList:
                return

        if M_DEBUG:
            print("running CenterLinePoint.execute !")

        # To be compatible with previous version > 2019
        if 'Parametric' in selfobj.PropertiesList:
            # Create the object the first time regardless
            # the parametric behavior
            if selfobj.Parametric == 'Not' and self.created:
                return
            if selfobj.Parametric == 'Interactive' and self.created:
                return
        # To be compatible with previous version 2018
        if 'parametric' in selfobj.PropertiesList:
            self.execute_2018(selfobj)

        try:
            vector_point = None
            if selfobj.Point1 is not None and selfobj.Point2 is not None:
                # n1 = eval(selfobj.Point1[1][0].lstrip('Vertex'))
                # n2 = eval(selfobj.Point2[1][0].lstrip('Vertex'))
                m_n1 = re.sub('[^0-9]', '', selfobj.Point1[1][0])
                m_n2 = re.sub('[^0-9]', '', selfobj.Point2[1][0])
                m_n1 = int(m_n1)
                m_n2 = int(m_n2)
                if M_DEBUG:
                    print_msg(str(selfobj.Point1))
                    print_msg(str(selfobj.Point2))
                    print_msg("m_n1 = " + str(m_n1))
                    print_msg("m_n2 = " + str(m_n2))

                point1 = selfobj.Point1[0].Shape.Vertexes[m_n1 - 1].Point
                point2 = selfobj.Point2[0].Shape.Vertexes[m_n2 - 1].Point

                vector_point = alongTwoPointsPoint(point1,
                                                   point2,
                                                   selfobj.IndexPart,
                                                   selfobj.NumberLinePart)
            elif selfobj.Edge is not None:
                m_n = re.sub('[^0-9]', '', selfobj.Edge[1][0])
                m_n = int(m_n)
                if M_DEBUG:
                    print_msg(str(selfobj.Edge))
                    print_msg("m_n = " + str(m_n))

                if not selfobj.Edge[0].Shape.Edges:
                    return

                vector_point = alongLinePoint(selfobj.Edge[0].Shape.Edges[m_n - 1],
                                              selfobj.IndexPart,
                                              selfobj.NumberLinePart)
            if vector_point is not None:
                point = Part.Point(vector_point)
                selfobj.Shape = point.toShape()
                propertiesPoint(selfobj.Label, self.color)
                selfobj.X = float(vector_point.x)
                selfobj.Y = float(vector_point.y)
                selfobj.Z = float(vector_point.z)
                # To be compatible with previous version 2018
                if 'Parametric' in selfobj.PropertiesList:
                    self.created = True
        except AttributeError as err:
            print("AttributeError" + str(err))
        except Exception as err:
            printError_msg(err.args[0], title=M_MACRO)