converter_dw100_vertexmap.h

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2025, Ideas on Board Oy
 *
 * DW100 vertex map interface
 */
 
#pragma once
 
#include <assert.h>
#include <cmath>
#include <stdint.h>
#include <vector>
 
#include <libcamera/base/span.h>
 
#include <libcamera/geometry.h>
#include <libcamera/transform.h>
 
#include "libcamera/internal/matrix.h"
#include "libcamera/internal/vector.h"
 
namespace libcamera {
 
class Dw100VertexMap
{
public:
    enum ScaleMode {
        Fill = 0,
        Crop = 1,
    };
 
    void applyLimits();
    void setInputSize(const Size &size)
    {
        inputSize_ = size;
        scalerCrop_ = Rectangle(size);
    }
 
    void setSensorCrop(const Rectangle &rect) { sensorCrop_ = rect; }
 
    void setScalerCrop(const Rectangle &rect) { scalerCrop_ = rect; }
    const Rectangle &effectiveScalerCrop() const { return effectiveScalerCrop_; }
 
    void setOutputSize(const Size &size) { outputSize_ = size; }
    const Size &outputSize() const { return outputSize_; }
 
    void setTransform(const Transform &transform) { transform_ = transform; }
    const Transform &transform() const { return transform_; }
 
    void setScale(const float scale) { scale_ = scale; }
    float effectiveScale() const { return (effectiveScaleX_ + effectiveScaleY_) * 0.5; }
 
    void setRotation(const float rotation) { rotation_ = rotation; }
    float rotation() const { return rotation_; }
 
    void setOffset(const Point &offset) { offset_ = offset; }
    const Point &effectiveOffset() const { return effectiveOffset_; }
 
    void setMode(const ScaleMode mode) { mode_ = mode; }
    ScaleMode mode() const { return mode_; }
 
    int setDewarpParams(const Matrix<double, 3, 3> &cm, const Span<const double> &coeffs);
    bool dewarpParamsValid() { return dewarpParamsValid_; }
 
    void setLensDewarpEnable(bool enable) { lensDewarpEnable_ = enable; }
    bool lensDewarpEnable() { return lensDewarpEnable_; }
 
    std::vector<uint32_t> getVertexMap();
 
private:
    Vector<double, 2> dewarpPoint(const Vector<double, 2> &p);
 
    Rectangle scalerCrop_;
    Rectangle sensorCrop_;
    Transform transform_ = Transform::Identity;
    Size inputSize_;
    Size outputSize_;
    Point offset_;
    double scale_ = 1.0;
    double rotation_ = 0.0;
    ScaleMode mode_ = Fill;
    double effectiveScaleX_;
    double effectiveScaleY_;
    Point effectiveOffset_;
    Rectangle effectiveScalerCrop_;
 
    Matrix<double, 3, 3> dewarpM_ = Matrix<double, 3, 3>::identity();
    std::array<double, 12> dewarpCoeffs_;
    bool lensDewarpEnable_ = true;
    bool dewarpParamsValid_ = false;
};
 
} /* namespace libcamera */