Examples with DefaultGeometryProperty eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty used on opensource projects

Example 1 with DefaultGeometryProperty

use of eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty in project hale by halestudio.

the class SpatiaLiteGeometries method convertToInstanceGeometry.

/**
 * @see eu.esdihumboldt.hale.io.jdbc.GeometryAdvisor#convertToInstanceGeometry(java.lang.Object,
 *      eu.esdihumboldt.hale.common.schema.model.TypeDefinition,
 *      java.lang.Object, java.util.function.Supplier)
 */
@Override
public GeometryProperty<?> convertToInstanceGeometry(Object geom, TypeDefinition columnType, SQLiteConnection connection, Supplier<CRSDefinition> crsProvider) throws Exception {
    // show error and abort if SpatiaLite is not available
    if (!SpatiaLiteHelper.isSpatialLiteLoadedReport(connection, true)) {
    // don't throw, will prevent any data being loaded
    // throw new IllegalStateException("SpatiaLite module is not available");
    }
    // decode geometry read from DB
    GeometryMetadata columnTypeMetadata = columnType.getConstraint(GeometryMetadata.class);
    Geometry jtsGeom = decodeGeometryValue(geom, columnTypeMetadata, connection);
    // determine CRS
    CRSDefinition crsDef = null;
    String authName = columnTypeMetadata.getAuthName();
    if (authName != null && authName.equalsIgnoreCase("EPSG")) {
        String epsgCode = authName + ":" + columnTypeMetadata.getSrs();
        crsDef = new CodeDefinition(epsgCode, null);
    } else {
        String wkt = columnTypeMetadata.getSrsText();
        if (wkt != null) {
            crsDef = new WKTDefinition(wkt, null);
        }
    }
    return new DefaultGeometryProperty<Geometry>(crsDef, jtsGeom);
}

Example 2 with DefaultGeometryProperty

use of eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty in project hale by halestudio.

the class ArcByCenterPointHandler method createGeometry.

