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 __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.__theta)
return projectPoint(r, Point2(x, y))
def fixed_center_dot(viewState, m, view_center=None):
if view_center is None:
view_center = Point2(viewState.width/2, viewState.height/2)
world_center = viewState.tfV2W(view_center)
proj_orig_center = projectPoint(viewState.transform, world_center)
viewState.transform = viewState.transform.dot(m)
proj_new_center = projectPoint(viewState.transform, world_center)
dx = proj_new_center[0] - proj_orig_center[0]
dy = proj_new_center[1] - proj_orig_center[1]
viewState.transform = M.translate(-dx, -dy).dot(viewState.transform)
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 fixed_center_dot(viewState, m, view_center=None):
if view_center is None:
view_center = Point2(viewState.width/2, viewState.height/2)
world_center = viewState.tfV2W(view_center)
proj_orig_center = projectPoint(viewState.transform, world_center)
viewState.transform = viewState.transform.dot(m)
proj_new_center = projectPoint(viewState.transform, world_center)
dx = proj_new_center[0] - proj_orig_center[0]
dy = proj_new_center[1] - proj_orig_center[1]
viewState.transform = M.translate(-dx, -dy).dot(viewState.transform)
def im2V(self, pt):
"""Translate Image coordinates to viewport coordinates"""
if self.model_overall.view_mode:
ph = projectPoint(self.model.image_matrix, pt)
return self.viewState.tfW2V(ph)
else:
return self.viewState.tfW2V(pt)
def im2V(self, pt):
"""Translate Image coordinates to viewport coordinates"""
if self.model_overall.view_mode:
ph = projectPoint(self.model.image_matrix, pt)
return self.viewState.tfW2V(ph)
else:
return self.viewState.tfW2V(pt)
def mousePressEvent(self, event):
handle = self.get_keypoint_for_mouse(event.pos())
if event.button(
) == QtCore.Qt.LeftButton and event.modifiers() & ADD_MODIFIER:
# If we're in world view mode, we need to figure out where this keypoint would be in image space as well
if self.model.view_mode == 1:
# World coords of event
world = Point2(self.vs.tfV2W(event.pos()))
# Normalized image coords of event
im_norm = projectPoint(self.model.kp.image_matrix_inv, world)
# Pixel coords of event
im_px = self._parent.il.n2p(im_norm)
# Do all ops as a single macro
self._parent.undoStack.beginMacro("Add/Set Keypoint")
cmd = cmd_add_keypoint(self.model.kp)
self._parent.undoStack.push(cmd)
# Since we added it manually, we want to use it as part of the alignment
cmd2 = cmd_set_keypoint_used(self.model.kp, cmd.index, True)
self._parent.undoStack.push(cmd2)
# If adding a keypoint in world space, setup the im-space version as well
if self.model.view_mode == 1:
cmd2 = cmd_set_keypoint_px(self.model.kp, cmd.index, im_px)
self._parent.undoStack.push(cmd2)
# select the keypoint
self.model.kp.selected_idx = cmd.index
# and move it to where the click was
self.do_set_cmd(event.pos(), True)
self._parent.undoStack.endMacro()
return
elif event.button() == QtCore.Qt.LeftButton and event.modifiers(
) & DEL_MODIFIER and (handle is not None):
cmd = cmd_del_keypoint(self.model.kp, self.model.kp.selected_idx)
self._parent.undoStack.push(cmd)
self.model.kp.selected_idx = None
elif event.button() == QtCore.Qt.LeftButton:
self.model.kp.selected_idx = handle
if handle is not None:
self.has_dragged = False
self.behave_mode = MODE_DRAGGING
else:
return False
return True
def mousePressEvent(self, event):
handle = self.get_keypoint_for_mouse(event.pos())
if event.button() == QtCore.Qt.LeftButton and event.modifiers() & ADD_MODIFIER:
# If we're in world view mode, we need to figure out where this keypoint would be in image space as well
if self.model.view_mode == 1:
# World coords of event
world = Point2(self.vs.tfV2W(event.pos()))
# Normalized image coords of event
im_norm = projectPoint(self.model.kp.image_matrix_inv, world)
# Pixel coords of event
im_px = self._parent.il.n2p(im_norm)
# Do all ops as a single macro
self._parent.undoStack.beginMacro("Add/Set Keypoint")
cmd = cmd_add_keypoint(self.model.kp)
self._parent.undoStack.push(cmd)
# Since we added it manually, we want to use it as part of the alignment
cmd2 = cmd_set_keypoint_used(self.model.kp, cmd.index, True)
self._parent.undoStack.push(cmd2)
# If adding a keypoint in world space, setup the im-space version as well
if self.model.view_mode == 1:
cmd2 = cmd_set_keypoint_px(self.model.kp, cmd.index, im_px)
self._parent.undoStack.push(cmd2)
# select the keypoint
self.model.kp.selected_idx = cmd.index
# and move it to where the click was
self.do_set_cmd(event.pos(), True)
self._parent.undoStack.endMacro()
return
elif event.button() == QtCore.Qt.LeftButton and event.modifiers() & DEL_MODIFIER and (
handle is not None):
cmd = cmd_del_keypoint(self.model.kp, self.model.kp.selected_idx)
self._parent.undoStack.push(cmd)
self.model.kp.selected_idx = None
elif event.button() == QtCore.Qt.LeftButton:
self.model.kp.selected_idx = handle
if handle is not None:
self.has_dragged = False
self.behave_mode = MODE_DRAGGING
else:
return False
return True
def V2im(self, pt):
"""
Translate viewport coordinates to image coordinates
:param pt:
:return:
"""
world = self.viewState.tfV2W(pt)
if self.model_overall.view_mode:
inv = numpy.linalg.inv(self.model.image_matrix)
return projectPoint(inv, world)
else:
return Vec2(world)
def V2im(self, pt):
"""
Translate viewport coordinates to image coordinates
:param pt:
:return:
"""
world = self.viewState.tfV2W(pt)
if self.model_overall.view_mode:
inv = numpy.linalg.inv(self.model.image_matrix)
return projectPoint(inv, world)
else:
return Vec2(world)
def _build_points(self, dip):
bx = dip.body_width() / 2
by = dip.body_length() / 2
points = []
points.extend(projectPoints(dip.matrix, map(Point2, [(-bx, by), (-bx,-by),(bx,-by),(bx,by) ])))
for i in range(28):
theta = -math.pi * i / 27
points.append(projectPoint(dip.matrix, Point2(math.cos(theta) * units.MM, math.sin(theta) * units.MM + by)))
return list(zip(points, points[1:] + points[0:1]))
def _build_points(self, smd):
lines = []
by = smd.dim_1_body / 2
bx = smd.dim_2_body / 2
corners = [
projectPoint(smd.matrix, Point2(t))
for t in [(-bx, by), (-bx, -by), (bx, -by), (bx, by)]
]
for p1, p2 in zip(corners, corners[1:] + corners[0:1]):
lines.append((p1, p2))
scale = min(smd.dim_1_body, smd.dim_2_body) / 5
if scale > units.MM:
scale = units.MM
if scale < units.MM / 5:
scale = units.MM / 5
size = scale / 2
offs = scale
posx = -bx + offs
posy = by - offs
circle_points = []
circ_center = projectPoint(smd.matrix, Point2(posx, posy))
for i in range(28):
theta = math.pi * 2 * i / 27
d = Point2(math.cos(theta) * size, math.sin(theta) * size)
circle_points.append(d + circ_center)
for p1, p2 in zip(circle_points,
circle_points[1:] + circle_points[0:1]):
lines.append((p1, p2))
return lines
def _build_points(self, smd):
lines = []
by = smd.dim_1_body/2
bx = smd.dim_2_body/2
corners = [projectPoint(smd.matrix, Point2(t)) for t in [(-bx, by), (-bx,-by),(bx,-by),(bx,by) ]]
for p1, p2 in zip(corners, corners[1:] + corners[0:1]):
lines.append((p1, p2))
scale = min(smd.dim_1_body, smd.dim_2_body) / 5
if scale > units.MM:
scale = units.MM
if scale < units.MM/5:
scale = units.MM/5
size = scale/2
offs = scale
posx = -bx + offs
posy = by - offs
circle_points = []
circ_center = projectPoint(smd.matrix, Point2(posx, posy))
for i in range(28):
theta = math.pi * 2 * i / 27
d = Point2(math.cos(theta) * size, math.sin(theta) * size)
circle_points.append(d + circ_center)
for p1, p2 in zip(circle_points, circle_points[1:] + circle_points[0:1]):
lines.append((p1, p2))
return lines
def __init__(self,
parent,
pad_no,
rel_center,
theta,
w,
l,
th_diam=0,
side=None):
"""
:param parent: Parent
:param rel_center:
:type rel_center: Point2
:param theta:
:param w:
:param l:
:param r:
:return:
"""
self.parent = parent
self.__rel_center = rel_center
# Cached translation-only location matrix
self.__translate_mat = translate(self.__rel_center.x,
self.__rel_center.y)
self.__theta = theta
self.w = w
self.l = l
self.side = side
# Throughhole diameter, 0 if not T/H
self.th_diam = th_diam
self.pad_no = pad_no
if self.parent is not None:
pmat = self.parent.matrix
else:
pmat = numpy.identity(3, dtype=numpy.float32)
self.__pmat = pmat
self.center = projectPoint(pmat, self.__rel_center)
self.layer = self.parent._side_layer_oracle.stackup.layer_for_side(
self.side)
def prepare(self):
self.__text_render.updateTexture()
clist = []
for mat, str_info in self.__strs:
for (x, y), (u, v) in str_info.arr:
newpt = projectPoint(mat, Point2(x, y))
clist.append(((newpt.x, newpt.y), (u, v)))
arr = numpy.array(clist, dtype=self.__text_render.buffer_dtype)
self.vbo.data = arr
self.vbo.size = None
self.vbo.copied = False
self.vbo.bind()
self.__elem_count = len(arr)
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 _build_points(self, dip):
bx = dip.body_width() / 2
by = dip.body_length() / 2
points = []
points.extend(
projectPoints(
dip.matrix,
map(Point2, [(-bx, by), (-bx, -by), (bx, -by), (bx, by)])))
for i in range(28):
theta = -math.pi * i / 27
points.append(
projectPoint(
dip.matrix,
Point2(
math.cos(theta) * units.MM,
math.sin(theta) * units.MM + by)))
return list(zip(points, points[1:] + points[0:1]))
def __init__(self, parent, pad_no, rel_center, theta, w, l, th_diam=0, side=None):
"""
:param parent: Parent
:param rel_center:
:type rel_center: Point2
:param theta:
:param w:
:param l:
:param r:
:return:
"""
self.parent = parent
self.__rel_center = rel_center
# Cached translation-only location matrix
self.__translate_mat = translate(self.__rel_center.x, self.__rel_center.y)
self.__theta = theta
self.w = w
self.l = l
self.side = side
# Throughhole diameter, 0 if not T/H
self.th_diam = th_diam
self.pad_no = pad_no
if self.parent is not None:
pmat = self.parent.matrix
else:
pmat = numpy.identity(3, dtype=numpy.float32)
self.__pmat = pmat
self.center = projectPoint(pmat, self.__rel_center)
self.layer = self.parent._side_layer_oracle.stackup.layer_for_side(self.side)
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 tfV2P(self, pt):
m = numpy.linalg.inv(self.__ndc2v.dot(self.__w2ndc))
return projectPoint(m, pt)
def n2p(self, pt):
return projectPoint(self.normalized_to_pixel, pt)
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 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 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 p2n(self, pt):
return projectPoint(self.pixel_to_normalized, pt)
def tfP2V(self, pt):
return projectPoint(self.__w2ndc, pt)
def tfV2P(self, pt):
m = numpy.linalg.inv(self.__ndc2v.dot(self.__w2ndc))
return projectPoint(m, pt)
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 tfW2V(self, pt):
return projectPoint(self.__fwdMatrix, pt)
def p2n(self, pt):
return projectPoint(self.pixel_to_normalized, pt)
def tfV2P(self, pt):
return projectPoint(self.__v2w, pt)
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 tfW2V(self, pt):
return projectPoint(self.fwdMatrix, pt)
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 tfV2W(self, pt):
return projectPoint(self.revMatrix, pt)
def tfV2P(self, pt):
return projectPoint(self.__v2w, pt)
def n2p(self, pt):
return projectPoint(self.normalized_to_pixel, pt)
def tfP2V(self, pt):
return projectPoint(self.__w2ndc, pt)
def tfV2W(self, pt):
return projectPoint(self.__revMatrix, pt)
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)