include/tools/poly.hxx

   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 #ifndef INCLUDED_TOOLS_POLY_HXX
  20 #define INCLUDED_TOOLS_POLY_HXX
  21
  22 #include <rtl/ustring.hxx>
  23 #include <tools/toolsdllapi.h>
  24 #include <tools/gen.hxx>
  25 #include <tools/degree.hxx>
  26 #include <o3tl/typed_flags_set.hxx>
  27 #include <o3tl/cow_wrapper.hxx>
  28
  29 #include <vector>
  30
  31 #define POLY_APPEND             (0xFFFF)
  32 #define POLYPOLY_APPEND         (0xFFFF)
  33
  34 enum class PolyOptimizeFlags {
  35     NONE      = 0x0000,
  36     CLOSE     = 0x0001,
  37     NO_SAME   = 0x0002,
  38     EDGES     = 0x0004,
  39 };
  40 namespace o3tl
  41 {
  42     template<> struct typed_flags<PolyOptimizeFlags> : is_typed_flags<PolyOptimizeFlags, 0x0007> {};
  43 }
  44
  45 enum class PolyStyle
  46 {
  47     Arc = 1,
  48     Pie = 2,
  49     Chord = 3
  50 };
  51
  52 enum class PolyFlags : sal_uInt8
  53 {
  54     Normal,   // start-/endpoint of a curve or a line
  55     Smooth,   // smooth transition between curves
  56     Control,  // control handles of a Bezier curve
  57     Symmetric // smooth and symmetrical transition between curves
  58 };
  59
  60 class SvStream;
  61 class ImplPolygon;
  62 struct ImplPolyPolygon;
  63
  64 namespace basegfx
  65 {
  66     class B2DPolygon;
  67     class B2DPolyPolygon;
  68 }
  69
  70 namespace tools {
  71
  72 class SAL_WARN_UNUSED TOOLS_DLLPUBLIC Polygon
  73 {
  74 public:
  75     typedef             o3tl::cow_wrapper<ImplPolygon> ImplType;
  76 private:
  77     ImplType            mpImplPolygon;
  78
  79 public:
  80     static void         ImplReduceEdges( tools::Polygon& rPoly, const double& rArea, sal_uInt16 nPercent );
  81     void                ImplRead( SvStream& rIStream );
  82     void                ImplWrite( SvStream& rOStream ) const;
  83
  84 public:
  85                         Polygon();
  86                         Polygon( sal_uInt16 nSize );
  87                         Polygon( sal_uInt16 nPoints, const Point* pPtAry,
  88                                  const PolyFlags* pFlagAry = nullptr );
  89                         Polygon( const tools::Rectangle& rRect );
  90                         Polygon( const tools::Rectangle& rRect,
  91                                  sal_uInt32 nHorzRound, sal_uInt32 nVertRound );
  92                         Polygon( const Point& rCenter,
  93                                  tools::Long nRadX, tools::Long nRadY );
  94                         Polygon( const tools::Rectangle& rBound,
  95                                  const Point& rStart, const Point& rEnd,
  96                                  PolyStyle ePolyStyle = PolyStyle::Arc,
  97                                  const bool bClockWiseArcDirection = false);
  98                         Polygon( const Point& rBezPt1, const Point& rCtrlPt1,
  99                                  const Point& rBezPt2, const Point& rCtrlPt2,
 100                                  sal_uInt16 nPoints );
 101
 102                         Polygon( const tools::Polygon& rPoly );
 103                         Polygon( tools::Polygon&& rPoly) noexcept;
 104                         ~Polygon();
 105
 106     void                SetPoint( const Point& rPt, sal_uInt16 nPos );
 107     const Point&        GetPoint( sal_uInt16 nPos ) const;
 108
 109     void                SetFlags( sal_uInt16 nPos, PolyFlags eFlags );
 110     PolyFlags           GetFlags( sal_uInt16 nPos ) const;
 111     bool                HasFlags() const;
 112
 113     bool                IsRect() const;
 114
 115     void                SetSize( sal_uInt16 nNewSize );
 116     sal_uInt16          GetSize() const;
 117
 118     void                Clear();
 119
 120     tools::Rectangle           GetBoundRect() const;
 121     bool                Contains( const Point& rPt ) const;
 122     double              CalcDistance( sal_uInt16 nPt1, sal_uInt16 nPt2 ) const;
 123     void                Clip( const tools::Rectangle& rRect );
 124     void                Optimize( PolyOptimizeFlags nOptimizeFlags );
 125
 126     /** Adaptive subdivision of polygons with curves
 127
 128         This method adaptively subdivides bezier arcs within the
 129         polygon to straight line segments and returns the resulting
 130         polygon.
 131
 132         @param rResult
 133         The resulting subdivided polygon
 134
 135         @param d
 136         This parameter controls the amount of subdivision. The
 137         original curve is guaranteed to not differ by more than this
 138         amount per bezier segment from the subdivided
 139         lines. Concretely, if the polygon is in device coordinates and
 140         d equals 1.0, then the difference between the subdivided and
 141         the original polygon is guaranteed to be smaller than one
 142         pixel.
 143      */
 144     void                AdaptiveSubdivide( tools::Polygon& rResult, const double d = 1.0 ) const;
 145     static Polygon      SubdivideBezier( const Polygon& rPoly );
 146
 147     void                Move( tools::Long nHorzMove, tools::Long nVertMove );
 148     void                Translate( const Point& rTrans );
 149     void                Scale( double fScaleX, double fScaleY );
 150     void                Rotate( const Point& rCenter, double fSin, double fCos );
 151     void                Rotate( const Point& rCenter, Degree10 nAngle10 );
 152
 153     void                Insert( sal_uInt16 nPos, const Point& rPt );
 154     void                Insert( sal_uInt16 nPos, const tools::Polygon& rPoly );
 155
 156     const Point&        operator[]( sal_uInt16 nPos ) const { return GetPoint( nPos ); }
 157     Point&              operator[]( sal_uInt16 nPos );
 158
 159     tools::Polygon&     operator=( const tools::Polygon& rPoly );
 160     tools::Polygon&     operator=( tools::Polygon&& rPoly ) noexcept;
 161     bool                operator==( const tools::Polygon& rPoly ) const;
 162     bool                operator!=( const tools::Polygon& rPoly ) const
 163                             { return !(Polygon::operator==( rPoly )); }
 164     bool                IsEqual( const tools::Polygon& rPoly ) const;
 165
 166     // streaming a Polygon does ignore PolyFlags, so use the Write Or Read
 167     // method to take care of PolyFlags
 168     TOOLS_DLLPUBLIC friend SvStream&    ReadPolygon( SvStream& rIStream, tools::Polygon& rPoly );
 169     TOOLS_DLLPUBLIC friend SvStream&    WritePolygon( SvStream& rOStream, const tools::Polygon& rPoly );
 170
 171     void                Read( SvStream& rIStream );
 172     void                Write( SvStream& rOStream ) const;
 173
 174     Point *             GetPointAry();
 175     const Point*        GetConstPointAry() const;
 176     const PolyFlags*    GetConstFlagAry() const;
 177
 178     // convert to ::basegfx::B2DPolygon and return
 179     ::basegfx::B2DPolygon getB2DPolygon() const;
 180
 181     // constructor to convert from ::basegfx::B2DPolygon
 182     // #i76339# made explicit
 183     explicit Polygon(const ::basegfx::B2DPolygon& rPolygon);
 184 };
 185
 186
 187 class SAL_WARN_UNUSED TOOLS_DLLPUBLIC PolyPolygon
 188 {
 189 private:
 190     o3tl::cow_wrapper<ImplPolyPolygon>  mpImplPolyPolygon;
 191
 192     enum class PolyClipOp {
 193         INTERSECT,
 194         UNION
 195     };
 196     TOOLS_DLLPRIVATE void  ImplDoOperation( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult, PolyClipOp nOperation ) const;
 197
 198 public:
 199                         PolyPolygon( sal_uInt16 nInitSize = 16 );
 200                         PolyPolygon( const tools::Polygon& rPoly );
 201                         PolyPolygon( const tools::PolyPolygon& rPolyPoly );
 202                         PolyPolygon( tools::PolyPolygon&& rPolyPoly ) noexcept;
 203                         ~PolyPolygon();
 204
 205     void                Insert( const tools::Polygon& rPoly, sal_uInt16 nPos = POLYPOLY_APPEND );
 206     void                Remove( sal_uInt16 nPos );
 207     void                Replace( const Polygon& rPoly, sal_uInt16 nPos );
 208     const tools::Polygon& GetObject( sal_uInt16 nPos ) const;
 209
 210     bool                IsRect() const;
 211
 212     void                Clear();
 213
 214     sal_uInt16          Count() const;
 215     tools::Rectangle           GetBoundRect() const;
 216     void                Clip( const tools::Rectangle& rRect );
 217     void                Optimize( PolyOptimizeFlags nOptimizeFlags );
 218
 219     /** Adaptive subdivision of polygons with curves
 220
 221         This method adaptively subdivides bezier arcs within the
 222         polygon to straight line segments and returns the resulting
 223         polygon.
 224
 225         @param rResult
 226         The resulting subdivided polygon
 227
 228         If the polygon is in device coordinates, then the difference between the subdivided and
 229         the original polygon is guaranteed to be smaller than one
 230         pixel.
 231      */
 232     void                AdaptiveSubdivide( tools::PolyPolygon& rResult ) const;
 233     static tools::PolyPolygon  SubdivideBezier( const tools::PolyPolygon& rPolyPoly );
 234
 235     void                GetIntersection( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const;
 236     void                GetUnion( const tools::PolyPolygon& rPolyPoly, tools::PolyPolygon& rResult ) const;
 237
 238     void                Move( tools::Long nHorzMove, tools::Long nVertMove );
 239     void                Translate( const Point& rTrans );
 240     void                Scale( double fScaleX, double fScaleY );
 241     void                Rotate( const Point& rCenter, double fSin, double fCos );
 242     void                Rotate( const Point& rCenter, Degree10 nAngle10 );
 243
 244     const tools::Polygon& operator[]( sal_uInt16 nPos ) const { return GetObject( nPos ); }
 245     tools::Polygon& operator[]( sal_uInt16 nPos );
 246
 247     tools::PolyPolygon& operator=( const tools::PolyPolygon& rPolyPoly );
 248     tools::PolyPolygon& operator=( tools::PolyPolygon&& rPolyPoly ) noexcept;
 249     bool                operator==( const tools::PolyPolygon& rPolyPoly ) const;
 250     bool                operator!=( const tools::PolyPolygon& rPolyPoly ) const
 251                             { return !(PolyPolygon::operator==( rPolyPoly )); }
 252
 253     TOOLS_DLLPUBLIC friend SvStream&    ReadPolyPolygon( SvStream& rIStream, tools::PolyPolygon& rPolyPoly );
 254     TOOLS_DLLPUBLIC friend SvStream&    WritePolyPolygon( SvStream& rOStream, const tools::PolyPolygon& rPolyPoly );
 255
 256     void                Read( SvStream& rIStream );
 257     void                Write( SvStream& rOStream ) const;
 258
 259     // convert to ::basegfx::B2DPolyPolygon and return
 260     ::basegfx::B2DPolyPolygon getB2DPolyPolygon() const;
 261
 262     // constructor to convert from ::basegfx::B2DPolyPolygon
 263      // #i76339# made explicit
 264      explicit PolyPolygon(const ::basegfx::B2DPolyPolygon& rPolyPolygon);
 265 };
 266
 267 template< typename charT, typename traits >
 268 inline std::basic_ostream<charT, traits> & operator <<(
 269     std::basic_ostream<charT, traits> & stream, const Polygon& poly )
 270 {
 271     stream << "<" << poly.GetSize() << ":";
 272     for (sal_uInt16 i = 0; i < poly.GetSize(); i++)
 273     {
 274         if (i > 0)
 275             stream << "--";
 276         stream << poly.GetPoint(i);
 277
 278         OUString aFlag;
 279         if (poly.GetFlags(i) == PolyFlags::Normal)
 280             aFlag = "Normal";
 281         else if (poly.GetFlags(i) == PolyFlags::Smooth)
 282             aFlag = "Smooth";
 283         else if (poly.GetFlags(i) == PolyFlags::Control)
 284             aFlag = "Control";
 285         else if (poly.GetFlags(i) == PolyFlags::Symmetric)
 286             aFlag = "Symmetric";
 287
 288         stream << ";f=" << aFlag;
 289     }
 290     stream << ">";
 291     return stream;
 292 }
 293
 294 template< typename charT, typename traits >
 295 inline std::basic_ostream<charT, traits> & operator <<(
 296     std::basic_ostream<charT, traits> & stream, const PolyPolygon& poly )
 297 {
 298     stream << "[" << poly.Count() << ":";
 299     for (sal_uInt16 i = 0; i < poly.Count(); i++)
 300     {
 301         if (i > 0)
 302             stream << ",";
 303         stream << poly.GetObject(i);
 304     }
 305     stream << "]";
 306     return stream;
 307 }
 308
 309 } /* namespace tools */
 310
 311 typedef std::vector< tools::PolyPolygon > PolyPolyVector;
 312
 313 #endif
 314
 315 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */