/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2018, Google Inc.
 *
 * camera.cpp - Camera device
 */

#include <libcamera/camera.h>

#include <iomanip>

#include <libcamera/request.h>
#include <libcamera/stream.h>

#include "log.h"
#include "pipeline_handler.h"
#include "utils.h"

/**
 * \file camera.h
 * \brief Camera device handling
 *
 * At the core of libcamera is the camera device, combining one image source
 * with processing hardware able to provide one or multiple image streams. The
 * Camera class represents a camera device.
 *
 * A camera device contains a single image source, and separate camera device
 * instances relate to different image sources. For instance, a phone containing
 * front and back image sensors will be modelled with two camera devices, one
 * for each sensor. When multiple streams can be produced from the same image
 * source, all those streams are guaranteed to be part of the same camera
 * device.
 *
 * While not sharing image sources, separate camera devices can share other
 * system resources, such as an ISP. For this reason camera device instances may
 * not be fully independent, in which case usage restrictions may apply. For
 * instance, a phone with a front and a back camera device may not allow usage
 * of the two devices simultaneously.
 */

namespace libcamera {

LOG_DECLARE_CATEGORY(Camera)

/**
 * \class CameraConfiguration
 * \brief Hold configuration for streams of the camera

 * The CameraConfiguration holds an ordered list of stream configurations. It
 * supports iterators and operates as a vector of StreamConfiguration instances.
 * The stream configurations are inserted by addConfiguration(), and the
 * operator[](int) returns a reference to the StreamConfiguration based on its
 * insertion index. Accessing a stream configuration with an invalid index
 * results in undefined behaviour.
 *
 * CameraConfiguration instances are retrieved from the camera with
 * Camera::generateConfiguration(). Applications may then inspect the
 * configuration, modify it, and possibly add new stream configuration entries
 * with addConfiguration(). Once the camera configuration satisfies the
 * application, it shall be validated by a call to validate(). The validation
 * implements "try" semantics: it adjusts invalid configurations to the closest
 * achievable parameters instead of rejecting them completely. Applications
 * then decide whether to accept the modified configuration, or try again with
 * a different set of parameters. Once the configuration is valid, it is passed
 * to Camera::configure().
 */

/**
 * \enum CameraConfiguration::Status
 * \brief Validity of a camera configuration
 * \var CameraConfiguration::Valid
 * The configuration is fully valid
 * \var CameraConfiguration::Adjusted
 * The configuration has been adjusted to a valid configuration
 * \var CameraConfiguration::Invalid
 * The configuration is invalid and can't be adjusted automatically
 */

/**
 * \typedef CameraConfiguration::iterator
 * \brief Iterator for the stream configurations in the camera configuration
 */

/**
 * \typedef CameraConfiguration::const_iterator
 * \brief Const iterator for the stream configuration in the camera
 * configuration
 */

/**
 * \brief Create an empty camera configuration
 */
CameraConfiguration::CameraConfiguration()
	: config_({})
{
}

CameraConfiguration::~CameraConfiguration()
{
}

/**
 * \brief Add a stream configuration to the camera configuration
 * \param[in] cfg The stream configuration
 */
void CameraConfiguration::addConfiguration(const StreamConfiguration &cfg)
{
	config_.push_back(cfg);
}

/**
 * \fn CameraConfiguration::validate()
 * \brief Validate and possibly adjust the camera configuration
 *
 * This method adjusts the camera configuration to the closest valid
 * configuration and returns the validation status.
 *
 * \todo: Define exactly when to return each status code. Should stream
 * parameters set to 0 by the caller be adjusted without returning Adjusted ?
 * This would potentially be useful for applications but would get in the way
 * in Camera::configure(). Do we need an extra status code to signal this ?
 *
 * \todo: Handle validation of buffers count when refactoring the buffers API.
 *
 * \return A CameraConfiguration::Status value that describes the validation
 * status.
 * \retval CameraConfiguration::Invalid The configuration is invalid and can't
 * be adjusted. This may only occur in extreme cases such as when the
 * configuration is empty.
 * \retval CameraConfigutation::Adjusted The configuration has been adjusted
 * and is now valid. Parameters may have changed for any stream, and stream
 * configurations may have been removed. The caller shall check the
 * configuration carefully.
 * \retval CameraConfiguration::Valid The configuration was already valid and
 * hasn't been adjusted.
 */

/**
 * \brief Retrieve a reference to a stream configuration
 * \param[in] index Numerical index
 *
 * The \a index represents the zero based insertion order of stream
 * configuration into the camera configuration with addConfiguration(). Calling
 * this method with an invalid index results in undefined behaviour.
 *
 * \return The stream configuration
 */
StreamConfiguration &CameraConfiguration::at(unsigned int index)
{
	return config_[index];
}

/**
 * \brief Retrieve a const reference to a stream configuration
 * \param[in] index Numerical index
 *
 * The \a index represents the zero based insertion order of stream
 * configuration into the camera configuration with addConfiguration(). Calling
 * this method with an invalid index results in undefined behaviour.
 *
 * \return The stream configuration
 */
const StreamConfiguration &CameraConfiguration::at(unsigned int index) const
{
	return config_[index];
}

/**
 * \fn StreamConfiguration &CameraConfiguration::operator[](unsigned int)
 * \brief Retrieve a reference to a stream configuration
 * \param[in] index Numerical index
 *
 * The \a index represents the zero based insertion order of stream
 * configuration into the camera configuration with addConfiguration(). Calling
 * this method with an invalid index results in undefined behaviour.
 *
 * \return The stream configuration
 */

/**
 * \fn const StreamConfiguration &CameraConfiguration::operator[](unsigned int) const
 * \brief Retrieve a const reference to a stream configuration
 * \param[in] index Numerical index
 *
 * The \a index represents the zero based insertion order of stream
 * configuration into the camera configuration with addConfiguration(). Calling
 * this method with an invalid index results in undefined behaviour.
 *
 * \return The stream configuration
 */

/**
 * \brief Retrieve an iterator to the first stream configuration in the
 * sequence
 * \return An iterator to the first stream configuration
 */
CameraConfiguration::iterator CameraConfiguration::begin()
{
	return config_.begin();
}

/**
 * \brief Retrieve a const iterator to the first element of the stream
 * configurations
 * \return A const iterator to the first stream configuration
 */
CameraConfiguration::const_iterator CameraConfiguration::begin() const
{
	return config_.begin();
}

/**
 * \brief Retrieve an iterator pointing to the past-the-end stream
 * configuration in the sequence
 * \return An iterator to the element following the last stream configuration
 */
CameraConfiguration::iterator CameraConfiguration::end()
{
	return config_.end();
}

/**
 * \brief Retrieve a const iterator pointing to the past-the-end stream
 * configuration in the sequence
 * \return A const iterator to the element following the last stream
 * configuration
 */
CameraConfiguration::const_iterator CameraConfiguration::end() const
{
	return config_.end();
}

/**
 * \brief Check if the camera configuration is empty
 * \return True if the configuration is empty
 */
bool CameraConfiguration::empty() const
{
	return config_.empty();
}

/**
 * \brief Retrieve the number of stream configurations
 * \return Number of stream configurations
 */
std::size_t CameraConfiguration::size() const
{
	return config_.size();
}

/**
 * \var CameraConfiguration::config_
 * \brief The vector of stream configurations
 */

/**
 * \class Camera
 * \brief Camera device
 *
 * \todo Add documentation for camera start timings. What exactly does the
 * camera expect the pipeline handler to do when start() is called?
 *
 * The Camera class models a camera capable of producing one or more image
 * streams from a single image source. It provides the main interface to
 * configuring and controlling the device, and capturing image streams. It is
 * the central object exposed by libcamera.
 *
 * To support the central nature of Camera objects, libcamera manages the
 * lifetime of camera instances with std::shared_ptr<>. Instances shall be
 * created with the create() function which returns a shared pointer. The
 * Camera constructors and destructor are private, to prevent instances from
 * being constructed and destroyed manually.
 *
 * \section camera_operation Operating the Camera
 *
 * An application needs to perform a sequence of operations on a camera before
 * it is ready to process requests. The camera needs to be acquired, configured
 * and resources allocated or imported to prepare the camera for capture. Once
 * started the camera can process requests until it is stopped. When an
 * application is done with a camera all resources allocated need to be freed
 * and the camera released.
 *
 * An application may start and stop a camera multiple times as long as it is
 * not released. The camera may also be reconfigured provided that all
 * resources allocated are freed prior to the reconfiguration.
 *
 * \subsection Camera States
 *
 * To help manage the sequence of operations needed to control the camera a set
 * of states are defined. Each state describes which operations may be performed
 * on the camera. Operations not listed in the state diagram are allowed in all
 * states.
 *
 * \dot
 * digraph camera_state_machine {
 *   node [shape = doublecircle ]; Available;
 *   node [shape = circle ]; Acquired;
 *   node [shape = circle ]; Configured;
 *   node [shape = circle ]; Prepared;
 *   node [shape = circle ]; Running;
 *
 *   Available -> Available [label = "release()"];
 *   Available -> Acquired [label = "acquire()"];
 *
 *   Acquired -> Available [label = "release()"];
 *   Acquired -> Configured [label = "configure()"];
 *
 *   Configured -> Available [label = "release()"];
 *   Configured -> Configured [label = "configure()"];
 *   Configured -> Prepared [label = "allocateBuffers()"];
 *
 *   Prepared -> Configured [label = "freeBuffers()"];
 *   Prepared -> Prepared [label = "createRequest()"];
 *   Prepared -> Running [label = "start()"];
 *
 *   Running -> Prepared [label = "stop()"];
 *   Running -> Running [label = "createRequest(), queueRequest()"];
 * }
 * \enddot
 *
 * \subsubsection Available
 * The base state of a camera, an application can inspect the properties of the
 * camera to determine if it wishes to use it. If an application wishes to use
 * a camera it should acquire() it to proceed to the Acquired state.
 *
 * \subsubsection Acquired
 * In the acquired state an application has exclusive access to the camera and
 * may modify the camera's parameters to configure it and proceed to the
 * Configured state.
 *
 * \subsubsection Configured
 * The camera is configured and ready for the application to prepare it with
 * resources. The camera may be reconfigured multiple times until resources
 * are provided and the state progresses to Prepared.
 *
 * \subsubsection Prepared
 * The camera has been configured and provided with resources and is ready to be
 * started. The application may free the camera's resources to get back to the
 * Configured state or start() it to progress to the Running state.
 *
 * \subsubsection Running
 * The camera is running and ready to process requests queued by the
 * application. The camera remains in this state until it is stopped and moved
 * to the Prepared state.
 */

/**
 * \brief Create a camera instance
 * \param[in] name The name of the camera device
 * \param[in] pipe The pipeline handler responsible for the camera device
 * \param[in] streams Array of streams the camera provides
 *
 * The caller is responsible for guaranteeing unicity of the camera name.
 *
 * \return A shared pointer to the newly created camera object
 */
std::shared_ptr<Camera> Camera::create(PipelineHandler *pipe,
				       const std::string &name,
				       const std::set<Stream *> &streams)
{
	struct Deleter : std::default_delete<Camera> {
		void operator()(Camera *camera)
		{
			delete camera;
		}
	};

	Camera *camera = new Camera(pipe, name);
	camera->streams_ = streams;

	return std::shared_ptr<Camera>(camera, Deleter());
}

/**
 * \brief Retrieve the name of the camera
 * \return Name of the camera device
 */
const std::string &Camera::name() const
{
	return name_;
}

/**
 * \var Camera::bufferCompleted
 * \brief Signal emitted when a buffer for a request queued to the camera has
 * completed
 */

/**
 * \var Camera::requestCompleted
 * \brief Signal emitted when a request queued to the camera has completed
 */

/**
 * \var Camera::disconnected
 * \brief Signal emitted when the camera is disconnected from the system
 *
 * This signal is emitted when libcamera detects that the camera has been
 * removed from the system. For hot-pluggable devices this is usually caused by
 * physical device disconnection. The media device is passed as a parameter.
 *
 * As soon as this signal is emitted the camera instance will refuse all new
 * application API calls by returning errors immediately.
 */

Camera::Camera(PipelineHandler *pipe, const std::string &name)
	: pipe_(pipe->shared_from_this()), name_(name), disconnected_(false),
	  state_(CameraAvailable)
{
}

Camera::~Camera()
{
	if (!stateIs(CameraAvailable))
		LOG(Camera, Error) << "Removing camera while still in use";
}

static const char *const camera_state_names[] = {
	"Available",
	"Acquired",
	"Configured",
	"Prepared",
	"Running",
};

bool Camera::stateBetween(State low, State high) const
{
	if (state_ >= low && state_ <= high)
		return true;

	ASSERT(static_cast<unsigned int>(low) < ARRAY_SIZE(camera_state_names) &&
	       static_cast<unsigned int>(high) < ARRAY_SIZE(camera_state_names));

	LOG(Camera, Debug) << "Camera in " << camera_state_names[state_]
			   << " state trying operation requiring state between "
			   << camera_state_names[low] << " and "
			   << camera_state_names[high];

	return false;
}

bool Camera::stateIs(State state) const
{
	if (state_ == state)
		return true;

	ASSERT(static_cast<unsigned int>(state) < ARRAY_SIZE(camera_state_names));

	LOG(Camera, Debug) << "Camera in " << camera_state_names[state_]
			   << " state trying operation requiring state "
			   << camera_state_names[state];

	return false;
}

/**
 * \brief Notify camera disconnection
 *
 * This method is used to notify the camera instance that the underlying
 * hardware has been unplugged. In response to the disconnection the camera
 * instance notifies the application by emitting the #disconnected signal, and
 * ensures that all new calls to the application-facing Camera API return an
 * error immediately.
 *
 * \todo Deal with pending requests if the camera is disconnected in a
 * running state.
 * \todo Update comment about Running state when importing buffers as well as
 * allocating them are supported.
 */
void Camera::disconnect()
{
	LOG(Camera, Debug) << "Disconnecting camera " << name_;

	/*
	 * If the camera was running when the hardware was removed force the
	 * state to Prepared to allow applications to call freeBuffers() and
	 * release() before deleting the camera.
	 */
	if (state_ == CameraRunning)
		state_ = CameraPrepared;

	disconnected_ = true;
	disconnected.emit(this);
}

/**
 * \brief Acquire the camera device for exclusive access
 *
 * After opening the device with open(), exclusive access must be obtained
 * before performing operations that change the device state. This function is
 * not blocking, if the device has already been acquired (by the same or another
 * process) the -EBUSY error code is returned.
 *
 * Acquiring a camera will limit usage of any other camera(s) provided by the
 * same pipeline handler to the same instance of libcamera. The limit is in
 * effect until all cameras from the pipeline handler are released. Other
 * instances of libcamera can still list and examine the cameras but will fail
 * if they attempt to acquire() any of them.
 *
 * Once exclusive access isn't needed anymore, the device should be released
 * with a call to the release() function.
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EBUSY The camera is not free and can't be acquired by the caller
 */
int Camera::acquire()
{
	if (disconnected_)
		return -ENODEV;

	if (!stateIs(CameraAvailable))
		return -EBUSY;

	if (!pipe_->lock()) {
		LOG(Camera, Info)
			<< "Pipeline handler in use by another process";
		return -EBUSY;
	}

	state_ = CameraAcquired;

	return 0;
}

/**
 * \brief Release exclusive access to the camera device
 *
 * Releasing the camera device allows other users to acquire exclusive access
 * with the acquire() function.
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -EBUSY The camera is running and can't be released
 */
int Camera::release()
{
	if (!stateBetween(CameraAvailable, CameraConfigured))
		return -EBUSY;

	pipe_->unlock();

	state_ = CameraAvailable;

	return 0;
}

/**
 * \brief Retrieve all the camera's stream information
 *
 * Retrieve all of the camera's static stream information. The static
 * information describes among other things how many streams the camera
 * supports and the capabilities of each stream.
 *
 * \return An array of all the camera's streams.
 */
const std::set<Stream *> &Camera::streams() const
{
	return streams_;
}

/**
 * \brief Generate a default camera configuration according to stream roles
 * \param[in] roles A list of stream roles
 *
 * Generate a camera configuration for a set of desired stream roles. The caller
 * specifies a list of stream roles and the camera returns a configuration
 * containing suitable streams and their suggested default configurations. An
 * empty list of roles is valid, and will generate an empty configuration that
 * can be filled by the caller.
 *
 * \return A CameraConfiguration if the requested roles can be satisfied, or a
 * null pointer otherwise. The ownership of the returned configuration is
 * passed to the caller.
 */
std::unique_ptr<CameraConfiguration> Camera::generateConfiguration(const StreamRoles &roles)
{
	if (disconnected_ || roles.size() > streams_.size())
		return nullptr;

	CameraConfiguration *config = pipe_->generateConfiguration(this, roles);
	if (!config) {
		LOG(Camera, Debug)
			<< "Pipeline handler failed to generate configuration";
		return nullptr;
	}

	std::ostringstream msg("streams configuration:", std::ios_base::ate);

	if (config->empty())
		msg << " empty";

	for (unsigned int index = 0; index < config->size(); ++index)
		msg << " (" << index << ") " << config->at(index).toString();

	LOG(Camera, Debug) << msg.str();

	return std::unique_ptr<CameraConfiguration>(config);
}

/**
 * \brief Configure the camera prior to capture
 * \param[in] config The camera configurations to setup
 *
 * Prior to starting capture, the camera must be configured to select a
 * group of streams to be involved in the capture and their configuration.
 * The caller specifies which streams are to be involved and their configuration
 * by populating \a config.
 *
 * The configuration is created by generateConfiguration(), and adjusted by the
 * caller with CameraConfiguration::validate(). This method only accepts fully
 * valid configurations and returns an error if \a config is not valid.
 *
 * Exclusive access to the camera shall be ensured by a call to acquire() prior
 * to calling this function, otherwise an -EACCES error will be returned.
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * Upon return the StreamConfiguration entries in \a config are associated with
 * Stream instances which can be retrieved with StreamConfiguration::stream().
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EACCES The camera is not in a state where it can be configured
 * \retval -EINVAL The configuration is not valid
 */
int Camera::configure(CameraConfiguration *config)
{
	int ret;

	if (disconnected_)
		return -ENODEV;

	if (!stateBetween(CameraAcquired, CameraConfigured))
		return -EACCES;

	if (config->validate() != CameraConfiguration::Valid) {
		LOG(Camera, Error)
			<< "Can't configure camera with invalid configuration";
		return -EINVAL;
	}

	std::ostringstream msg("configuring streams:", std::ios_base::ate);

	for (unsigned int index = 0; index < config->size(); ++index) {
		StreamConfiguration &cfg = config->at(index);
		cfg.setStream(nullptr);
		msg << " (" << index << ") " << cfg.toString();
	}

	LOG(Camera, Info) << msg.str();

	ret = pipe_->configure(this, config);
	if (ret)
		return ret;

	activeStreams_.clear();
	for (const StreamConfiguration &cfg : *config) {
		Stream *stream = cfg.stream();
		if (!stream)
			LOG(Camera, Fatal)
				<< "Pipeline handler failed to update stream configuration";

		stream->configuration_ = cfg;
		activeStreams_.insert(stream);

		/*
		 * Allocate buffer objects in the pool.
		 * Memory will be allocated and assigned later.
		 */
		stream->bufferPool().createBuffers(cfg.bufferCount);
	}

	state_ = CameraConfigured;

	return 0;
}

/**
 * \brief Allocate buffers for all configured streams
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EACCES The camera is not in a state where buffers can be allocated
 * \retval -EINVAL The configuration is not valid
 */
int Camera::allocateBuffers()
{
	if (disconnected_)
		return -ENODEV;

	if (!stateIs(CameraConfigured))
		return -EACCES;

	if (activeStreams_.empty()) {
		LOG(Camera, Error)
			<< "Can't allocate buffers without streams";
		return -EINVAL;
	}

	int ret = pipe_->allocateBuffers(this, activeStreams_);
	if (ret) {
		LOG(Camera, Error) << "Failed to allocate buffers";
		return ret;
	}

	state_ = CameraPrepared;

	return 0;
}

/**
 * \brief Release all buffers from allocated pools in each stream
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -EACCES The camera is not in a state where buffers can be freed
 */
int Camera::freeBuffers()
{
	if (!stateIs(CameraPrepared))
		return -EACCES;

	for (Stream *stream : activeStreams_) {
		if (!stream->bufferPool().count())
			continue;

		/*
		 * All mappings must be destroyed before buffers can be freed
		 * by the V4L2 device that has allocated them.
		 */
		stream->bufferPool().destroyBuffers();
	}

	state_ = CameraConfigured;

	return pipe_->freeBuffers(this, activeStreams_);
}

/**
 * \brief Create a request object for the camera
 *
 * This method creates an empty request for the application to fill with
 * buffers and paramaters, and queue for capture.
 *
 * The ownership of the returned request is passed to the caller, which is
 * responsible for either queueing the request or deleting it.
 *
 * This function shall only be called when the camera is in the Prepared
 * or Running state, see \ref camera_operation.
 *
 * \return A pointer to the newly created request, or nullptr on error
 */
Request *Camera::createRequest()
{
	if (disconnected_ || !stateBetween(CameraPrepared, CameraRunning))
		return nullptr;

	return new Request(this);
}

/**
 * \brief Queue a request to the camera
 * \param[in] request The request to queue to the camera
 *
 * This method queues a \a request to the camera for capture.
 *
 * After allocating the request with createRequest(), the application shall
 * fill it with at least one capture buffer before queuing it. Requests that
 * contain no buffers are invalid and are rejected without being queued.
 *
 * Once the request has been queued, the camera will notify its completion
 * through the \ref requestCompleted signal.
 *
 * Ownership of the request is transferred to the camera. It will be deleted
 * automatically after it completes.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EACCES The camera is not running so requests can't be queued
 * \retval -EINVAL The request is invalid
 */
int Camera::queueRequest(Request *request)
{
	if (disconnected_)
		return -ENODEV;

	if (!stateIs(CameraRunning))
		return -EACCES;

	for (auto const &it : request->buffers()) {
		Stream *stream = it.first;
		if (activeStreams_.find(stream) == activeStreams_.end()) {
			LOG(Camera, Error) << "Invalid request";
			return -EINVAL;
		}
	}

	int ret = request->prepare();
	if (ret) {
		LOG(Camera, Error) << "Failed to prepare request";
		return ret;
	}

	return pipe_->queueRequest(this, request);
}

/**
 * \brief Start capture from camera
 *
 * Start the camera capture session. Once the camera is started the application
 * can queue requests to the camera to process and return to the application
 * until the capture session is terminated with \a stop().
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EACCES The camera is not in a state where it can be started
 */
int Camera::start()
{
	if (disconnected_)
		return -ENODEV;

	if (!stateIs(CameraPrepared))
		return -EACCES;

	LOG(Camera, Debug) << "Starting capture";

	int ret = pipe_->start(this);
	if (ret)
		return ret;

	state_ = CameraRunning;

	return 0;
}

/**
 * \brief Stop capture from camera
 *
 * This method stops capturing and processing requests immediately. All pending
 * requests are cancelled and complete synchronously in an error state.
 *
 * This function affects the state of the camera, see \ref camera_operation.
 *
 * \return 0 on success or a negative error code otherwise
 * \retval -ENODEV The camera has been disconnected from the system
 * \retval -EACCES The camera is not running so can't be stopped
 */
int Camera::stop()
{
	if (disconnected_)
		return -ENODEV;

	if (!stateIs(CameraRunning))
		return -EACCES;

	LOG(Camera, Debug) << "Stopping capture";

	state_ = CameraPrepared;

	pipe_->stop(this);

	return 0;
}

/**
 * \brief Handle request completion and notify application
 * \param[in] request The request that has completed
 *
 * This function is called by the pipeline handler to notify the camera that
 * the request has completed. It emits the requestCompleted signal and deletes
 * the request.
 */
void Camera::requestComplete(Request *request)
{
	std::map<Stream *, Buffer *> buffers(std::move(request->bufferMap_));
	requestCompleted.emit(request, buffers);
	delete request;
}

} /* namespace libcamera */
l num">1</span>

    <span class="hl str">&apos;&apos;&apos;</span>
