| gvSIG desktop 1

/*

 * Created on 01-may-2004

 *

 * @author "Luis W. Sevilla" <sevilla_lui@gva.es>

 */

package org.cresques.geo;

import java.awt.FontMetrics;

import java.awt.Graphics2D;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import org.cresques.px.Extent;

/**

 * Proyeccion Mercator

 * @author "Luis W. Sevilla" <sevilla_lui@gva.es>* @author administrador

 */

public class Mercator  extends Projection {

        static String name = "Mercator";

        static String abrev = "Mer";

        private double a, f, b, Eps2, EE2, EE3, Epps2;

        public Mercator(Ellipsoid eli) {

                super(eli);

                grid = new Graticule(this);

                double [] p = eli.getParam();

                a      =p[1];

                f      =1/p[2];

                b      =p[3];

                Eps2   =p[5];

                EE2    =Eps2*Eps2;

                EE3    =EE2*Eps2;

                Epps2  =p[7];

        }

        public String getAbrev() { return abrev;}

        public static Mercator getProjection(Ellipsoid eli) {

                return new Mercator(eli);

        }

        /**

         * 

         */

        public static Projection getProjectionByName(Ellipsoid eli, String name) {

                if (name.indexOf("Me") < 0)

                        return null;

                return getProjection(eli);

        }

        /**

         * 

         */        

        public Point2D createPoint(double x, double y){

                return new ProjPoint(this, x, y);

        }

        /**

         * 

         * @param uPt

         * @return

         */        

        public GeoPoint toGeo(Point2D mPt) {

                GeoPoint gPt = new GeoPoint();

                return toGeo((ProjPoint) mPt, gPt);

        }

        /**

         * 

         * @param mPt

         * @param gPt

         * @return

         */

        public GeoPoint toGeo(ProjPoint mPt, GeoPoint gPt) {

                double t = Math.pow(Math.E,(-mPt.getY()/a));

                double x1, x=(Math.PI/2-2*Math.atan(t));

                do {

                        x1 =x;

                        x = Math.PI/2-2*Math.atan(t*(Math.pow((1-Math.sqrt(Eps2)*Math.sin(x))/

                                (1+Math.sqrt(Eps2)*Math.sin(x)),(Math.sqrt(Eps2)/2))));

                } while ((x-x1)>0.0000000001);

                double lat = Math.PI / 2-2 * Math.atan(t*(Math.pow((1-Math.sqrt(Eps2)*Math.sin(x))/

                        (1+Math.sqrt(Eps2)*Math.sin(x)),(Math.sqrt(Eps2)/2))));

                double lng = mPt.getX()/a;

                gPt.setLocation(lng*180.0/Math.PI, lat*180.0/Math.PI);

                gPt.proj = Geodetic.getProjection(mPt.proj.eli);

                return gPt;

        }

        /**

         * 

         * @param gPt

         * @param uPt

         * @return

         */        

        public Point2D fromGeo(GeoPoint gPt, ProjPoint mPt) {

                 double sl = Math.sin(gPt.Latitude.ToRadians());

                double cl = Math.cos(gPt.Latitude.ToRadians());

                double tl =(1+sl)/(1-sl);

                // Calcula Easting

                double x = a * gPt.Longitude.ToRadians();

                // Calcula Northing

                double y=Math.pow(((1-Math.sqrt(Eps2)*sl)/(1+Math.sqrt(Eps2)*sl)),(Math.sqrt(Eps2)));

                y= a/2 *(Math.log(tl*y));

                mPt.setLocation(x, y);

                mPt.proj = this;

                 return mPt;

        }

        // Calcula el step en funci?n del zoom

