basegfx/source/polygon/b3dpolygontools.cxx

   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 <osl/diagnose.h>
  21 #include <basegfx/polygon/b3dpolygontools.hxx>
  22 #include <basegfx/polygon/b3dpolygon.hxx>
  23 #include <basegfx/numeric/ftools.hxx>
  24 #include <basegfx/range/b3drange.hxx>
  25 #include <basegfx/point/b2dpoint.hxx>
  26 #include <basegfx/matrix/b3dhommatrix.hxx>
  27 #include <basegfx/polygon/b2dpolygon.hxx>
  28 #include <basegfx/polygon/b2dpolygontools.hxx>
  29 #include <basegfx/tuple/b3ituple.hxx>
  30 #include <numeric>
  31
  32 namespace basegfx
  33 {
  34     namespace tools
  35     {
  36         // B3DPolygon tools
  37         void checkClosed(B3DPolygon& rCandidate)
  38         {
  39             while(rCandidate.count() > 1L
  40                 && rCandidate.getB3DPoint(0L).equal(rCandidate.getB3DPoint(rCandidate.count() - 1L)))
  41             {
  42                 rCandidate.setClosed(true);
  43                 rCandidate.remove(rCandidate.count() - 1L);
  44             }
  45         }
  46
  47         sal_uInt32 getIndexOfSuccessor(sal_uInt32 nIndex, const B3DPolygon& rCandidate)
  48         {
  49             OSL_ENSURE(nIndex < rCandidate.count(), "getIndexOfPredecessor: Access to polygon out of range (!)");
  50
  51             if(nIndex + 1L < rCandidate.count())
  52             {
  53                 return nIndex + 1L;
  54             }
  55             else
  56             {
  57                 return 0L;
  58             }
  59         }
  60
  61         B3DRange getRange(const B3DPolygon& rCandidate)
  62         {
  63             B3DRange aRetval;
  64             const sal_uInt32 nPointCount(rCandidate.count());
  65
  66             for(sal_uInt32 a(0L); a < nPointCount; a++)
  67             {
  68                 const B3DPoint aTestPoint(rCandidate.getB3DPoint(a));
  69                 aRetval.expand(aTestPoint);
  70             }
  71
  72             return aRetval;
  73         }
  74
  75         B3DVector getNormal(const B3DPolygon& rCandidate)
  76         {
  77             return rCandidate.getNormal();
  78         }
  79
  80         double getLength(const B3DPolygon& rCandidate)
  81         {
  82             double fRetval(0.0);
  83             const sal_uInt32 nPointCount(rCandidate.count());
  84
  85             if(nPointCount > 1L)
  86             {
  87                 const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
  88
  89                 for(sal_uInt32 a(0L); a < nLoopCount; a++)
  90                 {
  91                     const sal_uInt32 nNextIndex(getIndexOfSuccessor(a, rCandidate));
  92                     const B3DPoint aCurrentPoint(rCandidate.getB3DPoint(a));
  93                     const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
  94                     const B3DVector aVector(aNextPoint - aCurrentPoint);
  95                     fRetval += aVector.getLength();
  96                 }
  97             }
  98
  99             return fRetval;
 100         }
 101
 102         void applyLineDashing(const B3DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fDotDashLength)
 103         {
 104             const sal_uInt32 nPointCount(rCandidate.count());
 105             const sal_uInt32 nDotDashCount(rDotDashArray.size());
 106
 107             if(fTools::lessOrEqual(fDotDashLength, 0.0))
 108             {
 109                 fDotDashLength = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
 110             }
 111
 112             if(fTools::more(fDotDashLength, 0.0) && (pLineTarget || pGapTarget) && nPointCount)
 113             {
 114                 // clear targets
 115                 if(pLineTarget)
 116                 {
 117                     pLineTarget->clear();
 118                 }
 119
 120                 if(pGapTarget)
 121                 {
 122                     pGapTarget->clear();
 123                 }
 124
 125                 // prepare current edge's start
 126                 B3DPoint aCurrentPoint(rCandidate.getB3DPoint(0));
 127                 const sal_uInt32 nEdgeCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1);
 128
 129                 // prepare DotDashArray iteration and the line/gap switching bool
 130                 sal_uInt32 nDotDashIndex(0);
 131                 bool bIsLine(true);
 132                 double fDotDashMovingLength(rDotDashArray[0]);
 133                 B3DPolygon aSnippet;
 134
 135                 // iterate over all edges
 136                 for(sal_uInt32 a(0); a < nEdgeCount; a++)
 137                 {
 138                     // update current edge
 139                     const sal_uInt32 nNextIndex((a + 1) % nPointCount);
 140                     const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
 141                     const double fEdgeLength(B3DVector(aNextPoint - aCurrentPoint).getLength());
 142
 143                     if(!fTools::equalZero(fEdgeLength))
 144                     {
 145                         double fLastDotDashMovingLength(0.0);
 146                         while(fTools::less(fDotDashMovingLength, fEdgeLength))
 147                         {
 148                             // new split is inside edge, create and append snippet [fLastDotDashMovingLength, fDotDashMovingLength]
 149                             const bool bHandleLine(bIsLine && pLineTarget);
 150                             const bool bHandleGap(!bIsLine && pGapTarget);
 151
 152                             if(bHandleLine || bHandleGap)
 153                             {
 154                                 if(!aSnippet.count())
 155                                 {
 156                                     aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fLastDotDashMovingLength / fEdgeLength));
 157                                 }
 158
 159                                 aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fDotDashMovingLength / fEdgeLength));
 160
 161                                 if(bHandleLine)
 162                                 {
 163                                     pLineTarget->append(aSnippet);
 164                                 }
 165                                 else
 166                                 {
 167                                     pGapTarget->append(aSnippet);
 168                                 }
 169
 170                                 aSnippet.clear();
 171                             }
 172
 173                             // prepare next DotDashArray step and flip line/gap flag
 174                             fLastDotDashMovingLength = fDotDashMovingLength;
 175                             fDotDashMovingLength += rDotDashArray[(++nDotDashIndex) % nDotDashCount];
 176                             bIsLine = !bIsLine;
 177                         }
 178
 179                         // append snippet [fLastDotDashMovingLength, fEdgeLength]
 180                         const bool bHandleLine(bIsLine && pLineTarget);
 181                         const bool bHandleGap(!bIsLine && pGapTarget);
 182
 183                         if(bHandleLine || bHandleGap)
 184                         {
 185                             if(!aSnippet.count())
 186                             {
 187                                 aSnippet.append(interpolate(aCurrentPoint, aNextPoint, fLastDotDashMovingLength / fEdgeLength));
 188                             }
 189
 190                             aSnippet.append(aNextPoint);
 191                         }
 192
 193                         // prepare move to next edge
 194                         fDotDashMovingLength -= fEdgeLength;
 195                     }
 196
 197                     // prepare next edge step (end point gets new start point)
 198                     aCurrentPoint = aNextPoint;
 199                 }
 200
 201                 // append last intermediate results (if exists)
 202                 if(aSnippet.count())
 203                 {
 204                     if(bIsLine && pLineTarget)
 205                     {
 206                         pLineTarget->append(aSnippet);
 207                     }
 208                     else if(!bIsLine && pGapTarget)
 209                     {
 210                         pGapTarget->append(aSnippet);
 211                     }
 212                 }
 213
 214                 // check if start and end polygon may be merged
 215                 if(pLineTarget)
 216                 {
 217                     const sal_uInt32 nCount(pLineTarget->count());
 218
 219                     if(nCount > 1)
 220                     {
 221                         // these polygons were created above, there exists none with less than two points,
 222                         // thus dircet point access below is allowed
 223                         const B3DPolygon aFirst(pLineTarget->getB3DPolygon(0));
 224                         B3DPolygon aLast(pLineTarget->getB3DPolygon(nCount - 1));
 225
 226                         if(aFirst.getB3DPoint(0).equal(aLast.getB3DPoint(aLast.count() - 1)))
 227                         {
 228                             // start of first and end of last are the same -> merge them
 229                             aLast.append(aFirst);
 230                             aLast.removeDoublePoints();
 231                             pLineTarget->setB3DPolygon(0, aLast);
 232                             pLineTarget->remove(nCount - 1);
 233                         }
 234                     }
 235                 }
 236
 237                 if(pGapTarget)
 238                 {
 239                     const sal_uInt32 nCount(pGapTarget->count());
 240
 241                     if(nCount > 1)
 242                     {
 243                         // these polygons were created above, there exists none with less than two points,
 244                         // thus dircet point access below is allowed
 245                         const B3DPolygon aFirst(pGapTarget->getB3DPolygon(0));
 246                         B3DPolygon aLast(pGapTarget->getB3DPolygon(nCount - 1));
 247
 248                         if(aFirst.getB3DPoint(0).equal(aLast.getB3DPoint(aLast.count() - 1)))
 249                         {
 250                             // start of first and end of last are the same -> merge them
 251                             aLast.append(aFirst);
 252                             aLast.removeDoublePoints();
 253                             pGapTarget->setB3DPolygon(0, aLast);
 254                             pGapTarget->remove(nCount - 1);
 255                         }
 256                     }
 257                 }
 258             }
 259             else
 260             {
 261                 // parameters make no sense, just add source to targets
 262                 if(pLineTarget)
 263                 {
 264                     pLineTarget->append(rCandidate);
 265                 }
 266
 267                 if(pGapTarget)
 268                 {
 269                     pGapTarget->append(rCandidate);
 270                 }
 271             }
 272         }
 273
 274         B3DPolygon applyDefaultNormalsSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter)
 275         {
 276             B3DPolygon aRetval(rCandidate);
 277
 278             for(sal_uInt32 a(0L); a < aRetval.count(); a++)
 279             {
 280                 B3DVector aVector(aRetval.getB3DPoint(a) - rCenter);
 281                 aVector.normalize();
 282                 aRetval.setNormal(a, aVector);
 283             }
 284
 285             return aRetval;
 286         }
 287
 288         B3DPolygon invertNormals( const B3DPolygon& rCandidate)
 289         {
 290             B3DPolygon aRetval(rCandidate);
 291
 292             if(aRetval.areNormalsUsed())
 293             {
 294                 for(sal_uInt32 a(0L); a < aRetval.count(); a++)
 295                 {
 296                     aRetval.setNormal(a, -aRetval.getNormal(a));
 297                 }
 298             }
 299
 300             return aRetval;
 301         }
 302
 303         B3DPolygon applyDefaultTextureCoordinatesParallel( const B3DPolygon& rCandidate, const B3DRange& rRange, bool bChangeX, bool bChangeY)
 304         {
 305             B3DPolygon aRetval(rCandidate);
 306
 307             if(bChangeX || bChangeY)
 308             {
 309                 // create projection of standard texture coordinates in (X, Y) onto
 310                 // the 3d coordinates straight
 311                 const double fWidth(rRange.getWidth());
 312                 const double fHeight(rRange.getHeight());
 313                 const bool bWidthSet(!fTools::equalZero(fWidth));
 314                 const bool bHeightSet(!fTools::equalZero(fHeight));
 315                 const double fOne(1.0);
 316
 317                 for(sal_uInt32 a(0L); a < aRetval.count(); a++)
 318                 {
 319                     const B3DPoint aPoint(aRetval.getB3DPoint(a));
 320                     B2DPoint aTextureCoordinate(aRetval.getTextureCoordinate(a));
 321
 322                     if(bChangeX)
 323                     {
 324                         if(bWidthSet)
 325                         {
 326                             aTextureCoordinate.setX((aPoint.getX() - rRange.getMinX()) / fWidth);
 327                         }
 328                         else
 329                         {
 330                             aTextureCoordinate.setX(0.0);
 331                         }
 332                     }
 333
 334                     if(bChangeY)
 335                     {
 336                         if(bHeightSet)
 337                         {
 338                             aTextureCoordinate.setY(fOne - ((aPoint.getY() - rRange.getMinY()) / fHeight));
 339                         }
 340                         else
 341                         {
 342                             aTextureCoordinate.setY(fOne);
 343                         }
 344                     }
 345
 346                     aRetval.setTextureCoordinate(a, aTextureCoordinate);
 347                 }
 348             }
 349
 350             return aRetval;
 351         }
 352
 353         B3DPolygon applyDefaultTextureCoordinatesSphere( const B3DPolygon& rCandidate, const B3DPoint& rCenter, bool bChangeX, bool bChangeY)
 354         {
 355             B3DPolygon aRetval(rCandidate);
 356
 357             if(bChangeX || bChangeY)
 358             {
 359                 // create texture coordinates using sphere projection to cartesian coordinates,
 360                 // use object's center as base
 361                 const double fOne(1.0);
 362                 const sal_uInt32 nPointCount(aRetval.count());
 363                 bool bPolarPoints(false);
 364                 sal_uInt32 a;
 365
 366                 // create center cartesian coordinates to have a possibility to decide if on boundary
 367                 // transitions which value to choose
 368                 const B3DRange aPlaneRange(getRange(rCandidate));
 369                 const B3DPoint aPlaneCenter(aPlaneRange.getCenter() - rCenter);
 370                 const double fXCenter(fOne - ((atan2(aPlaneCenter.getZ(), aPlaneCenter.getX()) + F_PI) / F_2PI));
 371
 372                 for(a = 0L; a < nPointCount; a++)
 373                 {
 374                     const B3DVector aVector(aRetval.getB3DPoint(a) - rCenter);
 375                     const double fY(fOne - ((atan2(aVector.getY(), aVector.getXZLength()) + F_PI2) / F_PI));
 376                     B2DPoint aTexCoor(aRetval.getTextureCoordinate(a));
 377
 378                     if(fTools::equalZero(fY))
 379                     {
 380                         // point is a north polar point, no useful X-coordinate can be created.
 381                         if(bChangeY)
 382                         {
 383                             aTexCoor.setY(0.0);
 384
 385                             if(bChangeX)
 386                             {
 387                                 bPolarPoints = true;
 388                             }
 389                         }
 390                     }
 391                     else if(fTools::equal(fY, fOne))
 392                     {
 393                         // point is a south polar point, no useful X-coordinate can be created. Set
 394                         // Y-coordinte, though
 395                         if(bChangeY)
 396                         {
 397                             aTexCoor.setY(fOne);
 398
 399                             if(bChangeX)
 400                             {
 401                                 bPolarPoints = true;
 402                             }
 403                         }
 404                     }
 405                     else
 406                     {
 407                         double fX(fOne - ((atan2(aVector.getZ(), aVector.getX()) + F_PI) / F_2PI));
 408
 409                         // correct cartesinan point coordiante dependent from center value
 410                         if(fX > fXCenter + 0.5)
 411                         {
 412                             fX -= fOne;
 413                         }
 414                         else if(fX < fXCenter - 0.5)
 415                         {
 416                             fX += fOne;
 417                         }
 418
 419                         if(bChangeX)
 420                         {
 421                             aTexCoor.setX(fX);
 422                         }
 423
 424                         if(bChangeY)
 425                         {
 426                             aTexCoor.setY(fY);
 427                         }
 428                     }
 429
 430                     aRetval.setTextureCoordinate(a, aTexCoor);
 431                 }
 432
 433                 if(bPolarPoints)
 434                 {
 435                     // correct X-texture coordinates if polar points are contained. Those
 436                     // coordinates cannot be correct, so use prev or next X-coordinate
 437                     for(a = 0L; a < nPointCount; a++)
 438                     {
 439                         B2DPoint aTexCoor(aRetval.getTextureCoordinate(a));
 440
 441                         if(fTools::equalZero(aTexCoor.getY()) || fTools::equal(aTexCoor.getY(), fOne))
 442                         {
 443                             // get prev, next TexCoor and test for pole
 444                             const B2DPoint aPrevTexCoor(aRetval.getTextureCoordinate(a ? a - 1L : nPointCount - 1L));
 445                             const B2DPoint aNextTexCoor(aRetval.getTextureCoordinate((a + 1L) % nPointCount));
 446                             const bool bPrevPole(fTools::equalZero(aPrevTexCoor.getY()) || fTools::equal(aPrevTexCoor.getY(), fOne));
 447                             const bool bNextPole(fTools::equalZero(aNextTexCoor.getY()) || fTools::equal(aNextTexCoor.getY(), fOne));
 448
 449                             if(!bPrevPole && !bNextPole)
 450                             {
 451                                 // both no poles, mix them
 452                                 aTexCoor.setX((aPrevTexCoor.getX() + aNextTexCoor.getX()) / 2.0);
 453                             }
 454                             else if(!bNextPole)
 455                             {
 456                                 // copy next
 457                                 aTexCoor.setX(aNextTexCoor.getX());
 458                             }
 459                             else
 460                             {
 461                                 // copy prev, even if it's a pole, hopefully it is already corrected
 462                                 aTexCoor.setX(aPrevTexCoor.getX());
 463                             }
 464
 465                             aRetval.setTextureCoordinate(a, aTexCoor);
 466                         }
 467                     }
 468                 }
 469             }
 470
 471             return aRetval;
 472         }
 473
 474         bool isInside(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithBorder)
 475         {
 476             if(bWithBorder && isPointOnPolygon(rCandidate, rPoint, true))
 477             {
 478                 return true;
 479             }
 480             else
 481             {
 482                 bool bRetval(false);
 483                 const B3DVector aPlaneNormal(rCandidate.getNormal());
 484
 485                 if(!aPlaneNormal.equalZero())
 486                 {
 487                     const sal_uInt32 nPointCount(rCandidate.count());
 488
 489                     if(nPointCount)
 490                     {
 491                         B3DPoint aCurrentPoint(rCandidate.getB3DPoint(nPointCount - 1));
 492                         const double fAbsX(fabs(aPlaneNormal.getX()));
 493                         const double fAbsY(fabs(aPlaneNormal.getY()));
 494                         const double fAbsZ(fabs(aPlaneNormal.getZ()));
 495
 496                         if(fAbsX > fAbsY && fAbsX > fAbsZ)
 497                         {
 498                             // normal points mostly in X-Direction, use YZ-Polygon projection for check
 499                             // x -> y, y -> z
 500                             for(sal_uInt32 a(0); a < nPointCount; a++)
 501                             {
 502                                 const B3DPoint aPreviousPoint(aCurrentPoint);
 503                                 aCurrentPoint = rCandidate.getB3DPoint(a);
 504
 505                                 // cross-over in Z?
 506                                 const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ()));
 507                                 const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ()));
 508
 509                                 if(bCompZA != bCompZB)
 510                                 {
 511                                     // cross-over in Y?
 512                                     const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY()));
 513                                     const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY()));
 514
 515                                     if(bCompYA == bCompYB)
 516                                     {
 517                                         if(bCompYA)
 518                                         {
 519                                             bRetval = !bRetval;
 520                                         }
 521                                     }
 522                                     else
 523                                     {
 524                                         const double fCompare(
 525                                             aCurrentPoint.getY() - (aCurrentPoint.getZ() - rPoint.getZ()) *
 526                                             (aPreviousPoint.getY() - aCurrentPoint.getY()) /
 527                                             (aPreviousPoint.getZ() - aCurrentPoint.getZ()));
 528
 529                                         if(fTools::more(fCompare, rPoint.getY()))
 530                                         {
 531                                             bRetval = !bRetval;
 532                                         }
 533                                     }
 534                                 }
 535                             }
 536                         }
 537                         else if(fAbsY > fAbsX && fAbsY > fAbsZ)
 538                         {
 539                             // normal points mostly in Y-Direction, use XZ-Polygon projection for check
 540                             // x -> x, y -> z
 541                             for(sal_uInt32 a(0); a < nPointCount; a++)
 542                             {
 543                                 const B3DPoint aPreviousPoint(aCurrentPoint);
 544                                 aCurrentPoint = rCandidate.getB3DPoint(a);
 545
 546                                 // cross-over in Z?
 547                                 const bool bCompZA(fTools::more(aPreviousPoint.getZ(), rPoint.getZ()));
 548                                 const bool bCompZB(fTools::more(aCurrentPoint.getZ(), rPoint.getZ()));
 549
 550                                 if(bCompZA != bCompZB)
 551                                 {
 552                                     // cross-over in X?
 553                                     const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX()));
 554                                     const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX()));
 555
 556                                     if(bCompXA == bCompXB)
 557                                     {
 558                                         if(bCompXA)
 559                                         {
 560                                             bRetval = !bRetval;
 561                                         }
 562                                     }
 563                                     else
 564                                     {
 565                                         const double fCompare(
 566                                             aCurrentPoint.getX() - (aCurrentPoint.getZ() - rPoint.getZ()) *
 567                                             (aPreviousPoint.getX() - aCurrentPoint.getX()) /
 568                                             (aPreviousPoint.getZ() - aCurrentPoint.getZ()));
 569
 570                                         if(fTools::more(fCompare, rPoint.getX()))
 571                                         {
 572                                             bRetval = !bRetval;
 573                                         }
 574                                     }
 575                                 }
 576                             }
 577                         }
 578                         else
 579                         {
 580                             // normal points mostly in Z-Direction, use XY-Polygon projection for check
 581                             // x -> x, y -> y
 582                             for(sal_uInt32 a(0); a < nPointCount; a++)
 583                             {
 584                                 const B3DPoint aPreviousPoint(aCurrentPoint);
 585                                 aCurrentPoint = rCandidate.getB3DPoint(a);
 586
 587                                 // cross-over in Y?
 588                                 const bool bCompYA(fTools::more(aPreviousPoint.getY(), rPoint.getY()));
 589                                 const bool bCompYB(fTools::more(aCurrentPoint.getY(), rPoint.getY()));
 590
 591                                 if(bCompYA != bCompYB)
 592                                 {
 593                                     // cross-over in X?
 594                                     const bool bCompXA(fTools::more(aPreviousPoint.getX(), rPoint.getX()));
 595                                     const bool bCompXB(fTools::more(aCurrentPoint.getX(), rPoint.getX()));
 596
 597                                     if(bCompXA == bCompXB)
 598                                     {
 599                                         if(bCompXA)
 600                                         {
 601                                             bRetval = !bRetval;
 602                                         }
 603                                     }
 604                                     else
 605                                     {
 606                                         const double fCompare(
 607                                             aCurrentPoint.getX() - (aCurrentPoint.getY() - rPoint.getY()) *
 608                                             (aPreviousPoint.getX() - aCurrentPoint.getX()) /
 609                                             (aPreviousPoint.getY() - aCurrentPoint.getY()));
 610
 611                                         if(fTools::more(fCompare, rPoint.getX()))
 612                                         {
 613                                             bRetval = !bRetval;
 614                                         }
 615                                     }
 616                                 }
 617                             }
 618                         }
 619                     }
 620                 }
 621
 622                 return bRetval;
 623             }
 624         }
 625
 626         bool isPointOnLine(const B3DPoint& rStart, const B3DPoint& rEnd, const B3DPoint& rCandidate, bool bWithPoints)
 627         {
 628             if(rCandidate.equal(rStart) || rCandidate.equal(rEnd))
 629             {
 630                 // candidate is in epsilon around start or end -> inside
 631                 return bWithPoints;
 632             }
 633             else if(rStart.equal(rEnd))
 634             {
 635                 // start and end are equal, but candidate is outside their epsilon -> outside
 636                 return false;
 637             }
 638             else
 639             {
 640                 const B3DVector aEdgeVector(rEnd - rStart);
 641                 const B3DVector aTestVector(rCandidate - rStart);
 642
 643                 if(areParallel(aEdgeVector, aTestVector))
 644                 {
 645                     double fParamTestOnCurr(0.0);
 646
 647                     if(aEdgeVector.getX() > aEdgeVector.getY())
 648                     {
 649                         if(aEdgeVector.getX() > aEdgeVector.getZ())
 650                         {
 651                             // X is biggest
 652                             fParamTestOnCurr = aTestVector.getX() / aEdgeVector.getX();
 653                         }
 654                         else
 655                         {
 656                             // Z is biggest
 657                             fParamTestOnCurr = aTestVector.getZ() / aEdgeVector.getZ();
 658                         }
 659                     }
 660                     else
 661                     {
 662                         if(aEdgeVector.getY() > aEdgeVector.getZ())
 663                         {
 664                             // Y is biggest
 665                             fParamTestOnCurr = aTestVector.getY() / aEdgeVector.getY();
 666                         }
 667                         else
 668                         {
 669                             // Z is biggest
 670                             fParamTestOnCurr = aTestVector.getZ() / aEdgeVector.getZ();
 671                         }
 672                     }
 673
 674                     if(fTools::more(fParamTestOnCurr, 0.0) && fTools::less(fParamTestOnCurr, 1.0))
 675                     {
 676                         return true;
 677                     }
 678                 }
 679
 680                 return false;
 681             }
 682         }
 683
 684         bool isPointOnPolygon(const B3DPolygon& rCandidate, const B3DPoint& rPoint, bool bWithPoints)
 685         {
 686             const sal_uInt32 nPointCount(rCandidate.count());
 687
 688             if(nPointCount > 1L)
 689             {
 690                 const sal_uInt32 nLoopCount(rCandidate.isClosed() ? nPointCount : nPointCount - 1L);
 691                 B3DPoint aCurrentPoint(rCandidate.getB3DPoint(0));
 692
 693                 for(sal_uInt32 a(0); a < nLoopCount; a++)
 694                 {
 695                     const B3DPoint aNextPoint(rCandidate.getB3DPoint((a + 1) % nPointCount));
 696
 697                     if(isPointOnLine(aCurrentPoint, aNextPoint, rPoint, bWithPoints))
 698                     {
 699                         return true;
 700                     }
 701
 702                     aCurrentPoint = aNextPoint;
 703                 }
 704             }
 705             else if(nPointCount && bWithPoints)
 706             {
 707                 return rPoint.equal(rCandidate.getB3DPoint(0));
 708             }
 709
 710             return false;
 711         }
 712
 713         bool getCutBetweenLineAndPlane(const B3DVector& rPlaneNormal, const B3DPoint& rPlanePoint, const B3DPoint& rEdgeStart, const B3DPoint& rEdgeEnd, double& fCut)
 714         {
 715             if(!rPlaneNormal.equalZero() && !rEdgeStart.equal(rEdgeEnd))
 716             {
 717                 const B3DVector aTestEdge(rEdgeEnd - rEdgeStart);
 718                 const double fScalarEdge(rPlaneNormal.scalar(aTestEdge));
 719
 720                 if(!fTools::equalZero(fScalarEdge))
 721                 {
 722                     const B3DVector aCompareEdge(rPlanePoint - rEdgeStart);
 723                     const double fScalarCompare(rPlaneNormal.scalar(aCompareEdge));
 724
 725                     fCut = fScalarCompare / fScalarEdge;
 726                     return true;
 727                 }
 728             }
 729
 730             return false;
 731         }
 732
 733         // snap points of horizontal or vertical edges to discrete values
 734         B3DPolygon snapPointsOfHorizontalOrVerticalEdges(const B3DPolygon& rCandidate)
 735         {
 736             const sal_uInt32 nPointCount(rCandidate.count());
 737
 738             if(nPointCount > 1)
 739             {
 740                 // Start by copying the source polygon to get a writeable copy. The closed state is
 741                 // copied by aRetval's initialisation, too, so no need to copy it in this method
 742                 B3DPolygon aRetval(rCandidate);
 743
 744                 // prepare geometry data. Get rounded from original
 745                 B3ITuple aPrevTuple(basegfx::fround(rCandidate.getB3DPoint(nPointCount - 1)));
 746                 B3DPoint aCurrPoint(rCandidate.getB3DPoint(0));
 747                 B3ITuple aCurrTuple(basegfx::fround(aCurrPoint));
 748
 749                 // loop over all points. This will also snap the implicit closing edge
 750                 // even when not closed, but that's no problem here
 751                 for(sal_uInt32 a(0); a < nPointCount; a++)
 752                 {
 753                     // get next point. Get rounded from original
 754                     const bool bLastRun(a + 1 == nPointCount);
 755                     const sal_uInt32 nNextIndex(bLastRun ? 0 : a + 1);
 756                     const B3DPoint aNextPoint(rCandidate.getB3DPoint(nNextIndex));
 757                     const B3ITuple aNextTuple(basegfx::fround(aNextPoint));
 758
 759                     // get the states
 760                     const bool bPrevVertical(aPrevTuple.getX() == aCurrTuple.getX());
 761                     const bool bNextVertical(aNextTuple.getX() == aCurrTuple.getX());
 762                     const bool bPrevHorizontal(aPrevTuple.getY() == aCurrTuple.getY());
 763                     const bool bNextHorizontal(aNextTuple.getY() == aCurrTuple.getY());
 764                     const bool bSnapX(bPrevVertical || bNextVertical);
 765                     const bool bSnapY(bPrevHorizontal || bNextHorizontal);
 766
 767                     if(bSnapX || bSnapY)
 768                     {
 769                         const B3DPoint aSnappedPoint(
 770                             bSnapX ? aCurrTuple.getX() : aCurrPoint.getX(),
 771                             bSnapY ? aCurrTuple.getY() : aCurrPoint.getY(),
 772                             aCurrPoint.getZ());
 773
 774                         aRetval.setB3DPoint(a, aSnappedPoint);
 775                     }
 776
 777                     // prepare next point
 778                     if(!bLastRun)
 779                     {
 780                         aPrevTuple = aCurrTuple;
 781                         aCurrPoint = aNextPoint;
 782                         aCurrTuple = aNextTuple;
 783                     }
 784                 }
 785
 786                 return aRetval;
 787             }
 788             else
 789             {
 790                 return rCandidate;
 791             }
 792         }
 793
 794     } // end of namespace tools
 795 } // end of namespace basegfx
 796
 797 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */