Application: gvSIG desktop » gvSIG data provider for DWG

import org.gvsig.fmap.geom.primitive.Curve;

//	/**

//	 * Method that changes a Point3D array to a FPolyline3D. Is useful to

//	 * convert a polyline given by it points to a FPolyline3D, a polyline 3D in

//	 * the FMap model object

//	 *

//	 * @param pts

//	 *            Array of Point3D that defines the polyline 3D that will be

//	 *            converted in a FPolyline3D

//	 * @return FPolyline3D This FPolyline3D is build using the array of Point3D

//	 *         that is the argument of the method

//	 */

//	public static FPolyline3D points3DToFPolyline3D(List pts) {

//		GeneralPathX genPathX = getGeneralPathX(pts);

//		double[] elevations = new double[pts.size()];

//		for (int i = 0; i < pts.size(); i++) {

//			elevations[i] = ((double[])pts.get(i))[2];

//		}

//		return new FPolyline3D(genPathX, elevations);

//	}

	private static GeometryManager gManager = GeometryLocator

			.getGeometryManager();

//	/**

//	 * Method that changes a Point2D array to a FPolyline2D. Is useful to

//	 * convert a polyline given by it points to a FPolyline2D, a polyline in the

//	 * FMap model object

//	 *

//	 * @param pts

//	 *            Array of Point2D that defines the polyline that will be

//	 *            converted in a FPolyline2D

//	 * @return FPolyline2D This FPolyline2D is build using the array of Point2D

//	 *         that is the argument of the method

//	 */

//	public static FPolyline2D points2DToFPolyline2D(List pts) {

//		GeneralPathX genPathX = getGeneralPathX(pts);

//		return new FPolyline2D(genPathX);

//	}

	public static MultiCurve ptsToMultiCurve(List pts, int subType)

			throws CreateGeometryException {

		if (pts.size() < 2) {

			throw new IllegalArgumentException();

		}

		Point point, prevPoint;

		Curve curve;

		MultiCurve multi = (MultiCurve) gManager.create(

				Geometry.TYPES.MULTICURVE,

				subType);

		prevPoint = FMapUtil.createPoint(subType, pts.get(0));

		for (int i = 1; i < pts.size(); i++) {

			point = FMapUtil.createPoint(subType, pts.get(i));

			curve = (Curve) gManager.create(Geometry.TYPES.CURVE, subType);

			curve.setPoints(prevPoint, point);

			multi.addCurve(curve);

			prevPoint = FMapUtil.createPoint(subType, pts.get(i));

		}

		return multi;

	}

	public static Surface ptsToPolygon(List pts, int subType)

			throws CreateGeometryException {

		if (pts.size() < 3) {

			throw new IllegalArgumentException();

		}

		Point cur;

		Surface surface = (Surface) gManager.create(Geometry.TYPES.SURFACE,

				subType);

		Iterator iter = pts.iterator();

		while (iter.hasNext()) {

			cur = createPoint(subType, iter.next());

			surface.addVertex(cur);

		}

		return surface;

	}

	public static Point createPoint(int subType,

			Object point)

			throws CreateGeometryException {

		Point result = (Point) gManager.create(Geometry.TYPES.POINT, subType);

		if (point instanceof double[]) {

			result.setCoordinates((double[]) point);

		} else if (point instanceof Point2D) {

			Point2D p = (Point2D) point;

			result.setX(p.getX());

			result.setY(p.getY());

		} else if (point instanceof IDwgVertex) {

			result.setCoordinates(((IDwgVertex) point).getPoint());

		} else {

			throw new IllegalArgumentException();

		}

		return result;

	}

	/**

	 * Devuelve la distancia desde angle1 a angle2. Angulo en radianes de

	 * diferencia entre angle1 y angle2 en sentido antihorario

	 *

	 * @param angle1 angulo en radianes. Debe ser positivo y no dar ninguna

	 * 		  vuelta a la circunferencia

	 * @param angle2 angulo en radianes. Debe ser positivo y no dar ninguna

	 * 		  vuelta a la circunferencia

	 *

	 * @return distancia entre los �ngulos

	 */

	public static double angleDistance(double angle1, double angle2) {

		if (angle1 < angle2) {

			return angle2 - angle1;

		} else {

			return ((Math.PI * 2) - angle1) + angle2;

		}

	}