Examples of org.geotools.feature.simple.SimpleFeatureTypeBuilder

org.geotools.feature.simple.SimpleFeatureTypeBuilder
e the builder SimpleTypeBuilder builder = new SimpleTypeBuilder(); //set global state builder.setName( "testType" ); builder.setNamespaceURI( "http://www.geotools.org/" ); builder.setSRS( "EPSG:4326" ); //add attributes builder.add( "intProperty", Integer.class ); builder.add( "stringProperty", String.class ); builder.add( "pointProperty", Point.class ); //add attribute setting per attribute state builder.minOccurs(0).maxOccurs(2).nillable(false).add("doubleProperty",Double.class); //build the type SimpleFeatureType featureType = builder.buildFeatureType();
This builder builds type by maintaining state. Two types of state are maintained: Global Type State and Per Attribute State. Methods which set global state are named set<property>(). Methods which set per attribute state are named <property>(). Furthermore calls to per attribute

Global state is reset after a call to {@link #buildFeatureType()}. Per attribute state is reset after a call to {@link #add}.

A default geometry for the feature type can be specified explictly via {@link #setDefaultGeometry(String)}. However if one is not set the first geometric attribute ( {@link GeometryType}) added will be resulting default. So if only specifying a single geometry for the type there is no need to call the method. However if specifying multiple geometries then it is good practice to specify the name of the default geometry type. For instance:
```
 builder.add( "pointProperty", Point.class ); builder.add( "lineProperty", LineString.class ); builder.add( "polygonProperty", Polygon.class ); builder.setDefaultGeometry( "lineProperty" ); 
```
@author Justin Deolivera @author Jody Garnett @source $URL$

                return;
            }
        }
        catch( Exception e ) {}
        
        SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
        tb.setName( "widgetsNG" );
        tb.add( "name", String.class );
        
        ds.createSchema( tb.buildFeatureType() );
        
        FeatureWriter fw = ds.getFeatureWriterAppend( "widgetsNG", Transaction.AUTO_COMMIT );
        fw.hasNext();
        SimpleFeature sf = (SimpleFeature) fw.next();
        sf.setAttribute( "name", "one");

View Full Code Here

        layerInfo.setEnabled(true);
        layerInfo.setDefaultStyle(defaultStyle);
        layerInfo.setType(LayerInfo.Type.VECTOR);
        catalog.add(layerInfo);


        SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder();
        ftb.setNamespaceURI(TEST_NAMESPACE);
        ftb.setName(name);
        ftb.add("name", String.class);
        ftb.add("geom", geometryType, wgs84);
        SimpleFeatureType featureType = ftb.buildFeatureType();
        dataStore.createSchema(featureType);


        return new MapLayerInfo(layerInfo);
    }

View Full Code Here

        Polygon polygon = gf.createPolygon(gf
                .createLinearRing(new Coordinate[] { new Coordinate(0, 0),
                        new Coordinate(0, 200), new Coordinate(200, 200),
                        new Coordinate(200, 0), new Coordinate(0, 0) }), null);
        
        SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder();
        ftb.setName("test");
        ftb.add("geom", Geometry.class);
        SimpleFeatureType type = ftb.buildFeatureType();


        SimpleFeature f1 = SimpleFeatureBuilder.build(type, new Object[] { point }, null);
        SimpleFeature f2 = SimpleFeatureBuilder.build(type, new Object[] { line }, null);
        SimpleFeature f3 = SimpleFeatureBuilder.build(type, new Object[] { polygon }, null);

View Full Code Here

    SimpleFeatureType buildFeatureType( String name, String namespaceURI, int srid, List<String> names, List<String> mandatory, Class... types ) {
        if ( aliases != null && aliases.containsKey( name ) ) {
            name = (String) aliases.get( name );
        }
        
        SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder();
        b.setName( name );
        b.setNamespaceURI( namespaceURI );
        try {
            b.setCRS( CRS.decode( "EPSG:" + srid) );
        } 
        catch( Exception e ) {
            throw new RuntimeException( e );
        }
        
        for ( int i = 0; i < names.size(); i++ ) {
            String attName = names.get( i );
            if ( mandatory.contains( attName ) ) {
                b.minOccurs( 1 );
                b.nillable(false);
            }
            if ( "description".equalsIgnoreCase( attName) ) {
                b.length( 5000 );
            }
            
            b.add(  attName, types[ i ] );
        }
        
        return b.buildFeatureType();
    }

View Full Code Here

        c = remapCollectionSchema(c, null);
        
        SimpleFeatureType schema = c.getSchema();
        if(schema.getTypeName().contains(".")) {
          // having dots in the name prevents various programs to recognize the file as a shapefile
          SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
          tb.init(c.getSchema());
          tb.setName(c.getSchema().getTypeName().replace('.', '_'));
          SimpleFeatureType renamed = tb.buildFeatureType();
          c = new RetypingFeatureCollection(c, renamed);
        }


        FeatureStore<SimpleFeatureType, SimpleFeature> fstore = null;
        ShapefileDataStore dstore = null;

