xref: /aoo42x/main/basegfx/source/polygon/b2dpolypolygonrasterconverter.cxx (revision 09dbbe93)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_basegfx.hxx"

#include <basegfx/polygon/b2dpolypolygonrasterconverter.hxx>

#include <basegfx/numeric/ftools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>

#include <boost/mem_fn.hpp>

#include <algorithm>

namespace basegfx
{
	class radixSort {

		//! public interface
		public:

			//! default constructor
			radixSort( void );

			//! destructor
			~radixSort( void );

			bool sort( const float *pInput, sal_uInt32 nNumElements, sal_uInt32 dwStride );

			inline sal_uInt32 *indices( void ) const { return m_indices1; }

		//! private attributes
		private:

			// current size of index list
			sal_uInt32 m_current_size;

			// last known size of index list
			sal_uInt32 m_previous_size;

			// index lists
			sal_uInt32 *m_indices1;
			sal_uInt32 *m_indices2;

			sal_uInt32 m_counter[256*4];
			sal_uInt32 m_offset[256];

		//! private methods
		private:

			bool resize( sal_uInt32 nNumElements );
			inline void reset_indices( void );
			bool prepareCounters( const float *pInput, sal_uInt32 nNumElements, sal_uInt32 dwStride );
	};

	inline radixSort::radixSort( void ) {

		m_indices1 = NULL;
		m_indices2 = NULL;
		m_current_size = 0;
		m_previous_size = 0;

		reset_indices();
	}

	inline radixSort::~radixSort( void ) {

		delete [] m_indices2;
		delete [] m_indices1;
	}

	bool radixSort::resize( sal_uInt32 nNumElements ) {

		if(nNumElements==m_previous_size)
			return true;

		if(nNumElements > m_current_size) {

			// release index lists
			if(m_indices2)
				delete [] m_indices2;
			if(m_indices1)
				delete [] m_indices1;

			// allocate new index lists
			m_indices1 = new sal_uInt32[nNumElements];
			m_indices2 = new sal_uInt32[nNumElements];

			// check for out of memory situation
            if(!m_indices1 || !m_indices2) {
				delete [] m_indices1;
				delete [] m_indices2;
				m_indices1 = NULL;
				m_indices2 = NULL;
				m_current_size = 0;
				return false;
			}

			m_current_size = nNumElements;
		}

		m_previous_size = nNumElements;

		// initialize indices
		reset_indices();

		return true;
	}

	inline void radixSort::reset_indices( void ) {

		for(sal_uInt32 i=0;i<m_current_size;i++)
			m_indices1[i] = i;
	}

	bool radixSort::prepareCounters( const float *pInput, sal_uInt32 nNumElements, sal_uInt32 dwStride ) {

		// clear counters
		sal_uInt32 *ptr = m_counter;
		for(int i=0; i<64; ++i)
        {
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
			*ptr++ = 0;
		}

		// prepare pointers to relevant memory addresses
		sal_uInt8 *p = (sal_uInt8*)pInput;
		sal_uInt8 *pe = p+(nNumElements*dwStride);
		sal_uInt32 *h0= &m_counter[0];
		sal_uInt32 *h1= &m_counter[256];
		sal_uInt32 *h2= &m_counter[512];
		sal_uInt32 *h3= &m_counter[768];

		sal_uInt32 *Indices = m_indices1;
		float previous_value = *(float *)(((sal_uInt8 *)pInput)+(m_indices1[0]*dwStride));
		bool bSorted = true;
		while(p!=pe) {
			float value = *(float *)(((sal_uInt8 *)pInput)+((*Indices++)*dwStride));
			if(value<previous_value)	{
				bSorted = false;
				break;
			}
			previous_value = value;
			h0[*p++]++;
			h1[*p++]++;
			h2[*p++]++;
			h3[*p++]++;
			p += dwStride-4;
		}
		if(bSorted)
			return true;
		while(p!=pe) {
			h0[*p++]++;
			h1[*p++]++;
			h2[*p++]++;
			h3[*p++]++;
			p += dwStride-4;
		}
		return false;
	}

