From patchwork Tue Jun 11 14:02:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paul Elder X-Patchwork-Id: 20261 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 34B54C31E9 for ; Tue, 11 Jun 2024 14:02:34 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id DA6AB6546C; Tue, 11 Jun 2024 16:02:33 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (1024-bit key; unprotected) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="SVRF4ACs"; dkim-atps=neutral Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 4261261A26 for ; Tue, 11 Jun 2024 16:02:24 +0200 (CEST) Received: from neptunite.hamster-moth.ts.net (h175-177-049-156.catv02.itscom.jp [175.177.49.156]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 39888E0C; Tue, 11 Jun 2024 16:02:07 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1718114531; bh=6SkWhaVo8yh2kxVL49xg198Jfjk9xEEAb6+rbG6pks8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SVRF4ACsbbH4JyOv3uqn4iG8P6Q3qwGCd9u+uE+xOMGp+bWtqjNwQFej3Z9f0pd2G rv972JsFbOFj0NKy9ST388vEA8gD3hac695P+ydpRh+6+g8FOB8A86BEkXnFz3xehe ySTJKjOAMB/+vjBL9BGsX/NWcK4M4KO+gfjAeHwA= From: Paul Elder To: libcamera-devel@lists.libcamera.org Cc: Paul Elder , Stefan Klug , Kieran Bingham Subject: [PATCH v7 1/3] ipa: libipa: Add Matrix class Date: Tue, 11 Jun 2024 23:02:05 +0900 Message-Id: <20240611140207.520083-2-paul.elder@ideasonboard.com> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240611140207.520083-1-paul.elder@ideasonboard.com> References: <20240611140207.520083-1-paul.elder@ideasonboard.com> MIME-Version: 1.0 X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a class to represent a Matrix object and operations for adding matrices, multipling a matrix by a scalar, and multiplying two matrices. Signed-off-by: Paul Elder Reviewed-by: Stefan Klug Reviewed-by: Kieran Bingham --- Changes in v7: - fix copyright and license Changes in v6: - fix doxygen Changes in v5: - add documentation Changes in v4: - remove stray semicolons - add operator<< - clean up/optimize constructor - replace get() and set() with operator[] (and a second [] can be used as operator[] returns a Span) Changes in v3: - fix template parameters of operator* to allow different types for the scalar multiplier and the matrix's number type - clear data in constructors - fix assert in constructor Changes v2: - make rows and columns into template arguments - initialize to identity matrix on construction - add getter and setter - change from struct to class - fix matrix multiplication - clean up unused includes - avoid dereferencing an absent std::optional --- src/ipa/libipa/matrix.cpp | 123 ++++++++++++++++++++++++++ src/ipa/libipa/matrix.h | 172 +++++++++++++++++++++++++++++++++++++ src/ipa/libipa/meson.build | 2 + 3 files changed, 297 insertions(+) create mode 100644 src/ipa/libipa/matrix.cpp create mode 100644 src/ipa/libipa/matrix.h diff --git a/src/ipa/libipa/matrix.cpp b/src/ipa/libipa/matrix.cpp new file mode 100644 index 000000000000..02091a0b4ce1 --- /dev/null +++ b/src/ipa/libipa/matrix.cpp @@ -0,0 +1,123 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Matrix and related operations + */ + +#include "matrix.h" + +#include + +/** + * \file matrix.h + * \brief Matrix class + */ + +namespace libcamera { + +LOG_DEFINE_CATEGORY(Matrix) + +namespace ipa { + +/** + * \class Matrix + * \brief Matrix class + * \tparam T Type of numerical values to be stored in the matrix + * \tparam R Number of rows in the matrix + * \tparam C Number of columns in the matrix + */ + +/** + * \fn Matrix::Matrix() + * \brief Construct an identity matrix + */ + +/** + * \fn Matrix::Matrix(const std::vector &data) + * \brief Construct matrix from supplied data + * \param data Data from which to construct a matrix + * + * \a data is a one-dimensional vector and will be turned into a matrix in + * row-major order. The size of \a data must be equal to the product of the + * number of rows and columns of the matrix (RxC). + */ + +/** + * \fn Matrix::readYaml + * \brief Populate the matrix with yaml data + * \param yaml Yaml data to populate the matrix with + * + * Any existing data in the matrix will be overwritten. The size of the data + * read from \a yaml must be equal to the product of the number of rows and + * columns of the matrix (RxC). + * + * The yaml data is expected to be a list with elements of type T. + * + * \return 0 on success, negative error code otherwise + */ + +/** + * \fn Matrix::toString + * \brief Assemble and return a string describing the matrix + * \return A string describing the matrix + */ + +/** + * \fn Span Matrix::operator[](size_t i) const + * \brief Index to a row in the matrix + * \param i Index of row to retrieve + * + * This operator[] returns a Span, which can then be indexed into again with + * another operator[], allowing a convenient m[i][j] to access elements of the + * matrix. Note that the lifetime of the Span returned by this first-level + * operator[] is bound to that of the Matrix itself, so it is not recommended + * to save the Span that is the result of this operator[]. + * + * \return Row \a i from the matrix, as a Span + */ + +/** + * \fn Matrix::operator[](size_t i) + * \copydoc Matrix::operator[](size_t i) const + */ + +/** + * \fn Matrix::Matrix operator*(T d, const Matrix &m) + * \brief Scalar product + * \tparam T Type of the numerical scalar value + * \tparam U Type of numerical values in the matrix + * \tparam R Number of rows in the matrix + * \tparam C Number of columns in the matrix + * \param d Scalar + * \param m Matrix + * \return Product of scalar \a d and matrix \a m + */ + +/** + * \fn Matrix operator*(const Matrix &m1, const Matrix &m2) + * \brief Matrix multiplication + * \tparam T Type of numerical values in the matrices + * \tparam R1 Number of rows in the first matrix + * \tparam C1 Number of columns in the first matrix + * \tparam R2 Number of rows in the second matrix + * \tparam C2 Number of columns in the second matrix + * \param m1 Multiplicand matrix + * \param m2 Multiplier matrix + * \return Matrix product of matrices \a m1 and \a m2 + */ + +/** + * \fn Matrix operator+(const Matrix &m1, const Matrix &m2) + * \brief Matrix addition + * \tparam T Type of numerical values in the matrices + * \tparam R Number of rows in the matrices + * \tparam C Number of columns in the matrices + * \param m1 Summand matrix + * \param m2 Summand matrix + * \return Matrix sum of matrices \a m1 and \a m2 + */ + +} /* namespace ipa */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/matrix.h b/src/ipa/libipa/matrix.h new file mode 100644 index 000000000000..90eaea03bd14 --- /dev/null +++ b/src/ipa/libipa/matrix.h @@ -0,0 +1,172 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 2024, Paul Elder + * + * Matrix and related operations + */ +#pragma once + +#include +#include +#include +#include + +#include +#include + +#include "libcamera/internal/yaml_parser.h" + +namespace libcamera { + +LOG_DECLARE_CATEGORY(Matrix) + +namespace ipa { + +#ifndef __DOXYGEN__ +template> * = nullptr> +#else +template +#endif /* __DOXYGEN__ */ +class Matrix +{ +public: + Matrix() + : data_(R * C, static_cast(false)) + { + for (size_t i = 0; i < std::min(R, C); i++) + (*this)[i][i] = static_cast(true); + } + + Matrix(const std::vector &data) + { + ASSERT(data.size() == R * C); + + data_.clear(); + for (const T &x : data) + data_.push_back(x); + } + + ~Matrix() = default; + + int readYaml(const libcamera::YamlObject &yaml) + { + if (yaml.size() != R * C) { + LOG(Matrix, Error) + << "Wrong number of values in matrix: expected " + << R * C << ", got " << yaml.size(); + return -EINVAL; + } + + unsigned int i = 0; + for (const auto &x : yaml.asList()) { + auto value = x.get(); + if (!value) { + LOG(Matrix, Error) << "Failed to read matrix value"; + return -EINVAL; + } + + data_[i++] = *value; + } + + return 0; + } + + const std::string toString() const + { + std::stringstream out; + + out << "Matrix { "; + for (unsigned int i = 0; i < R; i++) { + out << "[ "; + for (unsigned int j = 0; j < C; j++) { + out << (*this)[i][j]; + out << ((j + 1 < C) ? ", " : " "); + } + out << ((i + 1 < R) ? "], " : "]"); + } + out << " }"; + + return out.str(); + } + + Span operator[](size_t i) const + { + return Span{ &data_.data()[i * C], C }; + } + + Span operator[](size_t i) + { + return Span{ &data_.data()[i * C], C }; + } + +private: + std::vector data_; +}; + +#ifndef __DOXYGEN__ +template && std::is_arithmetic_v> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator*(T d, const Matrix &m) +{ + Matrix result; + + for (unsigned int i = 0; i < R; i++) + for (unsigned int j = 0; j < C; j++) + result[i][j] = d * m[i][j]; + + return result; +} + +#ifndef __DOXYGEN__ +template && C1 == R2> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator*(const Matrix &m1, const Matrix &m2) +{ + Matrix result; + + for (unsigned int i = 0; i < R1; i++) { + for (unsigned int j = 0; j < C2; j++) { + T sum = 0; + + for (unsigned int k = 0; k < C1; k++) + sum += m1[i][k] * m2[k][j]; + + result[i][j] = sum; + } + } + + return result; +} + +#ifndef __DOXYGEN__ +template> * = nullptr> +#endif /* __DOXYGEN__ */ +Matrix operator+(const Matrix &m1, const Matrix &m2) +{ + Matrix result; + + for (unsigned int i = 0; i < R; i++) + for (unsigned int j = 0; j < C; j++) + result[i][j] = m1[i][j] + m2[i][j]; + + return result; +} + +} /* namespace ipa */ + +#ifndef __DOXYGEN__ +template +std::ostream &operator<<(std::ostream &out, const ipa::Matrix &m) +{ + out << m.toString(); + return out; +} +#endif /* __DOXYGEN__ */ + +} /* namespace libcamera */ diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build index b663afc7d9fe..067d0d273e0a 100644 --- a/src/ipa/libipa/meson.build +++ b/src/ipa/libipa/meson.build @@ -7,6 +7,7 @@ libipa_headers = files([ 'exposure_mode_helper.h', 'fc_queue.h', 'histogram.h', + 'matrix.h', 'module.h', ]) @@ -17,6 +18,7 @@ libipa_sources = files([ 'exposure_mode_helper.cpp', 'fc_queue.cpp', 'histogram.cpp', + 'matrix.cpp', 'module.cpp', ])