/// <summary>
/// ScanSubGrids scans all sub grids at a requested level in the tree that
/// intersect the given real world extent. Each sub grid that exists in the
/// extent is passed to the OnProcessLeafSubGrid event for processing
/// leafFunctor and nodeFunctor are delegate/events called when scanning
/// leaf sub grids in the sub grid tree (or any other events where the
/// a leaf sub grid needs to passed to a processor). A return result of False
/// from a functor indicates the receiver of the event has requested the scanning process stop.
/// </summary>
/// <returns>A boolean indicating the ScanSubGrids operation was successful and not aborted by a functor</returns>
public bool ScanSubGrids(BoundingIntegerExtent2D extent,
Func <ISubGrid, bool> leafFunctor = null,
Func <ISubGrid, SubGridProcessNodeSubGridResult> nodeFunctor = null)
{
// Allow the scanner to deal with the node sub grid and short circuit scanning here if desired
if (nodeFunctor != null && nodeFunctor(this) == SubGridProcessNodeSubGridResult.TerminateProcessing)
{
return(false);
}
// Work out the on-the-ground cell extent needed to be scanned that this sub grid covers
var scanMinX = Math.Max(originX, extent.MinX);
var scanMinY = Math.Max(originY, extent.MinY);
var scanMaxX = Math.Min(originX + AxialCellCoverageByThisSubGrid() - 1, extent.MaxX);
var scanMaxY = Math.Min(originY + AxialCellCoverageByThisSubGrid() - 1, extent.MaxY);
// Convert the on-the-ground cell indexes into sub grid indexes at this level in the sub grid tree
GetSubGridCellIndex(scanMinX, scanMinY, out var subGridMinX, out var subGridMinY);
GetSubGridCellIndex(scanMaxX, scanMaxY, out var subGridMaxX, subGridY: out var subGridMaxY);
ForEachSubGrid(subGrid =>
{
if (leafFunctor != null && subGrid.IsLeafSubGrid()) // Leaf sub grids are passed to leafFunctor
{
return(leafFunctor(subGrid) ? SubGridProcessNodeSubGridResult.OK : SubGridProcessNodeSubGridResult.TerminateProcessing);
}
// Node sub grids are descended into recursively to continue processing
return(!((INodeSubGrid)subGrid).ScanSubGrids(extent, leafFunctor, nodeFunctor) ? SubGridProcessNodeSubGridResult.TerminateProcessing : SubGridProcessNodeSubGridResult.OK);
},
subGridMinX, subGridMinY, subGridMaxX, subGridMaxY);
return(true);
}
/// <summary>
/// Constructs the context of a pipelined processor based on the project, filters and other common criteria
/// of pipelined requests
/// </summary>
/// <param name="overrideSpatialCellRestriction">A restriction on the cells that are returned via the query that intersects with the spatial selection filtering and criteria</param>
public IPipelineProcessor NewInstance <TSubGridsRequestArgument>(Guid requestDescriptor,
Guid dataModelID,
GridDataType gridDataType,
ISubGridsPipelinedReponseBase response,
IFilterSet filters,
DesignOffset cutFillDesign,
ITRexTask task,
ISubGridPipelineBase pipeline,
IRequestAnalyser requestAnalyser,
bool requireSurveyedSurfaceInformation,
bool requestRequiresAccessToDesignFileExistenceMap,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
ILiftParameters liftParams)
{
var pipelineProcessor = NewInstanceNoBuild <TSubGridsRequestArgument>
(requestDescriptor, dataModelID, gridDataType, response, filters, cutFillDesign,
task, pipeline, requestAnalyser, requireSurveyedSurfaceInformation, requestRequiresAccessToDesignFileExistenceMap,
overrideSpatialCellRestriction, liftParams);
if (!pipelineProcessor.Build())
{
Log.LogError($"Failed to build pipeline processor for request to model {dataModelID}");
pipelineProcessor = null;
}
return(pipelineProcessor as IPipelineProcessor);
}
public void NewInstance()
{
var factory = new PipelineProcessorFactory();
var processor = factory.NewInstance <SubGridsRequestArgument>(
Guid.NewGuid(),
Guid.NewGuid(),
GridDataType.Height,
new PatchRequestResponse(),
new FilterSet(new CombinedFilter()),
new DesignOffset(),
DIContext.Obtain <Func <PipelineProcessorTaskStyle, ITRexTask> >()(PipelineProcessorTaskStyle.PatchExport),
DIContext.Obtain <Func <PipelineProcessorPipelineStyle, ISubGridPipelineBase> >()(PipelineProcessorPipelineStyle.DefaultProgressive),
DIContext.Obtain <IRequestAnalyser>(),
false,
false,
BoundingIntegerExtent2D.Inverted(),
new LiftParameters());
processor.Should().BeNull("because there is no site model");
// Configure the request analyser to return a single page of results.
// processor.RequestAnalyser.SinglePageRequestNumber = 1;
// processor.RequestAnalyser.SinglePageRequestSize = 10;
// processor.RequestAnalyser.SubmitSinglePageOfRequests = true;
// processor.Build().Should().BeFalse("because there is no sitemodel");
}
/// <summary>
/// Constructs the context of a pipelined processor based on the project, filters and other common criteria
/// of pipelined requests
/// </summary>
/// <param name="requestDescriptor"></param>
/// <param name="dataModelID"></param>
/// <param name="gridDataType"></param>
/// <param name="response"></param>
/// <param name="filters"></param>
/// <param name="cutFillDesign"></param>
/// <param name="task"></param>
/// <param name="pipeline"></param>
/// <param name="requestAnalyser"></param>
/// <param name="requireSurveyedSurfaceInformation"></param>
/// <param name="requestRequiresAccessToDesignFileExistenceMap"></param>
/// <param name="overrideSpatialCellRestriction">A restriction on the cells that are returned via the query that intersects with the spatial selection filtering and criteria</param>
/// <param name="liftParams"></param>
public PipelineProcessor(Guid requestDescriptor,
Guid dataModelID,
GridDataType gridDataType,
ISubGridsPipelinedReponseBase response,
IFilterSet filters,
DesignOffset cutFillDesign,
ITRexTask task,
ISubGridPipelineBase pipeline,
IRequestAnalyser requestAnalyser,
bool requireSurveyedSurfaceInformation,
bool requestRequiresAccessToDesignFileExistenceMap,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
ILiftParameters liftParams)
{
RequestDescriptor = requestDescriptor;
DataModelID = dataModelID;
GridDataType = gridDataType;
Response = response;
Filters = filters;
CutFillDesign = cutFillDesign;
Task = task;
Pipeline = pipeline;
RequestAnalyser = requestAnalyser;
RequireSurveyedSurfaceInformation = requireSurveyedSurfaceInformation;
RequestRequiresAccessToDesignFileExistenceMap = requestRequiresAccessToDesignFileExistenceMap;
OverrideSpatialCellRestriction = overrideSpatialCellRestriction;
LiftParams = liftParams;
}
/// <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;
}
private ProgressiveVolumesSubGridRetriever MakeANewRetriever(ISiteModel siteModel)
{
var retriever = new ProgressiveVolumesSubGridRetriever
(siteModel,
GridDataType.ProgressiveVolumes,
siteModel.PrimaryStorageProxy,
new CombinedFilter(),
new CellPassAttributeFilterProcessingAnnex(),
false,
BoundingIntegerExtent2D.Inverted(),
true,
int.MaxValue,
new AreaControlSet(),
new FilteredValuePopulationControl(),
new SubGridTreeBitMask(),
new OverrideParameters(),
new LiftParameters()
);
retriever.StartDate = new DateTime(2020, 1, 1, 0, 0, 0);
retriever.EndDate = new DateTime(2020, 1, 1, 1, 0, 0);
retriever.Interval = new TimeSpan(0, 10, 0);
return(retriever);
}
public void Assign(ICellSpatialFilter source)
{
if (source.Fence != null)
{
Fence = new Fence();
Fence.Assign(source.Fence);
}
if (source.AlignmentFence != null)
{
AlignmentFence = new Fence(); // contains alignment boundary to help speed up filtering on alignment files
AlignmentFence.Assign(source.AlignmentFence);
}
PositionX = source.PositionX;
PositionY = source.PositionY;
PositionRadius = source.PositionRadius;
IsSquare = source.IsSquare;
OverrideSpatialCellRestriction = new BoundingIntegerExtent2D(source.OverrideSpatialCellRestriction);
StartStation = source.StartStation;
EndStation = source.EndStation;
LeftOffset = source.LeftOffset;
RightOffset = source.RightOffset;
CoordsAreGrid = source.CoordsAreGrid;
IsSpatial = source.IsSpatial;
IsPositional = source.IsPositional;
IsDesignMask = source.IsDesignMask;
SurfaceDesignMaskDesignUid = source.SurfaceDesignMaskDesignUid;
IsAlignmentMask = source.IsAlignmentMask;
AlignmentDesignMaskDesignUID = source.AlignmentDesignMaskDesignUID;
}
/// <summary>
/// Primary method called to begin analytics computation
/// </summary>
public bool ComputeAnalytics(BaseAnalyticsResponse response)
{
using var processor = DIContext.Obtain <IPipelineProcessorFactory>().NewInstanceNoBuild <SubGridsRequestArgument>(
RequestDescriptor,
SiteModel.ID,
RequestedGridDataType,
response,
Filters,
CutFillDesign,
DIContext.Obtain <Func <PipelineProcessorTaskStyle, ITRexTask> >()(PipelineProcessorTaskStyle.AggregatedPipelined),
DIContext.Obtain <Func <PipelineProcessorPipelineStyle, ISubGridPipelineBase> >()(PipelineProcessorPipelineStyle.DefaultAggregative),
DIContext.Obtain <IRequestAnalyser>(),
IncludeSurveyedSurfaces,
CutFillDesign?.DesignID != Guid.Empty,
BoundingIntegerExtent2D.Inverted(),
LiftParams
);
// Assign the provided aggregator into the pipelined sub grid task
((IAggregatedPipelinedSubGridTask)processor.Task).Aggregator = Aggregator;
if (!processor.Build())
{
Log.LogError($"Failed to build pipeline processor for request to model {SiteModel.ID}");
return(false);
}
processor.Process();
return(response.ResultStatus == RequestErrorStatus.OK);
}
public void Area()
{
var bound = new BoundingIntegerExtent2D(0, 0, 100, 100);
bound.SizeX.Should().Be(100);
bound.SizeY.Should().Be(100);
bound.Area().Should().Be(10000);
}
public void Inverted()
{
var bound = new BoundingIntegerExtent2D(0, 0, 100, 100);
bound.SetInverted();
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(int.MaxValue, int.MaxValue, int.MinValue, int.MinValue));
}
public void Expand()
{
var bound = new BoundingIntegerExtent2D(0, 0, 100, 100);
bound.Expand(1);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(-1, -1, 101, 101));
bound.Expand(-1);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(0, 0, 100, 100));
}
/// <summary>
/// Executor that implements requesting and rendering sub grid information to create the rendered tile
/// </summary>
/// <returns></returns>
public async Task <bool> ExecuteAsync()
{
Log.LogInformation($"Performing Execute for DataModel:{DataModelID}, Mode={Mode}, RequestingNodeID={RequestingTRexNodeID}");
ApplicationServiceRequestStatistics.Instance.NumSubgridPageRequests.Increment();
Guid RequestDescriptor = Guid.NewGuid();
using (var processor = DIContext.Obtain <IPipelineProcessorFactory>().NewInstanceNoBuild <SubGridsRequestArgument>(
RequestDescriptor,
DataModelID,
// Patch requests always want time with height information
Mode == DisplayMode.Height ? GridDataType.HeightAndTime : GridDataFromModeConverter.Convert(Mode),
PatchSubGridsResponse,
Filters,
CutFillDesign,
DIContext.Obtain <Func <PipelineProcessorTaskStyle, ITRexTask> >()(PipelineProcessorTaskStyle.PatchExport),
DIContext.Obtain <Func <PipelineProcessorPipelineStyle, ISubGridPipelineBase> >()(PipelineProcessorPipelineStyle.DefaultProgressive),
DIContext.Obtain <IRequestAnalyser>(),
Rendering.Utilities.DisplayModeRequireSurveyedSurfaceInformation(Mode) &&
Rendering.Utilities.FilterRequireSurveyedSurfaceInformation(Filters),
Rendering.Utilities.RequestRequiresAccessToDesignFileExistenceMap(Mode, CutFillDesign),
BoundingIntegerExtent2D.Inverted(),
LiftParams))
{
// Set the surface TRexTask parameters for progressive processing
processor.Task.TRexNodeID = RequestingTRexNodeID;
// Configure the request analyser to return a single page of results.
processor.RequestAnalyser.SinglePageRequestNumber = DataPatchPageNumber;
processor.RequestAnalyser.SinglePageRequestSize = DataPatchPageSize;
processor.RequestAnalyser.SubmitSinglePageOfRequests = true;
if (!processor.Build())
{
Log.LogError($"Failed to build pipeline processor for request to model {DataModelID}");
return(false);
}
// If this is the first page requested then count the total number of patches required for all sub grids to be returned
if (DataPatchPageNumber == 0)
{
PatchSubGridsResponse.TotalNumberOfPagesToCoverFilteredData =
(int)Math.Truncate(Math.Ceiling(processor.RequestAnalyser.CountOfSubGridsThatWillBeSubmitted() / (double)DataPatchPageSize));
}
processor.Process();
if (PatchSubGridsResponse.ResultStatus == RequestErrorStatus.OK)
{
PatchSubGridsResponse.SubGrids = ((PatchTask)processor.Task).PatchSubGrids;
}
return(true);
}
}
public void Offset()
{
var bound = new BoundingIntegerExtent2D(0, 0, 100, 100);
bound.Offset(1, 2);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(1, 2, 101, 102));
bound.Offset(-1, -2);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(0, 0, 100, 100));
}
public void Creation()
{
var bound = new BoundingIntegerExtent2D();
bound.IsValidExtent.Should().Be(true);
bound.MinX.Should().Be(0);
bound.MinY.Should().Be(0);
bound.MaxX.Should().Be(0);
bound.MaxY.Should().Be(0);
}
public void Assign()
{
var bound = new BoundingIntegerExtent2D(1, 1, 100, 100);
var bound2 = new BoundingIntegerExtent2D();
bound2.Assign(bound);
bound2.Should().BeEquivalentTo(bound);
}
public void IsValidExtent()
{
var bound = new BoundingIntegerExtent2D();
bound.IsValidExtent.Should().BeTrue();
bound.MinX = 100;
bound.IsValidExtent.Should().BeFalse();
}
public void Creation2()
{
var bound = new BoundingIntegerExtent2D(1, 2, 3, 4);
bound.IsValidExtent.Should().Be(true);
bound.MinX.Should().Be(1);
bound.MinY.Should().Be(2);
bound.MaxX.Should().Be(3);
bound.MaxY.Should().Be(4);
}
/// <summary>
/// An extension method providing a ToBinary() semantic to BoundingIntegerExtent2D
/// </summary>
public static void ToBinary(this BoundingIntegerExtent2D item, IBinaryRawWriter writer)
{
const byte VERSION_NUMBER = 1;
VersionSerializationHelper.EmitVersionByte(writer, VERSION_NUMBER);
writer.WriteInt(item.MinX);
writer.WriteInt(item.MinY);
writer.WriteInt(item.MaxX);
writer.WriteInt(item.MaxY);
}
/// <summary>
/// Computes the bounding extent of the cells (bits) in the sub grid that are set to 1 (true)
/// </summary>
public BoundingIntegerExtent2D ComputeCellsExtents()
{
BoundingIntegerExtent2D Result = Bits.ComputeCellsExtents();
if (Result.IsValidExtent)
{
Result.Offset((int)OriginX, (int)OriginY);
}
return(Result);
}
public void Test_Equals()
{
var bound = new BoundingIntegerExtent2D(0, 0, 100, 100);
var bound2 = new BoundingIntegerExtent2D(0, 0, 100, 100);
var bound3 = new BoundingIntegerExtent2D(0, 0, 101, 101);
bound.Equals((object)bound2).Should().BeTrue();
bound.Equals((object)bound3).Should().BeFalse();
bound.Equals(bound2).Should().BeTrue();
bound.Equals(bound3).Should().BeFalse();
}
public void Test_SubGridTree_FullCellExtent()
{
ISubGridTree tree = new SubGridTree(SubGridTreeConsts.SubGridTreeLevels, 1.0, new SubGridFactory <NodeSubGrid, LeafSubGrid>());
BoundingIntegerExtent2D extent = tree.FullCellExtent();
// Cell extents cover the non-negative (upper-right quadrant) cartesian coordinates that are used to address
// the possible cell locations in a sub grid tree in the range (0, 0) -> (2^20, 2^30) where
// tree.IndexOriginOffset should be 2^29
Assert.True(extent.MinX == 0 && extent.MinY == 0 &&
extent.MaxX == (2 * tree.IndexOriginOffset) && extent.MaxY == (2 * tree.IndexOriginOffset),
"Cell grid extents are not the expected size");
}
public void Include()
{
var bound = new BoundingIntegerExtent2D(0, 0, 0, 0);
bound.Include(0, 1000);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(0, 0, 0, 1000));
bound.Include(1000, 0);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(0, 0, 1000, 1000));
bound.Include(0, -1000);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(0, -1000, 1000, 1000));
bound.Include(-1000, 0);
bound.Should().BeEquivalentTo(new BoundingIntegerExtent2D(-1000, -1000, 1000, 1000));
}
/// <summary>
/// Calculates the integer bounding rectangle within the bit mask sub grid that encloses all bits that
/// are set to 1 (true)
/// </summary>
private BoundingIntegerExtent2D ComputeCellsExtents()
{
var SubGridCellsExtents = new BoundingIntegerExtent2D();
SubGridCellsExtents.SetInverted();
ScanAllSubGrids(x =>
{
SubGridCellsExtents.Include(((SubGridTreeLeafBitmapSubGrid)x).ComputeCellsExtents());
return(true);
});
return(SubGridCellsExtents);
}
/// <summary>
/// An extension method providing a ToBinary() semantic to BoundingIntegerExtent2D
/// </summary>
public static BoundingIntegerExtent2D FromBinary(this BoundingIntegerExtent2D item, IBinaryRawReader reader)
{
const byte VERSION_NUMBER = 1;
var version = VersionSerializationHelper.CheckVersionByte(reader, VERSION_NUMBER);
if (version == 1)
{
item.MinX = reader.ReadInt();
item.MinY = reader.ReadInt();
item.MaxX = reader.ReadInt();
item.MaxY = reader.ReadInt();
}
return(item);
}
public void SubGridForCaching_IgnoresFilterMask_WithPartialNonOverlappingOverrideMaskRetriction()
{
var siteModel = BuildModelForSubGridRequest();
var retriever = new SubGridRetriever(siteModel,
GridDataType.Height,
siteModel.PrimaryStorageProxy,
new CombinedFilter(),
new CellPassAttributeFilterProcessingAnnex(),
true, // Has override mask
BoundingIntegerExtent2D.Inverted(),
true, // prepareGridForCacheStorageIfNoSieving
1000,
AreaControlSet.CreateAreaControlSet(),
new FilteredValuePopulationControl(),
siteModel.ExistenceMap,
new OverrideParameters(),
new LiftParameters()
);
var clientGrid = ClientLeafSubGridFactoryFactory.CreateClientSubGridFactory().GetSubGridEx
(GridDataType.Height, SubGridTreeConsts.DefaultCellSize, SubGridTreeConsts.SubGridTreeLevels,
SubGridTreeConsts.DefaultIndexOriginOffset, SubGridTreeConsts.DefaultIndexOriginOffset);
var overrideMask = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Unfilled);
overrideMask[10, 10] = true; // This does not overlap the filter but should still return a result
var result = retriever.RetrieveSubGrid(clientGrid, overrideMask, out var seiveFilterInUse,
() =>
{
clientGrid.FilterMap.Clear();
clientGrid.FilterMap[0, 0] = true;
clientGrid.ProdDataMap.Fill();
return(ServerRequestResult.NoError);
});
result.Should().Be(ServerRequestResult.NoError);
seiveFilterInUse.Should().BeFalse();
clientGrid.FilterMap.CountBits().Should().Be(1); // Only asking for the one cell...
clientGrid.CountNonNullCells().Should().Be(1024); // All cells should be returned
}
/// <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;
}
/// <summary>
/// Constructs the context of a pipelined processor based on the project, filters and other common criteria
/// of pipelined requests, but does not perform the build action on the pipeline processor
/// </summary>
/// <param name="overrideSpatialCellRestriction">A restriction on the cells that are returned via the query that intersects with the spatial selection filtering and criteria</param>
public IPipelineProcessor NewInstanceNoBuild <TSubGridsRequestArgument>(Guid requestDescriptor,
Guid dataModelID,
GridDataType gridDataType,
ISubGridsPipelinedReponseBase response,
IFilterSet filters,
DesignOffset cutFillDesign,
ITRexTask task,
ISubGridPipelineBase pipeline,
IRequestAnalyser requestAnalyser,
bool requireSurveyedSurfaceInformation,
bool requestRequiresAccessToDesignFileExistenceMap,
BoundingIntegerExtent2D overrideSpatialCellRestriction,
ILiftParameters liftParams)
{
return(new PipelineProcessor <TSubGridsRequestArgument>
(requestDescriptor, dataModelID, gridDataType, response, filters, cutFillDesign,
task, pipeline, requestAnalyser, requireSurveyedSurfaceInformation, requestRequiresAccessToDesignFileExistenceMap,
overrideSpatialCellRestriction, liftParams) as IPipelineProcessor);
}
public void Includes()
{
var bound = new BoundingIntegerExtent2D(1, 1, 100, 100);
bound.Includes(101, 101).Should().BeFalse();
bound.Includes(0, 0).Should().BeFalse();
// Int version
bound.Includes(1, 1).Should().BeTrue();
bound.Includes(1, 100).Should().BeTrue();
bound.Includes(100, 100).Should().BeTrue();
bound.Includes(100, 1).Should().BeTrue();
// UInt version
bound.Includes(1U, 1U).Should().BeTrue();
bound.Includes(1U, 100U).Should().BeTrue();
bound.Includes(100U, 100U).Should().BeTrue();
bound.Includes(100U, 1U).Should().BeTrue();
}
public void Test_SubGridTreeBitmapSubGridBitsTests_ComputeCellsExtents()
{
// Test extents for empty, full and arbitrary masks
SubGridTreeBitmapSubGridBits bits = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Filled);
BoundingIntegerExtent2D boundsFull = bits.ComputeCellsExtents();
Assert.True(boundsFull.Equals(new BoundingIntegerExtent2D(0, 0, SubGridTreeConsts.SubGridTreeDimensionMinus1, SubGridTreeConsts.SubGridTreeDimensionMinus1)),
"ComputeCellsExtents is incorrect for full grid");
bits.Clear();
BoundingIntegerExtent2D boundsClear = bits.ComputeCellsExtents();
Assert.False(boundsClear.IsValidExtent, "ComputeCellsExtents is incorrect for clear grid");
bits.SetBit(1, 1);
BoundingIntegerExtent2D bounds11 = bits.ComputeCellsExtents();
Assert.True(bounds11.Equals(new BoundingIntegerExtent2D(1, 1, 1, 1)), "ComputeCellsExtents is incorrect for grid with bit set at (1, 1)");
}