	bool radixSort::sort( const float *pInput, sal_uInt32 nNumElements, sal_uInt32 dwStride ) {

		if(!(pInput))
			return false;
		if(!(nNumElements))
			return false;
		if(!(resize(nNumElements)))
			return false;

		// prepare radix counters, return if already sorted
		if(prepareCounters(pInput,nNumElements,dwStride))
			return true;

		// count number of negative values
		sal_uInt32 num_negatives = 0;
		sal_uInt32 *h3= &m_counter[768];
		for(sal_uInt32 i=128;i<256;i++)
			num_negatives += h3[i];

		// perform passes, one for each byte
		for(sal_uInt32 j=0;j<4;j++) {

			// ignore this pass if all values have the same byte
			bool bRun = true;
			sal_uInt32 *current_counter = &m_counter[j<<8];
			sal_uInt8 unique_value = *(((sal_uInt8*)pInput)+j);
			if(current_counter[unique_value]==nNumElements)
				bRun=false;

			// does the incoming byte contain the sign bit?
			sal_uInt32 i;
			if(j!=3) {
				if(bRun) {
					m_offset[0] = 0;
					for(i=1;i<256;i++)
						m_offset[i] = m_offset[i-1] + current_counter[i-1];
					sal_uInt8 *InputBytes = (sal_uInt8 *)pInput;
					sal_uInt32 *Indices = m_indices1;
					sal_uInt32 *IndicesEnd = &m_indices1[nNumElements];
					InputBytes += j;
					while(Indices!=IndicesEnd) {
						sal_uInt32 id = *Indices++;
						m_indices2[m_offset[InputBytes[id*dwStride]]++] = id;
					}
					sal_uInt32 *Tmp	= m_indices1;
					m_indices1 = m_indices2;
					m_indices2 = Tmp;
				}
			}
			else {
				if(bRun) {
					m_offset[0] = num_negatives;
					for(i=1;i<128;i++)
						m_offset[i] = m_offset[i-1] + current_counter[i-1];
					m_offset[255] = 0;
					for(i=0;i<127;i++)
						m_offset[254-i] = m_offset[255-i] + current_counter[255-i];
					for(i=128;i<256;i++)
						m_offset[i] += current_counter[i];
					for(i=0;i<nNumElements;i++) {
						sal_uInt32 Radix = (*(sal_uInt32 *)(((sal_uInt8 *)pInput)+(m_indices1[i]*dwStride)))>>24;
						if(Radix<128) m_indices2[m_offset[Radix]++] = m_indices1[i];
						else m_indices2[--m_offset[Radix]] = m_indices1[i];
					}
					sal_uInt32 *Tmp	= m_indices1;
					m_indices1 = m_indices2;
					m_indices2 = Tmp;
				}
				else {
					if(unique_value>=128) {
						for(i=0;i<nNumElements;i++)
							m_indices2[i] = m_indices1[nNumElements-i-1];
						sal_uInt32 *Tmp	= m_indices1;
						m_indices1 = m_indices2;
						m_indices2 = Tmp;
					}
				}
			}
		}

		return true;
	}

	//************************************************************
	// Internal vertex storage of B2DPolyPolygonRasterConverter
	//************************************************************

    inline B2DPolyPolygonRasterConverter::Vertex::Vertex() :
        aP1(),
        aP2(),
        bDownwards( true )
    {
    }

    inline B2DPolyPolygonRasterConverter::Vertex::Vertex( const B2DPoint& rP1, const B2DPoint& rP2, bool bDown ) :
        aP1( rP1 ),
        aP2( rP2 ),
        bDownwards( bDown )
    {
    }


	//************************************************************
	// Helper class for holding horizontal line segments during raster
	// conversion
	//************************************************************

	namespace
    {
        class ImplLineNode
        {
		public:
            sal_Int32	mnYCounter;
            float		mfXPos;
            float		mfXDelta;
            bool		mbDownwards;

