/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2019, Google Inc.
 *
 * camera_device.cpp - libcamera Android Camera Device
 */

#include "camera_device.h"

#include <algorithm>
#include <fstream>
#include <sys/mman.h>
#include <unistd.h>
#include <vector>

#include <libcamera/base/log.h>
#include <libcamera/base/thread.h>
#include <libcamera/base/utils.h>

#include <libcamera/control_ids.h>
#include <libcamera/controls.h>
#include <libcamera/formats.h>
#include <libcamera/property_ids.h>

#include "system/graphics.h"

#include "camera_buffer.h"
#include "camera_hal_config.h"
#include "camera_ops.h"
#include "camera_request.h"

using namespace libcamera;

LOG_DECLARE_CATEGORY(HAL)

namespace {

/*
 * \struct Camera3StreamConfig
 * \brief Data to store StreamConfiguration associated with camera3_stream(s)
 * \var streams List of the pairs of a stream requested by Android HAL client
 * and CameraStream::Type associated with the stream
 * \var config StreamConfiguration for streams
 */
struct Camera3StreamConfig {
	struct Camera3Stream {
		camera3_stream_t *stream;
		CameraStream::Type type;
	};

	std::vector<Camera3Stream> streams;
	StreamConfiguration config;
};

/*
 * Reorder the configurations so that libcamera::Camera can accept them as much
 * as possible. The sort rule is as follows.
 * 1.) The configuration for NV12 request whose resolution is the largest.
 * 2.) The configuration for JPEG request.
 * 3.) Others. Larger resolutions and different formats are put earlier.
 */
void sortCamera3StreamConfigs(std::vector<Camera3StreamConfig> &unsortedConfigs,
			      const camera3_stream_t *jpegStream)
{
	const Camera3StreamConfig *jpegConfig = nullptr;

	std::map<PixelFormat, std::vector<const Camera3StreamConfig *>> formatToConfigs;
	for (const auto &streamConfig : unsortedConfigs) {
		if (jpegStream && !jpegConfig) {
			const auto &streams = streamConfig.streams;
			if (std::find_if(streams.begin(), streams.end(),
					 [jpegStream](const auto &stream) {
						 return stream.stream == jpegStream;
					 }) != streams.end()) {
				jpegConfig = &streamConfig;
				continue;
			}
		}
		formatToConfigs[streamConfig.config.pixelFormat].push_back(&streamConfig);
	}

	if (jpegStream && !jpegConfig)
		LOG(HAL, Fatal) << "No Camera3StreamConfig is found for JPEG";

	for (auto &fmt : formatToConfigs) {
		auto &streamConfigs = fmt.second;

		/* Sorted by resolution. Smaller is put first. */
		std::sort(streamConfigs.begin(), streamConfigs.end(),
			  [](const auto *streamConfigA, const auto *streamConfigB) {
				  const Size &sizeA = streamConfigA->config.size;
				  const Size &sizeB = streamConfigB->config.size;
				  return sizeA < sizeB;
			  });
	}

	std::vector<Camera3StreamConfig> sortedConfigs;
	sortedConfigs.reserve(unsortedConfigs.size());

	/*
	 * NV12 is the most prioritized format. Put the configuration with NV12
	 * and the largest resolution first.
	 */
	const auto nv12It = formatToConfigs.find(formats::NV12);
	if (nv12It != formatToConfigs.end()) {
		auto &nv12Configs = nv12It->second;
		const Camera3StreamConfig *nv12Largest = nv12Configs.back();

		/*
		 * If JPEG will be created from NV12 and the size is larger than
		 * the largest NV12 configurations, then put the NV12
		 * configuration for JPEG first.
		 */
		if (jpegConfig && jpegConfig->config.pixelFormat == formats::NV12) {
			const Size &nv12SizeForJpeg = jpegConfig->config.size;
			const Size &nv12LargestSize = nv12Largest->config.size;

			if (nv12LargestSize < nv12SizeForJpeg) {
				LOG(HAL, Debug) << "Insert " << jpegConfig->config.toString();
				sortedConfigs.push_back(std::move(*jpegConfig));
				jpegConfig = nullptr;
			}
		}

		LOG(HAL, Debug) << "Insert " << nv12Largest->config.toString();
		sortedConfigs.push_back(*nv12Largest);
		nv12Configs.pop_back();

		if (nv12Configs.empty())
			formatToConfigs.erase(nv12It);
	}

	/* If the configuration for JPEG is there, then put it. */
	if (jpegConfig) {
		LOG(HAL, Debug) << "Insert " << jpegConfig->config.toString();
		sortedConfigs.push_back(std::move(*jpegConfig));
		jpegConfig = nullptr;
	}

	/*
	 * Put configurations with different formats and larger resolutions
	 * earlier.
	 */
	while (!formatToConfigs.empty()) {
		for (auto it = formatToConfigs.begin(); it != formatToConfigs.end();) {
			auto &configs = it->second;
			LOG(HAL, Debug) << "Insert " << configs.back()->config.toString();
			sortedConfigs.push_back(*configs.back());
			configs.pop_back();

			if (configs.empty())
				it = formatToConfigs.erase(it);
			else
				it++;
		}
	}

	ASSERT(sortedConfigs.size() == unsortedConfigs.size());

	unsortedConfigs = sortedConfigs;
}

const char *rotationToString(int rotation)
{
	switch (rotation) {
	case CAMERA3_STREAM_ROTATION_0:
		return "0";
	case CAMERA3_STREAM_ROTATION_90:
		return "90";
	case CAMERA3_STREAM_ROTATION_180:
		return "180";
	case CAMERA3_STREAM_ROTATION_270:
		return "270";
	}
	return "INVALID";
}

#if defined(OS_CHROMEOS)
/*
 * Check whether the crop_rotate_scale_degrees values for all streams in
 * the list are valid according to the Chrome OS camera HAL API.
 */
bool validateCropRotate(const camera3_stream_configuration_t &streamList)
{
	ASSERT(streamList.num_streams > 0);
	const int cropRotateScaleDegrees =
		streamList.streams[0]->crop_rotate_scale_degrees;
	for (unsigned int i = 0; i < streamList.num_streams; ++i) {
		const camera3_stream_t &stream = *streamList.streams[i];

		switch (stream.crop_rotate_scale_degrees) {
		case CAMERA3_STREAM_ROTATION_0:
		case CAMERA3_STREAM_ROTATION_90:
		case CAMERA3_STREAM_ROTATION_270:
			break;

		/* 180° rotation is specified by Chrome OS as invalid. */
		case CAMERA3_STREAM_ROTATION_180:
		default:
			LOG(HAL, Error) << "Invalid crop_rotate_scale_degrees: "
					<< stream.crop_rotate_scale_degrees;
			return false;
		}

		if (cropRotateScaleDegrees != stream.crop_rotate_scale_degrees) {
			LOG(HAL, Error) << "crop_rotate_scale_degrees in all "
					<< "streams are not identical";
			return false;
		}
	}

	return true;
}
#endif

} /* namespace */

