Cycles: Improved robustness of hair motion blur.motion_curve_fix

In some instances, the number of control vertices of a hair could change mid-frame.
Cycles would then be unable to calculate proper motion blur for those hairs. This adds
interpolated CVs to fill in for the missing data. While this will not necessarily result in
a fully accurate reconstruction of the guide hair, it preserves motion blur instead of disabling it.

Reviewers: #cycles, sergey

Reviewed By: #cycles, sergey

Subscribers: sergey, brecht, #cycles

Tags: #cycles

Differential Revision: https://developer.blender.org/D3695

1 files changed, 167 insertions, 0 deletions

diff --git a/release/scripts/modules/bpy_extras/wm_utils/progress_report.py b/release/scripts/modules/bpy_extras/wm_utils/progress_report.py
new file mode 100644
index 00000000000..bcce44aab9f
--- /dev/null
+++ b/release/scripts/modules/bpy_extras/wm_utils/progress_report.py
@@ -0,0 +1,167 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+import time
+
+
+class ProgressReport:
+    """
+    A basic 'progress report' using either simple prints in console, or WindowManager's 'progress' API.
+
+    This object can be used as a context manager.
+
+    It supports multiple levels of 'substeps' - you shall always enter at least one substep (because level 0
+    has only one single step, representing the whole 'area' of the progress stuff).
+
+    You should give the expected number of substeps each time you enter a new one (you may then step more or less then
+    given number, but this will give incoherent progression).
+
+    Leaving a substep automatically steps by one the parent level.
+
+        with ProgressReport() as progress:  # Not giving a WindowManager here will default to console printing.
+            progress.enter_substeps(10)
+            for i in range(10):
+                progress.enter_substeps(100)
+                for j in range(100):
+                    progress.step()
+                progress.leave_substeps()  # No need to step here, this implicitly does it.
+            progress.leave_substeps("Finished!")  # You may pass some message too.
+    """
+    __slots__ = ('wm', 'running', 'steps', 'curr_step', 'start_time')
+
+    def __init__(self, wm=None):
+        self_wm = getattr(self, 'wm', None)
+        if self_wm:
+            self.finalize()
+        self.running = False
+
+        self.wm = wm
+        self.steps = [100000]
+        self.curr_step = [0]
+
+    initialize = __init__
+
+    def __enter__(self):
+        self.start_time = [time.time()]
+        if self.wm:
+            self.wm.progress_begin(0, self.steps[0])
+            self.update()
+            self.running = True
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        self.running = False
+        if self.wm:
+            self.wm.progress_end()
+            self.wm = None
+        print("\n")
+        self.steps = [100000]
+        self.curr_step = [0]
+        self.start_time = [time.time()]
+
+    def start(self):
+        self.__enter__()
+
+    def finalize(self):
+        self.__exit__()
+
+    def update(self, msg=""):
+        steps = sum(s * cs for (s, cs) in zip(self.steps, self.curr_step))
+        steps_percent = steps / self.steps[0] * 100.0
+        tm = time.time()
+        loc_tm = tm - self.start_time[-1]
+        tm -= self.start_time[0]
+        if self.wm and self.running:
+            self.wm.progress_update(steps)
+        if msg:
+            prefix = "  " * (len(self.steps) - 1)
+            print(prefix + "(%8.4f sec | %8.4f sec) %s\nProgress: %6.2f%%\r" %
+                  (tm, loc_tm, msg, steps_percent), end='')
+        else:
+            print("Progress: %6.2f%%\r" % (steps_percent,), end='')
+
+    def enter_substeps(self, nbr, msg=""):
+        if msg:
+            self.update(msg)
+        self.steps.append(self.steps[-1] / max(nbr, 1))
+        self.curr_step.append(0)
+        self.start_time.append(time.time())
+
+    def step(self, msg="", nbr=1):
+        self.curr_step[-1] += nbr
+        self.update(msg)
+
+    def leave_substeps(self, msg=""):
+        if (msg):
+            self.update(msg)
+        assert(len(self.steps) > 1)
+        del self.steps[-1]
+        del self.curr_step[-1]
+        del self.start_time[-1]
+        self.step()
+
+
+class ProgressReportSubstep:
+    """
+    A sub-step context manager for ProgressReport.
+
+    It can be used to generate other sub-step contexts too, and can act as a (limited) proxy of its real ProgressReport.
+
+    Its exit method always ensure ProgressReport is back on 'level' it was before entering this context.
+    This means it is especially useful to ensure a coherent behavior around code that could return/continue/break
+    from many places, without having to bother to explicitly leave substep in each and every possible place!
+
+        with ProgressReport() as progress:  # Not giving a WindowManager here will default to console printing.
+            with ProgressReportSubstep(progress, 10, final_msg="Finished!") as subprogress1:
+                for i in range(10):
+                    with ProgressReportSubstep(subprogress1, 100) as subprogress2:
+                        for j in range(100):
+                            subprogress2.step()
+    """
+    __slots__ = ('progress', 'nbr', 'msg', 'final_msg', 'level')
+
+    def __init__(self, progress, nbr, msg="", final_msg=""):
+        # Allows to generate a subprogress context handler from another one.
+        progress = getattr(progress, 'progress', progress)
+
+        self.progress = progress
+        self.nbr = nbr
+        self.msg = msg
+        self.final_msg = final_msg
+
+    def __enter__(self):
+        self.level = len(self.progress.steps)
+        self.progress.enter_substeps(self.nbr, self.msg)
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        assert(len(self.progress.steps) > self.level)
+        while len(self.progress.steps) > self.level + 1:
+            self.progress.leave_substeps()
+        self.progress.leave_substeps(self.final_msg)
+
+    def enter_substeps(self, nbr, msg=""):
+        self.progress.enter_substeps(nbr, msg)
+
+    def step(self, msg="", nbr=1):
+        self.progress.step(msg, nbr)
+
+    def leave_substeps(self, msg=""):
+        self.progress.leave_substeps(msg)