method when exporting layouts to PDF
Options are for Lossy compression, which is the default JPEG compression
used, and Lossless compression (which creates bigger files in most
cases, but is much more suitable for professional printing outputs
or for post-production in Illustrator/etc)
The Bad news: this option is available in builds based on Qt 5.14
or later.
This feature allows users to enable map clipping for layout map items
so that the maps are clipped to the boundary of the current atlas feature.
(It's available for polygon atlas coverage layers only, for obvious reasons!)
Options exist for:
- Enabling or disabling the clipping on a per-map basis
- Specifying the clipping type:
- "Clip During Render Only": applies a painter based clip, so that
portions of vector features which sit outside the atlas feature become
invisible
- "Clip Feature Before Render": applies the clip before rendering features,
so borders of features which fall partially outside the atlas feature
will still be visible on the boundary of the atlas feature
- "Render Intersecting Features Unchanged": just renders all features
which intersect the current atlas feature, but without clipping their
geometry
- Controlling whether labels should be forced placed inside the atlas feature,
or whether they may be placed outside the feature
- Restricting the clip to a subset of the layers in the project, so that
only some are clipped
Sponsored by City of Canning
by a preset amount
Allows for tweaking the positioning of dashes/spaces in the line, so
that the dashes/spaces can be placed at nicer positions to account
for corners in the line (also can be used potentially to "align"
adjacent dash pattern borders)
Offset can be set in different units, including map units, and can
be data defined
Unlike QgsGeometry::asQPolygonF, this allows for correct handling
of multipolygons and rings, etc.
And potentially, the generated QPainterPaths could use arc segments
instead of segmentizing geometries. In fact, there's been disabled
code which seems to do this in place since the new geometry engine
was introduced back in 2.10! TODO: check if this code works correctly...
We don't want labels to be positioned using unclipped feature
geometries, rather we want them to be positioned nicely on the
visible portions of features
[FEATURE] Introduces memory dataset groups for mesh layer. These dataset groups are temporary and are not kept when the project is closed.
Memory dataset groups can be created from the mesh calculator with a new option.
Allows the possibility to remove or save these memory dataset groups to a file with specified driver.
Now it's possible to get a breakdown of the various stages of
project load, in order to identify the causes of slow project
load times.
TODO: in 99% of cases this will be caused by one or more layers,
so it would be nice to further break down the individual layer load
times, e.g. so that for a WFS layer we see the time taken for
the initial server capabilities queries, etc...
For now, you just get the overall load time of each individual
layer.
The QgsFeature default constructors initialized
feature id to 0, which is a valid feature id
instead of initializing it fo FID_NULL.
This was just wrong and broke the validator for
UNIQUE constraints in case a feature with fid 0
existed in the data provider.
Fixes#36962
Long story short: calling provider's addFeatures
is implemented for some providers in a way that
will roll back all changes on errors, leaving
the backend storage unchanged.
Adding a QgsFeatureSink flag to control this
behavior allows certain providers to support
partial feature addition.
The issue comes from QgsVectorDataProvider::commitChanges
that is documented to leave the provider unchanged (roll
back) on any error, giving the client code the possibility
to fix errors (in the editing buffer) and re-commit.
Without a full rollback implementation in the memory
provider and after the type check introduction in this
PR we ended up with situations like this:
vl = ... an empty memory layer
self.assertTrue(vl.addFeatures([valid, invalid]))
self.assertFalse(vl.commitChanges())
self.assertEqual(vl.featureCount(), 1) <--- fails!
We actually had 3 features from vl.getFeatures():
[valid, invalid, valid] (the first from the provider
the second and third from the editing buffer).
On the other hand, QgsFeatureSink would probably assume
that addFeatures will allow partial additions.
BTW: This is for sure the longest commit message I've ever
written.
Fixes#36715
Adds a method to check for QVariant conversions, also
check for integral type narrowing so that for example
floating point 123.45 does not get down casted to integer
without raising an error.
Also
* in settings UI, add a 'Early resampling' checkbox
* in raster properties UI, add similar checkbox
* serialize/deserialize new settings in QgsRasterLayer XML
Fixes#36820
The way QGIS is currently handling resampling is sub-optimal given GDAL >= 2
capability of having sub-pixel accuracy. So when a QgsRasterResampleFilter
is set, make it try to delegate resampling back to the underlying input interface,
and implement that improved resampling in the GDAL provider.
The GDAL resampling will take into account the settings of the QGIS resample
filter: zoom-in resampling kernel, zoom-out resampling kernel and max resampling
factor. The later is important to avoid performance issues if not enough overview
levels are generated (in the case, we will fallback to the generic method, which
may introduce sub-pixel shifts)
