def compute(self, inputs, outputs):
layout = inputs["layout"]
squares = []
for n in range(n_quadrilaterals):
square = [[1.0 / n_quadrilaterals * n, 0.0],
[n * 1.0 / n_quadrilaterals, 1.0],
[(n + 1) * 1.0 / n_quadrilaterals, 1.0],
[(n + 1) * 1.0 / n_quadrilaterals, 0.0]]
squares.append(square)
area = inputs["areas"]
maps = [
AreaMapping(area[n], squares[n]) for n in range(n_quadrilaterals)
]
count = 0
magnitude = 0.0
for t in layout:
if t[1] > separation_equation_y(t[0]):
mapped = maps[0].transform_to_rectangle(t[0], t[1])
else:
mapped = maps[1].transform_to_rectangle(t[0], t[1])
c, m = self.inarea(mapped)
count += c
magnitude += m
outputs["n_constraint_violations"] = count
outputs["magnitude_violations"] = magnitude
def create_random():
xt, yt = 2.0, 2.0
while (xt < 0.0 or xt > 1.0) or (yt < 0.0 or yt > 1.0):
xb, yb = uniform(
min(min([item[0] for item in areas[0]]),
min([item[0] for item in areas[1]])),
max(max([item[0] for item in areas[0]]),
max([item[0] for item in areas[1]]))), uniform(
min(min([item[1] for item in areas[0]]),
min([item[1] for item in areas[1]])),
max(max([item[1] for item in areas[0]]),
max([item[1] for item in areas[1]])))
if yb > separation_equation_y(xb):
xt, yt = borssele_mapping1.transform_to_rectangle(xb, yb)
else:
xt, yt = borssele_mapping2.transform_to_rectangle(xb, yb)
return [xb, yb]
def regular_layout(dx, dy, dh, areas, angle):
layout_final = []
centroid_small = centroid(areas)
angle = deg2rad(angle)
with open("area.dat", "w") as areaout:
for area in areas:
for n in list(range(4)) + [0]:
areaout.write("{} {}\n".format(area[n][0], area[n][1]))
n_rows = int(
old_div((max([
rotate(place, angle, centroid_small)[0] for area in areas
for place in area
]) - min([
rotate(place, angle, centroid_small)[0] for area in areas
for place in area
])), dx)) + 10
n_columns = int(
old_div((max([
rotate(place, angle, centroid_small)[1] for area in areas
for place in area
]) - min([
rotate(place, angle, centroid_small)[1] for area in areas
for place in area
])), dy)) + 10
layout = [[[0, 0] for _ in range(n_columns)] for _ in range(n_rows)]
layout_translated = [[[0, 0] for _ in range(n_columns)]
for _ in range(n_rows)]
layout_rotated = [[[0, 0] for _ in range(n_columns)]
for _ in range(n_rows)]
x0, y0 = min([place[0] for area in areas for place in area
]), min([place[1] for area in areas for place in area])
layout[0][0] = [x0, y0]
last_x = layout[0][0][0] + dx * n_rows
last_y = layout[0][0][1] + dy * n_columns
big_area = np.array([[
layout[0][0], [last_x, layout[0][0][1]], [last_x, last_y],
[layout[0][0][0], last_y]
]])
centroid_big = centroid(big_area)
for j in range(1, n_columns):
if j % 2 == 0:
layout[0][j] = [layout[0][j - 1][0] - dh, layout[0][j - 1][1] + dy]
else:
layout[0][j] = [layout[0][j - 1][0] + dh, layout[0][j - 1][1] + dy]
for i in range(1, n_rows):
layout[i][0] = [layout[i - 1][0][0] + dx, layout[i - 1][0][1]]
for j in range(1, n_columns):
if j % 2 == 0:
layout[i][j] = [
layout[i][j - 1][0] - dh, layout[i][j - 1][1] + dy
]
else:
layout[i][j] = [
layout[i][j - 1][0] + dh, layout[i][j - 1][1] + dy
]
for i in range(n_rows):
for j in range(n_columns):
layout_translated[i][j] = [
layout[i][j][0] - (centroid_big[0] - centroid_small[0]),
layout[i][j][1] - (centroid_big[1] - centroid_small[1])
]
layout_rotated[i][j] = rotate(layout_translated[i][j], angle,
centroid_small)
eps = 1e-8
squares = []
for n in range(n_quadrilaterals):
square = [[1.0 / n_quadrilaterals * n, 0.0],
[n * 1.0 / n_quadrilaterals, 1.0],
[(n + 1) * 1.0 / n_quadrilaterals, 1.0],
[(n + 1) * 1.0 / n_quadrilaterals, 0.0]]
squares.append(square)
maps = [AreaMapping(areas[n], squares[n]) for n in range(n_quadrilaterals)]
count = 0
for i in range(n_rows):
for j in range(n_columns):
if separation_equation_y(
layout_rotated[i][j][0]) < layout_rotated[i][j][1] or len(
areas) == 1:
mapped = maps[0].transform_to_rectangle(
layout_rotated[i][j][0], layout_rotated[i][j][1])
else:
mapped = maps[1].transform_to_rectangle(
layout_rotated[i][j][0], layout_rotated[i][j][1])
if mapped[0] >= 0.0 - eps and mapped[0] <= 1.0 + eps and mapped[
1] >= 0.0 - eps and mapped[1] <= 1.0 + eps:
extra = 0
layout_final.append(
[layout_rotated[i][j][0][0], layout_rotated[i][j][1][0]])
count += 1
else:
extra = 1
return layout_final, count