sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-12-15 00:07:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move QGis::UnitType to QgsUnitTypes::DistanceUnit

Browse Source 
This change consolidates more unit handling and conversion into
QgsUnitTypes.

Additionally, UnknownUnit was renamed to UnknownDistanceUnit.
All methods which accepted QGis::UnitType parameters have been
updated to take QgsUnitTypes::DistanceUnit instead.

ALso remove the unit handling methods toLiteral, fromLiteral, tr,
fromTr, and fromUnitToUnitFactor from QGis. Their corresponding
counterparts in QgsUnitTypes should be used instead.
This commit is contained in:
Nyall Dawson 2016-07-17 14:56:05 +10:00
parent 59aed7b231
commit f6f5010131
83 changed files with 572 additions and 662 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/api_break.dox
View File

@ -52,6 +52,12 @@ qgsPermissiveToInt()</li>
<li>The constants DEFAULT_IDENTIFY_RADIUS and MINIMUM_POINT_SIZE were removed</li>
<li>QGis::DecimalDegrees, DegreesMinutesSeconds and DegreesDecimalMinutes have been removed, and have all been replaced
with the general Degrees unit</li>
<li>The distance unit types QGis::UnitType (including QGis::Meters, QGis::Feet, QGis::Degrees, QGis::NauticalMiles,
QGis::Kilometers, QGis::Yards, QGis::Miles and QGis::UnknownUnit have been moved to QgsUnitTypes::DistanceUnit.
Additionally, UnknownUnit was renamed to UnknownDistanceUnit. All methods which accepted QGis::UnitType parameters
have been updated to take QgsUnitTypes::DistanceUnit instead.</li>
<li>The unit handling methods toLiteral, fromLiteral, tr, fromTr, fromUnitToUnitFactor have been removed. Their
corresponding counterparts in QgsUnitTypes should be used instead.</li>
</ul>
\subsection qgis_api_break_3_0_QgsAuthConfigUriEdit QgsAuthConfigUriEdit

6
python/core/dxf/qgsdxfexport.sip
View File

@ -63,14 +63,14 @@ class QgsDxfExport
* Set map units
* @param u unit
*/
void setMapUnits( Qgis::UnitType u );
void setMapUnits( QgsUnitTypes::DistanceUnit u );
/**
* Retrieve map units
* @returns unit
* @see setMapUnits
*/
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
/**
* Set symbology export mode
@ -327,7 +327,7 @@ class QgsDxfExport
//! @note added in 2.15
void writeMText( const QString &layer, const QString &text, const QgsPointV2 &pt, double width, double angle, const QColor& color );
static double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits );
static double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits );
//! Return cleaned layer name for use in DXF
static QString dxfLayerName( const QString &name );

38
python/core/qgis.sip
View File

@ -136,44 +136,6 @@ class Qgis
QImage::Format_ARGB32_Premultiplied */ ARGB32_Premultiplied,
};
/** Map units that qgis supports
* @note that QGIS < 1.4 api had only Meters, Feet, Degrees and UnknownUnit
* @note and QGIS >1.8 returns to that
*/
//TODO QGIS 3.0 - clean up and move to QgsUnitTypes and rename to DistanceUnit
enum UnitType
{
Meters, /*!< meters */
Feet, /*!< imperial feet */
Degrees, /*!< degrees, for planar geographic CRS distance measurements */ //for 1.0 api backwards compatibility
NauticalMiles, /*!< nautical miles */
Kilometers, /*!< kilometers */
Yards, /*!< imperial yards */
Miles, /*!< terrestial miles */
UnknownUnit, /*!< unknown distance unit */
};
//! Provides the canonical name of the type value
//! @deprecated use QgsUnitTypes::encodeUnit() instead
static QString toLiteral( Qgis::UnitType unit ) /Deprecated/;
//! Converts from the canonical name to the type value
//! @deprecated use QgsUnitTypes::decodeDistanceUnit() instead
static UnitType fromLiteral( const QString& literal, Qgis::UnitType defaultType = UnknownUnit ) /Deprecated/;
//! Provides translated version of the type value
//! @deprecated use QgsUnitTypes::toString() instead
static QString tr( Qgis::UnitType unit ) /Deprecated/;
//! Provides type value from translated version
//! @deprecated use QgsUnitTypes::stringToDistanceUnit() instead
static UnitType fromTr( const QString& literal, Qgis::UnitType defaultType = UnknownUnit ) /Deprecated/;
//! Returns the conversion factor between the specified units
//! @deprecated use QgsUnitTyoes::fromUnitToUnitFactor() instead
static double fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit ) /Deprecated/;
//! User defined event types
enum UserEvent
{

2
python/core/qgscoordinatereferencesystem.sip
View File

@ -446,7 +446,7 @@ class QgsCoordinateReferenceSystem
/** Returns the units for the projection used by the CRS.
*/
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
// Mutators -----------------------------------

10
python/core/qgsdistancearea.sip
View File

@ -155,7 +155,7 @@ class QgsDistanceArea
* @note added in QGIS 2.14
* @see areaUnits()
*/
Qgis::UnitType lengthUnits() const;
QgsUnitTypes::DistanceUnit lengthUnits() const;
/** Returns the units of area for areal calculations made by this object.
* @note added in QGIS 2.14
@ -179,7 +179,7 @@ class QgsDistanceArea
* @return formatted measurement string
* @deprecated use formatDistance() or formatArea() instead
*/
static QString textUnit( double value, int decimals, Qgis::UnitType u, bool isArea, bool keepBaseUnit = false ) /Deprecated/;
static QString textUnit( double value, int decimals, QgsUnitTypes::DistanceUnit u, bool isArea, bool keepBaseUnit = false ) /Deprecated/;
/** Returns an distance formatted as a friendly string.
* @param distance distance to format
@ -191,7 +191,7 @@ class QgsDistanceArea
* @note added in QGIS 2.16
* @see formatArea()
*/
static QString formatDistance( double distance, int decimals, Qgis::UnitType unit, bool keepBaseUnit = false );
static QString formatDistance( double distance, int decimals, QgsUnitTypes::DistanceUnit unit, bool keepBaseUnit = false );
/** Returns an area formatted as a friendly string.
* @param area area to format
@ -208,7 +208,7 @@ class QgsDistanceArea
//! Helper for conversion between physical units
// TODO QGIS 3.0 - remove this method, as its behaviour is non-intuitive.
void convertMeasurement( double &measure /In,Out/, Qgis::UnitType &measureUnits /In,Out/, Qgis::UnitType displayUnits, bool isArea ) const;
void convertMeasurement( double &measure /In,Out/, QgsUnitTypes::DistanceUnit &measureUnits /In,Out/, QgsUnitTypes::DistanceUnit displayUnits, bool isArea ) const;
/** Takes a length measurement calculated by this QgsDistanceArea object and converts it to a
* different distance unit.
@ -219,7 +219,7 @@ class QgsDistanceArea
* @see convertAreaMeasurement()
* @note added in QGIS 2.14
*/
double convertLengthMeasurement( double length, Qgis::UnitType toUnits ) const;
double convertLengthMeasurement( double length, QgsUnitTypes::DistanceUnit toUnits ) const;
/** Takes an area measurement calculated by this QgsDistanceArea object and converts it to a
* different areal unit.

4
python/core/qgsexpression.sip
View File

@ -167,14 +167,14 @@ class QgsExpression
* @note added in QGIS 2.14
* @see setDistanceUnits()
*/
Qgis::UnitType distanceUnits() const;
QgsUnitTypes::DistanceUnit distanceUnits() const;
/** Sets the desired distance units for calculations involving geomCalculator(), eg "$length" and "$perimeter".
* @note distances are only converted when a geomCalculator() has been set
* @note added in QGIS 2.14
* @see distanceUnits()
*/
void setDistanceUnits( Qgis::UnitType unit );
void setDistanceUnits( QgsUnitTypes::DistanceUnit unit );
/** Returns the desired areal units for calculations involving geomCalculator(), eg "$area".
* @note areas are only converted when a geomCalculator() has been set

4
python/core/qgsmapsettings.sip
View File

@ -91,9 +91,9 @@ class QgsMapSettings
QgsCoordinateReferenceSystem destinationCrs() const;
//! Get units of map's geographical coordinates - used for scale calculation
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
//! Set units of map's geographical coordinates - used for scale calculation
void setMapUnits( Qgis::UnitType u );
void setMapUnits( QgsUnitTypes::DistanceUnit u );
//! Set the background color of the map
void setBackgroundColor( const QColor& color );

2
python/core/qgsproject.sip
View File

@ -246,7 +246,7 @@ class QgsProject : QObject
* @note added in QGIS 2.14
* @see areaUnits()
*/
Qgis::UnitType distanceUnits() const;
QgsUnitTypes::DistanceUnit distanceUnits() const;
/** Convenience function to query default area measurement units for project.
* @note added in QGIS 2.14

9
python/core/qgsscalecalculator.sip
View File

@ -13,11 +13,10 @@ class QgsScaleCalculator
/**
* Constructor
* @param dpi Monitor resolution in dots per inch
* @param mapUnits Units of the data on the map. Must match a value from the
* Qgis::UnitType enum (Meters, Feet, Degrees)
* @param mapUnits Units of the data on the map
*/
QgsScaleCalculator( double dpi = 0,
Qgis::UnitType mapUnits = Qgis::Meters );
QgsUnitTypes::DistanceUnit mapUnits = QgsUnitTypes::Meters );
/**
* Set the dpi to be used in scale calculations
@ -35,10 +34,10 @@ class QgsScaleCalculator
* Set the map units
* @param mapUnits Units of the data on the map. Must match a value from the
*/
void setMapUnits( Qgis::UnitType mapUnits );
void setMapUnits( QgsUnitTypes::DistanceUnit mapUnits );
/** Returns current map units */
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
/**
* Calculate the scale denominator

27
python/core/qgsunittypes.sip
View File

@ -12,6 +12,19 @@ class QgsUnitTypes
public:
//! Units of distance
enum DistanceUnit
{
Meters, /*!< meters */
Kilometers, /*!< kilometers */
Feet, /*!< imperial feet */
NauticalMiles, /*!< nautical miles */
Yards, /*!< imperial yards */
Miles, /*!< terrestial miles */
Degrees, /*!< degrees, for planar geographic CRS distance measurements */
UnknownDistanceUnit, /*!< unknown distance unit */
};
/** Types of distance units
*/
enum DistanceUnitType
@ -50,14 +63,14 @@ class QgsUnitTypes
/** Returns the type for a distance unit.
*/
static DistanceUnitType unitType( Qgis::UnitType unit );
static DistanceUnitType unitType( QgsUnitTypes::DistanceUnit unit );
/** Encodes a distance unit to a string.
* @param unit unit to encode
* @returns encoded string
* @see decodeDistanceUnit()
*/
static QString encodeUnit( Qgis::UnitType unit );
static QString encodeUnit( QgsUnitTypes::DistanceUnit unit );
/** Decodes a distance unit from a string.
* @param string string to decode
@ -65,27 +78,27 @@ class QgsUnitTypes
* @returns decoded units
* @see encodeUnit()
*/
static Qgis::UnitType decodeDistanceUnit( const QString& string, bool *ok = 0 );
static QgsUnitTypes::DistanceUnit decodeDistanceUnit( const QString& string, bool *ok = 0 );
/** Returns a translated string representing a distance unit.
* @param unit unit to convert to string
* @see stringToDistanceUnit()
*/
static QString toString( Qgis::UnitType unit );
static QString toString( QgsUnitTypes::DistanceUnit unit );
/** Converts a translated string to a distance unit.
* @param string string representing a distance unit
* @param ok optional boolean, will be set to true if string was converted successfully
* @see toString()
*/
static Qgis::UnitType stringToDistanceUnit( const QString& string, bool *ok = 0 );
static QgsUnitTypes::DistanceUnit stringToDistanceUnit( const QString& string, bool *ok = 0 );
/** Returns the conversion factor between the specified distance units.
* @param fromUnit distance unit to convert from
* @param toUnit distance unit to convert to
* @returns multiplication factor to convert between units
*/
static double fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit );
static double fromUnitToUnitFactor( QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit );
/** Returns the type for an areal unit.
*/
@ -130,7 +143,7 @@ class QgsUnitTypes
* @param distanceUnit distance unit to convert
* @return matching areal unit
*/
static AreaUnit distanceToAreaUnit( Qgis::UnitType distanceUnit );
static AreaUnit distanceToAreaUnit( QgsUnitTypes::DistanceUnit distanceUnit );
// ANGULAR UNITS

2
python/core/qgsvectorfilewriter.sip
View File

@ -271,7 +271,7 @@ class QgsVectorFileWriter
QString errorMessage();
/** Add feature to the currently opened data source */
bool addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer = 0, Qgis::UnitType outputUnit = Qgis::Meters );
bool addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer = 0, QgsUnitTypes::DistanceUnit outputUnit = QgsUnitTypes::Meters );
//! @note not available in python bindings
// QMap<int, int> attrIdxToOgrIdx();

4
python/core/qgsxmlutils.sip
View File

@ -10,11 +10,11 @@ class QgsXmlUtils
/* reading */
static Qgis::UnitType readMapUnits( const QDomElement& element );
static QgsUnitTypes::DistanceUnit readMapUnits( const QDomElement& element );
static QgsRectangle readRectangle( const QDomElement& element );
/* writing */
static QDomElement writeMapUnits( Qgis::UnitType units, QDomDocument& doc );
static QDomElement writeMapUnits( QgsUnitTypes::DistanceUnit units, QDomDocument& doc );
static QDomElement writeRectangle( const QgsRectangle& rect, QDomDocument& doc );
};

4
python/gui/qgsmapcanvas.sip
View File

@ -223,10 +223,10 @@ class QgsMapCanvas : QGraphicsView
bool isFrozen();
//! Set map units (needed by project properties dialog)
void setMapUnits( Qgis::UnitType mapUnits );
void setMapUnits( QgsUnitTypes::DistanceUnit mapUnits );
//! Get the current canvas map units
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
//! Getter for stored overrides of styles for layers.
//! @note added in 2.12

6
python/gui/qgsmaptoolidentify.sip
View File

