#!/usr/bin/env python3
#
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (C) 2019, Raspberry Pi (Trading) Limited
#
# ctt.py - camera tuning tool
import os
import sys
from ctt_image_load import *
from ctt_ccm import *
from ctt_awb import *
from ctt_alsc import *
from ctt_lux import *
from ctt_noise import *
from ctt_geq import *
from ctt_pretty_print_json import *
import random
import json
import re
"""
This file houses the camera object, which is used to perform the calibrations.
The camera object houses all the calibration images as attributes in two lists:
- imgs (macbeth charts)
- imgs_alsc (alsc correction images)
Various calibrations are methods of the camera object, and the output is stored
in a dictionary called self.json.
Once all the caibration has been completed, the Camera.json is written into a
json file.
The camera object initialises its json dictionary by reading from a pre-written
blank json file. This has been done to avoid reproducing the entire json file
in the code here, thereby avoiding unecessary clutter.
"""
"""
Get the colour and lux values from the strings of each inidvidual image
"""
def get_col_lux(string):
"""
Extract colour and lux values from filename
"""
col = re.search(r'([0-9]+)[kK](\.(jpg|jpeg|brcm|dng)|_.*\.(jpg|jpeg|brcm|dng))$', string)
lux = re.search(r'([0-9]+)[lL](\.(jpg|jpeg|brcm|dng)|_.*\.(jpg|jpeg|brcm|dng))$', string)
try:
col = col.group(1)
except AttributeError:
"""
Catch error if images labelled incorrectly and pass reasonable defaults
"""
return None, None
try:
lux = lux.group(1)
except AttributeError:
"""
Catch error if images labelled incorrectly and pass reasonable defaults
Still returns colour if that has been found.
"""
return col, None
return int(col), int(lux)
"""
Camera object that is the backbone of the tuning tool.
Input is the desired path of the output json.
"""
class Camera:
def __init__(self, jfile):
self.path = os.path.dirname(os.path.expanduser(__file__)) + '/'
if self.path == '/':
self.path = ''
self.imgs = []
self.imgs_alsc = []
self.log = 'Log created : ' + time.asctime(time.localtime(time.time()))
self.log_separator = '\n'+'-'*70+'\n'
self.jf = jfile
"""
initial json dict populated by uncalibrated values
"""
self.json = {
"rpi.black_level": {
"black_level": 4096
},
"rpi.dpc": {
},
"rpi.lux": {
"reference_shutter_speed": 10000,
"reference_gain": 1,
"reference_aperture": 1.0
},
"rpi.noise": {
},
"rpi.geq": {
},
"rpi.sdn": {
},
"rpi.awb": {
"priors": [
{"lux": 0, "prior": [2000, 1.0, 3000, 0.0, 13000, 0.0]},
{"lux": 800, "prior": [2000, 0.0, 6000, 2.0, 13000, 2.0]},
{"lux": 1500, "prior": [2000, 0.0, 4000, 1.0, 6000, 6.0, 6500, 7.0, 7000, 1.0, 13000, 1.0]}
],
"modes": {
"auto": {"lo": 2500, "hi": 8000},
"incandescent": {"lo": 2500, "hi": 3000},
"tungsten": {"lo": 3000, "hi": 3500},
"fluorescent": {"lo": 4000, "hi": 4700},
"indoor": {"lo": 3000, "hi": 5000},
"daylight": {"lo": 5500, "hi": 6500},
"cloudy": {"lo": 7000, "hi": 8600}
},
"bayes": 1
},
"rpi.agc": {
"metering_modes": {
"centre-weighted": {
"weights": [3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0]
},
"spot": {
"weights": [2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
},
"matrix": {
"weights": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
}
},
"exposure_modes": {
"normal": {
"shutter": [100, 10000, 30000, 60000, 120000],
"gain": [1.0, 2.0, 4.0, 6.0, 6.0]
},
"short": {
"shutter": [100, 5000, 10000, 20000, 120000],
"gain": [1.0, 2.0, 4.0, 6.0, 6.0]
}
},
"constraint_modes": {
"normal": [
{"bound": "LOWER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.5, 1000, 0.5]}
],
"highlight": [
{"bound": "LOWER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.5, 1000, 0.5]},
{"bound": "UPPER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.8, 1000, 0.8]}
]
},
"y_target": [0, 0.16, 1000, 0.165, 10000, 0.17]
},
"rpi.alsc": {
'omega': 1.3,
'n_iter': 100,
'luminance_strength': 0.7,
},
"rpi.contrast": {
"ce_enable": 1,
"gamma_curve": [
0, 0,
1024, 5040,
2048, 9338,
3072, 12356,
4096, 15312,
5120, 18051,
6144, 20790,
7168, 23193,
8192, 25744,
9216, 27942,
10240, 30035,
11264, 32005,
12288, 33975,
13312, 35815,
14336, 37600,
15360, 39168,
16384, 40642,
18432, 43379,
20480, 45749,
22528, 47753,
24576, 49621,
26624, 51253,
28672, 52698,
30720, 53796,
32768, 54876,
36864, 57012,
40960, 58656,
45056, 59954,
49152, 61183,
53248, 62355,
57344, 63419,
61440, 64476,
65535, 65535
]
},
"rpi.ccm": {
},
"rpi.sharpen": {
}
}
"""
Perform colour correction calibrations by comparing macbeth patch colours
to standard macbeth chart colours.
"""
def ccm_cal(self, do_alsc_colour):
if 'rpi.ccm' in self.disable:
return 1
print('\nStarting CCM calibration')
self.log_new_sec('CCM')
"""
if image is greyscale then CCm makes no sense
"""
if self.grey:
print('\nERROR: Can\'t do CCM on greyscale image!')
self.log += '\nERROR: Cannot perform CCM calibration '
self.log += 'on greyscale image!\nCCM aborted!'
del self.json['rpi.ccm']
return 0
a = time.time()
"""
Check if alsc tables have been generated, if not then do ccm without
alsc
"""
if ("rpi.alsc" not in self.disable) and do_alsc_colour:
"""
case where ALSC colour has been done, so no errors should be
expected...
"""
try:
cal_cr_list = self.json['rpi.alsc']['calibrations_Cr']
cal_cb_list = self.json['rpi.alsc']['calibrations_Cb']
self.log += '\nALSC tables found successfully'
except KeyError:
cal_cr_list, cal_cb_list = None, None
print('WARNING! No ALSC tables found for CCM!')
print('Performing CCM calibrations without ALSC correction...')
self.log += '\nWARNING: No ALSC tables found.\nCCM calibration '
self.log += 'performed without ALSC correction...'
else:
"""
case where config options result in CCM done without ALSC colour tables
"""
cal_cr_list, cal_cb_list = None, None
self.log += '\nWARNING: No ALSC tables found.\nCCM calibration '
self.log += 'performed without ALSC correction...'
"""
Do CCM calibration
"""
try:
ccms = ccm(self, cal_cr_list, cal_cb_list)
except ArithmeticError:
print('ERROR: Matrix is singular!\nTake new pictures and try again...')
self.log += '\nERROR: Singular matrix encountered during fit!'
self.log += '\nCCM aborted!'
return 1
"""
Write output to json
"""
self.json['rpi.ccm']['ccms'] = ccms
self.log += '\nCCM calibration written to json file'
print('Finished CCM calibration')
"""
Auto white balance calibration produces a colour curve for
various colour temperatures, as well as providing a maximum 'wiggle room'
distance from this curve (transverse_neg/pos).
"""
def awb_cal(self, greyworld, do_alsc_colour):
if 'rpi.awb' in self.disable:
return 1
print('\nStarting AWB calibration')
self.log_new_sec('AWB')
"""
if image is greyscale then AWB makes no sense
"""
if self.grey:
print('\nERROR: Can\'t do AWB on greyscale image!')
self.log += '\nERROR: Cannot perform AWB calibration '
self.log += 'on greyscale image!\nAWB aborted!'
del self.json['rpi.awb']
return 0
"""
optional set greyworld (e.g. for noir cameras)
"""
if greyworld:
self.json['rpi.awb']['bayes'] = 0
self.log += '\nGreyworld set'
"""
Check if alsc tables have been generated, if not then do awb without
alsc correction
"""
if ("rpi.alsc" not in self.disable) and do_alsc_colour:
try:
cal_cr_list = self.json['rpi.alsc']['calibrations_Cr']
cal_cb_list = self.json['rpi.alsc']['calibrations_Cb']
self.log += '\nALSC tables found successfully'
except KeyError:
cal_cr_list, cal_cb_list = None, None
print('ERROR, no ALSC calibrations found for AWB')
print('Performing AWB without ALSC tables')
self.log += '\nWARNING: No ALSC tables found.\nAWB calibration '
self.log += 'performed without ALSC correction...'
else:
cal_cr_list, cal_cb_list = None, None
self.log += '\nWARNING: No ALSC tables found.\nAWB calibration '
self.log += 'performed without ALSC correction...'
"""
call calibration function
"""
plot = "rpi.awb" in self.plot
awb_out = awb(self, cal_cr_list, cal_cb_list, plot)
ct_curve, transverse_neg, transverse_pos = awb_out
"""
write output to json
"""
self.json['rpi.awb']['ct_curve'] = ct_curve
self.json['rpi.awb']['sensitivity_r'] = 1.0
self.json['rpi.awb']['sensitivity_b'] = 1.0
self.json['rpi.awb']['transverse_pos'] = transverse_pos
self.json['rpi.awb']['transverse_neg'] = transverse_neg
self.log += '\nAWB calibration written to json file'
print('Finished AWB calibration')
"""
Auto lens shading correction completely mitigates the effects of lens shading for ech
colour channel seperately, and then partially corrects for vignetting.
The extent of the correction depends on the 'luminance_strength' parameter.
"""
def alsc_cal(self, luminance_strength, do_alsc_colour):
if 'rpi.alsc' in self.disable:
return 1
print('\nStarting ALSC calibration')
self.log_new_sec('ALSC')
"""
check if alsc images have been taken
"""
if len(self.imgs_alsc) == 0:
print('\nError:\nNo alsc calibration images found')
self.log += '\nERROR: No ALSC calibration images found!'
self.log += '\nALSC calibration aborted!'
return 1
self.json['rpi.alsc']['luminance_strength'] = luminance_strength
if self.grey and do_alsc_colour:
print('Greyscale camera so only luminance_lut calculated')
do_alsc_colour = False
self.log += '\nWARNING: ALSC colour correction cannot be done on '
self.log += 'greyscale image!\nALSC colour corrections forced off!'
"""
call calibration function
"""
plot = "rpi.alsc" in self.plot
alsc_out = alsc_all(self, do_alsc_colour, plot)
cal_cr_list, cal_cb_list, luminance_lut, av_corn = alsc_out
"""
write ouput to json and finish if not do_alsc_colour
"""
if not do_alsc_colour:
self.json['rpi.alsc']['luminance_lut'] = luminance_lut
self.json['rpi.alsc']['n_iter'] = 0
self.log += '\nALSC calibrations written to json file'
self.log += '\nNo colour calibrations performed'
print('Finished ALSC calibrations')
return 1
self.json['rpi.alsc']['calibrations_Cr'] = cal_cr_list
self.json['rpi.alsc']['calibrations_Cb'] = cal_cb_list
self.json['rpi.alsc']['luminance_lut'] = luminance_lut
self.log += '\nALSC colour and luminance tables written to json file'
"""
The sigmas determine the strength of the adaptive algorithm, that
cleans up any lens shading that has slipped through the alsc. These are
determined by measuring a 'worst-case' difference between two alsc tables
that are adjacent in colour space. If, however, only one colour
temperature has been provided, then this difference can not be computed
as only one table is available.
To determine the sigmas you would have to estimate the error of an alsc
table with only the image it was taken on as a check. To avoid circularity,
dfault exaggerated sigmas are used, which can result in too much alsc and
is therefore not advised.
In general, just take another alsc picture at another colour temperature!
"""
if len(self.imgs_alsc) == 1:
self.json['rpi.alsc']['sigma'] = 0.005
self.json['rpi.alsc']['sigma_Cb'] = 0.005
print('\nWarning:\nOnly one alsc calibration found'
'\nStandard sigmas used for adaptive algorithm.')
print('Finished ALSC calibrations')
self.log += '\nWARNING: Only one colour temperature found in '
self.log += 'calibration images.\nStandard sigmas used for adaptive '
self.log += 'algorithm!'
return 1
"""
obtain worst-case scenario residual sigmas
"""
sigma_r, sigma_b = get_sigma(self, cal_cr_list, cal_cb_list)
"""
write output to json
"""
self.json['rpi.alsc']['sigma'] = np.round(sigma_r, 5)
self.json['rpi.alsc']['sigma_Cb'] = np.round(sigma_b, 5)
self.log += '\nCalibrated sigmas written to json file'
print('Finished ALSC calibrations')
"""
Green equalisation fixes problems caused by discrepancies in green
channels. This is done by measuring the effect on macbeth chart patches,
which ideally would have the same green values throughout.
An upper bound linear model is fit, fixing a threshold for the green
differences that are corrected.
"""
def geq_cal(self):
if 'rpi.geq' in self.disable:
return 1
print('\nStarting GEQ calibrations')
self.log_new_sec('GEQ')
"""
perform calibration
"""
plot = 'rpi.geq' in self.plot
slope, offset = geq_fit(self, plot)
"""
write output to json
"""
self.json['rpi.geq']['offset'] = offset
self.json['rpi.geq']['slope'] = slope
self.log += '\nGEQ calibrations written to json file'
print('Finished GEQ calibrations')
"""
Lux calibrations allow the lux level of a scene to be estimated by a ratio
calculation. Lux values are used in the pipeline for algorithms such as AGC
and AWB
"""
def lux_cal(self):
if 'rpi.lux' in self.disable:
return 1
print('\nStarting LUX calibrations')
self.log_new_sec('LUX')
"""
The lux calibration is done on a single image. For best effects, the
image with lux level closest to 1000 is chosen.
"""
luxes = [Img.lux for Img in self.imgs]
argmax = luxes.index(min(luxes, key=lambda l: abs(1000-l)))
Img = self.imgs[argmax]
self.log += '\nLux found closest to 1000: {} lx'.format(Img.lux)
self.log += '\nImage used: ' + Img.name
if Img.lux < 50:
self.log += '\nWARNING: Low lux could cause inaccurate calibrations!'
"""
do calibration
"""
lux_out, shutter_speed, gain = lux(self, Img)
"""
write output to json
"""
self.json['rpi.lux']['reference_shutter_speed'] = shutter_speed
self.json['rpi.lux']['reference_gain'] = gain
self.json['rpi.lux']['reference_lux'] = Img.lux
self.json['rpi.lux']['reference_Y'] = lux_out
self.log += '\nLUX calibrations written to json file'
print('Finished LUX calibrations')
"""
Noise alibration attempts to describe the noise profile of the sensor. The
calibration is run on macbeth images and the final output is taken as the average
"""
def noise_cal(self):
if 'rpi.noise' in self.disable:
return 1
print('\nStarting NOISE calibrations')
self.log_new_sec('NOISE')
"""
run calibration on all images and sort by slope.
"""
plot = "rpi.noise" in self.plot
noise_out = sorted([noise(self, Img, plot) for Img in self.imgs], key=lambda x: x[0])
self.log += '\nFinished processing images'
"""
take the average of the interquartile
"""
length = len(noise_out)
noise_out = np.mean(noise_out[length//4:1+3*length//4], axis=0)
self.log += '\nAverage noise profile: constant = {} '.format(int(noise_out[1]))
self.log += 'slope = {:.3f}'.format(noise_out[0])
"""
write to json
"""
self.json['rpi.noise']['reference_constant'] = int(noise_out[1])
self.json['rpi.noise']['reference_slope'] = round(noise_out[0], 3)
self.log += '\nNOISE calibrations written to json'
print('Finished NOISE calibrations')
"""
Removes json entries that are turned off
"""
def json_remove(self, disable):
self.log_new_sec('Disabling Options', cal=False)
if len(self.disable) == 0:
self.log += '\nNothing disabled!'
return 1
for key in disable:
try:
del self.json[key]
self.log += '\nDisabled: ' + key
except KeyError:
self.log += '\nERROR: ' + key + ' not found!'
"""
writes the json dictionary to the raw json file then make pretty
"""
def write_json(self):
"""
Write json dictionary to file
"""
jstring = json.dumps(self.json, sort_keys=False)
"""
make it pretty :)
"""
pretty_print_json(jstring, self.jf)
"""
add a new section to the log file
"""
def log_new_sec(self, section, cal=True):
self.log += '\n'+self.log_separator
self.log += section
if cal:
self.log += ' Calibration'
self.log += self.log_separator
"""
write script arguments to log file
"""
def log_user_input(self, json_output, directory, config, log_output):
self.log_new_sec('User Arguments', cal=False)
self.log += '\nJson file output: ' + json_output
self.log += '\nCalibration images directory: ' + directory
if config is None:
self.log += '\nNo configuration file input... using default options'
elif config is False:
self.log += '\nWARNING: Invalid configuration file path...'
self.log += ' using default options'
elif config is True:
self.log += '\nWARNING: Invalid syntax in configuration file...'
self.log += ' using default options'
else:
self.log += '\nConfiguration file: ' + config
if log_output is None:
self.log += '\nNo log file path input... using default: ctt_log.txt'
else:
self.log += '\nLog file output: ' + log_output
# if log_output
"""
write log file
"""
def write_log(self, filename):
if filename is None:
filename = 'ctt_log.txt'
self.log += '\n' + self.log_separator
with open(filename, 'w') as logfile:
logfile.write(self.log)
"""
Add all images from directory, pass into relevant list of images and
extrace lux and temperature values.
"""
def add_imgs(self, directory, mac_config, blacklevel=-1):
self.log_new_sec('Image Loading', cal=False)
img_suc_msg = 'Image loaded successfully!'
print('\n\nLoading images from '+directory)
self.log += '\nDirectory: ' + directory
"""
get list of files
"""
filename_list = get_photos(directory)
print("Files found: {}".format(len(filename_list)))
self.log += '\nFiles found: {}'.format(len(filename_list))
"""
iterate over files
"""
filename_list.sort()
for filename in filename_list:
address = directory + filename
print('\nLoading image: '+filename)
self.log += '\n\nImage: ' + filename
"""
obtain colour and lux value
"""
col, lux = get_col_lux(filename)
"""
Check if image is an alsc calibration image
"""
if 'alsc' in filename:
Img = load_image(self, address, mac=False)
self.log += '\nIdentified as an ALSC image'
"""
check if imagae data has been successfully unpacked
"""
if Img == 0:
print('\nDISCARDED')
self.log += '\nImage discarded!'
continue
"""
check that image colour temperature has been successfuly obtained
"""
elif col is not None:
"""
if successful, append to list and continue to next image
"""
Img.col = col
Img.name = filename
self.log += '\nColour temperature: {} K'.format(col)
self.imgs_alsc.append(Img)
if blacklevel != -1:
Img.blacklevel_16 = blacklevel
print(img_suc_msg)
continue
else:
print('Error! No colour temperature found!')
self.log += '\nWARNING: Error reading colour temperature'
self.log += '\nImage discarded!'
print('DISCARDED')
else:
self.log += '\nIdentified as macbeth chart image'
"""
if image isn't an alsc correction then it must have a lux and a
colour temperature value to be useful
"""
if lux is None:
print('DISCARDED')
self.log += '\nWARNING: Error reading lux value'
self.log += '\nImage discarded!'
continue
Img = load_image(self, address, mac_config)
"""
check that image data has been successfuly unpacked
"""
if Img == 0:
print('DISCARDED')
self.log += '\nImage discarded!'
continue
else:
"""
if successful, append to list and continue to next image
"""
Img.col, Img.lux = col, lux
Img.name = filename
self.log += '\nColour temperature: {} K'.format(col)
self.log += '\nLux value: {} lx'.format(lux)
if blacklevel != -1:
Img.blacklevel_16 = blacklevel
print(img_suc_msg)
self.imgs.append(Img)
print('\nFinished loading images')
"""
Check that usable images have been found
Possible errors include:
- no macbeth chart
- incorrect filename/extension
- images from different cameras
"""
def check_imgs(self):
self.log += '\n\nImages found:'
self.log += '\nMacbeth : {}'.format(len(self.imgs))
self.log += '\nALSC : {} '.format(len(self.imgs_alsc))
self.log += '\n\nCamera metadata'
"""
check usable images found
"""
if len(self.imgs) == 0:
print('\nERROR: No usable macbeth chart images found')
self.log += '\nERROR: No usable macbeth chart images found'
return 0
"""
Double check that every image has come from the same camera...
"""
all_imgs = self.imgs + self.imgs_alsc
camNames = list(set([Img.camName for Img in all_imgs]))
patterns = list(set([Img.pattern for Img in all_imgs]))
sigbitss = list(set([Img.sigbits for Img in all_imgs]))
blacklevels = list(set([Img.blacklevel_16 for Img in all_imgs]))
sizes = list(set([(Img.w, Img.h) for Img in all_imgs]))
if len(camNames) == 1 and len(patterns) == 1 and len(sigbitss) == 1 and \
len(blacklevels) == 1 and len(sizes) == 1:
self.grey = (patterns[0] == 128)
self.blacklevel_16 = blacklevels[0]
self.log += '\nName: {}'.format(camNames[0])
self.log += '\nBayer pattern case: {}'.format(patterns[0])
if self.grey:
self.log += '\nGreyscale camera identified'
self.log += '\nSignificant bits: {}'.format(sigbitss[0])
self.log += '\nBlacklevel: {}'.format(blacklevels[0])
self.log += '\nImage size: w = {} h = {}'.format(sizes[0][0], sizes[0][1])
return 1
else:
print('\nERROR: Images from different cameras')
self.log += '\nERROR: Images are from different cameras'
return 0
def run_ctt(json_output, directory, config, log_output):
"""
check input files are jsons
"""
if json_output[-5:] != '.json':
raise ArgError('\n\nError: Output must be a json file!')
if config is not None:
"""
check if config file is actually a json
"""
if config[-5:] != '.json':
raise ArgError('\n\nError: Config file must be a json file!')
"""
read configurations
"""
try:
with open(config, 'r') as config_json:
configs = json.load(config_json)
except FileNotFoundError:
configs = {}
config = False
except json.decoder.JSONDecodeError:
configs = {}
config = True
else:
configs = {}
"""
load configurations from config file, if not given then set default
"""
disable = get_config(configs, "disable", [], 'list')
plot = get_config(configs, "plot", [], 'list')
awb_d = get_config(configs, "awb", {}, 'dict')
greyworld = get_config(awb_d, "greyworld", 0, 'bool')
alsc_d = get_config(configs, "alsc", {}, 'dict')
do_alsc_colour = get_config(alsc_d, "do_alsc_colour", 1, 'bool')
luminance_strength = get_config(alsc_d, "luminance_strength", 0.5, 'num')
blacklevel = get_config(configs, "blacklevel", -1, 'num')
macbeth_d = get_config(configs, "macbeth", {}, 'dict')
mac_small = get_config(macbeth_d, "small", 0, 'bool')
mac_show = get_config(macbeth_d, "show", 0, 'bool')
mac_config = (mac_small, mac_show)
if blacklevel < -1 or blacklevel >= 2**16:
print('\nInvalid blacklevel, defaulted to 64')
blacklevel = -1
if luminance_strength < 0 or luminance_strength > 1:
print('\nInvalid luminance_strength strength, defaulted to 0.5')
luminance_strength = 0.5
"""
sanitise directory path
"""
if directory[-1] != '/':
directory += '/'
"""
initialise tuning tool and load images
"""
try:
Cam = Camera(json_output)
Cam.log_user_input(json_output, directory, config, log_output)
Cam.disable = disable
Cam.plot = plot
Cam.add_imgs(directory, mac_config, blacklevel)
except FileNotFoundError:
raise ArgError('\n\nError: Input image directory not found!')
"""
preform calibrations as long as check_imgs returns True
If alsc is activated then it must be done before awb and ccm since the alsc
tables are used in awb and ccm calibrations
ccm also technically does an awb but it measures this from the macbeth
chart in the image rather than using calibration data
"""
if Cam.check_imgs():
Cam.json['rpi.black_level']['black_level'] = Cam.blacklevel_16
Cam.json_remove(disable)
print('\nSTARTING CALIBRATIONS')
Cam.alsc_cal(luminance_strength, do_alsc_colour)
Cam.geq_cal()
Cam.lux_cal()
Cam.noise_cal()
Cam.awb_cal(greyworld, do_alsc_colour)
Cam.ccm_cal(do_alsc_colour)
print('\nFINISHED CALIBRATIONS')
Cam.write_json()
Cam.write_log(log_output)
print('\nCalibrations written to: '+json_output)
if log_output is None:
log_output = 'ctt_log.txt'
print('Log file written to: '+log_output)
pass
else:
Cam.write_log(log_output)
if __name__ == '__main__':
"""
initialise calibration
"""
if len(sys.argv) == 1:
print("""
Pisp Camera Tuning Tool version 1.0
Required Arguments:
'-i' : Calibration image directory.
'-o' : Name of output json file.
Optional Arguments:
'-c' : Config file for the CTT. If not passed, default parameters used.
'-l' : Name of output log file. If not passed, 'ctt_log.txt' used.
""")
quit(0)
else:
"""
parse input arguments
"""
json_output, directory, config, log_output = parse_input()
run_ctt(json_output, directory, config, log_output)
2' href='#n832'>832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* cam - Options parsing
*/
#include <assert.h>
#include <getopt.h>
#include <iomanip>
#include <iostream>
#include <string.h>
#include <vector>
#include "options.h"
/**
* \enum OptionArgument
* \brief Indicate if an option takes an argument
*
* \var OptionArgument::ArgumentNone
* \brief The option doesn't accept any argument
*
* \var OptionArgument::ArgumentRequired
* \brief The option requires an argument
*
* \var OptionArgument::ArgumentOptional
* \brief The option accepts an optional argument
*/
/**
* \enum OptionType
* \brief The type of argument for an option
*
* \var OptionType::OptionNone
* \brief No argument type, used for options that take no argument
*
* \var OptionType::OptionInteger
* \brief Integer argument type, with an optional base prefix (`0` for base 8,
* `0x` for base 16, none for base 10)
*
* \var OptionType::OptionString
* \brief String argument
*
* \var OptionType::OptionKeyValue
* \brief key=value list argument
*/
/* -----------------------------------------------------------------------------
* Option
*/
/**
* \struct Option
* \brief Store metadata about an option
*
* \var Option::opt
* \brief The option identifier
*
* \var Option::type
* \brief The type of the option argument
*
* \var Option::name
* \brief The option name
*
* \var Option::argument
* \brief Whether the option accepts an optional argument, a mandatory
* argument, or no argument at all
*
* \var Option::argumentName
* \brief The argument name used in the help text
*
* \var Option::help
* \brief The help text (may be a multi-line string)
*
* \var Option::keyValueParser
* \brief For options of type OptionType::OptionKeyValue, the key-value parser
* to parse the argument
*
* \var Option::isArray
* \brief Whether the option can appear once or multiple times
*
* \var Option::parent
* \brief The parent option
*
* \var Option::children
* \brief List of child options, storing all options whose parent is this option
*
* \fn Option::hasShortOption()
* \brief Tell if the option has a short option specifier (e.g. `-f`)
* \return True if the option has a short option specifier, false otherwise
*
* \fn Option::hasLongOption()
* \brief Tell if the option has a long option specifier (e.g. `--foo`)
* \return True if the option has a long option specifier, false otherwise
*/
struct Option {
int opt;
OptionType type;
const char *name;
OptionArgument argument;
const char *argumentName;
const char *help;
KeyValueParser *keyValueParser;
bool isArray;
Option *parent;
std::list<Option> children;
bool hasShortOption() const { return isalnum(opt); }
bool hasLongOption() const { return name != nullptr; }
const char *typeName() const;
std::string optionName() const;
};
/**
* \brief Retrieve a string describing the option type
* \return A string describing the option type
*/
const char *Option::typeName() const
{
switch (type) {
case OptionNone:
return "none";
case OptionInteger:
return "integer";
case OptionString:
return "string";
case OptionKeyValue:
return "key=value";
}
return "unknown";
}
/**
* \brief Retrieve a string describing the option name, with leading dashes
* \return A string describing the option name, as a long option identifier
* (double dash) if the option has a name, or a short option identifier (single
* dash) otherwise
*/
std::string Option::optionName() const
{
if (name)
return "--" + std::string(name);
else
return "-" + std::string(1, opt);
}
/* -----------------------------------------------------------------------------
* OptionBase<T>
*/
/**
* \class template<typename T> OptionBase
* \brief Container to store the values of parsed options
* \tparam T The type through which options are identified
*
* The OptionsBase class is generated by a parser (either OptionsParser or
* KeyValueParser) when parsing options. It stores values for all the options
* found, and exposes accessor functions to retrieve them. The options are
* accessed through an identifier to type \a T, which is an int referencing an
* Option::opt for OptionsParser, or a std::string referencing an Option::name
* for KeyValueParser.
*/
/**
* \fn OptionsBase::OptionsBase()
* \brief Construct an OptionsBase instance
*
* The constructed instance is initially invalid, and will be populated by the
* options parser.
*/
/**
* \brief Tell if the stored options list is empty
* \return True if the container is empty, false otherwise
*/
template<typename T>
bool OptionsBase<T>::empty() const
{
return values_.empty();
}
/**
* \brief Tell if the options parsing completed successfully
* \return True if the container is returned after successfully parsing
* options, false if it is returned after an error was detected during parsing
*/
template<typename T>
bool OptionsBase<T>::valid() const
{
return valid_;
}
/**
* \brief Tell if the option \a opt is specified
* \param[in] opt The option to search for
* \return True if the \a opt option is set, false otherwise
*/
template<typename T>
bool OptionsBase<T>::isSet(const T &opt) const
{
return values_.find(opt) != values_.end();
}
/**
* \brief Retrieve the value of option \a opt
* \param[in] opt The option to retrieve
* \return The value of option \a opt if found, an empty OptionValue otherwise
*/
template<typename T>
const OptionValue &OptionsBase<T>::operator[](const T &opt) const
{
static const OptionValue empty;
auto it = values_.find(opt);
if (it != values_.end())
return it->second;
return empty;
}
/**
* \brief Mark the container as invalid
*
* This function can be used in a key-value parser's override of the
* KeyValueParser::parse() function to mark the returned options as invalid if
* a validation error occurs.
*/
template<typename T>
void OptionsBase<T>::invalidate()
{
valid_ = false;
}
template<typename T>
bool OptionsBase<T>::parseValue(const T &opt, const Option &option,
const char *arg)
{
OptionValue value;
switch (option.type) {
case OptionNone:
break;
case OptionInteger:
unsigned int integer;
if (arg) {
char *endptr;
integer = strtoul(arg, &endptr, 0);
if (*endptr != '\0')
return false;
} else {
integer = 0;
}
value = OptionValue(integer);
break;
case OptionString:
value = OptionValue(arg ? arg : "");
break;
case OptionKeyValue:
KeyValueParser *kvParser = option.keyValueParser;
KeyValueParser::Options keyValues = kvParser->parse(arg);
if (!keyValues.valid())
return false;
value = OptionValue(keyValues);
break;
}
if (option.isArray)
values_[opt].addValue(value);
else
values_[opt] = value;
return true;
}
template class OptionsBase<int>;
template class OptionsBase<std::string>;
/* -----------------------------------------------------------------------------
* KeyValueParser
*/
/**
* \class KeyValueParser
* \brief A specialized parser for list of key-value pairs
*
* The KeyValueParser is an options parser for comma-separated lists of
* `key=value` pairs. The supported keys are added to the parser with
* addOption(). A given key can only appear once in the parsed list.
*
* Instances of this class can be passed to the OptionsParser::addOption()
* function to create options that take key-value pairs as an option argument.
* Specialized versions of the key-value parser can be created by inheriting
* from this class, to pre-build the options list in the constructor, and to add
* custom validation by overriding the parse() function.
*/
/**
* \class KeyValueParser::Options
* \brief An option list generated by the key-value parser
*
* This is a specialization of OptionsBase with the option reference type set to
* std::string.
*/
KeyValueParser::KeyValueParser() = default;
KeyValueParser::~KeyValueParser() = default;
/**
* \brief Add a supported option to the parser
* \param[in] name The option name, corresponding to the key name in the
* key=value pair. The name shall be unique.
* \param[in] type The type of the value in the key=value pair
* \param[in] help The help text
* \param[in] argument Whether the value is optional, mandatory or not allowed.
* Shall be ArgumentNone if \a type is OptionNone.
*
* \sa OptionsParser
*
* \return True if the option was added successfully, false if an error
* occurred.
*/
bool KeyValueParser::addOption(const char *name, OptionType type,
const char *help, OptionArgument argument)
{
if (!name)
return false;
if (!help || help[0] == '\0')
return false;
if (argument != ArgumentNone && type == OptionNone)
return false;
/* Reject duplicate options. */
if (optionsMap_.find(name) != optionsMap_.end())
return false;
optionsMap_[name] = Option({ 0, type, name, argument, nullptr,
help, nullptr, false, nullptr, {} });
return true;
}
/**
* \brief Parse a string containing a list of key-value pairs
* \param[in] arguments The key-value pairs string to parse
*
* If a parsing error occurs, the parsing stops and the function returns an
* invalid container. The container is populated with the options successfully
* parsed so far.
*
* \return A valid container with the list of parsed options on success, or an
* invalid container otherwise
*/
KeyValueParser::Options KeyValueParser::parse(const char *arguments)
{
Options options;
for (const char *pair = arguments; *arguments != '\0'; pair = arguments) {
const char *comma = strchrnul(arguments, ',');
size_t len = comma - pair;
/* Skip over the comma. */
arguments = *comma == ',' ? comma + 1 : comma;
/* Skip to the next pair if the pair is empty. */
if (!len)
continue;
std::string key;
std::string value;
const char *separator = static_cast<const char *>(memchr(pair, '=', len));
if (!separator) {
key = std::string(pair, len);
value = "";
} else {
key = std::string(pair, separator - pair);
value = std::string(separator + 1, comma - separator - 1);
}
/* The key is mandatory, the value might be optional. */
if (key.empty())
continue;
if (optionsMap_.find(key) == optionsMap_.end()) {
std::cerr << "Invalid option " << key << std::endl;
return options;
}
OptionArgument arg = optionsMap_[key].argument;
if (value.empty() && arg == ArgumentRequired) {
std::cerr << "Option " << key << " requires an argument"
<< std::endl;
return options;
} else if (!value.empty() && arg == ArgumentNone) {
std::cerr << "Option " << key << " takes no argument"
<< std::endl;
return options;
}
const Option &option = optionsMap_[key];
if (!options.parseValue(key, option, value.c_str())) {
std::cerr << "Failed to parse '" << value << "' as "
<< option.typeName() << " for option " << key
<< std::endl;
return options;
}
}
options.valid_ = true;
return options;
}
unsigned int KeyValueParser::maxOptionLength() const
{
unsigned int maxLength = 0;
for (auto const &iter : optionsMap_) {
const Option &option = iter.second;
unsigned int length = 10 + strlen(option.name);
if (option.argument != ArgumentNone)
length += 1 + strlen(option.typeName());
if (option.argument == ArgumentOptional)
length += 2;
if (length > maxLength)
maxLength = length;
}
return maxLength;
}
void KeyValueParser::usage(int indent)
{
for (auto const &iter : optionsMap_) {
const Option &option = iter.second;
std::string argument = std::string(" ") + option.name;
if (option.argument != ArgumentNone) {
if (option.argument == ArgumentOptional)
argument += "[=";
else
argument += "=";
argument += option.typeName();
if (option.argument == ArgumentOptional)
argument += "]";
}
std::cerr << std::setw(indent) << argument;
for (const char *help = option.help, *end = help; end;) {
end = strchr(help, '\n');
if (end) {
std::cerr << std::string(help, end - help + 1);
std::cerr << std::setw(indent) << " ";
help = end + 1;
} else {
std::cerr << help << std::endl;
}
}
}
}
/* -----------------------------------------------------------------------------
* OptionValue
*/
/**
* \class OptionValue
* \brief Container to store the value of an option
*
* The OptionValue class is a variant-type container to store the value of an
* option. It supports empty values, integers, strings, key-value lists, as well
* as arrays of those types. For array values, all array elements shall have the
* same type.
*
* OptionValue instances are organized in a tree-based structure that matches
* the parent-child relationship of the options added to the parser. Children
* are retrieved with the children() function, and are stored as an
* OptionsBase<int>.
*/
/**
* \enum OptionValue::ValueType
* \brief The option value type
*
* \var OptionValue::ValueType::ValueNone
* \brief Empty value
*
* \var OptionValue::ValueType::ValueInteger
* \brief Integer value (int)
*
* \var OptionValue::ValueType::ValueString
* \brief String value (std::string)
*
* \var OptionValue::ValueType::ValueKeyValue
* \brief Key-value list value (KeyValueParser::Options)
*
* \var OptionValue::ValueType::ValueArray
* \brief Array value
*/
/**
* \brief Construct an empty OptionValue instance
*
* The value type is set to ValueType::ValueNone.
*/
OptionValue::OptionValue()
: type_(ValueNone), integer_(0)
{
}
/**
* \brief Construct an integer OptionValue instance
* \param[in] value The integer value
*
* The value type is set to ValueType::ValueInteger.
*/
OptionValue::OptionValue(int value)
: type_(ValueInteger), integer_(value)
{
}
/**
* \brief Construct a string OptionValue instance
* \param[in] value The string value
*
* The value type is set to ValueType::ValueString.
*/
OptionValue::OptionValue(const char *value)
: type_(ValueString), integer_(0), string_(value)
{
}
/**
* \brief Construct a string OptionValue instance
* \param[in] value The string value
*
* The value type is set to ValueType::ValueString.
*/
OptionValue::OptionValue(const std::string &value)
: type_(ValueString), integer_(0), string_(value)
{
}
/**
* \brief Construct a key-value OptionValue instance
* \param[in] value The key-value list
*
* The value type is set to ValueType::ValueKeyValue.
*/
OptionValue::OptionValue(const KeyValueParser::Options &value)
: type_(ValueKeyValue), integer_(0), keyValues_(value)
{
}
/**
* \brief Add an entry to an array value
* \param[in] value The entry value
*
* This function can only be called if the OptionValue type is
* ValueType::ValueNone or ValueType::ValueArray. Upon return, the type will be
* set to ValueType::ValueArray.
*/
void OptionValue::addValue(const OptionValue &value)
{
assert(type_ == ValueNone || type_ == ValueArray);
type_ = ValueArray;
array_.push_back(value);
}
/**
* \fn OptionValue::type()
* \brief Retrieve the value type
* \return The value type
*/
/**
* \fn OptionValue::empty()
* \brief Check if the value is empty
* \return True if the value is empty (type set to ValueType::ValueNone), or
* false otherwise
*/
/**
* \brief Cast the value to an int
* \return The option value as an int, or 0 if the value type isn't
* ValueType::ValueInteger
*/
OptionValue::operator int() const
{
return toInteger();
}
/**
* \brief Cast the value to a std::string
* \return The option value as an std::string, or an empty string if the value
* type isn't ValueType::ValueString
*/
OptionValue::operator std::string() const
{
return toString();
}
/**
* \brief Retrieve the value as an int
* \return The option value as an int, or 0 if the value type isn't
* ValueType::ValueInteger
*/
int OptionValue::toInteger() const
{
if (type_ != ValueInteger)
return 0;
return integer_;
}
/**
* \brief Retrieve the value as a std::string
* \return The option value as a std::string, or an empty string if the value
* type isn't ValueType::ValueString
*/
std::string OptionValue::toString() const
{
if (type_ != ValueString)
return std::string();
return string_;
}
/**
* \brief Retrieve the value as a key-value list
*
* The behaviour is undefined if the value type isn't ValueType::ValueKeyValue.
*
* \return The option value as a KeyValueParser::Options
*/
const KeyValueParser::Options &OptionValue::toKeyValues() const
{
assert(type_ == ValueKeyValue);
return keyValues_;
}
/**
* \brief Retrieve the value as an array
*
* The behaviour is undefined if the value type isn't ValueType::ValueArray.
*
* \return The option value as a std::vector of OptionValue
*/
const std::vector<OptionValue> &OptionValue::toArray() const
{
assert(type_ == ValueArray);
return array_;
}
/**
* \brief Retrieve the list of child values
* \return The list of child values
*/
const OptionsParser::Options &OptionValue::children() const
{
return children_;
}
/* -----------------------------------------------------------------------------
* OptionsParser
*/
/**
* \class OptionsParser
* \brief A command line options parser
*
* The OptionsParser class is an easy to use options parser for POSIX-style
* command line options. Supports short (e.g. `-f`) and long (e.g. `--foo`)
* options, optional and mandatory arguments, automatic parsing arguments for
* integer types and comma-separated list of key=value pairs, and multi-value
* arguments. It handles help text generation automatically.
*
* An OptionsParser instance is initialized by adding supported options with
* addOption(). Options are specified by an identifier and a name. If the
* identifier is an alphanumeric character, it will be used by the parser as a
* short option identifier (e.g. `-f`). The name, if specified, will be used as
* a long option identifier (e.g. `--foo`). It should not include the double
* dashes. The name is optional if the option identifier is an alphanumeric
* character and mandatory otherwise.
*
* An option has a mandatory help text, which is used to print the full options
* list with the usage() function. The help text may be a multi-line string.
* Correct indentation of the help text is handled automatically.
*
* Options accept arguments when created with OptionArgument::ArgumentRequired
* or OptionArgument::ArgumentOptional. If the argument is required, it can be
* specified as a positional argument after the option (e.g. `-f bar`,
* `--foo bar`), collated with the short option (e.g. `-fbar`) or separated from
* the long option by an equal sign (e.g. `--foo=bar`'). When the argument is
* optional, it must be collated with the short option or separated from the
* long option by an equal sign.
*
* If an option has a required or optional argument, an argument name must be
* set when adding the option. The argument name is used in the help text as a
* place holder for an argument value. For instance, a `--write` option that
* takes a file name as an argument could set the argument name to `filename`,
* and the help text would display `--write filename`. This is only used to
* clarify the help text and has no effect on option parsing.
*
* The option type tells the parser how to process the argument. Arguments for
* string options (OptionType::OptionString) are stored as-is without any
* processing. Arguments for integer options (OptionType::OptionInteger) are
* converted to an integer value, using an optional base prefix (`0` for base 8,
* `0x` for base 16, none for base 10). Arguments for key-value options are
* parsed by a KeyValueParser given to addOption().
*
* By default, a given option can appear once only in the parsed command line.
* If the option is created as an array option, the parser will accept multiple
* instances of the option. The order in which identical options are specified
* is preserved in the values of an array option.
*
* After preparing the parser, it can be used any number of times to parse
* command line options with the parse() function. The function returns an
* Options instance that stores the values for the parsed options. The
* Options::isSet() function can be used to test if an option has been found,
* and is the only way to access options that take no argument (specified by
* OptionType::OptionNone and OptionArgument::ArgumentNone). For options that
* accept an argument, the option value can be access by Options::operator[]()
* using the option identifier as the key. The order in which different options
* are specified on the command line isn't preserved.
*
* Options can be created with parent-child relationships to organize them as a
* tree instead of a flat list. When parsing a command line, the child options
* are considered related to the parent option that precedes them. This is
* useful when the parent is an array option. The Options values list generated
* by the parser then turns into a tree, which each parent value storing the
* values of child options that follow that instance of the parent option.
* For instance, with a `capture` option specified as a child of a `camera`
* array option, parsing the command line
*
* `--camera 1 --capture=10 --camera 2 --capture=20`
*
* will return an Options instance containing a single OptionValue instance of
* array type, for the `camera` option. The OptionValue will contain two
* entries, with the first entry containing the integer value 1 and the second
* entry the integer value 2. Each of those entries will in turn store an
* Options instance that contains the respective children. The first entry will
* store in its children a `capture` option of value 10, and the second entry a
* `capture` option of value 20.
*
* The command line
*
* `--capture=10 --camera 1`
*
* would result in a parsing error, as the `capture` option has no preceding
* `camera` option on the command line.
*/
/**
* \class OptionsParser::Options
* \brief An option list generated by the options parser
*
* This is a specialization of OptionsBase with the option reference type set to
* int.
*/
OptionsParser::OptionsParser() = default;
OptionsParser::~OptionsParser() = default;
/**
* \brief Add an option to the parser
* \param[in] opt The option identifier
* \param[in] type The type of the option argument
* \param[in] help The help text (may be a multi-line string)
* \param[in] name The option name
* \param[in] argument Whether the option accepts an optional argument, a
* mandatory argument, or no argument at all
* \param[in] argumentName The argument name used in the help text
* \param[in] array Whether the option can appear once or multiple times
* \param[in] parent The identifier of the parent option (optional)
*
* \return True if the option was added successfully, false if an error
* occurred.
*/
bool OptionsParser::addOption(int opt, OptionType type, const char *help,
const char *name, OptionArgument argument,
const char *argumentName, bool array, int parent)
{
/*
* Options must have at least a short or long name, and a text message.
* If an argument is accepted, it must be described by argumentName.
*/
if (!isalnum(opt) && !name)
return false;
if (!help || help[0] == '\0')
return false;
if (argument != ArgumentNone && !argumentName)
return false;
/* Reject duplicate options. */
if (optionsMap_.find(opt) != optionsMap_.end())
return false;
/*
* If a parent is specified, create the option as a child of its parent.
* Otherwise, create it in the parser's options list.
*/
Option *option;
if (parent) {
auto iter = optionsMap_.find(parent);
if (iter == optionsMap_.end())
return false;
Option *parentOpt = iter->second;
parentOpt->children.push_back({
opt, type, name, argument, argumentName, help, nullptr,
array, parentOpt, {}
});
option = &parentOpt->children.back();
} else {
options_.push_back({ opt, type, name, argument, argumentName,
help, nullptr, array, nullptr, {} });
option = &options_.back();
}
optionsMap_[opt] = option;
return true;
}
/**
* \brief Add a key-value pair option to the parser
* \param[in] opt The option identifier
* \param[in] parser The KeyValueParser for the option value
* \param[in] help The help text (may be a multi-line string)
* \param[in] name The option name
* \param[in] array Whether the option can appear once or multiple times
*
* \sa Option
*
* \return True if the option was added successfully, false if an error
* occurred.
*/
bool OptionsParser::addOption(int opt, KeyValueParser *parser, const char *help,
const char *name, bool array, int parent)
{
if (!addOption(opt, OptionKeyValue, help, name, ArgumentRequired,
"key=value[,key=value,...]", array, parent))
return false;
optionsMap_[opt]->keyValueParser = parser;
return true;
}
/**
* \brief Parse command line arguments
* \param[in] argc The number of arguments in the \a argv array
* \param[in] argv The array of arguments
*
* If a parsing error occurs, the parsing stops, the function prints an error
* message that identifies the invalid argument, prints usage information with
* usage(), and returns an invalid container. The container is populated with
* the options successfully parsed so far.
*
* \return A valid container with the list of parsed options on success, or an
* invalid container otherwise
*/
OptionsParser::Options OptionsParser::parse(int argc, char **argv)
{
OptionsParser::Options options;
/*
* Allocate short and long options arrays large enough to contain all
* options.
*/
std::vector<char> shortOptions(optionsMap_.size() * 3 + 2);
std::vector<struct option> longOptions(optionsMap_.size() + 1);
unsigned int ids = 0;
unsigned int idl = 0;
shortOptions[ids++] = ':';
for (const auto [opt, option] : optionsMap_) {
if (option->hasShortOption()) {
shortOptions[ids++] = opt;
if (option->argument != ArgumentNone)
shortOptions[ids++] = ':';
if (option->argument == ArgumentOptional)
shortOptions[ids++] = ':';
}
if (option->hasLongOption()) {
longOptions[idl].name = option->name;
switch (option->argument) {
case ArgumentNone:
longOptions[idl].has_arg = no_argument;
break;
case ArgumentRequired:
longOptions[idl].has_arg = required_argument;
break;
case ArgumentOptional:
longOptions[idl].has_arg = optional_argument;
break;
}
longOptions[idl].flag = 0;
longOptions[idl].val = option->opt;
idl++;
}
}
shortOptions[ids] = '\0';
memset(&longOptions[idl], 0, sizeof(longOptions[idl]));
opterr = 0;
while (true) {
int c = getopt_long(argc, argv, shortOptions.data(),
longOptions.data(), nullptr);
if (c == -1)
break;
if (c == '?' || c == ':') {
if (c == '?')
std::cerr << "Invalid option ";
else
std::cerr << "Missing argument for option ";
std::cerr << argv[optind - 1] << std::endl;
usage();
return options;
}
const Option &option = *optionsMap_[c];
if (!parseValue(option, optarg, &options)) {
usage();
return options;
}
}
if (optind < argc) {
std::cerr << "Invalid non-option argument '" << argv[optind]
<< "'" << std::endl;
usage();
return options;
}
options.valid_ = true;
return options;
}
/**
* \brief Print usage text to std::cerr
*
* The usage text list all the supported option with their arguments. It is
* generated automatically from the options added to the parser. Caller of this
* function may print additional usage information for the application before
* the list of options.
*/
void OptionsParser::usage()
{
unsigned int indent = 0;
for (const auto &opt : optionsMap_) {
const Option *option = opt.second;
unsigned int length = 14;
if (option->hasLongOption())
length += 2 + strlen(option->name);
if (option->argument != ArgumentNone)
length += 1 + strlen(option->argumentName);
if (option->argument == ArgumentOptional)
length += 2;
if (option->isArray)
length += 4;
if (length > indent)
indent = length;
if (option->keyValueParser) {
length = option->keyValueParser->maxOptionLength();
if (length > indent)
indent = length;
}
}
indent = (indent + 7) / 8 * 8;
std::cerr << "Options:" << std::endl;
std::ios_base::fmtflags f(std::cerr.flags());
std::cerr << std::left;
usageOptions(options_, indent);
std::cerr.flags(f);
}
void OptionsParser::usageOptions(const std::list<Option> &options,
unsigned int indent)
{
std::vector<const Option *> parentOptions;
for (const Option &option : options) {
std::string argument;
if (option.hasShortOption())
argument = std::string(" -")
+ static_cast<char>(option.opt);
else
argument = " ";
if (option.hasLongOption()) {
if (option.hasShortOption())
argument += ", ";
else
argument += " ";
argument += std::string("--") + option.name;
}
if (option.argument != ArgumentNone) {
if (option.argument == ArgumentOptional)
argument += "[=";
else
argument += " ";
argument += option.argumentName;
if (option.argument == ArgumentOptional)
argument += "]";
}
if (option.isArray)
argument += " ...";
std::cerr << std::setw(indent) << argument;
for (const char *help = option.help, *end = help; end; ) {
end = strchr(help, '\n');
if (end) {
std::cerr << std::string(help, end - help + 1);
std::cerr << std::setw(indent) << " ";
help = end + 1;
} else {
std::cerr << help << std::endl;
}
}
if (option.keyValueParser)
option.keyValueParser->usage(indent);
if (!option.children.empty())
parentOptions.push_back(&option);
}
if (parentOptions.empty())
return;
for (const Option *option : parentOptions) {
|