Source: api/GeometryConverter.js

/**
 * @class spw.api.GeometryConverter
 * @classdesc Classe utilitaire permettant de convertir des géométries dans divers formats et vice versa
 */
define([
    "dojo/_base/declare", "dojo/_base/array", "esri/geometry/Polygon",
    "esri/geometry/Point", "esri/geometry/Multipoint", "esri/geometry/Polyline",
    "esri/geometry/Extent",

    "spw/libs/togeojson",
    "spw/libs/terraformer-1.0.3.min"
],
    /** @lends spw.api.GeometryConverter.prototype */
    function (declare, array, Polygon, Point, Multipoint, Polyline, Extent, togeojson) {
        var GeometryConverter = declare("spw.api.GeometryConverter", null, {});

        GeometryConverter.esriToGeoJSON = function(esriGeometry) {
            return Terraformer.ArcGIS.parse(esriGeometry);
        };

        GeometryConverter.geoJSONToEsri = function(geoJSONGeometry, options) {
        	if((!options || !options.sr) && geoJSONGeometry.crs && geoJSONGeometry.crs.properties && geoJSONGeometry.crs.properties.name){
        		if(!options) options= {};
        		options.sr = (geoJSONGeometry.crs.properties.name.indexOf("EPSG:") > -1 ? 
        				parseInt(geoJSONGeometry.crs.properties.name.split("EPSG:")[1]) :
    					null);
        	}
            var json = Terraformer.ArcGIS.convert(geoJSONGeometry, options);
            if(!json) {
                console.error("Error occured : transform geoJSONGeometry to esriGeometry.");
                return null;
            }
            return _instanciateEsriGeometry(json);
        };

        GeometryConverter.esriToWkt = function(esriGeometry) {
            return Terraformer.WKT.convert(Terraformer.ArcGIS.parse(esriGeometry));
        };

        GeometryConverter.kmlToGeoJSON = function(doc) {
            return toGeoJSON.kml(doc);
        };

        GeometryConverter.gpxToGeoJSON = function(doc) {
            return toGeoJSON.gpx(doc);
        };

        GeometryConverter.wktToEsri = function(wktGeometry, options) {
            var json = Terraformer.ArcGIS.convert(Terraformer.WKT.parse(wktGeometry), options);
            if(!json) {
                console.error("Error occured : transform wktGeometry to esriGeometry.");
                return null;
            }
            return _instanciateEsriGeometry(json);
        };

        GeometryConverter.instanciateEsriGeometry = function(json) {
            return _instanciateEsriGeometry(json);
        };

        function _instanciateEsriGeometry(json){
            if(!json) {
                console.error("Error occured : _instanciateEsriGeometry.");
                return null;
            }

            if(json.rings)
                return new Polygon(json);
            if(json.x && json.y)
                return new Point(json);
            if(json.paths)
                return new Polyline(json);
            if(json.points)
                return new Multipoint(json);
            if(json.xmin && json.xmax && json.ymin && json.ymax)
                return new Extent(json);

            return null;
        };

        GeometryConverter.shapeGeometryToEsri = function(shapeGeometry) {
            if (shapeGeometry.type == 5/*ShpType.SHAPE_POLYGON*/ && shapeGeometry.rings){
                /*  shape: ShpPolygon
                    box: Object
                    rings: Array[1]
                        0: Array[7]
                            0: ShpPoint
                                type: 1
                                x: 5.48395564959111
                                y: 50.67435638866909 */
                var rings = [];
                array.forEach(shapeGeometry.rings, function(r){
                    var ring = [];
                    array.forEach(r, function(p){
                        ring.push([p.x, p.y]);
                    });
                    rings.push(ring);
                });
                return new Polygon(rings);
            } else if(shapeGeometry.type == 3/*ShpType.SHAPE_POLYLINE*/&& shapeGeometry.rings) {
            	var path = [];
            	array.forEach(shapeGeometry.rings[0], function(p){
                    path.push([p.x, p.y]);
                });
            	return new Polyline(path);
            } else if (shapeGeometry.type == 1/*ShpType.SHAPE_POINT*/) {
                return new Point(shapeGeometry.x, shapeGeometry.y);
            } else {
                console.error("GeometryConverter.shapeGeometryToEsri - type unsupported");
            }
        };

        return GeometryConverter;
    }
);