def computeEndPointsFromChunk(self, chunk, update = True):
"""
Derives and returns the endpoints and radius of a Peptide chunk.
@param chunk: a Peptide chunk
@type chunk: Chunk
@return: endPoint1, endPoint2 and radius
@rtype: Point, Point and float
@note: computing the endpoints works fine when n=m or m=0. Otherwise,
the endpoints can be slightly off the central axis, especially
if the Peptide is short.
@attention: endPoint1 and endPoint2 may not be the original endpoints,
and they may be flipped (opposites of) the original
endpoints.
"""
# Since chunk.axis is not always one of the vectors chunk.evecs
# (actually chunk.poly_evals_evecs_axis[2]), it's best to just use
# the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(axis) # needed
center = chunk._get_center()
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot( points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:,0]**2 + v[:,1]**2
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:,2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
# Adjust the endpoints such that the ladder rungs (rings) will fall
# on the ring segments.
# TO DO: Fix drawPeptideLadder() to offset the first ring, then I can
# remove this adjustment. --Mark 2008-04-12
z_adjust = self.getEndPointZOffset()
min_z += z_adjust
max_z -= z_adjust
endpoint1 = center + min_z * axis
endpoint2 = center + max_z * axis
if update:
#print "Original endpoints:", self.getEndPoints()
self.setEndPoints(endpoint1, endpoint2)
#print "New endpoints:", self.getEndPoints()
return (endpoint1, endpoint2, radius)
def compute_memo(self, chunk):
"""
If drawing chunk in this display mode can be optimized by precomputing some info from chunk's appearance,
compute that info and return it.
If this computation requires preference values, access them as env.prefs[key],
and that will cause the memo to be removed (invalidated) when that preference value is changed by the user.
This computation is assumed to also depend on, and only on, chunk's appearance in ordinary display modes
(i.e. it's invalidated whenever havelist is). There is not yet any way to change that,
so bugs will occur if any ordinarily invisible chunk info affects this rendering,
and potential optimizations will not be done if any ordinarily visible info is not visible in this rendering.
These can be fixed if necessary by having the real work done within class Chunk's _recompute_ rules,
with this function or drawchunk just accessing the result of that (and sometimes causing its recomputation),
and with whatever invalidation is needed being added to appropriate setter methods of class Chunk.
If the real work can depend on more than chunk's ordinary appearance can, the access would need to be in drawchunk;
otherwise it could be in drawchunk or in this method compute_memo.
"""
# for this example, we'll turn the chunk axes into a cylinder.
# Since chunk.axis is not always one of the vectors chunk.evecs (actually chunk.poly_evals_evecs_axis[2]),
# it's best to just use the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(
axis
) # needed (unless we're sure it's already unit length, which is likely)
center = chunk.center
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot(points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:, 0]**2 + v[:, 1]**2
## r_xy = sqrt(r_xy_2) # not needed
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:, 2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
bcenter = chunk.abs_to_base(center)
# return, in chunk-relative coords, end1, end2, and radius of the cylinder, and color.
color = chunk.color
if color is None:
color = V(0.5, 0.5, 0.5)
# make sure it's longer than zero (in case of a single-atom chunk); in fact, add a small margin all around
# (note: this is not sufficient to enclose all atoms entirely; that's intentional)
margin = 0.2
min_z -= margin
max_z += margin
radius += margin
return (bcenter + min_z * axis, bcenter + max_z * axis, radius, color)
def compute_memo(self, chunk):
"""
If drawing chunk in this display mode can be optimized by precomputing some info from chunk's appearance,
compute that info and return it.
If this computation requires preference values, access them as env.prefs[key],
and that will cause the memo to be removed (invalidated) when that preference value is changed by the user.
This computation is assumed to also depend on, and only on, chunk's appearance in ordinary display modes
(i.e. it's invalidated whenever havelist is). There is not yet any way to change that,
so bugs will occur if any ordinarily invisible chunk info affects this rendering,
and potential optimizations will not be done if any ordinarily visible info is not visible in this rendering.
These can be fixed if necessary by having the real work done within class Chunk's _recompute_ rules,
with this function or drawchunk just accessing the result of that (and sometimes causing its recomputation),
and with whatever invalidation is needed being added to appropriate setter methods of class Chunk.
If the real work can depend on more than chunk's ordinary appearance can, the access would need to be in drawchunk;
otherwise it could be in drawchunk or in this method compute_memo.
"""
# for this example, we'll turn the chunk axes into a cylinder.
# Since chunk.axis is not always one of the vectors chunk.evecs (actually chunk.poly_evals_evecs_axis[2]),
# it's best to just use the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(axis) # needed (unless we're sure it's already unit length, which is likely)
center = chunk.center
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot( points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:,0]**2 + v[:,1]**2
## r_xy = sqrt(r_xy_2) # not needed
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:,2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
bcenter = chunk.abs_to_base(center)
# return, in chunk-relative coords, end1, end2, and radius of the cylinder, and color.
color = chunk.color
if color is None:
color = V(0.5,0.5,0.5)
# make sure it's longer than zero (in case of a single-atom chunk); in fact, add a small margin all around
# (note: this is not sufficient to enclose all atoms entirely; that's intentional)
margin = 0.2
min_z -= margin
max_z += margin
radius += margin
return (bcenter + min_z * axis, bcenter + max_z * axis, radius, color)