/*
 * \class CameraDevice
 *
 * The CameraDevice class wraps a libcamera::Camera instance, and implements
 * the camera3_device_t interface, bridging calls received from the Android
 * camera service to the CameraDevice.
 *
 * The class translates parameters and operations from the Camera HALv3 API to
 * the libcamera API to provide static information for a Camera, create request
 * templates for it, process capture requests and then deliver capture results
 * back to the framework using the designated callbacks.
 */

CameraDevice::CameraDevice(unsigned int id, std::shared_ptr<Camera> camera)
	: id_(id), state_(State::Stopped), camera_(std::move(camera)),
	  facing_(CAMERA_FACING_FRONT), orientation_(0)
{
	camera_->requestCompleted.connect(this, &CameraDevice::requestComplete);

	maker_ = "libcamera";
	model_ = "cameraModel";

	/* \todo Support getting properties on Android */
	std::ifstream fstream("/var/cache/camera/camera.prop");
	if (!fstream.is_open())
		return;

	std::string line;
	while (std::getline(fstream, line)) {
		std::string::size_type delimPos = line.find("=");
		if (delimPos == std::string::npos)
			continue;
		std::string key = line.substr(0, delimPos);
		std::string val = line.substr(delimPos + 1);

		if (!key.compare("ro.product.model"))
			model_ = val;
		else if (!key.compare("ro.product.manufacturer"))
			maker_ = val;
	}
}

CameraDevice::~CameraDevice() = default;

std::unique_ptr<CameraDevice> CameraDevice::create(unsigned int id,
						   std::shared_ptr<Camera> cam)
{
	return std::unique_ptr<CameraDevice>(
		new CameraDevice(id, std::move(cam)));
}

/*
 * Initialize the camera static information retrieved from the
 * Camera::properties or from the cameraConfigData.
 *
 * cameraConfigData is optional for external camera devices and can be
 * nullptr.
 *
 * This function is called before the camera device is opened.
 */
int CameraDevice::initialize(const CameraConfigData *cameraConfigData)
{
	/*
	 * Initialize orientation and facing side of the camera.
	 *
	 * If the libcamera::Camera provides those information as retrieved
	 * from firmware use them, otherwise fallback to values parsed from
	 * the configuration file. If the configuration file is not available
	 * the camera is external so its location and rotation can be safely
	 * defaulted.
	 */
	const ControlList &properties = camera_->properties();

	if (properties.contains(properties::Location)) {
		int32_t location = properties.get(properties::Location);
		switch (location) {
		case properties::CameraLocationFront:
			facing_ = CAMERA_FACING_FRONT;
			break;
		case properties::CameraLocationBack:
			facing_ = CAMERA_FACING_BACK;
			break;
		case properties::CameraLocationExternal:
			/*
			 * If the camera is reported as external, but the
			 * CameraHalManager has overriden it, use what is
			 * reported in the configuration file. This typically
			 * happens for UVC cameras reported as 'External' by
			 * libcamera but installed in fixed position on the
			 * device.
			 */
			if (cameraConfigData && cameraConfigData->facing != -1)
				facing_ = cameraConfigData->facing;
			else
				facing_ = CAMERA_FACING_EXTERNAL;
			break;
		}

		if (cameraConfigData && cameraConfigData->facing != -1 &&
		    facing_ != cameraConfigData->facing) {
			LOG(HAL, Warning)
				<< "Camera location does not match"
				<< " configuration file. Using " << facing_;
		}
	} else if (cameraConfigData) {
		if (cameraConfigData->facing == -1) {
			LOG(HAL, Error)
				<< "Camera facing not in configuration file";
			return -EINVAL;
		}
		facing_ = cameraConfigData->facing;
	} else {
		facing_ = CAMERA_FACING_EXTERNAL;
	}

	/*
	 * The Android orientation metadata specifies its rotation correction
	 * value in clockwise direction whereas libcamera specifies the
	 * rotation property in anticlockwise direction. Read the libcamera's
	 * rotation property (anticlockwise) and compute the corresponding
	 * value for clockwise direction as required by the Android orientation
	 * metadata.
	 */
	if (properties.contains(properties::Rotation)) {
		int rotation = properties.get(properties::Rotation);
		orientation_ = (360 - rotation) % 360;
		if (cameraConfigData && cameraConfigData->rotation != -1 &&
		    orientation_ != cameraConfigData->rotation) {
			LOG(HAL, Warning)
				<< "Camera orientation does not match"
				<< " configuration file. Using " << orientation_;
		}
	} else if (cameraConfigData) {
		if (cameraConfigData->rotation == -1) {
			LOG(HAL, Error)
				<< "Camera rotation not in configuration file";
			return -EINVAL;
		}
		orientation_ = cameraConfigData->rotation;
	} else {
		orientation_ = 0;
	}

	return capabilities_.initialize(camera_, orientation_, facing_);
}

/*
 * Open a camera device. The static information on the camera shall have been
 * initialized with a call to CameraDevice::initialize().
 */
int CameraDevice::open(const hw_module_t *hardwareModule)
{
	int ret = camera_->acquire();
	if (ret) {
		LOG(HAL, Error) << "Failed to acquire the camera";
		return ret;
	}

	/* Initialize the hw_device_t in the instance camera3_module_t. */
	camera3Device_.common.tag = HARDWARE_DEVICE_TAG;
	camera3Device_.common.version = CAMERA_DEVICE_API_VERSION_3_3;
	camera3Device_.common.module = (hw_module_t *)hardwareModule;
	camera3Device_.common.close = hal_dev_close;

	/*
	 * The camera device operations. These actually implement
	 * the Android Camera HALv3 interface.
	 */
	camera3Device_.ops = &hal_dev_ops;
	camera3Device_.priv = this;

	return 0;
}

void CameraDevice::close()
{
	stop();

	camera_->release();
}

