ArcGIS Pro 3.8 API Reference Guide
ArcGIS.Core.Geometry Namespace / PolygonBuilderEx Class / FromJson Method
JSON string representation of Polygon.
Example

In This Topic
    FromJson Method (PolygonBuilderEx)
    In This Topic
    Creates a new instance of a Polygon class from a JSON string representation.
    Syntax
    public static Polygon FromJson( 
       string jsonString
    )
    Public Shared Function FromJson( _
       ByVal jsonString As String _
    ) As Polygon

    Parameters

    jsonString
    JSON string representation of Polygon.

    Return Value

    Exceptions
    ExceptionDescription
    The jsonString is empty or null.
    The JSON string is invalid or does not represent a polygon string.
    Example
    Construct GeometryBag - from an enumeration of geometries
    {
      // Use a builder convenience method or use a builder constructor.
    
      MapPoint point = MapPointBuilderEx.CreateMapPoint(10, 20);
      List<Coordinate2D> coords = new List<Coordinate2D>() { new Coordinate2D(50, 60), new Coordinate2D(-120, -70), new Coordinate2D(40, 60) };
      Multipoint multipointNew = MultipointBuilderEx.CreateMultipoint(coords, SpatialReferences.WebMercator);
      Polyline polylineNew = PolylineBuilderEx.CreatePolyline(coords);
    
      string json = "{\"rings\":[[[0,0],[0,1],[1,1],[1,0],[0,0]],[[3,0],[3,1],[4,1],[4,0],[3,0]]]}";
      Polygon polygonNew = PolygonBuilderEx.FromJson(json);
    
      var geometries = new List<Geometry>() { point, multipoint, polyline, polygon };
    
      // Builder convenience methods don't need to run on the MCT.
      var bag = GeometryBagBuilderEx.CreateGeometryBag(geometries, SpatialReferences.WGS84);
    
      var builder = new GeometryBagBuilderEx(geometries, SpatialReferences.WGS84);
      // do something with the builder
      bag = builder.ToGeometry();
    }
    Construct GeometryBag - adding or inserting an enumeration of geometries
    {
      MapPoint point = MapPointBuilderEx.CreateMapPoint(10, 20);
      List<Coordinate2D> coords = new List<Coordinate2D>() { new Coordinate2D(50, 60), new Coordinate2D(-120, -70), new Coordinate2D(40, 60) };
      Multipoint multipointNew = MultipointBuilderEx.CreateMultipoint(coords, SpatialReferences.WebMercator);
      Polyline polylineNew = PolylineBuilderEx.CreatePolyline(coords);
    
      string json = "{\"rings\":[[[0,0],[0,1],[1,1],[1,0],[0,0]],[[3,0],[3,1],[4,1],[4,0],[3,0]]]}";
      Polygon polygonNew = PolygonBuilderEx.FromJson(json);
    
      var geometries = new List<Geometry>() { point, multipoint, polyline, polygon };
    
      var builder = new GeometryBagBuilderEx(SpatialReferences.WGS84);
      builder.AddGeometries(geometries);
    
      GeometryBag geomBag = builder.ToGeometry();
      // geomBag.PartCount == 4    (point, multipoint, polyline, polygon)
    
      geometries = new List<Geometry>() { point, polyline };
      builder.InsertGeometries(1, geometries);
      // builder.GeometryCount == 6
      geomBag = builder.ToGeometry();
      // geomBag.PartCount == 6    (point, point, polyline, multipoint, polyline, polygon)
    }
    Construct Multipatch via Extrusion of Polygon or Polyline
    {
      // build a polygon
      string json = "{\"hasZ\":true,\"rings\":[[[0,0,0],[0,1,0],[1,1,0],[1,0,0],[0,0,0]]],\"spatialReference\":{\"wkid\":4326}}";
      Polygon polygonNew = PolygonBuilderEx.FromJson(json);
    
      // extrude the polygon by an offset to create a multipatch
      multipatch = GeometryEngine.Instance.ConstructMultipatchExtrude(polygon, 2);
    
      // a different polygon
      json = "{\"hasZ\":true,\"rings\":[[[0,0,1],[0,1,2],[1,1,3],[1,0,4],[0,0,1]]],\"spatialReference\":{\"wkid\":4326}}";
      polygon = PolygonBuilderEx.FromJson(json);
    
      // extrude between z values to create a multipatch
      multipatch = GeometryEngine.Instance.ConstructMultipatchExtrudeFromToZ(polygon, -10, 20);
    
      // extrude along the axis defined by the coordinate to create a multipatch
      Coordinate3D coord = new Coordinate3D(10, 18, -10);
      multipatch = GeometryEngine.Instance.ConstructMultipatchExtrudeAlongVector3D(polygon, coord);
    
      // build a polyline
      json = "{\"hasZ\":true,\"paths\":[[[400,800,1000],[800,1400,1500],[1200,800,2000],[1800,1800,2500],[2200,800,3000]]],\"spatialReference\":{\"wkid\":3857}}";
      Polyline polylineNew = PolylineBuilderEx.FromJson(json);
    
      // extrude to a specific z value to create a multipatch
      multipatch = GeometryEngine.Instance.ConstructMultipatchExtrudeToZ(polyline, 500);
    
      Coordinate3D fromCoord = new Coordinate3D(50, 50, -500);
      Coordinate3D toCoord = new Coordinate3D(200, 50, 1000);
    
      // extrude between two coordinates to create a multipatch
      multipatch = GeometryEngine.Instance.ConstructMultipatchExtrudeAlongLine(polyline, fromCoord, toCoord);
    }
    Import and Export Geometries to JSON
    {
      // MapPoint
      string inputString =
        "{\"x\":1,\"y\":2,\"spatialReference\":{\"wkid\":4326,\"latestWkid\":4326}}";
      Geometry geometryFromJson = GeometryEngine.Instance.ImportFromJson(
        JsonImportFlags.JsonImportDefaults, inputString);
    
      MapPoint importPoint = geometryFromJson as MapPoint;
      // importPoint = 1, 2
      // importPoint.SpatialReference.WKid = 4326
    
      // use the MapPointBuilderEx convenience method
      MapPoint importPoint2 = MapPointBuilderEx.FromJson(inputString);
      // importPoint2 = 1, 2
      // impointPoint2.SpatialReference.Wkid = 4326
    
      string outputString = GeometryEngine.Instance.ExportToJson(
        JsonExportFlags.JsonExportDefaults, importPoint);
      // outputString =
      //   "{\"x\":1,\"y\":2,\"spatialReference\":{\"wkid\":4326,\"latestWkid\":4326}}"
    
      string outputString2 = importPoint.ToJson();
    
      inputString =
        "{\"spatialReference\":{\"wkid\":4326},\"z\":3,\"m\":4,\"x\":1,\"y\":2}";
      importPoint = GeometryEngine.Instance.ImportFromJson(
        JsonImportFlags.JsonImportDefaults, inputString) as MapPoint;
      // importPoint.HasM = true
      // importPoint.HasZ = true
      // importPoint.X = 1
      // importPoint.Y = 2
      // importPoint.M = 4
      // importPoint.Z = 3
    
      importPoint2 = MapPointBuilderEx.FromJson(inputString);
    
      // export to json - skip spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                    JsonExportFlags.JsonExportSkipCRS, importPoint);
      // outputString = "{\"x\":1,\"y\":2,\"z\":3,\"m\":4}"
    
      // export from mappoint, skipping the sr - same as GeometryEngine.Instance.ExportToJson w JsonExportFlags.JsonExportSkipCRS
      outputString2 = importPoint.ToJson(true);
    
      //
      // Multipoint
      //
      List<Coordinate2D> coords = new List<Coordinate2D>()
    {
      new Coordinate2D(100, 200),
      new Coordinate2D(201, 300),
      new Coordinate2D(301, 400),
      new Coordinate2D(401, 500)
    };
    
      Multipoint multipointFromCoords = MultipointBuilderEx.CreateMultipoint(
        coords, SpatialReferences.WebMercator);
    
      inputString =
        "{\"points\":[[100,200],[201,300],[301,400],[401,500]],\"spatialReference\":{\"wkid\":3857}}";
      Multipoint importMultipoint =
        GeometryEngine.Instance.ImportFromJson(
               JsonImportFlags.JsonImportDefaults, inputString) as Multipoint;
      // importMultipoint.IsEqual(multipoint) = true
    
      ReadOnlyPointCollection pointsFromMultipoint = importMultipoint.Points;
      // points.Count = 4
      // points[0] = 100, 200
      // points[1] = 201, 300
      // points[2] = 301, 400
      // points[3] = 401, 500
    
      // use the MultipointbuilderEx convenience method
      Multipoint importMultipoint2 = MultipointBuilderEx.FromJson(inputString);
      // importMultipoint2.IsEqual(multipoint) = true
    
      // export to json
      outputString = GeometryEngine.Instance.ExportToJson(
                      JsonExportFlags.JsonExportDefaults, multipointFromCoords);
      // outputString = inputString
    
      // or use the multipoint itself
      outputString2 = multipointFromCoords.ToJson();
    
      //
      // Polyline
      //
      Polyline polylineFromCoords = PolylineBuilderEx.CreatePolyline(
                               coords, SpatialReferences.WebMercator);
    
      // export without the spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                              JsonExportFlags.JsonExportSkipCRS, polylineFromCoords);
      // import
      geometry = GeometryEngine.Instance.ImportFromJson(
                   JsonImportFlags.JsonImportDefaults, outputString);
      Polyline importPolyline = geometryFromJson as Polyline;
      // importPolyline.SpatialReference = null
    
    
      pointsFromMultipoint = importPolyline.Points;
      // points.Count = 4
      // points[0] = 100, 200
      // points[1] = 201, 300
      // points[2] = 301, 400
      // points[3] = 401, 500
    
      // use the polylineBuilderEx convenience method
      Polyline importPolyline2 = PolylineBuilderEx.FromJson(outputString);
      // importPolyline2 = importPolyline
    
      outputString2 = importPolyline2.ToJson();
      // outputString2 = outputString
    
      //
      // Polygon
      //
      Polygon polygonFromCoords = PolygonBuilderEx.CreatePolygon(
                                    coords, SpatialReferences.WebMercator);
    
      // export without the spatial reference
      outputString = GeometryEngine.Instance.ExportToJson(
                                JsonExportFlags.JsonExportSkipCRS, polygonFromCoords);
      // import
      geometryFromJson = GeometryEngine.Instance.ImportFromJson(
                           JsonImportFlags.JsonImportDefaults, outputString);
    
      Polygon importPolygon = geometry as Polygon;
      // importPolygon.SpatialReference = null
      pointsFromMultipoint = importPolygon.Points;
      // points.Count = 5
    
      // polygonBuilderEx convenience method
      Polygon importPolyon2 = PolygonBuilderEx.FromJson(outputString);
      // importPolygon2 = importPolygon
    
      // export from the polygon
      outputString2 = importPolyon2.ToJson(true);
    
      // Empty polygon
      polygon = PolygonBuilderEx.CreatePolygon(SpatialReferences.WebMercator);
      outputString = GeometryEngine.Instance.ExportToJson(
                                     JsonExportFlags.JsonExportDefaults, polygon);
      importPolygon = GeometryEngine.Instance.ImportFromJson(
                          JsonImportFlags.JsonImportDefaults, outputString) as Polygon;
    
      // importPolygon.IsEmpty = true
      // importPolygon.SpatialReference.Wkid = 3857
    }
    Determine area of a polygon
    {
      var g1 = PolygonBuilderEx.FromJson("{\"rings\": [ [ [0, 0], [10, 0], [10, 10], [0, 10] ] ] }");
      double d = GeometryEngine.Instance.Area(g1);
      // d = -100.0         //negative due to wrong ring orientation
      d = GeometryEngine.Instance.Area(GeometryEngine.Instance.SimplifyAsFeature(g1));
      // d = 100.0        // feature has been simplifed; ring orientation is correct
    }
    Get the minimum and maximum M values - GetMinMaxM
    {
      string json = "{\"hasM\":true,\"rings\":[[[-3000,-2000,10],[-2000,-2000,15],[-1000,-2000,20],[0,-2000,0],[1000,-2000,-20],[2000,-2000,-30],[3000,-2000,10],[4000,-2000,5]]],\"spatialReference\":{\"wkid\":3857}}";
      polygon = PolygonBuilderEx.FromJson(json);
    
      GeometryEngine.Instance.GetMinMaxM(polygon, out double minM, out double maxM);
      // minM = -30
      // maxM = 20
    
      json = "{\"hasM\":true,\"paths\":[[[-3000,-2000,10],[-2000,-2000,null],[-1000,-2000,null]]]}";
      polyline = PolylineBuilderEx.FromJson(json);
    
      GeometryEngine.Instance.GetMinMaxM(polyline, out minM, out maxM);
      // minM = 10
      // maxM = 10
    
      json = "{\"hasM\":true,\"paths\":[[[-3000,-2000,null],[-2000,-2000,null],[-1000,-2000,null]]]}";
      polyline = PolylineBuilderEx.FromJson(json);
    
      GeometryEngine.Instance.GetMinMaxM(polyline, out minM, out maxM);
      // minM = double.Nan
      // maxM = double.Nan
    }
    Set the M-values to the cumulative length of the start of the multipart - SetMsAtDistance
    {
      string json = "{\"hasM\":true,\"paths\":[[[-3000,-2000,1],[-2000,-2000,2],[-1000,-2000,3],[0,-2000,null],[1000,-2000,4],[2000,-2000,5],[3000,-2000,10],[4000,-2000,11],[5000,-2000,12],[6000,-2000,13],[7000,-2000,14]]],\"spatialReference\":{\"wkid\":3857}}";
      polyline = PolylineBuilderEx.FromJson(json);
    
      Polyline outPolyline = GeometryEngine.Instance.SetMsAsDistance(polyline, AsRatioOrLength.AsLength) as Polyline;
      // The xy-coordinates don't change.
      // The M-values of the vertices in outPolyline are (x, y, m):
      // { 0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000 }
    
      json = "{\"hasM\":true,\"rings\":[[[0,0],[0,3000],[4000,3000],[4000,0],[0,0]]],\"spatialReference\":{\"wkid\":3857}}";
      polygon = PolygonBuilderEx.FromJson(json);
    
      Polygon outPolygon = GeometryEngine.Instance.SetMsAsDistance(polygon, AsRatioOrLength.AsLength) as Polygon;
      // The M-values of the vertices in outPolygon are (x, y, m): { 0, 3000, 7000, 10000, 14000 };
    }
    Simplify a polygon
    {
      var g1 = PolygonBuilderEx.FromJson("{\"rings\": [ [ [0, 0], [10, 0], [10, 10], [0, 10] ] ] }");
      var result = GeometryEngine.Instance.Area(g1);      // result = -100.0   - negative due to wrong ring orientation
                                                          // simplify it
      var result2 = GeometryEngine.Instance.Area(GeometryEngine.Instance.SimplifyAsFeature(g1, true));
      // result2 = 100.0  - positive due to correct ring orientation (clockwise)
    }
    Requirements

    Target Platforms: Windows 11 Home, Pro, Enterprise (64 bit)

    ArcGIS Pro version: 3.0 or higher.
    See Also