Python GeoMath.getSharedEdgesPrims方法代码示例

# 需要导入模块: from lib import GeoMath [as 别名]
# 或者: from lib.GeoMath import getSharedEdgesPrims [as 别名]
    def houDoBooleanOperation(self, prim, previousPrim, listOfDividedPrims, crack, volumeNode, sweepingNode):
        logging.debug("Start method houDoBooleanOperation, class PrimDivided")
        global epsilon
        logging.debug("This prim: %s", str(prim))
        logging.debug("Previous prim: %s", str(previousPrim))
        if previousPrim in listOfDividedPrims.keys():
            edgeToValidate = GeoMath.getSharedEdges(
                listOfDividedPrims[previousPrim].pointsOutside,
                [list(po.point().position()) for po in prim.vertices()],
                1,
            )
            if not edgeToValidate:
                self.prim = None
                logging.error("No edge to validate")
                logging.debug(
                    "Start method houDoBooleanOperation, class PrimDivided. State: No edge to valide in prim %s",
                    str(prim.number()),
                )
                return False
            edgeToValidate = edgeToValidate[0]
        else:
            edgeToValidate = GeoMath.getSharedEdgesPrims(previousPrim, prim, 1)[0]
            if not edgeToValidate:
                logging.error("No edge to validate")
                logging.debug(
                    "Start method houDoBooleanOperation, class PrimDivided. State: No edge to valide in prim %s",
                    str(prim.number()),
                )
                self.prim = None
                return False

        logging.debug("Edge to validate: %s", str(edgeToValidate))
        edgeToValidate = [list(edgeToValidate[0]), list(edgeToValidate[1])]

        firstPointCrack = crack[prim][0]
        lastPointCrack = crack[prim][len(crack[prim]) - 1]
        matched = False
        # Points ordered by prim
        points = [list(p.point().position()) for p in prim.vertices()]
        edgeFirst = GeoMath.getEdgeWithPointInPrim(prim, firstPointCrack)
        edgeFirst = [list(edgeFirst[0]), list(edgeFirst[1])]
        # Put the edge in clockwise direction
        if GeoMath.determineDirEdge(edgeFirst, prim, True):
            curEdge = [firstPointCrack, edgeFirst[1]]
        else:
            curEdge = [firstPointCrack, edgeFirst[0]]
        index = 0
        logging.debug("Points: %s", str(points))
        logging.debug("Current edge: %s", str(curEdge))
        count = 0
        while points[index] != curEdge[1]:
            count += 1
            if count == 10:
                logging.error("First edge not found")
                logging.debug("End method houDoBooleanOperation, class PrimDivided. State: first edge not found")
                return
            index += 1
        nextIndex = (index + 1) % len(points)
        nextEdge = [curEdge[1], points[nextIndex]]
        edgeLast = GeoMath.getEdgeWithPointInPrim(prim, lastPointCrack)
        edgeLast = [list(edgeLast[0]), list(edgeLast[1])]
        if not GeoMath.determineDirEdge(edgeLast, prim, True):
            edgeLast = [list(edgeLast[1]), list(edgeLast[0])]
        pointsDisplaced = []

        # Normal iteration over points
        count = 0
        logging.debug("Last edge where the 'to validate edge' lies: %s", str(edgeLast))
        self.pointsOutside = []
        logging.debug("Normal iteration over points")
        while len(GeoMath.getSharedEdges(curEdge, edgeLast, 1)) == 0:
            logging.debug("Current edge: %s", str(curEdge))
            count += 1
            if count == 10:
                logging.error("Last edge not found")
                logging.debug("End method houDoBooleanOperation, class PrimDivided. State: Last edge not found")
                return
            # Calcule the displacement
            vecDis = self.calculateDisplacement(curEdge, nextEdge)
            pointDisplaced = self.applyDisplacement(curEdge[1], vecDis)
            # Add displace point
            pointsDisplaced.append(pointDisplaced)
            self.pointsOutside.append(curEdge[1])
            if len(GeoMath.getSharedEdges(curEdge, edgeToValidate, 1)) > 0:
                matched = True
            curEdge = [curEdge[1], points[nextIndex]]
            nextIndex = (nextIndex + 1) % len(points)
            nextEdge = [nextEdge[1], points[nextIndex]]
        logging.debug("Ha salido del segundo bucle con: %s", str(curEdge))
        curEdge = [curEdge[0], lastPointCrack]
        # Last comprovation
        if not matched and (len(GeoMath.getSharedEdges(curEdge, edgeToValidate, 1)) > 0):
            logging.debug("Final comprovation edge: %s", str(curEdge))
            matched = True
        if not matched:
            logging.debug("Not matched at normal iteration over points, trying in inverse mode")
            # Do inverse
            # Put the edge in not clockwise direction
            if GeoMath.determineDirEdge(edgeFirst, prim, False):
                curEdge = [firstPointCrack, edgeFirst[1]]
