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 <osl/endian.h>
21 : #include <tools/bigint.hxx>
22 : #include <tools/debug.hxx>
23 : #include <tools/helpers.hxx>
24 : #include <tools/stream.hxx>
25 : #include <tools/vcompat.hxx>
26 : #include <tools/gen.hxx>
27 : #include <poly.h>
28 : #include <tools/line.hxx>
29 : #include <tools/vector2d.hxx>
30 : #include <tools/poly.hxx>
31 : #include <basegfx/polygon/b2dpolygon.hxx>
32 : #include <basegfx/point/b2dpoint.hxx>
33 : #include <basegfx/vector/b2dvector.hxx>
34 : #include <basegfx/polygon/b2dpolygontools.hxx>
35 : #include <basegfx/curve/b2dcubicbezier.hxx>
36 :
37 : #include <vector>
38 : #include <iterator>
39 : #include <algorithm>
40 : #include <cstring>
41 : #include <limits.h>
42 : #include <cmath>
43 :
44 : #define EDGE_LEFT 1
45 : #define EDGE_TOP 2
46 : #define EDGE_RIGHT 4
47 : #define EDGE_BOTTOM 8
48 : #define EDGE_HORZ (EDGE_RIGHT | EDGE_LEFT)
49 : #define EDGE_VERT (EDGE_TOP | EDGE_BOTTOM)
50 : #define SMALL_DVALUE 0.0000001
51 : #define FSQRT2 1.4142135623730950488016887242097
52 :
53 : static ImplPolygonData aStaticImplPolygon =
54 : {
55 : NULL, NULL, 0, 0
56 : };
57 :
58 0 : ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, bool bFlags )
59 : {
60 0 : if ( nInitSize )
61 : {
62 0 : mpPointAry = (Point*)new char[(sal_uIntPtr)nInitSize*sizeof(Point)];
63 0 : memset( mpPointAry, 0, (sal_uIntPtr)nInitSize*sizeof(Point) );
64 : }
65 : else
66 0 : mpPointAry = NULL;
67 :
68 0 : if( bFlags )
69 : {
70 0 : mpFlagAry = new sal_uInt8[ nInitSize ];
71 0 : memset( mpFlagAry, 0, nInitSize );
72 : }
73 : else
74 0 : mpFlagAry = NULL;
75 :
76 0 : mnRefCount = 1;
77 0 : mnPoints = nInitSize;
78 0 : }
79 :
80 0 : ImplPolygon::ImplPolygon( const ImplPolygon& rImpPoly )
81 : {
82 0 : if ( rImpPoly.mnPoints )
83 : {
84 0 : mpPointAry = (Point*)new char[(sal_uIntPtr)rImpPoly.mnPoints*sizeof(Point)];
85 0 : memcpy( mpPointAry, rImpPoly.mpPointAry, (sal_uIntPtr)rImpPoly.mnPoints*sizeof(Point) );
86 :
87 0 : if( rImpPoly.mpFlagAry )
88 : {
89 0 : mpFlagAry = new sal_uInt8[ rImpPoly.mnPoints ];
90 0 : memcpy( mpFlagAry, rImpPoly.mpFlagAry, rImpPoly.mnPoints );
91 : }
92 : else
93 0 : mpFlagAry = NULL;
94 : }
95 : else
96 : {
97 0 : mpPointAry = NULL;
98 0 : mpFlagAry = NULL;
99 : }
100 :
101 0 : mnRefCount = 1;
102 0 : mnPoints = rImpPoly.mnPoints;
103 0 : }
104 :
105 0 : ImplPolygon::ImplPolygon( sal_uInt16 nInitSize, const Point* pInitAry, const sal_uInt8* pInitFlags )
106 : {
107 0 : if ( nInitSize )
108 : {
109 0 : mpPointAry = (Point*)new char[(sal_uIntPtr)nInitSize*sizeof(Point)];
110 0 : memcpy( mpPointAry, pInitAry, (sal_uIntPtr)nInitSize*sizeof( Point ) );
111 :
112 0 : if( pInitFlags )
113 : {
114 0 : mpFlagAry = new sal_uInt8[ nInitSize ];
115 0 : memcpy( mpFlagAry, pInitFlags, nInitSize );
116 : }
117 : else
118 0 : mpFlagAry = NULL;
119 : }
120 : else
121 : {
122 0 : mpPointAry = NULL;
123 0 : mpFlagAry = NULL;
124 : }
125 :
126 0 : mnRefCount = 1;
127 0 : mnPoints = nInitSize;
128 0 : }
129 :
130 0 : ImplPolygon::~ImplPolygon()
131 : {
132 0 : if ( mpPointAry )
133 : {
134 0 : delete[] (char*) mpPointAry;
135 : }
136 :
137 0 : if( mpFlagAry )
138 0 : delete[] mpFlagAry;
139 0 : }
140 :
141 0 : void ImplPolygon::ImplSetSize( sal_uInt16 nNewSize, bool bResize )
142 : {
143 0 : if( mnPoints == nNewSize )
144 0 : return;
145 :
146 : Point* pNewAry;
147 :
148 0 : if ( nNewSize )
149 : {
150 0 : pNewAry = (Point*)new char[(sal_uIntPtr)nNewSize*sizeof(Point)];
151 :
152 0 : if ( bResize )
153 : {
154 : // Alte Punkte kopieren
155 0 : if ( mnPoints < nNewSize )
156 : {
157 : // Neue Punkte mit 0 initialisieren
158 0 : memset( pNewAry+mnPoints, 0, (sal_uIntPtr)(nNewSize-mnPoints)*sizeof(Point) );
159 0 : if ( mpPointAry )
160 0 : memcpy( pNewAry, mpPointAry, mnPoints*sizeof(Point) );
161 : }
162 : else
163 : {
164 0 : if ( mpPointAry )
165 0 : memcpy( pNewAry, mpPointAry, (sal_uIntPtr)nNewSize*sizeof(Point) );
166 : }
167 : }
168 : }
169 : else
170 0 : pNewAry = NULL;
171 :
172 0 : if ( mpPointAry )
173 0 : delete[] (char*) mpPointAry;
174 :
175 : // ggf. FlagArray beruecksichtigen
176 0 : if( mpFlagAry )
177 : {
178 : sal_uInt8* pNewFlagAry;
179 :
180 0 : if( nNewSize )
181 : {
182 0 : pNewFlagAry = new sal_uInt8[ nNewSize ];
183 :
184 0 : if( bResize )
185 : {
186 : // Alte Flags kopieren
187 0 : if ( mnPoints < nNewSize )
188 : {
189 : // Neue Punkte mit 0 initialisieren
190 0 : memset( pNewFlagAry+mnPoints, 0, nNewSize-mnPoints );
191 0 : memcpy( pNewFlagAry, mpFlagAry, mnPoints );
192 : }
193 : else
194 0 : memcpy( pNewFlagAry, mpFlagAry, nNewSize );
195 : }
196 : }
197 : else
198 0 : pNewFlagAry = NULL;
199 :
200 0 : delete[] mpFlagAry;
201 0 : mpFlagAry = pNewFlagAry;
202 : }
203 :
204 0 : mpPointAry = pNewAry;
205 0 : mnPoints = nNewSize;
206 : }
207 :
208 0 : void ImplPolygon::ImplSplit( sal_uInt16 nPos, sal_uInt16 nSpace, ImplPolygon* pInitPoly )
209 : {
210 0 : const sal_uIntPtr nSpaceSize = nSpace * sizeof( Point );
211 :
212 : //Can't fit this in :-(, throw ?
213 0 : if (mnPoints + nSpace > USHRT_MAX)
214 0 : return;
215 :
216 0 : const sal_uInt16 nNewSize = mnPoints + nSpace;
217 :
218 0 : if( nPos >= mnPoints )
219 : {
220 : // Append at the back
221 0 : nPos = mnPoints;
222 0 : ImplSetSize( nNewSize, true );
223 :
224 0 : if( pInitPoly )
225 : {
226 0 : memcpy( mpPointAry + nPos, pInitPoly->mpPointAry, nSpaceSize );
227 :
228 0 : if( pInitPoly->mpFlagAry )
229 0 : memcpy( mpFlagAry + nPos, pInitPoly->mpFlagAry, nSpace );
230 : }
231 : }
232 : else
233 : {
234 0 : const sal_uInt16 nSecPos = nPos + nSpace;
235 0 : const sal_uInt16 nRest = mnPoints - nPos;
236 :
237 0 : Point* pNewAry = (Point*) new char[ (sal_uIntPtr) nNewSize * sizeof( Point ) ];
238 :
239 0 : memcpy( pNewAry, mpPointAry, nPos * sizeof( Point ) );
240 :
241 0 : if( pInitPoly )
242 0 : memcpy( pNewAry + nPos, pInitPoly->mpPointAry, nSpaceSize );
243 : else
244 0 : memset( pNewAry + nPos, 0, nSpaceSize );
245 :
246 0 : memcpy( pNewAry + nSecPos, mpPointAry + nPos, nRest * sizeof( Point ) );
247 0 : delete[] (char*) mpPointAry;
248 :
249 : // consider FlagArray
250 0 : if( mpFlagAry )
251 : {
252 0 : sal_uInt8* pNewFlagAry = new sal_uInt8[ nNewSize ];
253 :
254 0 : memcpy( pNewFlagAry, mpFlagAry, nPos );
255 :
256 0 : if( pInitPoly && pInitPoly->mpFlagAry )
257 0 : memcpy( pNewFlagAry + nPos, pInitPoly->mpFlagAry, nSpace );
258 : else
259 0 : memset( pNewFlagAry + nPos, 0, nSpace );
260 :
261 0 : memcpy( pNewFlagAry + nSecPos, mpFlagAry + nPos, nRest );
262 0 : delete[] mpFlagAry;
263 0 : mpFlagAry = pNewFlagAry;
264 : }
265 :
266 0 : mpPointAry = pNewAry;
267 0 : mnPoints = nNewSize;
268 : }
269 : }
270 :
271 0 : void ImplPolygon::ImplCreateFlagArray()
272 : {
273 0 : if( !mpFlagAry )
274 : {
275 0 : mpFlagAry = new sal_uInt8[ mnPoints ];
276 0 : memset( mpFlagAry, 0, mnPoints );
277 : }
278 0 : }
279 :
280 0 : inline void Polygon::ImplMakeUnique()
281 : {
282 : // copy references if any exist
283 0 : if ( mpImplPolygon->mnRefCount != 1 )
284 : {
285 0 : if ( mpImplPolygon->mnRefCount )
286 0 : mpImplPolygon->mnRefCount--;
287 0 : mpImplPolygon = new ImplPolygon( *mpImplPolygon );
288 : }
289 0 : }
290 :
291 0 : inline double ImplGetParameter( const Point& rCenter, const Point& rPt, double fWR, double fHR )
292 : {
293 0 : const long nDX = rPt.X() - rCenter.X();
294 0 : double fAngle = atan2( -rPt.Y() + rCenter.Y(), ( ( nDX == 0L ) ? 0.000000001 : nDX ) );
295 :
296 0 : return atan2(fWR*sin(fAngle), fHR*cos(fAngle));
297 : }
298 :
299 0 : Polygon::Polygon()
300 : {
301 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
302 0 : }
303 :
304 0 : Polygon::Polygon( sal_uInt16 nSize )
305 : {
306 :
307 0 : if ( nSize )
308 0 : mpImplPolygon = new ImplPolygon( nSize );
309 : else
310 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
311 0 : }
312 :
313 0 : Polygon::Polygon( sal_uInt16 nPoints, const Point* pPtAry, const sal_uInt8* pFlagAry )
314 : {
315 :
316 0 : if( nPoints )
317 0 : mpImplPolygon = new ImplPolygon( nPoints, pPtAry, pFlagAry );
318 : else
319 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
320 0 : }
321 :
322 0 : Polygon::Polygon( const Polygon& rPoly )
323 : {
324 : DBG_ASSERT( rPoly.mpImplPolygon->mnRefCount < 0xFFFFFFFE, "Polygon: RefCount overflow" );
325 :
326 0 : mpImplPolygon = rPoly.mpImplPolygon;
327 0 : if ( mpImplPolygon->mnRefCount )
328 0 : mpImplPolygon->mnRefCount++;
329 0 : }
330 :
331 0 : Polygon::Polygon( const Rectangle& rRect )
332 : {
333 :
334 0 : if ( rRect.IsEmpty() )
335 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
336 : else
337 : {
338 0 : mpImplPolygon = new ImplPolygon( 5 );
339 0 : mpImplPolygon->mpPointAry[0] = rRect.TopLeft();
340 0 : mpImplPolygon->mpPointAry[1] = rRect.TopRight();
341 0 : mpImplPolygon->mpPointAry[2] = rRect.BottomRight();
342 0 : mpImplPolygon->mpPointAry[3] = rRect.BottomLeft();
343 0 : mpImplPolygon->mpPointAry[4] = rRect.TopLeft();
344 : }
345 0 : }
346 :
347 0 : Polygon::Polygon( const Rectangle& rRect, sal_uIntPtr nHorzRound, sal_uIntPtr nVertRound )
348 : {
349 0 : if ( rRect.IsEmpty() )
350 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
351 : else
352 : {
353 0 : Rectangle aRect( rRect );
354 0 : aRect.Justify(); // SJ: i9140
355 :
356 0 : nHorzRound = std::min( nHorzRound, (sal_uIntPtr) labs( aRect.GetWidth() >> 1 ) );
357 0 : nVertRound = std::min( nVertRound, (sal_uIntPtr) labs( aRect.GetHeight() >> 1 ) );
358 :
359 0 : if( !nHorzRound && !nVertRound )
360 : {
361 0 : mpImplPolygon = new ImplPolygon( 5 );
362 0 : mpImplPolygon->mpPointAry[0] = aRect.TopLeft();
363 0 : mpImplPolygon->mpPointAry[1] = aRect.TopRight();
364 0 : mpImplPolygon->mpPointAry[2] = aRect.BottomRight();
365 0 : mpImplPolygon->mpPointAry[3] = aRect.BottomLeft();
366 0 : mpImplPolygon->mpPointAry[4] = aRect.TopLeft();
367 : }
368 : else
369 : {
370 0 : const Point aTL( aRect.Left() + nHorzRound, aRect.Top() + nVertRound );
371 0 : const Point aTR( aRect.Right() - nHorzRound, aRect.Top() + nVertRound );
372 0 : const Point aBR( aRect.Right() - nHorzRound, aRect.Bottom() - nVertRound );
373 0 : const Point aBL( aRect.Left() + nHorzRound, aRect.Bottom() - nVertRound );
374 0 : Polygon* pEllipsePoly = new Polygon( Point(), nHorzRound, nVertRound );
375 0 : sal_uInt16 i, nEnd, nSize4 = pEllipsePoly->GetSize() >> 2;
376 :
377 0 : mpImplPolygon = new ImplPolygon( pEllipsePoly->GetSize() + 1 );
378 :
379 0 : const Point* pSrcAry = pEllipsePoly->GetConstPointAry();
380 0 : Point* pDstAry = mpImplPolygon->mpPointAry;
381 :
382 0 : for( i = 0, nEnd = nSize4; i < nEnd; i++ )
383 0 : ( pDstAry[ i ] = pSrcAry[ i ] ) += aTR;
384 :
385 0 : for( nEnd = nEnd + nSize4; i < nEnd; i++ )
386 0 : ( pDstAry[ i ] = pSrcAry[ i ] ) += aTL;
387 :
388 0 : for( nEnd = nEnd + nSize4; i < nEnd; i++ )
389 0 : ( pDstAry[ i ] = pSrcAry[ i ] ) += aBL;
390 :
391 0 : for( nEnd = nEnd + nSize4; i < nEnd; i++ )
392 0 : ( pDstAry[ i ] = pSrcAry[ i ] ) += aBR;
393 :
394 0 : pDstAry[ nEnd ] = pDstAry[ 0 ];
395 0 : delete pEllipsePoly;
396 : }
397 : }
398 0 : }
399 :
400 0 : Polygon::Polygon( const Point& rCenter, long nRadX, long nRadY, sal_uInt16 nPoints )
401 : {
402 0 : if( nRadX && nRadY )
403 : {
404 : // Compute default (depends on size)
405 0 : if( !nPoints )
406 : {
407 0 : nPoints = (sal_uInt16) ( F_PI * ( 1.5 * ( nRadX + nRadY ) -
408 0 : sqrt( (double) labs( nRadX * nRadY ) ) ) );
409 :
410 0 : nPoints = (sal_uInt16) MinMax( nPoints, 32, 256 );
411 :
412 0 : if( ( nRadX > 32 ) && ( nRadY > 32 ) && ( nRadX + nRadY ) < 8192 )
413 0 : nPoints >>= 1;
414 : }
415 :
416 : // Ceil number of points until divisible by four
417 0 : mpImplPolygon = new ImplPolygon( nPoints = (nPoints + 3) & ~3 );
418 :
419 : Point* pPt;
420 : sal_uInt16 i;
421 0 : sal_uInt16 nPoints2 = nPoints >> 1;
422 0 : sal_uInt16 nPoints4 = nPoints >> 2;
423 : double nAngle;
424 0 : double nAngleStep = F_PI2 / ( nPoints4 - 1 );
425 :
426 0 : for( i=0, nAngle = 0.0; i < nPoints4; i++, nAngle += nAngleStep )
427 : {
428 0 : long nX = FRound( nRadX * cos( nAngle ) );
429 0 : long nY = FRound( -nRadY * sin( nAngle ) );
430 :
431 0 : pPt = &(mpImplPolygon->mpPointAry[i]);
432 0 : pPt->X() = nX + rCenter.X();
433 0 : pPt->Y() = nY + rCenter.Y();
434 0 : pPt = &(mpImplPolygon->mpPointAry[nPoints2-i-1]);
435 0 : pPt->X() = -nX + rCenter.X();
436 0 : pPt->Y() = nY + rCenter.Y();
437 0 : pPt = &(mpImplPolygon->mpPointAry[i+nPoints2]);
438 0 : pPt->X() = -nX + rCenter.X();
439 0 : pPt->Y() = -nY + rCenter.Y();
440 0 : pPt = &(mpImplPolygon->mpPointAry[nPoints-i-1]);
441 0 : pPt->X() = nX + rCenter.X();
442 0 : pPt->Y() = -nY + rCenter.Y();
443 0 : }
444 : }
445 : else
446 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
447 0 : }
448 :
449 0 : Polygon::Polygon( const Rectangle& rBound, const Point& rStart, const Point& rEnd,
450 : PolyStyle eStyle, bool bFullCircle )
451 : {
452 0 : const long nWidth = rBound.GetWidth();
453 0 : const long nHeight = rBound.GetHeight();
454 :
455 0 : if( ( nWidth > 1 ) && ( nHeight > 1 ) )
456 : {
457 0 : const Point aCenter( rBound.Center() );
458 0 : const long nRadX = aCenter.X() - rBound.Left();
459 0 : const long nRadY = aCenter.Y() - rBound.Top();
460 : sal_uInt16 nPoints;
461 :
462 0 : nPoints = (sal_uInt16) ( F_PI * ( 1.5 * ( nRadX + nRadY ) -
463 0 : sqrt( (double) labs( nRadX * nRadY ) ) ) );
464 :
465 0 : nPoints = (sal_uInt16) MinMax( nPoints, 32, 256 );
466 :
467 0 : if( ( nRadX > 32 ) && ( nRadY > 32 ) && ( nRadX + nRadY ) < 8192 )
468 0 : nPoints >>= 1;
469 :
470 : // compute threshold
471 0 : const double fRadX = nRadX;
472 0 : const double fRadY = nRadY;
473 0 : const double fCenterX = aCenter.X();
474 0 : const double fCenterY = aCenter.Y();
475 0 : double fStart = ImplGetParameter( aCenter, rStart, fRadX, fRadY );
476 0 : double fEnd = ImplGetParameter( aCenter, rEnd, fRadX, fRadY );
477 0 : double fDiff = fEnd - fStart;
478 : double fStep;
479 : sal_uInt16 nStart;
480 : sal_uInt16 nEnd;
481 :
482 0 : if( fDiff < 0. )
483 0 : fDiff += F_2PI;
484 :
485 0 : if ( bFullCircle )
486 0 : fDiff = F_2PI;
487 :
488 : // Proportionally shrink number of points( fDiff / (2PI) );
489 0 : nPoints = std::max( (sal_uInt16) ( ( fDiff * 0.1591549 ) * nPoints ), (sal_uInt16) 16 );
490 0 : fStep = fDiff / ( nPoints - 1 );
491 :
492 0 : if( POLY_PIE == eStyle )
493 : {
494 0 : const Point aCenter2( FRound( fCenterX ), FRound( fCenterY ) );
495 :
496 0 : nStart = 1;
497 0 : nEnd = nPoints + 1;
498 0 : mpImplPolygon = new ImplPolygon( nPoints + 2 );
499 0 : mpImplPolygon->mpPointAry[ 0 ] = aCenter2;
500 0 : mpImplPolygon->mpPointAry[ nEnd ] = aCenter2;
501 : }
502 : else
503 : {
504 0 : mpImplPolygon = new ImplPolygon( ( POLY_CHORD == eStyle ) ? ( nPoints + 1 ) : nPoints );
505 0 : nStart = 0;
506 0 : nEnd = nPoints;
507 : }
508 :
509 0 : for(; nStart < nEnd; nStart++, fStart += fStep )
510 : {
511 0 : Point& rPt = mpImplPolygon->mpPointAry[ nStart ];
512 :
513 0 : rPt.X() = FRound( fCenterX + fRadX * cos( fStart ) );
514 0 : rPt.Y() = FRound( fCenterY - fRadY * sin( fStart ) );
515 : }
516 :
517 0 : if( POLY_CHORD == eStyle )
518 0 : mpImplPolygon->mpPointAry[ nPoints ] = mpImplPolygon->mpPointAry[ 0 ];
519 : }
520 : else
521 0 : mpImplPolygon = (ImplPolygon*) &aStaticImplPolygon;
522 0 : }
523 :
524 0 : Polygon::Polygon( const Point& rBezPt1, const Point& rCtrlPt1,
525 : const Point& rBezPt2, const Point& rCtrlPt2,
526 : sal_uInt16 nPoints )
527 : {
528 0 : nPoints = ( 0 == nPoints ) ? 25 : ( ( nPoints < 2 ) ? 2 : nPoints );
529 :
530 0 : const double fInc = 1.0 / ( nPoints - 1 );
531 0 : double fK_1 = 0.0, fK1_1 = 1.0;
532 : double fK_2, fK_3, fK1_2, fK1_3, fK12, fK21;
533 0 : const double fX0 = rBezPt1.X();
534 0 : const double fY0 = rBezPt1.Y();
535 0 : const double fX1 = 3.0 * rCtrlPt1.X();
536 0 : const double fY1 = 3.0 * rCtrlPt1.Y();
537 0 : const double fX2 = 3.0 * rCtrlPt2.X();
538 0 : const double fY2 = 3.0 * rCtrlPt2.Y();
539 0 : const double fX3 = rBezPt2.X();
540 0 : const double fY3 = rBezPt2.Y();
541 :
542 0 : mpImplPolygon = new ImplPolygon( nPoints );
543 :
544 0 : for( sal_uInt16 i = 0; i < nPoints; i++, fK_1 += fInc, fK1_1 -= fInc )
545 : {
546 0 : Point& rPt = mpImplPolygon->mpPointAry[ i ];
547 :
548 0 : fK_2 = fK_1, fK_3 = ( fK_2 *= fK_1 ), fK_3 *= fK_1;
549 0 : fK1_2 = fK1_1, fK1_3 = ( fK1_2 *= fK1_1 ), fK1_3 *= fK1_1;
550 0 : fK12 = fK_1 * fK1_2, fK21 = fK_2 * fK1_1;
551 :
552 0 : rPt.X() = FRound( fK1_3 * fX0 + fK12 * fX1 + fK21 * fX2 + fK_3 * fX3 );
553 0 : rPt.Y() = FRound( fK1_3 * fY0 + fK12 * fY1 + fK21 * fY2 + fK_3 * fY3 );
554 : }
555 0 : }
556 :
557 0 : Polygon::~Polygon()
558 : {
559 :
560 : // Remove if refcount == 0, otherwise decrement refcount
561 0 : if ( mpImplPolygon->mnRefCount )
562 : {
563 0 : if ( mpImplPolygon->mnRefCount > 1 )
564 0 : mpImplPolygon->mnRefCount--;
565 : else
566 0 : delete mpImplPolygon;
567 : }
568 0 : }
569 :
570 0 : const Point* Polygon::GetConstPointAry() const
571 : {
572 0 : return (Point*)mpImplPolygon->mpPointAry;
573 : }
574 :
575 0 : const sal_uInt8* Polygon::GetConstFlagAry() const
576 : {
577 0 : return mpImplPolygon->mpFlagAry;
578 : }
579 :
580 0 : void Polygon::SetPoint( const Point& rPt, sal_uInt16 nPos )
581 : {
582 : DBG_ASSERT( nPos < mpImplPolygon->mnPoints,
583 : "Polygon::SetPoint(): nPos >= nPoints" );
584 :
585 0 : ImplMakeUnique();
586 0 : mpImplPolygon->mpPointAry[nPos] = rPt;
587 0 : }
588 :
589 0 : void Polygon::SetFlags( sal_uInt16 nPos, PolyFlags eFlags )
590 : {
591 : DBG_ASSERT( nPos < mpImplPolygon->mnPoints,
592 : "Polygon::SetFlags(): nPos >= nPoints" );
593 :
594 : // we do only want to create the flag array if there
595 : // is at least one flag different to POLY_NORMAL
596 0 : if ( mpImplPolygon || ( eFlags != POLY_NORMAL ) )
597 : {
598 0 : ImplMakeUnique();
599 0 : mpImplPolygon->ImplCreateFlagArray();
600 0 : mpImplPolygon->mpFlagAry[ nPos ] = (sal_uInt8) eFlags;
601 : }
602 0 : }
603 :
604 0 : const Point& Polygon::GetPoint( sal_uInt16 nPos ) const
605 : {
606 : DBG_ASSERT( nPos < mpImplPolygon->mnPoints,
607 : "Polygon::GetPoint(): nPos >= nPoints" );
608 :
609 0 : return mpImplPolygon->mpPointAry[nPos];
610 : }
611 :
612 0 : PolyFlags Polygon::GetFlags( sal_uInt16 nPos ) const
613 : {
614 : DBG_ASSERT( nPos < mpImplPolygon->mnPoints,
615 : "Polygon::GetFlags(): nPos >= nPoints" );
616 : return( mpImplPolygon->mpFlagAry ?
617 0 : (PolyFlags) mpImplPolygon->mpFlagAry[ nPos ] :
618 0 : POLY_NORMAL );
619 : }
620 :
621 0 : bool Polygon::HasFlags() const
622 : {
623 0 : return mpImplPolygon->mpFlagAry != NULL;
624 : }
625 :
626 0 : bool Polygon::IsRect() const
627 : {
628 0 : bool bIsRect = false;
629 0 : if ( mpImplPolygon->mpFlagAry == NULL )
630 : {
631 0 : if ( ( ( mpImplPolygon->mnPoints == 5 ) && ( mpImplPolygon->mpPointAry[ 0 ] == mpImplPolygon->mpPointAry[ 4 ] ) ) ||
632 0 : ( mpImplPolygon->mnPoints == 4 ) )
633 : {
634 0 : if ( ( mpImplPolygon->mpPointAry[ 0 ].X() == mpImplPolygon->mpPointAry[ 3 ].X() ) &&
635 0 : ( mpImplPolygon->mpPointAry[ 0 ].Y() == mpImplPolygon->mpPointAry[ 1 ].Y() ) &&
636 0 : ( mpImplPolygon->mpPointAry[ 1 ].X() == mpImplPolygon->mpPointAry[ 2 ].X() ) &&
637 0 : ( mpImplPolygon->mpPointAry[ 2 ].Y() == mpImplPolygon->mpPointAry[ 3 ].Y() ) )
638 0 : bIsRect = true;
639 : }
640 : }
641 0 : return bIsRect;
642 : }
643 :
644 0 : void Polygon::SetSize( sal_uInt16 nNewSize )
645 : {
646 0 : if( nNewSize != mpImplPolygon->mnPoints )
647 : {
648 0 : ImplMakeUnique();
649 0 : mpImplPolygon->ImplSetSize( nNewSize );
650 : }
651 0 : }
652 :
653 0 : sal_uInt16 Polygon::GetSize() const
654 : {
655 0 : return mpImplPolygon->mnPoints;
656 : }
657 :
658 0 : void Polygon::Clear()
659 : {
660 0 : if ( mpImplPolygon->mnRefCount )
661 : {
662 0 : if ( mpImplPolygon->mnRefCount > 1 )
663 0 : mpImplPolygon->mnRefCount--;
664 : else
665 0 : delete mpImplPolygon;
666 : }
667 :
668 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
669 0 : }
670 :
671 0 : double Polygon::CalcDistance( sal_uInt16 nP1, sal_uInt16 nP2 )
672 : {
673 : DBG_ASSERT( nP1 < mpImplPolygon->mnPoints,
674 : "Polygon::CalcDistance(): nPos1 >= nPoints" );
675 : DBG_ASSERT( nP2 < mpImplPolygon->mnPoints,
676 : "Polygon::CalcDistance(): nPos2 >= nPoints" );
677 :
678 0 : const Point& rP1 = mpImplPolygon->mpPointAry[ nP1 ];
679 0 : const Point& rP2 = mpImplPolygon->mpPointAry[ nP2 ];
680 0 : const double fDx = rP2.X() - rP1.X();
681 0 : const double fDy = rP2.Y() - rP1.Y();
682 :
683 0 : return sqrt( fDx * fDx + fDy * fDy );
684 : }
685 :
686 0 : void Polygon::Optimize( sal_uIntPtr nOptimizeFlags, const PolyOptimizeData* pData )
687 : {
688 : DBG_ASSERT( !mpImplPolygon->mpFlagAry, "Optimizing could fail with beziers!" );
689 :
690 0 : sal_uInt16 nSize = mpImplPolygon->mnPoints;
691 :
692 0 : if( nOptimizeFlags && nSize )
693 : {
694 0 : if( nOptimizeFlags & POLY_OPTIMIZE_EDGES )
695 : {
696 0 : const Rectangle aBound( GetBoundRect() );
697 0 : const double fArea = ( aBound.GetWidth() + aBound.GetHeight() ) * 0.5;
698 0 : const sal_uInt16 nPercent = pData ? pData->GetPercentValue() : 50;
699 :
700 0 : Optimize( POLY_OPTIMIZE_NO_SAME );
701 0 : ImplReduceEdges( *this, fArea, nPercent );
702 : }
703 0 : else if( nOptimizeFlags & ( POLY_OPTIMIZE_REDUCE | POLY_OPTIMIZE_NO_SAME ) )
704 : {
705 0 : Polygon aNewPoly;
706 0 : const Point& rFirst = mpImplPolygon->mpPointAry[ 0 ];
707 : sal_uIntPtr nReduce;
708 :
709 0 : if( nOptimizeFlags & ( POLY_OPTIMIZE_REDUCE ) )
710 0 : nReduce = pData ? pData->GetAbsValue() : 4UL;
711 : else
712 0 : nReduce = 0UL;
713 :
714 0 : while( nSize && ( mpImplPolygon->mpPointAry[ nSize - 1 ] == rFirst ) )
715 0 : nSize--;
716 :
717 0 : if( nSize > 1 )
718 : {
719 0 : sal_uInt16 nLast = 0, nNewCount = 1;
720 :
721 0 : aNewPoly.SetSize( nSize );
722 0 : aNewPoly[ 0 ] = rFirst;
723 :
724 0 : for( sal_uInt16 i = 1; i < nSize; i++ )
725 : {
726 0 : if( ( mpImplPolygon->mpPointAry[ i ] != mpImplPolygon->mpPointAry[ nLast ] ) &&
727 0 : ( !nReduce || ( nReduce < (sal_uIntPtr) FRound( CalcDistance( nLast, i ) ) ) ) )
728 : {
729 0 : aNewPoly[ nNewCount++ ] = mpImplPolygon->mpPointAry[ nLast = i ];
730 : }
731 : }
732 :
733 0 : if( nNewCount == 1 )
734 0 : aNewPoly.Clear();
735 : else
736 0 : aNewPoly.SetSize( nNewCount );
737 : }
738 :
739 0 : *this = aNewPoly;
740 : }
741 :
742 0 : nSize = mpImplPolygon->mnPoints;
743 :
744 0 : if( nSize > 1 )
745 : {
746 0 : if( ( nOptimizeFlags & POLY_OPTIMIZE_CLOSE ) &&
747 0 : ( mpImplPolygon->mpPointAry[ 0 ] != mpImplPolygon->mpPointAry[ nSize - 1 ] ) )
748 : {
749 0 : SetSize( mpImplPolygon->mnPoints + 1 );
750 0 : mpImplPolygon->mpPointAry[ mpImplPolygon->mnPoints - 1 ] = mpImplPolygon->mpPointAry[ 0 ];
751 : }
752 0 : else if( ( nOptimizeFlags & POLY_OPTIMIZE_OPEN ) &&
753 0 : ( mpImplPolygon->mpPointAry[ 0 ] == mpImplPolygon->mpPointAry[ nSize - 1 ] ) )
754 : {
755 0 : const Point& rFirst = mpImplPolygon->mpPointAry[ 0 ];
756 :
757 0 : while( nSize && ( mpImplPolygon->mpPointAry[ nSize - 1 ] == rFirst ) )
758 0 : nSize--;
759 :
760 0 : SetSize( nSize );
761 : }
762 : }
763 : }
764 0 : }
765 :
766 :
767 : /** Recursively subdivide cubic bezier curve via deCasteljau.
768 :
769 : @param rPointIter
770 : Output iterator, where the subdivided polylines are written to.
771 :
772 : @param d
773 : Squared difference of curve to a straight line
774 :
775 : @param P*
776 : Exactly four points, interpreted as support and control points of
777 : a cubic bezier curve. Must be in device coordinates, since stop
778 : criterion is based on the following assumption: the device has a
779 : finite resolution, it is thus sufficient to stop subdivision if the
780 : curve does not deviate more than one pixel from a straight line.
781 :
782 : */
783 0 : static void ImplAdaptiveSubdivide( ::std::back_insert_iterator< ::std::vector< Point > >& rPointIter,
784 : const double old_d2,
785 : int recursionDepth,
786 : const double d2,
787 : const double P1x, const double P1y,
788 : const double P2x, const double P2y,
789 : const double P3x, const double P3y,
790 : const double P4x, const double P4y )
791 : {
792 : // Hard limit on recursion depth, empiric number.
793 : enum {maxRecursionDepth=128};
794 :
795 : // Perform bezier flatness test (lecture notes from R. Schaback,
796 : // Mathematics of Computer-Aided Design, Uni Goettingen, 2000)
797 :
798 : // ||P(t) - L(t)|| <= max ||b_j - b_0 - j/n(b_n - b_0)||
799 : // 0<=j<=n
800 :
801 : // What is calculated here is an upper bound to the distance from
802 : // a line through b_0 and b_3 (P1 and P4 in our notation) and the
803 : // curve. We can drop 0 and n from the running indices, since the
804 : // argument of max becomes zero for those cases.
805 0 : const double fJ1x( P2x - P1x - 1.0/3.0*(P4x - P1x) );
806 0 : const double fJ1y( P2y - P1y - 1.0/3.0*(P4y - P1y) );
807 0 : const double fJ2x( P3x - P1x - 2.0/3.0*(P4x - P1x) );
808 0 : const double fJ2y( P3y - P1y - 2.0/3.0*(P4y - P1y) );
809 0 : const double distance2( ::std::max( fJ1x*fJ1x + fJ1y*fJ1y,
810 0 : fJ2x*fJ2x + fJ2y*fJ2y) );
811 :
812 : // stop if error measure does not improve anymore. This is a
813 : // safety guard against floating point inaccuracies.
814 : // stop at recursion level 128. This is a safety guard against
815 : // floating point inaccuracies.
816 : // stop if distance from line is guaranteed to be bounded by d
817 0 : if( old_d2 > d2 &&
818 0 : recursionDepth < maxRecursionDepth &&
819 : distance2 >= d2 )
820 : {
821 : // deCasteljau bezier arc, split at t=0.5
822 : // Foley/vanDam, p. 508
823 0 : const double L1x( P1x ), L1y( P1y );
824 0 : const double L2x( (P1x + P2x)*0.5 ), L2y( (P1y + P2y)*0.5 );
825 0 : const double Hx ( (P2x + P3x)*0.5 ), Hy ( (P2y + P3y)*0.5 );
826 0 : const double L3x( (L2x + Hx)*0.5 ), L3y( (L2y + Hy)*0.5 );
827 0 : const double R4x( P4x ), R4y( P4y );
828 0 : const double R3x( (P3x + P4x)*0.5 ), R3y( (P3y + P4y)*0.5 );
829 0 : const double R2x( (Hx + R3x)*0.5 ), R2y( (Hy + R3y)*0.5 );
830 0 : const double R1x( (L3x + R2x)*0.5 ), R1y( (L3y + R2y)*0.5 );
831 0 : const double L4x( R1x ), L4y( R1y );
832 :
833 : // subdivide further
834 0 : ++recursionDepth;
835 0 : ImplAdaptiveSubdivide(rPointIter, distance2, recursionDepth, d2, L1x, L1y, L2x, L2y, L3x, L3y, L4x, L4y);
836 0 : ImplAdaptiveSubdivide(rPointIter, distance2, recursionDepth, d2, R1x, R1y, R2x, R2y, R3x, R3y, R4x, R4y);
837 : }
838 : else
839 : {
840 : // requested resolution reached.
841 : // Add end points to output iterator.
842 : // order is preserved, since this is so to say depth first traversal.
843 0 : *rPointIter++ = Point( FRound(P1x), FRound(P1y) );
844 : }
845 0 : }
846 :
847 0 : void Polygon::AdaptiveSubdivide( Polygon& rResult, const double d ) const
848 : {
849 0 : if( !mpImplPolygon->mpFlagAry )
850 : {
851 0 : rResult = *this;
852 : }
853 : else
854 : {
855 : sal_uInt16 i;
856 0 : sal_uInt16 nPts( GetSize() );
857 0 : ::std::vector< Point > aPoints;
858 0 : aPoints.reserve( nPts );
859 0 : ::std::back_insert_iterator< ::std::vector< Point > > aPointIter( aPoints );
860 :
861 0 : for(i=0; i<nPts;)
862 : {
863 0 : if( ( i + 3 ) < nPts )
864 : {
865 0 : sal_uInt8 P1( mpImplPolygon->mpFlagAry[ i ] );
866 0 : sal_uInt8 P4( mpImplPolygon->mpFlagAry[ i + 3 ] );
867 :
868 0 : if( ( POLY_NORMAL == P1 || POLY_SMOOTH == P1 || POLY_SYMMTR == P1 ) &&
869 0 : ( POLY_CONTROL == mpImplPolygon->mpFlagAry[ i + 1 ] ) &&
870 0 : ( POLY_CONTROL == mpImplPolygon->mpFlagAry[ i + 2 ] ) &&
871 0 : ( POLY_NORMAL == P4 || POLY_SMOOTH == P4 || POLY_SYMMTR == P4 ) )
872 : {
873 0 : ImplAdaptiveSubdivide( aPointIter, d*d+1.0, 0, d*d,
874 0 : mpImplPolygon->mpPointAry[ i ].X(), mpImplPolygon->mpPointAry[ i ].Y(),
875 0 : mpImplPolygon->mpPointAry[ i+1 ].X(), mpImplPolygon->mpPointAry[ i+1 ].Y(),
876 0 : mpImplPolygon->mpPointAry[ i+2 ].X(), mpImplPolygon->mpPointAry[ i+2 ].Y(),
877 0 : mpImplPolygon->mpPointAry[ i+3 ].X(), mpImplPolygon->mpPointAry[ i+3 ].Y() );
878 0 : i += 3;
879 0 : continue;
880 : }
881 : }
882 :
883 0 : *aPointIter++ = mpImplPolygon->mpPointAry[ i++ ];
884 :
885 0 : if (aPoints.size() >= SAL_MAX_UINT16)
886 : {
887 : OSL_ENSURE(aPoints.size() < SAL_MAX_UINT16,
888 : "Polygon::AdapativeSubdivision created polygon too many points;"
889 : " using original polygon instead");
890 :
891 : // The resulting polygon can not hold all the points
892 : // that we have created so far. Stop the subdivision
893 : // and return a copy of the unmodified polygon.
894 0 : rResult = *this;
895 0 : return;
896 : }
897 : }
898 :
899 : // fill result polygon
900 0 : rResult = Polygon( (sal_uInt16)aPoints.size() ); // ensure sufficient size for copy
901 0 : ::std::copy(aPoints.begin(), aPoints.end(), rResult.mpImplPolygon->mpPointAry);
902 : }
903 : }
904 :
905 0 : void Polygon::ImplReduceEdges( Polygon& rPoly, const double& rArea, sal_uInt16 nPercent )
906 : {
907 0 : const double fBound = 2000.0 * ( 100 - nPercent ) * 0.01;
908 0 : sal_uInt16 nNumNoChange = 0,
909 0 : nNumRuns = 0;
910 :
911 0 : while( nNumNoChange < 2 )
912 : {
913 0 : sal_uInt16 nPntCnt = rPoly.GetSize(), nNewPos = 0;
914 0 : Polygon aNewPoly( nPntCnt );
915 0 : bool bChangeInThisRun = false;
916 :
917 0 : for( sal_uInt16 n = 0; n < nPntCnt; n++ )
918 : {
919 0 : bool bDeletePoint = false;
920 :
921 0 : if( ( n + nNumRuns ) % 2 )
922 : {
923 0 : sal_uInt16 nIndPrev = !n ? nPntCnt - 1 : n - 1;
924 0 : sal_uInt16 nIndPrevPrev = !nIndPrev ? nPntCnt - 1 : nIndPrev - 1;
925 0 : sal_uInt16 nIndNext = ( n == nPntCnt-1 ) ? 0 : n + 1;
926 0 : sal_uInt16 nIndNextNext = ( nIndNext == nPntCnt - 1 ) ? 0 : nIndNext + 1;
927 0 : Vector2D aVec1( rPoly[ nIndPrev ] ); aVec1 -= rPoly[ nIndPrevPrev ];
928 0 : Vector2D aVec2( rPoly[ n ] ); aVec2 -= rPoly[ nIndPrev ];
929 0 : Vector2D aVec3( rPoly[ nIndNext ] ); aVec3 -= rPoly[ n ];
930 0 : Vector2D aVec4( rPoly[ nIndNextNext ] ); aVec4 -= rPoly[ nIndNext ];
931 0 : double fDist1 = aVec1.GetLength(), fDist2 = aVec2.GetLength();
932 0 : double fDist3 = aVec3.GetLength(), fDist4 = aVec4.GetLength();
933 0 : double fTurnB = aVec2.Normalize().Scalar( aVec3.Normalize() );
934 :
935 0 : if( fabs( fTurnB ) < ( 1.0 + SMALL_DVALUE ) && fabs( fTurnB ) > ( 1.0 - SMALL_DVALUE ) )
936 0 : bDeletePoint = true;
937 : else
938 : {
939 0 : Vector2D aVecB( rPoly[ nIndNext ] );
940 0 : double fDistB = ( aVecB -= rPoly[ nIndPrev ] ).GetLength();
941 0 : double fLenWithB = fDist2 + fDist3;
942 0 : double fLenFact = ( fDistB != 0.0 ) ? fLenWithB / fDistB : 1.0;
943 0 : double fTurnPrev = aVec1.Normalize().Scalar( aVec2 );
944 0 : double fTurnNext = aVec3.Scalar( aVec4.Normalize() );
945 : double fGradPrev, fGradB, fGradNext;
946 :
947 0 : if( fabs( fTurnPrev ) < ( 1.0 + SMALL_DVALUE ) && fabs( fTurnPrev ) > ( 1.0 - SMALL_DVALUE ) )
948 0 : fGradPrev = 0.0;
949 : else
950 0 : fGradPrev = acos( fTurnPrev ) / ( aVec1.IsNegative( aVec2 ) ? -F_PI180 : F_PI180 );
951 :
952 0 : fGradB = acos( fTurnB ) / ( aVec2.IsNegative( aVec3 ) ? -F_PI180 : F_PI180 );
953 :
954 0 : if( fabs( fTurnNext ) < ( 1.0 + SMALL_DVALUE ) && fabs( fTurnNext ) > ( 1.0 - SMALL_DVALUE ) )
955 0 : fGradNext = 0.0;
956 : else
957 0 : fGradNext = acos( fTurnNext ) / ( aVec3.IsNegative( aVec4 ) ? -F_PI180 : F_PI180 );
958 :
959 0 : if( ( fGradPrev > 0.0 && fGradB < 0.0 && fGradNext > 0.0 ) ||
960 0 : ( fGradPrev < 0.0 && fGradB > 0.0 && fGradNext < 0.0 ) )
961 : {
962 0 : if( ( fLenFact < ( FSQRT2 + SMALL_DVALUE ) ) &&
963 0 : ( ( ( fDist1 + fDist4 ) / ( fDist2 + fDist3 ) ) * 2000.0 ) > fBound )
964 : {
965 0 : bDeletePoint = true;
966 : }
967 : }
968 : else
969 : {
970 0 : double fRelLen = 1.0 - sqrt( fDistB / rArea );
971 :
972 0 : if( fRelLen < 0.0 )
973 0 : fRelLen = 0.0;
974 0 : else if( fRelLen > 1.0 )
975 0 : fRelLen = 1.0;
976 :
977 0 : if( ( (sal_uInt32) ( ( ( fLenFact - 1.0 ) * 1000000.0 ) + 0.5 ) < fBound ) &&
978 0 : ( fabs( fGradB ) <= ( fRelLen * fBound * 0.01 ) ) )
979 : {
980 0 : bDeletePoint = true;
981 : }
982 0 : }
983 0 : }
984 : }
985 :
986 0 : if( !bDeletePoint )
987 0 : aNewPoly[ nNewPos++ ] = rPoly[ n ];
988 : else
989 0 : bChangeInThisRun = true;
990 : }
991 :
992 0 : if( bChangeInThisRun && nNewPos )
993 : {
994 0 : aNewPoly.SetSize( nNewPos );
995 0 : rPoly = aNewPoly;
996 0 : nNumNoChange = 0;
997 : }
998 : else
999 0 : nNumNoChange++;
1000 :
1001 0 : nNumRuns++;
1002 0 : }
1003 0 : }
1004 :
1005 0 : void Polygon::Move( long nHorzMove, long nVertMove )
1006 : {
1007 : // This check is required for DrawEngine
1008 0 : if ( !nHorzMove && !nVertMove )
1009 0 : return;
1010 :
1011 0 : ImplMakeUnique();
1012 :
1013 : // Move points
1014 0 : sal_uInt16 nCount = mpImplPolygon->mnPoints;
1015 0 : for ( sal_uInt16 i = 0; i < nCount; i++ )
1016 : {
1017 0 : Point* pPt = &(mpImplPolygon->mpPointAry[i]);
1018 0 : pPt->X() += nHorzMove;
1019 0 : pPt->Y() += nVertMove;
1020 : }
1021 : }
1022 :
1023 0 : void Polygon::Translate(const Point& rTrans)
1024 : {
1025 0 : ImplMakeUnique();
1026 :
1027 0 : for ( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
1028 0 : mpImplPolygon->mpPointAry[ i ] += rTrans;
1029 0 : }
1030 :
1031 0 : void Polygon::Scale( double fScaleX, double fScaleY )
1032 : {
1033 0 : ImplMakeUnique();
1034 :
1035 0 : for ( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
1036 : {
1037 0 : Point& rPnt = mpImplPolygon->mpPointAry[i];
1038 0 : rPnt.X() = (long) ( fScaleX * rPnt.X() );
1039 0 : rPnt.Y() = (long) ( fScaleY * rPnt.Y() );
1040 : }
1041 0 : }
1042 :
1043 0 : void Polygon::Rotate( const Point& rCenter, sal_uInt16 nAngle10 )
1044 : {
1045 0 : nAngle10 %= 3600;
1046 :
1047 0 : if( nAngle10 )
1048 : {
1049 0 : const double fAngle = F_PI1800 * nAngle10;
1050 0 : Rotate( rCenter, sin( fAngle ), cos( fAngle ) );
1051 : }
1052 0 : }
1053 :
1054 0 : void Polygon::Rotate( const Point& rCenter, double fSin, double fCos )
1055 : {
1056 0 : ImplMakeUnique();
1057 :
1058 : long nX, nY;
1059 0 : long nCenterX = rCenter.X();
1060 0 : long nCenterY = rCenter.Y();
1061 :
1062 0 : for( sal_uInt16 i = 0, nCount = mpImplPolygon->mnPoints; i < nCount; i++ )
1063 : {
1064 0 : Point& rPt = mpImplPolygon->mpPointAry[ i ];
1065 :
1066 0 : nX = rPt.X() - nCenterX;
1067 0 : nY = rPt.Y() - nCenterY;
1068 0 : rPt.X() = (long) FRound( fCos * nX + fSin * nY ) + nCenterX;
1069 0 : rPt.Y() = -(long) FRound( fSin * nX - fCos * nY ) + nCenterY;
1070 : }
1071 0 : }
1072 :
1073 0 : class ImplPointFilter
1074 : {
1075 : public:
1076 : virtual void LastPoint() = 0;
1077 : virtual void Input( const Point& rPoint ) = 0;
1078 :
1079 : protected:
1080 0 : ~ImplPointFilter() {}
1081 : };
1082 :
1083 : class ImplPolygonPointFilter : public ImplPointFilter
1084 : {
1085 : public:
1086 : ImplPolygon* mpPoly; // Don't remove, assigned by polygon
1087 : sal_uInt16 mnSize;
1088 :
1089 0 : ImplPolygonPointFilter( sal_uInt16 nDestSize ) :
1090 0 : mnSize( 0 )
1091 : {
1092 0 : mpPoly = new ImplPolygon( nDestSize );
1093 0 : }
1094 :
1095 0 : virtual ~ImplPolygonPointFilter() {}
1096 :
1097 : virtual void LastPoint() SAL_OVERRIDE;
1098 : virtual void Input( const Point& rPoint ) SAL_OVERRIDE;
1099 : };
1100 :
1101 0 : void ImplPolygonPointFilter::Input( const Point& rPoint )
1102 : {
1103 0 : if ( !mnSize || (rPoint != mpPoly->mpPointAry[mnSize-1]) )
1104 : {
1105 0 : mnSize++;
1106 0 : if ( mnSize > mpPoly->mnPoints )
1107 0 : mpPoly->ImplSetSize( mnSize );
1108 0 : mpPoly->mpPointAry[mnSize-1] = rPoint;
1109 : }
1110 0 : }
1111 :
1112 0 : void ImplPolygonPointFilter::LastPoint()
1113 : {
1114 0 : if ( mnSize < mpPoly->mnPoints )
1115 0 : mpPoly->ImplSetSize( mnSize );
1116 0 : };
1117 :
1118 : class ImplEdgePointFilter : public ImplPointFilter
1119 : {
1120 : Point maFirstPoint;
1121 : Point maLastPoint;
1122 : ImplPointFilter& mrNextFilter;
1123 : const long mnLow;
1124 : const long mnHigh;
1125 : const int mnEdge;
1126 : int mnLastOutside;
1127 : bool mbFirst;
1128 :
1129 : public:
1130 0 : ImplEdgePointFilter( int nEdge, long nLow, long nHigh,
1131 : ImplPointFilter& rNextFilter ) :
1132 : mrNextFilter( rNextFilter ),
1133 : mnLow( nLow ),
1134 : mnHigh( nHigh ),
1135 : mnEdge( nEdge ),
1136 : mnLastOutside( 0 ),
1137 0 : mbFirst( true )
1138 : {
1139 0 : }
1140 :
1141 0 : virtual ~ImplEdgePointFilter() {}
1142 :
1143 : Point EdgeSection( const Point& rPoint, int nEdge ) const;
1144 : int VisibleSide( const Point& rPoint ) const;
1145 0 : bool IsPolygon() const
1146 0 : { return maFirstPoint == maLastPoint; }
1147 :
1148 : virtual void Input( const Point& rPoint ) SAL_OVERRIDE;
1149 : virtual void LastPoint() SAL_OVERRIDE;
1150 : };
1151 :
1152 0 : inline int ImplEdgePointFilter::VisibleSide( const Point& rPoint ) const
1153 : {
1154 0 : if ( mnEdge & EDGE_HORZ )
1155 : {
1156 0 : return rPoint.X() < mnLow ? EDGE_LEFT :
1157 0 : rPoint.X() > mnHigh ? EDGE_RIGHT : 0;
1158 : }
1159 : else
1160 : {
1161 0 : return rPoint.Y() < mnLow ? EDGE_TOP :
1162 0 : rPoint.Y() > mnHigh ? EDGE_BOTTOM : 0;
1163 : }
1164 : }
1165 :
1166 0 : Point ImplEdgePointFilter::EdgeSection( const Point& rPoint, int nEdge ) const
1167 : {
1168 0 : long lx = maLastPoint.X();
1169 0 : long ly = maLastPoint.Y();
1170 0 : long md = rPoint.X() - lx;
1171 0 : long mn = rPoint.Y() - ly;
1172 : long nNewX;
1173 : long nNewY;
1174 :
1175 0 : if ( nEdge & EDGE_VERT )
1176 : {
1177 0 : nNewY = (nEdge == EDGE_TOP) ? mnLow : mnHigh;
1178 0 : long dy = nNewY - ly;
1179 0 : if ( !md )
1180 0 : nNewX = lx;
1181 0 : else if ( (LONG_MAX / std::abs(md)) >= std::abs(dy) )
1182 0 : nNewX = (dy * md) / mn + lx;
1183 : else
1184 : {
1185 0 : BigInt ady = dy;
1186 0 : ady *= md;
1187 0 : if( ady.IsNeg() )
1188 0 : if( mn < 0 )
1189 0 : ady += mn/2;
1190 : else
1191 0 : ady -= (mn-1)/2;
1192 : else
1193 0 : if( mn < 0 )
1194 0 : ady -= (mn+1)/2;
1195 : else
1196 0 : ady += mn/2;
1197 0 : ady /= mn;
1198 0 : nNewX = (long)ady + lx;
1199 : }
1200 : }
1201 : else
1202 : {
1203 0 : nNewX = (nEdge == EDGE_LEFT) ? mnLow : mnHigh;
1204 0 : long dx = nNewX - lx;
1205 0 : if ( !mn )
1206 0 : nNewY = ly;
1207 0 : else if ( (LONG_MAX / std::abs(mn)) >= std::abs(dx) )
1208 0 : nNewY = (dx * mn) / md + ly;
1209 : else
1210 : {
1211 0 : BigInt adx = dx;
1212 0 : adx *= mn;
1213 0 : if( adx.IsNeg() )
1214 0 : if( md < 0 )
1215 0 : adx += md/2;
1216 : else
1217 0 : adx -= (md-1)/2;
1218 : else
1219 0 : if( md < 0 )
1220 0 : adx -= (md+1)/2;
1221 : else
1222 0 : adx += md/2;
1223 0 : adx /= md;
1224 0 : nNewY = (long)adx + ly;
1225 : }
1226 : }
1227 :
1228 0 : return Point( nNewX, nNewY );
1229 : }
1230 :
1231 0 : void ImplEdgePointFilter::Input( const Point& rPoint )
1232 : {
1233 0 : int nOutside = VisibleSide( rPoint );
1234 :
1235 0 : if ( mbFirst )
1236 : {
1237 0 : maFirstPoint = rPoint;
1238 0 : mbFirst = false;
1239 0 : if ( !nOutside )
1240 0 : mrNextFilter.Input( rPoint );
1241 : }
1242 0 : else if ( rPoint == maLastPoint )
1243 0 : return;
1244 0 : else if ( !nOutside )
1245 : {
1246 0 : if ( mnLastOutside )
1247 0 : mrNextFilter.Input( EdgeSection( rPoint, mnLastOutside ) );
1248 0 : mrNextFilter.Input( rPoint );
1249 : }
1250 0 : else if ( !mnLastOutside )
1251 0 : mrNextFilter.Input( EdgeSection( rPoint, nOutside ) );
1252 0 : else if ( nOutside != mnLastOutside )
1253 : {
1254 0 : mrNextFilter.Input( EdgeSection( rPoint, mnLastOutside ) );
1255 0 : mrNextFilter.Input( EdgeSection( rPoint, nOutside ) );
1256 : }
1257 :
1258 0 : maLastPoint = rPoint;
1259 0 : mnLastOutside = nOutside;
1260 : }
1261 :
1262 0 : void ImplEdgePointFilter::LastPoint()
1263 : {
1264 0 : if ( !mbFirst )
1265 : {
1266 0 : int nOutside = VisibleSide( maFirstPoint );
1267 :
1268 0 : if ( nOutside != mnLastOutside )
1269 0 : Input( maFirstPoint );
1270 0 : mrNextFilter.LastPoint();
1271 : }
1272 0 : }
1273 :
1274 0 : void Polygon::Clip( const Rectangle& rRect, bool bPolygon )
1275 : {
1276 : // #105251# Justify rect befor edge filtering
1277 0 : Rectangle aJustifiedRect( rRect );
1278 0 : aJustifiedRect.Justify();
1279 :
1280 0 : sal_uInt16 nSourceSize = mpImplPolygon->mnPoints;
1281 0 : ImplPolygonPointFilter aPolygon( nSourceSize );
1282 0 : ImplEdgePointFilter aHorzFilter( EDGE_HORZ, aJustifiedRect.Left(), aJustifiedRect.Right(),
1283 0 : aPolygon );
1284 0 : ImplEdgePointFilter aVertFilter( EDGE_VERT, aJustifiedRect.Top(), aJustifiedRect.Bottom(),
1285 0 : aHorzFilter );
1286 :
1287 0 : for ( sal_uInt16 i = 0; i < nSourceSize; i++ )
1288 0 : aVertFilter.Input( mpImplPolygon->mpPointAry[i] );
1289 0 : if ( bPolygon || aVertFilter.IsPolygon() )
1290 0 : aVertFilter.LastPoint();
1291 : else
1292 0 : aPolygon.LastPoint();
1293 :
1294 : // Delete old ImpPolygon-data and assign from ImpPolygonPointFilter
1295 0 : if ( mpImplPolygon->mnRefCount )
1296 : {
1297 0 : if ( mpImplPolygon->mnRefCount > 1 )
1298 0 : mpImplPolygon->mnRefCount--;
1299 : else
1300 0 : delete mpImplPolygon;
1301 : }
1302 0 : mpImplPolygon = aPolygon.mpPoly;
1303 0 : }
1304 :
1305 0 : Rectangle Polygon::GetBoundRect() const
1306 : {
1307 : // Removing the assert. Bezier curves have the attribute that each single
1308 : // curve segment defined by four points can not exit the four-point polygon
1309 : // defined by that points. This allows to say that the curve segment can also
1310 : // never leave the Range of it's defining points.
1311 : // The result is that Polygon::GetBoundRect() may not create the minimal
1312 : // BoundRect of the Polygon (to get that, use basegfx::B2DPolygon classes),
1313 : // but will always create a valid BoundRect, at least as long as this method
1314 : // 'blindly' travels over all points, including control points.
1315 :
1316 : // DBG_ASSERT( !mpImplPolygon->mpFlagAry, "GetBoundRect could fail with beziers!" );
1317 :
1318 0 : sal_uInt16 nCount = mpImplPolygon->mnPoints;
1319 0 : if( ! nCount )
1320 0 : return Rectangle();
1321 :
1322 : long nXMin, nXMax, nYMin, nYMax;
1323 :
1324 0 : const Point* pPt = &(mpImplPolygon->mpPointAry[0]);
1325 0 : nXMin = nXMax = pPt->X();
1326 0 : nYMin = nYMax = pPt->Y();
1327 :
1328 0 : for ( sal_uInt16 i = 0; i < nCount; i++ )
1329 : {
1330 0 : pPt = &(mpImplPolygon->mpPointAry[i]);
1331 :
1332 0 : if ( pPt->X() < nXMin )
1333 0 : nXMin = pPt->X();
1334 0 : if ( pPt->X() > nXMax )
1335 0 : nXMax = pPt->X();
1336 0 : if ( pPt->Y() < nYMin )
1337 0 : nYMin = pPt->Y();
1338 0 : if ( pPt->Y() > nYMax )
1339 0 : nYMax = pPt->Y();
1340 : }
1341 :
1342 0 : return Rectangle( nXMin, nYMin, nXMax, nYMax );
1343 : }
1344 :
1345 0 : double Polygon::GetSignedArea() const
1346 : {
1347 : DBG_ASSERT( !mpImplPolygon->mpFlagAry, "GetArea could fail with beziers!" );
1348 :
1349 0 : double fArea = 0.0;
1350 :
1351 0 : if( mpImplPolygon->mnPoints > 2 )
1352 : {
1353 0 : const sal_uInt16 nCount1 = mpImplPolygon->mnPoints - 1;
1354 :
1355 0 : for( sal_uInt16 i = 0; i < nCount1; )
1356 : {
1357 0 : const Point& rPt = mpImplPolygon->mpPointAry[ i ];
1358 0 : const Point& rPt1 = mpImplPolygon->mpPointAry[ ++i ];
1359 0 : fArea += ( rPt.X() - rPt1.X() ) * ( rPt.Y() + rPt1.Y() );
1360 : }
1361 :
1362 0 : const Point& rPt = mpImplPolygon->mpPointAry[ nCount1 ];
1363 0 : const Point& rPt0 = mpImplPolygon->mpPointAry[ 0 ];
1364 0 : fArea += ( rPt.X() - rPt0.X() ) * ( rPt.Y() + rPt0.Y() );
1365 : }
1366 :
1367 0 : return fArea;
1368 : }
1369 :
1370 0 : bool Polygon::IsInside( const Point& rPoint ) const
1371 : {
1372 : DBG_ASSERT( !mpImplPolygon->mpFlagAry, "IsInside could fail with beziers!" );
1373 :
1374 0 : const Rectangle aBound( GetBoundRect() );
1375 0 : const Line aLine( rPoint, Point( aBound.Right() + 100L, rPoint.Y() ) );
1376 0 : sal_uInt16 nCount = mpImplPolygon->mnPoints;
1377 0 : sal_uInt16 nPCounter = 0;
1378 :
1379 0 : if ( ( nCount > 2 ) && aBound.IsInside( rPoint ) )
1380 : {
1381 0 : Point aPt1( mpImplPolygon->mpPointAry[ 0 ] );
1382 0 : Point aIntersection;
1383 0 : Point aLastIntersection;
1384 :
1385 0 : while ( ( aPt1 == mpImplPolygon->mpPointAry[ nCount - 1 ] ) && ( nCount > 3 ) )
1386 0 : nCount--;
1387 :
1388 0 : for ( sal_uInt16 i = 1; i <= nCount; i++ )
1389 : {
1390 0 : const Point& rPt2 = mpImplPolygon->mpPointAry[ ( i < nCount ) ? i : 0 ];
1391 :
1392 0 : if ( aLine.Intersection( Line( aPt1, rPt2 ), aIntersection ) )
1393 : {
1394 : // This avoids insertion of double intersections
1395 0 : if ( nPCounter )
1396 : {
1397 0 : if ( aIntersection != aLastIntersection )
1398 : {
1399 0 : aLastIntersection = aIntersection;
1400 0 : nPCounter++;
1401 : }
1402 : }
1403 : else
1404 : {
1405 0 : aLastIntersection = aIntersection;
1406 0 : nPCounter++;
1407 : }
1408 : }
1409 :
1410 0 : aPt1 = rPt2;
1411 : }
1412 : }
1413 :
1414 : // is inside, if number of intersection points is odd
1415 0 : return ( ( nPCounter & 1 ) == 1 );
1416 : }
1417 :
1418 0 : bool Polygon::IsRightOrientated() const
1419 : {
1420 0 : return GetSignedArea() >= 0.0;
1421 : }
1422 :
1423 0 : void Polygon::Insert( sal_uInt16 nPos, const Point& rPt, PolyFlags eFlags )
1424 : {
1425 0 : ImplMakeUnique();
1426 :
1427 0 : if( nPos >= mpImplPolygon->mnPoints )
1428 0 : nPos = mpImplPolygon->mnPoints;
1429 :
1430 0 : mpImplPolygon->ImplSplit( nPos, 1 );
1431 0 : mpImplPolygon->mpPointAry[ nPos ] = rPt;
1432 :
1433 0 : if( POLY_NORMAL != eFlags )
1434 : {
1435 0 : mpImplPolygon->ImplCreateFlagArray();
1436 0 : mpImplPolygon->mpFlagAry[ nPos ] = (sal_uInt8) eFlags;
1437 : }
1438 0 : }
1439 :
1440 0 : void Polygon::Insert( sal_uInt16 nPos, const Polygon& rPoly )
1441 : {
1442 0 : const sal_uInt16 nInsertCount = rPoly.mpImplPolygon->mnPoints;
1443 :
1444 0 : if( nInsertCount )
1445 : {
1446 0 : ImplMakeUnique();
1447 :
1448 0 : if( nPos >= mpImplPolygon->mnPoints )
1449 0 : nPos = mpImplPolygon->mnPoints;
1450 :
1451 0 : if( rPoly.mpImplPolygon->mpFlagAry )
1452 0 : mpImplPolygon->ImplCreateFlagArray();
1453 :
1454 0 : mpImplPolygon->ImplSplit( nPos, nInsertCount, rPoly.mpImplPolygon );
1455 : }
1456 0 : }
1457 :
1458 0 : Point& Polygon::operator[]( sal_uInt16 nPos )
1459 : {
1460 : DBG_ASSERT( nPos < mpImplPolygon->mnPoints, "Polygon::[]: nPos >= nPoints" );
1461 :
1462 0 : ImplMakeUnique();
1463 0 : return mpImplPolygon->mpPointAry[nPos];
1464 : }
1465 :
1466 0 : Polygon& Polygon::operator=( const Polygon& rPoly )
1467 : {
1468 : DBG_ASSERT( rPoly.mpImplPolygon->mnRefCount < 0xFFFFFFFE, "Polygon: RefCount overflow" );
1469 :
1470 : // Increase refcounter before assigning
1471 : // Note: RefCount == 0 for static objects
1472 0 : if ( rPoly.mpImplPolygon->mnRefCount )
1473 0 : rPoly.mpImplPolygon->mnRefCount++;
1474 :
1475 : // Delete if recount == 0, otherwise decrement
1476 0 : if ( mpImplPolygon->mnRefCount )
1477 : {
1478 0 : if ( mpImplPolygon->mnRefCount > 1 )
1479 0 : mpImplPolygon->mnRefCount--;
1480 : else
1481 0 : delete mpImplPolygon;
1482 : }
1483 :
1484 0 : mpImplPolygon = rPoly.mpImplPolygon;
1485 0 : return *this;
1486 : }
1487 :
1488 0 : bool Polygon::operator==( const Polygon& rPoly ) const
1489 : {
1490 :
1491 0 : if ( (rPoly.mpImplPolygon == mpImplPolygon) )
1492 0 : return true;
1493 : else
1494 0 : return false;
1495 : }
1496 :
1497 0 : bool Polygon::IsEqual( const Polygon& rPoly ) const
1498 : {
1499 0 : bool bIsEqual = true;
1500 : sal_uInt16 i;
1501 0 : if ( GetSize() != rPoly.GetSize() )
1502 0 : bIsEqual = false;
1503 : else
1504 : {
1505 0 : for ( i = 0; i < GetSize(); i++ )
1506 : {
1507 0 : if ( ( GetPoint( i ) != rPoly.GetPoint( i ) ) ||
1508 0 : ( GetFlags( i ) != rPoly.GetFlags( i ) ) )
1509 : {
1510 0 : bIsEqual = false;
1511 0 : break;
1512 : }
1513 : }
1514 : }
1515 0 : return bIsEqual;
1516 : }
1517 :
1518 0 : SvStream& ReadPolygon( SvStream& rIStream, Polygon& rPoly )
1519 : {
1520 : DBG_ASSERTWARNING( rIStream.GetVersion(), "Polygon::>> - Solar-Version not set on rIStream" );
1521 :
1522 : sal_uInt16 i;
1523 0 : sal_uInt16 nPoints(0);
1524 :
1525 : // read all points and create array
1526 0 : rIStream.ReadUInt16( nPoints );
1527 0 : if ( rPoly.mpImplPolygon->mnRefCount != 1 )
1528 : {
1529 0 : if ( rPoly.mpImplPolygon->mnRefCount )
1530 0 : rPoly.mpImplPolygon->mnRefCount--;
1531 0 : rPoly.mpImplPolygon = new ImplPolygon( nPoints );
1532 : }
1533 : else
1534 0 : rPoly.mpImplPolygon->ImplSetSize( nPoints, false );
1535 :
1536 : {
1537 : // Determine whether we need to write through operators
1538 : #if (SAL_TYPES_SIZEOFLONG) == 4
1539 : #ifdef OSL_BIGENDIAN
1540 : if ( rIStream.GetNumberFormatInt() == NUMBERFORMAT_INT_BIGENDIAN )
1541 : #else
1542 0 : if ( rIStream.GetNumberFormatInt() == NUMBERFORMAT_INT_LITTLEENDIAN )
1543 : #endif
1544 0 : rIStream.Read( rPoly.mpImplPolygon->mpPointAry, nPoints*sizeof(Point) );
1545 : else
1546 : #endif
1547 : {
1548 0 : for( i = 0; i < nPoints; i++ )
1549 : {
1550 : //fdo#39428 SvStream no longer supports operator>>(long&)
1551 0 : sal_Int32 nTmpX(0), nTmpY(0);
1552 0 : rIStream.ReadInt32( nTmpX ).ReadInt32( nTmpY );
1553 0 : rPoly.mpImplPolygon->mpPointAry[i].X() = nTmpX;
1554 0 : rPoly.mpImplPolygon->mpPointAry[i].Y() = nTmpY;
1555 : }
1556 : }
1557 : }
1558 :
1559 0 : return rIStream;
1560 : }
1561 :
1562 0 : SvStream& WritePolygon( SvStream& rOStream, const Polygon& rPoly )
1563 : {
1564 : DBG_ASSERTWARNING( rOStream.GetVersion(), "Polygon::<< - Solar-Version not set on rOStream" );
1565 :
1566 : sal_uInt16 i;
1567 0 : sal_uInt16 nPoints = rPoly.GetSize();
1568 :
1569 : // Write number of points
1570 0 : rOStream.WriteUInt16( nPoints );
1571 :
1572 : {
1573 : // Determine whether we need to write through operators
1574 : #if (SAL_TYPES_SIZEOFLONG) == 4
1575 : #ifdef OSL_BIGENDIAN
1576 : if ( rOStream.GetNumberFormatInt() == NUMBERFORMAT_INT_BIGENDIAN )
1577 : #else
1578 0 : if ( rOStream.GetNumberFormatInt() == NUMBERFORMAT_INT_LITTLEENDIAN )
1579 : #endif
1580 : {
1581 0 : if ( nPoints )
1582 0 : rOStream.Write( rPoly.mpImplPolygon->mpPointAry, nPoints*sizeof(Point) );
1583 : }
1584 : else
1585 : #endif
1586 : {
1587 0 : for( i = 0; i < nPoints; i++ )
1588 : {
1589 : //fdo#39428 SvStream no longer supports operator<<(long)
1590 0 : rOStream.WriteInt32( sal::static_int_cast<sal_Int32>( rPoly.mpImplPolygon->mpPointAry[i].X() ) )
1591 0 : .WriteInt32( sal::static_int_cast<sal_Int32>( rPoly.mpImplPolygon->mpPointAry[i].Y() ) );
1592 : }
1593 : }
1594 : }
1595 :
1596 0 : return rOStream;
1597 : }
1598 :
1599 0 : void Polygon::ImplRead( SvStream& rIStream )
1600 : {
1601 0 : sal_uInt8 bHasPolyFlags(0);
1602 :
1603 0 : ReadPolygon( rIStream, *this );
1604 0 : rIStream.ReadUChar( bHasPolyFlags );
1605 :
1606 0 : if ( bHasPolyFlags )
1607 : {
1608 0 : mpImplPolygon->mpFlagAry = new sal_uInt8[ mpImplPolygon->mnPoints ];
1609 0 : rIStream.Read( mpImplPolygon->mpFlagAry, mpImplPolygon->mnPoints );
1610 : }
1611 0 : }
1612 :
1613 0 : void Polygon::Read( SvStream& rIStream )
1614 : {
1615 0 : VersionCompat aCompat( rIStream, STREAM_READ );
1616 :
1617 0 : ImplRead( rIStream );
1618 0 : }
1619 :
1620 0 : void Polygon::ImplWrite( SvStream& rOStream ) const
1621 : {
1622 0 : bool bHasPolyFlags = mpImplPolygon->mpFlagAry != NULL;
1623 0 : WritePolygon( rOStream, *this );
1624 0 : rOStream.WriteUChar(sal_uInt8(bHasPolyFlags));
1625 :
1626 0 : if ( bHasPolyFlags )
1627 0 : rOStream.Write( mpImplPolygon->mpFlagAry, mpImplPolygon->mnPoints );
1628 0 : }
1629 :
1630 0 : void Polygon::Write( SvStream& rOStream ) const
1631 : {
1632 0 : VersionCompat aCompat( rOStream, STREAM_WRITE, 1 );
1633 :
1634 0 : ImplWrite( rOStream );
1635 0 : }
1636 :
1637 : // #i74631#/#i115917# numerical correction method for B2DPolygon
1638 0 : void impCorrectContinuity(basegfx::B2DPolygon& roPolygon, sal_uInt32 nIndex, sal_uInt8 nCFlag)
1639 : {
1640 0 : const sal_uInt32 nPointCount(roPolygon.count());
1641 : OSL_ENSURE(nIndex < nPointCount, "impCorrectContinuity: index access out of range (!)");
1642 :
1643 0 : if(nIndex < nPointCount && (POLY_SMOOTH == nCFlag || POLY_SYMMTR == nCFlag))
1644 : {
1645 0 : if(roPolygon.isPrevControlPointUsed(nIndex) && roPolygon.isNextControlPointUsed(nIndex))
1646 : {
1647 : // #i115917# Patch from osnola (modified, thanks for showing the porblem)
1648 :
1649 : // The correction is needed because an integer polygon with control points
1650 : // is converted to double precision. When C1 or C2 is used the involved vectors
1651 : // may not have the same directions/lengths since these come from integer coordinates
1652 : // and may have been snapped to different nearest integer coordinates. The snap error
1653 : // is in the range of +-1 in y and y, thus 0.0 <= error <= sqrt(2.0). Nonetheless,
1654 : // it needs to be corrected to be able to detect the continuity in this points
1655 : // correctly.
1656 :
1657 : // We only have the integer data here (already in double precision form, but no mantisses
1658 : // used), so the best correction is to use:
1659 :
1660 : // for C1: The longest vector since it potentially has best preserved the original vector.
1661 : // Even better the sum of the vectors, weighted by their length. This gives the
1662 : // normal vector addition to get the vector itself, lengths need to be preserved.
1663 : // for C2: The mediated vector(s) since both should be the same, but mirrored
1664 :
1665 : // extract the point and vectors
1666 0 : const basegfx::B2DPoint aPoint(roPolygon.getB2DPoint(nIndex));
1667 0 : const basegfx::B2DVector aNext(roPolygon.getNextControlPoint(nIndex) - aPoint);
1668 0 : const basegfx::B2DVector aPrev(aPoint - roPolygon.getPrevControlPoint(nIndex));
1669 :
1670 : // calculate common direction vector, normalize
1671 0 : const basegfx::B2DVector aDirection(aNext + aPrev);
1672 :
1673 0 : if(POLY_SMOOTH == nCFlag)
1674 : {
1675 : // C1: apply common direction vector, preserve individual lengths
1676 0 : const double fInvDirectionLen(1.0 / aDirection.getLength());
1677 0 : roPolygon.setNextControlPoint(nIndex, basegfx::B2DPoint(aPoint + (aDirection * (aNext.getLength() * fInvDirectionLen))));
1678 0 : roPolygon.setPrevControlPoint(nIndex, basegfx::B2DPoint(aPoint - (aDirection * (aPrev.getLength() * fInvDirectionLen))));
1679 : }
1680 : else // POLY_SYMMTR
1681 : {
1682 : // C2: get mediated length. Taking half of the unnormalized direction would be
1683 : // an approximation, but not correct.
1684 0 : const double fMedLength((aNext.getLength() + aPrev.getLength()) * (0.5 / aDirection.getLength()));
1685 0 : const basegfx::B2DVector aScaledDirection(aDirection * fMedLength);
1686 :
1687 : // Bring Direction to correct length and apply
1688 0 : roPolygon.setNextControlPoint(nIndex, basegfx::B2DPoint(aPoint + aScaledDirection));
1689 0 : roPolygon.setPrevControlPoint(nIndex, basegfx::B2DPoint(aPoint - aScaledDirection));
1690 0 : }
1691 : }
1692 : }
1693 0 : }
1694 :
1695 : // convert to basegfx::B2DPolygon and return
1696 0 : basegfx::B2DPolygon Polygon::getB2DPolygon() const
1697 : {
1698 0 : basegfx::B2DPolygon aRetval;
1699 0 : const sal_uInt16 nCount(mpImplPolygon->mnPoints);
1700 :
1701 0 : if(nCount)
1702 : {
1703 0 : if(mpImplPolygon->mpFlagAry)
1704 : {
1705 : // handling for curves. Add start point
1706 0 : const Point aStartPoint(mpImplPolygon->mpPointAry[0]);
1707 0 : sal_uInt8 nPointFlag(mpImplPolygon->mpFlagAry[0]);
1708 0 : aRetval.append(basegfx::B2DPoint(aStartPoint.X(), aStartPoint.Y()));
1709 0 : Point aControlA, aControlB;
1710 :
1711 0 : for(sal_uInt16 a(1); a < nCount;)
1712 : {
1713 0 : bool bControlA(false);
1714 0 : bool bControlB(false);
1715 :
1716 0 : if(POLY_CONTROL == mpImplPolygon->mpFlagAry[a])
1717 : {
1718 0 : aControlA = mpImplPolygon->mpPointAry[a++];
1719 0 : bControlA = true;
1720 : }
1721 :
1722 0 : if(a < nCount && POLY_CONTROL == mpImplPolygon->mpFlagAry[a])
1723 : {
1724 0 : aControlB = mpImplPolygon->mpPointAry[a++];
1725 0 : bControlB = true;
1726 : }
1727 :
1728 : // assert invalid polygons
1729 : OSL_ENSURE(bControlA == bControlB, "Polygon::getB2DPolygon: Invalid source polygon (!)");
1730 : (void)bControlB;
1731 :
1732 0 : if(a < nCount)
1733 : {
1734 0 : const Point aEndPoint(mpImplPolygon->mpPointAry[a]);
1735 :
1736 0 : if(bControlA)
1737 : {
1738 : // bezier edge, add
1739 : aRetval.appendBezierSegment(
1740 0 : basegfx::B2DPoint(aControlA.X(), aControlA.Y()),
1741 0 : basegfx::B2DPoint(aControlB.X(), aControlB.Y()),
1742 0 : basegfx::B2DPoint(aEndPoint.X(), aEndPoint.Y()));
1743 :
1744 0 : impCorrectContinuity(aRetval, aRetval.count() - 2, nPointFlag);
1745 : }
1746 : else
1747 : {
1748 : // no bezier edge, add end point
1749 0 : aRetval.append(basegfx::B2DPoint(aEndPoint.X(), aEndPoint.Y()));
1750 : }
1751 :
1752 0 : nPointFlag = mpImplPolygon->mpFlagAry[a++];
1753 : }
1754 : }
1755 :
1756 : // if exist, remove double first/last points, set closed and correct control points
1757 0 : basegfx::tools::checkClosed(aRetval);
1758 :
1759 0 : if(aRetval.isClosed())
1760 : {
1761 : // closeWithGeometryChange did really close, so last point(s) were removed.
1762 : // Correct the continuity in the changed point
1763 0 : impCorrectContinuity(aRetval, 0, mpImplPolygon->mpFlagAry[0]);
1764 : }
1765 : }
1766 : else
1767 : {
1768 : // extra handling for non-curves (most-used case) for speedup
1769 0 : for(sal_uInt16 a(0); a < nCount; a++)
1770 : {
1771 : // get point and add
1772 0 : const Point aPoint(mpImplPolygon->mpPointAry[a]);
1773 0 : aRetval.append(basegfx::B2DPoint(aPoint.X(), aPoint.Y()));
1774 : }
1775 :
1776 : // set closed flag
1777 0 : basegfx::tools::checkClosed(aRetval);
1778 : }
1779 : }
1780 :
1781 0 : return aRetval;
1782 : }
1783 :
1784 : // constructor to convert from basegfx::B2DPolygon
1785 : // #i76891# Needed to change from adding all control points (even for unused
1786 : // edges) and creating a fixed-size Polygon in the first run to creating the
1787 : // minimal Polygon. This requires a temporary Point- and Flag-Array for curves
1788 : // and a memcopy at ImplPolygon creation, but contains no zero-controlpoints
1789 : // for straight edges.
1790 0 : Polygon::Polygon(const basegfx::B2DPolygon& rPolygon)
1791 0 : : mpImplPolygon(0)
1792 : {
1793 0 : const bool bCurve(rPolygon.areControlPointsUsed());
1794 0 : const bool bClosed(rPolygon.isClosed());
1795 0 : sal_uInt32 nB2DLocalCount(rPolygon.count());
1796 :
1797 0 : if(bCurve)
1798 : {
1799 : // #127979# Reduce source point count hard to the limit of the tools Polygon
1800 0 : if(nB2DLocalCount > ((0x0000ffff / 3L) - 1L))
1801 : {
1802 : OSL_FAIL("Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)");
1803 0 : nB2DLocalCount = ((0x0000ffff / 3L) - 1L);
1804 : }
1805 :
1806 : // calculate target point count
1807 0 : const sal_uInt32 nLoopCount(bClosed ? nB2DLocalCount : (nB2DLocalCount ? nB2DLocalCount - 1L : 0L ));
1808 :
1809 0 : if(nLoopCount)
1810 : {
1811 : // calculate maximum array size and allocate; prepare insert index
1812 0 : const sal_uInt32 nMaxTargetCount((nLoopCount * 3) + 1);
1813 0 : mpImplPolygon = new ImplPolygon(static_cast< sal_uInt16 >(nMaxTargetCount), true);
1814 :
1815 : // prepare insert index and current point
1816 0 : sal_uInt32 nArrayInsert(0);
1817 0 : basegfx::B2DCubicBezier aBezier;
1818 0 : aBezier.setStartPoint(rPolygon.getB2DPoint(0));
1819 :
1820 0 : for(sal_uInt32 a(0L); a < nLoopCount; a++)
1821 : {
1822 : // add current point (always) and remember StartPointIndex for evtl. later corrections
1823 0 : const Point aStartPoint(FRound(aBezier.getStartPoint().getX()), FRound(aBezier.getStartPoint().getY()));
1824 0 : const sal_uInt32 nStartPointIndex(nArrayInsert);
1825 0 : mpImplPolygon->mpPointAry[nStartPointIndex] = aStartPoint;
1826 0 : mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_NORMAL;
1827 0 : nArrayInsert++;
1828 :
1829 : // prepare next segment
1830 0 : const sal_uInt32 nNextIndex((a + 1) % nB2DLocalCount);
1831 0 : aBezier.setEndPoint(rPolygon.getB2DPoint(nNextIndex));
1832 0 : aBezier.setControlPointA(rPolygon.getNextControlPoint(a));
1833 0 : aBezier.setControlPointB(rPolygon.getPrevControlPoint(nNextIndex));
1834 :
1835 0 : if(aBezier.isBezier())
1836 : {
1837 : // if one is used, add always two control points due to the old schema
1838 0 : mpImplPolygon->mpPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointA().getX()), FRound(aBezier.getControlPointA().getY()));
1839 0 : mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_CONTROL;
1840 0 : nArrayInsert++;
1841 :
1842 0 : mpImplPolygon->mpPointAry[nArrayInsert] = Point(FRound(aBezier.getControlPointB().getX()), FRound(aBezier.getControlPointB().getY()));
1843 0 : mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_CONTROL;
1844 0 : nArrayInsert++;
1845 : }
1846 :
1847 : // test continuity with previous control point to set flag value
1848 0 : if(aBezier.getControlPointA() != aBezier.getStartPoint() && (bClosed || a))
1849 : {
1850 0 : const basegfx::B2VectorContinuity eCont(rPolygon.getContinuityInPoint(a));
1851 :
1852 0 : if(basegfx::CONTINUITY_C1 == eCont)
1853 : {
1854 0 : mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_SMOOTH;
1855 : }
1856 0 : else if(basegfx::CONTINUITY_C2 == eCont)
1857 : {
1858 0 : mpImplPolygon->mpFlagAry[nStartPointIndex] = (sal_uInt8)POLY_SYMMTR;
1859 : }
1860 : }
1861 :
1862 : // prepare next polygon step
1863 0 : aBezier.setStartPoint(aBezier.getEndPoint());
1864 : }
1865 :
1866 0 : if(bClosed)
1867 : {
1868 : // add first point again as closing point due to old definition
1869 0 : mpImplPolygon->mpPointAry[nArrayInsert] = mpImplPolygon->mpPointAry[0];
1870 0 : mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_NORMAL;
1871 0 : nArrayInsert++;
1872 : }
1873 : else
1874 : {
1875 : // add last point as closing point
1876 0 : const basegfx::B2DPoint aClosingPoint(rPolygon.getB2DPoint(nB2DLocalCount - 1L));
1877 0 : const Point aEnd(FRound(aClosingPoint.getX()), FRound(aClosingPoint.getY()));
1878 0 : mpImplPolygon->mpPointAry[nArrayInsert] = aEnd;
1879 0 : mpImplPolygon->mpFlagAry[nArrayInsert] = (sal_uInt8)POLY_NORMAL;
1880 0 : nArrayInsert++;
1881 : }
1882 :
1883 : DBG_ASSERT(nArrayInsert <= nMaxTargetCount, "Polygon::Polygon from basegfx::B2DPolygon: wrong max point count estimation (!)");
1884 :
1885 0 : if(nArrayInsert != nMaxTargetCount)
1886 : {
1887 0 : mpImplPolygon->ImplSetSize(static_cast< sal_uInt16 >(nArrayInsert), true);
1888 0 : }
1889 : }
1890 : }
1891 : else
1892 : {
1893 : // #127979# Reduce source point count hard to the limit of the tools Polygon
1894 0 : if(nB2DLocalCount > (0x0000ffff - 1L))
1895 : {
1896 : OSL_FAIL("Polygon::Polygon: Too many points in given B2DPolygon, need to reduce hard to maximum of tools Polygon (!)");
1897 0 : nB2DLocalCount = (0x0000ffff - 1L);
1898 : }
1899 :
1900 0 : if(nB2DLocalCount)
1901 : {
1902 : // point list creation
1903 0 : const sal_uInt32 nTargetCount(nB2DLocalCount + (bClosed ? 1L : 0L));
1904 0 : mpImplPolygon = new ImplPolygon( static_cast< sal_uInt16 >(nTargetCount) );
1905 0 : sal_uInt16 nIndex(0);
1906 :
1907 0 : for(sal_uInt32 a(0L); a < nB2DLocalCount; a++)
1908 : {
1909 0 : basegfx::B2DPoint aB2DPoint(rPolygon.getB2DPoint(a));
1910 0 : Point aPoint(FRound(aB2DPoint.getX()), FRound(aB2DPoint.getY()));
1911 0 : mpImplPolygon->mpPointAry[nIndex++] = aPoint;
1912 0 : }
1913 :
1914 0 : if(bClosed)
1915 : {
1916 : // add first point as closing point
1917 0 : mpImplPolygon->mpPointAry[nIndex] = mpImplPolygon->mpPointAry[0];
1918 : }
1919 : }
1920 : }
1921 :
1922 0 : if(!mpImplPolygon)
1923 : {
1924 : // no content yet, create empty polygon
1925 0 : mpImplPolygon = (ImplPolygon*)(&aStaticImplPolygon);
1926 : }
1927 0 : }
1928 :
1929 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
