Пример #1
0
bool SelectionBase::ExpressionPart::match(const SPFeatureI &feature,SelectionBase *operation) const
{
    if ( _type == ExpressionPart::ptFEATURETYPE){
        return hasType(feature->geometryType(), _geometryType);
    }
    if ( _type == ExpressionPart::ptENVELOPE && _envelope.isValid())   {
        return _envelope.contains(feature->geometry().get());
    }
    if ( _type == ExpressionPart::ptPOLYGON && _polygon.get() != 0)   {
        return _polygon->contains(feature->geometry().get());
    }

    if ( _type == ExpressionPart::ptATTRIBUTESELECTION )   {
        QVariant val = feature(_leftSide);
        ColumnDefinition coldef = feature->attributedefinition(_leftSide);
        if ( coldef.datadef().domain()->ilwisType() == itITEMDOMAIN){
            val = coldef.datadef().domain()->impliedValue(val);
        }
        if ( QString(val.typeName()) == "QString" && QString(_rightSide.typeName()) == "QString"){
            return operation->compare1(_operator,val.toString(), _rightSide.toString());
        } else {
            bool ok1,ok2;
            double v1 = val.toDouble(&ok1);
            double v2 = _rightSide.toDouble(&ok2);
            bool ok3 = operation->compare2(_operator, v1, v2, true);
            return ok1&& ok2 && ok3;
        }
    }
    return false;
}
Пример #2
0
FeatureDrawing SimplePointSetter::setSpatialAttributes(const SPFeatureI &feature, QVector<QVector3D> &vertices, QVector<QVector3D> &) const
{
    Envelope env = _rootDrawer->attribute("coverageenvelope").value<Envelope>();
    double size = env.xlength() / 150.0;
    const UPGeometry& geometry = feature->geometry();
    int n = geometry->getNumGeometries();
    FeatureDrawing drawing(itPOINT);
    for(int  geom = 0; geom < n; ++geom ){
        const geos::geom::Geometry *subgeom = geometry->getGeometryN(geom);
        if (!subgeom)
            continue;
        const geos::geom::Coordinate *crd = subgeom->getCoordinate();
        Coordinate coord = *crd;
        if ( coordinateConversionNeeded()){
            coord = _targetSystem->coord2coord(_sourceSystem, *crd);
        }

        drawing._indices.push_back(VertexIndex(vertices.size(),5,GL_LINE_STRIP,feature->featureid()));
        double z = coord.z == rUNDEF || std::isnan(coord.z)? 0 : coord.z;
        vertices.push_back(QVector3D(coord.x + size, coord.y + size, z));
        vertices.push_back(QVector3D(coord.x - size, coord.y + size, z));
        vertices.push_back(QVector3D(coord.x - size, coord.y - size, z));
        vertices.push_back(QVector3D(coord.x + size, coord.y - size, z));
        vertices.push_back(QVector3D(coord.x + size, coord.y + size, z));
        drawing._center = QVector3D(coord.x, coord.y, coord.z);
    }
    return drawing;

}
Пример #3
0
SPFeatureI FeatureCoverage::newFeatureFrom(const SPFeatureI& existingFeature) {
    Locker lock(_mutex);
    if ( existingFeature.isNull() || existingFeature->isValid() == false)
        return SPFeatureI();
    SPFeatureI newFeature = new Feature(this);
    for(int i=0; i < existingFeature->trackSize(); ++i)
        newFeature->set(existingFeature->geometry(),i);
    _features.push_back(newFeature);
    quint32 cnt = featureCount(newFeature->ilwisType());
    setFeatureCount(newFeature->ilwisType(),++cnt );
    return _features.back();
}
Пример #4
0
FeatureDrawing SimplePolygonSetter::setSpatialAttributes(const SPFeatureI &feature, QVector<QVector3D> &vertices, QVector<QVector3D> &normals) const
{
    IlwisTesselator tesselator;
    const UPGeometry& geometry = feature->geometry();
    int n = geometry->getNumGeometries();
    FeatureDrawing drawing(itPOLYGON);
    for(int  geom = 0; geom < n; ++geom ){
        const geos::geom::Geometry *subgeom = geometry->getGeometryN(geom);
        if (!subgeom)
            continue;
        tesselator.tesselate(_targetSystem,_sourceSystem, subgeom,feature->featureid(), vertices, drawing._indices);
    }
    return drawing;
}
bool GdalFeatureConnector::store(IlwisObject *obj, const IOOptions&   )
{

    if (!loadDriver())
        return false;

    IFeatureCoverage coverage;
    coverage.set(static_cast<FeatureCoverage *>(obj));

    std::vector<SourceHandles> datasources(3);
    std::vector<bool> validAttributes;
    if(!setDataSourceAndLayers(coverage, datasources, validAttributes))
        return false;

    std::vector<ColumnDefinition> defs;
    for(int i=0; i < coverage->attributeTable()->columnCount(); ++i){
        defs.push_back(coverage->attributeTable()->columndefinition(i));
    }

    FeatureIterator fiter(coverage);
    FeatureIterator endIter = end(coverage);
    for(; fiter != endIter; ++fiter) {
        SPFeatureI feature = *fiter;
        IlwisTypes geomType = feature->geometryType();
        if ( geomType != 0){
            OGRLayerH lyr = datasources[ilwisType2Index(geomType)]._layers[0];
            OGRFeatureH hfeature = gdal()->createFeature(gdal()->getLayerDef(lyr));
            if (hfeature) {
                setAttributes(hfeature, feature, validAttributes, defs);
                const geos::geom::Geometry* geometry = feature->geometry().get();
                if (gdal()->setGeometryDirectly(hfeature,createFeature(geometry)) != OGRERR_NONE)
                    ERROR2(ERR_COULD_NOT_ALLOCATE_2, TR("geometry"), _filename.toString());
                if (gdal()->addFeature2Layer(lyr, hfeature) != OGRERR_NONE) {
                    ERROR2(ERR_COULD_NOT_ALLOCATE_2, TR("feature"), _filename.toString());
                }
                gdal()->destroyFeature(hfeature);
            };
        }
    }
    for(auto& datasource : datasources){
        if ( datasource._source != 0)
            gdal()->destroyDataSource(datasource._source);
    }

    return true;

}
Пример #6
0
SPFeatureI FeatureCoverage::newFeatureFrom(const SPFeatureI& existingFeature, const ICoordinateSystem& csySource) {
    Locker<> lock(_mutex);

    auto transform = [&](const UPGeometry& geom)->geos::geom::Geometry * {
        if ( geom.get() == 0)
            return 0;

        geos::geom::Geometry *newgeom = geom->clone();
        if ( csySource.isValid() && !csySource->isEqual(coordinateSystem().ptr())){
            CsyTransform trans(csySource, coordinateSystem());
            newgeom->apply_rw(&trans);
            newgeom->geometryChangedAction();
        }
        GeometryHelper::setCoordinateSystem(newgeom, coordinateSystem().ptr());

        return newgeom;
    };
    if (!connector()->dataIsLoaded()) {
        connector()->loadData(this);
    }
    auto *newfeature = createNewFeature(existingFeature->geometryType());
    const UPGeometry& geom = existingFeature->geometry();
    newfeature->geometry(transform(geom)) ;

    auto variantIndexes = _attributeDefinition.indexes();
    for(auto index : variantIndexes){
        const auto& variant = existingFeature[index];
        auto *variantFeature = createNewFeature(variant->geometryType());
        const auto& geom = variant->geometry();
        variantFeature->geometry(transform(geom)) ;
        newfeature->setSubFeature(index, variantFeature);


    }
    _features.push_back(newfeature);
    return _features.back();
}
bool PostgresqlFeatureCoverageLoader::storeData(FeatureCoverage *fcoverage) const
{
    bool queryOk = true;
    ITable baseData = fcoverage->attributeTable();
    PostgresqlParameters params (_resource.url(true).toString());
    PostgresqlDatabaseUtil pgUtil(params);
    SqlStatementHelper sqlHelper(params);
   bool newTable = false;
   if ( !pgUtil.tableExists()){
       if(!pgUtil.createTable(fcoverage)){
           return false;
       }
       newTable = true;
   }

   IDomain semantics; // subfeature semantics
    QList<QString> primaryKeys; // readonly keys
    QList<MetaGeometryColumn> metaGeomColumns; // geometry columns
    pgUtil.getMetaForGeometryColumns(metaGeomColumns);
    pgUtil.prepareSubFeatureSemantics(semantics, metaGeomColumns, _options);
    pgUtil.getPrimaryKeys(primaryKeys);
    // add geoms to update/insert data table
    FeatureIterator featureIter(fcoverage);
    featureIter.flow(FeatureIterator::fDEPTHFIRST);

    QString columnNamesCommaSeparated = sqlHelper.columnNamesCommaSeparated(baseData.ptr());

    QString code = fcoverage->coordinateSystem()->code();
    QString srid = code.right(code.indexOf(":"));
    QString qtablename = params.table().toLower();
    while(featureIter != featureIter.end()) {
        SPFeatureI feature = (*featureIter);
        bool newFeature = newTable ? true : !pgUtil.exists(feature);
        QString columnValuesCommaSeparated = sqlHelper.columnValuesCommaSeparated(feature);
        QString sqlStmt;
        if (newFeature) {
            sqlStmt = "INSERT INTO ";
            sqlStmt.append(qtablename);


            sqlStmt.append(" ( ");
            sqlStmt.append(columnNamesCommaSeparated);

            foreach (MetaGeometryColumn geomMeta, metaGeomColumns) {
                sqlStmt.append(", ");
                sqlStmt.append(geomMeta.geomColumn);
            }

            sqlStmt.append(" ) ");
            sqlStmt.append(" VALUES ( ");
            sqlStmt.append(columnValuesCommaSeparated);
            sqlStmt.append(", ");

            // add geometry values

            /*
            // TODO storing level n data only makes sense
            //      if subfeatures are stored in separate
            //      tables related via foreign keys, but
            //      separate tables aren't supported now

            ITabel levelData = fcoverage->attributeTable(level);
            PostgresqlTableConnector connector(_resource,false);
            tableOk = connector.store(levelData.ptr(), options);
            */

            QString rootGeomColumn = fcoverage->attributeDefinitionsRef().index((quint32)0);
            // have to iterate the order of given geom columns
            foreach (MetaGeometryColumn geomMeta, metaGeomColumns) {
                QString wkt = "NULL";
                QString geomColumn = geomMeta.geomColumn;
                if (rootGeomColumn == geomColumn || rootGeomColumn == sUNDEF) {
                    if (feature->geometry() != nullptr){
                        wkt = QString("'%1'").arg(GeometryHelper::toWKT(feature->geometry().get()));
                    }
                } else if (feature[geomColumn]->geometry() != nullptr){
                    // access subfeature geometries
                    SPFeatureI subfeature = feature[geomColumn];
                    wkt = QString("'%1'").arg(GeometryHelper::toWKT(subfeature->geometry().get()));
                }
                sqlStmt.append("st_geomfromtext(").append(wkt);
                sqlStmt.append(", ").append(srid).append(")");
                sqlStmt.append(",");

                // skip subfeature's geometries, as accessed already via domain
                ++featureIter;
            }

            sqlStmt = sqlHelper.trimAndRemoveLastCharacter(sqlStmt);


            sqlStmt.append(" ); ");
        } else {
Пример #8
0
void FeatureCoverageTest::testVariants() {
    Ilwis::IFeatureCoverage featureCoverage;
       featureCoverage.prepare();

       Ilwis::ICoordinateSystem csy("code=proj4:+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs");

       Ilwis::Envelope env(Ilwis::LatLon(50,-30), Ilwis::LatLon(-50, 60));
       featureCoverage->coordinateSystem(csy);
       featureCoverage->envelope(env);

       Ilwis::ITimeDomain dom;
       dom.prepare();
       dom->range(new Ilwis::TimeInterval("20090101", "20110101"));
       std::vector<QString> times = {"20090101","20090131","20090602","20090703", "20100109","20110101"};

       featureCoverage->attributeDefinitionsRef().addColumn("population", "value");
       featureCoverage->attributeDefinitionsRef().setSubDefinition(dom,times);

       Ilwis::SPFeatureI feature1 = featureCoverage->newFeature(0);

       geos::geom::Geometry *geom = Ilwis::GeometryHelper::fromWKT("Linestring(40 20, 10 12, -20 -10)", featureCoverage->coordinateSystem().ptr());
       feature1->geometry(geom);
       feature1("population", 200);

       geom = Ilwis::GeometryHelper::fromWKT("Linestring(40 30, 10 12, -20 -10)", featureCoverage->coordinateSystem().ptr());
       Ilwis::SPFeatureI feature2 = featureCoverage->newFeature(geom);
       feature2("population", 300);

       geom = Ilwis::GeometryHelper::fromWKT("Linestring(40 30, 12 12, -20 -10)", featureCoverage->coordinateSystem().ptr());
       Ilwis::SPFeatureI feature3 = featureCoverage->newFeature(geom);
       feature3("population", 100);
    feature1->createSubFeature("20090101", geom);
    feature1->createSubFeature("20090703", geom);

       geom = Ilwis::GeometryHelper::fromWKT("Linestring(30 10, 10 15, -23 -12)",featureCoverage->coordinateSystem().ptr());

       feature1->createSubFeature("20090101", geom);

       geom = Ilwis::GeometryHelper::fromWKT("Linestring(20 10, 10 15, -23 -12)",featureCoverage->coordinateSystem().ptr());

       feature2->createSubFeature("20090101", geom);

       auto *attrdef = new Ilwis::FeatureAttributeDefinition();
       attrdef->addColumn("temperature", "value");
       featureCoverage->attributeDefinitionsRef().featureAttributeDefinition(attrdef);

       feature1["20090101"]("temperature", 26.5);
       feature2["20090101"]("temperature", 19.5);


    FeatureIterator featureIter(featureCoverage);
    featureIter.flow(FeatureIterator::fDEPTHFIRST);

    while(featureIter != featureIter.end()) {
        SPFeatureI f = (*featureIter);
        f->geometry(); // test if geometry is null
        DOTEST(true, "geometry of (sub)feature not null.");
        featureIter++; // move to next
    }






}