def test_single_camera_point_positions(self):
"""Point positions for a single camera case"""
num_cams = 1
# prepare MultimediaParams
cpar_file = b'testing_fodder/single_cam/parameters/ptv.par'
vpar_file = b'testing_fodder/single_cam/parameters/criteria.par'
cpar = ControlParams(num_cams)
cpar.read_control_par(cpar_file)
mult_params = cpar.get_multimedia_params()
vpar = VolumeParams()
vpar.read_volume_par(vpar_file)
ori_name = b'testing_fodder/single_cam/calibration/cam_1.tif.ori'
add_name = b'testing_fodder/single_cam/calibration/cam_1.tif.addpar'
calibs = []
# read calibration for each camera from files
new_cal = Calibration()
new_cal.from_file(ori_file=ori_name, add_file=add_name)
calibs.append(new_cal)
# 3d point
points = np.array([[1, 1, 0],
[-1, -1, 0]], dtype=float)
targs_plain = []
targs_jigged = []
jigg_amp = 0.4
new_plain_targ = image_coordinates(
points, calibs[0], mult_params)
targs_plain.append(new_plain_targ)
jigged_points = points - np.r_[0, jigg_amp, 0]
new_jigged_targs = image_coordinates(
jigged_points, calibs[0], mult_params)
targs_jigged.append(new_jigged_targs)
targs_plain = np.array(targs_plain).transpose(1,0,2)
targs_jigged = np.array(targs_jigged).transpose(1,0,2)
skew_dist_plain = point_positions(targs_plain, cpar, calibs, vpar)
skew_dist_jigged = point_positions(targs_jigged, cpar, calibs, vpar)
if np.any(np.linalg.norm(points - skew_dist_plain[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position.')
if np.any(np.linalg.norm(jigged_points - skew_dist_jigged[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position after jigging.')
def test_single_camera_point_positions(self):
"""Point positions for a single camera case"""
num_cams = 1
# prepare MultimediaParams
cpar_file = b'testing_fodder/single_cam/parameters/ptv.par'
vpar_file = b'testing_fodder/single_cam/parameters/criteria.par'
cpar = ControlParams(num_cams)
cpar.read_control_par(cpar_file)
mult_params = cpar.get_multimedia_params()
vpar = VolumeParams()
vpar.read_volume_par(vpar_file)
ori_name = b'testing_fodder/single_cam/calibration/cam_1.tif.ori'
add_name = b'testing_fodder/single_cam/calibration/cam_1.tif.addpar'
calibs = []
# read calibration for each camera from files
new_cal = Calibration()
new_cal.from_file(ori_file=ori_name, add_file=add_name)
calibs.append(new_cal)
# 3d point
points = np.array([[1, 1, 0], [-1, -1, 0]], dtype=float)
targs_plain = []
targs_jigged = []
jigg_amp = 0.4
new_plain_targ = image_coordinates(points, calibs[0], mult_params)
targs_plain.append(new_plain_targ)
jigged_points = points - np.r_[0, jigg_amp, 0]
new_jigged_targs = image_coordinates(jigged_points, calibs[0],
mult_params)
targs_jigged.append(new_jigged_targs)
targs_plain = np.array(targs_plain).transpose(1, 0, 2)
targs_jigged = np.array(targs_jigged).transpose(1, 0, 2)
skew_dist_plain = point_positions(targs_plain, cpar, calibs, vpar)
skew_dist_jigged = point_positions(targs_jigged, cpar, calibs, vpar)
if np.any(np.linalg.norm(points - skew_dist_plain[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position.')
if np.any(
np.linalg.norm(jigged_points -
skew_dist_jigged[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position after jigging.')
def py_determination_proc_c(n_cams, sorted_pos, sorted_corresp, corrected):
""" Returns 3d positions """
# Control parameters
cpar = ControlParams(n_cams)
cpar.read_control_par(b'parameters/ptv.par')
# Volume parameters
vpar = VolumeParams()
vpar.read_volume_par(b'parameters/criteria.par')
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)
# 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) < 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 in a temporary file
fname = b"".join([default_naming['corres'],b'.123456789']) # hard-coded frame number
with open(fname, 'w') as rt_is:
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)
def py_determination_proc_c(n_cams, sorted_pos, sorted_corresp, corrected):
""" Returns 3d positions """
# Control parameters
cpar = ControlParams(n_cams)
cpar.read_control_par('parameters/ptv.par')
# Volume parameters
vpar = VolumeParams()
vpar.read_volume_par('parameters/criteria.par')
cals = []
for i_cam in xrange(n_cams):
cal = Calibration()
tmp = cpar.get_cal_img_base_name(i_cam)
cal.from_file(tmp + '.ori', tmp + '.addpar')
cals.append(cal)
# 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) == 1: # single camera case
sorted_corresp = np.tile(sorted_corresp, (4, 1))
sorted_corresp[1:, :] = -1
# Save rt_is in a temporary file
frame = 123456789 # just a temporary workaround. todo: think how to write
with open(default_naming['corres'] + '.' + str(frame), 'w') as rt_is:
rt_is.write(str(pos.shape[0]) + '\n')
for pix, pt in enumerate(pos):
pt_args = (pix + 1, ) + tuple(pt) + tuple(sorted_corresp[:, pix])
rt_is.write("%4d %9.3f %9.3f %9.3f %4d %4d %4d %4d\n" % pt_args)
def test_point_positions(self):
"""Point positions"""
# prepare MultimediaParams
mult_params = self.control.get_multimedia_params()
mult_params.set_n1(1.)
mult_params.set_layers(np.array([1.]), np.array([1.]))
mult_params.set_n3(1.)
# 3d point
points = np.array([[17, 42, 0], [17, 42, 0]], dtype=float)
num_cams = 4
ori_tmpl = r'testing_fodder/calibration/sym_cam{cam_num}.tif.ori'
add_file = r'testing_fodder/calibration/cam1.tif.addpar'
calibs = []
targs_plain = []
targs_jigged = []
jigg_amp = 0.5
# read calibration for each camera from files
for cam in range(num_cams):
ori_name = ori_tmpl.format(cam_num=cam + 1)
new_cal = Calibration()
new_cal.from_file(ori_file=ori_name, add_file=add_file)
calibs.append(new_cal)
for cam_num, cam_cal in enumerate(calibs):
new_plain_targ = image_coordinates(
points, cam_cal, self.control.get_multimedia_params())
targs_plain.append(new_plain_targ)
if (cam_num % 2) == 0:
jigged_points = points - np.r_[0, jigg_amp, 0]
else:
jigged_points = points + np.r_[0, jigg_amp, 0]
new_jigged_targs = image_coordinates(
jigged_points, cam_cal, self.control.get_multimedia_params())
targs_jigged.append(new_jigged_targs)
targs_plain = np.array(targs_plain).transpose(1, 0, 2)
targs_jigged = np.array(targs_jigged).transpose(1, 0, 2)
skew_dist_plain = point_positions(targs_plain, self.control, calibs)
skew_dist_jigged = point_positions(targs_jigged, self.control, calibs)
if np.any(skew_dist_plain[1] > 1e-10):
self.fail(('skew distance of target#{targ_num} ' \
+ 'is more than allowed').format(
targ_num=np.nonzero(skew_dist_plain[1] > 1e-10)[0][0]))
if np.any(np.linalg.norm(points - skew_dist_plain[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position.')
if np.any(skew_dist_jigged[1] > 0.7):
self.fail(('skew distance of target#{targ_num} ' \
+ 'is more than allowed').format(
targ_num=np.nonzero(skew_dist_jigged[1] > 1e-10)[0][0]))
if np.any(np.linalg.norm(points - skew_dist_jigged[0], axis=1) > 0.1):
self.fail('Rays converge on wrong position after jigging.')
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()
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()
def test_point_positions(self):
"""Point positions"""
# prepare MultimediaParams
mult_params = self.control.get_multimedia_params()
mult_params.set_n1(1.)
mult_params.set_layers(np.array([1.]), np.array([1.]))
mult_params.set_n3(1.)
# 3d point
points = np.array([[17, 42, 0],
[17, 42, 0]], dtype=float)
num_cams = 4
ori_tmpl = r'testing_fodder/calibration/sym_cam{cam_num}.tif.ori'
add_file = r'testing_fodder/calibration/cam1.tif.addpar'
calibs = []
targs_plain = []
targs_jigged = []
jigg_amp = 0.5
# read calibration for each camera from files
for cam in range(num_cams):
ori_name = ori_tmpl.format(cam_num=cam + 1)
new_cal = Calibration()
new_cal.from_file(ori_file=ori_name, add_file=add_file)
calibs.append(new_cal)
for cam_num, cam_cal in enumerate(calibs):
new_plain_targ = image_coordinates(
points, cam_cal, self.control.get_multimedia_params())
targs_plain.append(new_plain_targ)
if (cam_num % 2) == 0:
jigged_points = points - np.r_[0, jigg_amp, 0]
else:
jigged_points = points + np.r_[0, jigg_amp, 0]
new_jigged_targs = image_coordinates(
jigged_points, cam_cal, self.control.get_multimedia_params())
targs_jigged.append(new_jigged_targs)
targs_plain = np.array(targs_plain).transpose(1,0,2)
targs_jigged = np.array(targs_jigged).transpose(1,0,2)
skew_dist_plain = point_positions(targs_plain, self.control, calibs)
skew_dist_jigged = point_positions(targs_jigged, self.control, calibs)
if np.any(skew_dist_plain[1] > 1e-10):
self.fail(('skew distance of target#{targ_num} ' \
+ 'is more than allowed').format(
targ_num=np.nonzero(skew_dist_plain[1] > 1e-10)[0][0]))
if np.any(np.linalg.norm(points - skew_dist_plain[0], axis=1) > 1e-6):
self.fail('Rays converge on wrong position.')
if np.any(skew_dist_jigged[1] > 0.7):
self.fail(('skew distance of target#{targ_num} ' \
+ 'is more than allowed').format(
targ_num=np.nonzero(skew_dist_jigged[1] > 1e-10)[0][0]))
if np.any(np.linalg.norm(points - skew_dist_jigged[0], axis=1) > 0.1):
self.fail('Rays converge on wrong position after jigging.')