static SimpleFeatureType makeContourSchema() { /* Create the output feature schema. */ SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("contours"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); // Do not use "geom" or "geometry" below, it seems to broke shapefile generation tbuilder.add("the_geom", MultiPolygon.class); tbuilder.add("time", Integer.class); // TODO change to something more descriptive and lowercase return tbuilder.buildFeatureType(); }
/** * * Takes into account eventual joins * * @param query * @return */ public SimpleFeatureType getFeatureType(Query query) { SimpleFeatureType result; if (query.getPropertyNames() != Query.ALL_NAMES) { result = SimpleFeatureTypeBuilder.retype(featureType, query.getPropertyNames()); } else { result = featureType; } // add back the joined features in case of join if (!query.getJoins().isEmpty()) { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(result); for (Join join : query.getJoins()) { String joinedFeatureAttribute = join.getAlias(); if (joinedFeatureAttribute == null) { joinedFeatureAttribute = join.getTypeName(); } tb.add(joinedFeatureAttribute, SimpleFeature.class); } result = tb.buildFeatureType(); } return result; }
/** @return a simple feature type with location before count */ private SimpleFeatureType buildLocationCountType() { SimpleFeatureTypeBuilder builder = buildPartialBuilder(); builder.add("location", Point.class, (CoordinateReferenceSystem) null); builder.add("count", Integer.class); return builder.buildFeatureType(); }
public void testMaintainDefaultGeometryOnRetype() { builder.setName("testGeometries"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("geo2", Polygon.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("geo1"); SimpleFeatureType type = builder.buildFeatureType(); // performing an attribute selection, even changing order, should not change // the default geometry, that had a special meaning in the original source SimpleFeatureType retyped = SimpleFeatureTypeBuilder.retype(type, new String[] {"geo2", "geo1"}); assertEquals("geo1", retyped.getGeometryDescriptor().getLocalName()); }
static SimpleFeatureType makePointSchema() { SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("points"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); tbuilder.add("Geometry", Point.class); tbuilder.add("Time", Integer.class); return tbuilder.buildFeatureType(); }
SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.init(schema); typeBuilder.add(attName, SimpleFeature.class); schema = typeBuilder.buildFeatureType();
public void testRetypeGeometryless() { builder.setName("testGeometryless"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("integer", Integer.class); builder.setDefaultGeometry("geo1"); SimpleFeatureType type = builder.buildFeatureType(); // performing an attribute selection, even changing order, should not change // the default geometry, that had a special meaning in the original source SimpleFeatureType retyped = SimpleFeatureTypeBuilder.retype(type, new String[] {"integer"}); assertNotNull(retyped); assertNull(retyped.getGeometryDescriptor()); assertEquals(1, retyped.getAttributeCount()); assertEquals("integer", retyped.getAttributeDescriptors().get(0).getLocalName()); }
/** @return a simple feature type with count before location */ private SimpleFeatureType buildCountLocationType() { SimpleFeatureTypeBuilder builder = buildPartialBuilder(); builder.add("count", Integer.class); builder.add("location", Point.class, (CoordinateReferenceSystem) null); return builder.buildFeatureType(); }
static SimpleFeatureType makeContourSchema() { /* Create the output feature schema. */ SimpleFeatureTypeBuilder tbuilder = new SimpleFeatureTypeBuilder(); tbuilder.setName("contours"); tbuilder.setCRS(DefaultGeographicCRS.WGS84); tbuilder.add("Geometry", MultiPolygon.class); tbuilder.add("Time", Integer.class); return tbuilder.buildFeatureType(); }
protected SimpleFeatureType createSchema() throws SchemaException { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); for (int i = 0, ii = attributeReader.getAttributeCount(); i < ii; i++) { builder.add(attributeReader.getAttributeType(i)); } return builder.buildFeatureType(); }
/** * Flattens a SimpleFeatureCollection that may contain SimpleFeatures as attributes of other * features. * * @param collection The input SimpleFeatureCollection * @return A SimpleFeatureCollection whose features have no SimpleFeature attributes, or the * original one, if no SimpleFeature attributes were found */ public static SimpleFeatureCollection flatten(SimpleFeatureCollection collection) { SimpleFeatureType schema = collection.getSchema(); // collect the attributes List<AttributeDescriptor> attributeDescriptors = new ArrayList<AttributeDescriptor>(); scanAttributeDescriptors(attributeDescriptors, schema, null); // build the flattened feature type SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName(schema.getName()); for (AttributeDescriptor desc : attributeDescriptors) builder.add(desc); SimpleFeatureType flattenedType = builder.buildFeatureType(); // if the number of attributes is the same, we did not encounter a new attribute if (collection.getSchema().getAttributeCount() == flattenedType.getAttributeCount()) { return collection; } return new FlatteningFeatureCollection(collection, flattenedType); }
private SimpleFeatureType buildTargetSchema(SimpleFeatureType sourceSchema) { if (sourceSchema.getDescriptor("location") != null) { return sourceSchema; } SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(sourceSchema); tb.add("location", String.class); return tb.buildFeatureType(); } }
SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder(); ftb.add("description", String.class); ftb.add("pointProperty", MultiPoint.class); // poly -> multi-poly ftb.add("intProperty", Long.class); // int -> long ftb.add("dateTimeProperty", Date.class); // timestamp -> date ftb.add("newProperty", String.class); // new property ftb.setName(RENAMED); // rename type primitive = ftb.buildFeatureType();
static SimpleFeatureType retype(SimpleFeatureType featureType, JoinInfo join) { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.init(featureType); for (JoinPart part : join.getParts()) { b.add(part.getAttributeName(), SimpleFeature.class); } return b.buildFeatureType(); } }
SimpleFeatureType sft = (SimpleFeatureType) ft; SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(sft); tb.setName(info.getName()); tb.setNamespaceURI(info.getNamespace().getURI()); ad = handleDescriptor(ad, info); tb.add(ad); tb.add(ad); ft = tb.buildFeatureType();
private SimpleFeatureType appendAttributes( SimpleFeatureType acc, SimpleFeatureType typeToAppend) { if (typeToAppend == null) { return acc; } SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(acc); for (AttributeDescriptor ad : typeToAppend.getAttributeDescriptors()) { // only add attributes that we don't already have if (acc.getDescriptor(ad.getLocalName()) == null) { tb.add(ad); } } return tb.buildFeatureType(); }
private SimpleFeatureType createType(CoordinateReferenceSystem crs, boolean stretch) { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.add(ATTR_GEOM, Point.class, crs); tb.add(ATTR_COUNT, Integer.class); tb.add(ATTR_COUNT_UNIQUE, Integer.class); tb.add(ATTR_BOUNDING_BOX_GEOM, Polygon.class); tb.add(ATTR_BOUNDING_BOX, String.class); if (stretch) { tb.add(ATTR_NORM_COUNT, Double.class); tb.add(ATTR_NORM_COUNT_UNIQUE, Double.class); } tb.setName("stackedPoint"); SimpleFeatureType sfType = tb.buildFeatureType(); return sfType; }
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()); } else { b.setDefaultGeometry(null); } return b.buildFeatureType(); }
/** * Creates the feature TYPE * * @param typeName name for the feature TYPE; if {@code null} or empty, {@linkplain * #DEFAULT_TYPE_NAME} will be used * @param crs coordinate reference system (may be {@code null}) * @return the feature TYPE */ protected static SimpleFeatureType createType(CoordinateReferenceSystem crs) { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("grid"); tb.add("cell", Polygon.class, crs); tb.add("id", Integer.class); tb.add("centerX", Double.class); tb.add("centerY", Double.class); return tb.buildFeatureType(); }
/** * Copys a feature type. * * <p>This method does a deep copy in that all individual attributes are copied as well. */ public static SimpleFeatureType copy(SimpleFeatureType original) { SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); // initialize the builder b.init(original); // clear attributes b.attributes().clear(); // add attributes in order for (AttributeDescriptor descriptor : original.getAttributeDescriptors()) { AttributeTypeBuilder ab = new AttributeTypeBuilder(b.factory); ab.init(descriptor); b.add(ab.buildDescriptor(descriptor.getLocalName())); } return b.buildFeatureType(); } }