@Override
public Object createGeometry(Instance instance, int srsDimension, IOProvider reader) throws GeometryNotSupportedException {
    PointHandler handler = new PointHandler();
    // XXX support for different types of line strings in one instance (we
    // support only one type per instance!)
    Coordinate[] controlCoord = null;
    double radius = 0;
    double startAngle = 0;
    double endAngle = 0;
    // to parse coordinates of a line string
    // for use with GML 2, 3, 3.1, 3.2
    Collection<Object> values = PropertyResolver.getValues(instance, "coordinates", false);
    if (values != null && !values.isEmpty()) {
        Object value = values.iterator().next();
        if (value instanceof Instance) {
            try {
                controlCoord = GMLGeometryUtil.parseCoordinates((Instance) value);
            } catch (ParseException e) {
                throw new GeometryNotSupportedException("Could not parse coordinates", e);
            }
        }
    }
    // for use with GML 3, 3.2
    if (controlCoord == null || controlCoord.length == 0) {
        values = PropertyResolver.getValues(instance, "pos", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    Coordinate c = GMLGeometryUtil.parseDirectPosition((Instance) value);
                    if (c != null) {
                        cs.add(c);
                    }
                }
            }
            controlCoord = cs.toArray(new Coordinate[cs.size()]);
        }
    }
    // for use with GML 3.1, 3.2
    if (controlCoord == null || controlCoord.length == 0) {
        values = PropertyResolver.getValues(instance, "posList", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            Object value = iterator.next();
            if (value instanceof Instance) {
                controlCoord = GMLGeometryUtil.parsePosList((Instance) value, srsDimension);
            }
        }
    }
    if (controlCoord == null || controlCoord.length == 0) {
        values = PropertyResolver.getValues(instance, "pointRep.Point", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    try {
                        @SuppressWarnings("unchecked") DefaultGeometryProperty<Point> point = (DefaultGeometryProperty<Point>) handler.createGeometry((Instance) value, srsDimension, reader);
                        cs.add(point.getGeometry().getCoordinate());
                    } catch (GeometryNotSupportedException e) {
                        throw new GeometryNotSupportedException("Could not parse Point Representation", e);
                    }
                }
            }
            controlCoord = cs.toArray(new Coordinate[cs.size()]);
        }
    }
    // for use with GML 3.1
    if (controlCoord == null || controlCoord.length == 0) {
        values = PropertyResolver.getValues(instance, "pointProperty.Point", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    try {
                        @SuppressWarnings("unchecked") DefaultGeometryProperty<Point> point = (DefaultGeometryProperty<Point>) handler.createGeometry((Instance) value, srsDimension, reader);
                        cs.add(point.getGeometry().getCoordinate());
                    } catch (GeometryNotSupportedException e) {
                        throw new GeometryNotSupportedException("Could not parse Point Property", e);
                    }
                }
            }
            controlCoord = cs.toArray(new Coordinate[cs.size()]);
        }
    }
    // for use with GML2, 3, 3.1, 3.2
    if (controlCoord == null || controlCoord.length == 0) {
        values = PropertyResolver.getValues(instance, "coord", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    Coordinate c = GMLGeometryUtil.parseCoord((Instance) value);
                    if (c != null) {
                        cs.add(c);
                    }
                }
            }
            controlCoord = cs.toArray(new Coordinate[cs.size()]);
        }
    }
    values = PropertyResolver.getValues(instance, "radius", false);
    if (values != null && !values.isEmpty()) {
        Object value = values.iterator().next();
        if (value instanceof Instance) {
            // ##TODO :: need to check with real time data
            radius = ConversionUtil.getAs(((Instance) value).getValue(), Double.class);
        }
    }
    values = PropertyResolver.getValues(instance, "startAngle", false);
    if (values != null && !values.isEmpty()) {
        Object value = values.iterator().next();
        if (value != null) {
            if (value instanceof Instance) {
                // ##TODO: handle if value comes in degree, minute and
                // second format. Need to check with real time data
                startAngle = ConversionUtil.getAs(((Instance) value).getValue(), Double.class);
            }
        }
    }
    values = PropertyResolver.getValues(instance, "endAngle", false);
    if (values != null && !values.isEmpty()) {
        Object value = values.iterator().next();
        if (value != null) {
            if (value instanceof Instance) {
                // ##TODO: handle if value comes in degree, minute and
                // second format. Need to check with real time data
                endAngle = ConversionUtil.getAs(((Instance) value).getValue(), Double.class);
            }
        }
    }
    if (controlCoord != null && controlCoord.length != 0 && radius != 0) {
        CRSDefinition crsDef = GMLGeometryUtil.findCRS(instance);
        // create Arc
        // FIXME verify how arc should be created from information in GML
        boolean clockwise = endAngle - startAngle < 0;
        Arc arc = new ArcByCenterPointImpl(controlCoord[0], radius, Angle.fromDegrees(startAngle), Angle.fromDegrees(endAngle), clockwise);
        // get interpolation algorithm
        InterpolationAlgorithm interpol = InterpolationHelper.getInterpolation(reader, getGeometryFactory());
        LineString interpolatedArc = interpol.interpolateArc(arc);
        if (interpolatedArc == null) {
            log.error("Arc could be not interpolated to Linestring");
            return null;
        }
        return new DefaultGeometryProperty<LineString>(crsDef, interpolatedArc);
    }
    throw new GeometryNotSupportedException();
}

Example 3 with DefaultGeometryProperty

use of eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty in project hale by halestudio.

the class CircleHandler method createGeometry.

@Override
public Object createGeometry(Instance instance, int srsDimension, IOProvider reader) throws GeometryNotSupportedException {
    @SuppressWarnings("unchecked") DefaultGeometryProperty<LineString> lineStringGeomProperty = (DefaultGeometryProperty<LineString>) super.createGeometry(instance, srsDimension, reader);
    // create Arc for circle
    Coordinate[] coords = lineStringGeomProperty.getGeometry().getCoordinates();
    if (coords.length != 3) {
        throw new GeometryNotSupportedException("Arc must be defined by three points");
    }
    Arc arc = new ArcByPointsImpl(coords[0], coords[1], coords[2]);
    ArcByCenterPoint byCenter = arc.toArcByCenterPoint();
    ArcByCenterPoint circle = new ArcByCenterPointImpl(byCenter.getCenterPoint(), byCenter.getRadius(), byCenter.getStartAngle(), byCenter.getStartAngle(), byCenter.isClockwise());
    // get interpolation algorithm
    InterpolationAlgorithm interpol = InterpolationHelper.getInterpolation(reader, getGeometryFactory());
    LineString interpolatedCircle = interpol.interpolateArc(circle);
    if (interpolatedCircle == null) {
        log.error("Circle could be not interpolated to Linestring");
        return null;
    }
    return new DefaultGeometryProperty<LineString>(lineStringGeomProperty.getCRSDefinition(), interpolatedCircle);
}

Example 4 with DefaultGeometryProperty

