def generate(self):
""" Generate the rig.
Do NOT modify any of the original bones, except for adding constraints.
The main armature should be selected and active before this is called.
"""
ctrl_bones = self.fk_limb.generate()
thigh = ctrl_bones[0]
shin = ctrl_bones[1]
foot = ctrl_bones[2]
foot_mch = ctrl_bones[3]
# Position foot control
bpy.ops.object.mode_set(mode='EDIT')
eb = self.obj.data.edit_bones
foot_e = eb[foot]
vec = Vector(eb[self.org_bones[3]].vector)
vec.normalize()
foot_e.tail = foot_e.head + (vec * foot_e.length)
foot_e.roll = eb[self.org_bones[3]].roll
bpy.ops.object.mode_set(mode='OBJECT')
# Create foot widget
ob = create_widget(self.obj, foot)
if ob is not None:
verts = [(0.7, 1.5, 0.0), (0.7, -0.25, 0.0), (-0.7, -0.25, 0.0), (-0.7, 1.5, 0.0), (0.7, 0.723, 0.0), (-0.7, 0.723, 0.0), (0.7, 0.0, 0.0), (-0.7, 0.0, 0.0)]
edges = [(1, 2), (0, 3), (0, 4), (3, 5), (4, 6), (1, 6), (5, 7), (2, 7)]
mesh = ob.data
mesh.from_pydata(verts, edges, [])
mesh.update()
mod = ob.modifiers.new("subsurf", 'SUBSURF')
mod.levels = 2
return [thigh, shin, foot, foot_mch]
def write_camera(self, camera, name="Active Camera"):
pos, target, up = camera.GetOrientation()
bpy.ops.object.add(type='CAMERA', location=pos)
ob = self.context.object
ob.name = name
z = (Vector(pos) - Vector(target))
x = Vector(up).cross(z)
y = z.cross(x)
x.normalize()
y.normalize()
z.normalize()
ob.matrix_world.col[0] = x.resized(4)
ob.matrix_world.col[1] = y.resized(4)
ob.matrix_world.col[2] = z.resized(4)
cam = ob.data
aspect_ratio = camera.aspect_ratio
fov = camera.fov
if aspect_ratio == False: # we seem to be using dynamic / screen aspect ratio
sketchupLog("CAMERA {} uses dynamic / screen aspect ratio ".format(name))
aspect_ratio = self.aspect_ratio
if fov == False:
sketchupLog("CAMERA {} is ortho ".format(name))
cam.type = 'ORTHO'
else:
cam.angle = (pi * fov / 180 ) * aspect_ratio
cam.clip_end = self.prefs.camera_far_plane
cam.name = name
def scale_bone_from_origin(bone_name, length): """ returns the bone tail Vector(x,y,z) """ direction = Vector(amt.edit_bones[bone_name].tail) - Vector(amt.edit_bones[bone_name].head) direction.normalize() direction *= length return Vector(amt.edit_bones[bone_name].head) + direction
def normalAt(self, t): tan = self.tangentAt(t) # Rotate the normal along the Z-up axis normal = Vector((tan.y, -tan.x, tan.z)) normal.normalize() return normal
def triangle_relative_to_verts(top, base_relative, base_length):
v1 = Vector(top)
v = Vector([-base_relative[1] / 2, base_relative[0] / 2])
v.normalize()
v *= base_length / 2
vb = Vector(base_relative)
v2 = v1 + vb + v
v3 = v1 + vb - v
return v1, v2, v3
def depth_cast(self, xy, radius=0, cached=True, coords='REGION'):
xy = self.convert_ui_coord(xy, coords, 'REGION', False)
radius = int(radius)
search = (radius > 0)
radius = max(radius, 1)
sz = radius * 2 + 1 # kernel size
w, h = sz, sz
zbuf = self.read_zbuffer(xy, (sz, sz), centered=True, cached=cached)
def get_pos(x, y):
wnd_x = min(max(x+radius, 0), w-1)
wnd_y = min(max(y+radius, 0), h-1)
z = zbuf[wnd_x + wnd_y * w]
if (z >= 1.0) or (z < 0.0): return None
d = self.zbuf_to_depth(z)
return self.unproject((xy[0]+x, xy[1]+y), d)
cx, cy = 0, 0
center = None
if search:
rr = radius * radius
for dxy in self.__radial_search_pattern:
if dxy[2] > rr: break
p = get_pos(dxy[0], dxy[1])
if p is not None:
cx, cy = dxy[0], dxy[1]
center = p
break
else:
center = get_pos(0, 0)
if center is None: return (False, None, Matrix(), Vector(), Vector())
normal_count = 0
normal = Vector()
last_i = -10 # just some big number
last_p = None
neighbors = ((-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
for i, nbc in enumerate(neighbors):
nbx, nby = nbc
p = get_pos(cx + nbx, cy + nby)
if p is None: continue
if (i - last_i) < 4:
d0 = last_p - center
d1 = p - center
normal += d0.cross(d1).normalized()
normal_count += 1
last_p = p
last_i = i
if normal_count > 1: normal.normalize()
return (True, None, Matrix(), center, normal)
def create_geometry(self, bm, e_loops):
geom_extruded = bmesh.ops.extrude_edge_only(bm, edges=e_loops)["geom"]
self.offset_verts = offset_verts = [e for e in geom_extruded if isinstance(e, bmesh.types.BMVert)]
self.offset_edges = offset_edges = [e for e in geom_extruded if isinstance(e, bmesh.types.BMEdge)]
self.side_faces = side_faces = [f for f in geom_extruded if isinstance(f, bmesh.types.BMFace)]
bmesh.ops.recalc_face_normals(bm, faces=side_faces)
self.side_edges = side_edges = [e.link_loops[0].link_loop_next.edge for e in offset_edges]
for f in side_faces:
f.select = True
extended_verts = self.extended_verts
self.v_v_pairs = v_v_pairs = dict() # keys is offset vert,
# values is original vert.
for e in side_edges:
v1, v2 = e.verts
if v1 in offset_verts:
v_offset, v_orig = v1, v2
else:
v_offset, v_orig = v2, v1
v_v_pairs[v_offset] = v_orig
if v_orig in extended_verts:
extended_verts.add(v_offset)
self.faces = faces = bmesh.ops.edgeloop_fill(bm, edges=offset_edges, mat_nr=0, use_smooth=False)["faces"]
self.l_fn_pairs = l_fn_pairs = dict() # loop - face normal pairs.
for face in faces:
face.loops.index_update()
if face.normal.dot(v_v_pairs[face.verts[0]].normal) < 0.0:
face.normal_flip()
for fl in face.loops:
edge = fl.link_loop_radial_next.link_loop_next.link_loop_next.edge
co = 0
normal = Vector((0.0, 0.0, 0.0))
for f in edge.link_faces:
if f not in side_faces and not f.hide and f.normal.length:
normal += f.normal
co += 1
if f.select:
l_fn_pairs[fl] = f.normal.copy()
break
else:
if co:
normal.normalize()
l_fn_pairs[fl] = normal
# Be careful, if you flip face normal after
# this line, l_fn_pairs won't work as you expect
# because face.normal_flip() changes loop order in
# the face.
return faces
def polygon_normal_angle_D(verts, poly, D):
''' The angle between the polygon normal and the given direction '''
N = polygon_normal(verts, poly)
v1 = Vector(N)
v2 = Vector(D)
v1.normalize()
v2.normalize()
angle = acos(v1.dot(v2)) # the angle in radians
return angle
def shape_square(context, orientation):
center = context.scene.cursor_location
active = context.active_object
zed = active.location[2]
base_dir = active.location.xy - center.xy
diagonal = base_dir.length
if orientation == 'XY':
zero_dir = get_xy_corner(base_dir).resized(3)
else:
zero_dir = base_dir.xy.resized(3)
num_objects = len(context.selected_objects)
num_side_objects = (num_objects // 4) - 1
ortho_angle = math.pi * 0.5
ortho_dir = Vector(zero_dir)
ortho_dir.rotate(Euler((0, 0, ortho_angle * 0.5)))
ortho_dir.normalize()
# sort objects based on angle to center
sorted_objects = sorted(context.selected_objects, key=lambda ob: get_angle(base_dir, ob, center))
corners = []
for i in range(0, num_objects, num_side_objects + 1):
corners.append(sorted_objects[i])
assert(len(corners) == 4)
sides = [ob for ob in sorted_objects if ob not in corners]
side_step = math.sqrt(2 * (diagonal ** 2)) / (num_side_objects + 1)
for i in range(4):
# corner
angle = ortho_angle * i
euler = Euler((0, 0, -angle))
direction = Vector(zero_dir)
direction.rotate(euler)
corners[i].location = center + direction
corners[i].location[2] = zed
side_dir = Vector(ortho_dir)
side_dir.rotate(euler)
for j in range(num_side_objects):
ob = sides[(i * num_side_objects) + j]
step = (j + 1) * side_step
ob.location = center + direction
ob.location.xy -= side_dir.xy * step
ob.location[2] = zed
def setCursor(self, v):
if self.stepLengthEnable:
c = CursorAccess.getCursor()
if (Vector(c) - Vector(v)).length > 0:
if self.stepLengthMode == "Absolute":
v = Vector(v) - Vector(c)
v.normalize()
v = v * self.stepLengthValue + Vector(c)
if self.stepLengthMode == "Proportional":
v = (Vector(v) - Vector(c)) * self.stepLengthValue + Vector(c)
CursorAccess.setCursor(Vector(v))
def polygon_normal_angle_P(verts, poly, P):
''' The angle between the polygon normal and the vector from polygon center to given point '''
N = polygon_normal(verts, poly)
C = polygon_center(verts, poly)
V = [P[0] - C[0], P[1] - C[1], P[2] - C[2]]
v1 = Vector(N)
v2 = Vector(V)
v1.normalize()
v2.normalize()
angle = acos(v1.dot(v2)) # the angle in radians
return angle
def nextpoint(poi,powers):
verts_ = [poi-pow for pow in powers]
vect = Vector()
for i in verts_:
vect+=i*(1/i.length**2)
vect.normalize()
# additional power:
#cos(x)
#sin
#3*exp(-(x**2+3**2)**2)
vertnext = poi + vect*(1/lent)
return vertnext
def react(self, position, direction, population):
res = Vector((0, 0, 0))
for individue in population:
diff = individue.position - position
diff = -diff
if True :
print(" agora ")
diff.normalize()
res += diff
res.normalize()
res = res * 5
return res
def _createBone(self, bone, armature):
name = bone.name()
print(" Creation of the bone '%s'..." % name)
bl_bone = armature.edit_bones.new(name)
bl_bone.head = bone.pivot_point.to_tuple()
if bone.usedChildrenCount() == 1:
bl_bone.tail = bone.children[0].pivot_point.to_tuple()
elif bone.usedChildrenCount() > 1:
done = False
if self.smart_bone_parenting:
max_depth = 0
max_depth_bones = []
for child in bone.usedChildren():
depth = child.depth(self.only_used_bones)
if depth > max_depth:
max_depth = depth
max_depth_bones = [child]
elif depth == max_depth:
max_depth_bones.append(child)
print("%s - %d - %d" % (bone.name(), max_depth, len(max_depth_bones)))
if len(max_depth_bones) == 1:
bl_bone.tail = max_depth_bones[0].pivot_point.to_tuple()
done = True
if not(done):
v = Vector( (0, 0, 0) )
for child in bone.usedChildren():
v += child.pivot_point
bl_bone.tail = (v / bone.usedChildrenCount()).to_tuple()
elif bone.parent is not None:
if bone.parent.bl_bone is None:
self._createBone(bone.parent, armature)
v = (bone.pivot_point - bone.parent.pivot_point)
if v.length >= 0.001:
v.normalize()
bl_bone.tail = (bone.parent.bl_bone.length * v + bone.pivot_point).to_tuple()
else:
bl_bone.tail = (bone.parent.bl_bone.length * bone.pivot_point.normalized() + bone.pivot_point).to_tuple()
else:
bl_bone.tail = (bone.pivot_point * 2).to_tuple()
if bone.parent is not None:
bl_bone.parent = bone.parent.bl_bone
bl_bone.use_connect = (bone.parent.usedChildrenCount() == 1)
bone.bl_bone = bl_bone
def spherize(context):
print ("in spherize")
#influence
influence = context.scene['unt_spherifyratio']
#gets the location of the center of the center object
if context.scene.centerobject:
center = bpy.data.objects[context.scene.centerobject].location
else:
center = bpy.context.scene.cursor_location
#get world matrix for the object
worldmatrix = bpy.context.object.matrix_world
ob = bpy.context.object
obdata = ob.data
#mandatory stupid step, calculate normals split, in object mode
bpy.ops.object.mode_set(mode="OBJECT")
obdata.calc_normals_split()
#prepare a list for all the normals. One per "loop"(vertice-per-faace)
normals = [Vector()]*len(obdata.loops)
#loop all the loops (subvertices) in the mesh
for loop in obdata.loops:
#obdata.calc_normals_split()
vertexindex = loop.vertex_index
normals[loop.index] = loop.normal
print ("normal: %s"% normals[loop.index])
#if the vertex is selected, normalize the normal
if obdata.vertices[vertexindex].select:
#get local coordinate of the related vertex
localco = obdata.vertices[vertexindex].co
#calculate the globla coordinates of the vertex
globalco = worldmatrix * obdata.vertices[vertexindex].co
#delta betwen the global location of the vertex and the center of the center object
v= Vector([y-x for x,y in zip(globalco,center)])
v.negate()
v.normalize()
#resulting vector (v*influence + normal*(1-influence))
normals[loop.index] = v * float(influence) + normals[loop.index] * (float(1)-float(influence))
#normals[loop.index].negate()
normals[loop.index].normalize()
print ("new normal: %s"% normals[loop.index])
obdata.normals_split_custom_set(normals)
bpy.ops.object.mode_set(mode="EDIT")
def add_pole(end,ray,length,r,backup):
vray = Vector(ray)
vray.normalize()
vend = Vector(end)
center = vend - vray*(length/2+r+backup)
ang = Vector((0,0,1)).rotation_difference(vray).to_euler()
add_cylinder(center,ang,r,length)
cyl_name = get_last_object('Cylinder')
add_sphere(vend-(r+backup)*vray,r)
sph_name = get_last_object('Sphere')
bpy.ops.object.select_pattern(pattern=cyl_name,extend=False)
bpy.ops.object.select_pattern(pattern=sph_name,extend=True)
bpy.ops.object.join()
return sph_name
def averageNormal(self):
weight_norx = 0.
weight_nory = 0.
weight_norz = 0.
aver_normal = None
for poly in self.select_poly:
weight_norx = weight_norx + (poly.normal.x * poly.area)
weight_nory = weight_nory + (poly.normal.y * poly.area)
weight_norz = weight_norz + (poly.normal.z * poly.area)
aver_normal = Vector((weight_norx, weight_nory, weight_norz))
aver_normal.normalize()
return aver_normal
def calc_average_fnorm(self):
self.e_fn_pairs = e_fn_pairs = dict()
# edge:average_face_normal pairs.
e_lp_pairs = self.e_lp_pairs
for e in self.offset_edges:
loops = e_lp_pairs[e]
if loops:
normal = Vector()
for lp in loops:
normal += lp.face.normal
normal.normalize()
e_fn_pairs[e] = normal
else:
e_fn_pairs[e] = None
def adhesion(loc, bvhtree, max_l):
# Compute the adhesion vector by finding the nearest point
nearest_location, *_ = bvhtree.find_nearest(loc, max_l)
adhesion_vector = Vector((0.0, 0.0, 0.0))
if nearest_location is not None:
# Compute the distance to the nearest point
adhesion_vector = nearest_location - loc
distance = adhesion_vector.length
# If it's less than the maximum allowed and not 0, continue
if distance:
# Compute the direction vector between the closest point and loc
adhesion_vector.normalize()
adhesion_vector *= 1.0 - distance / max_l
# adhesion_vector *= getFaceWeight(ob.data, nearest_result[3])
return adhesion_vector
def execute(self, context):
obj_curr = context.active_object
obj_curr.update_from_editmode()
mesh = obj_curr.data
bm = bmesh.from_edit_mesh(mesh)
vertex_normal_weight_layer = bm.verts.layers.int['vertex-normal-weight']
vertex_normal_x_layer = bm.verts.layers.float['vertex-normal-x']
vertex_normal_y_layer = bm.verts.layers.float['vertex-normal-y']
vertex_normal_z_layer = bm.verts.layers.float['vertex-normal-z']
# Determine enumerated vertex normal weight value.
vertex_normal_weight = self.vertex_normal_weight_map[self.type]
# Select vertices by given vertex normal weight.
if self.action == 'GET':
context.tool_settings.mesh_select_mode = (True, False, False)
for v in bm.verts:
if v[vertex_normal_weight_layer] == vertex_normal_weight:
v.select = True
else:
v.select = False
bm.select_mode = {'VERT'}
bm.select_flush_mode()
# Assign given vertex normal weight to selected vertices.
elif self.action == 'SET':
selected_verts = [v for v in bm.verts if v.select]
for v in selected_verts:
v[vertex_normal_weight_layer] = vertex_normal_weight
# Set unweighted vertex normal component values.
if self.type == 'UNWEIGHTED':
mesh.calc_normals_split()
for v in selected_verts:
n = Vector()
for loop in v.link_loops:
n += mesh.loops[loop.index].normal
n.normalize()
v[vertex_normal_x_layer] = n.x
v[vertex_normal_y_layer] = n.y
v[vertex_normal_z_layer] = n.z
# Update the mesh.
bmesh.update_edit_mesh(mesh)
if self.action == 'SET' and self.update:
bpy.ops.mesh.yavne_update_vertex_normals()
return {'FINISHED'}
def repeal_particles(self, iterations=20, factor=0.01):
particles = list(self.particles)
tree = KDTree(len(particles))
for index, particle in enumerate(particles):
tree.insert(particle.co, index)
tree.balance()
for i in range(iterations):
new_tree = KDTree(len(self.particles))
for index, particle in enumerate(particles):
if particle.tag in {"SHARP", "GREASE"}:
continue
d = Vector()
for loc, other_index, dist in tree.find_n(particle.co, 3):
if dist == 0:
continue
other = particles[other_index]
vec = particle.co - other.co
d += (vec / (dist ** 3))
if not self.triangle_mode:
u = particle.dir
v = u.cross(particle.normal)
for vec in (u + v, u - v, -u + v, -u - v):
vec *= particle.radius
vec += other.co
vec -= particle.co
dist = vec.length
d -= vec * 0.3 / (dist ** 3)
d.normalize()
location, normal, dir, s, c = self.field.sample_point(particle.co + (d * factor * particle.radius))
if location:
particle.co = location
particle.normal = normal
self.grid.update(particle)
particle.dir = dir
new_tree.insert(particle.co, index)
new_tree.balance()
tree = new_tree
yield i
def conformHeight(tree):
# retrieve float from UI
threshold = bpy.data.scenes['Scene'].my_tool.conform_threshold
tree_p = tree.getroot()
#READ XML
for venue in tree_p:
for Sector in venue.findall('Sector'):
for Seat in Sector:
# Get Position Data
posX, posY, posZ = float(Seat.get('px')), float(Seat.get('py')), float(Seat.get('pz'))
rotY = radians(float(Seat.get('ry')))
vec = mathutils.Vector((-posX,-posZ,posY))
# vec.rotate(Matrix.Rotation(radians(180), 3, 'Z'))
obj = bpy.context.object
vecDir = mathutils.Vector((math.sin(rotY), math.cos(rotY), 0))
origin = vec + (vecDir*(threshold))
direction = Vector((0, 0, 1))
direction.normalize()
def ray_cast():
sol = obj.ray_cast(origin + direction * 1000.0, -direction)
location = sol[1]
return location
ray_cast()
loc = ray_cast()
new_height = (loc[2])
new_height_f = '{:.3f}'.format(new_height)
Seat.set('py', new_height_f)
def calculate_normal(vertex):
#vertex has link_faces <= 2 and an adjacent inner vertex
if len(vertex.link_faces) <= 2:
for e in vertex.link_edges:
v = e.other_vert(vertex)
if not is_boundary_vertex(v):
return calculate_normal(v)
for f in vertex.link_faces:
for v in f.verts:
if not is_boundary_vertex(v):
return calculate_normal(v)
n = Vector((0,0,0))
for f in vertex.link_faces:
n += f.normal
return n
#vertex has link_faces <= 2 but no adjacent inner vertex
if len(vertex.link_faces) == 1:
return vertex.link_faces[0].normal
if len(vertex.link_faces) == 2:
fn1 = vertex.link_faces[0].normal
fn2 = vertex.link_faces[1].normal
n1 = bisector_plane(fn1, fn2)
e = []
for v in get_adjacent_vertices(vertex):
if is_boundary_vertex(v):
e.append(vertex.co - v.co)
n = intersect_planes(n1, e[0].cross(e[1]))
n.normalize()
return n
#vertex has link_faces >= 3
normals = bisector_planes(vertex)
n1 = normals[0]
for n in normals:
if (n-n1).length > error:
n2 = n
break
n = intersect_planes(n1, n2)
n.normalize()
for face in vertex.link_faces:
if face.normal.dot(n) < 0:
return -n
return n
def center_normal(points):
center = Vector((0, 0, 0))
for i in points:
center += i
center /= len(points)
normals = []
curr_vect = points[0] - center
for point in points[1:]:
new_vect = point - center
normals.append(new_vect.cross(curr_vect))
curr_vect = new_vect
normal = Vector((0, 0, 0))
normal = (points[0] - center).cross(points[len(points) // 4] - center)
# for i in normals:
# normal += i
normal.normalize()
return center, normal
def recalculateNormals(obj):
""" Recalculates the normals of a |KX_GameObject|, |KX_MeshProxy| or |KX_PolyProxy|.
It iterates through all the given vertex, it may be a slow operation, use with caution. """
if type(obj) is types.KX_GameObject:
mesh = obj.meshes[0]
elif type(obj) is types.KX_MeshProxy: mesh = obj
elif type(obj) is types.KX_PolyProxy: mesh = obj.getMesh()
else: raise ValueError("Argument must be KX_GameObject, KX_MeshPoxy or KX_PolyProxy, not " + str(type(obj)))
verdict = {} #Vertex Dictionary LOL
#Iterate throught Faces and make a list with all the vertex and the normals of the faces the are part of.
if type(obj) is not types.KX_PolyProxy:
for i in range(mesh.numPolygons):
poly = mesh.getPolygon(i)
normal = getPolyNormal(poly)
for j in range(poly.getNumVertex()):
try:
verdict[poly.getVertexIndex(j)].append(normal)
except KeyError:
verdict[poly.getVertexIndex(j)] = [normal]
else:
poly = obj
normal = getPolyNormal(poly)
for j in range(poly.getNumVertex()):
try:
verdict[poly.getVertexIndex(j)].append(normal)
except KeyError:
verdict[poly.getVertexIndex(j)] = [normal]
#Iterate throught the list recalculating the normal of each vertex.
for i, normals in verdict.items():
normal = Vector([0,0,0])
for n in normals:
normal += n
s = len(normals)
if s == 0: continue
normal.x /= s
normal.y /= s
normal.z /= s
normal.normalize()
mesh.getVertex(0, i).setNormal(normals[0].to_tuple())
def recalculateNormals(obj):
""" Recalculates the normals of a |KX_GameObject|, |KX_MeshProxy| or |KX_PolyProxy|.
It iterates through all the given vertex, it may be a slow operation, use with caution. """
if type(obj) is types.KX_GameObject:
mesh = obj.meshes[0]
elif type(obj) is types.KX_MeshProxy: mesh = obj
elif type(obj) is types.KX_PolyProxy: mesh = obj.getMesh()
else: raise ValueError("Argument must be KX_GameObject, KX_MeshPoxy or KX_PolyProxy, not " + str(type(obj)))
verdict = {} #Vertex Dictionary LOL
#Iterate throught Faces and make a list with all the vertex and the normals of the faces the are part of.
if type(obj) is not types.KX_PolyProxy:
for i in range(mesh.numPolygons):
poly = mesh.getPolygon(i)
normal = getPolyNormal(poly)
for j in range(poly.getNumVertex()):
try:
verdict[poly.getVertexIndex(j)].append(normal)
except KeyError:
verdict[poly.getVertexIndex(j)] = [normal]
else:
poly = obj
normal = getPolyNormal(poly)
for j in range(poly.getNumVertex()):
try:
verdict[poly.getVertexIndex(j)].append(normal)
except KeyError:
verdict[poly.getVertexIndex(j)] = [normal]
#Iterate throught the list recalculating the normal of each vertex.
for i, normals in verdict.items():
normal = Vector([0,0,0])
for n in normals:
normal += n
s = len(normals)
if s == 0: continue
normal.x /= s
normal.y /= s
normal.z /= s
normal.normalize()
mesh.getVertex(0, i).setNormal(normals[0].to_tuple())
def color_to_normals(mesh, src_vcol):
# ensure the mesh has empty split normals
if not mesh.has_custom_normals:
mesh.create_normals_split()
mesh.use_auto_smooth = True
# create a structure that matches the required input of the normals_split_custom_set function
clnors = [Vector()] * len(mesh.loops)
for loop_index, loop in enumerate(mesh.loops):
c = src_vcol.data[loop_index].color
# remap color to normal range
n = Vector([remap(channel, 0.0, 1.0, -1.0, 1.0) for channel in c[0:3]])
n.normalize()
clnors[loop_index] = n
mesh.normals_split_custom_set(clnors)
mesh.update()
def match(self):
owner = self.owner
p1 = Vector((owner.worldPosition.x, owner.worldPosition.y))
matching = Vector((0,0))
close = 0
for sheep in owner.flock:
p2 = Vector((sheep.worldPosition.x, sheep.worldPosition.y))
dist = (p1 - p2).magnitude
if dist < self.r2:
sheepFace = sheep.orientation[:][1]
sheepFace = Vector((sheepFace.x,sheepFace.y))
matching += sheepFace
close += 1
matching /= close
matching.normalize()
self.direction += 4 * matching
def save(self, ctx, filename):
start_time = process_time()
self._file = BH3File()
self._model = ctx.scene.objects.active
# self._mesh = object_.data
self._mesh = self._model.to_mesh(ctx.scene, True, 'PREVIEW', True)
self._mesh.calc_normals_split()
uv_layer = self._mesh.uv_layers.active
self._uv_loops = uv_layer.data if uv_layer is not None else None
for v in self._mesh.vertices:
average_normal = Vector()
for loop in self._mesh.loops:
if loop.vertex_index == v.index:
average_normal += loop.normal
average_normal.normalize()
self._normals.append(average_normal)
skin_mod = None
for modifier in self._model.modifiers:
if type(modifier) is bpy.types.ArmatureModifier:
skin_mod = modifier
break
skin = skin_mod.object
ctx.scene.objects.active = skin
bpy.ops.object.mode_set(mode='EDIT')
armature = skin.data
self._file.root_bone = self._create_bh3_bones(armature.edit_bones[0])
for face in self._mesh.polygons:
self._file.faces.append(
[face.vertices[0], face.vertices[1], face.vertices[2]])
bpy.ops.object.mode_set(mode='OBJECT')
ctx.scene.objects.active = self._model
bpy.data.meshes.remove(self._mesh)
self._file.write(filename)
print("BH3 export took {:f} seconds".format(process_time() -
start_time))
return {'FINISHED'}
def save(self, ctx, filename):
start_time = process_time()
self._file = BH3File()
self._model = ctx.scene.objects.active
# self._mesh = object_.data
self._mesh = self._model.to_mesh(ctx.scene, True, 'PREVIEW', True)
self._mesh.calc_normals_split()
uv_layer = self._mesh.uv_layers.active
self._uv_loops = uv_layer.data if uv_layer is not None else None
for v in self._mesh.vertices:
average_normal = Vector()
for loop in self._mesh.loops:
if loop.vertex_index == v.index:
average_normal += loop.normal
average_normal.normalize()
self._normals.append(average_normal)
skin_mod = None
for modifier in self._model.modifiers:
if type(modifier) is bpy.types.ArmatureModifier:
skin_mod = modifier
break
skin = skin_mod.object
ctx.scene.objects.active = skin
bpy.ops.object.mode_set(mode='EDIT')
armature = skin.data
self._file.root_bone = self._create_bh3_bones(armature.edit_bones[0])
for face in self._mesh.polygons:
self._file.faces.append([face.vertices[0],
face.vertices[1],
face.vertices[2]])
bpy.ops.object.mode_set(mode='OBJECT')
ctx.scene.objects.active = self._model
bpy.data.meshes.remove(self._mesh)
self._file.write(filename)
print("BH3 export took {:f} seconds".format(process_time() - start_time))
return {'FINISHED'}
def _cam2world_matrix_from_cam_extrinsics(self, config):
""" Determines camera extrinsics by using the given config and returns them in form of a cam to world frame transformation matrix.
:param config: The configuration object.
:return: The cam to world transformation matrix.
"""
if not config.has_param("cam2world_matrix"):
position = Utility.transform_point_to_blender_coord_frame(
config.get_vector3d("location", [0, 0, 0]), self.source_frame)
# Rotation
rotation_format = config.get_string("rotation/format", "euler")
value = config.get_vector3d("rotation/value", [0, 0, 0])
if rotation_format == "euler":
# Rotation, specified as euler angles
rotation_euler = Utility.transform_point_to_blender_coord_frame(
value, self.source_frame)
elif rotation_format == "forward_vec":
# Rotation, specified as forward vector
forward_vec = Vector(
Utility.transform_point_to_blender_coord_frame(
value, self.source_frame))
# Convert forward vector to euler angle (Assume Up = Z)
rotation_euler = forward_vec.to_track_quat('-Z',
'Y').to_euler()
elif rotation_format == "look_at":
# Compute forward vector
forward_vec = value - position
forward_vec.normalize()
# Convert forward vector to euler angle (Assume Up = Z)
rotation_euler = forward_vec.to_track_quat('-Z',
'Y').to_euler()
else:
raise Exception("No such rotation format:" +
str(rotation_format))
cam2world_matrix = Matrix.Translation(Vector(position)) @ Euler(
rotation_euler, 'XYZ').to_matrix().to_4x4()
else:
cam2world_matrix = Matrix(
np.array(config.get_list("cam2world_matrix")).reshape(
4, 4).astype(np.float32))
return cam2world_matrix
def adhesion(loc, ob, max_l):
# Get transfor vector and transformed loc
tran_mat = ob.matrix_world.inverted()
tran_loc = tran_mat * loc
# Compute the adhesion vector by finding the nearest point
nearest_result = ob.closest_point_on_mesh(tran_loc, max_l)
adhesion_vector = Vector((0.0, 0.0, 0.0))
if nearest_result[2] != -1:
# Compute the distance to the nearest point
adhesion_vector = ob.matrix_world * nearest_result[0] - loc
distance = adhesion_vector.length
# If it's less than the maximum allowed and not 0, continue
if distance:
# Compute the direction vector between the closest point and loc
adhesion_vector.normalize()
adhesion_vector *= 1.0 - distance / max_l
#adhesion_vector *= getFaceWeight(ob.data, nearest_result[2])
return adhesion_vector
def align_along():
act_name = utils.get_active_bone().name
selected = [
x.name for x in utils.get_selected_bones() if x.name != act_name
]
amt = bpy.context.object
utils.mode_e()
act = amt.data.edit_bones[act_name]
p = Vector(act.head)
vec_act = Vector(act.tail) - p
vec_act.normalize()
for b in selected:
bone = amt.data.edit_bones[b]
a = Vector(bone.head)
tail = Vector(bone.tail - bone.head)
bone.head = p + vec_act * (a - p).dot(vec_act)
bone.tail = bone.head + tail
def update_auto_bone_roll(cls, edit_bone):
# make a triangle face (p1,p2,p3)
p1 = edit_bone.head.copy()
p2 = edit_bone.tail.copy()
p3 = p2.copy()
# translate p3 in xz plane
# the normal vector of the face tracks -Y direction
xz = Vector((p2.x - p1.x, p2.z - p1.z))
xz.normalize()
theta = math.atan2(xz.y, xz.x)
norm = edit_bone.vector.length
p3.z += norm * math.cos(theta)
p3.x -= norm * math.sin(theta)
# calculate the normal vector of the face
y = (p2 - p1).normalized()
z_tmp = (p3 - p1).normalized()
x = y.cross(z_tmp) # normal vector
# z = x.cross(y)
cls.update_bone_roll(edit_bone, y.xzy, x.xzy)
def adhesion(loc, ob, max_l):
# Get transfor vector and transformed loc
tran_mat = ob.matrix_world.inverted()
tran_loc = tran_mat * loc
# Compute the adhesion vector by finding the nearest point
nearest_result = ob.closest_point_on_mesh(tran_loc, max_l)
adhesion_vector = Vector((0.0, 0.0, 0.0))
if nearest_result[2] != -1:
# Compute the distance to the nearest point
adhesion_vector = ob.matrix_world * nearest_result[0] - loc
distance = adhesion_vector.length
# If it's less than the maximum allowed and not 0, continue
if distance:
# Compute the direction vector between the closest point and loc
adhesion_vector.normalize()
adhesion_vector *= 1.0 - distance / max_l
#adhesion_vector *= getFaceWeight(ob.data, nearest_result[2])
return adhesion_vector
def AdjustRoll_axisplane(bone, nor):
props = bpy.context.scene.cyarigtools_props
mat = bone.matrix
z = Vector((mat[0][2], mat[1][2], mat[2][2]))
z.normalize()
#Xvectorを回転の正負判定に使う
#Ｘ軸と法線の内積が正なら＋、負ならー
x = Vector((mat[0][0], mat[1][0], mat[2][0]))
sign = x.dot(nor) / math.fabs(x.dot(nor))
cos_sita = z.dot(nor)
sita = math.acos(cos_sita)
if props.axis_plane == 'Z':
bone.roll = sita * sign
elif props.axis_plane == 'X':
bone.roll = sita * sign + math.pi / 2
def getLabelPoint(self, edge_index, label_indent):
edge = self.getEdgeByIndex(edge_index)
start = Vector(edge[0])
end = Vector(edge[1])
center = Vector(((start.x + end.x) / 2, (start.y + end.y) / 2))
v = start - center
v90 = Vector((-v.y, v.x))
v90.normalize()
labelPoint0 = center + v90 * label_indent
labelPoint1 = center - v90 * label_indent
if self.isPointInside(labelPoint0):
return Vector((labelPoint0[0], labelPoint0[1], 0))
elif self.isPointInside(labelPoint1):
return Vector((labelPoint1[0], labelPoint1[1], 0))
else:
raise Exception("Can't find label point!")
def _cam2world_matrix_from_cam_extrinsics_look_at(self, location, look_at):
""" Determines camera extrinsics by using the location and the look_at vector.
:param look_at: The look_at vector.
:return: The cam to world transformation matrix.
"""
position = Vector(
Utility.transform_point_to_blender_coord_frame(
location, self.source_frame))
forward_vec = Vector(look_at) - position
forward_vec.normalize()
# Convert forward vector to euler angle (Assume Up = Z)
rotation_euler = forward_vec.to_track_quat('-Z', 'Y').to_euler()
cam2world_matrix = Matrix.Translation(position) @ Euler(
rotation_euler, 'XYZ').to_matrix().to_4x4()
return cam2world_matrix
def avoid(self):
owner = self.owner
avoidance = Vector((0,0))
for sheep in owner.flock:
p1 = Vector((owner.worldPosition.x,owner.worldPosition.y))
p2 = Vector((sheep.worldPosition.x,sheep.worldPosition.y))
dist = (p1 - p2).magnitude
theta = atan2(p1.y - p2.y,p1.x - p2.x)
if .001 < dist < self.r1:
size = 1/dist**2
avoidance.x += size*cos(theta)
avoidance.y += size*sin(theta)
env = Environment.getInstance()
avoidance += env.staticAvoidanceVector(owner.worldPosition)
try:
ramAvoidance = owner.avoidanceVector('ram')
ramDist = owner.distance('ram')
if 0 < ramDist < 1.5*self.r1:
ramAvoidance *= 1.5/ramDist**2
avoidance += ramAvoidance
except:
pass
tractorDist = owner.distance('tractor')
if 0 < tractorDist < 3*self.r1:
avoidance += owner.avoidanceVector('tractor')*(5/tractorDist**2)
if avoidance.magnitude > 0.05:
owner.run()
self.direction += avoidance*10
return
if avoidance.magnitude > 0.04:
owner.flounder()
else:
owner.walk()
avoidance.normalize()
self.direction += avoidance*10
def align_direction():
selected = [x.name for x in utils.get_selected_bones()]
act_name = utils.get_active_bone().name
amt = bpy.context.object
utils.mode_e()
act = amt.data.edit_bones[act_name]
matrix = Matrix(act.matrix)
if len(selected) > 0:
for bonename in selected:
tgt = amt.data.edit_bones[bonename]
head = Vector(tgt.head)
tgt.matrix = matrix
l = tgt.length
vec = Vector(act.tail) - Vector(act.head)
vec.normalize()
tgt.head = head
tgt.tail = Vector(tgt.head) + vec * l
def averageNormal(self, obj, is_global):
weight_norx = 0.
weight_nory = 0.
weight_norz = 0.
aver_normal = None
bm = self.getBMesh(obj.data)
select_face = self.getSelectedFaces(bm)
for face in select_face:
weight_norx += face.normal.x * face.calc_area()
weight_nory += face.normal.y * face.calc_area()
weight_norz += face.normal.z * face.calc_area()
aver_normal = Vector((weight_norx, weight_nory, weight_norz))
aver_normal.normalize()
if is_global == True:
eul_obj_rot = obj.rotation_euler
aver_normal.rotate(eul_obj_rot)
return aver_normal
def parse_spotfx(fw, obj, EXPORT_GLOBAL_MATRIX):
from mathutils import Vector
rotation = obj.rotation_euler.to_matrix()
direction = Vector(EXPORT_GLOBAL_MATRIX * Vector(rotation * Vector(
(0.0, 1.0, 0.0))))
direction.normalize()
upVector = Vector(EXPORT_GLOBAL_MATRIX * Vector(rotation * Vector(
(0.0, 0.0, 1.0))))
upVector.normalize()
fw('spotFx\n')
fw('{\n')
fw(' name \"%s\"\n' % obj.name)
fw(' group \"%s\"\n' % obj.levelGroup)
fw(' origin %f %f %f\n' %
Vector(EXPORT_GLOBAL_MATRIX * Vector(obj.location))[:])
fw(' direction %f %f %f\n' % direction[:])
fw(' upVector %f %f %f\n' % upVector[:])
fw(' genType %i\n' % get_enum_type(
bpy.types.GeneratePropertyGroup.genType, obj.fxGen.genType))
fw(' genDelay %f\n' % obj.fxGen.genDelay)
fw(' red %f\n' % obj.fxColor[0])
fw(' green %f\n' % obj.fxColor[1])
fw(' blue %f\n' % obj.fxColor[2])
fw(' activeDelay %f\n' % obj.fxActiveDelay)
fw(' inactiveDelay %f\n' % obj.fxInactiveDelay)
fw(' primaryID %i\n' %
get_enum_type(bpy.types.Object.fxPrimaryID, obj.fxPrimaryID))
fw(' secondaryID %i\n' %
get_enum_type(bpy.types.Object.fxSecondaryID, obj.fxSecondaryID))
fw(' SFX \"%s\"\n' % obj.fxSFX)
fw(' volume %f\n' % obj.fxVolume)
fw(' speed %f\n' % obj.fxSpeed)
fw(' type %i\n' % get_enum_type(bpy.types.Object.fxType, obj.fxType))
fw(' sfxType %i\n' %
get_enum_type(bpy.types.Object.sfxType, obj.sfxType))
fw('}\n\n')
def visualizeCovariance(kf_x, P):
# Visualize CoVariance Matrix P:
# Source: https://geus.wordpress.com/2011/09/15/how-to-represent-a-3d-normal-function-with-ros-rviz/
# get Eigenvalues and Eigenvectors of P:
(eigValues, eigVectors) = np.linalg.eig(
P) # Possible Bug: Required to reduce to 3x3 Matrix
eigx = Vector([eigVectors[0, 0], eigVectors[0, 2], eigVectors[0, 4]])
eigy = Vector([eigVectors[2, 0], eigVectors[2, 2], eigVectors[2, 4]])
eigz = Vector([eigVectors[4, 0], eigVectors[4, 2], eigVectors[4, 4]])
eigx.normalize()
eigy.normalize()
eigz.normalize()
# build rotation matrix:
rot = Matrix([eigx, eigy, eigz])
rot.transpose()
# retrieve Quaternion
quat = rot.to_quaternion()
# update sphere object:
covObject.location.x = kf_x[0]
covObject.location.y = kf_x[2]
covObject.location.z = kf_x[4]
covObject.rotation_quaternion = quat
covObject.scale.x = eigValues[0] * 100
covObject.scale.y = eigValues[2] * 100
covObject.scale.z = eigValues[4] * 100
covObject.keyframe_insert(data_path="location")
covObject.keyframe_insert(data_path="rotation_quaternion")
covObject.keyframe_insert(data_path="scale")
def compact_vertices(self, unique_indices, split_normals):
for new_idx, old_idx in enumerate(unique_indices):
normal = Vector()
for n in split_normals[new_idx]:
for i in range(3):
normal[i] += n[i]
normal.normalize()
self.verts[new_idx] = self.verts[old_idx]
self.normals[new_idx] = tuple(normal[:3])
if self.uv1:
self.uv1[new_idx] = self.uv1[old_idx]
if self.uv2:
self.uv2[new_idx] = self.uv2[old_idx]
num_unique = len(unique_indices)
self.verts = self.verts[:num_unique]
self.normals = self.normals[:num_unique]
if self.uv1:
self.uv1 = self.uv1[:num_unique]
if self.uv2:
self.uv2 = self.uv2[:num_unique]
def get_current_grid_vectors(scene, with_rotation=True):
"""Returns the current grid X/Y/Z vectors from scene data
:param scene: scene data
:param with_rotation: bool, rotate the grid vectors by sprytile_data
:return: up_vector, right_vector, normal_vector
"""
data_normal = scene.sprytile_data.paint_normal_vector
data_up_vector = scene.sprytile_data.paint_up_vector
normal_vector = Vector((data_normal[0], data_normal[1], data_normal[2]))
up_vector = Vector((data_up_vector[0], data_up_vector[1], data_up_vector[2]))
normal_vector.normalize()
up_vector.normalize()
right_vector = up_vector.cross(normal_vector)
if with_rotation:
rotation = Quaternion(-normal_vector, scene.sprytile_data.mesh_rotate)
up_vector = rotation * up_vector
right_vector = rotation * right_vector
return up_vector, right_vector, normal_vector
def parse_camera(fw, obj, EXPORT_GLOBAL_MATRIX):
from mathutils import Vector
rotation = obj.rotation_euler.to_matrix()
direction = Vector(EXPORT_GLOBAL_MATRIX * Vector(rotation * Vector(
(0.0, 1.0, 0.0))))
direction.normalize()
upVector = Vector(EXPORT_GLOBAL_MATRIX * Vector(rotation * Vector(
(0.0, 0.0, 1.0))))
upVector.normalize()
fw('camera\n')
fw('{\n')
fw(' name \"%s\"\n' % obj.name)
fw(' group \"%s\"\n' % obj.levelGroup)
fw(' origin %f %f %f\n' %
Vector(EXPORT_GLOBAL_MATRIX * Vector(obj.location))[:])
fw(' direction %f %f %f\n' % direction[:])
fw(' upVector %f %f %f\n' % upVector[:])
fw('}\n\n')
def rotation_to(a, b):
"""Calculates shortest Quaternion from Vector a to Vector b"""
# a - up vector
# b - direction to point to
# http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another
# https://github.com/toji/gl-matrix/blob/f0583ef53e94bc7e78b78c8a24f09ed5e2f7a20c/src/gl-matrix/quat.js#L54
a = a.normalized()
b = b.normalized()
q = Quaternion()
tmpvec3 = Vector()
xUnitVec3 = Vector((1, 0, 0))
yUnitVec3 = Vector((0, 1, 0))
dot = a.dot(b)
if (dot < -0.999999):
# tmpvec3 = cross(xUnitVec3, a)
tmpvec3 = xUnitVec3.cross(a)
if (tmpvec3.length < 0.000001):
tmpvec3 = yUnitVec3.cross(a)
tmpvec3.normalize()
# q = Quaternion(tmpvec3, Math.PI)
q = Quaternion(tmpvec3, math.pi)
elif (dot > 0.999999):
q.x = 0
q.y = 0
q.z = 0
q.w = 1
else:
tmpvec3 = a.cross(b)
q.x = tmpvec3[0]
q.y = tmpvec3[1]
q.z = tmpvec3[2]
q.w = 1 + dot
q.normalize()
return q
def pipe_geometry(A, B, n, r0, r1, closed=False, phi=0):
points, faces = [], []
A, B = Vector(A), Vector(B)
# Setup of vectors
N = B - A
N.normalize()
F = N.cross((0, 0, 1))
if (F.length == 0):
F, E = Vector((1, 0, 0)), Vector((0, 1, 0))
else:
F.normalize()
E = N.cross(F)
E.normalize()
if (closed):
points.append(A)
points.append(B)
for i in range(n):
t = float(i) / float(n)
p0 = A + r0 * (F * cos(TAU * t + phi) + E * sin(TAU * t + phi))
p1 = B + r1 * (F * cos(TAU * t + phi) + E * sin(TAU * t + phi))
points.append(p0)
points.append(p1)
if (closed):
idx0, idx1 = 2 * i + 2, 2 * i + 3
iNext0, iNext1 = (idx0 % (2 * n)) + 2, (idx1 % (2 * n)) + 2
faces.append((idx0, 0, iNext0))
faces.append((1, idx1, iNext1))
faces.append((idx1, idx0, iNext0, iNext1))
else:
idx0, idx1 = 2 * i, 2 * i + 1
iNext0, iNext1 = (idx0 + 2) % (2 * n), (idx1 + 2) % (2 * n)
faces.append((idx1, idx0, iNext0, iNext1))
return points, faces
def generate(self):
""" Generate the rig.
Do NOT modify any of the original bones, except for adding constraints.
The main armature should be selected and active before this is called.
"""
ctrl_bones = self.fk_limb.generate()
thigh = ctrl_bones[0]
shin = ctrl_bones[1]
foot = ctrl_bones[2]
foot_mch = ctrl_bones[3]
# Position foot control
bpy.ops.object.mode_set(mode='EDIT')
eb = self.obj.data.edit_bones
foot_e = eb[foot]
vec = Vector(eb[self.org_bones[3]].vector)
vec.normalize()
foot_e.tail = foot_e.head + (vec * foot_e.length)
foot_e.roll = eb[self.org_bones[3]].roll
bpy.ops.object.mode_set(mode='OBJECT')
# Create foot widget
ob = create_widget(self.obj, foot)
if ob is not None:
verts = [(0.7, 1.5, 0.0), (0.7, -0.25, 0.0), (-0.7, -0.25, 0.0),
(-0.7, 1.5, 0.0), (0.7, 0.723, 0.0), (-0.7, 0.723, 0.0),
(0.7, 0.0, 0.0), (-0.7, 0.0, 0.0)]
edges = [(1, 2), (0, 3), (0, 4), (3, 5), (4, 6), (1, 6), (5, 7),
(2, 7)]
mesh = ob.data
mesh.from_pydata(verts, edges, [])
mesh.update()
mod = ob.modifiers.new("subsurf", 'SUBSURF')
mod.levels = 2
return [thigh, shin, foot, foot_mch]
def write_camera(self, camera, name="Active Camera"):
pos, target, up = camera.GetOrientation()
bpy.ops.object.add(type='CAMERA', location=pos)
ob = self.context.object
ob.name = name
z = (Vector(pos) - Vector(target))
x = Vector(up).cross(z)
y = z.cross(x)
x.normalize()
y.normalize()
z.normalize()
ob.matrix_world.col[0] = x.resized(4)
ob.matrix_world.col[1] = y.resized(4)
ob.matrix_world.col[2] = z.resized(4)
cam = ob.data
aspect_ratio = camera.aspect_ratio if camera.aspect_ratio else self.aspect_ratio
cam.angle = (pi * camera.fov / 180) * aspect_ratio
cam.clip_end = self.prefs.camera_far_plane
cam.name = name
def create_controllers(self, amt, main_bone, txt_a, txt_b, size_a, size_b, bx, bz, roll):
main_name = main_bone.name
tail = main_bone.tail
head = main_bone.head
v1 = Vector((head[0] - tail[0], head[1] - tail[1], head[2] - tail[2],))
v1.normalize()
# create controller A
bone_a = amt.edit_bones.new(main_name + txt_a)
bone_a.tail = head
bone_a.head = (head[0] + (v1[0] * size_a), head[1] + (v1[1] * size_a), head[2] + (v1[2] * size_a))
bone_a.bbone_x = bx * 1.15
bone_a.bbone_z = bz * 1.15
bone_a.roll = roll
# create controller B
bone_b = amt.edit_bones.new(main_name + txt_b)
bone_b.head = tail
bone_b.tail = (tail[0] + (v1[0] * -size_b), tail[1] + (v1[1] * -size_b), tail[2] + (v1[2] * -size_b))
bone_b.bbone_x = bx * 1.20
bone_b.bbone_z = bz * 1.20
bone_b.roll = roll
def align_at_flontview():
#props = bpy.context.scene.cyarigtools_props
#selected = [x.name for x in props.allbones ]
amt = bpy.context.object
utils.mode_e()
selected = utils.bone.sort()
bone1 = amt.data.edit_bones[selected[0]]
bone2 = amt.data.edit_bones[selected[-1]]
#法線を割り出す normal.y = 0
#vecのｘ、ｚを入れ替えればよい(どちらかにー符号をつける)
vec0 = Vector(bone1.head) - Vector(bone2.tail)
nor = Vector((vec0.z, 0, -vec0.x))
nor.normalize()
p = Vector(bone1.head)
for b in selected[1:]:
bone = amt.data.edit_bones[b]
a = Vector(bone.head)
pos = a + nor * (p - a).dot(nor)
bone.head = pos
def write_camera(self, camera, name="Active Camera"):
pos, target, up = camera.GetOrientation()
bpy.ops.object.add(type='CAMERA', location=pos)
ob = self.context.object
ob.name = name
z = (Vector(pos) - Vector(target))
x = Vector(up).cross(z)
y = z.cross(x)
x.normalize()
y.normalize()
z.normalize()
ob.matrix_world.col[0] = x.resized(4)
ob.matrix_world.col[1] = y.resized(4)
ob.matrix_world.col[2] = z.resized(4)
cam = ob.data
aspect_ratio = camera.aspect_ratio if camera.aspect_ratio else self.aspect_ratio
cam.angle = (pi * camera.fov / 180 ) * aspect_ratio
cam.clip_end = self.prefs.camera_far_plane
cam.name = name
def add_sun(shader, function, sun_parms, i):
color = [0.0, 0.0, 0.0]
intensity = 1.0
parms = sun_parms.split()
rotation = [0.0, 0.0]
name = shader + "_" + function + "." + str(i)
if function == "sun":
if len(parms) < 6:
print("not enogh sun parameters")
elif function == "q3map_sun":
if len(parms) < 6:
print("not enogh q3map_sun parameters")
elif function == "q3map_sunext":
if len(parms) < 8:
print("not enogh q3map_sunext parameters")
elif function == "q3gl2_sun":
if len(parms) < 9:
print("not enogh q3gl2_sun parameters")
color = Vector((float(parms[0]), float(parms[1]), float(parms[2])))
color.normalize()
intensity = float(parms[3])
rotation = [float(parms[4]), float(parms[5])]
light_vec = [0.0, 0.0, 0.0]
rotation[0] = rotation[0] / 180.0 * math.pi
rotation[1] = rotation[1] / 180.0 * math.pi
light_vec[0] = math.cos(rotation[0]) * math.cos(rotation[1])
light_vec[1] = math.sin(rotation[0]) * math.cos(rotation[1])
light_vec[2] = math.sin(rotation[1])
angle = math.radians(1.5)
QuakeLight.add_light(name, "SUN", intensity, color, light_vec, angle)
return True
def execute(self, context):
obj = context.active_object
mesh = obj.data
mesh.calc_normals_split()
if '__NORMALS__' not in mesh.vertex_colors:
mesh.vertex_colors.new(name="__NORMALS__")
color_map = mesh.vertex_colors['__NORMALS__']
for loop in mesh.loops:
i = loop.index
# Convert Loop normal to a valid colour.
normal = Vector(loop.normal)
normal.normalize()
rgb = (normal + Vector((1.0, 1.0, 1.0))) * 0.5
rgba = rgb.to_4d()
# Set Vertex color to new color
color_map.data[loop.index].color = rgba
return {'FINISHED'}
def __init__(self,
obj1,
obj2,
dir_vec,
mode='ANGLE',
Kp=0,
Ki=0,
Kd=0,
max_torque=None,
angle0=0):
self.obj1 = obj1
self.obj2 = obj2
world_dir_vec = Vector(dir_vec).normalized()
self.local_dir_vec1 = obj1.worldOrientation.inverted() * world_dir_vec
self.local_dir_vec2 = obj2.worldOrientation.inverted() * world_dir_vec
world_ang_vec = world_dir_vec.cross((0, 0, 1))
if world_ang_vec.dot(world_ang_vec) == 0:
world_ang_vec = Vector((1, 0, 0))
else:
world_ang_vec.normalize()
self.local_ang_vec1 = obj1.worldOrientation.inverted() * world_ang_vec
self.local_ang_vec2 = obj2.worldOrientation.inverted() * world_ang_vec
self.mode = mode
self.Kp = Kp
self.Ki = Ki
self.Kd = Kd
self.max_torque = max_torque
self.angle0 = angle0
self.value = 0
self.int_err = 0
self.prev_err = 0
self.prev_time = blenderapi.persistantstorage().time.time
def flatten(self, context, object):
mesh = object.data
bm = bmesh.from_edit_mesh(mesh)
if bpy.context.scene.tool_settings.mesh_select_mode[0]:
bpy.ops.mesh.select_mode(type="FACE")
if bpy.context.scene.tool_settings.mesh_select_mode[1]:
bpy.ops.mesh.select_mode(type="FACE")
if bpy.context.scene.tool_settings.mesh_select_mode[2]:
selected = []
# Get selected faces
for f in bm.faces:
if f.select:
selected.append(f)
# sum all selected normals
sum = Vector((1, 1, 1))
for f in selected:
sum = sum + f.normal
length = len(selected)
sum = (sum.x / length, sum.y / length, sum.z / length)
sum = Vector(sum)
sum.normalize()
print(sum)
for f in selected:
for v in f.verts:
v.normal = sum
# f.normal_update()
# bm.select_flush(True)
bmesh.update_edit_mesh(mesh)
mesh.update()
def matchIkLeg(legIk, toeFk, mBall, mToe, mHeel):
rmat = toeFk.matrix.to_3x3()
tHead = Vector(toeFk.matrix.col[3][:3])
ty = rmat.col[1]
tail = tHead + ty * toeFk.bone.length
zBall = mBall.matrix.col[3][2]
zToe = mToe.matrix.col[3][2]
zHeel = mHeel.matrix.col[3][2]
x = Vector(rmat.col[0])
y = Vector(rmat.col[1])
z = Vector(rmat.col[2])
if zHeel > zBall and zHeel > zToe:
# 1. foot.ik is flat
if abs(y[2]) > abs(z[2]):
y = -z
y[2] = 0
else:
# 2. foot.ik starts at heel
hHead = Vector(mHeel.matrix.col[3][:3])
y = tail - hHead
y.normalize()
x -= x.dot(y)*y
x.normalize()
if abs(x[2]) < 0.7:
x[2] = 0
x.normalize()
z = x.cross(y)
head = tail - y * legIk.bone.length
# Create matrix
gmat = Matrix()
gmat.col[0][:3] = x
gmat.col[1][:3] = y
gmat.col[2][:3] = z
gmat.col[3][:3] = head
pmat = getPoseMatrix(gmat, legIk)
insertLocation(legIk, pmat)
insertRotation(legIk, pmat)
def grow(self):
from numpy import sum, all, ones
self.itt += 1
stp = self.stp
killzone = self.killzone
noise = self.noise
v_xyz,s_xyz = self.get_positions()
dvv,dvs = self.get_distances(v_xyz,s_xyz)
vs_map,sv_map = self.make_maps(dvv,dvs,killzone)
nv,ns = dvs.shape
self.select_seed()
bm = self.get_bmesh()
nodes = [v for v in bm.verts]
for i,jj in vs_map.items():
v = Vector(sum(s_xyz[jj,:]-v_xyz[i,:],axis=0))
v.normalize()
# this is flawed. particularly for "flat" geometries
p,pn = self.closest_point_on_geom(nodes[i].co)
projected = pn.cross(v.cross(pn))
projected += random_unit_vector()*noise
projected.normalize()
new = nodes[i].co + projected*stp
verts = [nodes[i]]
new_vert = bmesh.ops.extrude_vert_indiv(
bm,
verts=verts)['verts'].pop()
new_vert.co = new
## mask out dead sources
mask = ones(ns,'bool')
for j,ii in sv_map.items():
if all(dvs[ii,j]<=killzone):
mask[j] = False
self.num_sources -= 1
print('merging:',len(ii),'deleted source:',j)
new_verts = []
for i in ii:
new = bmesh.ops.extrude_vert_indiv(
bm,
verts=[nodes[i]])['verts'].pop()
new.co = self.sources[j]
new_verts.append(new)
bmesh.ops.remove_doubles(bm,verts=new_verts,dist=0.01)
self.dead_sources.append(self.sources[j])
self.to_mesh()
self.sources = self.sources[mask,:]
return
def scan_advanced(scanner_object, max_distance = 10.0, evd_file=None, add_blender_mesh = False,
add_noisy_blender_mesh = False, tof_res_x = 176, tof_res_y = 144,
lens_angle_w=43.6, lens_angle_h=34.6, flength = 10.0, evd_last_scan=True,
noise_mu=0.0, noise_sigma=0.004, timestamp = 0.0, backfolding=False,
world_transformation=Matrix()):
inv_scan_x = scanner_object.inv_scan_x
inv_scan_y = scanner_object.inv_scan_y
inv_scan_z = scanner_object.inv_scan_z
start_time = time.time()
#10.0mm is currently the distance between the focal point and the sensor
sensor_width = 2 * math.tan(deg2rad(lens_angle_w/2.0)) * 10.0
sensor_height = 2 * math.tan(deg2rad(lens_angle_h/2.0)) * 10.0
if tof_res_x == 0 or tof_res_y == 0:
raise ValueError("Resolution must be > 0")
pixel_width = sensor_width / float(tof_res_x)
pixel_height = sensor_height / float(tof_res_y)
bpy.context.scene.render.resolution_percentage
width = bpy.context.scene.render.resolution_x
height = bpy.context.scene.render.resolution_y
cx = float(tof_res_x) /2.0
cy = float(tof_res_y) /2.0
evd_buffer = []
rays = []
ray_info = []
ray = Vector([0.0,0.0,0.0])
for x in range(tof_res_x):
for y in range(tof_res_y):
"""Calculate a vector that originates at the principal point
and points to the pixel in the sensor. This vector is then
scaled to the maximum scanning distance
"""
physical_x = float(x-cx) * pixel_width
physical_y = float(y-cy) * pixel_height
physical_z = -float(flength)
ray.xyz = [physical_x, physical_y, physical_z]
ray.normalize()
final_ray = max_distance*ray
rays.extend([final_ray[0],final_ray[1],final_ray[2]])
""" pitch and yaw are added for completeness, normally they are
not provided by a ToF Camera but can be derived
from the pixel position and the camera parameters.
"""
yaw = math.atan(physical_x/flength)
pitch = math.atan(physical_y/flength)
ray_info.append([yaw, pitch, timestamp])
returns = blensor.scan_interface.scan_rays(rays, max_distance, inv_scan_x = inv_scan_x, inv_scan_y = inv_scan_y, inv_scan_z = inv_scan_z)
verts = []
verts_noise = []
evd_storage = evd.evd_file(evd_file, tof_res_x, tof_res_y, max_distance)
reusable_vector = Vector([0.0,0.0,0.0,0.0])
for i in range(len(returns)):
idx = returns[i][-1]
distance_noise = random.gauss(noise_mu, noise_sigma)
#If everything works substitute the previous line with this
#distance_noise = pixel_noise[returns[idx][-1]] + random.gauss(noise_mu, noise_sigma)
reusable_vector.xyzw = [returns[i][1],returns[i][2],returns[i][3],1.0]
vt = (world_transformation * reusable_vector).xyz
v = [returns[i][1],returns[i][2],returns[i][3]]
verts.append ( vt )
vector_length = math.sqrt(v[0]**2+v[1]**2+v[2]**2)
norm_vector = [v[0]/vector_length, v[1]/vector_length, v[2]/vector_length]
vector_length_noise = vector_length+distance_noise
if backfolding:
#Distances > max_distance/2..max_distance are mapped to 0..max_distance/2
if vector_length_noise >= max_distance/2.0:
vector_length_noise = vector_length_noise - max_distance/2.0
reusable_vector.xyzw = [norm_vector[0]*vector_length_noise, norm_vector[1]*vector_length_noise, norm_vector[2]*vector_length_noise,1.0]
v_noise = (world_transformation * reusable_vector).xyz
verts_noise.append( v_noise )
evd_storage.addEntry(timestamp = ray_info[idx][2], yaw =(ray_info[idx][0]+math.pi)%(2*math.pi), pitch=ray_info[idx][1], distance=vector_length, distance_noise=vector_length_noise, x=vt[0], y=vt[1], z=vt[2], x_noise=v_noise[0], y_noise=v_noise[1], z_noise=v_noise[2], object_id=returns[i][4], color=returns[i][5], idx=returns[i][-1])
if evd_file:
evd_storage.appendEvdFile()
if add_blender_mesh:
mesh_utils.add_mesh_from_points_tf(verts, "Scan", world_transformation)
if add_noisy_blender_mesh:
mesh_utils.add_mesh_from_points_tf(verts_noise, "NoisyScan", world_transformation)
bpy.context.scene.update()
end_time = time.time()
scan_time = end_time-start_time
print ("Elapsed time: %.3f"%(scan_time))
return True, 0.0, scan_time
