private static IFeatureLayer OpenLayerPackage(string pathToLPK)
{
ILayerFile layerFile = new LayerFileClass();
layerFile.Open(pathToLPK);
return(layerFile.Layer as IFeatureLayer);
}
public static ILayer CreateLayer(string pathLayerFile)
{
try
{
if (System.IO.File.Exists(pathLayerFile) == true)
{
ILayer layer;
ILayerFile layerFile = new LayerFileClass();
layerFile.Open(pathLayerFile);
layer = layerFile.Layer;
// System.Runtime.InteropServices.Marshal.ReleaseComObject(layerFile);
return(layer);
}
else
{
return(null);
}
}
catch (Exception ex)
{
Trace.WriteLine("Umbriel.ArcGIS.Layer.Util.LayerHelper.CreateLayer Exception: " + ex.Message + "\n\nStackTrace: " + ex.StackTrace);
throw;
}
}
//保存图层
private void ctMenuSaveAsLyr_Click(object sender, EventArgs e)
{
this.saveFileDialog.Title = "保存为Lyr文件";
this.saveFileDialog.Filter = "Lyr文件|*.lyr";
if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
{
string direction = System.IO.Path.GetDirectoryName(this.saveFileDialog.FileName);
string file = System.IO.Path.GetFileName(this.saveFileDialog.FileName);
ILayerFile pLayerFile = new LayerFileClass();
pLayerFile.New(this.saveFileDialog.FileName);
pLayerFile.ReplaceContents(this.TOCRightLayer);
pLayerFile.Save();
}
}
///<summary>Write a Layer to a file on disk.</summary>
///
///<param name="layerFilePath">A System.String that is the path and filename for the layer file to be created. Example: "C:\temp\cities.lyr"</param>
///<param name="layer">An ILayer interface.</param>
///
///<remarks></remarks>
public static void SaveToLayerFile(string layerFilePath, ILayer layer)
{
if (layer == null)
{
Log.Warning("No valid layer file was found. Save not completed.");
return;
}
//create a new LayerFile instance
ESRI.ArcGIS.Carto.ILayerFile layerFile = new LayerFileClass();
//make sure that the layer file name is valid
if (Path.GetExtension(layerFilePath) != ".lyr")
{
return;
}
if (layerFile.get_IsPresent(layerFilePath))
{
File.Delete(layerFilePath);
}
var fileInfo = new FileInfo(layerFilePath);
if (!fileInfo.Directory.Exists)
{
Log.Information("Creating output directory {OutputDirectory}.", fileInfo.Directory.FullName);
fileInfo.Directory.Create();
}
//create a new layer file
layerFile.New(layerFilePath);
//attach the layer file with the actual layer
layerFile.ReplaceContents(layer);
//save the layer file
layerFile.Save();
layerFile.Close();
Log.Information("Layer saved.");
// save output path so that the calling process can get it - useful when unique file name for output
string tempFile = Path.Combine(Path.GetTempPath(), "Chameleon.txt");
using (StreamWriter sw = new StreamWriter(tempFile))
{
sw.WriteLine(layerFilePath);
}
}
private static async Task <ILayer> InitLayerFileAsync(string file)
{
await EsriLicense.GetLicenseAsync();
var layerFile = new LayerFileClass();
var layer = await Task.Run(() =>
{
layerFile.Open(file);
var l = layerFile.Layer;
layerFile.Close();
return(l);
});
return(layer);
}
/// <summary>
/// Write the NALayer out to disk as a layer file.
/// </summary>
private void SaveLayerToDisk(ILayer layer, String path)
{
try
{
Console.WriteLine("Writing layer file containing analysis to " + path);
ILayerFile layerFile = new LayerFileClass();
layerFile.New(path);
layerFile.ReplaceContents(layer as ILayer);
layerFile.Save();
Console.WriteLine("Writing layer file successfully saved");
}
catch (Exception err)
{
// Write out errors
Console.WriteLine(err.Message);
}
}
private IFeatureLayer CreateFeatureLayer(esriGeometryType pesriGeometryType, string pstrLayerName,
List <string> pstrFieldNameLt = null, List <esriFieldType> pesriFieldTypeLt = null,
int intRed = _intColor, int intGreen = _intColor, int intBlue = _intColor, double dblWidth = 1,
int intOutlineRed = _intColor, int intOutlineGreen = _intColor, int intOutlineBlue = _intColor,
esriSimpleLineStyle pesriSimpleLineStyle = esriSimpleLineStyle.esriSLSSolid,
esriSimpleFillStyle pesriSimpleFillStyle = esriSimpleFillStyle.esriSFSSolid,
string strSymbolLayerPath = null, bool blnVisible = true)
{
var pWorkspace = CConstants.ParameterInitialize.pWorkspace;
var pm_mapControl = CConstants.ParameterInitialize.m_mapControl;
pstrLayerName += CHelpFunc.GetTimeStampWithPrefix();
IFeatureClass pFeatureClass = CreateFeatureClass(pesriGeometryType, pstrLayerName, pWorkspace, pm_mapControl,
pstrFieldNameLt, pesriFieldTypeLt);
IFeatureLayer pFLayer = new FeatureLayerClass();
pFLayer.FeatureClass = pFeatureClass;
pFLayer.Name = pFeatureClass.AliasName;
pFLayer.SpatialReference = pm_mapControl.SpatialReference;
RenderLayer(ref pFLayer, pesriGeometryType, intRed, intGreen, intBlue, dblWidth,
intOutlineRed, intOutlineGreen, intOutlineBlue, pesriSimpleLineStyle, pesriSimpleFillStyle, strSymbolLayerPath);
//save Layer as layer file ".lyr"
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(pWorkspace.PathName + "\\" + pstrLayerName + ".lyr");
//attach the layer file with the actual layer
layerFile.ReplaceContents((ILayer)pFLayer);
//save the layer file
layerFile.Save();
//***********************************************是否添加到当前文档中来***********************************************//
//m_mapControl.AddLayer(pFLayer,m_mapControl .LayerCount);
pm_mapControl.AddLayer(pFLayer);
pFLayer.Visible = blnVisible;
pm_mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
return(pFLayer);
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
// TODO: Add SaveLayerFile.OnClick implementation
ILayer layer = (ILayer)m_mapControl.CustomProperty;
//ask the user to set a name for the new layer file
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Layer File|*.lyr|All Files|*.*";
saveFileDialog.Title = "Create Layer File";
saveFileDialog.RestoreDirectory = true;
saveFileDialog.FileName = System.IO.Path.Combine(saveFileDialog.InitialDirectory, layer.Name + ".lyr");
//get the layer name from the user
DialogResult dr = saveFileDialog.ShowDialog();
if (saveFileDialog.FileName != "" && dr == DialogResult.OK)
{
if (System.IO.File.Exists(saveFileDialog.FileName))
{
//try to delete the existing file
System.IO.File.Delete(saveFileDialog.FileName);
}
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(saveFileDialog.FileName);
//attach the layer file with the actual layer
layerFile.ReplaceContents(layer);
//save the layer file
layerFile.Save();
//ask the user whether he'd like to add the layer to the map
if (DialogResult.Yes == MessageBox.Show("Would you like to add the layer to the map?", "Message", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
m_mapControl.AddLayerFromFile(saveFileDialog.FileName, 0);
}
}
}
private static void SaveLayerFile(string layerFilePath, ILayer layer)
{
ILayerFile layerFile = new LayerFileClass();
if (layerFile.IsPresent[layerFilePath])
{
//The user gave permission in the file save dialog to replace the existing file.
try
{
System.IO.File.Delete(layerFilePath);
}
catch (Exception ex)
{
Console.WriteLine("Unable to overwrite " + layerFilePath + Environment.NewLine + ex.Message);
Environment.Exit(4);
}
}
layerFile.New(layerFilePath);
layerFile.ReplaceContents(layer);
layerFile.Save();
}
private static INAContext GetContextFromLayer(string layerFileName)
{
ILayerFile layerFile = new LayerFileClass();
try
{
layerFile.Open(layerFileName);
}
catch (Exception e)
{
throw new InvalidOdLayerException($"Unable to open layer file: {layerFileName}. Make sure it exists and is valid. Try opening it in ArcMap.{Environment.NewLine}" +
$"Error type: {e.GetType()}{Environment.NewLine}" +
$"Error message: {e.Message}");
}
var naLayer = layerFile.Layer as INALayer;
if (naLayer == null)
{
throw new InvalidOdLayerException($"Unable to get INALayer from layer file: {layerFileName}. Is your layer a Network Analysis layer?");
}
var context = naLayer.Context;
if (context == null)
{
throw new InvalidOdLayerException($"Null context on layer file: {layerFileName}. Is your layer a valid Network Analysis layer?");
}
var odSolver = context.Solver as INAODCostMatrixSolver2;
if (odSolver == null)
{
throw new InvalidOdLayerException($"Input layer '{layerFileName}' must be an Origin-Destination Cost Matrix layer.");
}
return(context);
}
private void btnLoadlpk_Click(object sender, EventArgs e)
{
try
{
ILayerFile layerFile = new LayerFileClass();
// Test to see if we can connect to ArcGIS.com
if (IsConnected())
{
// If so, open the Layer Package from ArcGIS.com, this will get the most recent data.
// for the package. If there is no change, the data will not get re-downloaded,
// just use what is stored on disk.
layerFile.Open(txtLayerPackage.Text.ToString());
}
else
{
// If we cannot connect to ArcGIS.com use what was previously downloaded.
if (DoesPackageExist(PackageType.LayerPackage))
{
foreach (FileInfo layerpackage in layerFiles)
{
// Layer packages can have multiple layers included in them. However,
// the LayerFile and MapDocument classes will only get the first one.
// Here the sample is using an array so we can get all the layer files
// and not worry about the name.
layerFile.Open(layerpackage.FullName);
}
}
}
ILayer layer = layerFile.Layer;
axMapControl1.AddLayer(layer);
}
catch (Exception ex)
{
MessageBox.Show("Failed to open Layer Package!", ex.ToString(), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void btnLoadlpk_Click(object sender, EventArgs e)
{
try
{
ILayerFile layerFile = new LayerFileClass();
// Test to see if we can connect to ArcGIS.com
if (IsConnected())
{
// If so, open the Layer Package from ArcGIS.com, this will get the most recent data.
// for the package. If there is no change, the data will not get re-downloaded,
// just use what is stored on disk.
layerFile.Open(txtLayerPackage.Text.ToString());
}
else
{
// If we cannot connect to ArcGIS.com use what was previously downloaded.
if (DoesPackageExist(PackageType.LayerPackage))
{
foreach (FileInfo layerpackage in layerFiles)
{
// Layer packages can have multiple layers included in them. However,
// the LayerFile and MapDocument classes will only get the first one.
// Here the sample is using an array so we can get all the layer files
// and not worry about the name.
layerFile.Open(layerpackage.FullName);
}
}
}
ILayer layer = layerFile.Layer;
axMapControl1.AddLayer(layer);
}
catch (Exception ex)
{
MessageBox.Show("Failed to open Layer Package!", ex.ToString(), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
static void Main(string[] args)
{
//arg 0 = source layer string file gdb string with feature class name
//arg 1 = target layer path for fabric layer
//arg 2 = control point tolerance (in projection units) to match with existing fabric points, -1 means don't do it
//arg 3 = merge tolerance. Merge with existing control points if within tolerance, -1 means turn off merging
//arg 4 = control merging choices for attributes [KeepExistingAttributes | UpdateExistingAttributes]
//arg 5 = must have same name to merge if within the tolerance? [NamesMustMatchToMerge | IgnoreNames]
//arg 6 = if control is merged keep existing names or update with incoming names? [KeepExistingNames | UpdateExistingNames]
//.....(arg 6 is ignored if arg 5 = NamesMustMatchToMerge)
//arg 7 = control merging choices for coordinates [UpdateXY | UpdateXYZ | UpdateZ | KeepExistingXYZ]
//arg 8 = create a log file at the same location as the executable? [LoggingOn | LoggingOff]
//.....(a log file is always generated unless LoggingOff is explcitly used)
//ESRI License Initializer generated code.
m_AOLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeStandard, esriLicenseProductCode.esriLicenseProductCodeAdvanced },
new esriLicenseExtensionCode[] { });
//ESRI License Initializer generated code.
//Do not make any call to ArcObjects after ShutDownApplication()
int iLen = args.Length;
if (iLen < 2)
{
UsageMessage();
m_AOLicenseInitializer.ShutdownApplication();
return;
}
ITrackCancel pTrkCan = new CancelTrackerClass();
// Create and display the Progress Dialog
IProgressDialogFactory pProDlgFact = new ProgressDialogFactoryClass();
IProgressDialog2 pProDlg = pProDlgFact.Create(pTrkCan, 0) as IProgressDialog2;
try
{
ICadastralControlImporter pControlPointCadastralImp = new CadastralControlImporterClass();
// args[0] ============================================
string PathToFileGDBandFeatureClass = args[0];
if (args[0].Contains(":") && args[0].Contains("\\"))
{
PathToFileGDBandFeatureClass = args[0];
}
else
{
string[] sExecPathArr = System.Reflection.Assembly.GetEntryAssembly().Location.Split('\\');
string x = "";
for (int i = 0; i < (sExecPathArr.Length - 1); i++)
{
x += sExecPathArr[i] + "\\";
}
PathToFileGDBandFeatureClass = x + PathToFileGDBandFeatureClass;
}
string[] PathToFileGDBArray = PathToFileGDBandFeatureClass.Split('\\');
string NameOfSourceFeatureClass = PathToFileGDBArray[PathToFileGDBArray.Length - 1];
string PathToFileGDB = "";
for (int i = 0; i < (PathToFileGDBArray.Length - 1); i++)
{
PathToFileGDB += PathToFileGDBArray[i] + "\\";
}
PathToFileGDB = PathToFileGDB.TrimEnd('\\');
if (!System.IO.Directory.Exists(PathToFileGDB))
{
throw new Exception("File does not exist. [" + PathToFileGDB + "]");
}
// args[1] ============================================
string layerFilePathToFabric = args[1];
if (!(layerFilePathToFabric.Contains(":") && layerFilePathToFabric.Contains("\\")))
{
string[] sExecPathArr = System.Reflection.Assembly.GetEntryAssembly().Location.Split('\\');
string x = "";
for (int i = 0; i < (sExecPathArr.Length - 1); i++)
{
x += sExecPathArr[i] + "\\";
}
layerFilePathToFabric = x + layerFilePathToFabric;
}
if (!System.IO.File.Exists(layerFilePathToFabric))
{
throw new Exception("File does not exist. [" + layerFilePathToFabric + "]");
}
ILayerFile layerFileToTargetFabric = new LayerFileClass();
layerFileToTargetFabric.Open(layerFilePathToFabric);
ILayer pLayer = layerFileToTargetFabric.Layer;
ICadastralFabricLayer pParcelFabLyr = pLayer as ICadastralFabricLayer;
ICadastralFabric pParcelFabric = pParcelFabLyr.CadastralFabric;
IDataset pDS = pParcelFabric as IDataset;
IName pDSName = pDS.FullName;
ICadastralFabricName pCadastralFabricName = pDSName as ICadastralFabricName;
IWorkspaceFactory workspaceFactory = new FileGDBWorkspaceFactory();
IFeatureWorkspace pFWS = (IFeatureWorkspace)workspaceFactory.OpenFromFile(PathToFileGDB, 0);
pDS = (IDataset)pFWS.OpenFeatureClass(NameOfSourceFeatureClass);
IName pSourceFeatClassName = pDS.FullName;
// args[2] ============================================
bool bHasControlTolerance = iLen > 2;
double dControlToFabricPointMatchTolerance = -1;
if (bHasControlTolerance)
{
if (!Double.TryParse(args[2], out dControlToFabricPointMatchTolerance))
{
throw new Exception("The third parameter should be a numeric value. [" + args[2] + "]");
}
}
pControlPointCadastralImp.ControlPointTolerance = dControlToFabricPointMatchTolerance;
//'***** performance, -1 means that matching to existing fabric points is turned off
pControlPointCadastralImp.UseShapeField = true;
//============= Arguments for merging control points ===============
// args[3] [4] [5] [6] [7] ============================================
bool bIsMergingControlPoints = (iLen == 7);
if (bIsMergingControlPoints)
{
//arg 3 = merge tolerance. Merge with existing control points if within tolerance, -1 means turn off merging
//arg 4 = control merging choices for attributes [KeepExistingAttributes | UpdateExistingAttributes]
//arg 5 = must have same name to merge if within the tolerance? [NamesMustMatchToMerge | IgnoreNames]
//arg 6 = if control is merged keep existing names or update with incoming names? [KeepExistingNames | UpdateExistingNames]
//.....(arg 6 is ignored if arg 5 = NamesMustMatchToMerge)
//arg 7 = control merging choices for coordinates [UpdateXY | UpdateXYZ | UpdateZ | KeepExistingXYZ]
double dControlPointMergingTolerance = -1;
if (!Double.TryParse(args[3], out dControlPointMergingTolerance))
{
{ throw new Exception("The fourth parameter should be a numeric value. [" + args[3] + "]"); }
}
ICadastralControlImporterMerging pImpMerge = pControlPointCadastralImp as ICadastralControlImporterMerging;
pImpMerge.MergeCloseControl = dControlPointMergingTolerance > 0;
pImpMerge.CloseControlTolerance = dControlPointMergingTolerance;
if (args[4].ToLower().Contains("updateexistingattributes"))
{
pImpMerge.MergeAttributesOption = esriCFControlMergingAttributes.esriCFControlMergingUpdateAttributes;
}
else
{
pImpMerge.MergeAttributesOption = esriCFControlMergingAttributes.esriCFControlMergingKeepAttributes;
}
pImpMerge.MergeControlNameCaseSensitive = false;
pImpMerge.MergeControlSameName = args[5].ToLower().Contains("namesmustmatchtomerge");
if (args[6].ToLower().Contains("updateexistingnames") && !args[5].ToLower().Contains("namesmustmatchtomerge"))
{
pImpMerge.MergeNameOption = esriCFControlMergingName.esriCFControlMergingUpdateExistingNames;
}
else
{
pImpMerge.MergeNameOption = esriCFControlMergingName.esriCFControlMergingKeepExistingNames;
}
if (args[7].ToLower() == "updatexy")
{
pImpMerge.MergeCoordinateOption = esriCFControlMergingCoordinate.esriCFControlMergingUpdateXY;
}
else if (args[7].ToLower() == "updatexyz")
{
pImpMerge.MergeCoordinateOption = esriCFControlMergingCoordinate.esriCFControlMergingUpdateXYZ;
}
else if (args[7].ToLower() == "updatez")
{
pImpMerge.MergeCoordinateOption = esriCFControlMergingCoordinate.esriCFControlMergingUpdateZ;
}
else if (args[7].ToLower() == "keepexistingxyz")
{
pImpMerge.MergeCoordinateOption = esriCFControlMergingCoordinate.esriCFControlMergingKeepExistingCoordinates;
}
}
ICadastralImporter pControlImporter = (ICadastralImporter)pControlPointCadastralImp;
bool bHasExplicitLogFileParameter = (iLen > 8);
bool bExplicitTurnLoggingOff = false;
/// Argument for logging importer results
//arg 8 = create a log file at the same location as the executable? [LoggingOn | LoggingOff | <path to logfile>]
//.....(a log file is always generated unless LoggingOff is explcitly used)
string sLogFilePath = "LogControlImport";
if (bHasExplicitLogFileParameter)
{
if (args[8].ToLower() == "loggingoff")
{
bExplicitTurnLoggingOff = true;
}
if (args[8].ToLower() != "loggingon" && !bExplicitTurnLoggingOff)
{
if (args[8].Contains(":") && args[8].Contains("\\")) //if (args[8].ToLower() != "loggingon")
{
sLogFilePath = args[8];
}
else
{
string[] sExecPathArr = System.Reflection.Assembly.GetEntryAssembly().Location.Split('\\');
string x = "";
for (int i = 0; i < (sExecPathArr.Length - 1); i++)
{
x += sExecPathArr[i] + "\\";
}
sLogFilePath = x + args[8];
}
}
}
else
{
string[] sExecPathArr = System.Reflection.Assembly.GetEntryAssembly().Location.Split('\\');
string x = "";
for (int i = 0; i < (sExecPathArr.Length - 1); i++)
{
x += sExecPathArr[i] + "\\";
}
sLogFilePath = x + sLogFilePath;
}
sLogFilePath += ".log";
if (!bExplicitTurnLoggingOff)
{
pControlImporter.OutputLogfile = sLogFilePath; //default location is same as executable
}
//Set the properties of the Progress Dialog
pProDlg.CancelEnabled = false;
pProDlg.Description = "Importing Control Point data ...";
pProDlg.Title = "Importing Control Points";
pProDlg.Animation = esriProgressAnimationTypes.esriProgressGlobe;
Console.WriteLine("Starting data load...");
pControlImporter.Import(pSourceFeatClassName, pCadastralFabricName, pTrkCan); //BUG fails if the TrackCancel is null
Console.WriteLine("Finished data load...");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
//UsageMessage();
}
finally
{
if (pProDlg != null)
{
pProDlg.HideDialog();
}
m_AOLicenseInitializer.ShutdownApplication();
}
}
private void ClipArea(ILayer pLayer,int index)
{
ISpatialFilter pFilter = new SpatialFilterClass();
pFilter.Geometry = m_Geometry;
pFilter.GeometryField = "SHAPE";
pFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureClass pFlnClass;
// IFields plnFCFields;
IFeatureCursor plnCursor;
IFeature pFeature;
IFeatureClass pFOutClass;
IFeatureCursor pOutCur;
//IFeatureCursor pOutFeatureCur;
IFeatureBuffer pOutBuff;
IFeature pOutFeature;
//裁剪
ITopologicalOperator pTopo;
//int indexl;
// int i;
IGeometry pGeom;
IFields plnFields;
if (pLayer is IFeatureLayer)
{
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
pFlnClass = pFeatureLayer.FeatureClass;
plnCursor = pFlnClass.Search(pFilter, false);
plnFields = pFlnClass.Fields;
IFeatureLayer pNewFeatrueLayer = null;
try
{
pNewFeatrueLayer = CreateFeatureLayerInmemeory(pLayer.Name, pLayer .Name +index .ToString (),m_hookHelper .FocusMap .SpatialReference , pFlnClass.ShapeType, plnFields);
}
catch(Exception ee)
{
MessageBox.Show(ee.ToString());
}
pFOutClass = pNewFeatrueLayer.FeatureClass;
pFeature = plnCursor.NextFeature();
while (pFeature != null)
{
pOutCur = pFOutClass.Insert(true);
pOutBuff = pFOutClass.CreateFeatureBuffer();
pOutFeature = pOutBuff as IFeature;
// indexl = pFeature.Fields.FindField("Shape");
pTopo = pFeature.Shape as ITopologicalOperator;//这里判断一下该地物几何类型
pGeom = pFeature.Shape;
if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry0Dimension); //这里的第二个参数就是区分点、线、面的
}
else if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry1Dimension);
}
else if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry2Dimension);
}
pOutFeature.Shape = pGeom;
CopyAttributes(pFeature, pOutFeature);
pOutCur.InsertFeature(pOutBuff);
pNewFeatrueLayer.FeatureClass = pFOutClass;
///////////////////////////////////
string FilePath = @"C:\任意打印\";
ILayerFile layerFile = new LayerFileClass();
layerFile.New(FilePath + pLayer .Name+ ".lyr");
layerFile.ReplaceContents(pNewFeatrueLayer as ILayer);
layerFile.Save();
/////////////////////////////////
try
{
m_ClipMap.AddLayer(layerFile.Layer );
}
catch (Exception ee)
{
MessageBox.Show(ee.ToString());
}
pFeature = plnCursor.NextFeature();
}
}
else if (pLayer is IRasterLayer)
{
}
}
//保存图层
private void ctMenuSaveAsLyr_Click(object sender, EventArgs e)
{
this.saveFileDialog.Title = "保存为Lyr文件";
this.saveFileDialog.Filter = "Lyr文件|*.lyr";
if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
{
string direction = System.IO.Path.GetDirectoryName(this.saveFileDialog.FileName);
string file = System.IO.Path.GetFileName(this.saveFileDialog.FileName);
ILayerFile pLayerFile = new LayerFileClass();
pLayerFile.New(this.saveFileDialog.FileName);
pLayerFile.ReplaceContents(this.TOCRightLayer);
pLayerFile.Save();
}
}
public string[] getQueryValueOptions_withSuffix(string queryType, string fileSuffix)
{
ESRI.ArcGIS.Carto.ILayerFile layerFile = new LayerFileClass();
//layerFile.Open("\\\\tornado\\Research3\\Tony\\Wetlands\\wetlands10.1\\10.0\\" + queryType + "_Poly.lyr");
layerFile.Open(GetAssemblyPath() + "\\Symbology\\LLWWW_" + queryType + "_Polygon" + fileSuffix + ".lyr");
IGeoFeatureLayer igfl_lyr = (IGeoFeatureLayer)layerFile.Layer;
iuvr = (IUniqueValueRenderer)igfl_lyr.Renderer;
string[] s = new string[iuvr.ValueCount];
for (int j = 0; j < iuvr.ValueCount; j++)
{
s[j] = iuvr.Label[iuvr.Value[j]] + " (" + iuvr.Value[j] + ")";
}
return s;
}
public virtual string[] getQueryValueOptions(string fieldname, string filename)
{
ESRI.ArcGIS.Carto.ILayerFile layerFile = new LayerFileClass();
//layerFile.Open("\\\\tornado\\Research3\\Tony\\Wetlands\\wetlands10.1\\10.0\\" + queryType + "_Poly.lyr");
layerFile.Open(GetAssemblyPath() + "\\Symbology\\" + filename + ".lyr");
IGeoFeatureLayer igfl_lyr = (IGeoFeatureLayer)layerFile.Layer;
IUniqueValueRenderer iuvr = (IUniqueValueRenderer)igfl_lyr.Renderer;
fields = new string[]{ fieldname };
if (iuvr.FieldCount == 1)
{
string[] s = new string[iuvr.ValueCount];
for (int j = 0; j < iuvr.ValueCount; j++)
{
s[j] = iuvr.Label[iuvr.Value[j]] + " (" + iuvr.Value[j] + ")";
}
return s;
}
else
{
string[] s = new string[iuvr.ValueCount];
string WhereClause = "";
char[] delimiter = { iuvr.FieldDelimiter[0] };
string prefix = ""; //sql.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string suffix = ""; //'sql.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
List<string> l = new List<string>();
for (int j = 0; j < iuvr.ValueCount; j++ )
{
string[] currValues = iuvr.Value[j].Split(delimiter);
s[j] = iuvr.Label[iuvr.Value[j]] + "( " + string.Join(";", currValues) + " )";
}
for (int k = 0; k < iuvr.FieldCount; k++)
{
l.Add(iuvr.Field[k]);
}
fields = l.ToArray();
#if false
for (int j = 0; j < iuvr.ValueCount; j++)
{
WhereClause = "";
string[] currValues = iuvr.Value[j].Split(delimiter);
for (int k = 0; k < currValues.Length; k++)
{
if (k > 0)
WhereClause += " AND ";
WhereClause += prefix + iuvr.Field[k] + suffix + " = '" + currValues[k].Trim() + "'";
}
s[j] = iuvr.Label[iuvr.Value[j]] + " (" + WhereClause + ")";
}
#endif
return s;
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
// find feature class inside the given feature dataset
IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter;
IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset;
string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt";
string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln";
string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply";
IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString);
IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString);
IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString);
// open the specified layers holding the symbology and editing templates
IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter);
IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter;
IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter);
bool isLayerOnDisk = false;
// create a clone of the source layer
// we will then go ahead and adjust the data source (dataset) of the cloned layer
IObjectCopy objectCopy = new ObjectCopyClass();
ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer;
IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer;
ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer;
//ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer;
//IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer;
//IClone cloneSource = osmPointGroupTemplateLayer as IClone;
//ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPointLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
IFeatureLayerDefinition2 featureLayerDefinition2 = null;
ISQLSyntax sqlSyntax = null;
IGPLayer adjustedPointGPLayer = null;
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer != null)
{
if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
}
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile pointLayerFile = new LayerFileClass();
if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPointLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120041, ex.Message);
return;
}
}
pointLayerFile.New(outputPointLayerGPValue.GetAsText());
pointLayerFile.ReplaceContents((ILayer)compositeLayer);
pointLayerFile.Save();
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer);
}
// IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue;
IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter;
IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter);
IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue;
IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPLineLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (string.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile lineLayerFile = new LayerFileClass();
if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputLineLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120042, ex.Message);
return;
}
}
lineLayerFile.New(outputLineLayerGPValue.GetAsText());
lineLayerFile.ReplaceContents((ILayer)compositeLayer);
lineLayerFile.Save();
}
IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter);
IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter;
IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter);
IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue;
IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPolygonLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile polygonLayerFile = new LayerFileClass();
if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPolygonLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120043, ex.Message);
return;
}
}
polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText());
polygonLayerFile.ReplaceContents((ILayer)compositeLayer);
polygonLayerFile.Save();
}
IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter);
}
}
catch (Exception ex)
{
message.AddError(-10, ex.Message);
}
}
private static void SaveLayerFile(string layerFilePath, ILayer layer)
{
ILayerFile layerFile = new LayerFileClass();
if (layerFile.IsPresent[layerFilePath])
{
//The user gave permission in the file save dialog to replace the existing file.
try
{
System.IO.File.Delete(layerFilePath);
}
catch (Exception ex)
{
Console.WriteLine("Unable to overwrite " + layerFilePath + Environment.NewLine + ex.Message);
Environment.Exit(4);
}
}
layerFile.New(layerFilePath);
layerFile.ReplaceContents(layer);
layerFile.Save();
}
private void ClipArea(ILayer pLayer, int index)
{
ISpatialFilter pFilter = new SpatialFilterClass();
pFilter.Geometry = m_Geometry;
pFilter.GeometryField = "SHAPE";
pFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureClass pFlnClass;
// IFields plnFCFields;
IFeatureCursor plnCursor;
IFeature pFeature;
IFeatureClass pFOutClass;
IFeatureCursor pOutCur;
//IFeatureCursor pOutFeatureCur;
IFeatureBuffer pOutBuff;
IFeature pOutFeature;
//裁剪
ITopologicalOperator pTopo;
//int indexl;
// int i;
IGeometry pGeom;
IFields plnFields;
if (pLayer is IFeatureLayer)
{
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
pFlnClass = pFeatureLayer.FeatureClass;
plnCursor = pFlnClass.Search(pFilter, false);
plnFields = pFlnClass.Fields;
IFeatureLayer pNewFeatrueLayer = null;
try
{
pNewFeatrueLayer = CreateFeatureLayerInmemeory(pLayer.Name, pLayer.Name + index.ToString(), m_hookHelper.FocusMap.SpatialReference, pFlnClass.ShapeType, plnFields);
}
catch (Exception ee)
{
MessageBox.Show(ee.ToString());
}
pFOutClass = pNewFeatrueLayer.FeatureClass;
pFeature = plnCursor.NextFeature();
while (pFeature != null)
{
pOutCur = pFOutClass.Insert(true);
pOutBuff = pFOutClass.CreateFeatureBuffer();
pOutFeature = pOutBuff as IFeature;
// indexl = pFeature.Fields.FindField("Shape");
pTopo = pFeature.Shape as ITopologicalOperator;//这里判断一下该地物几何类型
pGeom = pFeature.Shape;
if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry0Dimension); //这里的第二个参数就是区分点、线、面的
}
else if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry1Dimension);
}
else if (pFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
pGeom = pTopo.Intersect(m_Geometry, esriGeometryDimension.esriGeometry2Dimension);
}
pOutFeature.Shape = pGeom;
CopyAttributes(pFeature, pOutFeature);
pOutCur.InsertFeature(pOutBuff);
pNewFeatrueLayer.FeatureClass = pFOutClass;
///////////////////////////////////
string FilePath = @"C:\任意打印\";
ILayerFile layerFile = new LayerFileClass();
layerFile.New(FilePath + pLayer.Name + ".lyr");
layerFile.ReplaceContents(pNewFeatrueLayer as ILayer);
layerFile.Save();
/////////////////////////////////
try
{
m_ClipMap.AddLayer(layerFile.Layer);
}
catch (Exception ee)
{
MessageBox.Show(ee.ToString());
}
pFeature = plnCursor.NextFeature();
}
}
else if (pLayer is IRasterLayer)
{
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPValue inputLayersGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_LayersNumber));
IGPMultiValue inputLayersMultiValue = gpUtilities3.UnpackGPValue(inputLayersGPValue) as IGPMultiValue;
IGPParameter outputGroupLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter;
IGPValue outputGPGroupLayer = gpUtilities3.UnpackGPValue(outputGroupLayerParameter);
IGPCompositeLayer outputCompositeLayer = outputGPGroupLayer as IGPCompositeLayer;
if (outputCompositeLayer == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), outputGroupLayerParameter.Name));
return;
}
IGroupLayer groupLayer = null;
// find the last position of the "\" string
// in case we find such a thing, i.e. position is >= -1 then let's assume that we are dealing with a layer file on disk
// otherwise let's create a new group layer instance
string outputGPLayerNameAsString = outputGPGroupLayer.GetAsText();
int separatorPosition = outputGPLayerNameAsString.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
string layerName = String.Empty;
if (separatorPosition > -1)
{
layerName = outputGPGroupLayer.GetAsText().Substring(separatorPosition + 1);
}
else
{
layerName = outputGPGroupLayer.GetAsText();
}
ILayer foundLayer = null;
IGPLayer existingGPLayer = gpUtilities3.FindMapLayer2(layerName, out foundLayer);
if (foundLayer != null)
{
gpUtilities3.RemoveFromMapEx((IGPValue)existingGPLayer);
gpUtilities3.RemoveInternalLayerEx(foundLayer);
}
groupLayer = new GroupLayer();
((ILayer)groupLayer).Name = layerName;
for (int layerIndex = 0; layerIndex < inputLayersMultiValue.Count; layerIndex++)
{
IGPValue gpLayerToAdd = inputLayersMultiValue.get_Value(layerIndex) as IGPValue;
ILayer sourceLayer = gpUtilities3.DecodeLayer(gpLayerToAdd);
groupLayer.Add(sourceLayer);
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(groupLayer);
if (separatorPosition > -1)
{
try
{
// in the case that we are dealing with a layer file on disk
// let's persist the group layer information into the file
ILayerFile pointLayerFile = new LayerFileClass();
if (System.IO.Path.GetExtension(outputGPLayerNameAsString).ToUpper().Equals(".LYR"))
{
if (pointLayerFile.get_IsPresent(outputGPLayerNameAsString))
{
try
{
gpUtilities3.Delete(outputGPGroupLayer);
}
catch (Exception ex)
{
message.AddError(120001, ex.Message);
return;
}
}
pointLayerFile.New(outputGPLayerNameAsString);
pointLayerFile.ReplaceContents(groupLayer);
pointLayerFile.Save();
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(pointLayerFile.Layer);
}
catch (Exception ex)
{
message.AddError(120002, ex.Message);
return;
}
}
gpUtilities3.PackGPValue(outputGPGroupLayer, outputGroupLayerParameter);
}
catch (Exception ex)
{
message.AddError(120049, ex.Message);
}
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
if (m_hookHelper != null)
{
//TODO: Add Map/PageLayout related logic
object hook;
if (m_hookHelper.Hook is IToolbarControl2)
hook = ((IToolbarControl2)m_hookHelper.Hook).Buddy;
else
hook = m_hookHelper.Hook;
IMapControl3 mapControl = hook as IMapControl3;
if (mapControl == null)
return;
object customeProperty = mapControl.CustomProperty;
if (customeProperty == null || !(customeProperty is ILayer))
return;
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Layer File|*.lyr|All Files|*.*";
saveFileDialog.Title = "Create Layer File";
saveFileDialog.RestoreDirectory = true;
saveFileDialog.FileName = System.IO.Path.Combine(saveFileDialog.InitialDirectory, ((ILayer)customeProperty).Name + ".lyr");
DialogResult dr = saveFileDialog.ShowDialog();
if (saveFileDialog.FileName != "" && dr == DialogResult.OK)
{
if (System.IO.File.Exists(saveFileDialog.FileName))
{
//try to delete the existing file
System.IO.File.Delete(saveFileDialog.FileName);
}
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(saveFileDialog.FileName);
//attach the layer file with the actual layer
layerFile.ReplaceContents((ILayer)customeProperty);
//save the layer file
layerFile.Save();
//ask the user whether he'd like to add the layer to the map
if (DialogResult.Yes == MessageBox.Show("Would you like to add the layer to the map?", "Message", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
mapControl.AddLayerFromFile(saveFileDialog.FileName, 0);
}
}
}
else if (m_sceneHookHelper != null)
{
//TODO: Add Scene related logic
}
else if (m_globeHookHelper != null)
{
//TODO: Add Globe related logic
}
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
// find feature class inside the given feature dataset
IGPParameter osmFeatureDatasetParameter = paramvalues.get_Element(in_osmFeatureDatasetNumber) as IGPParameter;
IDEFeatureDataset osmFeatureDataset = gpUtilities3.UnpackGPValue(osmFeatureDatasetParameter) as IDEFeatureDataset;
string osmPointFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_pt";
string osmLineFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ln";
string osmPolygonFeatureClassString = ((IDataElement)osmFeatureDataset).Name + "_osm_ply";
IFeatureClass osmPointFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPointFeatureClassString);
IFeatureClass osmLineFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmLineFeatureClassString);
IFeatureClass osmPoylgonFeatureClass = gpUtilities3.OpenFeatureClassFromString(((IDataElement)osmFeatureDataset).CatalogPath + "/" + osmPolygonFeatureClassString);
// open the specified layers holding the symbology and editing templates
IGPParameter osmPointSymbolTemplateParameter = paramvalues.get_Element(in_osmPointLayerNumber) as IGPParameter;
IGPValue osmGPPointLayerValue = gpUtilities3.UnpackGPValue(osmPointSymbolTemplateParameter);
IGPParameter outputPointGPParameter = paramvalues.get_Element(out_osmPointLayerNumber) as IGPParameter;
IGPValue outputPointLayerGPValue = gpUtilities3.UnpackGPValue(outputPointGPParameter);
bool isLayerOnDisk = false;
// create a clone of the source layer
// we will then go ahead and adjust the data source (dataset) of the cloned layer
IObjectCopy objectCopy = new ObjectCopyClass();
ICompositeLayer adjustedPointTemplateLayer = objectCopy.Copy(osmGPPointLayerValue) as ICompositeLayer;
IGPGroupLayer osmPointGroupTemplateLayer = adjustedPointTemplateLayer as IGPGroupLayer;
ICompositeLayer compositeLayer = gpUtilities3.Open((IGPValue)osmPointGroupTemplateLayer) as ICompositeLayer;
//ICompositeLayer adjustedPointTemplateLayer = osmGPPointLayerValue as ICompositeLayer;
//IGPGroupLayer osmPointGroupTemplateLayer = osmGPPointLayerValue as IGPGroupLayer;
//IClone cloneSource = osmPointGroupTemplateLayer as IClone;
//ICompositeLayer compositeLayer = m_gpUtilities3.Open((IGPValue)cloneSource.Clone()) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPointLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
IFeatureLayerDefinition2 featureLayerDefinition2 = null;
ISQLSyntax sqlSyntax = null;
IGPLayer adjustedPointGPLayer = null;
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer != null)
{
if (geoFeatureLayer.ShapeType == osmPointFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPointFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPointFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPointFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
}
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile pointLayerFile = new LayerFileClass();
if (pointLayerFile.get_IsPresent(outputPointLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPointLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120041,ex.Message);
return;
}
}
pointLayerFile.New(outputPointLayerGPValue.GetAsText());
pointLayerFile.ReplaceContents((ILayer)compositeLayer);
pointLayerFile.Save();
adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)pointLayerFile.Layer);
}
// IGPLayer adjustedPointGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPointGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPointGPLayer, outputPointGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmLineSymbolTemplateParameter = paramvalues.get_Element(in_osmLineLayerNumber) as IGPParameter;
IGPValue osmGPLineLayerValue = gpUtilities3.UnpackGPValue(osmLineSymbolTemplateParameter) as IGPValue;
IGPParameter outputLineGPParameter = paramvalues.get_Element(out_osmLineLayerNumber) as IGPParameter;
IGPValue outputLineLayerGPValue = gpUtilities3.UnpackGPValue(outputLineGPParameter);
IGPValue adjustedLineTemplateLayer = objectCopy.Copy(osmGPLineLayerValue) as IGPValue;
IGPGroupLayer osmLineGroupTemplateLayer = adjustedLineTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmLineGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPLineLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmLineFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmLineFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmLineFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmLineFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (string.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile lineLayerFile = new LayerFileClass();
if (lineLayerFile.get_IsPresent(outputLineLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputLineLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120042, ex.Message);
return;
}
}
lineLayerFile.New(outputLineLayerGPValue.GetAsText());
lineLayerFile.ReplaceContents((ILayer)compositeLayer);
lineLayerFile.Save();
}
IGPLayer adjustLineGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustLineGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustLineGPLayer, outputLineGPParameter);
}
isLayerOnDisk = false;
IGPParameter osmPolygonSymbolTemplateParameter = paramvalues.get_Element(in_osmPolygonLayerNumber) as IGPParameter;
IGPValue osmGPPolygonLayerValue = gpUtilities3.UnpackGPValue(osmPolygonSymbolTemplateParameter);
IGPParameter outputPolygonGPParameter = paramvalues.get_Element(out_osmPolygonLayerNumber) as IGPParameter;
IGPValue outputPolygonLayerGPValue = gpUtilities3.UnpackGPValue(outputPolygonGPParameter);
IGPValue adjustedPolygonTemplateLayer = objectCopy.Copy(osmGPPolygonLayerValue) as IGPValue;
IGPGroupLayer osmPolygonGroupTemplateLayer = adjustedPolygonTemplateLayer as IGPGroupLayer;
compositeLayer = gpUtilities3.Open((IGPValue)osmPolygonGroupTemplateLayer) as ICompositeLayer;
if (compositeLayer == null)
{
ILayerFactoryHelper layerFactoryHelper = new LayerFactoryHelperClass();
IFileName layerFileName = new FileNameClass();
layerFileName.Path = osmGPPolygonLayerValue.GetAsText();
IEnumLayer enumLayer = layerFactoryHelper.CreateLayersFromName((IName)layerFileName);
enumLayer.Reset();
compositeLayer = enumLayer.Next() as ICompositeLayer;
isLayerOnDisk = true;
}
if (compositeLayer != null)
{
for (int layerIndex = 0; layerIndex < compositeLayer.Count; layerIndex++)
{
IFeatureLayer2 geoFeatureLayer = compositeLayer.get_Layer(layerIndex) as IFeatureLayer2;
if (geoFeatureLayer.ShapeType == osmPoylgonFeatureClass.ShapeType)
{
try
{
((IDataLayer2)geoFeatureLayer).Disconnect();
}
catch { }
((IDataLayer2)geoFeatureLayer).DataSourceName = ((IDataset)osmPoylgonFeatureClass).FullName;
((IDataLayer2)geoFeatureLayer).Connect(((IDataset)osmPoylgonFeatureClass).FullName);
featureLayerDefinition2 = geoFeatureLayer as IFeatureLayerDefinition2;
if (featureLayerDefinition2 != null)
{
string queryDefinition = featureLayerDefinition2.DefinitionExpression;
sqlSyntax = ((IDataset)osmPoylgonFeatureClass).Workspace as ISQLSyntax;
string delimiterIdentifier = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
if (String.IsNullOrEmpty(queryDefinition) == false)
{
string stringToReplace = queryDefinition.Substring(0, 1);
queryDefinition = queryDefinition.Replace(stringToReplace, delimiterIdentifier);
}
featureLayerDefinition2.DefinitionExpression = queryDefinition;
}
}
}
// save the newly adjusted layer information to disk
if (isLayerOnDisk == true)
{
ILayerFile polygonLayerFile = new LayerFileClass();
if (polygonLayerFile.get_IsPresent(outputPolygonLayerGPValue.GetAsText()))
{
try
{
File.Delete(outputPolygonLayerGPValue.GetAsText());
}
catch (Exception ex)
{
message.AddError(120043, ex.Message);
return;
}
}
polygonLayerFile.New(outputPolygonLayerGPValue.GetAsText());
polygonLayerFile.ReplaceContents((ILayer)compositeLayer);
polygonLayerFile.Save();
}
IGPLayer adjustedPolygonGPLayer = gpUtilities3.MakeGPLayerFromLayer((ILayer)compositeLayer);
gpUtilities3.AddInternalLayer2((ILayer)compositeLayer, adjustedPolygonGPLayer);
gpUtilities3.PackGPValue((IGPValue)adjustedPolygonGPLayer, outputPolygonGPParameter);
}
}
catch (Exception ex)
{
message.AddError(-10,ex.Message);
}
}
void Button_Click(object sender, EventArgs e)
{
#region 识别
if ((Button)sender == btn_Identify)
{
m_isIdentify = !m_isIdentify;
if (m_isIdentify)
{
m_isDraw = false;
m_isAddpoint = false;
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerIdentify;
}
else
{
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerArrow;
}
return;
}
#endregion
#region 择
if ((Button)sender == btn_select)
{
m_isDraw = !m_isDraw;
if (m_isDraw)
{
m_isIdentify = false;
m_isAddpoint = false;
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerCrosshair;
}
else
{
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerArrow;
}
return;
}
#endregion
#region 链接
if ((Button)sender == btn_link)
{
;
Geoprocessor gp = new Geoprocessor()
{
OverwriteOutput = true
};
string table = debugDir + "\\AirQuality\\kqzlzk.dbf";
ESRI.ArcGIS.ConversionTools.ExcelToTable pExcelToTavle = new ESRI.ArcGIS.ConversionTools.ExcelToTable()
{
Input_Excel_File = debugDir + "\\AirQuality\\空气质量状况.xls",
Output_Table = table,
Sheet = "Sheet1"
};
gp.Execute(pExcelToTavle, null);
IFeatureLayer pFeatureLayer = AeUtils.GetFeatureLayerByName(m_pMapC2.Map, "监测站");
ESRI.ArcGIS.DataManagementTools.JoinField pJoinField = new ESRI.ArcGIS.DataManagementTools.JoinField()
{
in_data = pFeatureLayer,
in_field = "Name",
join_table = table,
join_field = "NAME",
fields = "StationID;PM2_5;SO2;NO2"
};
gp.Execute(pJoinField, null);
}
#endregion
#region 注记
if ((Button)sender == btn_anno)
{
IFeatureLayer pFeatureLayer = AeUtils.GetFeatureLayerByName(m_pMapC2.Map, "北京区县界");
AeUtils.TextElementLabel(m_pMapC2, pFeatureLayer, "NAME");
}
#endregion
#region 符号化
if ((Button)sender == btn_symbol)
{
IFeatureLayer pFeatureLayer = AeUtils.GetFeatureLayerByName(m_pMapC2.Map, "北京区县界");
AeUtils.UniqueValueRenderer(pFeatureLayer, "NAME", m_pMapC2, axTOCControl_main);
}
#endregion
#region 保存图层
if ((Button)sender == btn_outlyr)
{
IFeatureLayer pFeatureLayer = AeUtils.GetFeatureLayerByName(m_pMapC2.Map, "北京区县界");
SaveFileDialog sfg = new SaveFileDialog()
{
Title = "保存图层",
Filter = "图层文件 (*.lyr)|*.lyr"
};
if (sfg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
ILayerFile layerfile = new LayerFileClass();
layerfile.New(sfg.FileName);
layerfile.ReplaceContents(pFeatureLayer);
layerfile.Save();
}
}
#endregion
if ((Button)sender == btn_addpt)
{
m_isAddpoint = !m_isAddpoint;
if (m_isAddpoint)
{
m_isDraw = false;
m_isIdentify = false;
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerCrosshair;
}
else
{
m_pMapC2.MousePointer = esriControlsMousePointer.esriPointerArrow;
}
}
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
//need to get the layer from the custom-property of the map
if (null == m_hookHelper)
{
return;
}
//get the mapControl hook
object hook = null;
if (m_hookHelper.Hook is IToolbarControl2)
{
hook = ((IToolbarControl2)m_hookHelper.Hook).Buddy;
}
else
{
hook = m_hookHelper.Hook;
}
//get the custom property from which is supposed to be the layer to be saved
object customProperty = null;
IMapControl3 mapControl = null;
if (hook is IMapControl3)
{
mapControl = (IMapControl3)hook;
customProperty = mapControl.CustomProperty;
}
else
{
return;
}
if (null == customProperty || !(customProperty is ILayer))
{
return;
}
//ask the user to set a name for the new layer file
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Layer File|*.lyr|All Files|*.*";
saveFileDialog.Title = "Create Layer File";
saveFileDialog.RestoreDirectory = true;
saveFileDialog.FileName = System.IO.Path.Combine(saveFileDialog.InitialDirectory, ((ILayer)customProperty).Name + ".lyr");
//get the layer name from the user
DialogResult dr = saveFileDialog.ShowDialog();
if (saveFileDialog.FileName != "" && dr == DialogResult.OK)
{
if (System.IO.File.Exists(saveFileDialog.FileName))
{
//try to delete the existing file
System.IO.File.Delete(saveFileDialog.FileName);
}
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(saveFileDialog.FileName);
//attach the layer file with the actual layer
layerFile.ReplaceContents((ILayer)customProperty);
//save the layer file
layerFile.Save();
//ask the user whether he'd like to add the layer to the map
if (DialogResult.Yes == MessageBox.Show("Would you like to add the layer to the map?", "Message", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
mapControl.AddLayerFromFile(saveFileDialog.FileName, 0);
}
}
}
public void Execute()
{
try {
// Create new spatial reference
ISpatialReference spatialReference = null;
if (this.SRef.ToLowerInvariant().Contains("projcs"))
{
spatialReference = new ProjectedCoordinateSystemClass();
}
else
{
spatialReference = new GeographicCoordinateSystemClass();
}
// Import SpatialReference Definition
int bytes2;
IESRISpatialReferenceGEN2 gen = (IESRISpatialReferenceGEN2)spatialReference;
gen.ImportFromESRISpatialReference(this.SRef, out bytes2);
// Create Search Extent
IEnvelope extent = new EnvelopeClass();
extent.PutCoords(this.XMin, this.YMin, this.XMax, this.YMax);
extent.SpatialReference = spatialReference;
// Open Saved Layer File
ILayerFile layerFile = new LayerFileClass();
layerFile.Open(this.Path);
ILayer layer = layerFile.Layer;
layerFile.Close();
// Where clause and list of selected OIDs
string where = string.Empty;
List <int> ids = new List <int>();
IImageServerLayer imageLayer = null;
if (layer is IImageServerLayer)
{
imageLayer = (IImageServerLayer)layer;
// Get Selection Set
IFeatureLayerDefinition definition = layer as IFeatureLayerDefinition;
if (definition != null)
{
// Find Selected OIDs
if (definition.DefinitionSelectionSet != null)
{
if (definition.DefinitionSelectionSet.Count > 0)
{
IEnumIDs emumids = definition.DefinitionSelectionSet.IDs;
int id = emumids.Next();
while (id != -1)
{
ids.Add(id);
id = emumids.Next();
}
}
}
// Update Where Clause
if (!string.IsNullOrEmpty(definition.DefinitionExpression))
{
where = definition.DefinitionExpression;
}
}
}
else if (layer is IMosaicLayer)
{
IMosaicLayer mosaicLayer = (IMosaicLayer)layer;
imageLayer = mosaicLayer.PreviewLayer;
ITableDefinition tableDefinition = mosaicLayer as ITableDefinition;
if (tableDefinition != null)
{
// Find Selected OIDs
if (tableDefinition.DefinitionSelectionSet != null)
{
if (tableDefinition.DefinitionSelectionSet.Count > 0)
{
IEnumIDs emumids = tableDefinition.DefinitionSelectionSet.IDs;
int id = emumids.Next();
while (id != -1)
{
ids.Add(id);
id = emumids.Next();
}
}
}
// Update Where Clause
if (!string.IsNullOrEmpty(tableDefinition.DefinitionExpression))
{
where = tableDefinition.DefinitionExpression;
}
}
}
// Use FeatureSelected (if any)
IFeatureSelection featureSelection = imageLayer as IFeatureSelection;
if (featureSelection != null)
{
if (featureSelection.SelectionSet != null)
{
if (featureSelection.SelectionSet.Count > 0)
{
IEnumIDs emumids = featureSelection.SelectionSet.IDs;
int id = emumids.Next();
while (id != -1)
{
ids.Add(id);
id = emumids.Next();
}
}
}
}
// Get Bands
ILongArray bands = new LongArrayClass();
IRasterRenderer rasterRenderer = imageLayer.Renderer;
if (rasterRenderer != null)
{
IRasterRGBRenderer2 rasterRGBRenderer = rasterRenderer as IRasterRGBRenderer2;
if (rasterRGBRenderer != null)
{
bands.Add(rasterRGBRenderer.UseRedBand ? rasterRGBRenderer.RedBandIndex : -1);
bands.Add(rasterRGBRenderer.UseGreenBand ? rasterRGBRenderer.GreenBandIndex : -1);
bands.Add(rasterRGBRenderer.UseBlueBand ? rasterRGBRenderer.BlueBandIndex : -1);
bands.Add(rasterRGBRenderer.UseAlphaBand ? rasterRGBRenderer.AlphaBandIndex : -1);
}
}
// Create Spatial Filter
ISpatialFilter spatialFilter = new SpatialFilterClass()
{
Geometry = extent,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects,
WhereClause = where
};
IImageServer imageServer = imageLayer.DataSource as IImageServer;
if (imageServer == null)
{
return;
}
IImageServer3 imageServer3 = imageServer as IImageServer3;
if (imageServer3 == null)
{
return;
}
IRecordSet recordSet = imageServer3.GetCatalogItems(spatialFilter);
ICursor cursor = recordSet.get_Cursor(false);
IFeatureCursor featureCursor = (IFeatureCursor)cursor;
IFeature feature = featureCursor.NextFeature();
List <IFeature> list = new List <IFeature>();
int indexCategory = featureCursor.FindField("Category");
while (feature != null)
{
// Exclude non-primary images (no overviews)
if (indexCategory != -1)
{
int cat = (int)feature.get_Value(indexCategory);
if (cat != 1)
{
feature = featureCursor.NextFeature();
continue;
}
}
// Exclude unselected features
if (ids.Count > 0)
{
int oid = feature.OID;
if (!ids.Contains(oid))
{
feature = featureCursor.NextFeature();
continue;
}
}
list.Add(feature);
feature = featureCursor.NextFeature();
}
// If nothing, fire event then exit
if (list.Count == 0)
{
this.OnThumbnailSummary(new SummaryEventArgs());
return;
}
// Get Full Extent of Features
SummaryEventArgs summary = new SummaryEventArgs()
{
XMin = list.Min(f => f.Shape.Envelope.CloneProject(spatialReference).XMin),
YMin = list.Min(f => f.Shape.Envelope.CloneProject(spatialReference).YMin),
XMax = list.Max(f => f.Shape.Envelope.CloneProject(spatialReference).XMax),
YMax = list.Max(f => f.Shape.Envelope.CloneProject(spatialReference).YMax),
Count = list.Count
};
// Add Fields
IFields fields = featureCursor.Fields;
for (int i = 0; i < fields.FieldCount; i++)
{
IField field = fields.get_Field(i);
switch (field.Type)
{
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeGlobalID:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeRaster:
case esriFieldType.esriFieldTypeXML:
break;
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeString:
summary.Fields.Add(
new Field()
{
Name = field.Name,
Alias = field.AliasName,
Type = field.Type
}
);
break;
default:
break;
}
}
// Raise Summary Event
this.OnThumbnailSummary(summary);
// Loop for each feature
foreach (IFeature feat in list)
{
// Project Extent to Current Map Spatial Reference
IEnvelope extentMap = feat.Shape.Envelope.CloneProject(spatialReference);
int width;
int height;
if (extentMap.Width > extentMap.Height)
{
width = this.MaxImageSize;
height = Convert.ToInt32((double)this.MaxImageSize * (double)extentMap.Height / (double)extentMap.Width);
}
else
{
width = Convert.ToInt32((double)this.MaxImageSize * (double)extentMap.Width / (double)extentMap.Height);
height = this.MaxImageSize;
}
IMosaicRule mosaicRule = new MosaicRuleClass()
{
MosaicMethod = esriMosaicMethod.esriMosaicLockRaster,
LockRasterID = feat.OID.ToString()
};
IGeoImageDescription geoImageDescription = new GeoImageDescriptionClass()
{
BandSelection = bands.Count > 0 ? bands : null,
MosaicRule = mosaicRule,
Compression = "PNG",
Width = width,
Height = height,
SpatialReference = spatialReference,
Extent = extentMap,
Interpolation = rstResamplingTypes.RSP_BilinearInterpolation,
};
// Assembly MosaicRequest (will be executed in background thread)
MosaicRequest mosaicRequest = new MosaicRequest()
{
MosaicExtractor = this,
ImageServer = imageServer3,
GeoImageDescription = geoImageDescription,
XMin = extentMap.XMin,
YMin = extentMap.YMin,
XMax = extentMap.XMax,
YMax = extentMap.YMax,
};
// Add Attributes Names and Values
foreach (Field field in summary.Fields)
{
int index = feat.Fields.FindField(field.Name);
if (index < 0)
{
continue;
}
mosaicRequest.Attributes.Add(field.Name, feat.get_Value(index));
}
// Start Mosaic Request in Background Thread
Thread thread = new Thread(new ThreadStart(mosaicRequest.Execute));
MosaicEnvironment.Default.Threads.Add(thread);
thread.Start();
}
}
catch { }
}
/// <summary>
/// Write the NALayer out to disk as a layer file.
/// </summary>
private void SaveLayerToDisk(ILayer layer, String path)
{
try
{
Console.WriteLine("Writing layer file containing analysis to " + path);
ILayerFile layerFile = new LayerFileClass();
layerFile.New(path);
layerFile.ReplaceContents(layer as ILayer);
layerFile.Save();
Console.WriteLine("Writing layer file successfully saved");
}
catch (Exception err)
{
// Write out errors
Console.WriteLine(err.Message);
}
}
private static void doSymbolizeLayer(IActiveView activeView, int i, string fieldName, bool doRemove, string filenamePrefix, string filenameSuffix, string filename)
{
if (filename == "") filename = fieldName;
try
{
if (ArcMap.Document.SelectedLayer == null)
{
System.Windows.Forms.MessageBox.Show("Select a layer before continuing.");
return;
}
IFeatureLayer ifl = (IFeatureLayer)ArcMap.Document.SelectedLayer;
if (fieldName == "Chemistry1" && ifl.FeatureClass.FindField(fieldName) < 0)
{
//try Chem if Chemistry1 not found
fieldName = "Chem";
}
if (ifl.FeatureClass.FindField(fieldName) < 0)
{
System.Windows.Forms.MessageBox.Show("Selected layer does not contain the " + fieldName + " field and can't be symbolized " +
"with this tool. Select another layer to continue.");
return;
}
string geomTypeName = "Polygon";
if (ifl.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolyline)
geomTypeName = "Polyline";
var asmPath = GetAssemblyPath();
ILayerFile layerFile = new LayerFileClass();
if (filenamePrefix == "NWIPlus")
{
layerFile.Open(asmPath + "/Symbology/" + filenamePrefix + filename + ".lyr");
}
else
{
if (fieldName == "Chem")
{
layerFile.Open(asmPath + "/Symbology/" + filenamePrefix + "Chemistry1" + filenameSuffix + ".lyr");
}
else
{
layerFile.Open(asmPath + "/Symbology/" + filenamePrefix + filename +filenameSuffix + ".lyr");
}
}
IGeoFeatureLayer igfl = (IGeoFeatureLayer)layerFile.Layer;
IUniqueValueRenderer iuvr = (IUniqueValueRenderer)igfl.Renderer;
IUniqueValueRenderer iuvr_new = iuvr;
#if false
if( filenameSuffix == "Rated") {
iuvr_new = new UniqueValueRendererClass();
iuvr_new.FieldCount = 1;
iuvr_new.Field[0] = fieldName;
iuvr_new.DefaultSymbol = iuvr.DefaultSymbol;
iuvr_new.UseDefaultSymbol = false;
// iuvr.UseDefaultSymbol = false;
// iuvr.Field[0] = symbType;
for (int l = 0; l < iuvr.ValueCount; l++)
{
//iuvr.Heading[iuvr.Value[l]] = symbType;
iuvr_new.AddValue(iuvr.Value[l], fieldName, iuvr.Symbol[iuvr.Value[l]]);
}
}
#endif
/*ILegendInfo li = (ILegendInfo)iuvr;
ILegendGroup gp = (ILegendGroup)li.LegendGroup[0];
gp.Heading = symbType;*/
IFeatureWorkspace iw = (IFeatureWorkspace)((IDataset)ifl.FeatureClass).Workspace;
ISQLSyntax sql = (ISQLSyntax)iw;
string prefix = sql.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string suffix = sql.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
IQueryFilter f = new QueryFilterClass();
int vCount = iuvr_new.ValueCount;
List<string> values = new List<string>();
#if false
for (int k0 = 0; k0 < iuvr_new.ValueCount; k0++)
{
try
{
IFillSymbol ifs = (IFillSymbol) iuvr_new.Symbol[iuvr.Value[k0]];
ifs.Outline = null;
//ifs.Outline.Width = 0;
}
catch(Exception abcd) {
}
}
#endif
if (doRemove)
{
char[] delimiter = { iuvr_new.FieldDelimiter[0] };
for (int j = 0; j < vCount; j++)
{
f.WhereClause = "";
string[] currValues = iuvr_new.Value[j].Split(delimiter);
for (int k = 0; k < currValues.Length; k++)
{
if (k > 0)
f.WhereClause += " AND ";
f.WhereClause += prefix + iuvr_new.Field[k] + suffix + " = '" + currValues[k].Trim() + "'";
}
ICursor fc = null;
bool bFound = false;
try
{
fc = ((ITable)ifl).Search(f, true);
bFound = (fc.NextRow() == null) ? false : true;
}
catch (Exception v)
{
//fc = null;
}
if (!bFound)
values.Add(iuvr_new.Value[j]);
}
}
foreach (string v in values)
{
iuvr_new.RemoveValue(v);
}
if (iuvr_new.ValueCount > 0)
{
IGeoFeatureLayer igd_dest = (IGeoFeatureLayer)ifl;
igd_dest.Renderer = (IFeatureRenderer)iuvr_new;
ArcMap.Document.ActiveView.ContentsChanged();
ArcMap.Document.UpdateContents();
ArcMap.Document.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
else
{
System.Windows.Forms.MessageBox.Show("No values found. No changes will be made to the symbology");
return;
}
//ArcMap.Document.CurrentContentsView.Deactivate();
//ArcMap.Document.ContentsView[0].Activate(ArcMap.Application.hWnd, ArcMap.Document);
}
catch (Exception e)
{
}
finally
{
}
}
public void Execute()
{
try {
// Create new spatial reference
ISpatialReference spatialReference = null;
if (this.SRef.ToLowerInvariant().Contains("projcs")) {
spatialReference = new ProjectedCoordinateSystemClass();
}
else {
spatialReference = new GeographicCoordinateSystemClass();
}
// Import SpatialReference Definition
int bytes2;
IESRISpatialReferenceGEN2 gen = (IESRISpatialReferenceGEN2)spatialReference;
gen.ImportFromESRISpatialReference(this.SRef, out bytes2);
// Create Search Extent
IEnvelope extent = new EnvelopeClass();
extent.PutCoords(this.XMin, this.YMin, this.XMax, this.YMax);
extent.SpatialReference = spatialReference;
// Open Saved Layer File
ILayerFile layerFile = new LayerFileClass();
layerFile.Open(this.Path);
ILayer layer = layerFile.Layer;
layerFile.Close();
// Where clause and list of selected OIDs
string where = string.Empty;
List<int> ids = new List<int>();
IImageServerLayer imageLayer = null;
if (layer is IImageServerLayer) {
imageLayer = (IImageServerLayer)layer;
// Get Selection Set
IFeatureLayerDefinition definition = layer as IFeatureLayerDefinition;
if (definition != null) {
// Find Selected OIDs
if (definition.DefinitionSelectionSet != null) {
if (definition.DefinitionSelectionSet.Count > 0) {
IEnumIDs emumids = definition.DefinitionSelectionSet.IDs;
int id = emumids.Next();
while (id != -1) {
ids.Add(id);
id = emumids.Next();
}
}
}
// Update Where Clause
if (!string.IsNullOrEmpty(definition.DefinitionExpression)) {
where = definition.DefinitionExpression;
}
}
}
else if (layer is IMosaicLayer) {
IMosaicLayer mosaicLayer = (IMosaicLayer)layer;
imageLayer = mosaicLayer.PreviewLayer;
ITableDefinition tableDefinition = mosaicLayer as ITableDefinition;
if (tableDefinition != null) {
// Find Selected OIDs
if (tableDefinition.DefinitionSelectionSet != null) {
if (tableDefinition.DefinitionSelectionSet.Count > 0) {
IEnumIDs emumids = tableDefinition.DefinitionSelectionSet.IDs;
int id = emumids.Next();
while (id != -1) {
ids.Add(id);
id = emumids.Next();
}
}
}
// Update Where Clause
if (!string.IsNullOrEmpty(tableDefinition.DefinitionExpression)) {
where = tableDefinition.DefinitionExpression;
}
}
}
// Use FeatureSelected (if any)
IFeatureSelection featureSelection = imageLayer as IFeatureSelection;
if (featureSelection != null) {
if (featureSelection.SelectionSet != null) {
if (featureSelection.SelectionSet.Count > 0) {
IEnumIDs emumids = featureSelection.SelectionSet.IDs;
int id = emumids.Next();
while (id != -1) {
ids.Add(id);
id = emumids.Next();
}
}
}
}
// Get Bands
ILongArray bands = new LongArrayClass();
IRasterRenderer rasterRenderer = imageLayer.Renderer;
if (rasterRenderer != null) {
IRasterRGBRenderer2 rasterRGBRenderer = rasterRenderer as IRasterRGBRenderer2;
if (rasterRGBRenderer != null) {
bands.Add(rasterRGBRenderer.UseRedBand ? rasterRGBRenderer.RedBandIndex : -1);
bands.Add(rasterRGBRenderer.UseGreenBand ? rasterRGBRenderer.GreenBandIndex : -1);
bands.Add(rasterRGBRenderer.UseBlueBand ? rasterRGBRenderer.BlueBandIndex : -1);
bands.Add(rasterRGBRenderer.UseAlphaBand ? rasterRGBRenderer.AlphaBandIndex : -1);
}
}
// Create Spatial Filter
ISpatialFilter spatialFilter = new SpatialFilterClass() {
Geometry = extent,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects,
WhereClause = where
};
IImageServer imageServer = imageLayer.DataSource as IImageServer;
if (imageServer == null) { return; }
IImageServer3 imageServer3 = imageServer as IImageServer3;
if (imageServer3 == null) { return; }
IRecordSet recordSet = imageServer3.GetCatalogItems(spatialFilter);
ICursor cursor = recordSet.get_Cursor(false);
IFeatureCursor featureCursor = (IFeatureCursor)cursor;
IFeature feature = featureCursor.NextFeature();
List<IFeature> list = new List<IFeature>();
int indexCategory = featureCursor.FindField("Category");
while (feature != null) {
// Exclude non-primary images (no overviews)
if (indexCategory != -1) {
int cat = (int)feature.get_Value(indexCategory);
if (cat != 1) {
feature = featureCursor.NextFeature();
continue;
}
}
// Exclude unselected features
if (ids.Count > 0) {
int oid = feature.OID;
if (!ids.Contains(oid)) {
feature = featureCursor.NextFeature();
continue;
}
}
list.Add(feature);
feature = featureCursor.NextFeature();
}
// If nothing, fire event then exit
if (list.Count == 0) {
this.OnThumbnailSummary(new SummaryEventArgs());
return;
}
// Get Full Extent of Features
SummaryEventArgs summary = new SummaryEventArgs() {
XMin = list.Min(f => f.Shape.Envelope.CloneProject(spatialReference).XMin),
YMin = list.Min(f => f.Shape.Envelope.CloneProject(spatialReference).YMin),
XMax = list.Max(f => f.Shape.Envelope.CloneProject(spatialReference).XMax),
YMax = list.Max(f => f.Shape.Envelope.CloneProject(spatialReference).YMax),
Count = list.Count
};
// Add Fields
IFields fields = featureCursor.Fields;
for (int i = 0; i < fields.FieldCount; i++) {
IField field = fields.get_Field(i);
switch (field.Type) {
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeGlobalID:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeRaster:
case esriFieldType.esriFieldTypeXML:
break;
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeString:
summary.Fields.Add(
new Field() {
Name = field.Name,
Alias = field.AliasName,
Type = field.Type
}
);
break;
default:
break;
}
}
// Raise Summary Event
this.OnThumbnailSummary(summary);
// Loop for each feature
foreach (IFeature feat in list) {
// Project Extent to Current Map Spatial Reference
IEnvelope extentMap = feat.Shape.Envelope.CloneProject(spatialReference);
int width;
int height;
if (extentMap.Width > extentMap.Height) {
width = this.MaxImageSize;
height = Convert.ToInt32((double)this.MaxImageSize * (double)extentMap.Height / (double)extentMap.Width);
}
else {
width = Convert.ToInt32((double)this.MaxImageSize * (double)extentMap.Width / (double)extentMap.Height);
height = this.MaxImageSize;
}
IMosaicRule mosaicRule = new MosaicRuleClass() {
MosaicMethod = esriMosaicMethod.esriMosaicLockRaster,
LockRasterID = feat.OID.ToString()
};
IGeoImageDescription geoImageDescription = new GeoImageDescriptionClass() {
BandSelection = bands.Count > 0 ? bands : null,
MosaicRule = mosaicRule,
Compression = "PNG",
Width = width,
Height = height,
SpatialReference = spatialReference,
Extent = extentMap,
Interpolation = rstResamplingTypes.RSP_BilinearInterpolation,
};
// Assembly MosaicRequest (will be executed in background thread)
MosaicRequest mosaicRequest = new MosaicRequest() {
MosaicExtractor = this,
ImageServer = imageServer3,
GeoImageDescription = geoImageDescription,
XMin = extentMap.XMin,
YMin = extentMap.YMin,
XMax = extentMap.XMax,
YMax = extentMap.YMax,
};
// Add Attributes Names and Values
foreach (Field field in summary.Fields) {
int index = feat.Fields.FindField(field.Name);
if (index < 0) { continue; }
mosaicRequest.Attributes.Add(field.Name, feat.get_Value(index));
}
// Start Mosaic Request in Background Thread
Thread thread = new Thread(new ThreadStart(mosaicRequest.Execute));
MosaicEnvironment.Default.Threads.Add(thread);
thread.Start();
}
}
catch { }
}
private void frmMain_Load(object sender, EventArgs e)
{
cboTopYear.Items.Clear();
cboTopYear.Items.AddRange(availableYrs);
cboBotYear.Items.Clear();
cboBotYear.Items.AddRange(availableYrs);
string dataPath = ConfigurationManager.AppSettings["BaseDataPath"];
#region Load base map layers through lyr file CODE for desktop with ILayerFile with engine license
ILayerFile layerFile = new LayerFileClass();
string basemappath = ConfigurationManager.AppSettings["BaseMapLyrPath"];
////TODO////Validate BaseMap Layer file Path
layerFile.Open(basemappath);
if (layerFile.Layer != null)
{
IMap map = m_MapControl.ActiveView.FocusMap;
map.AddLayer(layerFile.Layer);
}
#endregion
//Load parcel layers
IWorkspaceFactory2 workspaceFactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(dataPath + @"Shape", 0);
featureClassParcels = featureWorkspace.OpenFeatureClass("parcels");
//?????next time we will upgrade it to read fields from layer. I read from txt because I believe it will speed up my application.
string[] lines = System.IO.File.ReadAllLines(dataPath + @"Table\ParcelTable_3F.txt");
int i = 0;
List<string> lststNum = new List<string>();
List<string> lststName = new List<string>();
foreach (string line in lines)
{
string[] fields = new string[3];
fields = line.Split(new Char[] { ',' });
arylistParcelAdd.Add(new Parcel { FID = fields[0], StNum = fields[1], StName = fields[2] });
lststNum.Add(fields[1]);
lststName.Add(fields[2]);
i += 1;
}
distinctStNum = lststNum.Distinct().ToList();
distinctStName = lststName.Distinct().ToList();
var autoCompleStNum = new AutoCompleteStringCollection();
var autoCompleStName = new AutoCompleteStringCollection();
//why not use ToArray 4 lines ago??
autoCompleStNum.AddRange(distinctStNum.ToArray());
autoCompleStName.AddRange(distinctStName.ToArray());
tbStNa.AutoCompleteMode = AutoCompleteMode.Suggest;
tbStNa.AutoCompleteSource = AutoCompleteSource.CustomSource;
tbStNa.AutoCompleteCustomSource = autoCompleStName;
tbStNum.AutoCompleteMode = AutoCompleteMode.Suggest;
tbStNum.AutoCompleteSource = AutoCompleteSource.CustomSource;
tbStNum.AutoCompleteCustomSource = autoCompleStNum;
//Zoom the display to the full extent of all layers in the maop
m_MapControl.ActiveView.Extent = m_MapControl.ActiveView.FullExtent;
m_MapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
private string ValidateLayerFile()
{
if (string.IsNullOrEmpty(LayerFileName))
return "No layer file template is defined.";
if (!File.Exists(LayerFileName))
return "layer file '" + LayerFileName + "' does not exist.";
try
{
var layerFile = new LayerFileClass();
layerFile.Open(LayerFileName);
_layer = layerFile.Layer;
layerFile.Close();
}
catch (Exception ex)
{
_layer = null;
return "Could not load layer file '" + LayerFileName + "'\n" + ex.Message;
}
if (_layer == null)
return "layer file '" + LayerFileName + "' is empty.";
if (!(_layer is IFeatureLayerDefinition2))
{
_layer = null;
return "layer file '" + LayerFileName + "' does not support definition queries.";
}
return null;
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPValue inputLayersGPValue = gpUtilities3.UnpackGPValue(paramvalues.get_Element(in_LayersNumber));
IGPMultiValue inputLayersMultiValue = gpUtilities3.UnpackGPValue(inputLayersGPValue) as IGPMultiValue;
IGPParameter outputGroupLayerParameter = paramvalues.get_Element(out_groupLayerNumber) as IGPParameter;
IGPValue outputGPGroupLayer = gpUtilities3.UnpackGPValue(outputGroupLayerParameter);
IGPCompositeLayer outputCompositeLayer = outputGPGroupLayer as IGPCompositeLayer;
if (outputCompositeLayer == null)
{
message.AddError(120048, string.Format(resourceManager.GetString("GPTools_NullPointerParameterType"), outputGroupLayerParameter.Name));
return;
}
IGroupLayer groupLayer = null;
// find the last position of the "\" string
// in case we find such a thing, i.e. position is >= -1 then let's assume that we are dealing with a layer file on disk
// otherwise let's create a new group layer instance
string outputGPLayerNameAsString = outputGPGroupLayer.GetAsText();
int separatorPosition = outputGPLayerNameAsString.LastIndexOf(System.IO.Path.DirectorySeparatorChar);
string layerName = String.Empty;
if (separatorPosition > -1)
{
layerName = outputGPGroupLayer.GetAsText().Substring(separatorPosition + 1);
}
else
{
layerName = outputGPGroupLayer.GetAsText();
}
ILayer foundLayer = null;
IGPLayer existingGPLayer = gpUtilities3.FindMapLayer2(layerName, out foundLayer);
if (foundLayer != null)
{
gpUtilities3.RemoveFromMapEx((IGPValue)existingGPLayer);
gpUtilities3.RemoveInternalLayerEx(foundLayer);
}
groupLayer = new GroupLayer();
((ILayer)groupLayer).Name = layerName;
for (int layerIndex = 0; layerIndex < inputLayersMultiValue.Count; layerIndex++)
{
IGPValue gpLayerToAdd = inputLayersMultiValue.get_Value(layerIndex) as IGPValue;
ILayer sourceLayer = gpUtilities3.DecodeLayer(gpLayerToAdd);
groupLayer.Add(sourceLayer);
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(groupLayer);
if (separatorPosition > -1)
{
try
{
// in the case that we are dealing with a layer file on disk
// let's persist the group layer information into the file
ILayerFile pointLayerFile = new LayerFileClass();
if (System.IO.Path.GetExtension(outputGPLayerNameAsString).ToUpper().Equals(".LYR"))
{
if (pointLayerFile.get_IsPresent(outputGPLayerNameAsString))
{
try
{
gpUtilities3.Delete(outputGPGroupLayer);
}
catch (Exception ex)
{
message.AddError(120001, ex.Message);
return;
}
}
pointLayerFile.New(outputGPLayerNameAsString);
pointLayerFile.ReplaceContents(groupLayer);
pointLayerFile.Save();
}
outputGPGroupLayer = gpUtilities3.MakeGPValueFromObject(pointLayerFile.Layer);
}
catch (Exception ex)
{
message.AddError(120002, ex.Message);
return;
}
}
gpUtilities3.PackGPValue(outputGPGroupLayer, outputGroupLayerParameter);
}
catch (Exception ex)
{
message.AddError(120049, ex.Message);
}
}
internal void BuildLayer(string plant)
{
//Validate must be called by the user before calling BuildLayers
if (_layer == null)
throw new Exception("Unable to build this layer due to invalid (or unvalidated) configuration properties.");
//reload the layer file to create a new layer (we may get called many times)
var layerFile = new LayerFileClass();
layerFile.Open(LayerFileName);
_layer = layerFile.Layer;
layerFile.Close();
string definitionQuery;
if (string.IsNullOrEmpty(plant))
{
plant = "unspecified";
definitionQuery = "\"" + FieldName + "\" = '' OR \"" + FieldName + "\" is null";
}
else
{
definitionQuery = "\"" + FieldName + "\" = '" + plant.Replace("'", "''") + "'";
}
_layer.Name = string.Format(LayerNameFormat, plant);
((IFeatureLayerDefinition2)_layer).DefinitionExpression = definitionQuery;
// Call the layer fixer delegate
var layerFixer = LayerFixer;
if (layerFixer != null)
layerFixer(_layer);
ArcMap.Document.AddLayer(_layer);
}
/// <summary>
/// Builds the index file with layers
/// </summary>
/// <param name="searchPaths">The search paths.</param>
public void BuildIndex(List <string> searchPaths)
{
if (!File.Exists(this.IndexPath))
{
CreateNewIndexFile(this.IndexPath);
}
List <string> layerFiles = new List <string>();
int i = 0;
foreach (string searchPath in searchPaths)
{
i++;
LayerfileIndexer indexer = new LayerfileIndexer(searchPath);
indexer.Search();
layerFiles.AddRange(indexer.LayerFiles);
OnProgressUpdate(i, searchPaths.Count, "Scanning Search Path " + searchPath);
}
List <string> insertSQLStatements = new List <string>();
i = 0;
foreach (string filePath in layerFiles)
{
i++;
FileInfo fileInfo = new FileInfo(filePath);
ILayerFile layerFile = new LayerFileClass();
layerFile.Open(filePath);
ILayer layer = layerFile.Layer;
ILayerGeneralProperties layerProps = (ILayerGeneralProperties)layer;
ILayerExtensions layerExt = (ILayerExtensions)layer;
string lyrGUID = "00000000-0000-0000-0000-000000000000";
string revision = "0";
if (Layer.Util.LayerExtHelper.UmbrielPropertySetExists(layerExt))
{
IPropertySet propertySet = Util.LayerExtHelper.GetUmbrielPropertySet(layerExt);
if (propertySet != null && Util.LayerExtHelper.PropertyExists(propertySet, "GUID"))
{
lyrGUID = propertySet.GetProperty("GUID").ToString();
}
if (propertySet != null && Util.LayerExtHelper.PropertyExists(propertySet, "revision"))
{
revision = propertySet.GetProperty("revision").ToString();
}
}
StringBuilder sql = new StringBuilder();
sql.AppendLine("INSERT INTO layerfile ");
sql.AppendLine("(lyrgid,lyrName,lyrDescription,lyrFileName,lyrFullPath,lyrParentDir,lyrRevision,DateRecCreated,DateRecModified)");
sql.AppendLine(" VALUES (");
sql.AppendLine("'" + lyrGUID + "'");
sql.AppendLine(",'" + layer.Name.Replace("'", "''") + "'");
sql.AppendLine(",'" + layerProps.LayerDescription.Replace("'", "''") + "'");
sql.AppendLine(",'" + Path.GetFileName(filePath) + "'");
sql.AppendLine(",\"" + filePath + "\"");
sql.AppendLine(",'" + Path.GetDirectoryName(filePath) + "'");
sql.AppendLine("," + revision + "");
sql.AppendLine(",'" + SqliteDateString(DateTime.Now) + "'");
sql.AppendLine(",'" + SqliteDateString(DateTime.Now) + "'");
sql.AppendLine(")");
Debug.WriteLine(sql.ToString());
insertSQLStatements.Add(sql.ToString());
OnProgressUpdate(i, layerFiles.Count, "Building layer data file: ");
if (layer != null)
{
// System.Runtime.InteropServices.Marshal.FinalReleaseComObject(layerFile);
}
}
i = 0;
// build insert sql statement
using (SQLiteConnection cnn = new SQLiteConnection(this.GetDBConnectionString()))
{
cnn.Open();
using (DbTransaction transaction = cnn.BeginTransaction())
{
using (DbCommand cmd = cnn.CreateCommand())
{
foreach (string sql in insertSQLStatements)
{
i++;
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
OnProgressUpdate(i, insertSQLStatements.Count, "Inserting data: ");
}
}
transaction.Commit();
}
OnProgressUpdate(i, insertSQLStatements.Count, "Insert Complete!");
cnn.Close();
}
}
static void RunJob(CmdArgs args)
{
Log.Information("Processing file {LayerFile}", args.InputFile);
var inputFile = new FileInfo(args.InputFile);
ILayerFile inputLayer = new LayerFileClass();
inputLayer.Open(inputFile.FullName);
IGeoFeatureLayer geoFeatureLayer = inputLayer.Layer as IGeoFeatureLayer;
//var featureLayer = inputLayer.Layer as FeatureLayer;
//IFeatureClass featureClass = featureLayer.FeatureClass;
//var renderer = geoFeatureLayer.Renderer as ISimpleRenderer;
var esriRgb = CreateRGBColor(args.Colour);
ISimpleRenderer simpleRenderer = new SimpleRendererClass();
var symbolType = args.SymbolType.ToLowerInvariant();
if (args.GetSymbolTypeFromInputFileName)
{
var tempSymbolType = inputFile.Name.Replace(inputFile.Extension, "").ToLowerInvariant();
if (string.Equals(tempSymbolType, "point", StringComparison.OrdinalIgnoreCase) ||
string.Equals(tempSymbolType, "polyline", StringComparison.OrdinalIgnoreCase) ||
string.Equals(tempSymbolType, "line", StringComparison.OrdinalIgnoreCase) ||
string.Equals(tempSymbolType, "polygon", StringComparison.OrdinalIgnoreCase))
{
symbolType = tempSymbolType;
}
}
switch (symbolType)
{
case "point":
IMarkerSymbol pointSymbol = new SimpleMarkerSymbolClass();
pointSymbol.Size = args.PointSize;
pointSymbol.Color = esriRgb;
simpleRenderer.Symbol = (ISymbol)pointSymbol;
break;
case "polyline":
case "line":
ILineSymbol lineSymbol = new SimpleLineSymbolClass();
lineSymbol.Width = args.LineWidth;
lineSymbol.Color = esriRgb;
simpleRenderer.Symbol = (ISymbol)lineSymbol;
break;
case "polygon":
ILineSymbol outlineSymbol = new SimpleLineSymbolClass();
outlineSymbol.Width = args.LineWidth;
outlineSymbol.Color = CreateRGBColor(args.OutlineColour) ?? esriRgb;
ISimpleFillSymbol fillSymbol = new SimpleFillSymbolClass();
fillSymbol.Outline = outlineSymbol;
fillSymbol.Color = esriRgb;
simpleRenderer.Symbol = (ISymbol)fillSymbol;
break;
default:
inputLayer.Close();
Log.Warning("Unrecognized symbol type {SymbolType}. No symbol set for the layer renderer. Valid symbol types are point, polyline, line or polygon.", args.SymbolType);
return;
}
geoFeatureLayer.Renderer = (IFeatureRenderer)simpleRenderer;
var outputFileLocation = args.SaveFileNameUnique ? GetUniqueFilename(Path.Combine(args.OutputFolder, inputFile.Name)) : Path.Combine(args.OutputFolder, inputFile.Name);
var outputFile = new FileInfo(outputFileLocation);
Log.Information("Saving processed layer file to {OutputFile}", outputFile.FullName);
SaveToLayerFile(outputFile.FullName, inputLayer.Layer);
inputLayer.Close();
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
//need to get the layer from the custom-property of the map
if (null == m_hookHelper)
return;
//get the mapControl hook
object hook = null;
if (m_hookHelper.Hook is IToolbarControl2)
{
hook = ((IToolbarControl2)m_hookHelper.Hook).Buddy;
}
else
{
hook = m_hookHelper.Hook;
}
//get the custom property from which is supposed to be the layer to be saved
object customProperty = null;
IMapControl3 mapControl = null;
if (hook is IMapControl3)
{
mapControl = (IMapControl3)hook;
customProperty = mapControl.CustomProperty;
}
else
return;
if (null == customProperty || !(customProperty is ILayer))
return;
//ask the user to set a name for the new layer file
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Layer File|*.lyr|All Files|*.*";
saveFileDialog.Title = "Create Layer File";
saveFileDialog.RestoreDirectory = true;
saveFileDialog.FileName = System.IO.Path.Combine(saveFileDialog.InitialDirectory, ((ILayer)customProperty).Name + ".lyr");
//get the layer name from the user
DialogResult dr = saveFileDialog.ShowDialog();
if (saveFileDialog.FileName != "" && dr == DialogResult.OK)
{
if (System.IO.File.Exists(saveFileDialog.FileName))
{
//try to delete the existing file
System.IO.File.Delete(saveFileDialog.FileName);
}
//create a new LayerFile instance
ILayerFile layerFile = new LayerFileClass();
//create a new layer file
layerFile.New(saveFileDialog.FileName);
//attach the layer file with the actual layer
layerFile.ReplaceContents((ILayer)customProperty);
//save the layer file
layerFile.Save();
//ask the user whether he'd like to add the layer to the map
if (DialogResult.Yes == MessageBox.Show("Would you like to add the layer to the map?", "Message", MessageBoxButtons.YesNo, MessageBoxIcon.Question))
{
mapControl.AddLayerFromFile(saveFileDialog.FileName, 0);
}
}
}
private void ChangeBreaks()
{
IMxDocument pMxDoc = m_application.Document as IMxDocument;
IMap pMap = pMxDoc.FocusMap;
IGeoFeatureLayer pFeatureLayer = pMap.Layer[0] as IGeoFeatureLayer;
IGxLayer pGXLayer = new GxLayer();
IGxFile pGXFile = (IGxFile)pGXLayer;
pGXFile.Path = @"S:\Projects\TARRANT-Witchita\GIS\Layers\infreq_layers\test_Layer_2.lyr";
IGeoFeatureLayer pLayer = pGXLayer.Layer as IGeoFeatureLayer;
IClassBreaksRenderer pClassBreaksRenderer = (IClassBreaksRenderer)pLayer.Renderer;
int pNumberOfClassBreaks = pClassBreaksRenderer.BreakCount;
for (int i = 0; i < pNumberOfClassBreaks; i++)
{
pClassBreaksRenderer.Break[i] = i + 1;
}
IClassBreaksRenderer qClassBreaksRenderer = (IClassBreaksRenderer)pFeatureLayer.Renderer;
qClassBreaksRenderer = pClassBreaksRenderer;
int qNumberOfClassBreaks = qClassBreaksRenderer.BreakCount;
for (int i = 0; i < qNumberOfClassBreaks; i++)
{
qClassBreaksRenderer.Break[i] = i + 1;
}
//Create a new LayerFile instance.
ILayerFile layerFile = new LayerFileClass();
//Create a new layer file.
layerFile.New(@"S:\Projects\TARRANT-Witchita\GIS\Layers\test_Layer_3.lyr");
layerFile.ReplaceContents(pLayer);
layerFile.Save();
}
