QGIS API Documentation  3.2.0-Bonn (bc43194)
qgsgloweffect.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsgloweffect.cpp
3  -----------------
4  begin : December 2014
5  copyright : (C) 2014 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 *
12  * it under the terms of the GNU General Public License as published by *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17 
18 #include "qgsgloweffect.h"
19 #include "qgssymbollayerutils.h"
20 #include "qgsimageoperation.h"
21 #include "qgscolorramp.h"
22 #include "qgsunittypes.h"
23 
25  : mColor( Qt::white )
26 {
27 
28 }
29 
31  : QgsPaintEffect( other )
32  , mSpread( other.spread() )
33  , mSpreadUnit( other.spreadUnit() )
35  , mBlurLevel( other.blurLevel() )
36  , mOpacity( other.opacity() )
37  , mColor( other.color() )
38  , mBlendMode( other.blendMode() )
39  , mColorType( other.colorType() )
40 {
41  if ( other.ramp() )
42  {
43  mRamp = other.ramp()->clone();
44  }
45 }
46 
48 {
49  delete mRamp;
50 }
51 
53 {
54  if ( !source() || !enabled() || !context.painter() )
55  return;
56 
57  QImage im = sourceAsImage( context )->copy();
58 
59  QgsColorRamp *ramp = nullptr;
60  std::unique_ptr< QgsGradientColorRamp > tempRamp;
61  if ( mColorType == ColorRamp && mRamp )
62  {
63  ramp = mRamp;
64  }
65  else
66  {
67  //create a temporary ramp
68  QColor transparentColor = mColor;
69  transparentColor.setAlpha( 0 );
70  tempRamp.reset( new QgsGradientColorRamp( mColor, transparentColor ) );
71  ramp = tempRamp.get();
72  }
73 
76  dtProps.useMaxDistance = false;
77  dtProps.shadeExterior = shadeExterior();
78  dtProps.ramp = ramp;
80 
81  if ( mBlurLevel > 0 )
82  {
84  }
85 
87 
88  if ( !shadeExterior() )
89  {
90  //only keep interior portion
91  QPainter p( &im );
92  p.setRenderHint( QPainter::Antialiasing );
93  p.setCompositionMode( QPainter::CompositionMode_DestinationIn );
94  p.drawImage( 0, 0, *sourceAsImage( context ) );
95  p.end();
96  }
97 
98  QPainter *painter = context.painter();
99  painter->save();
100  painter->setCompositionMode( mBlendMode );
101  painter->drawImage( imageOffset( context ), im );
102  painter->restore();
103 }
104 
106 {
107  QgsStringMap props;
108  props.insert( QStringLiteral( "enabled" ), mEnabled ? "1" : "0" );
109  props.insert( QStringLiteral( "draw_mode" ), QString::number( int( mDrawMode ) ) );
110  props.insert( QStringLiteral( "blend_mode" ), QString::number( int( mBlendMode ) ) );
111  props.insert( QStringLiteral( "opacity" ), QString::number( mOpacity ) );
112  props.insert( QStringLiteral( "blur_level" ), QString::number( mBlurLevel ) );
113  props.insert( QStringLiteral( "spread" ), QString::number( mSpread ) );
114  props.insert( QStringLiteral( "spread_unit" ), QgsUnitTypes::encodeUnit( mSpreadUnit ) );
115  props.insert( QStringLiteral( "spread_unit_scale" ), QgsSymbolLayerUtils::encodeMapUnitScale( mSpreadMapUnitScale ) );
116  props.insert( QStringLiteral( "color_type" ), QString::number( static_cast< int >( mColorType ) ) );
117  props.insert( QStringLiteral( "single_color" ), QgsSymbolLayerUtils::encodeColor( mColor ) );
118 
119  if ( mRamp )
120  {
121  props.unite( mRamp->properties() );
122  }
123 
124  return props;
125 }
126 
128 {
129  bool ok;
130  QPainter::CompositionMode mode = static_cast< QPainter::CompositionMode >( props.value( QStringLiteral( "blend_mode" ) ).toInt( &ok ) );
131  if ( ok )
132  {
133  mBlendMode = mode;
134  }
135  if ( props.contains( QStringLiteral( "transparency" ) ) )
136  {
137  double transparency = props.value( QStringLiteral( "transparency" ) ).toDouble( &ok );
138  if ( ok )
139  {
140  mOpacity = 1.0 - transparency;
141  }
142  }
143  else
144  {
145  double opacity = props.value( QStringLiteral( "opacity" ) ).toDouble( &ok );
146  if ( ok )
147  {
148  mOpacity = opacity;
149  }
150  }
151  mEnabled = props.value( QStringLiteral( "enabled" ), QStringLiteral( "1" ) ).toInt();
152  mDrawMode = static_cast< QgsPaintEffect::DrawMode >( props.value( QStringLiteral( "draw_mode" ), QStringLiteral( "2" ) ).toInt() );
153  int level = props.value( QStringLiteral( "blur_level" ) ).toInt( &ok );
154  if ( ok )
155  {
156  mBlurLevel = level;
157  }
158  double spread = props.value( QStringLiteral( "spread" ) ).toDouble( &ok );
159  if ( ok )
160  {
161  mSpread = spread;
162  }
163  mSpreadUnit = QgsUnitTypes::decodeRenderUnit( props.value( QStringLiteral( "spread_unit" ) ) );
164  mSpreadMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( props.value( QStringLiteral( "spread_unit_scale" ) ) );
165  QgsGlowEffect::GlowColorType type = static_cast< QgsGlowEffect::GlowColorType >( props.value( QStringLiteral( "color_type" ) ).toInt( &ok ) );
166  if ( ok )
167  {
168  mColorType = type;
169  }
170  if ( props.contains( QStringLiteral( "single_color" ) ) )
171  {
172  mColor = QgsSymbolLayerUtils::decodeColor( props.value( QStringLiteral( "single_color" ) ) );
173  }
174 
175 //attempt to create color ramp from props
176  delete mRamp;
177  if ( props.contains( QStringLiteral( "rampType" ) ) && props[QStringLiteral( "rampType" )] == QStringLiteral( "cpt-city" ) )
178  {
179  mRamp = QgsCptCityColorRamp::create( props );
180  }
181  else
182  {
183  mRamp = QgsGradientColorRamp::create( props );
184  }
185 }
186 
188 {
189  delete mRamp;
190  mRamp = ramp;
191 }
192 
194 {
195  if ( &rhs == this )
196  return *this;
197 
198  delete mRamp;
199 
200  mSpread = rhs.spread();
201  mRamp = rhs.ramp() ? rhs.ramp()->clone() : nullptr;
202  mBlurLevel = rhs.blurLevel();
203  mOpacity = rhs.opacity();
204  mColor = rhs.color();
205  mBlendMode = rhs.blendMode();
206  mColorType = rhs.colorType();
207 
208  return *this;
209 }
210 
211 QRectF QgsGlowEffect::boundingRect( const QRectF &rect, const QgsRenderContext &context ) const
212 {
213  //spread size
215  //plus possible extension due to blur, with a couple of extra pixels thrown in for safety
216  spread += mBlurLevel * 2 + 10;
217  return rect.adjusted( -spread, -spread, spread, spread );
218 }
219 
220 
221 //
222 // QgsOuterGlowEffect
223 //
224 
226  : QgsGlowEffect()
227 {
228 
229 }
230 
232 {
233  QgsOuterGlowEffect *effect = new QgsOuterGlowEffect();
234  effect->readProperties( map );
235  return effect;
236 }
237 
239 {
240  QgsOuterGlowEffect *newEffect = new QgsOuterGlowEffect( *this );
241  return newEffect;
242 }
243 
244 
245 //
246 // QgsInnerGlowEffect
247 //
248 
250  : QgsGlowEffect()
251 {
252 
253 }
254 
256 {
257  QgsInnerGlowEffect *effect = new QgsInnerGlowEffect();
258  effect->readProperties( map );
259  return effect;
260 }
261 
263 {
264  QgsInnerGlowEffect *newEffect = new QgsInnerGlowEffect( *this );
265  return newEffect;
266 }
static void multiplyOpacity(QImage &image, double factor)
Multiplies opacity of image pixel values by a factor.
double opacity() const
Returns the opacity for the effect.
DrawMode mDrawMode
virtual QgsColorRamp * clone() const =0
Creates a clone of the color ramp.
Abstract base class for color ramps.
Definition: qgscolorramp.h:31
QPainter::CompositionMode mBlendMode
QgsGlowEffect & operator=(const QgsGlowEffect &rhs)
double spread
Maximum distance (in pixels) for the distance transform shading to spread.
Base class for visual effects which can be applied to QPicture drawings.
void draw(QgsRenderContext &context) override
Handles drawing of the effect&#39;s result on to the specified render context.
static QString encodeMapUnitScale(const QgsMapUnitScale &mapUnitScale)
static QgsColorRamp * create(const QgsStringMap &properties=QgsStringMap())
bool shadeExterior
Set to true to perform the distance transform on transparent pixels in the source image...
QMap< QString, QString > QgsStringMap
Definition: qgis.h:501
virtual bool shadeExterior() const =0
Specifies whether the glow is drawn outside the picture or within the picture.
Base class for paint effect which draw a glow inside or outside a picture.
Definition: qgsgloweffect.h:38
QImage * sourceAsImage(QgsRenderContext &context)
Returns the source QPicture rendered to a new QImage.
static QString encodeColor(const QColor &color)
QPointF imageOffset(const QgsRenderContext &context) const
Returns the offset which should be used when drawing the source image on to a destination render cont...
~QgsGlowEffect() override
QgsColorRamp * ramp
Color ramp to use for shading the distance transform.
GlowColorType mColorType
virtual QString type() const =0
Returns the effect type.
QgsUnitTypes::RenderUnit spreadUnit() const
Returns the units used for the glow spread distance.
Definition: qgsgloweffect.h:91
static QgsPaintEffect * create(const QgsStringMap &map)
Creates a new QgsOuterGlowEffect effect from a properties string map.
const QgsMapUnitScale & spreadMapUnitScale() const
Returns the map unit scale used for the spread distance.
static void distanceTransform(QImage &image, const QgsImageOperation::DistanceTransformProperties &properties)
Performs a distance transform on the source image and shades the result using a color ramp...
bool enabled() const
Returns whether the effect is enabled.
GlowColorType
Color sources for the glow.
Definition: qgsgloweffect.h:44
static Q_INVOKABLE QgsUnitTypes::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
bool useMaxDistance
Set to true to automatically calculate the maximum distance in the transform to use as the spread val...
QgsColorRamp * mRamp
GlowColorType colorType() const
Returns the color mode used for the glow.
A paint effect which draws a glow outside of a picture.
DrawMode
Drawing modes for effects.
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
QgsOuterGlowEffect * clone() const override
Duplicates an effect by creating a deep copy of the effect.
static QgsColorRamp * create(const QgsStringMap &properties=QgsStringMap())
Creates a new QgsColorRamp from a map of properties.
Contains information about the context of a rendering operation.
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
Use colors from a color ramp.
Definition: qgsgloweffect.h:47
double spread() const
Returns the spread distance used for drawing the glow effect.
Definition: qgsgloweffect.h:73
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
QgsInnerGlowEffect * clone() const override
Duplicates an effect by creating a deep copy of the effect.
static void stackBlur(QImage &image, int radius, bool alphaOnly=false)
Performs a stack blur on an image.
QgsMapUnitScale mSpreadMapUnitScale
void readProperties(const QgsStringMap &props) override
Reads a string map of an effect&#39;s properties and restores the effect to the state described by the pr...
virtual QgsStringMap properties() const =0
Returns a string map containing all the color ramp&#39;s properties.
QgsStringMap properties() const override
Returns the properties describing the paint effect encoded in a string format.
static QgsMapUnitScale decodeMapUnitScale(const QString &str)
void setRamp(QgsColorRamp *ramp)
Sets the color ramp for the glow.
QgsColorRamp * ramp() const
Returns the color ramp used for the glow.
const QPicture * source() const
Returns the source QPicture.
A paint effect which draws a glow within a picture.
Gradient color ramp, which smoothly interpolates between two colors and also supports optional extra ...
Definition: qgscolorramp.h:139
QRectF boundingRect(const QRectF &rect, const QgsRenderContext &context) const override
Returns the bounding rect required for drawing the effect.
static QgsPaintEffect * create(const QgsStringMap &map)
Creates a new QgsInnerGlowEffect effect from a properties string map.
static QColor decodeColor(const QString &str)
int blurLevel() const
Returns the blur level (strength) for the glow.
Struct for storing properties of a distance transform operation.
QgsUnitTypes::RenderUnit mSpreadUnit
QColor color() const
Returns the color for the glow.