from scipy import *
from pylab import *
import scipy.misc
'''
Prosta funkcja do wyswietlania obrazu.
img - obraz do wyswietlenia, monochromatyczny, z wartosciami pikseli z przedzialu [0.0, 1.0]
lub calkowitymi z przedzialu [0, 255]
imgTitle - tytul obrazu; opcjonalny, wartosc domyslna: '' (tekst pusty)
'''
def showImg(img, imgTitle = ''):
 figure()
 axis("off")
 title(imgTitle)
 vmax = 1.0 #domyslnie - obrazy float
 if "int" in str(img.dtype): #ale jesli obrazy int, to zakres do 255
  vmax = 255.
 imshow(img, cmap=cm.gray, vmin=0, vmax=vmax)
''' wczytanie obrazu i przeskalowanie wartosci '''
imgF = imread('samolot_mono.png') #obraz z wartosciami z przedzialu [0.0, 1.0]
imgI = (imgF*255).astype('uint8') #obraz z wartosciami calkowitymi z przedzialu [0, 255]
''' wczytanie obrazu funkcja scipy.misc.imread '''
img = scipy.misc.imread('samolot_mono.png') #obraz z wartosciami calkowitymi zprzedzialu [0, 255]
img2 = scipy.misc.imread('znak7.png')
imgtemp = scipy.misc.imread('znak7.png') #pomocnicza kopia znaku wodnego
showImg(img2, 'znak wodny')
'''funkcja ktora wpisuje znaki wodne na najmniej znaczacych bitach obrazu hosta'''
j=0 # pomocnicza zmienna ktora przechowuje numer rzedu znaku wodnego
showImg(img, 'obraz podstawowy')
for x in range(0,img.shape[0],1): # x oznaczac bedzie numer rzedu obrazu hosta krok jest 2 poniewaz w nastepnej petli pokrywamy wartosci z rzedu x+1
 i=0 #pomocnicza zmienna ktora przechowuje numer kolumny znaku wodnego
 if j==len(img2): #jesli j osiagnie wartosc 64 to ja zerujemy bo maksymalna dla naszego znaku do 63 (ma 64 rozdzielczosc ale liczymy od 0)
  j=0
 for y in range(0,img.shape[1],8): # y przechowuje numer kolumny obrazu hosta krok jest 2 poniewaz w nastepnej petli pokrywamy wartosci dla y+1
  if i==len(img2): # zerujemy gdy wartosc przekroczy rozdzielczosc znaku wodnego
   i=0;
   ''' tu wpisujemy wartosc piksela znaku wodnego na najmniej znaczace bity 8 pikseli
obrazu hosta w odpowienich miejscach
np pierwszy piksel znaku wodnego [0,0] na piksele [0,0], [0,1] , [1,0] , [0,1] obrazu
hosta'''
  if img2[j,i] !=0: #jesli wartosc piksela obrazu wodnego jest rowna 255
   img[x,y] |=0x01 #to zmieniamy najmniej znaczacy bit na 1
   img[x,y+1] |=0x01
   img[x,y+2] |=0x01
   img[x,y+3] |=0x01
   img[x,y+4] |=0x01
   img[x,y+5] |=0x01
   img[x,y+6] |=0x01
   img[x,y+7] |=0x01
  else: #jesli ma wartosc 0
   img[x,y]&=0xfe #to zmieniamy najmniejszy bit na 0
   img[x,y+1]&=0xfe
   img[x,y+2]&=0xfe
   img[x,y+3]&=0xfe
   img[x,y+4]&=0xfe
   img[x,y+5]&=0xfe
   img[x,y+6]&=0xfe
   img[x,y+7]&=0xfe
  i+=1 #przechodzimy do nastepnej kolumny
 j+=1 #przechodzimy do nastepnego wiersza
j=0
''' robimy tablice zer 64x64 ze znaku wodnego pomocniczego'''
for x in range(0, imgtemp.shape[0],1):
 for y in range(0, imgtemp.shape[1],1):
  imgtemp[x,y]=0


 '''odbicie lustrzane obrazu hosta. odbicie lewej strony obrazy na prawej'''
'''
for x in range(0, img.shape[0],1):
 for y in range(0,img.shape[1]/2,1):
  img[x,img.shape[1]-1-y]=img[x,y];
  '''

