Application: gvSIG desktop

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.mapcontrol;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateList;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import org.cresques.cts.GeoCalc;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.mapcontext.MapContext;

public class AreaAndPerimeterCalculator {

    public double perimeter(org.gvsig.fmap.geom.Geometry geom, IProjection proj, int distanceUnits) {

        ArrayList parts = getXY(geom);

        double perimeter = 0;

        for (int j = 0; j < parts.size(); j++) {

            Double[][] xsys = (Double[][]) parts.get(j);

            double dist;

            double distAll = 0;

            for (int i = 0; i < (xsys[0].length - 1); i++) {

                Point2D p = new Point2D.Double(xsys[0][i], xsys[1][i]);

                Point2D p2 = new Point2D.Double(xsys[0][i + 1], xsys[1][i + 1]);

                dist = distanceWorld(p, p2,proj,distanceUnits);

                distAll += dist;

            }

            perimeter += distAll / MapContext.getDistanceTrans2Meter()[distanceUnits];

        }

        return perimeter;        

    }

    public double area(org.gvsig.fmap.geom.Geometry geom, IProjection proj, int areaUnits) {

        ArrayList parts = getXY(geom);

        double area = 0;

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

            Double[][] xsys = (Double[][]) parts.get(i);

            Double[] xs = xsys[0];

            Double[] ys = xsys[1];

            if( isCCW(xs, ys) ) {

                if( proj.isProjected() ) {

                    area -= returnCoordsArea(

                        xs,

                        ys,

                        new Point2D.Double(xs[xs.length - 1], ys[ys.length - 1]),

                        areaUnits

                    );

                } else {

                    area -= returnGeoCArea(xs, ys);

                }

            } else {

                if( proj.isProjected() ) {

                    area += returnCoordsArea(

                        xs,

                        ys,

                        new Point2D.Double(xs[xs.length - 1], ys[ys.length - 1]),

                        areaUnits

                    );

                } else {

                    area += returnGeoCArea(xs, ys);

                }

            }

        }

        return area;

    }

    public double distanceWorld(Point2D pt1, Point2D pt2, IProjection proj, int distanceUnits) {

      double dist;

      if (proj.isProjected()) {

        dist = pt1.distance(pt2);

        dist = dist * MapContext.getDistanceTrans2Meter()[distanceUnits];

      }

      else {

        GeoCalc geocalc = new GeoCalc(proj);

        dist = geocalc.distanceVincenty(pt1, pt2);

      }

      return dist;

    }

    public boolean isCCW(Double[] xs, Double[] ys) {

        CoordinateList coordList = new CoordinateList();

        for( int i = 0; i < ys.length; i++ ) {

            Coordinate coord = new Coordinate(xs[i], ys[i]);

            coordList.add(coord);

        }

        if( coordList.isEmpty() ) {

            return true;

        }

        return CGAlgorithms.isCCW(coordList.toCoordinateArray());

    }

    private double returnGeoCArea(Double[] xs, Double[] ys) {

        double[] lat = new double[xs.length];

        double[] lon = new double[xs.length];

        for( int K = 0; K < xs.length; K++ ) {

            lon[K] = xs[K] / org.gvsig.fmap.mapcontrol.tools.geo.Geo.Degree;

            lat[K] = ys[K] / org.gvsig.fmap.mapcontrol.tools.geo.Geo.Degree;

        }

        return (org.gvsig.fmap.mapcontrol.tools.geo.Geo.sphericalPolyArea(lat, lon, xs.length - 1) * org.gvsig.fmap.mapcontrol.tools.geo.Geo.SqM);

    }

    /**

     * Calcula el ?rea.

     *

     * @param xs

     * @param ys

     * @param point

     * @param areaUnits

     *

     * @return ?rea.

     */

    public double returnCoordsArea(Double[] xs, Double[] ys, Point2D point, int areaUnits) {

        Point2D aux = point;

        double elArea = 0.0;

        Point2D pPixel;

        Point2D p;// = new Point2D.Double();

        Point2D.Double pAnt = new Point2D.Double();

        for( int pos = 0; pos < xs.length - 1; pos++ ) {

            pPixel = new Point2D.Double(xs[pos], ys[pos]);

            p = pPixel;

            if( pos == 0 ) {

                pAnt.x = aux.getX();

                pAnt.y = aux.getY();

            }

            elArea = elArea + ((pAnt.x - p.getX()) * (pAnt.y + p.getY()));

            pAnt.setLocation(p);

        }

        elArea = elArea + ((pAnt.x - aux.getX()) * (pAnt.y + aux.getY()));

        elArea = Math.abs(elArea / 2.0);

        return (elArea / (Math.pow(MapContext.getAreaTrans2Meter()[areaUnits], 2)));

    }

    public ArrayList getXY(org.gvsig.fmap.geom.Geometry geometry) {

        ArrayList xs = new ArrayList();

        ArrayList ys = new ArrayList();

        ArrayList parts = new ArrayList();

        double[] theData = new double[6];

        //double[] aux = new double[6];

        PathIterator theIterator;

        int theType;

        int numParts = 0;

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        theIterator = geometry.getPathIterator(null, geomManager.getFlatness()); //, flatness);

        boolean isClosed = false;

        while( !theIterator.isDone() ) {

            theType = theIterator.currentSegment(theData);

            switch( theType ) {

            case PathIterator.SEG_MOVETO:

                if( numParts == 0 ) {

                    xs.add(theData[0]);

                    ys.add(theData[1]);

                } else {

                    if( !isClosed ) {

                        Double[] x = (Double[]) xs.toArray(new Double[0]);

                        Double[] y = (Double[]) ys.toArray(new Double[0]);

                        parts.add(new Double[][]{x,

                            y});

                        xs.clear();

                        ys.clear();

                    }

                    xs.add(theData[0]);

                    ys.add(theData[1]);

                }

                numParts++;

                isClosed = false;

                break;

            case PathIterator.SEG_LINETO:

                isClosed = false;

                xs.add(theData[0]);

                ys.add(theData[1]);

                break;

            case PathIterator.SEG_CLOSE:

                isClosed = true;

                xs.add(theData[0]);

                ys.add(theData[1]);

                Double[] x = (Double[]) xs.toArray(new Double[0]);

                Double[] y = (Double[]) ys.toArray(new Double[0]);

                parts.add(new Double[][]{x,

                    y});

                xs.clear();

                ys.clear();

                break;

            } //end switch

            theIterator.next();

        } //end while loop

        if( !isClosed ) {

//                isClosed=true;

            xs.add(theData[0]);

            ys.add(theData[1]);

            Double[] x = (Double[]) xs.toArray(new Double[0]);

            Double[] y = (Double[]) ys.toArray(new Double[0]);

            parts.add(new Double[][]{x,

                y});

            xs.clear();

            ys.clear();

        }

        return parts;

    }

}