def mark_map_center(volume):
for s in volume.surfaces:
va, ta = s.vertices, s.triangles
from chimerax import surface
varea = surface.vertex_areas(va, ta)
a = varea.sum()
c = varea.dot(va) / a
_mouse_place_marker(volume.session, c)
def principle_axes_box(varray, tarray):
from chimerax import surface
weights = surface.vertex_areas(varray, tarray)
from chimerax.std_commands.measure_inertia import moments_of_inertia
axes, d2e, center = moments_of_inertia([(varray, weights)])
from chimerax.geometry import Place, point_bounds
axes_points = Place(axes=axes).inverse().transform_points(varray)
bounds = point_bounds(axes_points)
return axes, bounds
def surface_inertia(surfs):
vw = []
from chimerax.surface import vertex_areas
for s in surfs:
va, ta = s.vertices, s.triangles
weights = vertex_areas(va, ta)
v = s.scene_position.transform_points(va)
vw.append((v, weights))
return moments_of_inertia(vw)
def connected_center(triangle_pick):
d = triangle_pick.drawing()
t = triangle_pick.triangle_number
va, ta = d.vertices, d.triangles
from chimerax import surface
ti = surface.connected_triangles(ta, t)
tc = ta[ti, :]
varea = surface.vertex_areas(va, tc)
a = varea.sum()
c = varea.dot(va) / a
cscene = d.scene_position * c
vol, holes = surface.enclosed_volume(va, tc)
return cscene, vol
def _report_patch_intensities(patches, va, ta, signal_map, surf_position):
lines = ['# Area average intensities of map %s for %d patches' % (signal_map.name, len(patches)),
'# pnum area intensity']
from chimerax.surface import surface_area, vertex_areas
from chimerax.geometry import inner_product
varea = vertex_areas(va, ta)
for i, (vi,ti) in enumerate(patches):
pva, pta = va[vi], ta[ti]
area = surface_area(va, pta)
vsig = signal_map.interpolated_values(pva, surf_position)
pvarea = varea[vi]
vasig = inner_product(pvarea, vsig)
sig = vasig / pvarea.sum()
lines.append('%d %.6g %.6g' % (i+1, area, sig))
return '\n'.join(lines)
def ellipsoid_shell_size_from_moments(d2):
d2sum = sum(d2)
from math import sqrt
elen = [sqrt(max(0,3*(0.5*d2sum - d2[a]))) for a in range(3)]
varray, narray, tarray = ellipsoid_geometry(center = (0,0,0),
axes = ((1,0,0),(0,1,0),(0,0,1)),
axis_lengths = elen)
from chimerax.surface import vertex_areas
for k in range(10):
weights = vertex_areas(varray, tarray)
axes, d2e, center = moments_of_inertia([(varray, weights)])
de = (d2 - d2e) / d2
escale = 0.25*(-2*de+de.sum()) + 1
for a in range(3):
varray[:,a] *= escale[a]
elen = [elen[a]*escale[a] for a in range(3)]
return elen
def surface_blob_centers(surface):
'''
Return an array of center positions for each connected set of
displayed triangles in the surface. Centers are in surface coordinates.
A center is computed as average vertex position weighted by vertex area
where vertex area is 1/3 the area of the adjoining displayed triangles.
'''
# Get list of (vertex indices, triangle indices) for each connected piece
triangles = surface.masked_triangles
from chimerax.surface import connected_pieces, vertex_areas
blob_list = connected_pieces(triangles)
# Compute area-weighted center for each blob
vertices = surface.vertices
varea = vertex_areas(vertices, triangles)
from numpy import empty, float32
centers = empty((len(blob_list), 3), float32)
for i, (vi, ti) in enumerate(blob_list):
blob_varea = varea[vi]
blob_area = blob_varea.sum()
centers[i] = blob_varea.dot(vertices[vi]) / blob_area
return centers