| gvSIG desktop 1

import com.iver.cit.gvsig.fmap.core.FPolygon2D;

					if(from == null){

						from = new Coordinate(dataCoords[0], dataCoords[1]);

						first = from;

						break;

					} else {

						/* Puede significar un agujero en un pol?gono o un salto en una linea.

						 * Entonces, consumimos los segmentos que llevamos

						 * y empezamos un nuevo pol?gono o una nueva linea.

						 */

						try {

							if(p instanceof FPolygon2D){

								offsetSegments.append(offsetAndConsumeClosedSegments(offset, segments),

										false);

							} else {

								offsetSegments.append(offsetAndConsumeSegments(offset, segments),

										false);

							}

						} catch (NotEnoughSegmentsToClosePathException e) {

							Logger.getLogger(Line2DOffset.class).error(

									e.getMessage(), e);

						}

						segments.clear();

						from = new Coordinate(dataCoords[0], dataCoords[1]);

						first = from;

						break;

					}

					//					from = first;

					segments.clear();

					first =null;

					from = null;

					false);

	throws ParallelLinesCannotBeResolvedException, NotEnoughSegmentsToClosePathException {

			Hashtable<LineSegment, LineEquation> offsetLines = new Hashtable<LineSegment, LineEquation>();

			// first calculate offset lines with the starting point

			for (int i = 0; i < segmentCount; i++) {

				LineSegment segment = segments.get(i);

				double theta = segment.angle();

				//FIXME: ?Esto para qu? es?

				//			if (Math.abs(theta) % (Math.PI*0.5) < 0.00001){

				//				theta=theta+0.00000000000001;

				//			}

				double xOffset = offset * Math.sin(theta);

				double yOffset = offset * Math.cos(theta);

				Coordinate p0 = segment.p0;

				double x0 = p0.x + xOffset;

				double y0 = p0.y - yOffset;

				Coordinate p1 = segment.p1;

				double x1 = p1.x + xOffset;

				double y1 = p1.y - yOffset;

				LineEquation offsetLine = new LineEquation(theta, x0, y0, x1, y1);

				offsetLines.put(segment, offsetLine);

			}

			/*

			 * let's now calculate the end point of each segment with the point

			 * where each line crosses the next one. this point will be the end

			 * point of the first line, and the start point of its next one.

			 */

			Point2D pIni = null;

			Point2D pEnd = null;

			Point2D firstP = null;

			GeneralPathX gpx = new GeneralPathX();

			for (int i = 0; i < segmentCount; i++) {

				LineSegment segment = segments.get(0);

				LineEquation eq = offsetLines.get(segment);

				if (i == 0) { //Calculo de la intersecci?n entre el primer segmento y el ?ltimo

					LineEquation eq0 = offsetLines.get(segments.get(segmentCount-1));

					try{

						pIni = eq0.resolve(eq);

					} catch (ParallelLinesCannotBeResolvedException e) { //Las lineas son paralelas y NO son la misma.

//						pIni = new Point2D.Double(eq0.xEnd, eq0.yEnd);

						pIni = new Point2D.Double(eq.x, eq.y);

					}

					firstP = pIni;

				} else {

					pIni = pEnd;

				}

				if (i < segmentCount - 1) {

					LineEquation eq1 = offsetLines.get(segments.get(1));

					try{

						pEnd = eq.resolve(eq1);

					} catch (ParallelLinesCannotBeResolvedException e) { //Las lineas son paralelas y NO son la misma.

						pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

						gpx.append(new Line2D.Double(pIni, pEnd), true); // a?adimos una linea hasta el final del primer segmento

						//					 y asignamos como punto final el principio del siguiente segmento

						//					 para que en la siguiente iteraci?n lo tome como punto inicial.

						pIni = pEnd;

						pEnd = new Point2D.Double(eq1.x, eq1.y);

						segments.remove(0);

						continue;

					}

				} else {

//					pEnd = new Point2D.Double(eq.xEnd, eq.yEnd);

					pEnd = new Point2D.Double(firstP.getX(), firstP.getY());

				}

				gpx.append(new Line2D.Double(pIni, pEnd), true);

				segments.remove(0);

			}

			return gpx;

//	private static GeneralPathX offsetAndConsumeClosedSegments(double offset,

//			ArrayList<LineSegment> segments)

//	throws ParallelLinesCannotBeResolvedException,

//	NotEnoughSegmentsToClosePathException {

//		int segmentCount = segments.size();

//		if (segmentCount > 1) {

//			GeneralPathX openPath = offsetAndConsumeSegments(offset, segments);

//			openPath.closePath();

//			return openPath;

//		}

//		throw new NotEnoughSegmentsToClosePathException(segments);

//	}