qgslayoututils.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgslayoututils.cpp
3  ------------------
4  begin : July 2017
5  copyright : (C) 2017 by Nyall Dawson
6  email : nyall dot dawson at gmail dot com
7  ***************************************************************************/
8
9 /***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17
18 #include "qgslayoututils.h"
19 #include "qgslayout.h"
20 #include "qgsrendercontext.h"
21 #include "qgslayoutitemmap.h"
22 #include <QStyleOptionGraphicsItem>
23 #include <QPainter>
24 #include <cmath>
25
28 #endif
29
30 void QgsLayoutUtils::rotate( double angle, double &x, double &y )
31 {
32  double rotToRad = angle * M_PI / 180.0;
33  double xRot, yRot;
34  xRot = x * std::cos( rotToRad ) - y * std::sin( rotToRad );
35  yRot = x * std::sin( rotToRad ) + y * std::cos( rotToRad );
36  x = xRot;
37  y = yRot;
38 }
39
40 double QgsLayoutUtils::normalizedAngle( const double angle, const bool allowNegative )
41 {
42  double clippedAngle = angle;
43  if ( clippedAngle >= 360.0 || clippedAngle <= -360.0 )
44  {
45  clippedAngle = std::fmod( clippedAngle, 360.0 );
46  }
47  if ( !allowNegative && clippedAngle < 0.0 )
48  {
49  clippedAngle += 360.0;
50  }
51  return clippedAngle;
52 }
53
55 {
56  //normalize angle to 0-360 degrees
57  double clippedAngle = normalizedAngle( angle );
58
59  //snap angle to 45 degree
60  if ( clippedAngle >= 22.5 && clippedAngle < 67.5 )
61  {
62  return 45.0;
63  }
64  else if ( clippedAngle >= 67.5 && clippedAngle < 112.5 )
65  {
66  return 90.0;
67  }
68  else if ( clippedAngle >= 112.5 && clippedAngle < 157.5 )
69  {
70  return 135.0;
71  }
72  else if ( clippedAngle >= 157.5 && clippedAngle < 202.5 )
73  {
74  return 180.0;
75  }
76  else if ( clippedAngle >= 202.5 && clippedAngle < 247.5 )
77  {
78  return 225.0;
79  }
80  else if ( clippedAngle >= 247.5 && clippedAngle < 292.5 )
81  {
82  return 270.0;
83  }
84  else if ( clippedAngle >= 292.5 && clippedAngle < 337.5 )
85  {
86  return 315.0;
87  }
88  else
89  {
90  return 0.0;
91  }
92 }
93
95 {
96  if ( !map )
97  {
98  QgsRenderContext context;
99  context.setPainter( painter );
100  if ( dpi < 0 && painter && painter->device() )
101  {
102  context.setScaleFactor( painter->device()->logicalDpiX() / 25.4 );
103  }
104  else if ( dpi > 0 )
105  {
106  context.setScaleFactor( dpi / 25.4 );
107  }
108  else
109  {
110  context.setScaleFactor( 3.465 ); //assume 88 dpi as standard value
111  }
112  return context;
113  }
114  else
115  {
116  // default to 88 dpi if no painter specified
117  if ( dpi < 0 )
118  {
119  dpi = ( painter && painter->device() ) ? painter->device()->logicalDpiX() : 88;
120  }
121  double dotsPerMM = dpi / 25.4;
122
123  // get map settings from reference map
124  QgsRectangle extent = map->extent();
125  QSizeF mapSizeLayoutUnits = map->rect().size();
126  QSizeF mapSizeMM = map->layout()->convertFromLayoutUnits( mapSizeLayoutUnits, QgsUnitTypes::LayoutMillimeters ).toQSizeF();
127  QgsMapSettings ms = map->mapSettings( extent, mapSizeMM * dotsPerMM, dpi, false );
129  if ( painter )
130  context.setPainter( painter );
131
132  context.setFlags( map->layout()->renderContext().renderContextFlags() );
134  return context;
135  }
136 }
137
139 {
140  QgsLayoutItemMap *referenceMap = layout ? layout->referenceMap() : nullptr;
141  QgsRenderContext context = createRenderContextForMap( referenceMap, painter, dpi );
142  if ( layout )
143  {
144  context.setFlags( layout->renderContext().renderContextFlags() );
145  context.setTextRenderFormat( layout->renderContext().textRenderFormat() );
146  }
147
148  return context;
149 }
150
151 void QgsLayoutUtils::relativeResizeRect( QRectF &rectToResize, const QRectF &boundsBefore, const QRectF &boundsAfter )
152 {
153  //linearly scale rectToResize relative to the scaling from boundsBefore to boundsAfter
154  double left = relativePosition( rectToResize.left(), boundsBefore.left(), boundsBefore.right(), boundsAfter.left(), boundsAfter.right() );
155  double right = relativePosition( rectToResize.right(), boundsBefore.left(), boundsBefore.right(), boundsAfter.left(), boundsAfter.right() );
156  double top = relativePosition( rectToResize.top(), boundsBefore.top(), boundsBefore.bottom(), boundsAfter.top(), boundsAfter.bottom() );
157  double bottom = relativePosition( rectToResize.bottom(), boundsBefore.top(), boundsBefore.bottom(), boundsAfter.top(), boundsAfter.bottom() );
158
159  rectToResize.setRect( left, top, right - left, bottom - top );
160 }
161
162 double QgsLayoutUtils::relativePosition( const double position, const double beforeMin, const double beforeMax, const double afterMin, const double afterMax )
163 {
164  //calculate parameters for linear scale between before and after ranges
165  double m = ( afterMax - afterMin ) / ( beforeMax - beforeMin );
166  double c = afterMin - ( beforeMin * m );
167
168  //return linearly scaled position
169  return m * position + c;
170 }
171 QFont QgsLayoutUtils::scaledFontPixelSize( const QFont &font )
172 {
173  //upscale using FONT_WORKAROUND_SCALE
174  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
175  QFont scaledFont = font;
176  double pixelSize = pointsToMM( scaledFont.pointSizeF() ) * FONT_WORKAROUND_SCALE + 0.5;
177  scaledFont.setPixelSize( pixelSize );
178  return scaledFont;
179 }
180
181 double QgsLayoutUtils::fontAscentMM( const QFont &font )
182 {
183  //upscale using FONT_WORKAROUND_SCALE
184  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
185  QFont metricsFont = scaledFontPixelSize( font );
186  QFontMetricsF fontMetrics( metricsFont );
187  return ( fontMetrics.ascent() / FONT_WORKAROUND_SCALE );
188 }
189
190 double QgsLayoutUtils::fontDescentMM( const QFont &font )
191 {
192  //upscale using FONT_WORKAROUND_SCALE
193  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
194  QFont metricsFont = scaledFontPixelSize( font );
195  QFontMetricsF fontMetrics( metricsFont );
196  return ( fontMetrics.descent() / FONT_WORKAROUND_SCALE );
197
198 }
199
200 double QgsLayoutUtils::fontHeightMM( const QFont &font )
201 {
202  //upscale using FONT_WORKAROUND_SCALE
203  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
204  QFont metricsFont = scaledFontPixelSize( font );
205  QFontMetricsF fontMetrics( metricsFont );
206  return ( fontMetrics.height() / FONT_WORKAROUND_SCALE );
207
208 }
209
210 double QgsLayoutUtils::fontHeightCharacterMM( const QFont &font, QChar character )
211 {
212  //upscale using FONT_WORKAROUND_SCALE
213  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
214  QFont metricsFont = scaledFontPixelSize( font );
215  QFontMetricsF fontMetrics( metricsFont );
216  return ( fontMetrics.boundingRect( character ).height() / FONT_WORKAROUND_SCALE );
217 }
218
219 double QgsLayoutUtils::textWidthMM( const QFont &font, const QString &text )
220 {
221  //upscale using FONT_WORKAROUND_SCALE
222  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
223  QFont metricsFont = scaledFontPixelSize( font );
224  QFontMetricsF fontMetrics( metricsFont );
225  return ( fontMetrics.width( text ) / FONT_WORKAROUND_SCALE );
226 }
227
228 double QgsLayoutUtils::textHeightMM( const QFont &font, const QString &text, double multiLineHeight )
229 {
230  QStringList multiLineSplit = text.split( '\n' );
231  int lines = multiLineSplit.size();
232
233  //upscale using FONT_WORKAROUND_SCALE
234  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
235  QFont metricsFont = scaledFontPixelSize( font );
236  QFontMetricsF fontMetrics( metricsFont );
237
238  double fontHeight = fontMetrics.ascent() + fontMetrics.descent(); // ignore +1 for baseline
239  double textHeight = fontMetrics.ascent() + static_cast< double >( ( lines - 1 ) * fontHeight * multiLineHeight );
240
241  return textHeight / FONT_WORKAROUND_SCALE;
242 }
243
244 void QgsLayoutUtils::drawText( QPainter *painter, QPointF position, const QString &text, const QFont &font, const QColor &color )
245 {
246  if ( !painter )
247  {
248  return;
249  }
250
251  //upscale using FONT_WORKAROUND_SCALE
252  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
253  QFont textFont = scaledFontPixelSize( font );
254
255  painter->save();
256  painter->setFont( textFont );
257  if ( color.isValid() )
258  {
259  painter->setPen( color );
260  }
261  double scaleFactor = 1.0 / FONT_WORKAROUND_SCALE;
262  painter->scale( scaleFactor, scaleFactor );
263  painter->drawText( position * FONT_WORKAROUND_SCALE, text );
264  painter->restore();
265 }
266
267 void QgsLayoutUtils::drawText( QPainter *painter, const QRectF &rect, const QString &text, const QFont &font, const QColor &color, const Qt::AlignmentFlag halignment, const Qt::AlignmentFlag valignment, const int flags )
268 {
269  if ( !painter )
270  {
271  return;
272  }
273
274  //upscale using FONT_WORKAROUND_SCALE
275  //ref: http://osgeo-org.1560.x6.nabble.com/Multi-line-labels-and-font-bug-td4157152.html
276  QFont textFont = scaledFontPixelSize( font );
277
278  QRectF scaledRect( rect.x() * FONT_WORKAROUND_SCALE, rect.y() * FONT_WORKAROUND_SCALE,
279  rect.width() * FONT_WORKAROUND_SCALE, rect.height() * FONT_WORKAROUND_SCALE );
280
281  painter->save();
282  painter->setFont( textFont );
283  if ( color.isValid() )
284  {
285  painter->setPen( color );
286  }
287  double scaleFactor = 1.0 / FONT_WORKAROUND_SCALE;
288  painter->scale( scaleFactor, scaleFactor );
289  painter->drawText( scaledRect, halignment | valignment | flags, text );
290  painter->restore();
291 }
292
293 QRectF QgsLayoutUtils::largestRotatedRectWithinBounds( const QRectF &originalRect, const QRectF &boundsRect, const double rotation )
294 {
295  double originalWidth = originalRect.width();
296  double originalHeight = originalRect.height();
297  double boundsWidth = boundsRect.width();
298  double boundsHeight = boundsRect.height();
299  double ratioBoundsRect = boundsWidth / boundsHeight;
300
301  double clippedRotation = normalizedAngle( rotation );
302
303  //shortcut for some rotation values
304  if ( qgsDoubleNear( clippedRotation, 0.0 ) || qgsDoubleNear( clippedRotation, 90.0 ) || qgsDoubleNear( clippedRotation, 180.0 ) || qgsDoubleNear( clippedRotation, 270.0 ) )
305  {
306  double rectScale;
307  if ( qgsDoubleNear( clippedRotation, 0.0 ) || qgsDoubleNear( clippedRotation, 180.0 ) )
308  {
309  rectScale = ( ( originalWidth / originalHeight ) > ratioBoundsRect ) ? boundsWidth / originalWidth : boundsHeight / originalHeight;
310  }
311  else
312  {
313  rectScale = ( ( originalHeight / originalWidth ) > ratioBoundsRect ) ? boundsWidth / originalHeight : boundsHeight / originalWidth;
314  }
315  double rectScaledWidth = rectScale * originalWidth;
316  double rectScaledHeight = rectScale * originalHeight;
317
318  if ( qgsDoubleNear( clippedRotation, 0.0 ) || qgsDoubleNear( clippedRotation, 180.0 ) )
319  {
320  return QRectF( ( boundsWidth - rectScaledWidth ) / 2.0, ( boundsHeight - rectScaledHeight ) / 2.0, rectScaledWidth, rectScaledHeight );
321  }
322  else
323  {
324  return QRectF( ( boundsWidth - rectScaledHeight ) / 2.0, ( boundsHeight - rectScaledWidth ) / 2.0, rectScaledWidth, rectScaledHeight );
325  }
326  }
327
328  //convert angle to radians and flip
330  double cosAngle = std::cos( angleRad );
331  double sinAngle = std::sin( angleRad );
332
333  //calculate size of bounds of rotated rectangle
334  double widthBoundsRotatedRect = originalWidth * std::fabs( cosAngle ) + originalHeight * std::fabs( sinAngle );
335  double heightBoundsRotatedRect = originalHeight * std::fabs( cosAngle ) + originalWidth * std::fabs( sinAngle );
336
337  //compare ratio of rotated rect with bounds rect and calculate scaling of rotated
338  //rect to fit within bounds
339  double ratioBoundsRotatedRect = widthBoundsRotatedRect / heightBoundsRotatedRect;
340  double rectScale = ratioBoundsRotatedRect > ratioBoundsRect ? boundsWidth / widthBoundsRotatedRect : boundsHeight / heightBoundsRotatedRect;
341  double rectScaledWidth = rectScale * originalWidth;
342  double rectScaledHeight = rectScale * originalHeight;
343
344  //now calculate offset so that rotated rectangle is centered within bounds
345  //first calculate min x and y coordinates
346  double currentCornerX = 0;
347  double minX = 0;
348  currentCornerX += rectScaledWidth * cosAngle;
349  minX = minX < currentCornerX ? minX : currentCornerX;
350  currentCornerX += rectScaledHeight * sinAngle;
351  minX = minX < currentCornerX ? minX : currentCornerX;
352  currentCornerX -= rectScaledWidth * cosAngle;
353  minX = minX < currentCornerX ? minX : currentCornerX;
354
355  double currentCornerY = 0;
356  double minY = 0;
357  currentCornerY -= rectScaledWidth * sinAngle;
358  minY = minY < currentCornerY ? minY : currentCornerY;
359  currentCornerY += rectScaledHeight * cosAngle;
360  minY = minY < currentCornerY ? minY : currentCornerY;
361  currentCornerY += rectScaledWidth * sinAngle;
362  minY = minY < currentCornerY ? minY : currentCornerY;
363
364  //now calculate offset position of rotated rectangle
365  double offsetX = ratioBoundsRotatedRect > ratioBoundsRect ? 0 : ( boundsWidth - rectScale * widthBoundsRotatedRect ) / 2.0;
366  offsetX += std::fabs( minX );
367  double offsetY = ratioBoundsRotatedRect > ratioBoundsRect ? ( boundsHeight - rectScale * heightBoundsRotatedRect ) / 2.0 : 0;
368  offsetY += std::fabs( minY );
369
370  return QRectF( offsetX, offsetY, rectScaledWidth, rectScaledHeight );
371 }
372
374 {
375  QString s = string.trimmed();
376  if ( s.compare( QLatin1String( "Portrait" ), Qt::CaseInsensitive ) == 0 )
377  {
378  ok = true;
380  }
381  else if ( s.compare( QLatin1String( "Landscape" ), Qt::CaseInsensitive ) == 0 )
382  {
383  ok = true;
385  }
386  ok = false;
387  return QgsLayoutItemPage::Landscape; // default to landscape
388 }
389
390 double QgsLayoutUtils::scaleFactorFromItemStyle( const QStyleOptionGraphicsItem *style )
391 {
392  // workaround Qt bug 66185
393
394  // Refs #18027 - if a QGraphicsItem is rotated by 90 or 270 degrees, then the item
395  // style given to QGraphicsItem::paint incorrectly uses the shear parameter of the matrix (m12)
396  // to store the current view scale, instead of the horizontal scale parameter (m11) which
397  // is used in all other cases
398
399  // TODO - ifdef this out if Qt fixes upstream
400  return !qgsDoubleNear( style->matrix.m11(), 0.0 ) ? style->matrix.m11() : style->matrix.m12();
401 }
402
403 QgsMapLayer *QgsLayoutUtils::mapLayerFromString( const QString &string, QgsProject *project )
404 {
405  // Maybe it's a layer id?
406  if ( QgsMapLayer *ml = project->mapLayer( string ) )
407  return ml;
408
409  // Still nothing? Check for layer name
410  if ( QgsMapLayer *ml = project->mapLayersByName( string ).value( 0 ) )
411  return ml;
412
413  // Still nothing? Check for layer name, case-insensitive
414  const auto layers = project->mapLayers();
415  for ( auto it = layers.constBegin(); it != layers.constEnd(); ++it )
416  {
417  if ( it.value()->name().compare( string, Qt::CaseInsensitive ) == 0 )
418  return it.value();
419  }
420
421  return nullptr;
422 }
423
424 double QgsLayoutUtils::pointsToMM( const double pointSize )
425 {
426  //conversion to mm based on 1 point = 1/72 inch
427  return ( pointSize * 0.3527 );
428 }
429
430 double QgsLayoutUtils::mmToPoints( const double mmSize )
431 {
432  //conversion to points based on 1 point = 1/72 inch
433  return ( mmSize / 0.3527 );
434 }
static double snappedAngle(double angle)
Snaps an angle (in degrees) to its closest 45 degree angle.
static double scaleFactorFromItemStyle(const QStyleOptionGraphicsItem *style)
Extracts the scale factor from an item style.
Portrait orientation.
A rectangle specified with double values.
Definition: qgsrectangle.h:40
Base class for all map layer types.
Definition: qgsmaplayer.h:63
QgsMapSettings mapSettings(const QgsRectangle &extent, QSizeF size, double dpi, bool includeLayerSettings) const
Returns map settings that will be used for drawing of the map.
void setFlags(QgsRenderContext::Flags flags)
Set combination of flags that will be used for rendering.
Landscape orientation.
static double textWidthMM(const QFont &font, const QString &text)
Calculate a font width in millimeters for a text string, including workarounds for QT font rendering ...
static double relativePosition(double position, double beforeMin, double beforeMax, double afterMin, double afterMax)
Returns a scaled position given a before and after range.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:278
QgsLayoutMeasurement convertFromLayoutUnits(double length, QgsUnitTypes::LayoutUnit unit) const
Converts a length measurement from the layout&#39;s native units to a specified target unit...
Definition: qgslayout.cpp:341
QgsRenderContext::TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
QgsLayoutItemMap * referenceMap() const
Returns the map item which will be used to generate corresponding world files when the layout is expo...
Definition: qgslayout.cpp:427
static double fontDescentMM(const QFont &font)
Calculate a font descent in millimeters, including workarounds for QT font rendering issues...
void setTextRenderFormat(TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
QgsLayoutRenderContext & renderContext()
Returns a reference to the layout&#39;s render context, which stores information relating to the current ...
Definition: qgslayout.cpp:356
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786
The QgsMapSettings class contains configuration for rendering of the map.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QgsRenderContext::Flags renderContextFlags() const
Returns the combination of render context flags matched to the layout context&#39;s settings.
Layout graphical items for displaying a map.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
static QgsRenderContext createRenderContextForMap(QgsLayoutItemMap *map, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout map and painter destination.
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
static QFont scaledFontPixelSize(const QFont &font)
Returns a font where size is set in points and the size has been upscaled with FONT_WORKAROUND_SCALE ...
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
Definition: qgsproject.h:89
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition: qgslayout.h:49
static QgsMapLayer * mapLayerFromString(const QString &string, QgsProject *project)
Resolves a string into a map layer from a given project.
static void rotate(double angle, double &x, double &y)
Rotates a point / vector around the origin.
static void drawText(QPainter *painter, QPointF position, const QString &text, const QFont &font, const QColor &color=QColor())
Draws text on a painter at a specific position, taking care of layout specific issues (calculation to...
QList< QgsMapLayer * > mapLayersByName(const QString &layerName) const
Retrieve a list of matching registered layers by layer name.
static double fontHeightMM(const QFont &font)
Calculate a font height in millimeters, including workarounds for QT font rendering issues...
QgsRectangle extent() const
Returns the current map extent.
Contains information about the context of a rendering operation.
static double fontHeightCharacterMM(const QFont &font, QChar character)
Calculate a font height in millimeters of a single character, including workarounds for QT font rende...
static double fontAscentMM(const QFont &font)
Calculates a font ascent in millimeters, including workarounds for QT font rendering issues...
QgsMapLayer * mapLayer(const QString &layerId) const
Retrieve a pointer to a registered layer by layer ID.
static QRectF largestRotatedRectWithinBounds(const QRectF &originalRect, const QRectF &boundsRect, double rotation)
Calculates the largest scaled version of originalRect which fits within boundsRect, when it is rotated by the a specified rotation amount.
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
Orientation
Page orientiation.
static void relativeResizeRect(QRectF &rectToResize, const QRectF &boundsBefore, const QRectF &boundsAfter)
Resizes a QRectF relative to a resized bounding rectangle.
static double textHeightMM(const QFont &font, const QString &text, double multiLineHeight=1.0)
Calculate a font height in millimeters for a text string, including workarounds for QT font rendering...
const QgsLayout * layout() const
Returns the layout the object is attached to.
static double normalizedAngle(double angle, bool allowNegative=false)
Ensures that an angle (in degrees) is in the range 0 <= angle < 360.
static QgsLayoutItemPage::Orientation decodePaperOrientation(const QString &string, bool &ok)
Decodes a string representing a paper orientation and returns the decoded orientation.
QMap< QString, QgsMapLayer * > mapLayers() const
Returns a map of all registered layers by layer ID.