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/geom/AffineTransform.h"
#include "lsst/geom/Box.h"
#include "lsst/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 print(std::ostream &out) const = 0;
 
    friend std::ostream &operator<<(std::ostream &s, PhotometryTransform const &transform) {
        transform.print(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 print(std::ostream &out) const override {
        out << "PhotometryTransformSpatiallyInvariant: " << 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 print(std::ostream &out) const override { out << "PhotometryTransformChebyshev: " << _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