/// <summary>
/// Constructor for the sub grid retriever helper
/// </summary>
/// <param name="siteModel">The project this sub gris is being retrieved from</param>
/// <param name="gridDataType">The type of client grid data sub grids to be returned by this retriever</param>
/// <param name="storageProxy">The Ignite storage proxy to be used when requesting data from the persistent store</param>
/// <param name="filter">The TRex spatial and attribute filtering description for the request</param>
/// <param name="filterAnnex">An annex of data related to cell by cell filtering where the attributes related to that cell may change from cell to cell</param>
/// <param name="hasOverrideSpatialCellRestriction">The spatially selected cells are masked by a rectangular restriction boundary</param>
/// <param name="overrideSpatialCellRestriction"></param>
/// <param name="prepareGridForCacheStorageIfNoSieving">The cell coordinate bounding box restricting cells involved in the request</param>
/// <param name="maxNumberOfPassesToReturn">The maximum number of passes in a cell in a sub grid that will be considered when processing the request</param>
/// <param name="areaControlSet">The skip/step area control set for selection of cells with sub grids for processing. Cells not identified by the control set will return null values.</param>
/// <param name="populationControl">The delegate responsible for populating events depended on for processing the request.</param>
/// <param name="pDExistenceMap">The production data existence map for the project the request relates to</param>
/// <param name="overrides">The set of overriding machine event values to use</param>
/// <param name="liftParams">The set of layer/lift analysis parameters to use</param>
public ProgressiveVolumesSubGridRetriever(ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
: base(siteModel, gridDataType, filter, filterAnnex,
hasOverrideSpatialCellRestriction, overrideSpatialCellRestriction, prepareGridForCacheStorageIfNoSieving, maxNumberOfPassesToReturn,
storageProxy, areaControlSet, populationControl, pDExistenceMap, overrides, liftParams)
{
// Clear any time element from the supplied filter. Time constraints ar derived from the startDate and endDate parameters
filter.AttributeFilter.HasTimeFilter = false;
// Clear any instruction in the filter to extract the earliest value - this has no meaning in progressive calculations
filter.AttributeFilter.ReturnEarliestFilteredCellPass = false;
// Remove any first/last/highest/lowest aspect from the filter - this has no meaning in progressive calculations
filter.AttributeFilter.HasElevationTypeFilter = false;
// Remove any machine filtering - the intent here is to examine volume progression over time, machine breakdowns don't make sense at this point
filter.AttributeFilter.HasMachineFilter = false;
}
/// <summary>
/// Given a design used as an elevation range filter aspect, retrieve the existence map for the design and
/// includes it in the supplied overall existence map for the query
/// </summary>
public static bool ProcessDesignElevationsForFilter(ISiteModel siteModel, //Guid siteModelID,
ICombinedFilter filter,
ISubGridTreeBitMask overallExistenceMap)
{
if (filter == null)
{
return(true);
}
if (overallExistenceMap == null)
{
return(false);
}
if (filter.AttributeFilter.HasElevationRangeFilter && filter.AttributeFilter.ElevationRangeDesign.DesignID != Guid.Empty)
{
var designExistenceMap = DIContext.Obtain <IExistenceMaps>().GetSingleExistenceMap
(siteModel.ID, Consts.EXISTENCE_MAP_DESIGN_DESCRIPTOR, filter.AttributeFilter.ElevationRangeDesign.DesignID);
if (designExistenceMap != null)
{
// Not sure this is really needed...
designExistenceMap.CellSize = SubGridTreeConsts.SubGridTreeDimension * siteModel.CellSize;
overallExistenceMap.SetOp_OR(designExistenceMap);
}
}
return(true);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="startDate">The date at which to start calculating progressive sub grids</param>
/// <param name="endDate">The date beyond which no further progressive sub grids will be calculated</param>
/// <param name="interval">The time interval between successive calculations of progressive sub grids</param>
public ComputeProgressiveVolumes_Coordinator(Guid siteModelId,
ILiftParameters liftParams,
VolumeComputationType volumeType,
ICombinedFilter filter,
DesignOffset baseDesign,
DesignOffset topDesign,
ICombinedFilter additionalSpatialFilter,
double cutTolerance,
double fillTolerance,
DateTime startDate,
DateTime endDate,
TimeSpan interval)
{
SiteModelID = siteModelId;
VolumeType = volumeType;
Filter = filter;
_baseDesign = baseDesign;
_topDesign = topDesign;
AdditionalSpatialFilter = additionalSpatialFilter;
CutTolerance = cutTolerance;
FillTolerance = fillTolerance;
_liftParams = liftParams;
StartDate = startDate;
EndDate = endDate;
Interval = interval;
}
/// <summary>
/// Serializes content from the writer
/// </summary>
public override void InternalFromBinary(IBinaryRawReader reader)
{
base.InternalFromBinary(reader);
var version = VersionSerializationHelper.CheckVersionByte(reader, VERSION_NUMBER);
if (version == 1)
{
ProjectID = reader.ReadGuid() ?? Guid.Empty;
VolumeType = (VolumeComputationType)reader.ReadInt();
BaseFilter = ReadFilter(reader);
TopFilter = ReadFilter(reader);
if (reader.ReadBoolean())
{
BaseDesign = new DesignOffset();
BaseDesign.FromBinary(reader);
}
if (reader.ReadBoolean())
{
TopDesign = new DesignOffset();
TopDesign.FromBinary(reader);
}
AdditionalSpatialFilter = ReadFilter(reader);
CutTolerance = reader.ReadDouble();
FillTolerance = reader.ReadDouble();
}
}
/// <summary>
/// Constructor accepting a pair of filter to be set into the filter set
/// Null filters are not incorporated into the resulting filter set
/// </summary>
public FilterSet(ICombinedFilter filter1, ICombinedFilter filter2)
{
Filters = filter1 == null && filter2 == null
? new ICombinedFilter[0]
: filter2 == null
? new[] { filter1 }
: filter1 == null
? new [] { filter2 }
: new [] { filter1, filter2 };
}
private ICombinedFilter ReadFilter(IBinaryRawReader reader)
{
ICombinedFilter filter = null;
if (reader.ReadBoolean())
{
filter = new CombinedFilter();
filter.FromBinary(reader);
}
return(filter);
}
ITRexSpatialMemoryCacheContext[] CacheContexts) GetIntermediary(ICombinedFilter filter)
{
// Construct the appropriate list of surveyed surfaces
// Obtain local reference to surveyed surface list. If it is replaced while processing the
// list then the local reference will still be valid allowing lock free read access to the list.
ISurveyedSurfaces filteredSurveyedSurfaces = null;
var surveyedSurfaceList = siteModel.SurveyedSurfaces;
if (includeSurveyedSurfaceInformation && surveyedSurfaceList?.Count > 0)
{
filteredSurveyedSurfaces = DIContext.Obtain <ISurveyedSurfaces>();
// Filter out any surveyed surfaces which don't match current filter (if any) - realistically, this is time filters we're thinking of here
surveyedSurfaceList.FilterSurveyedSurfaceDetails(filter.AttributeFilter.HasTimeFilter,
filter.AttributeFilter.StartTime, filter.AttributeFilter.EndTime,
filter.AttributeFilter.ExcludeSurveyedSurfaces(), filteredSurveyedSurfaces,
filter.AttributeFilter.SurveyedSurfaceExclusionList);
// Ensure that the filtered surveyed surfaces are in a known ordered state
filteredSurveyedSurfaces.SortChronologically(filter.AttributeFilter.ReturnEarliestFilteredCellPass);
}
var filteredSurveyedSurfacesAsArray = filteredSurveyedSurfaces?.Count > 0 ? filteredSurveyedSurfaces.Select(s => s.ID).ToArray() : new Guid[0];
// Get a caching context for the sub grids returned by this requester, but only if the requested grid data type supports it
ITRexSpatialMemoryCacheContext[] subGridCacheContexts = null;
if (_enableGeneralSubGridResultCaching &&
ClientLeafSubGrid.SupportsAssignationFromCachedPreProcessedClientSubGrid[(int)gridDataType])
{
filter.AttributeFilter.SiteModel = siteModel;
var contextType1 = Utilities.IntermediaryICGridDataTypeForDataType(gridDataType, true);
var contextType2 = Utilities.IntermediaryICGridDataTypeForDataType(gridDataType, false);
var context1 = SubGridCache?.LocateOrCreateContext(siteModel.ID, contextType1,
SpatialCacheFingerprint.ConstructFingerprint(siteModel.ID, contextType1, filter, filteredSurveyedSurfacesAsArray));
var context2 = SubGridCache?.LocateOrCreateContext(siteModel.ID, contextType2,
SpatialCacheFingerprint.ConstructFingerprint(siteModel.ID, contextType2, filter, filteredSurveyedSurfacesAsArray));
subGridCacheContexts = new[] { context1, context2 }.Where(x => x != null).ToArray();
}
return(gridDataType,
filter,
filteredSurveyedSurfaces,
_surfaceElevationPatchRequestFactory(SubGridCache, SubGridCache?.LocateOrCreateContext(siteModel.ID, GridDataType.SurveyedSurfaceHeightAndTime,
SpatialCacheFingerprint.ConstructFingerprint(siteModel.ID, GridDataType.SurveyedSurfaceHeightAndTime, null,
filteredSurveyedSurfaces?.Select(x => x.ID).ToArray() ?? new Guid[0]))),
subGridCacheContexts);
}
/// <summary>
/// Constructor for the sub grid retriever helper
/// </summary>
/// <param name="siteModel">The project this sub gris is being retrieved from</param>
/// <param name="gridDataType">The type of client grid data sub grids to be returned by this retriever</param>
/// <param name="storageProxy">The Ignite storage proxy to be used when requesting data from the persistent store</param>
/// <param name="filter">The TRex spatial and attribute filtering description for the request</param>
/// <param name="filterAnnex">An annex of data related to cell by cell filtering where the attributes related to that cell may change from cell to cell</param>
/// <param name="hasOverrideSpatialCellRestriction">The spatially selected cells are masked by a rectangular restriction boundary</param>
/// <param name="overrideSpatialCellRestriction"></param>
/// <param name="prepareGridForCacheStorageIfNoSieving">The cell coordinate bounding box restricting cells involved in the request</param>
/// <param name="maxNumberOfPassesToReturn">The maximum number of passes in a cell in a sub grid that will be considered when processing the request</param>
/// <param name="areaControlSet">The skip/step area control set for selection of cells with sub grids for processing. Cells not identified by the control set will return null values.</param>
/// <param name="populationControl">The delegate responsible for populating events depended on for processing the request.</param>
/// <param name="pDExistenceMap">The production data existence map for the project the request relates to</param>
/// <param name="overrides">The set of overriding machine event values to use</param>
/// <param name="liftParams">The set of layer/lift analysis parameters to use</param>
public SubGridRetriever(ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
: base(siteModel, gridDataType, filter, filterAnnex,
hasOverrideSpatialCellRestriction, overrideSpatialCellRestriction, prepareGridForCacheStorageIfNoSieving, maxNumberOfPassesToReturn,
storageProxy, areaControlSet, populationControl, pDExistenceMap, overrides, liftParams)
{
}
protected SubGridRetrieverBase(ISiteModel siteModel,
GridDataType gridDataType,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
bool prepareGridForCacheStorageIfNoSieving,
int maxNumberOfPassesToReturn,
IStorageProxy storageProxy,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pDExistenceMap,
IOverrideParameters overrides,
ILiftParameters liftParams)
{
_segmentIterator = null;
_cellPassIterator = null;
_siteModel = siteModel;
_gridDataType = gridDataType;
_filter = filter;
_filterAnnex = filterAnnex;
_hasOverrideSpatialCellRestriction = hasOverrideSpatialCellRestriction;
_overrideSpatialCellRestriction = overrideSpatialCellRestriction;
_prepareGridForCacheStorageIfNoSieving = prepareGridForCacheStorageIfNoSieving;
_maxNumberOfPassesToReturn = maxNumberOfPassesToReturn;
_storageProxy = storageProxy;
_populationControl = populationControl;
_areaControlSet = areaControlSet;
_pdExistenceMap = pDExistenceMap;
_overrides = overrides;
_liftParams = liftParams;
// Create and configure the assignment context which is used to contain a filtered pass and
// its attendant machine events and target values prior to assignment to the client sub grid.
_assignmentContext = new FilteredValueAssignmentContext {
Overrides = overrides, LiftParams = liftParams
};
_filter.AttributeFilter.SiteModel = siteModel;
_canUseGlobalLatestCells = _filter.AttributeFilter.LastRecordedCellPassSatisfiesFilter;
}
public static bool ConstructSubGridCellFilterMask(ILeafSubGrid SubGridAsLeaf,
ISiteModel SiteModel,
ICombinedFilter Filter,
SubGridTreeBitmapSubGridBits CellOverrideMask,
bool AHasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D AOverrideSpatialCellRestriction,
SubGridTreeBitmapSubGridBits PDMask,
SubGridTreeBitmapSubGridBits FilterMask)
{
ConstructSubgridSpatialAndPositionalMask(SubGridAsLeaf, SiteModel, Filter,
AHasOverrideSpatialCellRestriction, AOverrideSpatialCellRestriction,
PDMask, FilterMask);
// Apply any override mask supplied by the caller. If all bits are required in the override,
// then a filled mask should be supplied...
PDMask.AndWith(CellOverrideMask);
// If the filter contains a design mask filter then compute this and AND it with the
// mask calculated in the step above to derive the final required filter mask
if (Filter != null && Filter.SpatialFilter.HasAlignmentDesignMask())
{
if (Filter.SpatialFilter.AlignmentFence.IsNull()) // Should have been done in ASNode but if not
{
throw new ArgumentException($"Spatial filter does not contained pre-prepared alignment fence for design {Filter.SpatialFilter.AlignmentDesignMaskDesignUID}");
}
// Go over set bits and determine if they are in Design fence boundary
FilterMask.ForEachSetBit((X, Y) =>
{
SiteModel.Grid.GetCellCenterPosition(SubGridAsLeaf.OriginX + X, SubGridAsLeaf.OriginY + Y, out var CX, out var CY);
if (!Filter.SpatialFilter.AlignmentFence.IncludesPoint(CX, CY))
{
FilterMask.ClearBit(X, Y); // remove interest as its not in design boundary
}
});
}
PDMask.AndWith(FilterMask);
return(true);
}
/// <summary>
/// Constructor
/// </summary>
public ComputeSimpleVolumes_Coordinator(Guid siteModelID,
ILiftParameters liftParams,
VolumeComputationType volumeType,
ICombinedFilter baseFilter,
ICombinedFilter topFilter,
DesignOffset baseDesign,
DesignOffset topDesign,
ICombinedFilter additionalSpatialFilter,
double cutTolerance,
double fillTolerance)
{
SiteModelID = siteModelID;
VolumeType = volumeType;
BaseFilter = baseFilter;
TopFilter = topFilter;
BaseDesign = baseDesign;
TopDesign = topDesign;
AdditionalSpatialFilter = additionalSpatialFilter;
CutTolerance = cutTolerance;
FillTolerance = fillTolerance;
LiftParams = liftParams;
}
/// <summary>
/// Given a filter compute which of the surfaces in the list match any given time aspect
/// of the filter, and the overall existence map of the surveyed surfaces that match the filter.
/// ComparisonList denotes a possibly pre-filtered set of surfaces for another filter; if this is the same as the
/// filtered set of surfaces then the overall existence map for those surfaces will not be computed as it is
/// assumed to be the same.
/// </summary>
public bool ProcessSurveyedSurfacesForFilter(Guid siteModelId,
ICombinedFilter filter,
ISurveyedSurfaces comparisonList,
ISurveyedSurfaces filteredSurveyedSurfaces,
ISubGridTreeBitMask overallExistenceMap)
{
// Filter out any surveyed surfaces which don't match current filter (if any) - realistically, this is time filters we're thinking of here
FilterSurveyedSurfaceDetails(filter.AttributeFilter.HasTimeFilter,
filter.AttributeFilter.StartTime, filter.AttributeFilter.EndTime,
filter.AttributeFilter.ExcludeSurveyedSurfaces(),
filteredSurveyedSurfaces,
filter.AttributeFilter.SurveyedSurfaceExclusionList);
if (filteredSurveyedSurfaces != null)
{
if (filteredSurveyedSurfaces.IsSameAs(comparisonList))
{
return(true);
}
if (filteredSurveyedSurfaces.Count > 0)
{
var surveyedSurfaceExistenceMap = GetExistenceMaps().GetCombinedExistenceMap(siteModelId,
filteredSurveyedSurfaces.Select(x => new Tuple <long, Guid>(Consts.EXISTENCE_SURVEYED_SURFACE_DESCRIPTOR, x.ID)).ToArray());
if (overallExistenceMap == null)
{
return(false);
}
overallExistenceMap.SetOp_OR(surveyedSurfaceExistenceMap);
}
}
return(true);
}
public static void ConstructSubgridSpatialAndPositionalMask(ILeafSubGrid SubGridAsLeaf,
ISiteModel SiteModel,
ICombinedFilter Filter,
bool AHasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D AOverrideSpatialCellRestriction,
SubGridTreeBitmapSubGridBits PDMask,
SubGridTreeBitmapSubGridBits FilterMask)
{
if (Filter == null || !Filter.SpatialFilter.HasSpatialOrPositionalFilters)
{
PDMask.Fill();
FilterMask.Fill();
return;
}
var originX = SubGridAsLeaf.OriginX;
var originY = SubGridAsLeaf.OriginY;
var cellSize = SiteModel.CellSize;
// Get the world location of the origin position
SiteModel.Grid.GetCellCenterPosition(originX, originY, out var OX, out var OY);
var SpatialFilter = Filter.SpatialFilter;
// Attempt to satisfy the calculation below on the basis of the sub grid wholly residing in the override and filter spatial restrictions
if (SpatialFilter.Fence.IncludesExtent(new BoundingWorldExtent3D(OX, OY,
OX + cellSize * SubGridTreeConsts.SubGridTreeDimension,
OY + cellSize * SubGridTreeConsts.SubGridTreeDimension)))
{
// The extent of the sub grid is wholly contained in the filter, therefore there is no need to iterate though all the cells
// individually...
FilterMask.Fill();
// ... unless there is an override spatial cell restriction that does not enclose the extent of the sub grid
if (AHasOverrideSpatialCellRestriction &&
!AOverrideSpatialCellRestriction.Encloses(new BoundingIntegerExtent2D((int)originX, (int)originY,
(int)originX + SubGridTreeConsts.SubGridTreeDimension,
(int)originY + SubGridTreeConsts.SubGridTreeDimension)))
{
for (byte I = 0; I < SubGridTreeConsts.SubGridTreeDimension; I++)
{
for (byte J = 0; J < SubGridTreeConsts.SubGridTreeDimension; J++)
{
if (!AOverrideSpatialCellRestriction.Includes(originX + I, originY + J))
{
FilterMask.ClearBit(I, J);
}
}
}
}
}
else
{
// Perform the calculation the long hand way
// ... Idea: Invert row and column order of calculation below to get and set bits based on an entire column of bits
FilterMask.Clear();
// Construct the filter mask based on the spatial and location (square/circle/polygonal) filtering
double CX = OX;
for (byte I = 0; I < SubGridTreeConsts.SubGridTreeDimension; I++)
{
int OriginXPlusI = originX + I;
double CY = OY; // Set to the first row in the column about to be processed
for (byte J = 0; J < SubGridTreeConsts.SubGridTreeDimension; J++)
{
if (AHasOverrideSpatialCellRestriction && !AOverrideSpatialCellRestriction.Includes((int)OriginXPlusI, (int)(originY + J)))
{
// Do nothing
}
else
{
// SiteModel.Grid.GetCellCenterPosition(OriginXPlusI, originY + J, out CX, out CY);
if (SpatialFilter.IsCellInSelection(CX, CY))
{
FilterMask.SetBit(I, J);
}
}
CY += cellSize; // Move to next row
}
CX += cellSize; // Move to next column
}
}
}
/// <summary>
/// Constructs a string representing the fingerprint of a request required spatial data. The fingerprint is designed to identify a context within
/// which cached general sub grid results may be stored and accessed during query processing.
/// </summary>
/// <param name="projectUid">The Guid identifying the project within the fingerprint</param>
/// <param name="gridDataType">The type of data being requested in the query</param>
/// <param name="filter">The set of filters that govern the query</param>
/// <param name="includedSurveyedSurfaces">The list of surveyed surfaces included in the query, expressed as a an array of GUIDs</param>
/// <returns>A string representing the uniqueness of this spatial cache element</returns>
public static string ConstructFingerprint(Guid projectUid, GridDataType gridDataType, ICombinedFilter filter, Guid[] includedSurveyedSurfaces)
{
var sb = new StringBuilder();
sb.Append(projectUid).Append('-').Append(gridDataType);
if (filter != null)
{
sb.Append('-').Append(filter.AttributeFilter.SpatialCacheFingerprint());
}
if (includedSurveyedSurfaces.Length > 0)
{
includedSurveyedSurfaces.ForEach(x => sb.Append(x));
}
return(sb.ToString());
}
/// <summary>
/// Constructor accepting a single filters to be set into the filter set
/// Null filters are not incorporated into the resulting filter set
/// </summary>
public FilterSet(ICombinedFilter filter)
{
Filters = filter != null ? new [] { filter } : new ICombinedFilter[0];
}
/*
* private IExistenceMaps existenceMaps = null;
* private IExistenceMaps GetExistenceMaps() => existenceMaps ??= DIContext.Obtain<IExistenceMaps>());
*/
/// <summary>
/// Prepare a filter for use by performing any necessary coordinate conversions and requesting any
/// supplemental information such as alignment design boundary calculations.
/// </summary>
public static RequestErrorStatus PrepareFilterForUse(ICombinedFilter filter, Guid dataModelId)
{
// Fence DesignBoundary = null;
var result = RequestErrorStatus.OK;
if (filter == null)
{
return(result);
}
if (filter.SpatialFilter != null)
{
if (!filter.SpatialFilter.CoordsAreGrid)
{
var siteModel = DIContext.Obtain <ISiteModels>().GetSiteModel(dataModelId);
XYZ[] llhCoords;
// If the filter has a spatial or positional context, then convert the LLH values in the
// spatial context into the NEE values consistent with the data model.
if (filter.SpatialFilter.IsSpatial)
{
llhCoords = new XYZ[filter.SpatialFilter.Fence.NumVertices];
// Note: Lat/Lons in filter fence boundaries are supplied to us in decimal degrees, not radians
for (var fencePointIdx = 0; fencePointIdx < filter.SpatialFilter.Fence.NumVertices; fencePointIdx++)
{
llhCoords[fencePointIdx] = new XYZ(MathUtilities.DegreesToRadians(filter.SpatialFilter.Fence[fencePointIdx].X), MathUtilities.DegreesToRadians(filter.SpatialFilter.Fence[fencePointIdx].Y), 0);
}
XYZ[] neeCoords;
try
{
neeCoords = DIContext
.Obtain <ICoreXWrapper>()
.LLHToNEE(siteModel.CSIB(), llhCoords.ToCoreX_XYZ(), InputAs.Radians)
.ToTRex_XYZ();
}
catch (Exception e)
{
return(RequestErrorStatus.FailedToConvertClientWGSCoords);
}
for (var fencePointIdx = 0; fencePointIdx < filter.SpatialFilter.Fence.NumVertices; fencePointIdx++)
{
filter.SpatialFilter.Fence[fencePointIdx].X = neeCoords[fencePointIdx].X;
filter.SpatialFilter.Fence[fencePointIdx].Y = neeCoords[fencePointIdx].Y;
}
// Ensure that the bounding rectangle for the filter fence correctly encloses the newly calculated grid coordinates
filter.SpatialFilter.Fence.UpdateExtents();
}
if (filter.SpatialFilter.IsPositional)
{
// Note: Lat/Lons in positions are supplied to us in decimal degrees, not radians
llhCoords = new[] { new XYZ(MathUtilities.DegreesToRadians(filter.SpatialFilter.PositionX), MathUtilities.DegreesToRadians(filter.SpatialFilter.PositionY), 0) };
XYZ[] neeCoords;
try
{
neeCoords = DIContext
.Obtain <ICoreXWrapper>()
.LLHToNEE(siteModel.CSIB(), llhCoords.ToCoreX_XYZ(), InputAs.Radians)
.ToTRex_XYZ();
}
catch
{
return(RequestErrorStatus.FailedToConvertClientWGSCoords);
}
filter.SpatialFilter.PositionX = neeCoords[0].X;
filter.SpatialFilter.PositionY = neeCoords[0].Y;
}
filter.SpatialFilter.CoordsAreGrid = true;
}
// Ensure that the bounding rectangle for the filter fence correctly encloses the newly calculated grid coordinates
filter.SpatialFilter?.Fence.UpdateExtents();
// Is there an alignment file to look up? If so, only do it if there not an already existing alignment fence boundary
if (filter.SpatialFilter.HasAlignmentDesignMask() && !(filter.SpatialFilter.AlignmentFence?.HasVertices ?? true))
{
var boundaryRequest = new AlignmentDesignFilterBoundaryRequest();
var boundaryResult = boundaryRequest.Execute
(new AlignmentDesignFilterBoundaryArgument
{
ProjectID = dataModelId,
ReferenceDesign = new DesignOffset(filter.SpatialFilter.AlignmentDesignMaskDesignUID, 0),
StartStation = filter.SpatialFilter.StartStation ?? Common.Consts.NullDouble,
EndStation = filter.SpatialFilter.EndStation ?? Common.Consts.NullDouble,
LeftOffset = filter.SpatialFilter.LeftOffset ?? Common.Consts.NullDouble,
RightOffset = filter.SpatialFilter.RightOffset ?? Common.Consts.NullDouble,
Filters = new FilterSet(new CombinedFilter())
});
if (boundaryResult.RequestResult != DesignProfilerRequestResult.OK)
{
_log.LogError($"{nameof(PrepareFilterForUse)}: Failed to get boundary for alignment design ID:{filter.SpatialFilter.AlignmentDesignMaskDesignUID}");
return(RequestErrorStatus.NoResultReturned);
}
filter.SpatialFilter.AlignmentFence = boundaryResult.Boundary;
}
// Is there a surface design to look up
if (filter.SpatialFilter.HasSurfaceDesignMask())
{
// Todo: Not yet supported (or demonstrated that it's needed as this should be taken care of in the larger scale determination of the sub grids that need to be queried).
/* If the filter needs to retain a reference to the existence map, then do this...
* Filter.SpatialFilter.DesignMaskExistenceMap = GetExistenceMaps().GetSingleExistenceMap(ProjectUid, EXISTENCE_MAP_DESIGN_DESCRIPTOR, Filter.SpatialFilter.SurfaceDesignMaskDesignUid);
*
* if (Filter.SpatialFilter.DesignMaskExistenceMap == null)
* {
* Log.LogError($"PrepareFilterForUse: Failed to get existence map for surface design ID:{Filter.SpatialFilter.SurfaceDesignMaskDesignUid}");
* }
*/
}
}
return(result);
}
private void WriteFilter(IBinaryRawWriter writer, ICombinedFilter filter)
{
writer.WriteBoolean(filter != null);
filter?.ToBinary(writer);
}
public ISubGridRetriever Instance(ISubGridsRequestArgument subGridsRequestArgument,
ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
ICellPassAttributeFilterProcessingAnnex filterAnnex,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pdExistenceMap,
ITRexSpatialMemoryCacheContext[] subGridCacheContexts,
IOverrideParameters overrides,
ILiftParameters liftParams)
{
if (gridDataType == GridDataType.ProgressiveVolumes)
{
var retriever = new ProgressiveVolumesSubGridRetriever(siteModel,
gridDataType,
storageProxy,
filter,
filterAnnex,
hasOverrideSpatialCellRestriction,
overrideSpatialCellRestriction,
subGridCacheContexts != null,
maxNumberOfPassesToReturn,
areaControlSet,
populationControl,
pdExistenceMap,
overrides,
liftParams);
if (subGridsRequestArgument is IProgressiveVolumesSubGridsRequestArgument argument)
{
retriever.StartDate = argument.StartDate;
retriever.EndDate = argument.EndDate;
retriever.Interval = argument.Interval;
}
else
{
throw new ArgumentException($"Argument passed to sub grid retriever factory for progressive volumes retriever construction is not an expected type: {subGridsRequestArgument.GetType()}");
}
return(retriever);
}
else
{
var retriever = new SubGridRetriever(siteModel,
gridDataType,
storageProxy,
filter,
filterAnnex,
hasOverrideSpatialCellRestriction,
overrideSpatialCellRestriction,
subGridCacheContexts != null,
maxNumberOfPassesToReturn,
areaControlSet,
populationControl,
pdExistenceMap,
overrides,
liftParams);
return(retriever);
}
}
/// <summary>
/// Constructor that accepts the common parameters around a set of sub grids the requester will be asked to process
/// and initializes the requester state ready to start processing individual sub grid requests.
/// </summary>
public void Initialize(ISubGridsRequestArgument subGridsRequestArgument,
ISiteModel siteModel,
GridDataType gridDataType,
IStorageProxy storageProxy,
ICombinedFilter filter,
bool hasOverrideSpatialCellRestriction,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
int maxNumberOfPassesToReturn,
AreaControlSet areaControlSet,
IFilteredValuePopulationControl populationControl,
ISubGridTreeBitMask pdExistenceMap,
ITRexSpatialMemoryCache subGridCache,
ITRexSpatialMemoryCacheContext[] subGridCacheContexts,
ISurveyedSurfaces filteredSurveyedSurfaces,
ISurfaceElevationPatchRequest surfaceElevationPatchRequest,
IOverrideParameters overrides,
ILiftParameters liftParams)
{
_siteModel = siteModel;
_gridDataType = gridDataType;
_filter = filter;
_hasOverrideSpatialCellRestriction = hasOverrideSpatialCellRestriction;
_overrideSpatialCellRestriction = overrideSpatialCellRestriction;
_retriever = DIContext.Obtain <ISubGridRetrieverFactory>().Instance(subGridsRequestArgument,
siteModel,
gridDataType,
storageProxy,
filter,
_filterAnnex,
hasOverrideSpatialCellRestriction,
overrideSpatialCellRestriction,
maxNumberOfPassesToReturn,
areaControlSet,
populationControl,
pdExistenceMap,
subGridCacheContexts,
overrides,
liftParams);
_returnEarliestFilteredCellPass = _filter.AttributeFilter.ReturnEarliestFilteredCellPass;
_processingMap = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Unfilled);
_surfaceElevationPatchRequest = surfaceElevationPatchRequest;
_subGridCache = subGridCache;
_subGridCacheContexts = subGridCacheContexts;
_surveyedSurfacePatchType = _filter.AttributeFilter.ReturnEarliestFilteredCellPass ? SurveyedSurfacePatchType.EarliestSingleElevation : SurveyedSurfacePatchType.LatestSingleElevation;
_filteredSurveyedSurfaces = filteredSurveyedSurfaces;
_filteredSurveyedSurfaces?.SortChronologically(_surveyedSurfacePatchType == SurveyedSurfacePatchType.LatestSingleElevation);
_filteredSurveyedSurfacesAsGuidArray = _filteredSurveyedSurfaces?.Select(x => x.ID).ToArray() ?? new Guid[0];
var elevRangeDesignFilter = _filter.AttributeFilter.ElevationRangeDesign;
if (elevRangeDesignFilter.DesignID != Guid.Empty)
{
var design = _siteModel.Designs.Locate(elevRangeDesignFilter.DesignID);
if (design == null)
{
_log.LogError($"ElevationRangeDesign {elevRangeDesignFilter.DesignID} is unknown in project {siteModel.ID}");
}
else
{
_elevationRangeDesign = new DesignWrapper(elevRangeDesignFilter, design);
}
}
if (_filter.SpatialFilter.IsDesignMask)
{
_surfaceDesignMaskDesign = _siteModel.Designs.Locate(_filter.SpatialFilter.SurfaceDesignMaskDesignUid);
}
_filter.AttributeFilter.SiteModel = _siteModel;
}
