public IEnumerable<MouseDragAction> GetDrawInstructions(List<ColorSpot> colorPalette, IDictionary<string, string> options = null, IBrushChanger brushChanger = null)
{
if (!colorPalette.Any())
{
throw new ArgumentException("I need some colors. Give me some colors. Thanks!");
}
var output = new List<MouseDragAction>();
var colorPixels = colorPalette.ToDictionary(colorSpot => colorSpot, colorSpot => new List<Point>());
using (var bitmap = new Bitmap(_bitmapPath))
{
bitmap.LoopThroughPixels((point, color) =>
{
var selectedColor = colorPalette.OrderBy(c => c.Color.DifferenceTo(color)).FirstOrDefault();
if (selectedColor == null || !colorPixels.ContainsKey(selectedColor) ||
selectedColor.Color.DifferenceTo(Color.White) == 0)
{
return;
}
colorPixels[selectedColor].Add(point);
});
}
foreach (var colorPixel in colorPixels.Where(colorPixel => colorPixel.Value.Any()))
{
output.Add(new MouseDragAction(new List<Point> { colorPixel.Key.Point }, true, colorPixel.Key.Color));
var actions = colorPixel.Value.Select(point => new MouseDragAction(new List<Point> { point })).ToList();
if (options.GetBoolValueOrDefault("MixPoints", false))
{
actions = actions.Shuffle().ToList();
}
output.AddRange(actions);
}
return output.ToArray();
}
public IEnumerable<MouseDragAction> GetDrawInstructions(List<ColorSpot> colorPalette, IDictionary<string, string> settings = null, IBrushChanger brushChanger = null)
{
if (colorPalette.All(c => c.Color.R + c.Color.G + c.Color.B != 0))
{
throw new ArgumentException("I need a black color in the palette!");
}
var selectedColor = colorPalette.First(c => c.Color.R + c.Color.G + c.Color.B == 0);
if (settings == null)
{
settings = new Dictionary<string, string>();
}
var args = new PixelAcceptanceArgs
{
MaxLight = settings.GetIntValueOrDefault("MaxLight", 700),
BlueEnabled = settings.GetBoolValueOrDefault("BlueEnabled", false),
BlueMax = settings.GetIntValueOrDefault("BlueMax", 255),
BlueMin = settings.GetIntValueOrDefault("BlueMin", 0),
GreenEnabled = settings.GetBoolValueOrDefault("GreenEnabled", false),
GreenMax = settings.GetIntValueOrDefault("GreenMax", 255),
GreenMin = settings.GetIntValueOrDefault("GreenMin", 0),
RedEnabled = settings.GetBoolValueOrDefault("RedEnabled", false),
RedMin = settings.GetIntValueOrDefault("RedMin", 0),
RedMax = settings.GetIntValueOrDefault("RedMax", 255)
};
if (String.IsNullOrEmpty(_bitmapPath))
{
return null;
}
var output = new List<MouseDragAction>
{
new MouseDragAction(new List<Point> { selectedColor.Point }, true, selectedColor.Color)
};
using (var bitmap = new Bitmap(_bitmapPath))
{
var currentAction = new List<Point>();
bitmap.LoopThroughPixels((point, color) =>
{
if (!pixelFits(color.R, color.G, color.B, args))
{
return;
}
if (currentAction.Any() && !currentAction.Last().IsANeighborOf(point))
{
output.Add(new MouseDragAction(currentAction));
currentAction = new List<Point>();
}
currentAction.Add(point);
});
}
return output.ToArray();
}
public IEnumerable<MouseDragAction> GetDrawInstructions(List<ColorSpot> color, IDictionary<string, string> settings = null, IBrushChanger brushChanger = null)
{
List<ColorSpot> knownColors = color.ToList();
int ignoredColor;
try
{
ignoredColor = knownColors.IndexOf(knownColors.First(x => x.IsBackgroundColor));
}
catch (Exception)
{
throw new Exception("I need a background color!!");
}
// prevent drawing of single pixels etc
int colorGroupMinSize = settings.GetIntValueOrDefault("MinimumStrokeSize", 15);
var output = new List<MouseDragAction>();
using (var bitmap = new Bitmap(this._bitmapPath))
{
this._bitmapHeight = bitmap.Height;
this._bitmapWidth = bitmap.Width;
var rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
this._colors = new int[bitmap.Width,bitmap.Height];
this._colorsProcessed = new bool[bitmap.Width,bitmap.Height];
//_pixels = new KeyValuePair<Point, PixelMeta>[bitmap.Width * bitmap.Height];
BitmapData bmpData = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);
IntPtr ptr = bmpData.Scan0;
int bytes = bmpData.Stride * bitmap.Height;
var rgbValues = new byte[bytes];
Marshal.Copy(ptr, rgbValues, 0, bytes);
for (int x = 0; x < bitmap.Width; x++)
{
for (int y = 0; y < bitmap.Height; y++)
{
int position = (y * bmpData.Stride) + (x * 3);
int blue = rgbValues[position];
int green = rgbValues[position + 1];
int red = rgbValues[position + 2];
Color currentColor = Color.FromArgb(red, green, blue);
ColorSpot closestColor = knownColors.OrderBy(c => c.Color.DifferenceTo(currentColor)).FirstOrDefault();
this._colors[x, y] = knownColors.IndexOf(closestColor);
}
}
bitmap.UnlockBits(bmpData);
}
var colorGroups = new List<List<Point>>();
for (int x = 0; x < this._bitmapWidth; x++)
{
for (int y = 0; y < this._bitmapHeight; y++)
{
if (this._colors[x, y] != ignoredColor && !this._colorsProcessed[x, y])
{
colorGroups.AddRange(this.GetNeighboringColors(x, y));
}
}
}
int? lastColorIndex = null;
IOrderedEnumerable<List<Point>> colorGroupsOrderedByColor =
colorGroups.Where(x => x.Count >= colorGroupMinSize).OrderBy(x => this._colors[x.First().X, x.First().Y]);
foreach (var colorGroup in colorGroupsOrderedByColor)
{
var colorOutput = new List<MouseDragAction>();
int currentColorIndex = this._colors[colorGroup.First().X, colorGroup.First().Y];
if (!lastColorIndex.HasValue || lastColorIndex.Value != currentColorIndex)
{
lastColorIndex = currentColorIndex;
ColorSpot currentColor = knownColors[this._colors[colorGroup.First().X, colorGroup.First().Y]];
var colorChangeAction = new MouseDragAction(new List<Point> { currentColor.Point }, true, currentColor.Color);
colorOutput.Add(colorChangeAction);
}
var ma = new MouseDragAction(colorGroup.Select(x => new Point(x.X, x.Y)).ToList());
colorOutput.Add(ma);
output.AddRange(colorOutput);
}
return output;
}
public IEnumerable<MouseDragAction> GetDrawInstructions(List<ColorSpot> PaletteColorSpots, IDictionary<string, string> settings = null, IBrushChanger brushChanger = null)
{
int ignoreColorIndex =
PaletteColorSpots.IndexOf(PaletteColorSpots.FirstOrDefault(x => x.Color.Name == IgnoreColor));
if (!PaletteColorSpots.Any())
{
PaletteColorSpots = new List<ColorSpot> {new ColorSpot {Color = Color.Black, Point = Point.Empty}};
}
int bitmapHeight;
int bitmapWidth;
var output = new List<MouseDragAction>();
using (var bitmap = new Bitmap(_bitmapPath))
{
bitmapHeight = bitmap.Height;
bitmapWidth = bitmap.Width;
_colors = new int[bitmapWidth,bitmapHeight];
var rect = new Rectangle(0, 0, bitmapWidth, bitmapHeight);
BitmapData bmpData = bitmap.LockBits(rect, ImageLockMode.ReadOnly, bitmap.PixelFormat);
IntPtr ptr = bmpData.Scan0;
int bytes = bmpData.Stride*bitmapHeight;
var rgbValues = new byte[bytes];
Marshal.Copy(ptr, rgbValues, 0, bytes);
for (int x = 0; x < bitmapWidth; x++)
{
for (int y = 0; y < bitmapHeight; y++)
{
int position = (y*bmpData.Stride) + (x*3);
int blue = rgbValues[position];
int green = rgbValues[position + 1];
int red = rgbValues[position + 2];
Color currentColor = Color.FromArgb(red, green, blue);
ColorSpot matchingColor =
PaletteColorSpots.OrderBy(c => c.Color.DifferenceTo(currentColor)).First();
_colors[x, y] = PaletteColorSpots.IndexOf(matchingColor);
}
}
bitmap.UnlockBits(bmpData);
}
int colorCount = PaletteColorSpots.Count;
var strokesForEachColor = new List<MouseDragAction>[colorCount];
for (int i = 0; i < colorCount; i++)
{
ColorSpot paletteColorSpot = PaletteColorSpots[i];
strokesForEachColor[i] = new List<MouseDragAction>
{new MouseDragAction(new List<Point> {paletteColorSpot.Point}, true, paletteColorSpot.Color)};
}
for (int x = 0; x < bitmapWidth; x++)
{
for (int y = 0; y < bitmapHeight; y++)
{
int currentPixelColorIndex = _colors[x, y];
if (currentPixelColorIndex == ignoreColorIndex)
{
continue;
}
var currentPixelPoint = new Point(x, y);
List<MouseDragAction> strokesForCurrentColor = strokesForEachColor[currentPixelColorIndex];
bool found = false;
foreach (MouseDragAction stroke in strokesForCurrentColor)
{
if (stroke.DiscardOffset)
{
continue;
}
Point lastPoint = stroke.Points[stroke.Points.Count - 1];
if (PointsAreNeighbors(lastPoint.X, lastPoint.Y, x, y))
{
stroke.PushPoint(new Point(x, y));
found = true;
break;
}
Point firstPoint = stroke.Points[0];
if (PointsAreNeighbors(firstPoint.X, firstPoint.Y, x, y))
{
stroke.AddPoint(new Point(x, y));
found = true;
break;
}
}
if (found)
{
continue;
}
strokesForEachColor[currentPixelColorIndex].Add(
new MouseDragAction(new List<Point> {currentPixelPoint}));
}
}
foreach (var mouseDragActions in strokesForEachColor)
{
output.AddRange(mouseDragActions);
}
return output;
}
