Examples with AbstractGeometry org.geotoolkit.gml.xml.AbstractGeometry used on opensource projects

Example 11 with AbstractGeometry

use of org.geotoolkit.gml.xml.AbstractGeometry in project geotoolkit by Geomatys.

the class ReadGeometryTest method testCollection.

protected void testCollection(final URL geometryFile, final Class<? extends GeometryCollection> expectedType, final int expectedInnerGeometries, final Envelope expectedEnvelope) throws Exception {
    final AbstractGeometry geom = read(geometryFile);
    final GeometryTransformer tr = new GeometryTransformer(geom);
    final Geometry result = tr.get();
    Assert.assertNotNull("Read geometry is null", result);
    Assert.assertTrue(String.format("Bad geometry type.%nExpected: %s%nBut was: %s", expectedType, result.getClass()), expectedType.isAssignableFrom(result.getClass()));
    final GeometryCollection col = (GeometryCollection) result;
    Assert.assertEquals("Bad number of polygon members", expectedInnerGeometries, col.getNumGeometries());
    final Envelope actual = col.getEnvelopeInternal();
    Assert.assertEquals(expectedEnvelope.getMinX(), actual.getMinX(), 0.01);
    Assert.assertEquals(expectedEnvelope.getMinY(), actual.getMinY(), 0.01);
    Assert.assertEquals(expectedEnvelope.getMaxX(), actual.getMaxX(), 0.01);
    Assert.assertEquals(expectedEnvelope.getMaxY(), actual.getMaxY(), 0.01);
}

Example 12 with AbstractGeometry

use of org.geotoolkit.gml.xml.AbstractGeometry in project geotoolkit by Geomatys.

the class NetcdfFeatureReader method getFeatureFromFOI.

protected final Feature getFeatureFromFOI(final AnyFeature foi) {
    if (foi instanceof SamplingFeature) {
        final SamplingFeature feature = (SamplingFeature) foi;
        final org.opengis.geometry.Geometry isoGeom = feature.getGeometry();
        try {
            final Geometry geom;
            if (isoGeom instanceof AbstractGeometry) {
                geom = GeometrytoJTS.toJTS((AbstractGeometry) isoGeom, AxisResolve.STRICT);
            } else {
                geom = null;
            }
            if (firstCRS && isoGeom != null) {
                // configure crs in the feature type
                final CoordinateReferenceSystem crs = ((AbstractGeometry) isoGeom).getCoordinateReferenceSystem(false);
                type = new ReprojectMapper(type, crs).getMappedType();
                firstCRS = false;
            }
            final Feature f = type.newInstance();
            f.setPropertyValue(AttributeConvention.IDENTIFIER, feature.getId());
            f.setPropertyValue(OMFeatureTypes.ATT_DESC.toString(), feature.getDescription());
            f.setPropertyValue(OMFeatureTypes.ATT_NAME.toString(), feature.getName());
            f.setPropertyValue(OMFeatureTypes.ATT_POSITION.toString(), geom);
            final List<String> sampleds = new ArrayList<>();
            for (FeatureProperty featProp : feature.getSampledFeatures()) {
                if (featProp.getHref() != null) {
                    sampleds.add(featProp.getHref());
                }
            }
            f.setPropertyValue(OMFeatureTypes.ATT_SAMPLED.toString(), sampleds);
            return f;
        } catch (FactoryException ex) {
            LOGGER.log(Level.WARNING, "error while transforming GML geometry to JTS", ex);
        }
    } else {
        LOGGER.warning("unable to find a valid feature of interest in the observation");
    }
    return null;
}

Example 13 with AbstractGeometry

use of org.geotoolkit.gml.xml.AbstractGeometry in project geotoolkit by Geomatys.

the class GeometryMapping method readValue.