#.........这里部分代码省略.........

# 需要导入模块: from lib import GeoMath [as 别名]
# 或者: from lib.GeoMath import getSharedEdgesPrims [as 别名]
 def getExtremPrims(self, Ipoint, primOfIpoint, partDes, refPrim, notDes, volume=None):
     '''
     We can't ensure that the primitives have a posible path, but we ensure that last primitive
     have at least 2 adjacent primitives and first primitive is connected with the last primitive
     '''
     logging.debug("Start method getExtremPrims, class DefPath")
     firstPrim = None
     lastPrim = None
     if(primOfIpoint and Ipoint):
         # NOT YET TOTALLY IMPLEMENTED
         edge = GeoMath.getEdgeWithPointInPrim(primOfIpoint, Ipoint)
         lastPrim = primOfIpoint
         for prim in partDes:
             if(prim != lastPrim):
                 sharedEdges = GeoMath.getSharedEdgesPrims(lastPrim, prim)
                 rs_lP_fP = False
                 if(volume):
                     for edge in sharedEdges:
                         rs = RejectionSampling.RejectionSampling(edge, volume)
                         rs.do()
                         point = rs.getValue()
                         if(point):
                             rs_lP_fP = True
                             break
                 if (len(sharedEdges >= 1) and  (edge in sharedEdges) and (volume == None or rs_lP_fP)):
                     firstPrim = prim
     else:
         # Automatically decision of extrem prims.
         # Ensure that 2 prims is connected to another primitive in
         # group of partially destroyed.
         # Didn't use "getConnectedPrims" because need ramdonless in choice of prims.
         stopSearch = False
         tempList1 = list(partDes)
         # minimum of 4 prims to get a path
         while (len(tempList1) > 4 and not stopSearch):
             numPrim1 = random.randint(0, len(tempList1) - 1)
             prim1 = tempList1[numPrim1]
             del tempList1[numPrim1]
             # We have to ensure that first prim has at least two conected prims
             if(True):  # prim1.number()>17 and prim1.number()<27
                 while((len(GeoMath.getConnectedPrims(prim1, list(partDes), 2)) < 2) and (len(tempList1) > 4)):
                     numPrim1 = random.randint(0, len(tempList1) - 1)
                     prim1 = tempList1[numPrim1]
                     del tempList1[numPrim1]
                 # If prim1 has at least two conected prims
                 if(len(tempList1) > 4):
                     conectedToPrim1 = GeoMath.getConnectedPrims(prim1, list(tempList1))
                     while (len(conectedToPrim1) > 0 and not stopSearch):
                         numPrim2 = random.randint(0, len(conectedToPrim1) - 1)
                         prim2 = conectedToPrim1[numPrim2]
                         if(prim2 != prim1):
                             # If prim2 has at least 2 conected prims
                             if(len(GeoMath.getConnectedPrims(prim2, list(tempList1), 2)) >= 2):
                                 stopSearch = True
                                 if(volume):
                                     rs_lP_fP = False
                                     for edge in GeoMath.getEdgesBetweenPrims(prim1, prim2):
                                         logging.debug("Edge: %s", str(edge))
                                         rs = RejectionSampling.RejectionSampling(edge, volume)
                                         rs.do()
                                         point = rs.getValue()
                                         if(point):
                                             rs_lP_fP = True
                                             break
                                     if(not rs_lP_fP):
                                         stopSearch = False
                                 if(stopSearch):
                                     # Assign the last evaluate because we have it now in a variable.
                                     firstPrim = InfoPathPrim.InfoPathPrim(prim2)
                                     # Last prim sure has two adjacent primitives.
                                     lastPrim = InfoPathPrim.InfoPathPrim(prim1)
                                     firstPrim.setiPoint(list(point))
                                     lastPrim.setfPoint(list(point))
                         del conectedToPrim1[numPrim2]
         if(firstPrim and lastPrim):
             logging.debug("End method getExtremPrims, class DefPath. State: good")
         else:
             logging.debug("End method getExtremPrims, class DefPath. State: no extrem prims")
         return firstPrim, lastPrim