pointset.h

Go to the documentation of this file.

/*
 *   libpal - Automated Placement of Labels Library
 *
 *   Copyright (C) 2008 Maxence Laurent, MIS-TIC, HEIG-VD
 *                      University of Applied Sciences, Western Switzerland
 *                      http://www.hes-so.ch
 *
 *   Contact:
 *      maxence.laurent <at> heig-vd <dot> ch
 *    or
 *      eric.taillard <at> heig-vd <dot> ch
 *
 * This file is part of libpal.
 *
 * libpal is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * libpal is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with libpal.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef POINTSET_H
#define POINTSET_H
 
#define SIP_NO_FILE
 
 
#include <cfloat>
#include <cmath>
#include <geos_c.h>
#include <memory>
#include <vector>
 
#include "qgis_core.h"
#include "qgsgeos.h"
#include "qgsrectangle.h"
 
namespace pal
{
 
  class Pal;
  class Projection;
  class LabelPosition;
 
  class PointSet;

  struct OrientedConvexHullBoundingBox
  {
    double x[4] = {0, 0, 0, 0};
    double y[4] = {0, 0, 0, 0};
 
    double alpha = 0;
 
    double width = 0;
    double length = 0;
  };

  class CORE_EXPORT PointSet
  {
      friend class FeaturePart;
      friend class LabelPosition;
      friend class CostCalculator;
      friend class PolygonCostCalculator;
      friend class Layer;
 
    public:
      PointSet();
      PointSet( int nbPoints, double *x, double *y );
      virtual ~PointSet();

      std::unique_ptr< PointSet > extractShape( int nbPtSh, int imin, int imax, int fps, int fpe, double fptx, double fpty );

      std::unique_ptr< PointSet > clone() const;

      bool containsPoint( double x, double y ) const;

      bool containsLabelCandidate( double x, double y, double width, double height, double alpha = 0 ) const;

      OrientedConvexHullBoundingBox computeConvexHullOrientedBoundingBox( bool &ok ) const;

      static QVector<PointSet *> splitPolygons( PointSet *inputShape, double labelWidth, double labelHeight );

      void extendLineByDistance( double startDistance, double endDistance, double smoothDistance );

      void offsetCurveByDistance( double distance );

      double minDistanceToPoint( double px, double py, double *rx = nullptr, double *ry = nullptr ) const;
 
      void getCentroid( double &px, double &py, bool forceInside = false ) const;
 
      int getGeosType() const { return type; }

      QgsRectangle boundingBox() const
      {
        return QgsRectangle( xmin, ymin, xmax, ymax );
      }

      bool boundingBoxIntersects( const PointSet *other ) const;

      PointSet *getHoleOf() const { return holeOf; }
 
      int getNumPoints() const { return nbPoints; }

      void getPointByDistance( double *d, double *ad, double dl, double *px, double *py ) const;

      geos::unique_ptr interpolatePoint( double distance ) const;

      double lineLocatePoint( const GEOSGeometry *point ) const;

      const GEOSGeometry *geos() const;

      double length() const;

      double area() const;

      bool isClosed() const;

      QString toWkt() const;

      std::tuple< std::vector< double >, double > edgeDistances() const;
 
      int nbPoints;
      std::vector< double > x;
      std::vector< double > y;   // points order is counterclockwise
 
    protected:
      mutable GEOSGeometry *mGeos = nullptr;
      mutable bool mOwnsGeom = false;
 
      std::vector< int > convexHull;
 
      int type;
 
      PointSet *holeOf = nullptr;
      PointSet *parent = nullptr;
 
      mutable double mArea = -1;
      mutable double mLength = -1;
 
 
      PointSet( double x, double y );
 
      PointSet( const PointSet &ps );
 
      void deleteCoords();
      void createGeosGeom() const;
      const GEOSPreparedGeometry *preparedGeom() const;
 
      void invalidateGeos() const;
 
      double xmin = std::numeric_limits<double>::max();
      double xmax = std::numeric_limits<double>::lowest();
      double ymin = std::numeric_limits<double>::max();
      double ymax = std::numeric_limits<double>::lowest();
 
    private:
 
      mutable const GEOSPreparedGeometry *mGeosPreparedBoundary = nullptr;
      mutable const GEOSPreparedGeometry *mPreparedGeom = nullptr;
 
      mutable GEOSGeometry *mMultipartGeos = nullptr;
      mutable const GEOSPreparedGeometry *mMultipartPreparedGeos = nullptr;
 
      PointSet &operator= ( const PointSet & ) = delete;
 
  };
 
} // namespace pal
 
#endif