示例#1
0
def py_detection_proc_c(list_of_images, cpar, tpar, cals):
    """ Detection of targets """

    detections, corrected = [], []
    for i_cam, img in enumerate(list_of_images):
        targs = target_recognition(img, tpar, i_cam, cpar)
        targs.sort_y()
        detections.append(targs)
        mc = MatchedCoords(targs, cpar, cals[i_cam])
        corrected.append(mc)

    return detections, corrected
示例#2
0
    def test_two_targets(self):
        img = np.array([[0, 0, 0, 0, 0], [0, 255, 0, 0, 0], [0, 0, 0, 0, 0],
                        [0, 0, 0, 251, 0], [0, 0, 0, 0, 0]],
                       dtype=np.uint8)

        cpar = ControlParams(4, image_size=(5, 5))
        tpar = TargetParams(gvthresh=[250, 100, 20, 20],
                            discont=5,
                            pixel_count_bounds=(1, 10),
                            min_sum_grey=12,
                            xsize_bounds=(1, 10),
                            ysize_bounds=(1, 10))

        targs = target_recognition(img, tpar, 0, cpar)

        self.assertEqual(len(targs), 2)
        self.assertEqual(targs[0].count_pixels(), (1, 1, 1))

        # Exclude the first target and try again:
        tpar.set_grey_thresholds([252, 100, 20, 20])
        targs = target_recognition(img, tpar, 0, cpar)

        self.assertEqual(len(targs), 1)
        self.assertEqual(targs[0].count_pixels(), (1, 1, 1))
示例#3
0
    def test_one_targets2(self):
        img = np.array(
            [[0, 0, 0, 0, 0], [0, 255, 250, 250, 0], [0, 251, 253, 251, 0],
             [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],
            dtype=np.uint8)

        cpar = ControlParams(4, image_size=(5, 5))
        tpar = TargetParams(gvthresh=[250, 100, 20, 20],
                            discont=5,
                            pixel_count_bounds=(1, 10),
                            min_sum_grey=12,
                            xsize_bounds=(1, 10),
                            ysize_bounds=(1, 10))

        targs = target_recognition(img, tpar, 0, cpar)
        self.assertEqual(len(targs), 1)
        self.assertEqual(targs[0].count_pixels(), (4, 3, 2))
示例#4
0
def py_detection_proc_c(list_of_images, cpar, tpar, cals):
    """ Detection of targets """

    pftVersionParams = par.PftVersionParams(path='./parameters')
    pftVersionParams.read()
    Existing_Target = np.bool(pftVersionParams.Existing_Target)

    detections, corrected = [], []
    for i_cam, img in enumerate(list_of_images):
        if Existing_Target:
            targs = read_targets(cpar.get_img_base_name(i_cam), 0)
        else:
            targs = target_recognition(img, tpar, i_cam, cpar)

        targs.sort_y()
        detections.append(targs)
        mc = MatchedCoords(targs, cpar, cals[i_cam])
        corrected.append(mc)

    return detections, corrected
示例#5
0
def py_sequence_loop(exp):
    """ Runs a sequence of detection, stereo-correspondence, determination and stores
        the data in the cam#.XXX_targets (rewritten) and rt_is.XXX files. Basically
        it is to run the batch as in pyptv_batch.py without tracking
    """
    n_cams, cpar, spar, vpar, tpar, cals = \
        exp.n_cams, exp.cpar, exp.spar, exp.vpar, exp.tpar, exp.cals

    pftVersionParams = par.PftVersionParams(path='./parameters')
    pftVersionParams.read()
    Existing_Target = np.bool(pftVersionParams.Existing_Target)

    # sequence loop for all frames
    for frame in range(spar.get_first(), spar.get_last() + 1):
        print("processing frame %d" % frame)

        detections = []
        corrected = []
        for i_cam in range(n_cams):
            if Existing_Target:
                targs = read_targets(spar.get_img_base_name(i_cam), frame)
            else:
                imname = spar.get_img_base_name(i_cam) + str(frame).encode()
                print(imname)
                if not os.path.exists(imname):
                    print(os.path.abspath(os.path.curdir))
                    print('{0} does not exist'.format(imname))

                img = imread(imname.decode())
                # time.sleep(.1) # I'm not sure we need it here
                hp = simple_highpass(img, cpar)
                targs = target_recognition(hp, tpar, i_cam, cpar)

            targs.sort_y()
            detections.append(targs)
            mc = MatchedCoords(targs, cpar, cals[i_cam])
            pos, pnr = mc.as_arrays()
            corrected.append(mc)

        #        if any([len(det) == 0 for det in detections]):
        #            return False

        # Corresp. + positions.
        sorted_pos, sorted_corresp, num_targs = correspondences(
            detections, corrected, cals, vpar, cpar)

        # Save targets only after they've been modified:
        for i_cam in range(n_cams):
            detections[i_cam].write(spar.get_img_base_name(i_cam), frame)


        print("Frame " + str(frame) + " had " \
              + repr([s.shape[1] for s in sorted_pos]) + " correspondences.")

        # Distinction between quad/trip irrelevant here.
        sorted_pos = np.concatenate(sorted_pos, axis=1)
        sorted_corresp = np.concatenate(sorted_corresp, axis=1)

        flat = np.array([corrected[i].get_by_pnrs(sorted_corresp[i]) \
                         for i in range(len(cals))])
        pos, rcm = point_positions(flat.transpose(1, 0, 2), cpar, cals, vpar)

        # if len(cals) == 1: # single camera case
        #     sorted_corresp = np.tile(sorted_corresp,(4,1))
        #     sorted_corresp[1:,:] = -1

        if len(cals) < 4:
            print_corresp = -1 * np.ones((4, sorted_corresp.shape[1]))
            print_corresp[:len(cals), :] = sorted_corresp
        else:
            print_corresp = sorted_corresp

        # Save rt_is
        print(default_naming['corres'])
        rt_is = open(default_naming['corres'] + b'.' + str(frame).encode(),
                     'w')
        rt_is.write(str(pos.shape[0]) + '\n')
        for pix, pt in enumerate(pos):
            pt_args = (pix + 1, ) + tuple(pt) + tuple(print_corresp[:, pix])
            rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
        rt_is.close()
示例#6
0
def run_batch(new_seq_first, new_seq_last):
    """ this file runs inside exp_path, so the other names are
    prescribed by the OpenPTV type of a folder:
        /parameters
        /img
        /cal
        /res
    """
    # read the number of cameras
    with open('parameters/ptv.par', 'r') as f:
        n_cams = int(f.readline())

    # Control parameters
    cpar = ControlParams(n_cams)
    cpar.read_control_par(b'parameters/ptv.par')

    # Sequence parameters
    spar = SequenceParams(num_cams=n_cams)
    spar.read_sequence_par(b'parameters/sequence.par', n_cams)
    spar.set_first(new_seq_first)
    spar.set_last(new_seq_last)

    # Volume parameters
    vpar = VolumeParams()
    vpar.read_volume_par(b'parameters/criteria.par')

    # Tracking parameters
    track_par = TrackingParams()
    track_par.read_track_par(b'parameters/track.par')

    # Target parameters
    tpar = TargetParams()
    tpar.read(b'parameters/targ_rec.par')

    #

    # Calibration parameters

    cals = []
    for i_cam in range(n_cams):
        cal = Calibration()
        tmp = cpar.get_cal_img_base_name(i_cam)
        cal.from_file(tmp + b'.ori', tmp + b'.addpar')
        cals.append(cal)

    # sequence loop for all frames
    for frame in range(new_seq_first, new_seq_last + 1):
        print("processing frame %d" % frame)

        detections = []
        corrected = []
        for i_cam in range(n_cams):
            imname = spar.get_img_base_name(i_cam) + str(frame)
            img = imread(imname)
            hp = simple_highpass(img, cpar)
            targs = target_recognition(hp, tpar, i_cam, cpar)
            print(targs)

            targs.sort_y()
            detections.append(targs)
            mc = MatchedCoords(targs, cpar, cals[i_cam])
            pos, pnr = mc.as_arrays()
            print(i_cam)
            corrected.append(mc)

        #        if any([len(det) == 0 for det in detections]):
        #            return False

        # Corresp. + positions.
        sorted_pos, sorted_corresp, num_targs = correspondences(
            detections, corrected, cals, vpar, cpar)

        # Save targets only after they've been modified:
        for i_cam in xrange(n_cams):
            detections[i_cam].write(spar.get_img_base_name(i_cam), frame)


        print("Frame " + str(frame) + " had " \
              + repr([s.shape[1] for s in sorted_pos]) + " correspondences.")

        # Distinction between quad/trip irrelevant here.
        sorted_pos = np.concatenate(sorted_pos, axis=1)
        sorted_corresp = np.concatenate(sorted_corresp, axis=1)

        flat = np.array([corrected[i].get_by_pnrs(sorted_corresp[i]) \
                         for i in xrange(len(cals))])
        pos, rcm = point_positions(flat.transpose(1, 0, 2), cpar, cals, vpar)

        if len(cals) < 4:
            print_corresp = -1 * np.ones((4, sorted_corresp.shape[1]))
            print_corresp[:len(cals), :] = sorted_corresp
        else:
            print_corresp = sorted_corresp

        # Save rt_is
        rt_is = open(default_naming['corres'] + '.' + str(frame), 'w')
        rt_is.write(str(pos.shape[0]) + '\n')
        for pix, pt in enumerate(pos):
            pt_args = (pix + 1, ) + tuple(pt) + tuple(print_corresp[:, pix])
            rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
        rt_is.close()
    # end of a sequence loop

    tracker = Tracker(cpar, vpar, track_par, spar, cals, default_naming)
    tracker.full_forward()