def __call__(self, p1, p2):
if self.rotation:
center = (p1+p2)/2
rot = rotation_2d(self.rotation)
return [PolyLine2D([center + rot.dot(p1-center), center+rot.dot(p2-center)], name=self.name)]
else:
return [PolyLine2D([p1, p2], name=self.name)]
def shape_flattened(self):
"""
Projected Shape of the glider (as it would lie on the ground - flattened)
"""
rot = rotation_2d(np.pi / 2)
front, back = flatten_list(self.get_spanwise(0), self.get_spanwise(1))
return Shape([rot.dot(p) for p in front], [rot.dot(p) for p in back])
def get_sequence(self, num=20):
lst = []
end = vector_angle(self.r, numpy.array(self.p3) - self.center)
for angle in numpy.linspace(0, end, num):
lst.append(self.center + rotation_2d(angle).dot(self.r))
return PolyLine2D(lst)
def apply(self, inner_lists, outer_left, outer_right, amount_3d=None):
#p1 = inner_lists[0][0][inner_lists[0][1]] # [[list1,pos1],[list2,pos2],...]
#p2 = inner_lists[-1][0][inner_lists[-1][1]]
p1, p2 = self.get_p1_p2(inner_lists, amount_3d)
indices = self._get_indices(inner_lists, amount_3d)
normvector = normalize(rotation_2d(math.pi / 2).dot(p1 - p2))
newlist = []
# todo: sort by distance
cuts_left = list(
outer_left.cut(p1, p2, inner_lists[0][1], extrapolate=True))
cuts_left.sort(key=lambda cut: abs(cut[1]))
leftcut_index = cuts_left[0][0]
leftcut = outer_left[leftcut_index]
newlist.append(leftcut)
newlist.append(leftcut + normvector * self.amount)
for thislist in inner_lists:
newlist.append(thislist[0][thislist[1]] + normvector * self.amount)
cuts_right = list(
outer_right.cut(p1, p2, inner_lists[-1][1], extrapolate=True))
cuts_right.sort(key=lambda cut: abs(cut[1]))
rightcut_index = cuts_right[0][0]
rightcut = outer_right[rightcut_index]
newlist.append(rightcut + normvector * self.amount)
newlist.append(rightcut)
curve = PolyLine2D(newlist)
return CutResult(curve, leftcut_index, rightcut_index, indices)
def apply(self, inner_lists, outer_left, outer_right, amount_3d=None):
p1, p2 = self.get_p1_p2(inner_lists, amount_3d)
indices = self._get_indices(inner_lists, amount_3d)
normvector = normalize(rotation_2d(math.pi / 2).dot(p1 - p2))
leftcut_index = next(
outer_left.cut(p1, p2, inner_lists[0][1], extrapolate=True))
rightcut_index = next(
outer_right.cut(p1, p2, inner_lists[-1][1], extrapolate=True))
index_left = leftcut_index[0]
index_right = rightcut_index[0]
leftcut = outer_left[index_left]
rightcut = outer_right[index_right]
leftcut_index_2 = outer_left.cut(p1 - normvector * self.amount,
p2 - normvector * self.amount,
inner_lists[0][1],
extrapolate=True)
rightcut_index_2 = outer_right.cut(p1 - normvector * self.amount,
p2 - normvector * self.amount,
inner_lists[-1][1],
extrapolate=True)
leftcut_2 = outer_left[next(leftcut_index_2)[0]]
rightcut_2 = outer_right[next(rightcut_index_2)[0]]
diff_l, diff_r = leftcut - leftcut_2, rightcut - rightcut_2
curve = PolyLine2D(
[leftcut, leftcut + diff_l, rightcut + diff_r, rightcut])
return CutResult(curve, leftcut_index[0], rightcut_index[0], indices)
def _insert_text(self, text):
inner, outer = self._get_inner_outer(self.config.rib_text_pos)
diff = outer - inner
p1 = inner + diff / 2
p2 = p1 + rotation_2d(np.pi / 2).dot(diff)
_text = Text(text, p1, p2, size=norm(outer - inner) * 0.5, valign=0)
#_text = Text(text, p1, p2, size=0.05)
self.plotpart.layers["text"] += _text.get_vectors()
def rotate(self, angle, startpoint=None, radians=True):
"""
Rotate counter-clockwise around a (non)given startpoint [rad]
"""
if not radians:
angle = np.pi * angle / 180
rotation_matrix = rotation_2d(angle)
new_data = []
for point in self.data:
if startpoint is not None:
new_data.append(startpoint +
rotation_matrix.dot(point - startpoint))
else:
new_data.append(rotation_matrix.dot(point))
self.data = new_data
return self
def apply(self, inner_lists, outer_left, outer_right, amount_3d=None):
p1, p2 = self.get_p1_p2(inner_lists, amount_3d)
indices = self._get_indices(inner_lists, amount_3d)
normvector = normalize(rotation_2d(math.pi / 2).dot(p1 - p2))
left_start_index = next(
outer_left.cut(p1, p2, inner_lists[0][1], extrapolate=True))[0]
right_start_index = next(
outer_right.cut(p1, p2, inner_lists[-1][1], extrapolate=True))[0]
pp1 = p1 - normvector * self.amount
pp2 = p2 - normvector * self.amount
left_end_index = next(
outer_left.cut(pp1, pp2, inner_lists[0][1], extrapolate=True))[0]
right_end_index = next(
outer_right.cut(pp1, pp2, inner_lists[-1][1], extrapolate=True))[0]
left_start = outer_left[left_start_index]
left_end = outer_left[left_end_index]
right_start = outer_right[right_start_index]
right_end = outer_right[right_end_index]
left_piece = outer_left[left_end_index:left_start_index]
right_piece = outer_right[right_end_index:right_start_index]
left_piece_mirrored = left_piece[::-1]
right_piece_mirrored = right_piece[::-1]
left_piece_mirrored.mirror(p1, p2)
right_piece_mirrored.mirror(p1, p2)
# mirror to (p1-p2) -> p'=p-2*(p.normvector)
last_left, last_right = left_start, right_start
new_left, new_right = PolyLine2D(None), PolyLine2D(None)
for i in range(self.num_folds):
left_this = left_piece if i % 2 else left_piece_mirrored
right_this = right_piece if i % 2 else right_piece_mirrored
left_this.move(last_left - left_this[0])
right_this.move(last_right - right_this[0])
new_left += left_this
new_right += right_this
last_left, last_right = new_left.data[-1], new_right.data[-1]
curve = new_left + new_right[::-1]
return CutResult(curve, left_start_index, right_start_index, indices)
def apply(self, inner_lists, outer_left, outer_right, amount_3d=None):
"""
:param inner_lists:
:param outer_left:
:param outer_right:
:param amount_3d: list of 3d-shaping amounts
:return:
"""
inner_new = []
point_list = []
for offset, lst in zip(amount_3d, inner_lists):
curve, ik = lst
ik_new = curve.extend(ik, offset)
inner_new.append([curve, ik_new])
p1, p2 = self.get_p1_p2(inner_lists, amount_3d)
normvector = normalize(rotation_2d(math.pi / 2).dot(p1 - p2))
leftcut_index = next(
outer_left.cut(p1, p2, inner_lists[0][1], extrapolate=True))
rightcut_index = next(
outer_right.cut(p1, p2, inner_lists[-1][1], extrapolate=True))
index_left = leftcut_index[0]
index_right = rightcut_index[0]
leftcut = outer_left[index_left]
rightcut = outer_right[index_right]
point_list.append(leftcut)
point_list.append(leftcut + normvector * self.amount)
for curve, ik in inner_new:
point_list.append(curve[ik] + normvector * self.amount)
point_list.append(rightcut + normvector * self.amount)
point_list.append(rightcut)
curve = PolyLine2D(point_list)
return CutResult(curve, index_left, index_right,
[x[1] for x in inner_new])
def __init__(self, func, rotation, center=True):
self.angle = rotation
self.rotation = rotation_2d(rotation)
super(Rotate, self).__init__(func)