source/inc/PolygonPoint.hxx

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#ifndef _POLYGON_POINT_HXX
#define _POLYGON_POINT_HXX

#include <vector>

//////////////////////////////////////////////////////////////////////////////

template < class Point > class SimplePointEntry
{
    Point                                           maPoint;

public:
    SimplePointEntry()
    :   maPoint(Point::getEmptyPoint())
    {
    }

    SimplePointEntry(const Point& rInitPoint)
    :   maPoint(rInitPoint)
    {
    }

    const Point& getPoint() const
    {
        return maPoint;
    }

    void setPoint(const Point& rValue)
    {
        maPoint = rValue;
    }

    bool operator==(const SimplePointEntry& rEntry) const
    {
        return (maPoint == rEntry.maPoint);
    }
};

//////////////////////////////////////////////////////////////////////////////

template < class Vector > class SimpleBezierEntry
{
    Vector                                          maBackward;
    Vector                                          maForward;

public:
    SimpleBezierEntry()
    :   maBackward(Vector::getEmptyVector()),
        maForward(Vector::getEmptyVector())
    {
    }

    SimpleBezierEntry(const Vector& rInitBackward, const Vector& rInitForward)
    :   maBackward(rInitBackward),
        maForward(rInitForward)
    {
    }

    const Vector& getBackwardVector() const
    {
        return maBackward;
    }

    void setBackwardVector(const Vector& rValue)
    {
        maBackward = rValue;
    }

    const Vector& getForwardVector() const
    {
        return maForward;
    }

    void setForwardVector(const Vector& rValue)
    {
        maForward = rValue;
    }

    bool isBezierNeeded()
    {
        if(maBackward != Vector::getEmptyVector() || maForward != Vector::getEmptyVector())
            return true;
        return false;
    }

    bool operator==(const SimpleBezierEntry& rEntry) const
    {
        return ((maBackward == rEntry.maBackward) && (maForward == rEntry.maForward));
    }

    void doInvertForFlip()
    {
        maBackward = -maBackward;
        maForward = -maForward;
    }
};

//////////////////////////////////////////////////////////////////////////////

