class WatermarkerUI(Tk):
def __init__(self):
# Initialize Tk
super().__init__()
# Create watermarker variable to contain watermarker object when initialized
self.watermarker = None
# Initialize Tk window (self is window now)
self.title("Watermarker")
# Style the widgets - import everything from ttk (tkinter.ttk *), otherwise not working
# self.style = Style(self)
# print(self.style.theme_names())
# print(self.style.theme_use("vista"))
self.config(padx=40, pady=40)
# Canvas for the image
#self.canvas = Canvas(width=300, height=300)
#self.canvas.grid(column=2, row=0)
# Main UI
self.label_text = Label(text="Watermark text:", font=("Segoe UI", 12))
self.label_text.grid(column=0, row=1)
self.entry_text = Entry()
self.entry_text.grid(column=1, row=1, columnspan=2, sticky="EW")
self.button_batch = Button(text="Batch images",
command=self.batch_watermark)
self.button_batch.grid(column=1, row=2, columnspan=1)
self.button_load = Button(text="Watermark one image",
command=self.add_watermark)
self.button_load.grid(column=2, row=2, columnspan=1)
# self.mainloop()
def initialize_watermaker(self):
text = self.entry_text.get()
# Create Watermarker object and pass it text from entry_text
self.watermarker = Watermarker(text)
def add_watermark(self):
self.initialize_watermaker()
# Open image
self.watermarker.open_image()
def batch_watermark(self):
self.initialize_watermaker()
# Open directory
self.watermarker.open_directory()
#!/usr/bin/python
import sys
import os
from optparse import OptionParser
from watermarker import Watermarker
from scipy import misc
parser = OptionParser()
parser.add_option("-o", "--outfile", dest="outfile", default = None,
help="output filename", metavar="FILE")
parser.add_option("-k", dest="k", type=int, default=6,
help="The k value to use in embedding (default is 6)")
if __name__ == "__main__":
(options, args) = parser.parse_args()
if len(args) != 2:
parser.error("Usage: <input file> <payload>")
infile, payload = args
if len(payload) > 6:
parser.error("Payload too long (up to 6 bytes)")
if not options.outfile:
options.outfile = "%s-%s.png" % (os.path.basename(infile).split(".")[0], payload)
w = Watermarker(6, 4)
misc.imsave(options.outfile, w.embed(misc.imread(infile), payload, options.k))
print "Created %s" % (options.outfile,)
print "Minimum JPG quality:", test_jpg(w, out)
print "Max Gaussian sigma:", test_filter(
w, out, "gauss-%s.png", gaussian_filter,
[i / 10.0 for i in range(1, 50)])
print "Max Laplacian of Gaussian sigma:", test_filter(
w, out, "log-%s.png", gaussian_laplace,
[i / 10.0 for i in range(1, 50)])
print "Max tv-denoising weight:", test_filter(
w, out, "tv-%s.png", tv_denoise, range(50, 1000, 25))
print "Max noise ratio: ", test_filter(
w, out, "noise-%s.png", add_noise,
[i / 20.0 for i in range(1, 20)])
print "Max random block coverage: ", test_filter(
w, out, "blocks-%s.png",
lambda img, k: add_blocks(img, k, 50, 50),
[i / 20.0 for i in range(1, 20)])
for flt in [
"contour", "detail", "edge_enhance", "edge_enhance_more",
"emboss", "find_edges", "smooth", "smooth_more", "sharpen"
]:
print "Max iterations of %r:" % (flt, ), test_recursive_filter(
w, out, "%s-%%s.png" % (flt, ),
lambda img: misc.imfilter(img, flt), range(1, 30))
print
if __name__ == "__main__":
w = Watermarker(6, 4)
run_tests(w, "123456", [2, 4, 6, 8])
def initialize_watermaker(self):
text = self.entry_text.get()
# Create Watermarker object and pass it text from entry_text
self.watermarker = Watermarker(text)
# Created by: Dare McAdewole <*****@*****.**>
from watermarker import Watermarker
from pathlib import Path
if __name__ == '__main__':
if (Watermarker.watermark('.../gordon.png', '.../echwoodd/lo.png',
'.../echwood-steve.png',
Watermarker.Position.top_right)):
print('Image watermarked successfully!')
else:
print('Image could not be watermarked')
import os
import numpy
from scipy import misc
from watermarker import Watermarker
from test import test_jpg, add_blocks, add_noise, test_filter, test_recursive_filter
from scipy.ndimage.filters import gaussian_filter, gaussian_laplace, uniform_filter, median_filter
from skimage.filter import tv_denoise
w = Watermarker(6, 4)
src = misc.imread("scans/facescan.png")
print w.extract(src)
print test_jpg(w, src)
#src = misc.lena()
#markers = [Watermarker(6, 4, seed = seed) for seed in range(50)]
#text = "the quick brown fox jumped over the lazy dog and laughed a great deal"
#
#for i, w in enumerate(markers):
# src = w.embed(src, text[i:i+6])
# print "%s\t%s" % (i+1, test_jpg(markers[0], src))
#out = w2.embed(out, "789012", k = 4, tv_denoising_weight = 0)
#out2 = misc.imread("orig.png")
#out2 = misc.imread("facescan.png")
#print w.extract(out2)
#print "min jpg quality:", test_jpg(w, out2)
#print w2.extract(out2)
#print "min jpg quality:", test_jpg(w2, out2)
import numpy
from scipy import misc
from watermarker import Watermarker
from test import test_jpg, add_blocks, test_filter
from skimage.exposure import rescale_intensity
w = Watermarker(6, 4)
w2 = Watermarker(6, 4, mother="haar", seed=212219812811)
# src = misc.imread("../qrmark/pics/sky.png")
src = misc.imread("pics/face.jpg")
# src = misc.lena()
out = w.embed(src, "123456", k=3, tv_denoising_weight=0)
out = w2.embed(out, "789012", k=4, tv_denoising_weight=0)
misc.imsave("orig.png", out)
out2 = misc.imread("orig.png")
print w.extract(out2)
print "min jpg quality:", test_jpg(w, out2)
print w2.extract(out2)
print "min jpg quality:", test_jpg(w2, out2)
# import random
# random.seed(3286912)
# print "Max random block coverage: ", test_filter(w, out2, "blocks-%s.png",
# lambda img, k: add_blocks(img, k, 50, 50), [i/20.0 for i in range(1, 20)])
parser.add_option("-m", dest="mother", type=str, default = "bior3.1",
help="The mother wavelet (default is bior3.1)")
parser.add_option("-t", dest="tv_weight", type=int, default = 0,
help="TV denoising weight (default is 0, meaning no denoising is performed)")
parser.add_option("-p", dest="payload_length", type=int, default = 6,
help="Payload length (default is 6)")
parser.add_option("-e", dest="ecc_length", type=int, default = 4,
help="ECC length (default is 4)")
if __name__ == "__main__":
(options, args) = parser.parse_args()
if len(args) != 2:
parser.error("Usage: [options] <input image file> <payload>")
infile, payload = args
if not options.outfile:
options.outfile = "%s-%s.png" % (os.path.basename(infile).split(".")[0], payload)
t0 = time.time()
w = Watermarker(options.payload_length, options.ecc_length, seed = options.seed,
mother = options.mother)
out = w.embed(misc.imread(infile), payload, options.k)
t1 = time.time()
if options.tv_weight > 0:
out = tv_denoise(out, options.tv_weight)
misc.imsave(options.outfile, out)
print "Created %s in %s seconds" % (options.outfile, t1-t0)
type=int,
default=6,
help="Payload length (default is 6)")
parser.add_option("-e",
dest="ecc_length",
type=int,
default=4,
help="ECC length (default is 4)")
if __name__ == "__main__":
(options, args) = parser.parse_args()
if len(args) != 2:
parser.error("Usage: [options] <input image file> <payload>")
infile, payload = args
if not options.outfile:
options.outfile = "%s-%s.png" % (
os.path.basename(infile).split(".")[0], payload)
t0 = time.time()
w = Watermarker(options.payload_length,
options.ecc_length,
seed=options.seed,
mother=options.mother)
out = w.embed(misc.imread(infile), payload, options.k)
t1 = time.time()
if options.tv_weight > 0:
out = tv_denoise(out, options.tv_weight)
misc.imsave(options.outfile, out)
print "Created %s in %s seconds" % (options.outfile, t1 - t0)
#!/usr/bin/python
import sys
import os
from watermarker import Watermarker
from scipy import misc
if __name__ == "__main__":
if len(sys.argv) != 2:
parser.error("Usage: <input file>")
w = Watermarker(6, 4)
print w.extract(misc.imread(sys.argv[1]))
import time
from watermarker import Watermarker
from scipy import misc
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-s", dest="seed", type=int, default = 1895746671,
help="The PRNG seed (if not given, a default one is used)")
parser.add_option("-m", dest="mother", type=str, default = "bior3.1",
help="The mother wavelet (default is bior3.1)")
parser.add_option("-p", dest="payload_length", type=int, default = 6,
help="Payload length (default is 6)")
parser.add_option("-e", dest="ecc_length", type=int, default = 4,
help="ECC length (default is 4)")
if __name__ == "__main__":
(options, args) = parser.parse_args()
if len(args) != 1:
parser.error("Usage: [options] <input image file>")
w = Watermarker(options.payload_length, options.ecc_length, seed = options.seed,
mother = options.mother)
src = misc.imread(sys.argv[1])
t0 = time.time()
print w.extract(src)
t1 = time.time()
print "Extraction took %s" % (t1 - t0,)
