Java SimpleFeatureTypeBuilder类代码示例

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
public SimpleFeatureType createFeatureType(Geometry newGeometry, String uuid, CoordinateReferenceSystem coordinateReferenceSystem) {
    String namespace = "http://www.52north.org/" + uuid;

    SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder();
    if (coordinateReferenceSystem == null) {
        coordinateReferenceSystem = getDefaultCRS();
    }
    typeBuilder.setCRS(coordinateReferenceSystem);
    typeBuilder.setNamespaceURI(namespace);
    Name nameType = new NameImpl(namespace, "Feature-" + uuid);
    typeBuilder.setName(nameType);

    typeBuilder.add("GEOMETRY", newGeometry.getClass());

    SimpleFeatureType featureType;

    featureType = typeBuilder.buildFeatureType();
    return featureType;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
/**
 * Here is how you can use a SimpleFeatureType builder to create the schema for your shapefile dynamically.
 * <p>
 * This method is an improvement on the code used in the main method above (where we used DataUtilities.createFeatureType) because we
 * can set a Coordinate Reference System for the FeatureType and a a maximum field length for the 'name' field dddd
 */
private static SimpleFeatureType createFeatureType() {
	
	SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
	builder.setName("Location");
	builder.setCRS(DefaultGeographicCRS.WGS84); // <- Coordinate reference system
	
	// add attributes in order
	builder.add("the_geom", Point.class);
	builder.length(15).add("Name", String.class); // <- 15 chars width for name field
	
	// build the type
	final SimpleFeatureType LOCATION = builder.buildFeatureType();
	
	return LOCATION;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
/**
 * Here is how you can use a SimpleFeatureType builder to create the schema for your shapefile dynamically.
 * <p>
 * This method is an improvement on the code used in the main method above (where we used DataUtilities.createFeatureType) because we
 * can set a Coordinate Reference System for the FeatureType and a a maximum field length for the 'name' field dddd
 */
@SuppressWarnings("unused")
private static SimpleFeatureType createFeatureType() {
	
	SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
	builder.setName("Location");
	builder.setCRS(DefaultGeographicCRS.WGS84); // <- Coordinate reference system
	
	// add attributes in order
	builder.add("Location", Point.class);
	builder.length(15).add("Name", String.class); // <- 15 chars width for name field
	
	// build the type
	final SimpleFeatureType LOCATION = builder.buildFeatureType();
	
	return LOCATION;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private static SimpleFeatureType createFeatureType(List<Integer> years) {

	SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
	builder.setName("FHAES");
	builder.setCRS(DefaultGeographicCRS.WGS84); // <- Coordinate reference system
	
	// add attributes in order
	builder.add("the_geom", Point.class);
	builder.add("name", String.class);
	for (Integer i : years)
	{
		builder.add(i + "", Integer.class);
	}
	
	// build the type
	final SimpleFeatureType FHAES = builder.buildFeatureType();
	
	return FHAES;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private static SimpleFeatureType createStyle2FeatureType() {

	SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
	builder.setName("FHAES");
	builder.setCRS(DefaultGeographicCRS.WGS84); // <- Coordinate reference system
	
	// add attributes in order
	builder.add("the_geom", Point.class);
	builder.add("name", String.class);
	builder.add("year", Integer.class);
	builder.add("value", Integer.class);
	
	// build the type
	final SimpleFeatureType FHAES = builder.buildFeatureType();
	
	return FHAES;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
/**
 * The purpose of this method is to generate the schema definition for the GeoJSON.
 * @return SimpleFeatureType defining the the feature properties.
 */
public SimpleFeatureType getFeatureSchema() {
    final SimpleFeatureTypeBuilder simpleFeatureType = new SimpleFeatureTypeBuilder();
    simpleFeatureType.add("geom", LineString.class, DefaultGeographicCRS.WGS84);
    simpleFeatureType.add("name", String.class);
    simpleFeatureType.add("activityId", Long.class);
    simpleFeatureType.setName("activity");
    simpleFeatureType.add("name", String.class);
    simpleFeatureType.add("sport", String.class);
    simpleFeatureType.add("startTime", String.class);
    simpleFeatureType.add("totalMeters", Double.class);
    simpleFeatureType.add("totalSeconds", Double.class);
    simpleFeatureType.add("minLat", Double.class);
    simpleFeatureType.add("minLon", Double.class);
    simpleFeatureType.add("maxLat", Double.class);
    simpleFeatureType.add("maxLon", Double.class);
    return simpleFeatureType.buildFeatureType();
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private SimpleFeatureType createFeatureType() {

		SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
		builder.setName("GPX");
		builder.setCRS(DefaultGeographicCRS.WGS84);

		// add attributes in order
		builder.add("the_geom", Point.class);
		builder.add("gpx_id", Integer.class);
		builder.add("trk_id", Integer.class);
		builder.add("seg_id", Integer.class);
		builder.add("trkpt_id", Integer.class);
		builder.add("timestamp", String.class);
		builder.add("ele", Double.class);

		return builder.buildFeatureType();
	}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
public static SimpleFeatureCollection createAggregationFeatures(List<Map<String,Object>> data) {
    final SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
    builder.setName( "testType" );
    builder.add("_aggregation", HashMap.class );
    builder.add("aString", String.class );
    final SimpleFeatureType featureType = builder.buildFeatureType();
    final DefaultFeatureCollection collection = new DefaultFeatureCollection();
    final SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(featureType);
    data.stream().forEach(item -> {
        item.keySet().stream().forEach(key -> {
            featureBuilder.set(key, item.get(key));
        });
        collection.add(featureBuilder.buildFeature(null));
    });
    return collection;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
/**
 * Here is how you can use a SimpleFeatureType builder to create the schema for your shapefile
 * dynamically.
 * <p>
 * This method is an improvement on the code used in the main method above (where we used
 * DataUtilities.createFeatureType) because we can set a Coordinate Reference System for the
 * FeatureType and a a maximum field length for the 'name' field
 */
private static SimpleFeatureType createFeatureType(String name) {

    SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
    builder.setName(name);
    builder.setCRS(DefaultGeographicCRS.WGS84); // <- Coordinate reference system

    // add attributes in order
    builder.add("the_geom", MultiPolygon.class);
    builder.length(50).add("au_name", String.class); // <- 15 chars width for name field
    builder.add("value", Double.class);
    builder.add("legend", Double.class);
    
    // build the type
    final SimpleFeatureType SOIL_INDEX_TYPE = builder.buildFeatureType();

    return SOIL_INDEX_TYPE;
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private static Layer createExtraFeatures() {
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName("Location");
    b.setCRS(DefaultGeographicCRS.WGS84);
    // picture location
    b.add("geom", Point.class);
    final SimpleFeatureType TYPE = b.buildFeatureType();

    GeometryFactory gf = JTSFactoryFinder.getGeometryFactory();
    Point point = gf.createPoint(new Coordinate(CANBERRA_LONG, CANBERRA_LAT));

    SimpleFeatureBuilder builder = new SimpleFeatureBuilder(TYPE);
    builder.add(point);
    SimpleFeature feature = builder.buildFeature("Canberra");
    DefaultFeatureCollection features = new DefaultFeatureCollection(null, null);
    features.add(feature);

    Style style = SLD.createPointStyle("Star", Color.BLUE, Color.BLUE, 0.3f, 10);

    return new FeatureLayer(features, style);
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private void createPolygons( CoordinateReferenceSystem crs, GeometryFactory gf, List<Geometry> polygons ) {
    outMap = new DefaultFeatureCollection();
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName(POLYGON);
    b.setCRS(crs);
    b.add("the_geom", Polygon.class);
    b.add("id", Long.class);
    SimpleFeatureType type = b.buildFeatureType();
    SimpleFeatureBuilder fbuilder = new SimpleFeatureBuilder(type);

    long index = 0;
    int numGeometries = polygons.size();
    for( int i = 0; i < numGeometries; i++ ) {
        Geometry geometry = polygons.get(i);
        Object[] values = new Object[]{geometry, index++};
        fbuilder.addAll(values);
        SimpleFeature feature = fbuilder.buildFeature(null);
        ((DefaultFeatureCollection) outMap).add(feature);
    }
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private void createPoints( CoordinateReferenceSystem crs, GeometryFactory gf, List<LineString> verticals,
        List<LineString> horizontals ) {
    outMap = new DefaultFeatureCollection();
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName(POINT);
    b.setCRS(crs);
    b.add("the_geom", Point.class);
    b.add("id", Long.class);
    SimpleFeatureType type = b.buildFeatureType();
    SimpleFeatureBuilder fbuilder = new SimpleFeatureBuilder(type);

    Geometry gVer = gf.createMultiLineString(verticals.toArray(new LineString[0]));
    Geometry gHor = gf.createMultiLineString(horizontals.toArray(new LineString[0]));

    Geometry intersection = gHor.intersection(gVer);

    long index = 0;
    int numGeometries = intersection.getNumGeometries();
    for( int i = 0; i < numGeometries; i++ ) {
        Geometry geometry = intersection.getGeometryN(i);
        Object[] values = new Object[]{geometry, index++};
        fbuilder.addAll(values);
        SimpleFeature feature = fbuilder.buildFeature(null);
        ((DefaultFeatureCollection) outMap).add(feature);
    }
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
private void createBboxGeometry( CoordinateReferenceSystem crs, File lasFile, SimpleFeatureCollection outGeodata )
        throws IOException {
    final ReferencedEnvelope3D envelope = lasReader.getHeader().getDataEnvelope();
    ReferencedEnvelope env2d = new ReferencedEnvelope(envelope);
    final Polygon polygon = FeatureUtilities.envelopeToPolygon(new Envelope2D(env2d));

    final SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName("lasdataenvelope");
    b.setCRS(crs);
    b.add("the_geom", Polygon.class);
    b.add("id", String.class);
    final SimpleFeatureType type = b.buildFeatureType();

    final SimpleFeatureBuilder builder = new SimpleFeatureBuilder(type);
    final Object[] values = new Object[]{polygon, lasFile.getName()};
    builder.addAll(values);
    final SimpleFeature feature = builder.buildFeature(null);
    ((DefaultFeatureCollection) outGeodata).add(feature);
    OmsVectorWriter.writeVector(outFile, outGeodata);
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
/**
 * @param oldFeatureType the {@link FeatureType} of the existing features.
 * @throws FactoryRegistryException 
 * @throws SchemaException
 */
public FeatureGeometrySubstitutor( SimpleFeatureType oldFeatureType, Class< ? > newGeometryType ) throws Exception {

    List<AttributeDescriptor> oldAttributeDescriptors = oldFeatureType.getAttributeDescriptors();

    // create the feature type
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName(oldFeatureType.getName());
    b.setCRS(oldFeatureType.getCoordinateReferenceSystem());

    if (newGeometryType == null) {
        b.addAll(oldAttributeDescriptors);
    } else {
        for( AttributeDescriptor attributeDescriptor : oldAttributeDescriptors ) {
            if (attributeDescriptor instanceof GeometryDescriptor) {
                b.add("the_geom", newGeometryType);
            } else {
                b.add(attributeDescriptor);
            }
        }
    }
    newFeatureType = b.buildFeatureType();
}
 

import org.geotools.feature.simple.SimpleFeatureTypeBuilder; //导入依赖的package包/类
public static SimpleFeatureBuilder getNmeaFeatureBuilder() {
    SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
    b.setName("nmea");
    b.setCRS(DefaultGeographicCRS.WGS84);
    b.add("the_geom", Point.class);
    b.add(NmeaGpsPoint.strSpeed, Double.class);
    b.add(NmeaGpsPoint.strAltitude, Double.class);
    b.add(NmeaGpsPoint.strQuality, Double.class);
    b.add(NmeaGpsPoint.strSat, Integer.class);
    b.add(NmeaGpsPoint.strHdop, Double.class);
    b.add(NmeaGpsPoint.strMsl, Double.class);
    b.add(NmeaGpsPoint.strUtctime, String.class);
    b.add(NmeaGpsPoint.strMag_var, Double.class);
    b.add(NmeaGpsPoint.strAngle, Double.class);
    final SimpleFeatureType featureType = b.buildFeatureType();
    SimpleFeatureBuilder nmeaSimpleFeatureBuilder = new SimpleFeatureBuilder(featureType);
    return nmeaSimpleFeatureBuilder;
}