public async Task TileExecutor_EmptySiteModel()
{
AddRoutings();
var siteModel = DITAGFileAndSubGridRequestsWithIgniteFixture.NewEmptyModel();
var request = new TRexTileRequest
(
siteModel.ID,
DisplayMode.Height,
null, //List<ColorPalette> palettes,
null, //new DesignDescriptor(0, FileDescriptor.EmptyFileDescriptor, 0),
new FilterResult(),
new FilterResult(),
null, //new BoundingBox2DLatLon boundingBoxLatLon,
new BoundingBox2DGrid(0, 0, 100, 100),
256,
256,
null,
null,
VolumesType.None);
request.Validate();
var executor = RequestExecutorContainer
.Build <TileExecutor>(DIContext.Obtain <IConfigurationStore>(),
DIContext.Obtain <ILoggerFactory>(),
DIContext.Obtain <IServiceExceptionHandler>());
var result = await executor.ProcessAsync(request) as TileResult;
result.Should().NotBeNull();
result?.Code.Should().Be(ContractExecutionStatesEnum.ExecutedSuccessfully);
result?.TileData.Should().NotBeNull();
}
/// <summary>
/// Actually only checking for serialization and deserilization exceptions
/// </summary>
private async Task <bool> ExecuteTileRequest(TRexTileRequest request)
{
var executor = RequestExecutorContainer
.Build <TileExecutor>(DIContext.Obtain <IConfigurationStore>(),
DIContext.Obtain <ILoggerFactory>(),
DIContext.Obtain <IServiceExceptionHandler>());
var result = await executor.ProcessAsync(request) as TileResult;
result?.Code.Should().Be(ContractExecutionStatesEnum.ExecutedSuccessfully);
return(true);
}
/// <summary>
/// Processes the request for type T.
/// </summary>
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
try
{
var request = CastRequestObjectTo <TileRequest>(item);
var filter1 = request.Filter1;
var filter2 = request.Filter2;
await PairUpAssetIdentifiers(request.ProjectUid.Value, filter1, filter2);
await PairUpImportedFileIdentifiers(request.ProjectUid.Value, request.DesignDescriptor, filter1, filter2);
if (request.ComputeVolumesType == VolumesType.Between2Filters)
{
if (!request.ExplicitFilters)
{
(filter1, filter2) = FilterUtilities.AdjustFilterToFilter(request.Filter1, request.Filter2);
}
}
else
{
(filter1, filter2) = FilterUtilities.ReconcileTopFilterAndVolumeComputationMode(filter1, filter2, request.Mode, request.ComputeVolumesType);
}
var trexRequest = new TRexTileRequest(
request.ProjectUid.Value,
request.Mode,
request.Palettes,
request.DesignDescriptor,
filter1,
filter2,
request.BoundBoxLatLon,
request.BoundBoxGrid,
request.Width,
request.Height,
AutoMapperUtility.Automapper.Map <OverridingTargets>(request.LiftBuildSettings),
AutoMapperUtility.Automapper.Map <LiftSettings>(request.LiftBuildSettings),
request.ComputeVolumesType
);
log.LogDebug($"{nameof(TilesExecutor)} trexRequest {JsonConvert.SerializeObject(trexRequest)}");
var fileResult = await trexCompactionDataProxy.SendDataPostRequestWithStreamResponse(trexRequest, "/tile", customHeaders);
using (var ms = new MemoryStream())
{
fileResult.CopyTo(ms);
return(new TileResult(ms.ToArray()));
}
}
finally
{
ContractExecutionStates.ClearDynamic();
}
}
public async Task <FileResult> GetTile([FromBody] TRexTileRequest request)
{
Log.LogInformation($"{nameof(GetTile)}: {JsonConvert.SerializeObject(request)}");
request.Validate();
ValidateFilterMachines(nameof(GetTile), request.ProjectUid, request.Filter1);
ValidateFilterMachines(nameof(GetTile), request.ProjectUid, request.Filter2);
var tileResult = await WithServiceExceptionTryExecuteAsync(() =>
RequestExecutorContainer
.Build <TileExecutor>(ConfigStore, LoggerFactory, ServiceExceptionHandler)
.ProcessAsync(request)) as TileResult;
if (tileResult?.TileData == null)
{
tileResult = TileResult.EmptyTile(WebMercatorProjection.TILE_SIZE, WebMercatorProjection.TILE_SIZE);
}
return(new FileStreamResult(new MemoryStream(tileResult.TileData), ContentTypeConstants.ImagePng));
}
/// <summary>
/// Processes the request for type of T.
/// </summary>
protected override async Task <ContractExecutionResult> ProcessAsyncEx <T>(T item)
{
try
{
var request = CastRequestObjectTo <TileRequest>(item);
var filter1 = request.Filter1;
var filter2 = request.Filter2;
if (request.ComputeVolumesType == VolumesType.Between2Filters && !request.ExplicitFilters)
{
(filter1, filter2) = FilterUtilities.AdjustFilterToFilter(request.Filter1, request.Filter2);
}
var trexRequest = new TRexTileRequest(
request.ProjectUid.Value,
request.Mode,
request.Palettes,
request.DesignDescriptor,
filter1,
filter2,
request.BoundBoxLatLon,
request.BoundBoxGrid,
request.Width,
request.Height,
AutoMapperUtility.Automapper.Map <OverridingTargets>(request.LiftBuildSettings),
AutoMapperUtility.Automapper.Map <LiftSettings>(request.LiftBuildSettings),
request.ComputeVolumesType
);
var fileResult = await trexCompactionDataProxy.SendDataPostRequestWithStreamResponse(trexRequest, "/tile", customHeaders);
using (var ms = new MemoryStream())
{
fileResult.CopyTo(ms);
return(new TileResult(ms.ToArray()));
}
}
finally
{
ContractExecutionStates.ClearDynamic();
}
}
private PaletteBase ConvertColorPalettes(TRexTileRequest request, ISiteModel siteModel)
{
const double PERCENTAGE_RANGE_MIN = 0.0;
const double PERCENTAGE_RANGE_MAX = 100.0;
const ushort PASS_COUNT_TARGET_RANGE_MIN = 1;
const ushort PASS_COUNT_TARGET_RANGE_MAX = ushort.MaxValue;
const ushort TEMPERATURE_LEVELS_MIN = 0;
const ushort TEMPERATURE_LEVELS_MAX = 100;
var overrides = AutoMapperUtility.Automapper.Map <OverrideParameters>(request.Overrides);
PaletteBase convertedPalette;
var availableTransitions = request.Palettes != null?request.Palettes.Select(p => new Transition(p.Value, ColorUtility.UIntToColor(p.Color))).ToArray() : new Transition[0];
switch (request.Mode)
{
case DisplayMode.CCA:
convertedPalette = new CCAPalette();
convertedPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.CCASummary:
convertedPalette = new CCASummaryPalette();
var ccaSummaryPalette = ((CCASummaryPalette)convertedPalette);
if (request.Palettes != null)
{
ccaSummaryPalette.UndercompactedColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
ccaSummaryPalette.CompactedColour = ColorUtility.UIntToColor(request.Palettes[1].Color);
ccaSummaryPalette.OvercompactedColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
}
break;
case DisplayMode.CCV:
convertedPalette = new CMVPalette();
var cmvPalette = ((CMVPalette)convertedPalette);
cmvPalette.CMVPercentageRange.Min = overrides?.CMVRange.Min ?? PERCENTAGE_RANGE_MIN;
cmvPalette.CMVPercentageRange.Max = overrides?.CMVRange.Max ?? PERCENTAGE_RANGE_MAX;
cmvPalette.UseMachineTargetCMV = !overrides?.OverrideMachineCCV ?? true;
cmvPalette.AbsoluteTargetCMV = overrides?.OverridingMachineCCV ?? 0;
cmvPalette.TargetCCVColour = Color.Green;
cmvPalette.DefaultDecoupledCMVColour = Color.Black;
cmvPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.CCVPercent:
case DisplayMode.CCVPercentSummary:
case DisplayMode.CCVPercentChange:
convertedPalette = new CCVPercentPalette();
var cmvPercentPalette = ((CCVPercentPalette)convertedPalette);
cmvPercentPalette.CMVPercentageRange.Min = overrides?.CMVRange.Min ?? PERCENTAGE_RANGE_MIN;
cmvPercentPalette.CMVPercentageRange.Max = overrides?.CMVRange.Max ?? PERCENTAGE_RANGE_MAX;
cmvPercentPalette.UseMachineTargetCMV = !overrides?.OverrideMachineCCV ?? true;
cmvPercentPalette.AbsoluteTargetCMV = overrides?.OverridingMachineCCV ?? 0;
if (request.Palettes != null)
{
cmvPercentPalette.WithinCMVTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
cmvPercentPalette.BelowCMVTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
cmvPercentPalette.AboveCMVTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[3].Color);
}
break;
case DisplayMode.CMVChange:
convertedPalette = new CMVChangePalette();
var cmvPercentChangePalette = ((CMVChangePalette)convertedPalette);
cmvPercentChangePalette.CMVPercentageRange.Min = overrides?.CMVRange.Min ?? PERCENTAGE_RANGE_MIN;
cmvPercentChangePalette.CMVPercentageRange.Max = overrides?.CMVRange.Max ?? PERCENTAGE_RANGE_MAX;
cmvPercentChangePalette.UseAbsoluteValues = false;
cmvPercentChangePalette.UseMachineTargetCMV = !overrides?.OverrideMachineCCV ?? true;
cmvPercentChangePalette.AbsoluteTargetCMV = overrides?.OverridingMachineCCV ?? 0;
cmvPercentChangePalette.TargetCCVColour = Color.Green;
cmvPercentChangePalette.DefaultDecoupledCMVColour = Color.Black;
cmvPercentChangePalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.CutFill:
convertedPalette = new CutFillPalette();
convertedPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.Height:
convertedPalette = request.Palettes != null ? new HeightPalette(request.Palettes.First().Value, request.Palettes.Last().Value) : new HeightPalette();
((HeightPalette)convertedPalette).ElevationPalette = request.Palettes?.Select(p => ColorUtility.UIntToColor(p.Color)).ToArray();
break;
case DisplayMode.MDP:
convertedPalette = new MDPPalette();
var mdpPalette = ((MDPPalette)convertedPalette);
mdpPalette.MDPPercentageRange.Min = overrides?.MDPRange.Min ?? PERCENTAGE_RANGE_MIN;
mdpPalette.MDPPercentageRange.Max = overrides?.MDPRange.Max ?? PERCENTAGE_RANGE_MAX;
mdpPalette.UseMachineTargetMDP = !overrides?.OverrideMachineMDP ?? true;
mdpPalette.AbsoluteTargetMDP = overrides?.OverridingMachineMDP ?? 0;
mdpPalette.TargetMDPColour = Color.Green;
mdpPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.MDPPercentSummary:
convertedPalette = new MDPSummaryPalette();
var mdpSummaryPalette = ((MDPSummaryPalette)convertedPalette);
mdpSummaryPalette.MDPPercentageRange.Min = overrides?.MDPRange.Min ?? PERCENTAGE_RANGE_MIN;
mdpSummaryPalette.MDPPercentageRange.Max = overrides?.MDPRange.Max ?? PERCENTAGE_RANGE_MAX;
mdpSummaryPalette.UseMachineTargetMDP = !overrides?.OverrideMachineMDP ?? true;
mdpSummaryPalette.AbsoluteTargetMDP = overrides?.OverridingMachineMDP ?? 0;
if (request.Palettes != null)
{
mdpSummaryPalette.WithinMDPTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
mdpSummaryPalette.BelowMDPTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
mdpSummaryPalette.AboveMDPTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[3].Color);
}
break;
case DisplayMode.PassCount:
convertedPalette = new PassCountPalette();
convertedPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.PassCountSummary:
convertedPalette = new PassCountSummaryPalette();
var passCountPalette = ((PassCountSummaryPalette)convertedPalette);
if (request.Palettes != null)
{
passCountPalette.AbovePassTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
passCountPalette.WithinPassTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[1].Color);
passCountPalette.BelowPassTargetRangeColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
}
passCountPalette.UseMachineTargetPass = !overrides?.OverrideTargetPassCount ?? true;
passCountPalette.TargetPassCountRange.Min = overrides?.OverridingTargetPassCountRange.Min ?? PASS_COUNT_TARGET_RANGE_MIN;
passCountPalette.TargetPassCountRange.Max = overrides?.OverridingTargetPassCountRange.Max ?? PASS_COUNT_TARGET_RANGE_MAX;
break;
case DisplayMode.MachineSpeed:
convertedPalette = new SpeedPalette();
convertedPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.TargetSpeedSummary:
convertedPalette = new SpeedSummaryPalette();
var speedSummaryPalette = ((SpeedSummaryPalette)convertedPalette);
if (request.Palettes != null)
{
speedSummaryPalette.LowerSpeedRangeColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
speedSummaryPalette.WithinSpeedRangeColour = ColorUtility.UIntToColor(request.Palettes[1].Color);
speedSummaryPalette.OverSpeedRangeColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
}
speedSummaryPalette.MachineSpeedTarget.Min = overrides?.TargetMachineSpeed.Min ?? CellPassConsts.NullMachineSpeed;
speedSummaryPalette.MachineSpeedTarget.Max = overrides?.TargetMachineSpeed.Max ?? CellPassConsts.NullMachineSpeed;
break;
case DisplayMode.TemperatureDetail:
convertedPalette = new TemperaturePalette();
convertedPalette.PaletteTransitions = availableTransitions;
break;
case DisplayMode.TemperatureSummary:
convertedPalette = new TemperatureSummaryPalette();
var temperatureSummaryPalette = ((TemperatureSummaryPalette)convertedPalette);
if (request.Palettes != null)
{
temperatureSummaryPalette.AboveMaxLevelColour = ColorUtility.UIntToColor(request.Palettes[2].Color);
temperatureSummaryPalette.WithinLevelsColour = ColorUtility.UIntToColor(request.Palettes[1].Color);
temperatureSummaryPalette.BelowMinLevelColour = ColorUtility.UIntToColor(request.Palettes[0].Color);
}
temperatureSummaryPalette.UseMachineTempWarningLevels = !overrides?.OverrideTemperatureWarningLevels ?? true;
temperatureSummaryPalette.TemperatureLevels.Min = overrides?.OverridingTemperatureWarningLevels.Min ?? TEMPERATURE_LEVELS_MIN;
temperatureSummaryPalette.TemperatureLevels.Max = overrides?.OverridingTemperatureWarningLevels.Max ?? TEMPERATURE_LEVELS_MAX;
break;
case DisplayMode.CompactionCoverage:
convertedPalette = new CompactionCoveragePalette();
var compactionCoveragePalette = ((CompactionCoveragePalette)convertedPalette);
compactionCoveragePalette.HasCMVData = availableTransitions[0].Color;
compactionCoveragePalette.HasNoCMVData = availableTransitions[1].Color;
break;
default:
// when adding modes, there are various other places in the code which will need work
throw new TRexException($"No implemented colour palette for this mode ({request.Mode})");
}
return(convertedPalette);
}
