public static T ToDecompressedPacket <T>(byte[] compressedBytes) where T : IPacket
{
var decompressedPacketBytes = new byte[compressedBytes.Length];
HuffmanCompressor.Decompress(compressedBytes, out decompressedPacketBytes);
return(ToPacket <T>(decompressedPacketBytes));
}
static void Main(string[] args)
{
Console.WriteLine("Ingrese el texto para codificar");
string text = Console.ReadLine();
var huffman = new HuffmanCompressor("..//..//..");
Console.WriteLine("El texto comprimido es:");
Console.WriteLine(huffman.ShowCompress(text));
Console.ReadLine();
}
public static byte[] ToCompressedBytes <T>(T packet) where T : IPacket
{
var packetBytes = ToBytes(packet);
var compressedPacketBytes = new byte[packetBytes.Length];
HuffmanCompressor.Compress(packetBytes, out compressedPacketBytes);
return(compressedPacketBytes);
}
static void Main(string[] args)
{
HuffmanCompressor oHuffmanCompressor = new HuffmanCompressor();
oHuffmanCompressor.Compress("test.txt");
Console.WriteLine("compressed");
oHuffmanCompressor.Decompress("test.txt");
Console.WriteLine("decompressed");
Console.ReadLine();
}
static void Main(string[] args)
{
string testStr = "This is a dummy text";
string outFile = "output.jelly";
CompressionInfo encodedFile = HuffmanCompressor.Encode(testStr, outFile);
Console.WriteLine($"Successfully created : {encodedFile}");
Console.WriteLine("Decoding..");
string decodedText = HuffmanCompressor.Decode(outFile);
Console.WriteLine(decodedText);
}
public static void CompressingPhrase(string uncompressedText, string expectedCompressedText)
{
//Arrange
var sorter = new BubbleSorter <HuffmanCompressor.ListNode>();
var translator = new Translator();
var huffman = new HuffmanCompressor(sorter, translator);
//Act
var(compressedText, decompressionKeys) = huffman.Compress(uncompressedText);
var decompressedText = translator.Translate(compressedText, decompressionKeys);
//Assert
Assert.AreEqual(expectedCompressedText, compressedText);
Assert.AreEqual(uncompressedText, decompressedText);
}
public void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100, Distinct = true)] int length)
{
//Arrange
var sorter = new BubbleSorter <HuffmanCompressor.ListNode>();
var translator = new Translator();
var huffman = new HuffmanCompressor(sorter, translator);
var text = Randomizer.CreateRandomizer().GetString(length);
//Act
var(compressedText, decompressionKeys) = huffman.Compress(text);
var decompressedText = translator.Translate(compressedText, decompressionKeys);
//Assert
Assert.AreEqual(text, decompressedText);
}
public IActionResult Compress([FromForm] IFormFile file, string name)
{
try
{
string path = env.ContentRootPath + "\\" + file.FileName;
using var saver = new FileStream(path, FileMode.Create);
file.CopyTo(saver);
saver.Close();
using var fileWritten = new FileStream(path, FileMode.OpenOrCreate);
using var reader = new BinaryReader(fileWritten);
byte[] buffer = new byte[0];
while (fileWritten.Position < fileWritten.Length)
{
int index = buffer.Length;
Array.Resize <byte>(ref buffer, index + 100000);
byte[] aux = reader.ReadBytes(100000);
aux.CopyTo(buffer, index);
}
reader.Close();
fileWritten.Close();
for (int i = 0; i < buffer.Length; i++)
{
if (buffer[i] == 0)
{
Array.Resize <byte>(ref buffer, i);
break;
}
}
if (buffer.Length > 0)
{
var compressor = new HuffmanCompressor(env.ContentRootPath);
path = compressor.Compress(buffer, file.FileName, name);
var fileStream = new FileStream(path, FileMode.OpenOrCreate);
return(File(fileStream, "text/plain"));
}
else
{
return(StatusCode(500, "El archivo está vacío"));
}
}
catch
{
return(StatusCode(500));
}
}
public IActionResult Decompress([FromForm] IFormFile file)
{
try
{
string path = env.ContentRootPath + "\\" + file.FileName;
using var saver = new FileStream(path, FileMode.Create);
file.CopyTo(saver);
using var reader = new StreamReader(saver);
saver.Position = 0;
var text = reader.ReadToEnd();
var compressor = new HuffmanCompressor(env.ContentRootPath);
path = compressor.Decompress(text);
var fileStream = new FileStream(path, FileMode.OpenOrCreate);
return(File(fileStream, "text/plain"));
}
catch
{
return(StatusCode(500));
}
}
private void ChooseCompressor( out ICompressor compressor, out string extension )
{
if ( CompressionScheme == Properties.Resources.HuffmanCode )
{
compressor = new HuffmanCompressor( );
extension = Properties.Resources.HuffmanCodeExt;
}
else if ( CompressionScheme == Properties.Resources.Lz77 )
{
compressor = new LZ77HuffmanCompressor( DefaultWidth );
extension = Properties.Resources.Lz77Ext;
}
else if ( CompressionScheme == Properties.Resources.ArithmeticCode )
{
compressor = new ArithmeticCodingCompressor( );
extension = Properties.Resources.ArithmeticCodeExt;
}
else
{
extension = null;
compressor = null;
}
}
public async void Decompress( )
{
var openFileDialog = new OpenFileDialog
{
Filter = $"Quantized huffman-encoded file|*.{Properties.Resources.HuffmanCodeExt}|" +
$"Quantized LZ77-encoded file|*.{Properties.Resources.Lz77Ext}|" +
$"Quantized arithmetic-encoded file|*.{Properties.Resources.ArithmeticCodeExt}",
ValidateNames = true
};
if ( openFileDialog.ShowDialog( ) != true )
return;
try
{
using ( var input = new FileInputStream( openFileDialog.FileName ) )
{
var dialog = new SaveFileDialog
{
DefaultExt = "csv",
Filter = "Text file|*.csv",
AddExtension = true
};
if ( dialog.ShowDialog( ) != true )
return;
var path = dialog.FileName;
var ext = Path.GetExtension( openFileDialog.FileName );
ICompressor compressor;
if ( ext == Properties.Resources.ArithmeticCodeExt )
{ compressor = new ArithmeticCodingCompressor( ); }
else if ( ext == Properties.Resources.Lz77Ext )
{ compressor = new LZ77HuffmanCompressor( DefaultWidth ); }
else
{ compressor = new HuffmanCompressor( ); }
var grid = await Task<IGrid>.Factory.StartNew( ( ) => compressor.Decompress( input ) );
var writer = new CsvGridWriter( ';' );
await Task.Factory.StartNew( ( ) => writer.Write( path, grid ) );
MessageBox.Show( "Done.", "Info", MessageBoxButton.OK, MessageBoxImage.Information );
}
}
catch ( Exception e )
{
MessageBox.Show( e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error );
}
}
public IEnumerable <Compression> GetCompressions()
{
var huffman = new HuffmanCompressor(env.ContentRootPath);
return(huffman.GetCompressions());
}