        public:
            /**rP1 and rP2 must not have equal y values, when rounded
               to integer!
            */
            ImplLineNode(const B2DPoint& rP1, const B2DPoint& rP2, bool bDown) :
                mnYCounter( fround(rP2.getY()) - fround(rP1.getY()) ),
                mfXPos( (float)(rP1.getX()) ),
                mfXDelta((float) ((rP2.getX() - rP1.getX()) / mnYCounter) ),
                mbDownwards( bDown )
            {
            }

            /// get current x position
            const float& getXPos() const
            {
                return mfXPos;
            }

            /// returns true, if line ends on this Y value
            float nextLine()
            {
                if(mnYCounter>=0)
                {
                    // go one step in Y
                    mfXPos += mfXDelta;
                    --mnYCounter;
					return mfXDelta;
                }

				return 0.0f;
            }

            bool isEnded()
            {
                return mnYCounter<=0;
            }

            bool isDownwards()
            {
                return mbDownwards;
            }
        };
    }

    typedef ::std::vector<ImplLineNode> VectorOfLineNodes;


	//************************************************************
	//   Base2D PolyPolygon Raster Converter (Rasterizer)
	//************************************************************

    namespace
    {
        struct VertexComparator
        {
            bool operator()( const B2DPolyPolygonRasterConverter::Vertex& rLHS,
                             const B2DPolyPolygonRasterConverter::Vertex& rRHS )
            {
                return rLHS.aP1.getX() < rRHS.aP1.getX();
            }
        };
    }

    void B2DPolyPolygonRasterConverter::init()
    {
        if(!maPolyPolyRectangle.isEmpty())
        {
            const sal_Int32	nMinY( fround(maPolyPolyRectangle.getMinY()) );
            const sal_Int32 nScanlines(fround(maPolyPolyRectangle.getMaxY()) - nMinY);

            maScanlines.resize( nScanlines+1 );

            // add all polygons
            for( sal_uInt32 i(0), nCount(maPolyPolygon.count());
                 i < nCount;
                 ++i )
            {
                // add all vertices
                const B2DPolygon& rPoly( maPolyPolygon.getB2DPolygon(i) );
                for( sal_uInt32 k(0), nVertices(rPoly.count());
                     k<nVertices;
                     ++k )
                {
                    const B2DPoint& rP1( rPoly.getB2DPoint(k) );
                    const B2DPoint& rP2( rPoly.getB2DPoint( (k + 1) % nVertices ) );

                    const sal_Int32 nVertexYP1( fround(rP1.getY()) );
                    const sal_Int32 nVertexYP2( fround(rP2.getY()) );

                    // insert only vertices which are not strictly
                    // horizontal. Note that the ImplLineNode relies on
                    // this.
                    if(nVertexYP1 != nVertexYP2)
                    {
                        if( nVertexYP2 < nVertexYP1 )
                        {
                            const sal_Int32 nStartScanline(nVertexYP2 - nMinY);

                            // swap edges
                            maScanlines[ nStartScanline ].push_back( Vertex(rP2, rP1, false) );
                        }
                        else
                        {
                            const sal_Int32 nStartScanline(nVertexYP1 - nMinY);

                            maScanlines[ nStartScanline ].push_back( Vertex(rP1, rP2, true) );
                        }
                    }
                }
            }

            // now sort all scanlines, with increasing x coordinates
            VectorOfVertexVectors::iterator aIter( maScanlines.begin() );
            VectorOfVertexVectors::iterator aEnd( maScanlines.end() );
            while( aIter != aEnd )
            {
                ::std::sort( aIter->begin(),
                             aIter->end(),
                             VertexComparator() );
                ++aIter;
            }
        }
    }

    B2DPolyPolygonRasterConverter::B2DPolyPolygonRasterConverter( const B2DPolyPolygon& rPolyPoly ) :
        maPolyPolygon( rPolyPoly ),
        maPolyPolyRectangle( tools::getRange( rPolyPoly ) ),
        maScanlines()
    {
        init();
    }