''' dodanie szumu impulsowego '''


threshold = 0.2 #prog okreslajacy jaki procent pikseli ma zostac zaszumiony
value = 1 #poczatkowa wartosc szumu (na zmiane wpisywana bedzie wartosc maksymalna i minimalna)
inoisedimg = zeros(img.shape) #utworzenie tablicy na obraz zaszumiony
for h in range(0, img.shape[0]): #dla kazdego wiersza
 for w in range(0, img.shape[1]): #dla kazdej kolumny
  n = rand() #losowanie liczby z przedzialu [0, 1]
  if n < threshold:
   inoisedimg[h][w] = value #wpisanie 'szumu'
   if value == 1: # \
    value = 0 # >zmiana wartosci 'szumu' - na zmiane wpisywana jest wartosc maksymalna i minimalna
   else: # |
    value = 1 # /
  else:
   inoisedimg[h][w] = img[h][w] #przepisanie wartosci piksela (brak szumu)
img = inoisedimg
#img = img*1.1 #zmiana kontrasu obrazu hosta
''' ponizej negatyw'''
'''
xp = [0, 255]
yp = [255, 0]
negimg = interp(img.flatten(), xp, yp)
img = negimg.reshape(img.shape)'''
img = img.astype('uint8') #po zmianie wartosci trzeba zmienic typ(kontrast)
#img = img +1 # rozjasniamy obraz
showImg(img, 'szum impulsowy')
j=0 #zmienna pomocnicza okreslajaca numer wiersza
''' w tej funkcji wyciagamy znak wodny z obrazu hosta '''
for x in range(0,img.shape[0],1):
 i=0 #zmienna pomocnicza okreslajaca numer komorki
 if j==len(img2):
  j=0
 for y in range(0,img.shape[1],8):
  if i==len(img2):
   i=0;
#ustawienie LSB dla 8 pikseli (po 1 piksel znaku wodnego na 8 obrazu hosta)
  if img[x,y] & 0x01:
   bit1 = 1.0 #ustawienie LSB na1
  else:
   bit1 = 0.0 #ustawienie LSB na 0
  if img[x,y+1] & 0x01:
   bit2 = 1.0
  else:
   bit2 = 0.0
  if img[x,y+2] & 0x01:
   bit3 = 1.0
  else:
   bit3 = 0.0
  if img[x,y+3] & 0x01:
   bit4 = 1.0
  else:
   bit4 = 0.0
  if img[x,y+4] & 0x01:
   bit5 = 1.0
  else:
   bit5 = 0.0
  if img[x,y+5] & 0x01:
   bit6 = 1.0
  else:
   bit6 = 0.0
  if img[x,y+6] & 0x01:
   bit7 = 1.0
  else:
   bit7 = 0.0
  if img[x,y+7] & 0x01:
   bit8 = 1.0
  else:
   bit8 = 0.0
  varbits = bit1 +bit2 + bit3 + bit4 + bit5 + bit6 + bit7 + bit8 # sumujemy
  imgtemp[j,i] += varbits # zwiekszamy wartosc o uzyskana sume np za kazdym razem jak trafimy na imgtemp[0,0] to te
#wartosci wszystkie nam sie zsumuja z kazdego wpisanego w obraz znaku wodnego( wyszlo ich 24)
  i+=1 #nastepny numer kolumny
 j+=1 #nastepny numer wiersza
'''konwertujemy uzyskane wartosci na jeden znak wodny'''
for x in range(0,imgtemp.shape[0],1):
 for y in range(0,imgtemp.shape[1],1):
  if imgtemp[x,y]<24/2*4:
   '''#jesli wartosci 1 bylo mniej niz wartosci 0 to ustawiamy wartosc na 0. 24 znaki
wodne mamy obrazie hosta mnozymy razy 4
bo 1 piksel znaku wodnego ->4 na obrazie hosta. jesli wartosci bylo po rowno
to ustawiamy na 255. dla odbicia lustrzanego sprawdzilam
rowniez co sie stanie jesli gdy wartosci 0 i 1 jest po rowno to ustawimy
wartosc na 0. (ustawimy w warunku znak <=)'''
   imgtemp[x,y]=0
  else:
   imgtemp[x,y]=255
showImg(imgtemp, 'znak wodny wyciagniety z obrazu hosta z szumem')
show()