ImageAlgorithm.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 functors over Image's pixels
 */
#ifndef LSST_AFW_IMAGE_IMAGE_ALGORITHM_H
#define LSST_AFW_IMAGE_IMAGE_ALGORITHM_H
 
#include <list>
#include <map>
#include <string>
#include <utility>
#include <functional>
 
#include "boost/format.hpp"
#include <memory>
 
#include "lsst/pex/exceptions.h"
 
namespace lsst {
namespace afw {
namespace image {
template <typename ValT>
struct pixelOp0 : public std::function<ValT()> {
    virtual ~pixelOp0() {}
    virtual ValT operator()() const = 0;
};

template <typename ValT>
struct pixelOp1 : public std::function<ValT(ValT)> {
    virtual ~pixelOp1() {}
    virtual ValT operator()(ValT lhs) const = 0;
};

template <typename ValT>
struct pixelOp1XY : public std::function<ValT(int, int, ValT)> {
    virtual ~pixelOp1XY() {}
    virtual ValT operator()(int x, int y, ValT lhs) const = 0;
};

template <typename LhsT, typename RhsT>
struct pixelOp2 : public std::function<LhsT(LhsT, RhsT)> {
    virtual ~pixelOp2() {}
    virtual LhsT operator()(LhsT lhs, RhsT rhs) const = 0;
};

template <typename LhsT, typename RhsT>
struct pixelOp2XY : public std::function<LhsT(int, int, LhsT, RhsT)> {
    virtual ~pixelOp2XY() {}
    virtual LhsT operator()(int x, int y, LhsT lhs, RhsT rhs) const = 0;
};

template <typename LhsT>
void for_each_pixel(Image<LhsT>& lhs,           
                    pixelOp0<LhsT> const& func  
) {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr) {
            *lhsPtr = func();
        }
    }
}

template <typename LhsT>
void for_each_pixel(Image<LhsT>& lhs,           
                    pixelOp1<LhsT> const& func  
) {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr) {
            *lhsPtr = func(*lhsPtr);
        }
    }
}

template <typename LhsT>
void for_each_pixel(Image<LhsT>& lhs,             
                    pixelOp1XY<LhsT> const& func  
) {
    for (int y = 0; y != lhs.getHeight(); ++y) {
        int x = lhs.getX0();
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++lhsPtr, ++x) {
            *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr);
        }
    }
}

template <typename LhsT, typename RhsT>
void for_each_pixel(Image<LhsT>& lhs,           
                    Image<RhsT> const& rhs,     
                    pixelOp1<RhsT> const& func  
) {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
            *lhsPtr = func(*rhsPtr);
        }
    }
}

template <typename LhsT, typename RhsT>
void for_each_pixel(Image<LhsT>& lhs,                 
                    Image<RhsT> const& rhs,           
                    pixelOp2<LhsT, RhsT> const& func  
) {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
 
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
            *lhsPtr = func(*lhsPtr, *rhsPtr);
        }
    }
}

template <typename LhsT, typename RhsT>
void for_each_pixel(Image<LhsT>& lhs,                   
                    Image<RhsT> const& rhs,             
                    pixelOp2XY<LhsT, RhsT> const& func  
) {
    if (lhs.getDimensions() != rhs.getDimensions()) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError,
                          (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
                           lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
                                  .str());
    }
 
    for (int y = 0; y != lhs.getHeight(); ++y) {
        typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
        int x = lhs.getX0();
        for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
             lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
            *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
        }
    }
}
}  // namespace image
}  // namespace afw
}  // namespace lsst
 
#endif