@ -114,18 +114,18 @@ class QgsMapToolIdentify : QgsMapTool
//! Private helper
//! @deprecated use displayDistanceUnits() and displayAreaUnits() instead
virtual void convertMeasurement( QgsDistanceArea &calc, double &measure, Qgis::UnitType &u, bool isArea ) /Deprecated/;
virtual void convertMeasurement( QgsDistanceArea &calc, double &measure, QgsUnitTypes::DistanceUnit &u, bool isArea ) /Deprecated/;
/** Transforms the measurements of derived attributes in the desired units
* @deprecated use displayDistanceUnits() and displayAreaUnits() instead
*/
virtual Qgis::UnitType displayUnits() /Deprecated/;
virtual QgsUnitTypes::DistanceUnit displayUnits() /Deprecated/;
/** Desired units for distance display.
* @note added in QGIS 2.14
* @see displayAreaUnits()
*/
virtual Qgis::UnitType displayDistanceUnits() const;
virtual QgsUnitTypes::DistanceUnit displayDistanceUnits() const;
/** Desired units for area display.
* @note added in QGIS 2.14

4
python/server/qgsmaprenderer.sip
View File

@ -74,8 +74,8 @@ class QgsMapRenderer : QObject
//! Recalculate the map scale
void updateScale();
Qgis::UnitType mapUnits() const;
void setMapUnits( Qgis::UnitType u );
QgsUnitTypes::DistanceUnit mapUnits() const;
void setMapUnits( QgsUnitTypes::DistanceUnit u );
//! sets whether map image will be for overview
void enableOverviewMode( bool isOverview = true );

4
src/analysis/vector/qgstransectsample.cpp
View File

@ -181,7 +181,7 @@ int QgsTransectSample::createSample( QProgressDialog* pd )
double minDistanceLayerUnits = minDistance;
//if minDistance is in meters and the data in degrees, we need to apply a rough conversion for the buffer distance
double bufferDist = bufferDistance( minDistance );
if ( mMinDistanceUnits == Meters && mStrataLayer->crs().mapUnits() == Qgis::Degrees )
if ( mMinDistanceUnits == Meters && mStrataLayer->crs().mapUnits() == QgsUnitTypes::Degrees )
{
minDistanceLayerUnits = minDistance / 111319.9;
}
@ -710,7 +710,7 @@ double QgsTransectSample::bufferDistance( double minDistanceFromAttribute ) cons
bufferDist = mBaselineBufferDistance;
}
if ( mMinDistanceUnits == Meters && mStrataLayer->crs().mapUnits() == Qgis::Degrees )
if ( mMinDistanceUnits == Meters && mStrataLayer->crs().mapUnits() == QgsUnitTypes::Degrees )
{
bufferDist /= 111319.9;
}

4
src/app/qgisapp.cpp
View File

@ -4420,7 +4420,7 @@ void QgisApp::fileNew( bool thePromptToSaveFlag, bool forceBlank )
prj->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
prj->writeEntry( "SpatialRefSys", "/ProjectCRSID", static_cast< int >( srs.srsid() ) );
prj->setDirty( false );
if ( srs.mapUnits() != Qgis::UnknownUnit )
if ( srs.mapUnits() != QgsUnitTypes::UnknownDistanceUnit )
{
mMapCanvas->setMapUnits( srs.mapUnits() );
}
@ -8508,7 +8508,7 @@ void QgisApp::setProjectCrsFromLayer()
QgsCoordinateReferenceSystem crs = mLayerTreeView->currentLayer()->crs();
mMapCanvas->freeze();
mMapCanvas->setDestinationCrs( crs );
if ( crs.mapUnits() != Qgis::UnknownUnit )
if ( crs.mapUnits() != QgsUnitTypes::UnknownDistanceUnit )
{
mMapCanvas->setMapUnits( crs.mapUnits() );
}

12
src/app/qgsdecorationgrid.cpp
View File

@ -93,8 +93,8 @@ void QgsDecorationGrid::projectRead()
QgsDecorationItem::projectRead();
mEnabled = QgsProject::instance()->readBoolEntry( mNameConfig, "/Enabled", false );
mMapUnits = static_cast< Qgis::UnitType >( QgsProject::instance()->readNumEntry( mNameConfig, "/MapUnits",
Qgis::UnknownUnit ) );
mMapUnits = static_cast< QgsUnitTypes::DistanceUnit >( QgsProject::instance()->readNumEntry( mNameConfig, "/MapUnits",
QgsUnitTypes::UnknownDistanceUnit ) );
mGridStyle = static_cast< GridStyle >( QgsProject::instance()->readNumEntry( mNameConfig, "/Style",
QgsDecorationGrid::Line ) );
mGridIntervalX = QgsProject::instance()->readDoubleEntry( mNameConfig, "/IntervalX", 10 );
@ -747,11 +747,11 @@ void QgsDecorationGrid::checkMapUnitsChanged()
// this is to avoid problems when CRS changes to/from geographic and projected
// a better solution would be to change the grid interval, but this is a little tricky
// note: we could be less picky (e.g. from degrees to DMS)
Qgis::UnitType mapUnits = QgisApp::instance()->mapCanvas()->mapSettings().mapUnits();
QgsUnitTypes::DistanceUnit mapUnits = QgisApp::instance()->mapCanvas()->mapSettings().mapUnits();
if ( mEnabled && ( mMapUnits != mapUnits ) )
{
mEnabled = false;
mMapUnits = Qgis::UnknownUnit; // make sure isDirty() returns true
mMapUnits = QgsUnitTypes::UnknownDistanceUnit; // make sure isDirty() returns true
if ( ! QgisApp::instance()->mapCanvas()->isFrozen() )
{
update();
@ -763,7 +763,7 @@ bool QgsDecorationGrid::isDirty()
{
// checks if stored map units is undefined or different from canvas map units
// or if interval is 0
if ( mMapUnits == Qgis::UnknownUnit ||
if ( mMapUnits == QgsUnitTypes::UnknownDistanceUnit ||
mMapUnits != QgisApp::instance()->mapCanvas()->mapSettings().mapUnits() ||
qgsDoubleNear( mGridIntervalX, 0.0 ) || qgsDoubleNear( mGridIntervalY, 0.0 ) )
return true;
@ -774,7 +774,7 @@ void QgsDecorationGrid::setDirty( bool dirty )
{
if ( dirty )
{
mMapUnits = Qgis::UnknownUnit;
mMapUnits = QgsUnitTypes::UnknownDistanceUnit;
}
else
{

6
src/app/qgsdecorationgrid.h
View File

@ -124,8 +124,8 @@ class APP_EXPORT QgsDecorationGrid: public QgsDecorationItem
const QgsMarkerSymbolV2* markerSymbol() const { return mMarkerSymbol; }
/** Sets map unit type */
void setMapUnits( Qgis::UnitType t ) { mMapUnits = t; }
Qgis::UnitType mapUnits() { return mMapUnits; }
void setMapUnits( QgsUnitTypes::DistanceUnit t ) { mMapUnits = t; }
QgsUnitTypes::DistanceUnit mapUnits() { return mMapUnits; }
/** Set mapUnits value */
void setDirty( bool dirty = true );
@ -193,7 +193,7 @@ class APP_EXPORT QgsDecorationGrid: public QgsDecorationItem
QgsLineSymbolV2* mLineSymbol;
QgsMarkerSymbolV2* mMarkerSymbol;
Qgis::UnitType mMapUnits;
QgsUnitTypes::DistanceUnit mMapUnits;
/** Draw coordinates for mGridAnnotationType Coordinate
@param p drawing painter

14
src/app/qgsdecorationscalebar.cpp
View File

@ -133,10 +133,10 @@ void QgsDecorationScaleBar::render( QPainter * theQPainter )
QSettings settings;
bool ok = false;
Qgis::UnitType myPreferredUnits = QgsUnitTypes::decodeDistanceUnit( settings.value( "/qgis/measure/displayunits" ).toString(), &ok );
QgsUnitTypes::DistanceUnit myPreferredUnits = QgsUnitTypes::decodeDistanceUnit( settings.value( "/qgis/measure/displayunits" ).toString(), &ok );
if ( !ok )
myPreferredUnits = Qgis::Meters;
Qgis::UnitType myMapUnits = canvas->mapUnits();
myPreferredUnits = QgsUnitTypes::Meters;
QgsUnitTypes::DistanceUnit myMapUnits = canvas->mapUnits();
// Adjust units meter/feet/... or vice versa
myMapUnitsPerPixelDouble *= QgsUnitTypes::fromUnitToUnitFactor( myMapUnits, myPreferredUnits );
@ -175,7 +175,7 @@ void QgsDecorationScaleBar::render( QPainter * theQPainter )
QString myScaleBarUnitLabel;
switch ( myMapUnits )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
if ( myActualSize > 1000.0 )
{
myScaleBarUnitLabel = tr( " km" );
@ -194,7 +194,7 @@ void QgsDecorationScaleBar::render( QPainter * theQPainter )
else
myScaleBarUnitLabel = tr( " m" );
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
if ( myActualSize > 5280.0 ) //5280 feet to the mile
{
myScaleBarUnitLabel = tr( " miles" );
@ -224,13 +224,13 @@ void QgsDecorationScaleBar::render( QPainter * theQPainter )
myScaleBarUnitLabel = tr( " feet" );
}
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
if ( myActualSize == 1.0 )
myScaleBarUnitLabel = tr( " degree" );
else
myScaleBarUnitLabel = tr( " degrees" );
break;
case Qgis::UnknownUnit:
case QgsUnitTypes::UnknownDistanceUnit:
myScaleBarUnitLabel = tr( " unknown" );
//intentional fall-through
FALLTHROUGH;

2
src/app/qgsmaptoolidentifyaction.cpp
View File

@ -185,7 +185,7 @@ void QgsMapToolIdentifyAction::deactivate()
QgsMapTool::deactivate();
}
Qgis::UnitType QgsMapToolIdentifyAction::displayDistanceUnits() const
QgsUnitTypes::DistanceUnit QgsMapToolIdentifyAction::displayDistanceUnits() const
{
return QgsProject::instance()->distanceUnits();
}

2
src/app/qgsmaptoolidentifyaction.h
View File

@ -76,7 +76,7 @@ class APP_EXPORT QgsMapToolIdentifyAction : public QgsMapToolIdentify
QgsIdentifyResultsDialog *resultsDialog();
virtual Qgis::UnitType displayDistanceUnits() const override;
virtual QgsUnitTypes::DistanceUnit displayDistanceUnits() const override;
virtual QgsUnitTypes::AreaUnit displayAreaUnits() const override;
};

32
src/app/qgsmeasuredialog.cpp
View File

@ -108,7 +108,7 @@ void QgsMeasureDialog::unitsChanged( int index )
if ( mMeasureArea )
mAreaUnits = static_cast< QgsUnitTypes::AreaUnit >( mUnitsCombo->itemData( index ).toInt() );
else
mDistanceUnits = static_cast< Qgis::UnitType >( mUnitsCombo->itemData( index ).toInt() );
mDistanceUnits = static_cast< QgsUnitTypes::DistanceUnit >( mUnitsCombo->itemData( index ).toInt() );
mTable->clear();
mTotal = 0.;
updateUi();
@ -274,7 +274,7 @@ void QgsMeasureDialog::updateUi()
if ( mMeasureArea )
{
if ( mTool->canvas()->mapSettings().destinationCrs().mapUnits() == Qgis::Degrees
if ( mTool->canvas()->mapSettings().destinationCrs().mapUnits() == QgsUnitTypes::Degrees
&& ( mAreaUnits == QgsUnitTypes::SquareDegrees || mAreaUnits == QgsUnitTypes::UnknownAreaUnit ) )
{
//both source and destination units are degrees
@ -348,8 +348,8 @@ void QgsMeasureDialog::updateUi()
}
else
{
if ( mTool->canvas()->mapSettings().destinationCrs().mapUnits() == Qgis::Degrees
&& mDistanceUnits == Qgis::Degrees )
if ( mTool->canvas()->mapSettings().destinationCrs().mapUnits() == QgsUnitTypes::Degrees
&& mDistanceUnits == QgsUnitTypes::Degrees )
{
//both source and destination units are degrees
toolTip += "<br> * " + tr( "Both project CRS (%1) and measured length are in degrees, so distance is calculated using cartesian calculations in degrees." ).arg(
@ -359,7 +359,7 @@ void QgsMeasureDialog::updateUi()
}
else
{
Qgis::UnitType resultUnit = Qgis::UnknownUnit;
QgsUnitTypes::DistanceUnit resultUnit = QgsUnitTypes::UnknownDistanceUnit;
if ( ! mTool->canvas()->hasCrsTransformEnabled() )
{
resultUnit = mTool->canvas()->mapSettings().destinationCrs().mapUnits();
@ -373,7 +373,7 @@ void QgsMeasureDialog::updateUi()
{
if ( mDa.willUseEllipsoid() )
{
resultUnit = Qgis::Meters;
resultUnit = QgsUnitTypes::Meters;
toolTip += "<br> * " + tr( "Project CRS transformation is turned on and ellipsoidal calculation is selected." ) + ' ';
toolTip += "<br> * " + tr( "The coordinates are transformed to the chosen ellipsoid (%1), and the distance is calculated in %2." ).arg( mDa.ellipsoid(),
QgsUnitTypes::toString( resultUnit ) );
@ -392,13 +392,13 @@ void QgsMeasureDialog::updateUi()
QgsUnitTypes::unitType( mDistanceUnits ) == QgsUnitTypes::Standard )
{
toolTip += "<br> * Distance is roughly converted to meters by using scale at equator (1 degree = 111319.49 meters).";
resultUnit = Qgis::Meters;
resultUnit = QgsUnitTypes::Meters;
}
else if ( QgsUnitTypes::unitType( resultUnit ) == QgsUnitTypes::Standard &&
QgsUnitTypes::unitType( mDistanceUnits ) == QgsUnitTypes::Geographic )
{
toolTip += "<br> * Distance is roughly converted to degrees by using scale at equator (1 degree = 111319.49 meters).";
resultUnit = Qgis::Degrees;
resultUnit = QgsUnitTypes::Degrees;
}
if ( resultUnit != mDistanceUnits )
@ -504,17 +504,17 @@ void QgsMeasureDialog::repopulateComboBoxUnits( bool isArea )
}
else
{
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Meters ), Qgis::Meters );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Kilometers ), Qgis::Kilometers );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Feet ), Qgis::Feet );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Yards ), Qgis::Yards );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Miles ), Qgis::Miles );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::Degrees ), Qgis::Degrees );
mUnitsCombo->addItem( QgsUnitTypes::toString( Qgis::NauticalMiles ), Qgis::NauticalMiles );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Meters ), QgsUnitTypes::Meters );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Kilometers ), QgsUnitTypes::Kilometers );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Feet ), QgsUnitTypes::Feet );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Yards ), QgsUnitTypes::Yards );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Miles ), QgsUnitTypes::Miles );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::Degrees ), QgsUnitTypes::Degrees );
mUnitsCombo->addItem( QgsUnitTypes::toString( QgsUnitTypes::NauticalMiles ), QgsUnitTypes::NauticalMiles );
}
}
double QgsMeasureDialog::convertLength( double length, Qgis::UnitType toUnit ) const
double QgsMeasureDialog::convertLength( double length, QgsUnitTypes::DistanceUnit toUnit ) const
{
return mDa.convertLengthMeasurement( length, toUnit );
}

6
src/app/qgsmeasuredialog.h
View File

@ -87,7 +87,7 @@ class APP_EXPORT QgsMeasureDialog : public QDialog, private Ui::QgsMeasureBase
*/
void repopulateComboBoxUnits( bool isArea );
double convertLength( double length, Qgis::UnitType toUnit ) const;
double convertLength( double length, QgsUnitTypes::DistanceUnit toUnit ) const;
double convertArea( double area, QgsUnitTypes::AreaUnit toUnit ) const;
@ -100,10 +100,10 @@ class APP_EXPORT QgsMeasureDialog : public QDialog, private Ui::QgsMeasureBase
int mDecimalPlaces;
//! Current unit for input values
Qgis::UnitType mCanvasUnits;
QgsUnitTypes::DistanceUnit mCanvasUnits;
//! Current unit for distance values
Qgis::UnitType mDistanceUnits;
QgsUnitTypes::DistanceUnit mDistanceUnits;
//! Current unit for area values
QgsUnitTypes::AreaUnit mAreaUnits;

22
src/app/qgsoptions.cpp
View File

@ -460,19 +460,19 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl )
}
// Set the units for measuring
mDistanceUnitsComboBox->addItem( tr( "Meters" ), Qgis::Meters );
mDistanceUnitsComboBox->addItem( tr( "Kilometers" ), Qgis::Kilometers );
mDistanceUnitsComboBox->addItem( tr( "Feet" ), Qgis::Feet );
mDistanceUnitsComboBox->addItem( tr( "Yards" ), Qgis::Yards );
mDistanceUnitsComboBox->addItem( tr( "Miles" ), Qgis::Miles );
mDistanceUnitsComboBox->addItem( tr( "Nautical miles" ), Qgis::NauticalMiles );
mDistanceUnitsComboBox->addItem( tr( "Degrees" ), Qgis::Degrees );
mDistanceUnitsComboBox->addItem( tr( "Map units" ), Qgis::UnknownUnit );
mDistanceUnitsComboBox->addItem( tr( "Meters" ), QgsUnitTypes::Meters );
mDistanceUnitsComboBox->addItem( tr( "Kilometers" ), QgsUnitTypes::Kilometers );
mDistanceUnitsComboBox->addItem( tr( "Feet" ), QgsUnitTypes::Feet );
mDistanceUnitsComboBox->addItem( tr( "Yards" ), QgsUnitTypes::Yards );
mDistanceUnitsComboBox->addItem( tr( "Miles" ), QgsUnitTypes::Miles );
mDistanceUnitsComboBox->addItem( tr( "Nautical miles" ), QgsUnitTypes::NauticalMiles );
mDistanceUnitsComboBox->addItem( tr( "Degrees" ), QgsUnitTypes::Degrees );
mDistanceUnitsComboBox->addItem( tr( "Map units" ), QgsUnitTypes::UnknownDistanceUnit );
bool ok = false;
Qgis::UnitType distanceUnits = QgsUnitTypes::decodeDistanceUnit( mSettings->value( "/qgis/measure/displayunits" ).toString(), &ok );
QgsUnitTypes::DistanceUnit distanceUnits = QgsUnitTypes::decodeDistanceUnit( mSettings->value( "/qgis/measure/displayunits" ).toString(), &ok );
if ( !ok )
distanceUnits = Qgis::Meters;
distanceUnits = QgsUnitTypes::Meters;
mDistanceUnitsComboBox->setCurrentIndex( mDistanceUnitsComboBox->findData( distanceUnits ) );
mAreaUnitsComboBox->addItem( tr( "Square meters" ), QgsUnitTypes::SquareMeters );
@ -1302,7 +1302,7 @@ void QgsOptions::saveOptions()
//measurement settings
Qgis::UnitType distanceUnit = static_cast< Qgis::UnitType >( mDistanceUnitsComboBox->itemData( mDistanceUnitsComboBox->currentIndex() ).toInt() );
QgsUnitTypes::DistanceUnit distanceUnit = static_cast< QgsUnitTypes::DistanceUnit >( mDistanceUnitsComboBox->itemData( mDistanceUnitsComboBox->currentIndex() ).toInt() );
mSettings->setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( distanceUnit ) );
QgsUnitTypes::AreaUnit areaUnit = static_cast< QgsUnitTypes::AreaUnit >( mAreaUnitsComboBox->itemData( mAreaUnitsComboBox->currentIndex() ).toInt() );

34
src/app/qgsprojectproperties.cpp
View File

@ -87,14 +87,14 @@ QgsProjectProperties::QgsProjectProperties( QgsMapCanvas* mapCanvas, QWidget *pa
mCoordinateDisplayComboBox->addItem( tr( "Degrees, minutes" ), DegreesMinutes );
mCoordinateDisplayComboBox->addItem( tr( "Degrees, minutes, seconds" ), DegreesMinutesSeconds );
mDistanceUnitsCombo->addItem( tr( "Meters" ), Qgis::Meters );
mDistanceUnitsCombo->addItem( tr( "Kilometers" ), Qgis::Kilometers );
mDistanceUnitsCombo->addItem( tr( "Feet" ), Qgis::Feet );
mDistanceUnitsCombo->addItem( tr( "Yards" ), Qgis::Yards );
mDistanceUnitsCombo->addItem( tr( "Miles" ), Qgis::Miles );
mDistanceUnitsCombo->addItem( tr( "Nautical miles" ), Qgis::NauticalMiles );
mDistanceUnitsCombo->addItem( tr( "Degrees" ), Qgis::Degrees );
mDistanceUnitsCombo->addItem( tr( "Map units" ), Qgis::UnknownUnit );
mDistanceUnitsCombo->addItem( tr( "Meters" ), QgsUnitTypes::Meters );
mDistanceUnitsCombo->addItem( tr( "Kilometers" ), QgsUnitTypes::Kilometers );
mDistanceUnitsCombo->addItem( tr( "Feet" ), QgsUnitTypes::Feet );
mDistanceUnitsCombo->addItem( tr( "Yards" ), QgsUnitTypes::Yards );
mDistanceUnitsCombo->addItem( tr( "Miles" ), QgsUnitTypes::Miles );
mDistanceUnitsCombo->addItem( tr( "Nautical miles" ), QgsUnitTypes::NauticalMiles );
mDistanceUnitsCombo->addItem( tr( "Degrees" ), QgsUnitTypes::Degrees );
mDistanceUnitsCombo->addItem( tr( "Map units" ), QgsUnitTypes::UnknownDistanceUnit );
mAreaUnitsCombo->addItem( tr( "Square meters" ), QgsUnitTypes::SquareMeters );
mAreaUnitsCombo->addItem( tr( "Square kilometers" ), QgsUnitTypes::SquareKilometers );
@ -733,17 +733,17 @@ QgsProjectProperties::~QgsProjectProperties()
}
// return the map units
Qgis::UnitType QgsProjectProperties::mapUnits() const
QgsUnitTypes::DistanceUnit QgsProjectProperties::mapUnits() const
{
return mMapCanvas->mapSettings().mapUnits();
}
void QgsProjectProperties::setMapUnits( Qgis::UnitType unit )
void QgsProjectProperties::setMapUnits( QgsUnitTypes::DistanceUnit unit )
{
// select the button
if ( unit == Qgis::UnknownUnit )
if ( unit == QgsUnitTypes::UnknownDistanceUnit )
{
unit = Qgis::Meters;
unit = QgsUnitTypes::Meters;
}
mMapCanvas->setMapUnits( unit );
@ -788,7 +788,7 @@ void QgsProjectProperties::apply()
{
// If we couldn't get the map units, default to the value in the
// projectproperties dialog box (set above)
if ( srs.mapUnits() != Qgis::UnknownUnit )
if ( srs.mapUnits() != QgsUnitTypes::UnknownDistanceUnit )
mMapCanvas->setMapUnits( srs.mapUnits() );
}
@ -832,7 +832,7 @@ void QgsProjectProperties::apply()
// Announce that we may have a new display precision setting
emit displayPrecisionChanged();
Qgis::UnitType distanceUnits = static_cast< Qgis::UnitType >( mDistanceUnitsCombo->itemData( mDistanceUnitsCombo->currentIndex() ).toInt() );
QgsUnitTypes::DistanceUnit distanceUnits = static_cast< QgsUnitTypes::DistanceUnit >( mDistanceUnitsCombo->itemData( mDistanceUnitsCombo->currentIndex() ).toInt() );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( distanceUnits ) );
QgsUnitTypes::AreaUnit areaUnits = static_cast< QgsUnitTypes::AreaUnit >( mAreaUnitsCombo->itemData( mAreaUnitsCombo->currentIndex() ).toInt() );
@ -1275,7 +1275,7 @@ void QgsProjectProperties::cbxWCSPubliedStateChanged( int aIdx )
}
}
void QgsProjectProperties::updateGuiForMapUnits( Qgis::UnitType units )
void QgsProjectProperties::updateGuiForMapUnits( QgsUnitTypes::DistanceUnit units )
{
//make sure map units option is shown in coordinate display combo
int idx = mCoordinateDisplayComboBox->findData( MapUnits );
@ -1283,7 +1283,7 @@ void QgsProjectProperties::updateGuiForMapUnits( Qgis::UnitType units )
mCoordinateDisplayComboBox->setItemText( idx, mapUnitString );
//also update unit combo boxes
idx = mDistanceUnitsCombo->findData( Qgis::UnknownUnit );
idx = mDistanceUnitsCombo->findData( QgsUnitTypes::UnknownDistanceUnit );
if ( idx >= 0 )
{
QString mapUnitString = tr( "Map units (%1)" ).arg( QgsUnitTypes::toString( units ) );
@ -1305,7 +1305,7 @@ void QgsProjectProperties::srIdUpdated()
QgsCoordinateReferenceSystem srs = QgsCrsCache::instance()->crsBySrsId( myCRSID );
//set radio button to crs map unit type
Qgis::UnitType units = srs.mapUnits();
QgsUnitTypes::DistanceUnit units = srs.mapUnits();
updateGuiForMapUnits( units );

7
src/app/qgsprojectproperties.h
View File

@ -20,6 +20,7 @@
#include "qgsoptionsdialogbase.h"
#include "ui_qgsprojectpropertiesbase.h"
#include "qgis.h"
#include "qgsunittypes.h"
#include "qgisgui.h"
#include "qgscontexthelp.h"
@ -47,12 +48,12 @@ class APP_EXPORT QgsProjectProperties : public QgsOptionsDialogBase, private Ui:
/** Gets the currently select map units
*/
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
/*!
* Set the map units
*/
void setMapUnits( Qgis::UnitType );
void setMapUnits( QgsUnitTypes::DistanceUnit );
/*!
Every project has a title
@ -240,5 +241,5 @@ class APP_EXPORT QgsProjectProperties : public QgsOptionsDialogBase, private Ui:
static const char * GEO_NONE_DESC;
void updateGuiForMapUnits( Qgis::UnitType units );
void updateGuiForMapUnits( QgsUnitTypes::DistanceUnit units );
};

8
src/core/composer/qgscomposerscalebar.cpp
View File

@ -306,20 +306,20 @@ double QgsComposerScaleBar::mapWidth() const
da.setSourceCrs( mComposition->mapSettings().destinationCrs().srsid() );
da.setEllipsoid( QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", "WGS84" ) );
Qgis::UnitType units = Qgis::Meters;
QgsUnitTypes::DistanceUnit units = QgsUnitTypes::Meters;
double measure = da.measureLine( QgsPoint( composerMapRect.xMinimum(), composerMapRect.yMinimum() ),
QgsPoint( composerMapRect.xMaximum(), composerMapRect.yMinimum() ),
units );
switch ( mUnits )
{
case QgsComposerScaleBar::Feet:
measure /= QgsUnitTypes::fromUnitToUnitFactor( Qgis::Feet, units );
measure /= QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::Feet, units );
break;
case QgsComposerScaleBar::NauticalMiles:
measure /= QgsUnitTypes::fromUnitToUnitFactor( Qgis::NauticalMiles, units );
measure /= QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::NauticalMiles, units );
break;
case QgsComposerScaleBar::Meters:
measure /= QgsUnitTypes::fromUnitToUnitFactor( Qgis::Meters, units );
measure /= QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::Meters, units );
break;
case QgsComposerScaleBar::MapUnits:
//avoid warning

10
src/core/dxf/qgsdxfexport.cpp
View File

@ -366,7 +366,7 @@ const char *QgsDxfExport::mDxfEncodings[][2] =
QgsDxfExport::QgsDxfExport()
: mSymbologyScaleDenominator( 1.0 )
, mSymbologyExport( NoSymbology )
, mMapUnits( Qgis::Meters )
, mMapUnits( QgsUnitTypes::Meters )
, mLayerTitleAsName( false )
, mSymbolLayerCounter( 0 )
, mNextHandleId( DXF_HANDSEED )
@ -912,7 +912,7 @@ void QgsDxfExport::writeEntities()
mapSettings.setExtent( bbox );
int dpi = 96;
double factor = 1000 * dpi / mSymbologyScaleDenominator / 25.4 * QgsUnitTypes::fromUnitToUnitFactor( mMapUnits, Qgis::Meters );
double factor = 1000 * dpi / mSymbologyScaleDenominator / 25.4 * QgsUnitTypes::fromUnitToUnitFactor( mMapUnits, QgsUnitTypes::Meters );
mapSettings.setOutputSize( QSize( bbox.width() * factor, bbox.height() * factor ) );
mapSettings.setOutputDpi( dpi );
mapSettings.setCrsTransformEnabled( false );
@ -3960,14 +3960,14 @@ QgsRenderContext QgsDxfExport::renderContext() const
return context;
}
double QgsDxfExport::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits )
double QgsDxfExport::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits )
{
if ( symbolUnits == QgsSymbolV2::MapUnit )
{
return 1.0;
}
// MM symbol unit
return scaleDenominator * QgsUnitTypes::fromUnitToUnitFactor( Qgis::Meters, mapUnits ) / 1000.0;
return scaleDenominator * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::Meters, mapUnits ) / 1000.0;
}
QList< QPair< QgsSymbolLayerV2*, QgsSymbolV2* > > QgsDxfExport::symbolLayers( QgsRenderContext &context )
@ -4164,7 +4164,7 @@ double QgsDxfExport::dashSeparatorSize() const
double QgsDxfExport::sizeToMapUnits( double s ) const
{
double size = s * QgsUnitTypes::fromUnitToUnitFactor( Qgis::Meters, mMapUnits );
double size = s * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::Meters, mMapUnits );
return size;
}

8
src/core/dxf/qgsdxfexport.h
View File

@ -86,14 +86,14 @@ class CORE_EXPORT QgsDxfExport
* Set map units
* @param u unit
*/
void setMapUnits( Qgis::UnitType u ) { mMapUnits = u; }
void setMapUnits( QgsUnitTypes::DistanceUnit u ) { mMapUnits = u; }
/**
* Retrieve map units
* @returns unit
* @see setMapUnits
*/
Qgis::UnitType mapUnits() const { return mMapUnits; }
QgsUnitTypes::DistanceUnit mapUnits() const { return mMapUnits; }
/**
* Set symbology export mode
@ -352,7 +352,7 @@ class CORE_EXPORT QgsDxfExport
//! @note added in 2.15
void writeMText( const QString &layer, const QString &text, const QgsPointV2 &pt, double width, double angle, const QColor& color );
static double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits );
static double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits );
//! Return cleaned layer name for use in DXF
static QString dxfLayerName( const QString &name );
@ -387,7 +387,7 @@ class CORE_EXPORT QgsDxfExport
/** Scale for symbology export (used if symbols units are mm)*/
double mSymbologyScaleDenominator;
SymbologyExport mSymbologyExport;
Qgis::UnitType mMapUnits;
QgsUnitTypes::DistanceUnit mMapUnits;
bool mLayerTitleAsName;
QTextStream mTextStream;

45
src/core/qgis.cpp
View File

@ -28,7 +28,6 @@
#include "qgsconfig.h"
#include "qgslogger.h"
#include "geometry/qgswkbtypes.h"
#include "qgsunittypes.h"
#include <ogr_api.h>
@ -88,20 +87,6 @@ double Qgis::DEFAULT_HIGHLIGHT_MIN_WIDTH_MM = 1.0;
double Qgis::SCALE_PRECISION = 0.9999999999;
// description strings for units
// Order must match enum indices
const char* Qgis::qgisUnitTypes[] =
{
QT_TRANSLATE_NOOP( "Qgis::UnitType", "meters" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "feet" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "degrees" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "<unknown>" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "degrees" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "degrees" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "degrees" ),
QT_TRANSLATE_NOOP( "Qgis::UnitType", "nautical miles" )
};
QgsWKBTypes::Type Qgis::fromOldWkbType( Qgis::WkbType type )
{
switch ( type )
@ -186,36 +171,6 @@ Qgis::WkbType Qgis::fromNewWkbType( QgsWKBTypes::Type type )
return static_cast< Qgis::WkbType >( type );
}
Qgis::UnitType Qgis::fromLiteral( const QString& literal, Qgis::UnitType defaultType )
{
bool ok = false;
Qgis::UnitType unit = QgsUnitTypes::decodeDistanceUnit( literal, &ok );
return ok ? unit : defaultType;
}
QString Qgis::toLiteral( Qgis::UnitType unit )
{
return QgsUnitTypes::encodeUnit( unit );
}
QString Qgis::tr( Qgis::UnitType unit )
{
return QgsUnitTypes::toString( unit );
}
Qgis::UnitType Qgis::fromTr( const QString& literal, Qgis::UnitType defaultType )
{
bool ok = false;
Qgis::UnitType unit = QgsUnitTypes::stringToDistanceUnit( literal, &ok );
return ok ? unit : defaultType;
}
double Qgis::fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit )
{
return QgsUnitTypes::fromUnitToUnitFactor( fromUnit, toUnit );
}
double qgsPermissiveToDouble( QString string, bool &ok )
{
//remove any thousands separators

38
src/core/qgis.h
View File

@ -150,44 +150,6 @@ class CORE_EXPORT Qgis
QImage::Format_ARGB32_Premultiplied */ ARGB32_Premultiplied = 13
};
/** Map units that qgis supports
* @note that QGIS < 1.4 api had only Meters, Feet, Degrees and UnknownUnit
* @note and QGIS >1.8 returns to that
*/
//TODO QGIS 3.0 - clean up and move to QgsUnitTypes and rename to DistanceUnit
enum UnitType
{
Meters = 0, /*!< meters */
Feet = 1, /*!< imperial feet */
Degrees = 2, /*!< degrees, for planar geographic CRS distance measurements */ //for 1.0 api backwards compatibility
NauticalMiles = 7, /*!< nautical miles */
Kilometers = 8, /*!< kilometers */
Yards = 9, /*!< imperial yards */
Miles = 10, /*!< terrestial miles */
UnknownUnit = 3, /*!< unknown distance unit */
};
//! Provides the canonical name of the type value
//! @deprecated use QgsUnitTypes::encodeUnit() instead
Q_DECL_DEPRECATED static QString toLiteral( Qgis::UnitType unit );
//! Converts from the canonical name to the type value
//! @deprecated use QgsUnitTypes::decodeDistanceUnit() instead
Q_DECL_DEPRECATED static UnitType fromLiteral( const QString& literal, Qgis::UnitType defaultType = UnknownUnit );
//! Provides translated version of the type value
//! @deprecated use QgsUnitTypes::toString() instead
Q_DECL_DEPRECATED static QString tr( Qgis::UnitType unit );
//! Provides type value from translated version
//! @deprecated use QgsUnitTypes::stringToDistanceUnit() instead
Q_DECL_DEPRECATED static UnitType fromTr( const QString& literal, Qgis::UnitType defaultType = UnknownUnit );
//! Returns the conversion factor between the specified units
//! @deprecated use QgsUnitTyoes::fromUnitToUnitFactor() instead
Q_DECL_DEPRECATED static double fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit );
//! User defined event types
enum UserEvent
{

20
src/core/qgscoordinatereferencesystem.cpp
View File

@ -852,7 +852,7 @@ bool QgsCoordinateReferenceSystem::geographicFlag() const
return d->mIsGeographic;
}
Qgis::UnitType QgsCoordinateReferenceSystem::mapUnits() const
QgsUnitTypes::DistanceUnit QgsCoordinateReferenceSystem::mapUnits() const
{
return d->mMapUnits;
}
@ -938,7 +938,7 @@ void QgsCoordinateReferenceSystem::setMapUnits()
d.detach();
if ( !d->mIsValid )
{
d->mMapUnits = Qgis::UnknownUnit;
d->mMapUnits = QgsUnitTypes::UnknownDistanceUnit;
return;
}
@ -967,13 +967,13 @@ void QgsCoordinateReferenceSystem::setMapUnits()
QgsDebugMsg( "Projection has linear units of " + unit );
if ( qgsDoubleNear( toMeter, 1.0 ) ) //Unit name for meters would be "metre"
d->mMapUnits = Qgis::Meters;
d->mMapUnits = QgsUnitTypes::Meters;
else if ( unit == "Foot" )
d->mMapUnits = Qgis::Feet;
d->mMapUnits = QgsUnitTypes::Feet;
else
{
QgsDebugMsg( "Unsupported map units of " + unit );
d->mMapUnits = Qgis::UnknownUnit;
d->mMapUnits = QgsUnitTypes::UnknownDistanceUnit;
}
}
else
@ -981,11 +981,11 @@ void QgsCoordinateReferenceSystem::setMapUnits()
OSRGetAngularUnits( d->mCRS, &unitName );
QString unit( unitName );
if ( unit == "degree" )
d->mMapUnits = Qgis::Degrees;
d->mMapUnits = QgsUnitTypes::Degrees;
else
{
QgsDebugMsg( "Unsupported map units of " + unit );
d->mMapUnits = Qgis::UnknownUnit;
d->mMapUnits = QgsUnitTypes::UnknownDistanceUnit;
}
QgsDebugMsgLevel( "Projection has angular units of " + unit, 3 );
}
@ -1400,15 +1400,15 @@ void QgsCoordinateReferenceSystem::debugPrint()
QgsDebugMsg( "* Proj4 : " + toProj4() );
QgsDebugMsg( "* WKT : " + toWkt() );
QgsDebugMsg( "* Desc. : " + d->mDescription );
if ( mapUnits() == Qgis::Meters )
if ( mapUnits() == QgsUnitTypes::Meters )
{
QgsDebugMsg( "* Units : meters" );
}
else if ( mapUnits() == Qgis::Feet )
else if ( mapUnits() == QgsUnitTypes::Feet )
{
QgsDebugMsg( "* Units : feet" );
}
else if ( mapUnits() == Qgis::Degrees )
else if ( mapUnits() == QgsUnitTypes::Degrees )
{
QgsDebugMsg( "* Units : degrees" );
}

4
src/core/qgscoordinatereferencesystem.h
View File

