#!/usr/bin/env python3 # SPDX-License-Identifier: GPL-2.0-or-later # Copyright (C) 2022, Tomi Valkeinen from typing import Any import argparse import binascii import libcamera as libcam import libcamera.utils import sys import traceback class CameraContext: camera: libcam.Camera id: str idx: int opt_stream: str opt_strict_formats: bool opt_crc: bool opt_metadata: bool opt_save_frames: bool opt_capture: int stream_names: dict[libcam.Stream, str] streams: list[libcam.Stream] allocator: libcam.FrameBufferAllocator requests: list[libcam.Request] reqs_queued: int reqs_completed: int last: int = 0 fps: float def __init__(self, camera, idx): self.camera = camera self.idx = idx self.id = 'cam' + str(idx) self.reqs_queued = 0 self.reqs_completed = 0 def do_cmd_list_props(self): print('Properties for', self.id) for cid, val in self.camera.properties.items(): print('\t{}: {}'.format(cid, val)) def do_cmd_list_controls(self): print('Controls for', self.id) for cid, info in self.camera.controls.items(): print('\t{}: {}'.format(cid, info)) def do_cmd_info(self): print('Stream info for', self.id) roles = [libcam.StreamRole.Viewfinder] camconfig = self.camera.generate_configuration(roles) if camconfig is None: raise Exception('Generating config failed') for i, stream_config in enumerate(camconfig): print('\t{}: {}'.format(i, stream_config)) formats = stream_config.formats for fmt in formats.pixel_formats: print('\t * Pixelformat:', fmt, formats.range(fmt)) for size in formats.sizes(fmt): print('\t -', size) def acquire(self): self.camera.acquire() def release(self): self.camera.release() def __parse_streams(self): streams = [] for stream_desc in self.opt_stream: stream_opts: dict[str, Any] stream_opts = {'role': libcam.StreamRole.Viewfinder} for stream_opt in stream_desc.split(','): if stream_opt == 0: continue arr = stream_opt.split('=') if len(arr) != 2: print('Bad stream option', stream_opt) sys.exit(-1) key = arr[0] value = arr[1] if key in ['width', 'height']: value = int(value) elif key == 'role': rolemap = { 'still': libcam.StreamRole.StillCapture, 'raw': libcam.StreamRole.Raw, 'video': libcam.StreamRole.VideoRecording, 'viewfinder': libcam.StreamRole.Viewfinder, } role = rolemap.get(value.lower(), None) if role is None: print('Bad stream role', value) sys.exit(-1) value = role elif key == 'pixelformat': pass else: print('Bad stream option key', key) sys.exit(-1) stream_opts[key] = value streams.append(stream_opts) return streams def configure(self): streams = self.__parse_streams() roles = [opts['role'] for opts in streams] camconfig = self.camera.generate_configuration(roles) if camconfig is None: raise Exception('Generating config failed') for idx, stream_opts in enumerate(streams): stream_config = camconfig.at(idx) if 'width' in stream_opts: stream_config.size.width = stream_opts['width'] if 'height' in stream_opts: stream_config.size.height = stream_opts['height'] if 'pixelformat' in stream_opts: stream_config.pixel_format = libcam.PixelFormat(stream_opts['pixelformat']) stat = camconfig.validate() if stat == libcam.CameraConfiguration.Status.Invalid: print('Camera configuration invalid') exit(-1) elif stat == libcam.CameraConfiguration.Status.Adjusted: if self.opt_strict_formats: print('Adjusting camera configuration disallowed by --strict-formats argument') exit(-1) print('Camera configuration adjusted') r = self.camera.configure(camconfig) if r != 0: raise Exception('Configure failed') self.stream_names = {} self.streams = [] for idx, stream_config in enumerate(camconfig): stream = stream_config.stream self.streams.append(stream) self.stream_names[stream] = 'stream' + str(idx) print('{}-{}: stream config {}'.format(self.id, self.stream_names[stream], stream.configuration)) def alloc_buffers(self): allocator = libcam.FrameBufferAllocator(self.camera) for stream in self.streams: ret = allocator.allocate(stream) if ret < 0: print('Cannot allocate buffers') exit(-1) allocated = len(allocator.buffers(stream)) print('{}-{}: Allocated {} buffers'.format(self.id, self.stream_names[stream], allocated)) self.allocator = allocator def create_requests(self): self.requests = [] # Identify the stream with the least number of buffers num_bufs = min([len(self.allocator.buffers(stream)) for stream in self.streams]) requests = [] for buf_num in range(num_bufs): request = self.camera.create_request(self.idx) if request is None: print('Can not create request') exit(-1) for stream in self.streams: buffers = self.allocator.buffers(stream) buffer = buffers[buf_num] ret = request.add_buffer(stream, buffer) if ret < 0: print('Can not set buffer for request') exit(-1) requests.append(request) self.requests = requests def start(self): self.camera.start() def stop(self): self.camera.stop() def queue_requests(self): for request in self.requests: self.camera.queue_request(request) self.reqs_queued += 1 del self.requests class CaptureState: cm: libcam.CameraManager contexts: list[CameraContext] renderer: Any def __init__(self, cm, contexts): self.cm = cm self.contexts = contexts # Called from renderer when there is a libcamera event def event_handler(self): try: reqs = self.cm.get_ready_requests() for req in reqs: ctx = next(ctx for ctx in self.contexts if ctx.idx == req.cookie) self.__request_handler(ctx, req) running = any(ctx.reqs_completed < ctx.opt_capture for ctx in self.contexts) return running except Exception: traceback.print_exc() return False def __request_handler(self, ctx, req): if req.status != libcam.Request.Status.Complete: raise Exception('{}: Request failed: {}'.format(ctx.id, req.status)) buffers = req.buffers # Compute the frame rate. The timestamp is arbitrarily retrieved from # the first buffer, as all buffers should have matching timestamps. ts = buffers[next(iter(buffers))].metadata.timestamp last = ctx.last fps = 1000000000.0 / (ts - last) if (last != 0 and (ts - last) != 0) else 0 ctx.last = ts ctx.fps = fps for stream, fb in buffers.items(): stream_name = ctx.stream_names[stream] crcs = [] if ctx.opt_crc: with libcamera.utils.MappedFrameBuffer(fb) as mfb: plane_crcs = [binascii.crc32(p) for p in mfb.planes] crcs.append(plane_crcs) meta = fb.metadata print('{:.6f} ({:.2f} fps) {}-{}: seq {}, bytes {}, CRCs {}' .format(ts / 1000000000, fps, ctx.id, stream_name, meta.sequence, '/'.join([str(p.bytes_used) for p in meta.planes]), crcs)) if ctx.opt_metadata: reqmeta = req.metadata for ctrl, val in reqmeta.items(): print(f'\t{ctrl} = {val}') if ctx.opt_save_frames: with libcamera.utils.MappedFrameBuffer(fb) as mfb: filename = 'frame-{}-{}-{}.data'.format(ctx.id, stream_name, ctx.reqs_completed) with open(filename, 'wb') as f: for p in mfb.planes: f.write(p) self.renderer.request_handler(ctx, req) ctx.reqs_completed += 1 # Called from renderer when it has finished with a request def request_processed(self, ctx, req): if ctx.reqs_queued < ctx.opt_capture: req.reuse() ctx.camera.queue_request(req) ctx.reqs_queued += 1 def __capture_init(self): for ctx in self.contexts: ctx.acquire() for ctx in self.contexts: ctx.configure() for ctx in self.contexts: ctx.alloc_buffers() for ctx in self.contexts: ctx.create_requests() def __capture_start(self): for ctx in self.contexts: ctx.start() for ctx in self.contexts: ctx.queue_requests() def __capture_deinit(self): for ctx in self.contexts: ctx.stop() for ctx in self.contexts: ctx.release() def do_cmd_capture(self): self.__capture_init() self.renderer.setup() self.__capture_start() self.renderer.run() self.__capture_deinit() class CustomAction(argparse.Action): def __init__(self, option_strings, dest, **kwargs): super().__init__(option_strings, dest, default={}, **kwargs) def __call__(self, parser, namespace, values, option_string=None): if len(namespace.camera) == 0: print(f'Option {option_string} requires a --camera context') sys.exit(-1) if self.type == bool: values = True current = namespace.camera[-1] data = getattr(namespace, self.dest) if self.nargs == '+': if current not in data: data[current] = [] data[current] += values else: data[current] = values def do_cmd_list(cm): print('Available cameras:') for idx, c in enumerate(cm.cameras): print(f'{idx + 1}: {c.id}') def main(): parser = argparse.ArgumentParser() # global options parser.add_argument('-l', '--list', action='store_true', help='List all cameras') parser.add_argument('-c', '--camera', type=int, action='extend', nargs=1, default=[], help='Specify which camera to operate on, by index') parser.add_argument('-p', '--list-properties', action='store_true', help='List cameras properties') parser.add_argument('--list-controls', action='store_true', help='List cameras controls') parser.add_argument('-I', '--info', action='store_true', help='Display information about stream(s)') parser.add_argument('-R', '--renderer', default='null', help='Renderer (null, kms, qt, qtgl)') # per camera options parser.add_argument('-C', '--capture', nargs='?', type=int, const=1000000, action=CustomAction, help='Capture until interrupted by user or until CAPTURE frames captured') parser.add_argument('--crc', nargs=0, type=bool, action=CustomAction, help='Print CRC32 for captured frames') parser.add_argument('--save-frames', nargs=0, type=bool, action=CustomAction, help='Save captured frames to files') parser.add_argument('--metadata', nargs=0, type=bool, action=CustomAction, help='Print the metadata for completed requests') parser.add_argument('--strict-formats', type=bool, nargs=0, action=CustomAction, help='Do not allow requested stream format(s) to be adjusted') parser.add_argument('-s', '--stream', nargs='+', action=CustomAction) args = parser.parse_args() cm = libcam.CameraManager.singleton() if args.list: do_cmd_list(cm) contexts = [] for cam_idx in args.camera: camera = next((c for i, c in enumerate(cm.cameras) if i + 1 == cam_idx), None) if camera is None: print('Unable to find camera', cam_idx) return -1 ctx = CameraContext(camera, cam_idx) ctx.opt_capture = args.capture.get(cam_idx, 0) ctx.opt_crc = args.crc.get(cam_idx, False) ctx.opt_save_frames = args.save_frames.get(cam_idx, False) ctx.opt_metadata = args.metadata.get(cam_idx, False) ctx.opt_strict_formats = args.strict_formats.get(cam_idx, False) ctx.opt_stream = args.stream.get(cam_idx, ['role=viewfinder']) contexts.append(ctx) for ctx in contexts: print('Using camera {} as {}'.format(ctx.camera.id, ctx.id)) for ctx in contexts: if args.list_properties: ctx.do_cmd_list_props() if args.list_controls: ctx.do_cmd_list_controls() if args.info: ctx.do_cmd_info() # Filter out capture contexts which are not marked for capture contexts = [ctx for ctx in contexts if ctx.opt_capture > 0] if contexts: state = CaptureState(cm, contexts) if args.renderer == 'null': import cam_null renderer = cam_null.NullRenderer(state) elif args.renderer == 'kms': import cam_kms renderer = cam_kms.KMSRenderer(state) elif args.renderer == 'qt': import cam_qt renderer = cam_qt.QtRenderer(state) elif args.renderer == 'qtgl': import cam_qtgl renderer = cam_qtgl.QtRenderer(state) else: print('Bad renderer', args.renderer) return -1 state.renderer = renderer state.do_cmd_capture() return 0 if __name__ == '__main__': sys.exit(main()) id='n345' href='#n345'>345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (C) 2019-2020, Raspberry Pi (Trading) Limited
#
# ctt_image_load.py - camera tuning tool image loading

