private async void CreateOpacityMap()
{
DisableControls(true);
opacityMapInfoLabel.Visible = true;
try
{
string filePath = filePathTextBox.Text;
string resultDirPath = GlobalData.ResultFileDirectory;
FileDataManager.CreateDirectoryIfNotExists(resultDirPath);
ArgbProcessor argbProc = new ArgbProcessor(filePath);
PacketObjMsg fileCreationPacket = await argbProc.CreateOpacityMapAndNonTransparentImageTaskStart(resultDirPath);
bool success = (bool)fileCreationPacket.Obj;
if (!String.IsNullOrEmpty(fileCreationPacket.Msg))
{
MessageBox.Show(fileCreationPacket.Msg);
}
if (success)
{
MessageBox.Show("Pomyślnie utworzono pliki!");
Process.Start(resultDirPath);
}
}
catch (Exception exception)
{
MessageBox.Show($"Błąd tworzenia mapy przezroczystości: {exception.Message}");
}
opacityMapInfoLabel.Visible = false;
DisableControls(false);
}
public static PacketObjMsg CreateGrayScaleImage(Bitmap sourceBitmap)
{
PacketObjMsg packet = new PacketObjMsg();
Bitmap resultBitmap = (Bitmap)sourceBitmap.Clone();
string msg = "";
try
{
int bmpWidth = sourceBitmap.Width;
int bmpHeight = sourceBitmap.Height;
Color pixelColor;
for (int y = 0; y < bmpHeight; y++)
{
for (int x = 0; x < bmpWidth; x++)
{
pixelColor = sourceBitmap.GetPixel(x, y);
int alpha = pixelColor.A;
int red = pixelColor.R;
int green = pixelColor.G;
int blue = pixelColor.B;
int avg = (red + green + blue) / 3;
decimal percentAlpha = DataProcessor.CalculatePercent(255M, Convert.ToDecimal(alpha));
int avgAlpha = Convert.ToInt32(avg * (percentAlpha / 100));
//Console.WriteLine($"% [{percentAlpha}] avg.A [{avgAlpha}]");
resultBitmap.SetPixel(x, y, Color.FromArgb(255, avgAlpha, avgAlpha, avgAlpha));
}
}
}
catch (Exception exception)
{
msg = $"Błąd tworzenia mapy w skali szarości: {exception.Message}";
}
packet.Obj = resultBitmap;
packet.Msg = msg;
return(packet);
}
public async void GenerateTexture(bool boundsChecker, int areaId = -1) //-1 dla wszystkich
{
if (this.loadingInProgress)
{
return;
}
this.loadingInProgress = true;
editPanelMainSplitContainer.Panel2.Enabled = false;
try
{
BitmapAreaProcessor bitmapProc = this.bitmapAreaInfo;
if (bitmapProc == null)
{
throw new Exception($"Obiekt przetwarzania mapy bitowej jest NULL!");
}
List <int> areaIdsList = (areaId == -1 ? bitmapProc.GetAllAreaIds() : new List <int>()
{
areaId
});
int bmpWidth = this.sourceBitmap.Width;
int bmpHeight = this.sourceBitmap.Height;
if (bmpWidth < 1 || bmpHeight < 1)
{
throw new Exception($"odczytano błędne wymiary bitmapy źródłowej [{bmpWidth},{bmpHeight}]!");
}
#region Wstępne wypełnianie bitmapy rezultatu - przezroczystość
//WSTĘPNE WYPEŁNIANIE BITMAPY REZULTATU
UpdateInfo($"Wstępne tworzenie bitmapy rezultatu");
PacketObjMsg transparentBmpPacket = await bitmapProc.GenerateTransparentBitmapTaskStart(bmpWidth, bmpHeight);
this.resultBitmap = (Bitmap)transparentBmpPacket.Obj;
if (!String.IsNullOrEmpty(transparentBmpPacket.Msg))
{
MessageBox.Show(transparentBmpPacket.Msg);
}
#endregion
foreach (int areaIdFromList in areaIdsList)
{
UpdateInfo($"Generowanie tekstury dla ID strefy [{areaIdFromList}]");
#region Ograniczenia strefy
//POBIERANIE OGRANICZEŃ STREFY
PacketObjMsg boundingsPacket = await bitmapProc.GetAreaBoundingsTaskStart(areaIdFromList);
AreaBoundings areaBoundings = (AreaBoundings)boundingsPacket.Obj;
if (!String.IsNullOrEmpty(boundingsPacket.Msg))
{
MessageBox.Show(boundingsPacket.Msg);
}
int areaMinX = areaBoundings.BoundsX.X;
int areaMaxX = areaBoundings.BoundsX.Y;
int areaMinY = areaBoundings.BoundsY.X;
int areaMaxY = areaBoundings.BoundsY.Y;
//obiekt, który będzie przechowywał poszerzone ograniczenia strefy w przypadku, w którym rysowanie wyjdzie poza ograniczenia (np. losowe punkty krzywej)
AreaBoundings processingAreaBoundings = areaBoundings.Copy();
#endregion
#region Test ograniczeń stref
//TEST
//Brush brush = new SolidBrush(Color.FromArgb(255, 255, 0, 0));
//using (Graphics gr = Graphics.FromImage(this.resultBitmap))
//{
// gr.FillRectangle(brush, areaMinX, areaMinY, (areaMaxX - areaMinX), (areaMaxY - areaMinY));
//}
#endregion
#region Ustawienia użytkownika
//USTAWIENIA UŻYTKOWNIKA DLA STREFY
AreaSettings userAreaSettings = this.uiController.GetAreaSettings(areaIdFromList);
AreaSettings.HairDrawingDirection hairDirection = userAreaSettings.Direction;
AreaSettings.HairCuttingSide hairCuttingSide = userAreaSettings.CuttingSide;
int drawingSteps = userAreaSettings.DrawingSteps;
int drawingIterations = userAreaSettings.DrawingIterations;
decimal iterationLossPercent = userAreaSettings.DrawingStepIterationLossPercent;
decimal bezierRandomRangePercent = userAreaSettings.BezierRandomRangePercent;
decimal bezierMarginPercent = userAreaSettings.BezierMarginPercent;
double cuttingRangePercent = Convert.ToDouble(userAreaSettings.CuttingRangePercent);
int bezierPointCount = userAreaSettings.MultiBezierPointCount;
if (userAreaSettings.BezierLineType == AreaSettings.BezierType.Quadratic || userAreaSettings.BezierLineType == AreaSettings.BezierType.QuadraticCp)
{
bezierPointCount = 3;
}
else
if (userAreaSettings.BezierLineType == AreaSettings.BezierType.Cubic)
{
bezierPointCount = 4;
}
Point3 backgroundRgbPalette = userAreaSettings.BackgroundRgbPalette;
Point3 foregroundRgbPalette = userAreaSettings.ForegroundRgbPalette;
bool hairMapDefinesOpacity = userAreaSettings.HairMapDefinesOpacity;
bool hairMapDefinesBrightness = userAreaSettings.HairMapDefinesBrightness;
#endregion
#region Dane wynikowe
//DANE WYNIKOWE
int iterationLossCount = Convert.ToInt32(drawingIterations * (iterationLossPercent / 100));
int currentIterationCount = drawingIterations;
int areaRangeX = areaMaxX - areaMinX;
int areaRangeY = areaMaxY - areaMinY;
#endregion
#region Dane przetwarzane
//DANE PRZETWARZANE W PĘTLACH
int currentAxisPosition;
double stepPercent;
double positionPercent;
double bezierPositionPercent;
PacketObjMsg lineRangePacket;
AreaLineRange lineRange;
int rangePointFrom;
int rangePointTo;
int resultPoint;
int boundRangeMin;
int boundRangeMax;
List <Point> hairBezierPoints = new List <Point>();
Point3 currentColorPalette = new Point3(0, 0, 0);
int currentR = 0;
int currentG = 0;
int currentB = 0;
bool cutOnStart = false;
bool cutOnEnd = false;
if (hairDirection == AreaSettings.HairDrawingDirection.TopToBottom || hairDirection == AreaSettings.HairDrawingDirection.LeftToRight)
{
cutOnStart = (hairCuttingSide == AreaSettings.HairCuttingSide.Beginning || hairCuttingSide == AreaSettings.HairCuttingSide.BothSides);
cutOnEnd = (hairCuttingSide == AreaSettings.HairCuttingSide.End || hairCuttingSide == AreaSettings.HairCuttingSide.BothSides);
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.BottomToTop || hairDirection == AreaSettings.HairDrawingDirection.RightToLeft)
{
cutOnEnd = (hairCuttingSide == AreaSettings.HairCuttingSide.Beginning || hairCuttingSide == AreaSettings.HairCuttingSide.BothSides);
cutOnStart = (hairCuttingSide == AreaSettings.HairCuttingSide.End || hairCuttingSide == AreaSettings.HairCuttingSide.BothSides);
}
#endregion
for (int drawingStep = 0; drawingStep < drawingSteps; drawingStep++) //PĘTLA TONÓW - KROKI
{
if (currentIterationCount <= 0)
{
break;
}
stepPercent = DataProcessor.CalculatePercent(Convert.ToDouble(drawingSteps - 1), Convert.ToDouble(drawingStep));
#region Kolor podstawowy (ton)
//WYODRĘBNIANIE PODSTAWOWEGO TONU KOLORU
currentR = Convert.ToInt32(DataProcessor.Lerp(backgroundRgbPalette.X, foregroundRgbPalette.X, (stepPercent / 100)));
currentG = Convert.ToInt32(DataProcessor.Lerp(backgroundRgbPalette.Y, foregroundRgbPalette.Y, (stepPercent / 100)));
currentB = Convert.ToInt32(DataProcessor.Lerp(backgroundRgbPalette.Z, foregroundRgbPalette.Z, (stepPercent / 100)));
currentR = DataProcessor.Clamp(0, 255, currentR);
currentG = DataProcessor.Clamp(0, 255, currentG);
currentB = DataProcessor.Clamp(0, 255, currentB);
currentColorPalette = new Point3(currentR, currentG, currentB);
#endregion
for (int drawingIteration = 0; drawingIteration < currentIterationCount; drawingIteration++) //PĘTLA ITERACJI - SZTUK WŁOSA
{
hairBezierPoints.Clear();
positionPercent = DataProcessor.CalculatePercent(Convert.ToDouble(currentIterationCount - 1), Convert.ToDouble(drawingIteration));
for (int bezierPointIteration = 0; bezierPointIteration < bezierPointCount; bezierPointIteration++)
{
bezierPositionPercent = DataProcessor.CalculatePercent(Convert.ToDouble(bezierPointCount - 1), Convert.ToDouble(bezierPointIteration));
if (hairDirection == AreaSettings.HairDrawingDirection.TopToBottom || hairDirection == AreaSettings.HairDrawingDirection.BottomToTop)
{
#region Pionowo
currentAxisPosition = Convert.ToInt32(DataProcessor.Lerp(areaMinY, areaMaxY, bezierPositionPercent / 100));
lineRangePacket = await this.bitmapAreaInfo.GetAreaLineRangeTaskStart
(
BitmapAreaProcessor.AreaAxis.Y,
currentAxisPosition,
areaIdFromList
);
lineRange = (AreaLineRange)lineRangePacket.Obj;
//POBIERANIE PUNKTÓW GRANICZNYCH DLA STREFY
rangePointFrom = lineRange.RangePointFrom;
rangePointTo = lineRange.RangePointTo;
//MODYFIKACJA O MARGINESY
rangePointFrom = Convert.ToInt32(rangePointFrom - (rangePointTo - rangePointFrom) * (bezierMarginPercent / 100));
rangePointTo = Convert.ToInt32(rangePointTo + (rangePointTo - rangePointFrom) * (bezierMarginPercent / 100));
if (rangePointFrom < 0)
{
rangePointFrom = 0;
}
if (rangePointTo > this.resultBitmap.Width - 1)
{
rangePointTo = this.resultBitmap.Width - 1;
}
//WSTĘPNE TWORZENIE PUNKTU WYNIKOWEGO
resultPoint = Convert.ToInt32(DataProcessor.Lerp(rangePointFrom, rangePointTo, positionPercent / 100));
//ZAKRES LOSOWANIA / LOSOWANIE PUNKTU
boundRangeMin = Convert.ToInt32(resultPoint - ((rangePointTo - rangePointFrom) * (bezierRandomRangePercent / 100)));
boundRangeMax = Convert.ToInt32(resultPoint + ((rangePointTo - rangePointFrom) * (bezierRandomRangePercent / 100)));
resultPoint = this.random.Next(boundRangeMin, boundRangeMax + 1);
resultPoint = DataProcessor.Clamp(0, this.resultBitmap.Width, resultPoint);
//PRZYPISYWANIE PUNKTU WYNIKOWEGO
hairBezierPoints.Add
(
new Point
(
resultPoint,
currentAxisPosition
)
);
#endregion
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.LeftToRight || hairDirection == AreaSettings.HairDrawingDirection.RightToLeft)
{
#region Poziomo
currentAxisPosition = Convert.ToInt32(DataProcessor.Lerp(areaMinX, areaMaxX, bezierPositionPercent / 100));
lineRangePacket = await this.bitmapAreaInfo.GetAreaLineRangeTaskStart
(
BitmapAreaProcessor.AreaAxis.X,
currentAxisPosition,
areaIdFromList
);
lineRange = (AreaLineRange)lineRangePacket.Obj;
//POBIERANIE PUNKTÓW GRANICZNYCH DLA STREFY
rangePointFrom = lineRange.RangePointFrom;
rangePointTo = lineRange.RangePointTo;
//MODYFIKACJA O MARGINESY
rangePointFrom = Convert.ToInt32(rangePointFrom - (rangePointTo - rangePointFrom) * (bezierMarginPercent / 100));
rangePointTo = Convert.ToInt32(rangePointTo + (rangePointTo - rangePointFrom) * (bezierMarginPercent / 100));
if (rangePointFrom < 0)
{
rangePointFrom = 0;
}
if (rangePointTo > this.resultBitmap.Height - 1)
{
rangePointTo = this.resultBitmap.Height - 1;
}
//WSTĘPNE TWORZENIE PUNKTU WYNIKOWEGO
resultPoint = Convert.ToInt32(DataProcessor.Lerp(rangePointFrom, rangePointTo, positionPercent / 100));
//ZAKRES LOSOWANIA / LOSOWANIE PUNKTU
boundRangeMin = Convert.ToInt32(resultPoint - ((rangePointTo - rangePointFrom) * (bezierRandomRangePercent / 100)));
boundRangeMax = Convert.ToInt32(resultPoint + ((rangePointTo - rangePointFrom) * (bezierRandomRangePercent / 100)));
resultPoint = this.random.Next(boundRangeMin, boundRangeMax + 1);
resultPoint = DataProcessor.Clamp(0, this.resultBitmap.Height, resultPoint);
//PRZYPISYWANIE PUNKTU WYNIKOWEGO
hairBezierPoints.Add
(
new Point
(
currentAxisPosition,
resultPoint
)
);
#endregion
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.Radial)
{
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.LinearX)
{
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.LinearY)
{
}
}
//RYSOWANIE
BitmapAreaProcessor.DrawBezierLineOnBitmap
(
hairBezierPoints,
this.resultBitmap,
(userAreaSettings.BezierLineType == AreaSettings.BezierType.QuadraticCp),
0.02,
currentColorPalette,
cutOnStart,
cutOnEnd,
cuttingRangePercent,
ref processingAreaBoundings
);
//POSZERZANIE GRANIC STREFY - DLA PRZETWARZANIA PRZEZROCZYSTOŚCI / POŁYSKU
//processingAreaBoundings.ExtendAreaBoundings(hairBezierPoints, this.resultBitmap.Width - 1, this.resultBitmap.Height - 1);
}
currentIterationCount -= iterationLossCount;
}
//PRZEZROCZYSTOŚĆ / POŁYSK
BitmapAreaProcessor.AreaAxis glossOpacAxis = BitmapAreaProcessor.AreaAxis.None;
if (hairDirection == AreaSettings.HairDrawingDirection.TopToBottom || hairDirection == AreaSettings.HairDrawingDirection.BottomToTop)
{
glossOpacAxis = BitmapAreaProcessor.AreaAxis.X;
}
else
if (hairDirection == AreaSettings.HairDrawingDirection.LeftToRight || hairDirection == AreaSettings.HairDrawingDirection.RightToLeft)
{
glossOpacAxis = BitmapAreaProcessor.AreaAxis.Y;
}
PacketObjMsg glossOpacityPacket = await bitmapProc.GenerateHairTexGlossinessAndOpacityTaskStart
(
processingAreaBoundings, //areaBoundings,
this.resultBitmap,
Color.FromArgb(255, backgroundRgbPalette.X, backgroundRgbPalette.Y, backgroundRgbPalette.Z),
hairMapDefinesBrightness,
hairMapDefinesOpacity,
//new double[] { Convert.ToDouble(bezierMarginPercent / 100), Convert.ToDouble(bezierRandomRangePercent / 100) },
//glossOpacAxis
boundsChecker
);
this.resultBitmap = (Bitmap)glossOpacityPacket.Obj;
if (!String.IsNullOrEmpty(glossOpacityPacket.Msg))
{
MessageBox.Show(glossOpacityPacket.Msg);
}
}
//WYŚWIETLANIE OBRAZU REZULTATU
SetPreview(PreviewType.Result, this.resultBitmap);
}
catch (Exception exception)
{
MessageBox.Show($"Błąd generowania tekstury: {exception.Message}");
}
UpdateInfo("");
editPanelMainSplitContainer.Panel2.Enabled = true;
this.loadingInProgress = false;
}
private async void LoadImage()
{
if (this.loadingInProgress)
{
return;
}
this.loadingInProgress = true;
editPanelMainSplitContainer.Panel2.Enabled = false;
try
{
int deadZoneRangeR = Convert.ToInt32(deadZoneRangeRNumericUpDown.Value);
int deadZoneRangeG = Convert.ToInt32(deadZoneRangeGNumericUpDown.Value);
int deadZoneRangeB = Convert.ToInt32(deadZoneRangeBNumericUpDown.Value);
#region Ścieżka - pobieranie / sprawdzanie
//POBIERANIE ŚCIEŻKI
string path = "";
using (OpenFileDialog ofd = new OpenFileDialog())
{
if (ofd.ShowDialog() == DialogResult.OK)
{
path = ofd.FileName;
}
}
if (String.IsNullOrWhiteSpace(path))
{
this.loadingInProgress = false;
editPanelMainSplitContainer.Panel2.Enabled = true;
UpdateInfo("Nie wybrano pliku!");
return;
}
if (!File.Exists(path))
{
throw new Exception($"plik [{path}] nie istnieje!");
}
string extension = Path.GetExtension(path);
bool extensionIsValid = false;
foreach (string ext in GlobalData.ImageFormats)
{
if (ext.ToLower() == extension || $".{ext.ToLower()}" == extension)
{
extensionIsValid = true;
}
}
if (!extensionIsValid)
{
throw new Exception($"plik [{path}] ma nieprawidłowy format [{extension}]");
}
#endregion
#region Przetwarzanie bitmapy źródłowej
//PRZETWARZANIE BITMAPY ŹRÓDŁOWEJ
UpdateInfo("Przetwarzanie mapy rozkładu...");
Bitmap originalBitmap = new Bitmap(path);
PacketObjMsg grayScaleImagePacket = await ArgbProcessor.CreateGrayScaleImageTaskStart(originalBitmap);
this.sourceBitmap = (Bitmap)grayScaleImagePacket.Obj;
if (!String.IsNullOrEmpty(grayScaleImagePacket.Msg))
{
MessageBox.Show(grayScaleImagePacket.Msg);
}
if (this.sourceBitmap == null)
{
throw new Exception("bitmapa źródłowa jest NULL!");
}
//SetPreview(PreviewType.HairMap, (Bitmap)this.sourceBitmap.Clone()); //PODGLĄD #1
#endregion
this.bitmapAreaInfo.Clear();
#region Inicjalizacja stref
//INICJALIZACJA MAPY STREF
UpdateInfo("Inicjalizacja mapy stref...");
PacketObjMsg bmpAreaLoadingPacket = await this.bitmapAreaInfo.LoadBitmapTaskStart(this.sourceBitmap);
bool bmpAreaLoadingSuccess = (bool)bmpAreaLoadingPacket.Obj;
if (!String.IsNullOrEmpty(bmpAreaLoadingPacket.Msg))
{
MessageBox.Show(bmpAreaLoadingPacket.Msg);
}
if (!bmpAreaLoadingSuccess)
{
throw new Exception("metoda inicjalizująca dane stref zwróciła wartość FALSE!");
}
#endregion
#region Wyodrębnianie typu stref
//WYODRĘBNIANIE TYPU STREF
UpdateInfo("Wyodrębnianie stref martwych i stref wpływu...");
PacketObjMsg areaMarkingPacket = await this.bitmapAreaInfo.GenerateAreasTaskStart(deadZoneRangeR, deadZoneRangeG, deadZoneRangeB);
bool areaExtractingSuccess = (bool)areaMarkingPacket.Obj;
if (!String.IsNullOrEmpty(areaMarkingPacket.Msg))
{
MessageBox.Show(areaMarkingPacket.Msg);
}
if (!areaExtractingSuccess)
{
throw new Exception("metoda wyodrębniająca strefy zwróciła wartość FALSE!");
}
#endregion
#region Indeksowanie stref
//WYODRĘBNIANIE INDEKSÓW STREF
UpdateInfo("Indeksowanie stref...");
PacketObjMsg areaIndexingPacket = await this.bitmapAreaInfo.GenerateAreaIndexesTaskStart();
bool areaIndexingSuccess = (bool)areaIndexingPacket.Obj;
if (!String.IsNullOrEmpty(areaIndexingPacket.Msg))
{
MessageBox.Show(areaIndexingPacket.Msg);
}
if (!areaIndexingSuccess)
{
throw new Exception("metoda indeksująca strefy zwróciła wartość FALSE!");
}
#endregion
#region Zwracanie obrazu rezultatu
//ZWRACANIE OBRAZU REZULTATU
UpdateInfo("Generowanie obrazu mapy rozłożenia...");
PacketObjMsg areaPreviewPacket = await this.bitmapAreaInfo.GenerateAreaPreviewImageTaskStart();
this.hairMapInfoBitmap = (Bitmap)areaPreviewPacket.Obj;
if (!String.IsNullOrEmpty(areaPreviewPacket.Msg))
{
MessageBox.Show(areaPreviewPacket.Msg);
}
if (this.hairMapInfoBitmap == null)
{
throw new Exception("referencja do obrazu podglądu jest NULL!");
}
SetPreview(PreviewType.HairMap, this.hairMapInfoBitmap); //PODGLĄD #2
#endregion
#region Tworzenie wstępne ustawień stref
//TWORZENIE USTAWIEŃ STREF/UPDATE UI
UpdateInfo("Inicjowanie danych ustawień stref...");
PacketObjMsg areaSettingsPacket = await this.bitmapAreaInfo.GenerateAreaSettingsTaskStart();
List <AreaSettings> areaSettingsList = (List <AreaSettings>)areaSettingsPacket.Obj;
if (!String.IsNullOrEmpty(areaSettingsPacket.Msg))
{
MessageBox.Show(areaSettingsPacket.Msg);
}
if (areaSettingsList.Count > 100)
{
MessageBox.Show("Ilość odczytanych stref jest zbyt duża! Należy wybrać obraz o mniej zróżnicowanych obszarach jasności lub zmienić zakres martwej strefy!");
areaSettingsList.Clear();
}
#endregion
#region Wypełnianie panelu
//WYPEŁNIANIE PENELU
UpdateInfo("Dynamiczne generowanie panelu ustawień stref...");
await GlobalProcessor.SleepTaskStart(200);
this.uiController.LoadAreaPanel(areaSettingsList);
#endregion
}
catch (Exception exception)
{
MessageBox.Show($"Błąd odczytu obrazu: {exception.Message}");
}
UpdateInfo("");
editPanelMainSplitContainer.Panel2.Enabled = true;
this.loadingInProgress = false;
}
public PacketObjMsg CreateOpacityMapAndNonTransparentImage(string destinationPath)
{
PacketObjMsg packet = new PacketObjMsg();
bool success = false;
string msg = "";
try
{
//Thread.Sleep(1000);
#region Wstępne
if (String.IsNullOrEmpty(this.filePath))
{
throw new Exception("ścieżka pliku jest pusta!");
}
if (!File.Exists(this.filePath))
{
throw new Exception($"plik nie istnieje!");
}
string extension = Path.GetExtension(this.filePath);
if (extension.ToLower() != ".png" && extension.ToLower() != "png")
{
throw new Exception($"plik ma nieprawidłowy format, powinien być .png! Format [{extension}].");
}
if (!Directory.Exists(destinationPath))
{
throw new Exception($"ścieżka docelowa [{destinationPath}] nie istnieje!");
}
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(this.filePath);
#endregion
#region Przetwarzanie
Bitmap bmp = new Bitmap(this.filePath);
Bitmap bmpOpacity;
Bitmap bmpNonTransparent;
object opacityBmpObj = bmp.Clone();
object nonTransparentBmpObj = bmp.Clone();
if (opacityBmpObj.GetType() == typeof(Bitmap) || nonTransparentBmpObj.GetType() == typeof(Bitmap))
{
bmpOpacity = (Bitmap)opacityBmpObj;
bmpNonTransparent = (Bitmap)nonTransparentBmpObj;
}
else
{
throw new Exception($"conajmniej jedna z kopii bitmapy ma nieprawidłowy typ, powinien być Bitmap. Kopia 1 [{opacityBmpObj.GetType().ToString()}] kopia 2 [{nonTransparentBmpObj.GetType().ToString()}]");
}
int bmpWidth = bmp.Width;
int bmpHeight = bmp.Height;
Color pixelColor;
for (int y = 0; y < bmpHeight; y++)
{
for (int x = 0; x < bmpWidth; x++)
{
pixelColor = bmp.GetPixel(x, y);
int alpha = pixelColor.A;
int red = pixelColor.R;
int green = pixelColor.G;
int blue = pixelColor.B;
int avg = (red + green + blue) / 3;
bmpOpacity.SetPixel(x, y, Color.FromArgb(255, alpha, alpha, alpha));
bmpNonTransparent.SetPixel(x, y, Color.FromArgb(255, red, green, blue));
}
}
#endregion
#region Zapis
string opacityMapPath = $"{destinationPath}\\{fileNameWithoutExtension}_opacity.png";
string nonTransparentImagePath = $"{destinationPath}\\{fileNameWithoutExtension}_nonTransparent.png";
bmpOpacity.Save(opacityMapPath);
bmpNonTransparent.Save(nonTransparentImagePath);
#endregion
success = true;
}
catch (Exception exception)
{
msg = $"Błąd tworzenia mapy przezroczystości dla obrazu [{this.filePath}]: {exception.Message}";
}
packet.Obj = success;
packet.Msg = msg;
return(packet);
}
