aswi2021tri-musketyri-gitlab/TextureEditing/MapEditor.cs @ 54fb8008

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Text;

namespace TextureEditing
{
    /// <summary>
    /// Edits input pngs
    /// </summary>
    class MapEditor
    {
        /// <summary> Path to data </summary>
        string dataPath;
        /// <summary> Path to output folder </summary>
        string outPath;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="dataPath">Path to data</param>
        /// <param name="outPath">Path to output folder</param>
        public MapEditor(string dataPath, string outPath)
        {
            this.dataPath = dataPath;
            this.outPath = outPath;
        }

        /// <summary>
        /// Crop all pngs from input data folder
        /// </summary>
        public void EditAllPngs()
        {
            // does dataPath folder exist
            if (!Directory.Exists(dataPath))
            {
                Console.WriteLine("Path does not exist");
                return;
            }

            List<PngEdited> cropped = new List<PngEdited>();

            // for all files
            string[] files = Directory.GetFiles(dataPath);
            foreach (string f in files)
            {
                Console.WriteLine("Processing file " + f);
                Bitmap img = new Bitmap(f);
                var newpng = Crop(img);
                newpng.name = Path.GetFileName(f);
                PositionInOriginal(img, newpng);
                PositionOfCentroid(newpng);
                cropped.Add(newpng);

                newpng.Save(outPath + "/" + newpng.name);
            }
            SaveTxt(cropped);

            /*
            int c = 0;
            foreach (PngEdited p in cropped)
            {
                c++;
                TestImage(p, c);
            }
            */
        }

        /// <summary>
        /// Testing method
        /// Prints out cropped image positioned back to original map and image with visible centroid
        /// </summary>
        /// <param name="pngEdited">Output image</param>
        /// <param name="i">Number of image</param>
        private void TestImage(PngEdited pngEdited, int i)
        {
            Bitmap png = new Bitmap("./bory-buildings.png");
            Bitmap newpng = pngEdited.png;

            Bitmap centroid = new Bitmap(20, 20);
            for (int h = 0; h < centroid.Height; h++)
                for (int w = 0; w < centroid.Width; w++)
                    centroid.SetPixel(w, h, Color.Red);


            int xPos = (int)((newpng.Width / 100.0f) * pngEdited.xCentr) - 10;
            int yPos = (int)((newpng.Height / 100.0f) * (100 - pngEdited.yCentr)) - 10;

            Bitmap centroidTest = new Bitmap(newpng.Width, newpng.Height);
            using (Graphics g = Graphics.FromImage(centroidTest))
            {
                g.DrawImage(newpng, new Rectangle(0, 0, newpng.Width, newpng.Height), new Rectangle(0, 0, newpng.Width, newpng.Height), GraphicsUnit.Pixel);
                g.DrawImage(centroid, new Rectangle(xPos, yPos, 20, 20), new Rectangle(0, 0, centroidTest.Width, centroidTest.Height), GraphicsUnit.Pixel);

                centroidTest.Save($"testCentroidOut{i}.png", ImageFormat.Png);
            }

            for (int h = 0; h < newpng.Height; h++)
                for (int w = 0; w < newpng.Width; w++)
                {
                    if (newpng.GetPixel(w, h).A != 0)
                    {
                        newpng.SetPixel(w, h, Color.Red);
                    }
                }

            xPos = (int) ((png.Width / 100.0f) * pngEdited.xPerc);
            yPos = (int)((png.Height / 100.0f) * (100-pngEdited.yPerc)) - newpng.Height;

            using (Graphics g = Graphics.FromImage(png))
            {
                g.DrawImage(newpng, new Rectangle(xPos, yPos, newpng.Width, newpng.Height), new Rectangle(0, 0, newpng.Width, newpng.Height), GraphicsUnit.Pixel);
                png.Save($"testOut{i}.png", ImageFormat.Png);
            }
        }

