/// <summary>
/// Not Implemented
/// This function will calculate the length of every line shape in the shapefile and save the results to the corresponding .dbf table.
/// </summary>
/// <param name="sf">The shapefile of lines whose lengths are to be computed.</param>
/// <param name="fieldIndex">The field index of the field to update with values.</param>
/// <param name="Units">The units of the dataset (e.g., Meters, Lat/Long).</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ComputeLengths(MapWinGIS.Shapefile sf, int fieldIndex, string Units)
{
try
{
//Loop trough all shapes
for (int i = 0; i <= sf.NumShapes - 1; i++)
{
double length = 0f;
MapWinGIS.Shape line = new MapWinGIS.Shape();
//Measure length of each line part
line = sf.get_Shape(i);
//-2 else out of bounds!!
for (int j = 0; j <= line.numPoints - 2; j++)
{
length += DistancePointToPoint(line.get_Point(j).x, line.get_Point(j).y, line.get_Point(j + 1).x, line.get_Point(j + 1).y, Units);
}
//Add length as attribute:
if (!sf.EditCellValue(fieldIndex, i, length))
{
Error.SetErrorMsg(sf.get_ErrorMsg(sf.LastErrorCode));
}
}
return(false);
}
catch (Exception lEx)
{
Error.SetErrorMsg(lEx.ToString());
return(false);
}
}
// Add the shapes one by one
private bool AddShapes(MapWinGIS.Shapefile inSF, out string errorMessage)
{
errorMessage = "No Error.";
int outShp = _outSF.NumShapes;
// Add all the shapes and attributes from the first shapefile
for (int shp = 0; shp < inSF.NumShapes; shp++)
{
MapWinGIS.Shape shape = inSF.get_Shape(shp);
_outSF.EditInsertShape(shape, ref outShp);
for (int fld = 0; fld < inSF.NumFields; fld++)
{
string name = inSF.get_Field(fld).Name;
int index = IndexOf(name);
if (index == -1)
{
errorMessage = "Could not find a field in the output shapefile: [" + name + "]";
return(false);
}
if (_outSF.EditCellValue(index, outShp, inSF.get_CellValue(fld, shp)) == false)
{
errorMessage = _outSF.get_ErrorMsg(_outSF.LastErrorCode);
return(false);
}
}
outShp++;
}
return(true);
}
/// <summary>
/// Exports the shapes from the inputSF which fall within the given polygon, saving to the resultSF provided.
/// </summary>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool SelectPointsWithPolygon(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool SkipMWShapeID)
{
MapWinGIS.Utils utils = new MapWinGIS.UtilsClass();
int numPoints = inputSF.NumShapes;
int shpIndex = 0;
if (Globals.CopyFields(ref inputSF, ref resultSF) == false)
{
return(false);
}
for (int i = 0; i <= numPoints - 1; i++)
{
MapWinGIS.Point currPt = new MapWinGIS.PointClass();
currPt = inputSF.QuickPoint(i, 0);
if (utils.PointInPolygon(polygon, currPt))
{
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(inputSF.get_Shape(i), ref shpIndex) == false)
{
gErrorMsg = "Problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
//add the table values
int numFields = resultSF.NumFields;
for (int j = 0; j <= numFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, i)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
} //end of looping through table
} //end of checking if point is inside polygon
} //end of looping through points
if (resultSF.NumShapes > 0)
{
if (resultSF.NumFields == 0 || !SkipMWShapeID)
{
//add the ID field and values
if (Globals.DoInsertIDs(ref resultSF) == false)
{
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
/// <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 from the inputSF which fall within the given polygon, saving to the resultSF provided.
/// </summary>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool SelectLinesWithPolygon(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool SkipMWShapeID)
{
int numLines = inputSF.NumShapes;
int shpIndex = 0;
// Boundary intersection test variables
double xMin1, xMax1, yMin1, yMax1, zMin1, zMax1, xMin2, xMax2, yMin2, yMax2, zMin2, zMax2;
// Get the masking polygon's boundaries only once:
polygon.Extents.GetBounds(out xMin2, out yMin2, out zMin2, out xMax2, out yMax2, out zMax2);
if (Globals.CopyFields(ref inputSF, ref resultSF) == false)
{
return(false);
}
MapWinGIS.Shape currLine;
MapWinGIS.Point currPt;
for (int i = 0; i <= numLines - 1; i++)
{
currLine = inputSF.get_Shape(i);
currLine.Extents.GetBounds(out xMin1, out yMin1, out zMin1, out xMax1, out yMax1, out zMax1);
// Are the boundaries intersecting?
if (!(xMin1 > xMax2 || xMax1 < xMin2 || yMin1 > yMax2 || yMax1 < yMin2))
{
//lines are nasty, just because the boundaries intersect it
//doesn't mean the line enters the polygon
//do a quick point check before doing a more thorough investigation
int numPoints = currLine.numPoints;
bool ptInside = false;
for (int j = 0; j <= numPoints - 1; j++)
{
currPt = currLine.get_Point(j);
if (polygon.PointInThisPoly(currPt))
{
ptInside = true;
break;
}
}
if (ptInside)
{
//we know part of the line is inside the polygon so add line to result file
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currLine, ref shpIndex) == false)
{
gErrorMsg = "Problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
//add the table values
int numFields = resultSF.NumFields;
for (int j = 0; j <= numFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, i)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
} //end of looping through table
} //end of ptInside check
else
{
// Avoid using a temp file to test each individual file;
// instead, just see if the line crosses the polygon
if (LineCrossesPoly(ref currLine, ref polygon))
{
//part of the line lies within the polygon, add to result file
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currLine, ref shpIndex) == false)
{
gErrorMsg = "Problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
//add the table values
int numFields = resultSF.NumFields;
for (int j = 0; j <= numFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, i)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
} //end of looping through table
} //end of successful cross
} //end of else no points were found inside polygon
} //end of checking bounds
} //end of looping through lines
if (resultSF.NumShapes > 0)
{
if (resultSF.NumFields == 0 || !SkipMWShapeID)
{
//add the ID field and values
if (Globals.DoInsertIDs(ref resultSF) == false)
{
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
/// <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>
/// Exports the shapes from the inputSF which fall within the given polygon, saving to the resultSF provided.
/// </summary>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool SelectPolygonsWithPolygon(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool SkipMWShapeID)
{
MapWinUtility.Logger.Dbg("SelectPolygonsWithPolygon(inputSF: " + Macro.ParamName(inputSF) + ",\n" +
" polygon: " + Macro.ParamName(polygon) + ",\n" +
" resultSF: ref " + Macro.ParamName(resultSF) + ",\n" +
" SkipMWShapeID: " + SkipMWShapeID.ToString() + ")");
int numShapes = inputSF.NumShapes;
int shpIndex = 0;
if (Globals.CopyFields(ref inputSF, ref resultSF) == false)
{
return(false);
}
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currShape = new MapWinGIS.ShapeClass();
currShape = inputSF.get_Shape(i);
bool boundsIntersect = Globals.CheckBounds(ref currShape, ref polygon);
if (boundsIntersect)
{
//check that actual intersection occurs
MapWinGIS.Shape intersectShp = new MapWinGIS.ShapeClass();
intersectShp = SpatialOperations.Intersection(currShape, polygon);
if (intersectShp != null && intersectShp.numPoints > 0)
{
//shape has at least a small portion inside polygon
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currShape, ref shpIndex) == false)
{
gErrorMsg = "Problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
//add the table values
int numFields = resultSF.NumFields;
for (int j = 0; j <= numFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, i)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
} //end of looping through table
} //end of checking for intersection
} //end of checking bounds
} //end of looping through shapes
if (resultSF.NumShapes > 0)
{
if (resultSF.NumFields == 0 || !SkipMWShapeID)
{
//add the ID field and values
if (Globals.DoInsertIDs(ref resultSF) == false)
{
return(false);
}
}
MapWinUtility.Logger.Dbg("Finished SelectPolygonsWithPolygon");
return(true);
}
else
{
MapWinUtility.Logger.Dbg("Finished SelectPolygonsWithPolygon");
return(false);
}
}
/// <summary>
/// This is used by the Identity process to export all shapes intesecting all polygons passed in.
/// Each identity polygon is used to select and clip input shapes. The new clipped shape is written
/// to the result shapefile. The attribute fields from both input and identity shapefiles are copied
/// to the result shapefile.
/// This process uses a QuadTree index to speed up the selection of overlapping geometries.
/// </summary>
/// <param name="inputSF">The shapefile, of any geometry type, to be clipped and exported.</param>
/// <param name="identitySF">The polygon shapefile used to clip the inputSF.</param>
/// <param name="resultSF">The result shapefile that will contain the results.</param>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool ExportShapesWithPolygons(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shapefile identitySF, ref MapWinGIS.Shapefile resultSF)
{
try
{
// Boundary intersection test variables
double xMin1, xMax1, yMin1, yMax1, zMin1, zMax1, xMin2, xMax2, yMin2, yMax2, zMin2, zMax2;
// Build Quadtree index for inputSF
MapWinGeoProc.NTS.Topology.Index.Quadtree.Quadtree myQuadTree = new MapWinGeoProc.NTS.Topology.Index.Quadtree.Quadtree();
MapWinGIS.Shape currGeom;
for (int i = 0; i < inputSF.NumShapes; i++)
{
currGeom = inputSF.get_Shape(i);
currGeom.Extents.GetBounds(out xMin1, out yMin1, out zMin1, out xMax1, out yMax1, out zMax1);
Envelope myItemEnv = new Envelope(xMin1, xMax1, yMin1, yMax1);
myQuadTree.Insert(myItemEnv, i);
}//end of looping through lines
// Copy inputSf and identitySF fields to resultSF, renaming duplicate fields
if (Globals.CopyFields(ref inputSF, ref resultSF) == false)
{
return(false);
}
if (Globals.CopyFields(ref identitySF, ref resultSF, true) == false)
{
return(false);
}
int resultNumFields = resultSF.NumFields;
int inputNumFields = inputSF.NumFields;
int identityNumFields = identitySF.NumFields;
int shpIndex = 0;
Envelope myQueryEnv = null;
Geometry queryPoly = null;
Geometry inputGeom = null;
IGeometry intersectGeom = null;
MapWinGIS.Shape identityShape = null;
MapWinGIS.Shape intersectShape = null;
IList results = null;
string progressmessage = "";
int inputShapesForIdentityShape = 0;
// Loop through identitySF and get inputSF geometries that intersect
for (int identityIndex = 0; identityIndex < identitySF.NumShapes; identityIndex++)
{
identityShape = identitySF.get_Shape(identityIndex);
queryPoly = NTS_Adapter.ShapeToGeometry(identityShape);
identityShape.Extents.GetBounds(out xMin2, out yMin2, out zMin2, out xMax2, out yMax2, out zMax2);
myQueryEnv = new Envelope(xMin2, xMax2, yMin2, yMax2);
//use quadtree index to find geometries that may intersect
results = myQuadTree.Query(myQueryEnv);
int intersectIndex = 0;
for (int i = 0; i < results.Count; i++)
{
intersectIndex = Convert.ToInt32(results[i]); // Get input id from quadtree results
currGeom = inputSF.get_Shape(intersectIndex); // Get input geometry
inputGeom = NTS_Adapter.ShapeToGeometry(currGeom); // Convert to NTS Geometry
for (int inputGoemIndex = 0; inputGoemIndex < inputGeom.NumGeometries; inputGoemIndex++) //use each part of the geometry
{
if (inputGeom.GetGeometryN(inputGoemIndex).Intersects(queryPoly)) // check for intersection
{
intersectGeom = MapWinGeoProc.NTS.Topology.Operation.Overlay.OverlayOp.Overlay(queryPoly, inputGeom.GetGeometryN(inputGoemIndex), MapWinGeoProc.NTS.Topology.Operation.Overlay.SpatialFunctions.Intersection); // create intersect geometry
if (!intersectGeom.IsEmpty)
{
for (int geomIndex = 0; geomIndex < intersectGeom.NumGeometries; geomIndex++) // process each part of intersect result
{
if (inputGeom.GetGeometryN(inputGoemIndex).GetType().Name == intersectGeom.GetGeometryN(geomIndex).GetType().Name) // only used geometries of the same type as the input.
{
// Write shape geometry
intersectShape = NTS_Adapter.GeometryToShape(intersectGeom.GetGeometryN(geomIndex));
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(intersectShape, ref shpIndex) == false)
{
gErrorMsg = string.Format("Problem inserting shape into result file: {0}, Input Id: {1}, IdentityId: {2}", resultSF.get_ErrorMsg(resultSF.LastErrorCode), intersectIndex, identityIndex);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
inputShapesForIdentityShape++;
intersectShape = null;
//add the table values from input SF
for (int j = 0; j <= inputNumFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, intersectIndex)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
}//end of looping through table
//add the table values from identity SF
for (int j = 0; j <= identityNumFields - 1; j++)
{
if (resultSF.EditCellValue(j + inputNumFields, shpIndex, identitySF.get_CellValue(j, identityIndex)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
return(false);
}
}//end of looping through table
}
}
}
}
}
inputGeom = null;
}
progressmessage = string.Format("{3}: Identity Index:{0}, Quadtree Results:{1}, Shapes added:{2}", identityIndex, results.Count, inputShapesForIdentityShape, DateTime.Now.ToShortTimeString());
results.Clear();
Debug.WriteLine(progressmessage);
inputShapesForIdentityShape = 0;
resultSF.StopEditingShapes(true, true, null);
resultSF.StartEditingShapes(true, null);
}
return(resultSF.NumShapes > 0);
}
catch (Exception E)
{
System.Windows.Forms.MessageBox.Show(E.ToString());
return(false);
}
}
/// <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));
}
}
private void Map(Round t)
{
AxMapWinGIS.AxMap map = new AxMapWinGIS.AxMap();
map.Width = 380;
map.Height = 380;
host.Child = map;
map.Show();
map.CreateControl();
map.ShowZoomBar = false;
map.ShowCoordinates = MapWinGIS.tkCoordinatesDisplay.cdmNone;
map.CursorMode = MapWinGIS.tkCursorMode.cmNone;
MapWinGIS.Shapefile shapeFileMap = new MapWinGIS.Shapefile();
shapeFileMap.Open(@"D:\Projets\TheManager\TheManager_GUI\bin\Debug\gis\world\World_Countries.shp", null);
map.AddLayer(shapeFileMap, true);
ILocalisation localisation = Session.Instance.Game.kernel.LocalisationTournament(t.Tournament);
double logoSize = 30.0;
if (localisation as Country != null)
{
map.ZoomToShape(0, (localisation as Country).ShapeNumber);
}
else
{
if (localisation.Name() == "Europe")
{
map.ZoomToShape(0, 68 /*12 101*/);
map.CurrentZoom = 4;
}
else if (localisation.Name() == "Africa")
{
map.ZoomToShape(0, 40);
map.CurrentZoom = 3;
}
logoSize = 15.0;
}
foreach (Club c in t.clubs)
{
CityClub cc = c as CityClub;
if (cc != null)
{
double projX = -1;
double projY = -1;
map.DegreesToProj(cc.city.Position.Longitude, cc.city.Position.Latitude, ref projX, ref projY);
MapWinGIS.Image img = new MapWinGIS.Image();
img.Open(Utils.Logo(c));
MapWinGIS.Shapefile sf = new MapWinGIS.Shapefile();
sf.CreateNew("", MapWinGIS.ShpfileType.SHP_POINT);
sf.DefaultDrawingOptions.AlignPictureByBottom = false;
sf.DefaultDrawingOptions.PointType = MapWinGIS.tkPointSymbolType.ptSymbolPicture;
sf.DefaultDrawingOptions.Picture = img;
sf.DefaultDrawingOptions.PictureScaleX = Math.Round(logoSize / img.OriginalWidth, 2);
sf.DefaultDrawingOptions.PictureScaleY = Math.Round(logoSize / img.OriginalHeight, 2);
sf.CollisionMode = MapWinGIS.tkCollisionMode.AllowCollisions;
MapWinGIS.Shape shp = new MapWinGIS.Shape();
shp.Create(MapWinGIS.ShpfileType.SHP_POINT);
shp.AddPoint(projX, projY);
sf.EditAddShape(shp);
map.AddLayer(sf, true);
}
}
if (_competition.rounds[_indexTour].clubs.Count > 0 && _competition.rounds[_indexTour].clubs[0] as NationalTeam != null)
{
shapeFileMap.StartEditingTable();
int fieldIndex = shapeFileMap.EditAddField("Qualification", MapWinGIS.FieldType.INTEGER_FIELD, 1, 1);
shapeFileMap.DefaultDrawingOptions.FillType = MapWinGIS.tkFillType.ftStandard;
for (int i = 0; i < shapeFileMap.NumShapes; i++)
{
shapeFileMap.EditCellValue(fieldIndex, i, 0);
}
Dictionary <NationalTeam, int> clubCourses = new Dictionary <NationalTeam, int>();
for (int i = 0; i < _competition.rounds.Count; i++)
{
Round round = _competition.rounds[i];
foreach (Club c in round.clubs)
{
NationalTeam nt = c as NationalTeam;
if (!clubCourses.ContainsKey(nt))
{
clubCourses.Add(nt, 1);
}
clubCourses[nt] = i + 1;
}
}
foreach (KeyValuePair <NationalTeam, int> kvp in clubCourses)
{
shapeFileMap.EditCellValue(fieldIndex, kvp.Key.country.ShapeNumber, kvp.Value);
}
shapeFileMap.Categories.Generate(fieldIndex, MapWinGIS.tkClassificationType.ctUniqueValues, _competition.rounds.Count + 1);
shapeFileMap.Categories.ApplyExpressions();
MapWinGIS.ColorScheme colorScheme = new MapWinGIS.ColorScheme();
colorScheme.SetColors2(MapWinGIS.tkMapColor.AliceBlue, MapWinGIS.tkMapColor.DarkBlue);
shapeFileMap.Categories.ApplyColorScheme(MapWinGIS.tkColorSchemeType.ctSchemeGraduated, colorScheme);
}
map.Redraw();
}
/// <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);
}
/// <summary>
/// Generalization of polyline
/// shapefiles using the Douglas-Peucker line simplification
/// algorithm. This method will output a line shapefile.
/// </summary>
/// <param name="inFileName">Input shapefile</param>
/// <param name="outFileName">Output shapefile</param>
/// <param name="tolerance">tolerance parameter -
/// specfies the maximum allowed distance between original polyline
/// and simplified polyline</param>
/// <param name="cback">Use this parameter for reporting progress. Set to null if not needed</param>
public static void Generalize(string inFileName, string outFileName, double tolerance, MapWinGIS.ICallback cback)
{
MapWinGIS.Shapefile oldSF = new MapWinGIS.Shapefile();
if (!oldSF.Open(inFileName, null))
{
throw new ArgumentException(string.Format("Shapefile {0} could not be opened. Error: {1}",
inFileName, oldSF.get_ErrorMsg(oldSF.LastErrorCode)));
}
//Check if it's a line shapefile
if (!(oldSF.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINE ||
oldSF.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEM ||
oldSF.ShapefileType == MapWinGIS.ShpfileType.SHP_POLYLINEZ))
{
throw new ArgumentException(string.Format("Shapefile {0} must be a polyline shapefile.", inFileName));
}
int numShapes = oldSF.NumShapes;
int numFields = oldSF.NumFields;
//create a new output shapefile
MapWinGIS.Shapefile newSF = new MapWinGIS.Shapefile();
MapWinGIS.ShpfileType sftype = MapWinGIS.ShpfileType.SHP_POLYLINE;
// if shapefile exists - open it and clear all shapes
if (System.IO.File.Exists(outFileName))
{
try
{
//TODO: ask for overwriting..
bool deleted = MapWinGeoProc.DataManagement.DeleteShapefile(ref outFileName);
}
finally
{
}
}
if (!newSF.CreateNew(outFileName, sftype))
{
throw new InvalidOperationException
("Error creating shapefile " + outFileName + " " + newSF.get_ErrorMsg(newSF.LastErrorCode));
}
newSF.StartEditingShapes(true, cback);
//Copy all fields
if (!Globals.CopyFields(ref oldSF, ref newSF))
{
throw new InvalidOperationException(string.Format("Error copying fields from {0} to {1}",
oldSF.Filename, newSF.Filename));
}
int newShapeIndex = 0;
for (int shpIdx = 0; shpIdx < numShapes; ++shpIdx)
{
MapWinGIS.Shape shp = oldSF.get_Shape(shpIdx);
// convert each part of the polyline shape to a 'geometry' object
Geometry geom = MapWinGeoProc.NTS_Adapter.ShapeToGeometry(shp);
for (int partIdx = 0; partIdx < geom.NumGeometries; ++partIdx)
{
Geometry geomPart = (Geometry)geom.GetGeometryN(partIdx);
//do the simplification
ICoordinate[] oldCoords = geomPart.Coordinates;
DouglasPeuckerLineSimplifier simplifier = new DouglasPeuckerLineSimplifier(oldCoords);
simplifier.DistanceTolerance = tolerance;
ICoordinate[] newCoords = simplifier.Simplify();
//convert the coordinates back to a geometry
Geometry newGeom = new LineString(newCoords);
//convert the geometry back to a shape
MapWinGIS.Shape newShape = MapWinGeoProc.NTS_Adapter.GeometryToShape(newGeom);
//add the shape to the new shapefile
newShapeIndex = newSF.NumShapes;
if (newSF.EditInsertShape(newShape, ref newShapeIndex) == false)
{
throw new InvalidOperationException("Error inserting shape: " +
newSF.get_ErrorMsg(newSF.LastErrorCode));
}
//add attribute values
for (int fldIdx = 0; fldIdx < numFields; ++fldIdx)
{
object val = oldSF.get_CellValue(fldIdx, shpIdx);
if (newSF.EditCellValue(fldIdx, newSF.NumShapes - 1, val) == false)
{
throw new InvalidOperationException("Error editing cell value: " +
newSF.get_ErrorMsg(newSF.LastErrorCode));
}
}
}
}
//close the old shapefile
oldSF.Close();
//stop editing and close the new shapefile
newSF.StopEditingShapes(true, true, cback);
newSF.Close();
}
