/* SPDX-License-Identifier: BSD-2-Clause */ /* * Copyright (C) 2019, Raspberry Pi Ltd * Copyright (C) 2024, Ideas on Board Oy * * Piecewise linear functions */ #include "pwl.h" #include #include /** * \file pwl.h * \brief Piecewise linear functions */ namespace libcamera { namespace ipa { /** * \class Pwl * \brief Describe a univariate piecewise linear function in two-dimensional * real space * * A piecewise linear function is a univariate function that maps reals to * reals, and it is composed of multiple straight-line segments. * * While a mathematical piecewise linear function would usually be defined by * a list of linear functions and for which values of the domain they apply, * this Pwl class is instead defined by a list of points at which these line * segments intersect. These intersecting points are known as knots. * * https://en.wikipedia.org/wiki/Piecewise_linear_function * * A consequence of the Pwl class being defined by knots instead of linear * functions is that the values of the piecewise linear function past the ends * of the function are constants as opposed to linear functions. In a * mathematical piecewise linear function that is defined by multiple linear * functions, the ends of the function are also linear functions and hence grow * to infinity (or negative infinity). However, since this Pwl class is defined * by knots, the y-value of the leftmost and rightmost knots will hold for all * x values to negative infinity and positive infinity, respectively. */ /** * \typedef Pwl::Point * \brief Describe a point in two-dimensional real space */ /** * \class Pwl::Interval * \brief Describe an interval in one-dimensional real space */ /** * \fn Pwl::Interval::Interval(double _start, double _end) * \brief Construct an interval * \param[in] _start Start of the interval * \param[in] _end End of the interval */ /** * \fn Pwl::Interval::contains * \brief Check if a given value falls within the interval * \param[in] value Value to check * \return True if the value falls within the interval, including its bounds, * or false otherwise */ /** * \fn Pwl::Interval::clamp * \brief Clamp a value such that it is within the interval * \param[in] value Value to clamp * \return The clamped value */ /** * \fn Pwl::Interval::length * \brief Compute the length of the interval * \return The length of the interval */ /** * \var Pwl::Interval::start * \brief Start of the interval */ /** * \var Pwl::Interval::end * \brief End of the interval */ /** * \brief Construct an empty piecewise linear function */ Pwl::Pwl() { } /** * \brief Construct a piecewise linear function from a list of 2D points * \param[in] points Vector of points from which to construct the piecewise * linear function * * \a points must be in ascending order of x-value. */ Pwl::Pwl(const std::vector &points) : points_(points) { } /** * \copydoc Pwl::Pwl(const std::vector &points) * * The contents of the \a points vector is moved to the newly constructed Pwl * instance. */ Pwl::Pwl(std::vector &&points) : points_(std::move(points)) { } /** * \brief Append a point to the end of the piecewise linear function * \param[in] x x-coordinate of the point to add to the piecewise linear function * \param[in] y y-coordinate of the point to add to the piecewise linear function * \param[in] eps Epsilon for the minimum x distance between points (optional) * * The point's x-coordinate must be greater than the x-coordinate of the last * (= greatest) point already in the piecewise linear function. */ void Pwl::append(double x, double y, const double eps) { if (points_.empty() || points_.back().x() + eps < x) points_.push_back(Point({ x, y })); } /** * \brief Prepend a point to the beginning of the piecewise linear function * \param[in] x x-coordinate of the point to add to the piecewise linear function * \param[in] y y-coordinate of the point to add to the piecewise linear function * \param[in] eps Epsilon for the minimum x distance between points (optional) * * The point's x-coordinate must be less than the x-coordinate of the first * (= smallest) point already in the piecewise linear function. */ void Pwl::prepend(double x, double y, const double eps) { if (points_.empty() || points_.front().x() - eps > x) points_.insert(points_.begin(), Point({ x, y })); } /** * \fn Pwl::empty() const * \brief Check if the piecewise linear function is empty * \return True if there are no points in the function, false otherwise */ /** * \fn Pwl::size() const * \brief Retrieve the number of points in the piecewise linear function * \return The number of points in the piecewise linear function */ /** * \brief Get the domain of the piecewise linear function * \return An interval representing the domain */ Pwl::Interval Pwl::domain() const { return Interval(points_[0].x(), points_[points_.size() - 1].x()); } /** * \brief Get the range of the piecewise linear function * \return An interval representing the range */ Pwl::Interval Pwl::range() const { double lo = points_[0].y(), hi = lo; for (auto &p : points_) lo = std::min(lo, p.y()), hi = std::max(hi, p.y()); return Interval(lo, hi); } /** * \brief Evaluate the piecewise linear function * \param[in] x The x value to input into the function * \param[inout] span Initial guess for span * \param[in] updateSpan Set to true to update span * * Evaluate Pwl, optionally supplying an initial guess for the * "span". The "span" may be optionally be updated. If you want to know * the "span" value but don't have an initial guess you can set it to * -1. * * \return The result of evaluating the piecewise linear function at position \a x */ double Pwl::eval(double x, int *span, bool updateSpan) const { int index = findSpan(x, span && *span != -1 ? *span : points_.size() / 2 - 1); if (span && updateSpan) *span = index; return points_[index].y() + (x - points_[index].x()) * (points_[index + 1].y() - points_[index].y()) / (points_[index + 1].x() - points_[index].x()); } int Pwl::findSpan(double x, int span) const { /* * Pwls are generally small, so linear search may well be faster than * binary, though could review this if large Pwls start turning up. */ int lastSpan = points_.size() - 2; /* * some algorithms may call us with span pointing directly at the last * control point */ span = std::max(0, std::min(lastSpan, span)); while (span < lastSpan && x >= points_[span + 1].x()) span++; while (span && x < points_[span].x()) span--; return span; } /** * \brief Compute the inverse function * \param[in] eps Epsilon for the minimum x distance between points (optional) * * The output includes whether the resulting inverse function is a proper * (true) inverse, or only a best effort (e.g. input was non-monotonic). * * \return A pair of the inverse piecewise linear function, and whether or not * the result is a proper/true inverse */ std::pair Pwl::inverse(const double eps) const { bool appended = false, prepended = false, neither = false; Pwl inverse; for (Point const &p : points_) { if (inverse.empty()) { inverse.append(p.y(), p.x(), eps); } else if (std::abs(inverse.points_.back().x() - p.y()) <= eps || std::abs(inverse.points_.front().x() - p.y()) <= eps) { /* do nothing */; } else if (p.y() > inverse.points_.back().x()) { inverse.append(p.y(), p.x(), eps); appended = true; } else if (p.y() < inverse.points_.front().x()) { inverse.prepend(p.y(), p.x(), eps); prepended = true; } else { neither = true; } } /* * This is not a proper inverse if we found ourselves putting points * onto both ends of the inverse, or if there were points that couldn't * go on either. */ bool trueInverse = !(neither || (appended && prepended)); return { inverse, trueInverse }; } /** * \brief Compose two piecewise linear functions together * \param[in] other The "other" piecewise linear function * \param[in] eps Epsilon for the minimum x distance between points (optional) * * The "this" function is done first, and "other" after. * * \return The composed piecewise linear function */ Pwl Pwl::compose(Pwl const &other, const double eps) const { double thisX = points_[0].x(), thisY = points_[0].y(); int thisSpan = 0, otherSpan = other.findSpan(thisY, 0); Pwl result({ Point({ thisX, other.eval(thisY, &otherSpan, false) }) }); while (thisSpan != (int)points_.size() - 1) { double dx = points_[thisSpan + 1].x() - points_[thisSpan].x(), dy = points_[thisSpan + 1].y() - points_[thisSpan].y(); if (std::abs(dy) > eps && otherSpan + 1 < (int)other.points_.size() && points_[thisSpan + 1].y() >= other.points_[otherSpan + 1].x() + eps) { /* * next control point in result will be where this * function's y reaches the next span in other */ thisX = points_[thisSpan].x() + (other.points_[otherSpan + 1].x() - points_[thisSpan].y()) * dx / dy; thisY = other.points_[++otherSpan].x(); } else if (std::abs(dy) > eps && otherSpan > 0 && points_[thisSpan + 1].y() <= other.points_[otherSpan - 1].x() - eps) { /* * next control point in result will be where this * function's y reaches the previous span in other */ thisX = points_[thisSpan].x() + (other.points_[otherSpan + 1].x() - points_[thisSpan].y()) * dx / dy; thisY = other.points_[--otherSpan].x(); } else { /* we stay in the same span in other */ thisSpan++; thisX = points_[thisSpan].x(), thisY = points_[thisSpan].y(); } result.append(thisX, other.eval(thisY, &otherSpan, false), eps); } return result; } /** * \brief Apply function to (x, y) values at every control point * \param[in] f Function to be applied */ void Pwl::map(std::function f) const { for (auto &pt : points_) f(pt.x(), pt.y()); } /** * \brief Apply function to (x, y0, y1) values wherever either Pwl has a * control point. * \param[in] pwl0 First piecewise linear function * \param[in] pwl1 Second piecewise linear function * \param[in] f Function to be applied * * This applies the function \a f to every parameter (x, y0, y1), where x is * the combined list of x-values from \a pwl0 and \a pwl1, y0 is the y-value * for the given x in \a pwl0, and y1 is the y-value for the same x in \a pwl1. */ void Pwl::map2(Pwl const &pwl0, Pwl const &pwl1, std::function f) { int span0 = 0, span1 = 0; double x = std::min(pwl0.points_[0].x(), pwl1.points_[0].x()); f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); while (span0 < (int)pwl0.points_.size() - 1 || span1 < (int)pwl1.points_.size() - 1) { if (span0 == (int)pwl0.points_.size() - 1) x = pwl1.points_[++span1].x(); else if (span1 == (int)pwl1.points_.size() - 1) x = pwl0.points_[++span0].x(); else if (pwl0.points_[span0 + 1].x() > pwl1.points_[span1 + 1].x()) x = pwl1.points_[++span1].x(); else x = pwl0.points_[++span0].x(); f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); } } /** * \brief Combine two Pwls * \param[in] pwl0 First piecewise linear function * \param[in] pwl1 Second piecewise linear function * \param[in] f Function to be applied * \param[in] eps Epsilon for the minimum x distance between points (optional) * * Create a new Pwl where the y values are given by running \a f wherever * either pwl has a knot. * * \return The combined pwl */ Pwl Pwl::combine(Pwl const &pwl0, Pwl const &pwl1, std::function f, const double eps) { Pwl result; map2(pwl0, pwl1, [&](double x, double y0, double y1) { result.append(x, f(x, y0, y1), eps); }); return result; } /** * \brief Multiply the piecewise linear function * \param[in] d Scalar multiplier to multiply the function by * \return This function, after it has been multiplied by \a d */ Pwl &Pwl::operator*=(double d) { for (auto &pt : points_) pt[1] *= d; return *this; } /** * \brief Assemble and return a string describing the piecewise linear function * \return A string describing the piecewise linear function */ std::string Pwl::toString() const { std::stringstream ss; ss << "Pwl { "; for (auto &p : points_) ss << "(" << p.x() << ", " << p.y() << ") "; ss << "}"; return ss.str(); } } /* namespace ipa */ #ifndef __DOXYGEN__ /* * The YAML data shall be a list of numerical values with an even number of * elements. They are parsed in pairs into x and y points in the piecewise * linear function, and added in order. x must be monotonically increasing. */ template<> std::optional YamlObject::Getter::get(const YamlObject &obj) const { if (!obj.size() || obj.size() % 2) return std::nullopt; ipa::Pwl pwl; const auto &list = obj.asList(); for (auto it = list.begin(); it != list.end(); it++) { auto x = it->get(); if (!x) return std::nullopt; auto y = (++it)->get(); if (!y) return std::nullopt; pwl.append(*x, *y); } if (pwl.size() != obj.size() / 2) return std::nullopt; return pwl; } #endif /* __DOXYGEN__ */ } /* namespace libcamera */ 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837

