void addGeometryType(SimpleFeatureTypeBuilder typeBuilder, Geometry geometry) { typeBuilder.add("geometry", geometry != null ? geometry.getClass() : Geometry.class); typeBuilder.setDefaultGeometry("geometry"); }
private static void setDefaultGeometry( SimpleFeatureTypeBuilder typeBuilder, String[] properties, SimpleFeatureType featureType) { GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor(); if (geometryDescriptor != null) { String propertyName = geometryDescriptor.getLocalName(); if (Arrays.asList(properties).contains(propertyName)) { typeBuilder.setDefaultGeometry(propertyName); } } } //
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(); }
builder.setDefaultGeometry(attributeType.getLocalName());
@Override protected void setUp() throws Exception { super.setUp(); factory = CommonFactoryFinder.getFilterFactory(null); SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.setName("test"); b.add("name", String.class); b.add("geom", Polygon.class, DefaultGeographicCRS.WGS84); b.setDefaultGeometry("geom"); featureType = b.buildFeatureType(); }
@Override protected SimpleFeatureType buildFeatureType() throws IOException { List<AttributeDescriptor> types = readAttributes(); SimpleFeatureType parent = null; GeometryDescriptor geomDescriptor = (GeometryDescriptor) types.get(0); Class<?> geomBinding = geomDescriptor.getType().getBinding(); if ((geomBinding == Point.class) || (geomBinding == MultiPoint.class)) { parent = BasicFeatureTypes.POINT; } else if ((geomBinding == Polygon.class) || (geomBinding == MultiPolygon.class)) { parent = BasicFeatureTypes.POLYGON; } else if ((geomBinding == LineString.class) || (geomBinding == MultiLineString.class)) { parent = BasicFeatureTypes.LINE; } SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setDefaultGeometry(geomDescriptor.getLocalName()); builder.addAll(types); builder.setName(entry.getName()); builder.setAbstract(false); if (parent != null) { builder.setSuperType(parent); } return builder.buildFeatureType(); }
/** * Create the modified feature type. * * @param sourceFeatureType the source feature type * @return the modified feature type * @throws ProcessException errror */ private SimpleFeatureType createTargetFeatureType(FeatureType sourceFeatureType) throws ProcessException { try { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(sourceFeatureType.getName().getLocalPart()); typeBuilder.setNamespaceURI(sourceFeatureType.getName().getNamespaceURI()); AttributeDescriptor geomAttbType = sourceFeatureType.getGeometryDescriptor(); for (PropertyDescriptor attbType : sourceFeatureType.getDescriptors()) { if (attbType.equals(geomAttbType)) { typeBuilder.add(geomAttbType.getLocalName(), Point.class); } else { typeBuilder.add((AttributeDescriptor) attbType); } } typeBuilder.setDefaultGeometry( sourceFeatureType.getGeometryDescriptor().getLocalName()); return typeBuilder.buildFeatureType(); } catch (Exception e) { LOGGER.warning("Error creating type: " + e); throw new ProcessException("Error creating type: " + e, e); } }
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { // retype from the abstract feature type, since extended data could have altered the schema // placemarks add an additional geometry field SimpleFeature feature = (SimpleFeature) value; SimpleFeatureType abstractFeatureType = feature.getFeatureType(); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(abstractFeatureType); tb.setName("placemark"); tb.add("Geometry", Geometry.class); tb.setDefaultGeometry("Geometry"); SimpleFeatureType placemarkFeatureType = tb.buildFeatureType(); SimpleFeatureBuilder b = new SimpleFeatureBuilder(placemarkFeatureType); b.init(feature); // <element minOccurs="0" ref="kml:Geometry"/> for (Object childObj : node.getChildren(Geometry.class)) { Node childNode = (Node) childObj; String componentName = childNode.getComponent().getName(); if (SUPPORTED_GEOMETRY_TYPES.contains(componentName)) { b.set("Geometry", childNode.getValue()); } } return b.buildFeature(feature.getID()); }
/** * Create the modified feature type. * * @param sourceFeatureType the source feature type * @return the modified feature type * @throws ProcessException errror */ private SimpleFeatureType createTargetFeatureType(FeatureType sourceFeatureType) throws ProcessException { try { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName(sourceFeatureType.getName().getLocalPart()); typeBuilder.setNamespaceURI(sourceFeatureType.getName().getNamespaceURI()); for (PropertyDescriptor attbType : sourceFeatureType.getDescriptors()) { typeBuilder.add((AttributeDescriptor) attbType); } typeBuilder.minOccurs(1).maxOccurs(1).nillable(false).add("lrs_measure", Double.class); typeBuilder.setDefaultGeometry( sourceFeatureType.getGeometryDescriptor().getLocalName()); return typeBuilder.buildFeatureType(); } catch (Exception e) { LOGGER.warning("Error creating type: " + e); throw new ProcessException("Error creating type: " + e, e); } }
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()); }
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()); }
@Before public void setUp() throws Exception { SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder(); ftb.setName("render-test"); ftb.add("the_geom", Point.class, DefaultGeographicCRS.WGS84); ftb.setDefaultGeometry("the_geom"); ftb.add("name", String.class); featureType = ftb.buildFeatureType(); GeometryFactory gf = JTSFactoryFinder.getGeometryFactory(); SimpleFeatureBuilder fb = new SimpleFeatureBuilder(featureType); fb.set("the_geom", gf.createPoint(new Coordinate(10, 10))); fb.set("name", "The name"); feature = fb.buildFeature(null); File shpFile = new File( "./target/screenMapTest/" + feature.getFeatureType().getName().getLocalPart() + ".shp"); shpFile.getParentFile().mkdirs(); ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory(); Map<String, Serializable> params = new HashMap<String, Serializable>(); params.put(ShapefileDataStoreFactory.URLP.key, shpFile.toURI().toURL()); shapeFileDataStore = dataStoreFactory.createNewDataStore(params); shapeFileDataStore.createSchema(feature.getFeatureType()); SimpleFeatureStore featureStore = (SimpleFeatureStore) shapeFileDataStore.getFeatureSource(shapeFileDataStore.getTypeNames()[0]); featureStore.addFeatures(DataUtilities.collection(feature)); RendererBaseTest.setupVeraFonts(); }
@Override protected SimpleFeatureType buildFeatureType() throws IOException { final WFSDataStore dataStore = getDataStore(); final Name localTypeName = getEntry().getName(); final QName remoteTypeName = dataStore.getRemoteTypeName(localTypeName); final SimpleFeatureType remoteSimpleFeatureType; remoteSimpleFeatureType = dataStore.getRemoteSimpleFeatureType(remoteTypeName); // adapt the feature type name SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.init(remoteSimpleFeatureType); builder.setName(localTypeName); String namespaceOverride = entry.getName().getNamespaceURI(); if (namespaceOverride != null) { builder.setNamespaceURI(namespaceOverride); } GeometryDescriptor defaultGeometry = remoteSimpleFeatureType.getGeometryDescriptor(); if (defaultGeometry != null) { builder.setDefaultGeometry(defaultGeometry.getLocalName()); builder.setCRS(defaultGeometry.getCoordinateReferenceSystem()); } final SimpleFeatureType adaptedFeatureType = builder.buildFeatureType(); return adaptedFeatureType; }
@Override protected SimpleFeatureType buildTargetFeatureType() { // create schema SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); for (AttributeDescriptor descriptor : delegate.getSchema().getAttributeDescriptors()) { if (!(descriptor.getType() instanceof GeometryTypeImpl) || (!delegate.getSchema().getGeometryDescriptor().equals(descriptor))) { tb.add(descriptor); } else { AttributeTypeBuilder builder = new AttributeTypeBuilder(); builder.setBinding(MultiPolygon.class); AttributeDescriptor attributeDescriptor = builder.buildDescriptor(descriptor.getLocalName(), builder.buildType()); tb.add(attributeDescriptor); if (tb.getDefaultGeometry() == null) { tb.setDefaultGeometry(descriptor.getLocalName()); } } } tb.setDescription(delegate.getSchema().getDescription()); tb.setCRS(delegate.getSchema().getCoordinateReferenceSystem()); tb.setName(delegate.getSchema().getName()); return tb.buildFeatureType(); }
@Test public void testEquals() { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName("SomeFeature"); builder.setCRS(null); builder.add("name", String.class); builder.add("geom1", Point.class); builder.add("geom2", Point.class); builder.setDefaultGeometry("geom1"); SimpleFeatureType ft1 = builder.buildFeatureType(); builder.setName("SomeFeature"); builder.setCRS(null); builder.add("name", String.class); builder.add("geom1", Point.class); builder.add("geom2", Point.class); builder.setDefaultGeometry("geom1"); SimpleFeatureType ft2 = builder.buildFeatureType(); assertTrue(FeatureTypes.equalsExact(ft1, ft2)); builder.setName("SomeFeature"); builder.setCRS(null); builder.add("name", String.class); builder.add("geom1", Point.class); builder.add("geom2", Point.class); builder.setDefaultGeometry("geom2"); ft2 = builder.buildFeatureType(); assertFalse(FeatureTypes.equalsExact(ft1, ft2)); } }
public void testMaintainDefaultGeometryOnInit() { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName("testGeometries"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("geo2", Polygon.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("geo2"); SimpleFeatureType type1 = builder.buildFeatureType(); builder = new SimpleFeatureTypeBuilder(); builder.init(type1); SimpleFeatureType type2 = builder.buildFeatureType(); assertEquals("geo2", type1.getGeometryDescriptor().getLocalName()); assertEquals("geo2", type2.getGeometryDescriptor().getLocalName()); }
public void testCRS() { builder.setName("testName"); builder.setNamespaceURI("testNamespaceURI"); builder.setCRS(DefaultGeographicCRS.WGS84); builder.crs(null).add("point", Point.class); builder.add("point2", Point.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("point"); SimpleFeatureType type = builder.buildFeatureType(); assertEquals(DefaultGeographicCRS.WGS84, type.getCoordinateReferenceSystem()); assertNull(type.getGeometryDescriptor().getType().getCoordinateReferenceSystem()); assertEquals( DefaultGeographicCRS.WGS84, ((GeometryType) type.getType("point2")).getCoordinateReferenceSystem()); }
public void testRemoveDefaultGeometryAfterInit() { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setName("testGeometries"); builder.add("geo1", Point.class, DefaultGeographicCRS.WGS84); builder.add("geo2", Polygon.class, DefaultGeographicCRS.WGS84); builder.setDefaultGeometry("geo2"); SimpleFeatureType type1 = builder.buildFeatureType(); builder = new SimpleFeatureTypeBuilder(); builder.init(type1); builder.remove("geo2"); SimpleFeatureType type2 = builder.buildFeatureType(); assertEquals("geo2", type1.getGeometryDescriptor().getLocalName()); assertEquals("geo1", type2.getGeometryDescriptor().getLocalName()); } }
/** * DOCUMENT ME! * * @throws SchemaException */ public static SimpleFeatureType createTestType() throws SchemaException { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("test"); tb.setCRS(null); tb.add("testGeometry", Point.class); tb.add("testBoolean", Boolean.class); tb.add("testCharacter", Character.class); tb.add("testByte", Byte.class); tb.add("testShort", Short.class); tb.add("testInteger", Integer.class); tb.add("testLong", Long.class); tb.add("testFloat", Float.class); tb.add("testDouble", Double.class); tb.add("testString", String.class); tb.setDefaultGeometry("testGeometry"); return tb.buildFeatureType(); } }
public void testGetAnyGeometry() throws Exception { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("test"); tb.setCRS(null); tb.add("g1", Point.class); tb.add("g2", Point.class); tb.setDefaultGeometry("g1"); SimpleFeatureType type = tb.buildFeatureType(); SimpleFeatureBuilder b = new SimpleFeatureBuilder(type); b.set("g1", null); Point p = new GeometryFactory().createPoint(new Coordinate(0, 0)); b.set("g2", p); SimpleFeature feature = b.buildFeature(null); assertNull(feature.getDefaultGeometry()); assertEquals( p, SimpleFeaturePropertyAccessorFactory.DEFAULT_GEOMETRY_ACCESS.get( feature, "", Geometry.class)); } }