def __init__(self, firstPrim, lastPrim, partDes, totDes, volume=None, max_iterations=None): global DEBUG if(DEBUG): reload(GeoMath) reload(InfoPathPrim) self.volume = volume #Convert all in InfoPathPrims indexFirst = partDes.index(firstPrim.prim) indexLast = partDes.index(lastPrim.prim) infoPartDes = InfoPathPrim.convertListIntoInfoPrim(partDes) infoTotDes = InfoPathPrim.convertListIntoInfoPrim(totDes) infoPartDes[indexFirst] = firstPrim infoPartDes[indexLast] = lastPrim firstInfoPrim = firstPrim lastInfoPrim = lastPrim self.firstPrim = firstInfoPrim self.lastPrim = lastInfoPrim self.partDes = infoPartDes self.totDes = infoTotDes self.clockwise = False self.goodPath = False self.path = [] self.max_iterations_exceeded = False self.currentIteration = 0 if(max_iterations): self.max_interations = max_iterations else: self.auto_choose_max_iterations()
def showCrack(self, node, groupOfInfoPrimsOrdered, allInOne): groupOfPrimsOrdered = InfoPathPrim.convertListFromInfoPrimToPrim(groupOfInfoPrimsOrdered) for countPrim in range(len(groupOfPrimsOrdered)): pointsString = "" prim = groupOfPrimsOrdered[countPrim] if(allInOne): crackNode = node.createNode('curve', 'crack_patternPrim_' + str(prim.number())) if(prim in self.linePerPrim): listOfPoints = self.linePerPrim[prim] for point in listOfPoints: pointsString = pointsString + str(point[0]) + "," + str(point[1]) + "," + str(point[2]) + " " crackNode.parm('coords').set(pointsString) crackNode.moveToGoodPosition() crackNode.setTemplateFlag(True) self.showCrackNodes.append(crackNode) else: count = 0 if(prim in self.patternCrack): for patt in self.patternCrack[prim]: # Show crack crackNode = node.createNode('curve', 'crack_pattern_' + str(prim.number()) + "_" + str(count)) pointsString = "" for point in patt.getPoints(): pointsString = pointsString + str(point[0]) + "," + str(point[1]) + "," + str(point[2]) + " " crackNode.parm('coords').set(pointsString) crackNode.moveToGoodPosition() crackNode.setTemplateFlag(True) self.showCrackNodes.append(crackNode) count += 1
def getPathAstar(self, firstPrim, lastPrim, notDes, partDes, totDes, refPrim, minimum=True, aperture=150, volume=None, DEBUG=False): p = PathAstar.PathAstar(firstPrim, lastPrim, partDes, refPrim, minimum, aperture, volume) p.do() if (len(p.path) > 3): if (ValidatePath.ValidatePath( notDes, partDes, totDes, InfoPathPrim.convertListFromInfoPrimToPrim( p.path)).getisValid()): logging.debug( "End method getPathBackTracking, class DefPath. State: good" ) goodPath = True else: logging.debug("Path have not closure around totally destroyed") goodPath = False else: logging.error("No path") logging.debug( "End method getPathBackTracking, class DefPath. State: path < 4" ) goodPath = False return p.getPath(), goodPath
def doLineCrackPerPrim(self, groupOfInfoPrimsOrdered): groupOfPrimsOrdered = InfoPathPrim.convertListFromInfoPrimToPrim(groupOfInfoPrimsOrdered) for prim in groupOfPrimsOrdered: self.linePerPrim[prim] = [] if(prim in self.patternCrack): for patt in self.patternCrack[prim]: for point in patt.getPoints(): self.linePerPrim[prim].append(point)
def getPathAstar(self, firstPrim, lastPrim, notDes, partDes, totDes, refPrim, minimum=True, aperture=150, volume=None, DEBUG=False): p = PathAstar.PathAstar(firstPrim, lastPrim, partDes, refPrim, minimum, aperture, volume) p.do() if(len(p.path) > 3): if(ValidatePath.ValidatePath(notDes, partDes, totDes, InfoPathPrim.convertListFromInfoPrimToPrim(p.path)).getisValid()): logging.debug("End method getPathBackTracking, class DefPath. State: good") goodPath = True else: logging.debug("Path have not closure around totally destroyed") goodPath = False else: logging.error("No path") logging.debug("End method getPathBackTracking, class DefPath. State: path < 4") goodPath = False return p.getPath(), goodPath
def __init__(self, firstPrim, lastPrim, partDes, refPrim, minimum=True, aperture=150, volume=None, DEBUG=False): # Convert all in InfoPathPrims indexFirst = partDes.index(firstPrim.prim) indexLast = partDes.index(lastPrim.prim) self.firstPrim = firstPrim self.lastPrim = lastPrim self.partDes = InfoPathPrim.convertListIntoInfoPrim(partDes) self.partDes[indexFirst] = firstPrim self.partDes[indexLast] = lastPrim self.refPrim = InfoPathPrim.InfoPathPrim(refPrim) self.minimum = minimum self.aperture = aperture self.volume = volume self.DEBUG = DEBUG
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
def getPathInPrims(self): return InfoPathPrim.convertListFromInfoPrimToPrim(self.path)
def backTracking(self, curPrim, path): global TimeExecutionFirst global TimeExecutionCurrent global MAXTIMEFORONEPATH global DEBUG logging.debug("Start method backTracking, class PathBackTracking") logging.debug("Current prim from parm: %s", str(curPrim.prim.number())) conPrims = GeoMath.getConnectedInfoPrims(curPrim, self.partDes) indexPrims = 0 pathAchieved = False startPoint = None max_iterations_exceeded = False while (not pathAchieved and indexPrims < len(conPrims) and not max_iterations_exceeded): logging.debug("Current iteration: " + str(self.currentIteration)) self.currentIteration += 1 nextPrim = conPrims[indexPrims] #Now, choose the best prim reference refPrim = self.getBestPrimReference(curPrim) logging.debug("Current prim: %s. Next prim: %s", str(curPrim.prim.number()), str(nextPrim.prim.number())) logging.debug("Conected prims: %s. Count: %s", str([p.prim.number() for p in conPrims]), str(indexPrims)) logging.debug("Reference prim: %s", str(refPrim.prim.number())) if(nextPrim not in path): if(self.volume): edges = GeoMath.getEdgesBetweenPrims(curPrim.prim, nextPrim.prim) for edge in edges: rs = RejectionSampling.RejectionSampling(edge, self.volume) rs.do() startPoint = rs.getValue() if(startPoint): break logging.debug("Inicial point: %s", str(startPoint)) if(startPoint): angleMin, angleMax = GeoMath.getMinMaxAngleBetweenPointsInPrim(curPrim.prim, nextPrim.prim, refPrim.prim) logging.debug("Current prim: %s. Next prim: s", str(curPrim.prim.number()), str(nextPrim.prim.number())) logging.debug("Min angle: %s. Max angle: %s", str(angleMin), str(angleMax)) if(self.clockWise and (angleMin > 0 or angleMin < -(math.pi - math.pi * 0.1))): logging.debug("ignorada por clockwise y revolverse") if(not self.clockWise and (angleMax < 0 and angleMax < (math.pi - math.pi * 0.1))): logging.debug("ignorada por not clockwise y revolverse") if(nextPrim == self.lastPrim and curPrim.sumAngle < (1.4 * math.pi)): logging.debug("ignorada por ultima y angulo no suficiente") if((nextPrim == self.lastPrim and curPrim.sumAngle > (1.4 * math.pi))): logging.debug("aceptada por ultima y angulo suficiente") if((not((self.clockWise and (angleMin > 0 or angleMin < -(math.pi - math.pi * 0.01))) or \ (not self.clockWise and (angleMax < 0 or angleMax > (math.pi - math.pi * 0.01))) or \ (nextPrim == self.lastPrim and curPrim.sumAngle < (1.4 * math.pi))) or \ (nextPrim == self.lastPrim and curPrim.sumAngle > (1.4 * math.pi)))): ch = CalculateHeuristic.CalculateHeuristic(curPrim, nextPrim, refPrim) ch.do() curPrim.next = nextPrim curPrim.setfPoint(list(startPoint)) nextPrim.setiPoint(list(startPoint)) path.append(nextPrim) logging.debug("Path: %s", str([p.number() for p in InfoPathPrim.convertListFromInfoPrimToPrim(path)])) if(nextPrim == self.lastPrim): #BASE CASE logging.debug("Last prim achieved") pathAchieved = True if((self.currentIteration >= self.max_interations / 2) and not pathAchieved): self.max_iterations_exceeded = True logging.error('Max iterations, no path achieved in the maximum iterations') #path.remove(nextPrim) pathAchieved = False if(not pathAchieved and not self.max_iterations_exceeded and self.backTracking(nextPrim, path)): pathAchieved = True elif (not pathAchieved and not self.max_iterations_exceeded): path.remove(nextPrim) logging.debug("Path: %s", str([p.number() for p in InfoPathPrim.convertListFromInfoPrimToPrim(path)])) indexPrims += 1 if(pathAchieved): logging.debug("End ireration of while, method backTracking, class PathBackTracking. State: good") else: logging.debug("End ireration of while, method backTracking, class PathBackTracking. State: no path achieved") return pathAchieved