Exemple #1
0
        private void GenerarCodigosPrefijo()
        {
            //Se agrega al diccionario<byte, string>, la key de tipo byte sirve para cuando va leyendo el texto
            //y si la encuentra en el diccionario agrega el value que es un string que va a tener el código prefijo
            foreach (var objetoCaracter in ListadoCaracteres)
            {
                if (!DiccionarioPrefijos.ContainsKey(objetoCaracter.Caracter))
                {
                    DiccionarioPrefijos.Add(objetoCaracter.Caracter, "");
                }
            }

            //Se va construyendo el "árbol" según las proobabilidades de ocurrencia de los caracteres
            while (ListadoCaracteres.Count != 1)
            {
                var nodoIzq = ListadoCaracteres[0];
                ListadoCaracteres[0] = null;
                ListadoCaracteres.RemoveAt(0);
                nodoIzq.Codigo += "0";

                var nodoDrch = ListadoCaracteres[0];
                ListadoCaracteres[0] = null;
                ListadoCaracteres.RemoveAt(0);
                nodoDrch.Codigo += "1";

                var nodoPadre = new ObjectCaracter(' ', 0, true);

                nodoPadre.Drch = nodoDrch;
                nodoPadre.Izq  = nodoIzq;

                nodoPadre.Probabilidad = nodoPadre.Drch.Probabilidad + nodoPadre.Izq.Probabilidad;

                ListadoCaracteres.Add(nodoPadre);
                ListadoCaracteres.Sort(ObjectCaracter.OrdenarPorProbabilidad);
            }

            var CodigoPrefijo = "";

            RecorrerArbol(ListadoCaracteres[0], CodigoPrefijo);
            ListadoCaracteres.RemoveAt(0);

            BufferLectura = new byte[largoBuffer];
        }
Exemple #2
0
        //---------------------------COMPRESION----------------------------------------------------------------------------------
        private void ObtenerTablaAparicionesProbabilidades()
        {
            //Se lee todo el archivo y se cuentan las apariciones de cada caracter del texto
            using (var file = new FileStream(RutaAbsolutaArchivoOriginal, FileMode.Open, FileAccess.Read))
            {
                using (var reader = new BinaryReader(file, Encoding.GetEncoding(28591)))
                {
                    while (reader.BaseStream.Position != reader.BaseStream.Length)
                    {
                        BufferLectura = reader.ReadBytes(largoBuffer);
                        var chars = Encoding.UTF8.GetChars(BufferLectura); //nuevo

                        foreach (var Caracter in chars)
                        {
                            //Predicado para buscar un caracter
                            Predicate <ObjectCaracter> BuscadorCaracter = delegate(ObjectCaracter ObjCaracter)
                            {
                                return(ObjCaracter.Caracter == Caracter);
                            };

                            //Si no encuentra el caracter que está leyendo en la lista de caracteres del texto
                            if (ListadoCaracteres.Find(BuscadorCaracter) == null)
                            {
                                //Crea un objeto caracter
                                var objCaracter = new ObjectCaracter(Caracter, 0, false);
                                objCaracter.CantidadRepetido++;
                                ListadoCaracteres.Add(objCaracter);
                            }
                            else
                            {
                                //Si lo encuentra le suma otra aparición en el texto
                                ListadoCaracteres.Find(BuscadorCaracter).CantidadRepetido++;
                            }
                            CantidadCaracteres++;
                        }
                    }
                }
            }

            //Se calcula la probabilidad de apariciones de cada caracter en el texto
            foreach (var objetoCaracter in ListadoCaracteres)
            {
                objetoCaracter.CalcularProbabilidad(CantidadCaracteres);
            }

            ListadoCaracteres.Sort(ObjectCaracter.OrdenarPorProbabilidad);

            //Se agrega al diccionario de apariciones el valor del caracter y su repetición en el texto
            foreach (var objetoCaracter in ListadoCaracteres)
            {
                DiccionarioApariciones.Add(objetoCaracter.Caracter, objetoCaracter.CantidadRepetido);
            }

            var linea = "";

            //Se va contruyendo la tabla que se irá a escribir al documento *.huff
            foreach (var caracter in DiccionarioApariciones)
            {
                if (caracter.Key == '\n')
                {
                    linea += "/n " + caracter.Value + "|";
                }
                else if (caracter.Key == '\t')
                {
                    linea += "/t " + caracter.Value + "|";
                }
                else if (caracter.Key == '\r')
                {
                    linea += "/r " + caracter.Value + "|";
                }
                else if (caracter.Key == ' ')
                {
                    linea += "esp " + caracter.Value + "|";
                }
                else
                {
                    linea += caracter.Key + " " + caracter.Value + "|";
                }
            }

            linea  = linea.Remove(linea.Length - 1);
            linea += Environment.NewLine;

            var bufferTabla = Encoding.UTF8.GetBytes(linea);
            var tabla       = Encoding.UTF8.GetChars(bufferTabla);

            //Se escribe la tabla en el arcivo
            using (var file = new FileStream(RutaAbosolutaServer + NombreArchivoOperado, FileMode.Create))
            {
                using (var writer = new BinaryWriter(file, Encoding.UTF8))
                {
                    writer.Write(tabla);
                }
            }
        }
Exemple #3
0
        //-----------------------------------------------------------------------------------------------------------------------

        //--------------------------DESCOMPRESION--------------------------------------------------------------------------------
        private int ObtenerTabla()
        {
            BufferLectura = new byte[largoBuffer];

            var leerHasta  = 0;
            var lineaTabla = "";

            using (var file = new FileStream(RutaAbsolutaArchivoOriginal, FileMode.Open))
            {
                using (var reader = new BinaryReader(file, Encoding.UTF8))
                {
                    while (reader.BaseStream.Position != reader.BaseStream.Length)
                    {
                        BufferLectura = reader.ReadBytes(largoBuffer);

                        for (int i = 0; i < BufferLectura.Length; i++)
                        {
                            leerHasta++;

                            if (BufferLectura[i] == 13)
                            {
                                reader.BaseStream.Position = reader.BaseStream.Length;
                                i = largoBuffer;
                            }
                        }
                    }
                    reader.BaseStream.Position = 0;
                    lineaTabla = Encoding.UTF8.GetString(reader.ReadBytes(leerHasta - 1));
                }
            }

            var itemsTabla = lineaTabla.Split('|');

            //Este objeto caracter por el momento es un string "A 12" con caracter y repeticion
            foreach (var objetoCaracter in itemsTabla)
            {
                char caracter = ' ';

                if (objetoCaracter != "" && objetoCaracter != " ")
                {
                    var repeticion = int.Parse(objetoCaracter.Split(' ')[1]);

                    if (objetoCaracter.Split(' ')[0] == "/r")
                    {
                        caracter = '\r';
                    }
                    else if (objetoCaracter.Split(' ')[0] == "/n")
                    {
                        caracter = '\n';
                    }
                    else if (objetoCaracter.Split(' ')[0] == "/t")
                    {
                        caracter = '\t';
                    }
                    else if (objetoCaracter.Split(' ')[0] == "esp")
                    {
                        caracter = ' ';
                    }
                    else
                    {
                        caracter = Convert.ToChar(objetoCaracter.Split(' ')[0]);
                    }

                    CantidadCaracteres += repeticion;

                    var _objetoCarater = new ObjectCaracter(caracter, repeticion, false);
                    ListadoCaracteres.Add(_objetoCarater);
                }
            }

            foreach (var objectCaracter in ListadoCaracteres)
            {
                objectCaracter.CalcularProbabilidad(CantidadCaracteres);
            }

            return(leerHasta);
        }