WKTDatatype class allows the URI "geo:wktLiteral" to be used as a datatype and it will parse that datatype to a JTS Geometry. More...

Inheritance diagram for EncodedPolylineDatatype:

[legend]

Collaboration diagram for EncodedPolylineDatatype:

[legend]

Public Member Functions
String	unparse (Geometry geometry)
	This method Un-parses the JTS Geometry to the WKT literal. More...

Geometry	read (String geometryLiteral)

String	toString ()

Static Public Member Functions
static String	encodePolyline (final LineString linestring)
	Encodes a sequence of LatLngs into an encoded path string. More...

static List< Coordinate >	decodePolyline (String polyline, int precision)

Static Public Attributes
static final String	URI = POSTGIS.EncodedPolyline
	The default WKT type URI. More...

static final EncodedPolylineDatatype	INSTANCE = new EncodedPolylineDatatype()
	A static instance of WKTDatatype. More...

Static Private Member Functions
static void	encode (long v, StringBuffer result)

Detailed Description

WKTDatatype class allows the URI "geo:wktLiteral" to be used as a datatype and it will parse that datatype to a JTS Geometry.

Req 10 All RDFS Literals of type geo:wktLiteral shall consist of an optional URI identifying the coordinate reference system followed by Simple Features Well Known Text (WKT) describing a geometric value. Valid geo:wktLiterals are formed by concatenating a valid, absolute URI as defined in [RFC 2396], one or more spaces (Unicode U+0020 character) as a separator, and a WKT string as defined in Simple Features [ISO 19125-1].

Req 11 The URI

<http://www.opengis.net/def/crs/OGC/1.3/CRS84>

shall be assumed as the spatial reference system for geo:wktLiterals that do not * specify an explicit spatial reference system URI.

Member Function Documentation

◆ decodePolyline()

static List<Coordinate> decodePolyline	(	String	polyline,
		int	precision
	)

static

      {
          List<Coordinate> coordinates = new ArrayList<Coordinate>();
          int index = 0, shift, result;
          int byte_;
          int lat = 0, lng = 0, latitude_change, longitude_change,
              factor = (int) Math.pow(10, precision);
  
          while (index < polyline.length()) {
              byte_ = 0;
              shift = 0;
              result = 0;
  
              do {
                  byte_ = polyline.charAt(index++) - 63;
                  result |= (byte_ & 0x1f) << shift;
                  shift += 5;
              } while (byte_ >= 0x20);
  
              latitude_change = ((result % 2 == 1) ? ~(result >> 1) : (result >> 1));
  
              shift = result = 0;
  
              do {
                  byte_ = polyline.charAt(index++) - 63;
                  result |= (byte_ & 0x1f) << shift;
                  shift += 5;
              } while (byte_ >= 0x20);
  
              longitude_change = ((result % 2 == 1) ? ~(result >> 1) : (result >> 1));
  
              lat += latitude_change;
              lng += longitude_change;
  
              coordinates.add(new Coordinate((double)lat / factor,(double)lng / factor));
          }
  
          return coordinates;
      }

Referenced by EncodedPolylineDatatype.read().

◆ encode()

static void encode	(	long	v,
		StringBuffer	result
	)

staticprivate

                                                             {
         v = v < 0 ? ~(v << 1) : v << 1;
         while (v >= 0x20) {
             result.append(Character.toChars((int) ((0x20 | (v & 0x1f)) + 63)));
             v >>= 5;
         }
         result.append(Character.toChars((int) (v + 63)));
     }

Referenced by EncodedPolylineDatatype.encodePolyline().

◆ encodePolyline()

static String encodePolyline ( final LineString linestring )

static

Encodes a sequence of LatLngs into an encoded path string.

Modified from https://gitlab.com/aceperry/androidmapsutil Apache License 2.0

                                                                      {
         long lastLat = 0;
         long lastLng = 0;
  
         final StringBuffer result = new StringBuffer();
  
         for (final Coordinate point : linestring.getCoordinates()) {
             long lat = Math.round(point.x * 1e5);
             long lng = Math.round(point.y * 1e5);
  
             long dLat = lat - lastLat;
             long dLng = lng - lastLng;
  
             encode(dLat, result);
             encode(dLng, result);
  
             lastLat = lat;
             lastLng = lng;
         }
         return result.toString();
     }

References EncodedPolylineDatatype.encode().

Referenced by EncodedPolylineDatatype.unparse().

◆ read()

Geometry read ( String geometryLiteral )

Reimplemented from VectorLiteral.

                                                  {
         GeometryFactory fac=new GeometryFactory();
         return fac.createLineString(decodePolyline(geometryLiteral, 5).toArray(new Coordinate[0]));
     }

References EncodedPolylineDatatype.decodePolyline().

◆ toString()

String toString ( )

                              {
         return "EncodedPolylineDatatype{" + URI + '}';
     }

References EncodedPolylineDatatype.URI.

◆ unparse()

String unparse ( Geometry geometry )

This method Un-parses the JTS Geometry to the WKT literal.

Parameters

geometry - the JTS Geometry to be un-parsed

Returns: WKT - the returned WKT Literal.
Notice that the Spatial Reference System is not specified in returned WKT literal.

Reimplemented from VectorLiteral.

                                              {
             if(geometry.getGeometryType().equals("LineString")){
                 return encodePolyline((LineString)geometry);                    
             }else {
                 throw new AssertionError("Object passed to EncodedPolylineDatatype is not a LineString: " + geometry);
             }
     }