    namespace
    {
        B2DRectangle getCombinedBounds( const B2DPolyPolygon& rPolyPolyRaster,
                                        const B2DRectangle&   rRasterArea )
        {
            B2DRectangle aRect( tools::getRange( rPolyPolyRaster ) );
            aRect.expand( rRasterArea );

            return aRect;
        }
    }

    B2DPolyPolygonRasterConverter::B2DPolyPolygonRasterConverter( const B2DPolyPolygon& rPolyPolyRaster,
                                                                  const B2DRectangle&   rRasterArea ) :
        maPolyPolygon( rPolyPolyRaster ),
        maPolyPolyRectangle(
            getCombinedBounds( rPolyPolyRaster,
                               rRasterArea ) ),
        maScanlines()
    {
        init();
    }

    B2DPolyPolygonRasterConverter::~B2DPolyPolygonRasterConverter()
    {
    }

    namespace
    {
        class LineNodeGenerator
        {
        public:
            LineNodeGenerator( VectorOfLineNodes& rActiveVertices ) :
                mrActiveVertices( rActiveVertices )
            {
            }

            void operator()( const B2DPolyPolygonRasterConverter::Vertex& rVertex )
            {
                mrActiveVertices.push_back( ImplLineNode(rVertex.aP1,
                                                         rVertex.aP2,
                                                         rVertex.bDownwards) );
            }

        private:
            VectorOfLineNodes& mrActiveVertices;
        };

        struct LineNodeComparator
        {
            bool operator()( const ImplLineNode& rLHS, const ImplLineNode& rRHS )
            {
                return rLHS.getXPos() < rRHS.getXPos();
            }
        };
    }

