private org.w3c.dom.Node node;

private Object geometry;

private BigDecimal lat;

private BigDecimal lon;

private Boolean hasGeometry = null; //Has 3 states: true, false, and null

private static String[] SupportedGeometryTypes = new String[]{

"Point", "Line", "Polygon", "LineString", "Box", "Envelope",

"MultiPoint", "MultiLine", "MultiPolygon", "MultiLineString"

};

/** GeoRSS NameSpace */

private String georss = "georss";

/** GML NameSpace */

private String gml = "gml";

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using an XML node. */

protected Location(org.w3c.dom.Node node, java.util.HashMap<String, String> namespaces) {

this.node = node;

String georss = namespaces.get("http://www.georss.org/georss");

if (georss!=null) this.georss = georss;

String gml = namespaces.get("http://www.opengis.net/gml");

if (gml==null) this.gml = gml;

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Creates a new instance of this class using a point. */

public Location(BigDecimal lat, BigDecimal lon){

this.lat = lat;

this.lon = lon;

}

protected Location(String lat, String lon){

this(new BigDecimal(lat), new BigDecimal(lon));

}

/*

//**************************************************************************

//** toWKT

//**************************************************************************

/** Used to return a Well-known Text (WKT) representation of the location.

public String toWKT(){

if (lat!=null && lon!=null){

return "POINT(" + lon + " " + lat + ")";

}

return (getGeometry()==null ? null : getGeometry().toString());

}

//**************************************************************************

//** toString

//**************************************************************************

/** Used to return a Well-known Text (WKT) representation of the location.

public String toString(){

return toWKT();

}

//**************************************************************************

//** getGeometry

//**************************************************************************

/** Used convert the location into a geometry object.

public Object getGeometry(){

if (hasGeometry==null){

if (lat!=null && lon!=null){

String nodeName = "Point";

String nodeValue =

"<gml:" + nodeName + ">" +

"<gml:coordinates cs=\" \" ts=\",\">" + lon + " " + lat +

"</gml:coordinates>" +

"</gml:" + nodeName + ">";

geometry = getGeometry(nodeName, nodeValue);

}

else{

String nodeName = node.getNodeName().toLowerCase();

String nodeValue = Parser.getNodeValue(node).trim();

if (nodeName.equals("where") || nodeName.equals(georss + ":where")){

NodeList nodes = node.getChildNodes();

for (int j=0; j<nodes.getLength(); j++){

node = nodes.item(j);

if (node.getNodeType()==1){

nodeName = node.getNodeName();

if (isGeometryNode(nodeName.toLowerCase(), gml, georss)){

geometry = getGeometry(nodeName, Parser.getNodeValue(node));

if (geometry!=null) break;

}

}

}

}

else if(isGeometryNode(nodeName, gml, georss)){

geometry = getGeometry(nodeName, nodeValue);

}

}

hasGeometry = (geometry==null);

}

return geometry;

}

//**************************************************************************

//** isLocationNode

//**************************************************************************

/** Protected method used to help determine whether a node represents a

protected static boolean isLocationNode(String nodeName, java.util.HashMap<String, String> namespaces){

String georss = namespaces.get("http://www.georss.org/georss");

if (georss==null) georss = "georss";

String gml = namespaces.get("http://www.opengis.net/gml");

if (gml==null) gml = "gml";

return (nodeName.equals("where") || nodeName.equals(georss + ":where") ||

isGeometryNode(nodeName, gml, georss));

}

//**************************************************************************

//** isGeometryNode

//**************************************************************************

/** Private method used to determine whether a node represents a geometry.

private static boolean isGeometryNode(String nodeName, String gml, String georss){

String namespace = null;

if (nodeName.contains(":")){

namespace = nodeName.substring(0, nodeName.lastIndexOf(":"));

nodeName = nodeName.substring(nodeName.lastIndexOf(":")+1);

}

if (namespace==null || namespace.equals(gml) || namespace.equals(georss)){

for (String geometryType : SupportedGeometryTypes){

if (nodeName.equalsIgnoreCase(geometryType)) return true;

}

}

return false;

}

//**************************************************************************

//** getGeometry

//**************************************************************************

/** Calls javaxt-gis or jts to try to parse location information.

private Object getGeometry(String nodeName, String nodeValue){

if (nodeValue!=null){

nodeValue = nodeValue.trim();

if (nodeValue.length()==0) nodeValue = null;

}

if (nodeValue==null) return null;

try{

//Try to parse the geometry using the javaxt-gis library

Class CoordinateParser = new ClassLoader("javaxt.geospatial.coordinate.Parser", "javaxt-gis.jar").load();

java.lang.reflect.Constructor constructor = CoordinateParser.getDeclaredConstructor(new Class[] {String.class});

java.lang.reflect.Method method = CoordinateParser.getDeclaredMethod("getGeometry");

Object instance = constructor.newInstance(new Object[] { nodeValue });

return method.invoke(instance);

}

catch(java.lang.ClassNotFoundException e){

//Try to parse the geometry using JTS

try{

//Hack for JTS Parser to deal with GeoRSS Simple Geometries

if (!nodeValue.startsWith("<")){

String Attributes = "";

if (nodeName.contains(":")){

nodeName = nodeName.substring(nodeName.indexOf(":")+1);

}

if (nodeName.equals("point")) nodeName = "Point";

else if(nodeName.equals("line")) nodeName = "LineString";

else if(nodeName.equals("polygon")) nodeName = "Polygon";

String p1 = (nodeName.equals("Polygon") ? "<gml:outerBoundaryIs><gml:LinearRing>" : "" );

String p2 = (nodeName.equals("Polygon") ? "</gml:LinearRing></gml:outerBoundaryIs>" : "" );

nodeValue =

"<gml:" + nodeName + Attributes + ">" + p1 +

"<gml:coordinates cs=\" \" ts=\",\">" + fixCoords(nodeValue) +

"</gml:coordinates>" + p2 +

"</gml:" + nodeName + ">";

}

//Hack for JTS Parser to deal with GML pos and posList tags

for (String pos : new String[]{"pos>", "posList>"}){

if (nodeValue.contains(pos)){

StringBuffer str = new StringBuffer();

String[] arr = nodeValue.split(pos);

for (int n=0; n<arr.length; n++){

str.append(arr[n]);

if (n<arr.length-1){

if ((n % 2 == 0)){

str.append("coordinates cs=\" \" ts=\",\">");

String coords = arr[n+1];

arr[n+1] = coords.substring(coords.indexOf("<"));

str.append(fixCoords(coords.substring(0, coords.indexOf("<"))));

}

else str.append("coordinates>");

}

}

nodeValue = str.toString().trim();

}

}

if (nodeValue.startsWith("<")){ //GML

Class GMLReader = new ClassLoader("com.vividsolutions.jts.io.gml2.GMLReader", "jts").load();

for (java.lang.reflect.Method method : GMLReader.getDeclaredMethods()){

if (method.getName().equals("read")){

Class[] parameters = method.getParameterTypes();

if (parameters.length==2){

if (parameters[0].getCanonicalName().equals("java.lang.String") &&

parameters[1].getCanonicalName().equals("com.vividsolutions.jts.geom.GeometryFactory") ){

Object instance = GMLReader.newInstance();

return method.invoke(instance, new Object[] { nodeValue, parameters[1].newInstance() });

}

}

}

}

}

}

catch(java.lang.reflect.InvocationTargetException ex){

Throwable cause = ex.getCause();

if (cause != null){

String msg = cause.getLocalizedMessage();

if (msg!=null) System.err.println(cause.getLocalizedMessage());

}

}

catch(Exception ex){

//ex.printStackTrace();

}

}

catch(java.lang.InstantiationException e){}

catch(java.lang.NoSuchMethodException e){}

catch(java.lang.IllegalAccessException e){}

catch(java.lang.reflect.InvocationTargetException e){}

return null;

}

//**************************************************************************

//** fixCoords

//**************************************************************************

/** Used to add commas between coordinate tuples. */

private static String fixCoords(String coords){

coords = coords.trim();

StringBuffer str = new StringBuffer();

String[] arr = coords.split(" ");

for (int n=0; n<arr.length; n++){

str.append(arr[n]);

if (n<arr.length-1){

if ((n % 2 == 0)) str.append(" ");

else str.append(", ");

}

}

return str.toString().trim();

}

private String className;

private String jarFile;

public ClassLoader(String className){

this.className = className;

}

//**************************************************************************

//** Constructor

//**************************************************************************

/** Used to dynamically Load a jar file along with the the given a class.

public ClassLoader(String className, String jarFile){

this.className = className;

this.jarFile = jarFile;

}

public Class load() throws java.lang.ClassNotFoundException {

try{

return Class.forName(className);

}

catch(java.lang.ClassNotFoundException e){

if (jarFile!=null){

try{

java.io.File jar = findJar(jarFile);

java.net.URLClassLoader child = new java.net.URLClassLoader(

new java.net.URL[]{jar.toURL()}, this.getClass().getClassLoader());

return Class.forName(className, true, child);

}

catch(Exception ex){}

}

throw e;

}

}

private java.io.File findJar(String prefix){

java.lang.Class Class = this.getClass();

java.lang.Package Package = Class.getPackage();

java.io.File file = null;

//Find physical path of this jar file

String path = Package.getName().replace((CharSequence)".",(CharSequence)"/");

String url = Class.getClassLoader().getResource(path).toString();

url = url.replace((CharSequence)" ",(CharSequence)"%20");

try{

java.net.URI uri = new java.net.URI(url);

if (uri.getPath()==null){

path = uri.toString();

if (path.startsWith("jar:file:")){

//Update Path and Define Zipped File

path = path.substring(path.indexOf("file:/"));

path = path.substring(0,path.toLowerCase().indexOf(".jar")+4);

if (path.startsWith("file://")){ //UNC Path

path = "C:/" + path.substring(path.indexOf("file:/")+7);

path = "/" + new java.net.URI(path).getPath();

}

else{

path = new java.net.URI(path).getPath();

}

file = new java.io.File(path);

}

}

else{

file = new java.io.File(uri);

}

}

catch(Exception e){

e.printStackTrace();

}

for (String fileName : file.getParentFile().list()){

if (fileName.toLowerCase().startsWith(prefix.toLowerCase()) &&

fileName.toLowerCase().endsWith(".jar"))

{

return new java.io.File(file.getParentFile(), fileName);

}

}

return null;

}

}