def testGenerateCollar(self):
        self.assertEqual(self.sc1.generate_collar(2),
                         S({
                             3: 1,
                             7: 0,
                             8: 1,
                             12: 0
                         }))

        # Input signal should be normalized in the generate_collar
        # function
        self.assertEqual(self.sc2.generate_collar(2),
                         S({
                             3: 1,
                             7: 0,
                             8: 1,
                             12: 0
                         }))

        self.assertEqual(self.sc3.generate_collar(2),
                         S({
                             -2: 1,
                             2: 0,
                             8: 1,
                             12: 0
                         }))

        # Output signal should be normalized
        self.assertEqual(self.sc1.generate_collar(5), S({0: 1, 15: 0}))
Esempio n. 2
0
 def testSubtraction(self):
     self.assertEqual(self.s1 - self.se, self.s1)
     self.assertEqual(self.se - self.s1, self.se)
     self.assertEqual(self.s1 - self.si1, S({30: 1, 45: 0}))
     self.assertEqual(self.si1 - self.s1, S({60: 1, 100: 0}))
     self.assertEqual(self.sb1 - self.s1, S({0: 1, 100: 0}))
     self.assertEqual(self.sb1 - self.sb3, S({0: 1, 60: 0}))
     self.assertEqual(self.sb3 - self.sb1, S({60: 1, 130: 0}))
     self.assertEqual(self.sb1 - self.se, self.sb1)
 def testUnion(self):
     self.assertEqual(self.se | self.se, self.se)
     self.assertEqual(self.s1 | self.s1, self.s1)
     self.assertEqual(self.s1 | self.s2, S({0: 1, 10: 0, 30: 1, 60: 0}))
     self.assertEqual(self.s2 | self.s1, S({0: 1, 10: 0, 30: 1, 60: 0}))
     self.assertEqual(self.s1 | self.s5 | self.s6, self.s7)
     self.assertEqual(self.s5 | self.s7, self.s7)
     self.assertEqual(self.s7 | self.s5, self.s7)
     self.assertEqual(
         S({
             '0': 1,
             '20941': 0
         }) | S({
             '19337': 1,
             '19352': 0
         }), S({
             '0': 1,
             '20941': 0
         }))
     self.assertEqual(
         S({
             '0': 1,
             '20941': 0
         }) | S({
             '4288': 1,
             '4636': 0
         }), S({
             '0': 1,
             '20941': 0
         }))
 def testSignalMultiAdd(self):
     self.assertEqual(reduce(add, [self.s1, self.s1, self.s1]),
                      S({
                          30: 3,
                          60: 0
                      }))
     self.assertEqual(reduce(add, [self.s1, self.s2, self.s3]),
                      S({
                          0: 1,
                          10: 0,
                          30: 2,
                          40: 1,
                          60: 0
                      }))
Esempio n. 5
0
def build_ref_sig(ref, file_framedur_lookup
                  ):  #(aligned_pairs, missed_ref, file_framedur_lookup):
    # Need to modify join, find ways to keep from doing full join each time.
    # reference stays the same, calculated once. system, just need to include
    # new false alarms
    #
    #print "Building Ref Sig"
    #num_aligned = len(ref) #aligned_pairs) + len(missed_ref)
    ref_temp_add = {}
    not_ref = {}
    nr_area = {}
    if ref == {}:  #num_aligned == 0:
        return [{}, {}, {}]
    for key, value in ref.items():

        ref_temp = [temporal_single_signal(b) for b in value]
        ref_temp_add[key] = reduce(add, [r[0] for r in ref_temp], S())
        not_ref[key] = ref_temp_add[key].not_sig(file_framedur_lookup[key])
        nr_area[key] = not_ref[key].area()

    #ref_temp = [temporal_single_signal(b) for b in aligned_pairs ] + [ temporal_single_signal(m) for m in missed_ref ] #list(itertools.chain([temporal_single_signal(b) for b in aligned_pairs], [temporal_single_signal(m) for m in missed_ref])) #[temporal_single_signal(r) for r in combined_ref ]
    #ref_temp_add=reduce(add, [r[0] for r in ref_temp], S())

    #not_ref=ref_temp_add.not_sig(file_framedur_lookup.get(ref_temp[0][1]))

    #nr_area=not_ref.area()
    #print "ref_temp_add"
    #print ref_temp_add
    #print "not_ref"
    #print not_ref
    #print "nr_area"
    #print nr_area
    return [ref_temp_add, not_ref, nr_area]
