def pick_frame_from_grid(index, bullet_height):
"""Get next picking frame.
Parameters
----------
index : int
Counter to iterate through picking positions.
bullet_height : float
Height of bullet to pick up.
Returns
-------
list of `class`:compas.geometry.Frame
"""
# If index is larger than amount on picking plate, start from zero again
index = index % (fab_conf["pick"]["xnum"].get() *
fab_conf["pick"]["ynum"].get())
xpos = index % fab_conf["pick"]["xnum"].get()
ypos = index // fab_conf["pick"]["xnum"].get()
x = (fab_conf["pick"]["origin_grid"]["x"].get() +
xpos * fab_conf["pick"]["grid_spacing"].get())
y = (fab_conf["pick"]["origin_grid"]["y"].get() +
ypos * fab_conf["pick"]["grid_spacing"].get())
z = bullet_height * fab_conf["pick"]["compression_height_factor"].get()
frame = Frame(
Point(x, y, z),
Vector(*fab_conf["pick"]["xaxis"].get()),
Vector(*fab_conf["pick"]["yaxis"].get()),
)
log.debug("Picking frame {:03d}: {}".format(index, frame))
return frame
def mesh_subdivide_tapered(mesh, k=1, height=1.0, ratio=0.5):
"""
TODO
"""
subd = mesh.copy()
for fkey in mesh.faces():
centroid = mesh.face_centroid(fkey)
centroid_vector = Vector(*centroid)
normal = mesh.face_normal(fkey)
normal_vector = Vector(*normal)
normal_vector *= height
face_verts = mesh.face_vertices(fkey)
new_verts = []
for v in face_verts:
v_coords = mesh.vertex_coordinates(v)
v_vector = Vector(*v_coords)
vert_to_cent = centroid_vector - v_vector
vert_to_cent *= ratio
new_vertex = v_vector + vert_to_cent + normal_vector
x, y, z = new_vertex
new_verts.append(subd.add_vertex(x=x, y=y, z=z))
for i,v in enumerate(face_verts):
next_v = face_verts[(i+1) % len(face_verts)]
new_v = new_verts[i]
next_new_v = new_verts[(i+1) % len(face_verts)]
new_face_key = subd.add_face([v, next_v, next_new_v, new_v])
top_face_key = subd.add_face(new_verts)
del subd.face[fkey]
return subd
def taper_face(mesh, fkey, height=0.0, ratio=0.5, keep_original=False):
centroid = mesh.face_centroid(fkey)
centroid_vector = Vector(*centroid)
normal = mesh.face_normal(fkey)
normal_vector = Vector(*normal)
normal_vector *= height
face_verts = mesh.face_vertices(fkey)
new_verts = []
for v in face_verts:
v_coords = mesh.vertex_coordinates(v)
v_vector = Vector(*v_coords)
vert_to_cent = centroid_vector - v_vector
vert_to_cent *= ratio
new_vertex = v_vector + vert_to_cent + normal_vector
x, y, z = new_vertex
new_verts.append(mesh.add_vertex(x=x, y=y, z=z))
new_keys = []
for i,v in enumerate(face_verts):
next_v = face_verts[(i+1) % len(face_verts)]
new_v = new_verts[i]
next_new_v = new_verts[(i+1) % len(face_verts)]
new_face_key = mesh.add_face([v, next_v, next_new_v, new_v])
new_keys.append(new_face_key)
top_face_key = mesh.add_face(new_verts)
new_keys.append(top_face_key)
if keep_original==False:
del mesh.face[fkey]
return new_keys
def arrays_cross(array1, array2):
cross_list = []
for i in range(len(array1)):
u = Vector(array1[i][0], array1[i][1], array1[i][2])
v = Vector(array2[i][0], array2[i][1], array2[i][2])
cross_list.append(u.cross(v))
return cross_list
def get_distance(self, point):
"""
single point distance function
Parameters
----------
point: :class:`compas.geometry.Point`
The point in R<sup>3</sup> space to query for it's distance.
Returns
-------
float
The distance from the query point to the surface of the object.
"""
if not isinstance(point, Point):
p = Point(*point)
else:
p = point
p.transform(self.inversetransform)
k0 = Vector(p.x / self.radiusX, p.y / self.radiusY,
p.z / self.radiusZ).length
k1 = Vector(p.x / self.radiusX**2, p.y / self.radiusY**2,
p.z / self.radiusZ**2).length
if k1 == 0:
return -1
else:
return k0 * (k0 - 1.0) / k1
def __init__(self, board_layer, identification, board_no_in_layer,
board_dimensions, z_value_toppoint, length_dir,
width_dir):
self.index = identification
self.layer = board_layer
self.no_in_layer = board_no_in_layer
self.dimensions = board_dimensions
self.width = self.dimensions[0]
self.height = self.dimensions[1]
self.length = self.dimensions[2]
self.drop_point = Point(0, 0, 0)
self.centre_point = Point(0, 0, 0)
self.z_drop = z_value_toppoint
self.length_direction = length_dir
self.width_direction = width_dir
self.glue_givers = []
self.glue_receivers = []
self.receiving_neighbours = []
self.giving_neighbours = []
if self.length_direction == 0:
self.length_vector = Vector(1, 0, 0)
self.width_vector = Vector(0, 1, 0)
else:
self.length_vector = Vector(0, 1, 0)
self.width_vector = Vector(1, 0, 0)
self.board_frame = Frame(self.centre_point, self.length_vector,
self.width_vector)
self.box = Box(self.board_frame, self.length, self.width,
self.height)
def board_setup(self):
for my_layer in range(layer_no):
if my_layer % 2 == 0:
my_frame = self.origin_fr
my_grid = self.ceiling_grids[0]
else:
my_frame = self.sec_fr
my_grid = self.ceiling_grids[1][0]
my_dir1 = normalize_vector(my_frame[1])
my_dir2 = normalize_vector(my_frame[2])
# we have to separate i/board_code because of possible exceptions in the centre
board_code = 0
for i, dist in enumerate(my_grid):
my_board = self.timberboards[my_layer][board_code]
# for the inner parts
if self.skipping and 0 < my_layer < self.layer_no - 1 and my_layer%2 == 0 and \
0 < i < len(my_grid) - 1 and i%2 != 0:
continue
# build the three vectors with which we later find he centre point
my_vec1 = scale_vector(my_dir1, my_board.length / 2)
my_vec2 = scale_vector(my_dir2, dist)
my_vec3 = Vector(0, 0, my_board.z_drop - my_board.height / 2)
my_centre = self.origin_pt + my_vec1 + my_vec2 + my_vec3
my_board.centre_point = my_centre
my_board.drop_point = my_centre + Vector(
0, 0, my_board.height / 2)
my_board.length_vector = normalize_vector(my_vec1)
my_board.width_vector = normalize_vector(my_vec2)
my_board.box_update()
board_code += 1
def surface_calc(upper_board, lower_board, intersection):
vec1 = Vector(lower_board.length_vector[0], lower_board.length_vector[1], lower_board.length_vector[2])
vec2 = Vector(upper_board.length_vector[0], upper_board.length_vector[1], upper_board.length_vector[2])
if upper_board.width > 10:
ang = vec1.angle(vec2)
print("stop")
if vec1.angle(vec2) > 0.5:
len_intersection = lower_board.width
wid_intersection = upper_board.width
else:
# for now we assume that they are parallel in this case, potential error source for later, though
print("parallel ones")
len_intersection = min(upper_board.length, lower_board.length)
wid_intersection = min(upper_board.width, lower_board.width)
dim1 = scale_vector(upper_board.length_vector, len_intersection*.5)
dim2 = scale_vector(upper_board.width_vector, wid_intersection*.5)
# this procedure is necessary only because of the glue path planning to make sure points are always ordered clockwise
ang = angle_vectors_signed(dim1, dim2, Vector(0, 0, 1))
if ang > 0:
pt1 = intersection + dim1 - dim2
pt2 = intersection + dim1 + dim2
pt3 = intersection - dim1 + dim2
pt4 = intersection - dim1 - dim2
else:
pt1 = intersection - dim1 + dim2
pt2 = intersection + dim1 + dim2
pt3 = intersection + dim1 - dim2
pt4 = intersection - dim1 - dim2
intersection_surf = Polygon([pt1, pt2, pt3, pt4])
return intersection_surf
def mesh_subdivide_pyramid(mesh, k=1, height=1.0):
"""
Subdivide a mesh using insertion of a vertex at centroid + height * face normal.
Parameters
----------
mesh : Mesh
The mesh object that will be subdivided.
k : int
Optional. The number of levels of subdivision. Default is ``1``.
height : float
The distance of the new vertex to the face.
Returns
-------
Mesh
A new subdivided mesh.
"""
subd = mesh.copy()
for fkey in mesh.faces():
centroid = mesh.face_centroid(fkey)
centroid_vector = Vector(*centroid)
normal = mesh.face_normal(fkey)
normal_vector = Vector(*normal)
new_vertex = centroid_vector + normal_vector * height
subd.insert_vertex(fkey, xyz=new_vertex)
return subd
def board_geometry_setup(self):
for my_layer in range(layer_no):
if my_layer % 2 == 0:
my_frame = self.origin_fr
my_grid = self.ceiling_grids[0][0]
else:
my_frame = self.sec_fr
my_grid = self.ceiling_grids[1][0]
my_dir1 = normalize_vector(my_frame[1])
my_dir2 = normalize_vector(my_frame[2])
# we have to separate i/board_code because of possible exceptions in the centre
board_code = 0
for my_board in self.timberboards[my_layer]:
dist = my_board.grid_position
# build the three vectors with which we later find he centre point
# one advanced case
if my_board.location == "high":
my_vec1 = scale_vector(my_dir1, primary_length - my_board.length / 2)
# all other cases
else:
my_vec1 = scale_vector(my_dir1, my_board.length / 2)
my_vec2 = scale_vector(my_dir2, dist)
my_vec3 = Vector(0, 0, my_board.z_drop - my_board.height / 2)
my_centre = self.origin_pt + my_vec1 + my_vec2 + my_vec3
my_board.centre_point = my_centre
my_board.drop_point = my_centre + Vector(0, 0, my_board.height / 2)
my_board.length_vector = normalize_vector(my_vec1)
my_board.width_vector = normalize_vector(my_vec2)
my_board.box_update()
board_code += 1
def to_local_geometry_xy(self):
if self.Type == 'W':
# wf == 'wireframe - center line of steel element, with origin at middle'
wf_pt0 = Point(0, self.d * 0.5 - self.tw * 0.5, 0)
wf_pt1 = Point(0, -(self.d * 0.5 - self.tw * 0.5), 0)
wf_pt2 = translate_points([wf_pt0], Vector(-self.bf * 0.5, 0, 0))[0]
wf_pt3 = translate_points([wf_pt0], Vector(self.bf * 0.5, 0, 0))[0]
wf_pt4 = translate_points([wf_pt1], Vector(-self.bf * 0.5, 0, 0))[0]
wf_pt5 = translate_points([wf_pt1], Vector(self.bf * 0.5, 0, 0))[0]
wf_pt2 = Point(*wf_pt2)
wf_pt3 = Point(*wf_pt3)
wf_pt4 = Point(*wf_pt4)
wf_pt5 = Point(*wf_pt5)
web_surf = self.create_plate_xy(wf_pt0, wf_pt1, self.length)
top_flange_srf = self.create_plate_xy(wf_pt2, wf_pt3, self.length)
bottom_flange_srf = self.create_plate_xy(wf_pt4, wf_pt5, self.length)
web_pl = self.extrude_plate(web_surf, self.tw, 'x')
top_flange = self.extrude_plate(top_flange_srf, self.tf, 'y')
bottom_flange = self.extrude_plate(bottom_flange_srf, self.tf, 'y')
return [web_pl, top_flange, bottom_flange]
if self.Type == 'HSS':
raise NotImplementedError
else:
raise NotImplementedError
def basis_vectors(self):
"""Returns the basis vectors from the ``Rotation`` component of the ``Transformation``.
"""
from compas.geometry import Vector
sc, sh, a, t, p = decompose_matrix(self.matrix)
R = matrix_from_euler_angles(a, static=True, axes='xyz')
xv, yv = basis_vectors_from_matrix(R)
return Vector(*xv), Vector(*yv)
def pyramid_face(mesh, fkey, height=0.0):
centroid = mesh.face_centroid(fkey)
centroid_vector = Vector(*centroid)
normal = mesh.face_normal(fkey)
normal_vector = Vector(*normal)
new_vertex = centroid_vector + normal_vector * height
new_keys = mesh.insert_vertex(fkey, xyz=new_vertex, return_fkeys=True)[1]
return new_keys
def get_frame(self):
""" Returns a Frame with x-axis pointing up, y-axis pointing towards the mesh normal. """
if abs(dot_vectors(self.up_vector, self.mesh_normal)
) < 1.0: # if the normalized vectors are not co-linear
c = cross_vectors(self.up_vector, self.mesh_normal)
return Frame(self.pt, c, self.mesh_normal)
else: # in horizontal surfaces the vectors happen to be co-linear
return Frame(self.pt, Vector(1, 0, 0), Vector(0, 1, 0))
def cutting_plane(mesh, ry=10, rz=-50):
plane = Plane(mesh.centroid(), Vector(1, 0, 0))
Ry = Rotation.from_axis_and_angle(Vector(0, 1, 0), radians(ry),
plane.point)
Rz = Rotation.from_axis_and_angle(Vector(0, 0, 1), radians(rz),
plane.point)
plane.transform(Rz * Ry)
return plane
def board_geometry_setup():
for my_element in self.elements():
my_board = my_element[1]
if my_board.layer % 2 == 0:
my_frame = self.origin_fr
layer_standard_length = self.primary_length
else:
my_frame = self.sec_fr
layer_standard_length = self.secondary_length
my_dir1 = normalize_vector(my_frame[1])
my_dir2 = normalize_vector(my_frame[2])
dist = my_board.grid_position
if my_board.location == "high":
if not my_board.supporter:
length_attribute_1 = layer_standard_length - my_board.length / 2
else:
length_attribute_1 = layer_standard_length - my_board.width / 2
elif my_board.location == "low":
if not my_board.supporter:
length_attribute_1 = my_board.length / 2
else:
length_attribute_1 = my_board.width / 2
else:
length_attribute_1 = layer_standard_length / 2
# position parallel to the boards (if not sup)
my_vec1 = scale_vector(my_dir1, length_attribute_1)
# position perpendicular to board direction (if not sup)
my_vec2 = scale_vector(my_dir2, dist)
# height vector
my_vec3 = Vector(0, 0, my_board.z_drop - my_board.height / 2)
my_centre = self.origin_pt + my_vec1 + my_vec2 + my_vec3
my_board.centre_point = my_centre
my_board.drop_point = my_centre + Vector(0, 0, my_board.height / 2)
if not my_board.perp:
my_board.length_vector = normalize_vector(my_vec1)
my_board.width_vector = normalize_vector(my_vec2)
else:
my_board.length_vector = normalize_vector(my_vec2)
my_board.width_vector = normalize_vector(my_vec1)
old_centre = my_board.center
T = Translation(my_centre - old_centre)
self.network.node[my_board.global_count]['x'] = my_centre[0]
self.network.node[my_board.global_count]['y'] = my_centre[1]
self.network.node[my_board.global_count]['z'] = my_centre[2]
my_board.transform(T)
my_board.board_frame = Frame(my_board.centre_point, my_board.length_vector, my_board.width_vector)
my_board.tool_frame = Frame(my_board.drop_point, my_board.length_vector, my_board.width_vector)
my_board.box = Box(my_board.board_frame, my_board.length, my_board.width, my_board.height)
def __init__(self, o, e=0.01):
self.o = o
self.e = e
self.ex = Point(e, 0, 0)
self.ey = Point(0, e, 0)
self.ez = Point(0, 0, e)
self.k0 = Vector(1, -1, -1)
self.k1 = Vector(-1, -1, 1)
self.k2 = Vector(-1, 1, -1)
self.k3 = Vector(1, 1, 1)
def test_basis_vectors():
trans1 = [1, 2, 3]
angle1 = [-2.142, 1.141, -0.142]
scale1 = [0.123, 2, 0.5]
T1 = Translation(trans1)
R1 = Rotation.from_euler_angles(angle1)
S1 = Scale(scale1)
M = (T1 * R1) * S1
x, y = M.basis_vectors
assert np.allclose(x, Vector(0.41249169135312663, -0.05897071585157175, -0.9090506362335324))
assert np.allclose(y, Vector(-0.8335562904208867, -0.4269749553355485, -0.35053715668381935))
def mesh_subdivide_tapered(mesh, k=1, height=1.0, ratio=0.5, doCap=False ):
"""
Subdivide a mesh extruding its faces tapered like a window by creating an
offset face and quads between every original edge and the
corresponding new edge.
Parameters
----------
mesh : Mesh
The mesh object that will be subdivided.
k : int
Optional. The number of levels of subdivision. Default is ``1``.
height : float
The distance of the new vertex to the face.
ratio : float
The relative offset distance
Returns
-------
Mesh
A new subdivided mesh.
"""
subd = mesh.copy()
for fkey in mesh.faces():
centroid = mesh.face_centroid(fkey)
centroid_vector = Vector(*centroid)
normal = mesh.face_normal(fkey)
normal_vector = Vector(*normal)
normal_vector *= height
face_verts = mesh.face_vertices(fkey)
new_verts = []
for v in face_verts:
v_coords = mesh.vertex_coordinates(v)
v_vector = Vector(*v_coords)
vert_to_cent = centroid_vector - v_vector
vert_to_cent *= ratio
new_vertex = v_vector + vert_to_cent + normal_vector
x, y, z = new_vertex
new_verts.append(subd.add_vertex(x=x, y=y, z=z))
for i, v in enumerate(face_verts):
next_v = face_verts[(i+1) % len(face_verts)]
new_v = new_verts[i]
next_new_v = new_verts[(i+1) % len(face_verts)]
new_face_key = subd.add_face([v, next_v, next_new_v, new_v])
if doCap:
top_face_key = subd.add_face(new_verts)
del subd.face[fkey]
return subd
def basis_vectors(self):
"""Returns the basis vectors of the ``Rotation``.
Returns
-------
tuple: (:class:`Vector`, :class:`Vector`)
"""
from compas.geometry import Vector
xaxis, yaxis = basis_vectors_from_matrix(self.matrix)
return Vector(*xaxis), Vector(*yaxis)
def basis_vectors(self):
"""The basis vectors from the rotation component of the transformation matrix.
Returns
-------
tuple of :class:`compas.geometry.Vector`
The basis vectors of the rotation component of the tranformation.
"""
from compas.geometry import Vector
x, y = basis_vectors_from_matrix(self.rotation.matrix)
return Vector(*x), Vector(*y)
def test_from_tcf_to_t0cf(mesh, frame):
tool = ToolModel(mesh, frame)
frames_tcf = [
Frame((-0.309, -0.046, -0.266), (0.276, 0.926, -0.256),
(0.879, -0.136, 0.456))
]
result = tool.from_tcf_to_t0cf(frames_tcf)
expected = [
Frame(Point(-0.363, 0.003, -0.147), Vector(0.388, -0.351, -0.852),
Vector(0.276, 0.926, -0.256))
]
assert allclose(result[0], expected[0], tol=1e-03)
def cross_product_arrays(a, b):
"""
Compute the cross products for two arrays of vectors using for loop
Args:
a: array of vectors: numpy.array, a list of vectors a
b: array of vectors: numpy.array, a list of vectors b
Returns:
cross products: list of compas.geometry.Vector
"""
if len(a) is not len(b):
raise Exception("Input arrays need to be same length")
return [Vector(*a[i]).cross(Vector(*b[i])) for i in range(len(a))]
def from_bounding_box(cls, bbox):
a = bbox[0]
b = bbox[1]
d = bbox[3]
e = bbox[4]
xaxis = Vector(*subtract_vectors(d, a))
yaxis = Vector(*subtract_vectors(b, a))
zaxis = Vector(*subtract_vectors(e, a))
xsize = xaxis.length
ysize = yaxis.length
zsize = zaxis.length
frame = Frame(a, xaxis, yaxis)
return cls(frame, xsize, ysize, zsize)
def gluepath_creator(int_surf, path_width):
def interval_checker(dimension):
underflow = dimension % path_width
if underflow > 0.2:
no_paths = dimension // path_width + 1
new_path_width = dimension / no_paths
return new_path_width
else:
return path_width
wid_gap = int_surf[1] - int_surf[0]
wid_vec = Vector(wid_gap[0], wid_gap[1], wid_gap[2])
wid = wid_vec.length
wid_vec.unitize()
len_gap = int_surf[2] - int_surf[1]
len_vec = Vector(len_gap[0], len_gap[1], len_gap[2])
len = len_vec.length
len_vec.unitize()
wid_path = interval_checker(wid)
len_path = interval_checker(len)
path_dims = [wid_path, len_path]
path_points = []
iteration = 0
path_unfinished = True
current_pt = int_surf[0] + scale_vector(
wid_vec, wid_path / 2) + scale_vector(len_vec, len_path / 2)
current_vec = len_vec.unitized()
len_left = len - len_path
wid_left = wid - wid_path
dims_left = [len_left, wid_left]
path_points.append(current_pt)
R = Rotation.from_axis_and_angle([0, 0, 1], -math.pi / 2)
while path_unfinished:
current_index = iteration % 2
current_dim = dims_left[current_index]
if iteration > 2:
current_dim -= path_dims[current_index]
dims_left[current_index] = current_dim
if current_dim < path_width * 0.95:
break
current_pt = current_pt + scale_vector(current_vec,
current_dim)
path_points.append(current_pt)
current_vec.transform(R)
current_vec.unitize()
iteration += 1
if not is_point_in_polygon_xy(current_pt, int_surf):
print("Error: Point not in polygon")
return path_points
def get_layer_ppts(self, layer, base_boundary):
""" Creates the PrintPoints of a single layer."""
max_layer_height = get_param(self.parameters,
key='max_layer_height',
defaults_type='layers')
min_layer_height = get_param(self.parameters,
key='min_layer_height',
defaults_type='layers')
avg_layer_height = get_param(self.parameters, 'avg_layer_height',
'layers')
all_pts = [pt for path in layer.paths for pt in path.points]
closest_fks, projected_pts = utils.pull_pts_to_mesh_faces(
self.slicer.mesh, all_pts)
normals = [
Vector(*self.slicer.mesh.face_normal(fkey)) for fkey in closest_fks
]
count = 0
crv_to_check = Path(
base_boundary.points,
True) # creation of fake path for the lower boundary
layer_ppts = {}
for i, path in enumerate(layer.paths):
layer_ppts['path_%d' % i] = []
for p in path.points:
cp = closest_point_on_polyline(p,
Polyline(crv_to_check.points))
d = distance_point_point(cp, p)
ppt = PrintPoint(pt=p,
layer_height=avg_layer_height,
mesh_normal=normals[count])
ppt.closest_support_pt = Point(*cp)
ppt.distance_to_support = d
ppt.layer_height = max(min(d, max_layer_height),
min_layer_height)
ppt.up_vector = Vector(
*normalize_vector(Vector.from_start_end(cp, p)))
ppt.frame = ppt.get_frame()
layer_ppts['path_%d' % i].append(ppt)
count += 1
crv_to_check = path
return layer_ppts
def convert_data_vectors_list_to_compas_vectors(vectors_data_list,
ROUND=False):
"""
vector_coordinates looks like this;
vector_coordinates = [x, y, z]
"""
compasVector_list = []
for vec_data in vectors_data_list:
if ROUND:
compasVector = Vector(round(vec_data[0], 3), round(vec_data[1], 3),
round(vec_data[2], 3))
else:
compasVector = Vector(vec_data[0], vec_data[1], vec_data[2])
compasVector_list.append(compasVector)
return compasVector_list
def to_local_geometry_xy(self):
mesh_Point3D = []
mesh_points = []
for pt in self.gusset_points:
mesh_Point3D.append(
translate_points([pt], Vector(0, 0, -0.5 * self.thickness))[0])
mesh_Point3D.append(
translate_points([pt], Vector(0, 0, 0.5 * self.thickness))[0])
for pt in mesh_Point3D:
mesh_points.append({
'x': float(pt[0]),
'y': float(pt[1]),
'z': float(pt[2])
})
return [mesh_points]
def board_geometry_setup(self):
for my_layer in range(self.layer_no):
if my_layer % 2 == 0:
my_frame = self.origin_fr
else:
my_frame = self.sec_fr
my_dir1 = normalize_vector(my_frame[1])
my_dir2 = normalize_vector(my_frame[2])
# we have to separate i/board_code because of possible exceptions in the centre
for my_board in self.timberboards[my_layer]:
dist = my_board.grid_position
# build the three vectors with which we later find he centre point
# one advanced case
layer_standard_length = my_board.layer.characteristic_length
if my_board.location == "high":
if not my_board.supporter:
length_attribute_1 = layer_standard_length - my_board.length / 2
else:
length_attribute_1 = layer_standard_length - my_board.width / 2
elif my_board.location == "low":
if not my_board.supporter:
length_attribute_1 = my_board.length / 2
else:
length_attribute_1 = my_board.width / 2
else:
length_attribute_1 = layer_standard_length / 2
# position parallel to the boards (if not sup)
my_vec1 = scale_vector(my_dir1, length_attribute_1)
# position perpendicular to board direction (if not sup)
my_vec2 = scale_vector(my_dir2, dist)
# height vector
my_vec3 = Vector(
0, 0, my_board.layer.z_drop_point - my_board.height / 2)
my_centre = self.origin_pt + my_vec1 + my_vec2 + my_vec3
my_board.centre_point = my_centre
my_board.drop_point = my_centre + Vector(
0, 0, my_board.height / 2)
if not my_board.supporter:
my_board.length_vector = normalize_vector(my_vec1)
my_board.width_vector = normalize_vector(my_vec2)
else:
my_board.length_vector = normalize_vector(my_vec2)
my_board.width_vector = normalize_vector(my_vec1)
my_board.box_update()
def get_normals_on_vertices(self):
if len(self.pts_list) > 2:
threePts_string = zip(self.pts_list[:-2], self.pts_list[1:-1],
self.pts_list[2:])
for threePts in threePts_string:
normal, radius, centrePt = calculate_normal_on_vertex_with_three_pts(
threePts)
self.normals.append(normal)
## first vertex ##
vecfirst = self.pts_list[0] - self.pts_list[1]
vecsecond = self.pts_list[2] - self.pts_list[1]
binormal_temp = vecfirst.cross(vecsecond)
binormal = binormal_temp.unitized()
normal_temp = vecfirst.cross(binormal)
normal = normal_temp.unitized()
self.normals.insert(0, normal)
## last vertex ##
veclast = self.pts_list[-1] - self.pts_list[-2]
vecseclast = self.pts_list[-3] - self.pts_list[-2]
binormal_temp = vecseclast.cross(veclast)
binormal = binormal_temp.unitized()
normal_temp = binormal.cross(veclast)
normal = normal_temp.unitized()
self.normals.append(normal)
else:
firstPt = self.pts_list[0]
lastPt = self.pts_list[1]
vec = firstPt - lastPt
normal = vec.cross(Vector(-1, 0, 0))
normal.unitize()
self.normals.append(normal)
self.normals.append(normal)