use of eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty in project hale by halestudio.

the class GenericGeometryHandler method createGeometry.

/**
 * Create a geometry value from a given instance.
 *
 * @param instance the instance
 * @param childGeometries the child geometries found in the instance
 * @param defaultCrs the definition of the default CRS for this instance
 * @param reader the IO provider
 * @return the geometry value derived from the instance, the return type
 *         should match the {@link Binding} created in
 *         {@link #getTypeConstraints(TypeDefinition)}.
 * @throws GeometryNotSupportedException if the type definition doesn't
 *             represent a geometry type supported by the handler
 */
@SuppressWarnings("unused")
protected Collection<GeometryProperty<?>> createGeometry(Instance instance, List<GeometryProperty<?>> childGeometries, CRSDefinition defaultCrs, IOProvider reader) throws GeometryNotSupportedException {
    List<Geometry> geomList = new ArrayList<Geometry>();
    Class<? extends Geometry> commonGeomType = null;
    CRSWrapper commonCrs = null;
    boolean allowCombine = true;
    // TODO partition based on CRS?
    for (GeometryProperty<?> geomProp : childGeometries) {
        if (geomProp.getGeometry() instanceof GeometryCollection) {
            GeometryCollection geomCollection = (GeometryCollection) geomProp.getGeometry();
            for (int i = 0; i < geomCollection.getNumGeometries(); i++) {
                // find the common geometry class
                Class<? extends Geometry> geometryType = geomCollection.getGeometryN(i).getClass();
                if (commonGeomType == null) {
                    commonGeomType = geometryType;
                } else if (!commonGeomType.equals(geometryType)) {
                    // TODO determine common type in inheritance?
                    commonGeomType = Geometry.class;
                }
                geomList.add(geomCollection.getGeometryN(i));
            }
        } else {
            // find the common geometry class
            Class<? extends Geometry> geometryType = geomProp.getGeometry().getClass();
            if (commonGeomType == null) {
                commonGeomType = geometryType;
            } else if (!commonGeomType.equals(geometryType)) {
                // find common super class
                commonGeomType = findClosestCommonSuperclass(commonGeomType, geometryType);
            }
            geomList.add(geomProp.getGeometry());
        }
        // check common CRS
        CRSWrapper crs = new CRSWrapper(geomProp.getCRSDefinition());
        if (commonCrs == null) {
            commonCrs = crs;
        } else if (!commonCrs.equals(crs)) {
            allowCombine = false;
        }
    }
    if (allowCombine && commonGeomType != null) {
        if (!(commonGeomType.equals(Polygon.class) || commonGeomType.equals(Point.class) || commonGeomType.equals(LineString.class))) {
            // check if it is a subclass of a supported type
            if (LineString.class.isAssignableFrom(commonGeomType)) {
                // for instance for InterpolatedLineString
                commonGeomType = LineString.class;
            }
            if (Point.class.isAssignableFrom(commonGeomType)) {
                commonGeomType = Point.class;
            }
            if (Polygon.class.isAssignableFrom(commonGeomType)) {
                commonGeomType = Polygon.class;
            }
        }
        Geometry geom = null;
        if (commonGeomType.equals(Polygon.class)) {
            // create a MultiPolygon
            Polygon[] polygons = new Polygon[geomList.size()];
            for (int i = 0; i < geomList.size(); i++) {
                polygons[i] = (Polygon) geomList.get(i);
            }
            geom = combine(polygons, reader);
        } else if (commonGeomType.equals(LineString.class)) {
            // create a MultiLineString
            LineString[] lines = new LineString[geomList.size()];
            for (int i = 0; i < geomList.size(); i++) {
                lines[i] = (LineString) geomList.get(i);
            }
            geom = combine(lines, reader);
        } else if (commonGeomType.equals(Point.class)) {
            // create a MultiPoint
            Point[] points = new Point[geomList.size()];
            for (int i = 0; i < geomList.size(); i++) {
                points[i] = (Point) geomList.get(i);
            }
            geom = combine(points, reader);
        }
        if (geom != null) {
            // returned combined property
            CRSDefinition crs = (commonCrs != null && commonCrs.getCrsDef() != null) ? (commonCrs.getCrsDef()) : (defaultCrs);
            return Collections.<GeometryProperty<?>>singleton(new DefaultGeometryProperty<Geometry>(crs, geom));
        }
    }
    // fall-back: return a collection of geometry properties
    if (childGeometries.isEmpty()) {
        return null;
    }
    return childGeometries;
}