Esempio n. 6
0
 def testIntersection(self):
     self.assertEqual(self.s1 & self.se, self.se)
     self.assertEqual(self.s1 & self.s1, self.s1)
     self.assertEqual(self.s1 & self.s2, self.se)
     self.assertEqual(self.s1 & self.s3, self.s3)
     self.assertEqual(self.s3 & self.s1, self.s3)
     self.assertEqual(self.s1 & self.sb1, self.s1)
     self.assertEqual(self.s1 & self.si1, S({45: 1, 60: 0}))
Esempio n. 7
0
    def setUp(self):
        super(TestNMIDE, self).setUp()

        self.cost_fn = lambda x: 1 * x

        self.r1 = S({5: 1, 15: 0})
        self.s1 = S({5: 1, 15: 0})

        self.s2 = S({2: 1, 10: 0})

        self.r3 = S({5: 1, 15: 0, 30: 1, 35: 0})
        self.s3 = S({10: 1, 15: 0, 40: 1, 50: 0})

        self.r4 = S({30: 1, 35: 0})

        self.c1 = [(A({ "f1": self.r1 }), A({ "f1": self.s1 })),
                   (A({ "f1": self.r3 }), A({ "f1": self.s3 }))]

        self.cd = [(A({ "f1": self.r1, "f2": self.r1 }), A({ "f1": self.s1, "f2": self.s1 })),
                   (A({ "f1": self.r3, "f2": self.r3 }), A({ "f1": self.s3, "f2": self.s3 }))]

        self.c3 = [(A({ "f1": self.r1 }), A({ "f2": self.s1 })),
                   (A({ "f1": self.r3 }), A({ "f2": self.s3 }))]

        self.c4 = [(A({ "f1": self.r1 }), A({ "f1": self.s2 })),
                   (A({ "f1": self.r4 }), A({ "f1": self.s3 }))]

        self.filedur_1 = { "f1": 80, "f2": 100 }

        # Testing 0 FA denominator
        self.filedur_2 = { "f1": 15 }

        self.cost_0 = lambda x: 0 * x
Esempio n. 8
0
    def _sweep(alignment_records):
        c, m, f = partition_alignment(alignment_records)
        
        if file_framedur_lookup != 0:
            ref_sigs = build_ref_sig([ (ar.ref) for ar in c ],
                                     [(ar.ref) for ar in m],
                                     file_framedur_lookup )
            fa_func=measure_funcs.pop()
        #sys_sig = build_sys_sig([ (ar.sys) for ar in c ])
        #print "sys_sig"
        #print sys_sig
        sys_sig=[[],S()]
        #sys_sig[0] = []
        #sys_sig[1] = S()
        total_c = len(c)
        num_m = len(m)
        out_points = []
        current_c, current_f = [], []
        
        
        
        # m records don't need to be sorted as they have None
        # confidence scores
        current_m = m + sorted(c, None, conf_key_func)
        remaining_f = sorted(f, None, conf_key_func)
        uniq_confs = sorted(set(map(conf_key_func, c + f)), reverse = True)
        for conf in uniq_confs:
            newsig = []
            newsig_tem = []
            while len(current_m) > 0 and current_m[-1].alignment != "MD" and conf_key_func(current_m[-1]) >= conf:
                if file_framedur_lookup != 0:
                    newsig.append(current_m[-1])
                current_c.append(current_m.pop())
            while len(remaining_f) > 0 and conf_key_func(remaining_f[-1]) >= conf:
                if file_framedur_lookup != 0:
                    newsig.append(remaining_f[-1])
                current_f.append(remaining_f.pop())
            if file_framedur_lookup != 0:
                if len(newsig) != 0:
                    newsig_tem = add_sys_sig(sys_sig[0],[(ar.sys) for ar in newsig])
                    sys_sig[0] = sys_sig[0] + newsig_tem
                    sys_sig[1] = reduce(add, [s[0] for s in newsig_tem], sys_sig[1])
                out_points.append((conf, reduce(merge_dicts, [ m(current_c, current_m, current_f) for m in measure_funcs ], fa_func(ref_sigs, sys_sig))))
            else:
                out_points.append((conf, reduce(merge_dicts, [ m(current_c, current_m, current_f) for m in measure_funcs ], {})))
            #print "out_points"
            #print out_points
            #print "sys_sig"
            #print sys_sig
            #out_points.append((conf, reduce(merge_dicts, [ m(current_c, current_m, current_f) for m in measure_funcs ], fa_func(ref_sigs, sys_sig))))

        return out_points
