LCOV - code coverage report
Current view: top level - basegfx/test - boxclipper.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 188 188 100.0 %
Date: 2015-06-13 12:38:46 Functions: 22 22 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <sal/types.h>
      21             : #include <cppunit/TestAssert.h>
      22             : #include <cppunit/TestFixture.h>
      23             : #include <cppunit/extensions/HelperMacros.h>
      24             : 
      25             : #include <basegfx/matrix/b2dhommatrix.hxx>
      26             : #include <basegfx/curve/b2dcubicbezier.hxx>
      27             : #include <basegfx/curve/b2dbeziertools.hxx>
      28             : #include <basegfx/range/b2dpolyrange.hxx>
      29             : #include <basegfx/polygon/b2dpolygon.hxx>
      30             : #include <basegfx/polygon/b2dpolygontools.hxx>
      31             : #include <basegfx/polygon/b2dpolypolygontools.hxx>
      32             : #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
      33             : #include <basegfx/polygon/b2dpolygonclipper.hxx>
      34             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      35             : #include <basegfx/numeric/ftools.hxx>
      36             : #include <comphelper/random.hxx>
      37             : 
      38             : #include <boost/bind.hpp>
      39             : 
      40             : #include <boxclipper.hxx>
      41             : 
      42             : using namespace ::basegfx;
      43             : 
      44             : namespace basegfx2d
      45             : {
      46             : /// Gets a random ordinal [0,n)
      47        1280 : double getRandomOrdinal( const ::std::size_t n )
      48             : {
      49             :     // use this one when displaying polygons in OOo, which still sucks
      50             :     // great rocks when trying to import non-integer svg:d attributes
      51        1280 :     return comphelper::rng::uniform_size_distribution(0, n-1);
      52             : }
      53             : 
      54        1795 : inline bool compare(const B2DPoint& left, const B2DPoint& right)
      55             : {
      56        1795 :     return left.getX()<right.getX()
      57        1795 :         || (left.getX()==right.getX() && left.getY()<right.getY());
      58             : }
      59             : 
      60           9 : class boxclipper : public CppUnit::TestFixture
      61             : {
      62             : private:
      63             :     B2DPolyRange aDisjunctRanges;
      64             :     B2DPolyRange aEqualRanges;
      65             :     B2DPolyRange aIntersectionN;
      66             :     B2DPolyRange aIntersectionE;
      67             :     B2DPolyRange aIntersectionS;
      68             :     B2DPolyRange aIntersectionW;
      69             :     B2DPolyRange aIntersectionNE;
      70             :     B2DPolyRange aIntersectionSE;
      71             :     B2DPolyRange aIntersectionSW;
      72             :     B2DPolyRange aIntersectionNW;
      73             :     B2DPolyRange aRingIntersection;
      74             :     B2DPolyRange aRingIntersection2;
      75             :     B2DPolyRange aRingIntersectExtraStrip;
      76             :     B2DPolyRange aComplexIntersections;
      77             :     B2DPolyRange aRandomIntersections;
      78             : 
      79             : public:
      80             :     // initialise your test code values here.
      81           3 :     void setUp() SAL_OVERRIDE
      82             :     {
      83           3 :         B2DRange aCenter(100, 100, -100, -100);
      84           3 :         B2DRange aOffside(800, 800, 1000, 1000);
      85           3 :         B2DRange aNorth(100, 0, -100, -200);
      86           3 :         B2DRange aSouth(100, 200, -100, 0);
      87           3 :         B2DRange aEast(0, 100, 200, -100);
      88           3 :         B2DRange aWest(-200, 100, 0, -100);
      89           3 :         B2DRange aNorthEast(0, 0, 200, -200);
      90           3 :         B2DRange aSouthEast(0, 0, 200, 200);
      91           3 :         B2DRange aSouthWest(0, 0, -200, 200);
      92           3 :         B2DRange aNorthWest(0, 0, -200, -200);
      93             : 
      94           3 :         B2DRange aNorth2(-150, 50,  150,  350);
      95           3 :         B2DRange aSouth2(-150, -50, 150, -350);
      96           3 :         B2DRange aEast2 (50,  -150, 350,  150);
      97           3 :         B2DRange aWest2 (-50, -150,-350,  150);
      98             : 
      99           3 :         aDisjunctRanges.appendElement( aCenter, B2VectorOrientation::Negative );
     100           3 :         aDisjunctRanges.appendElement( aOffside, B2VectorOrientation::Negative );
     101             : 
     102           3 :         aEqualRanges.appendElement( aCenter, B2VectorOrientation::Negative );
     103           3 :         aEqualRanges.appendElement( aCenter, B2VectorOrientation::Negative );
     104             : 
     105           3 :         aIntersectionN.appendElement( aCenter, B2VectorOrientation::Negative );
     106           3 :         aIntersectionN.appendElement( aNorth, B2VectorOrientation::Negative );
     107             : 
     108           3 :         aIntersectionE.appendElement( aCenter, B2VectorOrientation::Negative );
     109           3 :         aIntersectionE.appendElement( aEast, B2VectorOrientation::Negative );
     110             : 
     111           3 :         aIntersectionS.appendElement( aCenter, B2VectorOrientation::Negative );
     112           3 :         aIntersectionS.appendElement( aSouth, B2VectorOrientation::Negative );
     113             : 
     114           3 :         aIntersectionW.appendElement( aCenter, B2VectorOrientation::Negative );
     115           3 :         aIntersectionW.appendElement( aWest, B2VectorOrientation::Negative );
     116             : 
     117           3 :         aIntersectionNE.appendElement( aCenter, B2VectorOrientation::Negative );
     118           3 :         aIntersectionNE.appendElement( aNorthEast, B2VectorOrientation::Negative );
     119             : 
     120           3 :         aIntersectionSE.appendElement( aCenter, B2VectorOrientation::Negative );
     121           3 :         aIntersectionSE.appendElement( aSouthEast, B2VectorOrientation::Negative );
     122             : 
     123           3 :         aIntersectionSW.appendElement( aCenter, B2VectorOrientation::Negative );
     124           3 :         aIntersectionSW.appendElement( aSouthWest, B2VectorOrientation::Negative );
     125             : 
     126           3 :         aIntersectionNW.appendElement( aCenter, B2VectorOrientation::Negative );
     127           3 :         aIntersectionNW.appendElement( aNorthWest, B2VectorOrientation::Negative );
     128             : 
     129           3 :         aRingIntersection.appendElement( aNorth2, B2VectorOrientation::Negative );
     130           3 :         aRingIntersection.appendElement( aEast2, B2VectorOrientation::Negative );
     131           3 :         aRingIntersection.appendElement( aSouth2, B2VectorOrientation::Negative );
     132             : 
     133           3 :         aRingIntersection2 = aRingIntersection;
     134           3 :         aRingIntersection2.appendElement( aWest2, B2VectorOrientation::Negative );
     135             : 
     136           3 :         aRingIntersectExtraStrip = aRingIntersection2;
     137             :         aRingIntersectExtraStrip.appendElement( B2DRange(0, -25, 200, 25),
     138           3 :                                                 B2VectorOrientation::Negative );
     139             : 
     140           3 :         aComplexIntersections.appendElement( aCenter, B2VectorOrientation::Negative );
     141           3 :         aComplexIntersections.appendElement( aOffside, B2VectorOrientation::Negative );
     142           3 :         aComplexIntersections.appendElement( aCenter, B2VectorOrientation::Negative );
     143           3 :         aComplexIntersections.appendElement( aNorth, B2VectorOrientation::Negative );
     144           3 :         aComplexIntersections.appendElement( aEast, B2VectorOrientation::Negative );
     145           3 :         aComplexIntersections.appendElement( aSouth, B2VectorOrientation::Negative );
     146           3 :         aComplexIntersections.appendElement( aWest, B2VectorOrientation::Negative );
     147           3 :         aComplexIntersections.appendElement( aNorthEast, B2VectorOrientation::Negative );
     148           3 :         aComplexIntersections.appendElement( aSouthEast, B2VectorOrientation::Negative );
     149           3 :         aComplexIntersections.appendElement( aSouthWest, B2VectorOrientation::Negative );
     150           3 :         aComplexIntersections.appendElement( aNorthWest, B2VectorOrientation::Negative );
     151             : 
     152             : #ifdef GENERATE_RANDOM
     153             :         for( int i=0; i<800; ++i )
     154             :         {
     155             :             B2DRange aRandomRange(
     156             :                 getRandomOrdinal( 1000 ),
     157             :                 getRandomOrdinal( 1000 ),
     158             :                 getRandomOrdinal( 1000 ),
     159             :                 getRandomOrdinal( 1000 ) );
     160             : 
     161             :             aRandomIntersections.appendElement( aRandomRange, B2VectorOrientation::Negative );
     162             :         }
     163             : #else
     164           3 :         const char* randomSvg="m394 783h404v57h-404zm-197-505h571v576h-571zm356-634h75v200h-75zm-40-113h403v588h-403zm93-811h111v494h-111zm-364-619h562v121h-562zm-134-8h292v27h-292zm110 356h621v486h-621zm78-386h228v25h-228zm475-345h201v201h-201zm-2-93h122v126h-122zm-417-243h567v524h-567zm-266-738h863v456h-863zm262-333h315v698h-315zm-328-826h43v393h-43zm830-219h120v664h-120zm-311-636h221v109h-221zm-500 137h628v19h-628zm681-94h211v493h-211zm-366-646h384v355h-384zm-189-199h715v247h-715zm165-459h563v601h-563zm258-479h98v606h-98zm270-517h65v218h-65zm-44-259h96v286h-96zm-599-202h705v468h-705zm216-803h450v494h-450zm-150-22h26v167h-26zm-55-599h50v260h-50zm190-278h490v387h-490zm-290-453h634v392h-634zm257 189h552v300h-552zm-151-690h136v455h-136zm12-597h488v432h-488zm501-459h48v39h-48zm-224-112h429v22h-429zm-281 102h492v621h-492zm519-158h208v17h-208zm-681-563h56v427h-56zm126-451h615v392h-615zm-47-410h598v522h-598zm-32 316h79v110h-79zm-71-129h18v127h-18zm126-993h743v589h-743zm211-430h428v750h-428zm61-554h100v220h-100zm-353-49h658v157h-658zm778-383h115v272h-115zm-249-541h119v712h-119zm203 86h94v40h-94z";
     165           3 :         B2DPolyPolygon randomPoly;
     166             :         tools::importFromSvgD(
     167             :             randomPoly,
     168           3 :             OUString::createFromAscii(randomSvg), false, 0);
     169             :         std::for_each(randomPoly.begin(),
     170             :                       randomPoly.end(),
     171             :                       boost::bind(
     172             :              &B2DPolyRange::appendElement,
     173             :                           boost::ref(aRandomIntersections),
     174             :                           boost::bind(
     175             :                  &B2DPolygon::getB2DRange,
     176             :                               _1),
     177             :                           B2VectorOrientation::Negative,
     178           3 :                           1));
     179             : #endif
     180           3 :     }
     181             : 
     182           3 :     void tearDown() SAL_OVERRIDE
     183             :     {
     184           3 :     }
     185             : 
     186          50 :     B2DPolyPolygon normalizePoly( const B2DPolyPolygon& rPoly )
     187             :     {
     188          50 :         B2DPolyPolygon aRes;
     189         284 :         for( sal_uInt32 i=0; i<rPoly.count(); ++i )
     190             :         {
     191         234 :             B2DPolygon aTmp=rPoly.getB2DPolygon(i);
     192         234 :             if( B2VectorOrientation::Negative == tools::getOrientation(aTmp) )
     193         218 :                 aTmp.flip();
     194             : 
     195         234 :             aTmp=tools::removeNeutralPoints(aTmp);
     196         468 :             std::vector<B2DPoint> aTmp2(aTmp.count());
     197        1434 :             for(sal_uInt32 j=0; j<aTmp.count(); ++j)
     198        1200 :                 aTmp2[j] = aTmp.getB2DPoint(j);
     199             : 
     200         234 :             std::vector<B2DPoint>::iterator pSmallest=aTmp2.end();
     201        1434 :             for(std::vector<B2DPoint>::iterator pCurr=aTmp2.begin(); pCurr!=aTmp2.end(); ++pCurr)
     202             :             {
     203        1200 :                 if( pSmallest == aTmp2.end() || compare(*pCurr, *pSmallest) )
     204             :                 {
     205         466 :                     pSmallest=pCurr;
     206             :                 }
     207             :             }
     208             : 
     209         234 :             if( pSmallest != aTmp2.end() )
     210         228 :                 std::rotate(aTmp2.begin(),pSmallest,aTmp2.end());
     211             : 
     212         234 :             aTmp.clear();
     213        1434 :             for(std::vector<B2DPoint>::iterator pCurr=aTmp2.begin(); pCurr!=aTmp2.end(); ++pCurr)
     214        1200 :                 aTmp.append(*pCurr);
     215             : 
     216         234 :             aRes.append(aTmp);
     217         234 :         }
     218             : 
     219             :         // boxclipper & generic clipper disagree slightly on area-less
     220             :         // polygons (one or two points only)
     221          50 :         aRes = tools::stripNeutralPolygons(aRes);
     222             : 
     223             :         // now, sort all polygons with increasing 0th point
     224             :         std::sort(aRes.begin(),
     225             :                   aRes.end(),
     226             :                   boost::bind(
     227             :                       &compare,
     228             :                       boost::bind(
     229             :                           &B2DPolygon::getB2DPoint,
     230             :                           _1,0),
     231             :                       boost::bind(
     232             :                           &B2DPolygon::getB2DPoint,
     233          50 :                           _2,0)));
     234             : 
     235          50 :         return aRes;
     236             :     }
     237             : 
     238          15 :     void verifyPoly(const char* sName, const char* sSvg, const B2DPolyRange& toTest)
     239             :     {
     240          15 :         B2DPolyPolygon aTmp1;
     241          30 :         CPPUNIT_ASSERT_MESSAGE(sName,
     242             :                                tools::importFromSvgD(
     243          15 :                                    aTmp1, OUString::createFromAscii(sSvg), false, 0));
     244             : 
     245             :         const OUString aSvg=
     246          30 :             tools::exportToSvgD(toTest.solveCrossovers(), true, true, false);
     247          30 :         B2DPolyPolygon aTmp2;
     248          30 :         CPPUNIT_ASSERT_MESSAGE(sName,
     249             :                                tools::importFromSvgD(
     250          15 :                                    aTmp2, aSvg, false, 0));
     251             : 
     252          30 :         CPPUNIT_ASSERT_MESSAGE(
     253             :             sName,
     254          30 :             normalizePoly(aTmp2) == normalizePoly(aTmp1));
     255          15 :     }
     256             : 
     257           1 :     void verifyPoly()
     258             :     {
     259           1 :         const char* disjunct="m-100-100v200h200v-200zm900 900v200h200v-200z";
     260           1 :         const char* equal="m-100-100v200h200v-200zm200 0h-200v200h200v-200z";
     261           1 :         const char* intersectionN="m-100-100v100h200v-100zm200 0v-100h-200v100 200h200v-200z";
     262           1 :         const char* intersectionE="m0-100v200h100v-200zm0 0h-100v200h100 200v-200z";
     263           1 :         const char* intersectionS="m-100 0v100h200v-100zm0-100v200 100h200v-100-200z";
     264           1 :         const char* intersectionW="m-100-100v200h100v-200zm0 0h-100v200h100 200v-200z";
     265           1 :         const char* intersectionNE="m0-100v100h100v-100zm0-100v100h-100v200h200v-100h100v-200z";
     266           1 :         const char* intersectionSE="m0 0v100h100v-100zm100 0v-100h-200v200h100v100h200v-200z";
     267           1 :         const char* intersectionSW="m-100 0v100h100v-100zm0-100v100h-100v200h200v-100h100v-200z";
     268           1 :         const char* intersectionNW="m-100-100v100h100v-100zm100 0v-100h-200v200h100v100h200v-200z";
     269           1 :         const char* ringIntersection="m50-150v100h100v-100zm0 200v100h100v-100zm100-200v-200h-300v300h200v100h-200v300h300v-200h200v-300z";
     270             :         const char* ringIntersection2="m-150 50v100h100v-100zm0-200v100h100v-100zm100 200v-100h100v100z"
     271           1 :                                       "m100-200v100h100v-100zm0 200v100h100v-100zm100-200v-200h-300v200h-200v300h200v200h300v-200h200v-300z";
     272             :         const char* ringIntersectExtraStrip="m-150 50v100h100v-100zm0-200v100h100v-100zm100 200v-100h100v25h-50v50h50v25z"
     273             :                                             "m100-200v100h100v-100zm0 200v100h100v-100zm0-75v50h150v-50z"
     274           1 :                                             "m100-125v-200h-300v200h-200v300h200v200h300v-200h200v-300z";
     275             :         const char* complexIntersections="m0 0zm0 0zm0 0zm0 0v-100 100h-100 100v100-100h100zm0 0v-100 100h-100 100v100-100h100z"
     276             :                                          "m100 0v-100h-100-100v100 100h100 100v-100zm0 0v-100h-100-100v100 100h100 100v-100z"
     277             :                                          "m0 0v-100h-100v-100 100h-100v100h-100 100v100h100v100-100h100v-100h100z"
     278             :                                          "m0-100v-100h-100-100v100h-100v100 100h100v100h100 100v-100h100v-100-100z"
     279           1 :                                          "m100 0v-100h-200-100-100v100 200 100h100 100 200v-100-200zm600 900v200h200v-200z";
     280             :         const char* randomIntersections="m20-4515v393h43v-393zm34-8690v127h18v-127zm24 674v427h56v-427zm126-451v16-16z"
     281             :                                          "m22 3470v260h50v-260zm55 599v167h26v-167zm-49-1831v455h136v-455z"
     282             :                                          "m10 8845v19h158v-19zm54-38v25h228v-25zm156-13245v108h100v-108z"
     283             :                                          "m101 14826v200h75v-200zm-205-3000v365h315v-365zm-309-1877v19h628v-19z"
     284             :                                          "m549-1398v127h98v-127zm18 5351v215h111v-215zm-362-10061v152h488v-152z"
     285             :                                          "m488 0v-469h-492v621h4v280h488v-432zm-378 5368v48h384v-48zm274-10182v712h119v-712z"
     286             :                                          "m-424 3173v-94h-47v110h47v96h551v-112zm-105-2249v157h353v112h100v-112h205v-157z"
     287             :                                          "m284 5177v203h377v-203zm337 4727v66h40v-66zm-326 6110v57h374v-57zm351-12583v39h48v-39z"
     288             :                                          "m23 12583v-505h-571v576h571v-14h30v-57zm-368-2682v-8h-292v27h134v102h562v-121z"
     289             :                                          "m-9-12299v320h428v-320zm364 1216v-410h-598v316h-32v110h32v96h47v280h615v-392z"
     290             :                                          "m-537 11431v486h388v279h111v-279h122v-486zm112-4621v142h550v-142zm101-2719v494h450v-494z"
     291             :                                          "m340 6609v33h120v-33zm-85-4349v-479h-98v479h-258v459h-165v247h189v307h384v-307h142v-105h13v-601z"
     292             :                                          "m-270-3159v36h490v-36zm442 2163v7h52v-7zm-345 7158v588h403v-588zm378-1813v-93h-122v126h2v155h148v-188z"
     293             :                                          "m19-5345v-259h-96v266h44v20h52v-20h10v-7zm-91-6571v-430h-428v430h-211v589h743v-589z"
     294             :                                          "m101 6571v-461h-705v468h599v20h44v191h65v-218zm-89-8442v40h94v-40zm-71 10742v-43h-221v109h181v427h211v-493z"
     295             :                                          "m0-4727v-189h-634v392h257v97h33v351h490v-351h29v-300zm-97 6698v-333h-315v333h-262v456h863v-456z"
     296             :                                          "m-142-8556v22h429v-22zm238-56v17h208v-17zm91 7234v664h120v-664zm69 2452v-336h-567v524h419v13h201v-201z"
     297           1 :                                          "m-42-13332v272h115v-272z";
     298             : 
     299           1 :         verifyPoly("disjunct", disjunct, aDisjunctRanges);
     300           1 :         verifyPoly("equal", equal, aEqualRanges);
     301           1 :         verifyPoly("intersectionN", intersectionN, aIntersectionN);
     302           1 :         verifyPoly("intersectionE", intersectionE, aIntersectionE);
     303           1 :         verifyPoly("intersectionS", intersectionS, aIntersectionS);
     304           1 :         verifyPoly("intersectionW", intersectionW, aIntersectionW);
     305           1 :         verifyPoly("intersectionNE", intersectionNE, aIntersectionNE);
     306           1 :         verifyPoly("intersectionSE", intersectionSE, aIntersectionSE);
     307           1 :         verifyPoly("intersectionSW", intersectionSW, aIntersectionSW);
     308           1 :         verifyPoly("intersectionNW", intersectionNW, aIntersectionNW);
     309           1 :         verifyPoly("ringIntersection", ringIntersection, aRingIntersection);
     310           1 :         verifyPoly("ringIntersection2", ringIntersection2, aRingIntersection2);
     311           1 :         verifyPoly("ringIntersectExtraStrip", ringIntersectExtraStrip, aRingIntersectExtraStrip);
     312           1 :         verifyPoly("complexIntersections", complexIntersections, aComplexIntersections);
     313           1 :         verifyPoly("randomIntersections", randomIntersections, aRandomIntersections);
     314           1 :     }
     315             : 
     316          15 :     void dumpSvg(const char* pName,
     317             :                  const ::basegfx::B2DPolyPolygon& rPoly)
     318             :     {
     319             :         (void)pName; (void)rPoly;
     320             : #if OSL_DEBUG_LEVEL > 2
     321             :         fprintf(stderr, "%s - svg:d=\"%s\"\n",
     322             :                 pName, OUStringToOString(
     323             :                     basegfx::tools::exportToSvgD(rPoly, , true, true, false),
     324             :                     RTL_TEXTENCODING_UTF8).getStr() );
     325             : #endif
     326          15 :     }
     327             : 
     328           1 :     void getPolyPolygon()
     329             :     {
     330           1 :         dumpSvg("disjunct",aDisjunctRanges.solveCrossovers());
     331           1 :         dumpSvg("equal",aEqualRanges.solveCrossovers());
     332           1 :         dumpSvg("intersectionN",aIntersectionN.solveCrossovers());
     333           1 :         dumpSvg("intersectionE",aIntersectionE.solveCrossovers());
     334           1 :         dumpSvg("intersectionS",aIntersectionS.solveCrossovers());
     335           1 :         dumpSvg("intersectionW",aIntersectionW.solveCrossovers());
     336           1 :         dumpSvg("intersectionNE",aIntersectionNE.solveCrossovers());
     337           1 :         dumpSvg("intersectionSE",aIntersectionSE.solveCrossovers());
     338           1 :         dumpSvg("intersectionSW",aIntersectionSW.solveCrossovers());
     339           1 :         dumpSvg("intersectionNW",aIntersectionNW.solveCrossovers());
     340           1 :         dumpSvg("ringIntersection",aRingIntersection.solveCrossovers());
     341           1 :         dumpSvg("ringIntersection2",aRingIntersection2.solveCrossovers());
     342           1 :         dumpSvg("aRingIntersectExtraStrip",aRingIntersectExtraStrip.solveCrossovers());
     343           1 :         dumpSvg("complexIntersections",aComplexIntersections.solveCrossovers());
     344           1 :         dumpSvg("randomIntersections",aRandomIntersections.solveCrossovers());
     345             : 
     346           1 :         CPPUNIT_ASSERT_MESSAGE("getPolyPolygon", true );
     347           1 :     }
     348             : 
     349          10 :     void validatePoly( const char* pName, const B2DPolyRange& rRange )
     350             :     {
     351          10 :         B2DPolyPolygon genericClip;
     352          10 :         const sal_uInt32 nCount=rRange.count();
     353          30 :         for( sal_uInt32 i=0; i<nCount; ++i )
     354             :         {
     355          20 :             B2DPolygon aRect=tools::createPolygonFromRect(std::get<0>(rRange.getElement(i)));
     356          20 :             if( std::get<1>(rRange.getElement(i)) == B2VectorOrientation::Negative )
     357          20 :                 aRect.flip();
     358             : 
     359          20 :             genericClip.append(aRect);
     360          20 :         }
     361             : 
     362             : #if OSL_DEBUG_LEVEL > 2
     363             :         fprintf(stderr, "%s input      - svg:d=\"%s\"\n",
     364             :                 pName, OUStringToOString(
     365             :                     basegfx::tools::exportToSvgD(
     366             :                         genericClip, , true, true, false),
     367             :                     RTL_TEXTENCODING_UTF8).getStr() );
     368             : #endif
     369             : 
     370          20 :         const B2DPolyPolygon boxClipResult=rRange.solveCrossovers();
     371             :         const OUString boxClipSvg(
     372             :             basegfx::tools::exportToSvgD(
     373          20 :                 normalizePoly(boxClipResult), true, true, false));
     374             : #if OSL_DEBUG_LEVEL > 2
     375             :         fprintf(stderr, "%s boxclipper - svg:d=\"%s\"\n",
     376             :                 pName, OUStringToOString(
     377             :                     boxClipSvg,
     378             :                     RTL_TEXTENCODING_UTF8).getStr() );
     379             : #endif
     380             : 
     381          10 :         genericClip = tools::solveCrossovers(genericClip);
     382             :         const OUString genericClipSvg(
     383             :             basegfx::tools::exportToSvgD(
     384          20 :                 normalizePoly(genericClip), true, true, false));
     385             : #if OSL_DEBUG_LEVEL > 2
     386             :         fprintf(stderr, "%s genclipper - svg:d=\"%s\"\n",
     387             :                 pName, OUStringToOString(
     388             :                     genericClipSvg,
     389             :                     RTL_TEXTENCODING_UTF8).getStr() );
     390             : #endif
     391             : 
     392          20 :         CPPUNIT_ASSERT_MESSAGE(pName,
     393          20 :                                genericClipSvg == boxClipSvg);
     394          10 :     }
     395             : 
     396           1 :     void validatePoly()
     397             :     {
     398           1 :         validatePoly("disjunct", aDisjunctRanges);
     399           1 :         validatePoly("equal", aEqualRanges);
     400           1 :         validatePoly("intersectionN", aIntersectionN);
     401           1 :         validatePoly("intersectionE", aIntersectionE);
     402           1 :         validatePoly("intersectionS", aIntersectionS);
     403           1 :         validatePoly("intersectionW", aIntersectionW);
     404           1 :         validatePoly("intersectionNE", aIntersectionNE);
     405           1 :         validatePoly("intersectionSE", aIntersectionSE);
     406           1 :         validatePoly("intersectionSW", aIntersectionSW);
     407           1 :         validatePoly("intersectionNW", aIntersectionNW);
     408             :         // subtle differences on Solaris Intel, comparison not smart enough
     409             :         // (due to floating point inaccuracies)
     410             :         //validatePoly("ringIntersection", aRingIntersection);
     411             :         //validatePoly("ringIntersection2", aRingIntersection2);
     412             :         //validatePoly("ringIntersectExtraStrip", aRingIntersectExtraStrip);
     413             :         // generic clipper buggy here, likely
     414             :         //validatePoly("complexIntersections", aComplexIntersections);
     415             :         //validatePoly("randomIntersections", aRandomIntersections);
     416           1 :     }
     417             : 
     418             :     // Change the following lines only, if you add, remove or rename
     419             :     // member functions of the current class,
     420             :     // because these macros are need by auto register mechanism.
     421             : 
     422           2 :     CPPUNIT_TEST_SUITE(boxclipper);
     423           1 :     CPPUNIT_TEST(validatePoly);
     424           1 :     CPPUNIT_TEST(verifyPoly);
     425           1 :     CPPUNIT_TEST(getPolyPolygon);
     426           5 :     CPPUNIT_TEST_SUITE_END();
     427             : };
     428             : 
     429           1 : CPPUNIT_TEST_SUITE_REGISTRATION(basegfx2d::boxclipper);
     430           3 : } // namespace basegfx2d
     431             : 
     432             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11