public string Decompress(byte[] input)
{
var data = new CompressedData();
data.Load(input);
_huffmanTree.Build(data.Frequencies);
var originalLength = data.OriginalLength;
var output = new char[originalLength];
var bits = new BitReader(data.Data);
var node = _huffmanTree.Root;
var position = 0;
while (position < originalLength)
{
if (node.Character != '\0')
{
output[position] = node.Character;
node = _huffmanTree.Root;
position++;
}
node = bits.Read() ? node.Right : node.Left;
}
return(new string(output));
}
public void Execute()
{
var file = File.ReadAllText(_options.FileName);
var frequencyCalculator = new FrequencyCalculator();
var frequencies = frequencyCalculator.GetFrequencies(file);
_tree.Build(frequencies);
_visualisation = File.ReadAllText("Supporting Files\\Template.html");
_visualisation = _visualisation.Replace("{document}", Path.GetFileNameWithoutExtension(_options.FileName));
_visualisation = _visualisation.Replace("{css}", File.ReadAllText("Supporting Files\\Styles.css"));
_visualisation = _visualisation.Replace("{nodes}", $"<ul>{ProcessNode(_tree.Root)}</ul>");
var tempFile = Path.GetTempFileName().Replace(".tmp", ".html");
File.WriteAllText(tempFile, _visualisation);
Process.Start(new ProcessStartInfo
{
FileName = tempFile,
UseShellExecute = true
});
if (!string.IsNullOrWhiteSpace(_options.OutputFileName))
{
File.WriteAllText(_options.OutputFileName, _visualisation);
}
}
// Проверка правильности строки для кода Хаффмана
public static ReturnResult CheckString04(string reply, string generated)
{
try
{
bool yes = true;
string input = generated;
if (input.CompareTo("") == 0)
{
return new ReturnResult(false, "Вы не ввели текст!");
}
HuffmanTree huffmanTree = new HuffmanTree();
// Строим дерево Хаффмана по весам слов
huffmanTree.Build(input);
// Кодируем
BitArray encoded = (BitArray)huffmanTree.Encode(input);
if (huffmanTree.str != reply)
yes = false;
if (yes)
return new ReturnResult(true, "Абсолютно верное решение! ");
return new ReturnResult(false, "Это не оптимальный код Хаффмана. Вот он: " + huffmanTree.str);
}
catch (Exception e)
{
return new ReturnResult(false, "Ошибка ввода! " + e.Message);
}
}
public static string Process(string text)
{
var n = text.Length;
var list = new List <CharFreq>();
for (var i = 0; i < n; ++i)
{
var c = text[i];
var element = list.FirstOrDefault(v => v.Ch == c);
if (element != null)
{
++element.Freq;
continue;
}
list.Add(new CharFreq
{
Ch = c,
Freq = 1
});
}
var root = HuffmanTree.Build(list);
var leafNodes = 0;
var output = string.Empty;
InorderTraversal(root, string.Empty, ref leafNodes, ref output);
output += $"\r\n# characters = {n}\r\n";
output += $"# leaf nodes = {leafNodes}\r\n";
output += $"% compressed = {100.0 - 100.0 * leafNodes / n:F2}\r\n";
return(string.Concat(text.Select(c => list.FirstOrDefault(value => value.Ch == c)?.Label ?? string.Empty)));
}
static void Main(string[] args)
{
BitArray encoded;
char input = ' ';
string pathtofile;
Console.WriteLine("Input path to file");
pathtofile = Console.ReadLine();
HuffmanTree huffmanTree = new HuffmanTree();
using (BinaryReader sr = new BinaryReader(new FileStream(pathtofile, FileMode.Open), Encoding.UTF8))
huffmanTree.Build(input, sr);
using (BinaryReader sr = new BinaryReader(new FileStream(pathtofile, FileMode.Open), Encoding.UTF8))
encoded = huffmanTree.Encode(input, sr);
Console.Write("Encoded ");
string bytestr = "";
int i = 0;
while (i < encoded.Length)
{
if (bytestr.Length < 8)
{
bytestr += encoded[i] ? 1 : 0.ToString();
i++;
}
else
{
HuffmanTree.bytes.Add(Convert.ToByte(bytestr, 2));
bytestr = "";
}
}
if (bytestr.Length <= 8)
{
while (bytestr.Length < 8)
{
bytestr += "0";
Node.Delta++;
}
HuffmanTree.bytes.Add(Convert.ToByte(bytestr, 2));
}
using (StreamWriter sw = new StreamWriter("archive.txt", false))
{
sw.Write(Node.EncTree(huffmanTree.Root));
}
using (FileStream fs = new FileStream("archive.txt", FileMode.Append))
{
fs.Write(HuffmanTree.bytes.ToArray());
fs.WriteByte(Node.Delta);
}
Console.WriteLine();
huffmanTree.Root = new Node();
huffmanTree.Decode();
Console.WriteLine("Decoded");
Console.WriteLine("All done");
Console.ReadLine();
}
public static void Encode(string arquivo)
{
LZWEncoder encoder = new LZWEncoder();
string conteudo = Arquivo.Abrir(arquivo);
Console.WriteLine("Iniciada a compressão");
DateTime dataInicial = DateTime.Now;
//Codificação LZW
string lzwEncoded = encoder.Encode(conteudo);
HuffmanTree huffman = new HuffmanTree();
//Criação da árvore huffman
huffman.Build(lzwEncoded);
//Codificação huffman
var huffmanEncoded = huffman.Encode(lzwEncoded);
DateTime dataFinal = DateTime.Now;
string tempoDecorrido = (dataFinal - dataInicial).TotalSeconds.ToString("N2");
//Contabiliza apenas os tempos para compressão. Igora tempo de IO
Console.WriteLine($"Arquivo comprimido em {tempoDecorrido} segundos");
byte[] ret = new byte[(huffmanEncoded.Length - 1) / 8 + 1];
huffmanEncoded.CopyTo(ret, 0);
//Gravando arquivo comprimido
Arquivo.Gravar(ret, $"{arquivo.Split('.')[0]}.scps");
}
public HuffmanTreeTests()
{
_tree = new HuffmanTree();
var frequencies = GetFrequencies();
_tree.Build(frequencies);
}
public void TestHuffmanCodingProblem()
{
HuffmanTree hfmTree = new HuffmanTree();
string input = "sankara loves devi";
hfmTree.Build(input);
BitArray encoded = hfmTree.Encode(input);
string decoded = hfmTree.Decode(encoded);
Assert.IsTrue(input == decoded);
}
private void WriteHuffBuffer(byte off, byte maxlen)
{
if (StringBuffer[off] == 0)
{
WriteFlag(false);
WriteInt(0, 8);
return;
}
HuffmanTree.Build();
var len = Strlen(StringBuffer, off);
if (len > maxlen)
{
len = maxlen;
}
var numBits = 0U;
for (var i = 0; i < len; ++i)
{
numBits += HuffmanTree.Leaves[StringBuffer[off + i]].NumBits;
}
var flag = WriteFlag(numBits < (len * 8));
WriteInt(len, 8);
if (flag)
{
for (var i = 0; i < len; ++i)
{
var leaf = HuffmanTree.Leaves[StringBuffer[off + i]];
var code = BitConverter.GetBytes(leaf.Code);
WriteBits(leaf.NumBits, code);
}
}
else
{
var temp = new byte[len];
Array.Copy(StringBuffer, off, temp, 0, len);
Write(len, temp);
}
}
public static void TestHuffman()
{
char[] input2 = "eeeeeeeeeeeeeeeeeeeeeeeedddddddddddddddddddddddccccccccccbbbbbbbbbbbaaaaaaaaaaaxxxyyywvsr".ToCharArray();
LogLine("Input content:");
LogLine(new string(input2));
LogLine();
// Build huffman tree
HuffmanTree tree = new HuffmanTree();
tree.Build(input2);
tree.Print();
tree.RightBalance();
tree.Print();
}
private void button1_Click(object sender, EventArgs e)
{
int i = 0;
richTextBox1.Text = "";
htree.Build(textBox1.Text);
encoded = htree.Encode(textBox1.Text);
foreach (bool bit in encoded)
{
richTextBox1.Text += ((bit ? 1 : 0).ToString() + " ");
}
foreach (KeyValuePair <char, int> item in htree.Frequencies)
{
richTextBox3.Text += ("Символ: " + item.Key + "\t Кількість: " + item.Value.ToString() + "\t Частота: " + (Math.Round((float)item.Value / textBox1.Text.Length, 3)) + "\t Код " + htree.codec.ToArray()[i] + "\n");
i++;
}
}
private void button7_Click(object sender, EventArgs e)
{
if (richTextBox7.Text == " ")
{
MessageBox.Show("Please Enter A Text To Compress");
}
else
{
input = richTextBox7.Text;
huffmanTree = new HuffmanTree();
huffmanTree.Build(input);
encoded = huffmanTree.Encode(input);
richTextBox10.Visible = true;
for (int i = 0; i < encoded.Count; i++)
{
richTextBox10.Text += (encoded[i] ? 1 : 0).ToString();
}
}
}
private void ReadHuffBuffer(out string stringBuffer, byte off = 0)
{
HuffmanTree.Build();
uint len;
if (ReadFlag())
{
len = ReadInt(8);
for (var i = 0; i < len; ++i)
{
var current = HuffmanTree.Root;
while (true)
{
if (!HuffmanTree.IsLeaf(current))
{
current = ReadFlag() ? current.Right : current.Left;
continue;
}
StringBuffer[i + off] = current.Symbol;
break;
}
}
}
else
{
len = ReadInt(8);
var buff = new byte[len];
Read(len, buff);
Array.Copy(buff, 0, StringBuffer, off, len);
StringBuffer[off + len] = 0;
}
stringBuffer = Encoding.UTF8.GetString(StringBuffer, 0, (int)(len + off));
}
private void button9_Click(object sender, EventArgs e)
{
var watch = new System.Diagnostics.Stopwatch();
var watch2 = new System.Diagnostics.Stopwatch();
for (int s = min; s < max; s += step)
{
generatingbench(s);
BitArray temp = null;
for (int i = 0; i < nor; i++)
{
watch.Restart();
compress(inputbench.ToString());
huffmanTree = new HuffmanTree();
huffmanTree.Build(compressed.ToString());
BitArray encoded2 = huffmanTree.Encode(compressed.ToString());
benchmarktime1 += watch.Elapsed.TotalMilliseconds;
if (i == 0)
{
temp = huffmanTree.Encode(compressed.ToString());
}
watch.Stop();
}
//==================================================================================================
for (int i = 0; i < nor; i++)
{
watch2.Restart();
decompress();
string decoded = huffmanTree.Decode(temp);
benchmarktime2 += watch2.Elapsed.TotalMilliseconds;
watch2.Stop();
}
if (s == min)
{
this.richTextBox13.Text = "Data Size \t" + "Compress time \t" + "Decompress Time \t" + "\n" + "=====================================================" + "\n";
}
this.richTextBox13.Text += s + "\t\t" + Math.Round((benchmarktime1 / nor), 3).ToString() + "\t\t" + Math.Round((benchmarktime2 / nor), 3).ToString() + "\n";
benchmarktime1 = 0;
benchmarktime2 = 0;
}
}
// Проверка правильности строки для кода Хаффмана
public static string CheckString04(string reply, string generated)
{
try
{
bool yes = true;
string input = generated;
if (input.CompareTo("") == 0)
{
return("Вы не ввели текст!");
}
HuffmanTree huffmanTree = new HuffmanTree();
// Строим дерево Хаффмана по весам слов
huffmanTree.Build(input);
// Кодируем
BitArray encoded = (BitArray)huffmanTree.Encode(input);
if (huffmanTree.str != reply)
{
yes = false;
}
if (yes)
{
return("Абсолютно верное решение! ");
}
return("Это не оптимальный код Хаффмана. Вот он: " + huffmanTree.str);
}
catch (Exception e)
{
return("Ошибка ввода! " + e.Message);
}
}
private HuffmanTree InitializeHuffmanTree()
{
/*
* List<string> items = new List<string>();
* foreach(TXTRow row in ArmorTXT.Rows)
* {
* items.Add(row["code"]);
* }
* foreach (TXTRow row in WeaponsTXT.Rows)
* {
* items.Add(row["code"]);
* }
* foreach (TXTRow row in MiscTXT.Rows)
* {
* items.Add(row["code"]);
* }
*/
var itemCodeTree = new HuffmanTree();
itemCodeTree.Build(new List <string>());
return(itemCodeTree);
}
public static FrequencyRecord[] GetFrequencyDictionary(string text)
{
var result = new List <FrequencyRecord>();
var huffmanTree = new HuffmanTree();
huffmanTree.Build(text);
_entropy = 0;
for (int i = 0; i < huffmanTree.Frequencies.Count; i++)
{
var record = new FrequencyRecord();
record._char = huffmanTree.Frequencies.ElementAt(i).Key;
record._freq = huffmanTree.Frequencies.ElementAt(i).Value;
record._freqPercent = Math.Round(record._freq / ((float)text.Length), 2);
foreach (var item in huffmanTree.EncodeChar(record._char))
{
record._code += (item ? 1 : 0);
}
result.Add(record);
_entropy += Math.Round((-(result[i]._freqPercent * Math.Log(result[i]._freqPercent, 2))), 2);
}
BitArray encoded = huffmanTree.Encode(text);
Console.Write("Encoded: ");
var str = "";
foreach (bool bit in encoded)
{
str += (bit ? 1 : 0);
}
_avg = Math.Round((float)str.Length / (float)text.Length, 2);
_lenght = str.Length;
return(result.ToArray());
}
public static byte[] Encode(string text)
{
HuffmanTree tree = HuffmanTree.Build(text); // budowa drzewa
var dict = tree.Dictionary; // słownik kodów
var(encoded, padding) = Encode(text, dict); // zakodowanie wiadomośc
int maxLen = 4;
int estimatedBufferSize = 1 + dict.Count * (1 + 1 + maxLen) + 1 + encoded.Length; // przewidywany rozmiar pliku wyjściowego
var buff = new byte[estimatedBufferSize]; // utworzenie bufora
using var ms = new MemoryStream(buff);
// zapis kolejnych składowych formatu
ms.WriteByte((byte)dict.Count); // liczba znaków
foreach (var kvp in dict)
{
ms.WriteByte((byte)kvp.Key); // znak
ms.WriteByte((byte)kvp.Value.Length); // długośc kodu
ms.Write(kvp.Value.GetBytes().Item1); // kod
}
ms.WriteByte((byte)padding); // przesuniecie (margines do 8 bitów)
ms.Write(encoded); // zapis danych
return(buff.AsSpan(0, (int)ms.Position).ToArray());
}
static void Main(string[] args)
{
Console.WriteLine("Veuillez entrer les éléments de facturation du client :");
string input = Console.ReadLine();
HuffmanTree huffmanTree = new HuffmanTree();
// Construire l'arbre de huffman
huffmanTree.Build(input);
// Encoder
BitArray encoded = huffmanTree.Encode(input);
//on retourne le nombre d'octets du message lu au clavier
Console.WriteLine();
Console.WriteLine("Votre texte est de " + input.Length + " octets");
//on ouvre une session de connexion sur gmail à travers smtp
try
{
MailMessage mail = new MailMessage();
SmtpClient SmtpServer = new SmtpClient("smtp.gmail.com");
mail.From = new MailAddress("*****@*****.**"); //expéditeur
mail.To.Add("*****@*****.**"); //recepteur
mail.Subject = "Informations client"; //objet
//ic on affiche d'abord le message compréssé chez l'expéditeur
Console.WriteLine();
int cpt = 0; //j'initialise un compte ici pour avoir le nombre de bit à la fin de la compression
Console.Write("Compressé: ");
foreach (bool bit in encoded)
{
Console.Write((bit ? 1 : 0) + "");
cpt = cpt + 1;
}
Console.WriteLine();
Console.WriteLine("le texte compréssé est de " + (cpt / 8 + 1) + " octets");
Console.WriteLine();
Console.WriteLine("En cours d'envoi à " + mail.To + "...");
/*foreach (bool bit in encoded)
* {
* mail.Body = (bit ? 1 : 0) + "";
* }
* Console.WriteLine();*/
string chaine;
string message = "";
foreach (bool bit in encoded)
{
chaine = (bit ? 1 : 0) + "";
message = $"{message}{chaine}";
}
mail.Body = message;
SmtpServer.Port = 587;
SmtpServer.Credentials = new System.Net.NetworkCredential("*****@*****.**", "testisj2019");
SmtpServer.EnableSsl = true;
Console.WriteLine();
SmtpServer.Send(mail);
Console.WriteLine("Votre mail à été envoyé avec succes!!!");//Message succes
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
//cette partie du code permet de lire les mails de l'adresse passée en paramètre
try
{
using (Pop3 pop3 = new Pop3())
{
pop3.ConnectSSL("pop.gmail.com"); // or ConnectSSL for SSL
pop3.Login("*****@*****.**", "mayelle2010");
List <string> uids = pop3.GetAll();
foreach (string uid in uids)
{
IMail email = new MailBuilder()
.CreateFromEml(pop3.GetMessageByUID(uid));
Console.WriteLine("");
Console.WriteLine(email.Date);
Console.WriteLine(email.From);
Console.WriteLine(email.Subject);
}
pop3.Close();
}
}
catch (Limilabs.Client.ServerException e)
{
Console.WriteLine(e.ToString());
}
}
void backWorker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
System.ComponentModel.BackgroundWorker b = sender as System.ComponentModel.BackgroundWorker;
int samples = 32;
short[] buffer = new short[samples];
bw = new BinaryWriter(File.Open(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "/Code.huf", FileMode.Create));
stream = Bass.BASS_StreamCreateFile(path, 0L, 0L, BASSFlag.BASS_STREAM_DECODE);
ww = new WaveWriter(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "/HufSound.wav", stream, true);
int mult = 0;
long len = Bass.BASS_ChannelGetLength(stream, BASSMode.BASS_POS_BYTES);
while (Bass.BASS_ChannelIsActive(stream) == BASSActive.BASS_ACTIVE_PLAYING)
{
int length = Bass.BASS_ChannelGetData(stream, buffer, samples * 2);
mult++;
b.ReportProgress((int)(((samples * mult) * 100) / len * 2));
List <short> listBuffer = new List <short>();
HuffmanTree tree = new HuffmanTree();
if (length > 0)
{
listBuffer.AddRange(buffer);
short[] auxbuf = new short[buffer.Length];
auxbuf = buffer;
canvasWavComp.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.SystemIdle, new Action(delegate
{
//Whole Wave
//double xScale = canvasWavComp.Width / samples;
//Formula by Manuel García. Dude you're amazing.
//NOTE: multiply by 2 'cos I supoused some relation with Nyquist Theorem
double xScale = (canvasWavComp.Width * samples) / len * 2;
double yScale = (canvasWavComp.Height / (double)(amplitude * 2)) * ((double)amplitude / MAX_AMP);
Polyline graphLine = new Polyline();
//This Line is used to move on the x axis
Canvas.SetLeft(graphLine, xAxis);
graphLine.Stroke = new SolidColorBrush(Color.FromRgb(244, 67, 54));
graphLine.StrokeThickness = 2;
for (int i = 0; i < buffer.Length; i++)
{
graphLine.Points.Add(new Point(xScale * i, (canvasWavComp.Height / 2) - (buffer[i] * yScale)));
}
xAxis += xScale;
//canvasWavComp.Children.Clear();
canvasWavComp.Children.Add(graphLine);
}));
double entaux = 0;
foreach (var sym in listBuffer.GroupBy(i => i))
{
NodeHuf nodeHuf = new NodeHuf();
nodeHuf.Symbol = sym.Key;
nodeHuf.Frequency = sym.Count();
nodeHuf.Right = nodeHuf.Left = null;
tree.Add(nodeHuf);
double prob = (double)nodeHuf.Frequency / samples;
//entropy -= prob * (Math.Log(prob) / Math.Log(2));
entaux += prob * Math.Log(1 / (prob), 2);
entauxlbl = entaux;
}
entropy += entaux;
entcount++;
tree.Build();
//Encode
System.Collections.BitArray encoded = tree.Encode(auxbuf);
byte[] arrayBytes = new byte[encoded.Length / 8 + (encoded.Length % 8 == 0 ? 0 : 1)];
encoded.CopyTo(arrayBytes, 0);
File.WriteAllBytes("Compress.bin", arrayBytes);
//Decode
byte[] data;
Stream fs = File.OpenRead("Compress.bin");
data = new byte[fs.Length];
fs.Read(data, 0, data.Length);
System.Collections.BitArray bitDec = new System.Collections.BitArray(data);
short[] decoded = tree.Decode(bitDec);
if (decoded.Length > 0)
{
ww.Write(decoded, length);
}
bw.Write(data);
fs.Close();
}
}
//Delete temporaly file
File.Delete("Compress.bin");
//Close de Stream WAV ww
ww.Close();
//If you not add this line, the backgroundworker will be restat but when file is create again
//there will be an incongruence because the bw never was closed.
bw.Close();
entropy /= entcount;// (len / samples);
entcount = 0;
}
