[an error occurred while processing this directive]

hugin_base/panodata/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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#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; }

using namespace hugin_utils;

typedef std::vector<FDiff2D> VectorPolygon;

const int maskOffset=100;

class IMPEX MaskPolygon
{
public:
    enum MaskType 
    {
        Mask_negative=0,
        Mask_positive=1
    };
    MaskPolygon() : m_maskType(Mask_negative), m_invert(false), m_imgNr(0) {};
    bool isInside(const FDiff2D p) const;
    int getWindingNumber(const FDiff2D p) const;
    int getTotalWindingNumber() const;

    // access functions
    MaskType getMaskType() const { return m_maskType; };
    void setMaskType(const MaskType newType) { m_maskType=newType; };
    VectorPolygon getMaskPolygon() const { return m_polygon; };
    void setMaskPolygon(const VectorPolygon newMask) { m_polygon = 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 FDiff2D p);
    void insertPoint(const unsigned int index, const FDiff2D p);
    void removePoint(const unsigned int index);
    void movePointTo(const unsigned int index, const FDiff2D p);
    void movePointBy(const unsigned int index, const FDiff2D diff);
    void scale(const double factorx, const double factory);
    void scale(const double factor) { scale(factor,factor);} ;
    void transformPolygon(const PTools::Transform &trans);
    bool clipPolygon(const vigra::Rect2D rect);
    void rotate90(bool clockwise,unsigned int maskWidth,unsigned int maskHeight);
    void subSample(const double max_distance);

    unsigned int FindPointNearPos(const FDiff2D p, const double tol);

    //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;

private:
    // helper functions for clipping using Sutherland-Hodgeman Clipping Algorithm
    enum clipSide
    {
        clipLeft=0,
        clipRight,
        clipTop,
        clipBottom
    };
    bool clip_isSide(const FDiff2D p, const vigra::Rect2D r, const clipSide side);
    FDiff2D clip_getIntersection(const FDiff2D p, const FDiff2D q, const vigra::Rect2D r, const clipSide side);
    void clip_onPlane(const vigra::Rect2D r, clipSide side);

    //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;
};

typedef std::vector<MaskPolygon> MaskPolygonVector;

}; //namespace

namespace vigra_ext 
{

template <class SrcImageIterator, class SrcAccessor>
void applyMask(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> img, HuginBase::MaskPolygonVector masks)
{
    vigra::Diff2D imgSize = img.second - img.first;

    if(masks.size()<1)
        return;
    // create dest y iterator
    SrcImageIterator yd(img.first);
    // loop over the image and transform
    for(int y=0; y < imgSize.y; ++y, ++yd.y)
    {
        // create x iterators
        SrcImageIterator xd(yd);
        for(int x=0; x < imgSize.x; ++x, ++xd.x)
        {
            HuginBase::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 // PANOIMAGE_H

---