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

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)

44from matplotlib.patches import Rectangle (empty)

45 

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

47from one.alf import spec (empty)

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

49from iblutil.util import Bunch (empty)

50from iblutil.numerical import within_ranges (empty)

51 

52import ibllib.io.extractors.camera as camio (empty)

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

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

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

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

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

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

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

60from . import base (empty)

61 

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

63 

64try: (empty)

65 from labcams import parse_cam_log (empty)

66except ImportError: 

67 _log.warning('labcams not installed') 

68 

69 

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

71 """A class for computing camera QC metrics.""" 

72 

73 dstypes = [ (empty)

74 '_ibl_experiment.description', 

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

76 '_iblrig_Camera.frame_counter', 

77 '_iblrig_Camera.GPIO', 

78 '_iblrig_Camera.timestamps', 

79 '_iblrig_taskData.raw', 

80 '_iblrig_taskSettings.raw', 

81 '_iblrig_Camera.raw', 

82 'camera.times', 

83 'wheel.position', 

84 'wheel.timestamps' 

85 ] 

86 dstypes_fpga = [ (empty)

87 '_spikeglx_sync.channels', 

88 '_spikeglx_sync.polarities', 

89 '_spikeglx_sync.times', 

90 'ephysData.raw.meta' 

91 ] 

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

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

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

95 video_meta = { (empty)

96 'training': { 

97 'left': { 

98 'fps': 30, 

99 'width': 1280, 

100 'height': 1024 

101 } 

102 }, 

103 'ephys': { 

104 'left': { 

105 'fps': 60, 

106 'width': 1280, 

107 'height': 1024 

108 }, 

109 'right': { 

110 'fps': 150, 

111 'width': 640, 

112 'height': 512 

113 }, 

114 'body': { 

115 'fps': 30, 

116 'width': 640, 

117 'height': 512 

118 }, 

119 } 

120 } 

121 

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

123 """ 

124 Compute and view camera QC metrics. 

125 

126 :param session_path_or_eid: A session id or path 

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

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

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

130 the remote source. 

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

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

133 """ 

134 self.stream = kwargs.pop('stream', None) 6 ctx1fcahgb

135 self.n_samples = kwargs.pop('n_samples', 100) 6 ctx1fcahgb

136 self.sync_collection = kwargs.pop('sync_collection', None) 6 ctx1fcahgb

137 self.sync = kwargs.pop('sync_type', None) 6 ctx1fcahgb

138 super().__init__(session_path_or_eid, **kwargs) 6 ctx1fcahgb

139 

140 # Data 

141 self.label = assert_valid_label(camera) 6 ctx1fcahgb

142 filename = f'_iblrig_{self.label}Camera.raw*.mp4' 6 ctx1fcahgb

143 raw_video_path = self.session_path.joinpath('raw_video_data') 6 ctx1fcahgb

144 self.video_path = next(raw_video_path.glob(filename), None) 6 ctx1fcahgb

145 

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

147 if not self.video_path and self.stream is not False and self.one is not None: 6 ctx1fcahgb

148 try: 

149 self.stream = True 

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

151 except (StopIteration, ALFObjectNotFound): 

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

153 self.video_path = None 

154 

155 logging.disable(logging.NOTSET) 6 ctx1fcahgb

156 keys = ('count', 'pin_state', 'audio', 'fpga_times', 'wheel', 'video', 6 ctx1fcahgb

157 'frame_samples', 'timestamps', 'camera_times', 'bonsai_times') 

158 self.data = Bunch.fromkeys(keys) 6 ctx1fcahgb

159 self.frame_samples_idx = None 6 ctx1fcahgb

160 

161 # QC outcomes map 

162 self.metrics = None 6 ctx1fcahgb

163 self.outcome = spec.QC.NOT_SET 6 ctx1fcahgb

164 

165 # Specify any checks to remove 

166 self.checks_to_remove = [] 6 ctx1fcahgb

167 self._type = None 6 ctx1fcahgb

168 

169 @property (empty)

170 def type(self): (empty)

171 """ 

172 Returns the camera type based on the protocol. 

173 

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

175 """ 

176 if not self._type: 8 ctx1trocagbe

177 return 

178 else: 

179 return 'ephys' if 'ephys' in self._type else 'training' 8 ctx1trocagbe

180 

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

