Coverage for ibllib/qc/camera.py: 79%

1"""Video quality control. 

2 

3This module runs a list of quality control metrics on the camera and extracted video data. 

4 

5Examples 

6-------- 

7Run right camera QC, downloading all but video file 

8 

9>>> qc = CameraQC(eid, 'right', download_data=True, stream=True) 

10>>> qc.run() 

11 

12Run left camera QC with session path, update QC field in Alyx 

13 

14>>> qc = CameraQC(session_path, 'left') 

15>>> outcome, extended = qc.run(update=True) # Returns outcome of videoQC only 

16>>> print(f'video QC = {outcome}; overall session QC = {qc.outcome}') # NB difference outcomes 

17 

18Run only video QC (no timestamp/alignment checks) on 20 frames for the body camera 

19 

20>>> qc = CameraQC(eid, 'body', n_samples=20) 

21>>> qc.load_video_data() # Quicker than loading all data 

22>>> qc.run() 

23 

24Run specific video QC check and display the plots 

25 

26>>> qc = CameraQC(eid, 'left') 

27>>> qc.load_data(download_data=True) 

28>>> qc.check_position(display=True) # NB: Not all checks make plots 

29 

30Run the QC for all cameras 

31 

32>>> qcs = run_all_qc(eid) 

33>>> qcs['left'].metrics # Dict of checks and outcomes for left camera 

34""" 

35import logging (empty)

36from inspect import getmembers, isfunction (empty)

37from pathlib import Path (empty)

38from itertools import chain (empty)

39import copy (empty)

40 

41import cv2 (empty)

42import numpy as np (empty)

43import matplotlib.pyplot as plt (empty)

44import pandas as pd (empty)

45from matplotlib.patches import Rectangle (empty)

46from labcams import parse_cam_log (empty)

47 

48import one.alf.io as alfio (empty)

49from one.util import filter_datasets (empty)

50from one.alf.spec import is_session_path (empty)

51from one.alf.exceptions import ALFObjectNotFound (empty)

52from iblutil.util import Bunch (empty)

53from iblutil.numerical import within_ranges (empty)

54 

55from ibllib.io.extractors.camera import extract_camera_sync, extract_all (empty)

56from ibllib.io.extractors import ephys_fpga, training_wheel, mesoscope (empty)

57from ibllib.io.extractors.video_motion import MotionAlignment (empty)

58from ibllib.io.extractors.base import get_session_extractor_type (empty)

59from ibllib.io import raw_data_loaders as raw (empty)

60from ibllib.io.raw_daq_loaders import load_timeline_sync_and_chmap (empty)

61from ibllib.io.session_params import read_params, get_sync, get_sync_namespace (empty)

62import brainbox.behavior.wheel as wh (empty)

63from ibllib.io.video import get_video_meta, get_video_frames_preload, assert_valid_label (empty)

64from . import base (empty)

65 

66_log = logging.getLogger(__name__) (empty)

67 

68 

69class CameraQC(base.QC): (empty)

70 """A class for computing camera QC metrics""" 

71 dstypes = [ (empty)

72 '_ibl_experiment.description', 

73 '_iblrig_Camera.frameData', # Replaces the next 3 datasets 

74 '_iblrig_Camera.frame_counter', 

75 '_iblrig_Camera.GPIO', 

76 '_iblrig_Camera.timestamps', 

77 '_iblrig_taskData.raw', 

78 '_iblrig_taskSettings.raw', 

79 '_iblrig_Camera.raw', 

80 'camera.times', 

81 'wheel.position', 

82 'wheel.timestamps' 

83 ] 

84 dstypes_fpga = [ (empty)

85 '_spikeglx_sync.channels', 

86 '_spikeglx_sync.polarities', 

87 '_spikeglx_sync.times', 

88 'ephysData.raw.meta' 

89 ] 

90 """Recall that for the training rig there is only one side camera at 30 Hz and 1280 x 1024 px. (empty)

91 For the recording rig there are two label cameras (left: 60 Hz, 1280 x 1024 px; 

92 right: 150 Hz, 640 x 512 px) and one body camera (30 Hz, 640 x 512 px). """ 

93 video_meta = { (empty)

94 'training': { 

95 'left': { 

96 'fps': 30, 

97 'width': 1280, 

98 'height': 1024 

99 } 

100 }, 

101 'ephys': { 

102 'left': { 

103 'fps': 60, 

104 'width': 1280, 

105 'height': 1024 

106 }, 

107 'right': { 

108 'fps': 150, 

109 'width': 640, 

110 'height': 512 

111 }, 

112 'body': { 

113 'fps': 30, 

114 'width': 640, 

115 'height': 512 

116 }, 

117 } 

118 } 

