Core Solver - Pre-compute Valid Frames

The frames that can or cannot be solved are validated and culled before
a proper solve can be started.

This is intended to avoid invalid solves from attempting to be solved,
and overall produce a more robust solver.

We also move the logic of whether the solver is valid from the Python
"actionstate.py" file to the C++ core, which gives us more information
to make better and more informed decisions about solver validity.

This is partially related to gitHub issue #174.

Author: david-cattermole

python/mmSolver/_api/_execute/actionstate.py

@@ -99,8 +99,8 @@ def run_validate_action(vaction):
     frames = list(sorted(vkwargs.get('frame', [])))
     num_frames = len(frames)
     if num_frames == 0 and vfunc_is_mmsolver is True:
-        msg = 'Failed to validate number of frames: param=%r errors=%r frames=%r'
-        message = msg % (num_param, num_err, num_frames)
+        msg = 'Failed to validate frames: frames=%r'
+        message = msg % num_frames
         state = create_action_state(
             status=const.ACTION_STATUS_FAILED,
             message=message,
@@ -115,8 +115,8 @@ def run_validate_action(vaction):
     solve_data = vfunc(*vargs, **vkwargs)
 
     if vfunc_is_mmsolver is False:
-        msg = 'Validated parameters, errors and frames: param=%r errors=%r frames=%r'
-        message = msg % (num_param, num_err, num_frames)
+        msg = 'Validated frames: frames=%r'
+        message = msg % num_frames
         state = create_action_state(
             status=const.ACTION_STATUS_SUCCESS,
             message=message,
@@ -130,24 +130,28 @@ def run_validate_action(vaction):
     if vfunc_is_mmsolver_v2 is True:
         solve_data = vkwargs['resultsNode']
     if vfunc_is_camera_solve is True:
-        if const.SOLVER_VERSION_DEFAULT == const.SOLVER_VERSION_TWO:
-            # Get the collection node given to the camera solve.
-            solve_data = vargs[0]
+        # NOTE: This assumes that the camera solver is using
+        # const.SOLVER_VERSION_TWO.
+        #
+        # Get the collection node given to the camera solve.
+        solve_data = vargs[0]
 
     solres = solveresult.SolveResult(solve_data)
 
     print_stats = solres.get_print_stats()
     num_param = print_stats.get('number_of_parameters', 0)
     num_err = print_stats.get('number_of_errors', 0)
-    if num_param == 0 or num_err == 0 or num_param > num_err:
-        msg = (
-            'Invalid parameters and errors (param=%r errors=%r frames=%r), '
-            'skipping solve: %r'
-        )
-        message = msg % (num_param, num_err, num_frames, list(sorted(frames)))
+    solver_valid_frames = solres.get_solver_valid_frame_list()
+    if len(solver_valid_frames) == 0:
+        # This error should be raised if ALL the frames in the
+        # solve are invalid, and if they are invalid then the frames
+        # should just be skipped and the solve should be continued.
+        solver_invalid_frames = solres.get_solver_invalid_frame_list()
+        assert len(solver_invalid_frames) == len(frames)
+        msg = 'All frames are invalid, skipping solve: %r' % list(sorted(frames))
         state = create_action_state(
             status=const.ACTION_STATUS_FAILED,
-            message=message,
+            message=msg,
             error_number=num_err,
             parameter_number=num_param,
             frames_number=num_frames,

python/mmSolver/_api/solveresult.py

@@ -24,8 +24,9 @@
 from __future__ import print_function
 
 import collections
-import math
 import datetime
+import math
+import pprint
 
 import maya.cmds
 
@@ -51,9 +52,9 @@ def parse_command_result(cmd_result):
     data = collections.defaultdict(list)
     for res in cmd_result:
         assert isinstance(res, pycompat.TEXT_TYPE)
-        splt = res.partition(KEY_VALUE_SEP_CHAR)
-        key = splt[0]
-        value = splt[-1]
+        split = res.partition(KEY_VALUE_SEP_CHAR)
+        key = split[0]
+        value = split[-1]
         if len(key) == 0:
             continue
         if SPLIT_SEP_CHAR in value:
@@ -142,6 +143,33 @@ def _string_get_solver_stats(input_data):
     return solver_stats
 
 
+def _string_get_solver_frames_stats(input_data):
+    name_keys = [
+        ('number_of_valid_frames', 'number_of_valid_frames', int, None),
+        ('number_of_invalid_frames', 'number_of_invalid_frames', int, None),
+        ('valid_frames', 'valid_frames', list, int),
+        ('invalid_frames', 'invalid_frames', list, int),
+    ]
+    index = 0
+    solver_frames = {}
+    for name, key, outer_type, inner_type in name_keys:
+        value = input_data.get(key)
+        if value is None:
+            continue
+        if inner_type is None:
+            v = _convert_to(name, key, outer_type, value, index)
+            solver_frames[name] = v
+        else:
+            if len(value) == 1:
+                value = value[0]
+            values = []
+            for v in value:
+                if len(v) > 0:
+                    values.append(inner_type(v))
+            solver_frames[name] = values
+    return solver_frames
+
+
 def _string_get_error_stats(input_data):
     name_keys = [
         ('initial', 'error_initial', float),
@@ -254,6 +282,15 @@ def _get_maya_attr_anim_curve(node, attr_name, existing_attrs):
     return anim_curves[0]
 
 
+def _get_node_frame_list(node, attr_name, existing_attrs):
+    anim_curve = _get_maya_attr_anim_curve(node, attr_name, existing_attrs)
+    if anim_curve is None:
+        return {}
+
+    keyframe_times = maya.cmds.keyframe(anim_curve, query=True, timeChange=True) or []
+    return set(keyframe_times)
+
+
 def _get_node_frame_error_list(node, attr_name, existing_attrs):
     anim_curve = _get_maya_attr_anim_curve(node, attr_name, existing_attrs)
     if anim_curve is None:
@@ -343,6 +380,21 @@ def _node_get_solver_stats(node, existing_attrs):
     return data
 
 
+def _node_get_solver_frames_stats(node, existing_attrs):
+    assert maya.cmds.objExists(node) is True
+    data = {
+        'number_of_valid_frames': _get_maya_attr(
+            node, 'number_of_valid_frames', int, existing_attrs
+        ),
+        'number_of_invalid_frames': _get_maya_attr(
+            node, 'number_of_invalid_frames', int, existing_attrs
+        ),
+        'valid_frames': _get_node_frame_list(node, 'valid_frames', existing_attrs),
+        'invalid_frames': _get_node_frame_list(node, 'invalid_frames', existing_attrs),
+    }
+    return data
+
+
 def _node_get_print_stats(node, existing_attrs):
     assert maya.cmds.objExists(node) is True
     data = {
@@ -414,8 +466,8 @@ def __init__(self, *args, **kwargs):
             self._solver_stats = _node_get_solver_stats(node, existing_attrs)
             self._error_stats = _node_get_error_stats(node, existing_attrs)
             self._timer_stats = _node_get_timer_stats(node, existing_attrs)
+            self._solver_frames_stats = _node_get_solver_frames_stats(data)
             self._print_stats = _node_get_print_stats(node, existing_attrs)
-
             self._per_frame_error = _node_get_per_frame_error(node, existing_attrs)
             self._per_marker_per_frame_error = _node_get_per_marker_per_frame_error(
                 node, existing_attrs
@@ -428,6 +480,7 @@ def __init__(self, *args, **kwargs):
             self._solver_stats = _string_get_solver_stats(data)
             self._error_stats = _string_get_error_stats(data)
             self._timer_stats = _string_get_timer_stats(data)
+            self._solver_frames_stats = _string_get_solver_frames_stats(data)
             self._print_stats = _string_get_print_stats(data)
             self._per_marker_per_frame_error = _string_get_error_per_marker_per_frame(
                 data
@@ -509,6 +562,13 @@ def get_print_stats(self):
         """
         return self._print_stats.copy()
 
+    def get_solver_frames_stats(self):
+        """
+        Details of internal statistics that can be gathered and
+        printed out.
+        """
+        return self._solver_frames_stats.copy()
+
     def get_frame_list(self):
         """
         The list of frames that this solve result contains.
@@ -540,6 +600,20 @@ def get_marker_error_list(self, marker_node=None):
             v = self._per_marker_per_frame_error.get(marker_node)
         return v
 
+    def get_solver_valid_frame_list(self):
+        """
+        The list of valid frames that the solver can solve.
+        """
+        frame_list = self._solver_frames_stats.get('valid_frames', [])
+        return list(sorted(frame_list))
+
+    def get_solver_invalid_frame_list(self):
+        """
+        The list of invalid frames that the solver can solve.
+        """
+        frame_list = self._solver_frames_stats.get('invalid_frames', [])
+        return list(sorted(frame_list))
+
 
 def combine_timer_stats(solres_list):
     """