/// <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); }
/// <summary> /// Constructor /// </summary> public SubGridRequestsBase(ITRexTask tRexTask, Guid siteModelID, Guid requestID, Guid trexNodeId, GridDataType requestedGridDataType, bool includeSurveyedSurfaceInformation, ISubGridTreeBitMask prodDataMask, ISubGridTreeBitMask surveyedSurfaceOnlyMask, IFilterSet filters, DesignOffset referenceDesign, AreaControlSet areaControlSet, Action <TSubGridsRequestArgument> customArgumentInitializer, SubGridsRequestComputeStyle subGridsRequestComputeStyle) : this() { TRexTask = tRexTask; SiteModelID = siteModelID; RequestID = requestID; TRexNodeId = trexNodeId; RequestedGridDataType = requestedGridDataType; IncludeSurveyedSurfaceInformation = includeSurveyedSurfaceInformation; ProdDataMask = prodDataMask; SurveyedSurfaceOnlyMask = surveyedSurfaceOnlyMask; Filters = filters; ReferenceDesign = referenceDesign; AreaControlSet = areaControlSet; CustomArgumentInitializer = customArgumentInitializer; SubGridsRequestComputeStyle = SubGridsRequestComputeStyle; }
/// <summary> /// Constructs a cell profile analyzer that analyzes cells in a cell profile vector /// </summary> /// <param name="siteModel"></param> /// <param name="pDExistenceMap"></param> /// <param name="filterSet"></param> /// <param name="cellLiftBuilder"></param> /// <param name="overrides"></param> public CellProfileAnalyzer(ISiteModel siteModel, ISubGridTreeBitMask pDExistenceMap, IFilterSet filterSet, ICellLiftBuilder cellLiftBuilder, IOverrideParameters overrides, ILiftParameters liftParams) : base(siteModel, pDExistenceMap, filterSet, overrides, liftParams) { CellLiftBuilder = cellLiftBuilder; PassFilter = filterSet.Filters[0].AttributeFilter; if (PassFilter.HasElevationRangeFilter && PassFilter.ElevationRangeDesign.DesignID != Guid.Empty) { var design = siteModel.Designs.Locate(PassFilter.ElevationRangeDesign.DesignID); if (design == null) { Log.LogError($"ElevationRangeDesign {PassFilter.ElevationRangeDesign.DesignID} is unknown in project {siteModel.ID}"); } else { PassFilterElevationRangeDesign = new DesignWrapper(PassFilter.ElevationRangeDesign, design); } } PassFilterAnnex = new CellPassAttributeFilterProcessingAnnex(); CellFilter = filterSet.Filters[0].SpatialFilter; }
/// <summary> /// Constructor for the renderer /// </summary> public RenderOverlayTile(Guid dataModelId, //AExternalDescriptor :TASNodeRequestDescriptor; DisplayMode mode, XYZ blPoint, XYZ trPoint, bool coordsAreGrid, ushort nPixelsX, ushort nPixelsY, IFilterSet filters, DesignOffset cutFillDesign, IPlanViewPalette aColorPalettes, Color representColor, Guid requestingTRexNodeId, ILiftParameters liftParams, VolumeComputationType volumeType ) { DataModelID = dataModelId; // ExternalDescriptor = AExternalDescriptor Mode = mode; BLPoint = blPoint; TRPoint = trPoint; CoordsAreGrid = coordsAreGrid; NPixelsX = nPixelsX; NPixelsY = nPixelsY; Filters = filters; CutFillDesign = cutFillDesign; ColorPalettes = aColorPalettes; RepresentColor = representColor; RequestingTRexNodeID = requestingTRexNodeId; LiftParams = liftParams; VolumeType = volumeType; }
/// <summary> /// Creates a new builder responsible for determining a vector of cells that are crossed by a profile line /// </summary> public ICellProfileBuilder <T> NewCellProfileBuilder(ISiteModel siteModel, IFilterSet filterSet, IDesignWrapper cutFillDesignWrapper, bool slicerToolUsed) { return(new CellProfileBuilder <T>(siteModel, filterSet, cutFillDesignWrapper, slicerToolUsed)); }
/// <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> /// Creates a new builder responsible for processing cell pass, layer and other information for single cells in a profile /// </summary> public ICellLiftBuilder NewCellLiftBuilder(ISiteModel siteModel, GridDataType gridDataType, IFilteredValuePopulationControl populationControl, IFilterSet filterSet, ICellPassFastEventLookerUpper cellPassFastEventLookerUpper) { return(new CellLiftBuilder(siteModel, gridDataType, populationControl, filterSet, cellPassFastEventLookerUpper)); }
/// <summary> /// Determines if the supplied filter supports the inclusion of surveyed surface information in the request results /// </summary> public static bool FilterRequireSurveyedSurfaceInformation(IFilterSet filters) { return(filters == null || !filters.Filters.Any(x => x.AttributeFilter.HasVibeStateFilter || x.AttributeFilter.HasDesignFilter || x.AttributeFilter.HasMachineDirectionFilter || x.AttributeFilter.HasMachineFilter || x.AttributeFilter.HasGPSAccuracyFilter)); }
public CellPassesRequestArgument_ApplicationService(Guid siteModelId, bool coordsAreGrid, XYZ point, IFilterSet filters) { ProjectID = siteModelId; CoordsAreGrid = coordsAreGrid; Point = point; Filters = filters; }
public QuantizedMeshRequestArgument(Guid projectUid, int x, int y, int z, IFilterSet filters, int displayMode, bool hasLighting) { // todo whats needed ProjectID = projectUid; X = x; Y = y; Z = z; Filters = filters; DisplayMode = displayMode; HasLighting = hasLighting; }
/// <summary> /// Creates a CellProfile builder given a list of coordinates defining the path to profile and a container to place the resulting cells into /// </summary> /// <param name="siteModel"></param> /// <param name="filterSet"></param> /// <param name="cutFillDesignWrapper"></param> /// <param name="slicerToolUsed"></param> public CellProfileBuilder(ISiteModel siteModel, IFilterSet filterSet, IDesignWrapper cutFillDesignWrapper, bool slicerToolUsed) { SiteModel = siteModel; CellFilter = filterSet?.Filters[0].SpatialFilter; CutFillDesignWrapper = cutFillDesignWrapper; SlicerToolUsed = slicerToolUsed; Initialise(); }
public CellPassesRequestArgument_ClusterCompute(Guid siteModelID, XYZ neeCoords, int otgCellX, int otgCellY, IFilterSet filters) { ProjectID = siteModelID; NEECoords = neeCoords; OTGCellX = otgCellX; OTGCellY = otgCellY; Filters = filters; }
private void Intersect(FilterSet result, IFilterSet filtered, ref bool inited) { if (inited) { result.IntersectWith(filtered); } else { result.Add(filtered); inited = true; } }
/// <summary> /// Constructs a profile lift builder that analyzes cells in a cell profile vector /// </summary> public SummaryVolumesCellProfileAnalyzer(ISiteModel siteModel, ISubGridTreeBitMask pDExistenceMap, IFilterSet filterSet, IDesignWrapper referenceDesignWrapper, ICellLiftBuilder cellLiftBuilder, VolumeComputationType volumeType, IOverrideParameters overrides, ILiftParameters liftParams) : base(siteModel, pDExistenceMap, filterSet, overrides, liftParams) { svDesignWrapper = referenceDesignWrapper; VolumeType = volumeType; }
public CSVExportRequestArgument(Guid siteModelUid, IFilterSet filters, string fileName, CoordType coordType, OutputTypes outputType, CSVExportUserPreferences userPreferences, List <CSVExportMappedMachine> mappedMachines, bool restrictOutputSize, bool rawDataAsDBase) { ProjectID = siteModelUid; Filters = filters; FileName = fileName; CoordType = coordType; OutputType = outputType; UserPreferences = userPreferences; MappedMachines = mappedMachines; RestrictOutputSize = restrictOutputSize; RawDataAsDBase = rawDataAsDBase; }
/// <summary> /// Constructor for the renderer accepting all parameters necessary for its operation /// </summary> public TINSurfaceExportExecutor( Guid dataModelId, IFilterSet filters, double tolerance, Guid requestingTRexNodeId, ILiftParameters liftParams ) { _dataModelId = dataModelId; _filters = filters; _tolerance = tolerance; RequestingTRexNodeID = requestingTRexNodeId; _liftParams = liftParams; }
/// <summary> /// Constructs a profile lift builder that analyzes cells in a cell profile vector /// </summary> public CellProfileAnalyzerBase(ISiteModel siteModel, ISubGridTreeBitMask pDExistenceMap, IFilterSet filterSet, IOverrideParameters overrides, ILiftParameters liftParams) { SiteModel = siteModel; PDExistenceMap = pDExistenceMap; FilterSet = filterSet; Overrides = overrides; LiftParams = liftParams; Initialise(); }
/// <summary> /// Constructs the profile analysis executor /// </summary> public ComputeProfileExecutor_ClusterCompute(ProfileStyle profileStyle, Guid projectID, GridDataType profileTypeRequired, XYZ[] nEECoords, IFilterSet filters, // externalRequestDescriptor: TASNodeRequestDescriptor; DesignOffset design, bool returnAllPassesAndLayers, VolumeComputationType volumeType, IOverrideParameters overrides, ILiftParameters liftParams) { ProfileStyle = profileStyle; ProjectID = projectID; ProfileTypeRequired = profileTypeRequired; NEECoords = nEECoords; Filters = filters; Design = design; VolumeType = volumeType; Overrides = overrides; LiftParams = liftParams; }
public CellDatumRequestArgument_ApplicationService( Guid siteModelID, DisplayMode mode, bool coordsAreGrid, XYZ point, IFilterSet filters, DesignOffset referenceDesign, IOverrideParameters overrides) { ProjectID = siteModelID; Mode = mode; CoordsAreGrid = coordsAreGrid; Point = point; Filters = filters; ReferenceDesign = referenceDesign; Overrides = overrides; }
/// <summary> /// Constructs the set of filters that will be used to derive the set of production data sub grids. /// </summary> public static IFilterSet ConstructFilters(IFilterSet filterSet, VolumeComputationType volumeType) { if (volumeType == VolumeComputationType.None) { return(filterSet); } // If the volume calculation is between two filters then handle appropriately... if (volumeType == VolumeComputationType.Between2Filters) { var baseFilter = filterSet.Filters[0]; var topFilter = filterSet.Filters[1]; // Determine if intermediary filter/surface behaviour is required to support summary volumes var intermediaryFilterRequired = volumeType == VolumeComputationType.Between2Filters && baseFilter.AttributeFilter.HasTimeFilter && baseFilter.AttributeFilter.StartTime == Consts.MIN_DATETIME_AS_UTC && // 'From' has As-At Time filter !baseFilter.AttributeFilter.ReturnEarliestFilteredCellPass && // Want latest cell pass in 'from' topFilter.AttributeFilter.HasTimeFilter && topFilter.AttributeFilter.StartTime != Consts.MIN_DATETIME_AS_UTC && // 'To' has time-range filter with latest !topFilter.AttributeFilter.ReturnEarliestFilteredCellPass; // Want latest cell pass in 'to' if (intermediaryFilterRequired) { // Create and use the intermediary filter. The intermediary filter // is created from the Top filter, with the return earliest flag set to true var intermediaryFilter = new CombinedFilter(); intermediaryFilter.AttributeFilter.Assign(topFilter.AttributeFilter); intermediaryFilter.AttributeFilter.ReturnEarliestFilteredCellPass = true; intermediaryFilter.SpatialFilter.Assign(topFilter.SpatialFilter); return(new FilterSet(new[] { baseFilter, intermediaryFilter, topFilter })); } } else if (volumeType == VolumeComputationType.BetweenDesignAndFilter) { return(new FilterSet(filterSet.Filters[1])); } else if (volumeType == VolumeComputationType.BetweenFilterAndDesign) { return(new FilterSet(filterSet.Filters[0])); } return(filterSet); }
} = new LiftParameters(); // Stage three todo /// <summary> /// Constructor for the renderer accepting all parameters necessary for its operation /// </summary> public QMTileExecutor(Guid dataModelUid, IFilterSet filters, int x, int y, int z, int displayMode, bool hasLighting, Guid requestingTRexNodeId ) { DataModelUid = dataModelUid; Filters = filters; TileX = x; TileY = y; TileZ = z; DisplayMode = displayMode; HasLighting = hasLighting; RequestingTRexNodeID = requestingTRexNodeId; }
/// <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 CellDatumRequestArgument_ClusterCompute( Guid siteModelID, DisplayMode mode, XYZ neeCoords, int otgCellX, int otgCellY, IFilterSet filters, DesignOffset referenceDesign, IOverrideParameters overrides, ILiftParameters liftParams) { ProjectID = siteModelID; Mode = mode; NEECoords = neeCoords; OTGCellX = otgCellX; OTGCellY = otgCellY; Filters = filters; ReferenceDesign = referenceDesign; Overrides = overrides; LiftParams = liftParams; }
/// <summary> /// Configures a new profile builder that provides the three core builders used in profiling: construction of cell vector from profile line, /// profile analysis orchestration and per cell layer/statistics calculation /// </summary> public void Configure(ProfileStyle profileStyle, ISiteModel siteModel, ISubGridTreeBitMask productionDataExistenceMap, GridDataType gridDataType, IFilterSet filterSet, IDesignWrapper referenceDesignWrapper, IFilteredValuePopulationControl PopulationControl, ICellPassFastEventLookerUpper CellPassFastEventLookerUpper, VolumeComputationType volumeType, IOverrideParameters overrides, ILiftParameters liftParams, bool slicerToolUsed = true) { CellLiftBuilder = factory.NewCellLiftBuilder(siteModel, gridDataType, PopulationControl, filterSet, CellPassFastEventLookerUpper); CellProfileBuilder = factory.NewCellProfileBuilder(siteModel, filterSet, referenceDesignWrapper, slicerToolUsed); CellProfileAnalyzer = factory.NewCellProfileAnalyzer( profileStyle, siteModel, productionDataExistenceMap, filterSet, referenceDesignWrapper, CellLiftBuilder, volumeType, overrides, liftParams); }
/// <summary> /// Constructor for the renderer accepting all parameters necessary for its operation /// </summary> public PatchExecutor( Guid dataModelID, //AExternalDescriptor :TASNodeRequestDescriptor; DisplayMode mode, IFilterSet filters, DesignOffset cutFillDesign, Guid requestingTRexNodeId, int dataPatchPageNumber, int dataPatchPageSize, ILiftParameters liftParams ) { DataModelID = dataModelID; // ExternalDescriptor = AExternalDescriptor Mode = mode; Filters = filters; CutFillDesign = cutFillDesign; RequestingTRexNodeID = requestingTRexNodeId; DataPatchPageNumber = dataPatchPageNumber; DataPatchPageSize = dataPatchPageSize; LiftParams = liftParams; }
public TileRenderRequestArgument(Guid siteModelId, DisplayMode mode, IPlanViewPalette palette, BoundingWorldExtent3D extents, bool coordsAreGrid, ushort pixelsX, ushort pixelsY, IFilterSet filters, DesignOffset referenceDesign, VolumeComputationType volumeType) { ProjectID = siteModelId; Mode = mode; Palette = palette; Extents = extents; CoordsAreGrid = coordsAreGrid; PixelsX = pixelsX; PixelsY = pixelsY; Filters = filters; ReferenceDesign = referenceDesign; VolumeType = volumeType; }
private void ConfigurePipeline(SubGridPipelineAggregative <SubGridsRequestArgument, SimpleVolumesResponse> PipeLine) { //PipeLine.TimeToLiveSeconds := VLPDSvcLocations.VLPDPSNode_VolumePipelineTTLSeconds; PipeLine.RequestDescriptor = RequestDescriptor; //PipeLine.ExternalDescriptor := FExternalDescriptor; PipeLine.DataModelID = SiteModel.ID; Log.LogDebug($"Volume calculation extents for DM={SiteModel.ID}, Request={RequestDescriptor}: {Extents}"); PipeLine.OverallExistenceMap = OverallExistenceMap; PipeLine.ProdDataExistenceMap = ProdDataExistenceMap; PipeLine.DesignSubGridOverlayMap = DesignSubgridOverlayMap; // Initialise a request analyzer to provide to the pipeline PipeLine.RequestAnalyser = DIContext.Obtain <IRequestAnalyser>(); PipeLine.RequestAnalyser.Pipeline = PipeLine; PipeLine.RequestAnalyser.WorldExtents.Assign(Extents); PipeLine.LiftParams = LiftParams; // Construct and assign the filter set into the pipeline IFilterSet FilterSet = FilterUtilities.ConstructFilters(new FilterSet(BaseFilter, TopFilter), VolumeType); if (FilterSet.Filters.Length == 3) { PipeLine.SubGridsRequestComputeStyle = SubGridsRequestComputeStyle.SimpleVolumeThreeWayCoalescing; } PipeLine.FilterSet = FilterSet; PipeLine.GridDataType = GridDataType.Height; if (FilteredTopSurveyedSurfaces.Count > 0 || FilteredBaseSurveyedSurfaces.Count > 0) { PipeLine.IncludeSurveyedSurfaceInformation = true; } }
/// <summary> /// Creates a new builder responsible for analyzing profile information for a cell or cells identified along a profile line /// </summary> public ICellProfileAnalyzer <T> NewCellProfileAnalyzer(ProfileStyle profileStyle, ISiteModel siteModel, ISubGridTreeBitMask pDExistenceMap, IFilterSet filterSet, IDesignWrapper referenceDesignWrapper, ICellLiftBuilder cellLiftBuilder, VolumeComputationType volumeComputationType, IOverrideParameters overrides, ILiftParameters liftParams) { switch (profileStyle) { case ProfileStyle.CellPasses: return(DIContext.Obtain <Func <ISiteModel, ISubGridTreeBitMask, IFilterSet, ICellLiftBuilder, IOverrideParameters, ILiftParameters, ICellProfileAnalyzer <T> > >() (siteModel, pDExistenceMap, filterSet, cellLiftBuilder, overrides, liftParams)); case ProfileStyle.SummaryVolume: return(DIContext.Obtain <Func <ISiteModel, ISubGridTreeBitMask, IFilterSet, IDesignWrapper, ICellLiftBuilder, VolumeComputationType, IOverrideParameters, ILiftParameters, ICellProfileAnalyzer <T> > >() (siteModel, pDExistenceMap, filterSet, referenceDesignWrapper, cellLiftBuilder, volumeComputationType, overrides, liftParams)); default: throw new ArgumentOutOfRangeException(nameof(profileStyle), profileStyle, null); } }
public void IntersectWith(IFilterSet set) { _data.And(set.GetBitArray()); }
/// <summary> /// Builds the pipeline configured per the supplied state ready to execute the request /// </summary> public bool Build() { // Todo: This method is left as async as a reminder that the GetExistenveMap workflows could either be async (as they // potentially read from the persistent store), and/or they couild be cached in the site model designs/surveyed surfaces contexts // See Jira CCSSSCON-1481 try { var stopWatch = Stopwatch.StartNew(); // Ensure the task is initialised with the request descriptor Task.RequestDescriptor = RequestDescriptor; // Ensure the Task grid data type matches the pipeline processor Task.GridDataType = GridDataType; // Introduce the task and the pipeline to each other Pipeline.PipelineTask = Task; Task.PipeLine = Pipeline; (Pipeline as ISubGridPipelineBase <TSubGridsRequestArgument>).CustomArgumentInitializer = CustomArgumentInitializer; if ((Filters?.Filters?.Length ?? 0) == 0) { _log.LogError($"Filters supplied to pipeline processor is null or empty, replacing with single default filter"); Filters = new FilterSet(new CombinedFilter()); } // Construct an aggregated set of excluded surveyed surfaces for the filters used in the query foreach (var filter in Filters.Filters) { if (filter != null && SurveyedSurfaceExclusionList.Length > 0) { SurveyedSurfaceExclusionList = new Guid[filter.AttributeFilter.SurveyedSurfaceExclusionList.Length]; Array.Copy(filter.AttributeFilter.SurveyedSurfaceExclusionList, SurveyedSurfaceExclusionList, SurveyedSurfaceExclusionList.Length); } } // Get the SiteModel for the request SiteModel = DIContext.Obtain <ISiteModels>().GetSiteModel(DataModelID); if (SiteModel == null) { Response.ResultStatus = RequestErrorStatus.NoSuchDataModel; return(false); } SpatialExtents = SiteModel.GetAdjustedDataModelSpatialExtents(SurveyedSurfaceExclusionList); if (!SpatialExtents.IsValidPlanExtent) { Response.ResultStatus = RequestErrorStatus.FailedToRequestDatamodelStatistics; // Or there was no data in the model return(false); } // Get the current production data existence map from the site model ProdDataExistenceMap = SiteModel.ExistenceMap; // Obtain the sub grid existence map for the project // Retrieve the existence map for the datamodel OverallExistenceMap = new SubGridTreeSubGridExistenceBitMask { CellSize = SubGridTreeConsts.SubGridTreeDimension * SiteModel.CellSize }; if (RequireSurveyedSurfaceInformation) { // Obtain local reference to surveyed surfaces (lock free access) var localSurveyedSurfaces = SiteModel.SurveyedSurfaces; if (localSurveyedSurfaces != null) { // Construct two filtered surveyed surface lists to act as a rolling pair used as arguments // to the ProcessSurveyedSurfacesForFilter method var filterSurveyedSurfaces = DIContext.Obtain <ISurveyedSurfaces>(); var filteredSurveyedSurfaces = DIContext.Obtain <ISurveyedSurfaces>(); SurveyedSurfacesExcludedViaTimeFiltering = Filters.Filters.Length > 0; foreach (var filter in Filters.Filters) { if (!localSurveyedSurfaces.ProcessSurveyedSurfacesForFilter(DataModelID, filter, filteredSurveyedSurfaces, filterSurveyedSurfaces, OverallExistenceMap)) { Response.ResultStatus = RequestErrorStatus.FailedToRequestSubgridExistenceMap; return(false); } SurveyedSurfacesExcludedViaTimeFiltering &= filterSurveyedSurfaces.Count == 0; } } } OverallExistenceMap.SetOp_OR(ProdDataExistenceMap); foreach (var filter in Filters.Filters) { if (filter != null) { if (!DesignFilterUtilities.ProcessDesignElevationsForFilter(SiteModel, filter, OverallExistenceMap)) { Response.ResultStatus = RequestErrorStatus.NoDesignProvided; return(false); } Response.ResultStatus = FilterUtilities.PrepareFilterForUse(filter, DataModelID); if (Response.ResultStatus != RequestErrorStatus.OK) { _log.LogInformation($"PrepareFilterForUse failed: Datamodel={DataModelID}"); return(false); } } } // Adjust the extents we have been given to encompass the spatial extent of the supplied filters (if any) Filters.ApplyFilterAndSubsetBoundariesToExtents(SpatialExtents); // If this request involves a relationship with a design then ensure the existence map // for the design is loaded in to memory to allow the request pipeline to confine // sub grid requests that overlay the actual design if (RequestRequiresAccessToDesignFileExistenceMap) { if (CutFillDesign == null || CutFillDesign.DesignID == Guid.Empty) { _log.LogError($"No design provided to cut fill, summary volume or thickness overlay render request for datamodel {DataModelID}"); Response.ResultStatus = RequestErrorStatus.NoDesignProvided; return(false); } DesignSubGridOverlayMap = GetExistenceMaps().GetSingleExistenceMap(DataModelID, Consts.EXISTENCE_MAP_DESIGN_DESCRIPTOR, CutFillDesign.DesignID); if (DesignSubGridOverlayMap == null) { _log.LogError($"Failed to request sub grid overlay index for design {CutFillDesign.DesignID} in datamodel {DataModelID}"); Response.ResultStatus = RequestErrorStatus.NoDesignProvided; return(false); } DesignSubGridOverlayMap.CellSize = SubGridTreeConsts.SubGridTreeDimension * SiteModel.CellSize; } // Impose the final restriction on the spatial extents from the client context SpatialExtents.Intersect(OverrideSpatialExtents); // Introduce the Request analyzer to the pipeline and spatial extents it requires RequestAnalyser.Pipeline = Pipeline; RequestAnalyser.WorldExtents = SpatialExtents; ConfigurePipeline(); _log.LogInformation($"Pipeline processor build phase completed in {stopWatch.Elapsed}"); return(true); } catch (Exception e) { _log.LogError(e, "Exception occurred in pipeline builder"); throw; } }