double GetExactApproach(MerkelData merkelData)
{
double approach;
double delta = 1.0;
//---------------------------------------------------------------------
// Find approach within .001
//---------------------------------------------------------------------
for (approach = 0.0; approach < 100.0; approach += delta)
{
merkelData.Approach = approach;
double kavl = CalculationLibrary.CalculateMerkel(merkelData);
if (delta > 0.9)
{
if (kavl < merkelData.KaV_L)
{
delta = -0.001;
}
else
{
break; // calculation error?
}
}
else
{
if (kavl >= merkelData.KaV_L)
{
approach = Math.Round(approach, 3, MidpointRounding.ToEven);
break;
}
}
}
return(approach);
}
public bool MerkelCalculation(MerkelData data, out string errorMessage)
{
data.Range = data.HotWaterTemperature - data.ColdWaterTemperature;
data.Approach = data.ColdWaterTemperature - data.WetBulbTemperature;
CalculationLibrary.CalculateMerkel(data);
return(Merkel_CheckCalculationValues(data, out errorMessage));
}
public bool Psychrometrics_DryBulbTemperature_RelativeHumidity_Calculation(PsychrometricsData data, out string errorMessage)
{
if (data.IsInternationalSystemOfUnits_IS_)
{
// p = Elevation2KPA(m_dblElevation);
// SIWBsearch(p, TWB / 100, TDB, TWB);
// CalcSIProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
// UnitsTemperature = pszSITemp;
// UnitsEnthalpy = pszSIEnthrapy;
// UnitsDensity = pszSIDensity;
// UnitsVolume = pszSISPVolume;
// UnitsHumidity = pszSIHumidityRatio;
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInMetersToKilopascal(data.Elevation);
}
data.WetBulbTemperature = CalculationLibrary.CalculateTemperatureWetBulbSI(data.BarometricPressure, data.RelativeHumidity / 100, data.DryBulbTemperature);
CalculationLibrary.CalculatePropertiesSI(data);
}
else
{
// p = Elevation2PSI(m_dblElevation);
// IPWBsearch(p, TWB / 100, TDB, TWB);
// CalcIPProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
// UnitsTemperature = pszIPTemp;
// UnitsEnthalpy = pszIPEnthrapy;
// UnitsDensity = pszIPDensity;
// UnitsVolume = pszIPSPVolume;
// UnitsHumidity = pszIPHumidityRatio;
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInFeetToBarometricPressure(data.Elevation);
}
data.WetBulbTemperature = CalculationLibrary.CalculateTemperatureWetBulbIP(data.BarometricPressure, data.RelativeHumidity / 100, data.DryBulbTemperature);
//data.TemperatureWetBulb = CalculationLibrary.CalculateTemperatureWetBulbIP(data);
CalculationLibrary.CalculatePropertiesIP(data);
data.BarometricPressure = UnitConverter.CalculatePressureFahrenheit(data.BarometricPressure);
}
return(Psychrometrics_CheckCalculationValues(data, out errorMessage));
}
public override void Process()
{
var srtmStorage = MilSpaceConfiguration.DemStorages.SrtmStorage;
IEnumerable <string> errorMessages = new List <string>();
CalculationLibrary.RasterToOtherFormat(files, srtmStorage, out errorMessages);
var fileUsage = files.ToDictionary(f => new FileInfo(f), t => false);
foreach (var fi in fileUsage.Keys.ToArray())
{
var flNm = fi.Name;
fileUsage[fi] = errorMessages.Any(m => m.EndsWith(flNm, StringComparison.CurrentCultureIgnoreCase));
}
returnResult.Result.Log = errorMessages;
returnResult.Result.CopoedFiles = fileUsage.Where(f => f.Value).Select(f => f.Key.FullName);
}
void InitializeApproachList(DemandCurveData data)
{
MerkelData merkelData = new MerkelData()
{
WetBulbTemperature = data.WetBulbTemperature,
Range = data.Range,
Elevation = data.Elevation,
LiquidToGasRatio = 0.1
};
foreach (double approachValue in InitialApproachXValues)
{
merkelData.Approach = approachValue;
double KaVL = CalculationLibrary.CalculateMerkel(merkelData);
bool approachInRange = (KaVL > 0.1) && (KaVL < 5.0);
ApproachInRange.Add(approachInRange);
ApproachOutOfRange.Add(!approachInRange);
}
}
public override void Process()
{
result = new StringCollectionResult();
try
{
IEnumerable <string> mesasges = null;
if (!CalculationLibrary.GenerateProfileData(featureClass, profileSource, tableName, mesasges))
{
result.Exception = new MilSpaceVisibilityCalcFailedException();
}
if (mesasges != null && mesasges.Any())
{
mesasges.ToList().ForEach(m => logger.InfoEx(m));
}
result.Result = mesasges;
}
catch (Exception ex)
{
result.Exception = ex;
}
}
public static bool GenerateTiles(IEnumerable <string> filesToCombine, string resultFileName)
{
bool processing = true;
//var pathToTempFile = IO.Path.GetTempPath();
var pathToTempFile = IO.Path.Combine(MilSpaceConfiguration.DemStorages.SentinelStorage, "Temp");
if (!IO.Directory.Exists(pathToTempFile))
{
IO.Directory.CreateDirectory(pathToTempFile);
}
IEnumerable <string> messages = new List <string>();
log.InfoEx("Starting MosaicToRaster...");
var list = filesToCombine.ToList();
var tempFilesToDelete = new List <string>();
var commonMessages = new List <string>();
var tempFilePath = string.Empty;
var tileount = 3;
while (list.Count > 0)
{
var tempFileName = $"{MilSpace.DataAccess.Helper.GetTemporaryNameSuffix()}.tif";
tempFilePath = IO.Path.Combine(pathToTempFile, tempFileName);
var temp = list.Take(list.Count < tileount ? list.Count : tileount);
list = list.Except(temp).ToList();
if (list.Count > 0)
{
tempFilesToDelete.Add(tempFilePath);
list.Add(tempFilePath);
}
else
{
var fileInfo = new IO.FileInfo(resultFileName);
tempFileName = fileInfo.Name;
pathToTempFile = fileInfo.DirectoryName;
tempFilePath = resultFileName;
}
processing = CalculationLibrary.MosaicToRaster(temp, pathToTempFile, tempFileName, out messages, IO.Path.Combine(MilSpaceConfiguration.DemStorages.SentinelStorage, "Temp"));
commonMessages.AddRange(messages);
if (!processing)
{
break;
}
}
commonMessages.ForEach(m => { if (processing)
{
log.InfoEx(m);
}
else
{
log.ErrorEx(m);
} });
if (!processing)
{
return(false);
}
if (!IO.File.Exists(tempFilePath))
{
processing = false;
(messages.ToList()).Add($"ERROR: Об'єднаний файл {tempFilePath} не було знайдено!");
return(false);
}
//IO.File.Copy(tempFilePath, resultFileName, true);
IEnumerable <string> messagesToClip;
processing = false;
messages = commonMessages;
tempFilesToDelete.ForEach(f =>
{
var fl = new IO.FileInfo(f);
string templateToDel = $"{fl.Name.Substring(0, fl.Name.Length - 3)}*";
fl.Directory.GetFiles(templateToDel).ToList().ForEach(fd =>
{
try
{
IO.File.Delete(fd.FullName);
}
catch (Exception ex)
{
log.ErrorEx($"Cannot delete {fd.FullName}");
log.ErrorEx(ex.Message);
}
});
});
return(true);
}
void CalculateApproaches(DemandCurveData data)
{
//StreamWriter fs = new StreamWriter("new.txt");
MerkelData merkelData = new MerkelData()
{
WetBulbTemperature = 80, // data.WetBulbTemperature,
Range = data.Range,
Elevation = data.Elevation,
LiquidToGasRatio = data.LiquidToGasRatio
};
double kaVL = 0;
double calculatedWaterAirRatio = 0.0;
const double waterAirRatio_MIN = 0.01, waterAirRatio_MAX = 5.0;
double calculatedWaterAirRatio_MIN = 999.0;
//ApproachXValues[INDEX_TARGETAPPROACH] = TargetApproach;
//ApproachXValues[INDEX_USERAPPROACH] = UserApproach;
for (double waterAirRatio = waterAirRatio_MIN; waterAirRatio < waterAirRatio_MAX; waterAirRatio += .05)
{
//fs.WriteLine("\ndLG {0} \n", waterAirRatio.ToString("F6"));
DataRow dataRow = data.DataTable.NewRow();
for (int i = 0; i < InitialApproachXValues.Length; i++)
{
//fs.WriteLine("\niIndex {0} getapp(iIndex) {1} App[iIndex] {2} ", i, 1, (int)ApproachXValues[i]);
string approachXValue = ((int)InitialApproachXValues[i]).ToString();
if (ApproachInRange[i] && !ApproachOutOfRange[i])
{
merkelData.LiquidToGasRatio = waterAirRatio;
merkelData.Approach = InitialApproachXValues[i];
if (data.IsInternationalSystemOfUnits_IS_)
{
merkelData.Approach *= 1.8;
}
if (waterAirRatio > 1.3 && waterAirRatio < 1.4)
{
//fs.WriteLine();
}
//fs.WriteLine(" m_dblCurveWBT {0}, m_dblCurveRange {1}, App[iIndex] {2}, dLG {3}, m_dblAltitude {4} ", merkelData.WetBulbTemperature.ToString("F6"), merkelData.Range.ToString("F6"), merkelData.Approach.ToString("F6"), merkelData.WaterAirRatio.ToString("F6"), merkelData.Elevation.ToString("F6"));
kaVL = CalculationLibrary.CalculateMerkel(merkelData);
//fs.WriteLine(" m_dblCurveWBT {0}, m_dblCurveRange {1}, App[iIndex] {2}, dLG {3}, m_dblAltitude {4} ", merkelData.WetBulbTemperature.ToString("F6"), merkelData.Range.ToString("F6"), merkelData.Approach.ToString("F6"), merkelData.WaterAirRatio.ToString("F6"), merkelData.Elevation.ToString("F6"));
//fs.WriteLine("kavl {0} minVal {1} maxVal {2} dLG {3} App[iIndex] {4} ", kaVL.ToString("F6"), waterAirRatio_MIN.ToString("F6"), waterAirRatio_MAX.ToString("F6"), waterAirRatio.ToString("F6"), ApproachXValues[i].ToString("F6"));
// ddp
if ((kaVL < waterAirRatio_MIN) || (kaVL >= waterAirRatio_MAX))
{
double dInterp;
for (dInterp = waterAirRatio; ((kaVL < waterAirRatio_MIN) || (kaVL >= waterAirRatio_MAX)) && (dInterp > .1); dInterp -= 0.0002)
{
merkelData.Approach = InitialApproachXValues[i];
if (data.IsInternationalSystemOfUnits_IS_)
{
merkelData.Approach *= 1.8;
}
merkelData.LiquidToGasRatio = dInterp;
kaVL = CalculationLibrary.CalculateMerkel(merkelData);
}
calculatedWaterAirRatio = dInterp;
ApproachOutOfRange[i] = true; //DDP This is the last point
}
else
{
calculatedWaterAirRatio = waterAirRatio;
}
//fs.WriteLine("kavl {0} dLG {1} App[iIndex] {2} ", kaVL.ToString("F6"), waterAirRatio.ToString("F6"), ApproachXValues[i].ToString("F6"));
if ((calculatedWaterAirRatio_MIN > kaVL) && (kaVL > .1))
{
calculatedWaterAirRatio_MIN = kaVL;
}
//fs.Write("sDLG {0} ", calculatedWaterAirRatio.ToString("F6"));
//fs.Write("min4Lg {0} \n", min4Lg.ToString("F6"));
if ((kaVL <= 10.0) && (kaVL >= .1))
{
//fs.WriteLine("index {2} m_wndGraph {0} {1}", calculatedWaterAirRatio.ToString("F6"), kaVL.ToString("F6"), i);
dataRow[string.Format("L/G-{0}", approachXValue)] = calculatedWaterAirRatio;
dataRow[string.Format("kaVL-{0}", approachXValue)] = kaVL;
}
}
}
data.DataTable.Rows.Add(dataRow);
}
////---------------------------------------------------------------------
//// Draw Fill Line
////---------------------------------------------------------------------
//if ((data.CurveC1 != 0) && (data.CurveC2 != 0))//&& coef)
//{
// for (double waterAirRatio = data.CurveMinimum; waterAirRatio <= data.CurveMaximum; waterAirRatio += .05)
// {
// DataRow dataRow = data.DataTable.NewRow();
// if ((waterAirRatio >= data.CurveMinimum) && (waterAirRatio <= data.CurveMaximum))
// {
// double dblK = data.CurveC1 * Math.Pow(waterAirRatio, data.CurveC2);
// if ((dblK >= calculatedWaterAirRatio_MIN) && (dblK <= waterAirRatio_MAX))
// {
// dataRow["kaVL-COEF"] = kaVL;
// dataRow["L/G-COEF"] = calculatedWaterAirRatio;
// //m_wndGraph.GetSeries(INDEX_COEF).AddXY(waterAirRatio, dblK, NULL, 00099FF);
// }
// }
// data.DataTable.Rows.Add(dataRow);
// }
//}
//////---------------------------------------------------------------------
////// Draw L/G line
//////---------------------------------------------------------------------
//if (data.WaterAirRatio > waterAirRatio_MIN && data.WaterAirRatio <= waterAirRatio_MAX)// && Lg)
//{
// DataColumn dataColumn = new DataColumn();
// dataColumn.ColumnName = "L/G-X";
// dataColumn.DataType = Type.GetType("System.Double");
// data.DataTable.Columns.Add(dataColumn);
// dataColumn = new DataColumn();
// dataColumn.ColumnName = "L/G-Y";
// dataColumn.DataType = Type.GetType("System.Double");
// data.DataTable.Columns.Add(dataColumn);
// DataRow dataRow = data.DataTable.NewRow();
// dataRow["L/G-Y"] = data.WaterAirRatio;
// dataRow["L/G-X"] = calculatedWaterAirRatio_MIN;
// data.DataTable.Rows.Add(dataRow);
// dataRow = data.DataTable.NewRow();
// dataRow["L/G-Y"] = data.WaterAirRatio;
// dataRow["L/G-X"] = waterAirRatio_MAX;
// data.DataTable.Rows.Add(dataRow);
//}
//////---------------------------------------------------------------------
////// Draw KaV/L line
//////---------------------------------------------------------------------
//if ((data.KaV_L > 0.1) && (data.KaV_L <= waterAirRatio_MAX)) // && m_bShowKaVLLine)
//{
// DataRow dataRow = data.DataTable.NewRow();
// dataRow[string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MIN;
// dataRow[string.Format("L/G-{0}", INDEX_KAVL)] = data.KaV_L;
// data.DataTable.Rows.Add(dataRow);
// dataRow = data.DataTable.NewRow();
// dataRow[string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MAX;
// dataRow[string.Format("L/G-{0}", INDEX_KAVL)] = data.KaV_L;
// data.DataTable.Rows.Add(dataRow);
data.DataTable.Rows[0][string.Format("kaVL-{0}", INDEX_KAVL)] = waterAirRatio_MAX;
// data.DataTable.Rows[0][columnName] = waterAirRatio_MAX;
// data.DataTable.Rows[1][columnName] = waterAirRatio_MAX;
//}
//fs.Flush();
//fs.Close();
}
private IEnumerable <string> ProcessObservationPoint(List <string> results)
{
logger.InfoEx($"> ProcessObservationPoint START with parameters {calcResults}");
Dictionary <int, List <string> > generatedResults = null;
if (!showAllResults)
{
logger.InfoEx("Show all results was not set");
generatedResults = new Dictionary <int, List <string> >();
}
int iStepNum = 1;
IEnumerable <string> messages = null;
string oservStationsFeatureClassName = null;
//Used to clip the base immge to make it smaller and reduce the culculation time
int currentPointIdForBestParamsCalculations = pointsFilteringIds.Last();
//Handle Observation Objects
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.ObservationObjects))
{
oservStationsFeatureClassName = VisibilityTask.GetResultName(VisibilityCalculationResultsEnum.ObservationObjects, outputSourceName);
logger.InfoEx($"Export observation objects to {oservStationsFeatureClassName}");
//Add result To Delete if not to show all results. Add OP result
if (!showAllResults)
{
//pointResults =
generatedResults.Add(-1, new List <string>()
{
oservStationsFeatureClassName
});
}
var exportedFeatureClass = GdbAccess.Instance.ExportObservationFeatureClass(
observStationsfeatureClass as IDataset,
oservStationsFeatureClassName,
stationsFilteringIds);
if (!string.IsNullOrWhiteSpace(exportedFeatureClass))
{
logger.InfoEx($"Observation points feature class was created:{exportedFeatureClass}");
results.Add(iStepNum.ToString() + ". " + "Створено копію ОН для розрахунку: " + exportedFeatureClass);
iStepNum++;
}
else
{
string errorMessage = $"The feature calss {oservStationsFeatureClassName} was not exported";
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ExportObservationFeatureClass (1). errorMessage:{0}", errorMessage);
messages.Append(errorMessage);
results.Add("Помилка: " + errorMessage);
return(messages);
}
}
else if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
oservStationsFeatureClassName = observStationsfeatureClass.AliasName;
logger.InfoEx($"Export observation objects to {oservStationsFeatureClassName}");
}
//Handle Observation Points
List <KeyValuePair <VisibilityCalculationResultsEnum, int[]> > pointsIDs =
new List <KeyValuePair <VisibilityCalculationResultsEnum, int[]> >();
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.VisibilityAreaRaster) &&
!calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
pointsIDs.Add(
new KeyValuePair <VisibilityCalculationResultsEnum, int[]>(
VisibilityCalculationResultsEnum.ObservationPoints,
pointsFilteringIds));
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.ObservationPointSingle))
{
if (pointsFilteringIds.Length > 1)
{
pointsIDs.AddRange(
pointsFilteringIds.Select(
id => new KeyValuePair <VisibilityCalculationResultsEnum, int[]>(
VisibilityCalculationResultsEnum.ObservationPointSingle, new int[] { id }))
.ToArray());
}
else
{
calcResults &= ~VisibilityCalculationResultsEnum.ObservationPointSingle;
calcResults &= ~VisibilityCalculationResultsEnum.VisibilityAreaRasterSingle;
}
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
pointsIDs.AddRange(
pointsFilteringIds.Select(
id => new KeyValuePair <VisibilityCalculationResultsEnum, int[]>(
VisibilityCalculationResultsEnum.ObservationPointSingle, new int[] { id }))
.ToArray());
}
int index = -1;
bool removeFullImageFromresult = false;
int[] objIds = null;
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.ObservationObjects))
{
objIds = stationsFilteringIds;
}
var coverageTableManager = new CoverageTableManager();
BestOPParametersManager bestOPParametersManager = null;
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
bestOPParametersManager = new BestOPParametersManager(visibilityPercent, currentPointIdForBestParamsCalculations, showAllResults);
}
// There is no reason to clip image for the BestParameters mode, since the point just shance its Z value
var clipSourceImageForEveryPoint = true;
//Used to define a result layer name;
int pointIndex = -1;
var orifinalResterSource = rasterSource;
foreach (var curPoints in pointsIDs)
{
int pointId;
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
pointId = currentPointIdForBestParamsCalculations;
pointIndex = pointId - 1;
}
else
{
pointId = curPoints.Key == VisibilityCalculationResultsEnum.ObservationPoints ? -1 : ++index;
pointIndex = pointId;
}
logger.InfoEx($"Start processing point id {pointId} with index {pointIndex}");
if (!showAllResults)// Cretae the list to add datasets to delete
{
generatedResults.Add(pointId, new List <string>());
}
int[] curPointsValue = (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable)) ?
new int[] { pointId } : curPoints.Value;
var observPointFeatureClassName = VisibilityTask.GetResultName(curPoints.Key, outputSourceName, pointIndex);
logger.InfoEx($"Processing point(s) into {observPointFeatureClassName}");
//Add result To Delete if not to show all results. Add OP result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(observPointFeatureClassName);
}
var exportedFeatureClass = GdbAccess.Instance.ExportObservationFeatureClass(
observPointsfeatureClass as IDataset,
observPointFeatureClassName,
curPointsValue);
results.Add(iStepNum.ToString() + ". " + "Створено копію ПС для розрахунку: " + exportedFeatureClass);
logger.InfoEx($"Point(s) was exported into {observPointFeatureClassName} to process visibility");
iStepNum++;
if (string.IsNullOrWhiteSpace(exportedFeatureClass))
{
string errorMessage = $"The feature calss {observPointFeatureClassName} was not exported";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ExportObservationFeatureClass. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
bool clipSoutceImageByPotentialArea = clipSourceImageForEveryPoint && (curPoints.Key == VisibilityCalculationResultsEnum.ObservationPoints || curPoints.Key == VisibilityCalculationResultsEnum.ObservationPointSingle);
if (clipSoutceImageByPotentialArea)
{
logger.InfoEx($"Clipping calc image to potential area");
string featureClassName = exportedFeatureClass;
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable) && curPoints.Value.First() == 1)
{
featureClassName = observPointsfeatureClass.AliasName;
}
logger.InfoEx($"Calculate potential area for observation point in {featureClassName} and objects from {oservStationsFeatureClassName}");
coverageTableManager.SetCalculateAreas(featureClassName, oservStationsFeatureClassName, !calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable));
clipSourceImageForEveryPoint = false;// !calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable);
var visibilityPotentialAreaFCName = VisibilityCalcResults.GetResultName(VisibilityCalculationResultsEnum.VisibilityAreasPotential, outputSourceName);
coverageTableManager.AddPotentialArea(
visibilityPotentialAreaFCName,
(curPoints.Key == VisibilityCalculationResultsEnum.ObservationPoints ||
curPoints.Key == VisibilityCalculationResultsEnum.ObservationPointSingle), pointIndex + 1);
results.Add(iStepNum.ToString() + ". " + "Розраховано потенційне покриття: " + visibilityPotentialAreaFCName + " ПС: " + pointId.ToString());
//Calc protentilly visiblw area as Image
var fc = GenerateWorknArea(visibilityPotentialAreaFCName, observPointFeatureClassName, outputSourceName);
results.Add(iStepNum.ToString() + ". " + "Розраховано потенційне покриття для розрахунку: " + fc.AliasName + " ПС: " + pointId.ToString());
//Try to clip the raster source by visibilityPotentialAreaFCName
var visibilityPotentialAreaImgName =
VisibilityCalcResults.GetResultName(pointIndex > -1 ?
VisibilityCalculationResultsEnum.VisibilityRastertPotentialAreaSingle :
VisibilityCalculationResultsEnum.VisibilityRastertPotentialArea,
outputSourceName, pointIndex);
//Add result To Delete if not to show all results. Add OP result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(visibilityPotentialAreaImgName);
}
if (!CalculationLibrary.ClipVisibilityZonesByAreas(
rasterSource,
visibilityPotentialAreaImgName,
fc.AliasName,
out messages, "NONE"))
{
string errorMessage = $"The result {visibilityPotentialAreaImgName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ClipVisibilityZonesByAreas. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
else
{
results.Add(iStepNum.ToString() + ". " + "Розраховано покриття для розрахунку на основі потенційноі видимості: " + visibilityPotentialAreaImgName + " ПС: " + pointId.ToString());
rasterSource = visibilityPotentialAreaImgName;
//Delete temporary Featureclass usewd for clipping the base image by potential area
GdbAccess.Instance.RemoveFeatureClass(fc.AliasName);
}
}
//Generate Visibility Raster
string featureClass = observPointFeatureClassName;
string outImageName = VisibilityTask.GetResultName(
curPoints.Key == VisibilityCalculationResultsEnum.ObservationPoints ?
VisibilityCalculationResultsEnum.VisibilityAreaRaster :
VisibilityCalculationResultsEnum.VisibilityAreaRasterSingle,
outputSourceName,
pointIndex);
//Add result To Delete if not to show all results. Add Visibility raster result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(outImageName);
}
if (!CalculationLibrary.GenerateVisibilityData(
rasterSource,
featureClass,
VisibilityAnalysisTypesEnum.Frequency,
outImageName,
out messages))
{
string errorMessage = $"The result {outImageName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ConvertRasterToPolygon. errorMessage:{0}", errorMessage);
logger.ErrorEx("> ProcessObservationPoint ERROR ConvertRasterToPolygon. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
else
{
results.Add(iStepNum.ToString() + ". " + "Розраховано видимість: " + outImageName + " ПС: " + pointId.ToString());
iStepNum++;
logger.InfoEx($"Visibility image {outImageName} for point {pointId} was generated");
string visibilityArePolyFCName = null;
//ConvertToPolygon full visibility area
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.VisibilityAreaPolygons) &&
!calcResults.HasFlag(VisibilityCalculationResultsEnum.ObservationObjects))
{
logger.InfoEx($"Calculation of {VisibilityCalculationResultsEnum.VisibilityAreaPolygons} (Convert visible areas to polygon) was swithced on");
visibilityArePolyFCName =
VisibilityTask.GetResultName(pointIndex > -1 ?
VisibilityCalculationResultsEnum.VisibilityAreaPolygonSingle :
VisibilityCalculationResultsEnum.VisibilityAreaPolygons, outputSourceName, pointIndex);
//Add result To Delete if not to show all results. Add Visibility polygon result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(visibilityArePolyFCName);
}
if (!CalculationLibrary.ConvertRasterToPolygon(outImageName, visibilityArePolyFCName, out messages))
{
if (!messages.Any(m => m.StartsWith("ERROR 010151"))) // Observatioj areas dont intersect Visibility aresa
{
string errorMessage = $"The result {visibilityArePolyFCName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ConvertRasterToPolygon. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
results.Add(iStepNum.ToString() + ". " + "Видимисть відсутня. Полігони не були конвертовані: " + visibilityArePolyFCName + " ПС: " + pointId.ToString());
visibilityArePolyFCName = string.Empty;
logger.InfoEx($"There is no visibile areas for OP {pointId}");
}
else
{
results.Add(iStepNum.ToString() + ". " + "Конвертовано у полігони: " + visibilityArePolyFCName + " ПС: " + pointId.ToString());
logger.InfoEx($"Visibile areas for OP {pointId} was converted into {visibilityArePolyFCName} ");
}
iStepNum++;
}
//Clip
if (!string.IsNullOrEmpty(oservStationsFeatureClassName))
{
var inClipName = outImageName;
var resultLype =
pointId > -1 ?
VisibilityCalculationResultsEnum.VisibilityObservStationClipSingle :
VisibilityCalculationResultsEnum.VisibilityObservStationClip;
var outClipName = VisibilityTask.GetResultName(resultLype,
outputSourceName, pointIndex);
//Add result To Delete if not to show all results. Add Visibility polygon result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(outClipName);
}
logger.InfoEx($"Try to clip the visible areas {inClipName} by orservation object {oservStationsFeatureClassName}");
if (!CalculationLibrary.ClipVisibilityZonesByAreas(
inClipName,
outClipName,
oservStationsFeatureClassName,
out messages))
{
string errorMessage = $"The result {outClipName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ClipVisibilityZonesByAreas. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
else
{
results.Add(iStepNum.ToString() + ". " + "Зона видимості зведена до дійсного розміру: " + outClipName + " ПС: " + pointId.ToString());
logger.InfoEx($"Visible area {inClipName} was clipped by orservation objects {oservStationsFeatureClassName}");
iStepNum++;
if (!calcResults.HasFlag(resultLype))
{
calcResults |= resultLype;
}
//Change to VisibilityAreaPolygonForObjects
var curCulcRResult =
pointId > -1 ?
VisibilityCalculationResultsEnum.VisibilityAreaPolygonSingle :
VisibilityCalculationResultsEnum.VisibilityAreaPolygons;
visibilityArePolyFCName = VisibilityTask.GetResultName(curCulcRResult, outputSourceName, pointIndex);
var rasterDataset = GdbAccess.Instance.GetDatasetFromCalcWorkspace(
outClipName, VisibilityCalculationResultsEnum.VisibilityAreaRaster);
bool isEmpty = EsriTools.IsRasterEmpty((IRasterDataset2)rasterDataset);
if (isEmpty)
{
if (calcResults.HasFlag(curCulcRResult))
{
calcResults &= ~curCulcRResult;
}
results.Add($"{iStepNum.ToString()}. Видимість відсутня. Полігони {visibilityArePolyFCName} не було сформовано. ПС: {pointId.ToString()}");
logger.InfoEx($"There is no visible areas in {visibilityArePolyFCName}. Point {pointId}");
}
else
{
if (!CalculationLibrary.ConvertRasterToPolygon(outClipName, visibilityArePolyFCName, out messages))
{
if (!messages.Any(m => m.StartsWith("ERROR 010151"))) // Observatioj areas dont intersect Visibility area
{
string errorMessage = $"The result {visibilityArePolyFCName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ConvertRasterToPolygon. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
results.Add(iStepNum.ToString() + ". " + "Видимість відсутня. Полігони не було сформовано: " + visibilityArePolyFCName + " ПС: " + pointId.ToString());
logger.InfoEx($"There is no visible areas. {visibilityArePolyFCName} was not generated. Point {pointId}");
}
else
{
//Add result To Delete if not to show all results. Add Visibility polygon result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(visibilityArePolyFCName);
}
results.Add(iStepNum.ToString() + ". " + "Конвертовано у полігони: " + visibilityArePolyFCName + " ПС: " + pointId.ToString());
}
}
iStepNum++;
}
}
else if (calcResults.HasFlag(VisibilityCalculationResultsEnum.VisibilityAreasTrimmedByPoly) &&
!string.IsNullOrEmpty(visibilityArePolyFCName))
{
//Clip visibility images to valuable extent
var inClipName = outImageName;
var outClipName = VisibilityTask.GetResultName(pointIndex > -1 ?
VisibilityCalculationResultsEnum.VisibilityAreaTrimmedByPolySingle :
VisibilityCalculationResultsEnum.VisibilityAreasTrimmedByPoly, outputSourceName, pointIndex);
if (!CalculationLibrary.ClipVisibilityZonesByAreas(
inClipName,
outClipName,
visibilityArePolyFCName,
out messages,
"NONE"))
{
string errorMessage = $"The result {outClipName} was not generated";
result.Exception = new MilSpaceVisibilityCalcFailedException(errorMessage);
result.ErrorMessage = errorMessage;
logger.ErrorEx("> ProcessObservationPoint ERROR ClipVisibilityZonesByAreas. errorMessage:{0}", errorMessage);
results.Add("Помилка: " + errorMessage + " ПС: " + pointId.ToString());
return(messages);
}
else
{
//Add result To Delete if not to show all results. Add Visibility polygon result
if (!showAllResults && generatedResults.ContainsKey(pointId))
{
generatedResults[pointId].Add(outClipName);
}
results.Add(iStepNum.ToString() + ". " + "Зона видимості зведена до дійсного розміру: " + outClipName + " ПС: " + pointId.ToString());
iStepNum++;
removeFullImageFromresult = true;
}
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.CoverageTable))
{
var pointsCount = pointsFilteringIds.Where(id => id > -1).Count();
coverageTableManager.CalculateCoverageTableDataForPoint(
(pointId == -1),
visibilityArePolyFCName,
pointsCount,
exportedFeatureClass,
pointIndex + 1);
results.Add(iStepNum.ToString() + ". " + "Сформовані записи таблиці покриття. для ПС: " + pointId.ToString());
iStepNum++;
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
if (pointId != -1)
{
currentPointIdForBestParamsCalculations = bestOPParametersManager.FindVisibilityPercent(visibilityArePolyFCName, observStationsfeatureClass,
stationsFilteringIds, pointId);
results.Add(iStepNum.ToString() + ". " + "Знайдено відсоток покриття для кроку " + pointId.ToString());
iStepNum++;
if (currentPointIdForBestParamsCalculations < 0)
{
break;
}
}
}
}
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.CoverageTable))
{
var coverageTable = VisibilityTask.GetResultName(VisibilityCalculationResultsEnum.CoverageTable, outputSourceName);
coverageTableManager.SaveDataToCoverageTable(coverageTable);
results.Add(iStepNum.ToString() + ". " + "Збережена загальна таблиця покриття: " + coverageTable);
iStepNum++;
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.BestParametersTable))
{
var bestParamsTableName = VisibilityTask.GetResultName(VisibilityCalculationResultsEnum.BestParametersTable, outputSourceName);
if (bestOPParametersManager.CreateVOTable(observPointsfeatureClass,
visibilityPercent, bestParamsTableName))
{
//Delete unnecessary datasets
if (!showAllResults && bestOPParametersManager.AppropriateedParams != null)
{
foreach (var key in generatedResults.Keys)
{
if (!bestOPParametersManager.AppropriateedParams.Any(k => k.Key == key))
{
foreach (var fc in generatedResults[key])
{
//try to remove feature class
if (!GdbAccess.Instance.RemoveFeatureClass(fc))
{
// it is not FC try to remove raster
GdbAccess.Instance.RemoveRasterDataset(fc);
}
}
}
}
}
results.Add(iStepNum.ToString() + ". " + "Збережена таблиця накращих параметрів ПН для мінімальної видимості " + visibilityPercent + "%: " + bestParamsTableName);
iStepNum++;
}
else
{
results.Add(iStepNum.ToString() + ". " + "Відсутні результати для видимості " + visibilityPercent +
"%. Збережена таблиця з накращими можливими параметрами ПН: " + bestParamsTableName);
iStepNum++;
}
}
//Set real results to show
if (removeFullImageFromresult)
{
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.VisibilityAreaRaster))
{
calcResults &= ~VisibilityCalculationResultsEnum.VisibilityAreaRaster;
}
if (calcResults.HasFlag(VisibilityCalculationResultsEnum.VisibilityAreaRasterSingle))
{
calcResults &= ~VisibilityCalculationResultsEnum.VisibilityAreaRasterSingle;
}
}
session.CalculatedResults = (int)calcResults;
logger.InfoEx("> ProcessObservationPoint END");
return(messages);
}
public bool Psychrometrics_WetBulbTemperature_DryBulbTemperature_Calculation(PsychrometricsData data, out string errorMessage)
{
//if (TPropPageBase::CheckData()) return;
//double p;
//double altitude = m_dblElevation;
//double TWB = m_dblPsychWBT;
//double TDB = m_dblPsychDBT;
//double HumidRatio;
//double RelHumid;
//double Enthalpy;
//double SpVolume;
//double Density;
//double DEWPoint;
if (data.IsInternationalSystemOfUnits_IS_)
{
// metric
//{
// p = Elevation2KPA(m_dblElevation);
// CalcSIProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
// UnitsTemperature = pszSITemp;
// UnitsEnthalpy = pszSIEnthrapy;
// UnitsDensity = pszSIDensity;
// UnitsVolume = pszSISPVolume;
// UnitsHumidity = pszSIHumidityRatio;
// if (Enthalpy > 6030) Enthalpy = -999;
//}
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInMetersToKilopascal(data.Elevation);
}
CalculationLibrary.CalculatePropertiesSI(data);
if (data.Enthalpy > 6030)
{
data.Enthalpy = -999.0;
}
}
else
{
//{
// p = Elevation2PSI(m_dblElevation);
// CalcIPProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
// UnitsTemperature = pszIPTemp;
// UnitsEnthalpy = pszIPEnthrapy;
// UnitsDensity = pszIPDensity;
// UnitsVolume = pszIPSPVolume;
// UnitsHumidity = pszIPHumidityRatio;
// if (Enthalpy > 2758) Enthalpy = -999;
//}
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInFeetToBarometricPressure(data.Elevation);
}
CalculationLibrary.CalculatePropertiesIP(data);
if (data.Enthalpy > 2758)
{
data.Enthalpy = -999.0;
}
data.BarometricPressure = UnitConverter.CalculatePressureFahrenheit(data.BarometricPressure);
}
return(Psychrometrics_CheckCalculationValues(data, out errorMessage));
}
public bool Psychrometrics_Enthalpy_Calculation(PsychrometricsData data, out string errorMessage)
{
data.SpecificVolume = -999;
data.Density = -999;
data.DewPoint = -999;
data.DryBulbTemperature = data.Enthalpy;
if (data.IsInternationalSystemOfUnits_IS_)
{
//TWB = 0;
//p = Elevation2KPA(m_dblElevation);
//void SIEnthalpysearch (int sat,
// double p,
// double RootEnthalpy,
// double&OutputEnthalpy,
// double & TWB,
// double & TDB,
// double HumidRatio,
// double RelHumid,
// double SpVolume,
// double Density,
// double DEWPoint
// )
//SIEnthalpysearch(1, p, TDB, OutH, TWB, TDB, IPHR, IPRH, SpVolume, Density, DEWPoint);
//SIEnthalpysearch(1, BarometricPressure, EnthalpyIn, ref EnthalpyOut, ref TWB, ref TDB, IPHR, IPRH, SpecificVolume, Density, DewPoint);
//CalcSIProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
//Enthalpy = m_dblEnthalpy;
//UnitsTemperature = pszSITemp;
//UnitsEnthalpy = pszSIEnthrapy;
//UnitsDensity = pszSIDensity;
//UnitsVolume = pszSISPVolume;
//UnitsHumidity = pszSIHumidityRatio;
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInMetersToKilopascal(data.Elevation);
}
CalculationLibrary.EnthalpySI(1, data);
//CalculationLibrary.EnthalpySI(1,
// data.BarometricPressure,
// data.Enthalpy,
// ref dataEnthalpy,
// ref dataTemperatureWetBulb,
// ref dataTemperatureDryBulb,
// data.HumidityRatio,
// data.RelativeHumidity,
// data.SpecificVolume,
// data.Density,
// data.DewPoint);
CalculationLibrary.CalculatePropertiesSI(data);
}
else
{
//p = Elevation2PSI(m_dblElevation);
//void IPEnthalpysearch (int sat,
// double p,
// double RootEnthalpy,
// double&OutputEnthalpy,
// double & TWB,
// double & TDB,
// double HumidRatio,
// double RelHumid,
// double SpVolume,
// double Density,
// double DEWPoint)
//IPEnthalpysearch(1, p, TDB, OutH, TWB, TDB, IPHR, IPRH, SpVolume, Density, DEWPoint);
//CalcIPProperties(p, TWB, TDB, HumidRatio, RelHumid, Enthalpy, SpVolume, Density, DEWPoint);
//Enthalpy = m_dblEnthalpy;
//UnitsTemperature = pszIPTemp;
//UnitsEnthalpy = pszIPEnthrapy;
//UnitsDensity = pszIPDensity;
//UnitsVolume = pszIPSPVolume;
//UnitsHumidity = pszIPHumidityRatio;
if (data.IsElevation)
{
data.BarometricPressure = UnitConverter.ConvertElevationInFeetToBarometricPressure(data.Elevation);
}
CalculationLibrary.EnthalpyIP(1, data);
//CalculationLibrary.EnthalpyIP(1,
// data.BarometricPressure,
// data.Enthalpy,
// ref dataEnthalpy,
// ref dataTemperatureWetBulb,
// ref dataTemperatureDryBulb,
// data.HumidityRatio,
// data.RelativeHumidity,
// data.SpecificVolume,
// data.Density,
// data.DewPoint);
CalculationLibrary.CalculatePropertiesIP(data);
data.BarometricPressure = UnitConverter.CalculatePressureFahrenheit(data.BarometricPressure);
}
return(Psychrometrics_CheckCalculationValues(data, out errorMessage));
}
