TinghuiWang / pyActLearn

    return start_mismatch, stop_mismatch

def _get_timeliness_measures(classes, truth, prediction, time_list):

    num_classes = len(classes)

    start_mismatch = [list([]) for i in range(num_classes)]

    stop_mismatch = [list([]) for i in range(num_classes)]

    # Processing segmentation first!

    for j in range(num_classes):

        pred_segs = []

        truth_segs = []

        prev_pred = False

        prev_truth = False

        tseg_start = 0

        tseg_stop = 0

        pseg_start = 0

        pseg_stop = 0

        for i in range(truth.shape[0]):

            cur_truth = (int(truth[i]) == j)

            cur_pred = (int(prediction[i]) == j)

            # Truth segments

            if cur_truth != prev_truth:

                if cur_truth:

                    tseg_start = i

                elif tseg_stop != 0:

                    truth_segs.append((tseg_start, tseg_stop))

            tseg_stop = i

            # Prediction segments

            if cur_pred != prev_pred:

                if cur_pred:

                    pseg_start = i

                elif pseg_stop != 0:

                    pred_segs.append((pseg_start, pseg_stop))

            pseg_stop = i

            prev_truth = cur_truth

            prev_pred = cur_pred

        # Add compensated segments to predictions egments

        for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):

            ps = _find_overlap_seg(pred_segs, tseg_start)

            if ps == -1:

                # potential underfill or deletion

                ps = _find_seg_start_within(pred_segs, tseg_start, tseg_stop)

                if ps != -1:

                    pseg_start = pred_segs[ps][0]

                    offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()

                    if tseg_start != pseg_start and abs(offset) < 18000:

                        start_mismatch[j].append(offset)

            else:

                pseg_start = pred_segs[ps][0]

                # Check the end of previous truth

                if ts > 1 and truth_segs[ts-1][1] >= pseg_start:

                    continue

                else:

                    offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()

                    if tseg_start != pseg_start and abs(offset) < 18000:

                        # Calculate overfill

                        start_mismatch[j].append((time_list[tseg_start] - time_list[pseg_start]).total_seconds())

        for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):

            ps = _find_overlap_seg(pred_segs, tseg_stop)

            if ps == -1:

                # potential underfill or deletion

                ps = _find_seg_end_within(pred_segs, tseg_start, tseg_stop)

                if ps != -1:

                    pseg_stop = pred_segs[ps][1]

                    offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()

                    if tseg_stop != pseg_stop and abs(offset) < 18000:

                        stop_mismatch[j].append(offset)

            else:

                pseg_stop = pred_segs[ps][1]

                # Check the end of previous truth

                if ts < len(truth_segs) - 1 and truth_segs[ts-1][0] <= pseg_stop:

                    continue

                else:

                    offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()

                    if tseg_stop != pseg_stop and abs(offset) < 18000:

                        # Calculate overfill

                        stop_mismatch[j].append(offset)

        # print("class: %d" % j)

        # print("pred_segs: %d %s" % (len(pred_segs), str(pred_segs)))

        # print("truth_segs: %d %s" % (len(truth_segs), str(truth_segs)))

        # print("start_mismatch: %s" % start_mismatch)

        # print("stop_mismatch: %s" % stop_mismatch)

    return start_mismatch, stop_mismatch

def _get_timeliness_measures_depricated(classes, truth, prediction, truth_scoring, prediction_scoring, time_list):

    return found_seg_id

def _get_timeoffset_measures(classes, truth, prediction, time_list):

    num_classes = len(classes)

    start_mismatch = [list([]) for i in range(num_classes)]

    stop_mismatch = [list([]) for i in range(num_classes)]

    # Processing segmentation first!

    for j in range(num_classes):

        pred_segs = []

        truth_segs = []

        prev_pred = False

        prev_truth = False

        tseg_start = 0

        tseg_stop = 0

        pseg_start = 0

        pseg_stop = 0

        for i in range(truth.shape[0]):

            cur_truth = (int(truth[i]) == j)

            cur_pred = (int(prediction[i]) == j)

            # Truth segments

            if cur_truth != prev_truth:

                if cur_truth:

                    tseg_start = i

                elif tseg_stop != 0:

                    truth_segs.append((tseg_start, tseg_stop))

            tseg_stop = i

            # Prediction segments

            if cur_pred != prev_pred:

                if cur_pred:

                    pseg_start = i

                elif pseg_stop != 0:

                    pred_segs.append((pseg_start, pseg_stop))

            pseg_stop = i

            prev_truth = cur_truth

            prev_pred = cur_pred

        # Add compensated segments to predictions egments

        for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):

            ps = _find_overlap_seg(pred_segs, tseg_start)

            if ps == -1:

                # potential underfill or deletion

                ps = _find_seg_start_within(pred_segs, tseg_start, tseg_stop)

                if ps != -1:

                    pseg_start = pred_segs[ps][0]

                    offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()

                    if abs(offset) < 18000:

                        start_mismatch[j].append(offset)

            else:

                pseg_start = pred_segs[ps][0]

                # Check the end of previous truth

                if ts > 1 and truth_segs[ts-1][1] >= pseg_start:

                    continue

                else:

                    offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()

                    if abs(offset) < 18000:

                        # Calculate overfill

                        start_mismatch[j].append((time_list[tseg_start] - time_list[pseg_start]).total_seconds())

        for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):

            ps = _find_overlap_seg(pred_segs, tseg_stop)

            if ps == -1:

                # potential underfill or deletion

                ps = _find_seg_end_within(pred_segs, tseg_start, tseg_stop)

                if ps != -1:

                    pseg_stop = pred_segs[ps][1]

                    offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()

                    if tseg_stop != pseg_stop and abs(offset) < 18000:

                        stop_mismatch[j].append(offset)

            else:

                pseg_stop = pred_segs[ps][1]

                # Check the end of previous truth

                if ts < len(truth_segs) - 1 and truth_segs[ts-1][0] <= pseg_stop:

                    continue

                else:

                    offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()

                    if abs(offset) < 18000:

                        # Calculate overfill

                        stop_mismatch[j].append(offset)

        # print("class: %d" % j)

        # print("pred_segs: %d %s" % (len(pred_segs), str(pred_segs)))

        # print("truth_segs: %d %s" % (len(truth_segs), str(truth_segs)))

        # print("start_mismatch: %s" % start_mismatch)

        # print("stop_mismatch: %s" % stop_mismatch)

    return start_mismatch, stop_mismatch

def _get_timeliness_measures(classes, truth, prediction, time_list):