public void GenerateRecipeInfo()
{
RecipeInfo.Clear();
int index = 0;
MRecipe.BeginGetAllLayers(RecipeVm, (layer) =>
{
if (layer.TileDescriptions.Count() <= 0)
{
layer.GenerateTileDescriptionsFromSettings(
GeometricArithmeticModule.CalculateExtents(FetchDXF(layer))
);
}
var info = new RecipeProcessEntityInfo()
{
Index = index++,
Layer = layer,
EstimatedTime = EstimateProcessTime(layer)
};
RecipeInfo.Add(info);
});
// fetch recipe's count and extents
(RecipeGeometriesCount, RecipeExtents) = MRecipe.CalculateExtents(RecipeVm);
}
public virtual void AddLayerTiles(MRecipe recipe, MRecipeDeviceLayer layer)
{
// get layer's transform
var transform = MRecipe.GetRelativeTransform(recipe, layer);
// update layer's tile info
if (layer.TileDescriptions.Count <= 0)
{
layer.GenerateTileDescriptionsFromSettings(
(patternFilePath) =>
{
return(GeometricArithmeticModule.CalculateExtents(
_fetchDxfFunc(patternFilePath)
));
}
);
}
// render tiles
for (int i = 0; i < layer.TileDescriptions.Count; i++)
{
var tile = (MarkGeometryRectangle)layer.TileDescriptions[i];
tile.Transform(transform);
AddDefault(tile, TileColor);
}
}
private void Create(IList <MarkGeometryLine> lines)
{
var extents = GeometricArithmeticModule.CalculateExtents(lines);
Create(extents.Centre.X, extents.Centre.Y, extents.Hypotenuse);
foreach (var line in lines)
{
if (!Insert(line))
{
throw new Exception($"Error while attempting to insert line: {line}");
}
}
}
public override void SetExtents()
{
if (EndAngle < StartAngle)
{
Sweep = (EndAngle + (2d * Math.PI)) - StartAngle;
}
else
{
Sweep = EndAngle - StartAngle;
}
Area = 0.5 * Sweep * Math.Pow(Radius, 2);
Perimeter = Sweep * Radius;
// determine start and end points
StartPoint = GeometricArithmeticModule.GetPointAtPosition(this, 0.0);
EndPoint = GeometricArithmeticModule.GetPointAtPosition(this, 1.0);;
Extents = GeometricArithmeticModule.CalculateExtents((MarkGeometryPoint[])this);
}
public MSTLSlice(List <MContourStructure> contours)
: this()
{
NumberOfContours = contours.Count;
MarkGeometryPoint lastPoint = null;
foreach (var contourStructure in contours)
{
var(lines, minLineLength, perimeter) = GeometricArithmeticModule.GetLinesAndStatistics(
contourStructure.ToPoints()
);
ContourLines.AddRange(
lines
);
if (minLineLength < MinVectorLength)
{
MinVectorLength = minLineLength;
}
_totalContourMarkDistance += perimeter;
NumberOfJoints += (lines.Count - 1);
if (lines.Count > 0)
{
if (lastPoint != null)
{
// measure and track the jump distance between the last contour and this
_totalContourJumpDistance += GeometricArithmeticModule.ABSMeasure(lastPoint, lines[0].StartPoint);
}
lastPoint = lines[0].StartPoint;
}
}
_contourQuadTree = new ContourQuadTree(ContourLines);
Extents = GeometricArithmeticModule.CalculateExtents(ContourLines);
}
private static void SaveImage(Dictionary <string, List <IMarkGeometry> > geometriesIn, int capacity)
{
var _geometries = new List <IMarkGeometry>(capacity);
foreach (var items in geometriesIn.Values)
{
_geometries.AddRange(items);
}
var extents = GeometricArithmeticModule.CalculateExtents(_geometries);
Console.WriteLine($"Extents: {extents}");
GeometryToImageConverter.To1BppImage(
_geometries,
@"D:\Downloads\demo.tiff",
pixelSize: 25.4,
dpiX: 720,
dpiY: 720,
lineWidth: -1 // smallest possible
);
}
public virtual void AddDefault(IList <IMarkGeometry> geometriesIn, double[] color)
{
if (geometriesIn == null || color == null || color.Length < 3)
{
AddDefault(geometriesIn);
return;
}
if (geometriesIn.All(x => x is MarkGeometryPoint))
{
var currentExtents = GeometryExtents <double> .Combine(
new GeometryExtents <double>()
{
MinX = MinX,
MaxX = MaxX,
MinY = MinY,
MaxY = MaxY
},
GeometricArithmeticModule.CalculateExtents(
geometriesIn
)
);
// Update extents
MinX = currentExtents.MinX;
MaxX = currentExtents.MaxX;
MinY = currentExtents.MinY;
MaxY = currentExtents.MaxY;
// Update Counter
Count += geometriesIn.Count;
var vtx = new VertexGroup()
{
Color = color
};
for (int i = 0; i < geometriesIn.Count; i++)
{
vtx.Vertices.AddRange(ToDouble(geometriesIn[i] as MarkGeometryPoint));
}
_points.Add(vtx);
Update();
}
else if (geometriesIn.All(x => x is MarkGeometryLine))
{
var currentExtents = GeometryExtents <double> .Combine(
new GeometryExtents <double>()
{
MinX = MinX,
MaxX = MaxX,
MinY = MinY,
MaxY = MaxY
},
GeometricArithmeticModule.CalculateExtents(
geometriesIn
)
);
// Update extents
MinX = currentExtents.MinX;
MaxX = currentExtents.MaxX;
MinY = currentExtents.MinY;
MaxY = currentExtents.MaxY;
// Update Counter
Count += geometriesIn.Count;
var vtx = new VertexGroup()
{
Color = color
};
for (int i = 0; i < geometriesIn.Count; i++)
{
vtx.Vertices.AddRange(ToDouble(geometriesIn[i] as MarkGeometryLine));
}
_lines.Add(vtx);
Update();
}
else
{
for (int i = 0; i < geometriesIn.Count; i++)
{
AddDefault(geometriesIn[i], color);
}
}
}
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 override void SetExtents()
{
Extents = GeometricArithmeticModule.CalculateExtents(Flatten());
}
