API tools faq
paste
Aaaaa988

Untitled

Aaaaa988
Apr 7th, 2021
544
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 12.87 KB | None | 0 0
raw download clone embed print report
  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.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!