void CameraDevice::flush()
{
	{
		MutexLocker stateLock(stateMutex_);
		if (state_ != State::Running)
			return;

		state_ = State::Flushing;
	}

	worker_.stop();
	camera_->stop();

	MutexLocker stateLock(stateMutex_);
	state_ = State::Stopped;
}

void CameraDevice::stop()
{
	MutexLocker stateLock(stateMutex_);
	if (state_ == State::Stopped)
		return;

	worker_.stop();
	camera_->stop();

	descriptors_ = {};
	streams_.clear();

	state_ = State::Stopped;
}

unsigned int CameraDevice::maxJpegBufferSize() const
{
	return capabilities_.maxJpegBufferSize();
}

void CameraDevice::setCallbacks(const camera3_callback_ops_t *callbacks)
{
	callbacks_ = callbacks;
}

const camera_metadata_t *CameraDevice::getStaticMetadata()
{
	return capabilities_.staticMetadata()->getMetadata();
}

/*
 * Produce a metadata pack to be used as template for a capture request.
 */
const camera_metadata_t *CameraDevice::constructDefaultRequestSettings(int type)
{
	auto it = requestTemplates_.find(type);
	if (it != requestTemplates_.end())
		return it->second->getMetadata();

	/* Use the capture intent matching the requested template type. */
	std::unique_ptr<CameraMetadata> requestTemplate;
	uint8_t captureIntent;
	switch (type) {
	case CAMERA3_TEMPLATE_PREVIEW:
		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
		requestTemplate = capabilities_.requestTemplatePreview();
		break;
	case CAMERA3_TEMPLATE_STILL_CAPTURE:
		/*
		 * Use the preview template for still capture, they only differ
		 * for the torch mode we currently do not support.
		 */
		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
		requestTemplate = capabilities_.requestTemplateStill();
		break;
	case CAMERA3_TEMPLATE_VIDEO_RECORD:
		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
		requestTemplate = capabilities_.requestTemplateVideo();
		break;
	case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
		requestTemplate = capabilities_.requestTemplateVideo();
		break;
	case CAMERA3_TEMPLATE_MANUAL:
		captureIntent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
		requestTemplate = capabilities_.requestTemplateManual();
		break;
	/* \todo Implement templates generation for the remaining use cases. */
	case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
	default:
		LOG(HAL, Error) << "Unsupported template request type: " << type;
		return nullptr;
	}

	if (!requestTemplate || !requestTemplate->isValid()) {
		LOG(HAL, Error) << "Failed to construct request template";
		return nullptr;
	}

	requestTemplate->updateEntry(ANDROID_CONTROL_CAPTURE_INTENT,
				     captureIntent);

	requestTemplates_[type] = std::move(requestTemplate);
	return requestTemplates_[type]->getMetadata();
}

/*
 * Inspect the stream_list to produce a list of StreamConfiguration to
 * be use to configure the Camera.
 */
int CameraDevice::configureStreams(camera3_stream_configuration_t *stream_list)
{
	/* Before any configuration attempt, stop the camera. */
	stop();

	if (stream_list->num_streams == 0) {
		LOG(HAL, Error) << "No streams in configuration";
		return -EINVAL;
	}

#if defined(OS_CHROMEOS)
	if (!validateCropRotate(*stream_list))
		return -EINVAL;
#endif

	/*
	 * Generate an empty configuration, and construct a StreamConfiguration
	 * for each camera3_stream to add to it.
	 */
	std::unique_ptr<CameraConfiguration> config = camera_->generateConfiguration();
	if (!config) {
		LOG(HAL, Error) << "Failed to generate camera configuration";
		return -EINVAL;
	}

	/*
	 * Clear and remove any existing configuration from previous calls, and
	 * ensure the required entries are available without further
	 * reallocation.
	 */
	streams_.clear();
	streams_.reserve(stream_list->num_streams);

	std::vector<Camera3StreamConfig> streamConfigs;
	streamConfigs.reserve(stream_list->num_streams);

	/* First handle all non-MJPEG streams. */
	camera3_stream_t *jpegStream = nullptr;
	for (unsigned int i = 0; i < stream_list->num_streams; ++i) {
		camera3_stream_t *stream = stream_list->streams[i];
		Size size(stream->width, stream->height);

		PixelFormat format = capabilities_.toPixelFormat(stream->format);

		LOG(HAL, Info) << "Stream #" << i
			       << ", direction: " << stream->stream_type
			       << ", width: " << stream->width
			       << ", height: " << stream->height
			       << ", format: " << utils::hex(stream->format)
			       << ", rotation: " << rotationToString(stream->rotation)
#if defined(OS_CHROMEOS)
			       << ", crop_rotate_scale_degrees: "
			       << rotationToString(stream->crop_rotate_scale_degrees)
#endif
			       << " (" << format.toString() << ")";

		if (!format.isValid())
			return -EINVAL;

		/* \todo Support rotation. */
		if (stream->rotation != CAMERA3_STREAM_ROTATION_0) {
			LOG(HAL, Error) << "Rotation is not supported";
			return -EINVAL;
		}
#if defined(OS_CHROMEOS)
		if (stream->crop_rotate_scale_degrees != CAMERA3_STREAM_ROTATION_0) {
			LOG(HAL, Error) << "Rotation is not supported";
			return -EINVAL;
		}
#endif

		/* Defer handling of MJPEG streams until all others are known. */
		if (stream->format == HAL_PIXEL_FORMAT_BLOB) {
			if (jpegStream) {
				LOG(HAL, Error)
					<< "Multiple JPEG streams are not supported";
				return -EINVAL;
			}

			jpegStream = stream;
			continue;
		}

		Camera3StreamConfig streamConfig;
		streamConfig.streams = { { stream, CameraStream::Type::Direct } };
		streamConfig.config.size = size;
		streamConfig.config.pixelFormat = format;
		streamConfigs.push_back(std::move(streamConfig));

		/* This stream will be produced by hardware. */
		stream->usage |= GRALLOC_USAGE_HW_CAMERA_WRITE;
	}

	/* Now handle the MJPEG streams, adding a new stream if required. */
	if (jpegStream) {
		CameraStream::Type type;
		int index = -1;

		/* Search for a compatible stream in the non-JPEG ones. */
		for (size_t i = 0; i < streamConfigs.size(); ++i) {
			Camera3StreamConfig &streamConfig = streamConfigs[i];
			const auto &cfg = streamConfig.config;

			/*
			 * \todo The PixelFormat must also be compatible with
			 * the encoder.
			 */
			if (cfg.size.width != jpegStream->width ||
			    cfg.size.height != jpegStream->height)
				continue;

			LOG(HAL, Info)
				<< "Android JPEG stream mapped to libcamera stream " << i;

			type = CameraStream::Type::Mapped;
			index = i;

			/*
			 * The source stream will be read by software to
			 * produce the JPEG stream.
			 */
			camera3_stream_t *stream = streamConfig.streams[0].stream;
			stream->usage |= GRALLOC_USAGE_SW_READ_OFTEN;
			break;
		}

		/*
		 * Without a compatible match for JPEG encoding we must
		 * introduce a new stream to satisfy the request requirements.
		 */
		if (index < 0) {
			/*
			 * \todo The pixelFormat should be a 'best-fit' choice
			 * and may require a validation cycle. This is not yet
			 * handled, and should be considered as part of any
			 * stream configuration reworks.
			 */
			Camera3StreamConfig streamConfig;
			streamConfig.config.size.width = jpegStream->width;
			streamConfig.config.size.height = jpegStream->height;
			streamConfig.config.pixelFormat = formats::NV12;
			streamConfigs.push_back(std::move(streamConfig));

			LOG(HAL, Info) << "Adding " << streamConfig.config.toString()
				       << " for MJPEG support";

			type = CameraStream::Type::Internal;
			index = streamConfigs.size() - 1;
		}

		/* The JPEG stream will be produced by software. */
		jpegStream->usage |= GRALLOC_USAGE_SW_WRITE_OFTEN;

		streamConfigs[index].streams.push_back({ jpegStream, type });
	}

	sortCamera3StreamConfigs(streamConfigs, jpegStream);
	for (const auto &streamConfig : streamConfigs) {
		config->addConfiguration(streamConfig.config);

		for (auto &stream : streamConfig.streams) {
			streams_.emplace_back(this, config.get(), stream.type,
					      stream.stream, config->size() - 1);
			stream.stream->priv = static_cast<void *>(&streams_.back());
		}
	}

	switch (config->validate()) {
	case CameraConfiguration::Valid:
		break;
	case CameraConfiguration::Adjusted:
		LOG(HAL, Info) << "Camera configuration adjusted";

		for (const StreamConfiguration &cfg : *config)
			LOG(HAL, Info) << " - " << cfg.toString();

		return -EINVAL;
	case CameraConfiguration::Invalid:
		LOG(HAL, Info) << "Camera configuration invalid";
		return -EINVAL;
	}

	/*
	 * Once the CameraConfiguration has been adjusted/validated
	 * it can be applied to the camera.
	 */
	int ret = camera_->configure(config.get());
	if (ret) {
		LOG(HAL, Error) << "Failed to configure camera '"
				<< camera_->id() << "'";
		return ret;
	}

	/*
	 * Configure the HAL CameraStream instances using the associated
	 * StreamConfiguration and set the number of required buffers in
	 * the Android camera3_stream_t.
	 */
	for (CameraStream &cameraStream : streams_) {
		ret = cameraStream.configure();
		if (ret) {
			LOG(HAL, Error) << "Failed to configure camera stream";
			return ret;
		}
	}

	config_ = std::move(config);
	return 0;
}

