PhotometryTransform.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * This file is part of jointcal.
 *
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef LSST_JOINTCAL_PHOTOMETRY_TRANSFORM_H
#define LSST_JOINTCAL_PHOTOMETRY_TRANSFORM_H

#include <iostream>
#include <sstream>
#include <memory>

#include "Eigen/Core"
#include "ndarray.h"

#include "lsst/afw/geom/AffineTransform.h"
#include "lsst/afw/geom/Box.h"
#include "lsst/afw/geom/Point.h"
#include "lsst/jointcal/Point.h"

namespace lsst {
namespace jointcal {

class Point;

class PhotometryTransform {
public:
    virtual double transform(double x, double y, double value) const = 0;

    double transform(Point const &in, double value) const { return transform(in.x, in.y, value); }

    virtual double transformError(double x, double y, double value, double valueErr) const = 0;

    double transformError(Point const &in, double value, double valueErr) const {
        return transformError(in.x, in.y, value, valueErr);
    }

    virtual void dump(std::ostream &stream = std::cout) const = 0;

    friend std::ostream &operator<<(std::ostream &s, PhotometryTransform const &transform) {
        transform.dump(s);
        return s;
    }

    virtual std::size_t getNpar() const = 0;

    virtual void offsetParams(Eigen::VectorXd const &delta) = 0;

    virtual std::shared_ptr<PhotometryTransform> clone() const = 0;

    virtual void computeParameterDerivatives(double x, double y, double value,
                                             Eigen::Ref<Eigen::VectorXd> derivatives) const = 0;

    virtual Eigen::VectorXd getParameters() const = 0;
};

class PhotometryTransformSpatiallyInvariant : public PhotometryTransform {
public:
    explicit PhotometryTransformSpatiallyInvariant(double value) : _value(value) {}

    void dump(std::ostream &stream = std::cout) const override { stream << std::setprecision(10) << _value; }

    std::size_t getNpar() const override { return 1; }

    void offsetParams(Eigen::VectorXd const &delta) override { _value -= delta[0]; };

    Eigen::VectorXd getParameters() const override {
        Eigen::VectorXd parameters(1);
        parameters[0] = _value;
        return parameters;
    }

protected:
    double getValue() const { return _value; }

private:
    double _value;
};

class FluxTransformSpatiallyInvariant : public PhotometryTransformSpatiallyInvariant {
public:
    explicit FluxTransformSpatiallyInvariant(double value = 1)
            : PhotometryTransformSpatiallyInvariant(value) {}

    double transform(double x, double y, double value) const override { return value * getValue(); }

    double transformError(double x, double y, double value, double valueErr) const override {
        return getValue() * valueErr;
    }

    std::shared_ptr<PhotometryTransform> clone() const override {
        return std::make_shared<FluxTransformSpatiallyInvariant>(getValue());
    }

    void computeParameterDerivatives(double x, double y, double value,
                                     Eigen::Ref<Eigen::VectorXd> derivatives) const override {
        // the derivative of a spatially constant transform w.r.t. that value is just the value.
        derivatives[0] = value;
    }
};

class MagnitudeTransformSpatiallyInvariant : public PhotometryTransformSpatiallyInvariant {
public:
    explicit MagnitudeTransformSpatiallyInvariant(double value = 0)
            : PhotometryTransformSpatiallyInvariant(value) {}

    double transform(double x, double y, double mag) const override { return mag + getValue(); }

    double transformError(double x, double y, double value, double valueErr) const override {
        return valueErr;
    }

    std::shared_ptr<PhotometryTransform> clone() const override {
        return std::make_shared<MagnitudeTransformSpatiallyInvariant>(getValue());
    }

    void computeParameterDerivatives(double x, double y, double value,
                                     Eigen::Ref<Eigen::VectorXd> derivatives) const override {
        // the derivative of a spatially constant transform w.r.t. that value is 1.
        derivatives[0] = 1;
    }
};

class PhotometryTransformChebyshev : public PhotometryTransform {
public:
    PhotometryTransformChebyshev(size_t order, geom::Box2D const &bbox, bool identity);

    PhotometryTransformChebyshev(ndarray::Array<double, 2, 2> const &coefficients, geom::Box2D const &bbox);

    double transformError(double x, double y, double value, double valueErr) const override { return 0; }

    void dump(std::ostream &stream = std::cout) const override { stream << _coefficients; }

    std::size_t getNpar() const override { return _nParameters; }

    void offsetParams(Eigen::VectorXd const &delta) override;

    ndarray::Array<double, 2, 2> getCoefficients() const { return ndarray::copy(_coefficients); }

    Eigen::VectorXd getParameters() const override;

    ndarray::Size getOrder() const { return _order; }

    geom::Box2D getBBox() const { return _bbox; }

    double mean(geom::Box2D const &bbox) const;
    double mean() const;

    // Compute the integral of this function over a bounding-box (default to our bbox).
    double integrate(geom::Box2D const &bbox) const;
    double integrate() const;

protected:
    double computeChebyshev(double x, double y) const;

    void computeChebyshevDerivatives(double x, double y, Eigen::Ref<Eigen::VectorXd> derivatives) const;

private:
    geom::Box2D _bbox;                        // the domain of this function
    geom::AffineTransform _toChebyshevRange;  // maps points from the bbox to [-1,1]x[-1,1]

    ndarray::Array<double, 2, 2> _coefficients;  // shape=(order+1, order+1)
    ndarray::Size _order;
    ndarray::Size _nParameters;

    double oneIntegral(double x, double y) const;
};

class FluxTransformChebyshev : public PhotometryTransformChebyshev {
public:
    FluxTransformChebyshev(size_t order, geom::Box2D const &bbox)
            : PhotometryTransformChebyshev(order, bbox, true) {}

    FluxTransformChebyshev(ndarray::Array<double, 2, 2> const &coefficients, geom::Box2D const &bbox)
            : PhotometryTransformChebyshev(coefficients, bbox) {}

    double transform(double x, double y, double value) const override {
        return value * computeChebyshev(x, y);
    }

    void computeParameterDerivatives(double x, double y, double value,
                                     Eigen::Ref<Eigen::VectorXd> derivatives) const override {
        computeChebyshevDerivatives(x, y, derivatives);
        derivatives *= value;
    }

    std::shared_ptr<PhotometryTransform> clone() const override {
        return std::make_shared<FluxTransformChebyshev>(getCoefficients(), getBBox());
    }
};

class MagnitudeTransformChebyshev : public PhotometryTransformChebyshev {
public:
    MagnitudeTransformChebyshev(size_t order, geom::Box2D const &bbox)
            : PhotometryTransformChebyshev(order, bbox, false) {}

    MagnitudeTransformChebyshev(ndarray::Array<double, 2, 2> const &coefficients, geom::Box2D const &bbox)
            : PhotometryTransformChebyshev(coefficients, bbox) {}

    double transform(double x, double y, double value) const override {
        return value + computeChebyshev(x, y);
    }

    void computeParameterDerivatives(double x, double y, double value,
                                     Eigen::Ref<Eigen::VectorXd> derivatives) const override {
        // The derivatives here are independent of value
        computeChebyshevDerivatives(x, y, derivatives);
    }

    std::shared_ptr<PhotometryTransform> clone() const override {
        return std::make_shared<FluxTransformChebyshev>(getCoefficients(), getBBox());
    }
};

}  // namespace jointcal
}  // namespace lsst

#endif  // LSST_JOINTCAL_PHOTOMETRY_TRANSFORM_H