[v2,7/9] ipa: libipa: Add lsc polynomial class
diff mbox series

Message ID 20240913075750.35115-8-stefan.klug@ideasonboard.com
State Superseded
Headers show
Series
  • Implement polynomial lsc support
Related show

Commit Message

Stefan Klug Sept. 13, 2024, 7:57 a.m. UTC 
Add a basic class to represent polynomials as specified in the DNG spec
for vignetting correction.

Signed-off-by: Stefan Klug <stefan.klug@ideasonboard.com>
---
 src/ipa/libipa/lsc_polynomial.cpp |  81 +++++++++++++++++++++++
 src/ipa/libipa/lsc_polynomial.h   | 104 ++++++++++++++++++++++++++++++
 src/ipa/libipa/meson.build        |   2 +
 3 files changed, 187 insertions(+)
 create mode 100644 src/ipa/libipa/lsc_polynomial.cpp
 create mode 100644 src/ipa/libipa/lsc_polynomial.h

Comments

Kieran Bingham Sept. 13, 2024, 10:12 a.m. UTC | #1 
Quoting Stefan Klug (2024-09-13 08:57:25)
> Add a basic class to represent polynomials as specified in the DNG spec
> for vignetting correction.
> 
> Signed-off-by: Stefan Klug <stefan.klug@ideasonboard.com>
> ---
>  src/ipa/libipa/lsc_polynomial.cpp |  81 +++++++++++++++++++++++
>  src/ipa/libipa/lsc_polynomial.h   | 104 ++++++++++++++++++++++++++++++
>  src/ipa/libipa/meson.build        |   2 +
>  3 files changed, 187 insertions(+)
>  create mode 100644 src/ipa/libipa/lsc_polynomial.cpp
>  create mode 100644 src/ipa/libipa/lsc_polynomial.h
> 
> diff --git a/src/ipa/libipa/lsc_polynomial.cpp b/src/ipa/libipa/lsc_polynomial.cpp
> new file mode 100644
> index 000000000000..abbbcb6a724c
> --- /dev/null
> +++ b/src/ipa/libipa/lsc_polynomial.cpp
> @@ -0,0 +1,81 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Ideas On Board
> + *
> + * Polynomal class to represent lens shading correction
> + */
> +
> +#include "lsc_polynomial.h"
> +
> +#include <libcamera/base/log.h>
> +
> +/**
> + * \file lsc_polynomial.h
> + * \brief LscPolynomial class
> + */
> +
> +namespace libcamera {
> +
> +LOG_DEFINE_CATEGORY(LscPolynomial)
> +
> +namespace ipa {
> +
> +/**
> + * \class LscPolynomial
> + * \brief Class for handling even polynomial used in lens shading correction

'an even polynomial used in...'

or

'even polynomials used in...'

> + *
> + * Shading artifacts of camera lenses can be modeled using even radial
> + * polynomials. This class implements a polynomial with 5 coefficients which
> + * follows the definition of the FixVignetteRadial opcode in the Adobe DNG
> + * specification.
> + */
> +
> +/**
> + * \fn LscPolynomial::LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> +                     double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> +                     double k4 = 0.0)
> + * \brief Construct a polynomial using the given coefficients
> + * \param cx Center-x relative to the image in normalized coordinates (0..1)
> + * \param cy Center-y relative to the image in normalized coordinates (0..1)
> + * \param k0 Coefficient of the polynomial
> + * \param k1 Coefficient of the polynomial
> + * \param k2 Coefficient of the polynomial
> + * \param k3 Coefficient of the polynomial
> + * \param k4 Coefficient of the polynomial
> + */
> +
> +/**
> + * \fn LscPolynomial::sampleAtNormalizedPixelPos(double x, double y)

Ohh it's Pwl::PointF all over again ;-)



> + * \brief Sample the polynomial at the given normalized pixel position
> + *
> + * This functions samples the polynomial at the given pixel position divided by
> + * the value returned by getM().
> + *
> + * \param x x position in normalized coordinates
> + * \param y y position in normalized coordinates
> + * \return The sampled value
> + */
> +
> +/**
> + * \fn LscPolynomial::getM()
> + * \brief Get the value m as described in the dng specification
> + *
> + * Returns m according to dng spec. m represents the Euclidean distance
> + * (in pixels) from the optical center to the farthest pixel in the
> + * image.
> + *
> + * \return The sampled value
> + */
> +
> +/**
> + * \fn LscPolynomial::setReferenceImageSize(const Size &size)
> + * \brief Set the reference image size
> + *
> + * Set the reference image size that is used for subsequent calls to getM() and
> + * sampleAtNormalizedPixelPos()
> + *
> + * \param size THe size of the reference image

/THe/The/


That's all I've got so :


Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>

> + */
> +
> +} // namespace ipa
> +} // namespace libcamera
> diff --git a/src/ipa/libipa/lsc_polynomial.h b/src/ipa/libipa/lsc_polynomial.h
> new file mode 100644
> index 000000000000..890199017590
> --- /dev/null
> +++ b/src/ipa/libipa/lsc_polynomial.h
> @@ -0,0 +1,104 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Ideas On Board
> + *
> + * Helper for radial polynomial used in lens shading correction.
> + */
> +#pragma once
> +
> +#include <algorithm>
> +#include <array>
> +#include <assert.h>
> +#include <cmath>
> +
> +#include <libcamera/base/log.h>
> +#include <libcamera/base/span.h>
> +
> +#include "libcamera/internal/yaml_parser.h"
> +
> +namespace libcamera {
> +
> +LOG_DECLARE_CATEGORY(LscPolynomial)
> +
> +namespace ipa {
> +
> +class LscPolynomial
> +{
> +public:
> +       LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> +                     double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> +                     double k4 = 0.0)
> +               : cx_(cx), cy_(cy),
> +                 coefficients_({ k0, k1, k2, k3, k4 })
> +       {
> +       }
> +
> +       double sampleAtNormalizedPixelPos(double x, double y) const
> +       {
> +               double dx = x - cnx_;
> +               double dy = y - cny_;
> +               double r = sqrt(dx * dx + dy * dy);
> +               double res = 1.0;
> +               for (unsigned int i = 0; i < coefficients_.size(); i++) {
> +                       res += coefficients_[i] * std::pow(r, (i + 1) * 2);
> +               }
> +               return res;
> +       }
> +
> +       double getM() const
> +       {
> +               double cpx = imageSize_.width * cx_;
> +               double cpy = imageSize_.height * cy_;
> +               double mx = std::max(cpx, std::fabs(imageSize_.width - cpx));
> +               double my = std::max(cpy, std::fabs(imageSize_.height - cpy));
> +
> +               return sqrt(mx * mx + my * my);
> +       }
> +
> +       void setReferenceImageSize(const Size &size)
> +       {
> +               imageSize_ = size;
> +
> +               /* Calculate normalized centers */
> +               double m = getM();
> +               cnx_ = (size.width * cx_) / m;
> +               cny_ = (size.height * cy_) / m;
> +       }
> +
> +private:
> +       double cx_;
> +       double cy_;
> +       double cnx_;
> +       double cny_;
> +       std::array<double, 5> coefficients_;
> +
> +       Size imageSize_;
> +};
> +
> +} /* namespace ipa */
> +
> +#ifndef __DOXYGEN__
> +
> +template<>
> +struct YamlObject::Getter<ipa::LscPolynomial> {
> +       std::optional<ipa::LscPolynomial> get(const YamlObject &obj) const
> +       {
> +               std::optional<double> cx = obj["cx"].get<double>();
> +               std::optional<double> cy = obj["cy"].get<double>();
> +               std::optional<double> k0 = obj["k0"].get<double>();
> +               std::optional<double> k1 = obj["k1"].get<double>();
> +               std::optional<double> k2 = obj["k2"].get<double>();
> +               std::optional<double> k3 = obj["k3"].get<double>();
> +               std::optional<double> k4 = obj["k4"].get<double>();
> +
> +               if (!(cx && cy && k0 && k1 && k2 && k3 && k4))
> +                       LOG(LscPolynomial, Error)
> +                               << "Polynomial is missing a parameter";
> +
> +               return ipa::LscPolynomial(*cx, *cy, *k0, *k1, *k2, *k3, *k4);
> +       }
> +};
> +
> +#endif
> +
> +} /* namespace libcamera */
> diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
> index 3740178b2909..e78cbcd63633 100644
> --- a/src/ipa/libipa/meson.build
> +++ b/src/ipa/libipa/meson.build
> @@ -8,6 +8,7 @@ libipa_headers = files([
>      'fc_queue.h',
>      'histogram.h',
>      'interpolator.h',
> +    'lsc_polynomial.h',
>      'matrix.h',
>      'module.h',
>      'pwl.h',
> @@ -22,6 +23,7 @@ libipa_sources = files([
>      'fc_queue.cpp',
>      'histogram.cpp',
>      'interpolator.cpp',
> +    'lsc_polynomial.cpp',
>      'matrix.cpp',
>      'module.cpp',
>      'pwl.cpp',
> -- 
> 2.43.0
>
Paul Elder Sept. 13, 2024, 11:07 a.m. UTC | #2 
On Fri, Sep 13, 2024 at 09:57:25AM +0200, Stefan Klug wrote:
> Add a basic class to represent polynomials as specified in the DNG spec
> for vignetting correction.
> 
> Signed-off-by: Stefan Klug <stefan.klug@ideasonboard.com>
> ---
>  src/ipa/libipa/lsc_polynomial.cpp |  81 +++++++++++++++++++++++
>  src/ipa/libipa/lsc_polynomial.h   | 104 ++++++++++++++++++++++++++++++
>  src/ipa/libipa/meson.build        |   2 +
>  3 files changed, 187 insertions(+)
>  create mode 100644 src/ipa/libipa/lsc_polynomial.cpp
>  create mode 100644 src/ipa/libipa/lsc_polynomial.h
> 
> diff --git a/src/ipa/libipa/lsc_polynomial.cpp b/src/ipa/libipa/lsc_polynomial.cpp
> new file mode 100644
> index 000000000000..abbbcb6a724c
> --- /dev/null
> +++ b/src/ipa/libipa/lsc_polynomial.cpp
> @@ -0,0 +1,81 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Ideas On Board
> + *
> + * Polynomal class to represent lens shading correction

s/Polynomal/Polynomial/

> + */
> +
> +#include "lsc_polynomial.h"
> +
> +#include <libcamera/base/log.h>
> +
> +/**
> + * \file lsc_polynomial.h
> + * \brief LscPolynomial class
> + */
> +
> +namespace libcamera {
> +
> +LOG_DEFINE_CATEGORY(LscPolynomial)
> +
> +namespace ipa {
> +
> +/**
> + * \class LscPolynomial
> + * \brief Class for handling even polynomial used in lens shading correction
> + *
> + * Shading artifacts of camera lenses can be modeled using even radial
> + * polynomials. This class implements a polynomial with 5 coefficients which
> + * follows the definition of the FixVignetteRadial opcode in the Adobe DNG
> + * specification.
> + */
> +
> +/**
> + * \fn LscPolynomial::LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> +		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> +		      double k4 = 0.0)
> + * \brief Construct a polynomial using the given coefficients
> + * \param cx Center-x relative to the image in normalized coordinates (0..1)
> + * \param cy Center-y relative to the image in normalized coordinates (0..1)
> + * \param k0 Coefficient of the polynomial
> + * \param k1 Coefficient of the polynomial
> + * \param k2 Coefficient of the polynomial
> + * \param k3 Coefficient of the polynomial
> + * \param k4 Coefficient of the polynomial
> + */
> +
> +/**
> + * \fn LscPolynomial::sampleAtNormalizedPixelPos(double x, double y)
> + * \brief Sample the polynomial at the given normalized pixel position
> + *
> + * This functions samples the polynomial at the given pixel position divided by
> + * the value returned by getM().
> + *
> + * \param x x position in normalized coordinates
> + * \param y y position in normalized coordinates
> + * \return The sampled value
> + */
> +
> +/**
> + * \fn LscPolynomial::getM()
> + * \brief Get the value m as described in the dng specification
> + *
> + * Returns m according to dng spec. m represents the Euclidean distance
> + * (in pixels) from the optical center to the farthest pixel in the
> + * image.
> + *
> + * \return The sampled value
> + */
> +
> +/**
> + * \fn LscPolynomial::setReferenceImageSize(const Size &size)
> + * \brief Set the reference image size
> + *
> + * Set the reference image size that is used for subsequent calls to getM() and
> + * sampleAtNormalizedPixelPos()
> + *
> + * \param size THe size of the reference image
> + */
> +
> +} // namespace ipa
> +} // namespace libcamera
> diff --git a/src/ipa/libipa/lsc_polynomial.h b/src/ipa/libipa/lsc_polynomial.h
> new file mode 100644
> index 000000000000..890199017590
> --- /dev/null
> +++ b/src/ipa/libipa/lsc_polynomial.h
> @@ -0,0 +1,104 @@
> +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> +/*
> + * Copyright (C) 2024, Ideas On Board
> + *
> + * Helper for radial polynomial used in lens shading correction.
> + */
> +#pragma once
> +
> +#include <algorithm>
> +#include <array>
> +#include <assert.h>
> +#include <cmath>
> +
> +#include <libcamera/base/log.h>
> +#include <libcamera/base/span.h>
> +
> +#include "libcamera/internal/yaml_parser.h"
> +
> +namespace libcamera {
> +
> +LOG_DECLARE_CATEGORY(LscPolynomial)
> +
> +namespace ipa {
> +
> +class LscPolynomial
> +{
> +public:
> +	LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> +		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> +		      double k4 = 0.0)
> +		: cx_(cx), cy_(cy),
> +		  coefficients_({ k0, k1, k2, k3, k4 })
> +	{
> +	}
> +
> +	double sampleAtNormalizedPixelPos(double x, double y) const
> +	{
> +		double dx = x - cnx_;
> +		double dy = y - cny_;

Should cn{x,y}_ be initialized above?


Otherwise it looks fine.

Paul

> +		double r = sqrt(dx * dx + dy * dy);
> +		double res = 1.0;
> +		for (unsigned int i = 0; i < coefficients_.size(); i++) {
> +			res += coefficients_[i] * std::pow(r, (i + 1) * 2);
> +		}
> +		return res;
> +	}
> +
> +	double getM() const
> +	{
> +		double cpx = imageSize_.width * cx_;
> +		double cpy = imageSize_.height * cy_;
> +		double mx = std::max(cpx, std::fabs(imageSize_.width - cpx));
> +		double my = std::max(cpy, std::fabs(imageSize_.height - cpy));
> +
> +		return sqrt(mx * mx + my * my);
> +	}
> +
> +	void setReferenceImageSize(const Size &size)
> +	{
> +		imageSize_ = size;
> +
> +		/* Calculate normalized centers */
> +		double m = getM();
> +		cnx_ = (size.width * cx_) / m;
> +		cny_ = (size.height * cy_) / m;
> +	}
> +
> +private:
> +	double cx_;
> +	double cy_;
> +	double cnx_;
> +	double cny_;
> +	std::array<double, 5> coefficients_;
> +
> +	Size imageSize_;
> +};
> +
> +} /* namespace ipa */
> +
> +#ifndef __DOXYGEN__
> +
> +template<>
> +struct YamlObject::Getter<ipa::LscPolynomial> {
> +	std::optional<ipa::LscPolynomial> get(const YamlObject &obj) const
> +	{
> +		std::optional<double> cx = obj["cx"].get<double>();
> +		std::optional<double> cy = obj["cy"].get<double>();
> +		std::optional<double> k0 = obj["k0"].get<double>();
> +		std::optional<double> k1 = obj["k1"].get<double>();
> +		std::optional<double> k2 = obj["k2"].get<double>();
> +		std::optional<double> k3 = obj["k3"].get<double>();
> +		std::optional<double> k4 = obj["k4"].get<double>();
> +
> +		if (!(cx && cy && k0 && k1 && k2 && k3 && k4))
> +			LOG(LscPolynomial, Error)
> +				<< "Polynomial is missing a parameter";
> +
> +		return ipa::LscPolynomial(*cx, *cy, *k0, *k1, *k2, *k3, *k4);
> +	}
> +};
> +
> +#endif
> +
> +} /* namespace libcamera */
> diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
> index 3740178b2909..e78cbcd63633 100644
> --- a/src/ipa/libipa/meson.build
> +++ b/src/ipa/libipa/meson.build
> @@ -8,6 +8,7 @@ libipa_headers = files([
>      'fc_queue.h',
>      'histogram.h',
>      'interpolator.h',
> +    'lsc_polynomial.h',
>      'matrix.h',
>      'module.h',
>      'pwl.h',
> @@ -22,6 +23,7 @@ libipa_sources = files([
>      'fc_queue.cpp',
>      'histogram.cpp',
>      'interpolator.cpp',
> +    'lsc_polynomial.cpp',
>      'matrix.cpp',
>      'module.cpp',
>      'pwl.cpp',
> -- 
> 2.43.0
>
Stefan Klug Sept. 16, 2024, 3:38 p.m. UTC | #3 
Hi Paul,

Thank you for the review. 

On Fri, Sep 13, 2024 at 01:07:04PM +0200, Paul Elder wrote:
> On Fri, Sep 13, 2024 at 09:57:25AM +0200, Stefan Klug wrote:
> > Add a basic class to represent polynomials as specified in the DNG spec
> > for vignetting correction.
> > 
> > Signed-off-by: Stefan Klug <stefan.klug@ideasonboard.com>
> > ---
> >  src/ipa/libipa/lsc_polynomial.cpp |  81 +++++++++++++++++++++++
> >  src/ipa/libipa/lsc_polynomial.h   | 104 ++++++++++++++++++++++++++++++
> >  src/ipa/libipa/meson.build        |   2 +
> >  3 files changed, 187 insertions(+)
> >  create mode 100644 src/ipa/libipa/lsc_polynomial.cpp
> >  create mode 100644 src/ipa/libipa/lsc_polynomial.h
> > 
> > diff --git a/src/ipa/libipa/lsc_polynomial.cpp b/src/ipa/libipa/lsc_polynomial.cpp
> > new file mode 100644
> > index 000000000000..abbbcb6a724c
> > --- /dev/null
> > +++ b/src/ipa/libipa/lsc_polynomial.cpp
> > @@ -0,0 +1,81 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2024, Ideas On Board
> > + *
> > + * Polynomal class to represent lens shading correction
> 
> s/Polynomal/Polynomial/
> 
> > + */
> > +
> > +#include "lsc_polynomial.h"
> > +
> > +#include <libcamera/base/log.h>
> > +
> > +/**
> > + * \file lsc_polynomial.h
> > + * \brief LscPolynomial class
> > + */
> > +
> > +namespace libcamera {
> > +
> > +LOG_DEFINE_CATEGORY(LscPolynomial)
> > +
> > +namespace ipa {
> > +
> > +/**
> > + * \class LscPolynomial
> > + * \brief Class for handling even polynomial used in lens shading correction
> > + *
> > + * Shading artifacts of camera lenses can be modeled using even radial
> > + * polynomials. This class implements a polynomial with 5 coefficients which
> > + * follows the definition of the FixVignetteRadial opcode in the Adobe DNG
> > + * specification.
> > + */
> > +
> > +/**
> > + * \fn LscPolynomial::LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> > +		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> > +		      double k4 = 0.0)
> > + * \brief Construct a polynomial using the given coefficients
> > + * \param cx Center-x relative to the image in normalized coordinates (0..1)
> > + * \param cy Center-y relative to the image in normalized coordinates (0..1)
> > + * \param k0 Coefficient of the polynomial
> > + * \param k1 Coefficient of the polynomial
> > + * \param k2 Coefficient of the polynomial
> > + * \param k3 Coefficient of the polynomial
> > + * \param k4 Coefficient of the polynomial
> > + */
> > +
> > +/**
> > + * \fn LscPolynomial::sampleAtNormalizedPixelPos(double x, double y)
> > + * \brief Sample the polynomial at the given normalized pixel position
> > + *
> > + * This functions samples the polynomial at the given pixel position divided by
> > + * the value returned by getM().
> > + *
> > + * \param x x position in normalized coordinates
> > + * \param y y position in normalized coordinates
> > + * \return The sampled value
> > + */
> > +
> > +/**
> > + * \fn LscPolynomial::getM()
> > + * \brief Get the value m as described in the dng specification
> > + *
> > + * Returns m according to dng spec. m represents the Euclidean distance
> > + * (in pixels) from the optical center to the farthest pixel in the
> > + * image.
> > + *
> > + * \return The sampled value
> > + */
> > +
> > +/**
> > + * \fn LscPolynomial::setReferenceImageSize(const Size &size)
> > + * \brief Set the reference image size
> > + *
> > + * Set the reference image size that is used for subsequent calls to getM() and
> > + * sampleAtNormalizedPixelPos()
> > + *
> > + * \param size THe size of the reference image
> > + */
> > +
> > +} // namespace ipa
> > +} // namespace libcamera
> > diff --git a/src/ipa/libipa/lsc_polynomial.h b/src/ipa/libipa/lsc_polynomial.h
> > new file mode 100644
> > index 000000000000..890199017590
> > --- /dev/null
> > +++ b/src/ipa/libipa/lsc_polynomial.h
> > @@ -0,0 +1,104 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2024, Ideas On Board
> > + *
> > + * Helper for radial polynomial used in lens shading correction.
> > + */
> > +#pragma once
> > +
> > +#include <algorithm>
> > +#include <array>
> > +#include <assert.h>
> > +#include <cmath>
> > +
> > +#include <libcamera/base/log.h>
> > +#include <libcamera/base/span.h>
> > +
> > +#include "libcamera/internal/yaml_parser.h"
> > +
> > +namespace libcamera {
> > +
> > +LOG_DECLARE_CATEGORY(LscPolynomial)
> > +
> > +namespace ipa {
> > +
> > +class LscPolynomial
> > +{
> > +public:
> > +	LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
> > +		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
> > +		      double k4 = 0.0)
> > +		: cx_(cx), cy_(cy),
> > +		  coefficients_({ k0, k1, k2, k3, k4 })
> > +	{
> > +	}
> > +
> > +	double sampleAtNormalizedPixelPos(double x, double y) const
> > +	{
> > +		double dx = x - cnx_;
> > +		double dy = y - cny_;
> 
> Should cn{x,y}_ be initialized above?

Yes, you're right. I'll initialize them in the constructor.

Cheers,
Stefan

> 
> 
> Otherwise it looks fine.
> 
> Paul
> 
> > +		double r = sqrt(dx * dx + dy * dy);
> > +		double res = 1.0;
> > +		for (unsigned int i = 0; i < coefficients_.size(); i++) {
> > +			res += coefficients_[i] * std::pow(r, (i + 1) * 2);
> > +		}
> > +		return res;
> > +	}
> > +
> > +	double getM() const
> > +	{
> > +		double cpx = imageSize_.width * cx_;
> > +		double cpy = imageSize_.height * cy_;
> > +		double mx = std::max(cpx, std::fabs(imageSize_.width - cpx));
> > +		double my = std::max(cpy, std::fabs(imageSize_.height - cpy));
> > +
> > +		return sqrt(mx * mx + my * my);
> > +	}
> > +
> > +	void setReferenceImageSize(const Size &size)
> > +	{
> > +		imageSize_ = size;
> > +
> > +		/* Calculate normalized centers */
> > +		double m = getM();
> > +		cnx_ = (size.width * cx_) / m;
> > +		cny_ = (size.height * cy_) / m;
> > +	}
> > +
> > +private:
> > +	double cx_;
> > +	double cy_;
> > +	double cnx_;
> > +	double cny_;
> > +	std::array<double, 5> coefficients_;
> > +
> > +	Size imageSize_;
> > +};
> > +
> > +} /* namespace ipa */
> > +
> > +#ifndef __DOXYGEN__
> > +
> > +template<>
> > +struct YamlObject::Getter<ipa::LscPolynomial> {
> > +	std::optional<ipa::LscPolynomial> get(const YamlObject &obj) const
> > +	{
> > +		std::optional<double> cx = obj["cx"].get<double>();
> > +		std::optional<double> cy = obj["cy"].get<double>();
> > +		std::optional<double> k0 = obj["k0"].get<double>();
> > +		std::optional<double> k1 = obj["k1"].get<double>();
> > +		std::optional<double> k2 = obj["k2"].get<double>();
> > +		std::optional<double> k3 = obj["k3"].get<double>();
> > +		std::optional<double> k4 = obj["k4"].get<double>();
> > +
> > +		if (!(cx && cy && k0 && k1 && k2 && k3 && k4))
> > +			LOG(LscPolynomial, Error)
> > +				<< "Polynomial is missing a parameter";
> > +
> > +		return ipa::LscPolynomial(*cx, *cy, *k0, *k1, *k2, *k3, *k4);
> > +	}
> > +};
> > +
> > +#endif
> > +
> > +} /* namespace libcamera */
> > diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
> > index 3740178b2909..e78cbcd63633 100644
> > --- a/src/ipa/libipa/meson.build
> > +++ b/src/ipa/libipa/meson.build
> > @@ -8,6 +8,7 @@ libipa_headers = files([
> >      'fc_queue.h',
> >      'histogram.h',
> >      'interpolator.h',
> > +    'lsc_polynomial.h',
> >      'matrix.h',
> >      'module.h',
> >      'pwl.h',
> > @@ -22,6 +23,7 @@ libipa_sources = files([
> >      'fc_queue.cpp',
> >      'histogram.cpp',
> >      'interpolator.cpp',
> > +    'lsc_polynomial.cpp',
> >      'matrix.cpp',
> >      'module.cpp',
> >      'pwl.cpp',
> > -- 
> > 2.43.0
> >

Patch
diff mbox series 

diff --git a/src/ipa/libipa/lsc_polynomial.cpp b/src/ipa/libipa/lsc_polynomial.cpp
new file mode 100644
index 000000000000..abbbcb6a724c
--- /dev/null
+++ b/src/ipa/libipa/lsc_polynomial.cpp
@@ -0,0 +1,81 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2024, Ideas On Board
+ *
+ * Polynomal class to represent lens shading correction
+ */
+
+#include "lsc_polynomial.h"
+
+#include <libcamera/base/log.h>
+
+/**
+ * \file lsc_polynomial.h
+ * \brief LscPolynomial class
+ */
+
+namespace libcamera {
+
+LOG_DEFINE_CATEGORY(LscPolynomial)
+
+namespace ipa {
+
+/**
+ * \class LscPolynomial
+ * \brief Class for handling even polynomial used in lens shading correction
+ *
+ * Shading artifacts of camera lenses can be modeled using even radial
+ * polynomials. This class implements a polynomial with 5 coefficients which
+ * follows the definition of the FixVignetteRadial opcode in the Adobe DNG
+ * specification.
+ */
+
+/**
+ * \fn LscPolynomial::LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
+		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
+		      double k4 = 0.0)
+ * \brief Construct a polynomial using the given coefficients
+ * \param cx Center-x relative to the image in normalized coordinates (0..1)
+ * \param cy Center-y relative to the image in normalized coordinates (0..1)
+ * \param k0 Coefficient of the polynomial
+ * \param k1 Coefficient of the polynomial
+ * \param k2 Coefficient of the polynomial
+ * \param k3 Coefficient of the polynomial
+ * \param k4 Coefficient of the polynomial
+ */
+
+/**
+ * \fn LscPolynomial::sampleAtNormalizedPixelPos(double x, double y)
+ * \brief Sample the polynomial at the given normalized pixel position
+ *
+ * This functions samples the polynomial at the given pixel position divided by
+ * the value returned by getM().
+ *
+ * \param x x position in normalized coordinates
+ * \param y y position in normalized coordinates
+ * \return The sampled value
+ */
+
+/**
+ * \fn LscPolynomial::getM()
+ * \brief Get the value m as described in the dng specification
+ *
+ * Returns m according to dng spec. m represents the Euclidean distance
+ * (in pixels) from the optical center to the farthest pixel in the
+ * image.
+ *
+ * \return The sampled value
+ */
+
+/**
+ * \fn LscPolynomial::setReferenceImageSize(const Size &size)
+ * \brief Set the reference image size
+ *
+ * Set the reference image size that is used for subsequent calls to getM() and
+ * sampleAtNormalizedPixelPos()
+ *
+ * \param size THe size of the reference image
+ */
+
+} // namespace ipa
+} // namespace libcamera
diff --git a/src/ipa/libipa/lsc_polynomial.h b/src/ipa/libipa/lsc_polynomial.h
new file mode 100644
index 000000000000..890199017590
--- /dev/null
+++ b/src/ipa/libipa/lsc_polynomial.h
@@ -0,0 +1,104 @@ 
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2024, Ideas On Board
+ *
+ * Helper for radial polynomial used in lens shading correction.
+ */
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <assert.h>
+#include <cmath>
+
+#include <libcamera/base/log.h>
+#include <libcamera/base/span.h>
+
+#include "libcamera/internal/yaml_parser.h"
+
+namespace libcamera {
+
+LOG_DECLARE_CATEGORY(LscPolynomial)
+
+namespace ipa {
+
+class LscPolynomial
+{
+public:
+	LscPolynomial(double cx = 0.0, double cy = 0.0, double k0 = 0.0,
+		      double k1 = 0.0, double k2 = 0.0, double k3 = 0.0,
+		      double k4 = 0.0)
+		: cx_(cx), cy_(cy),
+		  coefficients_({ k0, k1, k2, k3, k4 })
+	{
+	}
+
+	double sampleAtNormalizedPixelPos(double x, double y) const
+	{
+		double dx = x - cnx_;
+		double dy = y - cny_;
+		double r = sqrt(dx * dx + dy * dy);
+		double res = 1.0;
+		for (unsigned int i = 0; i < coefficients_.size(); i++) {
+			res += coefficients_[i] * std::pow(r, (i + 1) * 2);
+		}
+		return res;
+	}
+
+	double getM() const
+	{
+		double cpx = imageSize_.width * cx_;
+		double cpy = imageSize_.height * cy_;
+		double mx = std::max(cpx, std::fabs(imageSize_.width - cpx));
+		double my = std::max(cpy, std::fabs(imageSize_.height - cpy));
+
+		return sqrt(mx * mx + my * my);
+	}
+
+	void setReferenceImageSize(const Size &size)
+	{
+		imageSize_ = size;
+
+		/* Calculate normalized centers */
+		double m = getM();
+		cnx_ = (size.width * cx_) / m;
+		cny_ = (size.height * cy_) / m;
+	}
+
+private:
+	double cx_;
+	double cy_;
+	double cnx_;
+	double cny_;
+	std::array<double, 5> coefficients_;
+
+	Size imageSize_;
+};
+
+} /* namespace ipa */
+
+#ifndef __DOXYGEN__
+
+template<>
+struct YamlObject::Getter<ipa::LscPolynomial> {
+	std::optional<ipa::LscPolynomial> get(const YamlObject &obj) const
+	{
+		std::optional<double> cx = obj["cx"].get<double>();
+		std::optional<double> cy = obj["cy"].get<double>();
+		std::optional<double> k0 = obj["k0"].get<double>();
+		std::optional<double> k1 = obj["k1"].get<double>();
+		std::optional<double> k2 = obj["k2"].get<double>();
+		std::optional<double> k3 = obj["k3"].get<double>();
+		std::optional<double> k4 = obj["k4"].get<double>();
+
+		if (!(cx && cy && k0 && k1 && k2 && k3 && k4))
+			LOG(LscPolynomial, Error)
+				<< "Polynomial is missing a parameter";
+
+		return ipa::LscPolynomial(*cx, *cy, *k0, *k1, *k2, *k3, *k4);
+	}
+};
+
+#endif
+
+} /* namespace libcamera */
diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
index 3740178b2909..e78cbcd63633 100644
--- a/src/ipa/libipa/meson.build
+++ b/src/ipa/libipa/meson.build
@@ -8,6 +8,7 @@  libipa_headers = files([
     'fc_queue.h',
     'histogram.h',
     'interpolator.h',
+    'lsc_polynomial.h',
     'matrix.h',
     'module.h',
     'pwl.h',
@@ -22,6 +23,7 @@  libipa_sources = files([
     'fc_queue.cpp',
     'histogram.cpp',
     'interpolator.cpp',
+    'lsc_polynomial.cpp',
     'matrix.cpp',
     'module.cpp',
     'pwl.cpp',