def __make_laser_sensor_long_range(self):
x = self.parameters['x']
y = self.parameters['y']
z = self.parameters['z']
lslr = fso.Box(x=x, y=y, z=z)
lens_r = self.parameters['lens_r']
lens_l = self.parameters['lens_l']
lens = fso.Cylinder(r=lens_r, l=lens_l)
lens.rotate(angle=-math.pi / 2, axis=[0, 1, 0])
lens_tx = -lens_l / 2 - x / 2
lens_ty = self.parameters['lens_ty']
lens.translate([lens_tx, lens_ty, 0])
lslr |= lens
lslr.set_color(self.parameters['color'], recursive=True)
if self.parameters['show_laser_beam']:
laser_beam = fso.Cylinder(r=self.parameters['laser_beam_r'],
l=self.parameters['laser_beam_l'])
laser_beam.rotate(angle=math.pi / 2, axis=[0, 1, 0])
laser_beam.set_color(self.parameters['laser_beam_color'])
laser_beam_tx = -self.parameters['laser_beam_l'] / 2
laser_beam_ty = lens_ty
laser_beam_tz = 0
laser_beam.translate([laser_beam_tx, laser_beam_ty, laser_beam_tz])
lslr |= laser_beam
self.add_obj(lslr)
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
# Pillowblock mount holes
hole_x = self.pillowblock_parameters['hole_z']
hole_y = self.pillowblock_parameters['hole_x']
base_hole = fso.Cylinder(r=hole_r, l=hole_l)
holes = po.LinearArray(base_hole, hole_x, hole_y, [0])
self.add_obj(holes)
# T-slotted bracket mount holes
hole_x = [-3.5, -2.5, 2.5, 3.5]
hole_y = [-1.5, -0.5, 0.5, 1.5]
holes = po.LinearArray(base_hole, hole_x, hole_y, [0])
self.add_obj(holes)
# Motorized sled mount holes
hole_x = [-2.125, 2.125]
hole_y = [-2.3125, 2.3125]
holes = po.LinearArray(base_hole, hole_x, hole_y, [0])
self.add_obj(holes)
# Slots for motorized sled mount holes
hole = fso.Cylinder(r=0.125, l=self.parameters['z'] * 2)
holes = po.LinearArray(hole, [0], [-0.5, 0.5], [0])
slot = fso.Box(x=0.25, y=1, z=self.parameters['z'] * 2)
slot = holes | slot
slots = po.LinearArray(slot, [-2.125, 2.125], [0], [0])
self.add_obj(slots)
def __make_carriage(self):
"""
Creates the carriage component of the RAB air bearing.
"""
# Create base rectangle
length = self.parameters['carriage_length']
width = self.parameters['carriage_width']
height = self.parameters['carriage_height']
carriage = fso.Box(x=length, y=width, z=height)
# Subtract slide from carraige
slide_width = self.parameters[
'slide_width'] + 2 * self.parameters['slide_tolerance']
slide_height = self.parameters[
'slide_height'] + 2 * self.parameters['slide_tolerance']
slide_negative = fso.Box(x=2 * length, y=slide_width, z=slide_height)
carriage = carriage - slide_negative
# Create mounting holes
radius = 0.5 * self.parameters['carriage_screw_size']
base_hole = fso.Cylinder(r=radius, l=2 * height)
hole_list = []
for i in (-1, 1):
for j in (-1, 1):
xpos = i * 0.5 * self.parameters['carriage_screw_dL']
ypos = j * 0.5 * self.parameters['carriage_screw_dW']
hole = base_hole.copy()
hole.translate([xpos, ypos, 0])
hole_list.append(hole)
# Remove hole material
# print hole_list
carriage -= hole_list
carriage.set_color(self.carriage_color, recursive=True)
self.carriage = carriage
def __make_slide(self):
"""
Creates the slide component of the RAB air bearing.
"""
# Create base rectangle for slide
length = self.parameters['slide_base_length'] + self.parameters[
'bearing_slide_travel']
width = self.parameters['slide_width']
height = self.parameters['slide_height']
slide = fso.Box(x=length, y=width, z=height)
# Create the mounting holes
radius = 0.5 * self.parameters['slide_screw_size']
base_hole = fso.Cylinder(r=radius, l=2 * height)
hole_list = []
for i in (-1, 1):
for j in (-1, 1):
xpos = i * (0.5 * length -
self.parameters['slide_screw_inset'])
ypos = j * (0.5 * self.parameters['slide_screw_dW'])
hole = base_hole.copy()
hole.translate([xpos, ypos, 0])
hole_list.append(hole)
# Remove hole material
slide -= hole_list
slide.set_color(self.slide_color, recursive=True)
self.slide = slide
def __make_holes(self):
# Add airbearing mount holes
hole_diameter = self.parameters['hole_diameter']
hole = fso.Cylinder(r=hole_diameter / 2, l=self.parameters['z'] * 2)
h_x = self.ab_parameters['carriage_screw_dL'] / 2
h_y = self.ab_parameters['carriage_screw_dW'] / 2
holes = po.LinearArray(hole, x=[-h_x, h_x], y=[-h_y, h_y], z=0)
self.add_obj(holes)
# Add y_beam mount counterbore holes
cb_diameter = 7 / 16
cb_depth = 0.25
cb = fso.Cylinder(r=cb_diameter / 2, l=self.parameters['z'])
cb.translate([0, 0, (-self.parameters['z'] + cb_depth)])
cbh = cb | hole
cbhs = po.LinearArray(cbh, x=[-2.5, 0, 2.5], y=[-1.5, 1.5], z=0)
self.add_obj(cbhs)
def __make_submersible(self):
body_diameter = self.parameters['body_diameter']
cylinder1 = fso.Cylinder(r=body_diameter / 2, l=body_diameter)
cylinder1.rotate(angle=math.pi / 2, axis=[0, 1, 0])
c2_length = self.parameters['body_length'] - body_diameter
cylinder2 = fso.Cylinder(r=body_diameter / 2, l=c2_length)
cylinder2.rotate(angle=math.pi / 2, axis=[0, 1, 0])
cylinder2.translate([body_diameter / 2 + c2_length / 2, 0, 0])
sphere = fso.Sphere(r=body_diameter / 2)
sphere.translate([body_diameter / 2 + c2_length, 0, 0])
cylinder3 = fso.Cylinder(r=self.parameters['shaft_diameter'] / 2,
l=self.parameters['shaft_length'])
cylinder3.translate([0, 0, self.parameters['shaft_length'] / 2])
box = fso.Box(x=2, y=0.25, z=body_diameter / 2 + 2)
box.translate([0, 0, -(body_diameter / 2 + 2) / 2])
submersible = cylinder1 | cylinder2 | sphere | cylinder3 | box
submersible.set_color(self.parameters['color'], recursive=True)
self.add_obj(submersible)
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
hole = fso.Cylinder(r=hole_r, l=hole_l)
hole_x = self.parameters['x'] / 2 - 0.5
hole_ay = [-1, 0, 1]
hole_z = 0
holes = po.LinearArray(hole, x=[-hole_x, hole_x], y=hole_ay, z=hole_z)
self.add_obj(holes)
def __make_holes(self):
hole_l = self.parameters['hole_l']
# Loadcell mount holes
hole_r_loadcell = self.parameters['hole_r_loadcell']
base_hole = fso.Cylinder(r=hole_r_loadcell, l=hole_l)
hole_x = self.loadcell_parameters['hole_z']
holes = po.LinearArray(base_hole, hole_x, 0, 0)
self.add_obj(holes)
# T-slotted bracket mount holes
hole_r_big = self.parameters['hole_r_big']
base_hole = fso.Cylinder(r=hole_r_big, l=hole_l)
hole_x = self.parameters['hole_x_big']
holes = po.LinearArray(base_hole, [-hole_x, hole_x], 0, 0)
self.add_obj(holes)
def __make_holes(self):
hole_l = self.parameters['hole_l']
# Laser_sensor_long_range mount holes
hole_r_counterbore = self.parameters['hole_r_counterbore']
base_hole = fso.Cylinder(r=hole_r_counterbore, l=hole_l)
hole_x = self.lssr_parameters['hole_x']
hole_y = self.lssr_parameters['hole_y']
holes = po.LinearArray(base_hole, [-hole_x, hole_x], [-hole_y, hole_y],
0)
self.add_obj(holes)
# T-slotted bracket mount holes
hole_r = self.parameters['hole_r']
base_hole = fso.Cylinder(r=hole_r, l=hole_l)
hole_x = self.parameters['hole_x_t-slotted']
hole_y = self.parameters['hole_y_t-slotted']
holes = po.LinearArray(base_hole, [-hole_x, hole_x], [-hole_y, hole_y],
0)
self.add_obj(holes)
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
hole = fso.Cylinder(r=hole_r, l=hole_l)
hole_x = self.parameters['hole_x']
hole_y = self.parameters['hole_y']
hole_z = 0
holes = po.LinearArray(hole,
x=[-hole_x, hole_x],
y=[-hole_y, hole_y],
z=hole_z)
self.add_obj(holes)
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
hole_tx = self.parameters['hole_tx']
hole_ty = self.parameters['hole_ty']
base_hole = fso.Cylinder(r=hole_r, l=hole_l)
hole1 = base_hole.copy()
hole1.translate([-hole_tx, hole_ty, 0])
hole2 = base_hole.copy()
hole2.translate([hole_tx, -hole_ty, 0])
hole1.set_color(self.parameters['color'])
hole2.set_color(self.parameters['color'])
self.add_obj([hole1, hole2])
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
hole = fso.Cylinder(r=hole_r, l=hole_l * 2)
hole_x = self.parameters['hole_x']
hole_y = self.parameters['hole_y']
hole_z = 0
holes = po.LinearArray(hole,
x=[-hole_x, hole_x],
y=[-hole_y, hole_y],
z=hole_z)
holes.translate([0, 0, -self.parameters['z'] / 2])
holes.set_color(self.parameters['color'], recursive=True)
self.add_obj(holes)
def __make_holes(self):
hole_r = self.parameters['hole_r']
hole_l = self.parameters['hole_l']
hole_x = self.parameters['hole_x']
hole_z = self.parameters['hole_z']
hole_list = []
base_hole = fso.Cylinder(r=hole_r, l=hole_l)
base_x_hole = base_hole.copy()
base_x_hole.rotate(angle=-math.pi / 2, axis=[1, 0, 0])
for z in hole_z:
for x in hole_x:
hole = base_x_hole.copy()
hole.translate([x, 0, z])
hole_list.append(hole)
self.add_obj(hole_list)
def __make_holes(self):
hole_l = self.parameters['hole_l']
# Laser_sensor_short_range mount holes
hole_r_lssr = self.parameters['hole_r_lssr']
base_hole = fso.Cylinder(r=hole_r_lssr, l=hole_l)
hole_x = self.lssr_parameters['hole_ty']
hole_y = self.lssr_parameters['hole_tx']
holes = po.LinearArray(base_hole, [-hole_x, hole_x], [-hole_y, hole_y],
0)
holes.translate(
[self.parameters['lssr_tx'], self.parameters['lssr_ty'], 0])
self.add_obj(holes)
# T-slotted bracket mount holes
hole_r_big = self.parameters['hole_r_big']
base_hole = fso.Cylinder(r=hole_r_big, l=hole_l)
hole_ax = [-0.5, 0.5]
hole_ay = [-1.5, 0, 1.5]
holes = po.LinearArray(base_hole, hole_ax, hole_ay, 0)
holes.translate([self.parameters['mount_hole_tx'], 0, 0])
self.add_obj(holes)
def __make_rails(self):
rail_radius = self.parameters['rail_diameter'] / 2
rail_rail_distance = self.parameters['rail_rail_distance']
rail_length = self.parameters['rail_length']
rail_color = self.parameters['rail_color']
rail = fso.Cylinder(r=rail_radius, l=rail_length)
rail.rotate(angle=math.pi / 2, axis=[0, 1, 0])
rails = po.LinearArray(
rail,
x=[0],
y=[-rail_rail_distance / 2, rail_rail_distance / 2],
z=[0])
rails.set_color(rail_color, recursive=True)
self.add_obj(rails)
def __make_laser_sensor_short_range(self):
profile = self.parameters['profile']
l = self.parameters['z']
lssr = fso.Extrusion(profile=profile, l=l)
lssr.set_color(self.parameters['color'], recursive=True)
if self.parameters['show_laser_beam']:
laser_beam = fso.Cylinder(r=self.parameters['laser_beam_r'],
l=self.parameters['laser_beam_l'])
laser_beam.rotate(angle=math.pi / 2, axis=[1, 0, 0])
laser_beam.set_color(self.parameters['laser_beam_color'])
laser_beam_tx = self.parameters['laser_beam_tx']
laser_beam_ty = -self.parameters['laser_beam_l'] / 2
laser_beam_tz = 0
laser_beam.translate([laser_beam_tx, laser_beam_ty, laser_beam_tz])
lssr |= laser_beam
self.add_obj(lssr)
def __init__(self, tail=[0, 0, 0], head=[1, 0, 0], color=[1, 0, 0]):
super(Vector, self).__init__()
z_axis = numpy.array([0, 0, 1])
tail = numpy.array(tail)
head = numpy.array(head)
vector = head - tail
length = numpy.linalg.norm(vector)
cone_cylinder_length_ratio = 0.2
cone_head_tail_ratio = 0.1
cylinder_radius_length_ratio = 0.02
cone_tail_cylinder_radius_ratio = 3
cone_head_cylinder_radius_ratio = 0.1
cylinder_length = length / (1 + cone_cylinder_length_ratio / 2)
cylinder_radius = cylinder_length * cylinder_radius_length_ratio
cone_length = cylinder_length * cone_cylinder_length_ratio
cone_tail_radius = cylinder_radius * cone_tail_cylinder_radius_ratio
cone_head_radius = cylinder_radius * cone_head_cylinder_radius_ratio
cylinder = fso.Cylinder(l=cylinder_length, r=cylinder_radius)
cone = fso.Cone(l=cone_length,
r_pos=cone_head_radius,
r_neg=cone_tail_radius)
cone.translate([0, 0, cylinder_length / 2])
self.add_obj([cylinder, cone])
self.translate([0, 0, cylinder_length / 2])
rot_axis = numpy.cross(z_axis, vector)
dot = numpy.dot(z_axis, vector)
z_axis_modulus = numpy.sqrt((z_axis * z_axis).sum())
vector_modulus = numpy.sqrt((vector * vector).sum())
rot_angle = numpy.pi / 2 - dot / z_axis_modulus / vector_modulus
# print "dot = " + str(dot)
# print "z_axis_modulus = " + str(z_axis_modulus)
# print "vector_modulus = " + str(vector_modulus)
# print "angle = " + str(rot_angle)
# print "axis = " + str(rot_axis)
self.rotate(angle=rot_angle, axis=rot_axis)
self.translate(list(tail))
self.set_color(color, recursive=True)
def __make_holes(self):
hole_r = self.profile_data['lbracket'][self.bracket_type]['hole_r']
hole_l = self.profile_data['lbracket'][self.bracket_type]['hole_l']
hole_x = self.profile_data['lbracket'][self.bracket_type]['hole_x']
hole_y = self.profile_data['lbracket'][self.bracket_type]['hole_y']
hole_z = self.profile_data['lbracket'][self.bracket_type]['hole_z']
# hole_list = []
base_hole = fso.Cylinder(r=hole_r, l=hole_l)
base_x_hole = base_hole.copy()
base_x_hole.rotate(angle=math.pi / 2, axis=[1, 0, 0])
x_holes = po.LinearArray(base_x_hole, x=hole_x, y=[0], z=hole_z)
self.add_obj(x_holes)
# for z in hole_z:
# for x in hole_x:
# hole = base_x_hole.copy()
# hole.translate([x,0,z])
# hole_list.append(hole)
base_y_hole = base_hole.copy()
base_y_hole.rotate(angle=math.pi / 2, axis=[0, 1, 0])
y_holes = po.LinearArray(base_y_hole, x=[0], y=hole_y, z=hole_z)
self.add_obj(y_holes)
def __make_bowl_cutout(self):
bowl_cutout_diameter = self.fly_bowl_parameters['bowl_diameter'] + 1
bowl_cutout_l = self.parameters['z']*2
bowl_cutout = fso.Cylinder(l=bowl_cutout_l,r=bowl_cutout_diameter/2)
self.add_obj(bowl_cutout)
def __make_holes(self):
hole = fso.Cylinder(r=self.parameters['hole_diameter'] / 2,
l=self.parameters['z'] * 2)
hole_ty = self.ab_parameters['slide_screw_dW'] / 2
holes = po.LinearArray(hole, x=0, y=[-hole_ty, hole_ty], z=0)
self.add_obj(holes)