public void Render()
{
_terminableTaskExecutor.CancelCurrentAndRun(
(ctIn) =>
{
// reset shader
MShader.Reset();
if (_geometriesBuffer != null)
{
int count = 0;
var extents = GeometryExtents <double> .CreateDefaultDouble();
foreach (var layerName in _geometriesBuffer.Keys)
{
MShader.AddDefault(
_geometriesBuffer[layerName],
_colours[(count++) % _colours.Length]
);
extents = GeometryExtents <double> .Combine(
extents, GeometricArithmeticModule.CalculateExtents(_geometriesBuffer[layerName])
);
}
// overlay tiles
foreach (var tile in MTileSettings.ToTiles(TileSettings, extents))
{
MShader.AddDefault((MarkGeometryRectangle)tile, _tileColor);
}
// calculate size of fiducial relative to the node
var fiducialSize = 0.05 * extents.Hypotenuse;
// generate fiducial pattern
GenerateFiducialPattern(fiducialSize);
// get base transform
var baseTransform = GeometricArithmeticModule.GetTranslationTransformationMatrix(
extents.Centre.X, extents.Centre.Y
);
// render fiducials in parent's reference frame
foreach (var fiducial in Fiducials)
{
var transform = GeometricArithmeticModule.CombineTransformations(
baseTransform,
GeometricArithmeticModule.GetTranslationTransformationMatrix(
fiducial.X, fiducial.Y, fiducial.Z
)
);
foreach (var geometry in _fiducialPattern)
{
var clone = (IMarkGeometry)geometry.Clone();
clone.Transform(transform);
MShader.AddDefault(clone, _fiducialColor);
}
}
}
// stop if new render is requested
ctIn.ThrowIfCancellationRequested();
MShader.Render();
DrawingExtentsX = MShader.Width;
DrawingExtentsY = MShader.Height;
DrawingCount = MShader.Count;
}
);
}
public void StartProcess()
{
_processTerminableTaskExecutor.CancelCurrentAndRun(
async(ctIn) =>
{
try
{
// reset timers
_processStopWatch.Reset();
_processTimer.Start();
IsRunning = true;
ClearLogs();
PrintLog("Starting process...");
#region Section: Executing Process
ProcessProgress = 0;
double progressIncrement = (1.0 / RecipeInfo.Count) * 100d;
// reset all
foreach (var info in RecipeInfo)
{
info.State = EntityState.WAITING;
}
// run pre recipe routine
await _model.RunPreExecutionTasks(ctIn);
int counter = 0;
foreach (var info in RecipeInfo)
{
// wait if paused
while (
IsPaused &&
!ctIn.IsCancellationRequested
)
{
await Task.Delay(100);
}
// process layer
if (!await _model.ProcessLayer(
RecipeVm,
info,
FetchDXF(info.Layer),
FetchDXFParameters(info.Layer),
() => IsPaused,
(message) => PrintLog(message),
(message) => PrintError(message),
ctIn
))
{
throw new Exception($"Failed while processing layer: {counter}");
}
ctIn.ThrowIfCancellationRequested();
ProcessProgress += progressIncrement;
counter += 1;
}
#endregion
PrintLog("Process completed successfully...");
}
catch (Exception exp)
{
PrintError("Process failed.");
PrintLog(exp.Message);
}
finally
{
try
{
await _model.RunPostExecutionTasks(ctIn);
}
catch (Exception e2)
{
PrintError("Failed to run pre-recipe tasks");
PrintLog(e2.Message);
}
IsRunning = false;
}
}
);
}
public void Render()
{
_terminableTaskExecutor.CancelCurrentAndRun(
(ctIn) =>
{
// reset shader
MShader.Reset();
// stop if new render is requested
ctIn.ThrowIfCancellationRequested();
// as we only render one layer at a time
// choose the closest layer in the recipe tree
var layer = GetClosestLayer();
if (layer != null)
{
// extract device's absolute transform
var baseTransform = MRecipe.GetRelativeTransform(RecipeVm, layer);
// calculate layer's transform
var transform = GeometricArithmeticModule.CombineTransformations(
baseTransform,
layer.TransformInfo.ToMatrix4x4()
);
// fetch pattern
var pattern = FetchDXF(layer);
for (int j = 0; j < pattern?.Count; j++)
{
// get copy of geometry
var geometry = (IMarkGeometry)pattern[j].Clone();
// apply transform to geometry
geometry.Transform(transform);
// add geometry
MShader.AddDefault(geometry);
}
// overlay tiles
foreach (var tile in layer.TileDescriptions)
{
var rect = (MarkGeometryRectangle)tile;
// apply transform to rect
rect.Transform(transform);
// add geometry
MShader.AddDefault(rect, MGLShader.Violet);
}
}
// stop if new render is requested
ctIn.ThrowIfCancellationRequested();
MShader.Render();
UpdateStats();
}
);
}
public void Render()
{
_terminableTaskExecutor.CancelCurrentAndRun(
(ctIn) =>
{
// reset shader
MShader.Reset();
if (_stlSlices != null)
{
// add geometries
if (CurrentSlice >= 0 && CurrentSlice < _stlSlices.Count && _stlSlices[CurrentSlice] != null)
{
var stlSlice = _stlSlices[CurrentSlice];
// tiles
for (int i = 0; i < stlSlice.Tiles?.Count; i++)
{
MShader.AddDefault(stlSlice.Tiles[i], _tileColor);
}
// contours
for (int i = 0; i < stlSlice.ContourLines?.Count; i++)
{
MShader.AddDefault(stlSlice.ContourLines[i], MGLShader.Green);
}
// hatches
for (int i = 0; i < stlSlice.HatchLines?.Count; i++)
{
MShader.AddDefault(stlSlice.HatchLines[i], MGLShader.White);
}
}
// stop if new render is requested
ctIn.ThrowIfCancellationRequested();
// get base transform
var baseTransform = GeometricArithmeticModule.GetTranslationTransformationMatrix(
StlModelReferencePoint.X, StlModelReferencePoint.Y
);
// render fiducials in parent's reference frame
foreach (var fiducial in Fiducials)
{
var transform = GeometricArithmeticModule.CombineTransformations(
baseTransform,
GeometricArithmeticModule.GetTranslationTransformationMatrix(
fiducial.X, fiducial.Y, fiducial.Z
)
);
foreach (var geometry in _fiducialPattern)
{
var clone = (IMarkGeometry)geometry.Clone();
clone.Transform(transform);
MShader.AddDefault(clone, _fiducialColor);
}
}
}
// stop if new render is requested
ctIn.ThrowIfCancellationRequested();
MShader.Render();
}
);
}