#!/usr/bin/env python3
#
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (C) 2019, Raspberry Pi Ltd
#
# ctt.py - camera tuning tool

import os
import sys
from ctt_image_load import *
from ctt_ccm import *
from ctt_awb import *
from ctt_alsc import *
from ctt_lux import *
from ctt_noise import *
from ctt_geq import *
from ctt_pretty_print_json import pretty_print
import random
import json
import re

"""
This file houses the camera object, which is used to perform the calibrations.
The camera object houses all the calibration images as attributes in two lists:
    - imgs (macbeth charts)
    - imgs_alsc (alsc correction images)
Various calibrations are methods of the camera object, and the output is stored
in a dictionary called self.json.
Once all the caibration has been completed, the Camera.json is written into a
json file.
The camera object initialises its json dictionary by reading from a pre-written
blank json file. This has been done to avoid reproducing the entire json file
in the code here, thereby avoiding unecessary clutter.
"""


"""
Get the colour and lux values from the strings of each inidvidual image
"""
def get_col_lux(string):
    """
    Extract colour and lux values from filename
    """
    col = re.search(r'([0-9]+)[kK](\.(jpg|jpeg|brcm|dng)|_.*\.(jpg|jpeg|brcm|dng))$', string)
    lux = re.search(r'([0-9]+)[lL](\.(jpg|jpeg|brcm|dng)|_.*\.(jpg|jpeg|brcm|dng))$', string)
    try:
        col = col.group(1)
    except AttributeError:
        """
        Catch error if images labelled incorrectly and pass reasonable defaults
        """
        return None, None
    try:
        lux = lux.group(1)
    except AttributeError:
        """
        Catch error if images labelled incorrectly and pass reasonable defaults
        Still returns colour if that has been found.
        """
        return col, None
    return int(col), int(lux)


