def createRandomSolutionFromSkeleton2(levelS, ratio):
# s = timeit.default_timer()
walls = [wallSkeleton.copyWithoutVoiles() for wallSkeleton in levelS.wallSkeletons]
# e = timeit.default_timer()
# print ("time it took copy1: " + str(e - s))
levelSkeleton = LevelSkeleton(walls,levelS.slabSkeleton.copy(),levelS.level)
voilesfixedLength = levelSkeleton.getVoilesTotalLength()
totalLength = levelSkeleton.getWallsTotalLength() - voilesfixedLength
needed = levelSkeleton.getVoileLengthNeeded(ratio)*2 - voilesfixedLength
# print("needed : " + str(needed) + " total length: " + str(totalLength))
size = len(levelSkeleton.wallSkeletons)
indexes = list(range(size))
# s1 = timeit.default_timer()
while len(indexes) > 0 and needed > 0:
ind = int(random.uniform(0,len(indexes)-0.1))
rand = indexes[ind]
del indexes[ind]
wallSkeleton = levelSkeleton.wallSkeletons[rand]
# s = timeit.default_timer()
length, voiles = wallSkeleton.createRandomVoilesFromLengthNeeded(totalLength, needed)
# e = timeit.default_timer()
# print ("time it took create voiles: " + str(e - s))
totalLength -= (wallSkeleton.vecLength.magn() - wallSkeleton.getVoilesLength())
wallSkeleton.attachVoiles(voiles)
needed -= length
# print("total length left: " + str(totalLength) + " needed left: " + str(needed))
# e1 = timeit.default_timer()
# print ("time it took loop: " + str(e1 - s1))
return Solution(levelSkeleton)
def init_skeletons(self, ind):
self.skeletonLevels = [
LevelSkeleton.createSkeletonFromLevel(level)
for level in self.levels
]
self.levelsHash = dict(list(zip(self.levels, self.skeletonLevels)))
self.skeletonLevelsHash = dict(
list(zip(self.skeletonLevels, self.levels)))
print(self.levels)
print(self.skeletonLevels)
self.levels = [
level for level in self.levels
if len(self.levelsHash[level].getPolys())
]
for level in self.levels:
level.relatedLevels = self.levels
self.skeletonLevels = [
levelSkeleton for levelSkeleton in self.skeletonLevels
if len(levelSkeleton.getPolys())
]
print("INFO INIT: DONE GENERATING LEVELSKELETONS FROM LEVELS")
baseSlabHeight = 0
for level in self.levels:
if not len(self.levelsHash[level].getPolys()
): # or level.getHeight() <= 0:
baseSlabHeight = level.getHeight()
else:
break
print(baseSlabHeight)
for i, levelSkeleton in enumerate(self.skeletonLevels):
prevLevels = self.skeletonLevelsHash[
levelSkeleton].getRightLowerLevels()
if not prevLevels:
continue
prevLevels = [
self.levelsHash[level] for level in prevLevels
if level.getHeight() >= baseSlabHeight
]
print(prevLevels)
if not len(prevLevels):
continue
levelSkeleton.restrictLevelUsableWalls(prevLevels)
if ind == 1:
self.skeletonLevels = LevelSkeleton.removeUnwantedWalls(
self.skeletonLevels, self.axesSolution, self.Columns)
self.solutions = {}
def cross(solution1, solution2):
levelS1 = solution1.levelSkeleton
levelS2 = solution2.levelSkeleton
resultWalls1 = []
resultWalls2 = []
for wall1, wall2 in zip(levelS1.wallSkeletons, levelS2.wallSkeletons):
w1, w2 = crossWalls(wall1, wall2, random.uniform(0, 1))
resultWalls1.append(w1)
resultWalls2.append(w2)
s1 = Solution(
LevelSkeleton(resultWalls1, levelS1.slabSkeleton, levelS1.level))
s2 = Solution(
LevelSkeleton(resultWalls2, levelS1.slabSkeleton, levelS1.level))
return s1, s2
def reinit_skeletons(self):
self.skeletonLevels = [LevelSkeleton.createSkeletonFromLevel(level) for level in self.levels]
self.levelsHash = dict(list(zip(self.levels, self.skeletonLevels)))
self.skeletonLevelsHash = dict(list(zip(self.skeletonLevels, self.levels)))
print("INFO INIT: DONE GENERATING LEVELSKELETONS FROM LEVELS")
baseSlabHeight = 0
for level in self.levels:
if not len(self.levelsHash[level].getPolys()): # or level.getHeight() <= 0:
baseSlabHeight = level.getHeight()
else:
break
for i, levelSkeleton in enumerate(self.skeletonLevels):
prevLevels = self.skeletonLevelsHash[levelSkeleton].getRightLowerLevels()
if not prevLevels:
continue
prevLevels = [self.levelsHash[level] for level in prevLevels if level.getHeight() > baseSlabHeight]
if not len(prevLevels):
continue
levelSkeleton.restrictLevelUsableWalls(prevLevels)
self.levels = [level for level in self.levels if len(self.levelsHash[level].getPolys())]
self.skeletonLevels = [levelSkeleton for levelSkeleton in self.skeletonLevels if len(levelSkeleton.getPolys())]
self.solutions = {}
def columnSearch(self):
self.potentialColumns, self.haxes, self.vaxes = WallSkeleton.Columns(
self.skeletonLevels, 0)
axes = [self.haxes, self.vaxes]
nlvls = len(self.skeletonLevels)
self.axesSolution = tabu_search(self.potentialColumns,
axes,
self.skeletonLevels[nlvls -
1].slabSkeleton,
limit=20)
print("Haxis solution:")
for axis in self.axesSolution.axes[0]:
print(axis.bounds)
print("Vaxis solution:")
for axis in self.axesSolution.axes[1]:
print(axis.bounds)
Columns = []
for Haxis in self.axesSolution.axes[0]:
for Vaxis in self.axesSolution.axes[1]:
column = linestring.BaseGeometry.intersection(Haxis, Vaxis)
if column not in Columns: Columns.append(column)
Distances = WallSkeleton.ColumnDistances(Columns)
for i in range(len(Columns)):
print("Distance of the column", i, "(", Columns[i].x, Columns[i].y,
")", Distances[0][i], Distances[1][i])
print("Total Height here:", self.totalHeight)
self.Columns, self.ColumnsLength = LevelSkeleton.CreateColumnShapes(
Distances, self.totalHeight, Columns)
for Column in self.Columns:
# VDim = round(Column.poly.MaxCoords().y()-Column.poly.MinCoods().y())
# Hdim = round(Column.poly.MaxCoords().x()-Column.poly.MinCoods().x())
print("Column:", Column.centroid, "Vdim:", Column.bounds)
def cross(solution1, solution2):
levelS1 = solution1.levelSkeleton
levelS2 = solution2.levelSkeleton
resultWalls1 = []
resultWalls2 = []
wallSkeletons1 = []
wallSkeletons2 = []
reserve1 = []
reserve2 = []
for wallskeleton in levelS1.wallSkeletons:
if not wallskeleton.iscolumnParent:
wallSkeletons1.append(wallskeleton)
else:
reserve1.append(wallskeleton)
for wallskeleton in levelS2.wallSkeletons:
if not wallskeleton.iscolumnParent:
wallSkeletons2.append(wallskeleton)
else:
reserve2.append(wallskeleton)
for wall1, wall2 in zip(wallSkeletons1, wallSkeletons2):
rand = random.uniform(0, 1)
if rand < 0.5:
resultWalls1.append(wall1)
resultWalls2.append(wall2)
else:
resultWalls1.append(wall2)
resultWalls2.append(wall1)
for wall in reserve1:
resultWalls1.append(wall)
for wall in reserve2:
resultWalls2.append(wall)
s1 = Solution(
LevelSkeleton(resultWalls1, levelS1.slabSkeleton, levelS1.level))
s2 = Solution(
LevelSkeleton(resultWalls2, levelS1.slabSkeleton, levelS1.level))
a = s1.levelSkeleton.ScoreOfUnacceptableVoiles()
b = s2.levelSkeleton.ScoreOfUnacceptableVoiles()
# print(a,b)
if 0 < a[0] < 0.9:
s1 = fixShortbeam(s1, a)
if 0 < b[0] < 0.9:
s1 = fixShortbeam(s2, b)
return s1, s2
def merge(solution1, solution2):
levelS1 = solution1.levelSkeleton
levelS2 = solution2.levelSkeleton
resultWalls = []
for wall1, wall2 in zip(levelS1.wallSkeletons, levelS2.wallSkeletons):
resultWalls.append(mergeWalls(wall1, wall2))
return Solution(
LevelSkeleton(resultWalls, levelS1.slabSkeleton, levelS1.level))
def cross(solution1,solution2):
levelS1 = solution1.levelSkeleton
levelS2 = solution2.levelSkeleton
resultWalls1 = []
resultWalls2 = []
for wall1,wall2 in zip(levelS1.wallSkeletons,levelS2.wallSkeletons):
rand = random.uniform(0,1)
if rand < 0.5:
resultWalls1.append(wall1)
resultWalls2.append(wall2)
else:
resultWalls1.append(wall2)
resultWalls2.append(wall1)
s1 = Solution(LevelSkeleton(resultWalls1,levelS1.slabSkeleton,levelS1.level))
s2 = Solution(LevelSkeleton(resultWalls2,levelS1.slabSkeleton,levelS1.level))
return s1,s2
def __init__(self, parent=None, wallShapes=None, slabShapes=None):
super(Launcher, self).__init__()
self.constraints = {
"ecc_w": -0.5,
"area_w": 1,
"length_w": 1,
"ratio": 1,
"d": 1,
}
self.levels = Level.generateLevelsFromShapes(wallShapes, slabShapes)
print("INFO INIT: DONE GENERATING LEVELS FROM SHAPES")
self.levels.sort(key=lambda lvl: lvl.getHeight())
self.skeletonLevels = [
LevelSkeleton.createSkeletonFromLevel(level)
for level in self.levels
]
self.levelsHash = dict(list(zip(self.levels, self.skeletonLevels)))
self.skeletonLevelsHash = dict(
list(zip(self.skeletonLevels, self.levels)))
print("INFO INIT: DONE GENERATING LEVELSKELETONS FROM LEVELS")
baseSlabHeight = 0
for level in self.levels:
if not len(self.levelsHash[level].getPolys()
): # or level.getHeight() <= 0:
baseSlabHeight = level.getHeight()
else:
break
for i, levelSkeleton in enumerate(self.skeletonLevels):
prevLevels = self.skeletonLevelsHash[
levelSkeleton].getRightLowerLevels()
if not prevLevels:
continue
prevLevels = [
self.levelsHash[level] for level in prevLevels
if level.getHeight() > baseSlabHeight
]
if not len(prevLevels):
continue
levelSkeleton.restrictLevelUsableWalls(prevLevels)
self.levels = [
level for level in self.levels
if len(self.levelsHash[level].getPolys())
]
for level in self.levels:
level.relatedLevels = self.levels
level.rlowerLevels = None
self.skeletonLevels = [
levelSkeleton for levelSkeleton in self.skeletonLevels
if len(levelSkeleton.getPolys())
]
self.solutions = {}
self.selectedRow = 1
self.pend = True
def getPolygonsFromLevels(self, levels):
polys = []
for level in levels:
polys += self.getPolygonsFromLevelSkeletons(
LevelSkeleton.createSkeletonFromLevel(level))
return polys
def __init__(self,
parent=None,
wallShapes=None,
slabShapes=None,
spaceShapes=None):
super(TryApp, self).__init__(parent)
self.constraints = {
"ecc_w": -0.5,
"area_w": 1,
"length_w": 1,
"ratio": 1,
"d": 1,
}
self.setupUi(self)
self.levels = Level.generateLevelsFromShapes(wallShapes, slabShapes)
print("INFO INIT: DONE GENERATING LEVELS FROM SHAPES")
self.levels.sort(key=lambda lvl: lvl.getHeight())
self.skeletonLevels = [
LevelSkeleton.createSkeletonFromLevel(level)
for level in self.levels
]
self.levelsHash = dict(list(zip(self.levels, self.skeletonLevels)))
self.skeletonLevelsHash = dict(
list(zip(self.skeletonLevels, self.levels)))
print("INFO INIT: DONE GENERATING LEVELSKELETONS FROM LEVELS")
baseSlabHeight = 0
for level in self.levels:
if not len(self.levelsHash[level].getPolys()
): # or level.getHeight() <= 0:
baseSlabHeight = level.getHeight()
else:
break
print(("getting lower levels", len(self.skeletonLevels)))
for i, levelSkeleton in enumerate(self.skeletonLevels):
prevLevels = self.skeletonLevelsHash[
levelSkeleton].getRightLowerLevels()
print(("getting for level", i))
if not prevLevels:
continue
prevLevels = [
self.levelsHash[level] for level in prevLevels
if level.getHeight() > baseSlabHeight
]
if not len(prevLevels):
continue
levelSkeleton.restrictLevelUsableWalls(prevLevels)
self.storey_mode = False
self.levels = [
level for level in self.levels
if len(self.levelsHash[level].getPolys())
]
self.skeletonLevels = [
levelSkeleton for levelSkeleton in self.skeletonLevels
if len(levelSkeleton.getPolys())
]
self.storeySkeletons = []
heights = []
for levelSkeleton in self.skeletonLevels:
height = levelSkeleton.level.getHeight()
if height not in heights:
skeletons = [levelSkeleton]
heights.append(height)
for ls in self.skeletonLevels:
if ls.level.getHeight() == height:
skeletons.append(ls)
self.storeySkeletons.append(StoreySkeleton(skeletons))
self.solutions = {}
self.selectedRow = 1
self.initListView(self.storey_mode)
self.listView.setModel(self.model)
self.listView.clicked.connect(self.listViewSelected)
self.sol1.clicked.connect(self.sol1CB)
self.sol2.clicked.connect(self.sol2CB)
self.merge.clicked.connect(self.mergeCB)
self.cross.clicked.connect(self.crossCB)
self.showLower.clicked.connect(self.showLowerFun)
self.scrollTab = QtGui.QScrollArea()
self.tabWidget.addTab(self.scrollTab, "upperView")
self.addViewerTab("Walls")
self.addViewerTab("Slabs")
self.addViewerTab("All")
self.addViewerTab("Selected")
self.tabWidget.removeTab(0)
self.tabWidget.removeTab(0)
self.setViewerDisplay("Walls", wallShapes)
self.setViewerDisplay("Slabs", slabShapes)
all = wallShapes + slabShapes
self.setViewerDisplay("All", all)
self.pend = True
def __init__(self, parent=None, wallShapes=None, slabShapes=None):
super(Launcher, self).__init__()
self.constraints = {
"ecc_w": -0.5,
"area_w": 1,
"length_w": 1,
"ratio": 1,
"d": 1,
}
self.levels = Level.generateLevelsFromShapes(wallShapes, slabShapes)
print("INFO INIT: DONE GENERATING LEVELS FROM SHAPES")
self.levels.sort(key=lambda lvl: lvl.getHeight())
self.skeletonLevels = [
LevelSkeleton.createSkeletonFromLevel(level)
for level in self.levels
]
self.levelsHash = dict(list(zip(self.levels, self.skeletonLevels)))
self.skeletonLevelsHash = dict(
list(zip(self.skeletonLevels, self.levels)))
print("INFO INIT: DONE GENERATING LEVELSKELETONS FROM LEVELS")
baseSlabHeight = 0
for level in self.levels:
if not len(self.levelsHash[level].getPolys()
): # or level.getHeight() <= 0:
baseSlabHeight = level.getHeight()
else:
break
for i, levelSkeleton in enumerate(self.skeletonLevels):
prevLevels = self.skeletonLevelsHash[
levelSkeleton].getRightLowerLevels()
if not prevLevels:
continue
prevLevels = [
self.levelsHash[level] for level in prevLevels
if level.getHeight() > baseSlabHeight
]
if not len(prevLevels):
continue
levelSkeleton.restrictLevelUsableWalls(prevLevels)
self.storey_mode = False
self.levels = [
level for level in self.levels
if len(self.levelsHash[level].getPolys())
]
self.skeletonLevels = [
levelSkeleton for levelSkeleton in self.skeletonLevels
if len(levelSkeleton.getPolys())
]
self.storeySkeletons = []
heights = []
for levelSkeleton in self.skeletonLevels:
height = levelSkeleton.level.getHeight()
if height not in heights:
skeletons = [levelSkeleton]
heights.append(height)
for ls in self.skeletonLevels:
if ls.level.getHeight() == height:
skeletons.append(ls)
self.storeySkeletons.append(StoreySkeleton(skeletons))
self.solutions = {}
self.solutions = {}
self.selectedRow = 1
self.pend = True
# Vertical Loads
Sdiv = SlabDivision(self.storeySkeletons[0])
# Sdiv.importWalls(self.skeletonLevels[0])
# Seg = Sdiv.createSlabSegments()
# f2 = plt.figure(3,)
# for segment in Sdiv.createSlabSegments():
# segment.End1.plotEnd()
# segment.End2.plotEnd()
# segment.PlotSeg()
for room in Sdiv.rooms:
# 0x7fd0cba0b9e0 >
print(("room", room))
fig, ax = plt.subplots()
color = (random(), random(), random())
color2 = (random(), random(), random())
for segment in room.get_segments():
e1, e2 = segment.End1.PntCoord, segment.End2.PntCoord
pnt1 = Pnt(e1.x, e1.y)
pnt2 = Pnt(e2.x, e2.y)
c = color if pnt1.isInPolygon(room.slab_poly) else "r"
segment.End1.plot(c, (fig, ax))
c2 = color if pnt2.isInPolygon(room.slab_poly) else "r"
segment.End2.plot(c2, (fig, ax))
segment.plot(color, (fig, ax))
room.plot(color2, figax=(fig, ax))
# axes = ax.gca()
ax.set_xlim([-10, 10])
ax.set_ylim([-8, 8])
plt.show()
