void ChecksumTests::TestCheckFileChecksum() {
gRepository.SetSettings("sqlite3", "database=:memory:");
gRepository.Connect();
gRepository.PopulateDatabase();
Q_INIT_RESOURCE(server_resources); // Use resources from diffrent project
QImage vAddedImage {QImage(":/sample_photo.jpg", "JPG")};
// Part adding image
QBuffer vBufferToStoreData;
QImageWriter vWriter(&vBufferToStoreData, "JPG");
vWriter.write(vAddedImage);
QByteArray vAddedData {vBufferToStoreData.data()};
uint16_t vChecksumAddImage = CalculateChecksumHelper::CalculateFileDataChecksum(
vAddedData);
CStorePhotoTransaction vStoreTransaction(
vAddedData, vAddedData.size(), vChecksumAddImage);
vStoreTransaction.Execute();
CChecksumList *vChecksumList {gRepository.GetChecksumList()};
QVERIFY(vChecksumList->CheckFileChecksum(vChecksumAddImage));
}
QByteArray CChecksumList::ConvertImageToByteArray(QImage aImage) {
QBuffer vBuffer;
QImageWriter vWriter(&vBuffer, "JPG");
vWriter.write(aImage); // unikniecie vWriter.write(*(*vIterator));
return vBuffer.data();
}
void MainWindow::on_pushButton_2_clicked() {
QImage vImage = QImage ("/home/mmichniewski/b.jpeg", "JPEG");
QBuffer vBuffer;
QImageWriter vWriter(&vBuffer, "JPEG");
vWriter.write(vImage);
QByteArray vData = vBuffer.data();
int v = CalculateFileDataChecksum(vData);
qDebug() << "suma->" << v;
vClient->WriteData(vData);
}
void StorePhotoTests::TestStorePhoto() {
gRepository.SetSettings("sqlite3",
"database=:memory:"); // dzięki temu, że w pamięci testy można w jenkinsie
gRepository.Connect();
gRepository.PopulateDatabase();
Q_INIT_RESOURCE(server_resources); // Use resources from diffrent project
QImage vAddedImage {QImage(":/sample_photo.jpg", "JPG")};
// Part adding image
QBuffer vBufferToStoreData;
QImageWriter vWriter(&vBufferToStoreData, "JPG");
vWriter.write(vAddedImage);
QByteArray vAddedData = vBufferToStoreData.data();
int16_t vChecksumAddImage = CalculateFileDataChecksumHelper(vAddedData);
CStorePhotoTransaction vStoreTransaction(
vAddedData, vAddedData.size(), vChecksumAddImage);
vStoreTransaction.Execute();
CRetrievePhotoTransaction vRetrieveTransaction(vChecksumAddImage);
vRetrieveTransaction.Execute();
QByteArray vRetrievedData = vRetrieveTransaction.GetData();
QCOMPARE(vAddedData, vRetrievedData);
// Convert array of bytes to image
QBuffer vBufferRetrieveData(&vRetrievedData);
vBufferRetrieveData.open(QIODevice::ReadOnly);
QImageReader vReader(&vBufferRetrieveData, "JPG");
QImage vRetrievedImage = vReader.read();
QCOMPARE(vAddedImage.size(), vRetrievedImage.size());
QCOMPARE(vAddedImage.format(), vRetrievedImage.format());
int16_t vChecksumRetrievedImage =
CalculateFileDataChecksumHelper(vRetrievedData);
QCOMPARE(vChecksumAddImage, vChecksumRetrievedImage);
// QVERIFY(vImage2.operator==(vImage)); // porównanie qimage w tym przypadku różne
// Pixel compare: różne 4281016857 != 4281016597
}
bool QgsOverlayAnalyzer::intersection( QgsVectorLayer* layerA, QgsVectorLayer* layerB,
const QString& shapefileName, bool onlySelectedFeatures,
QProgressDialog* p )
{
if ( !layerA && !layerB )
{
return false;
}
QgsVectorDataProvider* dpA = layerA->dataProvider();
QgsVectorDataProvider* dpB = layerB->dataProvider();
if ( !dpA && !dpB )
{
return false;
}
QGis::WkbType outputType = dpA->geometryType();
const QgsCoordinateReferenceSystem crs = layerA->srs();
QgsFieldMap fieldsA = dpA->fields();
QgsFieldMap fieldsB = dpB->fields();
combineFieldLists( fieldsA, fieldsB );
QgsVectorFileWriter vWriter( shapefileName, dpA->encoding(), fieldsA, outputType, &crs );
QgsFeature currentFeature;
QgsSpatialIndex index;
//take only selection
if ( onlySelectedFeatures )
{
const QgsFeatureIds selectionB = layerB->selectedFeaturesIds();
QgsFeatureIds::const_iterator it = selectionB.constBegin();
for ( ; it != selectionB.constEnd(); ++it )
{
if ( !layerB->featureAtId( *it, currentFeature, true, true ) )
{
continue;
}
index.insertFeature( currentFeature );
}
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selectionA = layerA->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selectionA.size() );
}
QgsFeature currentFeature;
int processedFeatures = 0;
it = selectionA.constBegin();
for ( ; it != selectionA.constEnd(); ++it )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !layerA->featureAtId( *it, currentFeature, true, true ) )
{
continue;
}
intersectFeature( currentFeature, &vWriter, layerB, &index );
++processedFeatures;
}
if ( p )
{
p->setValue( selectionA.size() );
}
}
//take all features
else
{
layerB->select( layerB->pendingAllAttributesList(), QgsRectangle(), true, false );
while ( layerB->nextFeature( currentFeature ) )
{
index.insertFeature( currentFeature );
}
QgsFeature currentFeature;
layerA->select( layerA->pendingAllAttributesList(), QgsRectangle(), true, false );
int featureCount = layerA->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
int processedFeatures = 0;
while ( layerA->nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
intersectFeature( currentFeature, &vWriter, layerB, &index );
++processedFeatures;
}
if ( p )
{
p->setValue( featureCount );
}
}
return true;
}
bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefileName, double bufferDistance,
bool onlySelectedFeatures, bool dissolve, int bufferDistanceField, QProgressDialog* p )
{
if ( !layer )
{
return false;
}
QgsVectorDataProvider* dp = layer->dataProvider();
if ( !dp )
{
return false;
}
QgsWkbTypes::Type outputType = QgsWkbTypes::Polygon;
if ( dissolve )
{
outputType = QgsWkbTypes::MultiPolygon;
}
QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->fields(), outputType, crs );
QgsFeature currentFeature;
QgsGeometry dissolveGeometry; //dissolve geometry (if dissolve enabled)
//take only selection
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selection.size() );
}
int processedFeatures = 0;
QgsFeatureIds::const_iterator it = selection.constBegin();
for ( ; it != selection.constEnd(); ++it )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( *it ) ).nextFeature( currentFeature ) )
{
continue;
}
bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );
++processedFeatures;
}
if ( p )
{
p->setValue( selection.size() );
}
}
//take all features
else
{
QgsFeatureIterator fit = layer->getFeatures();
int featureCount = layer->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
int processedFeatures = 0;
while ( fit.nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );
++processedFeatures;
}
if ( p )
{
p->setValue( featureCount );
}
}
if ( dissolve )
{
QgsFeature dissolveFeature;
if ( dissolveGeometry.isEmpty() )
{
QgsDebugMsg( "no dissolved geometry - should not happen" );
return false;
}
dissolveFeature.setGeometry( dissolveGeometry );
vWriter.addFeature( dissolveFeature );
}
return true;
}
bool QgsGeometryAnalyzer::dissolve( 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;
}
QgsWkbTypes::Type outputType = dp->wkbType();
QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->fields(), outputType, crs );
QgsFeature currentFeature;
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 ( !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 ) )
{
map.insert( currentFeature.attribute( uniqueIdField ).toString(), currentFeature.id() );
}
}
QgsGeometry dissolveGeometry; //dissolve geometry
QMultiMap<QString, QgsFeatureId>::const_iterator jt = map.constBegin();
QgsFeature outputFeature;
while ( jt != map.constEnd() )
{
QString currentKey = jt.key();
int processedFeatures = 0;
bool first = true;
//take only selection
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selection.size() );
}
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;
}
if ( first )
{
outputFeature.setAttributes( currentFeature.attributes() );
first = false;
}
dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );
++processedFeatures;
}
++jt;
}
}
//take all features
else
{
int featureCount = layer->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
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;
}
{
outputFeature.setAttributes( currentFeature.attributes() );
first = false;
}
dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );
++processedFeatures;
++jt;
}
}
outputFeature.setGeometry( dissolveGeometry );
vWriter.addFeature( outputFeature );
}
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( QStringLiteral( "UID" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "AREA" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "PERIM" ), QVariant::Double ) );
QgsWkbTypes::Type outputType = QgsWkbTypes::Polygon;
QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), fields, outputType, crs );
QgsFeature currentFeature;
QgsGeometry dissolveGeometry; //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.isEmpty() )
{
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;
if ( dissolveGeometry.isEmpty() )
{
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::simplify( QgsVectorLayer* layer,
const QString& shapefileName,
double tolerance,
bool onlySelectedFeatures,
QProgressDialog *p )
{
if ( !layer )
{
return false;
}
QgsVectorDataProvider* dp = layer->dataProvider();
if ( !dp )
{
return false;
}
QgsWkbTypes::Type outputType = dp->wkbType();
QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->fields(), outputType, crs );
QgsFeature currentFeature;
//take only selection
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selection.size() );
}
int processedFeatures = 0;
QgsFeatureIds::const_iterator it = selection.constBegin();
for ( ; it != selection.constEnd(); ++it )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( *it ) ).nextFeature( currentFeature ) )
{
continue;
}
simplifyFeature( currentFeature, &vWriter, tolerance );
++processedFeatures;
}
if ( p )
{
p->setValue( selection.size() );
}
}
//take all features
else
{
QgsFeatureIterator fit = layer->getFeatures();
int featureCount = layer->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
int processedFeatures = 0;
while ( fit.nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
simplifyFeature( currentFeature, &vWriter, tolerance );
++processedFeatures;
}
if ( p )
{
p->setValue( featureCount );
}
}
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;
}
QgsWkbTypes::Type outputType = QgsWkbTypes::Polygon;
QgsCoordinateReferenceSystem crs = layer->crs();
QgsFields fields;
fields.append( QgsField( QStringLiteral( "MINX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MINY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MAXX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "MAXY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "CNTX" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "CNTY" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "AREA" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "PERIM" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "HEIGHT" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "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;
}
bool QgsOverlayAnalyzer::intersection( QgsVectorLayer *layerA, QgsVectorLayer *layerB,
const QString &shapefileName, bool onlySelectedFeatures,
QProgressDialog *p )
{
if ( !layerA || !layerB )
{
return false;
}
QgsVectorDataProvider *dpA = layerA->dataProvider();
QgsVectorDataProvider *dpB = layerB->dataProvider();
if ( !dpA || !dpB )
{
return false;
}
QgsWkbTypes::Type outputType = dpA->wkbType();
QgsCoordinateReferenceSystem crs = layerA->crs();
QgsFields fieldsA = layerA->fields();
QgsFields fieldsB = layerB->fields();
combineFieldLists( fieldsA, fieldsB );
QgsVectorFileWriter vWriter( shapefileName, dpA->encoding(), fieldsA, outputType, crs );
QgsFeature currentFeature;
//take only selection
if ( onlySelectedFeatures )
{
QgsFeatureIds selectionB = layerB->selectedFeatureIds();
QgsFeatureRequest req = QgsFeatureRequest().setFilterFids( selectionB ).setSubsetOfAttributes( QgsAttributeList() );
QgsSpatialIndex index = QgsSpatialIndex( layerB->getFeatures( req ) );
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selectionA = layerA->selectedFeatureIds();
if ( p )
{
p->setMaximum( selectionA.size() );
}
req = QgsFeatureRequest().setFilterFids( selectionA );
QgsFeatureIterator selectionAIt = layerA->getFeatures( req );
QgsFeature currentFeature;
int processedFeatures = 0;
while ( selectionAIt.nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
intersectFeature( currentFeature, &vWriter, layerB, &index );
++processedFeatures;
}
if ( p )
{
p->setValue( selectionA.size() );
}
}
//take all features
else
{
QgsFeatureRequest req = QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() );
QgsSpatialIndex index = QgsSpatialIndex( layerB->getFeatures( req ) );
int featureCount = layerA->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
int processedFeatures = 0;
QgsFeatureIterator fit = layerA->getFeatures();
QgsFeature currentFeature;
while ( fit.nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
intersectFeature( currentFeature, &vWriter, layerB, &index );
++processedFeatures;
}
if ( p )
{
p->setValue( featureCount );
}
}
return true;
}
bool QgsGeometryAnalyzer::centroids( QgsVectorLayer* layer, const QString& shapefileName,
bool onlySelectedFeatures, QProgressDialog* p )
{
if ( !layer )
{
QgsDebugMsg( "No layer passed to centroids" );
return false;
}
QgsVectorDataProvider* dp = layer->dataProvider();
if ( !dp )
{
QgsDebugMsg( "No data provider for layer passed to centroids" );
return false;
}
QGis::WkbType outputType = QGis::WKBPoint;
const QgsCoordinateReferenceSystem crs = layer->crs();
QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->pendingFields(), outputType, &crs );
QgsFeature currentFeature;
//take only selection
if ( onlySelectedFeatures )
{
//use QgsVectorLayer::featureAtId
const QgsFeatureIds selection = layer->selectedFeaturesIds();
if ( p )
{
p->setMaximum( selection.size() );
}
int processedFeatures = 0;
QgsFeatureIds::const_iterator it = selection.constBegin();
for ( ; it != selection.constEnd(); ++it )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( !layer->getFeatures( QgsFeatureRequest().setFilterFid( *it ) ).nextFeature( currentFeature ) )
{
continue;
}
centroidFeature( currentFeature, &vWriter );
++processedFeatures;
}
if ( p )
{
p->setValue( selection.size() );
}
}
//take all features
else
{
QgsFeatureIterator fit = layer->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QgsAttributeList() ) );
int featureCount = layer->featureCount();
if ( p )
{
p->setMaximum( featureCount );
}
int processedFeatures = 0;
while ( fit.nextFeature( currentFeature ) )
{
if ( p )
{
p->setValue( processedFeatures );
}
if ( p && p->wasCanceled() )
{
break;
}
centroidFeature( currentFeature, &vWriter );
++processedFeatures;
}
if ( p )
{
p->setValue( featureCount );
}
}
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;
const QgsCoordinateReferenceSystem crs = layer->crs();
QgsFieldMap fields;
fields.insert( 0 , QgsField( QString( "MINX" ), QVariant::Double ) );
fields.insert( 1 , QgsField( QString( "MINY" ), QVariant::Double ) );
fields.insert( 2 , QgsField( QString( "MAXX" ), QVariant::Double ) );
fields.insert( 3 , QgsField( QString( "MAXY" ), QVariant::Double ) );
fields.insert( 4 , QgsField( QString( "CNTX" ), QVariant::Double ) );
fields.insert( 5 , QgsField( QString( "CNTY" ), QVariant::Double ) );
fields.insert( 6 , QgsField( QString( "AREA" ), QVariant::Double ) );
fields.insert( 7 , QgsField( QString( "PERIM" ), QVariant::Double ) );
fields.insert( 8 , QgsField( QString( "HEIGHT" ), QVariant::Double ) );
fields.insert( 9 , 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;
QgsAttributeMap map;
map.insert( 0 , QVariant( minx ) );
map.insert( 1 , QVariant( miny ) );
map.insert( 2 , QVariant( maxx ) );
map.insert( 3 , QVariant( maxy ) );
map.insert( 4 , QVariant( cntx ) );
map.insert( 5 , QVariant( cnty ) );
map.insert( 6 , QVariant( area ) );
map.insert( 7 , QVariant( perim ) );
map.insert( 8 , QVariant( height ) );
map.insert( 9 , QVariant( width ) );
feat.setAttributeMap( map );
feat.setGeometry( QgsGeometry::fromRect( rect ) );
vWriter.addFeature( feat );
return true;
}