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 getPathInPrims(self):
return InfoPathPrim.convertListFromInfoPrimToPrim(self.path)
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