@Override
public void readValue(XMLStreamReader reader, GenericName propName, Feature feature) throws XMLStreamException {
    final String localName = reader.getLocalName();
    if (decorated) {
        // check if we are dealing with a link href
        String link = reader.getAttributeValue(GMLConvention.XLINK_NAMESPACE, "href");
        if (link != null) {
            toTagEnd(reader, localName);
            Attribute attribute = (Attribute) feature.getProperty(propName.toString());
            AttributeType<String> charType = (AttributeType) attribute.getType().characteristics().get(GMLConvention.XLINK_HREF.tip().toString());
            Attribute<String> charValue = charType.newInstance();
            charValue.setValue(link);
            attribute.characteristics().put(GMLConvention.XLINK_HREF.tip().toString(), charValue);
            return;
        }
    }
    boolean skipCurrent = decorated;
    int event;
    Object value;
    // backward compatible with incorrect old writings
    final String propertyName = propertyType.getName().tip().toString();
    if (propertyName.equals(localName)) {
        skipCurrent = true;
    }
    // special case for SurfacePropertyType which may contain a simple polygon
    boolean forceMultiPolygon = propertyName.equalsIgnoreCase("multipolygon");
    if (skipCurrent) {
        event = reader.next();
    } else {
        event = reader.getEventType();
    }
    while (event != START_ELEMENT) {
        if (event == END_ELEMENT) {
            return;
        }
        event = reader.next();
    }
    try {
        Unmarshaller unmarshaller = pool.acquireUnmarshaller();
        final Geometry jtsGeom;
        final Object geometry = ((JAXBElement) unmarshaller.unmarshal(reader)).getValue();
        if (geometry instanceof JTSGeometry) {
            final JTSGeometry isoGeom = (JTSGeometry) geometry;
            if (isoGeom instanceof JTSMultiCurve) {
                ((JTSMultiCurve) isoGeom).applyCRSonChild();
            }
            jtsGeom = isoGeom.getJTSGeometry();
        } else if (geometry instanceof PolygonType) {
            final PolygonType polygon = ((PolygonType) geometry);
            jtsGeom = polygon.getJTSPolygon().getJTSGeometry();
            if (polygon.getCoordinateReferenceSystem() != null) {
                JTS.setCRS(jtsGeom, polygon.getCoordinateReferenceSystem());
            }
        } else if (geometry instanceof LineStringPosListType) {
            final JTSLineString line = ((LineStringPosListType) geometry).getJTSLineString();
            jtsGeom = line.getJTSGeometry();
            if (line.getCoordinateReferenceSystem() != null) {
                JTS.setCRS(jtsGeom, line.getCoordinateReferenceSystem());
            }
        } else if (geometry instanceof AbstractGeometry) {
            try {
                jtsGeom = GeometrytoJTS.toJTS((AbstractGeometry) geometry, longitudeFirst, forceMultiPolygon);
            } catch (FactoryException ex) {
                throw new XMLStreamException("Factory Exception while transforming GML object to JTS", ex);
            }
        } else {
            throw new IllegalArgumentException("unexpected geometry type:" + geometry);
        }
        value = jtsGeom;
        value = JTSMapping.convertType(jtsGeom, ((AttributeType) propertyType).getValueClass());
        pool.recycle(unmarshaller);
    } catch (JAXBException ex) {
        String msg = ex.getMessage();
        if (msg == null && ex.getLinkedException() != null) {
            msg = ex.getLinkedException().getMessage();
        }
        throw new IllegalArgumentException("JAXB exception while reading the feature geometry: " + msg, ex);
    }
    JAXPStreamFeatureReader.setValue(feature, propertyType, propName, null, value);
}

Example 14 with AbstractGeometry

use of org.geotoolkit.gml.xml.AbstractGeometry in project geotoolkit by Geomatys.

the class FilterToOGC200Converter method visit.

