def test_get_root_frames_from_markers_1(self):
# Time Range
start = 1001
end = 1101
maya.cmds.playbackOptions(animationStartTime=start,
minTime=start,
animationEndTime=end,
maxTime=end)
# Create Camera and Marker Group
cam_tfm = maya.cmds.createNode('transform', name='cam_tfm')
cam_shp = maya.cmds.createNode('camera',
name='cam_shp',
parent=cam_tfm)
cam = mmapi.Camera(shape=cam_shp)
mkr_grp = mmapi.MarkerGroup().create_node(cam=cam)
# Marker A
mkr_a = mmapi.Marker().create_node()
mkr_a_node = mkr_a.get_node()
times = [1000, 1001, 1101, 1102]
values = [0, 1, 1, 0]
anim_utils.create_anim_curve_node_apione(times, values,
mkr_a_node + '.enable')
# Calculate Root Frames
min_frames_per_marker = 2
mkr_list = [mkr_a]
start_frame, end_frame = time_utils.get_maya_timeline_range_inner()
frame_nums = mod.get_root_frames_from_markers(mkr_list,
min_frames_per_marker,
start_frame, end_frame)
print 'frames:', frame_nums
return
def update_deviation_on_collection(col, solres_list):
"""
Set keyframe data on the collection for the solver.
"""
node = col.get_node()
frame_error_list = solveresult.merge_frame_error_list(solres_list)
frame_list = []
err_list = []
for frame, err in frame_error_list.items():
frame_list.append(frame)
err_list.append(err)
if len(frame_list) == len(err_list) == 0:
frame_list.append(1)
err_list.append(999.9)
plug = '{0}.{1}'.format(node, const.MARKER_ATTR_LONG_NAME_DEVIATION)
try:
maya.cmds.setAttr(plug, lock=False)
anim_utils.create_anim_curve_node_apione(
frame_list,
err_list,
node_attr=plug,
anim_type=OpenMayaAnim.MFnAnimCurve.kAnimCurveTU)
finally:
maya.cmds.setAttr(plug, lock=True)
return
def create_first_last_keyframe_animCurve(selected_keyframes,
all_times,
all_values):
curve_times = []
curve_values = []
chunks_time_list, chunks_value_list = calculate_chunks(
selected_keyframes,
all_times,
all_values)
for chunk_time, chunk_value in zip(chunks_time_list, chunks_value_list):
first_time = chunk_time[0]
first_value = chunk_value[0]
last_time = chunk_time[-1]
last_value = chunk_value[-1]
curve_times.append(first_time)
curve_times.append(last_time)
curve_values.append(first_value)
curve_values.append(last_value)
tangent = OpenMayaAnim1.MFnAnimCurve.kTangentLinear
anim_chunk_fn = animcurve_utils.create_anim_curve_node_apione(
curve_times,
curve_values,
tangent_in_type=tangent,
tangent_out_type=tangent)
return anim_chunk_fn
def set_deviation(self, times, values):
"""
Set deviation keyframes on the marker.
:param times: Times to set deviation values for.
:type times: [float, ..]
:param values: Values of deviation to set at each time.
:type values: [float, ..]
"""
assert isinstance(times, (list, tuple))
assert isinstance(values, (list, tuple))
assert len(times) > 0
assert len(values) > 0
assert len(times) == len(values)
node = self.get_node()
attr_name = const.MARKER_ATTR_LONG_NAME_DEVIATION
plug = '{0}.{1}'.format(node, attr_name)
try:
maya.cmds.setAttr(plug, lock=False)
anim_curve_fn = anim_utils.create_anim_curve_node_apione(
times,
values,
node_attr=plug,
anim_type=OpenMayaAnim.MFnAnimCurve.kAnimCurveTU)
self.set_deviation_anim_curve_fn(anim_curve_fn)
finally:
maya.cmds.setAttr(plug, lock=True)
return
def __set_attr_keyframes(node,
attr_name,
keyframes,
before_value=None,
after_value=None,
reduce_keys=None):
"""
Set keyframes on a node.attribute, from a KeyframeData instance.
:param node: Node to set data on.
:type node: str
:param attr_name: Attribute (on 'node') to set keyframes.
:type attr_name: str
:param keyframes: The keyframe information.
:type keyframes: KeyframeData
:param before_value: Value to set before the first keyframe.
:type before_value: int, float or bool
:param after_value: Value to set after the first keyframe.
:type after_value: int, float or bool
:param reduce_keys: Allow reducing the keyframes, potentially
deleting all keyframes. Values will NEVER be
changed, only duplicate keyframe data is
removed.
:type reduce_keys: bool
:returns: Maya API (version 1) MFnAnimCurve object.
:rtype: maya.OpenMaya.MFnAnimCurve
"""
if isinstance(keyframes, interface.KeyframeData) is False:
msg = 'keyframes must be type %r'
raise TypeError(msg % interface.KeyframeData.__name__)
if reduce_keys is None:
reduce_keys = False
if isinstance(reduce_keys, bool) is False:
msg = "reduce_keys must be type 'bool'"
raise TypeError(msg)
times, values = keyframes.get_times_and_values()
assert len(times) == len(values)
# Set an extra value before/after the first/last keyframe.
if len(times) > 0:
if before_value is not None:
start_time = times[0]
times = [start_time - 1] + times
values = [before_value] + values
if after_value is not None:
end_time = times[-1]
times = times + [end_time + 1]
values = values + [after_value]
# Reduce keyframes, we don't need per-frame keyframes if the data
# is the same. Change the times/values just before we set the
# keyframes
if reduce_keys is True:
tmp_times = list(times)
tmp_values = list(values)
times = []
values = []
prev_t = None
prev_v = None
for t, v in zip(tmp_times, tmp_values):
if prev_v is None:
times.append(t)
values.append(v)
elif interface.float_is_equal(prev_v, v) is False:
times.append(prev_t)
values.append(prev_v)
times.append(t)
values.append(v)
prev_t = t
prev_v = v
node_attr = node + '.' + attr_name
anim_fn = anim_utils.create_anim_curve_node_apione(times, values,
node_attr)
if reduce_keys is True:
locked = maya.cmds.getAttr(node_attr, lock=True)
maya.cmds.setAttr(node_attr, lock=False)
maya.cmds.delete(node_attr, staticChannels=True)
maya.cmds.setAttr(node_attr, lock=locked)
return anim_fn
def main():
"""
Screen-Space Bake.
Usage:
1) Select transform nodes.
2) Activate viewport.
3) Run tool.
4) A new locator is created under the active camera
"""
mmapi.load_plugin()
editor = viewport_utils.get_active_model_editor()
if editor is None:
LOG.error('Please select an active viewport; editor=%r', editor)
return
cam_tfm, cam_shp = viewport_utils.get_viewport_camera(editor)
if cam_tfm is None or cam_shp is None:
LOG.error('Please select a camera; cam_tfm=%r cam_shp=%r',
cam_tfm, cam_shp)
return
cam = mmapi.Camera(transform=cam_tfm, shape=cam_shp)
img_width = maya.cmds.getAttr(cam_shp + '.horizontalFilmAperture') * 100.0
img_height = maya.cmds.getAttr(cam_shp + '.verticalFilmAperture') * 100.0
nodes = maya.cmds.ls(
selection=True,
long=True,
type='transform'
) or []
if len(nodes) == 0:
LOG.error('Please select transform nodes; %r', nodes)
return
start_frame, end_frame = utils_time.get_maya_timeline_range_inner()
times = range(start_frame, end_frame+1)
created_loc_tfms = []
for node in nodes:
grp_node, depth_tfm, loc_tfm, loc_shp = lib.create_screen_space_locator(cam)
created_loc_tfms.append(loc_tfm)
# BUG: If a camera has 'camera scale' attribute set other than
# 1.0, the reprojected values will not be correct.
values = maya.cmds.mmReprojection(
node,
camera=(cam_tfm, cam_shp),
time=times,
asMarkerCoordinate=True,
imageResolution=(int(img_width), int(img_height)),
)
stop = len(values)
step = 3
plug = loc_tfm + '.translateX'
values_x = values[0:stop:step]
animfn_x = anim_utils.create_anim_curve_node_apione(
times, values_x,
node_attr=plug
)
plug = loc_tfm + '.translateY'
values_y = values[1:stop:step]
animfn_y = anim_utils.create_anim_curve_node_apione(
times, values_y,
node_attr=plug
)
plug = depth_tfm + '.scaleX'
values_z = values[2:stop:step]
animfn_z = anim_utils.create_anim_curve_node_apione(
times, values_z,
node_attr=plug
)
if len(created_loc_tfms) > 0:
maya.cmds.select(created_loc_tfms, replace=True)
# Trigger Maya to refresh.
maya.cmds.currentTime(update=True)
maya.cmds.refresh()
return