119 

120 def __init__(self, session_path_or_eid, camera, **kwargs): (empty)

121 """ 

122 :param session_path_or_eid: A session id or path 

123 :param camera: The camera to run QC on, if None QC is run for all three cameras 

124 :param n_samples: The number of frames to sample for the position and brightness QC 

125 :param stream: If true and local video files not available, the data are streamed from 

126 the remote source. 

127 :param log: A logging.Logger instance, if None the 'ibllib' logger is used 

128 :param one: An ONE instance for fetching and setting the QC on Alyx 

129 """ 

130 # When an eid is provided, we will download the required data by default (if necessary) 

131 download_data = not is_session_path(session_path_or_eid) 7 ctx1gcaihbd

132 self.download_data = kwargs.pop('download_data', download_data) 7 ctx1gcaihbd

133 self.stream = kwargs.pop('stream', None) 7 ctx1gcaihbd

134 self.n_samples = kwargs.pop('n_samples', 100) 7 ctx1gcaihbd

135 self.sync_collection = kwargs.pop('sync_collection', None) 7 ctx1gcaihbd

136 self.sync = kwargs.pop('sync_type', None) 7 ctx1gcaihbd

137 super().__init__(session_path_or_eid, **kwargs) 7 ctx1gcaihbd

138 

139 # Data 

140 self.label = assert_valid_label(camera) 7 ctx1gcaihbd

141 filename = f'_iblrig_{self.label}Camera.raw*.mp4' 7 ctx1gcaihbd

142 raw_video_path = self.session_path.joinpath('raw_video_data') 7 ctx1gcaihbd

143 self.video_path = next(raw_video_path.glob(filename), None) 7 ctx1gcaihbd

144 

145 # If local video doesn't exist, change video path to URL 

146 if not self.video_path and self.stream is not False and self.one is not None: 7 ctx1gcaihbd

147 try: 

148 self.stream = True 

149 self.video_path = self.one.path2url(raw_video_path / filename.replace('*', '')) 

150 except (StopIteration, ALFObjectNotFound): 

151 _log.error('No remote or local video file found') 

152 self.video_path = None 

153 

154 logging.disable(logging.NOTSET) 7 ctx1gcaihbd

155 keys = ('count', 'pin_state', 'audio', 'fpga_times', 'wheel', 'video', 7 ctx1gcaihbd

156 'frame_samples', 'timestamps', 'camera_times', 'bonsai_times') 

157 self.data = Bunch.fromkeys(keys) 7 ctx1gcaihbd

158 self.frame_samples_idx = None 7 ctx1gcaihbd

159 

160 # QC outcomes map 

161 self.metrics = None 7 ctx1gcaihbd

162 self.outcome = 'NOT_SET' 7 ctx1gcaihbd

163 

164 # Specify any checks to remove 

165 self.checks_to_remove = [] 7 ctx1gcaihbd

166 self._type = None 7 ctx1gcaihbd

167 

168 @property (empty)

169 def type(self): (empty)

170 """ 

171 Returns the camera type based on the protocol. 

172 :return: Returns either None, 'ephys' or 'training' 

173 """ 

174 if not self._type: 11 ctx1ywqkcaihbfd

175 return 3 ctx1aib

176 else: 

177 return 'ephys' if 'ephys' in self._type else 'training' 11 ctx1ywqkcaihbfd

178 

179 def load_data(self, download_data: bool = None, extract_times: bool = False, load_video: bool = True) -> None: (empty)

180 """Extract the data from raw data files 

181 Extracts all the required task data from the raw data files. 

182 

183 Data keys: 

184 - count (int array): the sequential frame number (n, n+1, n+2...) 

185 - pin_state (): the camera GPIO pin; records the audio TTLs; should be one per frame 

186 - audio (float array): timestamps of audio TTL fronts 

187 - fpga_times (float array): timestamps of camera TTLs recorded by FPGA 

188 - timestamps (float array): extracted video timestamps (the camera.times ALF) 

189 - bonsai_times (datetime array): system timestamps of video PC; should be one per frame 

190 - camera_times (float array): camera frame timestamps extracted from frame headers 

191 - wheel (Bunch): rotary encoder timestamps, position and period used for wheel motion 

192 - video (Bunch): video meta data, including dimensions and FPS 

193 - frame_samples (h x w x n array): array of evenly sampled frames (1 colour channel) 

194 

195 :param download_data: if True, any missing raw data is downloaded via ONE. 

196 Missing data will raise an AssertionError 

197 :param extract_times: if True, the camera.times are re-extracted from the raw data 

198 :param load_video: if True, calls the load_video_data method 

199 """ 