"""
Camera object that is the backbone of the tuning tool.
Input is the desired path of the output json.
"""
class Camera:
    def __init__(self, jfile):
        self.path = os.path.dirname(os.path.expanduser(__file__)) + '/'
        if self.path == '/':
            self.path = ''
        self.imgs = []
        self.imgs_alsc = []
        self.log = 'Log created : ' + time.asctime(time.localtime(time.time()))
        self.log_separator = '\n'+'-'*70+'\n'
        self.jf = jfile
        """
        initial json dict populated by uncalibrated values
        """
        self.json = {
            "rpi.black_level": {
                "black_level": 4096
            },
            "rpi.dpc": {
            },
            "rpi.lux": {
                "reference_shutter_speed": 10000,
                "reference_gain": 1,
                "reference_aperture": 1.0
            },
            "rpi.noise": {
            },
            "rpi.geq": {
            },
            "rpi.sdn": {
            },
            "rpi.awb": {
                "priors": [
                    {"lux": 0, "prior": [2000, 1.0, 3000, 0.0, 13000, 0.0]},
                    {"lux": 800, "prior": [2000, 0.0, 6000, 2.0, 13000, 2.0]},
                    {"lux": 1500, "prior": [2000, 0.0, 4000, 1.0, 6000, 6.0, 6500, 7.0, 7000, 1.0, 13000, 1.0]}
                ],
                "modes": {
                    "auto": {"lo": 2500, "hi": 8000},
                    "incandescent": {"lo": 2500, "hi": 3000},
                    "tungsten": {"lo": 3000, "hi": 3500},
                    "fluorescent": {"lo": 4000, "hi": 4700},
                    "indoor": {"lo": 3000, "hi": 5000},
                    "daylight": {"lo": 5500, "hi": 6500},
                    "cloudy": {"lo": 7000, "hi": 8600}
                },
                "bayes": 1
            },
            "rpi.agc": {
                "metering_modes": {
                    "centre-weighted": {
                        "weights": [3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0]
                    },
                    "spot": {
                        "weights": [2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
                    },
                    "matrix": {
                        "weights": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
                    }
                },
                "exposure_modes": {
                    "normal": {
                        "shutter": [100, 10000, 30000, 60000, 120000],
                        "gain": [1.0, 2.0, 4.0, 6.0, 6.0]
                    },
                    "short": {
                        "shutter": [100, 5000, 10000, 20000, 120000],
                        "gain": [1.0, 2.0, 4.0, 6.0, 6.0]
                    }
                },
                "constraint_modes": {
                    "normal": [
                        {"bound": "LOWER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.5, 1000, 0.5]}
                    ],
                    "highlight": [
                        {"bound": "LOWER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.5, 1000, 0.5]},
                        {"bound": "UPPER", "q_lo": 0.98, "q_hi": 1.0, "y_target": [0, 0.8, 1000, 0.8]}
                    ]
                },
                "y_target": [0, 0.16, 1000, 0.165, 10000, 0.17]
            },
            "rpi.alsc": {
                'omega': 1.3,
                'n_iter': 100,
                'luminance_strength': 0.7,
            },
            "rpi.contrast": {
                "ce_enable": 1,
                "gamma_curve": [
                    0,     0,
                    1024,  5040,
                    2048,  9338,
                    3072,  12356,
                    4096,  15312,
                    5120,  18051,
                    6144,  20790,
                    7168,  23193,
                    8192,  25744,
                    9216,  27942,
                    10240, 30035,
                    11264, 32005,
                    12288, 33975,
                    13312, 35815,
                    14336, 37600,
                    15360, 39168,
                    16384, 40642,
                    18432, 43379,
                    20480, 45749,
                    22528, 47753,
                    24576, 49621,
                    26624, 51253,
                    28672, 52698,
                    30720, 53796,
                    32768, 54876,
                    36864, 57012,
                    40960, 58656,
                    45056, 59954,
                    49152, 61183,
                    53248, 62355,
                    57344, 63419,
                    61440, 64476,
                    65535, 65535
                ]
            },
            "rpi.ccm": {
            },
            "rpi.sharpen": {
            }
        }

    """
    Perform colour correction calibrations by comparing macbeth patch colours
    to standard macbeth chart colours.
    """
    def ccm_cal(self, do_alsc_colour):
        if 'rpi.ccm' in self.disable:
            return 1
        print('\nStarting CCM calibration')
        self.log_new_sec('CCM')
        """
        if image is greyscale then CCm makes no sense
        """
        if self.grey:
            print('\nERROR: Can\'t do CCM on greyscale image!')
            self.log += '\nERROR: Cannot perform CCM calibration '
            self.log += 'on greyscale image!\nCCM aborted!'
            del self.json['rpi.ccm']
            return 0
        a = time.time()
        """
        Check if alsc tables have been generated, if not then do ccm without
        alsc
        """
        if ("rpi.alsc" not in self.disable) and do_alsc_colour:
            """
            case where ALSC colour has been done, so no errors should be
            expected...
            """
            try:
                cal_cr_list = self.json['rpi.alsc']['calibrations_Cr']
                cal_cb_list = self.json['rpi.alsc']['calibrations_Cb']
                self.log += '\nALSC tables found successfully'
            except KeyError:
                cal_cr_list, cal_cb_list = None, None
                print('WARNING! No ALSC tables found for CCM!')
                print('Performing CCM calibrations without ALSC correction...')
                self.log += '\nWARNING: No ALSC tables found.\nCCM calibration '
                self.log += 'performed without ALSC correction...'
        else:
            """
            case where config options result in CCM done without ALSC colour tables
            """
            cal_cr_list, cal_cb_list = None, None
            self.log += '\nWARNING: No ALSC tables found.\nCCM calibration '
            self.log += 'performed without ALSC correction...'

        """
        Do CCM calibration
        """
        try:
            ccms = ccm(self, cal_cr_list, cal_cb_list)
        except ArithmeticError:
            print('ERROR: Matrix is singular!\nTake new pictures and try again...')
            self.log += '\nERROR: Singular matrix encountered during fit!'
            self.log += '\nCCM aborted!'
            return 1
        """
        Write output to json
        """
        self.json['rpi.ccm']['ccms'] = ccms
        self.log += '\nCCM calibration written to json file'
        print('Finished CCM calibration')

    """
    Auto white balance calibration produces a colour curve for
    various colour temperatures, as well as providing a maximum 'wiggle room'
    distance from this curve (transverse_neg/pos).
    """
    def awb_cal(self, greyworld, do_alsc_colour):
        if 'rpi.awb' in self.disable:
            return 1
        print('\nStarting AWB calibration')
        self.log_new_sec('AWB')
        """
        if image is greyscale then AWB makes no sense
        """
        if self.grey:
            print('\nERROR: Can\'t do AWB on greyscale image!')
            self.log += '\nERROR: Cannot perform AWB calibration '
            self.log += 'on greyscale image!\nAWB aborted!'
            del self.json['rpi.awb']
            return 0
        """
        optional set greyworld (e.g. for noir cameras)
        """
        if greyworld:
            self.json['rpi.awb']['bayes'] = 0
            self.log += '\nGreyworld set'
        """
        Check if alsc tables have been generated, if not then do awb without
        alsc correction
        """
        if ("rpi.alsc" not in self.disable) and do_alsc_colour:
            try:
                cal_cr_list = self.json['rpi.alsc']['calibrations_Cr']
                cal_cb_list = self.json['rpi.alsc']['calibrations_Cb']
                self.log += '\nALSC tables found successfully'
            except KeyError:
                cal_cr_list, cal_cb_list = None, None
                print('ERROR, no ALSC calibrations found for AWB')
                print('Performing AWB without ALSC tables')
                self.log += '\nWARNING: No ALSC tables found.\nAWB calibration '
                self.log += 'performed without ALSC correction...'
        else:
            cal_cr_list, cal_cb_list = None, None
            self.log += '\nWARNING: No ALSC tables found.\nAWB calibration '
            self.log += 'performed without ALSC correction...'
        """
        call calibration function
        """
        plot = "rpi.awb" in self.plot
        awb_out = awb(self, cal_cr_list, cal_cb_list, plot)
        ct_curve, transverse_neg, transverse_pos = awb_out
        """
        write output to json
        """
        self.json['rpi.awb']['ct_curve'] = ct_curve
        self.json['rpi.awb']['sensitivity_r'] = 1.0
        self.json['rpi.awb']['sensitivity_b'] = 1.0
        self.json['rpi.awb']['transverse_pos'] = transverse_pos
        self.json['rpi.awb']['transverse_neg'] = transverse_neg
        self.log += '\nAWB calibration written to json file'
        print('Finished AWB calibration')

    """
    Auto lens shading correction completely mitigates the effects of lens shading for ech
    colour channel seperately, and then partially corrects for vignetting.
    The extent of the correction depends on the 'luminance_strength' parameter.
    """
    def alsc_cal(self, luminance_strength, do_alsc_colour):