Package org.opengis.feature.type

Examples of org.opengis.feature.type.GeometryDescriptor


    protected void flush() throws IOException {
        // not sure the check for records <=0 is necessary,
        // but if records > 0 and shapeType is null there's probably
        // another problem.
        if ((records <= 0) && (shapeType == null)) {
            GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor();

            shapeType = JTSUtilities.getShapeType(geometryDescriptor);
        }

        shpWriter.writeHeaders(bounds, shapeType, records, shapefileLength);
View Full Code Here


        //NC - property (namespace) support
        for (PropertyName name : attNames) {
            Object att = name.evaluate(schema);

            if(att instanceof GeometryDescriptor) {
                GeometryDescriptor gd = (GeometryDescriptor) att;
                CoordinateReferenceSystem gdCrs = gd.getCoordinateReferenceSystem();
                if(crs == null) {
                    crs = gdCrs;
                } else if(gdCrs == null) {
                    crs = null;
                    break;
View Full Code Here

        if ( featureSource != null ) {
            FeatureCollection features = null;
            final FeatureType schema = featureSource.getSchema();

            final GeometryDescriptor geometryAttribute = schema.getGeometryDescriptor();
            if(geometryAttribute != null && geometryAttribute.getType() != null) {
                sourceCrs = geometryAttribute.getType().getCoordinateReferenceSystem();
            } else {
                sourceCrs = null;
            }
            if (LOGGER.isLoggable(Level.FINE)) {
                LOGGER.fine("Processing " + style.featureTypeStyles().size() +
View Full Code Here

     * @return
     */
    org.opengis.referencing.crs.CoordinateReferenceSystem getAttributeCRS(PropertyName geomName,
            FeatureType schema) {
        if (geomName == null || "".equals (geomName.getPropertyName())) {
            GeometryDescriptor geom = schema.getGeometryDescriptor();
            return geom.getType().getCoordinateReferenceSystem();
        } else {
            GeometryDescriptor geom = (GeometryDescriptor) geomName.evaluate(schema);
            return geom.getType().getCoordinateReferenceSystem();
        }
    }
View Full Code Here

    }
   
    public void testGeometryMetadataTable() throws Exception {
        testSetup.setupMetadataTable(dataStore);
       
        GeometryDescriptor gd = dataStore.getFeatureSource(tname("gtmeta")).getSchema().getGeometryDescriptor();
        assertEquals(Point.class, gd.getType().getBinding());
        assertEquals(4326, (int) CRS.lookupEpsgCode(gd.getCoordinateReferenceSystem(), false));
    }
View Full Code Here

    private Object createNewLayer(SimpleFeatureType schema, Object dataSource, String[] options,
        FeatureTypeMapper mapper) throws IOException, DataSourceException {
        Object layer;
        // get the spatial reference corresponding to the default geometry
        GeometryDescriptor geomType = schema.getGeometryDescriptor();
        long ogrGeomType = mapper.getOGRGeometryType(geomType);
        Object spatialReference = mapper.getSpatialReference(geomType
                .getCoordinateReferenceSystem());

        // create the layer
        layer = ogr.DataSourceCreateLayer(dataSource, schema.getTypeName(), spatialReference, ogrGeomType, options);
        if (layer == null) {
View Full Code Here

            st = cx.createStatement();

            // register all geometry columns in the database
            for (AttributeDescriptor att : featureType.getAttributeDescriptors()) {
                if (att instanceof GeometryDescriptor) {
                    GeometryDescriptor gd = (GeometryDescriptor) att;

                    if (geometryMetadataTable != null) {
                        // lookup or reverse engineer the srid
                        int srid = -1;
                        if (gd.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID) != null) {
                            srid = (Integer) gd.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID);
                        } else if (gd.getCoordinateReferenceSystem() != null) {
                            try {
                                Integer result = CRS.lookupEpsgCode(
                                        gd.getCoordinateReferenceSystem(), true);
                                if (result != null)
                                    srid = result;
                            } catch (Exception e) {
                                LOGGER.log(Level.FINE, "Error looking up the "
                                        + "epsg code for metadata " + "insertion, assuming -1", e);
                            }
                        }

                        // assume 2 dimensions, but ease future customisation
                        int dimensions = 2;

                        // grab the geometry type
                        String geomType = CLASS_TO_TYPE_MAP.get(gd.getType().getBinding());
                        if (geomType == null)
                            geomType = "GEOMETRY";

                        StringBuilder sqlBuilder = new StringBuilder();

                        // register the geometry type, first remove and eventual
                        // leftover, then write out the real one
                        sqlBuilder.append("DELETE FROM ").append(geometryMetadataTable)
                                .append(" WHERE f_table_schema = '").append(schemaName).append("'")
                                .append(" AND f_table_name = '").append(tableName).append("'")
                                .append(" AND f_geometry_column = '").append(gd.getLocalName())
                                .append("'");
                        LOGGER.fine(sqlBuilder.toString());
                        st.execute(sqlBuilder.toString());

                        sqlBuilder = new StringBuilder();
                        sqlBuilder.append("INSERT INTO ").append(geometryMetadataTable)
                                .append(" VALUES ('").append(schemaName).append("','")
                                .append(tableName).append("',").append("'")
                                .append(gd.getLocalName()).append("',").append(dimensions)
                                .append(",").append(srid).append(",").append("'").append(geomType)
                                .append("')");
                        LOGGER.fine(sqlBuilder.toString());
                        st.execute(sqlBuilder.toString());
                    }

                    //get the crs, and derive a bounds
                    //TODO: stop being lame and properly figure out the dimension and bounds, see
                    // oracle dialect for the proper way to do it
                    String bbox = null;
                    if (gd.getCoordinateReferenceSystem() != null) {
                        CoordinateReferenceSystem crs = gd.getCoordinateReferenceSystem();
                        CoordinateSystem cs = crs.getCoordinateSystem();
                        if (cs.getDimension() == 2) {
                            CoordinateSystemAxis a0 = cs.getAxis(0);
                            CoordinateSystemAxis a1 = cs.getAxis(1);
                            bbox = "(";
                            bbox += (Double.isInfinite(a0.getMinimumValue()) ?
                                DEFAULT_AXIS_MIN : a0.getMinimumValue()) + ", ";
                            bbox += (Double.isInfinite(a1.getMinimumValue()) ?
                                DEFAULT_AXIS_MIN : a1.getMinimumValue()) + ", ";

                            bbox += (Double.isInfinite(a0.getMaximumValue()) ?
                                DEFAULT_AXIS_MAX : a0.getMaximumValue()) + ", ";
                            bbox += Double.isInfinite(a1.getMaximumValue()) ?
                                DEFAULT_AXIS_MAX : a1.getMaximumValue();
                            bbox += ")";
                        }
                    }
                   
                    if (bbox == null) {
                        //no crs or could not figure out bounds
                        continue;
                    }
                    StringBuffer sql = new StringBuffer("CREATE SPATIAL INDEX ");
                    encodeTableName(featureType.getTypeName()+"_"+gd.getLocalName()+"_index", sql);
                    sql.append( " ON ");
                    encodeTableName(featureType.getTypeName(), sql);
                    sql.append("(");
                    encodeColumnName(null, gd.getLocalName(), sql);
                    sql.append(")");
                    sql.append( " WITH ( BOUNDING_BOX = ").append(bbox).append(")");
                   
                    LOGGER.fine(sql.toString());
                    st.execute(sql.toString());
View Full Code Here

      String tableName = featureType.getTypeName();
      String columnName = featureType.getGeometryDescriptor().getName().toString();
           
      for (AttributeDescriptor attr: featureType.getAttributeDescriptors()) {       
        if (attr instanceof GeometryDescriptor) {
          GeometryDescriptor gDescr = (GeometryDescriptor) attr;
          String srsName = null;
          Integer srsId = (Integer) gDescr.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID);
          if (srsId!= null) {
            PreparedStatement ps1 = cx.prepareStatement(SELECT_SRS_NAME_FROM_ID);
            ps1.setInt(1, srsId);
            ResultSet rs = ps1.executeQuery();
            if (rs.next())
              srsName=rs.getString(1);
            rs.close();
            ps1.close();           
          }
          if (srsName == null && gDescr.getCoordinateReferenceSystem()!=null) {
            for (ReferenceIdentifier ident : gDescr.getCoordinateReferenceSystem().getIdentifiers()) {                             
                PreparedStatement ps1 = cx.prepareStatement(SELECT_SRS_NAME_FROM_ORG);
                ps1.setString(1,ident.getCodeSpace());
                ps1.setInt(2,new Integer(ident.getCode()));
                ResultSet rs = ps1.executeQuery();
                if (rs.next()) {
                  srsName=rs.getString(1);
                  srsId=rs.getInt(2);
                }
                rs.close();
                ps1.close();
              if (srsName!=null) break
            }                                               
          }
          if (srsName==null) {
            srsName = DEFAULT_SRS_NAME;
            srsId = DEFAULT_SRS_ID;
          }
          DB2Util.executeRegister(schemaName, tableName, columnName, srsName, cx);
          gDescr.getUserData().put(JDBCDataStore.JDBC_NATIVE_SRID,srsId);
        }
       
      }
           
    }
View Full Code Here

                    LOGGER.log(Level.FINE, "Getting the full extent of the table using optimized search: {0}", sql);
                    rs = st.executeQuery(sql.toString());

                    if (rs.next()) {
                        // decode the geometry
                        GeometryDescriptor descriptor = (GeometryDescriptor) att;
                        Geometry geometry = readGeometry(rs, 1, new GeometryFactory(), cx);
                       
                        // Either a ReferencedEnvelope or ReferencedEnvelope3D will be generated here
                        ReferencedEnvelope env = JTS.bounds(geometry, descriptor.getCoordinateReferenceSystem() );

                        // reproject and merge
                        if (env != null && !env.isNull()) {
                            result.add(env);
                        }
View Full Code Here

            st = cx.createStatement();
           
            // register all geometry columns in the database
            for (AttributeDescriptor att : featureType.getAttributeDescriptors()) {
                if(att instanceof GeometryDescriptor) {
                    GeometryDescriptor geom = (GeometryDescriptor) att;
                   
                    // guess a tolerance, very small value for geographic data, 10cm for non geographic data
                    // (is there a better way to guess it?), and an extent.
                    // This is a hack for the moment, we need to find a better way to guess the extents,
                    // but unfortunately there is no reliable way to get the extent of a CRS due to
                    // http://jira.codehaus.org/browse/GEOT-1578
                    double tolerance;
                    int dims;
                    double[] min;
                    double[] max;
                    String[] axisNames;
                    if(geom.getCoordinateReferenceSystem() != null) {
                        CoordinateSystem cs = geom.getCoordinateReferenceSystem().getCoordinateSystem();
                        if(geom.getUserData().get(Hints.COORDINATE_DIMENSION) != null) {
                            dims = ((Number) geom.getUserData().get(Hints.COORDINATE_DIMENSION)).intValue();
                        } else {
                            dims = cs.getDimension();
                        }
                        min = new double[dims];
                        max = new double[dims];
                        axisNames = new String[dims];
                        double extent = Double.MAX_VALUE;
                        for (int i = 0; i < dims; i++) {
                            if(i < cs.getDimension()) {
                                CoordinateSystemAxis axis = cs.getAxis(i);
                                axisNames[i] = getCompatibleAxisName(axis, i);
                                min[i] = Double.isInfinite(axis.getMinimumValue()) ? DEFAULT_AXIS_MIN : axis.getMinimumValue();
                                max[i] = Double.isInfinite(axis.getMaximumValue()) ? DEFAULT_AXIS_MAX : axis.getMaximumValue();
                                if(max[i] - min[i] < extent)
                                    extent = max[i] - min[i];
                            } else {
                                min[i] = DEFAULT_AXIS_MIN;
                                max[i] = 10000000;
                            }
                        }
                        // 1/10M of the extent
                        tolerance = extent / 10000000;
                    } else {
                        // assume fake values for a 2d ref system
                        dims = 2;
                        axisNames = new String[2];
                        min = new double[2];
                        max = new double[2];
                        axisNames[0] = "X"; axisNames[1] = "Y";
                        min[0] = DEFAULT_AXIS_MIN;
                        min[1] = DEFAULT_AXIS_MIN;
                        max[0]= 10000000;
                        max[1] = 10000000;
                        tolerance = 0.01;
                    }
   
                    int srid = -1;
                    if(geom.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID) != null) {
                        srid = (Integer) geom.getUserData().get(JDBCDataStore.JDBC_NATIVE_SRID);
                    } else if(geom.getCoordinateReferenceSystem() != null) {
                        try {
                            Integer result = CRS.lookupEpsgCode(geom.getCoordinateReferenceSystem(), true);
                            if(result != null)
                                srid = result;
                        } catch(Exception e) {
                            LOGGER.log(Level.FINE, "Error looking up the epsg code for metadata insertion, assuming -1", e);
                        }
                    }
                   
                    // register the metadata
                    String geomColumnName = geom.getLocalName().toUpperCase();
                    String sql = "INSERT INTO USER_SDO_GEOM_METADATA" //       
                                 + "(TABLE_NAME, COLUMN_NAME, DIMINFO, SRID)\n" //
                                 + "VALUES (\n" //
                                 + "'" + tableName + "',\n" //
                                 + "'" + geomColumnName + "',\n" //
                                 + "MDSYS.SDO_DIM_ARRAY(\n";
                    for (int i = 0; i < dims; i++) {
                        sql += "   MDSYS.SDO_DIM_ELEMENT('" + axisNames[i] + "', "+ min[i] + ", " + max[i] +", " + tolerance + ")";
                        if(i < dims - 1)
                            sql += ", ";
                        sql += "\n";
                    }
                    sql = sql +  "),\n" //
                        + (srid == -1 ? "NULL" : String.valueOf(srid)) + ")";
                    LOGGER.log(Level.FINE, "Creating metadata with sql: {0}", sql);
                    st.execute(sql);
                   
                    // figure out the index dimension -> for geodetic data 11G accepts only 2d index,
                    // even if the data is 3d
                    int idxDim = isGeodeticSrid(srid, cx) ? 2 : dims;
                   
                    // create the spatial index (or we won't be able to run spatial predicates)
                    String type = CLASSES_TO_GEOM.get(geom.getType().getBinding());
                    String idxName = tableName +  "_" + geomColumnName + "_IDX";
                    if(idxName.length() > 30) {
                        idxName = "IDX_" + UUID.randomUUID().toString().replace("-", "").substring(0, 26);
                    }
                    sql = "CREATE INDEX " //
View Full Code Here

TOP

Related Classes of org.opengis.feature.type.GeometryDescriptor

Copyright © 2018 www.massapicom. All rights reserved.
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.