CScanlineMask.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <vector>
 
// Qt includes
#include <QtCore/QList>
 
// ACF 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 = NULL);
 
       void CreateFromCircle(const i2d::CCircle& circle, const i2d::CRect* clipAreaPtr = NULL);
 
       void CreateFromRectangle(const i2d::CRectangle& rect, const i2d::CRect* clipAreaPtr = NULL);
 
       void CreateFromAnnulus(const i2d::CAnnulus& annulus, const i2d::CRect* clipAreaPtr = NULL);
 
       void CreateFromPolygon(const i2d::CPolygon& polygon, const i2d::CRect* clipAreaPtr = NULL);
 
       void CreateFromTube(const i2d::CTubePolyline& tube, const i2d::CRect* clipAreaPtr = NULL);
 
       void CreateFromBitmap(const iimg::IBitmap& bitmap, const i2d::CRect* clipAreaPtr = NULL);
 
       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)
       virtual i2d::CVector2d GetCenter() const override;
       virtual void MoveCenterTo(const i2d::CVector2d& position) override;
       virtual i2d::CRectangle GetBoundingBox() const override;
 
       // reimplemented (iimg::IRasterImage)
       virtual bool IsEmpty() const override;
       virtual void ResetImage() override;
       virtual void ClearImage() override;
       virtual istd::CIndex2d GetImageSize() const override;
       virtual int GetComponentsCount() const override;
       virtual icmm::CVarColor GetColorAt(const istd::CIndex2d& position) const override;
       virtual bool SetColorAt(const istd::CIndex2d& position, const icmm::CVarColor& color) override;
       virtual const icmm::IColorModel* GetColorModel() const override;
 
       // reimplemented (iser::ISerializable)
       virtual bool Serialize(iser::IArchive& archive) override;
 
       // reimplemented (istd::IChangeable)
       virtual int GetSupportedOperations() const override;
       virtual bool CopyFrom(const istd::IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
       virtual bool ResetData(CompatibilityMode mode = CM_WITHOUT_REFS) override;
 
       bool operator==(const CScanlineMask& mask) const;
       bool operator!=(const CScanlineMask& mask) const;
 
       friend uint qHash(const CScanlineMask& key, uint 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 = NULL);
 
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;
       }
 
#if QT_VERSION >= 0x040700
       m_rangesContainer.reserve(linesCount);
#endif
 
       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 != NULL);
 
              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 != NULL){
                                   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
 
uint qHash(const CScanlineMask& key, uint seed = 0);
 
 
} // namespace iimg