182 """Extract the data from raw data files. 

183 

184 Extracts all the required task data from the raw data files. Missing data will raise an 

185 AssertionError. TODO This method could instead be moved to CameraExtractor classes. 

186 

187 Data keys: 

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

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

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

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

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

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

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

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

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

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

198 

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

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

201 """ 

202 assert self.session_path, 'no session path set' 5 ctx1cahgb

203 _log.info('Gathering data for QC') 5 ctx1cahgb

204 

205 # Get frame count and pin state 

206 self.data['count'], self.data['pin_state'] = \ 5 ctx1cahgb

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

208 

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

210 sess_params = read_params(self.session_path) or {} 5 ctx1cahgb

211 task_collection = get_task_collection(sess_params) 5 ctx1cahgb

212 ns = get_sync_namespace(sess_params) 5 ctx1cahgb

213 self._set_sync(sess_params) 5 ctx1cahgb

214 self._update_meta_from_session_params(sess_params) 5 ctx1cahgb

215 

216 # Load the audio and raw FPGA times 

217 sync = chmap = None 5 ctx1cahgb

218 if self.sync != 'bpod' and self.sync is not None: 5 ctx1cahgb

219 self.sync_collection = self.sync_collection or 'raw_ephys_data' 2 ctx1ag

220 ns = ns or 'spikeglx' 2 ctx1ag

221 if ns == 'spikeglx': 2 ctx1ag

222 sync, chmap = ephys_fpga.get_sync_and_chn_map(self.session_path, self.sync_collection) 2 ctx1ag

223 elif ns == 'timeline': 1 ctx1g

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

225 else: 

226 raise NotImplementedError(f'Unknown namespace "{ns}"') 1 ctx1g

227 audio_ttls = ephys_fpga.get_sync_fronts(sync, chmap['audio']) 2 ctx1ag

228 self.data['audio'] = audio_ttls['times'] # Get rises 2 ctx1ag

229 # Load raw FPGA times 

230 cam_ts = camio.extract_camera_sync(sync, chmap) 2 ctx1ag

231 self.data['fpga_times'] = cam_ts[self.label] 2 ctx1ag

232 else: 

233 self.sync_collection = self.sync_collection or task_collection 4 ctx1chgb

234 bpod_data = raw.load_data(self.session_path, task_collection) 4 ctx1chgb

235 _, audio_ttls = raw.load_bpod_fronts( 4 ctx1chgb

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

237 self.data['audio'] = audio_ttls['times'] 4 ctx1chgb

238 

239 # Load extracted frame times 

240 alf_path = self.session_path / 'alf' 5 ctx1cahgb

241 try: 5 ctx1cahgb

242 assert not extract_times 5 ctx1cahgb

243 self.data['timestamps'] = alfio.load_object( 3 ctx1chg

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

245 except AssertionError: # Re-extract 3 ctx1ahb

246 kwargs = dict(video_path=self.video_path, save=False) 2 ctx1ab

247 if self.sync == 'bpod': 2 ctx1ab

248 extractor = camio.CameraTimestampsBpod(self.session_path) 1 ctx1b

249 kwargs['task_collection'] = task_collection 1 ctx1b

250 else: 

251 kwargs.update(sync=sync, chmap=chmap) 1 ctx1a

252 extractor = camio.CameraTimestampsFPGA(self.label, self.session_path) 1 ctx1a

253 self.data['timestamps'] = extractor.extract(**kwargs)[0] 2 ctx1ab

254 except ALFObjectNotFound: 1 ctx1h

255 _log.warning('no camera.times ALF found for session') 1 ctx1h

256 

257 # Get audio and wheel data 

258 wheel_keys = ('timestamps', 'position') 5 ctx1cahgb

259 try: 5 ctx1cahgb

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

261 alf_path = next(alf_path.rglob('*wheel.timestamps*')).parent 5 ctx1cahgb

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

263 except (StopIteration, ALFObjectNotFound): 1 ctx1h

264 # Extract from raw data 

265 if self.sync != 'bpod' and self.sync is not None: 1 ctx1h

266 if ns == 'spikeglx': 

267 wheel_data = ephys_fpga.extract_wheel_sync(sync, chmap) 

268 elif ns == 'timeline': 

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

270 wheel_data = extractor.extract_wheel_sync() 

271 else: 

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

273 else: 

274 wheel_data = training_wheel.get_wheel_position( 1 ctx1h

275 self.session_path, task_collection=task_collection) 

276 self.data['wheel'] = Bunch(zip(wheel_keys, wheel_data)) 1 ctx1h

277 

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

279 if data_for_keys(wheel_keys, self.data['wheel']) and self.data['timestamps'] is not None: 5 ctx1cahgb

280 self.data['wheel'].period = self.get_active_wheel_period(self.data['wheel']) 4 ctx1cagb

281 

282 # Load Bonsai frame timestamps 

283 try: 5 ctx1cahgb

284 ssv_times = raw.load_camera_ssv_times(self.session_path, self.label) 5 ctx1cahgb

285 self.data['bonsai_times'], self.data['camera_times'] = ssv_times 5 ctx1cahgb

286 except AssertionError: 

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

288 

289 # Gather information from video file 

290 if load_video: 5 ctx1cahgb

291 _log.info('Inspecting video file...') 4 ctx1cahb

292 self.load_video_data() 4 ctx1cahb

293 

294 def load_video_data(self): (empty)

295 """Get basic properties of video. 

296 

297 Updates the `data` property with video metadata such as length and frame count, as well as 

298 loading some frames to perform QC on. 

299 """ 

300 try: 5 ctx1fcahb

301 self.data['video'] = get_video_meta(self.video_path, one=self.one) 5 ctx1fcahb

302 # Sample some frames from the video file 

303 indices = np.linspace(100, self.data['video'].length - 100, self.n_samples).astype(int) 5 ctx1fcahb

304 self.frame_samples_idx = indices 5 ctx1fcahb

305 self.data['frame_samples'] = get_video_frames_preload(self.video_path, indices, 5 ctx1fcahb

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

307 except AssertionError: 

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

309 self._outcome = spec.QC.CRITICAL 

310 

311 @staticmethod (empty)

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

313 """ 

314 Find period of active wheel movement. 

315 

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

317 wheel motion alignment QC. 

318 

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

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

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

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

323 """ 

324 pos, ts = wh.interpolate_position(wheel.timestamps, wheel.position) 5 ctx1mcagb

325 v, acc = wh.velocity_filtered(pos, 1000) 5 ctx1mcagb

326 on, off, *_ = wh.movements(ts, acc, pos_thresh=.1, make_plots=False) 5 ctx1mcagb

327 edges = np.c_[on, off] 5 ctx1mcagb

328 indices, _ = np.where(np.logical_and( 5 ctx1mcagb

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

330 if len(indices) == 0: 5 ctx1mcagb

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

332 return None 1 ctx1m

333 # Pick movement somewhere in the middle 

334 i = indices[int(indices.size / 2)] 4 ctx1cagb

335 if display: 4 ctx1cagb

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

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

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

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

340 return edges[i] 4 ctx1cagb

341 

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

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

344 

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

346 

347 Parameters 

348 ---------- 

349 session_params : dict, bool 

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

351 """ 

352 if session_params is False: 5 ctx1cahgb

353 if not self.session_path: 

354 raise ValueError('No session path set') 

355 session_params = read_params(self.session_path) 

356 sync, sync_dict = get_sync(session_params) 5 ctx1cahgb

357 self.sync = self.sync or sync 5 ctx1cahgb

358 self.sync_collection = self.sync_collection or sync_dict.get('collection') 5 ctx1cahgb

359 if self.sync: 5 ctx1cahgb

360 self._type = 'ephys' if self.sync == 'nidq' else 'training' 4 ctx1cagb

361 

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

363 """ 

364 Update the default expected video properties. 

365 

366 Use properties defined in the experiment description file, if present. This updates the 

367 `video_meta` property with the fps, width and height for the type and camera label. 

368 

369 Parameters 

370 ---------- 

371 sess_params : dict 

372 The loaded experiment description file. 

373 """ 

374 try: 5 ctx1cahgb

375 assert sess_params 5 ctx1cahgb

376 video_pars = sess_params.get('devices', {}).get('cameras', {}).get(self.label) 4 ctx1cagb

377 except (AssertionError, KeyError): 1 ctx1h

378 return 1 ctx1h

379 PROPERTIES = ('width', 'height', 'fps') 4 ctx1cagb

380 video_meta = copy.deepcopy(self.video_meta) # must re-assign as it's a class attribute 4 ctx1cagb

381 if self.type not in video_meta: 4 ctx1cagb

382 video_meta[self.type] = {} 

383 if self.label not in video_meta[self.type]: 4 ctx1cagb

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

385 video_meta[self.type][self.label].update( 4 ctx1cagb

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

387 ) 

388 self.video_meta = video_meta 4 ctx1cagb

389 

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

391 """ 

392 Run video QC checks and return outcome. 

393 

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

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

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

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

398 """ 

399 _log.info(f'Computing QC outcome for {self.label} camera, session {self.eid}') 4 ctx1cahb

400 namespace = f'video{self.label.capitalize()}' 4 ctx1cahb

401 if all(x is None for x in self.data.values()): 4 ctx1cahb

402 self.load_data(**kwargs) 3 ctx1cah

403 if self.data['frame_samples'] is None or self.data['timestamps'] is None: 4 ctx1cahb

404 return spec.QC.NOT_SET, {} 1 ctx1h

405 if self.data['timestamps'].shape[0] == 0: 3 ctx1cab

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

407 return spec.QC.CRITICAL, {} 

408 

409 def is_metric(x): 3 ctx1cab

410 return isfunction(x) and x.__name__.startswith('check_') 3 ctx1cab

411 # import importlib 

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

413 # print(classe) 

414 

415 checks = getmembers(self.__class__, is_metric) 3 ctx1cab

416 checks = self._remove_check(checks) 3 ctx1cab

417 self.metrics = {f'_{namespace}_' + k[6:]: fn(self) for k, fn in checks} 3 ctx1cab

418 

419 values = [x if isinstance(x, spec.QC) else x[0] for x in self.metrics.values()] 3 ctx1cab

420 outcome = max(map(spec.QC.validate, values)) 3 ctx1cab

421 

422 if update: 3 ctx1cab

423 extended = dict() 1 ctx1c

424 for k, v in self.metrics.items(): 1 ctx1c

425 if v is None: 1 ctx1c

426 extended[k] = spec.QC.NOT_SET.name 

427 elif isinstance(v, tuple): 1 ctx1c

428 extended[k] = tuple(i.name if isinstance(i, spec.QC) else i for i in v) 1 ctx1c

429 else: 

430 extended[k] = v.name 1 ctx1c

431 

432 self.update_extended_qc(extended) 1 ctx1c

433 self.update(outcome, namespace) 1 ctx1c

434 return outcome, self.metrics 3 ctx1cab

435 

436 def _remove_check(self, checks): (empty)

437 """ 

438 Remove one or more check functions from QC checklist. 

439 

440 Parameters 

441 ---------- 

442 checks : list of tuple 

443 The complete list of check function name and handle. 

444 

445 Returns 

446 ------- 

447 list of tuple 

448 The list of check function name and handle, sans names in `checks_to_remove` property. 

449 """ 

450 if len(self.checks_to_remove) == 0: 3 ctx1cab

451 return checks 3 ctx1cab

452 else: 

453 for check in self.checks_to_remove: 

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

455 idx = check_names.index(check) 

456 checks.pop(idx) 

457 return checks 

458 

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

460 """Check that the video brightness is within a given range. 

461 

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

463 deviation across samples frames should be less than the given value. Assumes that the 

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

465 

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

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

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

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

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

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

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

473 """ 

474 if self.data['frame_samples'] is None: 5 ctx1jcabe

475 return spec.QC.NOT_SET 1 ctx1j

476 if roi is True: 5 ctx1jcabe

477 _, h, w = self.data['frame_samples'].shape 5 ctx1jcabe

478 if self.label == 'body': # Latter half 5 ctx1jcabe

479 roi = (slice(None), slice(None), slice(int(w / 2), None, None)) 1 ctx1e

480 elif self.label == 'left': # Top left quadrant (~2/3, 1/2 height) 5 ctx1jcabe

481 roi = (slice(None), slice(None, int(h / 2), None), slice(None, int(w * .66), None)) 5 ctx1jcabe

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

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

484 else: 

485 roi = (slice(None), slice(None), slice(None)) 

486 brightness = self.data['frame_samples'][roi].mean(axis=(1, 2)) 5 ctx1jcabe

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

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

489 

490 if display: 5 ctx1jcabe

491 f = plt.figure() 1 ctx1j

492 gs = f.add_gridspec(2, 3) 1 ctx1j

493 indices = self.frame_samples_idx 1 ctx1j

494 # Plot mean frame luminance 

495 ax = f.add_subplot(gs[:2, :2]) 1 ctx1j

496 plt.plot(indices, brightness, label='brightness') 1 ctx1j

497 ax.set( 1 ctx1j

498 xlabel='frame #', 

499 ylabel='brightness (mean pixel)', 

500 title='Brightness') 

501 ax.hlines(bounds, 0, indices[-1], 1 ctx1j

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

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

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

505 ax.legend() 1 ctx1j

506 # Plot min-max frames 

507 for i, idx in enumerate((np.argmax(brightness), np.argmin(brightness))): 1 ctx1j

508 a = f.add_subplot(gs[i, 2]) 1 ctx1j

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

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

511 frame = self.data['frame_samples'][idx][roi[1:]] 1 ctx1j

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

513 self.imshow(frame, ax=a, title=title) 1 ctx1j

514 

515 PCT_PASS = .75 # Proportion of sample frames that must pass 5 ctx1jcabe

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

517 warn_range = np.logical_and(brightness > bounds[0], brightness < bounds[1]) 5 ctx1jcabe

518 warn_range = 'PASS' if sum(warn_range) / self.n_samples > PCT_PASS else 'WARNING' 5 ctx1jcabe

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

520 fail_range = np.logical_and(brightness > bounds[0] / 2, brightness < bounds[1] * 2) 5 ctx1jcabe

521 within_range = sum(fail_range) / self.n_samples > PCT_PASS 5 ctx1jcabe

522 fail_range = 'PASS' if within_range and np.std(brightness) < max_std else 'FAIL' 5 ctx1jcabe

523 return self.overall_outcome([warn_range, fail_range]) 5 ctx1jcabe

524 

525 def check_file_headers(self): (empty)

526 """Check reported frame rate matches FPGA frame rate.""" 

527 if None in (self.data['video'], self.video_meta): 5 ctx1tcabe

528 return spec.QC.NOT_SET 1 ctx1t

529 expected = self.video_meta[self.type][self.label] 5 ctx1tcabe

530 return spec.QC.PASS if self.data['video']['fps'] == expected['fps'] else spec.QC.FAIL 5 ctx1tcabe

531 

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

533 """Check camera times match specified frame rate for camera. 

534 

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

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

537 """ 

538 if any(x is None for x in (self.data['timestamps'], self.video_meta)): 4 ctx1rcab

539 return spec.QC.NOT_SET 1 ctx1r

540 fps = self.video_meta[self.type][self.label]['fps'] 4 ctx1rcab

541 Fs = 1 / np.median(np.diff(self.data['timestamps'])) # Approx. frequency of camera 4 ctx1rcab

542 return spec.QC.PASS if abs(Fs - fps) < threshold else spec.QC.FAIL, float(round(Fs, 3)) 4 ctx1rcab

543 

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

545 """Check the pin state reflects Bpod TTLs.""" 

546 if not data_for_keys(('video', 'pin_state', 'audio'), self.data): 4 ctx1kcab

547 return spec.QC.NOT_SET 2 ctx1kc

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

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

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

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

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

553 # state_ttl_matches = ndiff_low2high == 0 

554 # Check within ms of audio times 

555 if display: 3 ctx1kab

556 plt.Figure() 1 ctx1k

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

558 label='GPIO Low -> High') 

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

560 label='Audio TTL High') 

561 plt.xlabel('FPGA frame times / s') 1 ctx1k

562 plt.gca().set(yticklabels=[]) 1 ctx1k

563 plt.gca().tick_params(left=False) 1 ctx1k

564 plt.legend() 1 ctx1k

565 

566 outcome = self.overall_outcome( 3 ctx1kab

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

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

569 ) 

570 return outcome, ndiff_low2high, size_diff 3 ctx1kab

571 

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

573 """Check how many frames were reported missing. 

574 

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

576 """ 

577 if not data_for_keys(('video', 'count'), self.data): 4 ctx1lcab

578 return spec.QC.NOT_SET 2 ctx1lc

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

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

581 if not strict_increase: 3 ctx1lab

582 n_affected = np.sum(np.invert(strict_increase)) 1 ctx1l

583 _log.info(f'frame count not strictly increasing: ' 1 ctx1l

584 f'{n_affected} frames affected ({n_affected / strict_increase.size:.2%})') 

585 return spec.QC.CRITICAL 1 ctx1l

586 dropped = np.diff(self.data['count']).astype(int) - 1 3 ctx1lab

587 pct_dropped = (sum(dropped) / len(dropped) * 100) 3 ctx1lab

588 # Calculate overall outcome for this check 

589 outcome = self.overall_outcome( 3 ctx1lab

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

591 'PASS' if pct_dropped < threshold else 'FAIL') 

592 ) 

593 return outcome, int(sum(dropped)), size_diff 3 ctx1lab

594 

595 def check_timestamps(self): (empty)

596 """Check that the camera.times array is reasonable.""" 

597 if not data_for_keys(('timestamps', 'video'), self.data): 4 ctx1scab

598 return spec.QC.NOT_SET 1 ctx1s

599 # Check number of timestamps matches video 

600 length_matches = self.data['timestamps'].size == self.data['video'].length 4 ctx1scab

601 # Check times are strictly increasing 

602 increasing = all(np.diff(self.data['timestamps']) > 0) 4 ctx1scab

603 # Check times do not contain nans 

604 nanless = not np.isnan(self.data['timestamps']).any() 4 ctx1scab

605 return spec.QC.PASS if increasing and length_matches and nanless else spec.QC.FAIL 4 ctx1scab

606 

607 def check_camera_times(self): (empty)

608 """Check that the number of raw camera timestamps matches the number of video frames.""" 

609 if not data_for_keys(('bonsai_times', 'video'), self.data): 4 ctx1ucab

610 return spec.QC.NOT_SET 1 ctx1u

611 length_match = len(self.data['camera_times']) == self.data['video'].length 4 ctx1ucab

612 outcome = spec.QC.PASS if length_match else spec.QC.WARNING 4 ctx1ucab

613 # 1 / np.median(np.diff(self.data.camera_times)) 

614 return outcome, len(self.data['camera_times']) - self.data['video'].length 4 ctx1ucab

615 

616 def check_resolution(self): (empty)

617 """Check that the timestamps and video file resolution match what we expect.""" 

618 if self.data['video'] is None: 5 ctx1ocabe

619 return spec.QC.NOT_SET 1 ctx1o

620 actual = self.data['video'] 5 ctx1ocabe

621 expected = self.video_meta[self.type][self.label] 5 ctx1ocabe

622 match = actual['width'] == expected['width'] and actual['height'] == expected['height'] 5 ctx1ocabe

623 return spec.QC.PASS if match else spec.QC.FAIL 5 ctx1ocabe

624 

625 def check_wheel_alignment(self, tolerance=(1, 2), display=False): (empty)

626 """Check wheel motion in video correlates with the rotary encoder signal. 

627 

628 Check is skipped for body camera videos as the wheel is often obstructed 

629 

630 Parameters 

631 ---------- 

632 tolerance : int, (int, int) 

633 Maximum absolute offset in frames. If two values, the maximum value is taken as the 

634 warning threshold. 

635 display : bool 

636 If true, the wheel motion energy is plotted against the rotary encoder. 

637 

638 Returns 

639 ------- 

640 one.alf.spec.QC 

641 The outcome, one of {'NOT_SET', 'FAIL', 'WARNING', 'PASS'}. 

642 int 

643 Frame offset, i.e. by how many frames the video was shifted to match the rotary encoder 

644 signal. Negative values mean the video was shifted backwards with respect to the wheel 

645 timestamps. 

646 

647 Notes 

648 ----- 

649 - A negative frame offset typically means that there were frame TTLs at the beginning that 

650 do not correspond to any video frames (sometimes the first few frames aren't saved to 

651 disk). Since 2021-09-15 the extractor should compensate for this. 

652 """ 

653 wheel_present = data_for_keys(('position', 'timestamps', 'period'), self.data['wheel']) 5 ctx1nmcab

654 if not wheel_present or self.label == 'body': 5 ctx1nmcab

655 return spec.QC.NOT_SET 2 ctx1nm

656 

657 # Check the selected wheel movement period occurred within camera timestamp time 

658 camera_times = self.data['timestamps'] 4 ctx1ncab

659 in_range = within_ranges(camera_times, self.data['wheel']['period'].reshape(-1, 2)) 4 ctx1ncab

660 if not in_range.any(): 4 ctx1ncab

661 # Check if any camera timestamps overlap with the wheel times 

662 if np.any(np.logical_and( 2 ctx1nc

663 camera_times > self.data['wheel']['timestamps'][0], 

664 camera_times < self.data['wheel']['timestamps'][-1])