def load_model(camera,
svgs=None,
keys=None,
step=None,
group_params=dict(),
station_calib=False,
camera_calib=False,
fixed=None):
# Gather motion control
motion_images, motion_controls, motion_cam_params = cg.camera_motion_matches(
camera, station_calib=station_calib, camera_calib=camera_calib)
# Gather svg control
svg_images, svg_controls, svg_cam_params = cg.camera_svg_controls(
camera,
keys=keys,
svgs=svgs,
correction=True,
station_calib=station_calib,
camera_calib=camera_calib,
step=step)
# Standardize image sizes
imgszs = np.unique([img.cam.imgsz for img in (motion_images + svg_images)],
axis=0)
if len(imgszs) > 1:
i_max = np.argmax(imgszs[:, 0])
print('Resizing images and controls to', imgszs[i_max])
for control in motion_controls + svg_controls:
control.resize(size=imgszs[i_max], force=True)
# Set new imgsz as original camera imgsz
for img in motion_images + svg_images:
img.cam.original_vector[6:8] = imgszs[i_max]
# Determine whether xyz can be optimized
stations = [cg.parse_image_path(img.path)['station'] for img in svg_images]
if fixed is None:
if len(stations) > 0 and (np.array(stations) == stations[0]).all():
fixed = cg.Stations()[stations[0]]['properties']['fixed']
else:
fixed = True
station = None if fixed else stations[0]
if station:
group_params = glimpse.helpers.merge_dicts(group_params,
dict(xyz=True))
model = glimpse.optimize.Cameras(
cams=[img.cam for img in motion_images + svg_images],
controls=motion_controls + svg_controls,
cam_params=motion_cam_params + svg_cam_params,
group_params=group_params)
return motion_images, svg_images, model, station
observer_json = glimpse.helpers.read_json('observers.json',
object_pairs_hook=collections.OrderedDict)
# ---- Load DEM interpolant ----
dem_interpolant = glimpse.helpers.read_pickle(dem_interpolant_path)
dem_padding = 200 # m
# ---- Track points ----
for i_obs in range(0, len(observer_json)):
# ---- Load observers ----
# observers
observers = []
for station, basenames in observer_json[i_obs].items():
meta = cg.parse_image_path(basenames[0], sequence=True)
service_calibration = cg.load_calibrations(
station_estimate=meta['station'], station=meta['station'],
camera=meta['camera'], merge=True, file_errors=False)
datetimes = cg.paths_to_datetimes(basenames)
# Use dummy Exif for speed
service_exif = glimpse.Exif(cg.find_image(basenames[0]))
images = []
for basename, t in zip(basenames, datetimes):
calibration = glimpse.helpers.merge_dicts(service_calibration,
cg.load_calibrations(image=basename, viewdir=basename, merge=True,
file_errors=False))
path = cg.find_image(basename)
image = glimpse.Image(path, cam=calibration, datetime=t, exif=service_exif)
images.append(image)
# NOTE: Determine sigma programmatically?
if n < min_images:
continue
basenames = [glimpse.helpers.strip_path(img.path)
for img in images[selected]]
temp_basenames[j][station] = basenames
observers += temp_basenames
# Remove small Observers
for i, obs in enumerate(observers):
n = len(obs)
if n < min_observers:
print('Dropped', i, '-', n, 'observers')
_ = observers.pop(i)
else:
paths = np.concatenate(tuple(obs.values()))
datetimes = [cg.parse_image_path(path)['datetime'] for path in paths]
dt = np.max(datetimes) - np.min(datetimes)
if dt < min_dt:
print('Dropped', i, '-', dt, 'span')
_ = observers.pop(i)
# Write to file
glimpse.helpers.write_json(observers, path='observers.json', indent=4,
flat_arrays=True)
# ---- Count dropped images ----
print('--- Image loss (final) ----')
station_paths = {station: [] for station in stations}
for obs in observers:
for station in obs:
# ---- Control synths (ideal camera) ----
for image in images:
print(image)
start = timeit.default_timer()
basename = os.path.join('svg-synth', image)
if os.path.isfile(basename + '-synth.JPG'):
continue
# Load image
img_path = cg.find_image(image)
cam_args = cg.load_calibrations(image,
station_estimate=True, station=True, merge=True, file_errors=False)
img = glimpse.Image(img_path, cam=cam_args)
img.cam.resize(img_size)
# Select nearest dem and ortho
img_date = datetime.datetime.strptime(cg.parse_image_path(image)['date_str'], '%Y%m%d')
i_dem = np.argmin(np.abs(np.asarray(dem_dates) - img_date))
i_ortho = np.argmin(np.abs(np.asarray(ortho_dates) - img_date))
dem_path = dem_paths[i_dem]
ortho_path = ortho_paths[i_ortho]
# Load raster metadata
dem_grid = glimpse.Grid.read(dem_path, d=grid_size)
ortho_grid = glimpse.Grid.read(ortho_path, d=grid_size)
# Intersect bounding boxes
cam_box = img.cam.viewbox(50e3)[[0, 1, 3, 4]]
box = glimpse.helpers.intersect_boxes(np.row_stack((
cam_box, dem_grid.box2d, ortho_grid.box2d)))
# Read dem and ortho
dem = glimpse.Raster.read(dem_path, xlim=box[0::2], ylim=box[1::2], d=grid_size)
dem.crop(zlim=(0.1, np.inf))
radius = circle_radius.get(image, circle_radius_default)
'nikon-d200-08-24': keys - {'coast'},
'nikon-d200-13-20': keys - {'coast', 'moraines'},
'nikon-d200-14-20': keys - {'coast', 'moraines'},
'canon-40d-01': keys - {'terminus', 'coast'}
}
step = 20 # pixels
suffixes = ['', '-calib', '-ideal']
stations = (
'AK01', 'AK01b', 'AK03', 'AK03b', 'AK09', 'AK09b', 'AK10', 'AK10b',
'AK12', 'AKJNC', 'AKST03A', 'AKST03B', 'CG04', 'CG05', 'CG06')
# ---- Orient anchor images ----
paths = glob.glob(os.path.join('svg', '*.svg'))
paths += glob.glob(os.path.join('svg-synth', '*.svg'))
metas = [cg.parse_image_path(path) for path in paths]
selected = [meta['station'] in stations for meta in metas]
paths = [path for path, meta in zip(paths, metas)
if meta['station'] in stations]
for path in paths:
meta = cg.parse_image_path(path, sequence=True)
svg_keys = camera_keys.get(meta['camera'], keys)
for suffix in suffixes:
if not os.path.isfile(os.path.join(
'cameras', meta['camera'] + suffix + '.json')):
continue
basename = os.path.join('images', meta['basename'] + suffix)
if os.path.isfile(basename + '.json'):
continue
print(meta['basename'] + suffix)
not os.path.isfile(basename + suffix + '-synth.JPG')
for suffix in suffixes
]
if not any(np.logical_and(need, missing)):
continue
# Load base image
img_path = cg.find_image(image)
calibration = cg.load_calibrations(image=image, merge=True)
img = glimpse.Image(img_path, cam=calibration)
path = basename + '.JPG'
if not os.path.isfile(path):
bw = glimpse.helpers.rgb_to_gray(img.read()).astype(np.uint8)
img.write(path=path, I=clahe.apply(bw))
# Select nearest dem and ortho
img_date = datetime.datetime.strptime(
cg.parse_image_path(image)['date_str'], '%Y%m%d')
i_dem = np.argmin(np.abs(np.asarray(dem_dates) - img_date))
i_ortho = np.argmin(np.abs(np.asarray(ortho_dates) - img_date))
dem_path = dem_paths[i_dem]
ortho_path = ortho_paths[i_ortho]
# Load raster metadata
dem_grid = glimpse.Grid.read(dem_path, d=grid_size)
ortho_grid = glimpse.Grid.read(ortho_path, d=grid_size)
# Intersect bounding boxes
cam_box = img.cam.viewbox(50e3)[[0, 1, 3, 4]]
box = glimpse.helpers.intersect_boxes(
np.row_stack((cam_box, dem_grid.box2d, ortho_grid.box2d)))
# Read dem and ortho
dem = glimpse.Raster.read(dem_path,
xlim=box[0::2],
ylim=box[1::2],