/* * The JTS Topology Suite is a collection of Java classes that * implement the fundamental operations required to validate a given * geo-spatial data set to a known topological specification. * * Copyright (C) 2001 Vivid Solutions * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * For more information, contact: * * Vivid Solutions * Suite #1A * 2328 Government Street * Victoria BC V8T 5G5 * Canada * * (250)385-6040 * www.vividsolutions.com */ package com.vividsolutions.jts.precision; import com.vividsolutions.jts.geom.*; import com.vividsolutions.jts.operation.overlay.OverlayOp; /** * Provides versions of Geometry spatial functions which use * enhanced precision techniques to reduce the likelihood of robustness problems. * * @version 1.7 */ public class EnhancedPrecisionOp { /** * Computes the set-theoretic intersection of two {@link Geometry}s, using enhanced precision. * @param geom0 the first Geometry * @param geom1 the second Geometry * @return the Geometry representing the set-theoretic intersection of the input Geometries. */ public static Geometry intersection(Geometry geom0, Geometry geom1) { RuntimeException originalEx; try { Geometry result = geom0.intersection(geom1); return result; } catch (RuntimeException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); Geometry resultEP = cbo.intersection(geom0, geom1); // check that result is a valid geometry after the reshift to orginal precision if (! resultEP.isValid()) throw originalEx; return resultEP; } catch (RuntimeException ex2) { throw originalEx; } } /** * Computes the set-theoretic union of two {@link Geometry}s, using enhanced precision. * @param geom0 the first Geometry * @param geom1 the second Geometry * @return the Geometry representing the set-theoretic union of the input Geometries. */ public static Geometry union(Geometry geom0, Geometry geom1) { RuntimeException originalEx; try { Geometry result = geom0.union(geom1); return result; } catch (RuntimeException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); Geometry resultEP = cbo.union(geom0, geom1); // check that result is a valid geometry after the reshift to orginal precision if (! resultEP.isValid()) throw originalEx; return resultEP; } catch (RuntimeException ex2) { throw originalEx; } } /** * Computes the set-theoretic difference of two {@link Geometry}s, using enhanced precision. * @param geom0 the first Geometry * @param geom1 the second Geometry * @return the Geometry representing the set-theoretic difference of the input Geometries. */ public static Geometry difference(Geometry geom0, Geometry geom1) { RuntimeException originalEx; try { Geometry result = geom0.difference(geom1); return result; } catch (RuntimeException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); Geometry resultEP = cbo.difference(geom0, geom1); // check that result is a valid geometry after the reshift to orginal precision if (! resultEP.isValid()) throw originalEx; return resultEP; } catch (RuntimeException ex2) { throw originalEx; } } /** * Computes the set-theoretic symmetric difference of two {@link Geometry}s, using enhanced precision. * @param geom0 the first Geometry * @param geom1 the second Geometry * @return the Geometry representing the set-theoretic symmetric difference of the input Geometries. */ public static Geometry symDifference(Geometry geom0, Geometry geom1) { RuntimeException originalEx; try { Geometry result = geom0.symDifference(geom1); return result; } catch (RuntimeException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); Geometry resultEP = cbo.symDifference(geom0, geom1); // check that result is a valid geometry after the reshift to orginal precision if (! resultEP.isValid()) throw originalEx; return resultEP; } catch (RuntimeException ex2) { throw originalEx; } } /** * Computes the buffer of a {@link Geometry}, using enhanced precision. * This method should no longer be necessary, since the buffer algorithm * now is highly robust. * * @param geom the first Geometry * @param distance the buffer distance * @return the Geometry representing the buffer of the input Geometry. */ public static Geometry buffer(Geometry geom, double distance) { RuntimeException originalEx; try { Geometry result = geom.buffer(distance); return result; } catch (RuntimeException ex) { originalEx = ex; } /* * If we are here, the original op encountered a precision problem * (or some other problem). Retry the operation with * enhanced precision to see if it succeeds */ try { CommonBitsOp cbo = new CommonBitsOp(true); Geometry resultEP = cbo.buffer(geom, distance); // check that result is a valid geometry after the reshift to orginal precision if (! resultEP.isValid()) throw originalEx; return resultEP; } catch (RuntimeException ex2) { throw originalEx; } } }