@ -35,6 +35,7 @@ typedef struct sqlite3 sqlite3;
//qgis includes
#include "qgis.h"
#include "qgsunittypes.h"
#ifdef DEBUG
typedef struct OGRSpatialReferenceHS *OGRSpatialReferenceH;
@ -493,8 +494,7 @@ class CORE_EXPORT QgsCoordinateReferenceSystem
/** Returns the units for the projection used by the CRS.
*/
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
// Mutators -----------------------------------
/** Set user hint for validation

4
src/core/qgscoordinatereferencesystem_p.h
View File

@ -45,7 +45,7 @@ class QgsCoordinateReferenceSystemPrivate : public QSharedData
explicit QgsCoordinateReferenceSystemPrivate()
: mSrsId( 0 )
, mIsGeographic( false )
, mMapUnits( Qgis::UnknownUnit )
, mMapUnits( QgsUnitTypes::UnknownDistanceUnit )
, mSRID( 0 )
, mIsValid( 0 )
, mCRS( OSRNewSpatialReference( nullptr ) )
@ -97,7 +97,7 @@ class QgsCoordinateReferenceSystemPrivate : public QSharedData
bool mIsGeographic;
//! The map units for the CRS
Qgis::UnitType mMapUnits;
QgsUnitTypes::DistanceUnit mMapUnits;
//! If available, the Postgis spatial_ref_sys identifier for this CRS (defaults to 0)
long mSRID;

50
src/core/qgsdistancearea.cpp
View File

@ -487,11 +487,11 @@ double QgsDistanceArea::measureLine( const QList<QgsPoint> &points ) const
double QgsDistanceArea::measureLine( const QgsPoint &p1, const QgsPoint &p2 ) const
{
Qgis::UnitType units;
QgsUnitTypes::DistanceUnit units;
return measureLine( p1, p2, units );
}
double QgsDistanceArea::measureLine( const QgsPoint& p1, const QgsPoint& p2, Qgis::UnitType& units ) const
double QgsDistanceArea::measureLine( const QgsPoint& p1, const QgsPoint& p2, QgsUnitTypes::DistanceUnit& units ) const
{
double result;
units = mCoordTransform.sourceCrs().mapUnits();
@ -503,7 +503,7 @@ double QgsDistanceArea::measureLine( const QgsPoint& p1, const QgsPoint& p2, Qgi
QgsDebugMsgLevel( QString( "Measuring from %1 to %2" ).arg( p1.toString( 4 ), p2.toString( 4 ) ), 3 );
if ( mEllipsoidalMode && ( mEllipsoid != GEO_NONE ) )
{
units = Qgis::Meters;
units = QgsUnitTypes::Meters;
QgsDebugMsgLevel( QString( "Ellipsoidal calculations is enabled, using ellipsoid %1" ).arg( mEllipsoid ), 4 );
QgsDebugMsgLevel( QString( "From proj4 : %1" ).arg( mCoordTransform.sourceCrs().toProj4() ), 4 );
QgsDebugMsgLevel( QString( "To proj4 : %1" ).arg( mCoordTransform.destinationCrs().toProj4() ), 4 );
@ -528,9 +528,9 @@ double QgsDistanceArea::measureLine( const QgsPoint& p1, const QgsPoint& p2, Qgi
return result;
}
Qgis::UnitType QgsDistanceArea::lengthUnits() const
QgsUnitTypes::DistanceUnit QgsDistanceArea::lengthUnits() const
{
return willUseEllipsoid() ? Qgis::Meters : mCoordTransform.sourceCrs().mapUnits();
return willUseEllipsoid() ? QgsUnitTypes::Meters : mCoordTransform.sourceCrs().mapUnits();
}
QgsUnitTypes::AreaUnit QgsDistanceArea::areaUnits() const
@ -967,13 +967,13 @@ double QgsDistanceArea::computePolygonFlatArea( const QList<QgsPoint>& points )
return qAbs( area ); // All areas are positive!
}
QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u, bool isArea, bool keepBaseUnit )
QString QgsDistanceArea::textUnit( double value, int decimals, QgsUnitTypes::DistanceUnit u, bool isArea, bool keepBaseUnit )
{
QString unitLabel;
switch ( u )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
if ( isArea )
{
if ( keepBaseUnit )
@ -1022,7 +1022,7 @@ QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u,
}
}
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
if ( isArea )
{
if ( keepBaseUnit || qAbs( value ) <= 0.5*43560.0 )
@ -1063,7 +1063,7 @@ QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u,
}
}
break;
case Qgis::NauticalMiles:
case QgsUnitTypes::NauticalMiles:
if ( isArea )
{
unitLabel = QObject::tr( " sq. NM" );
@ -1073,7 +1073,7 @@ QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u,
unitLabel = QObject::tr( " NM" );
}
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
if ( isArea )
{
unitLabel = QObject::tr( " sq.deg." );
@ -1086,7 +1086,7 @@ QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u,
unitLabel = QObject::tr( " degrees" );
}
break;
case Qgis::UnknownUnit:
case QgsUnitTypes::UnknownDistanceUnit:
unitLabel.clear();
break;
default:
@ -1097,13 +1097,13 @@ QString QgsDistanceArea::textUnit( double value, int decimals, Qgis::UnitType u,
return QString( "%L1%2" ).arg( value, 0, 'f', decimals ).arg( unitLabel );
}
QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::UnitType unit, bool keepBaseUnit )
QString QgsDistanceArea::formatDistance( double distance, int decimals, QgsUnitTypes::DistanceUnit unit, bool keepBaseUnit )
{
QString unitLabel;
switch ( unit )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
if ( keepBaseUnit || qAbs( distance ) == 0.0 )
{
unitLabel = QObject::tr( " m" );
@ -1129,7 +1129,7 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
}
break;
case Qgis::Kilometers:
case QgsUnitTypes::Kilometers:
if ( keepBaseUnit || qAbs( distance ) >= 1.0 )
{
unitLabel = QObject::tr( " km" );
@ -1141,7 +1141,7 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
}
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
if ( qAbs( distance ) <= 5280.0 || keepBaseUnit )
{
unitLabel = QObject::tr( " ft" );
@ -1153,7 +1153,7 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
}
break;
case Qgis::Yards:
case QgsUnitTypes::Yards:
if ( qAbs( distance ) <= 1760.0 || keepBaseUnit )
{
unitLabel = QObject::tr( " yd" );
@ -1165,7 +1165,7 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
}
break;
case Qgis::Miles:
case QgsUnitTypes::Miles:
if ( qAbs( distance ) >= 1.0 || keepBaseUnit )
{
unitLabel = QObject::tr( " mi" );
@ -1177,11 +1177,11 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
}
break;
case Qgis::NauticalMiles:
case QgsUnitTypes::NauticalMiles:
unitLabel = QObject::tr( " NM" );
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
if ( qAbs( distance ) == 1.0 )
unitLabel = QObject::tr( " degree" );
@ -1189,7 +1189,7 @@ QString QgsDistanceArea::formatDistance( double distance, int decimals, Qgis::Un
unitLabel = QObject::tr( " degrees" );
break;
case Qgis::UnknownUnit:
case QgsUnitTypes::UnknownDistanceUnit:
unitLabel.clear();
break;
default:
@ -1335,17 +1335,17 @@ QString QgsDistanceArea::formatArea( double area, int decimals, QgsUnitTypes::Ar
return QString( "%L1%2" ).arg( area, 0, 'f', decimals ).arg( unitLabel );
}
void QgsDistanceArea::convertMeasurement( double &measure, Qgis::UnitType &measureUnits, Qgis::UnitType displayUnits, bool isArea ) const
void QgsDistanceArea::convertMeasurement( double &measure, QgsUnitTypes::DistanceUnit &measureUnits, QgsUnitTypes::DistanceUnit displayUnits, bool isArea ) const
{
// Helper for converting between meters and feet and degrees and NauticalMiles...
// The parameters measure and measureUnits are in/out
if (( measureUnits == Qgis::Degrees || measureUnits == Qgis::Feet || measureUnits == Qgis::NauticalMiles ) &&
if (( measureUnits == QgsUnitTypes::Degrees || measureUnits == QgsUnitTypes::Feet || measureUnits == QgsUnitTypes::NauticalMiles ) &&
mEllipsoid != GEO_NONE &&
mEllipsoidalMode )
{
// Measuring on an ellipsoid returned meters. Force!
measureUnits = Qgis::Meters;
measureUnits = QgsUnitTypes::Meters;
QgsDebugMsg( "We're measuring on an ellipsoid or using projections, the system is returning meters" );
}
else if ( mEllipsoidalMode && mEllipsoid == GEO_NONE )
@ -1366,10 +1366,10 @@ void QgsDistanceArea::convertMeasurement( double &measure, Qgis::UnitType &measu
measureUnits = displayUnits;
}
double QgsDistanceArea::convertLengthMeasurement( double length, Qgis::UnitType toUnits ) const
double QgsDistanceArea::convertLengthMeasurement( double length, QgsUnitTypes::DistanceUnit toUnits ) const
{
// get the conversion factor between the specified units
Qgis::UnitType measureUnits = lengthUnits();
QgsUnitTypes::DistanceUnit measureUnits = lengthUnits();
double factorUnits = QgsUnitTypes::fromUnitToUnitFactor( measureUnits, toUnits );
double result = length * factorUnits;

12
src/core/qgsdistancearea.h
View File

@ -193,13 +193,13 @@ class CORE_EXPORT QgsDistanceArea
* @returns calculated distance between points. Distance units are stored in units parameter.
* @note added in QGIS 2.12
*/
double measureLine( const QgsPoint& p1, const QgsPoint& p2, Qgis::UnitType& units ) const;
double measureLine( const QgsPoint& p1, const QgsPoint& p2, QgsUnitTypes::DistanceUnit& units ) const;
/** Returns the units of distance for length calculations made by this object.
* @note added in QGIS 2.14
* @see areaUnits()
*/
Qgis::UnitType lengthUnits() const;
QgsUnitTypes::DistanceUnit lengthUnits() const;
/** Returns the units of area for areal calculations made by this object.
* @note added in QGIS 2.14
@ -223,7 +223,7 @@ class CORE_EXPORT QgsDistanceArea
* @return formatted measurement string
* @deprecated use formatDistance() or formatArea() instead
*/
Q_DECL_DEPRECATED static QString textUnit( double value, int decimals, Qgis::UnitType u, bool isArea, bool keepBaseUnit = false );
Q_DECL_DEPRECATED static QString textUnit( double value, int decimals, QgsUnitTypes::DistanceUnit u, bool isArea, bool keepBaseUnit = false );
/** Returns an distance formatted as a friendly string.
* @param distance distance to format
@ -235,7 +235,7 @@ class CORE_EXPORT QgsDistanceArea
* @note added in QGIS 2.16
* @see formatArea()
*/
static QString formatDistance( double distance, int decimals, Qgis::UnitType unit, bool keepBaseUnit = false );
static QString formatDistance( double distance, int decimals, QgsUnitTypes::DistanceUnit unit, bool keepBaseUnit = false );
/** Returns an area formatted as a friendly string.
* @param area area to format
@ -251,7 +251,7 @@ class CORE_EXPORT QgsDistanceArea
//! Helper for conversion between physical units
// TODO QGIS 3.0 - remove this method, as its behaviour is non-intuitive.
void convertMeasurement( double &measure, Qgis::UnitType &measureUnits, Qgis::UnitType displayUnits, bool isArea ) const;
void convertMeasurement( double &measure, QgsUnitTypes::DistanceUnit &measureUnits, QgsUnitTypes::DistanceUnit displayUnits, bool isArea ) const;
/** Takes a length measurement calculated by this QgsDistanceArea object and converts it to a
* different distance unit.
@ -262,7 +262,7 @@ class CORE_EXPORT QgsDistanceArea
* @see convertAreaMeasurement()
* @note added in QGIS 2.14
*/
double convertLengthMeasurement( double length, Qgis::UnitType toUnits ) const;
double convertLengthMeasurement( double length, QgsUnitTypes::DistanceUnit toUnits ) const;
/** Takes an area measurement calculated by this QgsDistanceArea object and converts it to a
* different areal unit.

4
src/core/qgsexpression.cpp
View File

@ -3797,12 +3797,12 @@ QgsDistanceArea* QgsExpression::geomCalculator()
return d->mCalc.data();
}
Qgis::UnitType QgsExpression::distanceUnits() const
QgsUnitTypes::DistanceUnit QgsExpression::distanceUnits() const
{
return d->mDistanceUnit;
}
void QgsExpression::setDistanceUnits( Qgis::UnitType unit )
void QgsExpression::setDistanceUnits( QgsUnitTypes::DistanceUnit unit )
{
d->mDistanceUnit = unit;
}

4
src/core/qgsexpression.h
View File

@ -289,7 +289,7 @@ class CORE_EXPORT QgsExpression
* @see setDistanceUnits()
* @see areaUnits()
*/
Qgis::UnitType distanceUnits() const;
QgsUnitTypes::DistanceUnit distanceUnits() const;
/** Sets the desired distance units for calculations involving geomCalculator(), eg "$length" and "$perimeter".
* @note distances are only converted when a geomCalculator() has been set
@ -297,7 +297,7 @@ class CORE_EXPORT QgsExpression
* @see distanceUnits()
* @see setAreaUnits()
*/
void setDistanceUnits( Qgis::UnitType unit );
void setDistanceUnits( QgsUnitTypes::DistanceUnit unit );
/** Returns the desired areal units for calculations involving geomCalculator(), eg "$area".
* @note areas are only converted when a geomCalculator() has been set

4
src/core/qgsexpressionprivate.h
View File

@ -39,7 +39,7 @@ class QgsExpressionPrivate
, mRowNumber( 0 )
, mScale( 0 )
, mCalc( nullptr )
, mDistanceUnit( Qgis::UnknownUnit )
, mDistanceUnit( QgsUnitTypes::UnknownDistanceUnit )
, mAreaUnit( QgsUnitTypes::UnknownAreaUnit )
{}
@ -73,7 +73,7 @@ class QgsExpressionPrivate
QString mExp;
QSharedPointer<QgsDistanceArea> mCalc;
Qgis::UnitType mDistanceUnit;
QgsUnitTypes::DistanceUnit mDistanceUnit;
QgsUnitTypes::AreaUnit mAreaUnit;
};
///@endcond

8
src/core/qgsmapsettings.cpp
View File

@ -54,7 +54,7 @@ QgsMapSettings::QgsMapSettings()
updateDerived();
// set default map units - we use WGS 84 thus use degrees
setMapUnits( Qgis::Degrees );
setMapUnits( QgsUnitTypes::Degrees );
}
void QgsMapSettings::setMagnificationFactor( double factor )
@ -298,7 +298,7 @@ QgsCoordinateReferenceSystem QgsMapSettings::destinationCrs() const
}
void QgsMapSettings::setMapUnits( Qgis::UnitType u )
void QgsMapSettings::setMapUnits( QgsUnitTypes::DistanceUnit u )
{
mScaleCalculator.setMapUnits( u );
@ -329,7 +329,7 @@ bool QgsMapSettings::testFlag( QgsMapSettings::Flag flag ) const
return mFlags.testFlag( flag );
}
Qgis::UnitType QgsMapSettings::mapUnits() const
QgsUnitTypes::DistanceUnit QgsMapSettings::mapUnits() const
{
return mScaleCalculator.mapUnits();
}
@ -609,7 +609,7 @@ void QgsMapSettings::readXml( QDomNode& theNode )
{
// set units
QDomNode mapUnitsNode = theNode.namedItem( "units" );
Qgis::UnitType units = QgsXmlUtils::readMapUnits( mapUnitsNode.toElement() );
QgsUnitTypes::DistanceUnit units = QgsXmlUtils::readMapUnits( mapUnitsNode.toElement() );
setMapUnits( units );
// set projections flag

4
src/core/qgsmapsettings.h
View File

@ -139,9 +139,9 @@ class CORE_EXPORT QgsMapSettings
QgsCoordinateReferenceSystem destinationCrs() const;
//! Get units of map's geographical coordinates - used for scale calculation
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
//! Set units of map's geographical coordinates - used for scale calculation
void setMapUnits( Qgis::UnitType u );
void setMapUnits( QgsUnitTypes::DistanceUnit u );
//! Set the background color of the map
void setBackgroundColor( const QColor& color ) { mBackgroundColor = color; }

6
src/core/qgsproject.cpp
View File

@ -2076,7 +2076,7 @@ bool QgsProject::topologicalEditing() const
return ( QgsProject::instance()->readNumEntry( "Digitizing", "/TopologicalEditing", 0 ) > 0 );
}
Qgis::UnitType QgsProject::distanceUnits() const
QgsUnitTypes::DistanceUnit QgsProject::distanceUnits() const
{
QString distanceUnitString = QgsProject::instance()->readEntry( "Measurement", "/DistanceUnits", QString() );
if ( !distanceUnitString.isEmpty() )
@ -2085,8 +2085,8 @@ Qgis::UnitType QgsProject::distanceUnits() const
//fallback to QGIS default measurement unit
QSettings s;
bool ok = false;
Qgis::UnitType type = QgsUnitTypes::decodeDistanceUnit( s.value( "/qgis/measure/displayunits" ).toString(), &ok );
return ok ? type : Qgis::Meters;
QgsUnitTypes::DistanceUnit type = QgsUnitTypes::decodeDistanceUnit( s.value( "/qgis/measure/displayunits" ).toString(), &ok );
return ok ? type : QgsUnitTypes::Meters;
}
QgsUnitTypes::AreaUnit QgsProject::areaUnits() const

2
src/core/qgsproject.h
View File

@ -301,7 +301,7 @@ class CORE_EXPORT QgsProject : public QObject
* @note added in QGIS 2.14
* @see areaUnits()
*/
Qgis::UnitType distanceUnits() const;
QgsUnitTypes::DistanceUnit distanceUnits() const;
/** Convenience function to query default area measurement units for project.
* @note added in QGIS 2.14

14
src/core/qgsscalecalculator.cpp
View File

@ -21,7 +21,7 @@
#include "qgsrectangle.h"
#include "qgsscalecalculator.h"
QgsScaleCalculator::QgsScaleCalculator( double dpi, Qgis::UnitType mapUnits )
QgsScaleCalculator::QgsScaleCalculator( double dpi, QgsUnitTypes::DistanceUnit mapUnits )
: mDpi( dpi )
, mMapUnits( mapUnits )
{}
@ -35,13 +35,13 @@ double QgsScaleCalculator::dpi()
return mDpi;
}
void QgsScaleCalculator::setMapUnits( Qgis::UnitType mapUnits )
void QgsScaleCalculator::setMapUnits( QgsUnitTypes::DistanceUnit mapUnits )
{
QgsDebugMsgLevel( QString( "Map units set to %1" ).arg( QString::number( mapUnits ) ), 3 );
mMapUnits = mapUnits;
}
Qgis::UnitType QgsScaleCalculator::mapUnits() const
QgsUnitTypes::DistanceUnit QgsScaleCalculator::mapUnits() const
{
QgsDebugMsgLevel( QString( "Map units returned as %1" ).arg( QString::number( mMapUnits ) ), 4 );
return mMapUnits;
@ -55,23 +55,23 @@ double QgsScaleCalculator::calculate( const QgsRectangle &mapExtent, int canvasW
// users display, and the canvas width
switch ( mMapUnits )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
// convert meters to inches
conversionFactor = 39.3700787;
delta = mapExtent.xMaximum() - mapExtent.xMinimum();
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
conversionFactor = 12.0;
delta = mapExtent.xMaximum() - mapExtent.xMinimum();
break;
case Qgis::NauticalMiles:
case QgsUnitTypes::NauticalMiles:
// convert nautical miles to inches
conversionFactor = 72913.4;
delta = mapExtent.xMaximum() - mapExtent.xMinimum();
break;
default:
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
// degrees require conversion to meters first
conversionFactor = 39.3700787;
delta = calculateGeographicDistance( mapExtent );

12
src/core/qgsscalecalculator.h
View File

@ -20,6 +20,7 @@
#define QGSSCALECALCULATOR_H
#include <qgis.h>
#include "qgsunittypes.h"
class QString;
class QgsRectangle;
@ -35,11 +36,10 @@ class CORE_EXPORT QgsScaleCalculator
/**
* Constructor
* @param dpi Monitor resolution in dots per inch
* @param mapUnits Units of the data on the map. Must match a value from the
* Qgis::UnitType enum (Meters, Feet, Degrees)
* @param mapUnits Units of the data on the map
*/
QgsScaleCalculator( double dpi = 0,
Qgis::UnitType mapUnits = Qgis::Meters );
QgsUnitTypes::DistanceUnit mapUnits = QgsUnitTypes::Meters );
/**
* Set the dpi to be used in scale calculations
@ -57,10 +57,10 @@ class CORE_EXPORT QgsScaleCalculator
* Set the map units
* @param mapUnits Units of the data on the map. Must match a value from the
*/
void setMapUnits( Qgis::UnitType mapUnits );
void setMapUnits( QgsUnitTypes::DistanceUnit mapUnits );
/** Returns current map units */
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
/**
* Calculate the scale denominator
@ -84,7 +84,7 @@ class CORE_EXPORT QgsScaleCalculator
double mDpi;
//! map unit member
Qgis::UnitType mMapUnits;
QgsUnitTypes::DistanceUnit mMapUnits;
};
#endif // #ifndef QGSSCALECALCULATOR_H

290
src/core/qgsunittypes.cpp
View File

@ -23,22 +23,22 @@
* See details in QEP #17
****************************************************************************/
QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( Qgis::UnitType unit )
QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( DistanceUnit unit )
{
switch ( unit )
{
case Qgis::Meters:
case Qgis::Feet:
case Qgis::NauticalMiles:
case Qgis::Yards:
case Qgis::Miles:
case Qgis::Kilometers:
case Meters:
case Feet:
case NauticalMiles:
case Yards:
case Miles:
case Kilometers:
return Standard;
case Qgis::Degrees:
case Degrees:
return Geographic;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
return UnknownType;
}
return UnknownType;
@ -68,32 +68,32 @@ QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( QgsUnitTypes::AreaUnit un
return UnknownType;
}
QString QgsUnitTypes::encodeUnit( Qgis::UnitType unit )
QString QgsUnitTypes::encodeUnit( DistanceUnit unit )
{
switch ( unit )
{
case Qgis::Meters:
case Meters:
return "meters";
case Qgis::Kilometers:
case Kilometers:
return "km";
case Qgis::Feet:
case Feet:
return "feet";
case Qgis::Yards:
case Yards:
return "yd";
case Qgis::Miles:
case Miles:
return "mi";
case Qgis::Degrees:
case Degrees:
return "degrees";
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
return "<unknown>";
case Qgis::NauticalMiles:
case NauticalMiles:
return "nautical miles";
}
return QString();
@ -105,63 +105,63 @@ QString QgsUnitTypes::encodeUnit( Qgis::UnitType unit )
* See details in QEP #17
****************************************************************************/
Qgis::UnitType QgsUnitTypes::decodeDistanceUnit( const QString& string, bool* ok )
QgsUnitTypes::DistanceUnit QgsUnitTypes::decodeDistanceUnit( const QString& string, bool* ok )
{
QString normalized = string.trimmed().toLower();
if ( ok )
*ok = true;
if ( normalized == encodeUnit( Qgis::Meters ) )
return Qgis::Meters;
if ( normalized == encodeUnit( Qgis::Feet ) )
return Qgis::Feet;
if ( normalized == encodeUnit( Qgis::Degrees ) )
return Qgis::Degrees;
if ( normalized == encodeUnit( Qgis::NauticalMiles ) )
return Qgis::NauticalMiles;
if ( normalized == encodeUnit( Qgis::Kilometers ) )
return Qgis::Kilometers;
if ( normalized == encodeUnit( Qgis::Yards ) )
return Qgis::Yards;
if ( normalized == encodeUnit( Qgis::Miles ) )
return Qgis::Miles;
if ( normalized == encodeUnit( Qgis::UnknownUnit ) )
return Qgis::UnknownUnit;
if ( normalized == encodeUnit( Meters ) )
return Meters;
if ( normalized == encodeUnit( Feet ) )
return Feet;
if ( normalized == encodeUnit( Degrees ) )
return Degrees;
if ( normalized == encodeUnit( NauticalMiles ) )
return NauticalMiles;
if ( normalized == encodeUnit( Kilometers ) )
return Kilometers;
if ( normalized == encodeUnit( Yards ) )
return Yards;
if ( normalized == encodeUnit( Miles ) )
return Miles;
if ( normalized == encodeUnit( UnknownDistanceUnit ) )
return UnknownDistanceUnit;
if ( ok )
*ok = false;
return Qgis::UnknownUnit;
return UnknownDistanceUnit;
}
QString QgsUnitTypes::toString( Qgis::UnitType unit )
QString QgsUnitTypes::toString( DistanceUnit unit )
{
switch ( unit )
{
case Qgis::Meters:
return QCoreApplication::translate( "Qgis::UnitType", "meters" );
case Meters:
return QCoreApplication::translate( "UnitType", "meters" );
case Qgis::Kilometers:
return QCoreApplication::translate( "Qgis::UnitType", "kilometers" );
case Kilometers:
return QCoreApplication::translate( "UnitType", "kilometers" );
case Qgis::Feet:
return QCoreApplication::translate( "Qgis::UnitType", "feet" );
case Feet:
return QCoreApplication::translate( "UnitType", "feet" );
case Qgis::Yards:
return QCoreApplication::translate( "Qgis::UnitType", "yards" );
case Yards:
return QCoreApplication::translate( "UnitType", "yards" );
case Qgis::Miles:
return QCoreApplication::translate( "Qgis::UnitType", "miles" );
case Miles:
return QCoreApplication::translate( "UnitType", "miles" );
case Qgis::Degrees:
return QCoreApplication::translate( "Qgis::UnitType", "degrees" );
case Degrees:
return QCoreApplication::translate( "UnitType", "degrees" );
case Qgis::UnknownUnit:
return QCoreApplication::translate( "Qgis::UnitType", "<unknown>" );
case UnknownDistanceUnit:
return QCoreApplication::translate( "UnitType", "<unknown>" );
case Qgis::NauticalMiles:
return QCoreApplication::translate( "Qgis::UnitType", "nautical miles" );
case NauticalMiles:
return QCoreApplication::translate( "UnitType", "nautical miles" );
}
return QString();
}
@ -172,34 +172,34 @@ QString QgsUnitTypes::toString( Qgis::UnitType unit )
* See details in QEP #17
****************************************************************************/
Qgis::UnitType QgsUnitTypes::stringToDistanceUnit( const QString& string, bool* ok )
QgsUnitTypes::DistanceUnit QgsUnitTypes::stringToDistanceUnit( const QString& string, bool* ok )
{
QString normalized = string.trimmed().toLower();
if ( ok )
*ok = true;
if ( normalized == toString( Qgis::Meters ) )
return Qgis::Meters;
if ( normalized == toString( Qgis::Kilometers ) )
return Qgis::Kilometers;
if ( normalized == toString( Qgis::Feet ) )
return Qgis::Feet;
if ( normalized == toString( Qgis::Yards ) )
return Qgis::Yards;
if ( normalized == toString( Qgis::Miles ) )
return Qgis::Miles;
if ( normalized == toString( Qgis::Degrees ) )
return Qgis::Degrees;
if ( normalized == toString( Qgis::NauticalMiles ) )
return Qgis::NauticalMiles;
if ( normalized == toString( Qgis::UnknownUnit ) )
return Qgis::UnknownUnit;
if ( normalized == toString( Meters ) )
return Meters;
if ( normalized == toString( Kilometers ) )
return Kilometers;
if ( normalized == toString( Feet ) )
return Feet;
if ( normalized == toString( Yards ) )
return Yards;
if ( normalized == toString( Miles ) )
return Miles;
if ( normalized == toString( Degrees ) )
return Degrees;
if ( normalized == toString( NauticalMiles ) )
return NauticalMiles;
if ( normalized == toString( UnknownDistanceUnit ) )
return UnknownDistanceUnit;
if ( ok )
*ok = false;
return Qgis::UnknownUnit;
return UnknownDistanceUnit;
}
/***************************************************************************
@ -208,7 +208,7 @@ Qgis::UnitType QgsUnitTypes::stringToDistanceUnit( const QString& string, bool*
* See details in QEP #17
****************************************************************************/
double QgsUnitTypes::fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit )
double QgsUnitTypes::fromUnitToUnitFactor( DistanceUnit fromUnit, DistanceUnit toUnit )
{
#define DEGREE_TO_METER 111319.49079327358
#define FEET_TO_METER 0.3048
@ -221,175 +221,175 @@ double QgsUnitTypes::fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitTy
// Calculate the conversion factor between the specified units
switch ( fromUnit )
{
case Qgis::Meters:
case Meters:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return 1.0;
case Qgis::Kilometers:
case Kilometers:
return 1.0 / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return 1.0 / FEET_TO_METER;
case Qgis::Yards:
case Yards:
return 1.0 / YARDS_TO_METER;
case Qgis::Miles:
case Miles:
return 1.0 / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return 1.0 / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return 1.0 / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::Kilometers:
case Kilometers:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return KILOMETERS_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return 1.0;
case Qgis::Feet:
case Feet:
return KILOMETERS_TO_METER / FEET_TO_METER;
case Qgis::Yards:
case Yards:
return KILOMETERS_TO_METER / YARDS_TO_METER;
case Qgis::Miles:
case Miles:
return KILOMETERS_TO_METER / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return KILOMETERS_TO_METER / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return KILOMETERS_TO_METER / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::Feet:
case Feet:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return FEET_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return FEET_TO_METER / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return 1.0;
case Qgis::Yards:
case Yards:
return 1.0 / YARDS_TO_FEET;
case Qgis::Miles:
case Miles:
return FEET_TO_METER / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return FEET_TO_METER / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return FEET_TO_METER / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::Yards:
case Yards:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return YARDS_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return YARDS_TO_METER / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return YARDS_TO_FEET;
case Qgis::Yards:
case Yards:
return 1.0;
case Qgis::Miles:
case Miles:
return YARDS_TO_METER / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return YARDS_TO_METER / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return YARDS_TO_METER / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::Miles:
case Miles:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return MILES_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return MILES_TO_METER / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return MILES_TO_METER / FEET_TO_METER;
case Qgis::Yards:
case Yards:
return MILES_TO_METER / YARDS_TO_METER;
case Qgis::Miles:
case Miles:
return 1.0;
case Qgis::Degrees:
case Degrees:
return MILES_TO_METER / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return MILES_TO_METER / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::Degrees:
case Degrees:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return DEGREE_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return DEGREE_TO_METER / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return DEGREE_TO_METER / FEET_TO_METER;
case Qgis::Yards:
case Yards:
return DEGREE_TO_METER / YARDS_TO_METER;
case Qgis::Miles:
case Miles:
return DEGREE_TO_METER / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return 1.0;
case Qgis::NauticalMiles:
case NauticalMiles:
return DEGREE_TO_METER / NMILE_TO_METER;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::NauticalMiles:
case NauticalMiles:
{
switch ( toUnit )
{
case Qgis::Meters:
case Meters:
return NMILE_TO_METER;
case Qgis::Kilometers:
case Kilometers:
return NMILE_TO_METER / KILOMETERS_TO_METER;
case Qgis::Feet:
case Feet:
return NMILE_TO_METER / FEET_TO_METER;
case Qgis::Yards:
case Yards:
return NMILE_TO_METER / YARDS_TO_METER;
case Qgis::Miles:
case Miles:
return NMILE_TO_METER / MILES_TO_METER;
case Qgis::Degrees:
case Degrees:
return NMILE_TO_METER / DEGREE_TO_METER;
case Qgis::NauticalMiles:
case NauticalMiles:
return 1.0;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
break;
}
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
break;
}
return 1.0;
@ -796,32 +796,32 @@ double QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::AreaUnit fromUnit, QgsU
return 1.0;
}
QgsUnitTypes::AreaUnit QgsUnitTypes::distanceToAreaUnit( Qgis::UnitType distanceUnit )
QgsUnitTypes::AreaUnit QgsUnitTypes::distanceToAreaUnit( DistanceUnit distanceUnit )
{
switch ( distanceUnit )
{
case Qgis::Meters:
case Meters:
return SquareMeters;
case Qgis::Kilometers:
case Kilometers:
return SquareKilometers;
case Qgis::Feet:
case Feet:
return SquareFeet;
case Qgis::Yards:
case Yards:
return SquareYards;
case Qgis::Miles:
case Miles:
return SquareMiles;
case Qgis::Degrees:
case Degrees:
return SquareDegrees;
case Qgis::UnknownUnit:
case UnknownDistanceUnit:
return UnknownAreaUnit;
case Qgis::NauticalMiles:
case NauticalMiles:
return SquareNauticalMiles;
}

27
src/core/qgsunittypes.h
View File

@ -36,6 +36,19 @@ class CORE_EXPORT QgsUnitTypes
{
public:
//! Units of distance
enum DistanceUnit
{
Meters = 0, /*!< meters */
Kilometers, /*!< kilometers */
Feet, /*!< imperial feet */
NauticalMiles, /*!< nautical miles */
Yards, /*!< imperial yards */
Miles, /*!< terrestial miles */
Degrees, /*!< degrees, for planar geographic CRS distance measurements */
UnknownDistanceUnit, /*!< unknown distance unit */
};
/** Types of distance units
*/
enum DistanceUnitType
@ -76,14 +89,14 @@ class CORE_EXPORT QgsUnitTypes
/** Returns the type for a distance unit.
*/
static DistanceUnitType unitType( Qgis::UnitType unit );
static DistanceUnitType unitType( DistanceUnit unit );
/** Encodes a distance unit to a string.
* @param unit unit to encode
* @returns encoded string
* @see decodeDistanceUnit()
*/
static QString encodeUnit( Qgis::UnitType unit );
static QString encodeUnit( QgsUnitTypes::DistanceUnit unit );
/** Decodes a distance unit from a string.
* @param string string to decode
@ -91,27 +104,27 @@ class CORE_EXPORT QgsUnitTypes
* @returns decoded units
* @see encodeUnit()
*/
static Qgis::UnitType decodeDistanceUnit( const QString& string, bool *ok = 0 );
static QgsUnitTypes::DistanceUnit decodeDistanceUnit( const QString& string, bool *ok = 0 );
/** Returns a translated string representing a distance unit.
* @param unit unit to convert to string
* @see stringToDistanceUnit()
*/
static QString toString( Qgis::UnitType unit );
static QString toString( QgsUnitTypes::DistanceUnit unit );
/** Converts a translated string to a distance unit.
* @param string string representing a distance unit
* @param ok optional boolean, will be set to true if string was converted successfully
* @see toString()
*/
static Qgis::UnitType stringToDistanceUnit( const QString& string, bool *ok = 0 );
static QgsUnitTypes::DistanceUnit stringToDistanceUnit( const QString& string, bool *ok = 0 );
/** Returns the conversion factor between the specified distance units.
* @param fromUnit distance unit to convert from
* @param toUnit distance unit to convert to
* @returns multiplication factor to convert between units
*/
static double fromUnitToUnitFactor( Qgis::UnitType fromUnit, Qgis::UnitType toUnit );
static double fromUnitToUnitFactor( QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit );
// AREAL UNITS
@ -158,7 +171,7 @@ class CORE_EXPORT QgsUnitTypes
* @param distanceUnit distance unit to convert
* @return matching areal unit
*/
static AreaUnit distanceToAreaUnit( Qgis::UnitType distanceUnit );
static AreaUnit distanceToAreaUnit( QgsUnitTypes::DistanceUnit distanceUnit );
// ANGULAR UNITS

16
src/core/qgsvectorfilewriter.cpp
View File

@ -1776,7 +1776,7 @@ QString QgsVectorFileWriter::errorMessage()
return mErrorMessage;
}
bool QgsVectorFileWriter::addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer, Qgis::UnitType outputUnit )
bool QgsVectorFileWriter::addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer, QgsUnitTypes::DistanceUnit outputUnit )
{
// create the feature
OGRFeatureH poFeature = createFeature( feature );
@ -2318,7 +2318,7 @@ QgsVectorFileWriter::WriterError QgsVectorFileWriter::writeAsVectorFormat( QgsVe
int n = 0, errors = 0;
//unit type
Qgis::UnitType mapUnits = layer->crs().mapUnits();
QgsUnitTypes::DistanceUnit mapUnits = layer->crs().mapUnits();
if ( ct.isValid() )
{
mapUnits = ct.destinationCrs().mapUnits();
@ -2600,7 +2600,7 @@ void QgsVectorFileWriter::createSymbolLayerTable( QgsVectorLayer* vl, const Qgs
}
//unit type
Qgis::UnitType mapUnits = vl->crs().mapUnits();
QgsUnitTypes::DistanceUnit mapUnits = vl->crs().mapUnits();
if ( ct.isValid() )
{
mapUnits = ct.destinationCrs().mapUnits();
@ -2651,7 +2651,7 @@ QgsVectorFileWriter::WriterError QgsVectorFileWriter::exportFeaturesSymbolLevels
QHash< QgsSymbolV2*, QList<QgsFeature> > features;
//unit type
Qgis::UnitType mapUnits = layer->crs().mapUnits();
QgsUnitTypes::DistanceUnit mapUnits = layer->crs().mapUnits();
if ( ct.isValid() )
{
mapUnits = ct.destinationCrs().mapUnits();
@ -2775,7 +2775,7 @@ QgsVectorFileWriter::WriterError QgsVectorFileWriter::exportFeaturesSymbolLevels
return ( nErrors > 0 ) ? QgsVectorFileWriter::ErrFeatureWriteFailed : QgsVectorFileWriter::NoError;
}
double QgsVectorFileWriter::mmScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits )
double QgsVectorFileWriter::mmScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits )
{
if ( symbolUnits == QgsSymbolV2::MM )
{
@ -2784,7 +2784,7 @@ double QgsVectorFileWriter::mmScaleFactor( double scaleDenominator, QgsSymbolV2:
else
{
//conversion factor map units -> mm
if ( mapUnits == Qgis::Meters )
if ( mapUnits == QgsUnitTypes::Meters )
{
return 1000 / scaleDenominator;
}
@ -2793,7 +2793,7 @@ double QgsVectorFileWriter::mmScaleFactor( double scaleDenominator, QgsSymbolV2:
return 1.0; //todo: map units
}
double QgsVectorFileWriter::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits )
double QgsVectorFileWriter::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits )
{
if ( symbolUnits == QgsSymbolV2::MapUnit )
{
@ -2801,7 +2801,7 @@ double QgsVectorFileWriter::mapUnitScaleFactor( double scaleDenominator, QgsSymb
}
else
{
if ( symbolUnits == QgsSymbolV2::MM && mapUnits == Qgis::Meters )
if ( symbolUnits == QgsSymbolV2::MM && mapUnits == QgsUnitTypes::Meters )
{
return scaleDenominator / 1000;
}

8
src/core/qgsvectorfilewriter.h
View File

@ -338,7 +338,7 @@ class CORE_EXPORT QgsVectorFileWriter
QString errorMessage();
/** Add feature to the currently opened data source */
bool addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer = nullptr, Qgis::UnitType outputUnit = Qgis::Meters );
bool addFeature( QgsFeature& feature, QgsFeatureRendererV2* renderer = nullptr, QgsUnitTypes::DistanceUnit outputUnit = QgsUnitTypes::Meters );
//! @note not available in python bindings
QMap<int, int> attrIdxToOgrIdx() { return mAttrIdxToOgrIdx; }
@ -443,14 +443,14 @@ class CORE_EXPORT QgsVectorFileWriter
QgsRenderContext mRenderContext;
static QMap<QString, MetaData> initMetaData();
void createSymbolLayerTable( QgsVectorLayer* vl, const QgsCoordinateTransform& ct, OGRDataSourceH ds );
void createSymbolLayerTable( QgsVectorLayer* vl, const QgsCoordinateTransform& ct, OGRDataSourceH ds );
OGRFeatureH createFeature( QgsFeature& feature );
bool writeFeature( OGRLayerH layer, OGRFeatureH feature );
/** Writes features considering symbol level order*/
WriterError exportFeaturesSymbolLevels( QgsVectorLayer* layer, QgsFeatureIterator& fit, const QgsCoordinateTransform& ct, QString* errorMessage = nullptr );
double mmScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits );
double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, Qgis::UnitType mapUnits );
double mmScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits );
double mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::OutputUnit symbolUnits, QgsUnitTypes::DistanceUnit mapUnits );
void startRender( QgsVectorLayer* vl );
void stopRender( QgsVectorLayer* vl );

4
src/core/qgsvectorlayereditutils.cpp
View File

@ -688,11 +688,11 @@ int QgsVectorLayerEditUtils::addTopologicalPoints( const QgsPoint& p )
//work with a tolerance because coordinate projection may introduce some rounding
double threshold = 0.0000001;
if ( L->crs().mapUnits() == Qgis::Meters )
if ( L->crs().mapUnits() == QgsUnitTypes::Meters )
{
threshold = 0.001;
}
else if ( L->crs().mapUnits() == Qgis::Feet )
else if ( L->crs().mapUnits() == QgsUnitTypes::Feet )
{
threshold = 0.0001;
}

26
src/core/qgsxmlutils.cpp
View File

@ -20,32 +20,32 @@
#include "qgsrectangle.h"
Qgis::UnitType QgsXmlUtils::readMapUnits( const QDomElement& element )
QgsUnitTypes::DistanceUnit QgsXmlUtils::readMapUnits( const QDomElement& element )
{
if ( "meters" == element.text() )
{
return Qgis::Meters;
return QgsUnitTypes::Meters;
}
else if ( "feet" == element.text() )
{
return Qgis::Feet;
return QgsUnitTypes::Feet;
}
else if ( "nautical miles" == element.text() )
{
return Qgis::NauticalMiles;
return QgsUnitTypes::NauticalMiles;
}
else if ( "degrees" == element.text() )
{
return Qgis::Degrees;
return QgsUnitTypes::Degrees;
}
else if ( "unknown" == element.text() )
{
return Qgis::UnknownUnit;
return QgsUnitTypes::UnknownDistanceUnit;
}
else
{
QgsDebugMsg( "Unknown map unit type " + element.text() );
return Qgis::Degrees;
return QgsUnitTypes::Degrees;
}
}
@ -79,24 +79,24 @@ QgsRectangle QgsXmlUtils::readRectangle( const QDomElement& element )
QDomElement QgsXmlUtils::writeMapUnits( Qgis::UnitType units, QDomDocument& doc )
QDomElement QgsXmlUtils::writeMapUnits( QgsUnitTypes::DistanceUnit units, QDomDocument& doc )
{
QString unitsString;
switch ( units )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
unitsString = "meters";
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
unitsString = "feet";
break;
case Qgis::NauticalMiles:
case QgsUnitTypes::NauticalMiles:
unitsString = "nautical miles";
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
unitsString = "degrees";
break;
case Qgis::UnknownUnit:
case QgsUnitTypes::UnknownDistanceUnit:
default:
unitsString = "unknown";
break;

5
src/core/qgsxmlutils.h
View File

@ -21,6 +21,7 @@ class QDomElement;
class QgsRectangle;
#include "qgis.h"
#include "qgsunittypes.h"
/** \ingroup core
* Assorted helper methods for reading and writing chunks of XML
@ -31,12 +32,12 @@ class CORE_EXPORT QgsXmlUtils
/* reading */
static Qgis::UnitType readMapUnits( const QDomElement& element );
static QgsUnitTypes::DistanceUnit readMapUnits( const QDomElement& element );
static QgsRectangle readRectangle( const QDomElement& element );
/* writing */
static QDomElement writeMapUnits( Qgis::UnitType units, QDomDocument& doc );
static QDomElement writeMapUnits( QgsUnitTypes::DistanceUnit units, QDomDocument& doc );
static QDomElement writeRectangle( const QgsRectangle& rect, QDomDocument& doc );
};

4
src/gui/qgsmapcanvas.cpp
View File

@ -1681,7 +1681,7 @@ double QgsMapCanvas::mapUnitsPerPixel() const
} // mapUnitsPerPixel
void QgsMapCanvas::setMapUnits( Qgis::UnitType u )
void QgsMapCanvas::setMapUnits( QgsUnitTypes::DistanceUnit u )
{
if ( mSettings.mapUnits() == u )
return;
@ -1697,7 +1697,7 @@ void QgsMapCanvas::setMapUnits( Qgis::UnitType u )
}
Qgis::UnitType QgsMapCanvas::mapUnits() const
QgsUnitTypes::DistanceUnit QgsMapCanvas::mapUnits() const
{
return mapSettings().mapUnits();
}

4
src/gui/qgsmapcanvas.h
View File

@ -290,10 +290,10 @@ class GUI_EXPORT QgsMapCanvas : public QGraphicsView
bool isFrozen();
//! Set map units (needed by project properties dialog)
void setMapUnits( Qgis::UnitType mapUnits );
void setMapUnits( QgsUnitTypes::DistanceUnit mapUnits );
//! Get the current canvas map units
Qgis::UnitType mapUnits() const;
QgsUnitTypes::DistanceUnit mapUnits() const;
//! Getter for stored overrides of styles for layers.
//! @note added in 2.12

8
src/gui/qgsmaptoolidentify.cpp
View File

@ -660,13 +660,13 @@ bool QgsMapToolIdentify::identifyRasterLayer( QList<IdentifyResult> *results, Qg
return true;
}
void QgsMapToolIdentify::convertMeasurement( QgsDistanceArea &calc, double &measure, Qgis::UnitType &u, bool isArea )
void QgsMapToolIdentify::convertMeasurement( QgsDistanceArea &calc, double &measure, QgsUnitTypes::DistanceUnit &u, bool isArea )
{
// Helper for converting between units
// The parameter &u is out only...
// Get the canvas units
Qgis::UnitType myUnits = mCanvas->mapUnits();
QgsUnitTypes::DistanceUnit myUnits = mCanvas->mapUnits();
Q_NOWARN_DEPRECATED_PUSH
calc.convertMeasurement( measure, myUnits, displayUnits(), isArea );
@ -674,12 +674,12 @@ void QgsMapToolIdentify::convertMeasurement( QgsDistanceArea &calc, double &meas
Q_NOWARN_DEPRECATED_POP
}
Qgis::UnitType QgsMapToolIdentify::displayUnits()
QgsUnitTypes::DistanceUnit QgsMapToolIdentify::displayUnits()
{
return mCanvas->mapUnits();
}
Qgis::UnitType QgsMapToolIdentify::displayDistanceUnits() const
QgsUnitTypes::DistanceUnit QgsMapToolIdentify::displayDistanceUnits() const
{
return mCanvas->mapUnits();
}

6
src/gui/qgsmaptoolidentify.h
View File

@ -161,18 +161,18 @@ class GUI_EXPORT QgsMapToolIdentify : public QgsMapTool
//! Private helper
//! @deprecated use displayDistanceUnits() and displayAreaUnits() instead
Q_DECL_DEPRECATED virtual void convertMeasurement( QgsDistanceArea &calc, double &measure, Qgis::UnitType &u, bool isArea );
Q_DECL_DEPRECATED virtual void convertMeasurement( QgsDistanceArea &calc, double &measure, QgsUnitTypes::DistanceUnit &u, bool isArea );
/** Transforms the measurements of derived attributes in the desired units
* @deprecated use displayDistanceUnits() and displayAreaUnits() instead
*/
Q_DECL_DEPRECATED virtual Qgis::UnitType displayUnits();
Q_DECL_DEPRECATED virtual QgsUnitTypes::DistanceUnit displayUnits();
/** Desired units for distance display.
* @note added in QGIS 2.14
* @see displayAreaUnits()
*/
virtual Qgis::UnitType displayDistanceUnits() const;
virtual QgsUnitTypes::DistanceUnit displayDistanceUnits() const;
/** Desired units for area display.
* @note added in QGIS 2.14

6
src/plugins/coordinate_capture/coordinatecapture.cpp
View File

@ -97,7 +97,7 @@ void CoordinateCapture::initGui()
setSourceCrs(); //set up the source CRS
mTransform.setDestinationCrs( mCrs ); // set the CRS in the transform
mUserCrsDisplayPrecision = ( mCrs.mapUnits() == Qgis::Degrees ) ? 5 : 3; // precision depends on CRS units
mUserCrsDisplayPrecision = ( mCrs.mapUnits() == QgsUnitTypes::Degrees ) ? 5 : 3; // precision depends on CRS units
//create the dock widget
mpDockWidget = new QgsDockWidget( tr( "Coordinate Capture" ), mQGisIface->mainWindow() );
@ -190,14 +190,14 @@ void CoordinateCapture::setCRS()
{
mCrs.createFromSrsId( mySelector.selectedCrsId() );
mTransform.setDestinationCrs( mCrs );
mUserCrsDisplayPrecision = ( mCrs.mapUnits() == Qgis::Degrees ) ? 5 : 3; //precision depends on CRS units
mUserCrsDisplayPrecision = ( mCrs.mapUnits() == QgsUnitTypes::Degrees ) ? 5 : 3; //precision depends on CRS units
}
}
void CoordinateCapture::setSourceCrs()
{
mTransform.setSourceCrs( mQGisIface->mapCanvas()->mapSettings().destinationCrs() );
mCanvasDisplayPrecision = ( mQGisIface->mapCanvas()->mapSettings().destinationCrs().mapUnits() == Qgis::Degrees ) ? 5 : 3; // for the map canvas coordinate display
mCanvasDisplayPrecision = ( mQGisIface->mapCanvas()->mapSettings().destinationCrs().mapUnits() == QgsUnitTypes::Degrees ) ? 5 : 3; // for the map canvas coordinate display
}
void CoordinateCapture::mouseClicked( const QgsPoint& thePoint )

2
src/plugins/grass/qgsgrassnewmapset.cpp
View File

@ -527,7 +527,7 @@ void QgsGrassNewMapset::setRegionPage()
if ( ok )
{
int precision = newCrs.mapUnits() == Qgis::Degrees ? 6 : 1;
int precision = newCrs.mapUnits() == QgsUnitTypes::Degrees ? 6 : 1;
mNorthLineEdit->setText( qgsDoubleToString( points[1].y(), precision ) );
mSouthLineEdit->setText( qgsDoubleToString( points[0].y(), precision ) );
mEastLineEdit->setText( qgsDoubleToString( points[1].x(), precision ) );

4
src/plugins/grass/qgsgrassregion.cpp
View File

@ -256,12 +256,12 @@ QString QgsGrassRegion::formatExtent( double v )
{
// format with precision approximately to meters
// max length of degree of latitude on pole is 111694 m
return qgsDoubleToString( v, mCrs.mapUnits() == Qgis::Degrees ? 6 : 1 );
return qgsDoubleToString( v, mCrs.mapUnits() == QgsUnitTypes::Degrees ? 6 : 1 );
}
QString QgsGrassRegion::formatResolution( double v )
{
return qgsDoubleToString( v, mCrs.mapUnits() == Qgis::Degrees ? 10 : 4 );
return qgsDoubleToString( v, mCrs.mapUnits() == QgsUnitTypes::Degrees ? 10 : 4 );
}
void QgsGrassRegion::readRegion()

2
src/providers/arcgisrest/qgsamsprovider.cpp
View File

@ -247,7 +247,7 @@ QImage* QgsAmsProvider::draw( const QgsRectangle & viewExtent, int pixelWidth, i
QgsDataSourceURI dataSource( dataSourceUri() );
// Use of tiles currently only implemented if service CRS is meter based
if ( mServiceInfo["singleFusedMapCache"].toBool() && mCrs.mapUnits() == Qgis::Meters )
if ( mServiceInfo["singleFusedMapCache"].toBool() && mCrs.mapUnits() == QgsUnitTypes::Meters )
{
// Compute ideal resolution
// - Measure distance in meters along lower and upper edge of bounding box

6
src/providers/wcs/qgswcsprovider.cpp
View File

@ -1397,13 +1397,13 @@ QgsRasterIdentifyResult QgsWcsProvider::identify( const QgsPoint & thePoint, Qgs
// set resolution approximately to 1mm
switch ( mCrs.mapUnits() )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
xRes = 0.001;
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
xRes = 0.003;
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
// max length of degree of latitude on pole is 111694 m
xRes = 1e-8;
break;

4
src/providers/wfs/qgswfsshareddata.cpp
View File

@ -1009,9 +1009,9 @@ void QgsWFSSharedData::endOfDownload( bool success, int featureCount,
{
// Grow the extent by ~ 50 km (completely arbitrary number if you wonder!)
// so that it is sufficiently zoomed out
if ( mSourceCRS.mapUnits() == Qgis::Meters )
if ( mSourceCRS.mapUnits() == QgsUnitTypes::Meters )
mComputedExtent.grow( 50. * 1000. );
else if ( mSourceCRS.mapUnits() == Qgis::Degrees )
else if ( mSourceCRS.mapUnits() == QgsUnitTypes::Degrees )
mComputedExtent.grow( 50. / 110 );
QgsMessageLog::logMessage( tr( "Layer extent reported by the server is not correct. "
"You may need to zoom on layer and then zoom out to see all features" ), tr( "WFS" ) );

4
src/providers/wms/qgswmscapabilities.cpp
View File

@ -1289,7 +1289,7 @@ void QgsWmsCapabilities::parseWMTSContents( QDomElement const &e )
s.wkScaleSet = e0.firstChildElement( "WellKnownScaleSet" ).text();
double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), Qgis::Meters );
double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), QgsUnitTypes::Meters );
s.crs = crs.authid();
@ -1797,7 +1797,7 @@ bool QgsWmsCapabilities::detectTileLayerBoundingBox( QgsWmtsTileLayer& l )
return false;
const QgsWmtsTileMatrix& tm = *tmIt;
double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), Qgis::Meters );
double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), QgsUnitTypes::Meters );
double res = tm.scaleDenom * 0.00028 / metersPerUnit;
QgsPoint bottomRight( tm.topLeft.x() + res * tm.tileWidth * tm.matrixWidth,
tm.topLeft.y() - res * tm.tileHeight * tm.matrixHeight );

6
src/providers/wms/qgswmsprovider.cpp
View File

@ -2110,13 +2110,13 @@ QgsRasterIdentifyResult QgsWmsProvider::identify( const QgsPoint & thePoint, Qgs
// set resolution approximately to 1mm
switch ( crs.mapUnits() )
{
case Qgis::Meters:
case QgsUnitTypes::Meters:
xRes = 0.001;
break;
case Qgis::Feet:
case QgsUnitTypes::Feet:
xRes = 0.003;
break;
case Qgis::Degrees:
case QgsUnitTypes::Degrees:
// max length of degree of latitude on pole is 111694 m
xRes = 1e-8;
break;

6
src/server/qgsmaprenderer.cpp
View File

@ -51,7 +51,7 @@ QgsMapRenderer::QgsMapRenderer()
mOverview = false;
// set default map units - we use WGS 84 thus use degrees
setMapUnits( Qgis::Degrees );
setMapUnits( QgsUnitTypes::Degrees );
mSize = QSize( 0, 0 );
@ -584,7 +584,7 @@ void QgsMapRenderer::render( QPainter* painter, double* forceWidthScale )
mDrawing = false;
}
void QgsMapRenderer::setMapUnits( Qgis::UnitType u )
void QgsMapRenderer::setMapUnits( QgsUnitTypes::DistanceUnit u )
{
mScaleCalculator->setMapUnits( u );
@ -594,7 +594,7 @@ void QgsMapRenderer::setMapUnits( Qgis::UnitType u )
emit mapUnitsChanged();
}
Qgis::UnitType QgsMapRenderer::mapUnits() const
QgsUnitTypes::DistanceUnit QgsMapRenderer::mapUnits() const
{
return mScaleCalculator->mapUnits();
}

4
src/server/qgsmaprenderer.h
View File

@ -110,8 +110,8 @@ class SERVER_EXPORT QgsMapRenderer : public QObject
//! Recalculate the map scale
void updateScale();
Qgis::UnitType mapUnits() const;
void setMapUnits( Qgis::UnitType u );
QgsUnitTypes::DistanceUnit mapUnits() const;
void setMapUnits( QgsUnitTypes::DistanceUnit u );
//! sets whether map image will be for overview
void enableOverviewMode( bool isOverview = true ) { mOverview = isOverview; }

2
src/server/qgswmsserver.cpp
View File

@ -2018,7 +2018,7 @@ int QgsWmsServer::configureMapRender( const QPaintDevice* paintDevice ) const
throw QgsMapServiceException( "InvalidParameterValue", "Invalid BBOX parameter" );
}
Qgis::UnitType mapUnits = Qgis::Degrees;
QgsUnitTypes::DistanceUnit mapUnits = QgsUnitTypes::Degrees;
QString crs = mParameters.value( "CRS", mParameters.value( "SRS" ) );

4
tests/src/app/testqgsattributetable.cpp
View File

@ -90,7 +90,7 @@ void TestQgsAttributeTable::testFieldCalculation()
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int ) srs.srsid() );
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
QgsProject::instance()->writeEntry( "Measure", "/Ellipsoid", QString( "WGS84" ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Meters ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Meters ) );
// run length calculation
QScopedPointer< QgsAttributeTableDialog > dlg( new QgsAttributeTableDialog( tempLayer.data() ) );
@ -105,7 +105,7 @@ void TestQgsAttributeTable::testFieldCalculation()
QVERIFY( qgsDoubleNear( f.attribute( "col1" ).toDouble(), expected, 0.001 ) );
// change project length unit, check calculation respects unit
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
QScopedPointer< QgsAttributeTableDialog > dlg2( new QgsAttributeTableDialog( tempLayer.data() ) );
tempLayer->startEditing();
dlg2->runFieldCalculation( tempLayer.data(), "col1", "$length" );

4
tests/src/app/testqgsfieldcalculator.cpp
View File

@ -90,7 +90,7 @@ void TestQgsFieldCalculator::testLengthCalculations()
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int ) srs.srsid() );
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
QgsProject::instance()->writeEntry( "Measure", "/Ellipsoid", QString( "WGS84" ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Meters ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Meters ) );
// run length calculation
tempLayer->startEditing();
@ -112,7 +112,7 @@ void TestQgsFieldCalculator::testLengthCalculations()
QVERIFY( qgsDoubleNear( f.attribute( "col1" ).toDouble(), expected, 0.001 ) );
// change project length unit, check calculation respects unit
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
tempLayer->startEditing();
QScopedPointer< QgsFieldCalculator > calc2( new QgsFieldCalculator( tempLayer.data() ) );
calc2->mUpdateExistingGroupBox->setChecked( true );

8
tests/src/app/testqgsmaptoolidentifyaction.cpp
View File

@ -133,7 +133,7 @@ void TestQgsMapToolIdentifyAction::lengthCalculation()
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int ) srs.srsid() );
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
QgsProject::instance()->writeEntry( "Measure", "/Ellipsoid", QString( "WGS84" ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Meters ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Meters ) );
QgsPoint mapPoint = canvas->getCoordinateTransform()->transform( 2484588, 2425722 );
@ -145,7 +145,7 @@ void TestQgsMapToolIdentifyAction::lengthCalculation()
QVERIFY( qgsDoubleNear( length, 26932.2, 0.1 ) );
//check that project units are respected
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
result = action->identify( mapPoint.x(), mapPoint.y(), QList<QgsMapLayer*>() << tempLayer.data() );
QCOMPARE( result.length(), 1 );
derivedLength = result.at( 0 ).mDerivedAttributes[tr( "Length" )];
@ -188,7 +188,7 @@ void TestQgsMapToolIdentifyAction::perimeterCalculation()
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int ) srs.srsid() );
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
QgsProject::instance()->writeEntry( "Measure", "/Ellipsoid", QString( "WGS84" ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Meters ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Meters ) );
QgsPoint mapPoint = canvas->getCoordinateTransform()->transform( 2484588, 2425722 );
@ -200,7 +200,7 @@ void TestQgsMapToolIdentifyAction::perimeterCalculation()
QCOMPARE( perimeter, 128289.074 );
//check that project units are respected
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
result = action->identify( mapPoint.x(), mapPoint.y(), QList<QgsMapLayer*>() << tempLayer.data() );
QCOMPARE( result.length(), 1 );
derivedPerimeter = result.at( 0 ).mDerivedAttributes[tr( "Perimeter" )];

4
tests/src/app/testqgsmeasuretool.cpp
View File

@ -98,7 +98,7 @@ void TestQgsMeasureTool::testLengthCalculation()
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCRSID", ( int ) srs.srsid() );
QgsProject::instance()->writeEntry( "SpatialRefSys", "/ProjectCrs", srs.authid() );
QgsProject::instance()->writeEntry( "Measure", "/Ellipsoid", QString( "WGS84" ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Meters ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Meters ) );
// run length calculation
QScopedPointer< QgsMeasureTool > tool( new QgsMeasureTool( mCanvas, false ) );
@ -117,7 +117,7 @@ void TestQgsMeasureTool::testLengthCalculation()
QGSCOMPARENEAR( measured, expected, 0.001 );
// change project length unit, check calculation respects unit
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
QgsProject::instance()->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
QScopedPointer< QgsMeasureTool > tool2( new QgsMeasureTool( mCanvas, false ) );
QScopedPointer< QgsMeasureDialog > dlg2( new QgsMeasureDialog( tool2.data() ) );

2
tests/src/core/testqgsatlascomposition.cpp
View File

@ -146,7 +146,7 @@ void TestQgsAtlasComposition::init()
//create composition with composer map
mMapSettings->setLayers( QStringList() << mVectorLayer->id() );
mMapSettings->setCrsTransformEnabled( true );
mMapSettings->setMapUnits( Qgis::Meters );
mMapSettings->setMapUnits( QgsUnitTypes::Meters );
// select epsg:2154
QgsCoordinateReferenceSystem crs;

2
tests/src/core/testqgscomposerdd.cpp
View File

@ -84,7 +84,7 @@ void TestQgsComposerDD::initTestCase()
//create composition with composer map
mMapSettings->setLayers( QStringList() << mVectorLayer->id() );
mMapSettings->setCrsTransformEnabled( true );
mMapSettings->setMapUnits( Qgis::Meters );
mMapSettings->setMapUnits( QgsUnitTypes::Meters );
// select epsg:2154
QgsCoordinateReferenceSystem crs;

2
tests/src/core/testqgscomposition.cpp
View File

@ -77,7 +77,7 @@ void TestQgsComposition::initTestCase()
//create composition
mMapSettings->setCrsTransformEnabled( true );
mMapSettings->setMapUnits( Qgis::Meters );
mMapSettings->setMapUnits( QgsUnitTypes::Meters );
mComposition = new QgsComposition( *mMapSettings );
mComposition->setPaperSize( 297, 210 ); //A4 landscape
mComposition->setNumPages( 3 );

8
tests/src/core/testqgscoordinatereferencesystem.cpp
View File

@ -436,7 +436,7 @@ void TestQgsCoordinateReferenceSystem::mapUnits()
{
QgsCoordinateReferenceSystem myCrs;
myCrs.createFromSrid( GEOSRID );
QVERIFY( myCrs.mapUnits() == Qgis::Degrees );
QVERIFY( myCrs.mapUnits() == QgsUnitTypes::Degrees );
debugPrint( myCrs );
}
void TestQgsCoordinateReferenceSystem::setValidationHint()
@ -475,15 +475,15 @@ void TestQgsCoordinateReferenceSystem::debugPrint(
QgsDebugMsg( "* Proj4 : " + theCrs.toProj4() );
QgsDebugMsg( "* WKT : " + theCrs.toWkt() );
QgsDebugMsg( "* Desc. : " + theCrs.description() );
if ( theCrs.mapUnits() == Qgis::Meters )
if ( theCrs.mapUnits() == QgsUnitTypes::Meters )
{
QgsDebugMsg( "* Units : meters" );
}
else if ( theCrs.mapUnits() == Qgis::Feet )
else if ( theCrs.mapUnits() == QgsUnitTypes::Feet )
{
QgsDebugMsg( "* Units : feet" );
}
else if ( theCrs.mapUnits() == Qgis::Degrees )
else if ( theCrs.mapUnits() == QgsUnitTypes::Degrees )
{
QgsDebugMsg( "* Units : degrees" );
}

16
tests/src/core/testqgsdistancearea.cpp
View File

@ -158,13 +158,13 @@ void TestQgsDistanceArea::unit_conversions()
myDa.setEllipsoidalMode( false );
double inputValue;
Qgis::UnitType inputUnit;
Qgis::UnitType outputUnit;
QgsUnitTypes::DistanceUnit inputUnit;
QgsUnitTypes::DistanceUnit outputUnit;
inputValue = 10000.0;
inputUnit = Qgis::Meters;
outputUnit = Qgis::Feet;
//outputUnit = Qgis::Meters;
inputUnit = QgsUnitTypes::Meters;
outputUnit = QgsUnitTypes::Feet;
//outputUnit = QgsUnitTypes::Meters;
// First, convert from sq.meter to sq.feet
Q_NOWARN_DEPRECATED_PUSH
@ -238,20 +238,20 @@ void TestQgsDistanceArea::measureUnits()
calc.setEllipsoidalMode( false );
calc.setEllipsoid( "NONE" );
calc.setSourceCrs( 254L );
Qgis::UnitType units;
QgsUnitTypes::DistanceUnit units;
QgsPoint p1( 1341683.9854275715, 408256.9562717728 );
QgsPoint p2( 1349321.7807031618, 408256.9562717728 );
double result = calc.measureLine( p1, p2, units );
//no OTF, result will be in CRS unit (feet)
QCOMPARE( units, Qgis::Feet );
QCOMPARE( units, QgsUnitTypes::Feet );
QGSCOMPARENEAR( result, 7637.7952755903825, 0.001 );
calc.setEllipsoidalMode( true );
calc.setEllipsoid( "WGS84" );
result = calc.measureLine( p1, p2, units );
//OTF, result will be in meters
QCOMPARE( units, Qgis::Meters );
QCOMPARE( units, QgsUnitTypes::Meters );
QGSCOMPARENEAR( result, 2328.0988253106957, 0.001 );
}

20
tests/src/core/testqgsexpression.cpp
View File

@ -1777,10 +1777,10 @@ class TestQgsExpression: public QObject
expected = 128282.086;
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
// units should not be converted if no geometry calculator set
expPerimeter.setDistanceUnits( Qgis::Feet );
expPerimeter.setDistanceUnits( QgsUnitTypes::Feet );
vPerimeter = expPerimeter.evaluate( &context );
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
expPerimeter.setDistanceUnits( Qgis::NauticalMiles );
expPerimeter.setDistanceUnits( QgsUnitTypes::NauticalMiles );
vPerimeter = expPerimeter.evaluate( &context );
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
@ -1791,13 +1791,13 @@ class TestQgsExpression: public QObject
expected = 128289.074;
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
// test unit conversion
expPerimeter2.setDistanceUnits( Qgis::Meters ); //default units should be meters
expPerimeter2.setDistanceUnits( QgsUnitTypes::Meters ); //default units should be meters
vPerimeter = expPerimeter2.evaluate( &context );
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
expPerimeter2.setDistanceUnits( Qgis::UnknownUnit ); //unknown units should not be converted
expPerimeter2.setDistanceUnits( QgsUnitTypes::UnknownDistanceUnit ); //unknown units should not be converted
vPerimeter = expPerimeter2.evaluate( &context );
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
expPerimeter2.setDistanceUnits( Qgis::Feet );
expPerimeter2.setDistanceUnits( QgsUnitTypes::Feet );
expected = 420895.9120735;
vPerimeter = expPerimeter2.evaluate( &context );
QVERIFY( qgsDoubleNear( vPerimeter.toDouble(), expected, 0.001 ) );
@ -1813,10 +1813,10 @@ class TestQgsExpression: public QObject
expected = 26930.637;
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
// units should not be converted if no geometry calculator set
expLength.setDistanceUnits( Qgis::Feet );
expLength.setDistanceUnits( QgsUnitTypes::Feet );
vLength = expLength.evaluate( &context );
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
expLength.setDistanceUnits( Qgis::NauticalMiles );
expLength.setDistanceUnits( QgsUnitTypes::NauticalMiles );
vLength = expLength.evaluate( &context );
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
@ -1827,13 +1827,13 @@ class TestQgsExpression: public QObject
expected = 26932.156;
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
// test unit conversion
expLength2.setDistanceUnits( Qgis::Meters ); //default units should be meters
expLength2.setDistanceUnits( QgsUnitTypes::Meters ); //default units should be meters
vLength = expLength2.evaluate( &context );
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
expLength2.setDistanceUnits( Qgis::UnknownUnit ); //unknown units should not be converted
expLength2.setDistanceUnits( QgsUnitTypes::UnknownDistanceUnit ); //unknown units should not be converted
vLength = expLength2.evaluate( &context );
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );
expLength2.setDistanceUnits( Qgis::Feet );
expLength2.setDistanceUnits( QgsUnitTypes::Feet );
expected = 88360.0918635;
vLength = expLength2.evaluate( &context );
QVERIFY( qgsDoubleNear( vLength.toDouble(), expected, 0.001 ) );

12
tests/src/core/testqgsproject.cpp
View File

@ -92,20 +92,20 @@ void TestQgsProject::testProjectUnits()
//first set a default QGIS distance unit
QSettings s;
s.setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( Qgis::Feet ) );
s.setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QgsUnitTypes::Feet ) );
QgsProject* prj = QgsProject::instance();
// new project should inherit QGIS default distance unit
prj->clear();
QCOMPARE( prj->distanceUnits(), Qgis::Feet );
QCOMPARE( prj->distanceUnits(), QgsUnitTypes::Feet );
//changing default QGIS unit should not affect existing project
s.setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( Qgis::NauticalMiles ) );
QCOMPARE( prj->distanceUnits(), Qgis::Feet );
s.setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QgsUnitTypes::NauticalMiles ) );
QCOMPARE( prj->distanceUnits(), QgsUnitTypes::Feet );
//test setting new units for project
prj->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( Qgis::NauticalMiles ) );
QCOMPARE( prj->distanceUnits(), Qgis::NauticalMiles );
prj->writeEntry( "Measurement", "/DistanceUnits", QgsUnitTypes::encodeUnit( QgsUnitTypes::NauticalMiles ) );
QCOMPARE( prj->distanceUnits(), QgsUnitTypes::NauticalMiles );
// AREA

4
tests/src/python/test_qgsatlascomposition.py
View File

@ -22,7 +22,7 @@ import tempfile
from qgis.testing import start_app, unittest
from utilities import unitTestDataPath
from qgis.PyQt.QtCore import QFileInfo, QRectF, qWarning
from qgis.core import Qgis, QgsVectorLayer, QgsMapLayerRegistry, QgsMapSettings, QgsCoordinateReferenceSystem, \
from qgis.core import QgsUnitTypes, QgsVectorLayer, QgsMapLayerRegistry, QgsMapSettings, QgsCoordinateReferenceSystem, \
QgsComposition, QgsFillSymbolV2, QgsSingleSymbolRendererV2, QgsComposerLabel, QgsComposerMap, QgsFontUtils, \
QgsRectangle, QgsComposerLegend, QgsFeature, QgsGeometry, QgsPoint, QgsRendererCategoryV2, QgsCategorizedSymbolRendererV2, QgsMarkerSymbolV2
from qgscompositionchecker import QgsCompositionChecker
@ -48,7 +48,7 @@ class TestQgsAtlasComposition(unittest.TestCase):
layerStringList.append(mVectorLayer.id())
self.mapSettings.setLayers(layerStringList)
self.mapSettings.setCrsTransformEnabled(True)
self.mapSettings.setMapUnits(Qgis.Meters)
self.mapSettings.setMapUnits(QgsUnitTypes.Meters)
# select epsg:2154
crs = QgsCoordinateReferenceSystem()

75
tests/src/python/test_qgsdistancearea.py
View File

@ -18,7 +18,6 @@ from qgis.core import (QgsGeometry,
QgsPoint,
QgsDistanceArea,
QgsCoordinateReferenceSystem,
Qgis,
QgsUnitTypes
)
@ -171,16 +170,16 @@ class TestQgsDistanceArea(unittest.TestCase):
units = da.lengthUnits()
print("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == Qgis.Degrees) or
(abs(distance - 248.52) < 0.01 and units == Qgis.Meters))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == QgsUnitTypes.Degrees) or
(abs(distance - 248.52) < 0.01 and units == QgsUnitTypes.Meters))
da.setEllipsoid("WGS84")
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
units = da.lengthUnits()
print("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == Qgis.Degrees) or
(abs(distance - 248.52) < 0.01 and units == Qgis.Meters))
assert ((abs(distance - 2.23606797) < 0.00000001 and units == QgsUnitTypes.Degrees) or
(abs(distance - 248.52) < 0.01 and units == QgsUnitTypes.Meters))
da.setEllipsoidalMode(True)
distance = da.measureLine(QgsPoint(1, 1), QgsPoint(2, 3))
@ -189,10 +188,10 @@ class TestQgsDistanceArea(unittest.TestCase):
print("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))
# should always be in Meters
self.assertAlmostEqual(distance, 247555.57, delta=0.01)
self.assertEqual(units, Qgis.Meters)
self.assertEqual(units, QgsUnitTypes.Meters)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, Qgis.NauticalMiles)
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.NauticalMiles)
self.assertAlmostEqual(distance, 133.669, delta=0.01)
# now try with a source CRS which is in feet
@ -203,10 +202,10 @@ class TestQgsDistanceArea(unittest.TestCase):
units = da.lengthUnits()
print("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))
self.assertAlmostEqual(distance, 2.23606797, delta=0.000001)
self.assertEqual(units, Qgis.Feet)
self.assertEqual(units, QgsUnitTypes.Feet)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, Qgis.Meters)
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.Meters)
self.assertAlmostEqual(distance, 0.6815, delta=0.001)
da.setEllipsoidalMode(True)
@ -215,10 +214,10 @@ class TestQgsDistanceArea(unittest.TestCase):
units = da.lengthUnits()
print("measured {} in {}".format(distance, QgsUnitTypes.toString(units)))
self.assertAlmostEqual(distance, 0.67953772, delta=0.000001)
self.assertEqual(units, Qgis.Meters)
self.assertEqual(units, QgsUnitTypes.Meters)
# test converting the resultant length
distance = da.convertLengthMeasurement(distance, Qgis.Feet)
distance = da.convertLengthMeasurement(distance, QgsUnitTypes.Feet)
self.assertAlmostEqual(distance, 2.2294, delta=0.001)
def testAreaMeasureAndUnits(self):
@ -303,33 +302,33 @@ class TestQgsDistanceArea(unittest.TestCase):
def testFormatDistance(self):
"""Test formatting distances"""
QLocale.setDefault(QLocale.c())
self.assertEqual(QgsDistanceArea.formatDistance(45, 3, Qgis.Meters), u'45.000 m')
self.assertEqual(QgsDistanceArea.formatDistance(1300, 1, Qgis.Meters, False), u'1.3 km')
self.assertEqual(QgsDistanceArea.formatDistance(.005, 1, Qgis.Meters, False), u'5.0 mm')
self.assertEqual(QgsDistanceArea.formatDistance(.05, 1, Qgis.Meters, False), u'5.0 cm')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, Qgis.Kilometers, True), u'1.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, Qgis.Kilometers, False), u'1.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, Qgis.Kilometers, True), u'0.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, Qgis.Kilometers, False), u'500.000 m')
self.assertEqual(QgsDistanceArea.formatDistance(6000, 0, Qgis.Feet, True), u'6,000 ft')
self.assertEqual(QgsDistanceArea.formatDistance(6000, 3, Qgis.Feet, False), u'1.136 mi')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, Qgis.Feet, True), u'300 ft')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, Qgis.Feet, False), u'300 ft')
self.assertEqual(QgsDistanceArea.formatDistance(3000, 0, Qgis.Yards, True), u'3,000 yd')
self.assertEqual(QgsDistanceArea.formatDistance(3000, 3, Qgis.Yards, False), u'1.705 mi')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, Qgis.Yards, True), u'300 yd')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, Qgis.Yards, False), u'300 yd')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, Qgis.Miles, True), u'1.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, Qgis.Miles, False), u'1.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, Qgis.Miles, True), u'0.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 0, Qgis.Miles, False), u'2,640 ft')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 1, Qgis.NauticalMiles, True), u'0.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 1, Qgis.NauticalMiles, False), u'0.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, Qgis.NauticalMiles, True), u'1.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, Qgis.NauticalMiles, False), u'1.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, Qgis.Degrees, True), u'1.5 degrees')
self.assertEqual(QgsDistanceArea.formatDistance(1.0, 1, Qgis.Degrees, False), u'1.0 degree')
self.assertEqual(QgsDistanceArea.formatDistance(1.0, 1, Qgis.UnknownUnit, False), u'1.0')
self.assertEqual(QgsDistanceArea.formatDistance(45, 3, QgsUnitTypes.Meters), u'45.000 m')
self.assertEqual(QgsDistanceArea.formatDistance(1300, 1, QgsUnitTypes.Meters, False), u'1.3 km')
self.assertEqual(QgsDistanceArea.formatDistance(.005, 1, QgsUnitTypes.Meters, False), u'5.0 mm')
self.assertEqual(QgsDistanceArea.formatDistance(.05, 1, QgsUnitTypes.Meters, False), u'5.0 cm')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, QgsUnitTypes.Kilometers, True), u'1.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, QgsUnitTypes.Kilometers, False), u'1.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, QgsUnitTypes.Kilometers, True), u'0.500 km')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, QgsUnitTypes.Kilometers, False), u'500.000 m')
self.assertEqual(QgsDistanceArea.formatDistance(6000, 0, QgsUnitTypes.Feet, True), u'6,000 ft')
self.assertEqual(QgsDistanceArea.formatDistance(6000, 3, QgsUnitTypes.Feet, False), u'1.136 mi')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, QgsUnitTypes.Feet, True), u'300 ft')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, QgsUnitTypes.Feet, False), u'300 ft')
self.assertEqual(QgsDistanceArea.formatDistance(3000, 0, QgsUnitTypes.Yards, True), u'3,000 yd')
self.assertEqual(QgsDistanceArea.formatDistance(3000, 3, QgsUnitTypes.Yards, False), u'1.705 mi')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, QgsUnitTypes.Yards, True), u'300 yd')
self.assertEqual(QgsDistanceArea.formatDistance(300, 0, QgsUnitTypes.Yards, False), u'300 yd')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, QgsUnitTypes.Miles, True), u'1.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 3, QgsUnitTypes.Miles, False), u'1.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 3, QgsUnitTypes.Miles, True), u'0.500 mi')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 0, QgsUnitTypes.Miles, False), u'2,640 ft')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 1, QgsUnitTypes.NauticalMiles, True), u'0.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(0.5, 1, QgsUnitTypes.NauticalMiles, False), u'0.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, QgsUnitTypes.NauticalMiles, True), u'1.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, QgsUnitTypes.NauticalMiles, False), u'1.5 NM')
self.assertEqual(QgsDistanceArea.formatDistance(1.5, 1, QgsUnitTypes.Degrees, True), u'1.5 degrees')
self.assertEqual(QgsDistanceArea.formatDistance(1.0, 1, QgsUnitTypes.Degrees, False), u'1.0 degree')
self.assertEqual(QgsDistanceArea.formatDistance(1.0, 1, QgsUnitTypes.UnknownDistanceUnit, False), u'1.0')
QLocale.setDefault(QLocale.system())
if __name__ == '__main__':

95
tests/src/python/test_qgsunittypes.py
View File

@ -17,7 +17,6 @@ import qgis # NOQA
from qgis.testing import unittest
from qgis.core import (
QgsUnitTypes,
Qgis,
QgsSymbolV2
)
from qgis.PyQt.QtCore import QLocale
@ -31,14 +30,14 @@ class TestQgsUnitTypes(unittest.TestCase):
def testDistanceUnitType(self):
"""Test QgsUnitTypes::unitType() """
expected = {Qgis.Meters: QgsUnitTypes.Standard,
Qgis.Kilometers: QgsUnitTypes.Standard,
Qgis.Feet: QgsUnitTypes.Standard,
Qgis.Yards: QgsUnitTypes.Standard,
Qgis.Miles: QgsUnitTypes.Standard,
Qgis.Degrees: QgsUnitTypes.Geographic,
Qgis.UnknownUnit: QgsUnitTypes.UnknownType,
Qgis.NauticalMiles: QgsUnitTypes.Standard
expected = {QgsUnitTypes.Meters: QgsUnitTypes.Standard,
QgsUnitTypes.Kilometers: QgsUnitTypes.Standard,
QgsUnitTypes.Feet: QgsUnitTypes.Standard,
QgsUnitTypes.Yards: QgsUnitTypes.Standard,
QgsUnitTypes.Miles: QgsUnitTypes.Standard,
QgsUnitTypes.Degrees: QgsUnitTypes.Geographic,
QgsUnitTypes.UnknownDistanceUnit: QgsUnitTypes.UnknownType,
QgsUnitTypes.NauticalMiles: QgsUnitTypes.Standard
}
for t in expected.keys():
@ -46,14 +45,14 @@ class TestQgsUnitTypes(unittest.TestCase):
def testEncodeDecodeDistanceUnits(self):
"""Test encoding and decoding distance units"""
units = [Qgis.Meters,
Qgis.Kilometers,
Qgis.Feet,
Qgis.Yards,
Qgis.Miles,
Qgis.Degrees,
Qgis.UnknownUnit,
Qgis.NauticalMiles]
units = [QgsUnitTypes.Meters,
QgsUnitTypes.Kilometers,
QgsUnitTypes.Feet,
QgsUnitTypes.Yards,
QgsUnitTypes.Miles,
QgsUnitTypes.Degrees,
QgsUnitTypes.UnknownDistanceUnit,
QgsUnitTypes.NauticalMiles]
for u in units:
res, ok = QgsUnitTypes.decodeDistanceUnit(QgsUnitTypes.encodeUnit(u))
@ -63,23 +62,23 @@ class TestQgsUnitTypes(unittest.TestCase):
# Test decoding bad units
res, ok = QgsUnitTypes.decodeDistanceUnit('bad')
self.assertFalse(ok)
self.assertEqual(res, Qgis.UnknownUnit)
self.assertEqual(res, QgsUnitTypes.UnknownDistanceUnit)
# Test that string is cleaned before decoding
res, ok = QgsUnitTypes.decodeDistanceUnit(' FeEt ')
assert ok
self.assertEqual(res, Qgis.Feet)
self.assertEqual(res, QgsUnitTypes.Feet)
def testDistanceUnitsToFromString(self):
"""Test converting distance units to and from translated strings"""
units = [Qgis.Meters,
Qgis.Kilometers,
Qgis.Feet,
Qgis.Yards,
Qgis.Miles,
Qgis.Degrees,
Qgis.UnknownUnit,
Qgis.NauticalMiles]
units = [QgsUnitTypes.Meters,
QgsUnitTypes.Kilometers,
QgsUnitTypes.Feet,
QgsUnitTypes.Yards,
QgsUnitTypes.Miles,
QgsUnitTypes.Degrees,
QgsUnitTypes.UnknownDistanceUnit,
QgsUnitTypes.NauticalMiles]
for u in units:
res, ok = QgsUnitTypes.stringToDistanceUnit(QgsUnitTypes.toString(u))
@ -89,13 +88,13 @@ class TestQgsUnitTypes(unittest.TestCase):
# Test converting bad strings
res, ok = QgsUnitTypes.stringToDistanceUnit('bad')
self.assertFalse(ok)
self.assertEqual(res, Qgis.UnknownUnit)
self.assertEqual(res, QgsUnitTypes.UnknownDistanceUnit)
# Test that string is cleaned before conversion
res, ok = QgsUnitTypes.stringToDistanceUnit(' {} '.format(QgsUnitTypes.toString(Qgis.Feet).upper()))
print(' {} '.format(QgsUnitTypes.toString(Qgis.Feet).upper()))
res, ok = QgsUnitTypes.stringToDistanceUnit(' {} '.format(QgsUnitTypes.toString(QgsUnitTypes.Feet).upper()))
print(' {} '.format(QgsUnitTypes.toString(QgsUnitTypes.Feet).upper()))
assert ok
self.assertEqual(res, Qgis.Feet)
self.assertEqual(res, QgsUnitTypes.Feet)
def testAreaUnitType(self):
"""Test QgsUnitTypes::unitType() for area units """
@ -197,14 +196,14 @@ class TestQgsUnitTypes(unittest.TestCase):
def testFromUnitToUnitFactor(self):
"""Test calculation of conversion factor between units"""
expected = {Qgis.Meters: {Qgis.Meters: 1.0, Qgis.Kilometers: 0.001, Qgis.Feet: 3.28083989501, Qgis.Yards: 1.0936133, Qgis.Miles: 0.00062136931818182, Qgis.Degrees: 0.00000898315, Qgis.NauticalMiles: 0.000539957},
Qgis.Kilometers: {Qgis.Meters: 1000.0, Qgis.Kilometers: 1.0, Qgis.Feet: 3280.8398950, Qgis.Yards: 1093.6132983, Qgis.Miles: 0.62137121212119317271, Qgis.Degrees: 0.0089832, Qgis.NauticalMiles: 0.53995682073432482717},
Qgis.Feet: {Qgis.Meters: 0.3048, Qgis.Kilometers: 0.0003048, Qgis.Feet: 1.0, Qgis.Yards: 0.3333333, Qgis.Miles: 0.00018939375, Qgis.Degrees: 2.73806498599629E-06, Qgis.NauticalMiles: 0.000164579},
Qgis.Yards: {Qgis.Meters: 0.9144, Qgis.Kilometers: 0.0009144, Qgis.Feet: 3.0, Qgis.Yards: 1.0, Qgis.Miles: 0.000568182, Qgis.Degrees: 0.0000082, Qgis.NauticalMiles: 0.0004937366590756},
Qgis.Degrees: {Qgis.Meters: 111319.49079327358, Qgis.Kilometers: 111.3194908, Qgis.Feet: 365221.4264871, Qgis.Yards: 121740.4754957, Qgis.Miles: 69.1707247, Qgis.Degrees: 1.0, Qgis.NauticalMiles: 60.1077164},
Qgis.Miles: {Qgis.Meters: 1609.3440000, Qgis.Kilometers: 1.6093440, Qgis.Feet: 5280.0000000, Qgis.Yards: 1760.0000000, Qgis.Miles: 1.0, Qgis.Degrees: 0.0144570, Qgis.NauticalMiles: 0.8689762},
Qgis.NauticalMiles: {Qgis.Meters: 1852.0, Qgis.Kilometers: 1.8520000, Qgis.Feet: 6076.1154856, Qgis.Yards: 2025.3718285, Qgis.Miles: 1.1507794, Qgis.Degrees: 0.0166367990650, Qgis.NauticalMiles: 1.0},
Qgis.UnknownUnit: {Qgis.Meters: 1.0, Qgis.Kilometers: 1.0, Qgis.Feet: 1.0, Qgis.Yards: 1.0, Qgis.Miles: 1.0, Qgis.Degrees: 1.0, Qgis.NauticalMiles: 1.0}
expected = {QgsUnitTypes.Meters: {QgsUnitTypes.Meters: 1.0, QgsUnitTypes.Kilometers: 0.001, QgsUnitTypes.Feet: 3.28083989501, QgsUnitTypes.Yards: 1.0936133, QgsUnitTypes.Miles: 0.00062136931818182, QgsUnitTypes.Degrees: 0.00000898315, QgsUnitTypes.NauticalMiles: 0.000539957},
QgsUnitTypes.Kilometers: {QgsUnitTypes.Meters: 1000.0, QgsUnitTypes.Kilometers: 1.0, QgsUnitTypes.Feet: 3280.8398950, QgsUnitTypes.Yards: 1093.6132983, QgsUnitTypes.Miles: 0.62137121212119317271, QgsUnitTypes.Degrees: 0.0089832, QgsUnitTypes.NauticalMiles: 0.53995682073432482717},
QgsUnitTypes.Feet: {QgsUnitTypes.Meters: 0.3048, QgsUnitTypes.Kilometers: 0.0003048, QgsUnitTypes.Feet: 1.0, QgsUnitTypes.Yards: 0.3333333, QgsUnitTypes.Miles: 0.00018939375, QgsUnitTypes.Degrees: 2.73806498599629E-06, QgsUnitTypes.NauticalMiles: 0.000164579},
QgsUnitTypes.Yards: {QgsUnitTypes.Meters: 0.9144, QgsUnitTypes.Kilometers: 0.0009144, QgsUnitTypes.Feet: 3.0, QgsUnitTypes.Yards: 1.0, QgsUnitTypes.Miles: 0.000568182, QgsUnitTypes.Degrees: 0.0000082, QgsUnitTypes.NauticalMiles: 0.0004937366590756},
QgsUnitTypes.Degrees: {QgsUnitTypes.Meters: 111319.49079327358, QgsUnitTypes.Kilometers: 111.3194908, QgsUnitTypes.Feet: 365221.4264871, QgsUnitTypes.Yards: 121740.4754957, QgsUnitTypes.Miles: 69.1707247, QgsUnitTypes.Degrees: 1.0, QgsUnitTypes.NauticalMiles: 60.1077164},
QgsUnitTypes.Miles: {QgsUnitTypes.Meters: 1609.3440000, QgsUnitTypes.Kilometers: 1.6093440, QgsUnitTypes.Feet: 5280.0000000, QgsUnitTypes.Yards: 1760.0000000, QgsUnitTypes.Miles: 1.0, QgsUnitTypes.Degrees: 0.0144570, QgsUnitTypes.NauticalMiles: 0.8689762},
QgsUnitTypes.NauticalMiles: {QgsUnitTypes.Meters: 1852.0, QgsUnitTypes.Kilometers: 1.8520000, QgsUnitTypes.Feet: 6076.1154856, QgsUnitTypes.Yards: 2025.3718285, QgsUnitTypes.Miles: 1.1507794, QgsUnitTypes.Degrees: 0.0166367990650, QgsUnitTypes.NauticalMiles: 1.0},
QgsUnitTypes.UnknownDistanceUnit: {QgsUnitTypes.Meters: 1.0, QgsUnitTypes.Kilometers: 1.0, QgsUnitTypes.Feet: 1.0, QgsUnitTypes.Yards: 1.0, QgsUnitTypes.Miles: 1.0, QgsUnitTypes.Degrees: 1.0, QgsUnitTypes.NauticalMiles: 1.0}
}
for from_unit in expected.keys():
@ -217,7 +216,7 @@ class TestQgsUnitTypes(unittest.TestCase):
QgsUnitTypes.toString(from_unit),
QgsUnitTypes.toString(to_unit)))
#test conversion to unknown units
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, Qgis.UnknownUnit)
res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QgsUnitTypes.UnknownDistanceUnit)
self.assertAlmostEqual(res,
1.0,
msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
@ -254,14 +253,14 @@ class TestQgsUnitTypes(unittest.TestCase):
def testDistanceToAreaUnit(self):
"""Test distanceToAreaUnit conversion"""
expected = {Qgis.Meters: QgsUnitTypes.SquareMeters,
Qgis.Kilometers: QgsUnitTypes.SquareKilometers,
Qgis.Feet: QgsUnitTypes.SquareFeet,
Qgis.Yards: QgsUnitTypes.SquareYards,
Qgis.Miles: QgsUnitTypes.SquareMiles,
Qgis.Degrees: QgsUnitTypes.SquareDegrees,
Qgis.UnknownUnit: QgsUnitTypes.UnknownAreaUnit,
Qgis.NauticalMiles: QgsUnitTypes.SquareNauticalMiles
expected = {QgsUnitTypes.Meters: QgsUnitTypes.SquareMeters,
QgsUnitTypes.Kilometers: QgsUnitTypes.SquareKilometers,
QgsUnitTypes.Feet: QgsUnitTypes.SquareFeet,
QgsUnitTypes.Yards: QgsUnitTypes.SquareYards,
QgsUnitTypes.Miles: QgsUnitTypes.SquareMiles,
QgsUnitTypes.Degrees: QgsUnitTypes.SquareDegrees,
QgsUnitTypes.UnknownDistanceUnit: QgsUnitTypes.UnknownAreaUnit,
QgsUnitTypes.NauticalMiles: QgsUnitTypes.SquareNauticalMiles
}
for t in expected.keys():

4
tests/src/python/test_qgsvectorlayer.py
View File

@ -1269,7 +1269,7 @@ class TestQgsVectorLayer(unittest.TestCase):
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCRSID", srs.srsid())
QgsProject.instance().writeEntry("SpatialRefSys", "/ProjectCrs", srs.authid())
QgsProject.instance().writeEntry("Measure", "/Ellipsoid", "WGS84")
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(Qgis.Meters))
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.Meters))
idx = temp_layer.addExpressionField('$length', QgsField('length', QVariant.Double)) # NOQA
@ -1279,7 +1279,7 @@ class TestQgsVectorLayer(unittest.TestCase):
self.assertAlmostEqual(f['length'], expected, 3)
# change project length unit, check calculation respects unit
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(Qgis.Feet))
QgsProject.instance().writeEntry("Measurement", "/DistanceUnits", QgsUnitTypes.encodeUnit(QgsUnitTypes.Feet))
f = next(temp_layer.getFeatures())
expected = 88360.0918635
self.assertAlmostEqual(f['length'], expected, 3)