Line data    Source code

       1             : /******************************************************************************
       2             :  * File:   ogrdxf_polyline_smooth.h
       3             :  *
       4             :  * Project:  Interpolation support for smooth POLYLINE and LWPOLYLINE entities.
       5             :  * Purpose:  Definition of classes for OGR .dxf driver.
       6             :  * Author:   TJ Snider, timsn@thtree.com
       7             :  *           Ray Gardener, Daylon Graphics Ltd.
       8             :  *
       9             :  ******************************************************************************
      10             :  * Copyright (c) 2010 Daylon Graphics Ltd.
      11             :  *
      12             :  * SPDX-License-Identifier: MIT
      13             :  ****************************************************************************/
      14             : 
      15             : #ifndef OGRDXF_SMOOTH_POLYLINE_H_INCLUDED
      16             : #define OGRDXF_SMOOTH_POLYLINE_H_INCLUDED
      17             : 
      18             : #include "ogrsf_frmts.h"
      19             : #include "cpl_conv.h"
      20             : #include <vector>
      21             : #include "assert.h"
      22             : 
      23             : class DXFSmoothPolylineVertex
      24             : {
      25             :   public:
      26             :     double x;
      27             :     double y;
      28             :     double z;
      29             :     double bulge;
      30             : 
      31          72 :     DXFSmoothPolylineVertex()
      32          72 :     {
      33          72 :         x = y = z = bulge = 0.0;
      34          72 :     }
      35             : 
      36         279 :     DXFSmoothPolylineVertex(double dfX, double dfY, double dfZ, double dfBulge)
      37         279 :     {
      38         279 :         set(dfX, dfY, dfZ, dfBulge);
      39         279 :     }
      40             : 
      41         279 :     void set(double dfX, double dfY, double dfZ, double dfBulge)
      42             :     {
      43         279 :         x = dfX;
      44         279 :         y = dfY;
      45         279 :         z = dfZ;
      46         279 :         bulge = dfBulge;
      47         279 :     }
      48             : 
      49             :     void scale(double s)
      50             :     {
      51             :         x *= s;
      52             :         y *= s;
      53             :     }
      54             : 
      55          18 :     double length() const
      56             :     {
      57          18 :         return (sqrt(x * x + y * y));
      58             :     }
      59             : 
      60          18 :     void normalize()
      61             :     {
      62          18 :         const double len = length();
      63          18 :         assert(len != 0.0);
      64             : 
      65          18 :         x /= len;
      66          18 :         y /= len;
      67          18 :     }
      68             : 
      69          43 :     bool shares_2D_pos(const DXFSmoothPolylineVertex &v) const
      70             :     {
      71          43 :         return (x == v.x && y == v.y);
      72             :     }
      73             : };
      74             : 
      75             : // Quiet warning from gcc (possibly https://gcc.gnu.org/bugzilla/show_bug.cgi?id=112370)
      76             : #if defined(__GNUC__) && __GNUC__ >= 13
      77             : #pragma GCC diagnostic push
      78             : #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
      79             : #endif
      80             : class DXFSmoothPolyline
      81             : {
      82             :     // A DXF polyline that includes vertex bulge information.
      83             :     // Call Tessellate() to convert to an OGRGeometry.
      84             :     // We treat Z as constant over the entire string; this may
      85             :     // change in the future.
      86             : 
      87             :   private:
      88             :     std::vector<DXFSmoothPolylineVertex> m_vertices;
      89             :     mutable bool m_blinestringstarted;
      90             :     bool m_bClosed;
      91             :     int m_dim;
      92             :     bool m_bUseMaxGapWhenTessellatingArcs;
      93             : 
      94             :   public:
      95          73 :     DXFSmoothPolyline()
      96          73 :         : m_blinestringstarted(false), m_bClosed(false), m_dim(2),
      97          73 :           m_bUseMaxGapWhenTessellatingArcs(false)
      98             :     {
      99          73 :     }
     100             : 
     101             :     OGRGeometry *Tessellate(bool bAsPolygon) const;
     102             : 
     103         170 :     size_t size() const
     104             :     {
     105         170 :         return m_vertices.size();
     106             :     }
     107             : 
     108             :     void SetSize(int n)
     109             :     {
     110             :         m_vertices.reserve(n);
     111             :     }
     112             : 
     113         279 :     void AddPoint(double dfX, double dfY, double dfZ, double dfBulge)
     114             :     {
     115         279 :         m_vertices.push_back(DXFSmoothPolylineVertex(dfX, dfY, dfZ, dfBulge));
     116         279 :     }
     117             : 
     118             :     void Close();
     119             : 
     120          73 :     bool IsEmpty() const
     121             :     {
     122          73 :         return m_vertices.empty();
     123             :     }
     124             : 
     125         139 :     void setCoordinateDimension(int n)
     126             :     {
     127         139 :         m_dim = n;
     128         139 :     }
     129             : 
     130          72 :     void SetUseMaxGapWhenTessellatingArcs(bool bVal)
     131             :     {
     132          72 :         m_bUseMaxGapWhenTessellatingArcs = bVal;
     133          72 :     }
     134             : 
     135             :   private:
     136             :     void EmitArc(const DXFSmoothPolylineVertex &,
     137             :                  const DXFSmoothPolylineVertex &, double radius, double len,
     138             :                  double saggita, OGRLineString *, double dfZ = 0.0) const;
     139             : 
     140             :     void EmitLine(const DXFSmoothPolylineVertex &,
     141             :                   const DXFSmoothPolylineVertex &, OGRLineString *) const;
     142             : };
     143             : #if defined(__GNUC__) && __GNUC__ >= 13
     144             : #pragma GCC diagnostic pop
     145             : #endif
     146             : 
     147             : #endif /* OGRDXF_SMOOTH_POLYLINE_H_INCLUDED */