/*
* 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.generator;
import com.vividsolutions.jts.geom.*;
import com.vividsolutions.jts.operation.valid.IsValidOp;
/**
*
* This class is used to create a line string within the specified bounding box.
*
* Sucessive calls to create may or may not return the same geometry topology.
*
* @author David Zwiers, Vivid Solutions.
*/
public class LineStringGenerator extends GeometryGenerator {
protected int numberPoints = 2;
protected int generationAlgorithm = 0;
/**
* Create the points in a vertical line
*/
public static final int VERT = 1;
/**
* Create the points in a horizontal line
*/
public static final int HORZ = 2;
/**
* Create the points in an approximation of an open circle (one edge will not be included).
*
* Note: this requires the number of points to be greater than 2.
*
* @see #getNumberPoints()
* @see #setNumberPoints(int)
*/
public static final int ARC = 0;
/**
* Number of interations attempting to create a valid line string
*/
private static final int RUNS = 5;
/**
* As the user increases the number of points, the probability of creating a random valid linestring decreases.
* Please take not of this when selecting the generation style, and the number of points.
*
* May return null if a geometry could not be created.
*
* @see #getNumberPoints()
* @see #setNumberPoints(int)
* @see #getGenerationAlgorithm()
* @see #setGenerationAlgorithm(int)
*
* @see #VERT
* @see #HORZ
* @see #ARC
*
* @see com.vividsolutions.jts.generator.GeometryGenerator#create()
*
* @throws IllegalStateException When the alg is not valid or the number of points is invalid
* @throws NullPointerException when either the Geometry Factory, or the Bounding Box are undefined.
*/
public Geometry create() {
if(geometryFactory == null){
throw new NullPointerException("GeometryFactory is not declared");
}
if(boundingBox == null || boundingBox.isNull()){
throw new NullPointerException("Bounding Box is not declared");
}
if(numberPoints<2){
throw new IllegalStateException("Too few points");
}
Coordinate[] coords = new Coordinate[numberPoints];
double x = boundingBox.getMinX(); // base x
double dx = boundingBox.getMaxX()-x;
double y = boundingBox.getMinY(); // base y
double dy = boundingBox.getMaxY()-y;
for(int i=0;i<RUNS;i++){
switch(getGenerationAlgorithm()){
case VERT:
fillVert(x,dx,y,dy,coords,geometryFactory);
break;
case HORZ:
fillHorz(x,dx,y,dy,coords,geometryFactory);
break;
case ARC:
fillArc(x,dx,y,dy,coords,geometryFactory);
break;
default:
throw new IllegalStateException("Invalid Alg. Specified");
}
LineString ls = geometryFactory.createLineString(coords);
IsValidOp valid = new IsValidOp(ls);
if(valid.isValid()){
return ls;
}
}
return null;
}
private static void fillVert(double x, double dx, double y, double dy, Coordinate[] coords, GeometryFactory gf){
double fx = x+Math.random()*dx;
double ry = dy; // remainder of y distance
coords[0] = new Coordinate(fx,y);
gf.getPrecisionModel().makePrecise(coords[0]);
for(int i=1;i<coords.length-1;i++){
ry -= Math.random()*ry;
coords[i] = new Coordinate(fx,y+dy-ry);
gf.getPrecisionModel().makePrecise(coords[i]);
}
coords[coords.length-1] = new Coordinate(fx,y+dy);
gf.getPrecisionModel().makePrecise(coords[coords.length-1]);
}
private static void fillHorz(double x, double dx, double y, double dy, Coordinate[] coords, GeometryFactory gf){
double fy = y+Math.random()*dy;
double rx = dx; // remainder of x distance
coords[0] = new Coordinate(x,fy);
gf.getPrecisionModel().makePrecise(coords[0]);
for(int i=1;i<coords.length-1;i++){
rx -= Math.random()*rx;
coords[i] = new Coordinate(x+dx-rx,fy);
gf.getPrecisionModel().makePrecise(coords[i]);
}
coords[coords.length-1] = new Coordinate(x+dx,fy);
gf.getPrecisionModel().makePrecise(coords[coords.length-1]);
}
private static void fillArc(double x, double dx, double y, double dy, Coordinate[] coords, GeometryFactory gf){
if(coords.length == 2)
throw new IllegalStateException("Too few points for Arc");
double theta = 360/coords.length;
double start = theta/2;
double radius = dx<dy?dx/3:dy/3;
double cx = x+(dx/2); // center
double cy = y+(dy/2); // center
for(int i=0;i<coords.length;i++){
double angle = Math.toRadians(start+theta*i);
double fx = Math.sin(angle)*radius; // may be neg.
double fy = Math.cos(angle)*radius; // may be neg.
coords[i] = new Coordinate(cx+fx,cy+fy);
gf.getPrecisionModel().makePrecise(coords[i]);
}
}
/**
* @return Returns the numberPoints.
*/
public int getNumberPoints() {
return numberPoints;
}
/**
* @param numberPoints The numberPoints to set.
*/
public void setNumberPoints(int numberPoints) {
this.numberPoints = numberPoints;
}
/**
* @return Returns the generationAlgorithm.
*/
public int getGenerationAlgorithm() {
return generationAlgorithm;
}
/**
* @param generationAlgorithm The generationAlgorithm to set.
*/
public void setGenerationAlgorithm(int generationAlgorithm) {
this.generationAlgorithm = generationAlgorithm;
}
}