View Full Code Here

    FeatureCollection<SimpleFeatureType, SimpleFeature> remapCollectionSchema(FeatureCollection<SimpleFeatureType, SimpleFeature> fc, Class targetGeometry) {
        SimpleFeatureType schema = fc.getSchema();
        
        // having dots in the name prevents various programs to recognize the file as a shapefile
        if(schema.getTypeName().contains(".")) {
            SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
            if(targetGeometry == null) {
                tb.init(schema);
            } else {
                // force generic geometric attributes to the desired geometry type
                for (AttributeDescriptor ad : schema.getAttributeDescriptors()) {
                    if(!(ad instanceof GeometryDescriptor)) {
                        tb.add(ad);
                    } else {
                        Class geomType = ad.getType().getBinding();
                        if(geomType.equals(Geometry.class) || geomType.equals(GeometryCollection.class)) {
                            tb.add(ad.getName().getLocalPart(), targetGeometry, 
                                    ((GeometryDescriptor) ad).getCoordinateReferenceSystem());
                        } else {
                            tb.add(ad);
                        }
                    }
                } 
            }
            tb.setName(fc.getSchema().getTypeName().replace('.', '_'));
            SimpleFeatureType renamed = tb.buildFeatureType();
            fc = new RetypingFeatureCollection(fc, renamed);
        }
        
        // create attribute name mappings, to be compatible 
        // with shapefile constraints:

View Full Code Here

        // see if we already have a cached writer
        StoreWriter storeWriter = writers.get(target);
        if(storeWriter == null) {
            // retype the schema
            SimpleFeatureType original = f.getFeatureType();
            SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
            for (AttributeDescriptor d : original.getAttributeDescriptors()) {
                if(Geometry.class.isAssignableFrom(d.getType().getBinding())) {
                    GeometryDescriptor gd = (GeometryDescriptor) d;
                    builder.add(gd.getLocalName(), target, gd.getCoordinateReferenceSystem());
                    builder.setDefaultGeometry(gd.getLocalName());
                } else {
                    builder.add(d);
                }
            }
            builder.setName(original.getTypeName().replace('.', '_') + suffix);
            builder.setNamespaceURI(original.getName().getURI());
            SimpleFeatureType retyped = builder.buildFeatureType();
            
            // create the datastore for the current geom type
            DataStore dstore = buildStore(tempDir, charset, retyped);
            
            // cache it

View Full Code Here

                    
                    // TODO: support reprojection for non-simple FeatureType
                    if (ft instanceof SimpleFeatureType) {
                        SimpleFeatureType sft = (SimpleFeatureType) ft;
                        //create the feature type so it lines up with the "declared" schema
                        SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
                        tb.setName( info.getName() );
                        tb.setNamespaceURI( info.getNamespace().getURI() );


                        if ( info.getAttributes() == null || info.getAttributes().isEmpty() ) {
                            //take this to mean just load all native
                            for ( PropertyDescriptor pd : ft.getDescriptors() ) {
                                if ( !( pd instanceof AttributeDescriptor ) ) {
                                    continue;
                                }
                                
                                AttributeDescriptor ad = (AttributeDescriptor) pd;
                                ad = handleDescriptor(ad, info);
                                tb.add( ad );
                            }
                        }
                        else {
                            //only load native attributes configured
                            for ( AttributeTypeInfo att : info.getAttributes() ) {
                                String attName = att.getName();
                                
                                //load the actual underlying attribute type
                                PropertyDescriptor pd = ft.getDescriptor( attName );
                                if ( pd == null || !( pd instanceof AttributeDescriptor) ) {
                                    throw new IOException("the SimpleFeatureType " + info.getPrefixedName()
                                            + " does not contains the configured attribute " + attName
                                            + ". Check your schema configuration");
                                }
                            
                                AttributeDescriptor ad = (AttributeDescriptor) pd;
                                ad = handleDescriptor(ad, info);
                                tb.add( (AttributeDescriptor) ad );
                            }
                        }
                        ft = tb.buildFeatureType();
                    } // end special case for SimpleFeatureType
                    
                    featureTypeCache.put( info, ft ); 
                }
            }

View Full Code Here

    }


    private SimpleFeature createCrsBoundsFeature(Geometry geom, CoordinateReferenceSystem crs) {
        SimpleFeatureType featureType;


        SimpleFeatureTypeBuilder sftb = new SimpleFeatureTypeBuilder();
        sftb.setName("Bounds");
        try {
            sftb.add("the_geom", Geometry.class, CRS.decode("EPSG:4326", true));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


        featureType = sftb.buildFeatureType();


        SimpleFeature feature = SimpleFeatureBuilder.template(featureType, null);
        feature.setAttribute("the_geom", geom);
        return feature;
    }

View Full Code Here

            throw new RuntimeException(e);
        }
    }


    private DataStore createLatLonDataStore() throws Exception {
        SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
        tb.setName("latlon");
        tb.add("the_geom", LineString.class, CRS.decode("EPSG:4326", true));
        tb.add("level", Integer.class);


        SimpleFeatureType type = tb.buildFeatureType();
        MemoryDataStore ds = new MemoryDataStore();


        ds.createSchema(type);


        FeatureWriter<SimpleFeatureType, SimpleFeature> writer;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.geotools.feature.simple.SimpleFeatureTypeBuilder

it.geosolutions.geobatch.unredd.script.util.PostGISUtils

MainView

mil.nga.giat.geowave.types.geolife.GeoLifeUtils

mil.nga.giat.geowave.types.gpx.GpxUtils

org.catais.veriso.utils.GtUtils

org.geoserver.catalog.ResourcePool

org.geoserver.catalog.rest.FeatureTypeResource

org.geoserver.catalog.rest.JDBCTest

org.geoserver.feature.retype.RetypingFeatureSourceTest

org.geoserver.importer.FeatureDataConverterTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.