private static SqlGeometry CreateDefault(EsriShapeType esriType, int srid)
{
switch (esriType)
{
case EsriShapeType.EsriPoint:
case EsriShapeType.EsriPointM:
case EsriShapeType.EsriPointZ:
return(SqlSpatialHelper.CreateEmptyPoint(srid));
case EsriShapeType.EsriMultiPoint:
case EsriShapeType.EsriMultiPointM:
case EsriShapeType.EsriMultiPointZ:
return(SqlSpatialHelper.CreateEmptyMultipoint(srid));
case EsriShapeType.EsriPolyLine:
case EsriShapeType.EsriPolyLineM:
case EsriShapeType.EsriPolyLineZ:
return(SqlSpatialHelper.CreateEmptyLineString(srid));
case EsriShapeType.EsriPolygon:
case EsriShapeType.EsriPolygonM:
case EsriShapeType.EsriPolygonZ:
return(SqlSpatialHelper.CreateEmptyPolygon(srid));
case EsriShapeType.NullShape:
case EsriShapeType.EsriMultiPatch:
default:
return(SqlGeometry.Null);
}
}
private static bool AreConsistent(EsriShapeType esriType, OpenGisGeometryType ogcType)
{
switch (ogcType)
{
case OpenGisGeometryType.Point:
return(esriType == EsriShapeType.EsriPoint || esriType == EsriShapeType.EsriPointM || esriType == EsriShapeType.EsriPointZ);
case OpenGisGeometryType.MultiLineString:
case OpenGisGeometryType.LineString:
return(esriType == EsriShapeType.EsriPolyLine || esriType == EsriShapeType.EsriPolyLineM || esriType == EsriShapeType.EsriPolyLineZ);
case OpenGisGeometryType.Polygon:
case OpenGisGeometryType.MultiPolygon:
return(esriType == EsriShapeType.EsriPolygon || esriType == EsriShapeType.EsriPolygonM || esriType == EsriShapeType.EsriPolygonZ);
case OpenGisGeometryType.MultiPoint:
return(esriType == EsriShapeType.EsriMultiPoint || esriType == EsriShapeType.EsriMultiPointM || esriType == EsriShapeType.EsriMultiPointZ);
case OpenGisGeometryType.GeometryCollection:
case OpenGisGeometryType.CircularString:
case OpenGisGeometryType.CompoundCurve:
case OpenGisGeometryType.CurvePolygon:
default:
return(false);
}
}
public static void Write(string fileName, IEsriShapeCollection shapes, EsriShapeType shapeType, bool overwrite = false)
{
System.IO.MemoryStream shxWriter = new System.IO.MemoryStream();
int offset = 50;
foreach (IEsriShape item in shapes)
{
shxWriter.Write(WriteHeaderToByte(offset, item.ContentLength), 0, 2 * ShapeConstants.IntegerSize);
offset += item.ContentLength + 4;
}
System.IO.MemoryStream writer = new System.IO.MemoryStream();
int fileLength = (int)shxWriter.Length / 2 + 50;
writer.Write(WriteMainHeader(shapes, fileLength, shapeType), 0, 100);
writer.Write(shxWriter.ToArray(), 0, (int)shxWriter.Length);
//var mode = overwrite ? System.IO.FileMode.Create : System.IO.FileMode.CreateNew;
var mode = Shapefile.GetMode(fileName, overwrite);
System.IO.FileStream stream = new System.IO.FileStream(fileName, mode);
writer.WriteTo(stream);
shxWriter.Close();
writer.Close();
stream.Close();
}
/// <summary>
/// Translates the geometry type from the Esri Shape format to the geometry type
/// used by ArcObjects/ProSuite.
/// </summary>
/// <param name="shapeType"></param>
/// <returns></returns>
public static ProSuiteGeometryType TranslateEsriShapeType(EsriShapeType shapeType)
{
ProSuiteGeometryType geometryType;
switch (shapeType)
{
case EsriShapeType.EsriShapeGeneralPoint:
case EsriShapeType.EsriShapePoint:
case EsriShapeType.EsriShapePointZ:
case EsriShapeType.EsriShapePointM:
case EsriShapeType.EsriShapePointZM:
geometryType = ProSuiteGeometryType.Point;
break;
case EsriShapeType.EsriShapeGeneralMultipoint:
case EsriShapeType.EsriShapeMultipoint:
case EsriShapeType.EsriShapeMultipointZ:
case EsriShapeType.EsriShapeMultipointM:
case EsriShapeType.EsriShapeMultipointZM:
geometryType = ProSuiteGeometryType.Multipoint;
break;
case EsriShapeType.EsriShapeGeneralPolyline:
case EsriShapeType.EsriShapePolyline:
case EsriShapeType.EsriShapePolylineZ:
case EsriShapeType.EsriShapePolylineM:
case EsriShapeType.EsriShapePolylineZM:
geometryType = ProSuiteGeometryType.Polyline;
break;
case EsriShapeType.EsriShapeGeneralPolygon:
case EsriShapeType.EsriShapePolygon:
case EsriShapeType.EsriShapePolygonZ:
case EsriShapeType.EsriShapePolygonM:
case EsriShapeType.EsriShapePolygonZM:
geometryType = ProSuiteGeometryType.Polygon;
break;
case EsriShapeType.EsriShapeGeneralMultiPatch:
case EsriShapeType.EsriShapeMultiPatch:
case EsriShapeType.EsriShapeMultiPatchM:
geometryType = ProSuiteGeometryType.MultiPatch;
break;
case EsriShapeType.EsriShapeNull:
geometryType = ProSuiteGeometryType.Null;
break;
default:
throw new ArgumentOutOfRangeException(
$"Unsupported geometry type: {shapeType}");
}
return(geometryType);
}
internal override void UpdateUI()
{
base.UpdateUI();
if (this.ShapeModels == null)
{
return;
}
if (this.colorizerCache != null && !this.areModelsProcessed)
{
this.colorizerCache.Initialize(this.ShapeModels);
}
EsriShapeType shapeType = this.ShapeModels.Type;
switch (shapeType)
{
case EsriShapeType.NullShape:
break;
case EsriShapeType.Point:
case EsriShapeType.PointM:
case EsriShapeType.PointZ:
case EsriShapeType.Multipoint:
case EsriShapeType.MultipointM:
case EsriShapeType.MultipointZ:
this.RenderFilledShape();
break;
case EsriShapeType.Polyline:
case EsriShapeType.PolylineM:
case EsriShapeType.PolylineZ:
this.RenderPolylines(false);
break;
case EsriShapeType.Polygon:
case EsriShapeType.PolygonM:
case EsriShapeType.PolygonZ:
this.RenderPolylines(true);
break;
default:
throw new NotSupportedException();
}
this.areModelsProcessed = true;
}
/// <summary>
/// Removes Extera Geometries with inconsistent types (based on esriType argument)
/// </summary>
/// <param name="esriType"></param>
/// <param name="geometry"></param>
/// <returns></returns>
private static SqlGeometry ClearGeometry(EsriShapeType esriType, SqlGeometry geometry, int srid)
{
var collection = new List <SqlGeometry>();
for (int i = 0; i < geometry.STNumGeometries(); i++)
{
var temp = geometry.STGeometryN(i + 1);
if (!temp.IsNotValidOrEmpty() && AreConsistent(esriType, temp.GetOpenGisType()))
{
collection.Add(temp);
}
}
var result = CreateDefault(esriType, srid);
for (int i = 0; i < collection.Count; i++)
{
result = result.STUnion(collection[i]);
}
return(result);
}
internal MainFileHeader(int fileLength, EsriShapeType type, IRI.Msh.Common.Primitives.BoundingBox minimumnBoundingBox)
{
this.m_Version = 9994;
this.m_FileLength = fileLength;
this.m_ShapeType = (int)type;
this.m_XMin = minimumnBoundingBox.XMin;
this.m_YMin = minimumnBoundingBox.YMin;
this.m_XMax = minimumnBoundingBox.XMax;
this.m_YMax = minimumnBoundingBox.YMax;
this.m_ZMax = 0;
this.m_ZMin = 0;
this.m_MMax = 0;
this.m_MMin = 0;
}
public zReader(string fileName, EsriShapeType type, int srid)
: base(fileName, type, srid)
{
}
private static Task <MapShapeModelCollection> ParseShapes(object state)
{
ParseShapeTaskState taskState = (ParseShapeTaskState)state;
var cancellationTokenSource = taskState.CancellationTokenSource;
var token = cancellationTokenSource.Token;
var task = Task.Factory.StartNew(async() =>
{
using (var shapeStream = taskState.Stream.CloneStream())
{
int start = taskState.Start;
int end = taskState.End;
var coordinateConverter = taskState.CoordinateConverter;
var records = taskState.Records;
MapShapeModelCollection shapeModels = new MapShapeModelCollection();
for (int i = start; i < end; i++)
{
if (cancellationTokenSource.IsCancellationRequested)
{
return(null);
}
int contentOffset = records[i].ContentOffset;
shapeStream.Seek((ulong)contentOffset);
int contentLength = records[i].ContentLength;
byte[] content = new byte[contentLength];
await shapeStream.ReadAsync(content.AsBuffer(), (uint)contentLength, InputStreamOptions.Partial);
EsriShapeType shapeType = (EsriShapeType)BitConverter.ToInt32(content, 0);
if (shapeModels.Type == EsriShapeType.NullShape)
{
shapeModels.Type = shapeType;
}
// TODO: Consider specific support for "M" types (PointM, MultipointM, PolygonM) that support measure coordinate -- is this the Bubble visualization?.
switch (shapeType)
{
case EsriShapeType.NullShape:
shapeModels.Add(new NullShapeModel());
break;
case EsriShapeType.Point:
case EsriShapeType.PointM:
case EsriShapeType.PointZ:
CreatePoint(content, shapeModels, 4, coordinateConverter);
break;
case EsriShapeType.Polyline:
case EsriShapeType.PolylineM:
case EsriShapeType.PolylineZ:
CreatePolyline(content, shapeModels, coordinateConverter);
break;
case EsriShapeType.Polygon:
case EsriShapeType.PolygonM:
case EsriShapeType.PolygonZ:
CreatePolygon(content, shapeModels, coordinateConverter);
break;
default:
throw new NotSupportedException("The supported ESRI shape types are Point(MZ), Polyline(MZ), and Polygon(MZ).");
}
}
return(shapeModels);
}
},
token).Unwrap();
return(task);
}
internal static byte[] WriteMainHeader(IEsriShapeCollection shapes, int fileLength, EsriShapeType shapeType)
{
System.IO.MemoryStream result = new System.IO.MemoryStream();
result.Write(IRI.Msh.Common.Helpers.StreamHelper.Int32ToBigEndianOrderedBytes(ShapeConstants.FileCode), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
result.Write(IRI.Msh.Common.Helpers.StreamHelper.Int32ToBigEndianOrderedBytes(fileLength), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(ShapeConstants.Version), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes((int)shapeType), 0, ShapeConstants.IntegerSize);
result.Write(System.BitConverter.GetBytes(shapes.MainHeader.XMin), 0, ShapeConstants.DoubleSize);
result.Write(System.BitConverter.GetBytes(shapes.MainHeader.YMin), 0, ShapeConstants.DoubleSize);
result.Write(System.BitConverter.GetBytes(shapes.MainHeader.XMax), 0, ShapeConstants.DoubleSize);
result.Write(System.BitConverter.GetBytes(shapes.MainHeader.YMax), 0, ShapeConstants.DoubleSize);
double tempValue = shapes.MainHeader.ZMin;
if (double.IsNaN(tempValue))
{
tempValue = 0;
}
result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
tempValue = shapes.MainHeader.ZMax;
if (double.IsNaN(tempValue))
{
tempValue = 0;
}
result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
tempValue = shapes.MainHeader.MMin;
if (double.IsNaN(tempValue))
{
tempValue = 0;
}
result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
tempValue = shapes.MainHeader.MMax;
if (double.IsNaN(tempValue))
{
tempValue = 0;
}
result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
return(result.ToArray());
}
public static void Save(string shpFileName, IEnumerable <IEsriShape> shapes, bool createDbf = false, bool overwrite = false, SrsBase srs = null)
{
if (shapes.IsNullOrEmpty())
{
return;
}
var directory = System.IO.Path.GetDirectoryName(shpFileName);
if (!System.IO.Directory.Exists(directory) && !string.IsNullOrEmpty(directory))
{
System.IO.Directory.CreateDirectory(directory);
}
IEsriShapeCollection collection = new EsriShapeCollection <IEsriShape>(shapes);
EsriShapeType shapeType = shapes.First().Type;
using (System.IO.MemoryStream featureWriter = new System.IO.MemoryStream())
{
int recordNumber = 0;
foreach (IEsriShape item in shapes)
{
featureWriter.Write(ShpWriter.WriteHeaderToByte(++recordNumber, item), 0, 2 * ShapeConstants.IntegerSize);
featureWriter.Write(item.WriteContentsToByte(), 0, 2 * item.ContentLength);
}
using (System.IO.MemoryStream shpWriter = new System.IO.MemoryStream())
{
int fileLength = (int)featureWriter.Length / 2 + 50;
shpWriter.Write(ShpWriter.WriteMainHeader(collection, fileLength, shapeType), 0, 100);
shpWriter.Write(featureWriter.ToArray(), 0, (int)featureWriter.Length);
//var mode = overwrite ? System.IO.FileMode.Create : System.IO.FileMode.CreateNew;
var mode = Shapefile.GetMode(shpFileName, overwrite);
System.IO.FileStream stream = new System.IO.FileStream(shpFileName, mode);
shpWriter.WriteTo(stream);
stream.Close();
shpWriter.Close();
featureWriter.Close();
}
}
ShxWriter.Write(Shapefile.GetShxFileName(shpFileName), collection, shapeType, overwrite);
if (createDbf)
{
Dbf.DbfFile.WriteDefault(Shapefile.GetDbfFileName(shpFileName), collection.Count, overwrite);
}
//try to automatically find srs
if (srs == null)
{
var srid = shapes.First()?.Srid ?? 0;
srs = SridHelper.AsSrsBase(srid);
}
if (srs != null)
{
SaveAsPrj(shpFileName, srs, overwrite);
}
}
public static ProSuiteGeometryType GetGeometryType([NotNull] byte[] esriShapeBuffer)
{
EsriShapeType shapeType = GetShapeType(esriShapeBuffer);
return(TranslateEsriShapeType(shapeType));
}
internal static byte[] WriteMainHeader(IEsriShapeCollection shapes, int fileLength, EsriShapeType shapeType)
{
return(ShpWriter.WriteMainHeader(shapes, fileLength, shapeType));
//System.IO.MemoryStream result = new System.IO.MemoryStream();
//result.Write(IRI.Ket.IO.Binary.Int32ToBigEndianOrderedBytes(ShapeConstants.FileCode), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(0), 0, ShapeConstants.IntegerSize);
//result.Write(IRI.Ket.IO.Binary.Int32ToBigEndianOrderedBytes(fileLength), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(ShapeConstants.Version), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes((int)shapeType), 0, ShapeConstants.IntegerSize);
//result.Write(System.BitConverter.GetBytes(MapStatistics.GetMinX(shapes)), 0, ShapeConstants.DoubleSize);
//result.Write(System.BitConverter.GetBytes(MapStatistics.GetMinY(shapes)), 0, ShapeConstants.DoubleSize);
//result.Write(System.BitConverter.GetBytes(MapStatistics.GetMaxX(shapes)), 0, ShapeConstants.DoubleSize);
//result.Write(System.BitConverter.GetBytes(MapStatistics.GetMaxY(shapes)), 0, ShapeConstants.DoubleSize);
//double tempValue = MapStatistics.GetMinZ(shapes);
//if (double.IsNaN(tempValue)) { tempValue = 0; }
//result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
//tempValue = MapStatistics.GetMaxZ(shapes);
//if (double.IsNaN(tempValue)) { tempValue = 0; }
//result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
//tempValue = MapStatistics.GetMinM(shapes);
//if (double.IsNaN(tempValue)) { tempValue = 0; }
//result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
//tempValue = MapStatistics.GetMaxM(shapes);
//if (double.IsNaN(tempValue)) { tempValue = 0; }
//result.Write(System.BitConverter.GetBytes(tempValue), 0, ShapeConstants.DoubleSize);
//return result.ToArray();
}
protected ShpReader(string fileName, EsriShapeType type, int srid)
{
this._srid = srid;
//this.directoryName = System.IO.Path.GetDirectoryName(fileName);
//this.fileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(fileName);
if (!Shapefile.CheckAllNeededFilesExists(fileName))
{
throw new NotImplementedException();
}
ShxReader shxFile = new ShxReader(Shapefile.GetShxFileName(fileName));
using (System.IO.FileStream shpStream = new System.IO.FileStream(fileName, System.IO.FileMode.Open))
{
using (this.shpReader = new System.IO.BinaryReader(shpStream))
{
this.MainHeader = new MainFileHeader(this.shpReader.ReadBytes(ShapeConstants.MainHeaderLengthInBytes));
if ((EsriShapeType)this.MainHeader.ShapeType != type)
{
throw new NotImplementedException();
}
if (!MainFileHeader.CanBeForTheSameShapefile(this.MainHeader, shxFile.MainHeader))
{
throw new NotImplementedException();
}
this.elements = new EsriShapeCollection <T>(this.MainHeader);
int numberOfRecords = shxFile.NumberOfRecords;
for (int i = 0; i < numberOfRecords; i++)
{
int offset, contentLength02;
shxFile.GetRecord(i, out offset, out contentLength02);
shpReader.BaseStream.Position = offset * 2;
int recordNumber, contentLength;
ReadRecordHeader(out recordNumber, out contentLength);
if (contentLength != contentLength02)
{
System.Diagnostics.Trace.WriteLine("ERROR at contentLength != contentLength02: i=" + i.ToString());
//throw new NotImplementedException();
}
if (contentLength == 2)
{
continue;
}
elements.Add(ReadElement());
//4: length of the record header in words
//contentLength: length of the contents in words
//this.tempPosition = this.tempPosition - (ShapeConstants.RecordHeaderLengthInWords + contentLength);
}
}
}
}
