/// <summary>
/// Merge two layers, result is with bottom polarity
/// </summary>
/// <param name="layerBottom">Layer bottom, it's affected with the result</param>
/// <param name="layerTop">Layer top, it's unnafected</param>
protected void MergeLayers(PlarityLayerDTO layerBottom, PlarityLayerDTO layerTop)
{
if (layerBottom.IsDarkPolarity == layerTop.IsDarkPolarity)
{
layerTop.Rows.ForEach(r =>
AddColumns(layerBottom, r.RowIndex, r.Columns)
);
}
else
{
var rows = layerBottom.Rows;
var layer = new PlarityLayerDTO()
{
IsDarkPolarity = layerBottom.IsDarkPolarity
};
layerBottom.Rows.ForEach(rb =>
{
var rowTop = layerTop.Rows.FirstOrDefault(rt => rt.RowIndex == rb.RowIndex);
rowTop?.Columns.ForEach(columnTop =>
{
var overlappedColumns = rb.Columns.Where(c => c.Left <= columnTop.Right && c.Right >= columnTop.Left).ToList();
var deleted = new List <ColumnDataDTO>();
overlappedColumns.ForEach(columnBottom =>
{
if (columnTop.TypeColumn == TypeColumn.partial)
{
columnBottom.TypeColumn = TypeColumn.partial;
if (columnBottom.Traces == null)
{
columnBottom.Traces = new List <GerberTraceDTO>();
}
}
if (columnBottom.Left < columnTop.Left)
{
if (columnBottom.Right > columnTop.Right)
{
rb.Columns.Add(CreateColumn(columnTop.Right + 1, columnBottom.Right, columnBottom.Traces, columnBottom.TypeColumn));
}
columnBottom.Right = columnTop.Left - 1;
}
if (columnBottom.Right > columnTop.Right)
{
columnBottom.Left = columnTop.Right + 1;
}
if (columnBottom.Left >= columnTop.Left && columnBottom.Right <= columnTop.Right)
{
deleted.Add(columnBottom);
}
});
deleted.ForEach(d => rb.Columns.Remove(d));
deleted.Clear();
});
});
}
}
/// <summary>
/// Make a hole in aperture
/// </summary>
/// <param name="metaData">Metadata</param>
/// <param name="trace">Trace to use in partial columns</param>
/// <param name="aperture">Aperture with hole</param>
/// <param name="layer">Layer where merge</param>
protected void MakeHole(GerberMetaDataDTO metaData, GerberTraceDTO trace, GerberApertureDTO aperture, PlarityLayerDTO layer)
{
List <CoordinateDTO> hole = MidpointCircle(trace.AbsolutePointEnd.X / metaData.Scale,
trace.AbsolutePointEnd.Y / metaData.Scale,
aperture.Modifiers.Last() / metaData.Scale / 2,
topRow, bottomRow);
var layerHole = new PlarityLayerDTO();
layerHole.IsDarkPolarity = !layer.IsDarkPolarity;
ResumePoints(hole, layerHole, trace);
MergeLayers(layer, layerHole);
}
public override void Create(GerberMetaDataDTO metaDataBase, GerberMetaDataDTO metaData, GerberTraceDTO trace, GerberApertureDTO aperture, int layerIndex, int rowFrom, int rowTo)
{
base.Create(metaDataBase, metaData, trace, aperture, layerIndex, rowFrom, rowTo);
var leftColumn = trace.AbsolutePointEnd.X - aperture.Modifiers[0] / 2;
var rightColumn = leftColumn + aperture.Modifiers[0];
leftColumn /= metaData.Scale;
rightColumn /= metaData.Scale;
var layer = new PlarityLayerDTO()
{
IsDarkPolarity = metaData.PolarityLayers[layerIndex].IsDarkPolarity
};
for (var rowIndex = topRow; rowIndex >= bottomRow; rowIndex--)
{
var row = GetRow(layer, rowIndex);
var columns = new List <ColumnDataDTO>();
if (rowIndex == topRow || rowIndex == bottomRow)
{
columns.Add(
CreateColumn(leftColumn, rightColumn, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial)
);
}
else
{
columns.Add(
CreateColumn(leftColumn, leftColumn, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial)
);
columns.Add(
CreateColumn(leftColumn + 1, rightColumn - 1, null, TypeColumn.fill)
);
columns.Add(
CreateColumn(rightColumn, rightColumn, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial)
);
}
AddColumns(layer, rowIndex, columns);
}
if (aperture.Modifiers.Count == 3)
{
MakeHole(metaData, trace, aperture, layer);
}
MergeLayers(metaData.PolarityLayers[layerIndex], layer);
}
/// <summary>
/// Add columns to row, row is created whether isn't exist
/// </summary>
/// <param name="layer"></param>
/// <param name="rowIndex"></param>
/// <param name="columns"></param>
protected void AddColumns(PlarityLayerDTO layer, int rowIndex, List <ColumnDataDTO> columns)
{
var row = layer.Rows.Where(r => r.RowIndex == rowIndex).FirstOrDefault();
if (row == null)
{
row = new RowDataDTO()
{
RowIndex = rowIndex
};
layer.Rows.Add(row);
}
columns.ForEach(column => OverlapColumn(column, row.Columns));
}
/// <summary>
/// Resume points into columns in layer
/// </summary>
/// <param name="points">Coordinate to resume</param>
/// <param name="layer">Layer column would be added</param>
/// <param name="trace">Trace in partial columns</param>
protected void ResumePoints(List <CoordinateDTO> points, PlarityLayerDTO layer, GerberTraceDTO trace)
{
var total = points.Count();
var previousPoint = points[0];
var actualPoint = previousPoint;
var row = GetRow(layer, actualPoint.Y);
var columns = new List <ColumnDataDTO>();
var column = CreateColumn(actualPoint.X, actualPoint.X, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial);
for (var idx = 1; idx < total; idx++)
{
actualPoint = points[idx];
if (previousPoint.Y == actualPoint.Y)
{
if (previousPoint.X == actualPoint.X || previousPoint.X + 1 == actualPoint.X)
{
column.Right = actualPoint.X;
}
else
{
columns.Add(column);
if (previousPoint.X + 1 < actualPoint.X)
{
columns.Add(
CreateColumn(previousPoint.X + 1, actualPoint.X - 1, null, TypeColumn.fill)
);
}
column = CreateColumn(actualPoint.X, actualPoint.X, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial);
}
}
else
{
columns.Add(column);
AddColumns(layer, previousPoint.Y, columns);
columns.Clear();
column = CreateColumn(actualPoint.X, actualPoint.X, new List <GerberTraceDTO> {
trace
}, TypeColumn.partial);
}
previousPoint = actualPoint;
}
columns.Add(column);
AddColumns(layer, actualPoint.Y, columns);
}
public override void Create(GerberMetaDataDTO metaDataBase, GerberMetaDataDTO metaData, GerberTraceDTO trace, GerberApertureDTO aperture, int layerIndex, int rowFrom, int rowTo)
{
base.Create(metaDataBase, metaData, trace, aperture, layerIndex, rowFrom, rowTo);
var points = MidpointCircle(
trace.AbsolutePointEnd.X / metaData.Scale
, trace.AbsolutePointEnd.Y / metaData.Scale
, aperture.Modifiers[0] / metaData.Scale / 2,
topRow,
bottomRow);
var layer = new PlarityLayerDTO()
{
IsDarkPolarity = metaData.PolarityLayers[layerIndex].IsDarkPolarity
};
ResumePoints(points, layer, trace);
if (aperture.Modifiers.Count() == 2)
{
MakeHole(metaData, trace, aperture, layer);
}
MergeLayers(metaData.PolarityLayers[layerIndex], layer);
}
/// <summary>
/// Get row of layer
/// </summary>
/// <param name="layer">layer</param>
/// <param name="rowIndex">Layer index</param>
/// <returns></returns>
protected RowDataDTO GetRow(PlarityLayerDTO layer, int rowIndex)
{
return(layer.Rows.Where(r => r.RowIndex == rowIndex).FirstOrDefault());
}