Example 5 with DefaultGeometryProperty

use of eu.esdihumboldt.hale.common.instance.geometry.DefaultGeometryProperty in project hale by halestudio.

the class LineStringHandler method createGeometry.

// XXX support for Triangle and Rectangle is not optimal (only exterior and
// outerBounderIs needed)
@Override
public Object createGeometry(Instance instance, int srsDimension, IOProvider reader) throws GeometryNotSupportedException {
    LineString line = null;
    PointHandler handler = new PointHandler();
    // XXX support for different types of line strings in one instance (we
    // support only one type per instance!)
    // to parse coordinates of a line string
    // for use with GML 2, 3, 3.1, 3.2
    Collection<Object> values = PropertyResolver.getValues(instance, "coordinates", false);
    if (values != null && !values.isEmpty()) {
        Object value = values.iterator().next();
        if (value instanceof Instance) {
            try {
                Coordinate[] cs = GMLGeometryUtil.parseCoordinates((Instance) value);
                if (cs != null && cs.length > 0) {
                    line = getGeometryFactory().createLineString(moveCoordinates(cs, reader));
                }
            } catch (ParseException e) {
                throw new GeometryNotSupportedException("Could not parse coordinates", e);
            }
        }
    }
    // for use with GML 3, 3.2
    if (line == null) {
        values = PropertyResolver.getValues(instance, "pos", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    Coordinate c = GMLGeometryUtil.parseDirectPosition((Instance) value);
                    if (c != null) {
                        cs.add(c);
                    }
                }
            }
            Coordinate[] coords = moveCoordinates(cs.toArray(new Coordinate[cs.size()]), reader);
            line = getGeometryFactory().createLineString(coords);
        }
    }
    // for use with GML 3.1, 3.2
    if (line == null) {
        values = PropertyResolver.getValues(instance, "posList", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            Object value = iterator.next();
            if (value instanceof Instance) {
                Coordinate[] cs = GMLGeometryUtil.parsePosList((Instance) value, srsDimension);
                if (cs != null) {
                    line = getGeometryFactory().createLineString(moveCoordinates(cs, reader));
                }
            }
        }
    }
    if (line == null) {
        values = PropertyResolver.getValues(instance, "pointRep.Point", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    try {
                        @SuppressWarnings("unchecked") DefaultGeometryProperty<Point> point = (DefaultGeometryProperty<Point>) handler.createGeometry((Instance) value, srsDimension, reader);
                        cs.add(point.getGeometry().getCoordinate());
                    } catch (GeometryNotSupportedException e) {
                        throw new GeometryNotSupportedException("Could not parse Point Representation", e);
                    }
                }
            }
            Coordinate[] coords = moveCoordinates(cs.toArray(new Coordinate[cs.size()]), reader);
            line = getGeometryFactory().createLineString(coords);
        }
    }
    // for use with GML 3.1
    if (line == null) {
        values = PropertyResolver.getValues(instance, "pointProperty.Point", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    try {
                        @SuppressWarnings("unchecked") DefaultGeometryProperty<Point> point = (DefaultGeometryProperty<Point>) handler.createGeometry((Instance) value, srsDimension, reader);
                        cs.add(point.getGeometry().getCoordinate());
                    } catch (GeometryNotSupportedException e) {
                        throw new GeometryNotSupportedException("Could not parse Point Property", e);
                    }
                }
            }
            Coordinate[] coords = moveCoordinates(cs.toArray(new Coordinate[cs.size()]), reader);
            line = getGeometryFactory().createLineString(coords);
        }
    }
    // for use with GML2, 3, 3.1, 3.2
    if (line == null) {
        values = PropertyResolver.getValues(instance, "coord", false);
        if (values != null && !values.isEmpty()) {
            Iterator<Object> iterator = values.iterator();
            List<Coordinate> cs = new ArrayList<Coordinate>();
            while (iterator.hasNext()) {
                Object value = iterator.next();
                if (value instanceof Instance) {
                    Coordinate c = GMLGeometryUtil.parseCoord((Instance) value);
                    if (c != null) {
                        cs.add(c);
                    }
                }
            }
            Coordinate[] coords = moveCoordinates(cs.toArray(new Coordinate[cs.size()]), reader);
            line = getGeometryFactory().createLineString(coords);
        }
    }
    if (line != null) {
        CRSDefinition crsDef = GMLGeometryUtil.findCRS(instance);
        return new DefaultGeometryProperty<LineString>(crsDef, line);
    }
    throw new GeometryNotSupportedException();
}