// **********************************************************************
//
// <copyright>
//
// BBN Technologies
// 10 Moulton Street
// Cambridge, MA 02138
// (617) 873-8000
//
// Copyright (C) BBNT Solutions LLC. All rights reserved.
//
// </copyright>
// **********************************************************************
//
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/proj/LLXYView.java,v $
// $RCSfile: LLXYView.java,v $
// $Revision: 1.3.2.1 $
// $Date: 2004/10/14 18:27:36 $
// $Author: dietrick $
//
// **********************************************************************
package com.bbn.openmap.proj;
import java.awt.Point;
import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.util.Debug;
/**
* Implements the LLXY projection.
*/
public class LLXYView extends LLXY {
/**
* The LLXY name.
*/
public final static transient String LLXYViewName = "EPSG-4326";
/**
* The LLXY type of projection.
*/
public final static transient int LLXYViewType = 6303;
/** The "Helper" class manages user-space */
private LLXYViewHelper helper;
/** User-Space Center in lat/lon */
protected LatLonPoint uCtr;
protected float uCtrLat;
protected float uCtrLon;
/** Screen Origin in pixels (center=0,0) */
protected int sCtrX, sCtrY;
/** User Origin in pixels 0,0 = lat/lon center */
protected int uCtrX;
protected int uCtrY;
protected int dUSX;
/** delta between U and S, X axis */
protected int dUSY;
/** delta between U and S, Y axis */
/**
* Construct a LLXY projection.
*
* @param center LatLonPoint center of projection
* @param scale float scale of projection
* @param width width of screen
* @param height height of screen
*/
public LLXYView(LatLonPoint center, float scale, int width, int height) {
super(center, scale, width, height, LLXYViewType);
computeParameters();
}
/**
* Return stringified description of this projection.
*
* @return String
* @see Projection#getProjectionID
*/
public String toString() {
return "LLXYView[" + super.toString();
}
/**
* Called when some fundamental parameters change.
* <p>
* Each projection will decide how to respond to this change. For
* instance, they may need to recalculate "constant" paramters
* used in the forward() and inverse() calls.
* <p>
*/
protected void computeParameters() {
Debug.message("LLXYView", "LLXYView.computeParameters()");
super.computeParameters();
// compute the offsets
this.hy = height / 2;
this.wx = width / 2;
cLon = ProjMath.radToDeg(ctrLon);
// We have no way of constructing the User Space at anything
// other than 0,0 for now.
if (uCtr == null) {
uCtrLat = (float) 0.0;
uCtrLon = (float) 0.0;
uCtr = new LatLonPoint(uCtrLat, uCtrLon);
}
if (helper == null) {
helper = new LLXYViewHelper(uCtr, scale, width, height);
}
synchronized (helper) {
super.computeParameters();
// Screen stuff
Point temp = new Point();
helper.setAllParams(pixelsPerMeter,
planetRadius,
planetPixelRadius,
planetPixelCircumference,
minscale,
maxscale,
scale,
scaled_radius,
width,
height,
uCtrLat,
uCtrLon);
helper.forward(ctrLat, ctrLon, temp, true);
sCtrX = temp.x;
sCtrY = temp.y;
helper.forward(uCtrLat, uCtrLon, temp);
uCtrX = temp.x;
uCtrY = temp.y;
dUSX = sCtrX - uCtrX;
dUSY = sCtrY - uCtrY;
}
Debug.message("LLXYView", "User Center LL: " + uCtrLon + "," + uCtrLat
+ " User Center xy: " + uCtrX + "," + uCtrY
+ " Screen Center LL: " + ProjMath.radToDeg(ctrLon) + ","
+ ProjMath.radToDeg(ctrLat) + " Screen Center xy: " + sCtrX
+ "," + sCtrY + " Screen wh: " + width + "x" + height
+ " Screen halfwh: " + this.wx + "x" + this.hy + " Delta xy: "
+ dUSX + "," + dUSY);
}
/**
* Projects a point from Lat/Lon space to X/Y space.
*
* @param pt LatLonPoint
* @param p Point retval
* @return Point p
*/
public Point forward(LatLonPoint pt, Point p) {
// First translate to user-space
helper.forward(pt, p);
// Now translate to screen-space
p.x = p.x + this.wx - dUSX;
p.y = this.hy - p.y + dUSY;
if (Debug.debugging("LLXYViewf")) {
Debug.output("LLXYView.forward(pt.lon_:" + pt.getLongitude()
+ ", pt.lat_:" + pt.getLatitude() + ")\n"
+ "LLXYView.forward x:" + p.x + ", y:" + p.y);
}
return p;
}
/**
* Forward projects a lat,lon coordinates.
*
* @param lat raw latitude in decimal degrees
* @param lon raw longitude in decimal degrees
* @param p Resulting XY Point
* @return Point p
*/
public Point forward(float lat, float lon, Point p) {
// First translate to user-space
helper.forward(lat, lon, p);
// Now translate to screen-space
p.x = p.x + this.wx - dUSX;
p.y = this.hy - p.y + dUSY;
if (Debug.debugging("LLXYViewf")) {
Debug.output("LLXYView.forward(lon:" + lon + ", lat:" + lat + ")\n"
+ "LLXYView.forward x:" + p.x + ", y:" + p.y + " ctrLon:"
+ cLon + " wx:" + this.wx + " hy:" + this.hy);
}
return p;
}
/**
* Forward projects lat,lon into XY space and returns a Point.
*
* @param lat float latitude in radians
* @param lon float longitude in radians
* @param p Resulting XY Point
* @param isRadian bogus argument indicating that lat,lon
* arguments are in radians
* @return Point p
*/
public Point forward(float lat, float lon, Point p, boolean isRadian) {
// First translate to user-space
helper.forward(lat, lon, p, isRadian);
// Now translate to screen-space
p.x = p.x + this.wx - dUSX;
p.y = this.hy - p.y + dUSY;
if (Debug.debugging("LLXYViewf")) {
Debug.output("LLXYView.forward(lon:" + ProjMath.radToDeg(lon)
+ ", lat:" + ProjMath.radToDeg(lat) + " isRadian:"
+ isRadian + ")\n" + "LLXYView.forward x:" + p.x + ", y:"
+ p.y + " scale: " + (float) scale);
}
return p;
}
/**
* Inverse project a Point.
*
* @param pt x,y Point
* @param llp resulting LatLonPoint
* @return LatLonPoint llp
*/
public LatLonPoint inverse(Point pt, LatLonPoint llp) {
// convert from screen to user coordinates
int x = pt.x - this.wx + dUSX;
int y = this.hy - pt.y + dUSY;
// now convert to world coords
return (helper.inverse(x, y, llp));
}
/**
* Inverse project x,y coordinates into a LatLonPoint.
*
* @param x integer x coordinate
* @param y integer y coordinate
* @param llp LatLonPoint
* @return LatLonPoint llp
* @see Proj#inverse(Point)
*/
public LatLonPoint inverse(int x, int y, LatLonPoint llp) {
int tx = x - this.wx + dUSX;
int ty = this.hy - y + dUSY;
if (Debug.debugging("LLXYViewi")) {
// This is only to aid printing....
LatLonPoint tllp = helper.inverse(tx, ty, llp);
Debug.output("xy: " + x + "," + y + " txty: " + tx + "," + ty
+ " llp: " + tllp.getLongitude() + "," + tllp.getLatitude());
}
return (helper.inverse(tx, ty, llp));
}
/**
* Helper class manages "user space"
*/
private class LLXYViewHelper extends LLXY {
public LLXYViewHelper(LatLonPoint center, float scale, int width,
int height) {
super(center, scale, width, height, LLXYViewType);
}
public void setAllParams(int hPixelsPerMeter, float hPlanetRadius,
float hPlanetPixelRadius,
float hPlanetPixelCircumference,
float hMinscale, float hMaxscale,
float hScale, float hScaled_radius,
int hWidth, int hHeight, float hCtrLat,
float hCtrLon) {
this.pixelsPerMeter = hPixelsPerMeter;
this.planetRadius = hPlanetRadius;
this.planetPixelRadius = hPlanetPixelRadius;
this.planetPixelCircumference = hPlanetPixelCircumference;
this.minscale = hMinscale;
this.maxscale = hMaxscale;
this.scale = hScale;
this.scaled_radius = hScaled_radius;
this.width = hWidth;
this.height = hHeight;
this.ctrLat = hCtrLat;
this.ctrLon = hCtrLon;
this.computeParameters();
}
public String toString() {
return "LLXYViewHelper[" + super.toString();
}
/**
* Forward projects a LatLonPoint into USER space.
*/
public Point forward(LatLonPoint pt, Point p) {
super.forward(pt, p);
if (Debug.debugging("LLXYViewHelperf")) {
Debug.output("forward l,l,p: " + pt.getLongitude() + ","
+ pt.getLatitude() + " help xy: " + p.x + "," + p.y);
}
p.x = p.x - this.wx;
p.y = this.hy - p.y;
return p;
}
public Point forward(float lat, float lon, Point p) {
super.forward(lat, lon, p);
if (Debug.debugging("LLXYViewHelperf")) {
Debug.output("forward l,l,p: " + lon + "," + lat + " help xy: "
+ p.x + "," + p.y);
}
p.x = p.x - this.wx;
p.y = this.hy - p.y;
return p;
}
public Point forward(float lat, float lon, Point p, boolean isRadian) {
super.forward(lat, lon, p, isRadian);
if (Debug.debugging("LLXYViewHelperf")) {
Debug.output("forward l,l,p: " + ProjMath.radToDeg(lon) + ","
+ ProjMath.radToDeg(lat) + " help xy: " + p.x + ","
+ p.y);
}
p.x = p.x - this.wx;
p.y = this.hy - p.y;
return p;
}
public LatLonPoint inverse(Point pt, LatLonPoint llp) {
int x = pt.x + this.wx;
int y = this.hy - pt.y;
if (Debug.debugging("LLXYViewHelperi")) {
Debug.output("inverse helper x,y: " + x + "," + y);
}
// inverse project, using LLXY.inverse
return (super.inverse(x, y, llp));
}
public LatLonPoint inverse(int x, int y, LatLonPoint llp) {
x = x + this.wx;
y = this.hy - y;
if (Debug.debugging("LLXYViewHelperi")) {
Debug.output("inverse helper x,y: " + x + "," + y);
}
// inverse project using LLXY.inverse
return (super.inverse(x, y, llp));
}
}
}