Esempio n. 9
0
def build_ref_sig(ref, file_framedur_lookup):
    # Need to modify join, find ways to keep from doing full join each time.
    # reference stays the same, calculated once. system, just need to include
    # new false alarms
    ref_temp_add = {}
    not_ref = {}
    nr_area = {}
    if ref == {}:
        return [{}, {}, {}]
    for key, value in ref.items():
        ref_temp = [temporal_single_signal(b) for b in value]
        ref_temp_add[key] = reduce(add, [r[0] for r in ref_temp], S())
        not_ref[key] = ref_temp_add[key].not_sig(file_framedur_lookup[key])
        nr_area[key] = not_ref[key].area()

    return[ref_temp_add, not_ref, nr_area]
Esempio n. 10
0
def build_ref_sig(aligned_pairs, missed_ref, file_framedur_lookup):
    # Need to modify join, find ways to keep from doing full join each time.
    # reference stays the same, calculated once. system, just need to include
    # new false alarms
    #
    #print "Building Ref Sig"
    num_aligned = len(aligned_pairs) + len(missed_ref)
    if num_aligned == 0:
        return [{},{},0]
    #combined_ref = itertools.chain([temporal_single_signal(b) for b in aligned_pairs], [temporal_single_signal(m) for m in missed_ref]) #[b for b in aligned_pairs] + [m for m in missed_ref] #works
    ref_temp = [temporal_single_signal(b) for b in aligned_pairs ] + [ temporal_single_signal(m) for m in missed_ref ] #list(itertools.chain([temporal_single_signal(b) for b in aligned_pairs], [temporal_single_signal(m) for m in missed_ref])) #[temporal_single_signal(r) for r in combined_ref ]
    ref_temp_add=reduce(add, [r[0] for r in ref_temp], S())
    #ref_temp_add = reduce(add,ref_temp) #special_join(ref_temp)
    not_ref=ref_temp_add.not_sig(file_framedur_lookup.get(ref_temp[0][1]))
    
    nr_area=not_ref.area()

    return[ref_temp_add, not_ref, nr_area]
Esempio n. 11
0
    def test2D(self):
        self.assertEqual(self.s2d_1.area(), 250)
        self.assertEqual(self.s2d_2.area(), 250)

        self.assertEqual(self.s2d_1.join(self.s2d_1.join(self.s2d_1, lambda a, b: a.join(b, min, 0), S()), lambda a, b: a.join(b, sub, 0), S()), S())

        self.assertEqual(self.s2d_1.join(self.s2d_2, lambda a, b: a.join(b, min, 0), S()), S({10: S({15: 1, 20: 0}), 15: S(), 30: S({15: 1, 25: 0}), 35: S()}))
        self.assertEqual(self.s2d_1.join_nd(self.s2d_2, 2, min), S({10: S({15: 1, 20: 0}), 15: S(), 30: S({15: 1, 25: 0}), 35: S()}))

        self.assertEqual(self.s2d_1.join_nd(S(), 2, max), self.s2d_1)

        self.assertEqual(self.s2d_1.join_nd(self.s2d_2, 2, lambda a, b: a - min(a, b)), S({10: S({10: 1, 15: 0}), 15: S(), 30: S({25: 1, 35: 0}), 35: S({15: 1, 35: 0}), 40: S()}))
        self.assertEqual(self.s2d_1.join_nd(self.s2d_2, 2, lambda a, b: a - min(a, b)).area(), 175)

        self.assertEqual(self.s2d_1.join_nd(self.s2d_2, 2, max), S({10: S({10: 1, 25: 0}), 15: S({15: 1, 25: 0}), 30: S({15: 1, 35: 0}), 40: S()}))
        self.assertEqual(self.s2d_1.join_nd(self.s2d_2, 2, max).area(), 425)
