huff_unzip.py
===================================
from make_tree import *
def str_to_int(s, n):
i = n - 1
sum = 0
j = 1
while i >= 0:
sum = sum + j * ord(s[i])
i = i - 1
j = j * 256
return sum
def ascii_to_bin(s):
k = ord(s)
sp = ''
saras = []
while k > 0:
p = k % 2
k = k / 2
sp = sp + str(p)
saras.append(p)
k = 7 - len(saras) + 1
while k > 0:
saras.append(0)
k = k - 1
saras.reverse()
sk = ''
for i in saras:
sk = sk + str(i)
return sk
global eilute
eilute = ''
def tree_reverse(m, s):
if m.left == None and m.right == None:
global eilute
eilute = eilute + chr(m.freq)
return
if len(s) > 0:
x = s[0]
del s[0]
if x == '0': tree_reverse(m.left, s)
if x == '1': tree_reverse(m.right, s)
f = open('failas.krf', 'r')
p = f.read(2)
k = str_to_int(p,2)
p = f.read(k + k*2)
i = 0
medis = {}
while i < (k+k*2):
s = ''
s = p[i+1] + p[i+2]
j = str_to_int(s,2)
medis[ord(p[i])] = j
i = i + 3
l = f.read(1)
print 'l=' + l
sp = ''
if l == '|':
c = 't'
sp = ''
while c != '|':
c = f.read(1)
if c != '|': sp = sp + c
print 'l= ' + sp
m = make_tree(medis)
code = ''
print_tree(m, None, code)
ptr = f.read()
p = ''
for i in ptr:
p = p + ascii_to_bin(i)
ptr = list(l)
print p
for i in sp:
p = p + str(i)
p = list(p)
print p
while len(p) > 0:
tree_reverse(m, p)
print eilute
make_tree.py
=======================
'''
simple huffman tree
gives binary codes
written by kestaz
'''
from copy import deepcopy
class tree:
def __init__(self,freq,value):
self.value = value
self.freq = freq
self.right = None
self.left = None
def make_simple_tree(m):
l = []
for i in m:
l.append(i.freq)
l.sort()
x = l[0]
del l[0]
y = l[0]
for v,i in enumerate(m):
if x == i.freq:
t = 1
p1 = deepcopy(i)
v1 = v
if t == 1:
t = 0
del m[v1]
for v,i in enumerate(m):
if y == i.freq:
t = 1
p2 = deepcopy(i)
v2 = v
if t == 1:
del m[v2]
f = tree(p1.freq+p2.freq,'*')
f.right = p1
f.left = p2
m.append(f)
array = {}
def print_tree(d, c, code):
global array
if d != None:
if c != None: code = code + str(c)
if d.left == None and d.right == None:
print str(d.freq) + ' ' + str(d.value)
array[d.freq] = [d.value, code]
print code
code = ''
return
print_tree(d.right,1, code)
print_tree(d.left, 0, code)
def tree_print(d):
if d == None: return
print str(d.freq) + ' ' + str(d.value)
tree_print(d.left)
tree_print(d.right)
d = { 5: 1, 7: 2, 10: 3, 15: 4, 20: 5, 45:6}
m = []
def make_tree(d):
for i in d.keys():
k = d[i]
m.append(tree(i,k))
while len(m)>1:
make_simple_tree(m)
code = ''
return m[0]
#make_tree(d)
#code = ''
#print_tree(m[0], None, code)
#print ''
#tree_print(m[0])
huff.py
=========================
from make_tree import *
from copy import deepcopy
from string import split
def bin_str_convert_to_int(bin_code):
i = 7
j = 1
sum = 0
while i >= 0:
if bin_code[i] == '1': sum = sum + j * 1
j = j * 2
i = i - 1
return sum
def insert_ascii(num,num_len):
s = ''
while num > 0:
k = num % 256
num = num / 256
s = s + chr(k)
p = num_len - len(s) + 1
if p > 0:
s_tr = ''
while p > 1:
s_tr = s_tr + chr(0)
p = p - 1
s_tr = s_tr + s
return s_tr
if p == 0: return s
return s
file_name = 'failas.txt'
f = open('failas.txt')
text = f.read()
freq = {}
for i in text:
p = ord(i)
freq[p] = 0
for i in text:
p = ord(i)
k = freq[p]
k = k + 1
freq[p] = k
print freq
m = make_tree(freq)
code = ''
print_tree(m, None, code)
output = ''
print array
p = 0
for i in text:
t = 0
for k in array:
if i == chr(k):
t = 1
if t != 1:
p = 1
if p == 0:
print 'Tree created'
huffcode = ''
for i in text:
t = 0
for k in array:
if i == chr(k):
huffcode = huffcode + array[k][1]
print huffcode
print 'huffcode binary code length ' + str(len(huffcode))
huff_list = list(huffcode)
ascii_code = ''
while len(huff_list) > 8:
one_byte = ''
for i in range(8):
x = huff_list[0]
one_byte = one_byte + x
del huff_list[0]
k = bin_str_convert_to_int(one_byte)
ascii_code = ascii_code + chr(k)
print ascii_code
print 'last elements: ' + str(huff_list)
name, ext = split(file_name, '.')
f = open(name + '.krf', 'w')
f.write(insert_ascii(len(array),2 ))
for i in array.keys():
f.write(insert_ascii(i,1) + insert_ascii(array[i][0],2))
i = 7 - len(huff_list) + 1
s = ''
#while i > 0:
# s = s + '0'
# i = i - 1
for i in huff_list:
s = s + str(i)
#k = bin_str_convert_to_int(s)
f.write('|' + s + '|')
f.write(ascii_code)
f.close()
else:
print 'make tree error'