protected override void SetVertexStation(int VertexNum, double Value)
{
Debug.Assert(Range.InRange(VertexNum, 0, Vertices.Count - 1),
"VertexNum out of range in NFFLineworkSmoothedPolyLineEntity.SetVertexStation");
Vertices[VertexNum].Chainage = Value;
}
protected override double GetVertexStation(int VertexNum)
{
Debug.Assert(Range.InRange(VertexNum, 0, Vertices.Count - 1),
"VertexNum out of range in NFFLineworkSmoothedPolyLineEntity.GetVertexStation");
return(Vertices[VertexNum].Chainage);
}
/// <summary>
/// Computes the hash index for the given vertex location
/// </summary>
private int GetHashIndex(double X, double Y, double Z)
{
double HashValue = HashOrdinate == HashOrdinate.hoX ? X : Y;
int result = (int)Math.Round((HashValue - MinHashOrdinate) / (MaxHashOrdinate - MinHashOrdinate) * HashArray.Count());
return(Range.EnsureRange(result, 0, HashArray.Length - 1));
}
/// <summary>
/// Choose the appropriate colour from the palette given the cell height, expressed as a float value.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public new Color ChooseColour(float value)
{
if (value != CellPassConsts.NullHeight)
{
var index = (int)Math.Floor((value - MinElevation) / ElevationPerBand);
return(Range.InRange(index, 0, ElevationPalette.Length - 1) ? ElevationPalette[index] : UndefinedColor);
}
return(UndefinedColor);
}
public override double ElementLength(int Index)
{
if (!Range.InRange(Index, 0, Vertices.Count - 1))
{
throw new TRexException("Out of range vertex index in NFFLineworkSmoothedPolyLineEntityElementLength");
}
if (Index == Vertices.Count - 1)
{
return(0);
}
return(Vertices[Index + 1].Chainage - Vertices[Index].Chainage);
}
// procedure ProcessPolyLine;
// function Concatenate(SmoothedPolyline: NFFLineworkSmoothedPolyLineEntity): Boolean;
// Procedure Reverse; Override;
public override void ComputeStnOfs(double X, double Y, out double Stn, out double Ofs)
{
Stn = Consts.NullDouble;
Ofs = Consts.NullDouble;
int ClosestVertex = -1;
double ClosestDistance = 1E99;
double ClosestT = Consts.NullDouble;
// writeln(LogFile, '[SP] Start Calc'); {SKIP}
// Locate the interval in the smooth polyline the station value refers to.
for (int I = 0; I < Vertices.Count - 1; I++)
{
NFFUtils.DistanceToNFFCurve(Vertices[I].X, Vertices[I].Y,
Vertices[I + 1].X, Vertices[I + 1].Y,
X, Y,
Vertices[I + 1].Alpha,
Vertices[I + 1].Beta,
out Ofs, out double t);
if (Range.InRange(t, 0 - 0.001, 1 + 0.001))
{
if (Math.Abs(Ofs) < Math.Abs(ClosestDistance))
{
ClosestDistance = Ofs;
ClosestVertex = I;
ClosestT = t;
}
}
}
if (ClosestVertex > -1)
{
Stn = Vertices[ClosestVertex].Chainage + (ClosestT * (Vertices[ClosestVertex + 1].Chainage - Vertices[ClosestVertex].Chainage));
Ofs = ClosestDistance;
}
else
{
Ofs = Consts.NullDouble;
}
}
public new Color ChooseColour(SubGridCellPassDataCMVEntryRecord cmvData)
{
if (CMVCellValueToDisplay(cmvData, out var cmvPercentValue))
{
if (cmvData.IsDecoupled && DisplayDecoupledColourInPVM)
{
return(DefaultDecoupledCMVColour);
}
// Check to see if the value is in the target range and use the target CMV colour
// if it is. CCVRange holds a min/max percentage of target CMV...
if (DisplayTargetCCVColourInPVM && Range.InRange(cmvPercentValue, MAX_PERCENTAGE_VALUE * _minTarget, MAX_PERCENTAGE_VALUE * _maxTarget))
{
return(TargetCCVColour);
}
return(ChooseColour(cmvPercentValue));
}
return(Color.Empty);
}
// Procedure Reverse; Overload; Override;
// procedure Reverse(const StartIdx, EndIdx : Integer); Overload; Override;
// LocateEntityAtStation takes a station value and locates the element
// within which the station value lies.
public void LocateEntityAtStation(double Stn, out NFFStationedLineworkEntity Element)
{
Element = null;
for (int I = 0; I < Entities.Count; I++)
{
double Eps1;
if (I == 0)
{
Eps1 = 1E-4;
}
else if (Entities[I - 1].EndStation < Entities[I].StartStation)
{
Eps1 = 1E-4;
}
else
{
Eps1 = 0;
}
double Eps2;
if (I == Entities.Count - 1)
{
Eps2 = 1E-4;
}
else if (Entities[I + 1].StartStation > Entities[I].EndStation)
{
Eps2 = 1E-4;
}
else
{
Eps2 = 0;
}
if (Range.InRange(Stn, Entities[I].StartStation - Eps1, Entities[I].EndStation + Eps2))
{
Element = Entities[I];
}
}
}
public override NFFLineworkPolyLineVertexEntity GetVertex(int VertexNum)
{
Debug.Assert(Range.InRange(VertexNum, 0, Vertices.Count - 1), "Vertex index out of range");
return(Vertices[VertexNum]);
}
/// <summary>
/// Performs primary filtered iteration over cell passes in the cell being processed to determine the cell pass
/// to be selected.
/// </summary>
private void ProcessCellPasses()
{
_haveFilteredPass = false;
_firstPassMinElev = false;
while (_cellPassIterator.MayHaveMoreFilterableCellPasses() &&
_cellPassIterator.GetNextCellPass(ref _currentPass.FilteredPass))
{
FiltersValuePopulation.PopulateFilteredValues(_siteModel.MachinesTargetValues[_currentPass.FilteredPass.InternalSiteModelMachineIndex], _populationControl, ref _currentPass);
if (_filter.AttributeFilter.FilterPass(ref _currentPass, _filterAnnex))
{
if (_filter.AttributeFilter.HasElevationTypeFilter)
{
_assignmentContext.FilteredValue.PassCount = 1;
}
// Track cell passes against lowest/highest elevation criteria
if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Lowest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Highest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height > _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.First)
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
else if (_gridDataType == GridDataType.Temperature)
{
var materialTemperature = _currentPass.FilteredPass.MaterialTemperature;
if (materialTemperature != CellPassConsts.NullMaterialTemperatureValue)
{
if (_filter.AttributeFilter.HasTemperatureRangeFilter)
{
if (Range.InRange(materialTemperature, _filter.AttributeFilter.MaterialTemperatureMin, _filter.AttributeFilter.MaterialTemperatureMax))
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
}
else
{
// check for min elevation mode
var internalMachineIndex = _currentPass.FilteredPass.InternalSiteModelMachineIndex;
var machine = _siteModel.Machines[internalMachineIndex];
var machineIsAnExcavator = machine.MachineType == MachineType.Excavator;
var mappingMode = _siteModel.MachinesTargetValues[internalMachineIndex].ElevationMappingModeStateEvents.GetValueAtDate(_currentPass.FilteredPass.Time, out _, ElevationMappingMode.LatestElevation);
var minimumElevationMappingModeAtCellPassTime = mappingMode == ElevationMappingMode.MinimumElevation;
if (machineIsAnExcavator && minimumElevationMappingModeAtCellPassTime)
{
if (!_firstPassMinElev)
{
_firstPassMinElev = true;
_haveFilteredPass = true;
_tempPass = _currentPass;
}
else if (_currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass; // take if lowest pass
}
}
else
{
// All criteria have been met for acceptance of this pass
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
}
}
}
private void ChooseSingleFilteredPassForCellPromProfiler(byte stripeIndex, byte j, out int topMostLayerCompactionHalfPassCount)
{
// if (Debug_ExtremeLogSwitchD) Log.LogDebug{$"SI@{StripeIndex}/{J} at {clientGrid.OriginX}x{clientGrid.OriginY}: Using profiler");
topMostLayerCompactionHalfPassCount = 0;
if (_canUseGlobalLatestCells)
{
// Optimistically assume that the global latest value is acceptable
AssignRequiredFilteredPassAttributesFromGlobalLatestCells(ref _assignmentContext.FilteredValue.FilteredPassData.FilteredPass, stripeIndex, j);
_assignmentContext.FilteredValue.PassCount = -1;
// Check to see if there is a non-null value for the requested field in the latest value.
// If there is none, then there is no non-null value in any of the recorded cells passes
// so the null value may be returned as the filtered value.
if (_clientGrid.AssignableFilteredValueIsNull(ref _assignmentContext.FilteredValue.FilteredPassData))
{
return;
}
if (_clientGrid.WantsLiftProcessingResults())
{
_haveFilteredPass = IsFilteredValueFromLatestCellPass(stripeIndex, j);
}
if (_haveFilteredPass)
{
FiltersValuePopulation.PopulateFilteredValues(_siteModel.MachinesTargetValues[_currentPass.FilteredPass.InternalSiteModelMachineIndex],
_populationControl, ref _assignmentContext.FilteredValue.FilteredPassData);
}
}
if (!_haveFilteredPass)
{
_cellPassIterator.SetCellCoordinatesInSubGrid(stripeIndex, j);
// if (Debug_ExtremeLogSwitchD) Log.LogDebug{$"SI@{StripeIndex}/{J} at {clientGrid.OriginX}x{clientGrid.OriginY}: Calling BuildLiftsForCell");
if (_profiler.CellLiftBuilder.Build(_cellProfile, _liftParams, _clientGrid,
_assignmentContext, // Place a filtered value into this assignment context
_cellPassIterator, // Iterate over the cells using this cell pass iterator
true)) // Return an individual filtered value
{
// topMostLayerPassCount = _profiler.CellLiftBuilder.FilteredPassCountOfTopMostLayer;
topMostLayerCompactionHalfPassCount = _profiler.CellLiftBuilder.FilteredHalfCellPassCountOfTopMostLayer;
// Filtered value selection is combined with lift analysis in this context via
// the provision of the client grid and the assignment context to the lift analysis engine
// If we have a temperature filter to be filtered by last pass
if (_filter.AttributeFilter.HasTemperatureRangeFilter && _filter.AttributeFilter.FilterTemperatureByLastPass)
{
var materialTemperature = _cellProfile.Passes.FilteredPassData[_cellProfile.Passes.PassCount - 1].FilteredPass.MaterialTemperature;
_haveFilteredPass = materialTemperature != CellPassConsts.NullMaterialTemperatureValue &&
Range.InRange(materialTemperature, _filter.AttributeFilter.MaterialTemperatureMin, _filter.AttributeFilter.MaterialTemperatureMax);
}
else
{
_haveFilteredPass = true;
}
}
// if (Debug_ExtremeLogSwitchD) Log.LogDebug{$"SI@{StripeIndex}/{J} at {clientGrid.OriginX}x{clientGrid.OriginY}: Call to BuildLiftsForCell completed");
}
}
/// <summary>
/// Special version of ProcessCellPasses when using a pass count range Filter.
/// Performs primary filtered iteration over cell passes in the cell being processed to determine the cell pass
/// to be selected.
/// </summary>
private void ProcessCellPassesPassCountRange()
{
_haveFilteredPass = false;
var haveHalfPass = false;
var passRangeCount = 0;
int idxPtr;
var arrayLength = 1000;
var filteredPassDataArray = new FilteredPassData[arrayLength];
var filteredPassBoolArray = new bool[arrayLength];
var passes = 0;
var validPasses = 0;
var minElevCheckRequired = false;
_firstPassMinElev = false;
while (_cellPassIterator.MayHaveMoreFilterableCellPasses() &&
_cellPassIterator.GetNextCellPass(ref _currentPass.FilteredPass))
{
FiltersValuePopulation.PopulateFilteredValues(_siteModel.MachinesTargetValues[_currentPass.FilteredPass.InternalSiteModelMachineIndex], _populationControl, ref _currentPass);
if (_filter.AttributeFilter.FilterPass(ref _currentPass, _filterAnnex))
{
if (_gridDataType == GridDataType.Temperature)
{
// make sure we have a valid temperature pass
var materialTemperature = _currentPass.FilteredPass.MaterialTemperature;
if (materialTemperature != CellPassConsts.NullMaterialTemperatureValue)
{
if (_filter.AttributeFilter.HasTemperatureRangeFilter)
{
if (Range.InRange(materialTemperature, _filter.AttributeFilter.MaterialTemperatureMin, _filter.AttributeFilter.MaterialTemperatureMax))
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
// Add valid pass to list for pass count range filter
if (_haveFilteredPass)
{
filteredPassDataArray[passes] = _currentPass;
passes++;
if (passes == arrayLength - 1)
{
arrayLength = arrayLength + 500;
Array.Resize(ref filteredPassDataArray, arrayLength);
Array.Resize(ref filteredPassBoolArray, arrayLength);
}
_haveFilteredPass = false; // reset
}
} // end while more passes
_haveFilteredPass = false; // reset for next test
// For pass count range filtering we must walk from earliest to latest
// setup idxPtr to walk forward in time
if (_cellPassIterator.SegmentIterator.IterationDirection == IterationDirection.Forwards)
{
idxPtr = 0;
}
else
{
idxPtr = passes - 1; // last entry is earliest
}
if (passes > 0)
{
for (var i = 0; i < passes; i++)
{
if (i > 0)
{
if (_cellPassIterator.SegmentIterator.IterationDirection == IterationDirection.Forwards)
{
idxPtr++;
}
else
{
idxPtr--;
}
}
_currentPass = filteredPassDataArray[idxPtr];
if (_currentPass.FilteredPass.HalfPass)
{
if (haveHalfPass)
{
passRangeCount++; // increase count on second half pass encountered
}
else
{
haveHalfPass = true;
continue; // wont be using first half pass
}
haveHalfPass = false;
}
else
{
passRangeCount++; // increase count for a full pass
}
if (Range.InRange(passRangeCount, _filter.AttributeFilter.PassCountRangeMin, _filter.AttributeFilter.PassCountRangeMax))
{
filteredPassBoolArray[idxPtr] = true; // tagged for minElev check
if (_filter.AttributeFilter.HasElevationTypeFilter)
{
_assignmentContext.FilteredValue.PassCount = 1;
}
else
{
validPasses++;
_assignmentContext.FilteredValue.PassCount = validPasses;
}
if ((_filter.AttributeFilter.HasElevationMappingModeFilter && _filter.AttributeFilter.ElevationMappingMode == ElevationMappingMode.MinimumElevation) ||
(_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Lowest))
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Highest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height > _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else
{
// are we only interested in first pass
if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.First)
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break; // we are out of here
}
if (!minElevCheckRequired)
{
minElevCheckRequired = true; // means we need to do an extra check below for minElevation on chosen last pass
}
if (!_haveFilteredPass)
{
_haveFilteredPass = true;
}
_tempPass = _currentPass; // good pass. Last one assigned will be latest
}
} // end in range
if (passRangeCount == _filter.AttributeFilter.PassCountRangeMax)
{
break; // we are out of here
}
} // end pass loop
if (minElevCheckRequired)
{
// If minElevCheckRequired we now have a known list of good passes to determine the lowest pass
// Rule states we walk in direction of CellPassIterator and return lowest pass while mode is minElev
// Walk through list that was constructed by CellPassIterator direction to get lowest pass
_haveFilteredPass = false;
for (var i = 0; i < passes; i++)
{
if (!filteredPassBoolArray[i])
{
continue;
}
_currentPass = filteredPassDataArray[i];
// check for min elevation mode
var internalMachineIndex = _currentPass.FilteredPass.InternalSiteModelMachineIndex;
var machine = _siteModel.Machines[internalMachineIndex];
var machineIsAnExcavator = machine.MachineType == MachineType.Excavator;
var mappingMode = _siteModel.MachinesTargetValues[internalMachineIndex].ElevationMappingModeStateEvents.GetValueAtDate(_currentPass.FilteredPass.Time, out _, ElevationMappingMode.LatestElevation);
var minimumElevationMappingModeAtCellPassTime = mappingMode == ElevationMappingMode.MinimumElevation;
if (machineIsAnExcavator && minimumElevationMappingModeAtCellPassTime)
{
if (!_firstPassMinElev)
{
_firstPassMinElev = true; // take first pass in list as lowest to begin with
_tempPass = _currentPass;
}
else if (!_haveFilteredPass || (_currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height))
{
_tempPass = _currentPass;
}
if (!_haveFilteredPass)
{
_haveFilteredPass = true;
}
}
else
{
if (_firstPassMinElev && _haveFilteredPass) // take last know lowest pass
{
break;
}
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break; // we have the pass we need
}
} // end passes
} // end min check required
} // end passes > 0
}