from ctt_tools import *
from ctt_macbeth_locator import *
import json
import pyexiv2 as pyexif
import rawpy as raw


"""
Image class load image from raw data and extracts metadata.

Once image is extracted from data, it finds 24 16x16 patches for each
channel, centred at the macbeth chart squares
"""
class Image:
    def __init__(self, buf):
        self.buf = buf
        self.patches = None
        self.saturated = False

    '''
    obtain metadata from buffer
    '''
    def get_meta(self):
        self.ver = ba_to_b(self.buf[4:5])
        self.w = ba_to_b(self.buf[0xd0:0xd2])
        self.h = ba_to_b(self.buf[0xd2:0xd4])
        self.pad = ba_to_b(self.buf[0xd4:0xd6])
        self.fmt = self.buf[0xf5]
        self.sigbits = 2*self.fmt + 4
        self.pattern = self.buf[0xf4]
        self.exposure = ba_to_b(self.buf[0x90:0x94])
        self.againQ8 = ba_to_b(self.buf[0x94:0x96])
        self.againQ8_norm = self.againQ8/256
        camName = self.buf[0x10:0x10+128]
        camName_end = camName.find(0x00)
        self.camName = self.buf[0x10:0x10+128][:camName_end].decode()

        """
        Channel order depending on bayer pattern
        """
        bayer_case = {
            0: (0, 1, 2, 3),   # red
            1: (2, 0, 3, 1),   # green next to red
            2: (3, 2, 1, 0),   # green next to blue
            3: (1, 0, 3, 2),   # blue
            128: (0, 1, 2, 3)  # arbitrary order for greyscale casw
        }
        self.order = bayer_case[self.pattern]

        '''
        manual blacklevel - not robust
        '''
        if 'ov5647' in self.camName:
            self.blacklevel = 16
        else:
            self.blacklevel = 64
        self.blacklevel_16 = self.blacklevel << (6)
        return 1

    '''
    print metadata for debug
    '''
    def print_meta(self):
        print('\nData:')
        print('      ver = {}'.format(self.ver))
        print('      w = {}'.format(self.w))
        print('      h = {}'.format(self.h))
        print('      pad = {}'.format(self.pad))
        print('      fmt = {}'.format(self.fmt))
        print('      sigbits = {}'.format(self.sigbits))
        print('      pattern = {}'.format(self.pattern))
        print('      exposure = {}'.format(self.exposure))
        print('      againQ8 = {}'.format(self.againQ8))
        print('      againQ8_norm = {}'.format(self.againQ8_norm))
        print('      camName = {}'.format(self.camName))
        print('      blacklevel = {}'.format(self.blacklevel))
        print('      blacklevel_16 = {}'.format(self.blacklevel_16))

        return 1

    """
    get image from raw scanline data
    """
    def get_image(self, raw):
        self.dptr = []
        """
        check if data is 10 or 12 bits
        """
        if self.sigbits == 10:
            """
            calc length of scanline
            """
            lin_len = ((((((self.w+self.pad+3)>>2)) * 5)+31)>>5) * 32
            """
            stack scan lines into matrix
            """
            raw = np.array(raw).reshape(-1, lin_len).astype(np.int64)[:self.h, ...]
            """
            separate 5 bits in each package, stopping when w is satisfied
            """
            ba0 = raw[..., 0:5*((self.w+3)>>2):5]
            ba1 = raw[..., 1:5*((self.w+3)>>2):5]
            ba2 = raw[..., 2:5*((self.w+3)>>2):5]
            ba3 = raw[..., 3:5*((self.w+3)>>2):5]
            ba4 = raw[..., 4:5*((self.w+3)>>2):5]
            """
            assemble 10 bit numbers
            """
            ch0 = np.left_shift((np.left_shift(ba0, 2) + (ba4 % 4)), 6)
            ch1 = np.left_shift((np.left_shift(ba1, 2) + (np.right_shift(ba4, 2) % 4)), 6)
            ch2 = np.left_shift((np.left_shift(ba2, 2) + (np.right_shift(ba4, 4) % 4)), 6)
            ch3 = np.left_shift((np.left_shift(ba3, 2) + (np.right_shift(ba4, 6) % 4)), 6)
            """
            interleave bits
            """
            mat = np.empty((self.h, self.w), dtype=ch0.dtype)

            mat[..., 0::4] = ch0
            mat[..., 1::4] = ch1
            mat[..., 2::4] = ch2
            mat[..., 3::4] = ch3

            """
            There is som eleaking memory somewhere in the code. This code here
            seemed to make things good enough that the code would run for
            reasonable numbers of images, however this is techincally just a
            workaround. (sorry)
            """
            ba0, ba1, ba2, ba3, ba4 = None, None, None, None, None
            del ba0, ba1, ba2, ba3, ba4
            ch0, ch1, ch2, ch3 = None, None, None, None
            del ch0, ch1, ch2, ch3

            """
        same as before but 12 bit case
        """
        elif self.sigbits == 12:
            lin_len = ((((((self.w+self.pad+1)>>1)) * 3)+31)>>5) * 32
            raw = np.array(raw).reshape(-1, lin_len).astype(np.int64)[:self.h, ...]
            ba0 = raw[..., 0:3*((self.w+1)>>1):3]
            ba1 = raw[..., 1:3*((self.w+1)>>1):3]
            ba2 = raw[..., 2:3*((self.w+1)>>1):3]
            ch0 = np.left_shift((np.left_shift(ba0, 4) + ba2 % 16), 4)
            ch1 = np.left_shift((np.left_shift(ba1, 4) + (np.right_shift(ba2, 4)) % 16), 4)
            mat = np.empty((self.h, self.w), dtype=ch0.dtype)
            mat[..., 0::2] = ch0
            mat[..., 1::2] = ch1

        else:
            """
            data is neither 10 nor 12 or incorrect data
            """
            print('ERROR: wrong bit format, only 10 or 12 bit supported')
            return 0

        """
        separate bayer channels
        """
        c0 = mat[0::2, 0::2]
        c1 = mat[0::2, 1::2]
        c2 = mat[1::2, 0::2]
        c3 = mat[1::2, 1::2]
        self.channels = [c0, c1, c2, c3]
        return 1

    """
    obtain 16x16 patch centred at macbeth square centre for each channel
    """
    def get_patches(self, cen_coords, size=16):
        """
        obtain channel widths and heights
        """
        ch_w, ch_h = self.w, self.h
        cen_coords = list(np.array((cen_coords[0])).astype(np.int32))
        self.cen_coords = cen_coords
        """
        squares are ordered by stacking macbeth chart columns from
        left to right. Some useful patch indices:
            white = 3
            black = 23
            'reds' = 9, 10
            'blues' = 2, 5, 8, 20, 22
            'greens' = 6, 12, 17
            greyscale = 3, 7, 11, 15, 19, 23
        """
        all_patches = []
        for ch in self.channels:
            ch_patches = []
            for cen in cen_coords:
                '''
                macbeth centre is placed at top left of central 2x2 patch
                to account for rounding
                Patch pixels are sorted by pixel brightness so spatial
                information is lost.
                '''
                patch = ch[cen[1]-7:cen[1]+9, cen[0]-7:cen[0]+9].flatten()
                patch.sort()
                if patch[-5] == (2**self.sigbits-1)*2**(16-self.sigbits):
                    self.saturated = True
                ch_patches.append(patch)
                # print('\nNew Patch\n')
            all_patches.append(ch_patches)
            # print('\n\nNew Channel\n\n')
        self.patches = all_patches
        return 1