Esempio n. 12
0
def _temporal_signal_accessor(localization, k):
    return S(localization.get(k, {}))
Esempio n. 13
0
    def setUp(self):
        self.ae = A({})

        self.a1 = A({"f1": O(S({10: S({10: 1, 20: 0}), 15: S()}))})
        self.a2 = A({"f1": O(S({10: S({15: 1, 25: 0}), 35: S()}))})
        self.a3 = A({"f1": O(S({30: S({15: 1, 35: 0}), 40: S()}))})

        self.a4 = A({
            "f1": O(S({
                10: S({
                    10: 1,
                    20: 0
                }),
                15: S()
            })),
            "f2": O(S({
                30: S({
                    15: 1,
                    35: 0
                }),
                40: S()
            }))
        })
        self.a5 = A({
            "f1": O(S({
                10: S({
                    15: 1,
                    25: 0
                }),
                35: S()
            })),
            "f2": O(S({
                10: S({
                    15: 1,
                    25: 0
                }),
                35: S()
            }))
        })
Esempio n. 14
0
    def _sweep(alignment_records):
        c, m, f = partition_alignment(alignment_records)
        sys_sig = {}
        sys_sig_add = {}
        ref_all = {}
        if file_framedur_lookup != 0:
            for key in file_framedur_lookup:
                sys_sig[key] = []
                sys_sig_add[key] = S()
                ref_all[key] = []
            for ar in c:
                ref_all[ar.video_file].append(ar.ref)
            for ar in m:
                ref_all[ar.video_file].append((ar.ref))
            ref_sigs = build_ref_sig(ref_all, file_framedur_lookup)
            fa_func = measure_funcs.pop()

        out_points = []
        current_c, current_f = [], []
        # m records don't need to be sorted as they have None
        # confidence scores
        current_m = m + sorted(c, key=conf_key_func)
        remaining_f = sorted(f, key=conf_key_func)
        uniq_confs = sorted(set(map(conf_key_func, c + f)), reverse=True)

        if uniq_conf_limit != 0:
            if (len(uniq_confs) > uniq_conf_limit):
                le = len(uniq_confs)
                indices = np.round(np.linspace(0, len(uniq_confs)-1,
                                   min(len(uniq_confs), uniq_conf_limit))
                                   ).astype(int)
                uniq_confs = list(np.array(uniq_confs)[indices])
                print("""[Info] Reducing to {} unique confidence scores for"""
                      """ Sweeping to {} [{},{}] unique confidence scores"""
                      """""".format(
                        le, len(uniq_confs), uniq_confs[0], uniq_confs[-1]))

        for conf in uniq_confs:
            newsig = {}
            newsig_tem = {}
            while len(current_m) > 0 and current_m[-1].alignment != "MD" and \
                    conf_key_func(current_m[-1]) >= conf:
                if file_framedur_lookup != 0:
                    if not current_m[-1].video_file in newsig:
                        newsig[current_m[-1].video_file] = []
                    newsig[current_m[-1].video_file].append(current_m[-1])
                current_c.append(current_m.pop())
            while len(remaining_f) > 0 and \
                    conf_key_func(remaining_f[-1]) >= conf:
                if file_framedur_lookup != 0:
                    if not remaining_f[-1].video_file in newsig:
                        newsig[remaining_f[-1].video_file] = []
                    newsig[remaining_f[-1].video_file].append(remaining_f[-1])
                current_f.append(remaining_f.pop())
            if file_framedur_lookup != 0:
                if newsig != {}:
                    for key, value in newsig.items():
                        newsig_tem[key] = add_sys_sig(
                            sys_sig[key], [(ar.sys) for ar in newsig[key]])
                        sys_sig[key] = sys_sig[key] + newsig_tem[key]
                        sys_sig_add[key] = reduce(
                            add, [s[0] for s in newsig_tem[key]],
                            sys_sig_add[key])
                out_points.append((
                    conf, reduce(merge_dicts, [
                        m(current_c, current_m, current_f) for
                        m in measure_funcs], fa_func(
                            ref_sigs, sys_sig, sys_sig_add))))
            else:
                out_points.append((
                    conf, reduce(merge_dicts, [
                        m(current_c, current_m, current_f) for
                        m in measure_funcs], {})))
        return out_points
