Arithmetic.hxx

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * 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 2 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 GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#ifndef _Arithmetic_hxx
#define _Arithmetic_hxx



template <class ImageType>
void
IP3D::Addition(const ImageType& im1, const ImageType& im2, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1,im2),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::const_iteratorFast p2;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), p2 = im2.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, p2++, pDest++)
    {
        (*pDest) = (*p1) + (*p2);
    }

}


template <class ImageType>
void
IP3D::AdditionWithConstant(const ImageType& src, const typename ImageType::value_type& scalarValue, ImageType& res)
{
    res=src;

    for(typename ImageType::iteratorFast p=res.begin();p!=res.end();++p)
    {
        (*p)+=scalarValue;
    }
}


template <class ImageType>
void
IP3D::Difference(const ImageType& im1, const ImageType& im2, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1,im2),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::const_iteratorFast p2;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), p2 = im2.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, p2++, pDest++)
    {
        (*pDest) = (*p1) - (*p2);
    }
}


template <class ImageType>
void
IP3D::DifferenceWithConstant(const ImageType& src, const typename ImageType::value_type& scalarValue, ImageType& res)
{
    res=src;

    for(typename ImageType::iteratorFast p=res.begin();p!=res.end();++p)
    {
        (*p)-=scalarValue;
    }
}


template <class ImageType>
void
IP3D::Multiplication(const ImageType& im1, const ImageType& im2, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1,im2),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::const_iteratorFast p2;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), p2 = im2.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, p2++, pDest++)
    {
        (*pDest) = (*p1) * (*p2);
    }
}


template <class ImageType>
void
IP3D::Division(const ImageType& im1, const ImageType& im2, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1,im2),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::const_iteratorFast p2;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), p2 = im2.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, p2++, pDest++)
    {
        (*pDest) = (*p1) / (*p2);
    }
}


template <class ImageType>
void
IP3D::MultiplicationWithConstant(const ImageType& src, double v, ImageType& res)
{
    res=src;

    for(typename ImageType::iteratorFast p=res.begin();p!=res.end();++p)
    {
        (*p)=(typename ImageType::value_type)(v*(*p));
    }
}

template <class ImageType>
void
IP3D::MaxImage(const ImageType& im1, const ImageType& im2, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1,im2),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::const_iteratorFast p2;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), p2 = im2.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, p2++, pDest++)
    {
        (*pDest) = max((*p1) , (*p2));
    }

}
template <class ImageType>
void
IP3D::Abs(const ImageType& im1, ImageType& _imDest)
{
    ImageProcessorArgs<ImageType> args(ImArgs(im1),_imDest);
    args.SameSize();
    args.InPlace();
    ImageType &imDest=args.GetDest();

    typename ImageType::const_iteratorFast p1;
    typename ImageType::iteratorFast pDest;
    
    for (p1 = im1.begin(), pDest = imDest.begin(); pDest != imDest.end(); p1++, pDest++)
    {
        (*pDest) = AbsoluteValue(*p1);
    }

}


// **************************** Image3Dlinear : Operators********************
template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator+=(const Image3Dlinear<Im3DValue> &other)
{
    IP3D::Addition(*this, other, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator+=(const Im3DValue& scalarValue)
{
    IP3D::AdditionWithConstant(*this, scalarValue, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator-=(const Image3Dlinear<Im3DValue> &other)
{
    IP3D::Difference(*this, other, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator-=(const Im3DValue& scalarValue)
{
    IP3D::DifferenceWithConstant(*this, scalarValue, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator*=(const Image3Dlinear<Im3DValue> &other)
{
    IP3D::Multiplication(*this, other, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator*=(double scalarValue)
{
    IP3D::MultiplicationWithConstant(*this, scalarValue, *this);
    return *this;
}

template<class Im3DValue>
Image3Dlinear<Im3DValue> &Image3Dlinear<Im3DValue>::operator/=(const Image3Dlinear<Im3DValue> &other)
{
    IP3D::Division(*this, other, *this);
    return *this;
}


#endif // _Arithmetic_hxx

---