ImageBase.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/>.
 */
 
/*
 * Support for 2-D images
 *
 * This file contains the basic 2-d image support for LSST
 */
#ifndef LSST_AFW_IMAGE_IMAGEBASE_H
#define LSST_AFW_IMAGE_IMAGEBASE_H
 
#include <string>
#include <utility>
#include <functional>
 
#include <memory>
 
#include "lsst/geom.h"
#include "lsst/afw/image/lsstGil.h"
#include "lsst/afw/image/ImageUtils.h"
#include "lsst/afw/math/Function.h"
#include "lsst/pex/exceptions.h"
#include "ndarray.h"
 
namespace lsst {
namespace afw {
 
namespace fits {
class Fits;
class MemFileManager;
struct ImageWriteOptions;
}  // namespace fits
 
namespace image {
namespace detail {
//
// Traits for image types
//
struct basic_tag {};
struct Image_tag : public basic_tag {};
template <typename ImageT>
struct image_traits {
    using image_category = typename ImageT::image_category;
};
//
std::string const wcsNameForXY0 = "A";  // the name of the WCS to use to save (X0, Y0) to FITS files; e.g. "A"
}  // namespace detail
 
class CheckIndices {
public:
    explicit CheckIndices(bool check = true) : _check(check) {}
    operator bool() const { return _check; }
 
private:
    bool _check;
};
 
template <typename PixelT>
struct Reference {
    using type = typename boost::gil::channel_traits<PixelT>::reference;  
};
template <typename PixelT>
struct ConstReference {
    using type = typename boost::gil::channel_traits<PixelT>::const_reference;  
};
 
enum ImageOrigin { PARENT, LOCAL };
 
//
// You are not expected to use this class directly in your own code; use one of the
// specialised subclasses
//
template <typename PixelT>
class ImageBase {
private:
    using _view_t = typename lsst::afw::image::detail::types_traits<PixelT>::view_t;
    using _const_view_t = typename lsst::afw::image::detail::types_traits<PixelT>::const_view_t;
 
    using Manager = ndarray::Manager;
 
public:
    using image_category = detail::basic_tag;  
 
    using SinglePixel = PixelT;
    using Pixel = PixelT;
    using PixelReference = typename Reference<PixelT>::type;
    using PixelConstReference = typename ConstReference<PixelT>::type;
    using xy_locator = typename _view_t::xy_locator;
    using const_xy_locator = typename _view_t::xy_locator::const_t;
    using iterator = typename _view_t::iterator;
    using const_iterator = typename _const_view_t::iterator;
    using reverse_iterator = typename _view_t::reverse_iterator;
    using const_reverse_iterator = typename _const_view_t::reverse_iterator;
    using x_iterator = typename _view_t::x_iterator;
    using fast_iterator = x_iterator;
    using xy_x_iterator = typename _view_t::x_iterator;
    using const_x_iterator = typename _const_view_t::x_iterator;
    using y_iterator = typename _view_t::y_iterator;
    using xy_y_iterator = typename _view_t::y_iterator;
    using const_y_iterator = typename _const_view_t::y_iterator;
    using Array = typename ndarray::Array<PixelT, 2, 1>;
    using ConstArray = typename ndarray::Array<const PixelT, 2, 1>;
 
    template <typename OtherPixelT>
    friend class ImageBase;  // needed by generalised copy constructors
 
    template <typename SinglePixelT>
    static SinglePixel PixelCast(SinglePixelT rhs) {
        return SinglePixel(rhs);
    }
    //
    // DecoratedImage needs enough access to ImageBase to read data from disk; we might be able to design
    // around this
    //
    template <typename>
    friend class DecoratedImage;
    template <typename, typename, typename>
    friend class MaskedImage;
    explicit ImageBase(const lsst::geom::Extent2I& dimensions = lsst::geom::Extent2I());
    explicit ImageBase(const lsst::geom::Box2I& bbox);
    ImageBase(const ImageBase& src, const bool deep = false);
    ImageBase(ImageBase&& src);
    explicit ImageBase(const ImageBase& src, const lsst::geom::Box2I& bbox, const ImageOrigin origin = PARENT,
                       const bool deep = false);
    template <typename OtherPixelT>
    ImageBase(const ImageBase<OtherPixelT>& rhs, const bool deep) {
        if (!deep) {
            throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
                              "Only deep copies are permitted for ImageBases with different pixel types");
        }
 
        ImageBase<PixelT> tmp(rhs.getBBox());
        copy_and_convert_pixels(rhs._gilView, tmp._gilView);  // from boost::gil
 
        using std::swap;               // See Meyers, Effective C++, Item 25
        ImageBase<PixelT>::swap(tmp);  // See Meyers, Effective C++, Items 11 and 43
    }
 
    explicit ImageBase(Array const& array, bool deep = false,
                       lsst::geom::Point2I const& xy0 = lsst::geom::Point2I());
 
    virtual ~ImageBase() = default;
    ImageBase& operator=(const ImageBase& rhs);
    ImageBase& operator=(ImageBase&& rhs);
    ImageBase& operator=(const PixelT rhs);
 
    void assign(ImageBase const& rhs, lsst::geom::Box2I const& bbox = lsst::geom::Box2I(),
                ImageOrigin origin = PARENT);
 
