Aaaaa988

Untitled

Apr 7th, 2021
390
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.Drawing.Imaging;
  5. using System.IO;
  6. using System.Linq;
  7. using System.Runtime.InteropServices;
  8. using System.Windows.Forms;
  9.  
  10. namespace RGZ {
  11.     public partial class Form1 : Form {
  12.  
  13.         private class PCXTC {
  14.             public readonly byte ID;
  15.             public readonly byte Version;
  16.             public readonly byte Coding;
  17.             public readonly byte BitPerPixel;
  18.             public readonly short XMin;
  19.             public readonly short YMin;
  20.             public readonly short XMax;
  21.             public readonly short YMax;
  22.             public readonly short HRes;
  23.             public readonly short VRes;
  24.             public readonly byte[] Pal256x;
  25.             public readonly byte Reserved;
  26.             public readonly byte Planes;
  27.             public readonly short BytePerLine;
  28.             public readonly short PaletteInfo;
  29.             public readonly short HScreenSize;
  30.             public readonly short VScreenSize;
  31.             public readonly byte[] Filler;
  32.             public readonly short Width;
  33.             public readonly short Height;
  34.             public readonly byte[] Pal256;
  35.             public readonly byte[] Pixels;
  36.             public readonly Bitmap bmp;
  37.             public PCXTC() {
  38.                 Pal256x = new byte[48];
  39.                 Filler = new byte[54];
  40.                 Pixels = null;
  41.             }
  42.             public PCXTC(string FileName) {
  43.                 using (BinaryReader binReader = new BinaryReader(File.Open(FileName, FileMode.Open, FileAccess.Read))) {
  44.                     int totalSize = (int)binReader.BaseStream.Length;
  45.                     ID = binReader.ReadByte();
  46.                     Version = binReader.ReadByte();
  47.                     Coding = binReader.ReadByte();
  48.                     BitPerPixel = binReader.ReadByte();
  49.                     XMin = binReader.ReadInt16();
  50.                     YMin = binReader.ReadInt16();
  51.                     XMax = binReader.ReadInt16();
  52.                     YMax = binReader.ReadInt16();
  53.                     HRes = binReader.ReadInt16();
  54.                     VRes = binReader.ReadInt16();
  55.                     Pal256x = binReader.ReadBytes(48);
  56.                     Reserved = binReader.ReadByte();
  57.                     Planes = binReader.ReadByte();
  58.                     BytePerLine = binReader.ReadInt16();
  59.                     PaletteInfo = binReader.ReadInt16();
  60.                     HScreenSize = binReader.ReadInt16();
  61.                     VScreenSize = binReader.ReadInt16();
  62.                     Filler = binReader.ReadBytes(54);
  63.  
  64.                     Width = (short)(XMax - XMin + 1);
  65.                     Height = (short)(YMax - YMin + 1);
  66.                     Pixels = new byte[Width * Height * 3];
  67.  
  68.                     binReader.BaseStream.Seek(128, SeekOrigin.Begin);
  69.                     int totalData = totalSize - 769 - 128 * Planes;
  70.                     byte count = 0;
  71.                     byte data = 0;
  72.                     int pos = 0;
  73.  
  74.                     for (int i = 0; i < Height; ++i) {
  75.                         for (int j = 0; j < Planes; ++j) {
  76.                             pos = 3 * Width * i + j;
  77.                             for (int k = 0; k < BytePerLine; ++k) {
  78.                                 if (count == 0) {
  79.                                     data = binReader.ReadByte();
  80.                                     count = 1;
  81.                                     if ((data & 0b11000000) == 0b11000000) {
  82.                                         count = (byte)(data & 0b00111111);
  83.                                         data = binReader.ReadByte();
  84.                                     }
  85.                                 }
  86.                                 count--;
  87.                                 if (k < Width) {
  88.                                     Pixels[pos] = data;
  89.                                     pos += 3;
  90.                                 }
  91.                             }
  92.                         }
  93.                     }
  94.                 }
  95.                 bmp = new Bitmap(Width, Height, PixelFormat.Format24bppRgb);
  96.                 BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, bmp.PixelFormat);
  97.                 int padding = bmpData.Stride - 3 * Width;
  98.                 int counter = 0;
  99.                 unsafe {
  100.                     byte* ptr = (byte*)bmpData.Scan0;
  101.                     for (int i = 0; i < Height; ++i) {
  102.                         for (int j = 0; j < Width; ++j) {
  103.                             ptr[2] = Pixels[counter];
  104.                             ptr[1] = Pixels[counter + 1];
  105.                             ptr[0] = Pixels[counter + 2];
  106.                             counter += 3;
  107.                             ptr += 3;
  108.                         }
  109.                         ptr += padding;
  110.                     }
  111.                 }
  112.                 bmp.UnlockBits(bmpData);
  113.             }
  114.  
  115.         }
  116.  
  117.         private class BMP256 {
  118.             readonly byte ID;
  119.             readonly byte Version;
  120.             readonly byte Coding;
  121.             readonly byte BitPerPixel;
  122.             readonly short XMin;
  123.             readonly short YMin;
  124.             readonly short XMax;
  125.             readonly short YMax;
  126.             readonly short HRes;
  127.             readonly short VRes;
  128.             readonly byte[] Pal256x;
  129.             readonly byte Reserved;
  130.             readonly byte Planes;
  131.             readonly short BytePerLine;
  132.             readonly short PaletteInfo;
  133.             readonly short HScreenSize;
  134.             readonly short VScreenSize;
  135.             readonly byte[] Filler;
  136.             readonly short Width;
  137.             readonly short Height;
  138.             List<byte> PixelsRLE;
  139.             List<byte> Pixels;
  140.             List<Color> AllPixelsColor;
  141.             public Bitmap bmp;
  142.  
  143.             public static int rgbTo8Bit(int r, int g, int b) {
  144.                 bool grayPossible = true;
  145.                 bool gray = false;
  146.                 float sep = 42.5f;
  147.  
  148.                 while (grayPossible) {
  149.                     if (r < sep || g < sep || b < sep) {
  150.                         gray = r < sep && g < sep && b < sep;
  151.                         grayPossible = false;
  152.                     }
  153.                     sep += 42.5f;
  154.                 }
  155.  
  156.                 if (gray) {
  157.                     return (int)Math.Round(232f + (r + g + b) / 33f);
  158.                 }
  159.                 else {
  160.                     return 16 + ((int)(6f * (r / 256f))) * 36 + ((int)(6f * (g / 256f))) * 6 + ((int)(6f * (b / 256f)));
  161.                 }
  162.             }
  163.  
  164.             public BMP256() {
  165.                 Pal256x = new byte[48];
  166.                 Filler = new byte[54];
  167.             }
  168.             public BMP256(PCXTC TC, int delta) {
  169.                 ID = TC.ID;
  170.                 Version = 5;
  171.                 Coding = 1;
  172.                 BitPerPixel = 8;
  173.                 XMin = TC.XMin;
  174.                 YMin = TC.YMin;
  175.                 XMax = TC.XMax;
  176.                 YMax = TC.YMax;
  177.                 HRes = TC.HRes;
  178.                 VRes = TC.VRes;
  179.                 Pal256x = TC.Pal256x;
  180.                 Reserved = TC.Reserved;
  181.                 Planes = 1;
  182.                 BytePerLine = TC.BytePerLine;
  183.                 PaletteInfo = 1;
  184.                 HScreenSize = TC.HScreenSize;
  185.                 VScreenSize = TC.VScreenSize;
  186.                 Filler = TC.Filler;
  187.                 Width = TC.Width;
  188.                 Height = TC.Height;
  189.                 Pixels = new List<byte>();
  190.                 AllPixelsColor = new List<Color>();
  191.  
  192.                 for (int i = 0; i < TC.Pixels.Length; i += 3) {
  193.                     AllPixelsColor.Add(Color.FromArgb(TC.Pixels[i], TC.Pixels[i + 1], TC.Pixels[i + 2]));
  194.                 }
  195.  
  196.                 var groups = from s in AllPixelsColor
  197.                              group s by s into g
  198.                              select
  199.                              new { Stuff = g.Key, Count = g.Count() };
  200.  
  201.                 List<KeyValuePair<Color, int>> Probabilities = groups.ToDictionary(g => g.Stuff, g => g.Count).Where(x => x.Value > 10).OrderByDescending(x => x.Value).ToList();
  202.  
  203.                 Color[] Pallete = new Color[256];
  204.  
  205.                 double Delta = delta;
  206.                 int totalcolorInd = 0;
  207.                 for (int i = 0; i < 256; ++i)
  208.                 {
  209.                     bool found = false;
  210.                     Color newColor = Probabilities[i].Key;
  211.                     for (int NewColorInd = totalcolorInd; NewColorInd < Probabilities.Count; NewColorInd += 1)
  212.                     {
  213.                         for (int OldColorInd = 0; OldColorInd < i; ++OldColorInd)
  214.                         {
  215.                             double DifferenceR = Math.Pow(Pallete[OldColorInd].R - Probabilities[NewColorInd].Key.R, 2);
  216.                             double DifferenceG = Math.Pow(Pallete[OldColorInd].G - Probabilities[NewColorInd].Key.G, 2);
  217.                             double DifferenceB = Math.Pow(Pallete[OldColorInd].B - Probabilities[NewColorInd].Key.B, 2);
  218.                             double OverallDiffence = DifferenceR + DifferenceG + DifferenceB;
  219.                            
  220.                             if (Delta <= OverallDiffence)
  221.                             {
  222.                                 newColor = Probabilities[NewColorInd].Key;
  223.                                 if (NewColorInd + 1 < Probabilities.Count)
  224.                                     totalcolorInd = NewColorInd + 1;
  225.                                 found = true;
  226.                                 break;
  227.                             }
  228.                         }
  229.                         if (found)
  230.                             break;
  231.                     }
  232.                     Pallete[i] = newColor;
  233.                 }
  234.  
  235.                 for (int i = 0; i < AllPixelsColor.Count; ++i)
  236.                 {
  237.                     double LowestDifference = double.MaxValue;
  238.                     byte ColorIndex = 0;
  239.                     for (int cIndex = 0; cIndex < 256; ++cIndex)
  240.                     {
  241.                         double DifferenceR = Math.Pow(Pallete[cIndex].R - AllPixelsColor[i].R, 2);
  242.                         double DifferenceG = Math.Pow(Pallete[cIndex].G - AllPixelsColor[i].G, 2);
  243.                         double DifferenceB = Math.Pow(Pallete[cIndex].B - AllPixelsColor[i].B, 2);
  244.                         double OverallDiffence = DifferenceR + DifferenceG + DifferenceB;
  245.                         if (OverallDiffence < LowestDifference)
  246.                         {
  247.                             ColorIndex = (byte)cIndex;
  248.                             LowestDifference = OverallDiffence;
  249.                         }
  250.                     }
  251.                     Pixels.Add(ColorIndex);
  252.                 }
  253.  
  254.                 bmp = new Bitmap(Width, Height, PixelFormat.Format8bppIndexed);
  255.                 ColorPalette newColorPallete = bmp.Palette;
  256.                 for (int i = 0; i < 256; ++i)
  257.                     newColorPallete.Entries[i] = Pallete[i];
  258.                 bmp.Palette = newColorPallete;
  259.                 Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
  260.                 BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadWrite, bmp.PixelFormat);
  261.  
  262.                 List<byte> PixelsToOutput = new List<byte>();
  263.                 for (int i = 0; i < Pixels.Count; i += 2)
  264.                     PixelsToOutput.Add((byte)((byte)(Pixels[i] << 8) + Pixels[i + 1]));
  265.  
  266.                 Marshal.Copy(Pixels.ToArray(), 0, bmpData.Scan0, Pixels.Count);
  267.                 bmp.UnlockBits(bmpData);
  268.             }
  269.  
  270.         }
  271.  
  272.         PCXTC PicTC = new PCXTC();
  273.         BMP256 Pic256 = new BMP256();
  274.         public Form1() {
  275.             InitializeComponent();
  276.         }
  277.  
  278.         private void B_SelectFile_Click(object sender, EventArgs e) {
  279.             using (OpenFileDialog ofg = new OpenFileDialog()) {
  280.                 ofg.Filter = "PCX Image (.pcx)|*.pcx";
  281.                 ofg.FilterIndex = 0;
  282.                 if (ofg.ShowDialog() == DialogResult.OK) {
  283.                     string FileName = ofg.FileName;
  284.                     textBox_Path.Text = FileName;
  285.                     PicTC = new PCXTC(FileName);
  286.                     pB_Before.Image = PicTC.bmp;
  287.  
  288.                 }
  289.             }
  290.         }
  291.  
  292.         private void B_Convert_Click(object sender, EventArgs e) {
  293.             if (PicTC.bmp != null)
  294.             {
  295.                 Pic256 = new BMP256(PicTC, (int)numericUpDown1.Value);
  296.                 pB_After.Image = Pic256.bmp;
  297.             }
  298.         }
  299.  
  300.         private void button1_Click(object sender, EventArgs e)
  301.         {
  302.             if (Pic256.bmp != null)
  303.             using (SaveFileDialog dialog = new SaveFileDialog())
  304.             {
  305.                 dialog.Filter = "BMP Image|*.bmp";
  306.                 if (dialog.ShowDialog() == DialogResult.OK)
  307.                     Pic256.bmp.Save(dialog.FileName, ImageFormat.Bmp);
  308.  
  309.             }
  310.         }
  311.     }
  312. }
  313.  
RAW Paste Data