200 assert self.session_path, 'no session path set' 6 ctx1caihbd

201 if download_data is not None: 6 ctx1caihbd

202 self.download_data = download_data 2 ctx1ab

203 if self.download_data and self.eid and self.one and not self.one.offline: 6 ctx1caihbd

204 self.ensure_required_data() 

205 _log.info('Gathering data for QC') 6 ctx1caihbd

206 

207 # Get frame count and pin state 

208 self.data['count'], self.data['pin_state'] = \ 6 ctx1caihbd

209 raw.load_embedded_frame_data(self.session_path, self.label, raw=True) 

210 

211 # If there is an experiment description and there are video parameters 

212 sess_params = read_params(self.session_path) or {} 6 ctx1caihbd

213 task_collection = get_task_collection(sess_params) 6 ctx1caihbd

214 ns = get_sync_namespace(sess_params) 6 ctx1caihbd

215 self._set_sync(sess_params) 6 ctx1caihbd

216 if not self.sync: 6 ctx1caihbd

217 if not self.type: 3 ctx1aib

218 self._type = get_session_extractor_type(self.session_path, task_collection) 3 ctx1aib

219 self.sync = 'nidq' if 'ephys' in self.type else 'bpod' 3 ctx1aib

220 self._update_meta_from_session_params(sess_params) 6 ctx1caihbd

221 

222 # Load the audio and raw FPGA times 

223 if self.sync != 'bpod' and self.sync is not None: 6 ctx1caihbd

224 self.sync_collection = self.sync_collection or 'raw_ephys_data' 2 ctx1ah

225 ns = ns or 'spikeglx' 2 ctx1ah

226 if ns == 'spikeglx': 2 ctx1ah

227 sync, chmap = ephys_fpga.get_sync_and_chn_map(self.session_path, self.sync_collection) 2 ctx1ah

228 elif ns == 'timeline': 1 ctx1h

229 sync, chmap = load_timeline_sync_and_chmap(self.session_path / self.sync_collection) 

230 else: 

231 raise NotImplementedError(f'Unknown namespace "{ns}"') 1 ctx1h

232 audio_ttls = ephys_fpga.get_sync_fronts(sync, chmap['audio']) 2 ctx1ah

233 self.data['audio'] = audio_ttls['times'] # Get rises 2 ctx1ah

234 # Load raw FPGA times 

235 cam_ts = extract_camera_sync(sync, chmap) 2 ctx1ah

236 self.data['fpga_times'] = cam_ts[self.label] 2 ctx1ah

237 else: 

238 self.sync_collection = self.sync_collection or task_collection 5 ctx1cihbd

239 bpod_data = raw.load_data(self.session_path, task_collection) 5 ctx1cihbd

240 _, audio_ttls = raw.load_bpod_fronts( 5 ctx1cihbd

241 self.session_path, data=bpod_data, task_collection=task_collection) 

242 self.data['audio'] = audio_ttls['times'] 5 ctx1cihbd

243 

244 # Load extracted frame times 

245 alf_path = self.session_path / 'alf' 6 ctx1caihbd

246 try: 6 ctx1caihbd

247 assert not extract_times 6 ctx1caihbd

248 self.data['timestamps'] = alfio.load_object( 4 ctx1cihd

249 alf_path, f'{self.label}Camera', short_keys=True)['times'] 

250 except AssertionError: # Re-extract 3 ctx1aib

251 kwargs = dict(video_path=self.video_path, labels=self.label) 2 ctx1ab

252 if self.sync != 'bpod' and self.sync is not None: 2 ctx1ab

253 kwargs = {**kwargs, 'sync': sync, 'chmap': chmap} # noqa 1 ctx1a

254 outputs, _ = extract_all(self.session_path, self.sync, save=False, 2 ctx1ab

255 sync_collection=self.sync_collection, **kwargs) 

256 self.data['timestamps'] = outputs[f'{self.label}_camera_timestamps'] 2 ctx1ab

257 except ALFObjectNotFound: 1 ctx1i

258 _log.warning('no camera.times ALF found for session') 1 ctx1i

259 

260 # Get audio and wheel data 

261 wheel_keys = ('timestamps', 'position') 6 ctx1caihbd

262 try: 6 ctx1caihbd

263 # glob in case wheel data are in sub-collections 

264 alf_path = next(alf_path.rglob('*wheel.timestamps*')).parent 6 ctx1caihbd

265 self.data['wheel'] = alfio.load_object(alf_path, 'wheel', short_keys=True) 4 ctx1cahb