    void B2DPolyPolygonRasterConverter::rasterConvert( FillRule eFillRule )
    {
        if( maScanlines.empty() )
            return; // no scanlines at all -> bail out

        const sal_Int32	nMinY( fround(maPolyPolyRectangle.getMinY()) );
        const sal_Int32 nScanlines(fround(maPolyPolyRectangle.getMaxY()) - nMinY);

        // Vector of currently active vertices. A vertex is active, if
        // it crosses or touches the current scanline.
        VectorOfLineNodes	aActiveVertices;

		// mickey's optimized version...
		radixSort   rs;
		std::size_t nb(0);
        std::size_t nb_previous(0);
		bool        bSort(false);

        // process each scanline
        for( sal_Int32 y(0); y <= nScanlines; ++y )
        {
            // add vertices which start at current scanline into
            // active vertex vector
            ::std::for_each( maScanlines[y].begin(),
                             maScanlines[y].end(),
                             LineNodeGenerator( aActiveVertices ) );
			nb = aActiveVertices.size();
			if(nb != nb_previous)
            {
				nb_previous = nb;
				bSort = true;
			}

            // sort with increasing X
			if(bSort)
            {
				bSort = false;

                if( nb )
                {
                    rs.sort(&aActiveVertices[0].mfXPos,
                            nb,
                            sizeof(ImplLineNode));
                }
			}

            const std::size_t nLen( nb );
            if( !nLen )
            {
                // empty scanline - call derived with an 'off' span
                // for the full width
                span( maPolyPolyRectangle.getMinX(),
                      maPolyPolyRectangle.getMaxX(),
                      nMinY + y,
                      false );
            }
            else
            {
                const sal_Int32 nCurrY( nMinY + y );

                // scanline not empty - forward all scans to derived,
                // according to selected fill rule

                // TODO(P1): Maybe allow these 'off' span calls to be
                // switched off (or all 'on' span calls, depending on
                // use case scenario)

				// sorting didn't change the order of the elements
				// in memory but prepared a list of indices in sorted order.
				// thus we now process the nodes with an additional indirection.
				sal_uInt32 *sorted = rs.indices();

                // call derived with 'off' span for everything left of first active span
                if( aActiveVertices[sorted[0]].getXPos() > maPolyPolyRectangle.getMinX() )
                {
                    span( maPolyPolyRectangle.getMinX(),
                          aActiveVertices[sorted[0]].getXPos(),
                          nCurrY,
                          false );
                }

                switch( eFillRule )
                {
                    default:
                        OSL_ENSURE(false,
                                   "B2DPolyPolygonRasterConverter::rasterConvert(): Unexpected fill rule");
                        return;

                    case FillRule_EVEN_ODD:
                        // process each span in current scanline, with
                        // even-odd fill rule
                        for( ::std::size_t i(0), nLength(aActiveVertices.size());
                             i+1 < nLength;
                             ++i )
                        {
							sal_uInt32 nIndex = sorted[i];
							sal_uInt32 nNextIndex = sorted[i+1];
                            span( aActiveVertices[nIndex].getXPos(),
                                  aActiveVertices[nNextIndex].getXPos(),
                                  nCurrY,
                                  i % 2 == 0 );

                            float delta = aActiveVertices[nIndex].nextLine();
							if(delta > 0.0f)
                            {
								if(aActiveVertices[nIndex].getXPos() > aActiveVertices[nNextIndex].getXPos())
									bSort = true;
							}
							else if(delta < 0.0f)
                            {
								if(i)
                                {
									sal_uInt32 nPrevIndex = sorted[i-1];
									if(aActiveVertices[nIndex].getXPos() < aActiveVertices[nPrevIndex].getXPos())
										bSort = true;
								}
							}
                        }
                        break;

                    case FillRule_NONZERO_WINDING_NUMBER:
                        // process each span in current scanline, with
                        // non-zero winding numbe fill rule
                        sal_Int32 nWindingNumber(0);
                        for( ::std::size_t i(0), nLength(aActiveVertices.size());
                             i+1 < nLength;
                             ++i )
                        {
							sal_uInt32 nIndex = sorted[i];
							sal_uInt32 nNextIndex = sorted[i+1];
                            nWindingNumber += -1 + 2*aActiveVertices[nIndex].isDownwards();

                            span( aActiveVertices[nIndex].getXPos(),
                                  aActiveVertices[nNextIndex].getXPos(),
                                  nCurrY,
                                  nWindingNumber != 0 );

                            float delta = aActiveVertices[nIndex].nextLine();
							if(delta > 0.0f)
                            {
								if(aActiveVertices[nIndex].getXPos() > aActiveVertices[nNextIndex].getXPos())
									bSort = true;
							}
							else if(delta < 0.0f)
                            {
								if(i)
                                {
									sal_uInt32 nPrevIndex = sorted[i-1];
									if(aActiveVertices[nIndex].getXPos() < aActiveVertices[nPrevIndex].getXPos())
										bSort = true;
								}
							}
                        }
                        break;
                }

                // call derived with 'off' span for everything right of last active span
                if( aActiveVertices[sorted[nb-1]].getXPos()+1.0 < maPolyPolyRectangle.getMaxX() )
                {
                    span( aActiveVertices[sorted[nb-1]].getXPos()+1.0,
                          maPolyPolyRectangle.getMaxX(),
                          nCurrY,
                          false );
                }

                // also call nextLine on very last line node
				sal_uInt32 nIndex = sorted[nb-1];
                float delta = aActiveVertices[nIndex].nextLine();
				if(delta < 0.0f)
                {
					if(nb)
                    {
						sal_uInt32 nPrevIndex = sorted[nb-2];
						if(aActiveVertices[nIndex].getXPos() < aActiveVertices[nPrevIndex].getXPos())
							bSort = true;
					}
				}
            }

            // remove line nodes which have ended on the current scanline
            aActiveVertices.erase( ::std::remove_if( aActiveVertices.begin(),
                                                     aActiveVertices.end(),
                                                     ::boost::mem_fn( &ImplLineNode::isEnded ) ),
                                   aActiveVertices.end() );
			nb = aActiveVertices.size();
			if(nb != nb_previous)
            {
				nb_previous = nb;
				bSort = true;
			}
        }
	}
}
// eof