std::unique_ptr<FrameBuffer>
CameraDevice::createFrameBuffer(const buffer_handle_t camera3buffer,
				PixelFormat pixelFormat, const Size &size)
{
	CameraB
        <span class="hl kwa">for</span> ct <span class="hl kwa">in</span> <span class="hl kwb">sorted</span><span class="hl opt">(</span><span class="hl kwb">set</span><span class="hl opt">(</span>list_col<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">Colour temperature: {} K&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>ct<span class="hl opt">)</span>
            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            average tables for the same colour temperature</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            indices <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">(</span>list_col <span class="hl opt">==</span> ct<span class="hl opt">)</span>
            ct <span class="hl opt">=</span> <span class="hl kwb">int</span><span class="hl opt">(</span>ct<span class="hl opt">)</span>
            t_r <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>list_cr<span class="hl opt">[</span>indices<span class="hl opt">],</span> axis<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
            t_b <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>list_cb<span class="hl opt">[</span>indices<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 str">&quot;&quot;&quot;</span>
<span class="hl str">            force numbers to be stored to 3dp.... :(</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            t_r <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>t_r<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&lt;=</span> <span class="hl num">0.05</span><span class="hl opt">,</span> t_r<span class="hl opt">+</span><span class="hl num">0.001</span><span class="hl opt">,</span> t_r<span class="hl opt">)</span>
            t_b <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>t_b<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&lt;=</span> <span class="hl num">0.05</span><span class="hl opt">,</span> t_b<span class="hl opt">+</span><span class="hl num">0.001</span><span class="hl opt">,</span> t_b<span class="hl opt">)</span>
            t_r <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>t_r<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&gt;=</span> <span class="hl num">0.95</span><span class="hl opt">,</span> t_r<span class="hl opt">-</span><span class="hl num">0.001</span><span class="hl opt">,</span> t_r<span class="hl opt">)</span>
            t_b <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>t_b<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&gt;=</span> <span class="hl num">0.95</span><span class="hl opt">,</span> t_b<span class="hl opt">-</span><span class="hl num">0.001</span><span class="hl opt">,</span> t_b<span class="hl opt">)</span>
            t_r <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwb">round</span><span class="hl opt">(</span>t_r<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">)</span>
            t_b <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwb">round</span><span class="hl opt">(</span>t_b<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">)</span>
            r_corners <span class="hl opt">= (</span>t_r<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> t_r<span class="hl opt">[</span><span class="hl num">15</span><span class="hl opt">],</span> t_r<span class="hl opt">[-</span><span class="hl num">1</span><span class="hl opt">],</span> t_r<span class="hl opt">[-</span><span class="hl num">16</span><span class="hl opt">])</span>
            b_corners <span class="hl opt">= (</span>t_b<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> t_b<span class="hl opt">[</span><span class="hl num">15</span><span class="hl opt">],</span> t_b<span class="hl opt">[-</span><span class="hl num">1</span><span class="hl opt">],</span> t_b<span class="hl opt">[-</span><span class="hl num">16</span><span class="hl opt">])</span>
            r_cen <span class="hl opt">=</span> t_r<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>t_r<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]+</span>t_r<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>t_r<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]</span>
            r_cen <span class="hl opt">=</span> <span class="hl kwb">round</span><span class="hl opt">(</span>r_cen<span class="hl opt">/</span><span class="hl num">4</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">)</span>
            b_cen <span class="hl opt">=</span> t_b<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>t_b<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]+</span>t_b<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>t_b<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]</span>
            b_cen <span class="hl opt">=</span> <span class="hl kwb">round</span><span class="hl opt">(</span>b_cen<span class="hl opt">/</span><span class="hl num">4</span><span class="hl opt">,</span> <span class="hl num">3</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">Red table corners: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>r_corners<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">Red table centre: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>r_cen<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">Blue table corners: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>b_corners<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">Blue table centre: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>b_cen<span class="hl opt">)</span>
            cr_dict <span class="hl opt">= {</span>
                <span class="hl str">&apos;ct&apos;</span><span class="hl opt">:</span> ct<span class="hl opt">,</span>
                <span class="hl str">&apos;table&apos;</span><span class="hl opt">:</span> <span class="hl kwb">list</span><span class="hl opt">(</span>t_r<span class="hl opt">)</span>
            <span class="hl opt">}</span>
            cb_dict <span class="hl opt">= {</span>
                <span class="hl str">&apos;ct&apos;</span><span class="hl opt">:</span> ct<span class="hl opt">,</span>
                <span class="hl str">&apos;table&apos;</span><span class="hl opt">:</span> <span class="hl kwb">list</span><span class="hl opt">(</span>t_b<span class="hl opt">)</span>
            <span class="hl opt">}</span>
            cal_cr_list<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>cr_dict<span class="hl opt">)</span>
            cal_cb_list<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>cb_dict<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">&apos;</span>
    <span class="hl kwa">else</span><span class="hl opt">:</span>
        cal_cr_list<span class="hl opt">,</span> cal_cb_list <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 str">&quot;&quot;&quot;</span>