266 except (StopIteration, ALFObjectNotFound): 2 ctx1id

267 # Extract from raw data 

268 if self.sync != 'bpod' and self.sync is not None: 2 ctx1id

269 if ns == 'spikeglx': 

270 wheel_data = ephys_fpga.extract_wheel_sync(sync, chmap) 

271 elif ns == 'timeline': 

272 extractor = mesoscope.TimelineTrials(self.session_path, sync_collection=self.sync_collection) 

273 wheel_data = extractor.extract_wheel_sync() 

274 else: 

275 raise NotImplementedError(f'Unknown namespace "{ns}"') 

276 else: 

277 wheel_data = training_wheel.get_wheel_position( 2 ctx1id

278 self.session_path, task_collection=task_collection) 

279 self.data['wheel'] = Bunch(zip(wheel_keys, wheel_data)) 2 ctx1id

280 

281 # Find short period of wheel motion for motion correlation. 

282 if data_for_keys(wheel_keys, self.data['wheel']) and self.data['timestamps'] is not None: 6 ctx1caihbd

283 self.data['wheel'].period = self.get_active_wheel_period(self.data['wheel']) 5 ctx1cahbd

284 

285 # Load Bonsai frame timestamps 

286 try: 6 ctx1caihbd

287 ssv_times = raw.load_camera_ssv_times(self.session_path, self.label) 6 ctx1caihbd

288 self.data['bonsai_times'], self.data['camera_times'] = ssv_times 6 ctx1caihbd

289 except AssertionError: 

290 _log.warning('No Bonsai video timestamps file found') 

291 

292 # Gather information from video file 

293 if load_video: 6 ctx1caihbd

294 _log.info('Inspecting video file...') 5 ctx1caibd

295 self.load_video_data() 5 ctx1caibd

296 

297 def load_video_data(self): (empty)

298 # Get basic properties of video 

299 try: 6 ctx1gcaibd

300 self.data['video'] = get_video_meta(self.video_path, one=self.one) 6 ctx1gcaibd

301 # Sample some frames from the video file 

302 indices = np.linspace(100, self.data['video'].length - 100, self.n_samples).astype(int) 6 ctx1gcaibd

303 self.frame_samples_idx = indices 6 ctx1gcaibd

304 self.data['frame_samples'] = get_video_frames_preload(self.video_path, indices, 6 ctx1gcaibd

305 mask=np.s_[:, :, 0]) 

306 except AssertionError: 

307 _log.error('Failed to read video file; setting outcome to CRITICAL') 

308 self._outcome = 'CRITICAL' 

309 

310 @staticmethod (empty)

311 def get_active_wheel_period(wheel, duration_range=(3., 20.), display=False): (empty)

312 """ 

313 Attempts to find a period of movement where the wheel accelerates and decelerates for 

314 the wheel motion alignment QC. 

315 :param wheel: A Bunch of wheel timestamps and position data 

316 :param duration_range: The candidates must be within min/max duration range 

317 :param display: If true, plot the selected wheel movement 

318 :return: 2-element array comprising the start and end times of the active period 

319 """ 

320 pos, ts = wh.interpolate_position(wheel.timestamps, wheel.position) 6 ctx1ocahbd

321 v, acc = wh.velocity_filtered(pos, 1000) 6 ctx1ocahbd

322 on, off, *_ = wh.movements(ts, acc, pos_thresh=.1, make_plots=False) 6 ctx1ocahbd

323 edges = np.c_[on, off] 6 ctx1ocahbd

324 indices, _ = np.where(np.logical_and( 6 ctx1ocahbd

325 np.diff(edges) > duration_range[0], np.diff(edges) < duration_range[1])) 

326 if len(indices) == 0: 6 ctx1ocahbd

327 _log.warning('No period of wheel movement found for motion alignment.') 1 ctx1o

328 return None 1 ctx1o

329 # Pick movement somewhere in the middle 

330 i = indices[int(indices.size / 2)] 5 ctx1cahbd

331 if display: 5 ctx1cahbd

332 _, (ax0, ax1) = plt.subplots(2, 1, sharex='all') 

333 mask = np.logical_and(ts > edges[i][0], ts < edges[i][1]) 

334 ax0.plot(ts[mask], pos[mask]) 

335 ax1.plot(ts[mask], acc[mask]) 

336 return edges[i] 5 ctx1cahbd

337 

338 def ensure_required_data(self): (empty)

