void QgsGrassNewMapset::setCurrentRegion()
{
QgsDebugMsg( "entered." );
QgsRectangle ext = mIface->mapCanvas()->extent();
int srsid = QgsProject::instance()->readNumEntry(
"SpatialRefSys", "/ProjectCRSID", 0 );
QgsCoordinateReferenceSystem srs( srsid, QgsCoordinateReferenceSystem::InternalCrsId );
QgsDebugMsg( QString( "current project srsid = %1" ).arg( srsid ) );
QgsDebugMsg( QString( "srs.isValid() = %1" ).arg( srs.isValid() ) );
std::vector<QgsPoint> points;
// TODO: this is not perfect
points.push_back( QgsPoint( ext.xMinimum(), ext.yMinimum() ) );
points.push_back( QgsPoint( ext.xMaximum(), ext.yMaximum() ) );
// TODO add a method, this code is copy-paste from setSelectedRegion
if ( srs.isValid() && mSrs.isValid()
&& srs.srsid() != mSrs.srsid() )
{
QgsCoordinateTransform trans( srs, mSrs );
bool ok = true;
for ( int i = 0; i < 2; i++ )
{
try
{
points[i] = trans.transform( points[i] );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsDebugMsg( "Cannot transform point" );
ok = false;
break;
}
}
if ( !ok )
{
QMessageBox::warning( 0, tr( "Warning" ), tr( "Cannot reproject region" ) );
return;
}
}
mNorthLineEdit->setText( QString::number( points[1].y() ) );
mSouthLineEdit->setText( QString::number( points[0].y() ) );
mEastLineEdit->setText( QString::number( points[1].x() ) );
mWestLineEdit->setText( QString::number( points[0].x() ) );
mRegionModified = true;
checkRegion();
drawRegion();
QgsDebugMsg( "setCurrentRegion - End" );
}
void QgsDxfExport::writeHeaderAC1018( QTextStream& stream )
{
stream << "999\n";
stream << "DXF created from QGIS\n";
startSection();
stream << " 2\n";
stream << "HEADER\n";
//ACADVER
stream << " 9\n";
stream << "$ACADVER\n";
stream << " 1\n";
stream << "AC1018\n";
QgsRectangle ext = dxfExtent();
if ( !ext.isEmpty() )
{
//EXTMIN
stream << " 9\n";
stream << "$EXTMIN\n";
stream << " 10\n";
stream << ext.xMinimum() << "\n";
stream << " 20\n";
stream << ext.yMinimum() << "\n";
stream << " 30\n";
stream << "0\n";
//EXTMAX
stream << " 9\n";
stream << "$EXTMAX\n";
stream << " 10\n";
stream << ext.xMaximum() << "\n";
stream << " 20\n";
stream << ext.yMaximum() << "\n";
stream << " 30\n";
stream << "0\n";
}
//LTSCALE
stream << " 9\n";
stream << "$LTSCALE\n";
stream << " 40\n";
stream << "1.0\n";
//PDMODE
stream << " 9\n";
stream << "$PDMODE\n";
stream << " 70\n";
stream << "33\n";
//PDSIZE
stream << " 9\n";
stream << "$PDSIZE\n";
stream << " 40\n";
stream << "1\n";
endSection();
//PSLTSCALE
stream << " 9\n";
stream << "$PSLTSCALE\n";
stream << " 70\n";
stream << "0\n";
}
SpatialIndex::Region QgsSpatialIndex::rectToRegion( const QgsRectangle& rect )
{
double pt1[2], pt2[2];
pt1[0] = rect.xMinimum();
pt1[1] = rect.yMinimum();
pt2[0] = rect.xMaximum();
pt2[1] = rect.yMaximum();
return SpatialIndex::Region( pt1, pt2, 2 );
}
Tools::Geometry::Region QgsSpatialIndex::rectToRegion( QgsRectangle rect )
{
double pt1[2], pt2[2];
pt1[0] = rect.xMinimum();
pt1[1] = rect.yMinimum();
pt2[0] = rect.xMaximum();
pt2[1] = rect.yMaximum();
return Tools::Geometry::Region( pt1, pt2, 2 );
}
void QgsInterpolationDialog::setLayersBoundingBox()
{
QgsRectangle layersBoundingBox = boundingBoxOfLayers();
mXMinLineEdit->setText( QString::number( layersBoundingBox.xMinimum() ) );
mXMaxLineEdit->setText( QString::number( layersBoundingBox.xMaximum() ) );
mYMinLineEdit->setText( QString::number( layersBoundingBox.yMinimum() ) );
mYMaxLineEdit->setText( QString::number( layersBoundingBox.yMaximum() ) );
setNewCellsizeOnBoundingBoxChange();
}
void TestQgsRectangle::combine()
{
QgsRectangle rect;
// combine extent of null rectangle with valid rectangle
rect.combineExtentWith( QgsRectangle( 1, 2, 3, 4 ) );
QCOMPARE( rect.xMinimum(), 1.0 );
QCOMPARE( rect.yMinimum(), 2.0 );
QCOMPARE( rect.xMaximum(), 3.0 );
QCOMPARE( rect.yMaximum(), 4.0 );
// combine extent of valid rectangle with null rectangle
rect = QgsRectangle( 1, 2, 3, 4 );
rect.combineExtentWith( QgsRectangle() );
QCOMPARE( rect.xMinimum(), 1.0 );
QCOMPARE( rect.yMinimum(), 2.0 );
QCOMPARE( rect.xMaximum(), 3.0 );
QCOMPARE( rect.yMaximum(), 4.0 );
}
void QgsMapToolLabel::createRubberBands()
{
delete mLabelRubberBand;
delete mFeatureRubberBand;
//label rubber band
QgsRectangle rect = mCurrentLabel.pos.labelRect;
mLabelRubberBand = new QgsRubberBand( mCanvas, QgsWkbTypes::LineGeometry );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMaximum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMaximum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPointXY( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->setColor( QColor( 0, 255, 0, 65 ) );
mLabelRubberBand->setWidth( 3 );
mLabelRubberBand->show();
//feature rubber band
QgsVectorLayer *vlayer = mCurrentLabel.layer;
if ( vlayer )
{
QgsFeature f;
if ( currentFeature( f, true ) )
{
QgsGeometry geom = f.geometry();
if ( !geom.isNull() )
{
QgsSettings settings;
int r = settings.value( QStringLiteral( "qgis/digitizing/line_color_red" ), 255 ).toInt();
int g = settings.value( QStringLiteral( "qgis/digitizing/line_color_green" ), 0 ).toInt();
int b = settings.value( QStringLiteral( "qgis/digitizing/line_color_blue" ), 0 ).toInt();
int a = settings.value( QStringLiteral( "qgis/digitizing/line_color_alpha" ), 200 ).toInt();
mFeatureRubberBand = new QgsRubberBand( mCanvas, geom.type() );
mFeatureRubberBand->setColor( QColor( r, g, b, a ) );
mFeatureRubberBand->setToGeometry( geom, vlayer );
mFeatureRubberBand->show();
}
}
//fixpoint rubber band
QgsPointXY fixPoint;
if ( currentLabelRotationPoint( fixPoint, false, false ) )
{
if ( mCanvas )
{
const QgsMapSettings &s = mCanvas->mapSettings();
fixPoint = s.mapToLayerCoordinates( vlayer, fixPoint );
}
QgsGeometry pointGeom = QgsGeometry::fromPointXY( fixPoint );
mFixPointRubberBand = new QgsRubberBand( mCanvas, QgsWkbTypes::LineGeometry );
mFixPointRubberBand->setColor( QColor( 0, 0, 255, 65 ) );
mFixPointRubberBand->setToGeometry( pointGeom, vlayer );
mFixPointRubberBand->show();
}
}
}
bool QgsOsgEarthTileSource::intersects( const TileKey* key )
{
//Get the native extents of the tile
double xmin, ymin, xmax, ymax;
key->getExtent().getBounds( xmin, ymin, xmax, ymax );
QgsRectangle extent = mQGisIface->mapCanvas()->fullExtent();
if ( mCoordTranform ) extent = mCoordTranform->transformBoundingBox( extent );
return !( xmin >= extent.xMaximum() || xmax <= extent.xMinimum() || ymin >= extent.yMaximum() || ymax <= extent.yMinimum() );
}
static SpatialIndex::Region rect2region( const QgsRectangle& rect )
{
double pLow[2], pHigh[2];
pLow[0] = rect.xMinimum();
pLow[1] = rect.yMinimum();
pHigh[0] = rect.xMaximum();
pHigh[1] = rect.yMaximum();
return SpatialIndex::Region( pLow, pHigh, 2 );
}
//! Returns whether the envelope can be replaced by its BBOX when is applied the specified map2pixel context
bool QgsMapToPixelSimplifier::canbeGeneralizedByMapBoundingBox( const QgsRectangle& envelope, double map2pixelTol )
{
// Can replace the geometry by its BBOX ?
if (( envelope.xMaximum() - envelope.xMinimum() ) < map2pixelTol && ( envelope.yMaximum() - envelope.yMinimum() ) < map2pixelTol )
{
return true;
}
return false;
}
tileMatrixSetDef calculateTileMatrixSet( tileMatrixInfo tmi, double minScale )
{
QList< tileMatrixDef > tileMatrixList;
double scaleDenominator = tmi.scaleDenominator;
QgsRectangle extent = tmi.extent;
QgsUnitTypes::DistanceUnit unit = tmi.unit;
// constant
double resolution = tmi.resolution;
int column = std::ceil( ( extent.xMaximum() - extent.xMinimum() ) / ( tileSize * resolution ) );
int row = std::ceil( ( extent.yMaximum() - extent.yMinimum() ) / ( tileSize * resolution ) );
while ( scaleDenominator >= minScale )
{
double scale = scaleDenominator;
// Calculate resolution based on scale denominator
double res = resolution;
int col = column;
int r = row;
tileMatrixDef tm;
tm.resolution = res;
tm.scaleDenominator = scale;
tm.col = col;
tm.row = r;
tm.left = extent.xMinimum();
tm.top = extent.yMaximum();
tileMatrixList.append( tm );
scaleDenominator = scale / 2;
resolution = res / 2;
column = col * 2;
row = r * 2;
}
tileMatrixSetDef tms;
tms.ref = tmi.ref;
tms.extent = extent;
tms.unit = unit;
tms.hasAxisInverted = tmi.hasAxisInverted;
tms.tileMatrixList = tileMatrixList;
return tms;
}
void QgsComposerMapWidget::on_mSetToMapCanvasExtentButton_clicked()
{
if ( mComposerMap )
{
const QgsMapRenderer* renderer = mComposerMap->mapRenderer();
if ( renderer )
{
QgsRectangle newExtent = renderer->extent();
//Make sure the width/height ratio is the same as in current composer map extent.
//This is to keep the map item frame and the page layout fixed
QgsRectangle currentMapExtent = *( mComposerMap->currentMapExtent() );
double currentWidthHeightRatio = currentMapExtent.width() / currentMapExtent.height();
double newWidthHeightRatio = newExtent.width() / newExtent.height();
if ( currentWidthHeightRatio < newWidthHeightRatio )
{
//enlarge height of new extent, ensuring the map center stays the same
double newHeight = newExtent.width() / currentWidthHeightRatio;
double deltaHeight = newHeight - newExtent.height();
newExtent.setYMinimum( newExtent.yMinimum() - deltaHeight / 2 );
newExtent.setYMaximum( newExtent.yMaximum() + deltaHeight / 2 );
}
else
{
//enlarge width of new extent, ensuring the map center stays the same
double newWidth = currentWidthHeightRatio * newExtent.height();
double deltaWidth = newWidth - newExtent.width();
newExtent.setXMinimum( newExtent.xMinimum() - deltaWidth / 2 );
newExtent.setXMaximum( newExtent.xMaximum() + deltaWidth / 2 );
}
//fill text into line edits
mXMinLineEdit->setText( QString::number( newExtent.xMinimum() ) );
mXMaxLineEdit->setText( QString::number( newExtent.xMaximum() ) );
mYMinLineEdit->setText( QString::number( newExtent.yMinimum() ) );
mYMaxLineEdit->setText( QString::number( newExtent.yMaximum() ) );
mComposerMap->beginCommand( tr( "Map extent changed" ) );
mComposerMap->setNewExtent( newExtent );
mComposerMap->endCommand();
}
}
}
void QgsMapToolLabel::createRubberBands( )
{
delete mLabelRubberBand;
delete mFeatureRubberBand;
//label rubber band
QgsRectangle rect = mCurrentLabelPos.labelRect;
mLabelRubberBand = new QgsRubberBand( mCanvas, false );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMaximum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMaximum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->setColor( Qt::green );
mLabelRubberBand->setWidth( 3 );
mLabelRubberBand->show();
//feature rubber band
QgsVectorLayer* vlayer = currentLayer();
if ( vlayer )
{
QgsFeature f;
if ( currentFeature( f, true ) )
{
QgsGeometry* geom = f.geometry();
if ( geom )
{
mFeatureRubberBand = new QgsRubberBand( mCanvas, geom->type() == QGis::Polygon );
mFeatureRubberBand->setColor( Qt::red );
mFeatureRubberBand->setToGeometry( geom, vlayer );
mFeatureRubberBand->show();
}
}
//fixpoint rubber band
QgsPoint fixPoint;
if ( rotationPoint( fixPoint ) )
{
if ( mCanvas )
{
QgsMapRenderer* r = mCanvas->mapRenderer();
if ( r && r->hasCrsTransformEnabled() )
{
fixPoint = r->mapToLayerCoordinates( vlayer, fixPoint );
}
}
QgsGeometry* pointGeom = QgsGeometry::fromPoint( fixPoint );
mFixPointRubberBand = new QgsRubberBand( mCanvas, false );
mFixPointRubberBand->setColor( Qt::blue );
mFixPointRubberBand->setToGeometry( pointGeom, vlayer );
mFixPointRubberBand->show();
delete pointGeom;
}
}
}
void QgsGrassRasterProvider::readBlock( int bandNo, int xBlock, int yBlock, void *block )
{
Q_UNUSED( xBlock );
QgsDebugMsg( "Entered" );
clearLastError();
// TODO: optimize, see extent()
QgsDebugMsg( "yBlock = " + QString::number( yBlock ) );
QStringList arguments;
arguments.append( "map=" + mMapName + "@" + mMapset );
QgsRectangle ext = extent();
// TODO: cut the last block
double cellHeight = ext.height() / mRows;
double yMaximum = ext.yMaximum() - cellHeight * yBlock * mYBlockSize;
double yMinimum = yMaximum - cellHeight * mYBlockSize;
QgsDebugMsg( "mYBlockSize = " + QString::number( mYBlockSize ) );
arguments.append(( QString( "window=%1,%2,%3,%4,%5,%6" )
.arg( QgsRasterBlock::printValue( ext.xMinimum() ),
QgsRasterBlock::printValue( yMinimum ),
QgsRasterBlock::printValue( ext.xMaximum() ),
QgsRasterBlock::printValue( yMaximum ) )
.arg( mCols ).arg( mYBlockSize ) ) );
arguments.append( "format=value" );
QString cmd = QgsApplication::libexecPath() + "grass/modules/qgis.d.rast";
QByteArray data;
try
{
data = QgsGrass::runModule( mGisdbase, mLocation, mMapset, cmd, arguments );
}
catch ( QgsGrass::Exception &e )
{
QString error = tr( "Cannot read raster" ) + " : " + e.what();
QgsDebugMsg( error );
appendError( error );
// We don't set mValid to false, because the raster can be recreated and work next time
}
QgsDebugMsg( QString( "%1 bytes read from modules stdout" ).arg( data.size() ) );
// byteCount() in Qt >= 4.6
//int size = image->byteCount() < data.size() ? image->byteCount() : data.size();
int size = mCols * mYBlockSize * dataTypeSize( bandNo );
QgsDebugMsg( QString( "mCols = %1 mYBlockSize = %2 dataTypeSize = %3" ).arg( mCols ).arg( mYBlockSize ).arg( dataTypeSize( bandNo ) ) );
if ( size != data.size() )
{
QString error = tr( "%1 bytes expected but %2 byte were read from qgis.d.rast" ).arg( size ).arg( data.size() );
QgsDebugMsg( error );
appendError( error );
size = size < data.size() ? size : data.size();
}
memcpy( block, data.data(), size );
}
void QgsMapToolLabel::createRubberBands( )
{
delete mLabelRubberBand;
delete mFeatureRubberBand;
//label rubber band
QgsRectangle rect = mCurrentLabelPos.labelRect;
mLabelRubberBand = new QgsRubberBand( mCanvas, QGis::Line );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMaximum(), rect.yMaximum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMaximum(), rect.yMinimum() ) );
mLabelRubberBand->addPoint( QgsPoint( rect.xMinimum(), rect.yMinimum() ) );
mLabelRubberBand->setColor( QColor( 0, 255, 0, 65 ) );
mLabelRubberBand->setWidth( 3 );
mLabelRubberBand->show();
//feature rubber band
QgsVectorLayer* vlayer = currentLayer();
if ( vlayer )
{
QgsFeature f;
if ( currentFeature( f, true ) )
{
QgsGeometry* geom = f.geometry();
if ( geom )
{
mFeatureRubberBand = new QgsRubberBand( mCanvas, geom->type() );
mFeatureRubberBand->setColor( QColor( 255, 0, 0, 65 ) );
mFeatureRubberBand->setToGeometry( geom, vlayer );
mFeatureRubberBand->show();
}
}
//fixpoint rubber band
QgsPoint fixPoint;
if ( rotationPoint( fixPoint, false, false ) )
{
if ( mCanvas )
{
const QgsMapSettings& s = mCanvas->mapSettings();
if ( s.hasCrsTransformEnabled() )
{
fixPoint = s.mapToLayerCoordinates( vlayer, fixPoint );
}
}
QgsGeometry* pointGeom = QgsGeometry::fromPoint( fixPoint );
mFixPointRubberBand = new QgsRubberBand( mCanvas, QGis::Line );
mFixPointRubberBand->setColor( QColor( 0, 0, 255, 65 ) );
mFixPointRubberBand->setToGeometry( pointGeom, vlayer );
mFixPointRubberBand->show();
delete pointGeom;
}
}
}
void QgsZonalStatistics::statisticsFromMiddlePointTest( const QgsGeometry &poly, int pixelOffsetX,
int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle &rasterBBox, FeatureStats &stats )
{
double cellCenterX, cellCenterY;
cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
stats.reset();
GEOSGeometry *polyGeos = poly.exportToGeos();
if ( !polyGeos )
{
return;
}
GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
const GEOSPreparedGeometry *polyGeosPrepared = GEOSPrepare_r( geosctxt, polyGeos );
if ( !polyGeosPrepared )
{
GEOSGeom_destroy_r( geosctxt, polyGeos );
return;
}
GEOSCoordSequence *cellCenterCoords = nullptr;
GEOSGeometry *currentCellCenter = nullptr;
QgsRectangle featureBBox = poly.boundingBox().intersect( &rasterBBox );
QgsRectangle intersectBBox = rasterBBox.intersect( &featureBBox );
QgsRasterBlock *block = mRasterProvider->block( mRasterBand, intersectBBox, nCellsX, nCellsY );
for ( int i = 0; i < nCellsY; ++i )
{
cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2;
for ( int j = 0; j < nCellsX; ++j )
{
if ( validPixel( block->value( i, j ) ) )
{
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
cellCenterCoords = GEOSCoordSeq_create_r( geosctxt, 1, 2 );
GEOSCoordSeq_setX_r( geosctxt, cellCenterCoords, 0, cellCenterX );
GEOSCoordSeq_setY_r( geosctxt, cellCenterCoords, 0, cellCenterY );
currentCellCenter = GEOSGeom_createPoint_r( geosctxt, cellCenterCoords );
if ( GEOSPreparedContains_r( geosctxt, polyGeosPrepared, currentCellCenter ) )
{
stats.addValue( block->value( i, j ) );
}
}
cellCenterX += cellSizeX;
}
cellCenterY -= cellSizeY;
}
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared );
GEOSGeom_destroy_r( geosctxt, polyGeos );
delete block;
}
double QgsCoordinateTransform::scaleFactor( const QgsRectangle &ReferenceExtent ) const
{
QgsPointXY source1( ReferenceExtent.xMinimum(), ReferenceExtent.yMinimum() );
QgsPointXY source2( ReferenceExtent.xMaximum(), ReferenceExtent.yMaximum() );
double distSourceUnits = std::sqrt( source1.sqrDist( source2 ) );
QgsPointXY dest1 = transform( source1 );
QgsPointXY dest2 = transform( source2 );
double distDestUnits = std::sqrt( dest1.sqrDist( dest2 ) );
return distDestUnits / distSourceUnits;
}
void QgsRasterCalcDialog::setExtentSize( int width, int height, QgsRectangle bbox )
{
mNColumnsSpinBox->setValue( width );
mNRowsSpinBox->setValue( height );
mXMinSpinBox->setValue( bbox.xMinimum() );
mXMaxSpinBox->setValue( bbox.xMaximum() );
mYMinSpinBox->setValue( bbox.yMinimum() );
mYMaxSpinBox->setValue( bbox.yMaximum() );
mExtentSizeSet = true;
}
QPolygonF canvasExtent( const QgsMapSettings &mapSettings )
{
QPolygonF poly;
QgsRectangle extent = mapSettings.visibleExtent();
poly << QPointF( extent.xMinimum(), extent.yMaximum() );
poly << QPointF( extent.xMaximum(), extent.yMaximum() );
poly << QPointF( extent.xMaximum(), extent.yMinimum() );
poly << QPointF( extent.xMinimum(), extent.yMinimum() );
return poly;
}
QPolygonF canvasExtent()
{
QPolygonF poly;
QgsRectangle extent = canvas().extent();
poly << QPointF( extent.xMinimum(), extent.yMaximum() );
poly << QPointF( extent.xMaximum(), extent.yMaximum() );
poly << QPointF( extent.xMaximum(), extent.yMinimum() );
poly << QPointF( extent.xMinimum(), extent.yMinimum() );
return poly;
}
void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeometry* poly, int pixelOffsetX,
int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle& rasterBBox, FeatureStats &stats )
{
double cellCenterX, cellCenterY;
float* scanLine = ( float * ) CPLMalloc( sizeof( float ) * nCellsX );
cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
stats.reset();
const GEOSGeometry* polyGeos = poly->asGeos();
if ( !polyGeos )
{
return;
}
GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, poly->asGeos() );
if ( !polyGeosPrepared )
{
return;
}
GEOSCoordSequence* cellCenterCoords = nullptr;
GEOSGeometry* currentCellCenter = nullptr;
for ( int i = 0; i < nCellsY; ++i )
{
if ( GDALRasterIO( band, GF_Read, pixelOffsetX, pixelOffsetY + i, nCellsX, 1, scanLine, nCellsX, 1, GDT_Float32, 0, 0 )
!= CPLE_None )
{
continue;
}
cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2;
for ( int j = 0; j < nCellsX; ++j )
{
if ( validPixel( scanLine[j] ) )
{
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
cellCenterCoords = GEOSCoordSeq_create_r( geosctxt, 1, 2 );
GEOSCoordSeq_setX_r( geosctxt, cellCenterCoords, 0, cellCenterX );
GEOSCoordSeq_setY_r( geosctxt, cellCenterCoords, 0, cellCenterY );
currentCellCenter = GEOSGeom_createPoint_r( geosctxt, cellCenterCoords );
if ( GEOSPreparedContains_r( geosctxt, polyGeosPrepared, currentCellCenter ) )
{
stats.addValue( scanLine[j] );
}
}
cellCenterX += cellSizeX;
}
cellCenterY -= cellSizeY;
}
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
CPLFree( scanLine );
GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared );
}
//! Generalize the WKB-geometry using the BBOX of the original geometry
static bool generalizeWkbGeometryByBoundingBox(
QGis::WkbType wkbType,
QgsConstWkbPtr sourceWkbPtr,
QgsWkbPtr targetWkbPtr,
int &targetWkbSize,
const QgsRectangle &envelope, bool writeHeader )
{
QgsWkbPtr savedTargetWkb( targetWkbPtr );
unsigned int geometryType = QGis::singleType( QGis::flatType( wkbType ) );
int skipZM = ( QGis::wkbDimensions( wkbType ) - 2 ) * sizeof( double );
Q_ASSERT( skipZM >= 0 );
// If the geometry is already minimal skip the generalization
int minimumSize = geometryType == QGis::WKBLineString ? 4 + 2 * ( 2 * sizeof( double ) + skipZM ) : 8 + 5 * ( 2 * sizeof( double ) + skipZM );
if ( writeHeader )
minimumSize += 5;
if ( sourceWkbPtr.remaining() <= minimumSize )
{
targetWkbSize = 0;
return false;
}
double x1 = envelope.xMinimum();
double y1 = envelope.yMinimum();
double x2 = envelope.xMaximum();
double y2 = envelope.yMaximum();
// Write the main header of the geometry
if ( writeHeader )
{
targetWkbPtr << ( char ) QgsApplication::endian() << geometryType;
if ( geometryType == QGis::WKBPolygon ) // numRings
{
targetWkbPtr << 1;
}
}
// Write the generalized geometry
if ( geometryType == QGis::WKBLineString )
{
targetWkbPtr << 2 << x1 << y1 << x2 << y2;
}
else
{
targetWkbPtr << 5 << x1 << y1 << x2 << y1 << x2 << y2 << x1 << y2 << x1 << y1;
}
targetWkbSize += targetWkbPtr - savedTargetWkb;
return true;
}
QString QgsWFSConnection::uriGetFeature( QString typeName, QString crsString, QString filter, QgsRectangle bBox ) const
{
//get CRS
if ( !crsString.isEmpty() )
{
crsString.prepend( "&SRSNAME=" );
}
QString filterString;
//if the xml comes from the dialog, it needs to be a string to pass the validity test
if ( filter.startsWith( "'" ) && filter.endsWith( "'" ) && filter.size() > 1 )
{
filter.chop( 1 );
filter.remove( 0, 1 );
}
if ( !filter.isEmpty() )
{
//test if filterString is already an OGC filter xml
QDomDocument filterDoc;
if ( !filterDoc.setContent( filter ) )
{
//if not, if must be a QGIS expression
QgsExpression filterExpression( filter );
if ( !filterExpression.toOGCFilter( filterDoc ) )
{
//error
}
}
filterString = "&FILTER=" + filterDoc.toString();
}
QString bBoxString;
if ( !bBox.isEmpty() )
{
bBoxString = QString( "&BBOX=%1,%2,%3,%4" )
.arg( bBox.xMinimum(), 0, 'f' )
.arg( bBox.yMinimum(), 0, 'f' )
.arg( bBox.xMaximum(), 0, 'f' )
.arg( bBox.yMaximum(), 0, 'f' );
}
QString uri = mUri;
if ( !( uri.contains( "?" ) ) )
{
uri.append( "?" );
}
//add a wfs layer to the map
uri += "SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=" + typeName + crsString + bBoxString + filterString;
QgsDebugMsg( uri );
return uri;
}
QString QgsPostgresFeatureIterator::whereClauseRect()
{
QgsRectangle rect = mRequest.filterRect();
if ( P->mSpatialColType == sctGeography )
{
rect = QgsRectangle( -180.0, -90.0, 180.0, 90.0 ).intersect( &rect );
if ( !rect.isFinite() )
return "false";
}
QString qBox;
if ( P->mConnectionRO->majorVersion() < 2 )
{
qBox = QString( "setsrid('BOX3D(%1)'::box3d,%2)" )
.arg( rect.asWktCoordinates() )
.arg( P->mRequestedSrid.isEmpty() ? P->mDetectedSrid : P->mRequestedSrid );
}
else
{
qBox = QString( "st_makeenvelope(%1,%2,%3,%4,%5)" )
.arg( qgsDoubleToString( rect.xMinimum() ) )
.arg( qgsDoubleToString( rect.yMinimum() ) )
.arg( qgsDoubleToString( rect.xMaximum() ) )
.arg( qgsDoubleToString( rect.yMaximum() ) )
.arg( P->mRequestedSrid.isEmpty() ? P->mDetectedSrid : P->mRequestedSrid );
}
QString whereClause = QString( "%1 && %2" )
.arg( P->quotedIdentifier( P->mGeometryColumn ) )
.arg( qBox );
if ( mRequest.flags() & QgsFeatureRequest::ExactIntersect )
{
whereClause += QString( " AND %1(%2%3,%4)" )
.arg( P->mConnectionRO->majorVersion() < 2 ? "intersects" : "st_intersects" )
.arg( P->quotedIdentifier( P->mGeometryColumn ) )
.arg( P->mSpatialColType == sctGeography ? "::geometry" : "" )
.arg( qBox );
}
if ( !P->mRequestedSrid.isEmpty() && ( P->mRequestedSrid != P->mDetectedSrid || P->mRequestedSrid.toInt() == 0 ) )
{
whereClause += QString( " AND %1(%2%3)=%4" )
.arg( P->mConnectionRO->majorVersion() < 2 ? "srid" : "st_srid" )
.arg( P->quotedIdentifier( P->mGeometryColumn ) )
.arg( P->mSpatialColType == sctGeography ? "::geography" : "" )
.arg( P->mRequestedSrid );
}
if ( P->mRequestedGeomType != QGis::WKBUnknown && P->mRequestedGeomType != P->mDetectedGeomType )
{
whereClause += QString( " AND %1" ).arg( QgsPostgresConn::postgisTypeFilter( P->mGeometryColumn, P->mRequestedGeomType, P->mSpatialColType == sctGeography ) );
}
return whereClause;
}
double QgsMapSettings::layerToMapUnits( QgsMapLayer *theLayer, const QgsRectangle& referenceExtent ) const
{
QgsRectangle extent = referenceExtent.isEmpty() ? theLayer->extent() : referenceExtent;
QgsPoint l1( extent.xMinimum(), extent.yMinimum() );
QgsPoint l2( extent.xMaximum(), extent.yMaximum() );
double distLayerUnits = std::sqrt( l1.sqrDist( l2 ) );
QgsPoint m1 = layerToMapCoordinates( theLayer, l1 );
QgsPoint m2 = layerToMapCoordinates( theLayer, l2 );
double distMapUnits = std::sqrt( m1.sqrDist( m2 ) );
return distMapUnits / distLayerUnits;
}
void QgsFlatTerrainGenerator::writeXml( QDomElement &elem ) const
{
QgsRectangle r = mExtent;
QDomElement elemExtent = elem.ownerDocument().createElement( "extent" );
elemExtent.setAttribute( "xmin", QString::number( r.xMinimum() ) );
elemExtent.setAttribute( "xmax", QString::number( r.xMaximum() ) );
elemExtent.setAttribute( "ymin", QString::number( r.yMinimum() ) );
elemExtent.setAttribute( "ymax", QString::number( r.yMaximum() ) );
// crs is not read/written - it should be the same as destination crs of the map
}
QgsAABB QgsTerrainGenerator::rootChunkBbox( const Qgs3DMapSettings &map ) const
{
QgsRectangle te = extent();
QgsCoordinateTransform terrainToMapTransform( crs(), map.crs() );
te = terrainToMapTransform.transformBoundingBox( te );
float hMin, hMax;
rootChunkHeightRange( hMin, hMax );
return QgsAABB( te.xMinimum() - map.originX(), hMin * map.terrainVerticalScale(), -te.yMaximum() + map.originY(),
te.xMaximum() - map.originX(), hMax * map.terrainVerticalScale(), -te.yMinimum() + map.originY() );
}
void QgsGrassNewMapset::setCurrentRegion()
{
QgsDebugMsg( "entered" );
QgsRectangle ext = mIface->mapCanvas()->extent();
QgsCoordinateReferenceSystem srs = mIface->mapCanvas()->mapSettings().destinationCrs();
QgsDebugMsg( "srs = " + srs.toWkt() );
std::vector<QgsPoint> points;
// TODO: this is not perfect
points.push_back( QgsPoint( ext.xMinimum(), ext.yMinimum() ) );
points.push_back( QgsPoint( ext.xMaximum(), ext.yMaximum() ) );
// TODO add a method, this code is copy-paste from setSelectedRegion
if ( srs.isValid() && mCrs.isValid()
&& srs.srsid() != mCrs.srsid() )
{
QgsCoordinateTransform trans( srs, mCrs );
bool ok = true;
for ( int i = 0; i < 2; i++ )
{
try
{
points[i] = trans.transform( points[i] );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsDebugMsg( "Cannot transform point" );
ok = false;
break;
}
}
if ( !ok )
{
QgsGrass::warning( tr( "Cannot reproject region" ) );
return;
}
}
mNorthLineEdit->setText( QString::number( points[1].y() ) );
mSouthLineEdit->setText( QString::number( points[0].y() ) );
mEastLineEdit->setText( QString::number( points[1].x() ) );
mWestLineEdit->setText( QString::number( points[0].x() ) );
mRegionModified = true;
checkRegion();
drawRegion();
QgsDebugMsg( "setCurrentRegion - End" );
}
void TestQgsCoordinateTransform::transformBoundingBox()
{
//test transforming a bounding box which crosses the 180 degree longitude line
QgsCoordinateReferenceSystem sourceSrs;
sourceSrs.createFromSrid( 3994 );
QgsCoordinateReferenceSystem destSrs;
destSrs.createFromSrid( 4326 );
QgsCoordinateTransform tr( sourceSrs, destSrs );
QgsRectangle crossingRect( 6374985, -3626584, 7021195, -3272435 );
QgsRectangle resultRect = tr.transformBoundingBox( crossingRect, QgsCoordinateTransform::ForwardTransform, true );
QgsRectangle expectedRect;
expectedRect.setXMinimum( 175.771 );
expectedRect.setYMinimum( -39.7222 );
expectedRect.setXMaximum( -176.549 );
expectedRect.setYMaximum( -36.3951 );
QVERIFY( qgsDoubleNear( resultRect.xMinimum(), expectedRect.xMinimum(), 0.001 ) );
QVERIFY( qgsDoubleNear( resultRect.yMinimum(), expectedRect.yMinimum(), 0.001 ) );
QVERIFY( qgsDoubleNear( resultRect.xMaximum(), expectedRect.xMaximum(), 0.001 ) );
QVERIFY( qgsDoubleNear( resultRect.yMaximum(), expectedRect.yMaximum(), 0.001 ) );
}
QgsRectangle QgsRasterChangeCoords::getBoundingBox( const QgsRectangle &rect, bool toPixel )
{
QgsRectangle rectReturn;
QgsPointXY p1( rect.xMinimum(), rect.yMinimum() );
QgsPointXY p2( rect.xMaximum(), rect.yMaximum() );
QgsPointXY( QgsRasterChangeCoords::* func )( const QgsPointXY & );
func = toPixel ? &QgsRasterChangeCoords::toColumnLine : &QgsRasterChangeCoords::toXY;
rectReturn.set( ( this->*func )( p1 ), ( this->*func )( p2 ) );
return rectReturn;
}
