public virtual void DoWork(RunFitnessCaseCompletedHandler handler)
{
IGPEnvironment env = mPop.Environment as IGPEnvironment;
int fitness_case_count = env.GetFitnessCaseCount();
List <IGPFitnessCase> cases = new List <IGPFitnessCase>();
for (int i = 0; i < fitness_case_count; ++i)
{
IGPFitnessCase fitness_case = env.CreateFitnessCase(i);
for (int tindex = 0; tindex < mTrees.Count; ++tindex)
{
fitness_case.StoreOutput(mTrees[tindex].ExecuteOnFitnessCase(fitness_case), tindex);
}
handler(fitness_case);
}
}
private string DetermineLyrLocation(IArray environments, FileInfo initialLyrLocation)
{
string outputLyrLocation = initialLyrLocation.FullName;
try
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
// first check for the scratch workspace
// next for the current workspace
// and as a last resort pick the user's temp workspace
IGPEnvironment scratchworkspaceGPEnvironment = gpUtilities3.GetEnvironment(environments, "scratchworkspace");
if (scratchworkspaceGPEnvironment != null)
{
IDEWorkspace scratchworkspace = scratchworkspaceGPEnvironment.Value as IDEWorkspace;
if (scratchworkspace != null)
{
if (scratchworkspace.WorkspaceType == esriWorkspaceType.esriFileSystemWorkspace)
{
if (((IGPValue)scratchworkspace).IsEmpty() == false)
{
outputLyrLocation = ((IGPValue)scratchworkspace).GetAsText() + System.IO.Path.DirectorySeparatorChar + initialLyrLocation.Name;
return(outputLyrLocation);
}
}
else if (scratchworkspace.WorkspaceType == esriWorkspaceType.esriLocalDatabaseWorkspace)
{
if (((IGPValue)scratchworkspace).IsEmpty() == false)
{
int slashIndexPosition = ((IGPValue)scratchworkspace).GetAsText().LastIndexOf("\\");
string potentialFolderLocation = ((IGPValue)scratchworkspace).GetAsText().Substring(0, slashIndexPosition);
if (Directory.Exists(potentialFolderLocation))
{
outputLyrLocation = potentialFolderLocation + System.IO.Path.DirectorySeparatorChar + initialLyrLocation.Name;
return(outputLyrLocation);
}
}
}
else
{
string localTempPath = System.IO.Path.GetTempPath();
outputLyrLocation = localTempPath + initialLyrLocation.Name;
return(outputLyrLocation);
}
}
}
IGPEnvironment currentworkspaceGPEnvironment = gpUtilities3.GetEnvironment(environments, "workspace");
if (currentworkspaceGPEnvironment != null)
{
IDEWorkspace currentWorkspace = currentworkspaceGPEnvironment.Value as IDEWorkspace;
if (currentWorkspace != null)
{
if (currentWorkspace.WorkspaceType == esriWorkspaceType.esriFileSystemWorkspace)
{
if (((IGPValue)currentWorkspace).IsEmpty() == false)
{
outputLyrLocation = ((IGPValue)currentWorkspace).GetAsText() + System.IO.Path.DirectorySeparatorChar + initialLyrLocation.Name;
return(outputLyrLocation);
}
}
}
}
// combine temp directory path with the name of the incoming lyr file
string tempPath = System.IO.Path.GetTempPath();
outputLyrLocation = tempPath + initialLyrLocation.Name;
}
catch { }
return(outputLyrLocation);
}
public void Execute(ESRI.ArcGIS.esriSystem.IArray paramvalues, ESRI.ArcGIS.esriSystem.ITrackCancel TrackCancel, ESRI.ArcGIS.Geoprocessing.IGPEnvironmentManager envMgr, ESRI.ArcGIS.Geodatabase.IGPMessages message)
{
IGPUtilities3 gpUtilities3 = new GPUtilitiesClass();
OSMToolHelper osmToolHelper = new OSMToolHelper();
if (TrackCancel == null)
{
TrackCancel = new CancelTrackerClass();
}
IGPEnvironment configKeyword = OSMToolHelper.getEnvironment(envMgr, "configKeyword");
IGPString gpString = configKeyword.Value as IGPString;
string storageKeyword = String.Empty;
if (gpString != null)
{
storageKeyword = gpString.Value;
}
IGPParameter osmFileParameter = paramvalues.get_Element(0) as IGPParameter;
IGPValue osmFileLocationString = gpUtilities3.UnpackGPValue(osmFileParameter) as IGPValue;
IGPParameter loadSuperRelationParameter = paramvalues.get_Element(1) as IGPParameter;
IGPBoolean loadSuperRelationGPValue = gpUtilities3.UnpackGPValue(loadSuperRelationParameter) as IGPBoolean;
IGPParameter osmSourceLineFeatureClassParameter = paramvalues.get_Element(2) as IGPParameter;
IGPValue osmSourceLineFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmSourceLineFeatureClassParameter) as IGPValue;
IGPParameter osmSourcePolygonFeatureClassParameter = paramvalues.get_Element(3) as IGPParameter;
IGPValue osmSourcePolygonFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmSourcePolygonFeatureClassParameter) as IGPValue;
IGPParameter osmTargetLineFeatureClassParameter = paramvalues.get_Element(6) as IGPParameter;
IGPValue osmTargetLineFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmTargetLineFeatureClassParameter) as IGPValue;
IName workspaceName = gpUtilities3.CreateParentFromCatalogPath(osmTargetLineFeatureClassGPValue.GetAsText());
IWorkspace2 lineFeatureWorkspace = workspaceName.Open() as IWorkspace2;
string[] lineFCNameElements = osmTargetLineFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar);
IFeatureClass osmLineFeatureClass = null;
IGPParameter tagLineCollectionParameter = paramvalues.get_Element(4) as IGPParameter;
IGPMultiValue tagLineCollectionGPValue = gpUtilities3.UnpackGPValue(tagLineCollectionParameter) as IGPMultiValue;
List <String> lineTagstoExtract = null;
if (tagLineCollectionGPValue.Count > 0)
{
lineTagstoExtract = new List <string>();
for (int valueIndex = 0; valueIndex < tagLineCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagLineCollectionGPValue.get_Value(valueIndex).GetAsText();
lineTagstoExtract.Add(nameOfTag);
}
}
else
{
lineTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields();
}
// lines
try
{
osmLineFeatureClass = osmToolHelper.CreateSmallLineFeatureClass(lineFeatureWorkspace,
lineFCNameElements[lineFCNameElements.Length - 1], storageKeyword, "", "", lineTagstoExtract);
}
catch (Exception ex)
{
message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message));
return;
}
if (osmLineFeatureClass == null)
{
return;
}
IGPParameter osmTargetPolygonFeatureClassParameter = paramvalues.get_Element(7) as IGPParameter;
IGPValue osmTargetPolygonFeatureClassGPValue = gpUtilities3.UnpackGPValue(osmTargetPolygonFeatureClassParameter) as IGPValue;
workspaceName = gpUtilities3.CreateParentFromCatalogPath(osmTargetPolygonFeatureClassGPValue.GetAsText());
IWorkspace2 polygonFeatureWorkspace = workspaceName.Open() as IWorkspace2;
string[] polygonFCNameElements = osmTargetPolygonFeatureClassGPValue.GetAsText().Split(System.IO.Path.DirectorySeparatorChar);
IFeatureClass osmPolygonFeatureClass = null;
IGPParameter tagPolygonCollectionParameter = paramvalues.get_Element(5) as IGPParameter;
IGPMultiValue tagPolygonCollectionGPValue = gpUtilities3.UnpackGPValue(tagPolygonCollectionParameter) as IGPMultiValue;
List <String> polygonTagstoExtract = null;
if (tagPolygonCollectionGPValue.Count > 0)
{
polygonTagstoExtract = new List <string>();
for (int valueIndex = 0; valueIndex < tagPolygonCollectionGPValue.Count; valueIndex++)
{
string nameOfTag = tagPolygonCollectionGPValue.get_Value(valueIndex).GetAsText();
polygonTagstoExtract.Add(nameOfTag);
}
}
else
{
polygonTagstoExtract = OSMToolHelper.OSMSmallFeatureClassFields();
}
// polygons
try
{
osmPolygonFeatureClass = osmToolHelper.CreateSmallPolygonFeatureClass(polygonFeatureWorkspace,
polygonFCNameElements[polygonFCNameElements.Length - 1], storageKeyword, "", "", polygonTagstoExtract);
}
catch (Exception ex)
{
message.AddError(120035, String.Format(resourceManager.GetString("GPTools_OSMGPDownload_nullpointfeatureclass"), ex.Message));
return;
}
if (osmPolygonFeatureClass == null)
{
return;
}
ComReleaser.ReleaseCOMObject(osmPolygonFeatureClass);
ComReleaser.ReleaseCOMObject(osmLineFeatureClass);
string[] gdbComponents = new string[polygonFCNameElements.Length - 1];
System.Array.Copy(lineFCNameElements, gdbComponents, lineFCNameElements.Length - 1);
string fileGDBLocation = String.Join(System.IO.Path.DirectorySeparatorChar.ToString(), gdbComponents);
osmToolHelper.smallLoadOSMRelations(osmFileLocationString.GetAsText(),
osmSourceLineFeatureClassGPValue.GetAsText(),
osmSourcePolygonFeatureClassGPValue.GetAsText(),
osmTargetLineFeatureClassGPValue.GetAsText(),
osmTargetPolygonFeatureClassGPValue.GetAsText(),
lineTagstoExtract, polygonTagstoExtract, loadSuperRelationGPValue.Value);
}
public void Execute(IArray paramvalues, ITrackCancel trackcancel, IGPEnvironmentManager envMgr, IGPMessages message)
{
// Get Parameters
IGPParameter3 inputParameter = (IGPParameter3)paramvalues.get_Element(0);
IGPParameter3 polygonParameter = (IGPParameter3)paramvalues.get_Element(1);
IGPParameter3 outputParameter = (IGPParameter3)paramvalues.get_Element(2);
IGPParameter3 fieldParameter = (IGPParameter3)paramvalues.get_Element(3);
// UnPackGPValue. This ensures you get the value from either the dataelement or GpVariable (ModelBuilder)
IGPValue inputParameterValue = m_GPUtilities.UnpackGPValue(inputParameter);
IGPValue polygonParameterValue = m_GPUtilities.UnpackGPValue(polygonParameter);
IGPValue outputParameterValue = m_GPUtilities.UnpackGPValue(outputParameter);
IGPValue fieldParameterValue = m_GPUtilities.UnpackGPValue(fieldParameter);
// Decode Input Feature Layers
IFeatureClass inputFeatureClass;
IFeatureClass polygonFeatureClass;
IQueryFilter inputFeatureClassQF;
IQueryFilter polygonFeatureClassQF;
m_GPUtilities.DecodeFeatureLayer(inputParameterValue, out inputFeatureClass, out inputFeatureClassQF);
m_GPUtilities.DecodeFeatureLayer(polygonParameterValue, out polygonFeatureClass, out polygonFeatureClassQF);
if (inputFeatureClass == null)
{
message.AddError(2, "Could not open input dataset.");
return;
}
if (polygonFeatureClass == null)
{
message.AddError(2, "Could not open clipping polygon dataset.");
return;
}
if (polygonFeatureClass.FeatureCount(null) > 1)
{
message.AddWarning("Clipping polygon feature class contains more than one feature.");
}
// Create the Geoprocessor
Geoprocessor gp = new Geoprocessor();
// Create Output Polygon Feature Class
CreateFeatureclass cfc = new CreateFeatureclass();
IName name = m_GPUtilities.CreateFeatureClassName(outputParameterValue.GetAsText());
IDatasetName dsName = name as IDatasetName;
IFeatureClassName fcName = dsName as IFeatureClassName;
IFeatureDatasetName fdsName = fcName.FeatureDatasetName as IFeatureDatasetName;
// Check if output is in a FeatureDataset or not. Set the output path parameter for CreateFeatureClass tool.
if (fdsName != null)
{
cfc.out_path = fdsName;
}
else
{
cfc.out_path = dsName.WorkspaceName.PathName;
}
// Set the output Coordinate System for CreateFeatureClass tool.
// ISpatialReference3 sr = null;
IGPEnvironment env = envMgr.FindEnvironment("outputCoordinateSystem");
// Same as Input
if (env.Value.IsEmpty())
{
IGeoDataset ds = inputFeatureClass as IGeoDataset;
cfc.spatial_reference = ds.SpatialReference as ISpatialReference3;
}
// Use the environment setting
else
{
IGPCoordinateSystem cs = env.Value as IGPCoordinateSystem;
cfc.spatial_reference = cs.SpatialReference as ISpatialReference3;
}
// Remaining properties for Create Feature Class Tool
cfc.out_name = dsName.Name;
cfc.geometry_type = "POLYGON";
// Execute Geoprocessor
gp.Execute(cfc, null);
// Get Unique Field
int iField = inputFeatureClass.FindField(fieldParameterValue.GetAsText());
IField uniqueField = inputFeatureClass.Fields.get_Field(iField);
// Extract Clipping Polygon Geometry
IFeature polygonFeature = polygonFeatureClass.GetFeature(0);
IPolygon clippingPolygon = (IPolygon)polygonFeature.Shape;
// Spatial Filter
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = polygonFeature.ShapeCopy;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
// Debug Message
message.AddMessage("Generating TIN...");
// Create TIN
ITinEdit tinEdit = new TinClass();
// Advanced TIN Functions
ITinAdvanced2 tinAdv = (ITinAdvanced2)tinEdit;
try
{
// Initialize New TIN
IGeoDataset gds = inputFeatureClass as IGeoDataset;
tinEdit.InitNew(gds.Extent);
// Add Mass Points to TIN
tinEdit.StartEditing();
tinEdit.AddFromFeatureClass(inputFeatureClass, spatialFilter, uniqueField, uniqueField, esriTinSurfaceType.esriTinMassPoint);
tinEdit.Refresh();
// Get TIN Nodes
ITinNodeCollection tinNodeCollection = (ITinNodeCollection)tinEdit;
// Report Node Count
message.AddMessage("Input Node Count: " + inputFeatureClass.FeatureCount(null).ToString());
message.AddMessage("TIN Node Count: " + tinNodeCollection.NodeCount.ToString());
// Open Output Feature Class
IFeatureClass outputFeatureClass = m_GPUtilities.OpenFeatureClassFromString(outputParameterValue.GetAsText());
// Debug Message
message.AddMessage("Generating Polygons...");
// Create Voronoi Polygons
tinNodeCollection.ConvertToVoronoiRegions(outputFeatureClass, null, clippingPolygon, "", "");
// Release COM Objects
tinEdit.StopEditing(false);
System.Runtime.InteropServices.Marshal.ReleaseComObject(tinNodeCollection);
System.Runtime.InteropServices.Marshal.ReleaseComObject(tinEdit);
}
catch (Exception ex)
{
message.AddError(2, ex.Message);
}
}