339 """ 

340 Ensures the datasets required for QC are local. If the download_data attribute is True, 

341 any missing data are downloaded. If all the data are not present locally at the end of 

342 it an exception is raised. If the stream attribute is True, the video file is not 

343 required to be local, however it must be remotely accessible. 

344 NB: Requires a valid instance of ONE and a valid session eid. 

345 :return: 

346 """ 

347 assert self.one is not None, 'ONE required to download data' 1 ctx1k

348 

349 sess_params = {} 1 ctx1k

350 if self.download_data: 1 ctx1k

351 dset = self.one.list_datasets(self.session_path, '*experiment.description*', details=True) 

352 if self.one._check_filesystem(dset): 

353 sess_params = read_params(self.session_path) or {} 

354 else: 

355 sess_params = read_params(self.session_path) or {} 1 ctx1k

356 self._set_sync(sess_params) 1 ctx1k

357 

358 # Get extractor type 

359 is_ephys = 'ephys' in (self.type or self.one.get_details(self.eid)['task_protocol']) 1 ctx1k

360 self.sync = self.sync or ('nidq' if is_ephys else 'bpod') 1 ctx1k

361 

362 is_fpga = 'bpod' not in self.sync 1 ctx1k

363 

364 # dataset collections outside this list are ignored (e.g. probe00, raw_passive_data) 

365 collections = ( 1 ctx1k

366 'alf', '', get_task_collection(sess_params), get_video_collection(sess_params, self.label) 

367 ) 

368 dtypes = self.dstypes + self.dstypes_fpga if is_fpga else self.dstypes 1 ctx1k

369 assert_unique = True 1 ctx1k

370 # Check we have raw ephys data for session 

371 if is_ephys: 1 ctx1k

372 if len(self.one.list_datasets(self.eid, collection='raw_ephys_data')) == 0: 1 ctx1k

373 # Assert 3A probe model; if so download all probe data 

374 det = self.one.get_details(self.eid, full=True) 

375 probe_model = next(x['model'] for x in det['probe_insertion']) 

376 assert probe_model == '3A', 'raw ephys data missing' 

377 collections += (self.sync_collection or 'raw_ephys_data',) 

378 if sess_params: 

379 probes = sess_params.get('devices', {}).get('neuropixel', {}) 

380 probes = set(x.get('collection') for x in chain(*map(dict.values, probes))) 

381 collections += tuple(probes) 

382 else: 

383 collections += ('raw_ephys_data/probe00', 'raw_ephys_data/probe01') 

384 assert_unique = False 

385 else: 

386 # 3B probes have data in root collection 

387 collections += ('raw_ephys_data',) 1 ctx1k

388 for dstype in dtypes: 1 ctx1k

389 datasets = self.one.type2datasets(self.eid, dstype, details=True) 1 ctx1k

390 if 'camera' in dstype.lower(): # Download individual camera file 1 ctx1k

391 datasets = filter_datasets(datasets, filename=f'.*{self.label}.*') 1 ctx1k

392 else: # Ignore probe datasets, etc. 

393 _datasets = filter_datasets(datasets, collection=collections, assert_unique=assert_unique) 1 ctx1k

394 if '' in collections: # Must be handled as a separate query 1 ctx1k

395 datasets = filter_datasets(datasets, collection='', assert_unique=assert_unique) 1 ctx1k

396 datasets = pd.concat([datasets, _datasets]).sort_index() 1 ctx1k

397 else: 

398 datasets = _datasets 

399 

400 if any(x.endswith('.mp4') for x in datasets.rel_path) and self.stream: 1 ctx1k

401 names = [x.split('/')[-1] for x in self.one.list_datasets(self.eid, details=False)] 

402 assert f'_iblrig_{self.label}Camera.raw.mp4' in names, 'No remote video file found' 

403 continue 

404 optional = ('camera.times', '_iblrig_Camera.raw', 'wheel.position', 'wheel.timestamps', 1 ctx1k

405 '_iblrig_Camera.timestamps', '_iblrig_Camera.frame_counter', '_iblrig_Camera.GPIO', 

406 '_iblrig_Camera.frameData', '_ibl_experiment.description') 

407 present = ( 1 ctx1k

408 self.one._check_filesystem(datasets) 

409 if self.download_data 

410 else (next(self.session_path.rglob(d), None) for d in datasets['rel_path']) 

411 ) 

412 

413 required = (dstype not in optional) 1 ctx1k

414 all_present = not datasets.empty and all(present) 1 ctx1k

415 assert all_present or not required, f'Dataset {dstype} not found' 1 ctx1k

416 

417 if not self.type and self.sync != 'nidq': 

418 self._type = get_session_extractor_type(self.session_path) 

419 