public JAXBElement visit(Filter filter) {
    if (filter.equals(Filter.include()) || filter.equals(Filter.exclude())) {
        return null;
    }
    final CodeList<?> type = filter.getOperatorType();
    if (filter instanceof BetweenComparisonOperator) {
        final BetweenComparisonOperator pib = (BetweenComparisonOperator) filter;
        final LowerBoundaryType lbt = ogc_factory.createLowerBoundaryType();
        lbt.setExpression(extract(pib.getLowerBoundary()));
        final UpperBoundaryType ubt = ogc_factory.createUpperBoundaryType();
        ubt.setExpression(extract(pib.getUpperBoundary()));
        final PropertyIsBetweenType bot = new PropertyIsBetweenType();
        bot.setExpression(extract(pib.getExpression()));
        bot.setLowerBoundary(lbt);
        bot.setUpperBoundary(ubt);
        return ogc_factory.createPropertyIsBetween(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_EQUAL_TO) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsEqualToType bot = new PropertyIsEqualToType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsEqualTo(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_GREATER_THAN) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsGreaterThanType bot = new PropertyIsGreaterThanType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsGreaterThan(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_GREATER_THAN_OR_EQUAL_TO) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsGreaterThanOrEqualToType bot = new PropertyIsGreaterThanOrEqualToType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsGreaterThanOrEqualTo(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_LESS_THAN) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsLessThanType bot = new PropertyIsLessThanType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsLessThan(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_LESS_THAN_OR_EQUAL_TO) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsLessThanOrEqualToType bot = new PropertyIsLessThanOrEqualToType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsLessThanOrEqualTo(bot);
    } else if (filter instanceof LikeOperator) {
        final LikeOperator pis = (LikeOperator) filter;
        final List<Expression> expressions = filter.getExpressions();
        final PropertyIsLikeType bot = ogc_factory.createPropertyIsLikeType();
        bot.setEscape(String.valueOf(pis.getEscapeChar()));
        final LiteralType lt = ogc_factory.createLiteralType();
        lt.setContent(((Literal) expressions.get(1)).getValue());
        bot.getElements().add(ogc_factory.createLiteral(lt));
        final Expression expression = expressions.get(0);
        if (!(expression instanceof ValueReference)) {
            throw new IllegalArgumentException("LikeOperator can support ValueReference only, but was a " + expression);
        }
        bot.getElements().add(0, extract(expression));
        bot.setSingleChar(String.valueOf(pis.getSingleChar()));
        bot.setWildCard(String.valueOf(pis.getWildCard()));
        return ogc_factory.createPropertyIsLike(bot);
    } else if (type == ComparisonOperatorName.PROPERTY_IS_NOT_EQUAL_TO) {
        final BinaryComparisonOperator pit = (BinaryComparisonOperator) filter;
        final PropertyIsNotEqualToType bot = new PropertyIsNotEqualToType();
        bot.getExpression().add(extract(pit.getOperand1()));
        bot.getExpression().add(extract(pit.getOperand2()));
        return ogc_factory.createPropertyIsNotEqualTo(bot);
    } else if (filter instanceof NullOperator) {
        final NullOperator pis = (NullOperator) filter;
        final PropertyIsNullType bot = ogc_factory.createPropertyIsNullType();
        bot.setExpression(extract((Expression) pis.getExpressions().get(0)));
        return ogc_factory.createPropertyIsNull(bot);
    } else if (type == LogicalOperatorName.AND) {
        final LogicalOperator and = (LogicalOperator) filter;
        final List<JAXBElement> lot = new ArrayList<>();
        for (final Filter f : (List<Filter>) and.getOperands()) {
            final JAXBElement<?> ele = visit(f);
            if (ele != null && ele.getValue() instanceof LogicOpsType) {
                lot.add(ele);
            }
        }
        return ogc_factory.createAnd(new AndType(lot.toArray()));
    } else if (type == LogicalOperatorName.OR) {
        final LogicalOperator or = (LogicalOperator) filter;
        final List<JAXBElement> lot = new ArrayList<>();
        for (final Filter f : (List<Filter>) or.getOperands()) {
            final JAXBElement subFilter = visit(f);
            if (subFilter != null) {
                lot.add(subFilter);
            }
        }
        return ogc_factory.createOr(new OrType(lot.toArray()));
    } else if (type == LogicalOperatorName.NOT) {
        final LogicalOperator not = (LogicalOperator) filter;
        final JAXBElement<?> sf = visit((Filter) not.getOperands().get(0));
        // should not happen
        return ogc_factory.createNot(new NotType(sf));
    } else if (filter instanceof ResourceId) {
        throw new IllegalArgumentException("Not parsed yet : " + filter);
    } else if (type == SpatialOperatorName.BBOX) {
        final BBOX bbox = BBOX.wrap((BinarySpatialOperator) filter);
        final Expression left = bbox.getOperand1();
        final Expression right = bbox.getOperand2();
        final String property;
        final double minx;
        final double maxx;
        final double miny;
        final double maxy;
        String srs;
        if (left instanceof ValueReference) {
            property = ((ValueReference) left).getXPath();
            final Object objGeom = ((Literal) right).getValue();
            if (objGeom instanceof org.opengis.geometry.Envelope) {
                final org.opengis.geometry.Envelope env = (org.opengis.geometry.Envelope) objGeom;
                minx = env.getMinimum(0);
                maxx = env.getMaximum(0);
                miny = env.getMinimum(1);
                maxy = env.getMaximum(1);
                try {
                    srs = IdentifiedObjects.lookupURN(env.getCoordinateReferenceSystem(), null);
                    if (srs == null) {
                        srs = ReferencingUtilities.lookupIdentifier(env.getCoordinateReferenceSystem(), true);
                    }
                } catch (FactoryException ex) {
                    throw new IllegalArgumentException("invalid bbox element : " + filter + " " + ex.getMessage(), ex);
                }
            } else if (objGeom instanceof Geometry) {
                final Geometry geom = (Geometry) objGeom;
                final Envelope env = geom.getEnvelopeInternal();
                minx = env.getMinX();
                maxx = env.getMaxX();
                miny = env.getMinY();
                maxy = env.getMaxY();
                srs = SRIDGenerator.toSRS(geom.getSRID(), SRIDGenerator.Version.V1);
            } else {
                throw new IllegalArgumentException("invalid bbox element : " + filter);
            }
        } else if (right instanceof ValueReference) {
            property = ((ValueReference) right).getXPath();
            final Object objGeom = ((Literal) left).getValue();
            if (objGeom instanceof org.opengis.geometry.Envelope) {
                final org.opengis.geometry.Envelope env = (org.opengis.geometry.Envelope) objGeom;
                minx = env.getMinimum(0);
                maxx = env.getMaximum(0);
                miny = env.getMinimum(1);
                maxy = env.getMaximum(1);
                try {
                    srs = IdentifiedObjects.lookupURN(env.getCoordinateReferenceSystem(), null);
                    if (srs == null) {
                        srs = ReferencingUtilities.lookupIdentifier(env.getCoordinateReferenceSystem(), true);
                    }
                } catch (FactoryException ex) {
                    throw new IllegalArgumentException("invalid bbox element : " + filter + " " + ex.getMessage(), ex);
                }
            } else if (objGeom instanceof Geometry) {
                final Geometry geom = (Geometry) objGeom;
                final Envelope env = geom.getEnvelopeInternal();
                minx = env.getMinX();
                maxx = env.getMaxX();
                miny = env.getMinY();
                maxy = env.getMaxY();
                srs = SRIDGenerator.toSRS(geom.getSRID(), SRIDGenerator.Version.V1);
            } else {
                throw new IllegalArgumentException("invalid bbox element : " + filter);
            }
        } else {
            throw new IllegalArgumentException("invalid bbox element : " + filter);
        }
        final BBOXType bbtype = new BBOXType(property, minx, miny, maxx, maxy, srs);
        return ogc_factory.createBBOX(bbtype);
    } else if (filter instanceof ResourceId) {
        final ValueReference n = FF.property(AttributeConvention.IDENTIFIER);
        ResourceId idFilter = (ResourceId) filter;
        final String id = idFilter.getIdentifier();
        final ResourceIdType rId = ogc_factory.createResourceIdType();
        rId.setRid(id);
        return ogc_factory.createResourceId(rId);
    } else if (filter instanceof BinarySpatialOperator) {
        final BinarySpatialOperator spatialOp = (BinarySpatialOperator) filter;
        Expression exp1 = spatialOp.getOperand1();
        Expression exp2 = spatialOp.getOperand2();
        if (!(exp1 instanceof ValueReference)) {
            // flip order
            final Expression ex = exp1;
            exp1 = exp2;
            exp2 = ex;
        }
        if (!(exp1 instanceof ValueReference)) {
            throw new IllegalArgumentException("Filter can not be transformed in xml filter, " + "expression are not of the required type ");
        } else if (!(exp2 instanceof Literal)) {
            throw new IllegalArgumentException("Spatial operator should use a literal object containing the filtering geometry.");
        }
        final JAXBElement pnt = extract(exp1);
        final String pName;
        if (pnt.getValue() instanceof String) {
            pName = (String) pnt.getValue();
        } else {
            throw new IllegalArgumentException("Property name cannot be cast to string.");
        }
        final JAXBElement<?> geometryExpression;
        final Object geom = ((Literal) exp2).getValue();
        if (geom instanceof Geometry) {
            final Geometry jts = (Geometry) geom;
            final String srid = SRIDGenerator.toSRS(jts.getSRID(), SRIDGenerator.Version.V1);
            CoordinateReferenceSystem crs;
            try {
                crs = CRS.forCode(srid);
            } catch (Exception ex) {
                Logger.getLogger("org.geotoolkit.sld.xml").log(Level.WARNING, null, ex);
                crs = null;
            }
            final AbstractGeometry gmlGeom;
            try {
                gmlGeom = JTStoGeometry.toGML("3.2.1", jts);
            } catch (FactoryException ex) {
                throw new IllegalArgumentException(ex);
            }
            // TODO use gml method to return any JAXBElement
            if (gmlGeom instanceof PointType) {
                geometryExpression = gml_factory.createPoint((PointType) gmlGeom);
            } else if (gmlGeom instanceof CurveType) {
                geometryExpression = gml_factory.createCurve((CurveType) gmlGeom);
            } else if (gmlGeom instanceof LineStringType) {
                geometryExpression = gml_factory.createLineString((LineStringType) gmlGeom);
            } else if (gmlGeom instanceof PolygonType) {
                geometryExpression = gml_factory.createPolygon((PolygonType) gmlGeom);
            } else if (gmlGeom instanceof MultiSurfaceType) {
                geometryExpression = gml_factory.createMultiSurface((MultiSurfaceType) gmlGeom);
            } else if (gmlGeom instanceof MultiCurveType) {
                geometryExpression = gml_factory.createMultiCurve((MultiCurveType) gmlGeom);
            } else if (gmlGeom instanceof MultiPointType) {
                geometryExpression = gml_factory.createMultiPoint((MultiPointType) gmlGeom);
            } else if (gmlGeom instanceof MultiGeometryType) {
                geometryExpression = gml_factory.createMultiGeometry((MultiGeometryType) gmlGeom);
            } else if (gmlGeom instanceof SurfaceType) {
                geometryExpression = gml_factory.createPolyhedralSurface((SurfaceType) gmlGeom);
            } else {
                throw new IllegalArgumentException("Unexpected Geometry type:" + gmlGeom.getClass().getName());
            }
        } else if (geom instanceof org.opengis.geometry.Geometry) {
            throw new UnsupportedOperationException("No valid ISO implementation avaiable for now.");
        } else if (geom instanceof org.opengis.geometry.Envelope) {
            final org.opengis.geometry.Envelope genv = (org.opengis.geometry.Envelope) geom;
            EnvelopeType ee = gml_factory.createEnvelopeType();
            ee.setSrsDimension(genv.getDimension());
            if (genv.getCoordinateReferenceSystem() != null) {
                String urn;
                try {
                    urn = IdentifiedObjects.lookupURN(genv.getCoordinateReferenceSystem(), null);
                } catch (FactoryException ex) {
                    Logger.getLogger("org.geotoolkit.sld.xml").log(Level.WARNING, null, ex);
                    urn = null;
                }
                if (urn == null) {
                    urn = IdentifiedObjects.getIdentifierOrName(genv.getCoordinateReferenceSystem());
                }
                if (urn != null) {
                    ee.setSrsName(urn);
                }
            }
            ee.setLowerCorner(new DirectPositionType(genv.getLowerCorner(), false));
            ee.setUpperCorner(new DirectPositionType(genv.getUpperCorner(), false));
            geometryExpression = gml_factory.createEnvelope(ee);
        } else {
            throw new IllegalArgumentException("Type is neither geometric nor envelope.");
        }
        if (type == DistanceOperatorName.BEYOND) {
            throw new UnsupportedOperationException();
        } else if (type == SpatialOperatorName.CONTAINS) {
            return ogc_factory.createContains(new ContainsType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.CROSSES) {
            ogc_factory.createCrosses(new CrossesType(pName, geometryExpression));
        } else if (type == DistanceOperatorName.WITHIN) {
            Quantity q = ((DistanceOperator) filter).getDistance();
            return ogc_factory.createDWithin(new DWithinType(pName, geometryExpression, q.getValue().doubleValue(), q.getUnit().toString()));
        } else if (type == SpatialOperatorName.DISJOINT) {
            return ogc_factory.createDisjoint(new DisjointType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.EQUALS) {
            return ogc_factory.createEquals(new EqualsType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.INTERSECTS) {
            return ogc_factory.createIntersects(new IntersectsType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.OVERLAPS) {
            return ogc_factory.createOverlaps(new OverlapsType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.TOUCHES) {
            return ogc_factory.createTouches(new TouchesType(pName, geometryExpression));
        } else if (type == SpatialOperatorName.WITHIN) {
            return ogc_factory.createWithin(new WithinType(pName, geometryExpression));
        }
        throw new IllegalArgumentException("Unknown filter element : " + filter + " class :" + filter.getClass());
    }
    throw new IllegalArgumentException("Unknown filter element : " + filter + " class :" + filter.getClass());
}

Example 15 with AbstractGeometry

use of org.geotoolkit.gml.xml.AbstractGeometry in project geotoolkit by Geomatys.

the class WPSConvertersUtils method readGMLGeometryFromString.

/**
 * Helper method which extracts the GML Geometry from a String.
 *
 * @param content content string containing a GML geometry
 * @return a GeoJSONObject
 * @throws java.io.IOException on reading errors
 */
public static AbstractGeometry readGMLGeometryFromString(String content) throws IOException {
    ArgumentChecks.ensureNonEmpty("content", content);
    // Parse GeoJSON
    try (final StringReader contentReader = new StringReader(content)) {
        Unmarshaller um = GMLMarshallerPool.getInstance().acquireUnmarshaller();
        Object obj = um.unmarshal(contentReader);
        GMLMarshallerPool.getInstance().recycle(um);
        if (obj instanceof JAXBElement) {
            obj = ((JAXBElement) obj).getValue();
        }
        if (!(obj instanceof AbstractGeometry)) {
            throw new IOException("XML don't contains GML geometry");
        }
        return (AbstractGeometry) obj;
    } catch (JAXBException ex) {
        throw new IOException(ex);
    }
}