Esempio n. 15
0
def _bounding_box_to_signal(bounding_box):
    x, y, w, h = map(lambda e: bounding_box[e], ("x", "y", "w", "h"))
    return S({x: S({y: 1, y + h: 0}), x + w: S()})
Esempio n. 16
0
 def testSignalAdditionPass3(self):
     self.assertEqual(self.s1 + self.s5, S({0: 1, 60: 0}))
     self.assertEqual(self.s1 + self.s1, S({30: 2, 60: 0}))
     self.assertEqual(self.s1 + self.s6, S({30: 1, 100: 0}))
     self.assertEqual(self.s1 + self.s7, S({0: 1, 30: 2, 60: 1, 100: 0}))
Esempio n. 17
0
 def testSignalAdditionPass2(self):
     self.assertEqual(self.s1 + self.s2, S({0: 1, 10: 0, 30: 1, 60: 0}))
     self.assertEqual(self.s1 + self.s3, S({30: 2, 40: 1, 60: 0}))
     self.assertEqual(self.s1 + self.s4, S({30: 1, 80: 0}))
Esempio n. 18
0
 def testSignalEquivalence(self):
     self.assertEqual(self.se, self.se)
     self.assertEqual(self.s1, self.s1)
     self.assertEqual(S({30: 1, 60: 0}), self.s1)
Esempio n. 19
0
    def setUp(self):
        super(TestSparseSignal, self).setUp()

        self.se = S()
        self.s1 = S({30: 1, 60: 0})
        self.s2 = S({0: 1, 10: 0})
        self.s3 = S({30: 1, 40: 0})
        self.s4 = S({60: 1, 80: 0})
        self.s5 = S({0: 1, 30: 0})
        self.s6 = S({60: 1, 100: 0})
        self.s7 = S({0: 1, 100: 0})

        self.sb1 = S({0: 1, 30: 2, 60: 1, 100: 0})
        self.sb2 = S({30: 2, 40: 1, 60: 0})
        self.sb3 = S({30: 1, 60: 2, 100: 1, 130: 0})

        self.ss1 = S({0: 1, 30: 0, 60: 1, 100: 0})

        self.si1 = S({45: 1, 100: 0})

        self.sd1 = S({10: 1, 20: 0})
        self.sd2 = S({10.45: 1, 20: 0})
        self.sd3 = S({10.00: 1, 20.85: 0})
        self.sd4 = S({10.90: 1, 20.35: 0})
        self.sd5 = S({0.12: 1, 30.32: 0, 30.7: 1, 100.2: 0})
        self.sd6 = S({0.12: 1, 30.32: 2, 60.7: 1, 100.2: 0})

        self.sn1 = S({0: 1, 10: 1, 20: 0})

        self.sc1 = S({5: 1, 10: 0})
        self.sc2 = S({5: 1, 7:1, 10: 0})
        self.sc3 = S({0: 1, 10: 0})

        self.s2d_1 = S({10: S({10: 1, 20: 0}), 15: S(), 30: S({15: 1, 35: 0}), 40: S()})
        self.s2d_2 = S({10: S({15: 1, 25: 0}), 35: S()})

        self.s3d_1 = S({1: S({10: S({10: 1, 20: 0}), 20: S()}), 2: S({10: S({10: 1, 30: 0}), 30: S()}), 4: S()})
        self.s3d_2 = S({1: S({10: S({10: 1, 20: 0}), 20: S()}), 4: S()})

        self.s_iter1 = S({3: 1, 5: 2, 10: 0})

        self.s_iter2 = S({3: 1, 5: 0, 7: 1, 10: 0})