420 def _set_sync(self, session_params=False): (empty)

421 """Set the sync and sync_collection attributes if not already set. 

422 

423 Also set the type attribute based on the sync. NB The type attribute is for legacy sessions. 

424 

425 Parameters 

426 ---------- 

427 session_params : dict, bool 

428 The loaded experiment description file. If False, attempts to load it from the session_path. 

429 """ 

430 if session_params is False: 7 ctx1kcaihbd

431 if not self.session_path: 

432 raise ValueError('No session path set') 

433 session_params = read_params(self.session_path) 

434 sync, sync_dict = get_sync(session_params) 7 ctx1kcaihbd

435 self.sync = self.sync or sync 7 ctx1kcaihbd

436 self.sync_collection = self.sync_collection or sync_dict.get('collection') 7 ctx1kcaihbd

437 if self.sync: 7 ctx1kcaihbd

438 self._type = 'ephys' if self.sync == 'nidq' else 'training' 3 ctx1chd

439 

440 def _update_meta_from_session_params(self, sess_params): (empty)

441 """ 

442 Update the default expected video properties with those defined in the experiment 

443 description file (if any). This updates the `video_meta` property with the fps, width and 

444 height for the type and camera label. 

445 

446 Parameters 

447 ---------- 

448 sess_params : dict 

449 The loaded experiment.description file. 

450 """ 

451 try: 6 ctx1caihbd

452 assert sess_params 6 ctx1caihbd

453 video_pars = sess_params.get('devices', {}).get('cameras', {}).get(self.label) 3 ctx1chd

454 except (AssertionError, KeyError): 3 ctx1aib

455 return 3 ctx1aib

456 PROPERTIES = ('width', 'height', 'fps') 3 ctx1chd

457 video_meta = copy.deepcopy(self.video_meta) # must re-assign as it's a class attribute 3 ctx1chd

458 if self.type not in video_meta: 3 ctx1chd

459 video_meta[self.type] = {} 

460 if self.label not in video_meta[self.type]: 3 ctx1chd

461 video_meta[self.type][self.label] = {} 

462 video_meta[self.type][self.label].update( 3 ctx1chd

463 **{k: v for k, v in video_pars.items() if k in PROPERTIES} 

464 ) 

465 self.video_meta = video_meta 3 ctx1chd

466 

467 def run(self, update: bool = False, **kwargs) -> (str, dict): (empty)

468 """ 

469 Run video QC checks and return outcome 

470 :param update: if True, updates the session QC fields on Alyx 

471 :param download_data: if True, downloads any missing data if required 

472 :param extract_times: if True, re-extracts the camera timestamps from the raw data 

473 :returns: overall outcome as a str, a dict of checks and their outcomes 

474 """ 

475 _log.info(f'Computing QC outcome for {self.label} camera, session {self.eid}') 5 ctx1caibd

476 namespace = f'video{self.label.capitalize()}' 5 ctx1caibd

477 if all(x is None for x in self.data.values()): 5 ctx1caibd

478 self.load_data(**kwargs) 4 ctx1caid

479 if self.data['frame_samples'] is None or self.data['timestamps'] is None: 5 ctx1caibd

480 return 'NOT_SET', {} 1 ctx1i

481 if self.data['timestamps'].shape[0] == 0: 4 ctx1cabd

482 _log.error(f'No timestamps for {self.label} camera; setting outcome to CRITICAL') 

483 return 'CRITICAL', {} 

484 

485 def is_metric(x): 4 ctx1cabd

486 return isfunction(x) and x.__name__.startswith('check_') 4 ctx1cabd

487 # import importlib 

488 # classe = getattr(importlib.import_module(self.__module__), self.__name__) 

489 # print(classe) 

490 

491 checks = getmembers(self.__class__, is_metric) 4 ctx1cabd

492 checks = self.remove_check(checks) 4 ctx1cabd

493 self.metrics = {f'_{namespace}_' + k[6:]: fn(self) for k, fn in checks} 4 ctx1cabd

494 

495 values = [x if isinstance(x, str) else x[0] for x in self.metrics.values()] 4 ctx1cabd

496 code = max(base.CRITERIA[x] for x in values) 4 ctx1cabd

497 outcome = next(k for k, v in base.CRITERIA.items() if v == code) 4 ctx1cabd

498 

499 if update: 4 ctx1cabd

500 extended = { 2 ctx1cd

501 k: 'NOT_SET' if v is None else v 

502 for k, v in self.metrics.items() 

503 } 

504 self.update_extended_qc(extended) 2 ctx1cd

505 self.update(outcome, namespace) 2 ctx1cd

