← Back to branch summary

~ubuntu-branches/ubuntu/wily/qgis/wily

« back to all changes in this revision

Viewing changes to src/core/symbology-ng/qgsrendererv2.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Johan Van de Wauw
  • Date: 2010-07-11 20:23:24 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100711202324-5ktghxa7hracohmr
Tags: 1.4.0+12730-3ubuntu1
https://launchpad.net/bugs/540941
* Merge from Debian unstable (LP: #540941).
* Fix compilation issues with QT 4.7
* Add build-depends on libqt4-webkit-dev 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/symbology-ng/qgsrendererv2.cpp
 
1
 
 
2
#include "qgsrendererv2.h"
 
3
#include "qgssymbolv2.h"
 
4
#include "qgssymbollayerv2utils.h"
 
5
 
 
6
#include "qgssinglesymbolrendererv2.h" // for default renderer
 
7
 
 
8
#include "qgsrendererv2registry.h"
 
9
 
 
10
#include "qgsrendercontext.h"
 
11
#include "qgsgeometry.h"
 
12
#include "qgsfeature.h"
 
13
#include "qgslogger.h"
 
14
#include "qgsvectorlayer.h"
 
15
 
 
16
#include <QDomElement>
 
17
#include <QDomDocument>
 
18
#include <QPolygonF>
 
19
 
 
20
 
 
21
 
 
22
static unsigned char* _getPoint( QPointF& pt, QgsRenderContext& context, unsigned char* wkb )
 
23
{
 
24
  wkb++; // jump over endian info
 
25
  unsigned int wkbType = *(( int* ) wkb );
 
26
  wkb += sizeof( unsigned int );
 
27
 
 
28
  double x = *(( double * ) wkb ); wkb += sizeof( double );
 
29
  double y = *(( double * ) wkb ); wkb += sizeof( double );
 
30
 
 
31
  if ( wkbType == QGis::WKBPolygon25D )
 
32
    wkb += sizeof( double );
 
33
 
 
34
  if ( context.coordinateTransform() )
 
35
  {
 
36
    double z = 0; // dummy variable for coordiante transform
 
37
    context.coordinateTransform()->transformInPlace( x, y, z );
 
38
  }
 
39
 
 
40
  context.mapToPixel().transformInPlace( x, y );
 
41
 
 
42
  pt = QPointF( x, y );
 
43
  return wkb;
 
44
}
 
45
 
 
46
static unsigned char* _getLineString( QPolygonF& pts, QgsRenderContext& context, unsigned char* wkb )
 
47
{
 
48
  wkb++; // jump over endian info
 
49
  unsigned int wkbType = *(( int* ) wkb );
 
50
  wkb += sizeof( unsigned int );
 
51
  unsigned int nPoints = *(( int* ) wkb );
 
52
  wkb += sizeof( unsigned int );
 
53
 
 
54
  bool hasZValue = ( wkbType == QGis::WKBLineString25D );
 
55
  double x, y;
 
56
 
 
57
  pts.resize( nPoints );
 
58
 
 
59
  const QgsCoordinateTransform* ct = context.coordinateTransform();
 
60
  const QgsMapToPixel& mtp = context.mapToPixel();
 
61
  double z = 0; // dummy variable for coordiante transform
 
62
 
 
63
  for ( unsigned int i = 0; i < nPoints; ++i )
 
64
  {
 
65
    x = *(( double * ) wkb );
 
66
    wkb += sizeof( double );
 
67
    y = *(( double * ) wkb );
 
68
    wkb += sizeof( double );
 
69
 
 
70
    if ( hasZValue ) // ignore Z value
 
71
      wkb += sizeof( double );
 
72
 
 
73
    // TODO: maybe to the transform at once (faster?)
 
74
    if ( ct )
 
75
      ct->transformInPlace( x, y, z );
 
76
    mtp.transformInPlace( x, y );
 
77
 
 
78
    pts[i] = QPointF( x, y );
 
79
 
 
80
  }
 
81
 
 
82
  return wkb;
 
83
}
 
84
 
 
85
static unsigned char* _getPolygon( QPolygonF& pts, QList<QPolygonF>& holes, QgsRenderContext& context, unsigned char* wkb )
 
86
{
 
87
  wkb++; // jump over endian info
 
88
  unsigned int wkbType = *(( int* ) wkb );
 
89
  wkb += sizeof( unsigned int ); // jump over wkb type
 
90
  unsigned int numRings = *(( int* ) wkb );
 
91
  wkb += sizeof( unsigned int );
 
92
 
 
93
  if ( numRings == 0 )  // sanity check for zero rings in polygon
 
94
    return wkb;
 
95
 
 
96
  bool hasZValue = ( wkbType == QGis::WKBPolygon25D );
 
97
  double x, y;
 
98
  holes.clear();
 
99
 
 
100
  const QgsCoordinateTransform* ct = context.coordinateTransform();
 
101
  const QgsMapToPixel& mtp = context.mapToPixel();
 
102
  double z = 0; // dummy variable for coordiante transform
 
103
 
 
104
  for ( unsigned int idx = 0; idx < numRings; idx++ )
 
105
  {
 
106
    unsigned int nPoints = *(( int* )wkb );
 
107
    wkb += sizeof( unsigned int );
 
108
 
 
109
    QPolygonF poly( nPoints );
 
110
 
 
111
    // Extract the points from the WKB and store in a pair of vectors.
 
112
    for ( unsigned int jdx = 0; jdx < nPoints; jdx++ )
 
113
    {
 
114
      x = *(( double * ) wkb ); wkb += sizeof( double );
 
115
      y = *(( double * ) wkb ); wkb += sizeof( double );
 
116
 
 
117
      // TODO: maybe to the transform at once (faster?)
 
118
      if ( ct )
 
119
        ct->transformInPlace( x, y, z );
 
120
      mtp.transformInPlace( x, y );
 
121
 
 
122
      poly[jdx] = QPointF( x, y );
 
123
 
 
124
      if ( hasZValue )
 
125
        wkb += sizeof( double );
 
126
    }
 
127
 
 
128
    if ( nPoints < 1 )
 
129
      continue;
 
130
 
 
131
    if ( idx == 0 )
 
132
      pts = poly;
 
133
    else
 
134
      holes.append( poly );
 
135
  }
 
136
 
 
137
  return wkb;
 
138
}
 
139
 
 
140
 
 
141
QgsFeatureRendererV2::QgsFeatureRendererV2( QString type )
 
142
    : mType( type ), mUsingSymbolLevels( false ),
 
143
    mCurrentVertexMarkerType( QgsVectorLayer::Cross ),
 
144
    mCurrentVertexMarkerSize( 3 )
 
145
{
 
146
}
 
147
 
 
148
QgsFeatureRendererV2* QgsFeatureRendererV2::defaultRenderer( QGis::GeometryType geomType )
 
149
{
 
150
  return new QgsSingleSymbolRendererV2( QgsSymbolV2::defaultSymbol( geomType ) );
 
151
}
 
152
 
 
153
 
 
154
void QgsFeatureRendererV2::renderFeature( QgsFeature& feature, QgsRenderContext& context, int layer, bool drawVertexMarker )
 
155
{
 
156
  QgsSymbolV2* symbol = symbolForFeature( feature );
 
157
  if ( symbol == NULL )
 
158
    return;
 
159
 
 
160
  QgsSymbolV2::SymbolType symbolType = symbol->type();
 
161
 
 
162
  QgsGeometry* geom = feature.geometry();
 
163
  switch ( geom->wkbType() )
 
164
  {
 
165
    case QGis::WKBPoint:
 
166
    case QGis::WKBPoint25D:
 
167
    {
 
168
      if ( symbolType != QgsSymbolV2::Marker )
 
169
      {
 
170
        QgsDebugMsg( "point can be drawn only with marker symbol!" );
 
171
        break;
 
172
      }
 
173
      QPointF pt;
 
174
      _getPoint( pt, context, geom->asWkb() );
 
175
      (( QgsMarkerSymbolV2* )symbol )->renderPoint( pt, context, layer );
 
176
 
 
177
      //if ( drawVertexMarker )
 
178
      //  renderVertexMarker( pt, context );
 
179
    }
 
180
    break;
 
181
 
 
182
    case QGis::WKBLineString:
 
183
    case QGis::WKBLineString25D:
 
184
    {
 
185
      if ( symbolType != QgsSymbolV2::Line )
 
186
      {
 
187
        QgsDebugMsg( "linestring can be drawn only with line symbol!" );
 
188
        break;
 
189
      }
 
190
      QPolygonF pts;
 
191
      _getLineString( pts, context, geom->asWkb() );
 
192
      (( QgsLineSymbolV2* )symbol )->renderPolyline( pts, context, layer );
 
193
 
 
194
      if ( drawVertexMarker )
 
195
        renderVertexMarkerPolyline( pts, context );
 
196
    }
 
197
    break;
 
198
 
 
199
    case QGis::WKBPolygon:
 
200
    case QGis::WKBPolygon25D:
 
201
    {
 
202
      if ( symbolType != QgsSymbolV2::Fill )
 
203
      {
 
204
        QgsDebugMsg( "polygon can be drawn only with fill symbol!" );
 
205
        break;
 
206
      }
 
207
      QPolygonF pts;
 
208
      QList<QPolygonF> holes;
 
209
      _getPolygon( pts, holes, context, geom->asWkb() );
 
210
      (( QgsFillSymbolV2* )symbol )->renderPolygon( pts, ( holes.count() ? &holes : NULL ), context, layer );
 
211
 
 
212
      if ( drawVertexMarker )
 
213
        renderVertexMarkerPolygon( pts, ( holes.count() ? &holes : NULL ), context );
 
214
    }
 
215
    break;
 
216
 
 
217
    case QGis::WKBMultiPoint:
 
218
    case QGis::WKBMultiPoint25D:
 
219
    {
 
220
      if ( symbolType != QgsSymbolV2::Marker )
 
221
      {
 
222
        QgsDebugMsg( "multi-point can be drawn only with marker symbol!" );
 
223
        break;
 
224
      }
 
225
 
 
226
      unsigned char* wkb = geom->asWkb();
 
227
      unsigned int num = *(( int* )( wkb + 5 ) );
 
228
      unsigned char* ptr = wkb + 9;
 
229
      QPointF pt;
 
230
 
 
231
      for ( unsigned int i = 0; i < num; ++i )
 
232
      {
 
233
        ptr = _getPoint( pt, context, ptr );
 
234
        (( QgsMarkerSymbolV2* )symbol )->renderPoint( pt, context, layer );
 
235
 
 
236
        //if ( drawVertexMarker )
 
237
        //  renderVertexMarker( pt, context );
 
238
      }
 
239
    }
 
240
    break;
 
241
 
 
242
    case QGis::WKBMultiLineString:
 
243
    case QGis::WKBMultiLineString25D:
 
244
    {
 
245
      if ( symbolType != QgsSymbolV2::Line )
 
246
      {
 
247
        QgsDebugMsg( "multi-linestring can be drawn only with line symbol!" );
 
248
        break;
 
249
      }
 
250
 
 
251
      unsigned char* wkb = geom->asWkb();
 
252
      unsigned int num = *(( int* )( wkb + 5 ) );
 
253
      unsigned char* ptr = wkb + 9;
 
254
      QPolygonF pts;
 
255
 
 
256
      for ( unsigned int i = 0; i < num; ++i )
 
257
      {
 
258
        ptr = _getLineString( pts, context, ptr );
 
259
        (( QgsLineSymbolV2* )symbol )->renderPolyline( pts, context, layer );
 
260
 
 
261
        if ( drawVertexMarker )
 
262
          renderVertexMarkerPolyline( pts, context );
 
263
      }
 
264
    }
 
265
    break;
 
266
 
 
267
    case QGis::WKBMultiPolygon:
 
268
    case QGis::WKBMultiPolygon25D:
 
269
    {
 
270
      if ( symbolType != QgsSymbolV2::Fill )
 
271
      {
 
272
        QgsDebugMsg( "multi-polygon can be drawn only with fill symbol!" );
 
273
        break;
 
274
      }
 
275
 
 
276
      unsigned char* wkb = geom->asWkb();
 
277
      unsigned int num = *(( int* )( wkb + 5 ) );
 
278
      unsigned char* ptr = wkb + 9;
 
279
      QPolygonF pts;
 
280
      QList<QPolygonF> holes;
 
281
 
 
282
      for ( unsigned int i = 0; i < num; ++i )
 
283
      {
 
284
        ptr = _getPolygon( pts, holes, context, ptr );
 
285
        (( QgsFillSymbolV2* )symbol )->renderPolygon( pts, ( holes.count() ? &holes : NULL ), context, layer );
 
286
 
 
287
        if ( drawVertexMarker )
 
288
          renderVertexMarkerPolygon( pts, ( holes.count() ? &holes : NULL ), context );
 
289
      }
 
290
    }
 
291
    break;
 
292
 
 
293
    default:
 
294
      QgsDebugMsg( "unsupported wkb type for rendering" );
 
295
  }
 
296
}
 
297
 
 
298
QString QgsFeatureRendererV2::dump()
 
299
{
 
300
  return "UNKNOWN RENDERER\n";
 
301
}
 
302
 
 
303
 
 
304
QgsFeatureRendererV2* QgsFeatureRendererV2::load( QDomElement& element )
 
305
{
 
306
  // <renderer-v2 type=""> ... </renderer-v2>
 
307
 
 
308
  if ( element.isNull() )
 
309
    return NULL;
 
310
 
 
311
  // load renderer
 
312
  QString rendererType = element.attribute( "type" );
 
313
 
 
314
  QgsRendererV2CreateFunc pfCreate = QgsRendererV2Registry::instance()->rendererMetadata( rendererType ).createFunction();
 
315
 
 
316
  // unknown renderer type?
 
317
  if ( pfCreate == NULL )
 
318
    return NULL;
 
319
 
 
320
  QgsFeatureRendererV2* r = pfCreate( element );
 
321
  if ( r )
 
322
    r->setUsingSymbolLevels( element.attribute( "symbollevels", "0" ).toInt() );
 
323
 
 
324
  return r;
 
325
}
 
326
 
 
327
QDomElement QgsFeatureRendererV2::save( QDomDocument& doc )
 
328
{
 
329
  // create empty renderer element
 
330
  return doc.createElement( RENDERER_TAG_NAME );
 
331
}
 
332
 
 
333
QgsLegendSymbologyList QgsFeatureRendererV2::legendSymbologyItems( QSize iconSize )
 
334
{
 
335
  // empty list by default
 
336
  return QgsLegendSymbologyList();
 
337
}
 
338
 
 
339
void QgsFeatureRendererV2::setVertexMarkerAppearance( int type, int size )
 
340
{
 
341
  mCurrentVertexMarkerType = type;
 
342
  mCurrentVertexMarkerSize = size;
 
343
}
 
344
 
 
345
void QgsFeatureRendererV2::renderVertexMarker( QPointF& pt, QgsRenderContext& context )
 
346
{
 
347
  QgsVectorLayer::drawVertexMarker( pt.x(), pt.y(), *context.painter(),
 
348
                                    ( QgsVectorLayer::VertexMarkerType ) mCurrentVertexMarkerType,
 
349
                                    mCurrentVertexMarkerSize );
 
350
}
 
351
 
 
352
void QgsFeatureRendererV2::renderVertexMarkerPolyline( QPolygonF& pts, QgsRenderContext& context )
 
353
{
 
354
  foreach( QPointF pt, pts )
 
355
  renderVertexMarker( pt, context );
 
356
}
 
357
 
 
358
void QgsFeatureRendererV2::renderVertexMarkerPolygon( QPolygonF& pts, QList<QPolygonF>* rings, QgsRenderContext& context )
 
359
{
 
360
  foreach( QPointF pt, pts )
 
361
  renderVertexMarker( pt, context );
 
362
 
 
363
  if ( rings )
 
364
  {
 
365
    foreach( QPolygonF ring, *rings )
 
366
    {
 
367
      foreach( QPointF pt, ring )
 
368
      renderVertexMarker( pt, context );
 
369
    }
 
370
  }
 
371
}