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;
 
    using ParameterVector = Eigen::Vector3d;  
    using Jacobian = Eigen::Matrix3d;         
 
    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;
 
    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