def create_zerotable(self):
        n = self.n_data
        self.zero_table = [[-1 for i in range(n)] for j in range(n)]
        curve_tangents = segment_fitting.tangents_of_curve(self.curve)

        if self.verbose:
            print "Creating zerostop table"
            print "-" * (n-1)

        for i in range(n - 1):
            if self.verbose:
                sys.stdout.write("#")

            for j in range(i, n):
                if i == j:
                    continue
                if abs(i - j) == 1:
                    self.zero_table[i][j] = 0
                else:
                    seg = make_seg.true_tangents( self.curve[i:j+1]
                                                , curve_tangents[i:j+1]
                                                , self.res )
                    cost, cost_index = self.cost_fn(seg)
                    self.zero_table[i][j] = cost

        if self.verbose: print ""
Esempio n. 2
0
    def per_segment_solve(self, curve, keyframes):
        interps = []
        res = Algorithm.interp_res
        curve_tangents = segment_fitting.tangents_of_curve(curve)

        # Do initial fit using true tangents and
        # iterating-constrainted-salient-points
        n_keyframes = len(keyframes)
        for i in range(1, n_keyframes):
            k1 = keyframes[i-1]
            k2 = keyframes[i]
            seg_curve = curve[k1:k2+1]
            seg_tangents = curve_tangents[k1:k2+1]
            # if len(seg_curve) > 3:
            interp = interp_f.true_tangents( seg_curve
                                           , seg_tangents
                                           , res) 

            # for j in range(5):
            #     nts = interp.ts_nearest()
            #     interp = interp_f.true_tangents( interp.curve
            #                                    , curve_tangents
            #                                    , res
            #                                    , nts)

            interps.append(interp)

        return interps
    def create_zerostop_truetangents_cl(self):
        tmp_table = [[[0] for i in range(self.n_data)] for j in range(self.n_data)]
        curve_tangents = segment_fitting.tangents_of_curve(self.curve)

        cols = []
        col_index = 0
        n_i, n_j = self.curve.shape
        n = n_j

        inds_a = []
        inds_b = []
        inds_c = []
        fill_cell = []

        if self.verbose: print "-" * (self.n_data - 1)
        for s in range(self.n_data - 1):
            if self.verbose:
                sys.stdout.write("#")
            for e in range(s + 1, self.n_data):
                if s == e:
                    continue
                if abs(e - s) == 1:
                    continue
                else:
                    seg = make_seg.true_tangents( self.curve[s:e+1]
                                                , curve_tangents[s:e+1]
                                                , self.res )

                    a_p = seg.n_curve_interps(30)
                    b_p = seg.n_sampling(30)
                    # print a_p[:10]
                    # print a_b[:10]
                    # raise "hi"

                    for i in range(len(a_p)):
                        cols += a_p[i].tolist()
                        inds_a.append(col_index); col_index += 1
                        cols += b_p[i].tolist()
                        inds_b.append(col_index); col_index += 1
                        inds_c.append(0)
                        fill_cell.append((s, e))
        if self.verbose: print ""


        results = gg.gogo("dist_many.cl", n, cols, inds_a, inds_b, inds_c)
        for i in range(len(fill_cell)):
            s, e = fill_cell[i]
            tmp_table[s][e].append(results[i])

        self.zero_table = [[-1 for i in range(self.n_data)] for j in range(self.n_data)]
        for i in range(self.n_data):
            for j in range(self.n_data):
                self.zero_table[i][j] = sum(tmp_table[i][j])