def index():
# Get scale and compute image width
scale, scale_options = common_args.get_scale(config,flask.request)
redis_tools.set_str(db,'scale', scale)
image_width, image_height = get_image_size(scale)
ip_iface_ext = redis_tools.get_str(db,'ip_iface_ext')
mjpeg_info_dict = redis_tools.get_dict(db,'mjpeg_info_dict')
mjpeg_info = sorted(mjpeg_info_dict.items(), cmp=mjpeg_info_cmp)
# Build dict of urls for single camera views
single_view_url = {}
for camera in mjpeg_info_dict:
single_view_url[camera] = flask.url_for('single_camera_view.page',camera=camera)
render_dict = {
'scale' : scale,
'scale_options' : scale_options,
'image_width' : image_width,
'image_height' : image_height,
'ip_iface_ext' : ip_iface_ext,
'mjpeg_info' : mjpeg_info,
'single_view_url' : single_view_url,
}
return flask.render_template('zoom_calibration.html',**render_dict)
def index():
if flask.g.sijax.is_sijax_request:
flask.g.sijax.register_callback('calibrate_button', calibrate_button_handler)
flask.g.sijax.register_callback('save_button', save_button_handler)
flask.g.sijax.register_callback('reset_button_ok', reset_button_ok_handler)
flask.g.sijax.register_callback('reset_button_cancel', reset_button_cancel_handler)
flask.g.sijax.register_callback('timer_update', timer_update_handler)
return flask.g.sijax.process_request()
else:
# Get scale and compute image width
scale, scale_options = common_args.get_scale(config,flask.request)
redis_tools.set_str(db,'scale', scale)
image_width, image_height = get_image_size(scale)
ip_iface_ext = redis_tools.get_str(db,'ip_iface_ext')
mjpeg_info = redis_tools.get_dict(db,'mjpeg_info_dict')
camera_pairs = redis_tools.get_dict(db,'camera_pairs_dict')
camera_pairs_mjpeg_info = get_camera_pairs_mjpeg_info(camera_pairs, mjpeg_info)
calibration_info = get_calibration_info()
render_dict = {
'scale': scale,
'scale_options': scale_options,
'image_width': image_width,
'image_height': image_height,
'ip_iface_ext': ip_iface_ext,
'camera_pairs': camera_pairs,
'camera_pairs_mjpeg_info': camera_pairs_mjpeg_info,
'calibration_info': calibration_info,
}
return flask.render_template('transform_2d_calibration.html',**render_dict)
def setup_redis_db():
# Create db and add empty camera assignment
db = redis.Redis('localhost',db=config.redis_db)
# Add mjpeg info dictionary
mjpeg_info_dict = mjpeg_servers.get_mjpeg_info_dict()
redis_tools.set_dict(db,'mjpeg_info_dict', mjpeg_info_dict)
# Add external network interface
machine_def = mct_introspection.get_machine_def()
ip_iface_ext = iface_tools.get_ip_addr(machine_def['mct_master']['iface-ext'])
redis_tools.set_str(db,'ip_iface_ext',ip_iface_ext)
# Add default scale for image view
scale_default = config.camera_view_table['scale_default']
redis_tools.set_str(db,'scale', scale_default)
return db
def setup_redis_db():
# Create db and add empty camera assignment
db = redis.Redis('localhost', db=config.redis_db)
# Add regions dictionary
regions_dict = file_tools.read_tracking_2d_regions()
redis_tools.set_dict(db, 'regions_dict', regions_dict)
# Add extra video dictionary
extra_video_dict = file_tools.read_logging_extra_video()
redis_tools.set_dict(db, 'extra_video_dict', extra_video_dict)
# Add mjpeg info dictionary
mjpeg_info_dict = mjpeg_servers.get_mjpeg_info_dict()
redis_tools.set_dict(db, 'mjpeg_info_dict', mjpeg_info_dict)
# Add external network interface
machine_def = mct_introspection.get_machine_def()
ip_iface_ext = iface_tools.get_ip_addr(
machine_def['mct_master']['iface-ext'])
redis_tools.set_str(db, 'ip_iface_ext', ip_iface_ext)
# Set operating mode
redis_tools.set_str(db, 'current_mode', 'preview')
## Get frame rates
frame_rate_dict = file_tools.read_frame_rates()
redis_tools.set_dict(db, 'frame_rate_dict', frame_rate_dict)
frame_rate = frame_rate_dict['tracking_2d']
# Get logging directory - add base path to directory, and create if it doesn't exist
logging_params_dict = file_tools.read_logging_params()
logging_params_dict['directory'] = os.path.join(
os.environ['HOME'], logging_params_dict['directory'])
if not os.path.exists(logging_params_dict['directory']):
os.mkdir(logging_params_dict['directory'])
redis_tools.set_dict(db, 'logging_params_dict', logging_params_dict)
# Get lighting params
mightex_params_dict = file_tools.read_mightex_params()
lighting_params_dict = mightex_to_lighting_params(mightex_params_dict)
redis_tools.set_dict(db, 'lighting_params_dict', lighting_params_dict)
return db
def setup_redis_db():
"""
Sets up the redis database for the camera assignemnt application
"""
# Create db and add empty camera assignment
db = redis.Redis('localhost', db=config.redis_db)
machine_def = mct_introspection.get_machine_def()
ip_iface_ext = iface_tools.get_ip_addr(
machine_def['mct_master']['iface-ext'])
redis_tools.set_str(db, 'ip_iface_ext', ip_iface_ext)
mjpeg_info_dict = mjpeg_servers.get_mjpeg_info_dict()
redis_tools.set_dict(db, 'mjpeg_info_dict', mjpeg_info_dict)
camera_assignment = create_empty_assignment(mjpeg_info_dict)
redis_tools.set_dict(db, 'camera_assignment', camera_assignment)
return db
def index():
if flask.g.sijax.is_sijax_request:
flask.g.sijax.register_callback('calibrate_button_onclick', calibrate_button_handler)
flask.g.sijax.register_callback('save_button_onclick', save_button_handler)
flask.g.sijax.register_callback('reset_button_ok', reset_button_ok_handler)
flask.g.sijax.register_callback('reset_button_cancel', reset_button_cancel_handler)
flask.g.sijax.register_callback('timer_update', timer_update_handler)
return flask.g.sijax.process_request()
else:
# Get scale and compute image width
scale, scale_options = common_args.get_scale(config,flask.request)
redis_tools.set_str(db,'scale', scale)
image_width, image_height = get_image_size(scale)
ip_iface_ext = redis_tools.get_str(db,'ip_iface_ext')
mjpeg_info_dict = redis_tools.get_dict(db,'mjpeg_info_dict')
mjpeg_info = sorted(mjpeg_info_dict.items(), cmp=mjpeg_info_cmp)
target_info = redis_tools.get_dict(db,'target_info')
# Get list of current camera calibration files
calibration_info = get_camera_calibration_info()
# Build dict of urls for single camera views
single_view_url = {}
for camera in mjpeg_info_dict:
single_view_url[camera] = flask.url_for('single_camera_view.page',camera=camera)
render_dict = {
'scale' : scale,
'scale_options' : scale_options,
'image_width' : image_width,
'image_height' : image_height,
'ip_iface_ext' : ip_iface_ext,
'mjpeg_info' : mjpeg_info,
'target_info' : target_info,
'calibration_info' : calibration_info,
'single_view_url' : single_view_url,
}
return flask.render_template('camera_calibration.html',**render_dict)
def setup_redis_db():
"""
Sets up the redis database for the camera assignemnt application
"""
# Create db and add empty camera assignment
db = redis.Redis('localhost',db=config.redis_db)
mjpeg_info_dict = mjpeg_servers.get_mjpeg_info_dict()
for camera, info in mjpeg_info_dict.iteritems():
info['image_topic'] = info['image_topic'].replace('image_raw','image_calibrator')
redis_tools.set_dict(db,'mjpeg_info_dict', mjpeg_info_dict)
machine_def = mct_introspection.get_machine_def()
ip_iface_ext = iface_tools.get_ip_addr(machine_def['mct_master']['iface-ext'])
redis_tools.set_str(db,'ip_iface_ext',ip_iface_ext)
scale_default = config.camera_view_table['scale_default']
redis_tools.set_str(db,'scale', scale_default)
target_info = file_tools.read_target_info(config.camera_calib_target_type)
redis_tools.set_dict(db, 'target_info', target_info)
return db
def mode_change_handler(obj_response, new_mode):
old_mode = redis_tools.get_str(db, 'current_mode')
new_mode = str(new_mode)
if old_mode == new_mode:
return
redis_tools.set_str(db, 'current_mode', new_mode)
frame_rate = redis_tools.get_dict(db, 'frame_rate_dict')['tracking_2d']
regions_dict = redis_tools.get_dict(db, 'regions_dict')
# Stop camera triggers
camera_trigger.stop()
time.sleep(0.5) # wait for all frames to pass throught the system
reset_rand_sync()
if old_mode == 'recording' or new_mode == 'recording':
# Find logging and avi recording commands
service_list = mct_introspection.get_services()
logging_nodes = get_logging_nodes(service_list)
recording_nodes = get_recording_nodes(service_list)
if (old_mode == 'recording') and (new_mode != 'recording'):
# Stop logging and recording
for node in logging_nodes:
tracking_pts_logger.stop_logging(node)
for node in recording_nodes:
avi_writer.stop_recording(node, 'dummy.avi', frame_rate)
if new_mode == 'recording':
# Create sub-directory for log files.
log_dir_base = redis_tools.get_dict(
db, 'logging_params_dict')['directory']
log_dir = os.path.join(log_dir_base,
datetime.datetime.now().isoformat())
os.mkdir(log_dir)
# Start loggers
for node in logging_nodes:
filename = '_'.join(node.split('/')[1:3])
filename = os.path.join(log_dir, '{0}.json'.format(filename))
tracking_pts_logger.start_logging(node, filename)
# Start avi recordings
for node in recording_nodes:
filename = '_'.join(node.split('/')[1:3])
filename = os.path.join(log_dir, '{0}.avi'.format(filename))
avi_writer.start_recording(node, filename, frame_rate)
if new_mode in ('preview', 'recording'):
regions_dict = redis_tools.get_dict(db, 'regions_dict')
# Reset frame drop correctors and restart camera triggers
frame_drop_corrector.reset_all()
frame_drop_watchdog.reset()
# Reset image_stitcher and three_point_tracker synchronizer for all tracking regions
for region in regions_dict:
image_stitcher.reset(region)
three_point_tracker_synchronizer.reset(region)
camera_trigger.start(frame_rate)
