def cat_detection():
input_image = "images/black_cat.jfif"
catImg = Cat(input_image, catCascade)
faces = catImg.detect_face()
img = catImg.draw_rectangle(faces)
blur(input_image, faces, 10)
catImg.show_img(img)
def facial_blur():
input_image = "images/lcd_soundsystem.jpg"
faceImg = Img(input_image, faceCascade)
faces = faceImg.detect_face()
img = faceImg.draw_rectangle(faces)
blur(input_image, faces, 5)
faceImg.show_img(img)
def main():
if len(args) == 2:
puzzle()
elif len(args) == 5:
fade()
elif len(args) == 3:
blur()
else:
print('Error: Incorrect Number of Arguments')
def main(infile, outfile, iterations):
b = blur.blur()
img = misc.imread(infile, mode='RGB')
(height, width, channels) = img.shape
blurred = b.main(iterations, img)
# The .get() is to retrieve a Numpy array from the PyOpenCL array
# being returned.
misc.imsave(outfile, blurred.get().astype(numpy.uint8))
def main(infile, outfile, iterations):
b = blur.blur()
img = misc.imread(infile, mode='RGB')
(height, width, channels) = img.shape
blurred = b.main(iterations, img)
w = png.Writer(width, height, greyscale=False, alpha=False, bitdepth=8)
with open(outfile, 'wb') as f:
w.write(f, numpy.reshape(blurred.astype(numpy.uint8), (height, width*3)))
def main(infile, outfile, iterations):
b = blur.blur()
img = misc.imread(infile, mode='RGB')
(height, width, channels) = img.shape
blurred = b.main(iterations, img)
# The .get() is to retrieve a Numpy array from the PyOpenCL array
# being returned.
misc.imsave(outfile, blurred.get().astype(numpy.uint8))
def testBlurDistanceIsSmall(self):
n = 40
A, b, x = blur.blur(n, 3, 0.8)
diff = A * x - b
sum_squares_diff = numpy.sum(diff ** 2) / (n ** 2)
sum_squares_b = numpy.sum(b ** 2) / (n ** 2)
epsilon = 0.01
print("square error", sum_squares_b, sum_squares_diff, file=sys.stderr)
self.assertGreater(epsilon * sum_squares_b, sum_squares_diff)
def main():
global OUTPUT_FILES
use_squirrel = ("squirrel" in sys.argv)
use_squirrel = True
# Don't allow output if could not import matplotlib
OUTPUT_FILES = ("output" in sys.argv) and ('plt' in globals())
OUTPUT_FILES = True
N = 128
A, b, real_x = blur.blur(N, 3, 0.8, use_squirrel)
if OUTPUT_FILES:
blur.save_array_as_img(b, "blurred")
blur.save_array_as_img(real_x, "real")
solve_gradient_descent(use_squirrel, A, b)
solve_conjugate_gradient_method(use_squirrel, A, b)
def testLineSearch(self):
n = 50
A, b, _ = blur.blur(n, 3, 0.7)
search = q3_gradient_descent.GradientDescent(A, b)
for i in xrange(20):
print 'i', i
x0 = numpy.random.normal(128, 50, size=n ** 2)
self.assertEqual(b.shape, x0.shape)
gradient_x0 = search.gradient(x0)
best_alpha = search.line_search(x0, gradient_x0)
value_at_alpha = search.value(x0 + best_alpha * gradient_x0)
print 'best_alpha', best_alpha
for other_alpha in (best_alpha * 0.98, best_alpha * 1.02):
print other_alpha / best_alpha
value_at_other_alpha = search.value(x0 + other_alpha * gradient_x0)
print value_at_other_alpha, value_at_alpha
self.assertGreater(value_at_other_alpha, value_at_alpha)
def testConverge(self):
n = 128
A, b, real_x = blur.blur(n, 3, 0.8)
search = q3_gradient_descent.GradientDescent(A, b)
x0 = numpy.zeros(b.shape)
num_iters = 100
x = x0
gradient_norms = []
values = []
for i in xrange(num_iters):
gradient = search.gradient(x)
gradient_norms.append(numpy.linalg.norm(gradient))
values.append(search.value(x))
x = search.step(x, gradient)
gradient_x = search.gradient(x)
gradient_size = numpy.linalg.norm(gradient_x)
epsilon = 10
self.assertGreater(epsilon, gradient_size)
def getMask(img):
blurred = blur.blur(img, RADIUS)
mask = img.copy()
size = img.get_size()
for x in range(size[0]):
for y in range(size[1]):
old = mask.get_at((x, y))
blurred_col = blurred.get_at((x, y))
mask.set_at(
(x, y),
(
min(math.sqrt((old[0] - blurred_col[0]) ** 2) * MASK, 255),
min(math.sqrt((old[1] - blurred_col[1]) ** 2) * MASK, 255),
min(math.sqrt((old[2] - blurred_col[2]) ** 2) * MASK, 255),
),
)
return mask
def testGradient(self):
n = 50
A, b, _ = blur.blur(n, 3, 0.7)
search = q3_gradient_descent.GradientDescent(A, b)
x0 = numpy.random.normal(128, 50, size=n ** 2)
h = numpy.zeros(shape=x0.shape)
f_x0 = search.value(x0)
gradient_x0 = search.gradient(x0)
num_tests = 20
epsilon = 0.01
delta = numpy.linalg.norm(gradient_x0) / gradient_x0.size * 0.1
for i in xrange(num_tests):
print 'i', i
coordinate = numpy.random.randint(0, len(x0))
h[coordinate] += epsilon
f_delta = search.value(x0 + h) - f_x0
gradient_approx = f_delta / epsilon
print gradient_approx, gradient_x0[coordinate]
h[coordinate] -= epsilon
self.assertAlmostEqual(gradient_approx, gradient_x0[coordinate], delta=delta)
def main():
n = 128
A, b, real_x = blur.blur(n, 3, 0.8)
x0 = numpy.zeros(b.shape)
b_new = A.T.dot(b)
search = ConjugateGradient(A, b_new, x0)
num_iters = 100
gradient_norms = []
values = []
for i in xrange(num_iters):
gradient = search.gradient()
gradient_norms.append(numpy.linalg.norm(gradient))
values.append(search.value())
search.step()
x = search.state()
plt.plot(values[2:], 'ro')
plt.savefig('values_cgm.png')
plt.cla()
plt.plot(gradient_norms[2:], 'b+')
plt.savefig('gradient_norms_cgm.png')
blur.save_array_as_img(b, "converge_test_b_cgm")
blur.save_array_as_img(x, "converge_test_found_x_cgm")
blur.save_array_as_img(real_x, "converge_test_real_x_cgm")
import Contrasts
import HSVcounts
root_train = 'E:/ImageDataset_AVA/train/'
root_test = 'E:/ImageDataset_AVA/test/'
paths_train, counts_train = getPath.getPath(root_train)
paths_test, counts_test = getPath.getPath(root_test)
root_trainhigh = 'E:/ImageDataset_AVA/train/train_high'
root_trainlow = 'E:/ImageDataset_AVA/train/train_low'
root_testhigh = 'E:/ImageDataset_AVA/test/test_high'
root_testlow = 'E:/ImageDataset_AVA/test/test_low'
paths_trainhigh, counts_trainhigh = getPath.getPath(root_trainhigh)
paths_trainlow, counts_trainlow = getPath.getPath(root_trainlow)
paths_testhigh, counts_testhigh = getPath.getPath(root_testhigh)
paths_testlow, counts_testlow = getPath.getPath(root_testlow)
layoutComposition.layout(paths_trainhigh, paths_testhigh, paths_trainlow,
paths_testlow, paths_train, paths_test)
edgeComposition.EC(paths_trainhigh, paths_testhigh, paths_trainlow,
paths_testlow, paths_train, paths_test)
GT_layout.GT_layout(paths_train, paths_test)
GT_edge.GT_edge(paths_train, paths_test)
blur.blur(paths_train, paths_test)
dark.dark(paths_train, paths_test)
Contrasts.contrast(paths_train, paths_test)
HSVcounts.hsvcounts(paths_train, paths_test)
#colorPalette.colorPalette(paths_train,paths_test)
parser.add_argument('--color_filter', action='store_true')
parser.add_argument('--color',
help='red,green,blue,brown',
type=str,
default="red")
parser.add_argument("input_file", help="The input image file.")
parser.add_argument("output_file", help="The output image file.")
args = parser.parse_args()
img = imageIO.readImage(args.input_file)
if img is not None:
startTime = time.time()
log.status("proccessing image")
if args.blur:
blurImage = blur(img, args.sigma)
imageIO.writeImage(blurImage, args.output_file)
elif args.edge:
edgeImage = edgeDetection(img)
imageIO.writeImage(edgeImage, args.output_file)
elif args.invert_colors:
invertImage = basicFilters.invertColors(img)
imageIO.writeImage(invertImage, args.output_file)
elif args.grayscale:
grayscaleImage = basicFilters.grayscaleFilter(img)
imageIO.writeImage(grayscaleImage, args.output_file)
elif args.color_filter:
color = colors.getColor(args.color)
if color is not None:
colorImage = basicFilters.colorFiler(img, color)
imageIO.writeImage(colorImage, args.output_file)
def main(infile, outfile, iterations):
b = blur.blur()
img = misc.imread(infile, mode='RGB')
(height, width, channels) = img.shape
blurred = b.main(iterations, img)
misc.imsave(outfile,blurred.get())
)
# Halo part two: and repeat in opposite direction
cart_comm.Sendrecv(
sendbuf=imgLocal[xGhostsAbove : xGhostsAbove + blur_factor],
dest=above_rank,
recvbuf=imgLocal[xGhostsAbove + xLocal :],
source=below_rank,
)
# -----------------------------------------------------------------------------
# Blur, plot and save local data
# -----------------------------------------------------------------------------
# blurring including blurred ghosts
imgLocalBlurred = blur(imgLocal, blur_factor=blur_factor)
f, axarr = plt.subplots(2)
axarr[0].imshow(imgLocal)
axarr[0].set_title("Original Image, rank {}".format(rank))
axarr[1].imshow(imgLocalBlurred)
axarr[1].set_title("Blurred Image, rank {}".format(rank))
# turn off axis
axarr[0].get_xaxis().set_visible(False)
axarr[0].get_yaxis().set_visible(False)
axarr[1].get_xaxis().set_visible(False)
axarr[1].get_yaxis().set_visible(False)
def applyBlur(self):
self._blur = blur.blur(self._picref)
self._pixref = self._blur.load() # Override
import pygame
import sys
import blur
pygame.init()
canvas = pygame.display.set_mode([400, 400], pygame.NOFRAME)
HWND = pygame.display.get_wm_info()["window"]
blur.blur(HWND)
while True:
pygame.display.update()
canvas.fill([0, 0, 0])
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
screen = pygame.Surface([400, 400])
# pygame.display.
pygame.draw.circle(screen, [255, 0, 0], [100, 100], 50)
canvas.blit(screen, [0, 0], special_flags=(pygame.BLEND_RGBA_ADD))
def blurButton():
blur.blur()
import matplotlib.pyplot as plt
import numpy as np
from skimage import io
from blur import blur
#---------------------------------------------
# greyscale image blur
#---------------------------------------------
blur_factor = 3
image = io.imread("start.png")
image_blurred = blur(image, blur_factor=blur_factor)
# create plot comparing original and blurred image
f, axarr = plt.subplots(2)
axarr[0].imshow(image, cmap=plt.cm.Greys_r)
axarr[0].set_title('Original Image')
axarr[1].imshow(image_blurred, cmap=plt.cm.Greys_r)
axarr[1].set_title('Blurred Image')
# turn off axis
axarr[0].get_xaxis().set_visible(False)
axarr[0].get_yaxis().set_visible(False)
axarr[1].get_xaxis().set_visible(False)
axarr[1].get_yaxis().set_visible(False)
f.savefig('image_blur_compare_greyscale.png')
import numpy as np
import cv2
from blur import blur
"""
image = cv2.imread("test.jpg")
new_image = blur(image, [(0,0,image.shape[0],image.shape[1])], 10)
cv2.imshow("image", image)
cv2.imshow("new", new_image)
cv2.waitKey()
"""
image = cv2.imread("test.jpg")
districts = [(800, 1400, 400, 400), [100, 1400, 300, 300]]
new_image = blur(image, districts, 10)
i = 0
for district in districts:
cv2.imshow(
"image" + str(i), image[district[0]:district[0] + district[2],
district[1]:district[1] + district[3], :])
cv2.imshow(
"new" + str(i), new_image[district[0]:district[0] + district[2],
district[1]:district[1] + district[3], :])
i += 1
cv2.waitKey()
desampleTime = np.zeros(200)
desampleRealSignal = np.zeros(200)
realSignal = np.transpose(np.matrix(realSignal))
for i in range(0, 200):
desampleTime[i] = t[i * 5]
desampleRealSignal[i] = realSignal[i * 5]
#Signal: sinusoid1 50 Hz, amplitude 0.7 ; sinudois2 120 Hz, amplitude1
#s=np.zeros(1000)
#for i in range (0,999):
# s[i]=(0.7*math.sin(2*math.pi*50*t[i]) + math.sin(2*math.pi*120*t[i]))
##Blur it
(desampleConvolvedNoise, A, kernel, sigma, convolvedNoise,
desampleConvolved) = blur(t, realSignal)
desampleRealSignal = np.transpose(np.matrix(desampleRealSignal))
onlyNoisy = desampleRealSignal + np.transpose(
np.matrix(np.random.normal(0, 1, 200)))
# TwIST parameters
#Empirical setting for smoothing parameter, tau
#tau = 2*math.e**-2*sigma/(0.56**2)
#lamb=1e-4;
# TwIST is not very sensitive to this parameter
# rule of thumb: lam1=1e-4 for severyly ill-conditioned% problems
# : lam1=1e-1 for mildly ill-conditioned% problems
# : lam1=1 when A = Unitary matrix
#bestLamb=denoiseCheck(realSignal)
dest=below_rank,
recvbuf=imgLocal[0:xGhostsAbove],
source=above_rank)
# Halo part two: and repeat in opposite direction
cart_comm.Sendrecv(sendbuf=imgLocal[xGhostsAbove:xGhostsAbove + blur_factor],
dest=above_rank,
recvbuf=imgLocal[xGhostsAbove + xLocal:],
source=below_rank)
#-----------------------------------------------------------------------------
# Blur, plot and save local data
#-----------------------------------------------------------------------------
# blurring including blurred ghosts
imgLocalBlurred = blur(imgLocal, blur_factor=blur_factor)
f, axarr = plt.subplots(2)
axarr[0].imshow(imgLocal)
axarr[0].set_title('Original Image, rank {}'.format(rank))
axarr[1].imshow(imgLocalBlurred)
axarr[1].set_title('Blurred Image, rank {}'.format(rank))
# turn off axis
axarr[0].get_xaxis().set_visible(False)
axarr[0].get_yaxis().set_visible(False)
axarr[1].get_xaxis().set_visible(False)
axarr[1].get_yaxis().set_visible(False)
for n in range(len(checkerboard_Imgs)):
if n == 0:
CornerListSortedXY_stacked = []
filename = filename_Imgs[n]
img = checkerboard_Imgs[n]
offset = int(windowSize / 2)
x_size = filename.shape[1] - offset
y_size = filename.shape[0] - offset
nul = np.zeros((img.shape[0], img.shape[1]), np.uint8)
# mean blur
blur = bl.blur(filename)
# Partial differentiation hvor ** = ^2
Iy, Ix = np.gradient(blur)
# Representation of the M matrix
Ixx = Ix ** 2
Ixy = Iy * Ix
Iyy = Iy ** 2
CornerCoordinate = []
# Fra offset til y_size og offset til x_size
print("Start running corner detection . . . ")
for y in range(offset, y_size):
for x in range(offset, x_size):
