// Build a list of unique fields for the output file
private bool CombineFields(out string errorMessage)
{
errorMessage = "No Error";
List <MapWinGIS.Field> fields = new List <MapWinGIS.Field>();
List <string> names = new List <string>();
for (int fld = 0; fld < _inSF1.NumFields; fld++)
{
MapWinGIS.Field field = _inSF1.get_Field(fld);
fields.Add(field);
names.Add(field.Name);
}
for (int fld = 0; fld < _inSF2.NumFields; fld++)
{
MapWinGIS.Field field = _inSF2.get_Field(fld);
string name = field.Name;
if (names.Contains(name) == false)
{
fields.Add(field);
names.Add(name);
}
else
{
if (fields[names.IndexOf(name)].Type != field.Type)
{
errorMessage = "Fields with a common name [" + name + "] did not share the same type.";
return(false);
}
}
}
int fi = 0;
foreach (MapWinGIS.Field field in fields)
{
if (_outSF.EditInsertField(field, ref fi, null) == false)
{
errorMessage = _outSF.get_ErrorMsg(_outSF.LastErrorCode);
return(false);
}
fi++;
}
return(true);
}
/// <summary>
/// Converts a list of 3d-points to a point shapefile with z-value field.
/// This function creates a new shapefile. The shapefile has two fields:
/// a 'MWShapeId' field and a field which contains the z-value.
/// </summary>
/// <param name="ShpFileName">Name of the resulting point shapefile</param>
/// <param name="ZFieldName">Name of the z-field in the shapefile</param>
public void ToShapefile(string ShpFileName, string ZFieldName)
{
MapWinGIS.Shapefile newSF = new MapWinGIS.Shapefile();
try
{
Hashtable FieldIndices = new Hashtable();
MapWinGIS.ShpfileType sftype;
sftype = MapWinGIS.ShpfileType.SHP_POINT;
int fldIdx = 0;
// if shapefile exists - open it and clear all shapes
if (System.IO.File.Exists(ShpFileName))
{
newSF.Open(ShpFileName, null);
newSF.StartEditingShapes(true, null);
newSF.EditClear();
}
else //else, create a new shapefile
{
if (!newSF.CreateNew(ShpFileName, sftype))
{
throw new InvalidOperationException
("Error creating shapefile " + newSF.get_ErrorMsg(newSF.LastErrorCode));
}
newSF.StartEditingShapes(true, null);
}
//check existing fields:
for (int i = 0; i < newSF.NumFields; ++i)
{
MapWinGIS.Field fl = newSF.get_Field(i);
if (fl.Name == "MWShapeID")
{
FieldIndices.Add("MWShapeID", i);
}
if (fl.Name == ZFieldName)
{
FieldIndices.Add(ZFieldName, i);
}
}
//Add the fields:
if (!FieldIndices.ContainsKey("MWShapeID"))
{
//First an ID field
MapWinGIS.Field idFld = new MapWinGIS.Field();
idFld.Name = "MWShapeID";
idFld.Type = MapWinGIS.FieldType.INTEGER_FIELD;
fldIdx = newSF.NumFields;
if (newSF.EditInsertField(idFld, ref fldIdx, null) == false)
{
throw new InvalidOperationException("error inserting field " +
newSF.get_ErrorMsg(newSF.LastErrorCode));
}
FieldIndices.Add("MWShapeID", fldIdx);
}
if (!FieldIndices.ContainsKey(ZFieldName))
{
//Second add a Z-field
MapWinGIS.Field zFld = new MapWinGIS.Field();
zFld.Name = "Z";
zFld.Type = MapWinGIS.FieldType.DOUBLE_FIELD;
fldIdx = newSF.NumFields;
if (newSF.EditInsertField(zFld, ref fldIdx, null) == false)
{
throw new InvalidOperationException("error inserting field " +
newSF.get_ErrorMsg(newSF.LastErrorCode));
}
FieldIndices.Add("Z", fldIdx);
}
foreach (ICoordinate pt in _points)
{
//first, add a point shape (geometry)
MapWinGIS.Shape newShp = new MapWinGIS.Shape();
newShp.Create(MapWinGIS.ShpfileType.SHP_POINT);
MapWinGIS.Point newPt = new MapWinGIS.Point();
newPt.x = pt.X;
newPt.y = pt.Y;
int ptIdx = 0;
newShp.InsertPoint(newPt, ref ptIdx);
int shpIdx = newSF.NumShapes;
newSF.EditInsertShape(newShp, ref shpIdx);
//second add the z-value
newSF.EditCellValue(fldIdx, shpIdx, pt.Z);
}
}
finally
{
//finally stop editing and close the shapefile
newSF.StopEditingShapes(true, true, null);
if (newSF.Close() == false)
{
throw new InvalidOperationException("error closing shapefile " +
newSF.get_ErrorMsg(newSF.LastErrorCode));
}
}
}
/// <summary>
/// Exports the shapes that are selected in the MapWindow view to a new shapefile.
/// </summary>
/// <param name="MapWin">A reference to the running MapWindow.</param>
/// <param name="ExportToSFPath">The full path to where the result shapefile should be saved.</param>
/// <param name="AddToMap">Indicates that the output should be added to the map view immediately.</param>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool ExportSelectedMWViewShapes(MapWindow.Interfaces.IMapWin MapWin, string ExportToSFPath, bool AddToMap)
{
MapWinUtility.Logger.Dbg("ExportSelectedMWViewShapes(MapWin: IMapWin,\n" +
" ExportToSFPath: " + ExportToSFPath + ",\n" +
" AddToMap: " + AddToMap.ToString() + ")");
if (MapWin.Layers.NumLayers == 0)
{
gErrorMsg = "Please select a layer first.";
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (MapWin.View.SelectedShapes.NumSelected == 0)
{
gErrorMsg = "There are no selected features to export. Please select a feature first.";
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
MapWinGIS.Shapefile sf = new MapWinGIS.Shapefile();
MapWinGIS.Shapefile tollSF = new MapWinGIS.Shapefile();
MapWinGIS.Field fld = new MapWinGIS.Field();
MapWinGIS.Shape seg = new MapWinGIS.Shape();
int Segments;
bool Status;
Status = sf.Open(MapWin.Layers[MapWin.Layers.CurrentLayer].FileName, null);
if (Status == false)
{
gErrorMsg = sf.get_ErrorMsg(sf.LastErrorCode);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (System.IO.File.Exists(ExportToSFPath))
{
try
{
DataManagement.DeleteShapefile(ref ExportToSFPath);
}
catch
{
gErrorMsg = "The destination file already exists, but could not be deleted. Please check to make sure the file isn't in use.";
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
}
Status = tollSF.CreateNew(ExportToSFPath, sf.ShapefileType);
if (Status == false)
{
gErrorMsg = tollSF.get_ErrorMsg(tollSF.LastErrorCode);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
try
{
tollSF.Projection = sf.Projection;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
Status = tollSF.StartEditingShapes(true, null);
if (Status == false)
{
gErrorMsg = tollSF.get_ErrorMsg(tollSF.LastErrorCode);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
fld.Name = "MWShapeID";
fld.Type = MapWinGIS.FieldType.INTEGER_FIELD;
fld.Width = 12;
Segments = 0;
// Chris M -- This is already opened above, why open
// it again here?
// sf.Open(MapWin.Layers[MapWin.Layers.CurrentLayer].FileName, null);
for (int j = 0; j <= sf.NumFields - 1; j++)
{
tollSF.EditInsertField(sf.get_Field(j), ref j, null);
}
MapWin.View.MapCursor = MapWinGIS.tkCursor.crsrWait;
try
{
for (int i = 0; i <= MapWin.View.SelectedShapes.NumSelected - 1; i++)
{
seg = sf.get_Shape(MapWin.View.SelectedShapes[i].ShapeIndex);
Status = tollSF.EditInsertShape(seg, ref Segments);
if (Status == false)
{
gErrorMsg = tollSF.get_ErrorMsg(tollSF.LastErrorCode);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
for (int h = 0; h <= sf.NumFields - 1; h++)
{
tollSF.EditCellValue(h, i, sf.get_CellValue(h, MapWin.View.SelectedShapes[i].ShapeIndex));
}
Segments = Segments + 1;
}
sf.Close();
tollSF.StopEditingShapes(true, true, null);
}
catch (Exception ex)
{
gErrorMsg = ex.Message;
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
}
MapWin.View.MapCursor = MapWinGIS.tkCursor.crsrArrow;
tollSF.Close();
if (AddToMap)
{
MapWin.View.LockMap();
MapWindow.Interfaces.Layer thelayer;
thelayer = MapWin.Layers.Add(ExportToSFPath, System.IO.Path.GetFileNameWithoutExtension(ExportToSFPath), true);
thelayer.ClearLabels();
MapWin.View.UnlockMap();
}
MapWinUtility.Logger.Dbg("Finished ExportSelectedMWViewShapes");
return(true);
}
/// <summary>
/// Removes portions of the lineSF that fall within the erase polygon
/// </summary>
/// <param name="lineSF">The shapefile of lines to be erased.</param>
/// <param name="erasePoly">The polygon to be used for erasing portion of the line shapefile.</param>
/// <param name="resultSF">The resulting line shapefile with portions removed.</param>
/// <param name="CopyAttributes">Indicates whether to copy attributes</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool EraseLineSFWithPoly(ref MapWinGIS.Shapefile lineSF, ref MapWinGIS.Shape erasePoly, ref MapWinGIS.Shapefile resultSF, bool CopyAttributes)
{
MapWinUtility.Logger.Dbg("EraseLineSFWithPoly(lineSF: " + Macro.ParamName(lineSF) + ",\n" +
" erasePoly: " + Macro.ParamName(erasePoly) + ",\n" +
" resultSF: " + Macro.ParamName(resultSF) + ",\n" +
" CopyAttributes: " + CopyAttributes.ToString() + ")");
if (lineSF == null || erasePoly == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
string tmpName;
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = lineSF.get_Field(f);
tmpName = currField.Name;
tmpField.Name = tmpName;
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int shpIndex = 0;
int numLines = lineSF.NumShapes;
for (int i = 0; i <= numLines - 1; i++)
{
MapWinGIS.Shape currLine = new MapWinGIS.ShapeClass();
currLine.Create(lineSF.ShapefileType);
currLine = lineSF.get_Shape(i);
MapWinGIS.Shape lineEnvelope = new MapWinGIS.ShapeClass();
lineEnvelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
//create lineExtents' points out of the line extent points
MapWinGIS.Point lTop, rTop, rBottom, lBottom;
lTop = new MapWinGIS.PointClass();
lTop.x = currLine.Extents.xMin;
lTop.y = currLine.Extents.yMax;
rTop = new MapWinGIS.PointClass();
rTop.x = currLine.Extents.xMax;
rTop.y = currLine.Extents.yMax;
rBottom = new MapWinGIS.PointClass();
rBottom.x = currLine.Extents.xMax;
rBottom.y = currLine.Extents.yMin;
lBottom = new MapWinGIS.PointClass();
lBottom.x = currLine.Extents.xMin;
lBottom.y = currLine.Extents.yMin;
//now add the extent points to the new polygon shape: lineEnvelope
int ptIndex = 0;
lineEnvelope.InsertPoint(lTop, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(rTop, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(rBottom, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(lBottom, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(lTop, ref ptIndex);
//remove COM points from memory
while (Marshal.ReleaseComObject(lTop) != 0)
{
;
}
while (Marshal.ReleaseComObject(rTop) != 0)
{
;
}
while (Marshal.ReleaseComObject(rBottom) != 0)
{
;
}
while (Marshal.ReleaseComObject(lBottom) != 0)
{
;
}
//Check if line extents and polygon extents overlap
if (Globals.CheckBounds(ref lineEnvelope, ref erasePoly))
{
//make the envelope polygon slightly larger
MapWinGIS.Shape lgEnvelope = new MapWinGIS.ShapeClass();
lgEnvelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
SpatialOperations.BufferPolygon(ref lineEnvelope, 0.5, Enumerations.Buffer_HoleTreatment.Ignore, Enumerations.Buffer_CapStyle.Pointed, out lgEnvelope);
//take the difference of the envelope polygon with the erase polygon.
MapWinGIS.Shape diff = new MapWinGIS.ShapeClass();
diff.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
diff = SpatialOperations.Difference(lgEnvelope, erasePoly);
if (diff.numPoints > 0)
{
//the difference shape represents the line envelope
//minus the area of the erase polygon.
MapWinGIS.Shapefile inputLine = new MapWinGIS.ShapefileClass();
string tempPath = System.IO.Path.GetTempPath() + "tempInputLine.shp";
//CDM 8/4/2006 inputLine.CreateNew(tempPath, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempPath, ref inputLine, lineSF.ShapefileType);
shpIndex = 0;
inputLine.EditInsertShape(currLine, ref shpIndex);
int numParts = diff.NumParts;
if (numParts == 0)
{
numParts = 1;
}
if (numParts > 1)
{
//separate and test each part individually
MapWinGIS.Shape[] diffParts = new MapWinGIS.Shape[numParts];
Globals.SeparateParts(ref diff, out diffParts);
for (int j = 0; j <= numParts - 1; j++)
{
//don't check inside of holes
if (Globals.IsClockwise(ref diffParts[j]))
{
MapWinGIS.Shapefile tempLineResult = new MapWinGIS.ShapefileClass();
string tempLineFile = System.IO.Path.GetTempPath() + "tempLines.shp";
DataManagement.DeleteShapefile(ref tempLineFile);
//CDM 8/4/2006 tempLineResult.CreateNew(tempLineFile, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempLineFile, ref tempLineResult, lineSF.ShapefileType);
tempLineResult.StartEditingShapes(true, null);
SpatialOperations.ClipShapesWithPolygon(ref inputLine, ref diffParts[j], out tempLineResult, false);
int numResults = tempLineResult.NumShapes;
if (numResults > 0)
{
//add results to the final result file.
for (int k = 0; k <= numResults - 1; k++)
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(tempLineResult.get_Shape(k), ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //clipping successful
} //done checking islands
} //done looping through parts of the difference shape
}
else
{
MapWinGIS.Shapefile tempLineResult = new MapWinGIS.ShapefileClass();
string tempLineFile = System.IO.Path.GetTempPath() + "tempLines.shp";
DataManagement.DeleteShapefile(ref tempLineFile);
//CDM 8/4/2006 tempLineResult.CreateNew(tempLineFile, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempLineFile, ref tempLineResult, lineSF.ShapefileType);
tempLineResult.StartEditingShapes(true, null);
SpatialOperations.ClipShapesWithPolygon(ref inputLine, ref diff, out tempLineResult, false);
int numResults = tempLineResult.NumShapes;
if (numResults > 0)
{
//add results to the final result file.
for (int k = 0; k <= numResults - 1; k++)
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(tempLineResult.get_Shape(k), ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //clipping successful
}
} //difference operation successful
} //bounds overlapped
else
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(currLine, ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //end of looping through lines in the input shapefile
MapWinUtility.Logger.Dbg("Finished EraseLineSFWithPoly");
return(true);
}
/// <summary>
/// Removes points from the point shapefile that lie within the polygon.
/// </summary>
/// <param name="pointSF">The point shapefile.</param>
/// <param name="polygon">The erase polygon.</param>
/// <param name="resultSF">The resulting file with points removed.</param>
/// <param name="CopyAttributes">Indicates whether to copy attributes</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ErasePointSFWithPoly(ref MapWinGIS.Shapefile pointSF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool CopyAttributes)
{
MapWinUtility.Logger.Dbg("ErasePointSFWithPoly(pointSF: " + Macro.ParamName(pointSF) + "\n, " +
" polygon: " + Macro.ParamName(polygon) + "\n, " +
" resultSF: " + Macro.ParamName(resultSF) + "\n, " +
" CopyAttributes: " + CopyAttributes.ToString() + ")");
if (pointSF == null || polygon == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
string tmpName;
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= pointSF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = pointSF.get_Field(f);
tmpName = currField.Name;
tmpField.Name = tmpName;
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int numPts = pointSF.NumShapes;
int numParts = polygon.NumParts;
if (numParts == 0)
{
numParts = 1;
}
int shpIndex = 0;
Globals.Vertex[][] vertArray = new Globals.Vertex[numParts][];
Globals.ConvertPolyToVertexArray(ref polygon, out vertArray);
for (int i = 0; i <= numPts - 1; i++)
{
MapWinGIS.Point currPt = new MapWinGIS.PointClass();
currPt = pointSF.QuickPoint(i, 0);
double currX = currPt.x;
double currY = currPt.y;
if (Utils.PointInPoly(ref vertArray, currX, currY) == false)
{
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(pointSF.get_Shape(i), ref shpIndex) == false)
{
gErrorMsg = "ErasePointSF: problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
for (int f = 0; f <= pointSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, pointSF.get_CellValue(f, i));
}
}
}
}
MapWinUtility.Logger.Dbg("Finished ErasePointSFWithPoly");
return(true);
}
/// <summary>
/// Erases the portions of the polygon shapefile that are within the polygon shape.
/// </summary>
/// <param name="polySF">The polygon shapefile.</param>
/// <param name="polygon">The erase polygon.</param>
/// <param name="resultSF">The resulting shapefile, with portions removed.</param>
/// <param name="CopyAttributes">Indicates whether to copy attributes or not.</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ErasePolySFWithPoly(ref MapWinGIS.Shapefile polySF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool CopyAttributes)
{
MapWinUtility.Logger.Dbg("ErasePolySFWithPoly(polySF: " + Macro.ParamName(polySF) + ",\n" +
" polygon: " + Macro.ParamName(polygon) + ",\n" +
" resultSF: " + Macro.ParamName(resultSF) + "\n" +
" CopyAttributes: " + CopyAttributes.ToString());
if (polySF == null || polygon == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
string tmpName;
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = polySF.get_Field(f);
tmpName = currField.Name;
tmpField.Name = tmpName;
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int numShapes = polySF.NumShapes;
int shpIndex = 0;
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currShape = new MapWinGIS.Shape();
MapWinGIS.Shape resultShp = new MapWinGIS.Shape();
currShape = polySF.get_Shape(i);
//if bounds intersect, then check if all polygon points are inside the currShape
if (Globals.CheckBounds(ref currShape, ref polygon))
{
int numPts = polygon.numPoints;
bool allInside = true;
int numParts = currShape.NumParts;
if (numParts == 0)
{
numParts = 1;
}
Globals.Vertex[][] vertArray = new Globals.Vertex[numParts][];
Globals.ConvertPolyToVertexArray(ref currShape, out vertArray);
for (int j = 0; j <= numPts - 1; j++)
{
double x = polygon.get_Point(j).x;
double y = polygon.get_Point(j).y;
if (Utils.PointInPoly(ref vertArray, x, y) == false)
{
allInside = false;
break;
}
}
if (allInside == true)
{
resultShp = new MapWinGIS.ShapeClass();
resultShp.Create(polygon.ShapeType);
//we want the symmetric difference of these two shapes
//which should leave us with a hole where the erase polygon was in the currShape
resultShp = SpatialOperations.SymmetricDifference(polygon, currShape);
}
else
{
//erase overlapping section and add result to the file.
MapWinGIS.Shape intersect = new MapWinGIS.ShapeClass();
intersect.ShapeType = polygon.ShapeType;
intersect = SpatialOperations.Intersection(polygon, currShape);
if (intersect.numPoints > 0)
{
//there might be parts in the difference result that do not belong,
//perform an intersection operation with currShape to remove them.
MapWinGIS.Shape diff = new MapWinGIS.ShapeClass();
diff.ShapeType = polygon.ShapeType;
//diff = SpatialOperations.SymmetricDifference(intersect, currShape);
diff = SpatialOperations.Difference(currShape, polygon);
int numPoints = diff.numPoints;
if (numPoints > 0)
{
resultShp = diff;
} //difference operation successful
} //intersect operation successful
else
{
//no intersection, shapes do not collide
resultShp = currShape;
}
} //all points of erase polygon are not inside currShape
if (resultShp.numPoints > 0)
{
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(resultShp, ref shpIndex) == false)
{
gErrorMsg = "ErasePolySF: problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, polySF.get_CellValue(f, i));
}
}
}
} //end of if bounds intersect
else
{
//the erase object does not intersect with the current polygon,
//add current polygon to resultSF in unchanged form
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currShape, ref shpIndex) == false)
{
gErrorMsg = "ErasePolySF: problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, polySF.get_CellValue(f, i));
}
}
}
} //end of looping through shapes in shapefile
MapWinUtility.Logger.Dbg("Finished ErasePolySFWithPoly");
return(true);
}
/// <summary>
/// This creates a new shapefile that has Z values and follows along the same line segments.
/// The boundaries for grid cells are marked with vertices and the segment is given a Z value
/// that corresponds to the grid elevation it intersects.
/// </summary>
/// <param name="mwElevGrid">A MapWinGIS Grid that contains the elevations.</param>
/// <param name="mwPolyLine">A MapWinGIS Shapefile that shows the pathways of the cross sections in the X-Y direction.</param>
/// <param name="OutFileName">A string containing the full path of the desired output shapefile. The extension should be *.shp</param>
/// <param name="CrossSectionType">Clarifies the type of output. default = PolyLineWithZ</param>
/// <param name="ICallBack">A MapWinGIS.ICallback for progress messages. [Optional]</param>
/// <remarks>This function throws Argument or Application exceptions on errors, so it's recommended that coders enclose it in a try catch block.</remarks>
public static void GetCrossSection(MapWinGIS.Grid mwElevGrid, MapWinGIS.Shapefile mwPolyLine, string OutFileName, CrossSectionTypes CrossSectionType, MapWinGIS.ICallback ICallBack)
{
MapWinUtility.Logger.Dbg("GetCrossSection(mwElevGrid: " + Macro.ParamName(mwElevGrid) + ",\n" +
" mwPolyLine: " + Macro.ParamName(mwPolyLine) + ",\n" +
" OutFileName: " + OutFileName + ",\n" +
" CrossSectionType: " + CrossSectionType.ToString() + ",\n" +
" ICallback)");
bool res;
int Prog = 0;
int OldProg = 0;
double dS, dX, dY, XllCenter, YllCenter;
int NumRows, NumCols, ElevField, IDField;
ElevField = 1;
IDField = 0;
// Test to be sure that the elevation grid and shapefile are not null
if (mwElevGrid == null)
{
MapWinUtility.Logger.Dbg("Argument Exception: Elevation grid mwElevGrid can't be null.");
throw new ArgumentException("Elevation grid mwElevGrid can't be null.");
}
if (mwPolyLine == null)
{
MapWinUtility.Logger.Dbg("Argument Exception: The shapefile of input cross sections mwPolyLine can't be null.");
throw new ArgumentException("The shapefile of input cross sections mwPolyLine can't be null.");
}
// Clear any existing shapefile output filenames that might cause problems if they exist.
string fn;
if (System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(OutFileName)) == false)
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(OutFileName));
}
if (System.IO.File.Exists(OutFileName))
{
System.IO.File.Delete(OutFileName);
}
fn = System.IO.Path.ChangeExtension(OutFileName, ".dbf");
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
}
fn = System.IO.Path.ChangeExtension(OutFileName, ".shx");
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
}
fn = System.IO.Path.ChangeExtension(OutFileName, ".prj");
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
}
// Since we are given the lower left coordinate, just make sure dX and dY are positive
dX = Math.Abs(mwElevGrid.Header.dX);
if (dX == 0)
{
throw new ApplicationException("mwElevGrid.Header.dX cannot be 0.");
}
dY = Math.Abs(mwElevGrid.Header.dY);
if (dY == 0)
{
throw new ApplicationException("mwElevGrid.Header.dY cannot be 0.");
}
// Determine the stepping distance from the grid coordintes
dS = dX / 2;
if (dY < dX)
{
dS = dY / 2;
}
XllCenter = mwElevGrid.Header.XllCenter;
YllCenter = mwElevGrid.Header.YllCenter;
NumRows = mwElevGrid.Header.NumberRows;
NumCols = mwElevGrid.Header.NumberCols;
// Test for intersection between the entire shapefile and the grid
double left, right, top, bottom;
left = XllCenter - dX / 2;
right = XllCenter + NumCols * dX - dX / 2;
bottom = YllCenter - dY / 2;
top = YllCenter + NumRows * dY - dY / 2;
MapWinGeoProc.Topology2D.Envelope gExt = new MapWinGeoProc.Topology2D.Envelope(left, right, bottom, top);
MapWinGeoProc.Topology2D.Envelope pExt = new MapWinGeoProc.Topology2D.Envelope(mwPolyLine.Extents);
if (gExt.Intersects(pExt) == false)
{
MapWinUtility.Logger.Dbg("Application Exception: The shapefile doesn't overlap the grid, so no cross sections were found.");
throw new ApplicationException("The shapefile doesn't overlap the grid, so no cross sections were found.");
}
// Setup the output shapefile and the basic shape objects
MapWinGIS.Shape mwShape;
MapWinGIS.Shapefile sfOut = new MapWinGIS.Shapefile();
sfOut.Projection = mwPolyLine.Projection;
if (CrossSectionType == CrossSectionTypes.PointsWithZAndElevField)
{
res = sfOut.CreateNew(OutFileName, MapWinGIS.ShpfileType.SHP_POINTZ);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
res = sfOut.StartEditingShapes(true, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
MapWinGIS.Field ID = new MapWinGIS.Field();
ID.Name = "ID";
ID.Type = MapWinGIS.FieldType.INTEGER_FIELD;
res = sfOut.EditInsertField(ID, ref IDField, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
MapWinGIS.Field Elev = new MapWinGIS.Field();
Elev.Name = "Elevation";
Elev.Type = MapWinGIS.FieldType.DOUBLE_FIELD;
res = sfOut.EditInsertField(Elev, ref ElevField, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
}
else
{
res = sfOut.CreateNew(OutFileName, MapWinGIS.ShpfileType.SHP_POLYLINEZ);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
res = sfOut.StartEditingShapes(true, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
MapWinGIS.Field ID = new MapWinGIS.Field();
ID.Name = "ID";
ID.Type = MapWinGIS.FieldType.INTEGER_FIELD;
res = sfOut.EditInsertField(ID, ref IDField, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
}
MapWinGIS.Shape mwOutShape;
// Loop through all the shapes in the polyline shapefile
int shIndx = -1;
for (int shp = 0; shp < mwPolyLine.NumShapes; shp++)
{
mwShape = mwPolyLine.get_Shape(shp);
// By turning multi-part polylines into multiple linestrings, we avoid the annoying multi-part logic
MultiLineString MLS = GeometryFactory.CreateMultiLineString(mwShape);
for (int ls = 0; ls < MLS.NumGeometries; ls++)
{
LineString lsSource = MLS.GeometryN[ls] as LineString;
for (int pt = 0; pt < lsSource.Coordinates.Count - 1; pt++)
{
Coordinate start = lsSource.Coordinates[pt];
Coordinate end = lsSource.Coordinates[pt + 1];
// Crop the parts of each segment that do not overlap with the grid.
if (start.X < left)
{
if (end.X < left)
{
// this segment is outside the grid
continue;
}
// crop this segment to only the portion on the grid
start.X = left;
}
if (end.X < left)
{
// crop this segment to only the portion on the grid
end.X = left;
}
if (start.X > right)
{
if (end.X > right)
{
// this segment is outside the grid
continue;
}
// crop to grid
start.X = right;
}
if (end.X > right)
{
// crop to the grid
end.X = right;
}
double length = Math.Sqrt((end.X - start.X) * (end.X - start.X) + (end.Y - start.Y) * (end.Y - start.Y));
int NumSteps = (int)Math.Floor(length / dS);
double segDx = (end.X - start.X) / NumSteps;
double segDy = (end.Y - start.Y) / NumSteps;
mwOutShape = new MapWinGIS.Shape();
if (CrossSectionType == CrossSectionTypes.PolyLineWithZ)
{
mwOutShape.Create(MapWinGIS.ShpfileType.SHP_POLYLINEZ);
}
// step by dS and get the grid value at that point at each step
int p = 0;
for (int I = 0; I < NumSteps; I++)
{
int row, col;
object Elev;
double X = start.X + segDx * I;
double Y = start.Y + segDy * I;
mwElevGrid.ProjToCell(X, Y, out col, out row);
Elev = mwElevGrid.get_Value(col, row);
MapWinGIS.Point pnt = new MapWinGIS.Point();
pnt.x = X;
pnt.y = Y;
pnt.Z = (double)Elev;
if (CrossSectionType == CrossSectionTypes.PointsWithZAndElevField)
{
p = 0;
mwOutShape = new MapWinGIS.Shape();
mwOutShape.Create(MapWinGIS.ShpfileType.SHP_POINTZ);
res = mwOutShape.InsertPoint(pnt, ref p);
if (res == false)
{
throw new ApplicationException(mwOutShape.get_ErrorMsg(mwOutShape.LastErrorCode));
}
res = sfOut.EditInsertShape(mwOutShape, ref shIndx);
if (res != true)
{
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
res = sfOut.EditCellValue(IDField, shIndx, shIndx);
if (res != true)
{
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
res = sfOut.EditCellValue(ElevField, shIndx, Elev);
if (res != true)
{
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
shIndx++;
}
else
{
res = mwOutShape.InsertPoint(pnt, ref p);
p++;
if (res == false)
{
throw new ApplicationException(mwOutShape.get_ErrorMsg(mwOutShape.LastErrorCode));
}
}
}
if (CrossSectionType == CrossSectionTypes.PolyLineWithZ)
{
if (mwOutShape.numPoints > 0)
{
res = sfOut.EditInsertShape(mwOutShape, ref shIndx);
if (res != true)
{
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
res = sfOut.EditCellValue(IDField, shIndx, shIndx);
if (res != true)
{
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
shIndx++;
}
}
}
}
Prog = Convert.ToInt32(shp * 100 / mwPolyLine.NumShapes);
if (Prog > OldProg)
{
MapWinUtility.Logger.Progress("Evaluating Cross Section..." + Prog.ToString() + "% Complete.", Prog, OldProg);
OldProg = Prog;
}
}
res = sfOut.StopEditingShapes(true, true, ICallBack);
if (res != true)
{
MapWinUtility.Logger.Dbg("Application Exception: " + sfOut.get_ErrorMsg(sfOut.LastErrorCode));
throw new ApplicationException(sfOut.get_ErrorMsg(sfOut.LastErrorCode));
}
}
/// <summary>
/// Creates shapefile from specified database table.
/// Geometry or GeometryText columns are expected
/// </summary>
private MapWinGIS.Shapefile LoadShapefile(string sql)
{
this.CheckConnection();
MapWinGIS.Shapefile sf = null;
if (m_callback != null)
{
m_callback.Progress("", 0, "Extracting data...");
}
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
DbDataAdapter adapter = this.CreateAdapter();
adapter.SelectCommand = this.CreateCommand();
adapter.SelectCommand.Connection = m_connection;
adapter.SelectCommand.CommandText = sql;
DataTable dt = new DataTable();
adapter.Fill(dt);
int index = dt.Columns.IndexOf("Geometry");
if (index >= 0 && dt.Rows.Count > 0)
{
// get shapefile type by the first shape
MapWinGIS.ShpfileType shpType;
MapWinGIS.Shape shape = new MapWinGIS.Shape();
if (shape.ImportFromBinary(dt.Rows[0][index]))
{
shpType = shape.ShapeType;
}
else
{
return(null);
}
sf = new MapWinGIS.Shapefile();
sf.CreateNew("", shpType);
foreach (DataColumn column in dt.Columns)
{
MapWinGIS.Field field = new MapWinGIS.Field();
field.Name = column.ColumnName;
switch (column.DataType.Name.ToLower())
{
case "int32":
case "int64":
field.Type = MapWinGIS.FieldType.INTEGER_FIELD;
break;
case "double":
field.Type = MapWinGIS.FieldType.DOUBLE_FIELD;
break;
case "string":
field.Type = MapWinGIS.FieldType.STRING_FIELD;
break;
case "byte[]":
continue;
default:
continue;
}
int fieldIndex = sf.NumFields;
bool result = sf.EditInsertField(field, ref fieldIndex, null);
System.Diagnostics.Debug.Print(result.ToString());
}
int shapeIndex = dt.Rows.Count;
shape = null;
int percent = 0;
for (int i = 0; i < dt.Rows.Count; i++)
{
if (m_callback != null && dt.Rows.Count > 1)
{
int newPercent = Convert.ToInt32((double)i / (double)(dt.Rows.Count - 1) * 100.0);
if (newPercent > percent)
{
m_callback.Progress("", newPercent, "Creating shapefile...");
percent = newPercent;
}
}
DataRow row = dt.Rows[i];
shape = new MapWinGIS.Shape();
if (shape.ImportFromBinary(row[index]))
{
shapeIndex = sf.NumShapes;
if (sf.EditInsertShape(shape, ref shapeIndex))
{
for (int j = 0; j < sf.NumFields; j++)
{
sf.EditCellValue(j, shapeIndex, row[j + 1]);
}
}
}
}
if (m_callback != null)
{
m_callback.Progress("", 100, "");
}
}
watch.Stop();
Debug.Print("Finished: " + watch.Elapsed.ToString());
return(sf);
}