Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.jts.coerce;

import java.util.Iterator;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryCoercionContext;

import static org.gvsig.fmap.geom.GeometryCoercionContext.MODE_ONERROR_DONTCONVERT;

import static org.gvsig.fmap.geom.GeometryCoercionContext.MODE_ONERROR_NULL;

import static org.gvsig.fmap.geom.GeometryCoercionContext.MODE_ONERROR_THROW;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.geom.jts.AbstractGeometry;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

import org.gvsig.fmap.geom.primitive.Line;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.primitive.Polygon;

import org.gvsig.fmap.geom.primitive.Primitive;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.dataTypes.AbstractCoercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.CoercionContext;

/**

 * Convert a object to Geometry.

 *

 * Support convert: - Geometry to Geometry (do nothing) - WKB (byte[]) to

 * Geometry - WKT (String/toString) to Geometry

 *

 *

 * @author gvSIG Team

 * @version $Id$

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class CoerceToGeometry extends AbstractCoercion {

    private static GeometryManager manager = null;

    @Override

    public Object coerce(Object value, CoercionContext context) throws CoercionException {

        if (value == null) {

            return value;

        }

        int mode = MODE_ONERROR_NULL;

        Geometry geom;

        GeometryType targetGeometryType = null;

        Geometry sourcegeom = null;

        try {

//            TODO: descomentarizar para que tengan efecto los cambios.

            if ( context instanceof GeometryCoercionContext) {

                GeometryCoercionContext geomContext = (GeometryCoercionContext) context;

                targetGeometryType = geomContext.getGeometryType();

                mode = geomContext.getMode();

            }

            if ( value instanceof Geometry ) {

                geom = (Geometry) value;

            } else {

                if (value instanceof byte[]) {

                    geom = getManager().createFrom((byte[]) value);

                } else {

                    String wkt = value.toString();

                    if (StringUtils.isBlank(wkt)) {

                        return null;

                    }

                    geom = getManager().createFrom(value.toString());

                }

                if (geom == null) {

                    // Can't parse from WKB/WKT

                    switch(mode) {

                        case MODE_ONERROR_NULL:

                        case MODE_ONERROR_DONTCONVERT:

                            return null;

                        case MODE_ONERROR_THROW:

                        default:

                            throw new CoercionException();

                    }

                }

            }

            if ( targetGeometryType==null) {

                return geom;

            }

            sourcegeom = geom;

            if (geom.getGeometryType().equals(targetGeometryType)) {

                return geom;

            }

            switch (targetGeometryType.getType()) {

                case Geometry.TYPES.MULTIPOINT:

                    geom = geom.toPoints();

                    break;

                case Geometry.TYPES.MULTICURVE:

                    if(geom.getGeometryType().getSubType() != Geometry.TYPES.MULTICURVE){

                        geom = geom.toLines();

                    }

                    break;

                case Geometry.TYPES.MULTILINE:

                    geom = geom.toLines();

                    break;

                case Geometry.TYPES.MULTISURFACE:

                    if(geom.getGeometryType().getSubType() != Geometry.TYPES.MULTISURFACE){

                        geom = geom.toPolygons();

                    }

                    break;

                case Geometry.TYPES.MULTIPOLYGON:

                    geom = geom.toPolygons();

                    break;

                case Geometry.TYPES.POINT:

                    geom = this.convertToPoint(targetGeometryType, geom);

                    break;

                case Geometry.TYPES.CURVE:

                    if(geom.getGeometryType().getSubType() != Geometry.TYPES.CURVE){

                        geom = this.convertToLine(targetGeometryType, geom);

                    }

                    break;

                case Geometry.TYPES.LINE:

                    geom = this.convertToLine(targetGeometryType, geom);

                    break;

                case Geometry.TYPES.SURFACE:

                    if(geom.getGeometryType().getSubType() != Geometry.TYPES.SURFACE){

                        geom = this.convertToPolygon(targetGeometryType, geom);

                    }

                    break;

                case Geometry.TYPES.POLYGON:

                    geom = this.convertToPolygon(targetGeometryType, geom);

                    break;

                case Geometry.TYPES.GEOMETRY:

                    //Do not convert

                    break;

                default:

                    geom = null;

                    break;

            }

            if (geom.getGeometryType().getSubType() != targetGeometryType.getSubType()) {

                geom = geom.forceSubtype(targetGeometryType.getSubType());

            }

            if (geom != null) {

                // Return converted geometry

                return geom;

            }

            switch(mode) {

                case MODE_ONERROR_NULL:

                    return null;

                case MODE_ONERROR_DONTCONVERT:

                    return sourcegeom;

                case MODE_ONERROR_THROW:

                default:

                    throw new CoercionException();

            }

        } catch (Exception e) {

            switch(mode) {

                case MODE_ONERROR_NULL:

                    return null;

                case MODE_ONERROR_DONTCONVERT:

                    return sourcegeom;

                case MODE_ONERROR_THROW:

                default:

                    throw new CoercionException();

            }

        }

    }

    private static GeometryManager getManager() {

        if (manager == null) {

            manager = GeometryLocator.getGeometryManager();

        }

        return manager;

    }

    private Geometry convertToPoint(GeometryType geometryType, Geometry geom) {

        try {

            Point target = null;

            MultiPoint points = geom.toPoints();

            if(points.getPrimitivesNumber() == 1){

               target = (Point) points.getPrimitiveAt(0); 

            }

            return target;

        } catch (Exception ex) {

            return null;

        }

    }

    private Geometry convertToLine(GeometryType geometryType, Geometry geom) {

        try {

            Line target = null;

            MultiLine lines = geom.toLines();

            if(lines.getPrimitivesNumber() == 1){

               target = (Line) lines.getPrimitiveAt(0); 

            }

            return target;

        } catch (Exception ex) {

            return null;

        }

    }

    private Geometry convertToPolygon(GeometryType geometryType, Geometry geom) {

        try {

            Polygon target = null;

            MultiPolygon polygons = geom.toPolygons();

            if(polygons.getPrimitivesNumber() == 1){

               target = (Polygon) polygons.getPrimitiveAt(0); 

            }

            return target;

        } catch (Exception ex) {

            return null;

        }

    }

}