def __update_matrix(self):
rot = rotate(self.__theta)
if self.side == SIDE.Top:
sign = -1
else:
sign = 1
self.matrix = translate(self.center.x, self.center.y).dot(rotate(self.__theta))
def __update_matrix(self):
rot = rotate(self.__theta)
if self.side == SIDE.Top:
sign = -1
else:
sign = 1
self.matrix = translate(self.center.x,
self.center.y).dot(rotate(self.__theta))
def update_matrix(self):
rot = rotate(self._cmodel.theta)
center_to_corner = Vec2(
0,
self._model.pin_space * (self._model.pin_count - 1) / 2)
center_to_corner_w = project_point(rot, center_to_corner)
self._cmodel.center = self.p1_point.get() - center_to_corner_w
self.matrix = translate(self._cmodel.center.x,
self._cmodel.center.y).dot(
rotate(self._cmodel.theta))
def __init__(self, view, model, cmodel):
self._model = model
self._cmodel = cmodel
self.p1_point = EditablePoint(Point2(0, 0))
rmat = rotate(self._cmodel.theta)
dy = -(model.pin_count / 2 - 1) * model.pin_space
v_aligned = Vec2(0, dy)
v_delta = project_point(rmat, v_aligned)
# the pin on the end of the same row as P1
self.p_bottom_corner = OffsetDefaultPoint(self.p1_point, v_delta)
# Opposite corner point
self.p_opposite = WidthProjectedPoint(self)
points = [self.p1_point, self.p_bottom_corner, self.p_opposite]
super(DIPEditFlow, self).__init__(view, points, True)
self.update_matrix()
def gen_dim(self, idx, always_above = True):
"""
Generate rendering data for the dimension-lines
:param idx:
:return:
"""
a = self.im2V(self.model.dim_handles[0 + idx])
b = self.im2V(self.model.dim_handles[1 + idx])
d = b-a
delta = (b-a).norm()
normal = Point2(rotate(math.pi / 2)[:2,:2].dot(delta))
if always_above:
if numpy.cross(Vec2(1,0), normal) > 0:
normal = -normal
res = numpy.array([
a + normal * 8,
a + normal * 20,
a + normal * 15,
b + normal * 15,
b + normal * 8,
b + normal * 20,
])
return res
def __init__(self, view, model):
self._model = model
self.p1_point = EditablePoint(Point2(0, 0))
self.__theta = 0
self.__corner = Point2(0, 0)
rmat = rotate(self.theta)
dy = -(model.pin_count / 2 - 1) * model.pin_space
v_aligned = Vec2(0, dy)
v_delta = projectPoint(rmat, v_aligned)
# the pin on the end of the same row as P1
self.p_bottom_corner = OffsetDefaultPoint(self.p1_point, v_delta)
# Opposite corner point
self.p_opposite = WidthProjectedPoint(self)
points = [self.p1_point, self.p_bottom_corner, self.p_opposite]
super(DIPEditFlow, self).__init__(view, points, True)
if self.view.viewState.current_layer is None:
self.side = SIDE.Top
else:
self.side = self.view.viewState.current_layer.side
self.update_matrix()
def other_corner_offset():
x = self._model.pin_spacing * ((self._model.side1_pins - 1) / 2 +
(self._model.side3_pins - 1) / 2)
y = self._model.dim_2_pincenter
r = rotate(self._cmodel.theta)
return project_point(r, Point2(x, y))
def __init__(self, view, model):
self._model = model
self.p1_point = EditablePoint(Point2(0, 0))
self.__theta = 0
self.__corner = Point2(0, 0)
rmat = rotate(self.theta)
dy = -(model.pin_count / 2 - 1) * model.pin_space
v_aligned = Vec2(0, dy)
v_delta = projectPoint(rmat, v_aligned)
# the pin on the end of the same row as P1
self.p_bottom_corner = OffsetDefaultPoint(self.p1_point, v_delta)
# Opposite corner point
self.p_opposite = WidthProjectedPoint(self)
points = [self.p1_point, self.p_bottom_corner, self.p_opposite]
super(DIPEditFlow, self).__init__(view, points, True)
if self.view.viewState.current_layer is None:
self.side = SIDE.Top
else:
self.side = self.view.viewState.current_layer.side
self.update_matrix()
def gen_dim(self, idx, always_above = True):
"""
Generate rendering data for the dimension-lines
:param idx:
:return:
"""
a = self.im2V(self.model.dim_handles[0 + idx])
b = self.im2V(self.model.dim_handles[1 + idx])
d = b-a
delta = (b-a).norm()
normal = Point2(rotate(math.pi / 2)[:2,:2].dot(delta))
if always_above:
if numpy.cross(Vec2(1,0), normal) > 0:
normal = -normal
res = numpy.array([
a + normal * 8,
a + normal * 20,
a + normal * 15,
b + normal * 15,
b + normal * 8,
b + normal * 20,
])
return res
def gen_dim(self, idx: int, always_above: bool = True) -> 'npt.NDArray[numpy.float64]':
"""
Generate rendering data for the dimension-lines
:param idx:
:return:
"""
a = self.im2V(self.model.dim_handles[0 + idx])
b = self.im2V(self.model.dim_handles[1 + idx])
d = b - a
delta = (b - a).norm()
normal = Vec2.from_mat(rotate(math.pi / 2)[:2, :2].dot(delta))
if always_above:
if numpy.cross(Vec2(1, 0), normal) > 0:
normal = -normal
res = numpy.array([
a + normal * 8,
a + normal * 20,
a + normal * 15,
b + normal * 15,
b + normal * 8,
b + normal * 20,
], dtype=numpy.float64)
return res
def update_matrix(self):
rot = rotate(self._cmodel.theta)
sign = self.get_cur_sign()
center_to_corner = Vec2(
sign * self._model.pin_width / 2,
self._model.pin_space * (self._model.pin_count / 2 - 1) / 2)
center_to_corner_w = project_point(rot, center_to_corner)
self._cmodel.center = self.p1_point.get() - center_to_corner_w
self.matrix = translate(self._cmodel.center.x,
self._cmodel.center.y).dot(
rotate(self._cmodel.theta))
def p2_corner_offset():
x = self._model.pin_spacing * ((self._model.side1_pins - 1) /
2) + self._model.dim_1_pincenter / 2
y = self._model.dim_2_pincenter / 2 - (
self._model.side2_pins - 1) / 2 * self._model.pin_spacing
r = rotate(self._cmodel.theta)
return project_point(r, Point2(x, y))
def update_matrix(self):
rot = rotate(self.theta)
if self.side == SIDE.Top:
sign = -1
else:
sign = 1
center_to_corner = Vec2(
sign * self._model.pin_width / 2, self._model.pin_space * (self._model.pin_count / 2 - 1) / 2
)
center_to_corner_w = projectPoint(rot, center_to_corner)
self.center = self.p1_point.get() - center_to_corner_w
self.matrix = translate(self.center.x, self.center.y).dot(rotate(self.theta))
def update_matrix(self):
rot = rotate(self.theta)
if self.side == SIDE.Top:
sign = -1
else:
sign = 1
center_to_corner = Vec2(
sign * self._model.pin_width / 2,
self._model.pin_space * (self._model.pin_count / 2 - 1) / 2)
center_to_corner_w = projectPoint(rot, center_to_corner)
self.center = self.p1_point.get() - center_to_corner_w
self.matrix = translate(self.center.x,
self.center.y).dot(rotate(self.theta))
def render_handle(self, position, color, diagonal=False, filled=False):
if diagonal:
r = rotate(math.pi/4)
else:
r = numpy.identity(3)
m = self.viewState.glWMatrix.dot(translate(*position).dot(r))
GL.glUniformMatrix3fv(self.mat_loc, 1, True, m.astype(numpy.float32))
GL.glUniform4f(self.col_loc, *color)
GL.glDrawArrays(GL.GL_TRIANGLE_FAN if filled else GL.GL_LINE_LOOP, 0, 4)
def render_handle(self, position, color, diagonal=False, filled=False):
if diagonal:
r = rotate(math.pi/4)
else:
r = numpy.identity(3)
m = self.viewState.glWMatrix.dot(translate(*position).dot(r))
GL.glUniformMatrix3fv(self.mat_loc, 1, True, m.astype(numpy.float32))
GL.glUniform4f(self.col_loc, *color)
GL.glDrawArrays(GL.GL_TRIANGLE_FAN if filled else GL.GL_LINE_LOOP, 0, 4)
def __build_trace(self) -> None:
# Update trace VBO
self.working_array["vertex"][0] = (0, 0)
self.working_array["ptid"][0] = 0
self.working_array["vertex"][1] = (0, 0)
self.working_array["ptid"][1] = 1
end = Vec2(1, 0)
for i in range(0, NUM_ENDCAP_SEGMENTS):
theta = math.pi * i / (NUM_ENDCAP_SEGMENTS - 1) + math.pi / 2
m = rotate(theta).dot(end.homol())
self.working_array["vertex"][2 + i] = m[:2]
self.working_array["ptid"][2 + i] = 0
self.working_array["vertex"][2 + i + NUM_ENDCAP_SEGMENTS] = -m[:2]
self.working_array["ptid"][2 + i + NUM_ENDCAP_SEGMENTS] = 1
# Force data copy
self.trace_vbo.bind()
self.trace_vbo.set_array(self.working_array)
def __build_trace(self):
# Update trace VBO
self.working_array["vertex"][0] = (0, 0)
self.working_array["ptid"][0] = 0
self.working_array["vertex"][1] = (0, 0)
self.working_array["ptid"][1] = 1
end = Vec2(1, 0)
for i in range(0, NUM_ENDCAP_SEGMENTS):
theta = math.pi * i / (NUM_ENDCAP_SEGMENTS - 1) + math.pi / 2
m = rotate(theta).dot(end.homol())
self.working_array["vertex"][2 + i] = m[:2]
self.working_array["ptid"][2 + i] = 0
self.working_array["vertex"][2 + i + NUM_ENDCAP_SEGMENTS] = -m[:2]
self.working_array["ptid"][2 + i + NUM_ENDCAP_SEGMENTS] = 1
# Force data copy
self.trace_vbo.copied = False
self.trace_vbo.bind()
def matrix(self) -> 'npt.NDArray[numpy.float64]':
return translate(self.center.x, self.center.y) @ (
rotate(self.theta) @ (cflip(self.side == SIDE.Bottom)))
def __p2p_mat(self) -> 'npt.NDArray[numpy.float64]':
return rotate(-self.theta) @ translate(-self.rel_center.x,
-self.rel_center.y)
def get(self):
r = rotate(self.parent._cmodel.theta)
cv = Vec2(-self.parent._model.dim_1_body / 2,
-self.parent._model.dim_2_body / 2)
return self.parent._cmodel.center + project_point(r, cv)
def set(self, val):
r = rotate(-self.parent.theta)
p = projectPoint(r, val - self.parent.center)
self.parent._model.dim_1_body = abs(p.x) * 2
self.parent._model.dim_2_body = abs(p.y) * 2
def matrix(self):
return translate(self.center.x, self.center.y).dot(
rotate(self.theta).dot(cflip(self.side == SIDE.Bottom)))
def __inv_p2p_mat(self):
return translate(self.rel_center.x, self.rel_center.y).dot(rotate(self.theta))
def matrix(self):
return translate(self.center.x, self.center.y).dot(rotate(self.theta).dot(cflip(self.side == SIDE.Bottom)))
def rotate(self, angle):
self.transform = self.transform.dot(M.rotate(math.radians(angle)))
def __inv_p2p_mat(self):
return translate(self.rel_center.x,
self.rel_center.y).dot(rotate(self.theta))
def rotate(self, angle):
self.transform = self.transform.dot(M.rotate(math.radians(angle)))
def flip_rotate_matrix(self) -> 'npt.NDArray[numpy.float64]':
return cast('npt.NDArray[numpy.float64]',
rotate(self.rotate_theta).dot(scale(-1 if self.flip_x else 1, -1 if self.flip_y else 1))
)
def other_corner_offset():
x = self._model.pin_spacing * ((self._model.side1_pins - 1) / 2 + (self._model.side3_pins - 1) / 2)
y = self._model.dim_2_pincenter
r = rotate(self.__theta)
return projectPoint(r, Point2(x, y))
def get(self):
r = rotate(self.parent.theta)
cv = Vec2(-self.parent._model.dim_1_body/2, -self.parent._model.dim_2_body/2)
return self.parent.center + projectPoint(r, cv)
def point_inside(self, pt):
v = pt - self.center
v_in_cmp = projectPoint(rotate(-self.theta), v)
return self.theta_bbox.point_test(v_in_cmp)
def __p2p_mat(self):
return rotate(-self.theta).dot(translate(-self.rel_center.x, -self.rel_center.y))
def rotate(self, angle: float) -> None:
# Angle is in a clockwise direction
self.__rotate_flip = M.rotate(math.radians(-angle)) @ self.__rotate_flip
self.__update()
def point_inside(self, pt):
v = pt - self.center
v_in_cmp = projectPoint(rotate(-self.theta), v)
return self.theta_bbox.point_test(v_in_cmp)
def __inv_p2p_mat(self) -> 'npt.NDArray[numpy.float64]':
return translate(self.rel_center.x, self.rel_center.y) @ rotate(
self.theta)
def flip_rotate_matrix(self):
return rotate(self.rotate_theta).dot(scale(-1 if self.flip_x else 1, -1 if self.flip_y else 1))
def __update_matrix(self):
rot = rotate(self._cmodel.theta)
self.matrix = translate(self._cmodel.center.x,
self._cmodel.center.y).dot(
rotate(self._cmodel.theta))
def p2_corner_offset():
x = self._model.pin_spacing * ((self._model.side1_pins - 1) / 2) + self._model.dim_1_pincenter/2
y = self._model.dim_2_pincenter / 2 - (self._model.side2_pins - 1) / 2 * self._model.pin_spacing
r = rotate(self.__theta)
return projectPoint(r, Point2(x, y))
def set(self, val):
r = rotate(-self.parent._cmodel.theta)
p = project_point(r, val - self.parent._cmodel.center)
self.parent._model.dim_1_body = abs(p.x) * 2
self.parent._model.dim_2_body = abs(p.y) * 2
def __p2p_mat(self):
return rotate(-self.theta).dot(
translate(-self.rel_center.x, -self.rel_center.y))
def flip_rotate_matrix(self):
return rotate(self.rotate_theta).dot(scale(-1 if self.flip_x else 1, -1 if self.flip_y else 1))
