basegfx/source/tools/unotools.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 <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
  21 #include <com/sun/star/drawing/PointSequence.hpp>
  22 #include <com/sun/star/drawing/FlagSequence.hpp>
  23 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  24 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  25 #include <basegfx/polygon/b2dpolygontools.hxx>
  26 #include <basegfx/polygon/b2dpolygon.hxx>
  27 #include <basegfx/curve/b2dcubicbezier.hxx>
  28
  29 #include <basegfx/utils/unotools.hxx>
  30 #include <comphelper/sequence.hxx>
  31
  32 using namespace ::com::sun::star;
  33
  34 namespace basegfx
  35 {
  36 namespace unotools
  37 {
  38
  39     B2DPolyPolygon polyPolygonBezierToB2DPolyPolygon(const drawing::PolyPolygonBezierCoords& rSourcePolyPolygon)
  40     {
  41         const sal_Int32 nOuterSequenceCount(rSourcePolyPolygon.Coordinates.getLength());
  42         B2DPolyPolygon aNewPolyPolygon;
  43
  44         if(rSourcePolyPolygon.Flags.getLength() != nOuterSequenceCount)
  45             throw lang::IllegalArgumentException();
  46
  47         // get pointers to inner sequence
  48         const drawing::PointSequence* pInnerSequence = rSourcePolyPolygon.Coordinates.getConstArray();
  49         const drawing::FlagSequence* pInnerSequenceFlags = rSourcePolyPolygon.Flags.getConstArray();
  50
  51         for(sal_Int32 a(0); a < nOuterSequenceCount; a++)
  52         {
  53             const sal_Int32 nInnerSequenceCount(pInnerSequence->getLength());
  54
  55             if (!nInnerSequenceCount)
  56                 throw lang::IllegalArgumentException();
  57
  58             if (pInnerSequenceFlags->getLength() != nInnerSequenceCount)
  59                 throw lang::IllegalArgumentException();
  60
  61             // prepare new polygon
  62             basegfx::B2DPolygon aNewPolygon;
  63             const awt::Point* pArray = pInnerSequence->getConstArray();
  64             const drawing::PolygonFlags* pArrayFlags = pInnerSequenceFlags->getConstArray();
  65
  66             // get first point and flag
  67             basegfx::B2DPoint aNewCoordinatePair(pArray->X, pArray->Y); pArray++;
  68             drawing::PolygonFlags ePolyFlag(*pArrayFlags); pArrayFlags++;
  69             basegfx::B2DPoint aControlA;
  70             basegfx::B2DPoint aControlB;
  71
  72             // first point is not allowed to be a control point
  73             if(ePolyFlag == drawing::PolygonFlags_CONTROL)
  74                 throw lang::IllegalArgumentException();
  75
  76             // add first point as start point
  77             aNewPolygon.append(aNewCoordinatePair);
  78             for(sal_Int32 b(1); b < nInnerSequenceCount;)
  79             {
  80                 // prepare loop
  81                 bool bControlA(false);
  82                 bool bControlB(false);
  83
  84                 // get next point and flag
  85                 aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
  86                 ePolyFlag = *pArrayFlags;
  87                 pArray++; pArrayFlags++; b++;
  88
  89                 if(b < nInnerSequenceCount && ePolyFlag == drawing::PolygonFlags_CONTROL)
  90                 {
  91                     aControlA = aNewCoordinatePair;
  92                     bControlA = true;
  93
  94                     // get next point and flag
  95                     aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
  96                     ePolyFlag = *pArrayFlags;
  97                     pArray++; pArrayFlags++; b++;
  98                 }
  99
 100                 if(b < nInnerSequenceCount && ePolyFlag == drawing::PolygonFlags_CONTROL)
 101                 {
 102                     aControlB = aNewCoordinatePair;
 103                     bControlB = true;
 104
 105                     // get next point and flag
 106                     aNewCoordinatePair = basegfx::B2DPoint(pArray->X, pArray->Y);
 107                     ePolyFlag = *pArrayFlags;
 108                     pArray++; pArrayFlags++; b++;
 109                 }
 110
 111                 // two or no control points are consumed, another one would be an error.
 112                 // It's also an error if only one control point was read
 113                 if(ePolyFlag == drawing::PolygonFlags_CONTROL || bControlA != bControlB)
 114                     throw lang::IllegalArgumentException();
 115
 116                 // the previous writes used the B2DPolyPoygon -> utils::PolyPolygon converter
 117                 // which did not create minimal PolyPolygons, but created all control points
 118                 // as null vectors (identical points). Because of the former P(CA)(CB)-norm of
 119                 // B2DPolygon and it's unused sign of being the zero-vector and CA and CB being
 120                 // relative to P, an empty edge was exported as P == CA == CB. Luckily, the new
 121                 // export format can be read without errors by the old OOo-versions, so we need only
 122                 // to correct here at read and do not need to export a wrong but compatible version
 123                 // for the future.
 124                 if(bControlA
 125                    && aControlA.equal(aControlB)
 126                    && aControlA.equal(aNewPolygon.getB2DPoint(aNewPolygon.count() - 1)))
 127                 {
 128                     bControlA = bControlB = false;
 129                 }
 130
 131                 if(bControlA)
 132                 {
 133                     // add bezier edge
 134                     aNewPolygon.appendBezierSegment(aControlA, aControlB, aNewCoordinatePair);
 135                 }
 136                 else
 137                 {
 138                     // add edge
 139                     aNewPolygon.append(aNewCoordinatePair);
 140                 }
 141             }
 142
 143             // next sequence
 144             pInnerSequence++;
 145             pInnerSequenceFlags++;
 146
 147             // #i72807# API import uses old line start/end-equal definition for closed,
 148             // so we need to correct this to closed state here
 149             basegfx::utils::checkClosed(aNewPolygon);
 150
 151             // add new subpolygon
 152             aNewPolyPolygon.append(aNewPolygon);
 153         }
 154
 155         return aNewPolyPolygon;
 156     }
 157
 158     void b2DPolyPolygonToPolyPolygonBezier( const basegfx::B2DPolyPolygon& rPolyPoly,
 159                                             drawing::PolyPolygonBezierCoords& rRetval )
 160     {
 161         rRetval.Coordinates.realloc(rPolyPoly.count());
 162         rRetval.Flags.realloc(rPolyPoly.count());
 163
 164         drawing::PointSequence* pOuterSequence = rRetval.Coordinates.getArray();
 165         drawing::FlagSequence*  pOuterFlags = rRetval.Flags.getArray();
 166
 167         for(sal_uInt32 a=0;a<rPolyPoly.count();a++)
 168         {
 169             const B2DPolygon& rPoly = rPolyPoly.getB2DPolygon(a);
 170             sal_uInt32 nCount(rPoly.count());
 171             const bool bClosed(rPoly.isClosed());
 172
 173             // calculate input vertex count
 174             const sal_uInt32 nLoopCount(bClosed ? nCount : (nCount ? nCount - 1 : 0 ));
 175
 176             std::vector<awt::Point> aPoints; aPoints.reserve(nLoopCount);
 177             std::vector<drawing::PolygonFlags> aFlags; aFlags.reserve(nLoopCount);
 178
 179             if( nCount )
 180             {
 181                 // prepare insert index and current point
 182                 basegfx::B2DCubicBezier aBezier;
 183                 aBezier.setStartPoint(rPoly.getB2DPoint(0));
 184
 185                 for(sal_uInt32 b(0); b<nLoopCount; b++)
 186                 {
 187                     // add current point (always) and remember StartPointIndex for evtl. later corrections
 188                     const awt::Point aStartPoint(fround(aBezier.getStartPoint().getX()),
 189                                                  fround(aBezier.getStartPoint().getY()));
 190                     const sal_uInt32 nStartPointIndex(aPoints.size());
 191                     aPoints.push_back(aStartPoint);
 192                     aFlags.push_back(drawing::PolygonFlags_NORMAL);
 193
 194                     // prepare next segment
 195                     const sal_uInt32 nNextIndex((b + 1) % nCount);
 196                     aBezier.setEndPoint(rPoly.getB2DPoint(nNextIndex));
 197                     aBezier.setControlPointA(rPoly.getNextControlPoint(b));
 198                     aBezier.setControlPointB(rPoly.getPrevControlPoint(nNextIndex));
 199
 200                     if(aBezier.isBezier())
 201                     {
 202                         // if one is used, add always two control points due to the old schema
 203                         aPoints.emplace_back(fround(aBezier.getControlPointA().getX()),
 204                                              fround(aBezier.getControlPointA().getY()) );
 205                         aFlags.push_back(drawing::PolygonFlags_CONTROL);
 206
 207                         aPoints.emplace_back(fround(aBezier.getControlPointB().getX()),
 208                                              fround(aBezier.getControlPointB().getY()) );
 209                         aFlags.push_back(drawing::PolygonFlags_CONTROL);
 210                     }
 211
 212                     // test continuity with previous control point to set flag value
 213                     if(aBezier.getControlPointA() != aBezier.getStartPoint() && (bClosed || b))
 214                     {
 215                         const basegfx::B2VectorContinuity eCont(rPoly.getContinuityInPoint(b));
 216
 217                         if(eCont == basegfx::B2VectorContinuity::C1)
 218                         {
 219                             aFlags[nStartPointIndex] = drawing::PolygonFlags_SMOOTH;
 220                         }
 221                         else if(eCont == basegfx::B2VectorContinuity::C2)
 222                         {
 223                             aFlags[nStartPointIndex] = drawing::PolygonFlags_SYMMETRIC;
 224                         }
 225                     }
 226
 227                     // prepare next polygon step
 228                     aBezier.setStartPoint(aBezier.getEndPoint());
 229                 }
 230
 231                 if(bClosed)
 232                 {
 233                     // add first point again as closing point due to old definition
 234                     aPoints.push_back( aPoints[0] );
 235                     aFlags.push_back(drawing::PolygonFlags_NORMAL);
 236                 }
 237                 else
 238                 {
 239                     // add last point as closing point
 240                     const basegfx::B2DPoint aClosingPoint(rPoly.getB2DPoint(nCount - 1));
 241                     const awt::Point aEnd(fround(aClosingPoint.getX()),
 242                                           fround(aClosingPoint.getY()));
 243                     aPoints.push_back(aEnd);
 244                     aFlags.push_back(drawing::PolygonFlags_NORMAL);
 245                 }
 246             }
 247
 248             *pOuterSequence++ = comphelper::containerToSequence(aPoints);
 249             *pOuterFlags++ = comphelper::containerToSequence(aFlags);
 250         }
 251     }
 252
 253 }
 254 }
 255
 256 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */