QGIS API Documentation  3.21.0-Master (909859188c)
layer.h
Go to the documentation of this file.
1 /*
2  * libpal - Automated Placement of Labels Library
3  *
4  * Copyright (C) 2008 Maxence Laurent, MIS-TIC, HEIG-VD
5  * University of Applied Sciences, Western Switzerland
6  * http://www.hes-so.ch
7  *
8  * Contact:
9  * maxence.laurent <at> heig-vd <dot> ch
10  * or
11  * eric.taillard <at> heig-vd <dot> ch
12  *
13  * This file is part of libpal.
14  *
15  * libpal is free software: you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation, either version 3 of the License, or
18  * (at your option) any later version.
19  *
20  * libpal is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with libpal. If not, see <http://www.gnu.org/licenses/>.
27  *
28  */
29 
30 #ifndef PAL_LAYER_H_
31 #define PAL_LAYER_H_
32 
33 #define SIP_NO_FILE
34 
35 
36 #include "qgis_core.h"
37 #include "pal.h" // for LineArrangementFlags enum
38 #include "qgsgeos.h"
39 #include "qgsgenericspatialindex.h"
40 #include <QMutex>
41 #include <QLinkedList>
42 #include <QHash>
43 #include <fstream>
44 
45 class QgsLabelFeature;
46 
47 namespace pal
48 {
49 
50  class FeaturePart;
51 
52  class Pal;
53  class LabelInfo;
54 
61  class CORE_EXPORT Layer
62  {
63  friend class Pal;
64  friend class FeaturePart;
65 
66  friend class Problem;
67 
68  friend class LabelPosition;
69 
70  public:
72  {
73  Upright, // upside-down labels (90 <= angle < 270) are shown upright
74  ShowDefined, // show upside down when rotation is layer- or data-defined
75  ShowAll // show upside down for all labels, including dynamic ones
76  };
77 
91  Layer( QgsAbstractLabelProvider *provider, const QString &name, QgsPalLayerSettings::Placement arrangement, double defaultPriority, bool active, bool toLabel, Pal *pal, bool displayAll = false );
92 
93  virtual ~Layer();
94 
95  bool displayAll() const { return mDisplayAll; }
96 
100  int featureCount() { return mHashtable.size(); }
101 
106  std::size_t maximumPointLabelCandidates() const
107  {
108  // when an extreme number of features exist in the layer, we limit the number of candidates
109  // to avoid the engine processing endlessly...
110  const int size = mHashtable.size();
111  if ( size > 1000 )
112  return static_cast< std::size_t >( mPal->globalCandidatesLimitPoint() > 0 ? std::min( mPal->globalCandidatesLimitPoint(), 4 ) : 4 );
113  else if ( size > 500 )
114  return static_cast< std::size_t >( mPal->globalCandidatesLimitPoint() > 0 ? std::min( mPal->globalCandidatesLimitPoint(), 6 ) : 6 );
115  else if ( size > 200 )
116  return static_cast< std::size_t >( mPal->globalCandidatesLimitPoint() > 0 ? std::min( mPal->globalCandidatesLimitPoint(), 8 ) : 8 );
117  else if ( size > 100 )
118  return static_cast< std::size_t >( mPal->globalCandidatesLimitPoint() > 0 ? std::min( mPal->globalCandidatesLimitPoint(), 12 ) : 12 );
119  else
120  return static_cast< std::size_t >( std::max( mPal->globalCandidatesLimitPoint(), 0 ) );
121  }
122 
127  std::size_t maximumLineLabelCandidates() const
128  {
129  // when an extreme number of features exist in the layer, we limit the number of candidates
130  // to avoid the engine processing endlessly...
131  const int size = mHashtable.size();
132  if ( size > 1000 )
133  return static_cast< std::size_t >( mPal->globalCandidatesLimitLine() > 0 ? std::min( mPal->globalCandidatesLimitLine(), 5 ) : 5 );
134  else if ( size > 500 )
135  return static_cast< std::size_t >( mPal->globalCandidatesLimitLine() > 0 ? std::min( mPal->globalCandidatesLimitLine(), 10 ) : 10 );
136  else if ( size > 200 )
137  return static_cast< std::size_t >( mPal->globalCandidatesLimitLine() > 0 ? std::min( mPal->globalCandidatesLimitLine(), 20 ) : 20 );
138  else if ( size > 100 )
139  return static_cast< std::size_t >( mPal->globalCandidatesLimitLine() > 0 ? std::min( mPal->globalCandidatesLimitLine(), 40 ) : 40 );
140  else
141  return static_cast< std::size_t >( std::max( mPal->globalCandidatesLimitLine(), 0 ) );
142  }
143 
148  std::size_t maximumPolygonLabelCandidates() const
149  {
150  // when an extreme number of features exist in the layer, we limit the number of candidates
151  // to avoid the engine processing endlessly...
152  const int size = mHashtable.size();
153  if ( size > 1000 )
154  return static_cast< std::size_t >( mPal->globalCandidatesLimitPolygon() > 0 ? std::min( mPal->globalCandidatesLimitPolygon(), 5 ) : 5 );
155  else if ( size > 500 )
156  return static_cast< std::size_t >( mPal->globalCandidatesLimitPolygon() > 0 ? std::min( mPal->globalCandidatesLimitPolygon(), 15 ) : 15 );
157  else if ( size > 200 )
158  return static_cast< std::size_t >( mPal->globalCandidatesLimitPolygon() > 0 ? std::min( mPal->globalCandidatesLimitPolygon(), 20 ) : 20 );
159  else if ( size > 100 )
160  return static_cast< std::size_t >( mPal->globalCandidatesLimitPolygon() > 0 ? std::min( mPal->globalCandidatesLimitPolygon(), 25 ) : 25 );
161  else
162  return static_cast< std::size_t >( std::max( mPal->globalCandidatesLimitPolygon(), 0 ) );
163  }
164 
166  QgsAbstractLabelProvider *provider() const { return mProvider; }
167 
171  QString name() const { return mName; }
172 
177  QgsPalLayerSettings::Placement arrangement() const { return mArrangement; }
178 
182  bool isCurved() const { return mArrangement == QgsPalLayerSettings::Curved || mArrangement == QgsPalLayerSettings::PerimeterCurved; }
183 
189  void setArrangement( QgsPalLayerSettings::Placement arrangement ) { mArrangement = arrangement; }
190 
201  void setActive( bool active ) { mActive = active; }
202 
207  bool active() const { return mActive; }
208 
216  void setLabelLayer( bool toLabel ) { mLabelLayer = toLabel; }
217 
222  bool labelLayer() const { return mLabelLayer; }
223 
229  QgsLabelObstacleSettings::ObstacleType obstacleType() const { return mObstacleType; }
230 
237  void setObstacleType( QgsLabelObstacleSettings::ObstacleType obstacleType ) { mObstacleType = obstacleType; }
238 
245  void setPriority( double priority );
246 
252  double priority() const { return mDefaultPriority; }
253 
259  void setMergeConnectedLines( bool merge ) { mMergeLines = merge; }
260 
265  bool mergeConnectedLines() const { return mMergeLines; }
266 
272  void setUpsidedownLabels( UpsideDownLabels ud ) { mUpsidedownLabels = ud; }
273 
278  UpsideDownLabels upsidedownLabels() const { return mUpsidedownLabels; }
279 
287  void setCentroidInside( bool forceInside ) { mCentroidInside = forceInside; }
288 
294  bool centroidInside() const { return mCentroidInside; }
295 
305  bool registerFeature( QgsLabelFeature *label );
306 
308  void joinConnectedFeatures();
309 
315  int connectedFeatureId( QgsFeatureId featureId ) const;
316 
318  void chopFeaturesAtRepeatDistance();
319 
320  protected:
322  QString mName;
323 
325  std::deque< std::unique_ptr< FeaturePart > > mFeatureParts;
326 
328  QList<FeaturePart *> mObstacleParts;
329 
330  std::vector< geos::unique_ptr > mGeosObstacleGeometries;
331 
332  Pal *mPal = nullptr;
333 
335 
337  bool mActive;
341 
344 
346 
348 
350  QHash< QgsFeatureId, QgsLabelFeature *> mHashtable;
351 
352  QHash< QString, QVector<FeaturePart *> > mConnectedHashtable;
353  QHash< QgsFeatureId, int > mConnectedFeaturesIds;
354 
355  QMutex mMutex;
356 
358  void addFeaturePart( std::unique_ptr< FeaturePart > fpart, const QString &labelText = QString() );
359 
361  void addObstaclePart( FeaturePart *fpart );
362 
363  };
364 
365 } // end namespace pal
366 
367 
368 #endif
The QgsAbstractLabelProvider class is an interface class.
The QgsLabelFeature class describes a feature that should be used within the labeling engine.
ObstacleType
Valid obstacle types, which affect how features within the layer will act as obstacles for labels.
Placement
Placement modes which determine how label candidates are generated for a feature.
@ PerimeterCurved
Arranges candidates following the curvature of a polygon's boundary. Applies to polygon layers only.
@ Curved
Arranges candidates following the curvature of a line feature. Applies to line layers only.
Main class to handle feature.
Definition: feature.h:65
pal labeling engine
LabelPosition is a candidate feature label position.
Definition: labelposition.h:56
A set of features which influence the labeling process.
Definition: layer.h:62
QMutex mMutex
Definition: layer.h:355
QHash< QString, QVector< FeaturePart * > > mConnectedHashtable
Definition: layer.h:352
std::deque< std::unique_ptr< FeaturePart > > mFeatureParts
List of feature parts.
Definition: layer.h:325
QgsPalLayerSettings::Placement arrangement() const
Returns the layer's arrangement policy.
Definition: layer.h:177
QList< FeaturePart * > mObstacleParts
List of obstacle parts.
Definition: layer.h:328
double mDefaultPriority
Definition: layer.h:334
void setUpsidedownLabels(UpsideDownLabels ud)
Sets how upside down labels will be handled within the layer.
Definition: layer.h:272
QString name() const
Returns the layer's name.
Definition: layer.h:171
bool mLabelLayer
Definition: layer.h:338
std::size_t maximumPolygonLabelCandidates() const
Returns the maximum number of polygon label candidates to generate for features in this layer.
Definition: layer.h:148
bool active() const
Returns whether the layer is currently active.
Definition: layer.h:207
bool mDisplayAll
Definition: layer.h:339
void setObstacleType(QgsLabelObstacleSettings::ObstacleType obstacleType)
Sets the obstacle type, which controls how features within the layer act as obstacles for labels.
Definition: layer.h:237
bool displayAll() const
Definition: layer.h:95
QgsAbstractLabelProvider * mProvider
Definition: layer.h:321
QgsPalLayerSettings::Placement mArrangement
Optional flags used for some placement methods.
Definition: layer.h:343
std::size_t maximumPointLabelCandidates() const
Returns the maximum number of point label candidates to generate for features in this layer.
Definition: layer.h:106
bool mergeConnectedLines() const
Returns whether connected lines will be merged before labeling.
Definition: layer.h:265
void setMergeConnectedLines(bool merge)
Sets whether connected lines should be merged before labeling.
Definition: layer.h:259
void setActive(bool active)
Sets whether the layer is currently active.
Definition: layer.h:201
QHash< QgsFeatureId, int > mConnectedFeaturesIds
Definition: layer.h:353
QgsAbstractLabelProvider * provider() const
Returns pointer to the associated provider.
Definition: layer.h:166
bool mMergeLines
Definition: layer.h:345
bool mCentroidInside
Definition: layer.h:340
QHash< QgsFeatureId, QgsLabelFeature * > mHashtable
Lookup table of label features (owned by the label feature provider that created them)
Definition: layer.h:350
UpsideDownLabels
Definition: layer.h:72
@ Upright
Definition: layer.h:73
@ ShowDefined
Definition: layer.h:74
void setLabelLayer(bool toLabel)
Sets whether the layer will be labeled.
Definition: layer.h:216
std::vector< geos::unique_ptr > mGeosObstacleGeometries
Definition: layer.h:330
int featureCount()
Returns the number of features in layer.
Definition: layer.h:100
UpsideDownLabels mUpsidedownLabels
Definition: layer.h:347
QString mName
Definition: layer.h:322
bool labelLayer() const
Returns whether the layer will be labeled or not.
Definition: layer.h:222
bool centroidInside() const
Returns whether labels placed at the centroid of features within the layer are forced to be placed in...
Definition: layer.h:294
UpsideDownLabels upsidedownLabels() const
Returns how upside down labels are handled within the layer.
Definition: layer.h:278
bool isCurved() const
Returns true if the layer has curved labels.
Definition: layer.h:182
void setCentroidInside(bool forceInside)
Sets whether labels placed at the centroid of features within the layer are forced to be placed insid...
Definition: layer.h:287
QgsLabelObstacleSettings::ObstacleType obstacleType() const
Returns the obstacle type, which controls how features within the layer act as obstacles for labels.
Definition: layer.h:229
void setArrangement(QgsPalLayerSettings::Placement arrangement)
Sets the layer's arrangement policy.
Definition: layer.h:189
double priority() const
Returns the layer's priority, between 0 and 1.
Definition: layer.h:252
bool mActive
Definition: layer.h:337
std::size_t maximumLineLabelCandidates() const
Returns the maximum number of line label candidates to generate for features in this layer.
Definition: layer.h:127
Main Pal labeling class.
Definition: pal.h:80
Representation of a labeling problem.
Definition: problem.h:72
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
Definition: qgsfeatureid.h:28