def brcm_load_image(Cam, im_str):
    """
    Load image where raw data and metadata is in the BRCM format
    """
    try:
        """
        create byte array
        """
        with open(im_str, 'rb') as image:
            f = image.read()
            b = bytearray(f)
        """
        return error if incorrect image address
        """
    except FileNotFoundError:
        print('\nERROR:\nInvalid image address')
        Cam.log += '\nWARNING: Invalid image address'
        return 0

    """
    return error if problem reading file
    """
    if f is None:
        print('\nERROR:\nProblem reading file')
        Cam.log += '\nWARNING: Problem readin file'
        return 0

    # print('\nLooking for EOI and BRCM header')
    """
    find end of image followed by BRCM header by turning
    bytearray into hex string and string matching with regexp
    """
    start = -1
    match = bytearray(b'\xff\xd9@BRCM')
    match_str = binascii.hexlify(match)
    b_str = binascii.hexlify(b)
    """
    note index is divided by two to go from string to hex
    """
    indices = [m.start()//2 for m in re.finditer(match_str, b_str)]
    # print(indices)
    try:
        start = indices[0] + 3
    except IndexError:
        print('\nERROR:\nNo Broadcom header found')
        Cam.log += '\nWARNING: No Broadcom header found!'
        return 0
    """
    extract data after header
    """
    # print('\nExtracting data after header')
    buf = b[start:start+32768]
    Img = Image(buf)
    Img.str = im_str
    # print('Data found successfully')

    """
    obtain metadata
    """
    # print('\nReading metadata')
    Img.get_meta()
    Cam.log += '\nExposure : {} us'.format(Img.exposure)
    Cam.log += '\nNormalised gain : {}'.format(Img.againQ8_norm)
    # print('Metadata read successfully')

    """
    obtain raw image data
    """
    # print('\nObtaining raw image data')
    raw = b[start+32768:]
    Img.get_image(raw)
    """
    delete raw to stop memory errors
    """
    raw = None
    del raw
    # print('Raw image data obtained successfully')

    return Img


def dng_load_image(Cam, im_str):
    try:
        Img = Image(None)

        # RawPy doesn't load all the image tags that we need, so we use py3exiv2
        metadata = pyexif.ImageMetadata(im_str)
        metadata.read()

        Img.ver = 100  # random value
        Img.w = metadata['Exif.SubImage1.ImageWidth'].value
        Img.pad = 0
        Img.h = metadata['Exif.SubImage1.ImageLength'].value
        white = metadata['Exif.SubImage1.WhiteLevel'].value
        Img.sigbits = int(white).bit_length()
        Img.fmt = (Img.sigbits - 4) // 2
        Img.exposure = int(metadata['Exif.Photo.ExposureTime'].value*1000000)
        Img.againQ8 = metadata['Exif.Photo.ISOSpeedRatings'].value*256/100
        Img.againQ8_norm = Img.againQ8 / 256
        Img.camName = metadata['Exif.Image.Model'].value
        Img.blacklevel = int(metadata['Exif.SubImage1.BlackLevel'].value[0])
        Img.blacklevel_16 = Img.blacklevel << (16 - Img.sigbits)
        bayer_case = {
            '0 1 1 2': (0, (0, 1, 2, 3)),
            '1 2 0 1': (1, (2, 0, 3, 1)),
            '2 1 1 0': (2, (3, 2, 1, 0)),
            '1 0 2 1': (3, (1, 0, 3, 2))
        }
        cfa_pattern = metadata['Exif.SubImage1.CFAPattern'].value
        Img.pattern = bayer_case[cfa_pattern][0]
        Img.order = bayer_case[cfa_pattern][1]

        # Now use RawPy tp get the raw Bayer pixels
        raw_im = raw.imread(im_str)
        raw_data = raw_im.raw_image
        shift = 16 - Img.sigbits
        c0 = np.left_shift(raw_data[0::2, 0::2].astype(np.int64), shift)
        c1 = np.left_shift(raw_data[0::2, 1::2].astype(np.int64), shift)
        c2 = np.left_shift(raw_data[1::2, 0::2].astype(np.int64), shift)
        c3 = np.left_shift(raw_data[1::2, 1::2].astype(np.int64), shift)
        Img.channels = [c0, c1, c2, c3]

    except Exception:
        print("\nERROR: failed to load DNG file", im_str)
        print("Either file does not exist or is incompatible")
        Cam.log += '\nERROR: DNG file does not exist or is incompatible'
        raise

    return Img


'''
load image from file location and perform calibration
check correct filetype

mac boolean is true if image is expected to contain macbeth chart and false
if not (alsc images don't have macbeth charts)
'''
def load_image(Cam, im_str, mac_config=None, show=False, mac=True, show_meta=False):
    """
    check image is correct filetype
    """
    if '.jpg' in im_str or '.jpeg' in im_str or '.brcm' in im_str or '.dng' in im_str:
        if '.dng' in im_str:
            Img = dng_load_image(Cam, im_str)
        else:
            Img = brcm_load_image(Cam, im_str)
        if show_meta:
            Img.print_meta()

        if mac:
            """
            find macbeth centres, discarding images that are too dark or light
            """
            av_chan = (np.mean(np.array(Img.channels), axis=0)/(2**16))
            av_val = np.mean(av_chan)
            # print(av_val)
            if av_val < Img.blacklevel_16/(2**16)+1/64:
                macbeth = None
                print('\nError: Image too dark!')
                Cam.log += '\nWARNING: Image too dark!'
            else:
                macbeth = find_macbeth(Cam, av_chan, mac_config)

            """
            if no macbeth found return error
            """
            if macbeth is None:
                print('\nERROR: No macbeth chart found')
                return 0
            mac_cen_coords = macbeth[1]
            # print('\nMacbeth centres located successfully')

            """
            obtain image patches
            """
            # print('\nObtaining image patches')
            Img.get_patches(mac_cen_coords)
            if Img.saturated:
                print('\nERROR: Macbeth patches have saturated')
                Cam.log += '\nWARNING: Macbeth patches have saturated!'
                return 0

        """
        clear memory
        """
        Img.buf = None
        del Img.buf

        # print('Image patches obtained successfully')

        """
        optional debug
        """
        if show and __name__ == '__main__':
            copy = sum(Img.channels)/2**18
            copy = np.reshape(copy, (Img.h//2, Img.w//2)).astype(np.float64)
            copy, _ = reshape(copy, 800)
            represent(copy)

        return Img

        """
    return error if incorrect filetype
    """
    else:
        # print('\nERROR:\nInvalid file extension')
        return 0


"""
bytearray splice to number little endian
"""
def ba_to_b(b):
    total = 0
    for i in range(len(b)):
        total += 256**i * b[i]
    return total
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-20 22:04:31 +0000