        /// <summary>
        /// Compute the position of centroid. Coordinates are computed in % from bottom left corner of cropped png
        /// </summary>
        /// <param name="newpng">Output png in instance PngEdited</param>
        private void PositionOfCentroid(PngEdited newpng)
        {
            // from all non transparent pixels
            int coordY = 0, coordX = 0;
            int count = 0;
            for (int h = 0; h < newpng.png.Height; h++)
                for (int w = 0; w < newpng.png.Width; w++)
                {
                    if (newpng.png.GetPixel(w, h).A != 0 )
                    {
                        count++;
                        coordY += h;
                        coordX += w;
                    }
                }

            // coordinates
            newpng.xCentr = coordX / count;
            newpng.yCentr = coordY / count;

            // to %
            float onePercX = newpng.png.Width / 100.0f;
            float percX = newpng.xCentr / onePercX;
            newpng.xCentr = percX;

            float onePercY = newpng.png.Height / 100.0f;
            float percY = 100 - (newpng.yCentr / onePercY);
            newpng.yCentr = percY;
        }

        /// <summary>
        /// Find the position of cropped image in original. Coordinates of bottom left corner are computed in % from bottom left corner of original
        /// </summary>
        /// <param name="img">Original</param>
        /// <param name="newpng">New image</param>
        private void PositionInOriginal(Bitmap img, PngEdited newpng)
        {
            // left bottom corner
            int xLeft = newpng.xStart;
            int yLeft = newpng.yEnd;

            // compute percentages
            float onePercX = img.Width / 100.0f;
            float percX = xLeft / onePercX;
            newpng.xPerc = percX;

            float onePercY = img.Height / 100.0f;
            float percY = 100 - (yLeft / onePercY);
            newpng.yPerc = percY;
        }

        /// <summary>
        /// Save information about output files as csv
        /// [name];[x coordinate of bottom left corner];[y coordinate of bottom left corner];[x coordinate of centroid];[y coordinate of centroid]
        /// Coordinates of bottom left corner are computed in % from bottom left corner of original, coordinates of centroid are computed in % from bottom left corner of output png
        /// </summary>
        /// <param name="cropped"></param>
        private void SaveTxt(List<PngEdited> cropped)
        {
            string res = "";

            foreach (PngEdited png in cropped)
                res += $"{png.name};{png.xPerc};{png.yPerc};{png.xCentr};{png.yCentr}\n";

            File.WriteAllBytes(outPath + "/output.csv", Encoding.ASCII.GetBytes(res));
        }

        /// <summary>
        /// Crop image so it does not contain any transparent padding
        /// </summary>
        /// <param name="img">Original image</param>
        /// <returns>Cropped image as PngEdited instance</returns>
        private PngEdited Crop(Bitmap img)
        {
            PngEdited res = new PngEdited();

            int xFrom = img.Width, xTo = 0;
            int yFrom = img.Height, yTo = 0;
            
            // find start + end of x and y
            for (int h = 0; h < img.Height; h++)
                for (int w = 0; w < img.Width; w++)
                {
                    if (img.GetPixel(w, h).A != 0 && xFrom > w)
                        xFrom = w;

                    if (img.GetPixel(w, h).A != 0 && xTo < w)
                        xTo = w;

                    if (img.GetPixel(w, h).A != 0 && yFrom > h)
                        yFrom = h;

                    if (img.GetPixel(w, h).A != 0 && yTo < h)
                        yTo = h;
                }


            // crop
            Bitmap cropped = new Bitmap(xTo - xFrom + 1, yTo - yFrom + 1);
            using (Graphics g = Graphics.FromImage(cropped))
            {
                g.DrawImage(img, new Rectangle(0, 0, cropped.Width, cropped.Height), new Rectangle(xFrom, yFrom, cropped.Width, cropped.Height), GraphicsUnit.Pixel);
                res.png = cropped;
            }

            res.xStart = xFrom;
            res.xEnd = xTo;
            res.yStart = yFrom;
            res.yEnd = yTo;

            return res;
        }

    }
}