package org.opentrafficsim.core.network.geotools;
   
   import java.io.Serializable;
   
   import org.geotools.geometry.DirectPosition2D;
   import org.geotools.referencing.CRS;
   import org.geotools.referencing.GeodeticCalculator;
   import org.opengis.geometry.DirectPosition;
   import org.opengis.geometry.coordinate.PointArray;
  import org.opengis.referencing.crs.CoordinateReferenceSystem;
  import org.opengis.referencing.operation.TransformException;
  import org.opentrafficsim.core.network.NetworkException;
  import org.opentrafficsim.core.unit.LengthUnit;
  import org.opentrafficsim.core.value.vdouble.scalar.DoubleScalar;
  
  import com.vividsolutions.jts.geom.Coordinate;
  import com.vividsolutions.jts.geom.CoordinateSequence;
  import com.vividsolutions.jts.geom.GeometryFactory;
  import com.vividsolutions.jts.geom.LineString;
  import com.vividsolutions.jts.geom.Point;
  import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;
  
  /**
   * This class implements a geotools-based geometry for a link in a network.
   * <p>
   * Copyright (c) 2013-2014 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
   * BSD-style license. See <a href="http://opentrafficsim.org/node/13">OpenTrafficSim License</a>.
   * <p>
   * @version Aug 21, 2014 <br>
   * @author <a href="http://www.tbm.tudelft.nl/averbraeck">Alexander Verbraeck</a>
   * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
   * @author <a href="http://www.citg.tudelft.nl">Guus Tamminga</a>
   */
  public class LinearGeometry implements Serializable
  {
      /** */
      private static final long serialVersionUID = 20141008L;
  
      /** link the geometry belongs to. */
      private final LinkGeotools<?, ?> link;
  
      /** geotools (or jts in this case) geometry that represents the link in 3D. */
      private final LineString line;
  
      /** Coordinate Reference System. */
      private final CoordinateReferenceSystem crs;
  
      /** length in meters. */
      private final DoubleScalar.Rel<LengthUnit> length;
  
      /**
       * @param link the link for which this geometry applies.
       * @param pointArray the geometry from geotools that represents the link in a CRS.
       * @throws NetworkException when transformation for distance calculation failed.
       */
      public LinearGeometry(final LinkGeotools<?, ?> link, final PointArray pointArray) throws NetworkException
      {
          super();
          this.link = link;
          this.crs = pointArray.getCoordinateReferenceSystem();
          double len = 0.0;
          GeodeticCalculator calc = new GeodeticCalculator(this.crs);
          Coordinate[] coords = new Coordinate[pointArray.size()];
          DirectPosition prevPos = null;
          for (int i = 0; i < pointArray.size(); i++)
          {
              DirectPosition p = pointArray.get(i).getDirectPosition();
              double x = p.getOrdinate(0);
              double y = p.getDimension() > 1 ? p.getOrdinate(1) : 0;
              double z = p.getDimension() > 2 ? p.getOrdinate(2) : 0;
              coords[i] = new Coordinate(x, y, z);
              if (i > 0)
              {
                  try
                  {
                      calc.setStartingPosition(prevPos);
                      calc.setDestinationPosition(p);
                      len += calc.getOrthodromicDistance();
                  }
                  catch (TransformException te)
                  {
                      throw new NetworkException("When constructing LinearGeometry for link=" + link.toString()
                          + ": transformation for distance calculation failed in CRS=" + this.crs.toWKT(), te);
                  }
              }
              prevPos = p;
          }
          CoordinateSequence points = new CoordinateArraySequence(coords);
          GeometryFactory factory = new GeometryFactory();
          this.line = new LineString(points, factory);
          this.length = new DoubleScalar.Rel<LengthUnit>(len, LengthUnit.METER);
          link.setGeometry(this);
      }
  
      /**
       * @param link the link for which this geometry applies.
       * @param lineString a JTS LineString representing the geometry.
       * @param crs the Coordinate Reference System for this line.
       * @throws NetworkException when transformation for distance calculation failed.
      */
     public LinearGeometry(final LinkGeotools<?, ?> link, final LineString lineString, final CoordinateReferenceSystem crs)
         throws NetworkException
     {
         super();
         this.link = link;
         this.crs = crs;
         double len = 0.0;
         DirectPosition prevPos = null;
         GeodeticCalculator calc = null;
         if (CRS.getEllipsoid(this.crs) != null)
         {
             calc = new GeodeticCalculator(this.crs);
         }
         for (int i = 0; i < lineString.getNumPoints(); i++)
         {
             Point point = lineString.getPointN(i);
             DirectPosition pos = new DirectPosition2D(this.crs, point.getX(), point.getY());
             if (i > 0)
             {
                 try
                 {
                     if (calc != null)
                     {
                         calc.setStartingPosition(prevPos);
                         calc.setDestinationPosition(pos);
                         len += calc.getOrthodromicDistance();
                     }
                     else
                     {
                         // TODO see if CRS is in meters...
                         double dx =
                             prevPos.getDirectPosition().getCoordinate()[0] - pos.getDirectPosition().getCoordinate()[0];
                         double dy =
                             prevPos.getDirectPosition().getCoordinate()[1] - pos.getDirectPosition().getCoordinate()[1];
                         len += Math.sqrt(dx * dx + dy * dy);
                     }
                 }
                 catch (TransformException te)
                 {
                     throw new NetworkException("When constructing LinearGeometry for link=" + link.toString()
                         + ": transformation for distance calculation failed in CRS=" + this.crs.toWKT(), te);
                 }
             }
             prevPos = pos;
         }
         this.line = lineString;
         this.length = new DoubleScalar.Rel<LengthUnit>(len, LengthUnit.METER);
         link.setGeometry(this);
     }
 
     // TODO possibly add a couple of other constructors for convenience.
 
     /**
      * @return link.
      */
     public final LinkGeotools<?, ?> getLink()
     {
         return this.link;
     }
 
     /**
      * @return line.
      */
     public final LineString getLineString()
     {
         return this.line;
     }
 
     /**
      * @return crs.
      */
     public final CoordinateReferenceSystem getCRS()
     {
         return this.crs;
     }
 
     /**
      * @return line length.
      */
     public final DoubleScalar.Rel<LengthUnit> getLineLength()
     {
         return this.length;
     }
 }