private void SetAccessibleResultsSets(List <VisibilityCalcResults> userSession, ISpatialReference spatialReference)
{
var currentSessionProfiles = new List <VisibilityCalcResults>(userSession);
var allAccessibleProfilesSets = VisibilityZonesFacade.GetAllVisibilityResults().ToList();
var notInCurrentSessionProfilesSet = new List <VisibilityCalcResults>(allAccessibleProfilesSets.Count);
foreach (var set in allAccessibleProfilesSets)
{
var currentSessionSet = currentSessionProfiles.FirstOrDefault(session => session.Id == set.Id);
if (currentSessionSet != null)
{
currentSessionProfiles.Remove(currentSessionSet);
}
else
{
notInCurrentSessionProfilesSet.Add(set);
}
}
//notInCurrentSessionProfilesSet.ForEach(session =>
//{
// session.ConvertLinesToEsriPolypile(spatialReference);
//});
_accessibleProfilesSets = notInCurrentSessionProfilesSet.ToArray();
}
private static void OnCalculationFinished(IActionResult message)
{
if (message is VisibilityCalculationResult res)
{
var session = res.Result.Session;
if (res.Result.CalculationMessages.Count() > 0)
{
foreach (var calcRes in res.Result.CalculationMessages)
{
//Here should be checked if the results match with session.CalculatedResults
logger.InfoEx("> OnCalculationFinished. The result layer {0} was composed in {1}", calcRes, session.ReferencedGDB);
}
}
if (res.Exception != null)
{
VisibilityZonesFacade.FinishVisibilityTask(session);
throw res.Exception;
}
if (!string.IsNullOrWhiteSpace(res.ErrorMessage))
{
throw new MilSpaceVisibilityCalcFailedException(res.ErrorMessage);
}
}
}
internal bool ShareResults(string id)
{
try
{
var selectedResults = _visibilityResults.First(res => res.Id == id);
VisibilityZonesFacade.UpdateVisibilityResults(selectedResults);
selectedResults.Shared = true;
return(true);
}
catch
{
return(false);
}
}
internal bool AddSharedResults(IEnumerable <VisibilityCalcResults> results)
{
var res = true;
foreach (var result in results)
{
if (!VisibilityZonesFacade.AddSharedVisibilityResultsToUserSession(result))
{
res = false;
}
else
{
_visibilityResults.Add(result);
}
}
return(res);
}
private IEnumerable <string> GetResults(bool allresults = false)
{
//VisibilityCalculationresultsEnum resultsInGDB = GdbAccess.Instance.CheckVisibilityResult(Id);
if (allResulrs == null)
{
var resultsToShow = ResultsToShow[CalculationType];
allResulrs = new List <string>();
VisibilityCalculationResultsEnum calculatedResults = (VisibilityCalculationResultsEnum)CalculatedResults;
int pointsCount = (Summary.ObservationPoints == null) ? 0 : Summary.ObservationPoints.Count();
foreach (var result in VisibilityResulSuffixes)
{
if (calculatedResults.HasFlag(result.Key) && resultsToShow.Any(r => r.Equals(result.Key)))
{
if (ResultsRelatedToSingle.Any(v => result.Key == v))
{
//int index = pointsCount - 1;
for (int index = 0; index < pointsCount; index++)
{
string resultBName = GetResultName(result.Key, Id, index);
if (VisibilityZonesFacade.CheckVisibilityResultEistance(resultBName, result.Key))
{
allResulrs.Add(resultBName);
}
}
}
else
{
var resultBName = GetResultName(result.Key, Id);
if (VisibilityZonesFacade.CheckVisibilityResultEistance(resultBName, result.Key))
{
allResulrs.Add(resultBName);
}
}
}
}
}
return(allResulrs);
}
internal bool RemoveResult(string id, IActiveView activeView)
{
var selectedResults = _visibilityResults.First(res => res.Id == id);
var results = selectedResults.ValueableResults();
var removingResult = true;
if (VisibilityZonesFacade.IsResultsBelongToUser(id))
{
foreach (var result in results)
{
if (result != selectedResults.Id && !EsriTools.RemoveDataSet(selectedResults.ReferencedGDB, result))
{
return(false);
}
}
removingResult = VisibilityZonesFacade.DeleteVisibilityResults(id);
if (removingResult)
{
RemoveSession(id);
EsriTools.RemoveLayer(selectedResults.Name, activeView.FocusMap);
}
}
else
{
VisibilityZonesFacade.DeleteVisibilityResultsFromUserSession(id);
}
if (removingResult)
{
_visibilityResults.Remove(selectedResults);
}
return(removingResult);
}
internal bool RemoveSession(string id)
{
if (_calculationTasks.Count == 0)
{
UpdateVisibilitySessionsList();
}
var removedSession = _calculationTasks.FirstOrDefault(session => session.Id == id);
if (removedSession == null)
{
return(false);
}
var result = VisibilityZonesFacade.DeleteVisibilitySession(id);
if (result)
{
_calculationTasks.Remove(removedSession);
_view.RemoveSessionFromList(id);
}
return(result);
}
internal IEnumerable <ObservationPoint> GetAllObservationPoints()
{
return(VisibilityZonesFacade.GetAllObservationPoints());
}
internal void UpdateObservationPointsList()
{
view.FillObservationPointList(VisibilityZonesFacade.GetAllObservationPoints(), view.GetFilter);
}
internal void UpdateVisibilityResultsTree(bool isNewSessionAdded = false)
{
_visibilityResults = VisibilityZonesFacade.GetAllVisibilityResults(true).ToList();
_view.FillVisibilityResultsTree(_visibilityResults);
}
internal void UpdateVisibilitySessionsList(bool isNewSessionAdded = false, string newSessionName = null)
{
_calculationTasks = VisibilityZonesFacade.GetAllVisibilityTasks(true).ToList();
_view.FillVisibilitySessionsList(_calculationTasks, isNewSessionAdded, newSessionName);
}
internal IEnumerable <VisibilityTask> GetUserVisibilitySessions()
{
return(VisibilityZonesFacade.GetFinishedVisibilityTasks().Where(session => session.UserName == Environment.UserName));
}
internal IEnumerable <VisibilityTask> GetVisibilityTasks()
{
return(VisibilityZonesFacade.GetFinishedVisibilityTasks());
}
public static VisibilityTask Generate(
IFeatureClass obervationPoints,
IEnumerable <int> pointsToExport,
IFeatureClass obervationStations,
IEnumerable <int> stationsToExport,
string sourceDem,
VisibilityCalculationResultsEnum culcResults,
string taskName,
string taskId,
VisibilityCalcTypeEnum calculationType,
IMap currentMap,
short visibilityPercent,
bool showAllResults = true)
{
logger.InfoEx("> Generate START. Visiblility result {2} using DEM {0} from observation points {1}"
.InvariantFormat(sourceDem, obervationPoints, taskId));
CurrentMap = currentMap;
//Target dataset name
string nameOfTargetDataset = taskId;
var calcTask = new VisibilityTask
{
Id = nameOfTargetDataset,
Name = taskName,
ReferencedGDB = MilSpaceConfiguration.ConnectionProperty.TemporaryGDBConnection,
CalculatedResults = (int)culcResults,
UserName = Environment.UserName,
CalculationType = calculationType,
Surface = sourceDem
};
calcTask = VisibilityZonesFacade.AddVisibilityTask(calcTask);
OnGenerationStarted.Invoke(true, calcTask.Id);
if (calcTask == null)
{
throw new MilSpaceVisibilityCalcFailedException("Cannot save visibility session");
}
var action = new ActionParam <string>()
{
ParamName = ActionParamNamesCore.Action,
Value = ActionsEnum.vblt.ToString()
};
var prm = new List <IActionParam>
{
action,
new ActionParam <IFeatureClass>()
{
ParamName = ActionParameters.FeatureClass, Value = obervationPoints
},
new ActionParam <IFeatureClass>()
{
ParamName = ActionParameters.FeatureClassX, Value = obervationStations
},
new ActionParam <int[]>()
{
ParamName = ActionParameters.FilteringPointsIds, Value = pointsToExport.ToArray()
},
new ActionParam <int[]>()
{
ParamName = ActionParameters.FilteringStationsIds, Value = stationsToExport.ToArray()
},
new ActionParam <string>()
{
ParamName = ActionParameters.ProfileSource, Value = sourceDem
},
new ActionParam <VisibilityCalculationResultsEnum>()
{
ParamName = ActionParameters.Calculationresults, Value = culcResults
},
new ActionParam <string>()
{
ParamName = ActionParameters.OutputSourceName, Value = nameOfTargetDataset
},
new ActionParam <VisibilityTask>()
{
ParamName = ActionParameters.Session, Value = calcTask
},
new ActionParam <short>()
{
ParamName = ActionParameters.VisibilityPercent, Value = visibilityPercent
},
new ActionParam <bool>()
{
ParamName = ActionParameters.ShowAllResults, Value = showAllResults
}
};
var procc = new ActionProcessor(prm);
VisibilityZonesFacade.StarthVisibilitySession(calcTask);
var res = procc.Process <VisibilityCalculationResult>();
calcTask = res.Result.Session;
if (res.Result.CalculationMessages != null && res.Result.CalculationMessages.Count() > 0)
{
foreach (var calcRes in res.Result.CalculationMessages)
{
//Here should be checked if the results match with session.CalculatedResults
//logger.InfoEx($"The result layer {calcRes} was successfully composed in {calcTask.ReferencedGDB}");
}
}
if (res.Exception != null)
{
VisibilityZonesFacade.UpdateVisibilityTask(calcTask);
throw res.Exception;
}
else
{
VisibilityZonesFacade.FinishVisibilityTask(calcTask);
VisibilityZonesFacade.AddVisibilityResults(calcTask.GetVisibilityResults(false));
}
if (!string.IsNullOrWhiteSpace(res.ErrorMessage))
{
throw new MilSpaceVisibilityCalcFailedException(res.ErrorMessage);
}
return(calcTask);
}
