One of the standard methods of representing geometric shapes is by using the WKT (Well-Known-Text) standard. This is a human readable standard method of representing geometric shapes that can be used to easily pass spatial data between applications. I know GML or GeoRSS may be a little more applicable since they are based on XML, but WKT can work just fine in some cases.

If you don’t know what WKT is here are a couple links for reference:

http://en.wikipedia.org/wiki/Well-known_text

This is also one of the things that Virtual Earth does NOT have support built in for. So I wrote a little code that simply converts VEShape objects to a WKT string representation.

The code below allows you to represent Pushpins, Polygons and Polylines as strings like the following:

```POINT(-99.71000000000001 43.74999999999998)

POLYGON((-99.71000000000001 46.74999999999998,
-96.71000000000001 46.74999999999998,
-96.71000000000001 43.74999999999998,
-99.71000000000001 46.74999999999998))

LINESTRING(-99.71000000000001 40.74999999999998,
-102.71000000000001 40.74999999999998,
-102.71000000000001 43.74999999999998)```

Here are some examples of using the conversion methods:

```// Get Map Center Point
var centerPoint = map.GetCenter();

// Create Pushpin VEShape and Get it's WKT representation
var wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Pushpin, centerPoint));
// Create a VEShape from the WKT representation
var shape = VirtualEarthWKT.ShapeFromWKT(wktShape);

// Create Polygons' Location Array
var polygonLocations = [
new VELatLong(centerPoint.Latitude + 3, centerPoint.Longitude),
new VELatLong(centerPoint.Latitude + 3, centerPoint.Longitude + 3),
new VELatLong(centerPoint.Latitude, centerPoint.Longitude + 3)
];

// Create Polygon VEShape and Get it's WKT representation
wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Polygon, polygonLocations));
// Create a VEShape from the WKT representation
shape = VirtualEarthWKT.ShapeFromWKT(wktShape);

// Create Polylines' Location Array
var polylineLocations = [
new VELatLong(centerPoint.Latitude - 3, centerPoint.Longitude),
new VELatLong(centerPoint.Latitude - 3, centerPoint.Longitude - 3),
new VELatLong(centerPoint.Latitude, centerPoint.Longitude - 3)
];

// Create Polyline VEShape and Get it's WKT representation
wktShape = VirtualEarthWKT.ShapeToWKT(new VEShape(VEShapeType.Polyline, polylineLocations));
// Create a VEShape from the WKT representation
shape = VirtualEarthWKT.ShapeFromWKT(wktShape);

Here’s the full code to the VirtualEarthWKT object that contains the static methods:

```// Create the singleton object that contains the WKT (Well-Known-Text) transformation methods.
var VirtualEarthWKT = new (function() {
// Declare some "private" methods that will only be used internally
var priv = {
trimSpaces: function(str) {
// Trim beginning spaces
while (priv.startsWith(str, " ")) {
str = str.substring(1);
}
// Trim ending spaces
while (priv.endsWith(str, " ")) {
str = str.substring(0, str.length - 1);
}
return str;
},
startsWith: function(str, startstr) {
return str.substring(0, startstr.length) == startstr;
},
endsWith: function(str, endstr) {
return str.substring(str.length - endstr.length) == endstr;
}
};
// Declare the "public" methods that will be exposed
var that = {
///Converts a VEShape object to WKT (Well-Known-Text) string representation.
ShapeToWKT: function(shape) {
if (shape == null) {
throw "VirtualEarthWKT.ShapeToWKT: 'shape' parameter can not be null.";
}
var wktTemplate = "";
var wktGeomPoints = "";

// Figure out the WKT Geometry Type
switch (shape.GetType()) {
case VEShapeType.Pushpin:
wktTemplate = "POINT({points})";
break;
case VEShapeType.Polygon:
wktTemplate = "POLYGON(({points}))";
break;
case VEShapeType.Polyline:
wktTemplate = "LINESTRING({points})";
break;
default:
throw "VirtualEarthWKT.ShapeToWKT: VEShapeType (" + shape.GetType() + ") not supported.";
break;
}

// Get the List of VELatLong objects represented as WKT compatible list of points
var shapePoints = shape.GetPoints();
for (var i = 0; i < shapePoints.length; i++) {
if (wktGeomPoints.length > 0) {
wktGeomPoints += ", ";
}
wktGeomPoints += shapePoints[i].Longitude + " " + shapePoints[i].Latitude;
}

// return WKT representation of the VEShape
return wktTemplate.replace("{points}", wktGeomPoints);
},
///</span>
///Converts WKT (Well-Known-Text) string representation of a point/polygon/linestring to a VEShape object.
///</summary>
ShapeFromWKT: function(strWKT) {
if (strWKT == null) {
throw "VirtualEarthWKT.ShapeFromWKT: 'strWKT' parameter can not be null.";
}
if (strWKT.length == 0) {
throw "VirtualEarthWKT.ShapeFromWKT: 'strWKT' parameter can not be an empty string.";
}
var shapeType = null;
var wktPoints = null;

// Get the Shape Type and list of "Longitude Latitude" location points
switch (strWKT.substring(0, 5).toLowerCase()) {
case "point":
shapeType = VEShapeType.Pushpin;
wktPoints = strWKT.substring(6, strWKT.length - 1);
break;
case "polyg":
shapeType = VEShapeType.Polygon;
wktPoints = strWKT.substring(9, strWKT.length - 2);
break;
case "lines":
shapeType = VEShapeType.Polyline;
wktPoints = strWKT.substring(11, strWKT.length - 1);
break;
default:
throw "VirtualEarthWKT.ShapeFromWKT: Unknown WKT Geometry Type";
break;
}

// split out the wkt points to be seperate
wktPoints = wktPoints.split(",");

// Convert the WKT Points to VELatLong locations
var shapePoints = new Array();
for (var i = 0; i < wktPoints.length; i++) {
// Split the "Longitude Latitude" apart
var loc = priv.trimSpaces(wktPoints[i]).split(" ");
// Create VELatLong location
shapePoints[shapePoints.length] = new VELatLong(parseFloat(loc[1]), parseFloat(loc[0]));
}

// Return a VEShape that represents this WKT Geometry
return new VEShape(shapeType, shapePoints);
}
};
// Return the object that contains the "public" and "private" methods
return that;
})();</pre>
```