Esempio n. 20
0
 def __init__(self, bounding_box, conf, obj_type, obj_id):
     self.spatial_signal = _bounding_box_to_signal(
         bounding_box) if bounding_box else S()
     self.presenceConf = conf
     self.objectType = obj_type
     self.objectID = obj_id
Esempio n. 21
0
def _spatial_signal_accessor(localization, k):
    if k in localization:
        return localization.get(k).spatial_signal
    else:
        return S()
Esempio n. 22
0
def _temporal_signal_accessor(localization, k):
    #print 'localization:'
    #print localization
    return S(localization.get(k, {}))
def _object_congruence(r, s, obj_kernel_builder, ref_filter, sys_filter, cmiss,
                       cfa, target_rfas):
    ro, so = r.objects, s.objects

    # For N_MODE computation, localizations spanning multiple files
    # are treated independently
    total_c, total_m, total_f, total_r = [], [], [], []
    frame_alignment_records = []
    # We need to report out the ref filter localization for aggregate
    # PMiss@RFA measurements
    ref_filter_localization = {}
    for r, s, k in temporal_signal_pairs(r, s):
        local_so_localizations = map(lambda o: o.localization.get(k, S()), so)
        local_ro_localizations = map(lambda o: o.localization.get(k, S()), ro)

        sos_lookup = _object_signals_to_lookup(sys_filter(r, s),
                                               local_so_localizations)
        ros_lookup = _object_signals_to_lookup(ref_filter(r, s),
                                               local_ro_localizations)

        ref_filter_localization[k] = ref_filter(r, s)

        for frame in sos_lookup.viewkeys() | ros_lookup.viewkeys():
            sys = sos_lookup.get(frame, [])
            ref = ros_lookup.get(frame, [])

            c, m, f = perform_alignment(ref, sys, obj_kernel_builder(sys))
            total_c.extend(c)
            total_m.extend(m)
            total_f.extend(f)
            total_r.extend(ref)

            for ar in c + m + f:
                frame_alignment_records.append((frame, ar))

    num_miss = len(total_m)
    num_correct = len(total_c)

    ref_filter_area = sum([v.area() for v in ref_filter_localization.values()])

    def _conf_sweep_reducer(init, conf):
        mode_scores, det_points = init
        num_filtered_c = len(
            filter(lambda ar: ar.sys.presenceConf >= conf, total_c))
        num_filtered_fa = len(
            filter(lambda ar: ar.sys.presenceConf >= conf, total_f))
        num_miss_w_filtered_c = num_miss + num_correct - num_filtered_c
        mode_scores.append((conf,
                            mode(num_filtered_c, num_miss_w_filtered_c,
                                 num_filtered_fa, cmiss, cfa)))
        det_points.append((conf,
                           r_fa(num_filtered_c, num_miss_w_filtered_c,
                                num_filtered_fa, ref_filter_area),
                           p_miss(num_filtered_c, num_miss_w_filtered_c,
                                  num_filtered_fa)))

        return init

    mode_scores, det_points = reduce(
        _conf_sweep_reducer,
        sorted(list({ar.sys.presenceConf
                     for ar in total_c + total_f})), ([], []))

    min_mode = min(map(lambda x: x[1],
                       mode_scores)) if len(mode_scores) > 0 else None
    pmiss_at_rfa_measures = {
        "object-p_miss@{}rfa".format(target_rfa):
        p_miss_at_r_fa(det_points, target_rfa)
        for target_rfa in target_rfas
    }

    out_components = {
        "object_congruence": 1 - min_mode if min_mode is not None else None,
        "minMODE": min_mode,
        "MODE_records": mode_scores,
        "alignment_records": frame_alignment_records,
        "det_points": det_points,
        "ref_filter_localization": ref_filter_localization
    }

    return merge_dicts(out_components, pmiss_at_rfa_measures)
