예제 #1
0
    def exec_oneshot(self, *args):
        keyframes = self.global_extractor.get_n_keyframes(self.n_globals)
        n_keyframes = len(keyframes)

        interps = []

        for name in self.curves.keys():
            for dim in self.dimensions[name].keys():
                if not self.dimensions[name][dim]:
                    continue

                index = -1
                if dim == "rx": index = 1
                if dim == "ry": index = 2
                if dim == "rz": index = 3
                curve = []
                for i in range(len(Motion.mocap["single"][name])):
                    curve.append([Motion.mocap["single"][name].item(i, 0), Motion.mocap["single"][name].item(i, index)])
                curve = np.array(curve)

                for i in range(1, n_keyframes):
                    k1 = keyframes[i-1]
                    k2 = keyframes[i]
                    seg_curve = curve[k1:k2+1]
                    interp = interp_f.unconstrained(seg_curve, 100)
                    interps.append(interp)

        for i in range(len(interps)):
            seg = interps[i]
            if len(seg.curve) <= 3:
                interps[i] = interp_f.line(seg.curve, 100)

        self.interps = interps
        self.app.update()
        return interps
예제 #2
0
    def tighten_fitting_with_breaking(self, interps):
        for i in range(len(interps)):
            interp = interps[i]
            refit = interp_f.unconstrained( interp.curve
                                          , Algorithm.interp_res )
            cost_org  = Algorithm.eval_method_refit(interp)[0]
            cost_new  = Algorithm.eval_method_refit(refit)[0]

            if cost_org == 0:
              continue

            # print "%s %s %d improved = before:%2.3f after:%2.3f" % i, cost_org, cost_new)
            if 1 - (cost_new / float(cost_org)) > Algorithm.refit_cost:
                interps[i] = refit

        return interps
예제 #3
0
    def eval_errors(self):
        def keyframe_of_worst(cases):
            max_cost = 0
            keyframe = -1
            for (cost, index) in cases:
                if cost > max_cost:
                    max_cost = cost
                    keyframe = index
            return keyframe

        def combine_costs(cases):
            return max([case[0] for c in cases])

        worst_cases = []
        for i in range(1, n_keyframes):
            k1 = keyframes[i-1]
            k2 = keyframes[i]
            seg = make_seg.unconstrained(self.curve[k1:k2+1], self.res)
            cost, index = self.cost_fn(seg)
            worst_cases.append([cost, k1 + index])

        return combine_costs(cases)