LCOV - code coverage report
Current view: top level - basegfx/source/polygon - b2dpolypolygontools.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 164 311 52.7 %
Date: 2015-06-13 12:38:46 Functions: 16 29 55.2 %
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 <basegfx/polygon/b2dpolypolygontools.hxx>
      21             : #include <osl/diagnose.h>
      22             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      23             : #include <basegfx/polygon/b2dpolygon.hxx>
      24             : #include <basegfx/polygon/b2dpolygontools.hxx>
      25             : #include <basegfx/numeric/ftools.hxx>
      26             : #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
      27             : #include <numeric>
      28             : 
      29             : namespace basegfx
      30             : {
      31             :     namespace tools
      32             :     {
      33        4626 :         B2DPolyPolygon correctOrientations(const B2DPolyPolygon& rCandidate)
      34             :         {
      35        4626 :             B2DPolyPolygon aRetval(rCandidate);
      36        4626 :             const sal_uInt32 nCount(aRetval.count());
      37             : 
      38        9441 :             for(sal_uInt32 a(0L); a < nCount; a++)
      39             :             {
      40        4815 :                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
      41        4815 :                 const B2VectorOrientation aOrientation(tools::getOrientation(aCandidate));
      42        4815 :                 sal_uInt32 nDepth(0L);
      43             : 
      44       10136 :                 for(sal_uInt32 b(0L); b < nCount; b++)
      45             :                 {
      46        5321 :                     if(b != a)
      47             :                     {
      48         506 :                         const B2DPolygon aCompare(rCandidate.getB2DPolygon(b));
      49             : 
      50         506 :                         if(tools::isInside(aCompare, aCandidate, true))
      51             :                         {
      52          12 :                             nDepth++;
      53         506 :                         }
      54             :                     }
      55             :                 }
      56             : 
      57        4815 :                 const bool bShallBeHole(1L == (nDepth & 0x00000001));
      58        4815 :                 const bool bIsHole(B2VectorOrientation::Negative == aOrientation);
      59             : 
      60        4815 :                 if(bShallBeHole != bIsHole && B2VectorOrientation::Neutral != aOrientation)
      61             :                 {
      62         197 :                     B2DPolygon aFlipped(aCandidate);
      63         197 :                     aFlipped.flip();
      64         197 :                     aRetval.setB2DPolygon(a, aFlipped);
      65             :                 }
      66        4815 :             }
      67             : 
      68        4626 :             return aRetval;
      69             :         }
      70             : 
      71        4328 :         B2DPolyPolygon correctOutmostPolygon(const B2DPolyPolygon& rCandidate)
      72             :         {
      73        4328 :             const sal_uInt32 nCount(rCandidate.count());
      74             : 
      75        4328 :             if(nCount > 1L)
      76             :             {
      77         120 :                 for(sal_uInt32 a(0L); a < nCount; a++)
      78             :                 {
      79         120 :                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
      80         120 :                     sal_uInt32 nDepth(0L);
      81             : 
      82         416 :                     for(sal_uInt32 b(0L); b < nCount; b++)
      83             :                     {
      84         296 :                         if(b != a)
      85             :                         {
      86         176 :                             const B2DPolygon aCompare(rCandidate.getB2DPolygon(b));
      87             : 
      88         176 :                             if(tools::isInside(aCompare, aCandidate, true))
      89             :                             {
      90           0 :                                 nDepth++;
      91         176 :                             }
      92             :                         }
      93             :                     }
      94             : 
      95         120 :                     if(!nDepth)
      96             :                     {
      97         120 :                         B2DPolyPolygon aRetval(rCandidate);
      98             : 
      99         120 :                         if(a != 0L)
     100             :                         {
     101             :                             // exchange polygon a and polygon 0L
     102           0 :                             aRetval.setB2DPolygon(0L, aCandidate);
     103           0 :                             aRetval.setB2DPolygon(a, rCandidate.getB2DPolygon(0L));
     104             :                         }
     105             : 
     106             :                         // exit
     107         120 :                         return aRetval;
     108             :                     }
     109           0 :                 }
     110             :             }
     111             : 
     112        4208 :             return rCandidate;
     113             :         }
     114             : 
     115           0 :         B2DPolyPolygon adaptiveSubdivideByDistance(const B2DPolyPolygon& rCandidate, double fDistanceBound)
     116             :         {
     117           0 :             if(rCandidate.areControlPointsUsed())
     118             :             {
     119           0 :                 const sal_uInt32 nPolygonCount(rCandidate.count());
     120           0 :                 B2DPolyPolygon aRetval;
     121             : 
     122           0 :                 for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     123             :                 {
     124           0 :                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     125             : 
     126           0 :                     if(aCandidate.areControlPointsUsed())
     127             :                     {
     128           0 :                         aRetval.append(tools::adaptiveSubdivideByDistance(aCandidate, fDistanceBound));
     129             :                     }
     130             :                     else
     131             :                     {
     132           0 :                         aRetval.append(aCandidate);
     133             :                     }
     134           0 :                 }
     135             : 
     136           0 :                 return aRetval;
     137             :             }
     138             :             else
     139             :             {
     140           0 :                 return rCandidate;
     141             :             }
     142             :         }
     143             : 
     144        4372 :         B2DPolyPolygon adaptiveSubdivideByAngle(const B2DPolyPolygon& rCandidate, double fAngleBound)
     145             :         {
     146        4372 :             if(rCandidate.areControlPointsUsed())
     147             :             {
     148          33 :                 const sal_uInt32 nPolygonCount(rCandidate.count());
     149          33 :                 B2DPolyPolygon aRetval;
     150             : 
     151          66 :                 for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     152             :                 {
     153          33 :                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     154             : 
     155          33 :                     if(aCandidate.areControlPointsUsed())
     156             :                     {
     157          33 :                         aRetval.append(tools::adaptiveSubdivideByAngle(aCandidate, fAngleBound));
     158             :                     }
     159             :                     else
     160             :                     {
     161           0 :                         aRetval.append(aCandidate);
     162             :                     }
     163          33 :                 }
     164             : 
     165          33 :                 return aRetval;
     166             :             }
     167             :             else
     168             :             {
     169        4339 :                 return rCandidate;
     170             :             }
     171             :         }
     172             : 
     173           0 :         B2DPolyPolygon adaptiveSubdivideByCount(const B2DPolyPolygon& rCandidate, sal_uInt32 nCount)
     174             :         {
     175           0 :             if(rCandidate.areControlPointsUsed())
     176             :             {
     177           0 :                 const sal_uInt32 nPolygonCount(rCandidate.count());
     178           0 :                 B2DPolyPolygon aRetval;
     179             : 
     180           0 :                 for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     181             :                 {
     182           0 :                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     183             : 
     184           0 :                     if(aCandidate.areControlPointsUsed())
     185             :                     {
     186           0 :                         aRetval.append(tools::adaptiveSubdivideByCount(aCandidate, nCount));
     187             :                     }
     188             :                     else
     189             :                     {
     190           0 :                         aRetval.append(aCandidate);
     191             :                     }
     192           0 :                 }
     193             : 
     194           0 :                 return aRetval;
     195             :             }
     196             :             else
     197             :             {
     198           0 :                 return rCandidate;
     199             :             }
     200             :         }
     201             : 
     202        5532 :         bool isInside(const B2DPolyPolygon& rCandidate, const B2DPoint& rPoint, bool bWithBorder)
     203             :         {
     204        5532 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     205             : 
     206        5532 :             if(1L == nPolygonCount)
     207             :             {
     208        5531 :                 return isInside(rCandidate.getB2DPolygon(0L), rPoint, bWithBorder);
     209             :             }
     210             :             else
     211             :             {
     212           1 :                 sal_Int32 nInsideCount(0L);
     213             : 
     214           4 :                 for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     215             :                 {
     216           3 :                     const B2DPolygon aPolygon(rCandidate.getB2DPolygon(a));
     217           3 :                     const bool bInside(isInside(aPolygon, rPoint, bWithBorder));
     218             : 
     219           3 :                     if(bInside)
     220             :                     {
     221           1 :                         nInsideCount++;
     222             :                     }
     223           3 :                 }
     224             : 
     225           1 :                 return (nInsideCount % 2L);
     226             :             }
     227             :         }
     228             : 
     229     4108048 :         B2DRange getRange(const B2DPolyPolygon& rCandidate)
     230             :         {
     231     4108048 :             B2DRange aRetval;
     232     4108048 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     233             : 
     234     8396440 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     235             :             {
     236     4288392 :                 B2DPolygon aCandidate = rCandidate.getB2DPolygon(a);
     237     4288392 :                 aRetval.expand(tools::getRange(aCandidate));
     238     4288392 :             }
     239             : 
     240     4108048 :             return aRetval;
     241             :         }
     242             : 
     243           0 :         double getSignedArea(const B2DPolyPolygon& rCandidate)
     244             :         {
     245           0 :             double fRetval(0.0);
     246           0 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     247             : 
     248           0 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     249             :             {
     250           0 :                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     251             : 
     252           0 :                 fRetval += tools::getSignedArea(aCandidate);
     253           0 :             }
     254             : 
     255           0 :             return fRetval;
     256             :         }
     257             : 
     258           0 :         double getArea(const B2DPolyPolygon& rCandidate)
     259             :         {
     260           0 :             return fabs(getSignedArea(rCandidate));
     261             :         }
     262             : 
     263           0 :         void applyLineDashing(const B2DPolyPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, B2DPolyPolygon* pGapTarget, double fFullDashDotLen)
     264             :         {
     265           0 :             if(0.0 == fFullDashDotLen && rDotDashArray.size())
     266             :             {
     267             :                 // calculate fFullDashDotLen from rDotDashArray
     268           0 :                 fFullDashDotLen = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
     269             :             }
     270             : 
     271           0 :             if(rCandidate.count() && fFullDashDotLen > 0.0)
     272             :             {
     273           0 :                 B2DPolyPolygon aLineTarget, aGapTarget;
     274             : 
     275           0 :                 for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
     276             :                 {
     277           0 :                     const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     278             : 
     279             :                     applyLineDashing(
     280             :                         aCandidate,
     281             :                         rDotDashArray,
     282             :                         pLineTarget ? &aLineTarget : 0,
     283             :                         pGapTarget ? &aGapTarget : 0,
     284           0 :                         fFullDashDotLen);
     285             : 
     286           0 :                     if(pLineTarget)
     287             :                     {
     288           0 :                         pLineTarget->append(aLineTarget);
     289             :                     }
     290             : 
     291           0 :                     if(pGapTarget)
     292             :                     {
     293           0 :                         pGapTarget->append(aGapTarget);
     294             :                     }
     295           0 :                 }
     296             :             }
     297           0 :         }
     298             : 
     299          50 :         bool isInEpsilonRange(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPosition, double fDistance)
     300             :         {
     301          50 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     302             : 
     303          58 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     304             :             {
     305          52 :                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     306             : 
     307          52 :                 if(isInEpsilonRange(aCandidate, rTestPosition, fDistance))
     308             :                 {
     309          44 :                     return true;
     310             :                 }
     311           8 :             }
     312             : 
     313           6 :             return false;
     314             :         }
     315             : 
     316       21972 :         B3DPolyPolygon createB3DPolyPolygonFromB2DPolyPolygon(const B2DPolyPolygon& rCandidate, double fZCoordinate)
     317             :         {
     318       21972 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     319       21972 :             B3DPolyPolygon aRetval;
     320             : 
     321       51376 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     322             :             {
     323       29404 :                 B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     324             : 
     325       29404 :                 aRetval.append(createB3DPolygonFromB2DPolygon(aCandidate, fZCoordinate));
     326       29404 :             }
     327             : 
     328       21972 :             return aRetval;
     329             :         }
     330             : 
     331        4837 :         B2DPolyPolygon createB2DPolyPolygonFromB3DPolyPolygon(const B3DPolyPolygon& rCandidate, const B3DHomMatrix& rMat)
     332             :         {
     333        4837 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     334        4837 :             B2DPolyPolygon aRetval;
     335             : 
     336       10034 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     337             :             {
     338        5197 :                 B3DPolygon aCandidate(rCandidate.getB3DPolygon(a));
     339             : 
     340        5197 :                 aRetval.append(createB2DPolygonFromB3DPolygon(aCandidate, rMat));
     341        5197 :             }
     342             : 
     343        4837 :             return aRetval;
     344             :         }
     345             : 
     346           0 :         double getSmallestDistancePointToPolyPolygon(const B2DPolyPolygon& rCandidate, const B2DPoint& rTestPoint, sal_uInt32& rPolygonIndex, sal_uInt32& rEdgeIndex, double& rCut)
     347             :         {
     348           0 :             double fRetval(DBL_MAX);
     349           0 :             const double fZero(0.0);
     350           0 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     351             : 
     352           0 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     353             :             {
     354           0 :                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     355             :                 sal_uInt32 nNewEdgeIndex;
     356           0 :                 double fNewCut(0.0);
     357           0 :                 const double fNewDistance(getSmallestDistancePointToPolygon(aCandidate, rTestPoint, nNewEdgeIndex, fNewCut));
     358             : 
     359           0 :                 if(DBL_MAX == fRetval || fNewDistance < fRetval)
     360             :                 {
     361           0 :                     fRetval = fNewDistance;
     362           0 :                     rPolygonIndex = a;
     363           0 :                     rEdgeIndex = nNewEdgeIndex;
     364           0 :                     rCut = fNewCut;
     365             : 
     366           0 :                     if(fTools::equal(fRetval, fZero))
     367             :                     {
     368             :                         // already found zero distance, cannot get better. Ensure numerical zero value and end loop.
     369           0 :                         fRetval = 0.0;
     370           0 :                         break;
     371             :                     }
     372             :                 }
     373           0 :             }
     374             : 
     375           0 :             return fRetval;
     376             :         }
     377             : 
     378           0 :         B2DPolyPolygon distort(const B2DPolyPolygon& rCandidate, const B2DRange& rOriginal, const B2DPoint& rTopLeft, const B2DPoint& rTopRight, const B2DPoint& rBottomLeft, const B2DPoint& rBottomRight)
     379             :         {
     380           0 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     381           0 :             B2DPolyPolygon aRetval;
     382             : 
     383           0 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     384             :             {
     385           0 :                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     386             : 
     387           0 :                 aRetval.append(distort(aCandidate, rOriginal, rTopLeft, rTopRight, rBottomLeft, rBottomRight));
     388           0 :             }
     389             : 
     390           0 :             return aRetval;
     391             :         }
     392             : 
     393          20 :         B2DPolyPolygon expandToCurve(const B2DPolyPolygon& rCandidate)
     394             :         {
     395          20 :             const sal_uInt32 nPolygonCount(rCandidate.count());
     396          20 :             B2DPolyPolygon aRetval;
     397             : 
     398          40 :             for(sal_uInt32 a(0L); a < nPolygonCount; a++)
     399             :             {
     400          20 :                 const B2DPolygon aCandidate(rCandidate.getB2DPolygon(a));
     401             : 
     402          20 :                 aRetval.append(expandToCurve(aCandidate));
     403          20 :             }
     404             : 
     405          20 :             return aRetval;
     406             :         }
     407             : 
     408         234 :         B2DPolyPolygon growInNormalDirection(const B2DPolyPolygon& rCandidate, double fValue)
     409             :         {
     410         234 :             if(0.0 != fValue)
     411             :             {
     412         234 :                 B2DPolyPolygon aRetval;
     413             : 
     414         468 :                 for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
     415             :                 {
     416         234 :                     aRetval.append(growInNormalDirection(rCandidate.getB2DPolygon(a), fValue));
     417             :                 }
     418             : 
     419         234 :                 return aRetval;
     420             :             }
     421             :             else
     422             :             {
     423           0 :                 return rCandidate;
     424             :             }
     425             :         }
     426             : 
     427           0 :         void correctGrowShrinkPolygonPair(SAL_UNUSED_PARAMETER B2DPolyPolygon& /*rOriginal*/, SAL_UNUSED_PARAMETER B2DPolyPolygon& /*rGrown*/)
     428             :         {
     429             :             //TODO!
     430           0 :         }
     431             : 
     432           0 :         B2DPolyPolygon reSegmentPolyPolygon(const B2DPolyPolygon& rCandidate, sal_uInt32 nSegments)
     433             :         {
     434           0 :             B2DPolyPolygon aRetval;
     435             : 
     436           0 :             for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
     437             :             {
     438           0 :                 aRetval.append(reSegmentPolygon(rCandidate.getB2DPolygon(a), nSegments));
     439             :             }
     440             : 
     441           0 :             return aRetval;
     442             :         }
     443             : 
     444           0 :         B2DPolyPolygon interpolate(const B2DPolyPolygon& rOld1, const B2DPolyPolygon& rOld2, double t)
     445             :         {
     446             :             OSL_ENSURE(rOld1.count() == rOld2.count(), "B2DPolyPolygon interpolate: Different geometry (!)");
     447           0 :             B2DPolyPolygon aRetval;
     448             : 
     449           0 :             for(sal_uInt32 a(0L); a < rOld1.count(); a++)
     450             :             {
     451           0 :                 aRetval.append(interpolate(rOld1.getB2DPolygon(a), rOld2.getB2DPolygon(a), t));
     452             :             }
     453             : 
     454           0 :             return aRetval;
     455             :         }
     456             : 
     457       18345 :         bool isRectangle( const B2DPolyPolygon& rPoly )
     458             :         {
     459             :             // exclude some cheap cases first
     460       18345 :             if( rPoly.count() != 1 )
     461           4 :                 return false;
     462             : 
     463       18341 :             return isRectangle( rPoly.getB2DPolygon(0) );
     464             :         }
     465             : 
     466             :         // #i76891#
     467         977 :         B2DPolyPolygon simplifyCurveSegments(const B2DPolyPolygon& rCandidate)
     468             :         {
     469         977 :             if(rCandidate.areControlPointsUsed())
     470             :             {
     471         487 :                 B2DPolyPolygon aRetval;
     472             : 
     473        2321 :                 for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
     474             :                 {
     475        1834 :                     aRetval.append(simplifyCurveSegments(rCandidate.getB2DPolygon(a)));
     476             :                 }
     477             : 
     478         487 :                 return aRetval;
     479             :             }
     480             :             else
     481             :             {
     482         490 :                 return rCandidate;
     483             :             }
     484             :         }
     485             : 
     486           0 :         B2DPolyPolygon snapPointsOfHorizontalOrVerticalEdges(const B2DPolyPolygon& rCandidate)
     487             :         {
     488           0 :             B2DPolyPolygon aRetval;
     489             : 
     490           0 :             for(sal_uInt32 a(0L); a < rCandidate.count(); a++)
     491             :             {
     492           0 :                 aRetval.append(snapPointsOfHorizontalOrVerticalEdges(rCandidate.getB2DPolygon(a)));
     493             :             }
     494             : 
     495           0 :             return aRetval;
     496             :         }
     497             : 
     498           0 :         bool containsOnlyHorizontalAndVerticalEdges(const B2DPolyPolygon& rCandidate)
     499             :         {
     500           0 :             if(rCandidate.areControlPointsUsed())
     501             :             {
     502           0 :                 return false;
     503             :             }
     504             : 
     505           0 :             for(sal_uInt32 a(0); a < rCandidate.count(); a++)
     506             :             {
     507           0 :                 if(!containsOnlyHorizontalAndVerticalEdges(rCandidate.getB2DPolygon(a)))
     508             :                 {
     509           0 :                     return false;
     510             :                 }
     511             :             }
     512             : 
     513           0 :             return true;
     514             :         }
     515             : 
     516           0 :         B2DPolyPolygon createSevenSegmentPolyPolygon(sal_Char nNumber, bool bLitSegments)
     517             :         {
     518             :             // config here
     519             :             // {
     520           0 :             const double fTotalSize=1.0;
     521           0 :             const double fPosMiddleSegment=0.6;
     522           0 :             const double fSegmentEndChopHoriz=0.08;
     523           0 :             const double fSegmentEndChopVert =0.04;
     524             :             // }
     525             :             // config here
     526             : 
     527           0 :             const double fLeft=0.0;
     528           0 :             const double fRight=fTotalSize;
     529           0 :             const double fTop=0.0;
     530           0 :             const double fMiddle=fPosMiddleSegment;
     531           0 :             const double fBottom=fTotalSize;
     532             : 
     533             :             // from 0 to 5: pair of segment corner coordinates
     534             : 
     535             :             // segment corner indices are these:
     536             : 
     537             :             //   0 - 1
     538             :             //   |   |
     539             :             //   2 - 3
     540             :             //   |   |
     541             :             //   4 - 5
     542             : 
     543             :             static const double corners[] =
     544             :             {
     545             :                 fLeft,  fTop,
     546             :                 fRight, fTop,
     547             :                 fLeft,  fMiddle,
     548             :                 fRight, fMiddle,
     549             :                 fLeft,  fBottom,
     550             :                 fRight, fBottom
     551             :             };
     552             : 
     553             :             // from 0 to 9: which segments are 'lit' for this number?
     554             : 
     555             :             // array denotes graph edges to traverse, with -1 means
     556             :             // stop (the vertices are the corner indices from above):
     557             :             //     0
     558             :             //     -
     559             :             // 1 |   | 2
     560             :             //     - 3
     561             :             // 4 |   | 5
     562             :             //     -
     563             :             //     6
     564             : 
     565             :             static const int numbers[] =
     566             :             {
     567             :                 1, 1, 1, 0, 1, 1, 1, // 0
     568             :                 0, 0, 1, 0, 0, 1, 0, // 1
     569             :                 1, 0, 1, 1, 1, 0, 1, // 2
     570             :                 1, 0, 1, 1, 0, 1, 1, // 3
     571             :                 0, 1, 1, 1, 0, 1, 0, // 4
     572             :                 1, 1, 0, 1, 0, 1, 1, // 5
     573             :                 1, 1, 0, 1, 1, 1, 1, // 6
     574             :                 1, 0, 1, 0, 0, 1, 0, // 1
     575             :                 1, 1, 1, 1, 1, 1, 1, // 8
     576             :                 1, 1, 1, 1, 0, 1, 1, // 9
     577             :                 0, 0, 0, 1, 0, 0, 0, // '-'
     578             :                 1, 1, 0, 1, 1, 0, 1, // 'E'
     579             :             };
     580             : 
     581             :             // maps segment index to two corner ids:
     582             :             static const int index2corner[] =
     583             :             {
     584             :                 0, 2,  // 0
     585             :                 0, 4,  // 1
     586             :                 2, 6,  // 2
     587             :                 4, 6,  // 3
     588             :                 4, 8,  // 4
     589             :                 6, 10, // 5
     590             :                 8, 10, // 6
     591             :             };
     592             : 
     593           0 :             B2DPolyPolygon aRes;
     594           0 :             if( nNumber == '-' )
     595             :             {
     596           0 :                 nNumber = 10;
     597             :             }
     598           0 :             else if( nNumber == 'E' )
     599             :             {
     600           0 :                 nNumber = 11;
     601             :             }
     602           0 :             else if( nNumber == '.' )
     603             :             {
     604           0 :                 if( bLitSegments )
     605             :                     aRes.append(createPolygonFromCircle(B2DPoint(fTotalSize/2, fTotalSize),
     606           0 :                                                         fSegmentEndChopHoriz));
     607           0 :                 return aRes;
     608             :             }
     609             :             else
     610             :             {
     611           0 :                 nNumber=clamp<sal_uInt32>(nNumber,'0','9') - '0';
     612             :             }
     613             : 
     614           0 :             B2DPolygon aCurrSegment;
     615           0 :             const size_t sliceSize=SAL_N_ELEMENTS(numbers)/12;
     616           0 :             const int* pCurrSegment=numbers + nNumber*sliceSize;
     617           0 :             for( size_t i=0; i<sliceSize; i++, pCurrSegment++)
     618             :             {
     619           0 :                 if( !(*pCurrSegment ^ int(bLitSegments)) )
     620             :                 {
     621           0 :                     const size_t j=2*i;
     622           0 :                     aCurrSegment.clear();
     623           0 :                     B2DPoint start(corners[index2corner[j]],
     624           0 :                                    corners[index2corner[j]+1]  );
     625           0 :                     B2DPoint end  (corners[index2corner[j+1]],
     626           0 :                                    corners[index2corner[j+1]+1]);
     627             : 
     628           0 :                     if( start.getX() == end.getX() )
     629             :                     {
     630           0 :                         start.setY(start.getY()+fSegmentEndChopVert);
     631           0 :                         end.setY(end.getY()-fSegmentEndChopVert);
     632             :                     }
     633             :                     else
     634             :                     {
     635           0 :                         start.setX(start.getX()+fSegmentEndChopHoriz);
     636           0 :                         end.setX(end.getX()-fSegmentEndChopHoriz);
     637             :                     }
     638             : 
     639           0 :                     aCurrSegment.append(start);
     640           0 :                     aCurrSegment.append(end);
     641             :                 }
     642           0 :                 aRes.append(aCurrSegment);
     643             :             }
     644             : 
     645           0 :             return aRes;
     646             :         }
     647             : 
     648             :         // converters for com::sun::star::drawing::PointSequence
     649             : 
     650          16 :         B2DPolyPolygon UnoPointSequenceSequenceToB2DPolyPolygon(
     651             :             const com::sun::star::drawing::PointSequenceSequence& rPointSequenceSequenceSource,
     652             :             bool bCheckClosed)
     653             :         {
     654          16 :             B2DPolyPolygon aRetval;
     655          16 :             const com::sun::star::drawing::PointSequence* pPointSequence = rPointSequenceSequenceSource.getConstArray();
     656          16 :             const com::sun::star::drawing::PointSequence* pPointSeqEnd = pPointSequence + rPointSequenceSequenceSource.getLength();
     657             : 
     658          17 :             for(;pPointSequence != pPointSeqEnd; pPointSequence++)
     659             :             {
     660           1 :                 const B2DPolygon aNewPolygon = UnoPointSequenceToB2DPolygon(*pPointSequence, bCheckClosed);
     661           1 :                 aRetval.append(aNewPolygon);
     662           1 :             }
     663             : 
     664          16 :             return aRetval;
     665             :         }
     666             : 
     667         446 :         void B2DPolyPolygonToUnoPointSequenceSequence(
     668             :             const B2DPolyPolygon& rPolyPolygon,
     669             :             com::sun::star::drawing::PointSequenceSequence& rPointSequenceSequenceRetval)
     670             :         {
     671         446 :             const sal_uInt32 nCount(rPolyPolygon.count());
     672             : 
     673         446 :             if(nCount)
     674             :             {
     675         446 :                 rPointSequenceSequenceRetval.realloc(nCount);
     676         446 :                 com::sun::star::drawing::PointSequence* pPointSequence = rPointSequenceSequenceRetval.getArray();
     677             : 
     678         892 :                 for(sal_uInt32 a(0); a < nCount; a++)
     679             :                 {
     680         446 :                     const B2DPolygon aPolygon(rPolyPolygon.getB2DPolygon(a));
     681             : 
     682         446 :                     B2DPolygonToUnoPointSequence(aPolygon, *pPointSequence);
     683         446 :                     pPointSequence++;
     684         446 :                 }
     685             :             }
     686             :             else
     687             :             {
     688           0 :                 rPointSequenceSequenceRetval.realloc(0);
     689             :             }
     690         446 :         }
     691             : 
     692             :         // converters for com::sun::star::drawing::PolyPolygonBezierCoords (curved polygons)
     693             : 
     694          20 :         B2DPolyPolygon UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
     695             :             const com::sun::star::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsSource,
     696             :             bool bCheckClosed)
     697             :         {
     698          20 :             B2DPolyPolygon aRetval;
     699          20 :             const sal_uInt32 nSequenceCount((sal_uInt32)rPolyPolygonBezierCoordsSource.Coordinates.getLength());
     700             : 
     701          20 :             if(nSequenceCount)
     702             :             {
     703             :                 OSL_ENSURE(nSequenceCount == (sal_uInt32)rPolyPolygonBezierCoordsSource.Flags.getLength(),
     704             :                     "UnoPolyPolygonBezierCoordsToB2DPolyPolygon: unequal number of Points and Flags (!)");
     705          20 :                 const com::sun::star::drawing::PointSequence* pPointSequence = rPolyPolygonBezierCoordsSource.Coordinates.getConstArray();
     706          20 :                 const com::sun::star::drawing::FlagSequence* pFlagSequence = rPolyPolygonBezierCoordsSource.Flags.getConstArray();
     707             : 
     708          40 :                 for(sal_uInt32 a(0); a < nSequenceCount; a++)
     709             :                 {
     710             :                     const B2DPolygon aNewPolygon(UnoPolygonBezierCoordsToB2DPolygon(
     711             :                         *pPointSequence,
     712             :                         *pFlagSequence,
     713          20 :                         bCheckClosed));
     714             : 
     715          20 :                     pPointSequence++;
     716          20 :                     pFlagSequence++;
     717          20 :                     aRetval.append(aNewPolygon);
     718          20 :                 }
     719             :             }
     720             : 
     721          20 :             return aRetval;
     722             :         }
     723             : 
     724         412 :         void B2DPolyPolygonToUnoPolyPolygonBezierCoords(
     725             :             const B2DPolyPolygon& rPolyPolygon,
     726             :             com::sun::star::drawing::PolyPolygonBezierCoords& rPolyPolygonBezierCoordsRetval)
     727             :         {
     728         412 :             const sal_uInt32 nCount(rPolyPolygon.count());
     729             : 
     730         412 :             if(nCount)
     731             :             {
     732             :                 // prepare return value memory
     733         412 :                 rPolyPolygonBezierCoordsRetval.Coordinates.realloc((sal_Int32)nCount);
     734         412 :                 rPolyPolygonBezierCoordsRetval.Flags.realloc((sal_Int32)nCount);
     735             : 
     736             :                 // get pointers to arrays
     737         412 :                 com::sun::star::drawing::PointSequence* pPointSequence = rPolyPolygonBezierCoordsRetval.Coordinates.getArray();
     738         412 :                 com::sun::star::drawing::FlagSequence*  pFlagSequence = rPolyPolygonBezierCoordsRetval.Flags.getArray();
     739             : 
     740         939 :                 for(sal_uInt32 a(0); a < nCount; a++)
     741             :                 {
     742         527 :                     const B2DPolygon aSource(rPolyPolygon.getB2DPolygon(a));
     743             : 
     744             :                     B2DPolygonToUnoPolygonBezierCoords(
     745             :                         aSource,
     746             :                         *pPointSequence,
     747         527 :                         *pFlagSequence);
     748         527 :                     pPointSequence++;
     749         527 :                     pFlagSequence++;
     750         527 :                 }
     751             :             }
     752             :             else
     753             :             {
     754           0 :                 rPolyPolygonBezierCoordsRetval.Coordinates.realloc(0);
     755           0 :                 rPolyPolygonBezierCoordsRetval.Flags.realloc(0);
     756             :             }
     757         412 :         }
     758             : 
     759             :     } // end of namespace tools
     760             : } // end of namespace basegfx
     761             : 
     762             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11