def _object_tracking_congruence(r, s, obj_kernel_builder, ref_filter,
                                sys_filter, object_types, cmiss, cfa, cid,
                                target_rfas):
    # If object_types provided as non-empty array, only consider objects included in object_types
    ro = r.objects if len(object_types) == 0 else filter(
        lambda o: o.objectType in object_types, r.objects)
    so = s.objects if len(object_types) == 0 else filter(
        lambda o: o.objectType in object_types, s.objects)

    # For N_MODE computation, localizations spanning multiple files
    # are treated independently
    total_c, total_m, total_f, total_r = [], [], [], []
    frame_alignment_records = []
    correct_frame_alignment_records = []
    # We need to report out the ref filter localization for aggregate
    # PMiss@RFA measurements
    ref_filter_localization = {}
    #    obj_align={}
    #    FirstRun=True
    for r, s, k in temporal_signal_pairs(r, s):
        local_so_localizations = map(lambda o: o.localization.get(k, S()), so)
        local_ro_localizations = map(lambda o: o.localization.get(k, S()), ro)

        sos_lookup = _object_signals_to_lookup(sys_filter(r, s),
                                               local_so_localizations)
        ros_lookup = _object_signals_to_lookup(ref_filter(r, s),
                                               local_ro_localizations)

        ref_filter_localization[k] = ref_filter(r, s)
        FirstRun = True
        obj_align = {}
        for frame in sos_lookup.viewkeys() | ros_lookup.viewkeys():
            sys = sos_lookup.get(frame, [])
            ref = ros_lookup.get(frame, [])

            c, m, f = perform_alignment(ref, sys, obj_kernel_builder(sys))
            #print "C: "
            #print c

            #print "C: "
            #print c
            #print "REFOBJECT ID?"
            #print c[0].ref.objectID
            #print "SYSOBJECT ID?"
            #print c[0].sys.objectID
            #print "FRAME: "
            #print frame
            #c.append(obj_switch)
            total_c.extend(c)
            total_m.extend(m)
            total_f.extend(f)
            total_r.extend(ref)

            for ar in c:
                correct_frame_alignment_records.append((frame, ar))
            for ar in c + m + f:
                frame_alignment_records.append((frame, ar))

        #print "correct_frame_alignment"
        #print correct_frame_alignment_records

    ref_filter_area = sum([v.area() for v in ref_filter_localization.values()])

    sweeper = build_sweeper(lambda r: r.sys.presenceConf, [
        build_rfa_metric(ref_filter_area),
        build_pmiss_metric(),
        build_mode_metric(cmiss, cfa),
        build_mote_metric(correct_frame_alignment_records,
                          lambda r: r.sys.presenceConf, cmiss, cfa, cid)
    ])
    sweep_recs = sweeper(total_c + total_m + total_f)

    # Filter out None mode scores (in the case of zero reference
    # objects)
    mode_scores = filter(lambda r: r[1] is not None,
                         flatten_sweeper_records(sweep_recs, ["mode"]))
    mote_scores = filter(lambda r: r[1] is not None,
                         flatten_sweeper_records(sweep_recs, ["mote"]))
    #   print "mote_scores"
    #   print mote_scores
    det_points = flatten_sweeper_records(sweep_recs, ["rfa", "p_miss"])

    min_mode = min(map(lambda x: x[1],
                       mode_scores)) if len(mode_scores) > 0 else None
    min_mote = min(map(lambda x: x[1],
                       mote_scores)) if len(mote_scores) > 0 else None

    pmiss_at_rfa_measures = get_points_along_confidence_curve(
        sweep_recs, "rfa", lambda r: r["rfa"], "object-p_miss",
        lambda r: r["p_miss"], target_rfas)

    out_components = {
        "object_congruence": 1 - min_mode if min_mode is not None else None,
        "minMODE": min_mode,
        "MODE_records": mode_scores,
        "object_tracking_congruence":
        min_mote if min_mote is not None else None,
        "minMOTE": min_mote,
        "MOTE_records": mote_scores,
        "alignment_records": frame_alignment_records,
        "det_points": det_points,
        "ref_filter_localization": ref_filter_localization
    }

    return merge_dicts(out_components, pmiss_at_rfa_measures)
Esempio n. 25
0
 def testNormalize(self):
     self.assertEqual(self.sn1.normalize(), S({0: 1, 20: 0}))