    // TODO: should deprecate these, but the replacement should take two ints
    // rather than a Point2I, to keep C++ loops simple
    PixelReference operator()(int x, int y);
    PixelReference operator()(int x, int y, CheckIndices const&);
    PixelConstReference operator()(int x, int y) const;
    PixelConstReference operator()(int x, int y, CheckIndices const&) const;
 
    PixelReference get(lsst::geom::Point2I const& index, ImageOrigin origin);
 
    PixelConstReference get(lsst::geom::Point2I const& index, ImageOrigin origin) const;
 
    PixelReference operator[](lsst::geom::Point2I const& index) { return get(index, PARENT); }
 
    PixelConstReference operator[](lsst::geom::Point2I const& index) const { return get(index, PARENT); }
 
    int getWidth() const { return _gilView.width(); }
    int getHeight() const { return _gilView.height(); }
    int getArea() const { return getWidth()*getHeight(); }
    int getX0() const { return _origin.getX(); }
    int getY0() const { return _origin.getY(); }
 
    lsst::geom::Point2I getXY0() const { return _origin; }
 
    std::pair<int, double> positionToIndex(
            double const pos,                
            lsst::afw::image::xOrY const xy  
            ) const {
        double const fullIndex = pos - PixelZeroPos - (xy == X ? getX0() : getY0());
        int const roundedIndex = static_cast<int>(fullIndex + 0.5);
        double const residual = fullIndex - roundedIndex;
        return std::pair<int, double>(roundedIndex, residual);
    }
 
    inline double indexToPosition(double ind,                      
                                  lsst::afw::image::xOrY const xy  
                                  ) const {
        return ind + PixelZeroPos + (xy == X ? getX0() : getY0());
    }
 
    lsst::geom::Extent2I getDimensions() const { return lsst::geom::Extent2I(getWidth(), getHeight()); }
 
    void swap(ImageBase& rhs);
 
    Array getArray();
    ConstArray getArray() const;
    //
    // Iterators and Locators
    //
    iterator begin() const;
    iterator end() const;
    reverse_iterator rbegin() const;
    reverse_iterator rend() const;
    iterator at(int x, int y) const;
 
    fast_iterator begin(bool contiguous) const;
    fast_iterator end(bool contiguous) const;
 
    x_iterator row_begin(int y) const { return _gilView.row_begin(y); }
 
    x_iterator row_end(int y) const { return _gilView.row_end(y); }
 
    x_iterator x_at(int x, int y) const { return _gilView.x_at(x, y); }
 
    y_iterator col_begin(int x) const { return _gilView.col_begin(x); }
 
    y_iterator col_end(int x) const { return _gilView.col_end(x); }
 
    y_iterator y_at(int x, int y) const { return _gilView.y_at(x, y); }
 
    xy_locator xy_at(int x, int y) const { return xy_locator(_gilView.xy_at(x, y)); }
    void setXY0(lsst::geom::Point2I const origin) { _origin = origin; }
    void setXY0(int const x0, int const y0) { setXY0(lsst::geom::Point2I(x0, y0)); }
 
    lsst::geom::Box2I getBBox(ImageOrigin origin = PARENT) const {
        if (origin == PARENT) {
            return lsst::geom::Box2I(_origin, getDimensions());
        } else
            return lsst::geom::Box2I(lsst::geom::Point2I(0, 0), getDimensions());
    }
 
private:
    lsst::geom::Point2I _origin;
    Manager::Ptr _manager;
    _view_t _gilView;
 
    // oring of ImageBase in some larger image as returned to and manipulated
    // by the user
 
protected:
    static _view_t _allocateView(lsst::geom::Extent2I const& dimensions, Manager::Ptr& manager);
    static _view_t _makeSubView(lsst::geom::Extent2I const& dimensions, lsst::geom::Extent2I const& offset,
                                const _view_t& view);
 
    _view_t _getRawView() const { return _gilView; }
 
    inline bool isContiguous() const { return begin() + getWidth() * getHeight() == end(); }
};
 
template <typename PixelT>
void swap(ImageBase<PixelT>& a, ImageBase<PixelT>& b);
 
// Inline template definitions
 
template <typename PixelT>
typename ImageBase<PixelT>::Array ImageBase<PixelT>::getArray() {
    int rowStride = 1;
    PixelT * data = nullptr;
    if (getArea() > 0) {
        data = reinterpret_cast<PixelT*>(row_begin(0));
    }
    if (getHeight() > 1) {
        rowStride = reinterpret_cast<PixelT*>(row_begin(1)) - reinterpret_cast<PixelT*>(row_begin(0));
    }
    return ndarray::external(data,
                             ndarray::makeVector(getHeight(), getWidth()), ndarray::makeVector(rowStride, 1),
                             this->_manager);
}
 
template <typename PixelT>
typename ImageBase<PixelT>::ConstArray ImageBase<PixelT>::getArray() const {
    int rowStride = 1;
    PixelT * data = nullptr;
    if (getArea() > 0) {
        data = reinterpret_cast<PixelT*>(row_begin(0));
    }
    if (getHeight() > 1) {
        rowStride = reinterpret_cast<PixelT*>(row_begin(1)) - reinterpret_cast<PixelT*>(row_begin(0));
    }
    return ndarray::external(data,
                             ndarray::makeVector(getHeight(), getWidth()), ndarray::makeVector(rowStride, 1),
                             this->_manager);
}
 
}  // namespace image
}  // namespace afw
}  // namespace lsst
 
#endif