Morphological Transformations

I started playing around with the OpenCV library in Python ("cv2"). Here are some of the mathematical morphological operations that can be done on an image of your choosing:

	import cv2 as cv
	import numpy as np
	img = cv.imread('Noise.jpg',0)
	kernel = np.ones((5,5),np.uint8)
	erosion = cv.erode(img,kernel,iterations = 1)
	cv.imwrite("Erosion.jpg",erosion)
	dilation = cv.dilate(img,kernel,iterations = 1)
	cv.imwrite("Dilation.jpg",dilation)
	kernel = np.ones((3,3),np.uint8)
	dilation = cv.dilate(img,kernel,iterations = 1)
	cv.imwrite("Dilation2.jpg",dilation)
	erosion = cv.erode(img,kernel,iterations = 1)
	cv.imwrite("Erosion2.jpg",erosion)
	kernel = np.ones((5,5),np.uint8)
	gradient = cv.morphologyEx(img, cv.MORPH_GRADIENT, kernel)
	cv.imwrite("MorphologicalGradient.jpg",gradient)
	kernel = np.ones((3,3),np.uint8)
	gradient = cv.morphologyEx(img, cv.MORPH_GRADIENT, kernel)
	cv.imwrite("MorphologicalGradient2.jpg",gradient)
	kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
	edge_detect = cv.filter2D(img, -1, kernel)
	cv.imwrite("filter2D.jpg",edge_detect)
	laplacian = cv.Laplacian(img,cv.CV_64F)
	cv.imwrite("Laplacian.jpg",laplacian)
	sharpen_filter = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
	sharped_img = cv.filter2D(img, -1, sharpen_filter)
	cv.imwrite("Sharpen.jpg",sharped_img)

view raw MorphologicalTransformations.py hosted with ❤ by GitHub

Here is an example of an "erosion" operation done on an image of a gradient. First, here is the input image that I used, of a gradient I also generated programmatically via Python:

And here is the processed image, using the erosion operation with a 3 x 3 kernel of 1s:

As I said, I've been playing around with these mathematical morphological operations, of erosion, dilation, edge detection and sharpening of images, all using the OpenCV library. The functions are pretty simple to use. The library is really powerful, giving you everything you need at the touch of a simple function. One can also use function composition to use a function on top of a function. I wrote some helper functions to facilitate the task of using the morphological transformation functions.

Generating a Gradient Programmatically

I've posted many times on this blog, my experiments in image generation through Python. I've been working on what I call my "Noisefield" project, where I generated a bitmap with random black and white pixels. I have now done something similar, except this time I generated a black to white gradient, using the PIL library in Python.

	import time
	import random
	from PIL import Image
	LINE = []
	for i in range(256):
	LINE.append(i)
	MATRIX = LINE*256
	nixel = iter(MATRIX)
	def noisefield():
	im = Image.new("L", (256, 256))
	for x in range(256):
	for y in range(256):
	im.putpixel((x, y), next(nixel))
	im.save('<FILEPATH>'+time.strftime('%Y%m%d%H%M%S')+".png")
	im.show()
	noisefield()

view raw gradient.py hosted with ❤ by GitHub

The idea is pretty simple. You create a vector or array of values from 0 to 255, then you repeat that 256 times, to make a square matrix, or bitmap (because Python puts in the pixels from top-left downwards and towards the right, line by line). So that way you get a gradient. I took the "LINE" variable that I created with a for loop and range() function and then multiplied it by 256 in a variable called MATRIX. I then used an iterator function on the Matrix which I called in the image-generation function by calling next(MATRIX). The result is a smooth matrix.

ADDENDUM: I have found a simpler way of generating a black to white gradient, using the np.linspace function in Numpy.

	import numpy as np
	from PIL import Image
	# gradient between 0 and 1 for 256*256
	array = np.linspace(0,1,256*256)
	# reshape to 2d
	mat = np.reshape(array,(256,256))
	# Creates and saves PIL image
	img = Image.fromarray(np.uint8(mat * 255) , 'L')
	img.save('/FILEPATH/Gradient.jpg')
	# OR img.show()
	'''
	# If you want to create a 512 pixel by 512 pixel image instead:
	>>> array = np.linspace(0,1,256*256)
	>>> array = np.repeat(array, 4)
	>>> len(array)
	262144
	>>> mat = np.reshape(array,(512,512))
	>>> img = Image.fromarray(np.uint8(mat*255), 'L')
	>>> img.save('/FILEPATH/Gradient.jpg')
	# OR img.show()
	'''

view raw gradient.py hosted with ❤ by GitHub

