// Maps the weasel files to their fgdb locations; key is weasel path and value is fgdb path
IDictionary <string, string> GetDictOfReqRasters(string aoiPath, FolderType fType)
{
IDictionary <string, string> dictRasters = new Dictionary <string, string>();
// surfaces layers
string surfacesGdb = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true);
string weaselPath = aoiPath + @"\output\surfaces\dem\filled\grid"; // Filled DEM
string gdbPath = surfacesGdb + Constants.FILE_DEM_FILLED;
dictRasters[weaselPath] = gdbPath;
weaselPath = aoiPath + @"\output\surfaces\dem\filled\aspect\grid"; // Aspect
gdbPath = surfacesGdb + Constants.FILE_ASPECT;
dictRasters[weaselPath] = gdbPath;
weaselPath = aoiPath + @"\output\surfaces\dem\filled\slope\grid"; // Slope
gdbPath = surfacesGdb + Constants.FILE_SLOPE;
dictRasters[weaselPath] = gdbPath;
weaselPath = aoiPath + @"\output\surfaces\dem\filled\flow-direction\flow-accumulation\grid"; // Flow accumulation
gdbPath = surfacesGdb + Constants.FILE_FLOW_ACCUMULATION;
dictRasters[weaselPath] = gdbPath;
weaselPath = aoiPath + @"\output\surfaces\dem\filled\flow-direction\grid"; // Flow direction
gdbPath = surfacesGdb + Constants.FILE_FLOW_DIRECTION;
dictRasters[weaselPath] = gdbPath;
// A couple of aoi layers
if (fType == FolderType.AOI)
{
string aoiGdb = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Aoi, true);
weaselPath = aoiPath + @"\aoib";
gdbPath = aoiGdb + Constants.FILE_AOI_BUFFERED_RASTER;
dictRasters[weaselPath] = gdbPath;
weaselPath = aoiPath + @"\p_aoi";
gdbPath = aoiGdb + Constants.FILE_AOI_PRISM_RASTER;
dictRasters[weaselPath] = gdbPath;
}
return(dictRasters);
}
IDictionary <string, string> GetDictOptWeaselRasters(string aoiPath, FolderType fType)
{
IDictionary <string, string> dictRasters = new Dictionary <string, string>();
string surfacesGdb = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true);
string layerPath = aoiPath + @"\output\surfaces\dem\grid";
string gdbPath = surfacesGdb + Constants.FILE_DEM;
dictRasters[layerPath] = gdbPath;
layerPath = aoiPath + @"\output\surfaces\dem\filled\hillshade\grid";
gdbPath = surfacesGdb + Constants.FILE_HILLSHADE;
dictRasters[layerPath] = gdbPath;
if (fType == FolderType.AOI)
{
// prism layers; optional because they can be reclipped
string[] arrPrismLayers = { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep",
"oct", "nov", "dec", "q1", "q2", "q3", "q4", "annual" };
string prismGdb = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Prism, true);
int i = 0;
foreach (var month in arrPrismLayers)
{
layerPath = aoiPath + @"\layers\PRISM\" + month + @"\grid";
PrismFile nextMonth = (PrismFile)i;
gdbPath = prismGdb + nextMonth.ToString();
dictRasters[layerPath] = gdbPath;
i++;
}
}
return(dictRasters);
}
public static async Task <IList <double> > GetDemStatsAsync(string aoiPath, string maskPath, double adjustmentFactor)
{
IList <double> returnList = new List <double>();
try
{
string sDemPath = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true) + Constants.FILE_DEM_FILLED;
double dblMin = -1;
var parameters = Geoprocessing.MakeValueArray(sDemPath, "MINIMUM");
var environments = Geoprocessing.MakeEnvironmentArray(workspace: aoiPath, mask: maskPath);
IGPResult gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory);
bool success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMin);
returnList.Add(dblMin - adjustmentFactor);
double dblMax = -1;
parameters = Geoprocessing.MakeValueArray(sDemPath, "MAXIMUM");
gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory);
success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMax);
returnList.Add(dblMax + adjustmentFactor);
}
catch (Exception e)
{
Module1.Current.ModuleLogManager.LogError(nameof(GetDemStatsAsync),
"Exception: " + e.Message);
}
return(returnList);
}
public static async Task <IList <double> > GetDemStatsAsync(string aoiPath, double adjustmentFactor)
{
IList <double> returnList = new List <double>();
try
{
string sMask = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Aoi, true) + Constants.FILE_AOI_VECTOR;
string sDemPath = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Surfaces, true) + Constants.FILE_DEM_FILLED;
double dblMin = -1;
var parameters = Geoprocessing.MakeValueArray(sDemPath, "MINIMUM");
var environments = Geoprocessing.MakeEnvironmentArray(workspace: aoiPath, mask: sMask);
IGPResult gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments,
ArcGIS.Desktop.Framework.Threading.Tasks.CancelableProgressor.None, GPExecuteToolFlags.AddToHistory);
bool success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMin);
returnList.Add(dblMin - adjustmentFactor);
double dblMax = -1;
parameters = Geoprocessing.MakeValueArray(sDemPath, "MAXIMUM");
gpResult = await Geoprocessing.ExecuteToolAsync("GetRasterProperties_management", parameters, environments,
ArcGIS.Desktop.Framework.Threading.Tasks.CancelableProgressor.None, GPExecuteToolFlags.AddToHistory);
success = Double.TryParse(Convert.ToString(gpResult.ReturnValue), out dblMax);
returnList.Add(dblMax + adjustmentFactor);
}
catch (Exception e)
{
Debug.WriteLine("GetDemStatsAsync: " + e.Message);
}
return(returnList);
}
public static async Task <double> CalculateTotalPolygonAreaAsync(Uri gdbUri, string featureClassName)
{
double dblRetVal = 0;
try
{
bool bExists = await GeodatabaseTools.FeatureClassExistsAsync(gdbUri, featureClassName);
if (!bExists)
{
return(dblRetVal);
}
await QueuedTask.Run(() =>
{
using (Geodatabase geodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(gdbUri)))
using (Table table = geodatabase.OpenDataset <Table>(featureClassName))
{
QueryFilter queryFilter = new QueryFilter();
using (RowCursor aCursor = table.Search(queryFilter, false))
{
while (aCursor.MoveNext())
{
using (Feature feature = (Feature)aCursor.Current)
{
var geometry = feature.GetShape();
var area = GeometryEngine.Instance.Area(geometry);
dblRetVal = dblRetVal + area;
}
}
}
}
});
}
catch (Exception e)
{
Module1.Current.ModuleLogManager.LogError(nameof(CalculateTotalPolygonAreaAsync),
"Exception: " + e.Message);
dblRetVal = -1;
}
return(dblRetVal);
}
public static async Task <FolderType> GetAoiFolderTypeAsync(string folderPath)
{
Uri gdbUri = new Uri(GetGeodatabasePath(folderPath, GeodatabaseNames.Aoi, false));
if (System.IO.Directory.Exists(gdbUri.LocalPath))
{
Uri uriToCheck = new Uri(gdbUri.LocalPath + Constants.FILE_AOI_RASTER);
bool bExists = await GeodatabaseTools.RasterDatasetExistsAsync(gdbUri, Constants.FILE_AOI_RASTER);
if (bExists)
{
return(FolderType.AOI);
}
bExists = await FeatureClassExistsAsync(gdbUri, Constants.FILE_AOI_VECTOR);
if (bExists)
{
return(FolderType.BASIN);
}
}
return(FolderType.FOLDER);
}
IDictionary <string, string> GetDictOfReqWeaselVectors(string aoiPath, FolderType fType)
{
IDictionary <string, string> dictVectors = new Dictionary <string, string>();
string aoiGdb = GeodatabaseTools.GetGeodatabasePath(aoiPath, GeodatabaseNames.Aoi, true);
string layerPath = aoiPath + @"\aoi_v.shp";
string gdbPath = aoiGdb + Constants.FILE_AOI_VECTOR;
dictVectors[layerPath] = gdbPath;
if (fType == FolderType.AOI)
{
layerPath = aoiPath + @"\aoib_v.shp";
gdbPath = aoiGdb + Constants.FILE_AOI_BUFFERED_VECTOR;
dictVectors[layerPath] = gdbPath;
layerPath = aoiPath + @"\p_aoi_v.shp";
gdbPath = aoiGdb + Constants.FILE_AOI_PRISM_VECTOR;
dictVectors[layerPath] = gdbPath;
layerPath = aoiPath + @"\pourpoint.shp";
gdbPath = aoiGdb + Constants.FILE_POURPOINT;
dictVectors[layerPath] = gdbPath;
}
return(dictVectors);
}
private async void RunImplAsync(object param)
{
// Create initial log entry
string strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Starting batch tool to publish in " +
Path.GetDirectoryName(_strLogFile) + "\r\n";
File.WriteAllText(_strLogFile, strLogEntry); // overwrite file if it exists
// Check for existing map package files and warn user
if (ArchiveChecked)
{
string[] filePaths = Directory.GetFiles(AoiFolder + "\\" + Constants.FOLDER_MAP_PACKAGE, "*.pdf",
SearchOption.TopDirectoryOnly);
if (filePaths.Length > 0)
{
System.Windows.MessageBoxResult res = ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("BAGIS-PRO found at least one .pdf document in the " +
"maps\\publish folder. These document(s) may be overwritten during the batch process. Uncheck " +
"the 'Copy Reports' checkbox to stop copying documents to the maps\\publish folder. " +
"The map packages will still be created in each AOI. Do you wish to continue and overwrite " +
"the documents ?", "BAGIS-PRO",
System.Windows.MessageBoxButton.YesNo);
if (res != System.Windows.MessageBoxResult.Yes)
{
return;
}
}
}
// Save off the publisher name if it is different than previous
string strPublisher = (string)Module1.Current.BatchToolSettings.Publisher;
if (!Publisher.Trim().Equals(strPublisher))
{
Module1.Current.BatchToolSettings.Publisher = Publisher;
String json = JsonConvert.SerializeObject(Module1.Current.BatchToolSettings, Formatting.Indented);
File.WriteAllText(SettingsFile, json);
}
// Make directory for required folders if they don't exist
// Make sure that maps and maps_publish folders exist
for (int idxRow = 0; idxRow < Names.Count; idxRow++)
{
if (Names[idxRow].AoiBatchIsSelected)
{
int errorCount = 0; // keep track of any non-fatal errors
AoiFolder = Names[idxRow].FilePath;
Names[idxRow].AoiBatchStateText = AoiBatchState.Started.ToString(); // update gui
string[] arrFolders = { AoiFolder + "\\" + Constants.FOLDER_MAPS, AoiFolder + "\\" + Constants.FOLDER_MAP_PACKAGE,
AoiFolder + "\\" + Constants.FOLDER_LOGS };
foreach (var directory in arrFolders)
{
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
}
// Set logger to AOI directory
string logFolderName = AoiFolder + "\\" + Constants.FOLDER_LOGS;
Module1.Current.ModuleLogManager.UpdateLogFileLocation(logFolderName);
// Set current AOI
BA_Objects.Aoi oAoi = await GeneralTools.SetAoiAsync(AoiFolder);
if (Module1.Current.CboCurrentAoi != null)
{
FrameworkApplication.Current.Dispatcher.Invoke(() =>
{
// Do something on the GUI thread
Module1.Current.CboCurrentAoi.SetAoiName(oAoi.Name);
});
}
// Create opening log entry for AOI
strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Starting batch PDF export for " +
oAoi.Name + "\r\n";
File.AppendAllText(_strLogFile, strLogEntry); // append
// Bring GP History tool forward
var cmdShowHistory = FrameworkApplication.GetPlugInWrapper("esri_geoprocessing_showToolHistory") as ICommand;
if (cmdShowHistory != null)
{
if (cmdShowHistory.CanExecute(null))
{
cmdShowHistory.Execute(null);
}
}
oAoi = Module1.Current.Aoi;
// Elevation zones
BA_ReturnCode success = await AnalysisTools.CalculateElevationZonesAsync(Module1.Current.Aoi.FilePath);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Slope zones
string strLayer = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Surfaces, true) +
Constants.FILE_SLOPE;
string strZonesRaster = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Analysis, true) +
Constants.FILE_SLOPE_ZONE;
string strMaskPath = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Aoi, true) + Constants.FILE_AOI_BUFFERED_VECTOR;
IList <BA_Objects.Interval> lstInterval = AnalysisTools.GetSlopeClasses();
success = await AnalysisTools.CalculateZonesAsync(AoiFolder, strLayer,
lstInterval, strZonesRaster, strMaskPath, "SLOPE");
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Check for PRISM buffer units
string[] arrPrismBufferInfo = await GeneralTools.QueryBufferDistanceAsync(AoiFolder, GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Aoi),
Constants.FILE_AOI_PRISM_VECTOR, false);
string pBufferDistance = arrPrismBufferInfo[0];
string pBufferUnits = arrPrismBufferInfo[1];
// Clip PRISM
string strDefaultBufferDistance = (string)Module1.Current.BatchToolSettings.PrecipBufferDistance;
string strDefaultBufferUnits = (string)Module1.Current.BatchToolSettings.PrecipBufferUnits;
success = await AnalysisTools.ClipLayersAsync(AoiFolder, Constants.DATA_TYPE_PRECIPITATION,
pBufferDistance, pBufferUnits, strDefaultBufferDistance, strDefaultBufferUnits);
if (success == BA_ReturnCode.Success)
{
success = await AnalysisTools.UpdateSitesPropertiesAsync(Module1.Current.Aoi.FilePath, SiteProperties.Precipitation);
}
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// PRISM Zones
strLayer = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Prism, true) +
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile);
strZonesRaster = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_PRECIP_ZONE;
success = await AnalysisTools.CalculatePrecipitationZonesAsync(strLayer, strZonesRaster);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Winter Precipitation
success = await AnalysisTools.GenerateWinterPrecipitationLayerAsync(oAoi);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Clip SWE
success = await AnalysisTools.ClipSweLayersAsync(pBufferDistance, pBufferUnits,
strDefaultBufferDistance, strDefaultBufferUnits);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Generate SWE Delta Layers
success = await AnalysisTools.CalculateSWEDeltaAsync(AoiFolder);
// Clip Snotel and Snow Course
double dblDistance = -1;
bool isDouble = Double.TryParse((string)Module1.Current.BatchToolSettings.SnotelBufferDistance, out dblDistance);
if (!isDouble)
{
dblDistance = 0;
}
Module1.Current.ModuleLogManager.LogDebug(nameof(RunImplAsync), "Buffer distance from settings: " + dblDistance);
string snoBufferDistance = dblDistance + " " + (string)Module1.Current.BatchToolSettings.SnotelBufferUnits;
Module1.Current.ModuleLogManager.LogDebug(nameof(RunImplAsync), "Sites buffer distance string: " + snoBufferDistance);
success = await AnalysisTools.ClipSnoLayersAsync(Module1.Current.Aoi.FilePath, true, snoBufferDistance,
true, snoBufferDistance);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Represented Area
if (success == BA_ReturnCode.Success)
{
double siteBufferDistanceMiles = (double)Module1.Current.BatchToolSettings.SiteBufferDistMiles;
double siteElevRangeFeet = (double)Module1.Current.BatchToolSettings.SiteElevRangeFeet;
success = await AnalysisTools.GenerateSiteLayersAsync(siteBufferDistanceMiles, siteElevRangeFeet);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Sites Zones
Uri uri = new Uri(GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers));
bool hasSnotel = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_SNOTEL);
bool hasSnowCourse = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_SNOW_COURSE);
if (hasSnotel || hasSnowCourse)
{
success = await AnalysisTools.CalculateSitesZonesAsync(Module1.Current.Aoi.FilePath, hasSnotel, hasSnowCourse);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
}
else
{
Module1.Current.ModuleLogManager.LogError(nameof(CmdRun),
"No sites found to create sites zone layers!!");
}
}
// Precipitation Contribution; Passing in -1 for threshold so we use STDEV
success = await AnalysisTools.CalculatePrecipitationContributionAsync(Module1.Current.Aoi.FilePath, -1);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Quarterly Precipitation Contribution
success = await AnalysisTools.CalculateQuarterlyPrecipitationAsync(Module1.Current.Aoi);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
// Aspect zones
success = await AnalysisTools.CalculateAspectZonesAsync();
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
string[] arrUnmanagedBufferInfo = await GeneralTools.QueryBufferDistanceAsync(AoiFolder, GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Aoi),
Constants.FILE_AOI_BUFFERED_VECTOR, false);
string unmanagedBufferDistance = arrPrismBufferInfo[0];
string unmanagedBufferUnits = arrPrismBufferInfo[1];
if (SiteAnalysisChecked)
{
// Clip Roads
string strOutputFc = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Layers, true)
+ Constants.FILE_ROADS;
success = await AnalysisTools.ClipFeatureLayerAsync(AoiFolder, strOutputFc, Constants.DATA_TYPE_ROADS,
unmanagedBufferDistance, unmanagedBufferUnits);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
if (success == BA_ReturnCode.Success)
{
// Buffer clipped roads for analysis
Uri uri = new Uri(GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Layers));
bool bExists = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_ROADS);
if (!bExists)
{
Module1.Current.ModuleLogManager.LogDebug(nameof(CmdRun),
"Unable to buffer roads because fs_roads layer does not exist. Process stopped!!");
}
else
{
string strDistance = Module1.Current.BatchToolSettings.RoadsAnalysisBufferDistance + " " +
Module1.Current.BatchToolSettings.RoadsAnalysisBufferUnits;
success = await AnalysisTools.GenerateProximityRoadsLayerAsync(uri, strDistance);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
}
}
// Clip public lands
strOutputFc = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Layers, true)
+ Constants.FILE_PUBLIC_LAND;
success = await AnalysisTools.ClipFeatureLayerAsync(AoiFolder, strOutputFc, Constants.DATA_TYPE_PUBLIC_LAND,
unmanagedBufferDistance, unmanagedBufferUnits);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
if (success == BA_ReturnCode.Success)
{
// Create public lands layer for potential site analysis
success = await AnalysisTools.GetFederalNonWildernessLandsAsync(AoiFolder);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
}
// Clip Vegetation layer
string strOutputRaster = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Layers, true)
+ Constants.FILE_VEGETATION_EVT;
success = await AnalysisTools.ClipRasterLayerAsync(AoiFolder, strOutputRaster, Constants.DATA_TYPE_VEGETATION,
unmanagedBufferDistance, unmanagedBufferUnits);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
if (success == BA_ReturnCode.Success)
{
// Create area below treeline layer for potential site analysis
success = await AnalysisTools.ExtractBelowTreelineAsync(AoiFolder);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
}
// Generate Potential Sites layer
success = await AnalysisTools.CalculatePotentialSitesAreaAsync(AoiFolder);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
}
// Clip Land cover
success = await AnalysisTools.ClipLandCoverAsync(AoiFolder, unmanagedBufferDistance, unmanagedBufferUnits);
// Generate Elevation Precipitation Correlation layer
strLayer = GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Prism, true) +
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile);
Uri uriPrism = new Uri(GeodatabaseTools.GetGeodatabasePath(AoiFolder, GeodatabaseNames.Prism));
success = await AnalysisTools.CalculateElevPrecipCorrAsync(AoiFolder, uriPrism,
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile));
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
if (success == BA_ReturnCode.Success)
{
Module1.Current.ModuleLogManager.LogDebug(nameof(CmdRun),
"Generated Elevation Precipitation Correlation layer");
}
// Generate complete PDF document
try
{
// Delete any old PDF files
//string[] arrAllPdfFiles = new string[Constants.FILES_EXPORT_WATERSHED_PDF.Length + FILES_EXPORT_SITE_ANALYSIS_PDF.Length];
//Array.Copy(Constants.FILES_EXPORT_WATERSHED_PDF, arrAllPdfFiles, Constants.FILES_EXPORT_WATERSHED_PDF.Length);
//Array.Copy(Constants.FILES_EXPORT_SITE_ANALYSIS_PDF, 0, arrAllPdfFiles,
// Constants.FILES_EXPORT_WATERSHED_PDF.Length, Constants.FILES_EXPORT_SITE_ANALYSIS_PDF.Length);
foreach (var item in Constants.FILES_EXPORT_WATERSHED_PDF)
{
string strPath = Module1.Current.Aoi.FilePath + "\\" + Constants.FOLDER_MAP_PACKAGE
+ "\\" + item;
if (System.IO.File.Exists(strPath))
{
try
{
System.IO.File.Delete(strPath);
}
catch (Exception)
{
System.Windows.MessageBoxResult res =
MessageBox.Show("Unable to delete file before creating new pdf. Do you want to close the file and try again?",
"BAGIS-PRO", System.Windows.MessageBoxButton.YesNo);
if (res == System.Windows.MessageBoxResult.Yes)
{
return;
}
}
}
}
Layout oLayout = await MapTools.GetDefaultLayoutAsync(Constants.MAPS_DEFAULT_LAYOUT_NAME);
// Always load the maps in case we are running through multiple Aois
success = await MapTools.DisplayMaps(Module1.Current.Aoi.FilePath, oLayout, false);
if (success != BA_ReturnCode.Success)
{
MessageBox.Show("Unable to load maps. The map package cannot be exported!!", "BAGIS-PRO");
Names[idxRow].AoiBatchStateText = AoiBatchState.Failed.ToString();
return;
}
// Legend
success = await MapTools.DisplayLegendAsync(Constants.MAPS_DEFAULT_MAP_FRAME_NAME, oLayout,
"ArcGIS Colors", "1.5 Point", true);
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
if (oLayout != null)
{
bool bFoundIt = false;
//A layout view may exist but it may not be active
//Iterate through each pane in the application and check to see if the layout is already open and if so, activate it
foreach (var pane in FrameworkApplication.Panes)
{
if (!(pane is ILayoutPane layoutPane)) //if not a layout view, continue to the next pane
{
continue;
}
if (layoutPane.LayoutView != null &&
layoutPane.LayoutView.Layout == oLayout) //if there is a match, activate the view
{
(layoutPane as Pane).Activate();
bFoundIt = true;
}
}
if (!bFoundIt)
{
await FrameworkApplication.Current.Dispatcher.Invoke(async() =>
{
// Do something on the GUI thread
ILayoutPane iNewLayoutPane = await FrameworkApplication.Panes.CreateLayoutPaneAsync(oLayout); //GUI thread
(iNewLayoutPane as Pane).Activate();
});
}
}
success = await MapTools.PublishMapsAsync(ReportType.Watershed); // export the watershed maps to pdf
if (success != BA_ReturnCode.Success)
{
MessageBox.Show("An error occurred while generating the watershed characteristics maps!!", "BAGIS-PRO");
errorCount++;
}
//if (SiteAnalysisChecked)
//{
// success = await MapTools.PublishMapsAsync(ReportType.SiteAnalysis); // export the site analysis maps to pdf
// if (success != BA_ReturnCode.Success)
// {
// MessageBox.Show("An error occurred while generating the site analysis maps!!", "BAGIS-PRO");
// errorCount++;
// }
//}
success = await GeneralTools.GenerateTablesAsync(false); // export the tables to pdf
if (success != BA_ReturnCode.Success)
{
MessageBox.Show("An error occurred while generating the Excel tables!!", "BAGIS-PRO");
errorCount++;
}
else
{
// Generate the crtical precip map; It has to follow the tables
Uri uriAnalysis = new Uri(GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Analysis));
if (await GeodatabaseTools.FeatureClassExistsAsync(uriAnalysis, Constants.FILE_CRITICAL_PRECIP_ZONE))
{
success = await MapTools.DisplayCriticalPrecipitationZonesMap(uriAnalysis);
string strButtonState = "MapButtonPalette_BtnCriticalPrecipZone_State";
if (success.Equals(BA_ReturnCode.Success))
{
Module1.ActivateState(strButtonState);
}
int foundS1 = strButtonState.IndexOf("_State");
string strMapButton = strButtonState.Remove(foundS1);
ICommand cmd = FrameworkApplication.GetPlugInWrapper(strMapButton) as ICommand;
Module1.Current.ModuleLogManager.LogDebug(nameof(RunImplAsync),
"About to toggle map button " + strMapButton);
if ((cmd != null))
{
do
{
await Task.Delay(TimeSpan.FromSeconds(0.4)); // build in delay until the command can execute
}while (!cmd.CanExecute(null));
cmd.Execute(null);
}
do
{
await Task.Delay(TimeSpan.FromSeconds(0.4)); // build in delay so maps can load
}while (Module1.Current.MapFinishedLoading == false);
success = await GeneralTools.ExportMapToPdfAsync(150); // export map to pdf
if (success == BA_ReturnCode.Success)
{
// append the map and chart together for posting
IList <string> lstToConcat = new List <string>();
lstToConcat.Add(GeneralTools.GetFullPdfFileName(Constants.FILE_EXPORT_MAP_CRITICAL_PRECIPITATION_ZONES_PDF));
lstToConcat.Add(GeneralTools.GetFullPdfFileName(Constants.FILE_EXPORT_TABLE_PRECIP_REPRESENT_PDF));
success = GeneralTools.ConcatenatePagesInPdf(GeneralTools.GetFullPdfFileName(Constants.FILE_EXPORT_CRITICAL_PRECIPITATION_ZONES_PDF),
lstToConcat);
}
else
{
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
"Unable to generate critical precipitation zones map!!");
}
}
}
success = await GeneralTools.GenerateSitesTableAsync(Module1.Current.Aoi);
success = await GeneralTools.GenerateMapsTitlePageAsync(ReportType.Watershed, strPublisher, Comments);
if (success != BA_ReturnCode.Success)
{
MessageBox.Show("An error occurred while generating the Title page!!", "BAGIS-PRO");
errorCount++;
}
string outputPath = GeneralTools.GetFullPdfFileName(Constants.FILE_EXPORT_WATERSHED_REPORT_PDF);
success = GeneralTools.PublishFullPdfDocument(outputPath, ReportType.Watershed); // Put it all together into a single pdf document
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
//if (SiteAnalysisChecked)
//{
// success = await GeneralTools.GenerateMapsTitlePageAsync(ReportType.SiteAnalysis, strPublisher, Comments);
// outputPath = GeneralTools.GetFullPdfFileName(Constants.FILE_EXPORT_SITE_ANALYSIS_REPORT_PDF);
// success = GeneralTools.PublishFullPdfDocument(outputPath, ReportType.SiteAnalysis); // Put it all together into a single pdf document
//}
if (success != BA_ReturnCode.Success)
{
errorCount++;
}
else if (ArchiveChecked)
{
string reportName = Constants.FILE_EXPORT_WATERSHED_REPORT_PDF;
// Copy final watershed analysis report to a central location
if (File.Exists(outputPath))
{
File.Copy(outputPath, GeneralTools.GetFullPdfFileName(reportName), true);
}
//if (SiteAnalysisChecked)
//{
// reportName = Constants.FILE_EXPORT_SITE_ANALYSIS_REPORT_PDF;
// File.Copy(outputPath, GeneralTools.GetFullPdfFileName(reportName), true);
//}
}
// Create closing log entry for AOI
if (errorCount == 0)
{
strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Completed batch PDF export for " +
oAoi.Name + ". The output is located at " + oAoi.FilePath + "\\" + Constants.FOLDER_MAP_PACKAGE + "\r\n";
Names[idxRow].AoiBatchStateText = AoiBatchState.Completed.ToString();
}
else
{
strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Completed batch PDF export WITH ERRORS for " +
oAoi.Name + ". The output is located at " + oAoi.FilePath + "\\" + Constants.FOLDER_MAP_PACKAGE + "\r\n" +
"Check for errors in the logs at " + oAoi.FilePath + "\\" + Constants.FOLDER_LOGS + "! \r\n";
Names[idxRow].AoiBatchStateText = AoiBatchState.Errors.ToString();
}
File.AppendAllText(_strLogFile, strLogEntry);
}
catch (Exception e)
{
MessageBox.Show("An error occurred while running the Batch PDF Tool!! " + e.Message, "BAGIS PRO");
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
e.StackTrace);
strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Batch PDF export failed for " +
oAoi.Name + ". Check for errors in the logs at " + oAoi.FilePath + "\\" + Constants.FOLDER_LOGS + "!\r\n";
File.AppendAllText(_strLogFile, strLogEntry);
Names[idxRow].AoiBatchStateText = AoiBatchState.Failed.ToString();
}
}
}
MessageBox.Show("Done!");
// Concluding log entry
strLogEntry = DateTime.Now.ToString("MM/dd/yy H:mm:ss ") + "Batch tool finished!! \r\n";
using (StreamWriter sw = File.AppendText(_strLogFile))
{
sw.WriteLine(strLogEntry);
}
}
private async Task ClipLayersAsync(bool clipSwe, bool clipPrism, bool clipSnotel, bool clipSnowCos,
bool clipRoads, bool clipPublicLands, bool clipVegetation, bool clipLandcover)
{
try
{
if (String.IsNullOrEmpty(Module1.Current.Aoi.Name))
{
MessageBox.Show("No AOI selected for analysis !!", "BAGIS-PRO");
return;
}
if (clipSwe == false && clipPrism == false &&
clipSnotel == false && clipSnowCos == false && clipRoads == false &&
clipPublicLands == false && clipVegetation == false && clipLandcover == false)
{
MessageBox.Show("No layers selected to clip !!", "BAGIS-PRO");
return;
}
var cmdShowHistory = FrameworkApplication.GetPlugInWrapper("esri_geoprocessing_showToolHistory") as ICommand;
if (cmdShowHistory != null)
{
if (cmdShowHistory.CanExecute(null))
{
cmdShowHistory.Execute(null);
}
}
var layersPane = (DockpaneLayersViewModel)FrameworkApplication.DockPaneManager.Find("bagis_pro_DockpaneLayers");
BA_ReturnCode success = BA_ReturnCode.Success;
// Check for PRISM units
string strPrismPath = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Prism, true)
+ PrismFile.Annual.ToString();
string pBufferDistance = "";
string pBufferUnits = "";
string strBagisTag = await GeneralTools.GetBagisTagAsync(strPrismPath, Constants.META_TAG_XPATH);
if (!string.IsNullOrEmpty(strBagisTag))
{
pBufferDistance = GeneralTools.GetValueForKey(strBagisTag, Constants.META_TAG_BUFFER_DISTANCE, ';');
pBufferUnits = GeneralTools.GetValueForKey(strBagisTag, Constants.META_TAG_XUNIT_VALUE, ';');
}
// Apply default buffer if left null
if (string.IsNullOrEmpty(PrismBufferDistance))
{
PrismBufferDistance = (string)Module1.Current.BatchToolSettings.PrecipBufferDistance;
PrismBufferUnits = (string)Module1.Current.BatchToolSettings.PrecipBufferUnits;
}
if (clipPrism)
{
success = await AnalysisTools.ClipLayersAsync(Module1.Current.Aoi.FilePath, Constants.DATA_TYPE_PRECIPITATION,
pBufferDistance, pBufferUnits, PrismBufferDistance, PrismBufferUnits);
if (success == BA_ReturnCode.Success)
{
success = await AnalysisTools.UpdateSitesPropertiesAsync(Module1.Current.Aoi.FilePath, SiteProperties.Precipitation);
}
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipPrism_Checked = false;
layersPane.Prism_Checked = true;
}
}
if (clipSwe)
{
success = await AnalysisTools.ClipSweLayersAsync(pBufferDistance, pBufferUnits,
SWEBufferDistance, SWEBufferUnits);
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipSwe_Checked = false;
layersPane.SWE_Checked = true;
}
}
if (clipSnotel || clipSnowCos)
{
string snotelBufferDistance = "";
string snowCosBufferDistance = "";
double dblDistance = -1;
bool isDouble = Double.TryParse(SnotelBufferDistance, out dblDistance);
if (clipSnotel && isDouble && dblDistance > 0)
{
snotelBufferDistance = SnotelBufferDistance + " " + SnotelBufferUnits;
}
isDouble = Double.TryParse(SnowCosBufferDistance, out dblDistance);
if (clipSnowCos && isDouble && dblDistance > 0)
{
snowCosBufferDistance = SnowCosBufferDistance + " " + SnowCosBufferUnits;
}
success = await AnalysisTools.ClipSnoLayersAsync(Module1.Current.Aoi.FilePath, clipSnotel, snotelBufferDistance,
clipSnowCos, snowCosBufferDistance);
if (success == BA_ReturnCode.Success)
{
if (clipSnotel)
{
layersPane.ReclipSNOTEL_Checked = false;
layersPane.SNOTEL_Checked = true;
}
if (clipSnowCos)
{
layersPane.ReclipSnowCos_Checked = false;
layersPane.SnowCos_Checked = true;
}
}
}
if (clipRoads)
{
string strOutputFc = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers, true)
+ Constants.FILE_ROADS;
success = await AnalysisTools.ClipFeatureLayerAsync(Module1.Current.Aoi.FilePath, strOutputFc, Constants.DATA_TYPE_ROADS,
RoadsBufferDistance, RoadsBufferUnits);
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipRoads_Checked = false;
layersPane.Roads_Checked = true;
}
else
{
MessageBox.Show("An error occurred while clipping the roads. Check the log file!!", "BAGIS-PRO");
}
}
if (clipPublicLands)
{
string strOutputFc = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers, true)
+ Constants.FILE_PUBLIC_LAND;
success = await AnalysisTools.ClipFeatureLayerAsync(Module1.Current.Aoi.FilePath, strOutputFc, Constants.DATA_TYPE_PUBLIC_LAND,
PublicLandsBufferDistance, PublicLandsBufferUnits);
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipPublicLands_Checked = false;
layersPane.PublicLands_Checked = true;
}
else
{
MessageBox.Show("An error occurred while clipping the public lands. Check the log file!!", "BAGIS-PRO");
}
}
if (clipVegetation)
{
string strOutputRaster = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers, true)
+ Constants.FILE_VEGETATION_EVT;
success = await AnalysisTools.ClipRasterLayerAsync(Module1.Current.Aoi.FilePath, strOutputRaster, Constants.DATA_TYPE_VEGETATION,
VegetationBufferDistance, VegetationBufferUnits);
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipVegetation_Checked = false;
layersPane.Vegetation_Checked = true;
}
else
{
MessageBox.Show("An error occurred while clipping the vegetation layer. Check the log file!!", "BAGIS-PRO");
}
}
if (clipLandcover)
{
success = await AnalysisTools.ClipLandCoverAsync(Module1.Current.Aoi.FilePath, LandCoverBufferDistance, LandCoverBufferUnits);
if (success == BA_ReturnCode.Success)
{
layersPane.ReclipLandCover_Checked = false;
layersPane.LandCover_Checked = true;
}
else
{
MessageBox.Show("An error occurred while clipping the land cover layer. Check the log file!!", "BAGIS-PRO");
}
}
if (success == BA_ReturnCode.Success)
{
MessageBox.Show("Analysis layers clipped!!", "BAGIS-PRO");
}
else
{
MessageBox.Show("An error occurred while trying to clip the layers !!", "BAGIS-PRO");
}
}
catch (Exception ex)
{
Module1.Current.ModuleLogManager.LogError(nameof(ClipLayersAsync),
"Exception: " + ex.Message);
}
}
private async void RunImplAsync(object param)
{
// Bring GP History tool forward
var cmdShowHistory = FrameworkApplication.GetPlugInWrapper("esri_geoprocessing_showToolHistory") as ICommand;
if (cmdShowHistory != null)
{
if (cmdShowHistory.CanExecute(null))
{
cmdShowHistory.Execute(null);
}
}
foreach (var oAoi in Names)
{
if (oAoi.AoiBatchIsSelected)
{
// Currently only support AOI conversion but BASIN may be added in future
FolderType fType = await GeodatabaseTools.GetWeaselAoiFolderTypeAsync(oAoi.FilePath);
IList <string> lstExistingGdb = null;
if (fType == FolderType.AOI)
{
lstExistingGdb = CheckForBagisGdb(oAoi.FilePath);
}
else
{
lstExistingGdb = CheckForBasinGdb(oAoi.FilePath);
}
// Make directory for log if it doesn't exist
if (!Directory.Exists(oAoi.FilePath + "\\" + Constants.FOLDER_LOGS))
{
DirectoryInfo info = Directory.CreateDirectory(oAoi.FilePath + "\\" + Constants.FOLDER_LOGS);
if (info == null)
{
MessageBox.Show("Unable to create logs directory in Aoi folder!!", "BAGIS-PRO");
}
}
// Set logger to AOI directory
string logFolderName = oAoi.FilePath + "\\" + Constants.FOLDER_LOGS;
Module1.Current.ModuleLogManager.UpdateLogFileLocation(logFolderName);
// Delete old geodatabases if they exist
foreach (var geodatabasePath in lstExistingGdb)
{
IGPResult gpResult = await QueuedTask.Run(() =>
{
var parameters = Geoprocessing.MakeValueArray(geodatabasePath);
return(Geoprocessing.ExecuteToolAsync("Delete_management", parameters, null,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory));
});
if (gpResult.IsFailed)
{
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
"Unable to delete geodatabase. Error code: " + gpResult.ErrorCode);
MessageBox.Show("Unable to delete geodatabase " + geodatabasePath + "!");
}
}
// Create new geodatabases
BA_ReturnCode success = await GeodatabaseTools.CreateGeodatabaseFoldersAsync(oAoi.FilePath, fType);
if (success == BA_ReturnCode.Success)
{
Module1.Current.ModuleLogManager.LogInfo(nameof(RunImplAsync),
"Created geodatabases in " + oAoi.FilePath);
}
else
{
MessageBox.Show("Unable to create geodatabases in " + oAoi.FilePath + ". Check logs!");
}
// Assemble a dictionary with rasters we want to copy
IDictionary <string, string> rastersToCopy = GetDictOfReqRasters(oAoi.FilePath, fType);
// Accomodate two possible names for raster aoi boundary layer (aoibagis or aoi)
IList <string> lstTest = new List <string>
{
oAoi.FilePath + @"\aoibagis"
};
string aoiGdb = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Aoi, true);
IList <string> existingLayers = null;
if (fType == FolderType.AOI)
{
existingLayers = await GeneralTools.RasterDatasetsExistAsync(lstTest);
if (existingLayers.Count == 0)
{
lstTest.Clear();
string strLayer = oAoi.FilePath + @"\aoi";
lstTest.Add(strLayer);
existingLayers = await GeneralTools.RasterDatasetsExistAsync(lstTest);
if (existingLayers.Count > 0)
{
rastersToCopy[strLayer] = aoiGdb + Constants.FILE_AOI_RASTER;
}
}
else
{
rastersToCopy[oAoi.FilePath + @"\aoibagis"] = aoiGdb + Constants.FILE_AOI_RASTER;
}
}
// Check to see if optional layers are present
IDictionary <string, string> optRasterDict = GetDictOptWeaselRasters(oAoi.FilePath, fType);
existingLayers = await GeneralTools.RasterDatasetsExistAsync(optRasterDict.Keys);
foreach (var layerPath in existingLayers)
{
string gdbPath = optRasterDict[layerPath];
rastersToCopy[layerPath] = gdbPath;
}
// Raster layers with non-deterministic names in analysis and layers folders
string strWeaselFolder = oAoi.FilePath + @"\layers";
string strGdbPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Layers, true);
IList <string> lstRasters = await GeneralTools.GetLayersInFolderAsync(strWeaselFolder, "Raster Dataset");
foreach (var item in lstRasters)
{
rastersToCopy[strWeaselFolder + "\\" + item] = strGdbPath + item;
}
strWeaselFolder = oAoi.FilePath + @"\analysis";
strGdbPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true);
lstRasters = await GeneralTools.GetLayersInFolderAsync(strWeaselFolder, "Raster Dataset");
foreach (var item in lstRasters)
{
rastersToCopy[strWeaselFolder + "\\" + item] = strGdbPath + item;
}
// Use Geoprocessor to copy the files
int errorCount = 0;
foreach (var key in rastersToCopy.Keys)
{
IGPResult gpResult = await QueuedTask.Run(() =>
{
var environments = Geoprocessing.MakeEnvironmentArray(workspace: oAoi.FilePath, cellSize: "MINOF");
var parameters = Geoprocessing.MakeValueArray(key, rastersToCopy[key]);
return(Geoprocessing.ExecuteToolAsync("CopyRaster_management", parameters, null,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory));
});
if (gpResult.IsFailed)
{
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
"Failed to copy raster " + key + "!");
errorCount++;
}
}
Module1.Current.ModuleLogManager.LogDebug(nameof(RunImplAsync),
"Raster copy completed with " + errorCount + " errors.");
// Assemble a dictionary with vectors we want to copy
IDictionary <string, string> vectorsToCopy = GetDictOfReqWeaselVectors(oAoi.FilePath, fType);
// Check for an optional vector
lstTest.Clear();
lstTest.Add(oAoi.FilePath + @"\unsnappedpp.shp");
existingLayers = await GeneralTools.ShapefilesExistAsync(lstTest);
if (existingLayers.Count > 0)
{
vectorsToCopy[oAoi.FilePath + @"\unsnappedpp.shp"] = aoiGdb + Constants.FILE_UNSNAPPED_POURPOINT;
}
// Vector layers with non-deterministic names in analysis and layers folders
strWeaselFolder = oAoi.FilePath + @"\layers";
strGdbPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Layers, true);
IList <string> lstVectors = await GeneralTools.GetLayersInFolderAsync(strWeaselFolder, "Shapefile");
foreach (var item in lstVectors)
{
string noExtension = Path.GetFileNameWithoutExtension(item);
vectorsToCopy[strWeaselFolder + "\\" + item] = strGdbPath + noExtension;
}
strWeaselFolder = oAoi.FilePath + @"\analysis";
strGdbPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true);
lstVectors = await GeneralTools.GetLayersInFolderAsync(strWeaselFolder, "Shapefile");
foreach (var item in lstVectors)
{
string noExtension = Path.GetFileNameWithoutExtension(item);
vectorsToCopy[strWeaselFolder + "\\" + item] = strGdbPath + noExtension;
}
// Use Geoprocessor to copy the files
errorCount = 0;
foreach (var entry in vectorsToCopy)
{
string strKey = entry.Key;
}
string strTempFile = Path.GetFileName("tmpVector");
string strDirectory = "";
foreach (var entry in vectorsToCopy)
{
IGPResult gpResult = await QueuedTask.Run(() =>
{
var environments = Geoprocessing.MakeEnvironmentArray(workspace: oAoi.FilePath);
strDirectory = Path.GetDirectoryName(entry.Value);
var parameters = Geoprocessing.MakeValueArray(entry.Key, strDirectory, strTempFile);
return(Geoprocessing.ExecuteToolAsync("FeatureClassToFeatureClass_conversion", parameters, null,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory));
});
if (gpResult.IsFailed)
{
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
"Failed to convert vector " + entry.Key + "!");
errorCount++;
}
else
{
//There is a bug with using converted shapefiles in Pro; We need to rename the converted file
//so that functions related to extent work
gpResult = await QueuedTask.Run(() =>
{
var environments = Geoprocessing.MakeEnvironmentArray(workspace: oAoi.FilePath);
strDirectory = Path.GetDirectoryName(entry.Value);
var parameters = Geoprocessing.MakeValueArray(strDirectory + "\\" + strTempFile, entry.Value);
return(Geoprocessing.ExecuteToolAsync("Rename_management", parameters, null,
CancelableProgressor.None, GPExecuteToolFlags.AddToHistory));
});
if (gpResult.IsFailed)
{
Module1.Current.ModuleLogManager.LogError(nameof(RunImplAsync),
"Failed to copy feature class " + entry.Key + "!");
errorCount++;
}
}
}
Module1.Current.ModuleLogManager.LogDebug(nameof(RunImplAsync),
"Vector copy completed with " + errorCount + " errors.");
}
}
MessageBox.Show("Done!");
}
private async Task GenerateLayersAsync(bool calculateRepresented, bool calculatePrism, bool calculateAspect,
bool calculateSlope, bool calculateElevation, bool bufferRoads, bool extractPublicLand,
bool extractBelowTreeline, bool elevPrecipCorr, bool calculateSitesZones, bool calculateSweDelta,
bool calculatePrecipContrib, bool winterPrecip)
{
try
{
if (String.IsNullOrEmpty(Module1.Current.Aoi.Name))
{
MessageBox.Show("No AOI selected for analysis !!", "BAGIS-PRO");
return;
}
if (calculateRepresented == false && calculatePrism == false && calculateAspect == false &&
calculateSlope == false && calculateElevation == false && bufferRoads == false &&
extractPublicLand == false && extractBelowTreeline == false && elevPrecipCorr == false &&
calculateSitesZones == false && calculateSweDelta == false && calculatePrecipContrib == false &&
winterPrecip == false)
{
MessageBox.Show("No layers selected to generate !!", "BAGIS-PRO");
return;
}
var cmdShowHistory = FrameworkApplication.GetPlugInWrapper("esri_geoprocessing_showToolHistory") as ICommand;
if (cmdShowHistory != null)
{
if (cmdShowHistory.CanExecute(null))
{
cmdShowHistory.Execute(null);
}
}
var layersPane = (DockAnalysisLayersViewModel)FrameworkApplication.DockPaneManager.Find("bagis_pro_DockAnalysisLayers");
BA_ReturnCode success = BA_ReturnCode.Success;
if (calculateRepresented)
{
double siteBufferDistanceMiles = (double)Module1.Current.BatchToolSettings.SiteBufferDistMiles;
double siteElevRangeFeet = (double)Module1.Current.BatchToolSettings.SiteElevRangeFeet;
success = await AnalysisTools.GenerateSiteLayersAsync(siteBufferDistanceMiles, siteElevRangeFeet);
if (success == BA_ReturnCode.Success)
{
layersPane.RepresentedArea_Checked = false;
}
}
if (calculatePrism)
{
string strLayer = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Prism, true) +
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile);
string strZonesRaster = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_PRECIP_ZONE;
success = await AnalysisTools.CalculatePrecipitationZonesAsync(strLayer, strZonesRaster);
if (success == BA_ReturnCode.Success)
{
layersPane.PrismZones_Checked = false;
}
}
if (calculateAspect)
{
success = await AnalysisTools.CalculateAspectZonesAsync();
if (success == BA_ReturnCode.Success)
{
layersPane.AspectZones_Checked = false;
}
}
if (calculateSlope)
{
string strLayer = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Surfaces, true) +
Constants.FILE_SLOPE;
string strZonesRaster = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_SLOPE_ZONE;
string strMaskPath = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Aoi, true) + Constants.FILE_AOI_BUFFERED_VECTOR;
IList <BA_Objects.Interval> lstInterval = AnalysisTools.GetSlopeClasses();
success = await AnalysisTools.CalculateZonesAsync(Module1.Current.Aoi.FilePath, strLayer,
lstInterval, strZonesRaster, strMaskPath, "SLOPE");
if (success == BA_ReturnCode.Success)
{
layersPane.SlopeZones_Checked = false;
}
}
if (calculateElevation)
{
success = await AnalysisTools.CalculateElevationZonesAsync(Module1.Current.Aoi.FilePath);
if (success == BA_ReturnCode.Success)
{
layersPane.ElevationZones_Checked = false;
}
}
if (calculateSitesZones)
{
Uri uri = new Uri(GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers));
bool hasSnotel = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_SNOTEL);
bool hasSnowCourse = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_SNOW_COURSE);
if (hasSnotel || hasSnowCourse)
{
success = await AnalysisTools.CalculateSitesZonesAsync(Module1.Current.Aoi.FilePath, hasSnotel, hasSnowCourse);
}
else
{
MessageBox.Show("No sites found to create sites zone layers!!", "BAGIS-PRO");
}
if (success == BA_ReturnCode.Success)
{
layersPane.SitesZones_Checked = false;
}
}
bool bSkipPotentialSites = false;
if (bufferRoads)
{
Uri uri = new Uri(GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Layers));
bool bExists = await GeodatabaseTools.FeatureClassExistsAsync(uri, Constants.FILE_ROADS);
if (!bExists)
{
MessageBox.Show("The roads layer is missing. Clip the roads layer before creating the roads analysis layer!!", "BAGIS-PRO");
Module1.Current.ModuleLogManager.LogDebug(nameof(GenerateLayersAsync),
"Unable to buffer roads because fs_roads layer does not exist. Process stopped!!");
return;
}
// This could come from the UI eventually
string strDistance = Module1.Current.BatchToolSettings.RoadsAnalysisBufferDistance + " " +
Module1.Current.BatchToolSettings.RoadsAnalysisBufferUnits;
success = await AnalysisTools.GenerateProximityRoadsLayerAsync(uri, strDistance);
if (success == BA_ReturnCode.Success)
{
layersPane.Roads_Checked = false;
}
else
{
bSkipPotentialSites = true; // may skip combined potential sites because this layer couldn't be generated
}
}
if (extractPublicLand)
{
success = await AnalysisTools.GetFederalNonWildernessLandsAsync(Module1.Current.Aoi.FilePath);
if (success == BA_ReturnCode.Success)
{
layersPane.FederalLand_Checked = false;
}
else
{
bSkipPotentialSites = true; // may skip combined potential sites because this layer couldn't be generated
}
}
if (extractBelowTreeline)
{
success = await AnalysisTools.ExtractBelowTreelineAsync(Module1.Current.Aoi.FilePath);
if (success == BA_ReturnCode.Success)
{
layersPane.BelowTreeline_Checked = false;
}
else
{
bSkipPotentialSites = true; // may skip combined potential sites because this layer couldn't be generated
}
}
if (!bSkipPotentialSites)
{
if (bufferRoads || extractPublicLand || extractBelowTreeline)
{
// if either of the underlying layers changed, we need to recalculate the
// potential sites layer
success = await AnalysisTools.CalculatePotentialSitesAreaAsync(Module1.Current.Aoi.FilePath);
if (success != BA_ReturnCode.Success)
{
MessageBox.Show("An error occurred while generating the potential sites layer!!", "BAGIS-PRO");
}
}
}
if (elevPrecipCorr == true)
{
string strLayer = GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Prism, true) +
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile);
Uri uriPrism = new Uri(GeodatabaseTools.GetGeodatabasePath(Module1.Current.Aoi.FilePath, GeodatabaseNames.Prism));
success = await AnalysisTools.CalculateElevPrecipCorrAsync(Module1.Current.Aoi.FilePath, uriPrism,
Path.GetFileName((string)Module1.Current.BatchToolSettings.AoiPrecipFile));
if (success == BA_ReturnCode.Success)
{
layersPane.ElevPrecipCorr_Checked = false;
}
}
if (calculateSweDelta == true)
{
success = await AnalysisTools.CalculateSWEDeltaAsync(Module1.Current.Aoi.FilePath);
if (success == BA_ReturnCode.Success)
{
layersPane.SWE_Delta_Checked = false;
}
}
if (calculatePrecipContrib == true)
{
success = await AnalysisTools.CalculatePrecipitationContributionAsync(Module1.Current.Aoi.FilePath, -1);
success = await AnalysisTools.CalculateQuarterlyPrecipitationAsync(Module1.Current.Aoi);
if (success == BA_ReturnCode.Success)
{
layersPane.Precip_Contrib_Checked = false;
}
}
if (winterPrecip == true)
{
success = await AnalysisTools.GenerateWinterPrecipitationLayerAsync(Module1.Current.Aoi);
if (success == BA_ReturnCode.Success)
{
layersPane.Winter_Precip_Checked = false;
}
}
if (success == BA_ReturnCode.Success)
{
MessageBox.Show("Analysis layers generated !!", "BAGIS-PRO");
}
}
catch (Exception ex)
{
Module1.Current.ModuleLogManager.LogError(nameof(GenerateLayersAsync),
"Exception: " + ex.Message);
}
}
public static async Task DisplayMaps(string strAoiPath)
{
BA_Objects.Aoi oAoi = Module1.Current.Aoi;
if (String.IsNullOrEmpty(oAoi.Name))
{
if (System.IO.Directory.Exists(strAoiPath))
{
// Initialize AOI object
oAoi = new BA_Objects.Aoi("animas_AOI_prms", strAoiPath);
// Store current AOI in Module1
Module1.Current.Aoi = oAoi;
}
else
{
ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show("!!Please set an AOI before testing the maps", "BAGIS Pro");
}
}
Map oMap = await MapTools.SetDefaultMapNameAsync(Constants.MAPS_DEFAULT_MAP_NAME);
if (oMap != null)
{
if (oMap.Layers.Count() > 0)
{
string strMessage = "Adding the maps to the display will overwrite the current arrangement of data layers. " +
"This action cannot be undone." + System.Environment.NewLine + "Do you wish to continue ?";
MessageBoxResult oRes = ArcGIS.Desktop.Framework.Dialogs.MessageBox.Show(strMessage, "BAGIS", MessageBoxButton.YesNo);
if (oRes != MessageBoxResult.Yes)
{
return;
}
}
Layout layout = await MapTools.GetDefaultLayoutAsync(Constants.MAPS_DEFAULT_LAYOUT_NAME);
if (layout != null)
{
bool bFoundIt = false;
//A layout view may exist but it may not be active
//Iterate through each pane in the application and check to see if the layout is already open and if so, activate it
foreach (var pane in ProApp.Panes)
{
if (!(pane is ILayoutPane layoutPane)) //if not a layout view, continue to the next pane
{
continue;
}
if (layoutPane.LayoutView.Layout == layout) //if there is a match, activate the view
{
(layoutPane as Pane).Activate();
bFoundIt = true;
}
}
if (!bFoundIt)
{
ILayoutPane iNewLayoutPane = await ProApp.Panes.CreateLayoutPaneAsync(layout); //GUI thread
}
await MapTools.SetDefaultMapFrameDimensionAsync(Constants.MAPS_DEFAULT_MAP_FRAME_NAME, layout, oMap,
1.0, 2.0, 7.5, 9.0);
//remove existing layers from map frame
await MapTools.RemoveLayersfromMapFrame();
//add aoi boundary to map and zoom to layer
string strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Aoi, true) +
Constants.FILE_AOI_VECTOR;
Uri aoiUri = new Uri(strPath);
await MapTools.AddAoiBoundaryToMapAsync(aoiUri, Constants.MAPS_AOI_BOUNDARY);
//add Snotel Represented Area Layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_SNOTEL_REPRESENTED;
Uri uri = new Uri(strPath);
CIMColor fillColor = CIMColor.CreateRGBColor(255, 0, 0, 50); //Red with 30% transparency
BA_ReturnCode success = await MapTools.AddPolygonLayerAsync(uri, fillColor, false, Constants.MAPS_SNOTEL_REPRESENTED);
if (success.Equals(BA_ReturnCode.Success))
{
Module1.ToggleState("MapButtonPalette_BtnSnotel_State");
}
// add aoi streams layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Layers, true) +
Constants.FILE_STREAMS;
uri = new Uri(strPath);
await MapTools.AddLineLayerAsync(uri, Constants.MAPS_STREAMS, ColorFactory.Instance.BlueRGB);
// add Snotel Layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Layers, true) +
Constants.FILE_SNOTEL;
uri = new Uri(strPath);
success = await MapTools.AddPointMarkersAsync(uri, Constants.MAPS_SNOTEL, ColorFactory.Instance.BlueRGB,
SimpleMarkerStyle.X, 16);
if (success == BA_ReturnCode.Success)
{
Module1.Current.AoiHasSnotel = true;
}
// add Snow Course Layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Layers, true) +
Constants.FILE_SNOW_COURSE;
uri = new Uri(strPath);
success = await MapTools.AddPointMarkersAsync(uri, Constants.MAPS_SNOW_COURSE, CIMColor.CreateRGBColor(0, 255, 255),
SimpleMarkerStyle.Star, 16);
if (success == BA_ReturnCode.Success)
{
Module1.Current.AoiHasSnowCourse = true;
}
// add hillshade layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Surfaces, true) +
Constants.FILE_HILLSHADE;
uri = new Uri(strPath);
await MapTools.DisplayRasterAsync(uri, Constants.MAPS_HILLSHADE, 0);
// add elev zones layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_ELEV_ZONE;
uri = new Uri(strPath);
await MapTools.DisplayRasterWithSymbolAsync(uri, Constants.MAPS_ELEV_ZONE, "ArcGIS Colors",
"Elevation #2", "NAME", 30, true);
Module1.ToggleState("MapButtonPalette_BtnElevation_State");
// add slope zones layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_SLOPE_ZONE;
uri = new Uri(strPath);
await MapTools.DisplayRasterWithSymbolAsync(uri, Constants.MAPS_SLOPE_ZONE, "ArcGIS Colors",
"Slope", "NAME", 30, false);
Module1.ToggleState("MapButtonPalette_BtnSlope_State");
// add aspect zones layer
strPath = GeodatabaseTools.GetGeodatabasePath(oAoi.FilePath, GeodatabaseNames.Analysis, true) +
Constants.FILE_ASPECT_ZONE;
uri = new Uri(strPath);
await MapTools.DisplayRasterWithSymbolAsync(uri, Constants.MAPS_ASPECT_ZONE, "ArcGIS Colors",
"Aspect", "NAME", 30, false);
Module1.ToggleState("MapButtonPalette_BtnAspect_State");
// create map elements
await MapTools.AddMapElements(Constants.MAPS_DEFAULT_LAYOUT_NAME, "ArcGIS Colors", "1.5 Point");
await MapTools.DisplayNorthArrowAsync(layout, Constants.MAPS_DEFAULT_MAP_FRAME_NAME);
await MapTools.DisplayScaleBarAsync(layout, Constants.MAPS_DEFAULT_MAP_FRAME_NAME);
// update map elements for default map (elevation)
BA_Objects.MapDefinition defaultMap = MapTools.LoadMapDefinition(BagisMapType.ELEVATION);
await MapTools.UpdateMapElementsAsync(layout, Module1.Current.Aoi.Name.ToUpper(), defaultMap);
await MapTools.UpdateLegendAsync(layout, defaultMap);
//zoom to aoi boundary layer
double bufferFactor = 1.1;
bool bZoomed = await MapTools.ZoomToExtentAsync(aoiUri, bufferFactor);
}
}
}