template < class Point, class Vector > class PolygonPointList
{
    typedef SimplePointEntry< Point > LocalSimplePointEntry;
    typedef SimpleBezierEntry< Vector > LocalSimpleBezierEntry;
    typedef ::std::vector< LocalSimplePointEntry > SimplePointVector;
    typedef ::std::vector< LocalSimpleBezierEntry > SimpleBezierVector;

    sal_uInt32                                      mnBezierCount;
    SimplePointVector                               maPoints;
    SimpleBezierVector*                             mpVectors;

    unsigned                                        mbIsClosed : 1;

    void implTryToReduceToPointVector()
    {
        if(!mnBezierCount && mpVectors)
        {
            delete mpVectors;
            mpVectors = 0L;
        }
    }

public:
    bool isBezier() const
    {
        return bool(mnBezierCount);
    }

    bool isClosed() const
    {
        return bool(mbIsClosed);
    }

    void setClosed(bool bNew)
    {
        mbIsClosed = bNew;
    }

    sal_uInt32 count() const
    {
        return maPoints.size();
    }

    PolygonPointList()
    :   mnBezierCount(0L),
        mpVectors(0L),
        mbIsClosed(false)
    {
        // complete initialization with defaults
    }

    PolygonPointList(const PolygonPointList& rSource)
    :   mnBezierCount(0L),
        maPoints(rSource.maPoints),
        mpVectors(0L),
        mbIsClosed(rSource.mbIsClosed)
    {
        // complete initialization using copy
        if(rSource.mpVectors && rSource.mnBezierCount)
        {
            mpVectors = new SimpleBezierVector(*rSource.mpVectors);
            mnBezierCount = rSource.mnBezierCount;
        }
    }

    PolygonPointList(const PolygonPointList& rSource, sal_uInt32 nIndex, sal_uInt32 nCount)
    :   mnBezierCount(0L),
        maPoints(nCount),
        mpVectors(0L),
        mbIsClosed(rSource.mbIsClosed)
    {
        // complete initialization using partly copy
        if(nCount)
        {
            // copy point data
            {
                SimplePointVector::const_iterator aStart(rSource.maPoints.begin());
                aStart += nIndex;
                SimplePointVector::const_iterator aEnd(aStart);
                aEnd += nCount;
                maPoints.insert(0L, aStart, aEnd);
            }

            // copy bezier data
            if(rSource.mpVectors && rSource.mnBezierCount)
            {
                mpVectors = new SimpleBezierVector();
                mpVectors->reserve(nCount);

                SimpleBezierVector::iterator aStart(mpVectors->begin());
                aStart += nIndex;
                SimpleBezierVector::iterator aEnd(aStart);
                aEnd += nCount;

                for( ; aStart != aEnd; ++aStart )
                {
                    if(aStart->IsBezierNeeded())
                    {
                        mnBezierCount++;
                    }

                    mpVectors->push_back(*aStart);
                }

                // maybe vectors are not needed anymore, try to reduce memory footprint
                implTryToReduceToPointVector();
            }
        }
    }

    ~PolygonPointList()
    {
        if(mpVectors)
        {
            delete mpVectors;
        }
    }

    bool isEqual(const PolygonPointList& rPointList) const
    {
        // same point count?
        if(maPoints.size() != rPointList.maPoints.size())
            return false;

        // if zero points the polys are equal
        if(!maPoints.size())
            return true;

        // if bezier count used it needs to be equal
        if(mnBezierCount != rPointList.mnBezierCount)
            return false;

        // compare point content
        if(maPoints != rPointList.maPoints)
            return false;

        // beziercounts are equal: if it's zero, we are done
        if(!mnBezierCount)
            return true;

        // beziercounts are equal and not zero; compare them
        OSL_ENSURE(0L != mpVectors, "Error: Bezier list needs to exist here(!)");
        OSL_ENSURE(0L != rPointList.mpVectors, "Error: Bezier list needs to exist here(!)");

        return (*mpVectors == *rPointList.mpVectors);
    }

    const Point& getPoint(sal_uInt32 nIndex) const
    {
        return maPoints[nIndex].getPoint();
    }

    void setPoint(sal_uInt32 nIndex, const Point& rValue)
    {
        maPoints[nIndex].setPoint(rValue);
    }

    const Vector& getBackwardVector(sal_uInt32 nIndex) const
    {
        if(mpVectors)
            return ((*mpVectors)[nIndex]).getBackwardVector();
        else
            return Vector::getEmptyVector();
    }

    void setBackwardVector(sal_uInt32 nIndex, const Vector& rValue)
    {
        if(mpVectors)
        {
            LocalSimpleBezierEntry& rDest = (*mpVectors)[nIndex];
            bool bBezierNeededBefore(rDest.isBezierNeeded());
            ((*mpVectors)[nIndex]).setBackwardVector(rValue);
            bool bBezierNeededAfter(rDest.isBezierNeeded());

            if(bBezierNeededBefore != bBezierNeededAfter)
            {
                if(bBezierNeededAfter)
                    mnBezierCount++;
                else
                    mnBezierCount--;
            }
        }
        else
        {
            bool bEmptyVector(rValue == Vector::getEmptyVector());

            if(bEmptyVector)
                return;

            mpVectors = new SimpleBezierVector(maPoints.size());
            ((*mpVectors)[nIndex]).setBackwardVector(rValue);
            mnBezierCount++;
        }
    }

    const Vector& getForwardVector(sal_uInt32 nIndex) const
    {
        if(mpVectors)
            return ((*mpVectors)[nIndex]).getForwardVector();
        else
            return Vector::getEmptyVector();
    }

    void setForwardVector(sal_uInt32 nIndex, const Vector& rValue)
    {
        if(mpVectors)
        {
            LocalSimpleBezierEntry& rDest = (*mpVectors)[nIndex];
            bool bBezierNeededBefore(rDest.isBezierNeeded());
            ((*mpVectors)[nIndex]).setForwardVector(rValue);
            bool bBezierNeededAfter(rDest.isBezierNeeded());

            if(bBezierNeededBefore != bBezierNeededAfter)
            {
                if(bBezierNeededAfter)
                    mnBezierCount++;
                else
                    mnBezierCount--;
            }
        }
        else
        {
            bool bEmptyVector(rValue == Vector::getEmptyVector());

            if(bEmptyVector)
                return;

            mpVectors = new SimpleBezierVector(maPoints.size());
            ((*mpVectors)[nIndex]).setForwardVector(rValue);
            mnBezierCount++;
        }
    }

    void insert(sal_uInt32 nIndex, const Point& rPoint, sal_uInt32 nCount)
    {
        if(nCount)
        {
            // maybe vectors are not needed anymore, try to reduce memory footprint
            implTryToReduceToPointVector();

            // add nCount copies of rPoint
            {
                LocalSimplePointEntry aNode(rPoint);
                SimplePointVector::iterator aIndex(maPoints.begin());
                aIndex += nIndex;
                maPoints.insert(aIndex, nCount, aNode);
            }

            // add nCount empty entries to keep indices synchronized
            if(mpVectors)
            {
                LocalSimpleBezierEntry aNode;
                SimpleBezierVector::iterator aIndex(mpVectors->begin());
                aIndex += nIndex;
                mpVectors->insert(aIndex, nCount, aNode);
            }
        }
    }

    void insert(sal_uInt32 nIndex, const PolygonPointList& rSource)
    {
        const sal_uInt32 nCount(rSource.maPoints.size());

        if(nCount)
        {
            // instert point data
            {
                SimplePointVector::iterator aIndex(maPoints.begin());
                aIndex += nIndex;

                SimplePointVector::const_iterator aStart(rSource.maPoints.begin());
                SimplePointVector::const_iterator aEnd(rSource.maPoints.end());

                maPoints.insert(aIndex, aStart, aEnd);
            }

            // insert bezier data
            if(rSource.mpVectors && rSource.mnBezierCount)
            {
                SimpleBezierVector::iterator aIndex(mpVectors->begin());
                aIndex += nIndex;

                SimpleBezierVector::iterator aStart(rSource.mpVectors->begin());
                SimpleBezierVector::iterator aEnd(rSource.mpVectors->end());

                if(!mpVectors)
                {
                    mpVectors = new SimpleBezierVector(maPoints.size() - nCount);
                }

                mpVectors->insert(aIndex, aStart, aEnd);

                mnBezierCount += rSource.mnBezierCount;
            }
            else
            {
                // maybe vectors are not needed anymore, try to reduce memory footprint
                implTryToReduceToPointVector();

                // add nCount empty entries to keep indices synchronized
                if(mpVectors)
                {
                    LocalSimpleBezierEntry aNode;
                    SimpleBezierVector::iterator aIndex(mpVectors->begin());
                    aIndex += nIndex;
                    mpVectors->insert(aIndex, nCount, aNode);
                }
            }
        }
    }

    void remove(sal_uInt32 nIndex, sal_uInt32 nCount)
    {
        if(nCount)
        {
            // maybe vectors are not needed anymore, try to reduce memory footprint
            implTryToReduceToPointVector();

            // remove point data
            {
                SimplePointVector::iterator aStart(maPoints.begin());
                aStart += nIndex;
                const SimplePointVector::iterator aEnd(aStart + nCount);

                maPoints.erase(aStart, aEnd);
            }

            // remove bezier data
            if(mpVectors)
            {
                SimpleBezierVector::iterator aStart(mpVectors->begin());
                aStart += nIndex;
                const SimpleBezierVector::iterator aEnd(aStart + nCount);

                // take care for correct mnBezierCount BEFORE erase
                if(mnBezierCount)
                {
                    SimpleBezierVector::iterator aTestIter(aStart);

                    for( ; mnBezierCount && aTestIter != aEnd; ++aTestIter)
                    {
                        if(aTestIter->isBezierNeeded())
                            mnBezierCount--;
                    }
                }

                if(mnBezierCount)
                {
                    // erase nodes
                    mpVectors->erase(aStart, aEnd);
                }
                else
                {
                    // try to reduce, maybe 0L == mnBezierCount
                    implTryToReduceToPointVector();
                }
            }
        }
    }

    void flip()
    {
        if(maPoints.size() > 1)
        {
            // maybe vectors are not needed anymore, try to reduce memory footprint
            implTryToReduceToPointVector();

            // calculate half size
            const sal_uInt32 nHalfSize(maPoints.size() >> 1L);

            // flip point data
            {
                SimplePointVector::iterator aStart(maPoints.begin());
                SimplePointVector::iterator aEnd(maPoints.end());

                for(sal_uInt32 a(0); a < nHalfSize; a++)
                {
                    LocalSimplePointEntry aTemp = *aStart;
                    *aStart++ = *aEnd;
                    *aEnd-- = aTemp;
                }
            }

            // flip bezier data
            if(mpVectors)
            {
                SimpleBezierVector::iterator aStart(mpVectors->begin());
                SimpleBezierVector::iterator aEnd(mpVectors->end());

                for(sal_uInt32 a(0); a < nHalfSize; a++)
                {
                    LocalSimpleBezierEntry aTemp = *aStart;
                    aTemp.doInvertForFlip();
                    *aStart = *aEnd;
                    aStart->doInvertForFlip();
                    aStart++;
                    *aEnd-- = aTemp;
                }

                // also flip vectors of middle point (if existing)
                if(maPoints.size() % 2)
                {
                    (*mpVectors)[nHalfSize].doInvertForFlip();
                }
            }
        }
    }
};

//////////////////////////////////////////////////////////////////////////////

#endif _POLYGON_POINT_HXX