/** * Forces the specified CRS on geometry attributes (all or some, depends on the parameters). * * @param schema the original schema * @param crs the forced crs * @param forceOnlyMissing if true, will force the specified crs only on the attributes that do * miss one * @return * @throws SchemaException */ public static SimpleFeatureType transform( SimpleFeatureType schema, CoordinateReferenceSystem crs, boolean forceOnlyMissing) throws SchemaException { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName(schema.getTypeName()); tb.setNamespaceURI(schema.getName().getNamespaceURI()); tb.setAbstract(schema.isAbstract()); GeometryDescriptor defaultGeometryType = null; for (int i = 0; i < schema.getAttributeCount(); i++) { AttributeDescriptor attributeType = schema.getDescriptor(i); if (attributeType instanceof GeometryDescriptor) { GeometryDescriptor geometryType = (GeometryDescriptor) attributeType; AttributeDescriptor forced; tb.descriptor(geometryType); if (!forceOnlyMissing || geometryType.getCoordinateReferenceSystem() == null) { tb.crs(crs); } tb.add(geometryType.getLocalName(), geometryType.getType().getBinding()); } else { tb.add(attributeType); } } if (schema.getGeometryDescriptor() != null) { tb.setDefaultGeometry(schema.getGeometryDescriptor().getLocalName()); } tb.setSuperType((SimpleFeatureType) schema.getSuper()); return tb.buildFeatureType(); }
public IntersectedFeatureCollection( SimpleFeatureCollection delegate, List<String> firstAttributes, SimpleFeatureCollection features, List<String> sndAttributes, IntersectionMode intersectionMode, boolean percentagesEnabled, boolean areasEnabled) { super(delegate); this.features = features; this.firstAttributes = firstAttributes; this.sndAttributes = sndAttributes; this.intersectionMode = intersectionMode; this.percentagesEnabled = percentagesEnabled; this.areasEnabled = areasEnabled; SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); SimpleFeatureType firstFeatureCollectionSchema = delegate.getSchema(); SimpleFeatureType secondFeatureCollectionSchema = features.getSchema(); if (intersectionMode == IntersectionMode.FIRST) { geomType = firstFeatureCollectionSchema.getGeometryDescriptor(); } if (intersectionMode == IntersectionMode.SECOND) { geomType = secondFeatureCollectionSchema.getGeometryDescriptor(); } if (intersectionMode == IntersectionMode.INTERSECTION) { geomType = getIntersectionType(delegate, features); } tb.add(geomType); // gather the attributes from the first feature collection and skip collectAttributes(firstFeatureCollectionSchema, firstAttributes, tb); // gather the attributes from the second feature collection collectAttributes(secondFeatureCollectionSchema, sndAttributes, tb); // add the dyamic attributes as needed if (percentagesEnabled) { tb.add("percentageA", Double.class); tb.add("percentageB", Double.class); } if (areasEnabled) { tb.add("areaA", Double.class); tb.add("areaB", Double.class); } tb.add("INTERSECTION_ID", Integer.class); tb.setDescription(firstFeatureCollectionSchema.getDescription()); tb.setCRS(firstFeatureCollectionSchema.getCoordinateReferenceSystem()); tb.setAbstract(firstFeatureCollectionSchema.isAbstract()); tb.setSuperType((SimpleFeatureType) firstFeatureCollectionSchema.getSuper()); tb.setName(firstFeatureCollectionSchema.getName()); this.fb = new SimpleFeatureBuilder(tb.buildFeatureType()); }
@Override public SimpleFeature decode(String recordId, String[] csvRecord) { SimpleFeatureType featureType = getFeatureType(); SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType); GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor(); GeometryFactory geometryFactory = new GeometryFactory(); Double lat = null, lng = null; String[] headers = csvFileState.getCSVHeaders(); for (int i = 0; i < headers.length; i++) { String header = headers[i]; if (i < csvRecord.length) { String value = csvRecord[i].trim(); if (geometryDescriptor != null && header.equals(latField)) { lat = Double.valueOf(value); } else if (geometryDescriptor != null && header.equals(lngField)) { lng = Double.valueOf(value); } else { builder.set(header, value); } } else { builder.set(header, null); } } if (geometryDescriptor != null && lat != null && lng != null) { Coordinate coordinate = new Coordinate(lng, lat); Point point = geometryFactory.createPoint(coordinate); builder.set(geometryDescriptor.getLocalName(), point); } return builder.buildFeature(csvFileState.getTypeName() + "-" + recordId); }
public void testImportCSV() throws Exception { File dir = unpack("csv/locations.zip"); ImportContext context = importer.createContext(new SpatialFile(new File(dir, "locations.csv"))); assertEquals(1, context.getTasks().size()); ImportTask task = context.getTasks().get(0); assertEquals(ImportTask.State.NO_CRS, task.getState()); LayerInfo layer = task.getLayer(); ResourceInfo resource = layer.getResource(); resource.setSRS("EPSG:4326"); assertTrue("Item not ready", importer.prep(task)); assertEquals(ImportTask.State.READY, task.getState()); context.updated(); assertEquals(ImportContext.State.PENDING, context.getState()); importer.run(context); assertEquals(ImportContext.State.COMPLETE, context.getState()); FeatureTypeInfo fti = (FeatureTypeInfo) resource; SimpleFeatureType featureType = (SimpleFeatureType) fti.getFeatureType(); GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor(); assertNull("Expecting no geometry", geometryDescriptor); assertEquals(4, featureType.getAttributeCount()); }
private void collectAttributes( SimpleFeatureType schema, List<String> retainedAttributes, SimpleFeatureTypeBuilder tb) { for (AttributeDescriptor descriptor : schema.getAttributeDescriptors()) { // check whether descriptor has been selected in the attribute list boolean isInRetainList = true; if (retainedAttributes != null) { isInRetainList = retainedAttributes.contains(descriptor.getLocalName()); logger.fine("Checking " + descriptor.getLocalName() + " --> " + isInRetainList); } if (!isInRetainList || schema.getGeometryDescriptor() == descriptor) { continue; } // build the attribute to return AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setName(schema.getName().getLocalPart() + "_" + descriptor.getName()); builder.setNillable(descriptor.isNillable()); builder.setBinding(descriptor.getType().getBinding()); builder.setMinOccurs(descriptor.getMinOccurs()); builder.setMaxOccurs(descriptor.getMaxOccurs()); builder.setDefaultValue(descriptor.getDefaultValue()); builder.setCRS(schema.getCoordinateReferenceSystem()); AttributeDescriptor intersectionDescriptor = builder.buildDescriptor( schema.getName().getLocalPart() + "_" + descriptor.getName(), descriptor.getType()); tb.add(intersectionDescriptor); tb.addBinding(descriptor.getType()); } }
/** * Creates a Query to be executed over a registered ArcSDE layer (whether it is from a table or a * spatial view). * * @param session the session the query works over. As its managed by the calling code its the * calling code responsibility to close it when done. * @param fullSchema * @param query * @param isMultiversioned whether the table is versioned, if so, the default version and current * state will be used for the SeQuery * @return * @throws IOException */ public static ArcSDEQuery createQuery( final ISession session, final SimpleFeatureType fullSchema, final Query query, final FIDReader fidReader, final ArcSdeVersionHandler versioningHandler) throws IOException { Filter filter = query.getFilter(); LOGGER.fine("Creating new ArcSDEQuery"); final String typeName = fullSchema.getTypeName(); final SeTable sdeTable = session.getTable(typeName); final SeLayer sdeLayer; if (fullSchema.getGeometryDescriptor() == null) { sdeLayer = null; } else { sdeLayer = session.getLayer(typeName); } // create the set of filters to work over final ArcSDEQuery.FilterSet filters = new ArcSDEQuery.FilterSet(sdeTable, sdeLayer, filter, fullSchema, null, null, fidReader); final Filter unsupportedFilter = filters.getUnsupportedFilter(); final String[] queryProperties = query.getPropertyNames(); final SimpleFeatureType querySchema = getQuerySchema(queryProperties, unsupportedFilter, fullSchema); final String sortByClause = buildSortByClause(fullSchema, query.getSortBy(), fidReader); final ArcSDEQuery sdeQuery; sdeQuery = new ArcSDEQuery(session, querySchema, filters, sortByClause, fidReader, versioningHandler); return sdeQuery; }
@Override public void createSchema(SimpleFeatureType featureType) throws IOException { List<String> header = new ArrayList<String>(); GeometryDescriptor geometryDescrptor = featureType.getGeometryDescriptor(); if (geometryDescrptor != null && CRS.equalsIgnoreMetadata( DefaultGeographicCRS.WGS84, geometryDescrptor.getCoordinateReferenceSystem()) && geometryDescrptor.getType().getBinding().isAssignableFrom(Point.class)) { header.add(this.latField); header.add(this.lngField); } else { throw new IOException( "Unable use '" + this.latField + "' / '" + this.lngField + "' to represent " + geometryDescrptor); } for (AttributeDescriptor descriptor : featureType.getAttributeDescriptors()) { if (descriptor instanceof GeometryDescriptor) continue; header.add(descriptor.getLocalName()); } // Write out header, producing an empty file of the correct type CsvWriter writer = new CsvWriter(new FileWriter(this.csvFileState.getFile()), ','); try { writer.writeRecord(header.toArray(new String[header.size()])); } finally { writer.close(); } }
/** * Creates the resultant features. * * @param splitGeometries List with the new geometries. * @param feature The old feature. * @throws OperationNotFoundException * @throws TransformException */ private List<SimpleFeature> createSplitFeatures( final List<Geometry> splitGeometries, final SimpleFeature feature) throws OperationNotFoundException, TransformException { final SimpleFeatureType featureType = feature.getFeatureType(); final CoordinateReferenceSystem featureCrs = featureType.getCoordinateReferenceSystem(); Class<? extends Geometry> geometryType = (Class<? extends Geometry>) featureType.getGeometryDescriptor().getType().getBinding(); List<SimpleFeature> splitFeatureList = new LinkedList<SimpleFeature>(); for (Geometry splittedPart : splitGeometries) { splittedPart = GeoToolsUtils.reproject(splittedPart, desiredCRS, featureCrs); splittedPart = GeometryUtil.adapt(splittedPart, geometryType); SimpleFeature newFeature = DataUtilities.template(featureType); GeoToolsUtils.copyAttributes(feature, newFeature); newFeature.setDefaultGeometry(splittedPart); splitFeatureList.add(newFeature); } return splitFeatureList; }
@Override public void postCreateFeatureType( SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx) throws SQLException { // figure out if the table has a spatial index and mark the feature type as so if (featureType.getGeometryDescriptor() == null) { return; } String idxTableName = featureType.getTypeName() + "_HATBOX"; ResultSet rs = metadata.getTables(null, schemaName, idxTableName, new String[] {"TABLE"}); try { if (rs.next()) { featureType.getGeometryDescriptor().getUserData().put(H2_SPATIAL_INDEX, idxTableName); } } finally { dataStore.closeSafe(rs); } }
/** Maps the default geometry attribute regardless of whether they are the same type. */ @SuppressWarnings("unchecked") private static void mapGeometryAttributes( SimpleFeatureType sourceSchema, SimpleFeatureType targetSchema, Map<String, String> queryAttributes) { // Now we'll match the geometry on type only. I don't care if it has the same type name. GeometryDescriptor defaultGeometry = targetSchema.getGeometryDescriptor(); if (defaultGeometry == null) { return; } else if (!queryAttributes.containsKey(defaultGeometry.getName())) { // first check source's default geom and see if it matches Class<?> binding = sourceSchema.getGeometryDescriptor().getType().getBinding(); if (defaultGeometry.getType().getBinding().isAssignableFrom(binding)) { queryAttributes.put( defaultGeometry.getName().getLocalPart(), sourceSchema.getGeometryDescriptor().getName().getLocalPart()); } else { // we have to look through all the source attributes looking for a geometry that // matches. boolean found = false; for (int i = 0; i < sourceSchema.getAttributeCount(); i++) { AttributeDescriptor source = sourceSchema.getDescriptor(i); if (defaultGeometry .getType() .getBinding() .isAssignableFrom(source.getType().getBinding())) { queryAttributes.put( defaultGeometry.getName().getLocalPart(), source.getName().getLocalPart()); found = true; break; } } // ok so we're going to have to do some transformations. Match default geometries // then. if (!found) { queryAttributes.put( defaultGeometry.getName().getLocalPart(), sourceSchema.getGeometryDescriptor().getName().getLocalPart()); } } } }
public IntersectedFeatureIterator( SimpleFeatureIterator delegate, SimpleFeatureCollection firstFeatures, SimpleFeatureCollection secondFeatures, SimpleFeatureType firstFeatureCollectionSchema, SimpleFeatureType secondFeatureCollectionSchema, List<String> retainAttributesFstPar, List<String> retainAttributesSndPar, IntersectionMode intersectionMode, boolean percentagesEnabled, boolean areasEnabled, SimpleFeatureBuilder sfb) { this.retainAttributesFst = retainAttributesFstPar; this.retainAttributesSnd = retainAttributesSndPar; this.delegate = delegate; this.firstFeatures = firstFeatures; this.secondFeatures = secondFeatures; this.percentagesEnabled = percentagesEnabled; this.areasEnabled = areasEnabled; this.intersectionMode = intersectionMode; logger.fine("Creating schema"); // create the geometry attribute descriptor for the result // SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); if (intersectionMode == IntersectionMode.FIRST) { geomType = firstFeatureCollectionSchema.getGeometryDescriptor(); } if (intersectionMode == IntersectionMode.SECOND) { geomType = secondFeatureCollectionSchema.getGeometryDescriptor(); } if (intersectionMode == IntersectionMode.INTERSECTION) { geomType = getIntersectionType(firstFeatures, secondFeatures); } this.fb = sfb; subFeatureCollection = this.secondFeatures; this.dataGeomName = this.firstFeatures.getSchema().getGeometryDescriptor().getLocalName(); logger.fine("Schema created"); }
public void testImportCSVIndirect() throws Exception { File dir = unpack("csv/locations.zip"); String wsName = getCatalog().getDefaultWorkspace().getName(); DataStoreInfo h2DataStore = createH2DataStore(wsName, "csvindirecttest"); SpatialFile importData = new SpatialFile(new File(dir, "locations.csv")); ImportContext context = importer.createContext(importData, h2DataStore); assertEquals(1, context.getTasks().size()); ImportTask task = context.getTasks().get(0); TransformChain transformChain = task.getTransform(); transformChain.add(new AttributesToPointGeometryTransform("LAT", "LON")); assertEquals(ImportTask.State.NO_CRS, task.getState()); LayerInfo layer = task.getLayer(); ResourceInfo resource = layer.getResource(); resource.setSRS("EPSG:4326"); assertTrue("Item not ready", importer.prep(task)); assertEquals(ImportTask.State.READY, task.getState()); context.updated(); assertEquals(ImportContext.State.PENDING, context.getState()); importer.run(context); assertEquals(ImportContext.State.COMPLETE, context.getState()); FeatureTypeInfo fti = (FeatureTypeInfo) resource; SimpleFeatureType featureType = (SimpleFeatureType) fti.getFeatureType(); GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor(); assertNotNull("Expecting geometry", geometryDescriptor); assertEquals("Invalid geometry name", "location", geometryDescriptor.getLocalName()); assertEquals(3, featureType.getAttributeCount()); FeatureSource<? extends FeatureType, ? extends Feature> featureSource = fti.getFeatureSource(null, null); FeatureCollection<? extends FeatureType, ? extends Feature> features = featureSource.getFeatures(); assertEquals(9, features.size()); FeatureIterator<? extends Feature> featureIterator = features.features(); assertTrue("Expected features", featureIterator.hasNext()); SimpleFeature feature = (SimpleFeature) featureIterator.next(); assertNotNull(feature); assertEquals("Invalid city attribute", "Trento", feature.getAttribute("CITY")); assertEquals("Invalid number attribute", 140, feature.getAttribute("NUMBER")); Object geomAttribute = feature.getAttribute("location"); assertNotNull("Expected geometry", geomAttribute); Point point = (Point) geomAttribute; Coordinate coordinate = point.getCoordinate(); assertEquals("Invalid x coordinate", 11.12, coordinate.x, 0.1); assertEquals("Invalid y coordinate", 46.07, coordinate.y, 0.1); featureIterator.close(); }
/** * Applies transform to all geometry attribute. * * @param feature Feature to be transformed * @param schema Schema for target transformation - transform( schema, crs ) * @param transform MathTransform used to transform coordinates - reproject( crs, crs ) * @return transformed Feature of type schema * @throws TransformException * @throws MismatchedDimensionException * @throws IllegalAttributeException */ public static SimpleFeature transform( SimpleFeature feature, SimpleFeatureType schema, MathTransform transform) throws MismatchedDimensionException, TransformException, IllegalAttributeException { feature = SimpleFeatureBuilder.copy(feature); GeometryDescriptor geomType = schema.getGeometryDescriptor(); Geometry geom = (Geometry) feature.getAttribute(geomType.getLocalName()); geom = JTS.transform(geom, transform); feature.setAttribute(geomType.getLocalName(), geom); return feature; }
// todo - add API doc describing what the method does (nf,ts - 2012-04-23) @Override public void setUserDataOf(SimpleFeatureType compatibleFeatureType) { compatibleFeatureType .getUserData() .put(PROPERTY_NAME_PLACEMARK_DESCRIPTOR, getClass().getName()); final org.opengis.feature.type.GeometryDescriptor geometryDescriptor = compatibleFeatureType.getGeometryDescriptor(); if (geometryDescriptor != null) { compatibleFeatureType .getUserData() .put(PROPERTY_NAME_DEFAULT_GEOMETRY, geometryDescriptor.getLocalName()); } }
/** * if the query has been parsed as just a where clause filter, or has no filter at all, the result * count calculation is optimized by selecting a <code>count()</code> single row. If the filter * involves any kind of spatial filter, such as BBOX, the calculation can't be optimized by this * way, because the ArcSDE Java API throws a <code>"DATABASE LEVEL * ERROR OCURRED"</code> exception. So, in this case, a query over the shape field is made and the * result is traversed counting the number of rows inside a while loop */ public int calculateResultCount() throws IOException { final SimpleFeatureType schema = this.schema; final GeometryDescriptor geometryDescriptor = schema.getGeometryDescriptor(); final String colName; if (geometryDescriptor == null) { // gemetryless type, use any other column for the query colName = schema.getDescriptor(0).getLocalName(); } else { colName = geometryDescriptor.getLocalName(); } final SeQueryInfo qInfo = filters.getQueryInfo(new String[] {colName}); final SeFilter[] spatialFilters = filters.getSpatialFilters(); final Command<Integer> countCmd = new Command<Integer>() { @Override public Integer execute(ISession session, SeConnection connection) throws SeException, IOException { SeQuery query = new SeQuery(connection); try { versioningHandler.setUpStream(session, query); if (spatialFilters != null && spatialFilters.length > 0) { query.setSpatialConstraints(SeQuery.SE_OPTIMIZE, true, spatialFilters); } SeTable.SeTableStats tableStats = query.calculateTableStatistics( "*", SeTable.SeTableStats.SE_COUNT_STATS, qInfo, 0); int actualCount = tableStats.getCount(); return new Integer(actualCount); } finally { query.close(); } } }; final Integer count = session.issue(countCmd); return count.intValue(); }
/** Convenient method to just calculate the resulting bound box of a given query. */ public static Envelope calculateQueryExtent( final ISession session, final FeatureTypeInfo typeInfo, final Query query, final ArcSdeVersionHandler versioningHandler) throws IOException { final SimpleFeatureType fullSchema = typeInfo.getFeatureType(); final GeometryDescriptor geometryDescriptor = fullSchema.getGeometryDescriptor(); if (geometryDescriptor == null) { return null; } final String defaultGeomAttName = geometryDescriptor.getLocalName(); // we're calculating the bounds, so we'd better be sure and add the // spatial column to the query's propertynames final Query realQuery = new Query(query); realQuery.setPropertyNames(new String[] {defaultGeomAttName}); final ArcSDEQuery boundsQuery; if (typeInfo.isInProcessView()) { final SeQueryInfo definitionQuery = typeInfo.getSdeDefinitionQuery(); final PlainSelect viewSelectStatement = typeInfo.getDefinitionQuery(); boundsQuery = createInprocessViewQuery( session, fullSchema, realQuery, definitionQuery, viewSelectStatement); } else { final FIDReader fidStrategy = typeInfo.getFidStrategy(); boundsQuery = createQuery(session, fullSchema, realQuery, fidStrategy, versioningHandler); } Envelope queryExtent = null; try { Filter unsupportedFilter = boundsQuery.getFilters().getUnsupportedFilter(); if (unsupportedFilter == Filter.INCLUDE) { // we can only use an optimized bounds calculation if the // query is fully supported by sde queryExtent = boundsQuery.calculateQueryExtent(); } } finally { boundsQuery.close(); } return queryExtent; }
private void checkSchemaCorrect(SimpleFeatureType ft, boolean includeProportionColumns) { if (includeProportionColumns) { assertEquals(5, ft.getAttributeCount()); } else { assertEquals(3, ft.getAttributeCount()); } assertEquals(Point.class, ft.getGeometryDescriptor().getType().getBinding()); assertEquals( Integer.class, ft.getDescriptor(PointStackerProcess.ATTR_COUNT).getType().getBinding()); assertEquals( Integer.class, ft.getDescriptor(PointStackerProcess.ATTR_COUNT_UNIQUE).getType().getBinding()); if (includeProportionColumns) { assertEquals( Double.class, ft.getDescriptor(PointStackerProcess.ATTR_NORM_COUNT).getType().getBinding()); assertEquals( Double.class, ft.getDescriptor(PointStackerProcess.ATTR_NORM_COUNT_UNIQUE).getType().getBinding()); } }
public static SimpleFeatureType retype(SimpleFeatureType original, List<String> types) { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); // initialize the builder b.init(original); // clear the attributes b.attributes().clear(); // add attributes in order for (int i = 0; i < types.size(); i++) { b.add(original.getDescriptor(types.get(i))); } // handle default geometry GeometryDescriptor defaultGeometry = original.getGeometryDescriptor(); if (defaultGeometry != null && types.contains(defaultGeometry.getLocalName())) { b.setDefaultGeometry(defaultGeometry.getLocalName()); } return b.buildFeatureType(); }
private Query reprojectFilter(Query query) throws IOException { final Filter originalFilter = query.getFilter() != null ? query.getFilter() : Filter.INCLUDE; if (Filter.INCLUDE.equals(originalFilter)) { return query; } final SimpleFeatureType nativeFeatureType = getSchema(); final GeometryDescriptor geom = nativeFeatureType.getGeometryDescriptor(); // if no geometry involved, no reprojection needed if (geom == null) { return query; } final FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null); try { CoordinateReferenceSystem nativeCRS = geom.getCoordinateReferenceSystem(); // now we apply a default to all geometries and bbox in the filter DefaultCRSFilterVisitor defaultCRSVisitor = new DefaultCRSFilterVisitor(ff, nativeCRS); final Filter defaultedFilter = (Filter) originalFilter.accept(defaultCRSVisitor, null); // and then we reproject all geometries so that the datastore // receives // them in the native projection system (or the forced one, in case // of force) ReprojectingFilterVisitor reprojectingVisitor = new ReprojectingFilterVisitor(ff, nativeFeatureType); final Filter reprojectedFilter = (Filter) defaultedFilter.accept(reprojectingVisitor, null); Query reprojectedQuery = new Query(query); reprojectedQuery.setFilter(reprojectedFilter); return reprojectedQuery; } catch (Exception e) { throw new DataSourceException("Had troubles handling filter reprojection...", e); } }
// FIXME copy/paste from FeatureDataAdater ... abstract! @Override protected List<IndexFieldHandler<SimpleFeature, ? extends CommonIndexValue, Object>> getDefaultTypeMatchingHandlers(final Object typeObj) { if ((typeObj != null) && (typeObj instanceof SimpleFeatureType)) { final SimpleFeatureType internalType = (SimpleFeatureType) typeObj; nativeFieldHandlers = typeToFieldHandlers((SimpleFeatureType) typeObj); final List<IndexFieldHandler<SimpleFeature, ? extends CommonIndexValue, Object>> defaultHandlers = new ArrayList<IndexFieldHandler<SimpleFeature, ? extends CommonIndexValue, Object>>(); final IndexFieldHandler<SimpleFeature, Time, Object> timeHandler = getTimeRangeHandler(internalType); if (timeHandler != null) { defaultHandlers.add(timeHandler); } defaultHandlers.add( new FeatureGeometryHandler(internalType.getGeometryDescriptor(), fieldVisiblityHandler)); return defaultHandlers; } // LOGGER.warn("Simple Feature Type could not be used for handling the // indexed data"); return super.getDefaultTypeMatchingHandlers(featureType); }
/** * Writing test that only engages against a remote geoserver. * * <p>Makes reference to the standard featureTypes that geoserver ships with. NOTE: Ignoring this * test for now because it edits topp:states and GeoServer doesn't return the correct Feature IDs * on transactions against shapefiles */ @Test @Ignore public void testWrite() throws NoSuchElementException, IllegalFilterException, IOException, IllegalAttributeException { if (url == null) return; Map m = new HashMap(); m.put(WFSDataStoreFactory.URL.key, url); m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(10000000)); DataStore post = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m); String typename = TO_EDIT_TYPE; SimpleFeatureType ft = post.getSchema(typename); SimpleFeatureSource fs = post.getFeatureSource(typename); class Watcher implements FeatureListener { public int count = 0; public void changed(FeatureEvent featureEvent) { System.out.println("Event " + featureEvent); count++; } } Watcher watcher = new Watcher(); fs.addFeatureListener(watcher); Id startingFeatures = createFidFilter(fs); FilterFactory2 filterFac = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); try { GeometryFactory gf = new GeometryFactory(); MultiPolygon mp = gf.createMultiPolygon( new Polygon[] { gf.createPolygon( gf.createLinearRing( new Coordinate[] { new Coordinate(-88.071564, 37.51099), new Coordinate(-88.467644, 37.400757), new Coordinate(-90.638329, 42.509361), new Coordinate(-89.834618, 42.50346), new Coordinate(-88.071564, 37.51099) }), new LinearRing[] {}) }); mp.setUserData("http://www.opengis.net/gml/srs/epsg.xml#" + EPSG_CODE); PropertyName geometryAttributeExpression = filterFac.property(ft.getGeometryDescriptor().getLocalName()); PropertyIsNull geomNullCheck = filterFac.isNull(geometryAttributeExpression); Query query = new Query(typename, filterFac.not(geomNullCheck), 1, Query.ALL_NAMES, null); SimpleFeatureIterator inStore = fs.getFeatures(query).features(); SimpleFeature f, f2; try { SimpleFeature feature = inStore.next(); SimpleFeature copy = SimpleFeatureBuilder.deep(feature); SimpleFeature copy2 = SimpleFeatureBuilder.deep(feature); f = SimpleFeatureBuilder.build(ft, copy.getAttributes(), null); f2 = SimpleFeatureBuilder.build(ft, copy2.getAttributes(), null); assertFalse("Max Feature failed", inStore.hasNext()); } finally { inStore.close(); } org.geotools.util.logging.Logging.getLogger("org.geotools.data.wfs").setLevel(Level.FINE); SimpleFeatureCollection inserts = DataUtilities.collection(new SimpleFeature[] {f, f2}); Id fp = WFSDataStoreWriteOnlineTest.doInsert(post, ft, inserts); // / okay now count ... FeatureReader<SimpleFeatureType, SimpleFeature> count = post.getFeatureReader(new Query(ft.getTypeName()), Transaction.AUTO_COMMIT); int i = 0; while (count.hasNext() && i < 3) { f = count.next(); i++; } count.close(); WFSDataStoreWriteOnlineTest.doDelete(post, ft, fp); WFSDataStoreWriteOnlineTest.doUpdate(post, ft, ATTRIBUTE_TO_EDIT, NEW_EDIT_VALUE); // assertFalse("events not fired", watcher.count == 0); } finally { try { ((SimpleFeatureStore) fs).removeFeatures(filterFac.not(startingFeatures)); } catch (Exception e) { System.out.println(e); } } }
private static GeometryDescriptor getGeometryAttDescriptor(SimpleFeatureType schema) { return schema.getGeometryDescriptor(); }
/** Executes the export command using the provided options. */ @Override protected final void runInternal(GeogigCLI cli) throws IOException { if (args.isEmpty()) { printUsage(cli); throw new CommandFailedException(); } String path = args.get(0); String tableName = args.get(1); checkParameter(tableName != null && !tableName.isEmpty(), "No table name specified"); DataStore dataStore = getDataStore(); ObjectId featureTypeId = null; if (!Arrays.asList(dataStore.getTypeNames()).contains(tableName)) { SimpleFeatureType outputFeatureType; if (sFeatureTypeId != null) { // Check the feature type id string is a correct id Optional<ObjectId> id = cli.getGeogig().command(RevParse.class).setRefSpec(sFeatureTypeId).call(); checkParameter(id.isPresent(), "Invalid feature type reference", sFeatureTypeId); TYPE type = cli.getGeogig().command(ResolveObjectType.class).setObjectId(id.get()).call(); checkParameter( type.equals(TYPE.FEATURETYPE), "Provided reference does not resolve to a feature type: ", sFeatureTypeId); outputFeatureType = (SimpleFeatureType) cli.getGeogig() .command(RevObjectParse.class) .setObjectId(id.get()) .call(RevFeatureType.class) .get() .type(); featureTypeId = id.get(); } else { try { SimpleFeatureType sft = getFeatureType(path, cli); outputFeatureType = new SimpleFeatureTypeImpl( new NameImpl(tableName), sft.getAttributeDescriptors(), sft.getGeometryDescriptor(), sft.isAbstract(), sft.getRestrictions(), sft.getSuper(), sft.getDescription()); } catch (GeoToolsOpException e) { throw new CommandFailedException("No features to export.", e); } } try { dataStore.createSchema(outputFeatureType); } catch (IOException e) { throw new CommandFailedException("Cannot create new table in database", e); } } else { if (!overwrite) { throw new CommandFailedException("The selected table already exists. Use -o to overwrite"); } } SimpleFeatureSource featureSource = dataStore.getFeatureSource(tableName); if (!(featureSource instanceof SimpleFeatureStore)) { throw new CommandFailedException("Can't write to the selected table"); } SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource; if (overwrite) { try { featureStore.removeFeatures(Filter.INCLUDE); } catch (IOException e) { throw new CommandFailedException("Error truncating table: " + e.getMessage(), e); } } ExportOp op = cli.getGeogig() .command(ExportOp.class) .setFeatureStore(featureStore) .setPath(path) .setFilterFeatureTypeId(featureTypeId) .setAlter(alter); if (defaultType) { op.exportDefaultFeatureType(); } try { op.setProgressListener(cli.getProgressListener()).call(); } catch (IllegalArgumentException iae) { throw new org.locationtech.geogig.cli.InvalidParameterException(iae.getMessage(), iae); } catch (GeoToolsOpException e) { switch (e.statusCode) { case MIXED_FEATURE_TYPES: throw new CommandFailedException( "The selected tree contains mixed feature types. Use --defaulttype or --featuretype <feature_type_ref> to export.", e); default: throw new CommandFailedException("Could not export. Error:" + e.statusCode.name(), e); } } cli.getConsole().println(path + " exported successfully to " + tableName); }
/** * Applies a set of heuristics to find which target attribute corresponds to a certain input * attribute * * @param sourceType * @param targetType * @return */ Map<String, String> buildAttributeMapping( SimpleFeatureType sourceType, SimpleFeatureType targetType) { // look for the typical manglings. For example, if the target is a // shapefile store it will move the geometry and name it the_geom // collect the source names Set<String> sourceNames = new HashSet<String>(); for (AttributeDescriptor sd : sourceType.getAttributeDescriptors()) { sourceNames.add(sd.getLocalName()); } // first check if we have been kissed by sheer luck and the names are // the same Map<String, String> result = new HashMap<String, String>(); for (String name : sourceNames) { if (targetType.getDescriptor(name) != null) { result.put(name, name); } } sourceNames.removeAll(result.keySet()); // then check for simple case difference (Oracle case) for (String name : sourceNames) { for (AttributeDescriptor td : targetType.getAttributeDescriptors()) { if (td.getLocalName().equalsIgnoreCase(name)) { result.put(name, td.getLocalName()); break; } } } sourceNames.removeAll(result.keySet()); // then check attribute names being cut (another Oracle case) for (String name : sourceNames) { String loName = name.toLowerCase(); for (AttributeDescriptor td : targetType.getAttributeDescriptors()) { String tdName = td.getLocalName().toLowerCase(); if (loName.startsWith(tdName)) { result.put(name, td.getLocalName()); break; } } } sourceNames.removeAll(result.keySet()); // consider the shapefile geometry descriptor mangling if (targetType.getGeometryDescriptor() != null && "the_geom".equals(targetType.getGeometryDescriptor().getLocalName()) && !"the_geom".equalsIgnoreCase(sourceType.getGeometryDescriptor().getLocalName())) { result.put(sourceType.getGeometryDescriptor().getLocalName(), "the_geom"); } // and finally we return with as much as we can match if (!sourceNames.isEmpty()) { LOGGER.warning( "Could not match the following attributes " + sourceNames + " to the target feature type ones: " + targetType); } return result; }
/** * Creates a query to be executed over an inprocess view (a view defined by a SQL SELECT statement * at the datastore configuration) * * @return the newly created ArcSDEQuery. * @throws IOException see <i>throws DataSourceException</i> bellow. * @see ArcSDEDataStore#registerView(String, PlainSelect) */ public static ArcSDEQuery createInprocessViewQuery( final ISession session, final SimpleFeatureType fullSchema, final Query query, final SeQueryInfo definitionQuery, final PlainSelect viewSelectStatement) throws IOException { final Filter filter = query.getFilter(); final FIDReader fidReader = FIDReader.NULL_READER; // the first table has to be the main layer final SeSqlConstruct construct; try { construct = definitionQuery.getConstruct(); } catch (SeException e) { throw new ArcSdeException("shouldn't happen: " + e.getMessage(), e); } final String[] tables = construct.getTables(); String layerName = tables[0]; // @REVISIT: HACK HERE!, look how to get rid of alias in // query info, or // better stop using queryinfo as definition query and use // the PlainSelect, // then construct the query info dynamically when needed? if (layerName.indexOf(" AS") > 0) { layerName = layerName.substring(0, layerName.indexOf(" AS")); } final SeTable sdeTable = session.getTable(layerName); final SeLayer sdeLayer; if (fullSchema.getGeometryDescriptor() == null) { sdeLayer = null; } else { sdeLayer = session.getLayer(layerName); } // create the set of filters to work over final ArcSDEQuery.FilterSet filters = new ArcSDEQuery.FilterSet( sdeTable, sdeLayer, filter, fullSchema, definitionQuery, viewSelectStatement, fidReader); final Filter unsupportedFilter = filters.getUnsupportedFilter(); final String[] queryProperties = query.getPropertyNames(); final SimpleFeatureType querySchema = getQuerySchema(queryProperties, unsupportedFilter, fullSchema); final ArcSDEQuery sdeQuery; sdeQuery = new ArcSDEQuery( session, querySchema, filters, null, fidReader, ArcSdeVersionHandler.NONVERSIONED_HANDLER); return sdeQuery; }
/* * Alte methode versuch wie shapefile zu importieren. könnte teilweise noch * hilfreich sein <- war doch richtig.. */ public void readFile(String tableName, File file) throws IOException { final InputStream inputstream = new FileInputStream(file); GeometryJSON gjson = new GeometryJSON(15); FeatureJSON fjson = new FeatureJSON(gjson); // System.out.println(fjson.readCRS(inputstream)); FeatureCollection<SimpleFeatureType, SimpleFeature> jfc = fjson.readFeatureCollection(inputstream); final SimpleFeatureType jsonSchema = jfc.getSchema(); final SimpleFeatureTypeBuilder dbSftBuilder = new SimpleFeatureTypeBuilder(); final List<AttributeDescriptor> ads = jsonSchema.getAttributeDescriptors(); for (final AttributeDescriptor ad : ads) { final String n = ad.getName().toString(); final Name name = new NameImpl(n.toUpperCase()); final AttributeDescriptor t = new AttributeDescriptorImpl( ad.getType(), name, ad.getMinOccurs(), ad.getMaxOccurs(), ad.isNillable(), ad.getDefaultValue()); dbSftBuilder.add(t); } // TODO: EPSG!! this.epsg = ""; this.geomType = jsonSchema.getGeometryDescriptor().getType().getBinding().getName(); dbSftBuilder.setName(new NameImpl(tableName)); final SimpleFeatureType dbSchema = dbSftBuilder.buildFeatureType(); List<SimpleFeature> sfList = new ArrayList<SimpleFeature>(); // Getting Geomtries and Attributes right try (FeatureIterator<SimpleFeature> jsonFeatures = jfc.features()) { String bar = null; while (jsonFeatures.hasNext()) { final SimpleFeature sf = jsonFeatures.next(); String foo = sf.getDefaultGeometry().getClass().getName(); // falls verschiedene Geoemtrien im JSON sind nur die erste // Anzeigen, alle anderen ignorieren. if (bar != null && !foo.equals(bar)) { System.out.println(foo); continue; } SimpleFeatureBuilder dbSfBuilder = new SimpleFeatureBuilder(dbSchema); for (final AttributeDescriptor ad : jsonSchema.getAttributeDescriptors()) { final String attr = ad.getLocalName(); final String name = attr.toUpperCase(); Object obj = sf.getAttribute(attr); dbSfBuilder.set(name, obj); } final SimpleFeature of = dbSfBuilder.buildFeature(null); sfList.add(of); bar = foo; } } FeatureCollection<SimpleFeatureType, SimpleFeature> collection = new ListFeatureCollection(dbSchema, sfList); dbCollection = collection; }