com.vividsolutions.jts.operation.buffer.BufferParameters Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of JTSplus Show documentation
Show all versions of JTSplus Show documentation
JTS Topology Suite 1.14 with additional functions for GeoSpark
/*
* 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.operation.buffer;
/**
* A value class containing the parameters which
* specify how a buffer should be constructed.
*
* The parameters allow control over:
*
* - Quadrant segments (accuracy of approximation for circular arcs)
*
- End Cap style
*
- Join style
*
- Mitre limit
*
- whether the buffer is single-sided
*
*
* @author Martin Davis
*
*/
public class BufferParameters
{
/**
* Specifies a round line buffer end cap style.
*/
public static final int CAP_ROUND = 1;
/**
* Specifies a flat line buffer end cap style.
*/
public static final int CAP_FLAT = 2;
/**
* Specifies a square line buffer end cap style.
*/
public static final int CAP_SQUARE = 3;
/**
* Specifies a round join style.
*/
public static final int JOIN_ROUND = 1;
/**
* Specifies a mitre join style.
*/
public static final int JOIN_MITRE = 2;
/**
* Specifies a bevel join style.
*/
public static final int JOIN_BEVEL = 3;
/**
* The default number of facets into which to divide a fillet of 90 degrees.
* A value of 8 gives less than 2% max error in the buffer distance.
* For a max error of < 1%, use QS = 12.
* For a max error of < 0.1%, use QS = 18.
*/
public static final int DEFAULT_QUADRANT_SEGMENTS = 8;
/**
* The default mitre limit
* Allows fairly pointy mitres.
*/
public static final double DEFAULT_MITRE_LIMIT = 5.0;
/**
* The default simplify factor
* Provides an accuracy of about 1%, which matches the accuracy of the default Quadrant Segments parameter.
*/
public static final double DEFAULT_SIMPLIFY_FACTOR = 0.01;
private int quadrantSegments = DEFAULT_QUADRANT_SEGMENTS;
private int endCapStyle = CAP_ROUND;
private int joinStyle = JOIN_ROUND;
private double mitreLimit = DEFAULT_MITRE_LIMIT;
private boolean isSingleSided = false;
private double simplifyFactor = DEFAULT_SIMPLIFY_FACTOR;
/**
* Creates a default set of parameters
*
*/
public BufferParameters() {
}
/**
* Creates a set of parameters with the
* given quadrantSegments value.
*
* @param quadrantSegments the number of quadrant segments to use
*/
public BufferParameters(int quadrantSegments)
{
setQuadrantSegments(quadrantSegments);
}
/**
* Creates a set of parameters with the
* given quadrantSegments and endCapStyle values.
*
* @param quadrantSegments the number of quadrant segments to use
* @param endCapStyle the end cap style to use
*/
public BufferParameters(int quadrantSegments,
int endCapStyle)
{
setQuadrantSegments(quadrantSegments);
setEndCapStyle(endCapStyle);
}
/**
* Creates a set of parameters with the
* given parameter values.
*
* @param quadrantSegments the number of quadrant segments to use
* @param endCapStyle the end cap style to use
* @param joinStyle the join style to use
* @param mitreLimit the mitre limit to use
*/
public BufferParameters(int quadrantSegments,
int endCapStyle,
int joinStyle,
double mitreLimit)
{
setQuadrantSegments(quadrantSegments);
setEndCapStyle(endCapStyle);
setJoinStyle(joinStyle);
setMitreLimit(mitreLimit);
}
/**
* Gets the number of quadrant segments which will be used
*
* @return the number of quadrant segments
*/
public int getQuadrantSegments()
{
return quadrantSegments;
}
/**
* Sets the number of line segments used to approximate an angle fillet.
*
* - If quadSegs >= 1, joins are round, and quadSegs indicates the number of
* segments to use to approximate a quarter-circle.
*
- If quadSegs = 0, joins are bevelled (flat)
*
- If quadSegs < 0, joins are mitred, and the value of qs
* indicates the mitre ration limit as
*
* mitreLimit = |quadSegs|
*
*
* For round joins, quadSegs determines the maximum
* error in the approximation to the true buffer curve.
* The default value of 8 gives less than 2% max error in the buffer distance.
* For a max error of < 1%, use QS = 12.
* For a max error of < 0.1%, use QS = 18.
* The error is always less than the buffer distance
* (in other words, the computed buffer curve is always inside the true
* curve).
*
* @param quadSegs the number of segments in a fillet for a quadrant
*/
public void setQuadrantSegments(int quadSegs)
{
quadrantSegments = quadSegs;
/**
* Indicates how to construct fillets.
* If qs >= 1, fillet is round, and qs indicates number of
* segments to use to approximate a quarter-circle.
* If qs = 0, fillet is bevelled flat (i.e. no filleting is performed)
* If qs < 0, fillet is mitred, and absolute value of qs
* indicates maximum length of mitre according to
*
* mitreLimit = |qs|
*/
if (quadrantSegments == 0)
joinStyle = JOIN_BEVEL;
if (quadrantSegments < 0) {
joinStyle = JOIN_MITRE;
mitreLimit = Math.abs(quadrantSegments);
}
if (quadSegs <= 0) {
quadrantSegments = 1;
}
/**
* If join style was set by the quadSegs value,
* use the default for the actual quadrantSegments value.
*/
if (joinStyle != JOIN_ROUND) {
quadrantSegments = DEFAULT_QUADRANT_SEGMENTS;
}
}
/**
* Computes the maximum distance error due to a given level
* of approximation to a true arc.
*
* @param quadSegs the number of segments used to approximate a quarter-circle
* @return the error of approximation
*/
public static double bufferDistanceError(int quadSegs)
{
double alpha = Math.PI / 2.0 / quadSegs;
return 1 - Math.cos(alpha / 2.0);
}
/**
* Gets the end cap style.
*
* @return the end cap style
*/
public int getEndCapStyle()
{
return endCapStyle;
}
/**
* Specifies the end cap style of the generated buffer.
* The styles supported are {@link #CAP_ROUND}, {@link #CAP_FLAT}, and {@link #CAP_SQUARE}.
* The default is CAP_ROUND.
*
* @param endCapStyle the end cap style to specify
*/
public void setEndCapStyle(int endCapStyle)
{
this.endCapStyle = endCapStyle;
}
/**
* Gets the join style
*
* @return the join style code
*/
public int getJoinStyle()
{
return joinStyle;
}
/**
* Sets the join style for outside (reflex) corners between line segments.
* Allowable values are {@link #JOIN_ROUND} (which is the default),
* {@link #JOIN_MITRE} and {link JOIN_BEVEL}.
*
* @param joinStyle the code for the join style
*/
public void setJoinStyle(int joinStyle)
{
this.joinStyle = joinStyle;
}
/**
* Gets the mitre ratio limit.
*
* @return the limit value
*/
public double getMitreLimit()
{
return mitreLimit;
}
/**
* Sets the limit on the mitre ratio used for very sharp corners.
* The mitre ratio is the ratio of the distance from the corner
* to the end of the mitred offset corner.
* When two line segments meet at a sharp angle,
* a miter join will extend far beyond the original geometry.
* (and in the extreme case will be infinitely far.)
* To prevent unreasonable geometry, the mitre limit
* allows controlling the maximum length of the join corner.
* Corners with a ratio which exceed the limit will be beveled.
*
* @param mitreLimit the mitre ratio limit
*/
public void setMitreLimit(double mitreLimit)
{
this.mitreLimit = mitreLimit;
}
/**
* Sets whether the computed buffer should be single-sided.
* A single-sided buffer is constructed on only one side of each input line.
*
* The side used is determined by the sign of the buffer distance:
*
* - a positive distance indicates the left-hand side
*
- a negative distance indicates the right-hand side
*
* The single-sided buffer of point geometries is
* the same as the regular buffer.
*
* The End Cap Style for single-sided buffers is
* always ignored,
* and forced to the equivalent of CAP_FLAT.
*
* @param isSingleSided true if a single-sided buffer should be constructed
*/
public void setSingleSided(boolean isSingleSided)
{
this.isSingleSided = isSingleSided;
}
/**
* Tests whether the buffer is to be generated on a single side only.
*
* @return true if the generated buffer is to be single-sided
*/
public boolean isSingleSided() {
return isSingleSided;
}
/**
* Gets the simplify factor.
*
* @return the simplify factor
*/
public double getSimplifyFactor() {
return simplifyFactor;
}
/**
* Sets the factor used to determine the simplify distance tolerance
* for input simplification.
* Simplifying can increase the performance of computing buffers.
* Generally the simplify factor should be greater than 0.
* Values between 0.01 and .1 produce relatively good accuracy for the generate buffer.
* Larger values sacrifice accuracy in return for performance.
*
* @param simplifyFactor a value greater than or equal to zero.
*/
public void setSimplifyFactor(double simplifyFactor)
{
this.simplifyFactor = simplifyFactor < 0 ? 0 : simplifyFactor;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy