if LANGUAGE == "PL":

opis = """

Celem projektu jest implementacja algorytmu do samo-rekonstrukcji

obrazow cyfrowych z wykorzystaniem kodowania fraktalnego.

Samo-rekonstrukcja (ang. self-recovery lub self-embedding) pozwala

na weryfikacje integralnosci zdjecia oraz na odtworzenie jego

oryginalnej tresci w oparciu o cyfrowy znak wodny. Opracowana

w ramach projektu aplikacje nalezy wyposazyc w graficzny interfejs

uzytkownika pozwalajacy na dostosowanie parametrow algorytmu oraz

na zabezpieczanie i weryfikacje integralnosci obrazow cyfrowych.

"""

decode_tab_name = "Zakoduj"

code_tab_name = "Dekoduj"

about_tab_name = "O programie"

block_size_label = """

Rozmiar bloku

(domyslnie 3)

"""

unable_to_open = "Nie mozna przetworzyc pliku. Sprobuj ponownie"

data_label = "Dostosuj opcje:"

save_data = "Zapisz dane"

load_file = "Otworz plik"

button_code = "Wykonaj kompresje i kodowanie"

button_decode = "Wykonaj dekompresje i dekodowanie"

in_progress = "Praca w toku..."

about_title = "TC-SEFR \n Uwierzytelnianie obrazow cyfrowych \nz wykorzystaniem kodowania fraktalnego \n\n Adam Niedzialkowski, Antoni Grzanka \n Akademia Gorniczo-Hutnicza w Krakowie"

visit_git = "Nasze repozytorium na GitHubie"

else:

opis = """\n\n

The aim of the project is to implement an algorithm for self-reconstruction

of digital images using fractal coding. Self-reconstruction (called self-recovery

or self-embedding) allows user to verify the integrity of the images and to

reconstruct the original content based on the digital watermark. Application

developped in the project is equipped with a graphical user interface that

allows user to adjust the algorithm parameters and to protect and verify

the integrity of digital image.

In this program, we implement algorithm from

"""

decode_tab_name = "Decode"

code_tab_name = "Code"

about_tab_name = "About"

block_size_label = """

Block size

(default 3)

"""

unable_to_open = "Unable to open/parse file. Try again"

data_label = "Configure options:"

save_data = "Save"

load_file = "Load file"

button_code = "Perform compression and coding"

button_decode = "Perform decompression and decoding"

in_progress = "Working..."

about_title = "TC-SEFR \n Authentication of digital image using fractal compression \n\n Adam Niedzialkowski, Antoni Grzanka \n AGH University of Science and Technology, Cracow"

def __init__(self, master, name):

Frame.__init__(self, master, width=700, height=400)

self.pack_propagate(0)

def __init__(self, master=None, init_name=None):

Frame.__init__(self, master, height=500)

self.tabs = {}

self.buttons = {}

self.current_tab = None

self.init_name = init_name

def show(self):

self.pack(side=TOP, fill=Y)

self.switch_tab(self.init_name or self.tabs.keys()[2]) # tutaj ostatnio zmienialem

def add(self, tab, tab_img, tab_name):

tab.pack_forget() # hide the tab on init

self.tabs[tab.tab_name] = tab # add it to the list of tabs

b = Button(self, text=tab.tab_name, relief=BASE, command=(lambda name=tab.tab_name: self.switch_tab(name)))

b.configure(image=tab_img)

b.configure(text=tab_name, compound=BOTTOM)

b.pack(side=LEFT) # pack the buttont to the left mose of self

self.buttons[tab.tab_name] = b # add it to the list of buttons

def delete(self, tabname):

if tabname == self.current_tab:

self.current_tab = None

self.tabs[tabname].pack_forget()

del self.tabs[tabname]

self.switch_tab(self.tabs.keys()[0])

else: del self.tabs[tabname]

self.buttons[tabname].pack_forget()

del self.buttons[tabname]

def switch_tab(self, name):

if self.current_tab:

self.buttons[self.current_tab].config(relief=BASE)

self.tabs[self.current_tab].pack_forget() # hide the current tab

self.tabs[name].pack(side=TOP, expand=YES, fill=Y) # tu grzebalem # add the new tab to the display

self.current_tab = name # set the current tab to itself

def __init__(self, root):

# default options for opening file

self.file_opt = options = {}

options['defaultextension'] = '.pgm'

options['filetypes'] = [('all files', '.*'), ('pgm files', '.pgm')]

options['initialdir'] = 'C:\\'

options['initialfile'] = 'myfile.pgm'

options['parent'] = root

options['title'] = 'PGM files'

def openfilename(self, which):

#tkFileDialog

global compressedname, decompressedname

try:

filename = tkFileDialog.askopenfilename(**self.file_opt)

if filename[-3:] not in ["pgm","PGM","Pgm"]:

raise IOError

except IOError:

print Strings.unable_to_open

else:

global image, imageToDecode, imageToDecode_thumb, image_thumb

if which=="code":

try:

image = img(filename)

except IOError:

print Strings.unable_to_open

else:

image.setflags(write=True)

head, tail = os.path.split(filename)

image.nazwa = tail

compressedname = tail[0:-4]

image.format = filename[-3:]

# resizing to fit the screen - does not support other than square!

image_thumb = image.resize((425,425))

image_thumb = preparePhotoImage(image_thumb)

# update image

img_code_label.configure(image=image_thumb)

img_code_label.image=image_thumb

CurrentData.refresh_img()

perform_button.configure(state=NORMAL)

saved_compressed.configure(text="")

elif which=="decode":

try:

imageToDecode = img(filename)

except IOError:

print Strings.unable_to_open

else:

imageToDecode.setflags(write=True)

head, tail = os.path.split(filename)

imageToDecode.nazwa = tail

decompressedname = tail[0:-4]

imageToDecode.format = filename[-3:]

# resizing to fit the screen - does not support other than square!

imageToDecode_thumb = imageToDecode.resize((425,425))

imageToDecode_thumb = preparePhotoImage(imageToDecode_thumb)

# update image

img_decode_label.configure(image=imageToDecode_thumb)

img_decode_label.image=imageToDecode_thumb

CurrentData.refresh_imgDecode()

authenticate_button.configure(state=NORMAL)

auth_label.configure(text="")

def refresh_opt(self):

global sizeOfBlock, deltaFromSlider, eFromSlider, lumFromSlider

title = "\n Current data:"

blocksize="Block size: " + str(block_size_slider.get())

sizeOfBlock = block_size_slider.get()

deltaFromSlider = delta_slider.get()

eFromSlider = e_slider.get()

lumFromSlider = lum_slider.get()

deltaFromSlider_txt = "Delta: " + str(delta_slider.get())

eFromSlider_txt = "E threshold: " + str(e_slider.get())

lumFromSlider_txt = "DCT threshold: " + str(lum_slider.get())

current_data=title + "\n" + blocksize + " " + deltaFromSlider_txt + " " + eFromSlider_txt + " " + lumFromSlider_txt

current_data_label.configure(text=current_data)

def refresh_img(self):

title = "Image data: "

img_name = "Filename: " + str(image.get_nazwa())

img_format = "Format: " + str(image.format)

img_size = "Image size: " + str(image.width()) + "x" + str(image.height())

img_data = title + "\n" + img_name + "\n" + img_format + ", " + img_size

img_data_label.configure(text=img_data)

def refresh_imgDecode(self):

title = "Image data: "

img_name = "Filename: " + str(imageToDecode.get_nazwa())

img_format = "Format: " + str(imageToDecode.format)

img_size = "Image size: " + str(imageToDecode.width()) + "x" + str(imageToDecode.height())

imgDecode_data = title + "\n" + img_name + "\n" + img_format + ", " + img_size

# global checksum_done, coefB_done, coefC_done, reconstr_done

def do_image(which):

if which=="code":

global code_animation

wrap.delete('ani')

wrap.create_image(80,100,image=code_animation[currentframe], tag='ani')

elif which=="decode":

global decode_animation

wrap.delete('ani')

wrap.create_image(80,100,image=decode_animation[currentframe], tag='ani')

if t.is_alive():

try:

do_image(which)

except IndexError:

currentframe = 0

do_image(which)

wrap.update_idletasks() #Force redraw

time_now = time.clock()

time_elapsed.set(secondformat(time_now-time_start))

currentframe = currentframe + 1

# Call myself again to keep the animation running in a loop

window.after(100, do_animation, currentframe, window, wrap, time_start, time_elapsed, which, t, working_label)

else:

nr *= 1000

nr = int(nr)

ms = nr % 10

nr -= ms

nr /= 10

seconds = nr%60

minutes = (nr - seconds)/60

if (seconds<10):

secondsS = "0" + str(seconds)

else:

secondsS = str(seconds)

if (minutes == 0):

minutesS = "0"

else:

minutesS = str(minutes)

msS = str(ms)

def finished(self, window, label, which):

label.configure(text="Finished!")

a = Timer(2.0, window.destroy)

a.start()

if which=="code":

savedas = "Saved as " + compressedname + "_watermarked.pgm"

saved_compressed.configure(text=savedas)

elif which=="decode":

savedas = "Saved as " + decompressedname + "_reconstructed.pgm"

saved_decompressed.configure(text=savedas)

def perform(self):

global code_animation, done, image

# tu byla funkcja finished

print "Called perform handler!"

window = Toplevel(root)

t = Process(target=main.perform_compression, args=(image,sizeOfBlock,CALC,deltaFromSlider,eFromSlider,lumFromSlider, compressedname))

for i in range(0,77):

if i in range(0,10):

num = "0" + str(i)

else:

num = str(i)

filename = "animation/code" + num + ".gif"

code_animation.append(PhotoImage(file=filename))

window.overrideredirect(1)

working_label = Label(window, text=Strings.in_progress)

working_label.pack(expand=YES, fill=BOTH)

wrap = Canvas(window, width=160, height=200)

wrap.pack(expand=YES, fill=BOTH)

time_start = time.clock()

time_now = time.clock()

time_elapsed = StringVar()

time_elapsed.set(secondformat(time_now-time_start))

time_label = Label(window, textvariable=time_elapsed)

time_label.pack(expand=YES, fill=X)

button_stop = Button(window, text="STOP", command=lambda:Handlers.destroywindow(window,t))

button_stop.pack(expand=YES, fill=BOTH)

window.after(10, do_animation, 0, window, wrap, time_start, time_elapsed, "code", t, working_label)

window.geometry("+" + str(SCREEN_WIDTH/2 - 160/2) + "+" + str(SCREEN_HEIGHT/2 - 200/2) )

t.start()

window.mainloop()

def authenticate(self):

global imageToDecode, sizeOfBlock, eFromSlider, deltaFromSlider, lumFromSlider, returnedFromAuth

abc = main.authenticate(imageToDecode, 8, CALC, deltaFromSlider, eFromSlider, lumFromSlider)

returnedFromAuth = abc

ones = [0,0,0]

count = [0,0,0]

wat = 0

for block in abc:

ones[wat] = 0

count[wat] = 0

for i in block:

for j in i:

count[wat] += 1

if j == 1:

ones[wat] +=1

wat +=1

first = ones[0]/float(count[0])

second = ones[1]/float(count[1])

third = ones[2]/float(count[2])

auth_text = "Checksum: " + str(ones[0]) + "/" + str(count[0]) + "\nWatermarks: \nA: " + str(ones[0]) + "/" + str(count[0]) + " B: " + str(ones[1]) + "/" + str(count[1]) + " C: " + str(ones[2]) + "/" + str(count[2])

auth_label.configure(text=auth_text)

decode_button.configure(state=NORMAL)

def destroywindow(self, window, t):

print "Stopped!"

window.destroy()

if t == False:

pass

else:

t.terminate()

def decode(self):

global decode_animation, checksum_flag, coefC_flag, coefB_flag, reconstr_flag, imageToDecode

# finish and close small window

def finished(window, label, which):

label.configure(text="Finished!")

t = Timer(2.0, window.destroy)

t.start()

savedas = "Saved as " + decompressedname + ".pgm"

saved_decompressed.configure(text=savedas)

print "Called decode handler"

window = Toplevel(root)

for i in range(0,77):

if i in range(0,10):

num = "0" + str(i)

else:

num = str(i)

filename = "animation/decode" + num + ".gif"

decode_animation.append(PhotoImage(file=filename))

window.overrideredirect(1)

working_label = Label(window, text=Strings.in_progress)

working_label.grid(row=0, column=0, columnspan=2)

wrap = Canvas(window, width=160, height=200)

wrap.grid(row=1, column=0, columnspan=2)

time_start = time.clock()

time_now = time.clock()

time_elapsed = StringVar()

time_elapsed.set(secondformat(time_now-time_start))

# none = PhotoImage(file="images/none.gif")

# checksum_done = Label(window,image=none)

# checksum_done.grid(row=3, column=0, sticky=E)

# checksum = Label(window, text="Checksum... ")

# checksum.grid(row=3,column=1, sticky=W)

# coefB_done = Label(window, image=none)

# coefB_done.grid(row=4,column=0, sticky=E)

# coefB = Label(window, text="Calculating B... ")

# coefB.grid(row=4,column=1, sticky=W)

# coefC_done = Label(window, image=none)

# coefC_done.grid(row=5,column=0, sticky=E)

# coefC = Label(window, text="Calculating C... ")

# coefC.grid(row=5,column=1, sticky=W)

# reconstr_done = Label(window, image=none)

# reconstr_done.grid(row=6, column=0, sticky=E)

# reconstr = Label(window, text="Reconstructing...")

# reconstr.grid(row=6,column=1, sticky=W)

# przyklady "zapalania" poszczegolnych "lampek"

#

# wykonano coefB:

# markAsDone(coefB_done, "done")

#

# t = Timer(5.0, markAsDone, (checksum_done, "done"))

# t.start()

# t2 = Timer(3.0, markAsDone, (coefB_done, "done"))

# t2.start()

# t3 = Timer(4.0, markAsDone, (coefC_done, "done"))

# t3.start()

# zakonczono?

# wywolaj finished(window, working_label)

# t4 = Timer(6.0, finished, (window, working_label))

# t4.start()

t = Process(target=main.reconstruction, args=(imageToDecode,8,returnedFromAuth, decompressedname))

time_label = Label(window, textvariable=time_elapsed)

time_label.grid(row=7, column=0, columnspan=2)

button_stop = Button(window, text="STOP", command=lambda:Handlers.destroywindow(window, False))

button_stop.grid(row=8, column=0, columnspan=2)

window.after(10, do_animation, 0, window, wrap, time_start, time_elapsed, "decode", t, working_label)

window.geometry("+" + str(SCREEN_WIDTH/2 - 160/2) + "+" + str(SCREEN_HEIGHT/2 - 200/2) )

t.start()

""" Input is any kind of ndarray, output is PhotoImage"""

imageArr = img.view(np.ndarray)

imageInst= Image.fromarray(imageArr, "L")