public TransposerParams(ImgPoint imgA, ImgPoint imgB, GpsPoint gpsA, GpsPoint gpsB, int step)
{
_imgStartPoint = imgA;
_imgEndPoint = imgB;
_gpsStartPoint = gpsA;
_gpsEndPoint = gpsB;
_stepLength = step;
}
//TODO cleanup this, not readable and does too many things. Split up the methods by skeleton type and by overlay (with overlay/without)
public void Merge(AssemblerResource <T> canvas, AssemblerResource <T> layer, SkeletonType skeletonType, Overlay overlay)
{
var newParts = new List <(ImgPoint point, IImage <T> Image, bool isPattern)>();
if (overlay != null && overlay.SourceType.ToObjectType() != layer.Definition.ObjectType)
{
// Each overlay color will tell us how many parts we need,
// i.e. if there are N overlay point for color X, then we need N parts
// If the resource has multiple images, use those, otherwise just use one image multiple times.
var offSets = overlay.Points[OverlayColorRef[layer.Definition.ObjectType]].Cast <ImgPoint>().ToList();
if (offSets.Count > 1 && layer.Definition.Meta.CannotDuplicate)
{
ImgPoint newOffset;
if (offSets.Count > 2)
{
newOffset = offSets.PickRandom();
}
else
{
newOffset = new ImgPoint((offSets[0].X + offSets[1].X) / 2, (offSets[0].Y + offSets[1].Y) / 2);
}
offSets = new List <ImgPoint>()
{
newOffset
};
}
// "00FF26" & "FF00E5" are the default anchor colors - just an arbitrary choice. Change if needed.
// TODO rewrite this, see anchor system overlay in garbler todo
var anchorInUse = skeletonType == SkeletonType.Overlay ? AnchorOverlay : AnchorSkeleton;
if (!layer.Definition.Meta.IsSet)
{
var anchor = layer.Definition.Meta.MainAnchor
?? ExtractAnchor(layer.Data, anchorInUse);
for (int i = 0; i < offSets.Count; i++)
{
AddPart(offSets[i], anchor, layer.Data, i > offSets.Count / 2);
}
}
else
{
// TODO rewrite with new anchor system
throw new NotImplementedException("currently disabled, re-enable when needed & after anchor system overhaul");
//var imagesAndAnchors = layer.AdditionalImages.Select(t =>
// new {
// anchor = ExtractAnchor(t, anchorInUse),
// image = t
// }).ToArray();
//for (int i = 0, j = 0; i < offSets.Count; i++, j++)
//{
// if (j >= imagesAndAnchors.Length)
// j = 0;
// var item = imagesAndAnchors[j];
// AddPart(offSets[i], item.anchor, item.image, i >= offSets.Count / 2);
//}
}
// PastSplit: At the moment we only allow to split a layer in two halves. Improve this if needed.
void AddPart(ImgPoint offset, ImgPoint anchor, IImage <T> image, bool PastSplit)
{
var offsetAnchor = new ImgPoint(offset.X - anchor.X, offset.Y - anchor.Y);
if (PastSplit && layer.Instruction.DepthSplit > 0)
{
canvas.SplitLayers.Add(new SplitLayer <T>()
{
Anchor = offsetAnchor,
image = image,
Queue = layer.Instruction.DepthSplit
});
}
else
{
newParts.Add((offsetAnchor, image, layer.Instruction.IsPattern));
}
}
}
else if (skeletonType == SkeletonType.Anchors)
{
// TODO rewrite with new anchor system
if (canvas.IsEmpty)
{
newParts.Add((new ImgPoint(
canvas.Data.Width / 2 - layer.Data.Width / 2,
canvas.Data.Height - layer.Data.Height),
layer.Data,
false));
}
else
{
var layerAnchor = layer.Definition.Meta.MainAnchor ?? ExtractAnchor(layer.Data, AnchorOverlay);
var canvasAnchor = canvas.Definition.Meta.MainAnchor ?? ExtractAnchor(canvas.Data, AnchorOverlay);
var offsetAnchor = new ImgPoint(canvasAnchor.X - layerAnchor.X, canvasAnchor.Y - layerAnchor.Y, RestrictedPoints);
newParts.Add((offsetAnchor, layer.Data, layer.Instruction.IsPattern));
}
}
else
{
newParts.Add((new ImgPoint(0, 0), layer.Data, layer.Instruction.IsPattern));
}
if (canvas.SplitLayers != null && canvas.SplitLayers.Any())
{
var insertions = canvas.SplitLayers
.Where(l => l.Queue == 0);
// Split layers out of the queue come out first
newParts.InsertRange(0, insertions.Select(l => (l.Anchor, l.image, false)));
canvas.SplitLayers = canvas.SplitLayers.Except(insertions).ToList();
foreach (var splitLayer in canvas.SplitLayers)
{
splitLayer.Queue--;
}
}
foreach (var part in newParts)
{
Merge(canvas.Data, part.Image, 0, 0, part.point.X, part.point.Y, part.isPattern);
canvas.IsEmpty = false;
}
}