<span class="hl str">    print metadata for debug</span>
<span class="hl str">    &apos;&apos;&apos;</span>
    <span class="hl kwa">def</span> <span class="hl kwd">print_meta</span><span class="hl opt">(</span>self<span class="hl opt">):</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">Data:&apos;</span><span class="hl opt">)</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      ver = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>ver<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      w = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>w<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      h = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>h<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      pad = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>pad<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      fmt = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>fmt<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      sigbits = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>sigbits<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      pattern = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>pattern<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      exposure = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>exposure<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      againQ8 = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>againQ8<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      againQ8_norm = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>againQ8_norm<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      camName = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>camName<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      blacklevel = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>blacklevel<span class="hl opt">))</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;      blacklevel_16 = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>self<span class="hl opt">.</span>blacklevel_16<span class="hl opt">))</span>

        <span class="hl kwa">return</span> <span class="hl num">1</span>

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

            mat<span class="hl opt">[...,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">4</span><span class="hl opt">] =</span> ch0
            mat<span class="hl opt">[...,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">4</span><span class="hl opt">] =</span> ch1
            mat<span class="hl opt">[...,</span> <span class="hl num">2</span><span class="hl opt">::</span><span class="hl num">4</span><span class="hl opt">] =</span> ch2
            mat<span class="hl opt">[...,</span> <span class="hl num">3</span><span class="hl opt">::</span><span class="hl num">4</span><span class="hl opt">] =</span> ch3

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

            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        same as before but 12 bit case</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        <span class="hl kwa">elif</span> self<span class="hl opt">.</span>sigbits <span class="hl opt">==</span> <span class="hl num">12</span><span class="hl opt">:</span>
            lin_len <span class="hl opt">= ((((((</span>self<span class="hl opt">.</span>w<span class="hl opt">+</span>self<span class="hl opt">.</span>pad<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)&gt;&gt;</span><span class="hl num">1</span><span class="hl opt">)) *</span> <span class="hl num">3</span><span class="hl opt">)+</span><span class="hl num">31</span><span class="hl opt">)&gt;&gt;</span><span class="hl num">5</span><span class="hl opt">) *</span> <span class="hl num">32</span>
            raw <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">array</span><span class="hl opt">(</span>raw<span class="hl opt">).</span><span class="hl kwd">reshape</span><span class="hl opt">(-</span><span class="hl num">1</span><span class="hl opt">,</span> lin_len<span class="hl opt">).</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>int64<span class="hl opt">)[:</span>self<span class="hl opt">.</span>h<span class="hl opt">, ...]</span>
            ba0 <span class="hl opt">=</span> raw<span class="hl opt">[...,</span> <span class="hl num">0</span><span class="hl opt">:</span><span class="hl num">3</span><span class="hl opt">*((</span>self<span class="hl opt">.</span>w<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)&gt;&gt;</span><span class="hl num">1</span><span class="hl opt">):</span><span class="hl num">3</span><span class="hl opt">]</span>
            ba1 <span class="hl opt">=</span> raw<span class="hl opt">[...,</span> <span class="hl num">1</span><span class="hl opt">:</span><span class="hl num">3</span><span class="hl opt">*((</span>self<span class="hl opt">.</span>w<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)&gt;&gt;</span><span class="hl num">1</span><span class="hl opt">):</span><span class="hl num">3</span><span class="hl opt">]</span>
            ba2 <span class="hl opt">=</span> raw<span class="hl opt">[...,</span> <span class="hl num">2</span><span class="hl opt">:</span><span class="hl num">3</span><span class="hl opt">*((</span>self<span class="hl opt">.</span>w<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">)&gt;&gt;</span><span class="hl num">1</span><span class="hl opt">):</span><span class="hl num">3</span><span class="hl opt">]</span>
            ch0 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">((</span>np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>ba0<span class="hl opt">,</span> <span class="hl num">4</span><span class="hl opt">) +</span> ba2 <span class="hl opt">%</span> <span class="hl num">16</span><span class="hl opt">),</span> <span class="hl num">4</span><span class="hl opt">)</span>
            ch1 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">((</span>np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>ba1<span class="hl opt">,</span> <span class="hl num">4</span><span class="hl opt">) + (</span>np<span class="hl opt">.</span><span class="hl kwd">right_shift</span><span class="hl opt">(</span>ba2<span class="hl opt">,</span> <span class="hl num">4</span><span class="hl opt">)) %</span> <span class="hl num">16</span><span class="hl opt">),</span> <span class="hl num">4</span><span class="hl opt">)</span>
            mat <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">empty</span><span class="hl opt">((</span>self<span class="hl opt">.</span>h<span class="hl opt">,</span> self<span class="hl opt">.</span>w<span class="hl opt">),</span> dtype<span class="hl opt">=</span>ch0<span class="hl opt">.</span>dtype<span class="hl opt">)</span>
            mat<span class="hl opt">[...,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">] =</span> ch0
            mat<span class="hl opt">[...,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">] =</span> ch1

        <span class="hl kwa">else</span><span class="hl opt">:</span>
            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            data is neither 10 nor 12 or incorrect data</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;ERROR: wrong bit format, only 10 or 12 bit supported&apos;</span><span class="hl opt">)</span>
            <span class="hl kwa">return</span> <span class="hl num">0</span>

        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        separate bayer channels</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        c0 <span class="hl opt">=</span> mat<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">]</span>
        c1 <span class="hl opt">=</span> mat<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">]</span>
        c2 <span class="hl opt">=</span> mat<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">]</span>
        c3 <span class="hl opt">=</span> mat<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">]</span>
        self<span class="hl opt">.</span>channels <span class="hl opt">= [</span>c0<span class="hl opt">,</span> c1<span class="hl opt">,</span> c2<span class="hl opt">,</span> c3<span class="hl opt">]</span>
        <span class="hl kwa">return</span> <span class="hl num">1</span>

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


<span class="hl kwa">def</span> <span class="hl kwd">brcm_load_image</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> im_str<span class="hl opt">):</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    Load image where raw data and metadata is in the BRCM format</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl kwa">try</span><span class="hl opt">:</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        create byte array</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        with <span class="hl kwb">open</span><span class="hl opt">(</span>im_str<span class="hl opt">,</span> <span class="hl str">&apos;rb&apos;</span><span class="hl opt">)</span> <span class="hl kwa">as</span> image<span class="hl opt">:</span>
            f <span class="hl opt">=</span> image<span class="hl opt">.</span><span class="hl kwd">read</span><span class="hl opt">()</span>
            b <span class="hl opt">=</span> <span class="hl kwd">bytearray</span><span class="hl opt">(</span>f<span class="hl opt">)</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        return error if incorrect image address</span>
<span class="hl str">        &quot;&quot;&quot;</span>
    <span class="hl kwa">except</span> FileNotFoundError<span class="hl opt">:</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR:</span><span class="hl esc">\n</span><span class="hl str">Invalid image address&apos;</span><span class="hl opt">)</span>
        Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">WARNING: Invalid image address&apos;</span>
        <span class="hl kwa">return</span> <span class="hl num">0</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    return error if problem reading file</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl kwa">if</span> f <span class="hl kwa">is None</span><span class="hl opt">:</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR:</span><span class="hl esc">\n</span><span class="hl str">Problem reading file&apos;</span><span class="hl opt">)</span>
        Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">WARNING: Problem readin file&apos;</span>
        <span class="hl kwa">return</span> <span class="hl num">0</span>

    <span class="hl slc"># print(&apos;\nLooking for EOI and BRCM header&apos;)</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    find end of image followed by BRCM header by turning</span>
<span class="hl str">    bytearray into hex string and string matching with regexp</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    start <span class="hl opt">= -</span><span class="hl num">1</span>
    match <span class="hl opt">=</span> <span class="hl kwd">bytearray</span><span class="hl opt">(</span>b<span class="hl str">&apos;</span><span class="hl esc">\xff\xd9</span><span class="hl str">&#64;BRCM&apos;</span><span class="hl opt">)</span>
    match_str <span class="hl opt">=</span> binascii<span class="hl opt">.</span><span class="hl kwd">hexlify</span><span class="hl opt">(</span>match<span class="hl opt">)</span>
    b_str <span class="hl opt">=</span> binascii<span class="hl opt">.</span><span class="hl kwd">hexlify</span><span class="hl opt">(</span>b<span class="hl opt">)</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    note index is divided by two to go from string to hex</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    indices <span class="hl opt">= [</span>m<span class="hl opt">.</span><span class="hl kwd">start</span><span class="hl opt">()//</span><span class="hl num">2</span> <span class="hl kwa">for</span> m <span class="hl kwa">in</span> re<span class="hl opt">.</span><span class="hl kwd">finditer</span><span class="hl opt">(</span>match_str<span class="hl opt">,</span> b_str<span class="hl opt">)]</span>
    <span class="hl slc"># print(indices)</span>
    <span class="hl kwa">try</span><span class="hl opt">:</span>
        start <span class="hl opt">=</span> indices<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] +</span> <span class="hl num">3</span>
    <span class="hl kwa">except</span> <span class="hl kwc">IndexError</span><span class="hl opt">:</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR:</span><span class="hl esc">\n</span><span class="hl str">No Broadcom header found&apos;</span><span class="hl opt">)</span>
        Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">WARNING: No Broadcom header found!&apos;</span>
        <span class="hl kwa">return</span> <span class="hl num">0</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    extract data after header</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl slc"># print(&apos;\nExtracting data after header&apos;)</span>
    buf <span class="hl opt">=</span> b<span class="hl opt">[</span>start<span class="hl opt">:</span>start<span class="hl opt">+</span><span class="hl num">32768</span><span class="hl opt">]</span>
    Img <span class="hl opt">=</span> <span class="hl kwd">Image</span><span class="hl opt">(</span>buf<span class="hl opt">)</span>
    Img<span class="hl opt">.</span><span class="hl kwb">str</span> <span class="hl opt">=</span> im_str
    <span class="hl slc"># print(&apos;Data found successfully&apos;)</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    obtain metadata</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl slc"># print(&apos;\nReading metadata&apos;)</span>
    Img<span class="hl opt">.</span><span class="hl kwd">get_meta</span><span class="hl opt">()</span>
    Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">Exposure : {} us&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>Img<span class="hl opt">.</span>exposure<span class="hl opt">)</span>
    Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">Normalised gain : {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>Img<span class="hl opt">.</span>againQ8_norm<span class="hl opt">)</span>
    <span class="hl slc"># print(&apos;Metadata read successfully&apos;)</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    obtain raw image data</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl slc"># print(&apos;\nObtaining raw image data&apos;)</span>
    raw <span class="hl opt">=</span> b<span class="hl opt">[</span>start<span class="hl opt">+</span><span class="hl num">32768</span><span class="hl opt">:]</span>
    Img<span class="hl opt">.</span><span class="hl kwd">get_image</span><span class="hl opt">(</span>raw<span class="hl opt">)</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    delete raw to stop memory errors</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    raw <span class="hl opt">=</span> <span class="hl kwa">None</span>
    <span class="hl kwa">del</span> raw
    <span class="hl slc"># print(&apos;Raw image data obtained successfully&apos;)</span>

    <span class="hl kwa">return</span> Img


<span class="hl kwa">def</span> <span class="hl kwd">dng_load_image</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> im_str<span class="hl opt">):</span>
    <span class="hl kwa">try</span><span class="hl opt">:</span>
        Img <span class="hl opt">=</span> <span class="hl kwd">Image</span><span class="hl opt">(</span><span class="hl kwa">None</span><span class="hl opt">)</span>

        <span class="hl slc"># RawPy doesn&apos;t load all the image tags that we need, so we use py3exiv2</span>
        metadata <span class="hl opt">=</span> pyexif<span class="hl opt">.</span><span class="hl kwd">ImageMetadata</span><span class="hl opt">(</span>im_str<span class="hl opt">)</span>
        metadata<span class="hl opt">.</span><span class="hl kwd">read</span><span class="hl opt">()</span>

        Img<span class="hl opt">.</span>ver <span class="hl opt">=</span> <span class="hl num">100</span>  <span class="hl slc"># random value</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        The DNG and TIFF/EP specifications use different IFDs to store the raw</span>
<span class="hl str">        image data and the Exif tags. DNG stores them in a SubIFD and in an Exif</span>
<span class="hl str">        IFD respectively (named &quot;SubImage1&quot; and &quot;Photo&quot; by pyexiv2), while</span>
<span class="hl str">        TIFF/EP stores them both in IFD0 (name &quot;Image&quot;). Both are used in &quot;DNG&quot;</span>
<span class="hl str">        files, with libcamera-apps following the DNG recommendation and</span>
<span class="hl str">        applications based on picamera2 following TIFF/EP.</span>
<span class="hl str"></span>
<span class="hl str">        This code detects which tags are being used, and therefore extracts the</span>
<span class="hl str">        correct values.</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        <span class="hl kwa">try</span><span class="hl opt">:</span>
            Img<span class="hl opt">.</span>w <span class="hl opt">=</span> metadata<span class="hl opt">[</span><span class="hl str">&apos;Exif.SubImage1.ImageWidth&apos;</span><span class="hl opt">].</span>value
            subimage <span class="hl opt">=</span> <span class="hl str">&quot;SubImage1&quot;</span>
            photo <span class="hl opt">=</span> <span class="hl str">&quot;Photo&quot;</span>
        <span class="hl kwa">except</span> <span class="hl kwc">KeyError</span><span class="hl opt">:</span>
            Img<span class="hl opt">.</span>w <span class="hl opt">=</span> metadata<span class="hl opt">[</span><span class="hl str">&apos;Exif.Image.ImageWidth&apos;</span><span class="hl opt">].</span>value
            subimage <span class="hl opt">=</span> <span class="hl str">&quot;Image&quot;</span>
            photo <span class="hl opt">=</span> <span class="hl str">&quot;Image&quot;</span>
        Img<span class="hl opt">.</span>pad <span class="hl opt">=</span> <span class="hl num">0</span>
        Img<span class="hl opt">.</span>h <span class="hl opt">=</span> metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{subimage}</span><span class="hl str">.ImageLength&apos;</span><span class="hl opt">].</span>value
        white <span class="hl opt">=</span> metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{subimage}</span><span class="hl str">.WhiteLevel&apos;</span><span class="hl opt">].</span>value
        Img<span class="hl opt">.</span>sigbits <span class="hl opt">=</span> <span class="hl kwb">int</span><span class="hl opt">(</span>white<span class="hl opt">).</span><span class="hl kwd">bit_length</span><span class="hl opt">()</span>
        Img<span class="hl opt">.</span>fmt <span class="hl opt">= (</span>Img<span class="hl opt">.</span>sigbits <span class="hl opt">-</span> <span class="hl num">4</span><span class="hl opt">) //</span> <span class="hl num">2</span>
        Img<span class="hl opt">.</span>exposure <span class="hl opt">=</span> <span class="hl kwb">int</span><span class="hl opt">(</span>metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{photo}</span><span class="hl str">.ExposureTime&apos;</span><span class="hl opt">].</span>value <span class="hl opt">*</span> <span class="hl num">1000000</span><span class="hl opt">)</span>
        Img<span class="hl opt">.</span>againQ8 <span class="hl opt">=</span> metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{photo}</span><span class="hl str">.ISOSpeedRatings&apos;</span><span class="hl opt">].</span>value <span class="hl opt">*</span> <span class="hl num">256</span> <span class="hl opt">/</span> <span class="hl num">100</span>
        Img<span class="hl opt">.</span>againQ8_norm <span class="hl opt">=</span> Img<span class="hl opt">.</span>againQ8 <span class="hl opt">/</span> <span class="hl num">256</span>
        Img<span class="hl opt">.</span>camName <span class="hl opt">=</span> metadata<span class="hl opt">[</span><span class="hl str">&apos;Exif.Image.Model&apos;</span><span class="hl opt">].</span>value
        Img<span class="hl opt">.</span>blacklevel <span class="hl opt">=</span> <span class="hl kwb">int</span><span class="hl opt">(</span>metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{subimage}</span><span class="hl str">.BlackLevel&apos;</span><span class="hl opt">].</span>value<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">])</span>
        Img<span class="hl opt">.</span>blacklevel_16 <span class="hl opt">=</span> Img<span class="hl opt">.</span>blacklevel <span class="hl opt">&lt;&lt; (</span><span class="hl num">16</span> <span class="hl opt">-</span> Img<span class="hl opt">.</span>sigbits<span class="hl opt">)</span>
        bayer_case <span class="hl opt">= {</span>
            <span class="hl str">&apos;0 1 1 2&apos;</span><span class="hl opt">: (</span><span class="hl num">0</span><span class="hl opt">, (</span><span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">)),</span>
            <span class="hl str">&apos;1 2 0 1&apos;</span><span class="hl opt">: (</span><span class="hl num">1</span><span class="hl opt">, (</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">)),</span>
            <span class="hl str">&apos;2 1 1 0&apos;</span><span class="hl opt">: (</span><span class="hl num">2</span><span class="hl opt">, (</span><span class="hl num">3</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">)),</span>
            <span class="hl str">&apos;1 0 2 1&apos;</span><span class="hl opt">: (</span><span class="hl num">3</span><span class="hl opt">, (</span><span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">))</span>
        <span class="hl opt">}</span>
        cfa_pattern <span class="hl opt">=</span> metadata<span class="hl opt">[</span>f<span class="hl str">&apos;Exif.</span><span class="hl ipl">{subimage}</span><span class="hl str">.CFAPattern&apos;</span><span class="hl opt">].</span>value
        Img<span class="hl opt">.</span>pattern <span class="hl opt">=</span> bayer_case<span class="hl opt">[</span>cfa_pattern<span class="hl opt">][</span><span class="hl num">0</span><span class="hl opt">]</span>
        Img<span class="hl opt">.</span>order <span class="hl opt">=</span> bayer_case<span class="hl opt">[</span>cfa_pattern<span class="hl opt">][</span><span class="hl num">1</span><span class="hl opt">]</span>

        <span class="hl slc"># Now use RawPy tp get the raw Bayer pixels</span>
        raw_im <span class="hl opt">=</span> raw<span class="hl opt">.</span><span class="hl kwd">imread</span><span class="hl opt">(</span>im_str<span class="hl opt">)</span>
        raw_data <span class="hl opt">=</span> raw_im<span class="hl opt">.</span>raw_image
        shift <span class="hl opt">=</span> <span class="hl num">16</span> <span class="hl opt">-</span> Img<span class="hl opt">.</span>sigbits
        c0 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>raw_data<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">].</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>int64<span class="hl opt">),</span> shift<span class="hl opt">)</span>
        c1 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>raw_data<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">].</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>int64<span class="hl opt">),</span> shift<span class="hl opt">)</span>
        c2 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>raw_data<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">].</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>int64<span class="hl opt">),</span> shift<span class="hl opt">)</span>
        c3 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">left_shift</span><span class="hl opt">(</span>raw_data<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">::</span><span class="hl num">2</span><span class="hl opt">].</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>int64<span class="hl opt">),</span> shift<span class="hl opt">)</span>
        Img<span class="hl opt">.</span>channels <span class="hl opt">= [</span>c0<span class="hl opt">,</span> c1<span class="hl opt">,</span> c2<span class="hl opt">,</span> c3<span class="hl opt">]</span>
        Img<span class="hl opt">.</span>rgb <span class="hl opt">=</span> raw_im<span class="hl opt">.</span><span class="hl kwd">postprocess</span><span class="hl opt">()</span>

    <span class="hl kwa">except</span> <span class="hl kwc">Exception</span><span class="hl opt">:</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">ERROR: failed to load DNG file&quot;</span><span class="hl opt">,</span> im_str<span class="hl opt">)</span>
        <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&quot;Either file does not exist or is incompatible&quot;</span><span class="hl opt">)</span>
        Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR: DNG file does not exist or is incompatible&apos;</span>
        <span class="hl kwa">raise</span>

    <span class="hl kwa">return</span> Img


<span class="hl str">&apos;&apos;&apos;</span>
<span class="hl str">load image from file location and perform calibration</span>
<span class="hl str">check correct filetype</span>
<span class="hl str"></span>
<span class="hl str">mac boolean is true if image is expected to contain macbeth chart and false</span>
<span class="hl str">if not (alsc images don&apos;t have macbeth charts)</span>
<span class="hl str">&apos;&apos;&apos;</span>
<span class="hl kwa">def</span> <span class="hl kwd">load_image</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> im_str<span class="hl opt">,</span> mac_config<span class="hl opt">=</span><span class="hl kwa">None</span><span class="hl opt">,</span> show<span class="hl opt">=</span><span class="hl kwa">False</span><span class="hl opt">,</span> mac<span class="hl opt">=</span><span class="hl kwa">True</span><span class="hl opt">,</span> show_meta<span class="hl opt">=</span><span class="hl kwa">False</span><span class="hl opt">):</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    check image is correct filetype</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl kwa">if</span> <span class="hl str">&apos;.jpg&apos;</span> <span class="hl kwa">in</span> im_str <span class="hl kwa">or</span> <span class="hl str">&apos;.jpeg&apos;</span> <span class="hl kwa">in</span> im_str <span class="hl kwa">or</span> <span class="hl str">&apos;.brcm&apos;</span> <span class="hl kwa">in</span> im_str <span class="hl kwa">or</span> <span class="hl str">&apos;.dng&apos;</span> <span class="hl kwa">in</span> im_str<span class="hl opt">:</span>
        <span class="hl kwa">if</span> <span class="hl str">&apos;.dng&apos;</span> <span class="hl kwa">in</span> im_str<span class="hl opt">:</span>
            Img <span class="hl opt">=</span> <span class="hl kwd">dng_load_image</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> im_str<span class="hl opt">)</span>
        <span class="hl kwa">else</span><span class="hl opt">:</span>
            Img <span class="hl opt">=</span> <span class="hl kwd">brcm_load_image</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> im_str<span class="hl opt">)</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        handle errors smoothly if loading image failed</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        <span class="hl kwa">if</span> Img <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">:</span>
            <span class="hl kwa">return</span> <span class="hl num">0</span>
        <span class="hl kwa">if</span> show_meta<span class="hl opt">:</span>
            Img<span class="hl opt">.</span><span class="hl kwd">print_meta</span><span class="hl opt">()</span>

        <span class="hl kwa">if</span> mac<span class="hl opt">:</span>
            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            find macbeth centres, discarding images that are too dark or light</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            av_chan <span class="hl opt">= (</span>np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwd">array</span><span class="hl opt">(</span>Img<span class="hl opt">.</span>channels<span class="hl opt">),</span> axis<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)/(</span><span class="hl num">2</span><span class="hl opt">**</span><span class="hl num">16</span><span class="hl opt">))</span>
            av_val <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>av_chan<span class="hl opt">)</span>
            <span class="hl slc"># print(av_val)</span>
            <span class="hl kwa">if</span> av_val <span class="hl opt">&lt;</span> Img<span class="hl opt">.</span>blacklevel_16<span class="hl opt">/(</span><span class="hl num">2</span><span class="hl opt">**</span><span class="hl num">16</span><span class="hl opt">)+</span><span class="hl num">1</span><span class="hl opt">/</span><span class="hl num">64</span><span class="hl opt">:</span>
                macbeth <span class="hl opt">=</span> <span class="hl kwa">None</span>
                <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">Error: Image too dark!&apos;</span><span class="hl opt">)</span>
                Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">WARNING: Image too dark!&apos;</span>
            <span class="hl kwa">else</span><span class="hl opt">:</span>
                macbeth <span class="hl opt">=</span> <span class="hl kwd">find_macbeth</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> av_chan<span class="hl opt">,</span> mac_config<span class="hl opt">)</span>

            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            if no macbeth found return error</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            <span class="hl kwa">if</span> macbeth <span class="hl kwa">is None</span><span class="hl opt">:</span>
                <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR: No macbeth chart found&apos;</span><span class="hl opt">)</span>
                <span class="hl kwa">return</span> <span class="hl num">0</span>
            mac_cen_coords <span class="hl opt">=</span> macbeth<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">]</span>
            <span class="hl slc"># print(&apos;\nMacbeth centres located successfully&apos;)</span>

            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            obtain image patches</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            <span class="hl slc"># print(&apos;\nObtaining image patches&apos;)</span>
            Img<span class="hl opt">.</span><span class="hl kwd">get_patches</span><span class="hl opt">(</span>mac_cen_coords<span class="hl opt">)</span>
            <span class="hl kwa">if</span> Img<span class="hl opt">.</span>saturated<span class="hl opt">:</span>
                <span class="hl kwa">print</span><span class="hl opt">(</span><span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">ERROR: Macbeth patches have saturated&apos;</span><span class="hl opt">)</span>
                Cam<span class="hl opt">.</span>log <span class="hl opt">+=</span> <span class="hl str">&apos;</span><span class="hl esc">\n</span><span class="hl str">WARNING: Macbeth patches have saturated!&apos;</span>
                <span class="hl kwa">return</span> <span class="hl num">0</span>

        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        clear memory</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        Img<span class="hl opt">.</span>buf <span class="hl opt">=</span> <span class="hl kwa">None</span>
        <span class="hl kwa">del</span> Img<span class="hl opt">.</span>buf

        <span class="hl slc"># print(&apos;Image patches obtained successfully&apos;)</span>

        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        optional debug</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        <span class="hl kwa">if</span> show <span class="hl kwa">and</span> __name__ <span class="hl opt">==</span> <span class="hl str">&apos;__main__&apos;</span><span class="hl opt">:</span>
            copy <span class="hl opt">=</span> <span class="hl kwb">sum</span><span class="hl opt">(</span>Img<span class="hl opt">.</span>channels<span class="hl opt">)/</span><span class="hl num">2</span><span class="hl opt">**</span><span class="hl num">18</span>
            copy <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">reshape</span><span class="hl opt">(</span>copy<span class="hl opt">, (</span>Img<span class="hl opt">.</span>h<span class="hl opt">//</span><span class="hl num">2</span><span class="hl opt">,</span> Img<span class="hl opt">.</span>w<span class="hl opt">//</span><span class="hl num">2</span><span class="hl opt">)).</span><span class="hl kwd">astype</span><span class="hl opt">(</span>np<span class="hl opt">.</span>float64<span class="hl opt">)</span>
            copy<span class="hl opt">,</span> _ <span class="hl opt">=</span> <span class="hl kwd">reshape</span><span class="hl opt">(</span>copy<span class="hl opt">,</span> <span class="hl num">800</span><span class="hl opt">)</span>
            <span class="hl kwd">represent</span><span class="hl opt">(</span>copy<span class="hl opt">)</span>

        <span class="hl kwa">return</span> Img

        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    return error if incorrect filetype</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl kwa">else</span><span class="hl opt">:</span>
        <span class="hl slc"># print(&apos;\nERROR:\nInvalid file extension&apos;)</span>
        <span class="hl kwa">return</span> <span class="hl num">0</span>


<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">bytearray splice to number little endian</span>
<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl kwa">def</span> <span class="hl kwd">ba_to_b</span><span class="hl opt">(</span>b<span class="hl opt">):</span>
    total <span class="hl opt">=</span> <span class="hl num">0</span>
    <span class="hl kwa">for</span> i <span class="hl kwa">in</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl kwb">len</span><span class="hl opt">(</span>b<span class="hl opt">)):</span>
        total <span class="hl opt">+=</span> <span class="hl num">256</span><span class="hl opt">**</span>i <span class="hl opt">*</span> b<span class="hl opt">[</span>i<span class="hl opt">]</span>
    <span class="hl kwa">return</span> total
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit v1.2.1</a> (<a href='https://git-scm.com/'>git 2.18.0</a>) at 2024-12-22 20:34:15 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>