// 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); } } }