BaseCore.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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 LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_AFW_GEOM_ELLIPSES_BaseCore_h_INCLUDED
#define LSST_AFW_GEOM_ELLIPSES_BaseCore_h_INCLUDED

/*
 *  Forward declarations, typedefs, and definitions for BaseCore.
 *
 *  Note: do not include directly; use the main ellipse header file.
 */

#include <memory>

#include "Eigen/Core"

#include "lsst/pex/exceptions.h"
#include "lsst/geom/LinearTransform.h"

namespace lsst {
namespace afw {
namespace geom {
namespace ellipses {

class Parametric;

class BaseCore {
public:
    class Transformer;
    class GridTransform;
    class Convolution;
    template <typename Output>
    struct Converter;

    typedef Eigen::Vector3d ParameterVector;  
    typedef Eigen::Matrix3d Jacobian;         

    static std::shared_ptr<BaseCore> make(std::string const& name);

    static std::shared_ptr<BaseCore> make(std::string const& name, ParameterVector const& parameters);

    static std::shared_ptr<BaseCore> make(std::string const& name, double v1, double v2, double v3);

    static std::shared_ptr<BaseCore> make(std::string const& name, BaseCore const& other);

    static std::shared_ptr<BaseCore> make(std::string const& name, Transformer const& other);

    static std::shared_ptr<BaseCore> make(std::string const& name, Convolution const& other);

    virtual std::string getName() const = 0;

    std::shared_ptr<BaseCore> clone() const { return _clone(); }

    virtual void normalize() = 0;

    void grow(double buffer);

    void scale(double factor);

    double getArea() const;

    double getDeterminantRadius() const;

    double getTraceRadius() const;

    Transformer transform(lsst::geom::LinearTransform const& transform);
    Transformer const transform(lsst::geom::LinearTransform const& transform) const;

    GridTransform const getGridTransform() const;

    Convolution convolve(BaseCore const& other);
    Convolution const convolve(BaseCore const& other) const;

    lsst::geom::Extent2D computeDimensions() const;

    virtual void readParameters(double const* iter) = 0;

    virtual void writeParameters(double* iter) const = 0;

    ParameterVector const getParameterVector() const;

    void setParameterVector(ParameterVector const& vector);

    bool operator==(BaseCore const& other) const;

    bool operator!=(BaseCore const& other) const { return !operator==(other); }

    BaseCore& operator=(BaseCore const& other);
    BaseCore& operator=(BaseCore&& other);

    Jacobian dAssign(BaseCore const& other);

    template <typename Output>
    Converter<Output> as() const;

    virtual ~BaseCore() = default;

protected:
    friend class Parametric;

    BaseCore() = default;
    BaseCore(BaseCore const&) = default;
    BaseCore(BaseCore&&) = default;

    static void registerSubclass(std::shared_ptr<BaseCore> const& example);

    template <typename T>
    struct Registrar {
        Registrar() { registerSubclass(std::make_shared<T>()); }
    };

    virtual std::shared_ptr<BaseCore> _clone() const = 0;

    static void _assignQuadrupoleToAxes(double ixx, double iyy, double ixy, double& a, double& b,
                                        double& theta);

    static Jacobian _dAssignQuadrupoleToAxes(double ixx, double iyy, double ixy, double& a, double& b,
                                             double& theta);

    static void _assignAxesToQuadrupole(double a, double b, double theta, double& ixx, double& iyy,
                                        double& ixy);

    static Jacobian _dAssignAxesToQuadrupole(double a, double b, double theta, double& ixx, double& iyy,
                                             double& ixy);

    virtual void _assignToQuadrupole(double& ixx, double& iyy, double& ixy) const = 0;
    virtual void _assignFromQuadrupole(double ixx, double iyy, double ixy) = 0;

    virtual void _assignToAxes(double& a, double& b, double& theta) const = 0;
    virtual void _assignFromAxes(double a, double b, double theta) = 0;

    virtual Jacobian _dAssignToQuadrupole(double& ixx, double& iyy, double& ixy) const = 0;
    virtual Jacobian _dAssignFromQuadrupole(double ixx, double iyy, double ixy) = 0;

    virtual Jacobian _dAssignToAxes(double& a, double& b, double& theta) const = 0;
    virtual Jacobian _dAssignFromAxes(double a, double b, double theta) = 0;
};

template <typename Output>
struct BaseCore::Converter {
    BaseCore const& input;

    explicit Converter(BaseCore const& input_) : input(input_) {}

    operator Output() const { return Output(input); }
    std::shared_ptr<Output> copy() const { return std::shared_ptr<Output>(new Output(input)); }
};

template <typename Output>
inline BaseCore::Converter<Output> BaseCore::as() const {
    return Converter<Output>(*this);
}
}  // namespace ellipses
}  // namespace geom
}  // namespace afw
}  // namespace lsst

#endif  // !LSST_AFW_GEOM_ELLIPSES_BaseCore_h_INCLUDED