MatrixBuilder.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014 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_SHAPELET_MatrixBuilder_h_INCLUDED
#define LSST_SHAPELET_MatrixBuilder_h_INCLUDED
 
#include "ndarray.h"
 
#include "lsst/shapelet/constants.h"
#include "lsst/shapelet/ShapeletFunction.h"
#include "lsst/shapelet/MultiShapeletFunction.h"
 
namespace lsst { namespace shapelet {
 
class MultiShapeletBasis;
 
template <typename T>
class MatrixBuilderFactory;
 
template <typename T>
class MatrixBuilderWorkspace;

template <typename T>
class MatrixBuilder {
public:
 
    typedef MatrixBuilderFactory<T> Factory;     
    typedef MatrixBuilderWorkspace<T> Workspace; 
 
    class Impl; // Private implementation, defined in .cc; public to allow us to subclass it there

    MatrixBuilder(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        int order
    );

    MatrixBuilder(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        int order,
        ShapeletFunction const & psf
    );

    MatrixBuilder(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        MultiShapeletBasis const & basis
    );

    MatrixBuilder(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        MultiShapeletBasis const & basis,
        MultiShapeletFunction const & psf
    );

    int getDataSize() const;

    int getBasisSize() const;

    ndarray::Array<T,2,-2> allocateOutput() const;

    void operator()(
        ndarray::Array<T,2,-1> const & output,
        afw::geom::ellipses::Ellipse const & ellipse
    ) const;

    ndarray::Array<T,2,-2> operator()(afw::geom::ellipses::Ellipse const & ellipse) const {
        ndarray::Array<T,2,-2> output = allocateOutput();
        (*this)(output, ellipse);
        return output;
    }
 
private:
 
    template <typename U> friend class MatrixBuilderFactory;
 
    explicit MatrixBuilder(std::shared_ptr<Impl> impl);
 
    std::shared_ptr<Impl> _impl;
};

template <typename T>
class MatrixBuilderWorkspace {
public:
 
    typedef Eigen::Map< Eigen::Array<T,Eigen::Dynamic,Eigen::Dynamic> > Matrix; 
    typedef Eigen::Map< Eigen::Array<T,Eigen::Dynamic,1> > Vector;  

    explicit MatrixBuilderWorkspace(int size);

    MatrixBuilderWorkspace(MatrixBuilderWorkspace const & other) :
        _current(other._current),
        _end(other._end),
        _manager(other._manager)
    {}

    int getRemaining() const { return _end - _current; }
 
#ifndef SWIG

    Matrix makeMatrix(int rows, int cols);

    Vector makeVector(int size);

    void increment(int size);

    ndarray::Manager::Ptr getManager() const { return _manager; }
 
#endif
 
private:
 
    void operator=(MatrixBuilderWorkspace & other); // disabled
 
    T * _current;
    T * _end;
    ndarray::Manager::Ptr _manager;
};

template <typename T>
class MatrixBuilderFactory {
public:
 
    typedef MatrixBuilderWorkspace<T> Workspace; 
    typedef MatrixBuilder<T> Builder; 
 
    class Impl; // Private implementation, defined in .cc; public to allow us to subclass it there

    MatrixBuilderFactory(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        int order
    );

    MatrixBuilderFactory(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        int order,
        ShapeletFunction const & psf
    );

    MatrixBuilderFactory(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        MultiShapeletBasis const & basis
    );

    MatrixBuilderFactory(
        ndarray::Array<T const,1,1> const & x,
        ndarray::Array<T const,1,1> const & y,
        MultiShapeletBasis const & basis,
        MultiShapeletFunction const & psf
    );

    int getDataSize() const;

    int getBasisSize() const;

    int computeWorkspace() const;

    MatrixBuilder<T> operator()() const;

    MatrixBuilder<T> operator()(Workspace & workspace) const;
 
private:
    std::shared_ptr<Impl> _impl;
};
 
}} // namespace lsst::shapelet
 
#endif // !LSST_SHAPELET_MatrixBuilder_h_INCLUDED