gov/nasa/worldwind/GeoRSSParser.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind;
   8
   9 import gov.nasa.worldwind.geom.*;
  10 import org.w3c.dom.*;
  11 import org.xml.sax.*;
  12
  13 import javax.xml.parsers.*;
  14 import javax.xml.namespace.*;
  15 import java.io.*;
  16 import java.util.*;
  17
  18 /**
  19  * @author tag
  20  * @version $Id: GeoRSSParser.java 1686 2007-05-02 21:58:49Z tgaskins $
  21  */
  22
  23 public class GeoRSSParser
  24 {
  25     public static final String GEORSS_URI = "http://www.georss.org/georss";
  26     public static final String GML_URI = "http://www.opengis.net/gml";
  27
  28     public static List<Renderable> parseFragment(String fragmentString, NamespaceContext nsc)
  29     {
  30         return parseShapes(fixNamespaceQualification(fragmentString));
  31     }
  32
  33     public static List<Renderable> parseShapes(String docString)
  34     {
  35         if (docString == null)
  36         {
  37             String message = WorldWind.retrieveErrMsg("nullValue.StringIsNull");
  38             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  39             throw new IllegalArgumentException(message);
  40         }
  41
  42         if (docString.length() < 1) // avoid empty strings
  43             return null;
  44
  45         try
  46         {
  47             DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
  48             docBuilderFactory.setNamespaceAware(true);
  49             DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
  50             Document doc = docBuilder.parse(new InputSource(new StringReader(docString)));
  51
  52             List<Renderable> shapes = parseShapes(doc);
  53
  54             if (shapes == null || shapes.size() < 1)
  55             {
  56                 String message = WorldWind.retrieveErrMsg("GeoRSS.NoShapes") + docString;
  57                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
  58                 return null;
  59             }
  60
  61             return shapes;
  62         }
  63         catch (ParserConfigurationException e)
  64         {
  65             String message = WorldWind.retrieveErrMsg("GeoRSS.ParserConfigurationException");
  66             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
  67             throw new WWRuntimeException(message, e);
  68         }
  69         catch (IOException e)
  70         {
  71             String message = WorldWind.retrieveErrMsg("GeoRSS.IOExceptionParsing") + docString;
  72             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
  73             throw new WWRuntimeException(message, e);
  74         }
  75         catch (SAXException e)
  76         {
  77             String message = WorldWind.retrieveErrMsg("GeoRSS.IOExceptionParsing") + docString;
  78             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
  79             throw new WWRuntimeException(message, e);
  80         }
  81     }
  82
  83     private static String fixNamespaceQualification(String xmlString)
  84     {
  85         String lcaseString = xmlString.toLowerCase();
  86         StringBuffer qualifiers = new StringBuffer();
  87
  88         if (lcaseString.contains("georss:") && !lcaseString.contains(GEORSS_URI))
  89         {
  90             qualifiers.append(" xmlns:georss=\"");
  91             qualifiers.append(GEORSS_URI);
  92             qualifiers.append("\"");
  93         }
  94
  95         if (lcaseString.contains("gml:") && !lcaseString.contains(GML_URI))
  96         {
  97             qualifiers.append(" xmlns:gml=\"");
  98             qualifiers.append(GML_URI);
  99             qualifiers.append("\"");
 100         }
 101
 102         if (qualifiers.length() > 0)
 103         {
 104             StringBuffer sb = new StringBuffer();
 105             sb.append("<wwdummyelement");
 106             sb.append(qualifiers);
 107             sb.append(">");
 108             sb.append(xmlString);
 109             sb.append("</wwdummyelement>");
 110
 111             return sb.toString();
 112         }
 113
 114         return xmlString;
 115     }
 116
 117     private static String surroundWithNameSpaces(String docString)
 118     {
 119         StringBuffer sb = new StringBuffer();
 120         sb.append("<wwdummyelement");
 121         sb.append(" xmlns:georss=\"");
 122         sb.append(GEORSS_URI);
 123         sb.append("\"");
 124         sb.append(" xmlns:gml=\"");
 125         sb.append(GML_URI);
 126         sb.append("\"");
 127         sb.append(">");
 128         sb.append(docString);
 129         sb.append("</wwdummyelement>");
 130 //        System.out.println(sb.toString());
 131
 132         return sb.toString();
 133     }
 134
 135     public static List<Renderable> parseShapes(File file)
 136     {
 137         if (file == null)
 138         {
 139             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 140             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 141             throw new IllegalArgumentException(message);
 142         }
 143
 144         try
 145         {
 146             DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
 147             docBuilderFactory.setNamespaceAware(false);
 148             DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
 149             Document doc = docBuilder.parse(file);
 150
 151             List<Renderable> shapes = parseShapes(doc);
 152
 153             if (shapes == null || shapes.size() < 1)
 154             {
 155                 String message = WorldWind.retrieveErrMsg("GeoRSS.NoShapes") + file.getPath();
 156                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
 157                 return null;
 158             }
 159
 160             return shapes;
 161         }
 162         catch (ParserConfigurationException e)
 163         {
 164             String message = WorldWind.retrieveErrMsg("GeoRSS.ParserConfigurationException");
 165             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
 166             throw new WWRuntimeException(message, e);
 167         }
 168         catch (IOException e)
 169         {
 170             String message = WorldWind.retrieveErrMsg("GeoRSS.IOExceptionParsing") + file.getPath();
 171             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
 172             throw new WWRuntimeException(message, e);
 173         }
 174         catch (SAXException e)
 175         {
 176             String message = WorldWind.retrieveErrMsg("GeoRSS.IOExceptionParsing") + file.getPath();
 177             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
 178             throw new WWRuntimeException(message, e);
 179         }
 180     }
 181
 182     public static List<Renderable> parseShapes(Document xmlDoc)
 183     {
 184         if (xmlDoc == null)
 185         {
 186             String message = WorldWind.retrieveErrMsg("nullValue.DocumentIsNull");
 187             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 188             throw new IllegalArgumentException(message);
 189         }
 190
 191         ArrayList<Node> shapeNodes = new ArrayList<Node>();
 192         ArrayList<Node> attributeNodes = new ArrayList<Node>();
 193
 194         // Shapes
 195         NodeList nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "where");
 196         if (nodes != null && nodes.getLength() > 0)
 197             addNodes(shapeNodes, nodes);
 198
 199         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "point");
 200         if (nodes != null && nodes.getLength() > 0)
 201             addNodes(shapeNodes, nodes);
 202
 203         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "line");
 204         if (nodes != null && nodes.getLength() > 0)
 205             addNodes(shapeNodes, nodes);
 206
 207         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "polygon");
 208         if (nodes != null && nodes.getLength() > 0)
 209             addNodes(shapeNodes, nodes);
 210
 211         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "box");
 212         if (nodes != null && nodes.getLength() > 0)
 213             addNodes(shapeNodes, nodes);
 214
 215         // Attributes
 216         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "radius");
 217         if (nodes != null && nodes.getLength() > 0)
 218             addNodes(attributeNodes, nodes);
 219
 220         nodes = xmlDoc.getElementsByTagNameNS(GEORSS_URI, "elev");
 221         if (nodes != null && nodes.getLength() > 0)
 222             addNodes(attributeNodes, nodes);
 223
 224         ArrayList<Renderable> shapes = new ArrayList<Renderable>();
 225
 226         if (shapeNodes.size() < 1)
 227             return null; // No warning here. Let the calling method inform of this case.
 228
 229         for (Node node : shapeNodes)
 230         {
 231             Renderable shape = null;
 232             String localName = node.getLocalName();
 233
 234             if (localName.equals("point"))
 235                 shape = makePointShape(node, attributeNodes);
 236
 237             else if (localName.equals("where"))
 238                 shape = makeWhereShape(node);
 239
 240             else if (localName.equals("line"))
 241                 shape = makeLineShape(node, attributeNodes);
 242
 243             else if (localName.equals("polygon"))
 244                 shape = makePolygonShape(node, attributeNodes);
 245
 246             else if (localName.equals("box"))
 247                 shape = makeBoxShape(node, attributeNodes);
 248
 249             if (shape != null)
 250                 shapes.add(shape);
 251         }
 252
 253         return shapes;
 254     }
 255
 256     private static void addNodes(ArrayList<Node> nodeList, NodeList nodes)
 257     {
 258         for (int i = 0; i < nodes.getLength(); i++)
 259         {
 260             nodeList.add(nodes.item(i));
 261         }
 262     }
 263
 264     private static Renderable makeWhereShape(Node node)
 265     {
 266         Node typeNode = findChildByLocalName(node, "Polygon");
 267         if (typeNode != null)
 268             return makeGMLPolygonShape(typeNode);
 269
 270         typeNode = findChildByLocalName(node, "Envelope");
 271         if (typeNode != null)
 272             return makeGMLEnvelopeShape(typeNode);
 273
 274         typeNode = findChildByLocalName(node, "LineString");
 275         if (typeNode != null)
 276             return makeGMLineStringShape(typeNode);
 277
 278         typeNode = findChildByLocalName(node, "Point");
 279         if (typeNode != null)
 280             return makeGMLPointShape(typeNode);
 281
 282         String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElementContent") + " where";
 283         WorldWind.logger().log(java.util.logging.Level.FINE, message);
 284         return null;
 285     }
 286
 287     private static Renderable makeGMLPolygonShape(Node node)
 288     {
 289         Node n = findChildByLocalName(node, "exterior");
 290         if (n == null)
 291         {
 292             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElement") + " exterior";
 293             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 294             return null;
 295         }
 296
 297         n = findChildByLocalName(n, "LinearRing");
 298         if (n == null)
 299         {
 300             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElement") + " LinearRing";
 301             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 302             return null;
 303         }
 304
 305         return makePolygonShape(n, null);
 306     }
 307
 308     private static Renderable makePolygonShape(Node node, Iterable<Node> attrs)
 309     {
 310         String valuesString = node.getTextContent();
 311         if (valuesString == null)
 312         {
 313             String message = WorldWind.retrieveErrMsg("GeoRSS.NoCoordinates" + node.getLocalName());
 314             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 315             return null;
 316         }
 317
 318         ArrayList<Double> values = getDoubleValues(valuesString);
 319         if (values.size() < 8 || values.size() % 2 != 0)
 320         {
 321             String message = WorldWind.retrieveErrMsg("GeoRSS.InvalidCoordinateCount" + node.getLocalName());
 322             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 323             return null;
 324         }
 325
 326         ArrayList<LatLon> positions = new ArrayList<LatLon>();
 327         for (int i = 0; i < values.size(); i += 2)
 328         {
 329             positions.add(LatLon.fromDegrees(values.get(i), values.get(i + 1)));
 330         }
 331
 332         double elevation = attrs != null ? getElevation(node, attrs) : 0d;
 333         if (elevation != 0)
 334         {
 335             Polyline pl = new Polyline(positions, elevation);
 336             pl.setFilled(true);
 337             pl.setFollowGreatCircles(true);
 338
 339             return pl;
 340         }
 341         else
 342         {
 343             return new SurfacePolygon(positions);
 344         }
 345     }
 346
 347     private static Renderable makeGMLEnvelopeShape(Node node)
 348     {
 349         Node n = findChildByLocalName(node, "lowerCorner");
 350         if (n == null)
 351         {
 352             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElement") + " lowerCorner";
 353             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 354             return null;
 355         }
 356
 357         String lowerCornerString = n.getTextContent();
 358         if (lowerCornerString == null)
 359         {
 360             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElementContent") + " lowerCorner";
 361             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 362             return null;
 363         }
 364
 365         n = findChildByLocalName(node, "upperCorner");
 366         if (n == null)
 367         {
 368             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElement") + " upperCorner";
 369             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 370             return null;
 371         }
 372
 373         String upperCornerString = n.getTextContent();
 374         if (upperCornerString == null)
 375         {
 376             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElementContent") + " upperCorner";
 377             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 378             return null;
 379         }
 380
 381         ArrayList<Double> lv = getDoubleValues(lowerCornerString);
 382         if (lv.size() != 2)
 383         {
 384             String message = WorldWind.retrieveErrMsg("GeoRSS.InvalidCoordinateCount" + " lowerCorner");
 385             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 386             return null;
 387         }
 388
 389         ArrayList<Double> uv = getDoubleValues(upperCornerString);
 390         if (uv.size() != 2)
 391         {
 392             String message = WorldWind.retrieveErrMsg("GeoRSS.InvalidCoordinateCount" + " upperCorner");
 393             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 394             return null;
 395         }
 396
 397         return new SurfaceQuadrilateral(Sector.fromDegrees(lv.get(0), uv.get(0), lv.get(1), uv.get(1)));
 398     }
 399
 400     private static Renderable makeBoxShape(Node node, Iterable<Node> attrs)
 401     {
 402         String valuesString = node.getTextContent();
 403         if (valuesString == null)
 404         {
 405             String message = WorldWind.retrieveErrMsg("GeoRSS.NoCoordinates" + node.getLocalName());
 406             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 407             return null;
 408         }
 409
 410         ArrayList<Double> p = getDoubleValues(valuesString);
 411         if (p.size() != 4)
 412         {
 413             String message = WorldWind.retrieveErrMsg("GeoRSS.InvalidCoordinateCount" + node.getLocalName());
 414             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 415             return null;
 416         }
 417
 418         double elevation = getElevation(node, attrs);
 419         if (elevation != 0)
 420             return new Quadrilateral(LatLon.fromDegrees(p.get(0), p.get(1)),
 421                 LatLon.fromDegrees(p.get(2), p.get(3)), elevation);
 422         else
 423             return new SurfaceQuadrilateral(Sector.fromDegrees(p.get(0), p.get(2), p.get(1), p.get(3)));
 424     }
 425
 426     private static Renderable makeGMLineStringShape(Node node)
 427     {
 428         Node n = findChildByLocalName(node, "posList");
 429         if (n == null)
 430         {
 431             String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElement") + " posList";
 432             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 433             return null;
 434         }
 435
 436         return makeLineShape(n, null);
 437     }
 438
 439     private static Renderable makeLineShape(Node node, Iterable<Node> attrs)
 440     {
 441         String valuesString = node.getTextContent();
 442         if (valuesString == null)
 443         {
 444             String message = WorldWind.retrieveErrMsg("GeoRSS.NoCoordinates" + node.getLocalName());
 445             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 446             return null;
 447         }
 448
 449         ArrayList<Double> values = getDoubleValues(valuesString);
 450         if (values.size() < 4)
 451         {
 452             String message = WorldWind.retrieveErrMsg("GeoRSS.InvalidCoordinateCount" + node.getLocalName());
 453             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 454             return null;
 455         }
 456
 457         ArrayList<LatLon> positions = new ArrayList<LatLon>();
 458         for (int i = 0; i < values.size(); i += 2)
 459         {
 460             positions.add(LatLon.fromDegrees(values.get(i), values.get(i + 1)));
 461         }
 462
 463         double elevation = attrs != null ? getElevation(node, attrs) : 0d;
 464         if (elevation != 0)
 465         {
 466             Polyline pl = new Polyline(positions, elevation);
 467             pl.setFollowGreatCircles(true);
 468             return pl;
 469         }
 470         else
 471         {
 472             return new SurfacePolyline(positions);
 473         }
 474     }
 475
 476     @SuppressWarnings({"UnusedDeclaration"})
 477     private static Renderable makeGMLPointShape(Node node)
 478     {
 479         return null; // No shape provided for points. Expect app to use icons.
 480     }
 481
 482     @SuppressWarnings({"UnusedDeclaration"})
 483     private static Renderable makePointShape(Node node, Iterable<Node> attrs)
 484     {
 485         return null; // No shape provided for points. Expect app to use icons.
 486     }
 487
 488     private static Node findChildByLocalName(Node parent, String localName)
 489     {
 490         NodeList children = parent.getChildNodes();
 491         if (children == null || children.getLength() < 1)
 492             return null;
 493
 494         for (int i = 0; i < children.getLength(); i++)
 495         {
 496             String ln = children.item(i).getLocalName();
 497             if (ln != null && ln.equals(localName))
 498                 return children.item(i);
 499         }
 500
 501         return null;
 502     }
 503
 504     private static Node findSiblingAttribute(String attrName, Iterable<Node> attribs, Node shapeNode)
 505     {
 506         for (Node attrib : attribs)
 507         {
 508             if (!attrib.getLocalName().equals(attrName))
 509                 continue;
 510
 511             if (attrib.getParentNode().equals(shapeNode.getParentNode()))
 512                 return attrib;
 513         }
 514
 515         return null;
 516     }
 517
 518     private static ArrayList<Double> getDoubleValues(String stringValues)
 519     {
 520         String[] tokens = stringValues.trim().split("[ ,\n]");
 521         if (tokens.length < 1)
 522             return null;
 523
 524         ArrayList<Double> arl = new ArrayList<Double>();
 525         for (String s : tokens)
 526         {
 527             if (s == null || s.length() < 1)
 528                 continue;
 529
 530             double d;
 531             try
 532             {
 533                 d = Double.parseDouble(s);
 534             }
 535             catch (NumberFormatException e)
 536             {
 537                 String message = WorldWind.retrieveErrMsg("GeoRSS.NumberFormatException" + s);
 538                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
 539                 continue;
 540             }
 541
 542             arl.add(d);
 543         }
 544
 545         return arl;
 546     }
 547
 548     private static double getElevation(Node shapeNode, Iterable<Node> attrs)
 549     {
 550         double elevation = 0d;
 551
 552         Node elevNode = findSiblingAttribute("elev", attrs, shapeNode);
 553         if (elevNode != null)
 554         {
 555             ArrayList<Double> ev = getDoubleValues(elevNode.getTextContent());
 556             if (ev != null && ev.size() > 0)
 557             {
 558                 elevation = ev.get(0);
 559             }
 560             else
 561             {
 562                 String message = WorldWind.retrieveErrMsg("GeoRSS.MissingElementContent") + " elev";
 563                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
 564             }
 565         }
 566
 567         return elevation;
 568     }
 569 }