FOR YOUR INFORMATION: I have written a few blog posts in the past about generating bitmaps with random black and white pixel values, or grey values between 0 and 255. I found a much quicker way to do this using the OpenCV library (cv2). (In passing, this np.random.randint() function gives the same results as the uniform_noise function below, in the second Gist below:

	import cv2
	import numpy as np
	noise = np.random.randint(0,256, size= (512, 512), dtype=np.uint8)
	cv2.imwrite("Noise.jpg", noise)
	'''
	# OR JUST USE THE FOLLOWING:
	import matplotlib.pyplot as plt
	plt.imsave("Noise.jpg", noise, cmap='Greys')
	'''

view raw noise.py hosted with ❤ by GitHub

Here's another way to generate noise, Gaussian noise in this case, via OpenCV (cv2). The Gaussian distribution is "smoother" in appearance, as it has mean 128 and standard deviation 20:

	from PIL import Image
	import cv2
	import numpy as np
	image = Image.new(mode = "L", size = (512,512))
	image = np.array(image)
	gaussian_noise = np.zeros((image.shape[0], image.shape[1]),dtype=np.uint8)
	cv2.randn(gaussian_noise, 128, 20)
	cv2.imwrite("GaussianRandomNoise.jpg",gaussian_noise)
	'''
	# OR FOR DIFFERENT DISTRIBUTION OF NOISE, WITH MEAN 0 AND STANDARD DEVIATION 256, USE:
	>>> cv2.randn(gaussian_noise, 0, 256)
	uniform_noise = np.zeros((image.shape[0], image.shape[1]),dtype=np.uint8)
	# OR:
	>>> cv2.randu(uniform_noise,0,255)
	>>> cv2.imwrite("Uniform random noise.jpg",uniform_noise)
	# OR:
	>>> ret,impulse_noise = cv2.threshold(uniform_noise,250,255,cv2.THRESH_BINARY)
	>>> cv2.imwrite("Impulse noise.jpg",impulse_noise)
	'''

view raw noise.py hosted with ❤ by GitHub

With mean 0 and standard deviation 256, we get a "coarser" noise distribution:

As stated, the uniform_noise "randu" function gives the same result as the previous np.random.randint() function, a uniform noise distribution:

If I add the following, "ret,thresh1 = cv2.threshold(uniform_noise,64,255,cv2.THRESH_BINARY)" and then write "cv2.imwrite("Noise.jpg",thresh1)", I get a noisy distribution with many more whites, because of the threshold value being at 64. For every pixel, the same threshold value is applied. If the pixel value is smaller than the threshold, it is set to 0, otherwise it is set to a maximum value, in this case 255, which is pure white. This way it is possible to adjust the parseness if you will of the noisy distribution using the threshold function:

The opposite would be true if we set the treshold higher, to say 250. Then it's mostly black, or at a pixel value of 0:

Finding The Mean Part II

A short while ago, I wrote a blog post called "Finding The Mean" where I gave code of a function I wrote which generates an array of n random real numbers between 0 and 1 inclusively. I wrote the function in Python, in R, and in GNU Octave. My goal was to write the function in as many programming languages as possible. I have now written a version in C.

	#include <stdio.h>
	#include <stdlib.h>
	#include <time.h>
	int main()
	{
	int i;
	int n;
	printf("Choose a number n: ");
	scanf("%d", &n);
	float array[n];
	srand(time(NULL));
	for (i = 0; i < n; i++) {
	array[i] = rand() / (float) RAND_MAX; /* [0, 1.0] */
	}
	float sum = 0;
	int j;
	for (j = 0; j < n; j++) {
	sum += array[j];
	}
	printf("%f\n", sum / n);
	return 0;
	}

view raw avg_probs.c hosted with ❤ by GitHub

I will be trying to write the same function in various other programming languages, probably including Ruby, Javascript, Scala, and many others, potentially in some functional programming languages like Haskell or SML (Standard ML). Stay tuned!

In passing, the main idea behind this program is the fact that as an array or list of random real numbers between 0 and 1 grows in size, the average will technically converge on 0.50. It's just a mathematical fact. I think it's called the Law of Large Numbers. "According to the law, the average of the results obtained from a large number of trials should be close to the expected value and will tend to become closer to the expected value as more trials are performed."

Here is a mathematical representation of the Law of Large Numbers:

ADDENDUM: Here is some Scala code that does the same thing, but only seems to work in the REPL. I'm not familiar enough with writing actual scala programs, but as I said it works in the REPL. Just change the value of n.

	def n_rands(n : Int) = {
	val r = new scala.util.Random
	1 to n map { _ => r.nextFloat() }
	}
	val n = 1000
	println(n_rands(n).sum/n)

view raw n_rands.scala hosted with ❤ by GitHub

I was also able to translate the code into Ruby. This works in the REPL and worked as a simple Ruby program, though I think it lacks some of the usual formalism of Ruby programs. I tried to turn it into a function (via function definition) but it said there was an "undefined method", not recognizing the .sum method for arrays. But I got it to work in the following way, decomposed into different lines of code. You just have to change the value of n. Remember, this is all to prove the Law of Large Numbers:

	n = 1000
	a = Array.new(n) { |_| rand }
	puts a.sum(0.0) / a.size

view raw n_rands.rb hosted with ❤ by GitHub

The idea behind this proof of the Law of Large Numbers is simply that given an array of random real numbers (floats) between 0 and 1, the larger the length n of the array, the closer the mean of the values of the array will become to 0.50. That is, the mean of a large number of such random numbers, or the expected value, is 0.50. And if you try these functions with 10,000 or more values in the array, you'll see that it converges on 0.50. This is my so-called "proof" of the Law of Large Numbers.