public void Mask(FastBitmap MaskImage)
{
for (int y = 0; y < MaskImage.Height; y++)
{
for (int x = 0; x < MaskImage.Width; x++)
{
if (MaskImage.GetPixel(x, y).Name != "ffffffff")
{
SetPixel(x, y, Color.Transparent);
}
}
}
}
/// <summary>
/// Rotiert einen bestimmten Bereich einer Bitmap nach links und
/// </summary>
/// <param name="InitHeight">Die Y Höhe ab der die Zeilen verschoben werden</param>
/// <param name="Bandwidth">Wie viele Zeilen verschoben werden sollen</param>
/// <param name="Moving">Um wie viele Pixel die Bitmap nach links verschoben werden soll</param>
/// <param name="ImageToOverwrite">Die Bitmap die verschoben werden soll</param>
/// <param name="Direction">Die Richtung in die sich der ausgewählte Teil bewegen soll</param>
/// <returns>Die neue Bitmap mit der entsprechend verschobenen Linien</returns>
public static Bitmap MoveLine(int InitHeight, int Bandwidth, int Moving, Bitmap ImageToOverwrite, Orientation Direction)
{
FastBitmap BM = new FastBitmap(ImageToOverwrite);
if (Moving == 0 || Bandwidth == 0) // \ Wenn der zu verschiebende Streifen keine Breite hat
{
return(BM); // / oder um keine Pixel verschoben werden soll, kann das Originalbild zurückgegeben werden.
}
if (Moving < 0) // \
{ // | Wenn um eine negative Anzahl von Pixel verschoben werden soll,
Moving = Math.Abs(Moving); // | dann wird die Richtung einfach umgekehrt und die Pixel positive.
Direction = Invert[Direction]; // |
} // /
// Left & Right
if ((int)Direction % 2 == 1)
{
if (Moving == BM.Width)
{
return(BM);
}
Moving = Moving % BM.Width;
if (Direction == Orientation.Right)
{
Moving = BM.Width - Moving;
}
//Erstellt ein 2D Farben Array, das Entsprechend der zu verschiebenden Breite hoch und ensprechend der Bitmap breit ist.
Color[,] Arr = new Color[Bandwidth, BM.Width];
//Die Schleife wird durchlaufen und schreibt die einzelnen Pixel in das Array.
//Sie beginnt an dem angegeben Beginwert und endet nachdem der Beginwert + Breite überschritten sind, oder das Ende des Bildes erreicht wurde.
for (int j = InitHeight; j < Bandwidth + InitHeight && j < BM.Height; j++)
{
//Verschachtelte Schleife, damit die ganze Zeile bearbeitet wird.
for (int i = 0; i < BM.Width; i++)
{
Arr[j - InitHeight, i] = BM.GetPixel(i, j); //Schreibt die Pixel farben an der Momentanen Stelle ins Array.
}
}
//Für das Array muss noch der BeginWert vom Zähler abgezogen werden.
FastBitmap N_BM = new FastBitmap(BM); //Erstellt eine Copie der Bitmap
//Die Schleife ist gleich aufgesetzt wie die Vorherige. Die verschachtelte Schleife auch
for (int j = InitHeight; j < Bandwidth + InitHeight && j < BM.Height; j++)
{
for (int i = 0; i < N_BM.Width; i++)
{
//Färbt die Pixel der neuen Bitmap ein. Die erste Variable muss wieder der Beginwert subtrahiert werden.
//Für die zweite Variable, wird der Wert, um den der Bereich verschoben werden soll addiert, und mit der Breite "Modolosiert"
N_BM.SetPixel(i, j, Arr[j - InitHeight, (i + Moving) % N_BM.Width]);
}
}
return(N_BM);
}
//Default: Hoch
else
{
if (Moving == BM.Height)
{
return(BM);
}
Moving = Moving % BM.Height;
if (Direction == Orientation.Down)
{
Moving = BM.Height - Moving;
}
//Erstellt ein 2D Farben Array, das Entsprechend der zu verschiebenden Breite hoch und ensprechend der Bitmap breit ist.
Color[,] Arr = new Color[Bandwidth, BM.Width];
//Die Schleife wird durchlaufen und schreibt die einzelnen Pixel in das Array.
//Sie beginnt an dem angegeben Beginwert und endet nachdem der Beginwert + Breite überschritten sind, oder das Ende des Bildes erreicht wurde.
for (int j = InitHeight + Moving, k = 0; k < Bandwidth; j++, k++)
{
//Verschachtelte Schleife, damit die ganze Zeile bearbeitet wird.
for (int i = 0; i < BM.Width; i++)
{
Arr[k, i] = BM.GetPixel(i, j % BM.Height); //Schreibt die Pixel farben an der Momentanen Stelle ins Array.
}
}
//Für das Array muss noch der BeginWert vom Zähler abgezogen werden.
FastBitmap N_BM = new FastBitmap(BM); //Erstellt eine Copie der Bitmap
//Die Schleife ist gleich aufgesetzt wie die Vorherige. Die verschachtelte Schleife auch
for (int j = InitHeight; j < Bandwidth + InitHeight && j < BM.Height; j++)
{
for (int i = 0; i < N_BM.Width; i++)
{
//Färbt die Pixel der neuen Bitmap ein. Die erste Variable muss wieder der Beginwert subtrahiert werden.
//Für die zweite Variable, wird der Wert, um den der Bereich verschoben werden soll addiert, und mit der Breite "Modolosiert"
N_BM.SetPixel(i, j, Arr[j - InitHeight, i]);
}
}
return(N_BM);
}
}
private void RunPropperImageFilter()
{
Bitmap Mask = new Bitmap(pcbOriginal.Image, new Size(256, HDMA.Scanlines));
float Value = (float)trbBlackWhite.Value / 10f;
switch ((ImageType)cmbImage_Type.SelectedItem)
{
case ImageType.Outline:
FastBitmap OutlineMask = new FastBitmap(Mask);
OutlineStart start = 0;
if (chbImage_TopLeft.Checked)
{
start |= OutlineStart.TopLeft;
}
if (chbImage_TopRight.Checked)
{
start |= OutlineStart.TopRight;
}
if (chbImage_BottomLeft.Checked)
{
start |= OutlineStart.BottomLeft;
}
if (chbImage_BottomRight.Checked)
{
start |= OutlineStart.BottomRight;
}
OutlineMask.Outline(start, trbBlackWhite.Value);
Value = 1f;
Mask = OutlineMask;
goto case ImageType.Transparent;
case ImageType.Transparent:
FastBitmap FastMask = new FastBitmap(Mask);
FastBitmap BlackBase = new FastBitmap(EffectClasses.BitmapEffects.FromColor(Color.Black, 256, 224));
for (int y = 0; y < 224; y++)
{
for (int x = 0; x < 256; x++)
{
if (FastMask.GetPixel(x, y).A <= (255 - (Value * 255f)))
{
BlackBase.SetPixel(x, y, Color.White);
}
}
}
if (chbImage_Invert.Checked)
{
pcbAfter.Image = ((Bitmap)BlackBase).Invert();
}
else
{
pcbAfter.Image = ((Bitmap)BlackBase);
}
break;
case ImageType.Color:
if (chbImage_Invert.Checked)
{
pcbAfter.Image = Mask.BlackWhite(Value).Invert();
}
else
{
pcbAfter.Image = Mask.BlackWhite(Value);
}
break;
}
UpdateMulti();
}