CScanlineMask.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#ifndef iimg_CScanlineMask_included
#define iimg_CScanlineMask_included
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QList>
 
// ICF includes
#include <istd/TRanges.h>
#include <i2d/CObject2dBase.h>
#include <i2d/CRect.h>
#include <i2d/CCircle.h>
#include <i2d/CAnnulus.h>
#include <i2d/CPolygon.h>
#include <i2d/CTubePolyline.h>
#include <iimg/IBitmap.h>
 
 
namespace iimg
{
 
 
class CScanlineMask:
        public i2d::CObject2dBase,
        virtual public IRasterImage
{
public:
    typedef i2d::CObject2dBase BaseClass;
    typedef QList<istd::CIntRanges> RangesContainer;
    typedef std::vector<int> Scanlines; // Index of container element for each scan line, negative value for empty element
 
    CScanlineMask();
 
    bool IsBitmapRegionEmpty() const;
 
    i2d::CRect GetBoundingRect() const;
 
    void ResetScanlines(const istd::CIntRange& verticalRange);
 
    const istd::CIntRanges* GetPixelRanges(int lineIndex) const;
 
    void CreateFilled(const i2d::CRect& clipArea);
    bool CreateFromGeometry(const i2d::IObject2d& geometry, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromCircle(const i2d::CCircle& circle, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromRectangle(const i2d::CRectangle& rect, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromAnnulus(const i2d::CAnnulus& annulus, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromPolygon(const i2d::CPolygon& polygon, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromTube(const i2d::CTubePolyline& tube, const i2d::CRect* clipAreaPtr = nullptr);
 
    void CreateFromBitmap(const iimg::IBitmap& bitmap, const i2d::CRect* clipAreaPtr = nullptr);
 
    void GetInverted(const i2d::CRect& clipArea, CScanlineMask& result) const;
 
    void Invert(const i2d::CRect& clipArea);
 
    CScanlineMask GetUnion(const CScanlineMask& mask) const;
 
    void GetUnion(const CScanlineMask& mask, CScanlineMask& result) const;
 
    void Union(const CScanlineMask& mask);
 
    CScanlineMask GetIntersection(const CScanlineMask& mask) const;
 
    void GetIntersection(const CScanlineMask& mask, CScanlineMask& result) const;
 
    void Intersection(const CScanlineMask& mask);
 
    CScanlineMask GetTranslated(int dx, int dy) const;
 
    void GetTranslated(int dx, int dy, CScanlineMask& result) const;
 
    void Translate(int dx, int dy);
 
    void Erode(int leftValue, int rightValue, int topValue, int bottomValue);
 
    void Dilate(int leftValue, int rightValue, int topValue, int bottomValue);
 
    // reimplemented (i2d::IObject2d)
    i2d::CVector2d GetCenter() const override;
    void MoveCenterTo(const i2d::CVector2d& position) override;
    i2d::CRectangle GetBoundingBox() const override;
 
    // reimplemented (iimg::IRasterImage)
    bool IsEmpty() const override;
    void ResetImage() override;
    void ClearImage() override;
    istd::CIndex2d GetImageSize() const override;
    int GetComponentsCount() const override;
    icmm::CVarColor GetColorAt(const istd::CIndex2d& position) const override;
    bool SetColorAt(const istd::CIndex2d& position, const icmm::CVarColor& color) override;
 
    // reimplemented (iser::ISerializable)
    bool Serialize(iser::IArchive& archive) override;
 
    // reimplemented (istd::IChangeable)
    int GetSupportedOperations() const override;
    bool CopyFrom(const istd::IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
    bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
    bool operator==(const CScanlineMask& mask) const;
    bool operator!=(const CScanlineMask& mask) const;
 
    friend size_t qHash(const CScanlineMask& key, size_t seed);
 
protected:
    void EnsureBoundingBoxValid() const;
    void CalcBoundingBox() const;
    void InitFromBoundingBox(const i2d::CRectangle& objectBoundingBox, const i2d::CRect* clipAreaPtr);
 
    template <typename PixelType>
    void CalculateMaskFromBitmap(const iimg::IBitmap& bitmap, const i2d::CRect* clipAreaPtr = nullptr);
 
private:
    RangesContainer m_rangesContainer;
 
    Scanlines m_scanlines;
 
    int m_firstLinePos;
 
    mutable i2d::CRect m_boundingBox;
    mutable bool m_isBoundingBoxValid;
};
 
 
// public inline methods
 
inline bool CScanlineMask::operator!=(const CScanlineMask& mask) const
{
    return !operator==(mask);
}
 
 
// protected inline methods
 
inline void CScanlineMask::EnsureBoundingBoxValid() const
{
    if (!m_isBoundingBoxValid) {
        CalcBoundingBox();
    }
}
 
 
// protected methods
 
template <typename PixelType>
void CScanlineMask::CalculateMaskFromBitmap(const iimg::IBitmap& bitmap, const i2d::CRect* clipAreaPtr)
{
    InitFromBoundingBox(bitmap.GetBoundingBox(), clipAreaPtr);
 
    int linesCount = int(m_scanlines.size());
    if (linesCount <= 0) {
        ResetImage();
 
        return;
    }
 
    m_rangesContainer.reserve(linesCount);
 
    Q_ASSERT(bitmap.GetImageSize().GetY() == (linesCount));
 
    int imageWidth = bitmap.GetImageSize().GetX();
 
    for (int lineIndex = 0; lineIndex < linesCount; lineIndex++) {
        istd::CIntRanges rangeList;
 
        PixelType* imageLinePtr = (PixelType*)bitmap.GetLinePtr(lineIndex);
        Q_ASSERT(imageLinePtr != nullptr);
 
        int left = -1;
        int right = -1;
 
        for (int x = 0; x < imageWidth; ++x) {
            PixelType pixel = *(imageLinePtr + x);
            if ((pixel > 0) && (left < 0)) {
                left = x;
            }
 
            if ((pixel == 0) && (left >= 0)) {
                right = x;
                if (clipAreaPtr != nullptr) {
                    if (left < clipAreaPtr->GetLeft()) {
                        left = clipAreaPtr->GetLeft();
                    }
 
                    if (right > clipAreaPtr->GetRight()) {
                        right = clipAreaPtr->GetRight();
                    }
                }
 
                if (left < right) {
                    rangeList.InsertSwitchPoint(left);
                    rangeList.InsertSwitchPoint(right);
                }
 
                left = -1;
                right = -1;
            }
        }
 
        if ((left >= 0) && (right < 0)) {
            rangeList.InsertSwitchPoint(left);
        }
 
        if (!rangeList.IsEmpty()) {
            m_rangesContainer.push_back(rangeList);
 
            m_scanlines[lineIndex] = m_rangesContainer.size() - 1;
        }
        else {
            m_scanlines[lineIndex] = -1;
        }
    }
}
 
 
// related global functions
 
size_t qHash(const CScanlineMask& key, size_t seed = 0);
 
 
} // namespace iimg
 
 
#endif // !iimg_CScanlineMask_included