Application: gvSIG desktop

import java.util.ArrayList;

import java.util.List;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.PrecisionModel;

import com.vividsolutions.jts.geom.TopologyException;

import com.vividsolutions.jts.precision.GeometryPrecisionReducer;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

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

import org.gvsig.fmap.geom.util.Converter;

    public Geometry union(Geometry other)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException {

        com.vividsolutions.jts.geom.Geometry this_jts, other_jts, union_jts;

        Geometry resp = null;

        try {

            this_jts = getJTS();

            other_jts = Converter.geometryToJts(other);

            union_jts = this_jts.union(other_jts);

            if (union_jts instanceof Polygon) {

                double tole = union_jts.getArea();

                tole = tole * 1e-12;

                union_jts = removeInvalidHoles((Polygon) union_jts, tole);

            } else {

                if (union_jts instanceof MultiPolygon) {

                    double tole = union_jts.getArea();

                    tole = tole * 1e-12;

                    union_jts =

                        removeInvalidHoles((MultiPolygon) union_jts, tole);

                }

            }

            resp = Converter.jtsToGeometry(union_jts);

            return resp;

        } catch (CreateGeometryException e) {

            throw new GeometryOperationException(e);

        } catch (TopologyException e) {

            /*

             * If JTS throws this, we'll try to simplify them

             */

            try {

                this_jts = getJTS();

                other_jts = Converter.geometryToJts(other);

                PrecisionModel pm = new PrecisionModel(1000000);

                GeometryPrecisionReducer gpr = new GeometryPrecisionReducer(pm);

                this_jts = gpr.reduce(this_jts);

                other_jts = gpr.reduce(other_jts);

                union_jts = this_jts.union(other_jts);

                if (union_jts instanceof Polygon) {

                    double tole = union_jts.getArea();

                    tole = tole * 1e-12;

                    union_jts = removeInvalidHoles((Polygon) union_jts, tole);

                } else {

                    if (union_jts instanceof MultiPolygon) {

                        double tole = union_jts.getArea();

                        tole = tole * 1e-12;

                        union_jts =

                            removeInvalidHoles((MultiPolygon) union_jts, tole);

                    }

                }

                resp = Converter.jtsToGeometry(union_jts);

                return resp;

            } catch (Exception exc) {

                throw new GeometryOperationException(exc);

            }

        }

    }

    private com.vividsolutions.jts.geom.Geometry getJTS() {

        return Converter.geometryToJts(this);

    }

    private MultiPolygon removeInvalidHoles(MultiPolygon mpo, double tol) {

        GeometryFactory gf = new GeometryFactory(mpo.getPrecisionModel());

        int npo = mpo.getNumGeometries();

        Polygon[] pos = new Polygon[npo];

        for (int i=0; i<npo; i++) {

            pos[i] = removeInvalidHoles((Polygon) mpo.getGeometryN(i), tol);

        }

        return gf.createMultiPolygon(pos);

    }

    private Polygon removeInvalidHoles(Polygon po, double tol) {

        GeometryFactory gf = new GeometryFactory(po.getPrecisionModel());

        int nholes = po.getNumInteriorRing();

        List validholes = new ArrayList();

        for (int i=0; i<nholes; i++) {

            LineString ls = po.getInteriorRingN(i);

            LinearRing lr = toLinearRing(ls, gf);

            if (getLinearRingArea(lr, gf) > tol) {

                validholes.add(lr);

            }

        }

        if (validholes.size() < nholes) {

            LinearRing[] holes = (LinearRing[]) validholes.toArray(new LinearRing[0]);

            return gf.createPolygon(

                toLinearRing(po.getExteriorRing(), gf), holes);

        } else {

            return po;

        }

    }

    private double getLinearRingArea(LinearRing lr, GeometryFactory gf) {

        Polygon po = gf.createPolygon(lr);

        double resp = po.getArea(); 

        return resp;

    }

    private LinearRing toLinearRing(LineString ls, GeometryFactory gf) {

        return gf.createLinearRing(ls.getCoordinateSequence());

    }