Mask.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
 
/*  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 software 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 software. If not, see
 *  <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _PANODATA_MASK_H
#define _PANODATA_MASK_H
 
#include <hugin_shared.h>
#include "hugin_utils/utils.h"
#include "hugin_math/hugin_math.h"
 
namespace HuginBase 
{
namespace PTools { class Transform; }
 
typedef std::vector<hugin_utils::FDiff2D> VectorPolygon;
 
const int maskOffset=100;
 
class IMPEX MaskPolygon
{
public:
    enum MaskType 
    {
        Mask_negative=0,
        Mask_positive=1,
        Mask_Stack_negative=2,
        Mask_Stack_positive=3,
        Mask_negative_lens=4
    };
    MaskPolygon() : m_maskType(Mask_negative), m_imgNr(0), m_invert(false) {};
    bool isInside(const hugin_utils::FDiff2D p) const;
    int getWindingNumber(const hugin_utils::FDiff2D p) const;
    int getTotalWindingNumber() const;
 
    // access functions
    MaskType getMaskType() const { return m_maskType; };
    void setMaskType(const MaskType newType) { m_maskType=newType; };
    bool isPositive() const;
    VectorPolygon getMaskPolygon() const { return m_polygon; };
    void setMaskPolygon(const VectorPolygon& newMask);
    unsigned int getImgNr() const { return m_imgNr; };
    void setImgNr(const unsigned int newImgNr) { m_imgNr=newImgNr; };
    void setInverted(const bool inverted) { m_invert = inverted; };
    bool isInverted() const { return m_invert; };
 
    // polygon modifier
    void addPoint(const hugin_utils::FDiff2D p);
    void insertPoint(const unsigned int index, const hugin_utils::FDiff2D p);
    void removePoint(const unsigned int index);
    void movePointTo(const unsigned int index, const hugin_utils::FDiff2D p);
    void movePointBy(const unsigned int index, const hugin_utils::FDiff2D diff);
    void scale(const double factorx, const double factory);
    void scale(const double factor) { scale(factor,factor);} ;
    void scale(const double factor, const hugin_utils::FDiff2D& p);
    void transformPolygon(const PTools::Transform &trans);
    bool clipPolygon(const vigra::Rect2D rect);
    bool clipPolygon(const hugin_utils::FDiff2D center, const double radius);
    void rotate90(bool clockwise,unsigned int maskWidth,unsigned int maskHeight);
    void subSample(const double max_distance);
 
    unsigned int FindPointNearPos(const hugin_utils::FDiff2D p, const double tol) const;
 
    //operators
    MaskPolygon &operator=(const MaskPolygon& otherPoly);
    const bool operator==(const MaskPolygon& otherPoly) const;
 
    //input/output functions
    bool parsePolygonString(const std::string& polygonStr);
    void printPolygonLine(std::ostream & o, const unsigned int newImgNr) const;
    hugin_utils::FDiff2D getCenter() const;
private:
    void calcBoundingBox();
    //variables for internal storage of Mask type, polygon and assigned image number
    MaskType m_maskType;
    VectorPolygon m_polygon;
    unsigned int m_imgNr;
    bool m_invert;
    vigra::Rect2D m_boundingBox;
};
 
typedef std::vector<MaskPolygon> MaskPolygonVector;
 
IMPEX void LoadMaskFromStream(std::istream& stream, vigra::Size2D& imageSize, MaskPolygonVector &newMasks, size_t imgNr);
IMPEX void SaveMaskToStream(std::ostream& stream, vigra::Size2D imageSize, MaskPolygon &maskToWrite, size_t imgNr);
 
}; //namespace
 
namespace vigra_ext 
{
 
template <class SrcImageIterator, class SrcAccessor>
void applyMask(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> img, HuginBase::MaskPolygonVector masks)
{
    const vigra::Diff2D imgSize = img.second - img.first;
 
    if(masks.empty())
        return;
    // loop over the image and transform
#pragma omp parallel for schedule(dynamic)
    for(int y=0; y < imgSize.y; ++y)
    {
        // create x iterators
        SrcImageIterator xd(img.first);
        xd.y += y;
        for(int x=0; x < imgSize.x; ++x, ++xd.x)
        {
            hugin_utils::FDiff2D newPoint(x,y);
            bool insideMasks=false;
            unsigned int i=0;
            while(!insideMasks && (i<masks.size()))
            {
                insideMasks=masks[i].isInside(newPoint);
                i++;
            };
            if(insideMasks)
                *xd=0;
        }
    }
}
 
} //namespace
#endif // _PANODATA_MASK_H