        private void generateGrid(Graphics2D g, Extent extent, AffineTransform mat) {

                // calculo del step en funci?n del zoom

                Point2D pt1 = extent.getMin();

                double step = 3.0, x = pt1.getX(), dist = 0.0;

                ProjPoint ppt1, ppt2;

                GeoPoint gp1, gp2;

                ppt1 = (ProjPoint) createPoint( x, pt1.getY());

                ppt2 = (ProjPoint) createPoint(x+100, pt1.getY()-100);

                gp1 = ppt1.toGeo();

                gp2 = ppt2.toGeo();

        /*        GeoPoint gp1, gp2;

                gp1 = (GeoPoint) createPoint( x, (int) pt1.getY());

                mat.transform(gp1, gp1);

                gp2 = (GeoPoint) createPoint(gp1.getX()+100, gp1.getY()-100);

                try {

                        mat.inverseTransform(gp2, gp2);

                } catch (NoninvertibleTransformException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                dist = (gp2.getX()-x);

                System.err.println("distX = " + dist);

                if (dist > 30.0) {                         step = 30.0;

                } else if (dist > 18.0) {         step = 18.0;

                } else if (dist > 12.0) {        step = 12.0;

                } else if (dist > 6.0) {        step = 6.0;

                } else if (dist > 3.0) {        step = 3.0;

                } else if (dist > 2.0) {        step = 2.0;

                } else if (dist > 1.0) {        step = 1.0;

                } else if (dist > .5) {                step =.5;

                } else if (dist > .25) {        step =.25;

                } else if (dist > 1.0/60*5.0) { step = 1.0/60*5.0;

                } else {                                        step = 1.0/60*2.0;

                }

                        //step = 1.0;

                */

                generateGrid(g, extent, mat, step);

        }

        private void generateGrid(Graphics2D g, Extent extent, AffineTransform mat, double step) {

                grid = new Graticule(this);

                Point2D pt1 = extent.getMin(), pt2 = extent.getMax();

                Point2D.Double ptx = new Point2D.Double(0.0, 0.0);

                GeoPoint gp1, gp2;

                ProjPoint up1 = (ProjPoint) createPoint(0,0),

                        up2 = (ProjPoint) createPoint(0,0);

                Geodetic geoProj = Geodetic.getProjection(this.getEllipsoid());

                double xAxis, yAxis;

                // Calculos para el texto

                FontMetrics fm = g.getFontMetrics();

                int fmWidth = 0, fmHeight = fm.getAscent();

                String tit = "";

                String fmt = "%G?%N";

                if (step < 1.0)

                        fmt = "%G?%M'%N";

                // Lineas Horzontales

                gp1 = toGeo(new ProjPoint(pt1));

                gp2 = toGeo(new ProjPoint(pt2));

                xAxis = gp1.getX(); yAxis = gp2.getY();

                System.err.println(name+": ViewPort Extent = ("+gp1+","+gp2+")");

                double xMin = (int) gp1.getX() - 1.0;

                xMin -= (xMin % step);

                double xMax = (int) gp2.getX() + 1.0;

                double yMin = (int) gp1.getY() - 1.0;

                yMin -= (yMin % step);

                double yMax = (int) gp2.getY() + 1.0;

                if (xMin < -180.0) xMin = -180.0;

                if (xMax > 180.0) xMax = 180.0;

                if (yMin < -80.0) yMin = -80.0;

                if (yMax > 80.0) yMax = 80.0;

                if (xAxis < -180.0) xAxis = -180.0;

                if (yAxis > 80.0) yAxis = 80.0;

                for (double y=yMin; y<=yMax; y+=step) {

                        gp1 = (GeoPoint) geoProj.createPoint(xAxis, y);

                        gp2 = (GeoPoint) geoProj.createPoint(xMax, y);

                        fromGeo(gp1, up1);

                        fromGeo(gp2, up2);

                        mat.transform(up1, up1);

                        mat.transform(up2, up2);

                        grid.addLine(up1, up2);

                        tit = coordToString(y, fmt, true);

                        //fmWidth = fm.stringWidth(tit);

                        ptx.setLocation(up1.getX()+3, up1.getY()-2);

                        grid.addText(tit, ptx);

                }

                // Lineas Verticales

                for (double x=xMin; x<=xMax; x+=step) {

                        gp1 = (GeoPoint) geoProj.createPoint(x, yMin);

                        gp2 = (GeoPoint) geoProj.createPoint(x, yAxis);

                        fromGeo(gp1, up1);

                        fromGeo(gp2, up2);

                        mat.transform(up1, up1);

                        mat.transform(up2, up2);

                        grid.addLine(up1, up2);

                        tit = coordToString(x, fmt, false);

                        //fmWidth = fm.stringWidth(tit);

                        ptx.setLocation(up2.getX()+3, up2.getY()+fmHeight);

                        grid.addText(tit, ptx);

                }

        }

        public void drawGrid(Graphics2D g, ViewPort vp) {

                generateGrid(g, vp.getExtent(), vp.getMat());

                grid.setColor(gridColor);

                grid.draw(g, vp);

        }

}