<span class="hl str">    average all values for luminance shading and return one table for all temperatures</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    lum_lut <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>list_cg<span class="hl opt">,</span> axis<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
    lum_lut <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>lum_lut<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&lt;=</span> <span class="hl num">0.05</span><span class="hl opt">,</span> lum_lut<span class="hl opt">+</span><span class="hl num">0.001</span><span class="hl opt">,</span> lum_lut<span class="hl opt">)</span>
    lum_lut <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">where</span><span class="hl opt">((</span><span class="hl num">100</span><span class="hl opt">*</span>lum_lut<span class="hl opt">) %</span> <span class="hl num">1</span> <span class="hl opt">&gt;=</span> <span class="hl num">0.95</span><span class="hl opt">,</span> lum_lut<span class="hl opt">-</span><span class="hl num">0.001</span><span class="hl opt">,</span> lum_lut<span class="hl opt">)</span>
    lum_lut <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 kwb">round</span><span class="hl opt">(</span>lum_lut<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">))</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    calculate average corner for lsc gain calculation further on</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    corners <span class="hl opt">= (</span>lum_lut<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> lum_lut<span class="hl opt">[</span><span class="hl num">15</span><span class="hl opt">],</span> lum_lut<span class="hl opt">[-</span><span class="hl num">1</span><span class="hl opt">],</span> lum_lut<span class="hl opt">[-</span><span class="hl num">16</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">Luminance table corners: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>corners<span class="hl opt">)</span>
    l_cen <span class="hl opt">=</span> lum_lut<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>lum_lut<span class="hl opt">[</span><span class="hl num">5</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]+</span>lum_lut<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">7</span><span class="hl opt">]+</span>lum_lut<span class="hl opt">[</span><span class="hl num">6</span><span class="hl opt">*</span><span class="hl num">16</span><span class="hl opt">+</span><span class="hl num">8</span><span class="hl opt">]</span>
    l_cen <span class="hl opt">=</span> <span class="hl kwb">round</span><span class="hl opt">(</span>l_cen<span class="hl opt">/</span><span class="hl num">4</span><span class="hl opt">,</span> <span class="hl num">3</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">Luminance table centre: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>l_cen<span class="hl opt">)</span>
    av_corn <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwb">sum</span><span class="hl opt">(</span>corners<span class="hl opt">)/</span><span class="hl num">4</span>

    <span class="hl kwa">return</span> cal_cr_list<span class="hl opt">,</span> cal_cb_list<span class="hl opt">,</span> lum_lut<span class="hl opt">,</span> av_corn


<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">calculate g/r and g/b for 32x32 points arranged in a grid for a single image</span>
<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl kwa">def</span> <span class="hl kwd">alsc</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> Img<span class="hl opt">,</span> do_alsc_colour<span class="hl opt">,</span> plot<span class="hl opt">=</span><span class="hl kwa">False</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">Processing image: &apos;</span> <span class="hl opt">+</span> Img<span class="hl opt">.</span>name
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    get channel in correct order</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    channels <span class="hl opt">= [</span>Img<span class="hl opt">.</span>channels<span class="hl opt">[</span>i<span class="hl opt">]</span> <span class="hl kwa">for</span> i <span class="hl kwa">in</span> Img<span class="hl opt">.</span>order<span class="hl opt">]</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    calculate size of single rectangle.</span>
<span class="hl str">    -(-(w-1)//32) is a ceiling division. w-1 is to deal robustly with the case</span>
<span class="hl str">    where w is a multiple of 32.</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    w<span class="hl opt">,</span> h <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> Img<span class="hl opt">.</span>h<span class="hl opt">/</span><span class="hl num">2</span>
    dx<span class="hl opt">,</span> dy <span class="hl opt">=</span> <span class="hl kwb">int</span><span class="hl opt">(-(-(</span>w<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">)//</span><span class="hl num">16</span><span class="hl opt">)),</span> <span class="hl kwb">int</span><span class="hl opt">(-(-(</span>h<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">)//</span><span class="hl num">12</span><span class="hl opt">))</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    average the green channels into one</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    av_ch_g <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">((</span>channels<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> axis<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
    <span class="hl kwa">if</span> do_alsc_colour<span class="hl opt">:</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        obtain 16x12 grid of intensities for each channel and subtract black level</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        g <span class="hl opt">=</span> <span class="hl kwd">get_16x12_grid</span><span class="hl opt">(</span>av_ch_g<span class="hl opt">,</span> dx<span class="hl opt">,</span> dy<span class="hl opt">) -</span> Img<span class="hl opt">.</span>blacklevel_16
        r <span class="hl opt">=</span> <span class="hl kwd">get_16x12_grid</span><span class="hl opt">(</span>channels<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">],</span> dx<span class="hl opt">,</span> dy<span class="hl opt">) -</span> Img<span class="hl opt">.</span>blacklevel_16
        b <span class="hl opt">=</span> <span class="hl kwd">get_16x12_grid</span><span class="hl opt">(</span>channels<span class="hl opt">[</span><span class="hl num">3</span><span class="hl opt">],</span> dx<span class="hl opt">,</span> dy<span class="hl opt">) -</span> Img<span class="hl opt">.</span>blacklevel_16
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        calculate ratios as 32 bit in order to be supported by medianBlur function</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        cr <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">reshape</span><span class="hl opt">(</span>g<span class="hl opt">/</span>r<span class="hl opt">, (</span><span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">16</span><span class="hl opt">)).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float32&apos;</span><span class="hl opt">)</span>
        cb <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">reshape</span><span class="hl opt">(</span>g<span class="hl opt">/</span>b<span class="hl opt">, (</span><span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">16</span><span class="hl opt">)).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float32&apos;</span><span class="hl opt">)</span>
        cg <span class="hl opt">=</span> np<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>g<span class="hl opt">, (</span><span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">16</span><span class="hl opt">)).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float32&apos;</span><span class="hl opt">)</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        median blur to remove peaks and save as float 64</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        cr <span class="hl opt">=</span> cv2<span class="hl opt">.</span><span class="hl kwd">medianBlur</span><span class="hl opt">(</span>cr<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float64&apos;</span><span class="hl opt">)</span>
        cb <span class="hl opt">=</span> cv2<span class="hl opt">.</span><span class="hl kwd">medianBlur</span><span class="hl opt">(</span>cb<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float64&apos;</span><span class="hl opt">)</span>
        cg <span class="hl opt">=</span> cv2<span class="hl opt">.</span><span class="hl kwd">medianBlur</span><span class="hl opt">(</span>cg<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float64&apos;</span><span class="hl opt">)</span>
        cg <span class="hl opt">=</span> cg<span class="hl opt">/</span>np<span class="hl opt">.</span><span class="hl kwb">min</span><span class="hl opt">(</span>cg<span class="hl opt">)</span>

        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        debugging code showing 2D surface plot of vignetting. Quite useful for</span>
<span class="hl str">        for sanity check</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        <span class="hl kwa">if</span> plot<span class="hl opt">:</span>
            hf <span class="hl opt">=</span> plt<span class="hl opt">.</span><span class="hl kwd">figure</span><span class="hl opt">(</span>figsize<span class="hl opt">=(</span><span class="hl num">8</span><span class="hl opt">,</span> <span class="hl num">8</span><span class="hl opt">))</span>
            ha <span class="hl opt">=</span> hf<span class="hl opt">.</span><span class="hl kwd">add_subplot</span><span class="hl opt">(</span><span class="hl num">311</span><span class="hl opt">,</span> projection<span class="hl opt">=</span><span class="hl str">&apos;3d&apos;</span><span class="hl opt">)</span>
            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            note Y is plotted as -Y so plot has same axes as image</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            X<span class="hl opt">,</span> Y <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">meshgrid</span><span class="hl opt">(</span><span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">),</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">12</span><span class="hl opt">))</span>
            ha<span class="hl opt">.</span><span class="hl kwd">plot_surface</span><span class="hl opt">(</span>X<span class="hl opt">, -</span>Y<span class="hl opt">,</span> cr<span class="hl opt">,</span> cmap<span class="hl opt">=</span>cm<span class="hl opt">.</span>coolwarm<span class="hl opt">,</span> linewidth<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
            ha<span class="hl opt">.</span><span class="hl kwd">set_title</span><span class="hl opt">(</span><span class="hl str">&apos;ALSC Plot</span><span class="hl esc">\n</span><span class="hl str">Img: {}</span><span class="hl esc">\n\n</span><span class="hl str">cr&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>Img<span class="hl opt">.</span><span class="hl kwb">str</span><span class="hl opt">))</span>
            hb <span class="hl opt">=</span> hf<span class="hl opt">.</span><span class="hl kwd">add_subplot</span><span class="hl opt">(</span><span class="hl num">312</span><span class="hl opt">,</span> projection<span class="hl opt">=</span><span class="hl str">&apos;3d&apos;</span><span class="hl opt">)</span>
            hb<span class="hl opt">.</span><span class="hl kwd">plot_surface</span><span class="hl opt">(</span>X<span class="hl opt">, -</span>Y<span class="hl opt">,</span> cb<span class="hl opt">,</span> cmap<span class="hl opt">=</span>cm<span class="hl opt">.</span>coolwarm<span class="hl opt">,</span> linewidth<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
            hb<span class="hl opt">.</span><span class="hl kwd">set_title</span><span class="hl opt">(</span><span class="hl str">&apos;cb&apos;</span><span class="hl opt">)</span>
            hc <span class="hl opt">=</span> hf<span class="hl opt">.</span><span class="hl kwd">add_subplot</span><span class="hl opt">(</span><span class="hl num">313</span><span class="hl opt">,</span> projection<span class="hl opt">=</span><span class="hl str">&apos;3d&apos;</span><span class="hl opt">)</span>
            hc<span class="hl opt">.</span><span class="hl kwd">plot_surface</span><span class="hl opt">(</span>X<span class="hl opt">, -</span>Y<span class="hl opt">,</span> cg<span class="hl opt">,</span> cmap<span class="hl opt">=</span>cm<span class="hl opt">.</span>coolwarm<span class="hl opt">,</span> linewidth<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
            hc<span class="hl opt">.</span><span class="hl kwd">set_title</span><span class="hl opt">(</span><span class="hl str">&apos;g&apos;</span><span class="hl opt">)</span>
            <span class="hl slc"># print(Img.str)</span>
            plt<span class="hl opt">.</span><span class="hl kwd">show</span><span class="hl opt">()</span>

        <span class="hl kwa">return</span> Img<span class="hl opt">.</span>col<span class="hl opt">,</span> cr<span class="hl opt">.</span><span class="hl kwd">flatten</span><span class="hl opt">(),</span> cb<span class="hl opt">.</span><span class="hl kwd">flatten</span><span class="hl opt">(),</span> cg<span class="hl opt">.</span><span class="hl kwd">flatten</span><span class="hl opt">(), (</span>w<span class="hl opt">,</span> h<span class="hl opt">,</span> dx<span class="hl opt">,</span> dy<span class="hl opt">)</span>

    <span class="hl kwa">else</span><span class="hl opt">:</span>
        <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">        only perform calculations for luminance shading</span>
<span class="hl str">        &quot;&quot;&quot;</span>
        g <span class="hl opt">=</span> <span class="hl kwd">get_16x12_grid</span><span class="hl opt">(</span>av_ch_g<span class="hl opt">,</span> dx<span class="hl opt">,</span> dy<span class="hl opt">) -</span> Img<span class="hl opt">.</span>blacklevel_16
        cg <span class="hl opt">=</span> np<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>g<span class="hl opt">, (</span><span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">16</span><span class="hl opt">)).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float32&apos;</span><span class="hl opt">)</span>
        cg <span class="hl opt">=</span> cv2<span class="hl opt">.</span><span class="hl kwd">medianBlur</span><span class="hl opt">(</span>cg<span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">).</span><span class="hl kwd">astype</span><span class="hl opt">(</span><span class="hl str">&apos;float64&apos;</span><span class="hl opt">)</span>
        cg <span class="hl opt">=</span> cg<span class="hl opt">/</span>np<span class="hl opt">.</span><span class="hl kwb">min</span><span class="hl opt">(</span>cg<span class="hl opt">)</span>

        <span class="hl kwa">if</span> plot<span class="hl opt">:</span>
            hf <span class="hl opt">=</span> plt<span class="hl opt">.</span><span class="hl kwd">figure</span><span class="hl opt">(</span>figssize<span class="hl opt">=(</span><span class="hl num">8</span><span class="hl opt">,</span> <span class="hl num">8</span><span class="hl opt">))</span>
            ha <span class="hl opt">=</span> hf<span class="hl opt">.</span><span class="hl kwd">add_subplot</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> projection<span class="hl opt">=</span><span class="hl str">&apos;3d&apos;</span><span class="hl opt">)</span>
            X<span class="hl opt">,</span> Y <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">meashgrid</span><span class="hl opt">(</span><span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">16</span><span class="hl opt">),</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">12</span><span class="hl opt">))</span>
            ha<span class="hl opt">.</span><span class="hl kwd">plot_surface</span><span class="hl opt">(</span>X<span class="hl opt">, -</span>Y<span class="hl opt">,</span> cg<span class="hl opt">,</span> cmap<span class="hl opt">=</span>cm<span class="hl opt">.</span>coolwarm<span class="hl opt">,</span> linewidth<span class="hl opt">=</span><span class="hl num">0</span><span class="hl opt">)</span>
            ha<span class="hl opt">.</span><span class="hl kwd">set_title</span><span class="hl opt">(</span><span class="hl str">&apos;ALSC Plot (Luminance only!)</span><span class="hl esc">\n</span><span class="hl str">Img: {}</span><span class="hl esc">\n\n</span><span class="hl str">cg&apos;</span><span class="hl opt">).</span><span class="hl kwd">format</span><span class="hl opt">(</span>Img<span class="hl opt">.</span><span class="hl kwb">str</span><span class="hl opt">)</span>
            plt<span class="hl opt">.</span><span class="hl kwd">show</span><span class="hl opt">()</span>

        <span class="hl kwa">return</span> Img<span class="hl opt">.</span>col<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> cg<span class="hl opt">.</span><span class="hl kwd">flatten</span><span class="hl opt">(), (</span>w<span class="hl opt">,</span> h<span class="hl opt">,</span> dx<span class="hl opt">,</span> dy<span class="hl opt">)</span>


<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">Compresses channel down to a 16x12 grid</span>
<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl kwa">def</span> <span class="hl kwd">get_16x12_grid</span><span class="hl opt">(</span>chan<span class="hl opt">,</span> dx<span class="hl opt">,</span> dy<span class="hl opt">):</span>
    grid <span class="hl opt">= []</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    since left and bottom border will not necessarily have rectangles of</span>
<span class="hl str">    dimension dx x dy, the 32nd iteration has to be handled separately.</span>
<span class="hl str">    &quot;&quot;&quot;</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 num">11</span><span class="hl opt">):</span>
        <span class="hl kwa">for</span> j <span class="hl kwa">in</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">15</span><span class="hl opt">):</span>
            grid<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>chan<span class="hl opt">[</span>dy<span class="hl opt">*</span>i<span class="hl opt">:</span>dy<span class="hl opt">*(</span><span class="hl num">1</span><span class="hl opt">+</span>i<span class="hl opt">),</span> dx<span class="hl opt">*</span>j<span class="hl opt">:</span>dx<span class="hl opt">*(</span><span class="hl num">1</span><span class="hl opt">+</span>j<span class="hl opt">)]))</span>
        grid<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>chan<span class="hl opt">[</span>dy<span class="hl opt">*</span>i<span class="hl opt">:</span>dy<span class="hl opt">*(</span><span class="hl num">1</span><span class="hl opt">+</span>i<span class="hl opt">),</span> <span class="hl num">15</span><span class="hl opt">*</span>dx<span class="hl opt">:]))</span>
    <span class="hl kwa">for</span> j <span class="hl kwa">in</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">15</span><span class="hl opt">):</span>
        grid<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>chan<span class="hl opt">[</span><span class="hl num">11</span><span class="hl opt">*</span>dy<span class="hl opt">:,</span> dx<span class="hl opt">*</span>j<span class="hl opt">:</span>dx<span class="hl opt">*(</span><span class="hl num">1</span><span class="hl opt">+</span>j<span class="hl opt">)]))</span>
    grid<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>chan<span class="hl opt">[</span><span class="hl num">11</span><span class="hl opt">*</span>dy<span class="hl opt">:,</span> <span class="hl num">15</span><span class="hl opt">*</span>dx<span class="hl opt">:]))</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    return as np.array, ready for further manipulation</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl kwa">return</span> np<span class="hl opt">.</span><span class="hl kwd">array</span><span class="hl opt">(</span>grid<span class="hl opt">)</span>


