QVariant QgsOgrUtils::getOgrFeatureAttribute( OGRFeatureH ogrFet, const QgsFields& fields, int attIndex, QTextCodec* encoding , bool* ok )
{
if ( !ogrFet || attIndex < 0 || attIndex >= fields.count() )
{
if ( ok )
*ok = false;
return QVariant();
}
OGRFieldDefnH fldDef = OGR_F_GetFieldDefnRef( ogrFet, attIndex );
if ( ! fldDef )
{
if ( ok )
*ok = false;
QgsDebugMsg( "ogrFet->GetFieldDefnRef(attindex) returns NULL" );
return QVariant();
}
QVariant value;
if ( ok )
*ok = true;
if ( OGR_F_IsFieldSet( ogrFet, attIndex ) )
{
switch ( fields.at( attIndex ).type() )
{
case QVariant::String:
{
if ( encoding )
value = QVariant( encoding->toUnicode( OGR_F_GetFieldAsString( ogrFet, attIndex ) ) );
else
value = QVariant( QString::fromUtf8( OGR_F_GetFieldAsString( ogrFet, attIndex ) ) );
break;
}
case QVariant::Int:
value = QVariant( OGR_F_GetFieldAsInteger( ogrFet, attIndex ) );
break;
#if defined(GDAL_VERSION_NUM) && GDAL_VERSION_NUM >= 2000000
case QVariant::LongLong:
value = QVariant( OGR_F_GetFieldAsInteger64( ogrFet, attIndex ) );
break;
#endif
case QVariant::Double:
value = QVariant( OGR_F_GetFieldAsDouble( ogrFet, attIndex ) );
break;
case QVariant::Date:
case QVariant::DateTime:
case QVariant::Time:
{
int year, month, day, hour, minute, second, tzf;
OGR_F_GetFieldAsDateTime( ogrFet, attIndex, &year, &month, &day, &hour, &minute, &second, &tzf );
if ( fields.at( attIndex ).type() == QVariant::Date )
value = QDate( year, month, day );
else if ( fields.at( attIndex ).type() == QVariant::Time )
value = QTime( hour, minute, second );
else
value = QDateTime( QDate( year, month, day ), QTime( hour, minute, second ) );
}
break;
default:
Q_ASSERT_X( false, "QgsOgrUtils::getOgrFeatureAttribute", "unsupported field type" );
if ( ok )
*ok = false;
}
}
else
{
value = QVariant( QString::null );
}
return value;
}
QgsVectorLayerExporter::ExportError QgsDb2Provider::createEmptyLayer( const QString &uri,
const QgsFields &fields,
QgsWkbTypes::Type wkbType,
const QgsCoordinateReferenceSystem &srs,
bool overwrite,
QMap<int, int> *oldToNewAttrIdxMap,
QString *errorMessage,
const QMap<QString, QVariant> *options )
{
Q_UNUSED( options );
// populate members from the uri structure
QgsDataSourceUri dsUri( uri );
QString connInfo = dsUri.connectionInfo();
QString errMsg;
QString srsName;
QgsDebugMsg( "uri: " + uri );
// connect to database
QSqlDatabase db = QgsDb2Provider::getDatabase( connInfo, errMsg );
if ( !errMsg.isEmpty() )
{
if ( errorMessage )
*errorMessage = errMsg;
return QgsVectorLayerExporter::ErrConnectionFailed;
}
// Get the SRS name using srid, needed to register the spatial column
// srs->posgisSrid() seems to return the authority id which is
// most often the EPSG id. Hopefully DB2 has defined an SRS using this
// value as the srid / srs_id. If not, we are out of luck.
QgsDebugMsg( "srs: " + srs.toWkt() );
long srid = srs.postgisSrid();
QgsDebugMsg( QString( "srid: %1" ).arg( srid ) );
if ( srid >= 0 )
{
QSqlQuery query( db );
QString statement = QStringLiteral( "SELECT srs_name FROM db2gse.st_spatial_reference_systems where srs_id=%1" )
.arg( srid );
QgsDebugMsg( statement );
if ( !query.exec( statement ) || !query.isActive() )
{
QgsDebugMsg( query.lastError().text() );
}
if ( query.next() )
{
srsName = query.value( 0 ).toString();
QgsDebugMsg( QString( "srs_name: %1" ).arg( srsName ) );
}
else
{
QgsDebugMsg( "Couldn't get srs_name from db2gse.st_spatial_reference_systems" );
}
}
QString schemaName = dsUri.schema().toUpper();
QString tableName = dsUri.table().toUpper();
QString fullName;
if ( schemaName.isEmpty() )
{
schemaName = dsUri.username().toUpper(); // set schema to user name
}
fullName = schemaName + "." + tableName;
QString geometryColumn = dsUri.geometryColumn().toUpper();
QString primaryKey = dsUri.keyColumn().toUpper();
QString primaryKeyType;
// TODO - this is a bad hack to cope with shapefiles.
// The wkbType from the shapefile header is usually a multi-type
// even if all the data is a single-type. If we create the column as
// a multi-type, the insert will fail if the actual data is a single-type
// due to type mismatch.
// We could potentially defer adding the spatial column until addFeatures is
// called the first time, but QgsVectorLayerExporter doesn't pass the CRS/srid
// information to the DB2 provider and we need this information to register
// the spatial column.
// This hack is problematic because the drag/drop will fail if the
// actual data is a multi-type which is possible with a shapefile or
// other data source.
QgsWkbTypes::Type wkbTypeSingle;
wkbTypeSingle = QgsWkbTypes::singleType( wkbType );
if ( wkbType != QgsWkbTypes::NoGeometry && geometryColumn.isEmpty() )
geometryColumn = QStringLiteral( "GEOM" );
if ( primaryKey.isEmpty() )
primaryKey = QStringLiteral( "QGS_FID" );
// get the pk's name and type
// if no pk name was passed, define the new pk field name
int fieldCount = fields.size();
if ( primaryKey.isEmpty() )
{
int index = 0;
QString pk = primaryKey = QStringLiteral( "QGS_FID" );
for ( int i = 0; i < fieldCount; ++i )
{
if ( fields.at( i ).name() == primaryKey )
{
// it already exists, try again with a new name
primaryKey = QStringLiteral( "%1_%2" ).arg( pk ).arg( index++ );
i = 0;
}
}
}
else
{
// search for the passed field
for ( int i = 0; i < fieldCount; ++i )
{
if ( fields.at( i ).name() == primaryKey )
{
// found, get the field type
QgsField fld = fields.at( i );
if ( convertField( fld ) )
{
primaryKeyType = fld.typeName();
}
}
}
}
QgsDebugMsg( "primaryKeyType: '" + primaryKeyType + "'" );
QString sql;
QSqlQuery q = QSqlQuery( db );
q.setForwardOnly( true );
// get wkb type and dimension
QString geometryType;
int dim = 2;
db2WkbTypeAndDimension( wkbTypeSingle, geometryType, dim );
QgsDebugMsg( QString( "wkbTypeSingle: %1; geometryType: %2" ).arg( wkbTypeSingle ).arg( geometryType ) );
if ( overwrite )
{
// remove the old table with the same name
sql = "DROP TABLE " + fullName;
if ( !q.exec( sql ) )
{
if ( q.lastError().number() != -206 ) // -206 is "not found" just ignore
{
QString lastError = q.lastError().text();
QgsDebugMsg( lastError );
if ( errorMessage )
{
*errorMessage = lastError;
}
return QgsVectorLayerExporter::ErrCreateLayer;
}
}
}
// add fields to the layer
if ( oldToNewAttrIdxMap )
oldToNewAttrIdxMap->clear();
QString attr2Create = QLatin1String( "" );
if ( fields.size() > 0 )
{
int offset = 0;
// get the list of fields
QgsDebugMsg( "PrimaryKey: '" + primaryKey + "'" );
for ( int i = 0; i < fieldCount; ++i )
{
QgsField fld = fields.field( i );
QgsDebugMsg( QString( "i: %1; fldIdx: %2; offset: %3" )
.arg( i ).arg( fields.lookupField( fld.name() ) ).arg( offset ) );
if ( oldToNewAttrIdxMap && fld.name() == primaryKey )
{
oldToNewAttrIdxMap->insert( i, 0 );
continue;
}
if ( fld.name() == geometryColumn )
{
// Found a field with the same name of the geometry column. Skip it!
continue;
}
QString db2Field = qgsFieldToDb2Field( fld );
if ( db2Field.isEmpty() )
{
if ( errorMessage )
{
*errorMessage = QObject::tr( "Unsupported type for field %1" ).arg( fld.name() );
}
return QgsVectorLayerExporter::ErrAttributeTypeUnsupported;
}
if ( oldToNewAttrIdxMap )
{
oldToNewAttrIdxMap->insert( fields.lookupField( fld.name() ), offset++ );
}
attr2Create += ',' + db2Field.toUpper();
}
QgsDebugMsg( attr2Create );
if ( !geometryColumn.isEmpty() )
{
sql = QString( // need to set specific geometry type
"CREATE TABLE %1(%2 BIGINT NOT NULL PRIMARY KEY GENERATED ALWAYS AS IDENTITY, "
"%3 DB2GSE.%4 %5) " )
.arg( fullName,
primaryKey,
geometryColumn,
geometryType,
attr2Create );
}
else
{
//geometryless table
sql = QStringLiteral( // need to set specific geometry type
"CREATE TABLE %1.%2(%3 INTEGER NOT NULL PRIMARY KEY GENERATED ALWAYS %4) " )
.arg( schemaName,
tableName,
primaryKey,
attr2Create );
}
QgsDebugMsg( sql );
if ( !q.exec( sql ) )
{
QString lastError = q.lastError().text();
QgsDebugMsg( lastError );
if ( errorMessage )
{
*errorMessage = lastError;
}
return QgsVectorLayerExporter::ErrCreateLayer;
}
if ( !geometryColumn.isEmpty() )
{
int computeExtents = 0;
int msgCode = 0;
int outCode;
int outMsg;
QVariant msgText( " " );
QSqlQuery query( db );
int db2Environment = ENV_LUW;
// get the environment
QgsDb2GeometryColumns gc( db );
int rc = gc.open( schemaName, tableName ); // returns SQLCODE if failure
if ( rc == 0 )
{
db2Environment = gc.db2Environment();
}
if ( ENV_LUW == db2Environment )
{
sql = QStringLiteral( "CALL DB2GSE.ST_Register_Spatial_Column(?, ?, ?, ?, ?, ?, ?)" );
outCode = 5;
outMsg = 6;
}
else // z/OS doesn't support 'computeExtents' parameter and has different schema
{
sql = QStringLiteral( "CALL SYSPROC.ST_Register_Spatial_Column(?, ?, ?, ?, ?, ?)" );
outCode = 4;
outMsg = 5;
}
query.prepare( sql );
query.bindValue( 0, schemaName );
query.bindValue( 1, tableName );
query.bindValue( 2, geometryColumn );
query.bindValue( 3, srsName );
if ( ENV_LUW == db2Environment )
{
query.bindValue( 4, computeExtents );
}
query.bindValue( outCode, msgCode, QSql::Out );
query.bindValue( outMsg, msgText, QSql::Out );
if ( !query.exec() )
{
QgsDebugMsg( QString( "error: %1; sql: %2" ).arg( query.lastError().text(), query.lastQuery() ) );
}
else
{
msgCode = query.boundValue( outCode ).toInt();
msgText = query.boundValue( outMsg ).toString(); // never gets a value...
if ( 0 != msgCode )
{
QgsDebugMsg( QString( "Register failed with code: %1; text: '%2'" ).arg( msgCode ).arg( msgText.toString() ) );
}
else
{
QgsDebugMsg( "Register successful" );
}
}
QList<QVariant> list = query.boundValues().values();
for ( int i = 0; i < list.size(); ++i )
{
QgsDebugMsg( QString( "i: %1; value: %2; type: %3" )
.arg( i ).arg( list.at( i ).toString().toLatin1().data(), list.at( i ).typeName() ) );
}
}
// clear any resources hold by the query
q.clear();
q.setForwardOnly( true );
}
QgsDebugMsg( "successfully created empty layer" );
return QgsVectorLayerExporter::NoError;
}
QgsVectorLayerImport::ImportError
QgsVectorLayerImport::importLayer( QgsVectorLayer* layer,
const QString& uri,
const QString& providerKey,
const QgsCoordinateReferenceSystem *destCRS,
bool onlySelected,
QString *errorMessage,
bool skipAttributeCreation,
QMap<QString, QVariant> *options,
QProgressDialog *progress )
{
const QgsCoordinateReferenceSystem* outputCRS;
QgsCoordinateTransform* ct = 0;
int shallTransform = false;
if ( layer == NULL )
{
return ErrInvalidLayer;
}
if ( destCRS && destCRS->isValid() )
{
// This means we should transform
outputCRS = destCRS;
shallTransform = true;
}
else
{
// This means we shouldn't transform, use source CRS as output (if defined)
outputCRS = &layer->crs();
}
bool overwrite = false;
bool forceSinglePartGeom = false;
if ( options )
{
overwrite = options->take( "overwrite" ).toBool();
forceSinglePartGeom = options->take( "forceSinglePartGeometryType" ).toBool();
}
QgsFields fields = skipAttributeCreation ? QgsFields() : layer->fields();
QGis::WkbType wkbType = layer->wkbType();
// Special handling for Shapefiles
if ( layer->providerType() == "ogr" && layer->storageType() == "ESRI Shapefile" )
{
// convert field names to lowercase
for ( int fldIdx = 0; fldIdx < fields.count(); ++fldIdx )
{
fields[fldIdx].setName( fields[fldIdx].name().toLower() );
}
if ( !forceSinglePartGeom )
{
// convert wkbtype to multipart (see #5547)
switch ( wkbType )
{
case QGis::WKBPoint:
wkbType = QGis::WKBMultiPoint;
break;
case QGis::WKBLineString:
wkbType = QGis::WKBMultiLineString;
break;
case QGis::WKBPolygon:
wkbType = QGis::WKBMultiPolygon;
break;
case QGis::WKBPoint25D:
wkbType = QGis::WKBMultiPoint25D;
break;
case QGis::WKBLineString25D:
wkbType = QGis::WKBMultiLineString25D;
break;
case QGis::WKBPolygon25D:
wkbType = QGis::WKBMultiPolygon25D;
break;
default:
break;
}
}
}
QgsVectorLayerImport * writer =
new QgsVectorLayerImport( uri, providerKey, fields, wkbType, outputCRS, overwrite, options, progress );
// check whether file creation was successful
ImportError err = writer->hasError();
if ( err != NoError )
{
if ( errorMessage )
*errorMessage = writer->errorMessage();
delete writer;
return err;
}
if ( errorMessage )
{
errorMessage->clear();
}
QgsAttributeList allAttr = skipAttributeCreation ? QgsAttributeList() : layer->attributeList();
QgsFeature fet;
QgsFeatureRequest req;
if ( wkbType == QGis::WKBNoGeometry )
req.setFlags( QgsFeatureRequest::NoGeometry );
if ( skipAttributeCreation )
req.setSubsetOfAttributes( QgsAttributeList() );
QgsFeatureIterator fit = layer->getFeatures( req );
const QgsFeatureIds& ids = layer->selectedFeaturesIds();
// Create our transform
if ( destCRS )
{
ct = new QgsCoordinateTransform( layer->crs(), *destCRS );
}
// Check for failure
if ( ct == NULL )
{
shallTransform = false;
}
int n = 0;
if ( errorMessage )
{
*errorMessage = QObject::tr( "Feature write errors:" );
}
if ( progress )
{
progress->setRange( 0, layer->featureCount() );
}
// write all features
while ( fit.nextFeature( fet ) )
{
if ( progress && progress->wasCanceled() )
{
if ( errorMessage )
{
*errorMessage += "\n" + QObject::tr( "Import was canceled at %1 of %2" ).arg( progress->value() ).arg( progress->maximum() );
}
break;
}
if ( writer->errorCount() > 1000 )
{
if ( errorMessage )
{
*errorMessage += "\n" + QObject::tr( "Stopping after %1 errors" ).arg( writer->errorCount() );
}
break;
}
if ( onlySelected && !ids.contains( fet.id() ) )
continue;
if ( shallTransform )
{
try
{
if ( fet.geometry() )
{
fet.geometry()->transform( *ct );
}
}
catch ( QgsCsException &e )
{
delete ct;
delete writer;
QString msg = QObject::tr( "Failed to transform a point while drawing a feature with ID '%1'. Writing stopped. (Exception: %2)" )
.arg( fet.id() ).arg( e.what() );
QgsMessageLog::logMessage( msg, QObject::tr( "Vector import" ) );
if ( errorMessage )
*errorMessage += "\n" + msg;
return ErrProjection;
}
}
if ( skipAttributeCreation )
{
fet.initAttributes( 0 );
}
if ( !writer->addFeature( fet ) )
{
if ( writer->hasError() && errorMessage )
{
*errorMessage += "\n" + writer->errorMessage();
}
}
n++;
if ( progress )
{
progress->setValue( n );
}
}
// flush the buffer to be sure that all features are written
if ( !writer->flushBuffer() )
{
if ( writer->hasError() && errorMessage )
{
*errorMessage += "\n" + writer->errorMessage();
}
}
int errors = writer->errorCount();
if ( !writer->createSpatialIndex() )
{
if ( writer->hasError() && errorMessage )
{
*errorMessage += "\n" + writer->errorMessage();
}
}
delete writer;
if ( shallTransform )
{
delete ct;
}
if ( errorMessage )
{
if ( errors > 0 )
{
*errorMessage += "\n" + QObject::tr( "Only %1 of %2 features written." ).arg( n - errors ).arg( n );
}
else
{
errorMessage->clear();
}
}
return errors == 0 ? NoError : ErrFeatureWriteFailed;
}
/**
* Display the attrbiutes for the current feature and load the image
*/
void eVisGenericEventBrowserGui::loadRecord()
{
treeEventData->clear();
//Get a pointer to the current feature
QgsFeature* myFeature;
myFeature = featureAtId( mFeatureIds.at( mCurrentFeatureIndex ) );
if ( !myFeature )
return;
QString myCompassBearingField = cboxCompassBearingField->currentText();
QString myCompassOffsetField = cboxCompassOffsetField->currentText();
QString myEventImagePathField = cboxEventImagePathField->currentText();
QgsFields myFields = mDataProvider->fields();
QgsAttributes myAttrs = myFeature->attributes();
//loop through the attributes and display their contents
for ( int i = 0; i < myAttrs.count(); ++i )
{
QStringList myValues;
QString fieldName = myFields.at( i ).name();
myValues << fieldName << myAttrs.at( i ).toString();
QTreeWidgetItem* myItem = new QTreeWidgetItem( myValues );
if ( fieldName == myEventImagePathField )
{
mEventImagePath = myAttrs.at( i ).toString();
}
if ( fieldName == myCompassBearingField )
{
mCompassBearing = myAttrs.at( i ).toDouble();
}
if ( mConfiguration.isAttributeCompassOffsetSet() )
{
if ( fieldName == myCompassOffsetField )
{
mCompassOffset = myAttrs.at( i ).toDouble();
}
}
else
{
mCompassOffset = 0.0;
}
//Check to see if the attribute is a know file type
int myIterator = 0;
while ( myIterator < tableFileTypeAssociations->rowCount() )
{
if ( tableFileTypeAssociations->item( myIterator, 0 ) && ( myAttrs.at( i ).toString().startsWith( tableFileTypeAssociations->item( myIterator, 0 )->text() + ':', Qt::CaseInsensitive ) || myAttrs.at( i ).toString().endsWith( tableFileTypeAssociations->item( myIterator, 0 )->text(), Qt::CaseInsensitive ) ) )
{
myItem->setBackground( 1, QBrush( QColor( 183, 216, 125, 255 ) ) );
break;
}
else
myIterator++;
}
treeEventData->addTopLevelItem( myItem );
}
//Modify EventImagePath as needed
buildEventImagePath();
//Request the image to be displayed in the browser
displayImage();
}
/**
* This method is an extension of the constructor. It was implemented to reduce the amount of code duplicated between the constructors.
*/
bool eVisGenericEventBrowserGui::initBrowser()
{
//setup gui
setWindowTitle( tr( "Generic Event Browser" ) );
connect( treeEventData, SIGNAL( itemDoubleClicked( QTreeWidgetItem *, int ) ), this, SLOT( launchExternalApplication( QTreeWidgetItem *, int ) ) );
mHighlightSymbol.load( QStringLiteral( ":/evis/eVisHighlightSymbol.png" ) );
mPointerSymbol.load( QStringLiteral( ":/evis/eVisPointerSymbol.png" ) );
mCompassOffset = 0.0;
//Flag to let us know if the browser fully loaded
mBrowserInitialized = false;
//Initialize some class variables
mDefaultEventImagePathField = 0;
mDefaultCompassBearingField = 0;
mDefaultCompassOffsetField = 0;
//initialize Display tab GUI elements
pbtnNext->setEnabled( false );
pbtnPrevious->setEnabled( false );
//Set up Attribute display
treeEventData->setColumnCount( 2 );
QStringList treeHeaders;
treeHeaders << tr( "Field" ) << tr( "Value" );
treeEventData->setHeaderLabels( treeHeaders );
//Initialize Options tab GUI elements
cboxEventImagePathField->setEnabled( true );
chkboxEventImagePathRelative->setChecked( false );
chkboxDisplayCompassBearing->setChecked( false );
cboxCompassBearingField->setEnabled( true );
rbtnManualCompassOffset->setChecked( false );
dsboxCompassOffset->setEnabled( true );
dsboxCompassOffset->setValue( 0.0 );
rbtnAttributeCompassOffset->setChecked( false );
cboxCompassOffsetField->setEnabled( true );
chkboxUseOnlyFilename->setChecked( false );
QString myThemePath = QgsApplication::activeThemePath();
pbtnResetEventImagePathData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetCompassBearingData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetCompassOffsetData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetBasePathData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetUseOnlyFilenameData->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
pbtnResetApplyPathRulesToDocs->setIcon( QIcon( QPixmap( myThemePath + "/mActionDraw.svg" ) ) );
chkboxSaveEventImagePathData->setChecked( false );
chkboxSaveCompassBearingData->setChecked( false );
chkboxSaveCompassOffsetData->setChecked( false );
chkboxSaveBasePathData->setChecked( false );
chkboxSaveUseOnlyFilenameData->setChecked( false );
//Set up Configure External Application buttons
pbtnAddFileType->setIcon( QIcon( QPixmap( myThemePath + "/mActionNewAttribute.svg" ) ) );
pbtnDeleteFileType->setIcon( QIcon( QPixmap( myThemePath + "/mActionDeleteAttribute.svg" ) ) );
//Check to for interface, not null when launched from plugin toolbar, otherwise expect map canvas
if ( mInterface )
{
//check for active layer
if ( mInterface->activeLayer() )
{
//verify that the active layer is a vector layer
if ( QgsMapLayer::VectorLayer == mInterface->activeLayer()->type() )
{
mVectorLayer = ( QgsVectorLayer* )mInterface->activeLayer();
mCanvas = mInterface->mapCanvas();
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "This tool only supports vector data" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "No active layers found" ) );
return false;
}
}
//check for map canvas, if map canvas is null, throw error
else if ( mCanvas )
{
//check for active layer
if ( mCanvas->currentLayer() )
{
//verify that the active layer is a vector layer
if ( QgsMapLayer::VectorLayer == mCanvas->currentLayer()->type() )
{
mVectorLayer = ( QgsVectorLayer* )mCanvas->currentLayer();
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "This tool only supports vector data" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Warning" ), tr( "No active layers found" ) );
return false;
}
}
else
{
QMessageBox::warning( this, tr( "Error" ), tr( "Unable to connect to either the map canvas or application interface" ) );
return false;
}
//Connect rendering routine for highlighting symbols and load symbols
connect( mCanvas, SIGNAL( renderComplete( QPainter * ) ), this, SLOT( renderSymbol( QPainter * ) ) );
mDataProvider = mVectorLayer->dataProvider();
/*
* A list of the selected feature ids is made so that we can move forward and backward through
* the list. The data providers only have the ability to get one feature at a time or
* sequentially move forward through the selected features
*/
if ( 0 == mVectorLayer->selectedFeatureCount() ) //if nothing is selected select everything
{
mVectorLayer->invertSelection();
mFeatureIds = mVectorLayer->selectedFeatureIds().toList();
}
else //use selected features
{
mFeatureIds = mVectorLayer->selectedFeatureIds().toList();
}
if ( 0 == mFeatureIds.size() )
return false;
//get the first feature in the list so we can set the field in the pulldown menues
QgsFeature* myFeature = featureAtId( mFeatureIds.at( mCurrentFeatureIndex ) );
if ( !myFeature )
{
QMessageBox::warning( this, tr( "Error" ), tr( "An invalid feature was received during initialization" ) );
return false;
}
QgsFields myFields = mDataProvider->fields();
mIgnoreEvent = true; //Ignore indexChanged event when adding items to combo boxes
for ( int x = 0; x < myFields.count(); x++ )
{
QString name = myFields.at( x ).name();
cboxEventImagePathField->addItem( name );
cboxCompassBearingField->addItem( name );
cboxCompassOffsetField->addItem( name );
if ( myFeature->attribute( x ).toString().contains( QRegExp( "(jpg|jpeg|tif|tiff|gif)", Qt::CaseInsensitive ) ) )
{
mDefaultEventImagePathField = x;
}
if ( name.contains( QRegExp( "(comp|bear)", Qt::CaseInsensitive ) ) )
{
mDefaultCompassBearingField = x;
}
if ( name.contains( QRegExp( "(offset|declination)", Qt::CaseInsensitive ) ) )
{
mDefaultCompassOffsetField = x;
}
}
mIgnoreEvent = false;
//Set Display tab gui items
if ( mFeatureIds.size() > 1 )
{
pbtnNext->setEnabled( true );
}
setWindowTitle( tr( "Event Browser - Displaying records 01 of %1" ).arg( mFeatureIds.size(), 2, 10, QChar( '0' ) ) );
//Set Options tab gui items
initOptionsTab();
//Load file associations into Configure External Applications tab gui items
QSettings myQSettings;
myQSettings.beginWriteArray( QStringLiteral( "/eVis/filetypeassociations" ) );
int myTotalAssociations = myQSettings.childGroups().count();
int myIterator = 0;
while ( myIterator < myTotalAssociations )
{
myQSettings.setArrayIndex( myIterator );
tableFileTypeAssociations->insertRow( tableFileTypeAssociations->rowCount() );
tableFileTypeAssociations->setItem( myIterator, 0, new QTableWidgetItem( myQSettings.value( QStringLiteral( "extension" ), "" ).toString() ) );
tableFileTypeAssociations->setItem( myIterator, 1, new QTableWidgetItem( myQSettings.value( QStringLiteral( "application" ), "" ).toString() ) );
myIterator++;
}
myQSettings.endArray();
mBrowserInitialized = true;
return true;
}
bool QgsGeometryAnalyzer::convexHull( QgsVectorLayer* layer, const QString& shapefileName,
bool onlySelectedFeatures, int uniqueIdField, QProgressDialog* p )
{
if ( !layer )
{
return false;
}
QgsVectorDataProvider* dp = layer->dataProvider();
if ( !dp )
{
return false;
}
bool useField = false;
if ( uniqueIdField == -1 )
{
uniqueIdField = 0;
}
else
{
useField = true;
}
QgsFields fields;
fields.append( QgsField( QString( "UID" ), QVariant::String ) );
fields.append( QgsField( QString( "AREA" ), QVariant::Double ) );
fields.append( QgsField( QString( "PERIM" ), QVariant::Double ) );
QGis::WkbType outputType = QGis::WKBPolygon;
QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), fields, outputType, &crs );
QgsFeature currentFeature;
QgsGeometry* dissolveGeometry = nullptr; //dissolve geometry
QMultiMap<QString, QgsFeatureId> map;
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
QgsFeatureIds::const_iterator it = selection.constBegin();
for ( ; it != selection.constEnd(); ++it )
{
#if 0
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
// break; // it may be better to do something else here?
return false;
}
#endif
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( *it ) ).nextFeature( currentFeature ) )
{
continue;
}
map.insert( currentFeature.attribute( uniqueIdField ).toString(), currentFeature.id() );
}
}
else
{
QgsFeatureIterator fit = layer->getFeatures();
while ( fit.nextFeature( currentFeature ) )
{
#if 0
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
// break; // it may be better to do something else here?
return false;
}
#endif
map.insert( currentFeature.attribute( uniqueIdField ).toString(), currentFeature.id() );
}
}
QMultiMap<QString, QgsFeatureId>::const_iterator jt = map.constBegin();
while ( jt != map.constEnd() )
{
QString currentKey = jt.key();
int processedFeatures = 0;
//take only selection
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selection.size() );
}
processedFeatures = 0;
while ( jt != map.constEnd() && ( jt.key() == currentKey || !useField ) )
{
if ( p && p->wasCanceled() )
{
break;
}
if ( selection.contains( jt.value() ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( jt.value() ) ).nextFeature( currentFeature ) )
{
continue;
}
convexFeature( currentFeature, processedFeatures, &dissolveGeometry );
++processedFeatures;
}
++jt;
}
QList<double> values;
if ( !dissolveGeometry )
{
QgsDebugMsg( "no dissolved geometry - should not happen" );
return false;
}
dissolveGeometry = dissolveGeometry->convexHull();
values = simpleMeasure( dissolveGeometry );
QgsAttributes attributes( 3 );
attributes[0] = QVariant( currentKey );
attributes[1] = values.at( 0 );
attributes[2] = values.at( 1 );
QgsFeature dissolveFeature;
dissolveFeature.setAttributes( attributes );
dissolveFeature.setGeometry( dissolveGeometry );
vWriter.addFeature( dissolveFeature );
}
//take all features
else
{
int featureCount = layer->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
processedFeatures = 0;
while ( jt != map.constEnd() && ( jt.key() == currentKey || !useField ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( jt.value() ) ).nextFeature( currentFeature ) )
{
continue;
}
convexFeature( currentFeature, processedFeatures, &dissolveGeometry );
++processedFeatures;
++jt;
}
QList<double> values;
// QgsGeometry* tmpGeometry = 0;
if ( !dissolveGeometry )
{
QgsDebugMsg( "no dissolved geometry - should not happen" );
return false;
}
dissolveGeometry = dissolveGeometry->convexHull();
// values = simpleMeasure( tmpGeometry );
values = simpleMeasure( dissolveGeometry );
QgsAttributes attributes;
attributes[0] = QVariant( currentKey );
attributes[1] = QVariant( values[ 0 ] );
attributes[2] = QVariant( values[ 1 ] );
QgsFeature dissolveFeature;
dissolveFeature.setAttributes( attributes );
dissolveFeature.setGeometry( dissolveGeometry );
vWriter.addFeature( dissolveFeature );
}
}
return true;
}
bool QgsGeometryAnalyzer::extent( QgsVectorLayer* layer,
const QString& shapefileName,
bool onlySelectedFeatures,
QProgressDialog * )
{
if ( !layer )
{
return false;
}
QgsVectorDataProvider* dp = layer->dataProvider();
if ( !dp )
{
return false;
}
QGis::WkbType outputType = QGis::WKBPolygon;
QgsCoordinateReferenceSystem crs = layer->crs();
QgsFields fields;
fields.append( QgsField( QString( "MINX" ), QVariant::Double ) );
fields.append( QgsField( QString( "MINY" ), QVariant::Double ) );
fields.append( QgsField( QString( "MAXX" ), QVariant::Double ) );
fields.append( QgsField( QString( "MAXY" ), QVariant::Double ) );
fields.append( QgsField( QString( "CNTX" ), QVariant::Double ) );
fields.append( QgsField( QString( "CNTY" ), QVariant::Double ) );
fields.append( QgsField( QString( "AREA" ), QVariant::Double ) );
fields.append( QgsField( QString( "PERIM" ), QVariant::Double ) );
fields.append( QgsField( QString( "HEIGHT" ), QVariant::Double ) );
fields.append( QgsField( QString( "WIDTH" ), QVariant::Double ) );
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), fields, outputType, &crs );
QgsRectangle rect;
if ( onlySelectedFeatures ) // take only selection
{
rect = layer->boundingBoxOfSelected();
}
else
{
rect = layer->extent();
}
double minx = rect.xMinimum();
double miny = rect.yMinimum();
double maxx = rect.xMaximum();
double maxy = rect.yMaximum();
double height = rect.height();
double width = rect.width();
double cntx = minx + ( width / 2.0 );
double cnty = miny + ( height / 2.0 );
double area = width * height;
double perim = ( 2 * width ) + ( 2 * height );
QgsFeature feat;
QgsAttributes attrs( 10 );
attrs[0] = QVariant( minx );
attrs[1] = QVariant( miny );
attrs[2] = QVariant( maxx );
attrs[3] = QVariant( maxy );
attrs[4] = QVariant( cntx );
attrs[5] = QVariant( cnty );
attrs[6] = QVariant( area );
attrs[7] = QVariant( perim );
attrs[8] = QVariant( height );
attrs[9] = QVariant( width );
feat.setAttributes( attrs );
feat.setGeometry( QgsGeometry::fromRect( rect ) );
vWriter.addFeature( feat );
return true;
}
