Java CGAlgorithms.isCCW方法代码示例

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
public Coordinate[] ensureOrientation(
		final int desiredOrientation, final Coordinate... coord) {
	if (coord.length == 0) {
		return coord;
	}

	final int orientation = CGAlgorithms.isCCW(coord) ? CGAlgorithms.COUNTERCLOCKWISE
			: CGAlgorithms.CLOCKWISE;

	if (orientation != desiredOrientation) {
		final Coordinate[] reverse = (Coordinate[]) coord.clone();
		reverse(reverse);

		return reverse;
	}

	return coord;
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * Adds an offset curve for a polygon ring.
 * The side and left and right topological location arguments
 * assume that the ring is oriented CW.
 * If the ring is in the opposite orientation,
 * the left and right locations must be interchanged and the side flipped.
 *
 * @param coord the coordinates of the ring (must not contain repeated points)
 * @param offsetDistance the distance at which to create the buffer
 * @param side the side of the ring on which to construct the buffer line
 * @param cwLeftLoc the location on the L side of the ring (if it is CW)
 * @param cwRightLoc the location on the R side of the ring (if it is CW)
 */
private void addPolygonRing(Coordinate[] coord, double offsetDistance, int side, int cwLeftLoc, int cwRightLoc) {
    // don't bother adding ring if it is "flat" and will disappear in the output
    if (offsetDistance == 0.0 && coord.length < LinearRing.MINIMUM_VALID_SIZE) {
        return;
    }

    int leftLoc = cwLeftLoc;
    int rightLoc = cwRightLoc;
    if (coord.length >= LinearRing.MINIMUM_VALID_SIZE
            && CGAlgorithms.isCCW(coord)) {
        leftLoc = cwRightLoc;
        rightLoc = cwLeftLoc;
        side = Position.opposite(side);
    }
    Coordinate[] curve = this.curveBuilder.getRingCurve(coord, side, offsetDistance);
    this.addCurve(curve, leftLoc, rightLoc);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * Adds an offset curve for a polygon ring.
 * The side and left and right topological location arguments
 * assume that the ring is oriented CW.
 * If the ring is in the opposite orientation,
 * the left and right locations must be interchanged and the side flipped.
 *
 * @param coord          the coordinates of the ring (must not contain repeated points)
 * @param offsetDistance the distance at which to create the buffer
 * @param side           the side of the ring on which to construct the buffer line
 * @param cwLeftLoc      the location on the L side of the ring (if it is CW)
 * @param cwRightLoc     the location on the R side of the ring (if it is CW)
 */
private void addPolygonRing(Coordinate[] coord, double offsetDistance, int side, int cwLeftLoc, int cwRightLoc) {
    // don't bother adding ring if it is "flat" and will disappear in the output
    if (offsetDistance == 0.0 && coord.length < LinearRing.MINIMUM_VALID_SIZE)
        return;

    int leftLoc = cwLeftLoc;
    int rightLoc = cwRightLoc;
    if (coord.length >= LinearRing.MINIMUM_VALID_SIZE
            && CGAlgorithms.isCCW(coord)) {
        leftLoc = cwRightLoc;
        rightLoc = cwLeftLoc;
        side = Position.opposite(side);
    }
    Coordinate[] curve = curveBuilder.getRingCurve(coord, side, offsetDistance);
    addCurve(curve, leftLoc, rightLoc);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
     * Compute a LinearRing from the point list previously collected.
     * Test if the ring is a hole (i.e. if it is CCW) and set the hole flag
     * accordingly.
     */
    public void computeRing() {
        if (this.ring != null) {
            return;   // don't compute more than once
        }
        Coordinate[] coord = new Coordinate[this.pts.size()];
        for (int i = 0; i < this.pts.size(); i++) {
            coord[i] = (Coordinate) this.pts.get(i);
        }
        this.ring = this.geometryFactory.createLinearRing(coord);
        this.isHole = CGAlgorithms.isCCW(this.ring.getCoordinates());
//Debug.println( (isHole ? "hole - " : "shell - ") + WKTWriter.toLineString(new CoordinateArraySequence(ring.getCoordinates())));
    }
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * Adds a polygon ring to the graph.
 * Empty rings are ignored.
 * <p>
 * The left and right topological location arguments assume that the ring is oriented CW.
 * If the ring is in the opposite orientation,
 * the left and right locations must be interchanged.
 */
private void addPolygonRing(LinearRing lr, int cwLeft, int cwRight) {
    // don't bother adding empty holes
    if (lr.isEmpty()) {
        return;
    }

    Coordinate[] coord = CoordinateArrays.removeRepeatedPoints(lr.getCoordinates());

    if (coord.length < 4) {
        this.hasTooFewPoints = true;
        this.invalidPoint = coord[0];
        return;
    }

    int left = cwLeft;
    int right = cwRight;
    if (CGAlgorithms.isCCW(coord)) {
        left = cwRight;
        right = cwLeft;
    }
    Edge e = new Edge(coord,
            new Label(this.argIndex, Location.BOUNDARY, left, right));
    this.lineEdgeMap.put(lr, e);

    this.insertEdge(e);
    // insert the endpoint as a node, to mark that it is on the boundary
    this.insertPoint(this.argIndex, coord[0], Location.BOUNDARY);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
private void normalize(LinearRing ring, boolean clockwise) {
    if (ring.isEmpty()) {
        return;
    }
    Coordinate[] uniqueCoordinates = new Coordinate[ring.getCoordinates().length - 1];
    System.arraycopy(ring.getCoordinates(), 0, uniqueCoordinates, 0, uniqueCoordinates.length);
    Coordinate minCoordinate = CoordinateArrays.minCoordinate(ring.getCoordinates());
    CoordinateArrays.scroll(uniqueCoordinates, minCoordinate);
    System.arraycopy(uniqueCoordinates, 0, ring.getCoordinates(), 0, uniqueCoordinates.length);
    ring.getCoordinates()[uniqueCoordinates.length] = uniqueCoordinates[0];
    if (CGAlgorithms.isCCW(ring.getCoordinates()) == clockwise) {
        CoordinateArrays.reverse(ring.getCoordinates());
    }
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
public static boolean isClockwise(ILineString line) {
  Geometry geom = null;
  try {
    geom = AdapterFactory.toGeometry(new GeometryFactory(), line);
  } catch (Exception e) {
    e.printStackTrace();
  }
  if (CGAlgorithms.isCCW(geom.getCoordinates()))
    return false;
  return true;
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
private static boolean isCCW(Coordinate[] oldCoordinates) {
	Coordinate[] coordinates = new Coordinate[oldCoordinates.length+1];
	int i=0;
	for(Coordinate coordinate : oldCoordinates) {
		coordinates[i++] = coordinate;
	}
	
	coordinates[coordinates.length-1] = coordinates[0]; 
	return CGAlgorithms.isCCW(coordinates);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * <p>convertPolygonPatch.</p>
 *
 * @param polygonPatch a {@link net.opengis.gml.v_3_1_1.PolygonPatchType} object.
 * @return a {@link com.vividsolutions.jts.geom.Polygon} object.
 * @throws nl.pdok.gml3.exceptions.GeometryException if any.
 */
public Polygon convertPolygonPatch(PolygonPatchType polygonPatch)
		throws GeometryException {
	if(polygonPatch.getExterior() == null) {
		throw new InvalidGeometryException(GeometryValidationErrorType.POLYGON_HAS_NO_EXTERIOR, null);
	}
	
	AbstractRingPropertyType abstractRing = polygonPatch.getExterior().getValue();
	LinearRing exteriorShell = gmlToLineConvertor.translateAbstractRing(abstractRing);
	if (!CGAlgorithms.isCCW(exteriorShell.getCoordinates())) {
		throw new InvalidGeometryException(
				GeometryValidationErrorType.OUTER_RING_IS_NOT_CCW, null);
	}

	LinearRing[] innerRings = new LinearRing[polygonPatch.getInterior().size()];
	for (int i = 0; i < polygonPatch.getInterior().size(); i++) {
		innerRings[i] = gmlToLineConvertor.translateAbstractRing(polygonPatch.getInterior()
				.get(i).getValue());
		if (CGAlgorithms.isCCW(innerRings[i].getCoordinates())) {
			throw new InvalidGeometryException(
					GeometryValidationErrorType.INNER_RING_IS_CCW, null);
		}

	}

	return geometryFactory.createPolygon(exteriorShell, innerRings);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * <p>convertPolygonPatch.</p>
 *
 * @param polygonPatch a {@link net.opengis.gml.v_3_2_1.PolygonPatchType} object.
 * @return a {@link com.vividsolutions.jts.geom.Polygon} object.
 * @throws nl.pdok.gml3.exceptions.GeometryException if any.
 */
public Polygon convertPolygonPatch(PolygonPatchType polygonPatch)
        throws GeometryException {
    if (polygonPatch.getExterior() == null) {
        throw new InvalidGeometryException(GeometryValidationErrorType.POLYGON_HAS_NO_EXTERIOR, null);
    }

    AbstractRingPropertyType abstractRing = polygonPatch.getExterior();
    LinearRing exteriorShell = gmlToLineConvertor.translateAbstractRing(abstractRing);
    if (!CGAlgorithms.isCCW(exteriorShell.getCoordinates())) {

        // Try to reverse it and try again
        exteriorShell = reverseRing(exteriorShell);
        if (!CGAlgorithms.isCCW(exteriorShell.getCoordinates())) {
            throw new InvalidGeometryException(
                    GeometryValidationErrorType.OUTER_RING_IS_NOT_CCW, null);
        }
    }

    LinearRing[] innerRings = new LinearRing[polygonPatch.getInterior().size()];
    for (int i = 0; i < polygonPatch.getInterior().size(); i++) {
        innerRings[i] = gmlToLineConvertor.translateAbstractRing(polygonPatch.getInterior()
                .get(i));
        if (CGAlgorithms.isCCW(innerRings[i].getCoordinates())) {
            throw new InvalidGeometryException(
                    GeometryValidationErrorType.INNER_RING_IS_CCW, null);
        }

    }

    return geometryFactory.createPolygon(exteriorShell, innerRings);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
     * Compute a LinearRing from the point list previously collected.
     * Test if the ring is a hole (i.e. if it is CCW) and set the hole flag
     * accordingly.
     */
    public void computeRing() {
        if (ring != null) return;   // don't compute more than once
        Coordinate[] coord = new Coordinate[pts.size()];
        for (int i = 0; i < pts.size(); i++) {
            coord[i] = (Coordinate) pts.get(i);
        }
        ring = geometryFactory.createLinearRing(coord);
        isHole = CGAlgorithms.isCCW(ring.getCoordinates());
//Debug.println( (isHole ? "hole - " : "shell - ") + WKTWriter.toLineString(new CoordinateArraySequence(ring.getCoordinates())));
    }
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * Adds a polygon ring to the graph.
 * Empty rings are ignored.
 * <p/>
 * The left and right topological location arguments assume that the ring is oriented CW.
 * If the ring is in the opposite orientation,
 * the left and right locations must be interchanged.
 */
private void addPolygonRing(LinearRing lr, int cwLeft, int cwRight) {
    // don't bother adding empty holes
    if (lr.isEmpty()) return;

    Coordinate[] coord = CoordinateArrays.removeRepeatedPoints(lr.getCoordinates());

    if (coord.length < 4) {
        hasTooFewPoints = true;
        invalidPoint = coord[0];
        return;
    }

    int left = cwLeft;
    int right = cwRight;
    if (CGAlgorithms.isCCW(coord)) {
        left = cwRight;
        right = cwLeft;
    }
    Edge e = new Edge(coord,
            new Label(argIndex, Location.BOUNDARY, left, right));
    lineEdgeMap.put(lr, e);

    insertEdge(e);
    // insert the endpoint as a node, to mark that it is on the boundary
    insertPoint(argIndex, coord[0], Location.BOUNDARY);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
   * Compute a LinearRing from the point list previously collected.
   * Test if the ring is a hole (i.e. if it is CCW) and set the hole flag
   * accordingly.
   */
  public void computeRing()
  {
    if (ring != null) return;   // don't compute more than once
    Coordinate[] coord = new Coordinate[pts.size()];
    for (int i = 0; i < pts.size(); i++) {
      coord[i] = (Coordinate) pts.get(i);
    }
    ring = geometryFactory.createLinearRing(coord);
    isHole = CGAlgorithms.isCCW(ring.getCoordinates());
//Debug.println( (isHole ? "hole - " : "shell - ") + WKTWriter.toLineString(new CoordinateArraySequence(ring.getCoordinates())));
  }
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
@Override
public boolean isCCW()
{
  Coordinate[] coordinates = new Coordinate[getNumPoints()];
  for (int i = 0; i < getNumPoints(); i++)
  {
    Point pt = getPoint(i);
    coordinates[i] = new Coordinate(pt.getX(), pt.getY());
  }

  return CGAlgorithms.isCCW(coordinates);
}
 

import com.vividsolutions.jts.algorithm.CGAlgorithms; //导入方法依赖的package包/类
/**
 * make sure outer ring is CCW and holes are CW
 * 
 * @param p
 *          polygon to check
 */
static Polygon createShpPolygon(Polygon p) {
  LinearRing outer;
  LinearRing[] holes = new LinearRing[p.getNumInteriorRing()];
  Coordinate[] coords;

  if (p.isEmpty())
    return p;

  coords = p.getExteriorRing().getCoordinates();

  if (CGAlgorithms.isCCW(coords)) {
    outer = reverseRing((LinearRing) p.getExteriorRing());
  } else {
    outer = (LinearRing) p.getExteriorRing();
  }

  for (int t = 0; t < p.getNumInteriorRing(); t++) {
    coords = p.getInteriorRingN(t).getCoordinates();

    if (!(CGAlgorithms.isCCW(coords))) {
      holes[t] = reverseRing((LinearRing) p.getInteriorRingN(t));
    } else {
      holes[t] = (LinearRing) p.getInteriorRingN(t);
    }
  }

  return new Polygon(outer, holes, new PrecisionModel(), 0);
}