506 return outcome, self.metrics 4 ctx1cabd

507 

508 def remove_check(self, checks): (empty)

509 if len(self.checks_to_remove) == 0: 4 ctx1cabd

510 return checks 4 ctx1cabd

511 else: 

512 for check in self.checks_to_remove: 

513 check_names = [ch[0] for ch in checks] 

514 idx = check_names.index(check) 

515 checks.pop(idx) 

516 return checks 

517 

518 def check_brightness(self, bounds=(40, 200), max_std=20, roi=True, display=False): (empty)

519 """Check that the video brightness is within a given range 

520 The mean brightness of each frame must be with the bounds provided, and the standard 

521 deviation across samples frames should be less then the given value. Assumes that the 

522 frame samples are 2D (no colour channels). 

523 

524 :param bounds: For each frame, check that: bounds[0] < M < bounds[1], 

525 where M = mean(frame). If less than 75% of sample frames outside of these bounds, the 

526 outcome is WARNING. If <75% of frames within twice the bounds, the outcome is FAIL. 

527 :param max_std: The standard deviation of the frame luminance means must be less than this 

528 :param roi: If True, check brightness on ROI of frame 

529 :param display: When True the mean frame luminance is plotted against sample frames. 

530 The sample frames with the lowest and highest mean luminance are shown. 

531 """ 

532 if self.data['frame_samples'] is None: 6 ctx1lcabfd

533 return 'NOT_SET' 1 ctx1l

534 if roi is True: 6 ctx1lcabfd

535 _, h, w = self.data['frame_samples'].shape 6 ctx1lcabfd

536 if self.label == 'body': # Latter half 6 ctx1lcabfd

537 roi = (slice(None), slice(None), slice(int(w / 2), None, None)) 1 ctx1f

538 elif self.label == 'left': # Top left quadrant (~2/3, 1/2 height) 6 ctx1lcabfd

539 roi = (slice(None), slice(None, int(h / 2), None), slice(None, int(w * .66), None)) 6 ctx1lcabfd

540 else: # Top right quadrant (~2/3 width, 1/2 height) 

541 roi = (slice(None), slice(None, int(h / 2), None), slice(int(w * .66), None, None)) 1 ctx1f

542 else: 

543 roi = (slice(None), slice(None), slice(None)) 

544 brightness = self.data['frame_samples'][roi].mean(axis=(1, 2)) 6 ctx1lcabfd

545 # dims = self.data['frame_samples'].shape 

546 # brightness /= np.array((*dims[1:], 255)).prod() # Normalize 

547 

548 if display: 6 ctx1lcabfd

549 f = plt.figure() 1 ctx1l

550 gs = f.add_gridspec(2, 3) 1 ctx1l

551 indices = self.frame_samples_idx 1 ctx1l

552 # Plot mean frame luminance 

553 ax = f.add_subplot(gs[:2, :2]) 1 ctx1l

554 plt.plot(indices, brightness, label='brightness') 1 ctx1l

555 ax.set( 1 ctx1l

556 xlabel='frame #', 

557 ylabel='brightness (mean pixel)', 

558 title='Brightness') 

559 ax.hlines(bounds, 0, indices[-1], 1 ctx1l

560 colors='tab:orange', linestyles=':', label='warning bounds') 

561 ax.hlines((bounds[0] / 2, bounds[1] * 2), 0, indices[-1], 1 ctx1l

562 colors='r', linestyles=':', label='failure bounds') 

563 ax.legend() 1 ctx1l

564 # Plot min-max frames 

565 for i, idx in enumerate((np.argmax(brightness), np.argmin(brightness))): 1 ctx1l

566 a = f.add_subplot(gs[i, 2]) 1 ctx1l

567 ax.annotate('*', (indices[idx], brightness[idx]), # this is the point to label 1 ctx1l

568 textcoords='offset points', xytext=(0, 1), ha='center') 

569 frame = self.data['frame_samples'][idx][roi[1:]] 1 ctx1l

570 title = ('min' if i else 'max') + ' mean luminance = %.2f' % brightness[idx] 1 ctx1l

571 self.imshow(frame, ax=a, title=title) 1 ctx1l

572 

573 PCT_PASS = .75 # Proportion of sample frames that must pass 6 ctx1lcabfd

574 # Warning if brightness not within range (3/4 of frames must be between bounds) 

575 warn_range = np.logical_and(brightness > bounds[0], brightness < bounds[1]) 6 ctx1lcabfd

576 warn_range = 'PASS' if sum(warn_range) / self.n_samples > PCT_PASS else 'WARNING' 6 ctx1lcabfd

577 # Fail if brightness not within twice the range or std less than threshold 

578 fail_range = np.logical_and(brightness > bounds[0] / 2, brightness < bounds[1] * 2) 6 ctx1lcabfd

579 within_range = sum(fail_range) / self.n_samples > PCT_PASS 6 ctx1lcabfd

580 fail_range = 'PASS' if within_range and np.std(brightness) < max_std else 'FAIL' 6 ctx1lcabfd

581 return self.overall_outcome([warn_range, fail_range]) 6 ctx1lcabfd

582 

583 def check_file_headers(self): (empty)

584 """Check reported frame rate matches FPGA frame rate""" 

585 if None in (self.data['video'], self.video_meta): 6 ctx1ycabfd

586 return 'NOT_SET' 1 ctx1y

587 expected = self.video_meta[self.type][self.label] 6 ctx1ycabfd

588 return 'PASS' if self.data['video']['fps'] == expected['fps'] else 'FAIL' 6 ctx1ycabfd

589 

590 def check_framerate(self, threshold=1.): (empty)

591 """Check camera times match specified frame rate for camera 

592 

593 :param threshold: The maximum absolute difference between timestamp sample rate and video 

594 frame rate. NB: Does not take into account dropped frames. 

595 """ 

596 if any(x is None for x in (self.data['timestamps'], self.video_meta)): 5 ctx1wcabd

597 return 'NOT_SET' 1 ctx1w

598 fps = self.video_meta[self.type][self.label]['fps'] 5 ctx1wcabd

599 Fs = 1 / np.median(np.diff(self.data['timestamps'])) # Approx. frequency of camera 5 ctx1wcabd

600 return 'PASS' if abs(Fs - fps) < threshold else 'FAIL', float(round(Fs, 3)) 5 ctx1wcabd

601 

602 def check_pin_state(self, display=False): (empty)

603 """Check the pin state reflects Bpod TTLs""" 

604 if not data_for_keys(('video', 'pin_state', 'audio'), self.data): 5 ctx1mcabd

605 return 'NOT_SET' 3 ctx1mcd

606 size_diff = int(self.data['pin_state'].shape[0] - self.data['video']['length']) 3 ctx1mab

607 # NB: The pin state can be high for 2 consecutive frames 

608 low2high = np.insert(np.diff(self.data['pin_state'][:, -1].astype(int)) == 1, 0, False) 3 ctx1mab

609 # NB: Time between two consecutive TTLs can be sub-frame, so this will fail 

610 ndiff_low2high = int(self.data['audio'][::2].size - sum(low2high)) 3 ctx1mab

611 # state_ttl_matches = ndiff_low2high == 0 

612 # Check within ms of audio times 

613 if display: 3 ctx1mab

614 plt.Figure() 1 ctx1m

615 plt.plot(self.data['timestamps'][low2high], np.zeros(sum(low2high)), 'o', 1 ctx1m

616 label='GPIO Low -> High') 

617 plt.plot(self.data['audio'], np.zeros(self.data['audio'].size), 'rx', 1 ctx1m

618 label='Audio TTL High') 

619 plt.xlabel('FPGA frame times / s') 1 ctx1m

620 plt.gca().set(yticklabels=[]) 1 ctx1m

621 plt.gca().tick_params(left=False) 1 ctx1m

622 plt.legend() 1 ctx1m

623 

624 outcome = self.overall_outcome( 3 ctx1mab

625 ('PASS' if size_diff == 0 else 'WARNING' if np.abs(size_diff) < 5 else 'FAIL', 

626 'PASS' if np.abs(ndiff_low2high) < 5 else 'WARNING') 

627 ) 

628 return outcome, ndiff_low2high, size_diff 3 ctx1mab

629 

630 def check_dropped_frames(self, threshold=.1): (empty)

631 """Check how many frames were reported missing 

632 

633 :param threshold: The maximum allowable percentage of dropped frames 

634 """ 

635 if not data_for_keys(('video', 'count'), self.data): 5 ctx1ncabd

636 return 'NOT_SET' 3 ctx1ncd

637 size_diff = int(self.data['count'].size - self.data['video']['length']) 3 ctx1nab

638 strict_increase = np.all(np.diff(self.data['count']) > 0) 3 ctx1nab

639 if not strict_increase: 3 ctx1nab

640 n_effected = np.sum(np.invert(strict_increase)) 1 ctx1n

641 _log.info(f'frame count not strictly increasing: ' 1 ctx1n

642 f'{n_effected} frames effected ({n_effected / strict_increase.size:.2%})') 

643 return 'CRITICAL' 1 ctx1n