/// <summary>
/// Applies pixels from preview layer to selected layer.
/// </summary>
public void ApplyPreviewLayer()
{
if (previewLayerChanges == null)
{
return;
}
foreach (var modifiedLayer in previewLayerChanges)
{
Layer layer = Manager.ActiveDocument.Layers.FirstOrDefault(x => x.LayerGuid == modifiedLayer.LayerGuid);
if (layer != null)
{
BitmapPixelChanges oldValues = ApplyToLayer(layer, modifiedLayer).PixelChanges;
BitmapChanged?.Invoke(this, new BitmapChangedEventArgs(
modifiedLayer.PixelChanges,
oldValues,
modifiedLayer.LayerGuid));
Manager.ActiveDocument.GeneratePreviewLayer();
}
}
previewLayerChanges = null;
}
public BitmapPixelChanges Draw(Coordinates startingCoords, Coordinates latestCords, Color color, int toolSize)
{
LineTool line = new LineTool();
return(BitmapPixelChanges.FromSingleColoredArray(
line.CreateLine(startingCoords, latestCords, toolSize), color));
}
public LayerChange[] Erase(Layer layer, Coordinates[] coordinates, int toolSize)
{
Coordinates startingCords = coordinates.Length > 1 ? coordinates[1] : coordinates[0];
BitmapPixelChanges pixels = pen.Draw(startingCords, coordinates[0], System.Windows.Media.Colors.Transparent, toolSize);
return(Only(pixels, layer));
}
public BitmapPixelChanges ChangeBrightness(Layer layer, Coordinates coordinates, int toolSize,
float correctionFactor)
{
DoubleCords centeredCoords = CoordinatesCalculator.CalculateThicknessCenter(coordinates, toolSize);
Coordinates[] rectangleCoordinates = CoordinatesCalculator.RectangleToCoordinates(centeredCoords.Coords1.X,
centeredCoords.Coords1.Y,
centeredCoords.Coords2.X, centeredCoords.Coords2.Y);
BitmapPixelChanges changes = new BitmapPixelChanges(new Dictionary <Coordinates, Color>());
for (int i = 0; i < rectangleCoordinates.Length; i++)
{
if (Mode == BrightnessMode.Default)
{
if (_pixelsVisited.Contains(rectangleCoordinates[i]))
{
continue;
}
_pixelsVisited.Add(rectangleCoordinates[i]);
}
Color pixel = layer.GetPixelWithOffset(rectangleCoordinates[i].X, rectangleCoordinates[i].Y);
Color newColor = ExColor.ChangeColorBrightness(Color.FromArgb(pixel.A, pixel.R, pixel.G, pixel.B),
correctionFactor);
changes.ChangedPixels.Add(new Coordinates(rectangleCoordinates[i].X, rectangleCoordinates[i].Y),
newColor);
}
return(changes);
}
public override void AfterAddedUndo(UndoManager undoManager)
{
if (currentSelection != null && currentSelection.Length > 0)
{
Change changes = undoManager.UndoStack.Peek();
// Inject to default undo system change custom changes made by this tool
foreach (var item in startPixelColors)
{
BitmapPixelChanges beforeMovePixels = BitmapPixelChanges.FromArrays(startSelection, item.Value);
BitmapPixelChanges afterMovePixels = BitmapPixelChanges.FromArrays(currentSelection, endPixelColors[item.Key]);
Guid layerGuid = item.Key;
var oldValue = (LayerChange[])changes.OldValue;
if (oldValue.Any(x => x.LayerGuid == layerGuid))
{
var layer = oldValue.First(x => x.LayerGuid == layerGuid);
layer.PixelChanges.ChangedPixels.AddRangeOverride(afterMovePixels.ChangedPixels);
layer.PixelChanges.ChangedPixels
.AddRangeOverride(beforeMovePixels.ChangedPixels);
((LayerChange[])changes.NewValue).First(x => x.LayerGuid == layerGuid).PixelChanges.ChangedPixels
.AddRangeNewOnly(BitmapPixelChanges
.FromSingleColoredArray(startSelection, System.Windows.Media.Colors.Transparent)
.ChangedPixels);
}
}
}
}
public BitmapChangedEventArgs(BitmapPixelChanges pixelsChanged, BitmapPixelChanges oldPixelsValues,
int changedLayerIndex)
{
PixelsChanged = pixelsChanged;
OldPixelsValues = oldPixelsValues;
ChangedLayerIndex = changedLayerIndex;
}
public void TestThatGetPixelsForSelectionReturnsCorrectPixels()
{
Coordinates[] cords = { new Coordinates(0, 0),
new Coordinates(1, 1),new Coordinates(0, 1), new Coordinates(1, 0) };
Layer[] layers = { new Layer("test", 2, 2), new Layer("test2", 2, 2) };
layers[0].SetPixels(BitmapPixelChanges.FromSingleColoredArray(new [] { cords[0] }, Colors.Green));
layers[1].SetPixels(BitmapPixelChanges.FromSingleColoredArray(new [] { cords[1] }, Colors.Red));
var output = BitmapUtils.GetPixelsForSelection(layers, cords);
List <Color> colors = new List <Color>();
foreach (var layerColor in output.ToArray())
{
foreach (var color in layerColor.Value)
{
colors.Add(color);
}
}
Assert.Single(colors.Where(x => x == Colors.Green));
Assert.Single(colors.Where(x => x == Colors.Red));
Assert.Equal(6, colors.Count(x => x.A == 0)); //6 because layer is 4 pixels,
//2 * 4 = 8, 2 other color pixels, so 8 - 2 = 6
}
public void TestThatFromSingleColoredArrayCreatesCorrectArray()
{
Coordinates[] cords = { new Coordinates(0, 0), new Coordinates(1, 0), new Coordinates(3, 2) };
BitmapPixelChanges bmpChanges = BitmapPixelChanges.FromSingleColoredArray(cords, SKColors.Lime);
Assert.All(bmpChanges.ChangedPixels.Values, changeColor => Assert.Equal(SKColors.Lime, changeColor));
Assert.True(bmpChanges.WasBuiltAsSingleColored);
}
public override LayerChange[] Use(Layer layer, Coordinates[] coordinates, Color color)
{
var pixels =
BitmapPixelChanges.FromSingleColoredArray(
CreateLine(coordinates,
(int)Toolbar.GetSetting("ToolSize").Value, CapType.Square, CapType.Square), color);
return(Only(pixels, layer));
}
private BitmapPixelChanges RemoveTransparentPixels(BitmapPixelChanges pixels)
{
foreach (var item in pixels.ChangedPixels.Where(x => x.Value.A == 0).ToList())
{
pixels.ChangedPixels.Remove(item.Key);
}
return(pixels);
}
private static PixelChangesController CreateBasicController()
{
Coordinates[] cords = { new Coordinates(0, 0), new Coordinates(1, 1) };
PixelChangesController controller = new PixelChangesController();
controller.AddChanges(new LayerChange(
BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black), 0),
new LayerChange(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Transparent), 0));
return(controller);
}
public override LayerChange[] Use(Layer layer, List <Coordinates> coordinates, Color color)
{
int thickness = Toolbar.GetSetting <SizeSetting>("ToolSize").Value;
BitmapPixelChanges pixels =
BitmapPixelChanges.FromSingleColoredArray(CreateRectangle(coordinates, thickness), color);
if (Toolbar.GetSetting <BoolSetting>("Fill").Value)
{
Color fillColor = Toolbar.GetSetting <ColorSetting>("FillColor").Value;
pixels.ChangedPixels.AddRangeOverride(
BitmapPixelChanges.FromSingleColoredArray(
CalculateFillForRectangle(coordinates[^ 1], coordinates[0], thickness), fillColor)
private void ClearSelectedPixels(Layer layer, Coordinates[] selection)
{
Guid layerGuid = layer.LayerGuid;
if (!clearedPixels.ContainsKey(layerGuid) || clearedPixels[layerGuid] == false)
{
ViewModelMain.Current.BitmapManager.ActiveDocument.Layers.First(x => x == layer)
.SetPixels(BitmapPixelChanges.FromSingleColoredArray(selection, System.Windows.Media.Colors.Transparent));
clearedPixels[layerGuid] = true;
}
}
private BitmapPixelChanges ForestFire(Layer layer, Coordinates startingCoords, Color newColor)
{
List <Coordinates> changedCoords = new List <Coordinates>();
int width = ViewModelMain.Current.BitmapManager.ActiveDocument.Width;
int height = ViewModelMain.Current.BitmapManager.ActiveDocument.Height;
var visited = new bool[width, height];
Color colorToReplace = layer.GetPixelWithOffset(startingCoords.X, startingCoords.Y);
var stack = new Stack <Coordinates>();
stack.Push(new Coordinates(startingCoords.X, startingCoords.Y));
while (stack.Count > 0)
{
var cords = stack.Pop();
var relativeCords = layer.GetRelativePosition(cords);
if (cords.X < 0 || cords.X > width - 1)
{
continue;
}
if (cords.Y < 0 || cords.Y > height - 1)
{
continue;
}
if (visited[cords.X, cords.Y])
{
continue;
}
if (layer.GetPixel(relativeCords.X, relativeCords.Y) == newColor)
{
continue;
}
if (layer.GetPixel(relativeCords.X, relativeCords.Y) == colorToReplace)
{
changedCoords.Add(new Coordinates(cords.X, cords.Y));
visited[cords.X, cords.Y] = true;
stack.Push(new Coordinates(cords.X, cords.Y - 1));
stack.Push(new Coordinates(cords.X, cords.Y + 1));
stack.Push(new Coordinates(cords.X - 1, cords.Y));
stack.Push(new Coordinates(cords.X + 1, cords.Y));
}
}
return(BitmapPixelChanges.FromSingleColoredArray(changedCoords, newColor));
}
public void ApplyPixels(BitmapPixelChanges pixels, Color color)
{
LayerBitmap.Lock();
foreach (var coords in pixels.ChangedCoordinates)
{
LayerBitmap.SetPixel(Math.Clamp(coords.X, 0, Width - 1), Math.Clamp(coords.Y, 0, Height - 1),
color);
}
LayerBitmap.Unlock();
}
public override LayerChange[] Use(Layer layer, Coordinates[] coordinates, Color color)
{
Coordinates startingCords = coordinates.Length > 1 ? coordinates[1] : coordinates[0];
BitmapPixelChanges pixels = Draw(
startingCords,
coordinates[0],
color,
toolSizeSetting.Value,
pixelPerfectSetting.Value,
ViewModelMain.Current.BitmapManager.ActiveDocument.PreviewLayer);
return(Only(pixels, layer));
}
private static Tuple <Guid, PixelChangesController> CreateBasicController()
{
Coordinates[] cords = { new Coordinates(0, 0), new Coordinates(1, 1) };
PixelChangesController controller = new PixelChangesController();
Guid guid = Guid.NewGuid();
controller.AddChanges(
new LayerChange(
BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black), guid),
new LayerChange(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Transparent), guid));
return(new Tuple <Guid, PixelChangesController>(guid, controller));
}
public override LayerChange[] Use(Layer layer, List <Coordinates> coordinates, Color color)
{
Coordinates startingCords = coordinates.Count > 1 ? coordinates[1] : coordinates[0];
BitmapPixelChanges pixels = Draw(
startingCords,
coordinates[0],
color,
toolSizeSetting.Value,
pixelPerfectSetting.Value,
BitmapManager.ActiveDocument.PreviewLayer);
return(Only(pixels, layer));
}
public void TestThatFormArraysWorks()
{
Coordinates[] coordinatesArray = { new Coordinates(0, 0), new Coordinates(2, 3), new Coordinates(5, 5) };
Color[] colorsArray = { Colors.Red, Colors.Green, Colors.Blue };
var result = BitmapPixelChanges.FromArrays(coordinatesArray, colorsArray);
for (int i = 0; i < coordinatesArray.Length; i++)
{
var cords = coordinatesArray[i];
Assert.Equal(colorsArray[i], result.ChangedPixels[cords]);
}
Assert.False(result.WasBuiltAsSingleColored);
}
public BitmapPixelChanges MoveSelection(Layer layer, Coordinates[] mouseMove)
{
Coordinates end = mouseMove[0];
currentSelection = TranslateSelection(end);
if (updateViewModelSelection)
{
ViewModelMain.Current.BitmapManager.ActiveDocument.ActiveSelection.SetSelection(currentSelection, SelectionType.New);
}
lastMouseMove = end;
return(BitmapPixelChanges.FromArrays(currentSelection, startPixelColors[layer.LayerGuid]));
}
public void TestThatCombineLayersReturnsCorrectBitmapWithSamePixels()
{
Coordinates[] cords = { new Coordinates(0, 0) };
Layer[] layers = { new Layer("test", 2, 2), new Layer("test2", 2, 2) };
layers[0].SetPixels(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Green));
layers[1].SetPixels(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Red));
var outputBitmap = BitmapUtils.CombineLayers(layers, 2, 2);
Assert.Equal(Colors.Red, outputBitmap.GetPixel(0, 0));
}
public void TestThatSetPixelsSetsPixels() //This also tests if Dynamic Resize works
{
Coordinates[] pixels = { new Coordinates(4, 2), new Coordinates(0, 0), new Coordinates(15, 2), };
Layer layer = new Layer("layer");
layer.SetPixels(BitmapPixelChanges.FromSingleColoredArray(pixels, Colors.Green));
for (int i = 0; i < pixels.Length; i++)
{
Assert.Equal(Colors.Green, layer.GetPixelWithOffset(pixels[i].X, pixels[i].Y));
}
}
public void TestThatCombineLayersReturnsCorrectBitmap()
{
Coordinates[] cords = { new Coordinates(0, 0), new Coordinates(1, 1) };
Layer[] layers = { new Layer("test", 2, 2), new Layer("test2", 2, 2) };
layers[0].SetPixels(BitmapPixelChanges.FromSingleColoredArray(new[] { cords[0] }, Colors.Green));
layers[1].SetPixels(BitmapPixelChanges.FromSingleColoredArray(new[] { cords[1] }, Colors.Red));
WriteableBitmap outputBitmap = BitmapUtils.CombineLayers(2, 2, layers);
Assert.Equal(Colors.Green, outputBitmap.GetPixel(0, 0));
Assert.Equal(Colors.Red, outputBitmap.GetPixel(1, 1));
}
private void MovePixelsToCheck(BitmapPixelChanges changes)
{
if (changes.ChangedPixels[lastChangedPixels[1]].A != 0)
{
lastChangedPixels[0] = lastChangedPixels[1];
lastChangedPixels[1] = lastChangedPixels[2];
changedPixelsindex = 2;
}
else
{
lastChangedPixels[0] = lastChangedPixels[2];
changedPixelsindex = 1;
}
}
private BitmapPixelChanges ApplyPixelPerfectToPixels(Coordinates p1, Coordinates p2, Coordinates p3, Color color, int toolSize)
{
if (Math.Abs(p3.X - p1.X) == 1 && Math.Abs(p3.Y - p1.Y) == 1 && !confirmedPixels.Contains(p2))
{
var changes = BitmapPixelChanges.FromSingleColoredArray(GetThickShape(new Coordinates[] { p1, p3 }, toolSize), color);
changes.ChangedPixels.AddRangeNewOnly(
BitmapPixelChanges.FromSingleColoredArray(
GetThickShape(new[] { p2 }, toolSize),
System.Windows.Media.Colors.Transparent).ChangedPixels);
return(changes);
}
return(BitmapPixelChanges.FromSingleColoredArray(GetThickShape(new Coordinates[] { p2, p3 }.Distinct(), toolSize), color));
}
public void TestThatAddChangesAddsAsNewChange()
{
var controller = CreateBasicController();
Coordinates[] cords = { new Coordinates(5, 3), new Coordinates(7, 2) };
controller.AddChanges(new LayerChange(
BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black), 1),
new LayerChange(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Transparent), 1));
var changes = controller.PopChanges();
Assert.Equal(2, changes.Length);
}
public void TestThatCombineCombineOverrideCombinesValues()
{
Coordinates[] cords1 = { new Coordinates(0, 0), new Coordinates(1, 0), new Coordinates(3, 2) };
Coordinates[] cords2 = { new Coordinates(3, 2), new Coordinates(0, 0), new Coordinates(5, 5) };
BitmapPixelChanges changes = BitmapPixelChanges.FromSingleColoredArray(cords1, Colors.Green);
BitmapPixelChanges changes2 = BitmapPixelChanges.FromSingleColoredArray(cords2, Colors.Red);
var output = BitmapPixelChanges.CombineOverride(new[] { changes, changes2 });
Assert.Equal(4, output.ChangedPixels.Count);
Assert.Equal(Colors.Red, output.ChangedPixels[new Coordinates(3, 2)]);
Assert.Equal(Colors.Red, output.ChangedPixels[new Coordinates(0, 0)]);
Assert.Equal(Colors.Green, output.ChangedPixels[new Coordinates(1, 0)]);
}
public void TestThatAddChangesAddsToExistingChange()
{
Coordinates[] cords2 = { new Coordinates(2, 2), new Coordinates(5, 5) };
var controller = CreateBasicController();
controller.AddChanges(new LayerChange(
BitmapPixelChanges.FromSingleColoredArray(cords2, Colors.Black), 0),
new LayerChange(BitmapPixelChanges.FromSingleColoredArray(cords2, Colors.Transparent), 0));
var changes = controller.PopChanges();
Assert.Single(changes);
Assert.Equal(4, changes[0].Item1.PixelChanges.ChangedPixels.Count);
Assert.Equal(4, changes[0].Item2.PixelChanges.ChangedPixels.Count);
}
public void TestThatBitmapOperationsUtilityDeletesPixels()
{
BitmapOperationsUtility util = new BitmapOperationsUtility(new BitmapManager());
Layer testLayer = new Layer("test layer", 10, 10);
Coordinates[] cords = { new Coordinates(0, 0), new Coordinates(1, 1) };
BitmapPixelChanges pixels = BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black);
testLayer.SetPixels(pixels);
util.DeletePixels(new [] { testLayer }, cords);
Assert.Equal(0, testLayer.GetPixel(0, 0).A);
Assert.Equal(0, testLayer.GetPixel(1, 1).A);
}
public void TestThatAddChangesAddsAsNewChange()
{
var data = CreateBasicController();
PixelChangesController controller = data.Item2;
Coordinates[] cords = { new Coordinates(5, 3), new Coordinates(7, 2) };
Guid guid = Guid.NewGuid();
controller.AddChanges(
new LayerChange(
BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black), guid),
new LayerChange(BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Transparent), guid));
System.Tuple <LayerChange, LayerChange>[] changes = controller.PopChanges();
Assert.Equal(2, changes.Length);
}
