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 GeometryExtents <double> AddLayer(MRecipe recipe, MRecipeDeviceLayer layer)
{
var extents = GeometryExtents <double> .CreateDefaultDouble();
// calculate layer's transform
var transform = MRecipe.GetRelativeTransform(recipe, layer);
// fetch geometries from pattern file
var geometries = _fetchDxfFunc(layer.PatternFilePath);
for (int i = 0; i < geometries?.Count; i++)
{
var clone = (IMarkGeometry)geometries[i].Clone();
clone.Transform(transform);
// render geometry
AddDefault(
clone,
DefaultColor
);
// update extents
extents = GeometryExtents <double> .Combine(
extents,
clone.Extents
);
}
return(extents);
}
public IMarkParametersComplete FetchDXFParameters(MRecipeDeviceLayer layer)
{
var processConfig = _model.GetProcessConfiguration(layer.TargetProcessMode);
processConfig?.ProcessParameterFileManager.LoadFromfile(layer.ProcessParametersFilePath);
return(processConfig?.ProcessParameterFileManager.ProcessParameters as IMarkParametersComplete);
}
public MRecipe GenerateRecipe(string outputFileName)
{
if (
_geometriesBuffer == null ||
_geometriesBuffer.Keys.Count <= 0 ||
!File.Exists(PatternFilePath)
)
{
throw new Exception("Missing or Invalid pattern");
}
var patternName = Path.GetFileNameWithoutExtension(outputFileName);
var device = new MRecipeDevice(patternName);
var recipe = new MRecipe(new MRecipePlate("Plate", device));
// add fiducials to recipe plate
recipe.Plates.First().Fiducials = new ObservableCollection <MFiducialInfo>(Fiducials);
if (SeperateLayers)
{
var dataDirectory = Path.Combine(
Path.GetDirectoryName(outputFileName),
$"{patternName} Data"
);
if (!Directory.Exists(dataDirectory))
{
Directory.CreateDirectory(dataDirectory);
}
foreach (var layerName in _geometriesBuffer?.Keys)
{
var fileName = Path.Combine(
dataDirectory, $"{layerName}.dxf"
);
GeometricArithmeticModule.SaveDXF(fileName, _geometriesBuffer[layerName]);
var layer = new MRecipeDeviceLayer(layerName);
layer.AlignmentType = AlignmentType;
layer.PatternFilePath = fileName;
layer.ProcessParametersFilePath = ProcessParametersFilePath;
layer.TargetProcessMode = TargetProcessMode?.Name.EnglishValue;
layer.TileSettings = (MTileSettings)TileSettings.Clone();
device.AddLayer(layer);
}
recipe.Save(
Path.Combine(
dataDirectory, $"{patternName}.{MRecipe.DefaultFileExtension}"
)
);
}
else
{
var layer = new MRecipeDeviceLayer(patternName);
layer.AlignmentType = AlignmentType;
layer.PatternFilePath = PatternFilePath;
layer.ProcessParametersFilePath = ProcessParametersFilePath;
layer.TargetProcessMode = TargetProcessMode?.Name.EnglishValue;
layer.TileSettings = (MTileSettings)TileSettings.Clone();
device.AddLayer(layer);
recipe.Save(
Path.Combine(
Path.GetDirectoryName(PatternFilePath), $"{patternName}.{MRecipe.DefaultFileExtension}"
)
);
}
// update recipe's parents
recipe.UpdateParents();
return(recipe);
}
public TimeSpan EstimateProcessTime(MRecipeDeviceLayer layer)
{
const double kConst = 0.000001;
double totalTaktTime = 0;
IMarkParametersComplete processParams = FetchDXFParameters(layer);
if (processParams == null)
{
return(TimeSpan.Zero);
}
int numOfJoints = 0;
double jumpDistance = 0;
double markDistance = 0;
double minX = double.MaxValue;
double minY = double.MaxValue;
double maxX = double.MinValue;
double maxY = double.MinValue;
MarkGeometryPoint lastPosition = null;
foreach (var geometry in FetchDXF(layer))
{
if (geometry is MarkGeometryPoint point)
{
if (lastPosition != null)
{
jumpDistance += GeometricArithmeticModule.ABSMeasure2D(lastPosition, point);
}
markDistance += point.Perimeter;
lastPosition = point;
}
else if (geometry is MarkGeometryLine line)
{
if (lastPosition != null)
{
jumpDistance += GeometricArithmeticModule.ABSMeasure2D(lastPosition, line.StartPoint);
}
markDistance += line.Perimeter;
lastPosition = line.EndPoint;
}
else if (geometry is MarkGeometryCircle circle)
{
if (lastPosition != null)
{
jumpDistance += GeometricArithmeticModule.ABSMeasure2D(
lastPosition,
GeometricArithmeticModule.GetPointAtPosition(
circle, 0
)
);
}
markDistance += circle.Perimeter;
numOfJoints += Math.Max(circle.VertexCount - 1, 0);
lastPosition = GeometricArithmeticModule.GetPointAtPosition(circle, 1.0);
}
else if (geometry is MarkGeometryArc arc)
{
if (lastPosition != null)
{
jumpDistance += GeometricArithmeticModule.ABSMeasure2D(lastPosition, arc.StartPoint);
}
markDistance += arc.Perimeter;
numOfJoints += Math.Max(arc.VertexCount - 1, 0);
lastPosition = arc.EndPoint;
}
else if (geometry is MarkGeometryPath path)
{
if (lastPosition != null)
{
jumpDistance += GeometricArithmeticModule.ABSMeasure2D(lastPosition, path.StartPoint);
}
markDistance += path.Perimeter;
numOfJoints += Math.Max(path.Points.Count - 1, 0);
lastPosition = path.EndPoint;
}
if (geometry.Extents.MinX < minX)
{
minX = geometry.Extents.MinX;
}
if (geometry.Extents.MinY < minY)
{
minY = geometry.Extents.MinY;
}
if (geometry.Extents.MaxX > maxX)
{
maxX = geometry.Extents.MaxX;
}
if (geometry.Extents.MaxY > maxY)
{
maxY = geometry.Extents.MaxY;
}
}
double taktTime = (
(markDistance / processParams.MarkSpeed) +
(jumpDistance / processParams.JumpSpeed) +
(kConst * numOfJoints * (processParams.JumpDelay_us + processParams.MarkDelay - processParams.Nprev))
);
// account for repeats and stepping between tiles - convert millisecond to second
totalTaktTime += ((taktTime * processParams.Passes) + (0.001 * layer.TileDescriptions.Count() * processParams.SettlingTimems));
return(TimeSpan.FromSeconds(Math.Round(totalTaktTime, 4)));
}
public List <IMarkGeometry> FetchDXF(MRecipeDeviceLayer layer)
{
return(FetchDXF(layer.PatternFilePath));
}