<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">obtains sigmas for red and blue, effectively a measure of the &apos;error&apos;</span>
<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl kwa">def</span> <span class="hl kwd">get_sigma</span><span class="hl opt">(</span>Cam<span class="hl opt">,</span> cal_cr_list<span class="hl opt">,</span> cal_cb_list<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">Calculating sigmas&apos;</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    provided colour alsc tables were generated for two different colour</span>
<span class="hl str">    temperatures sigma is calculated by comparing two calibration temperatures</span>
<span class="hl str">    adjacent in colour space</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    create list of colour temperatures</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    cts <span class="hl opt">= [</span>cal<span class="hl opt">[</span><span class="hl str">&apos;ct&apos;</span><span class="hl opt">]</span> <span class="hl kwa">for</span> cal <span class="hl kwa">in</span> cal_cr_list<span class="hl opt">]</span>
    <span class="hl slc"># print(cts)</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    calculate sigmas for each adjacent cts and return worst one</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    sigma_rs <span class="hl opt">= []</span>
    sigma_bs <span class="hl opt">= []</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>cts<span class="hl opt">)-</span><span class="hl num">1</span><span class="hl opt">):</span>
        sigma_rs<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span><span class="hl kwd">calc_sigma</span><span class="hl opt">(</span>cal_cr_list<span class="hl opt">[</span>i<span class="hl opt">][</span><span class="hl str">&apos;table&apos;</span><span class="hl opt">],</span> cal_cr_list<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span><span class="hl str">&apos;table&apos;</span><span class="hl opt">]))</span>
        sigma_bs<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span><span class="hl kwd">calc_sigma</span><span class="hl opt">(</span>cal_cb_list<span class="hl opt">[</span>i<span class="hl opt">][</span><span class="hl str">&apos;table&apos;</span><span class="hl opt">],</span> cal_cb_list<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span><span class="hl str">&apos;table&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">Colour temperature interval {} - {} K&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>cts<span class="hl opt">[</span>i<span class="hl opt">],</span> cts<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</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">Sigma red: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>sigma_rs<span class="hl opt">[-</span><span class="hl num">1</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">Sigma blue: {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>sigma_bs<span class="hl opt">[-</span><span class="hl num">1</span><span class="hl opt">])</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    return maximum sigmas, not necessarily from the same colour temperature</span>
<span class="hl str">    interval</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    sigma_r <span class="hl opt">=</span> <span class="hl kwb">max</span><span class="hl opt">(</span>sigma_rs<span class="hl opt">)</span> <span class="hl kwa">if</span> sigma_rs <span class="hl kwa">else</span> <span class="hl num">0.005</span>
    sigma_b <span class="hl opt">=</span> <span class="hl kwb">max</span><span class="hl opt">(</span>sigma_bs<span class="hl opt">)</span> <span class="hl kwa">if</span> sigma_bs <span class="hl kwa">else</span> <span class="hl num">0.005</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">Maximum sigmas: Red = {} Blue = {}&apos;</span><span class="hl opt">.</span><span class="hl kwd">format</span><span class="hl opt">(</span>sigma_r<span class="hl opt">,</span> sigma_b<span class="hl opt">)</span>

    <span class="hl slc"># print(sigma_rs, sigma_bs)</span>
    <span class="hl slc"># print(sigma_r, sigma_b)</span>
    <span class="hl kwa">return</span> sigma_r<span class="hl opt">,</span> sigma_b


<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">calculate sigma from two adjacent gain tables</span>
<span class="hl str">&quot;&quot;&quot;</span>
<span class="hl kwa">def</span> <span class="hl kwd">calc_sigma</span><span class="hl opt">(</span>g1<span class="hl opt">,</span> g2<span class="hl opt">):</span>
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    reshape into 16x12 matrix</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    g1 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">reshape</span><span class="hl opt">(</span>g1<span class="hl opt">, (</span><span class="hl num">12</span><span class="hl opt">,</span> <span class="hl num">16</span><span class="hl opt">))</span>
    g2 <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">reshape</span><span class="hl opt">(</span>g2<span class="hl opt">, (</span><span class="hl num">12</span><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">    apply gains to gain table</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    gg <span class="hl opt">=</span> g1<span class="hl opt">/</span>g2
    <span class="hl kwa">if</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>gg<span class="hl opt">) &lt;</span> <span class="hl num">1</span><span class="hl opt">:</span>
        gg <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">/</span>gg
    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    for each internal patch, compute average difference between it and its 4</span>
<span class="hl str">    neighbours, then append to list</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    diffs <span class="hl opt">= []</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 num">10</span><span class="hl opt">):</span>
        <span class="hl kwa">for</span> j <span class="hl kwa">in</span> <span class="hl kwb">range</span><span class="hl opt">(</span><span class="hl num">14</span><span class="hl opt">):</span>
            <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">            note indexing is incremented by 1 since all patches on borders are</span>
<span class="hl str">            not counted</span>
<span class="hl str">            &quot;&quot;&quot;</span>
            diff <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwb">abs</span><span class="hl opt">(</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">]-</span>gg<span class="hl opt">[</span>i<span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">])</span>
            diff <span class="hl opt">+=</span> np<span class="hl opt">.</span><span class="hl kwb">abs</span><span class="hl opt">(</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">]-</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">2</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">])</span>
            diff <span class="hl opt">+=</span> np<span class="hl opt">.</span><span class="hl kwb">abs</span><span class="hl opt">(</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">]-</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">])</span>
            diff <span class="hl opt">+=</span> np<span class="hl opt">.</span><span class="hl kwb">abs</span><span class="hl opt">(</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">]-</span>gg<span class="hl opt">[</span>i<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">][</span>j<span class="hl opt">+</span><span class="hl num">2</span><span class="hl opt">])</span>
            diffs<span class="hl opt">.</span><span class="hl kwd">append</span><span class="hl opt">(</span>diff<span class="hl opt">/</span><span class="hl num">4</span><span class="hl opt">)</span>

    <span class="hl str">&quot;&quot;&quot;</span>
<span class="hl str">    return mean difference</span>
<span class="hl str">    &quot;&quot;&quot;</span>
    mean_diff <span class="hl opt">=</span> np<span class="hl opt">.</span><span class="hl kwd">mean</span><span class="hl opt">(</span>diffs<span class="hl opt">)</span>
    <span class="hl kwa">return</span><span class="hl opt">(</span>np<span class="hl opt">.</span><span class="hl kwb">round</span><span class="hl opt">(</span>mean_diff<span class="hl opt">,</span> <span class="hl num">5</span><span class="hl opt">))</span>
</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 2025-03-07 12:08:20 +0000</div>
</div> <!-- id=cgit -->
</body>
</html>