Laplacian of a Gaussian (LoG) is just another linear filter which is a combination of Gaussian followed by the Laplacian filter on an image. Since the 2^nd derivative is very sensitive to noise, it is always a good idea to remove noise by smoothing the image before applying the Laplacian to ensure that noise is not aggravated. Because of the associative property of convolution, it can be thought of as taking the 2^nd derivative (Laplacian) of the Gaussian filter and then applying the resulting (combined) filter onto the image, hence the name LoG. It can be efficiently approximated using the difference of two Gaussians (DoG) with different scales (variances), as shown in the following diagram:

The following code block shows how to compute the LOG filter and the corresponding best DoG approximation (with a given value of σ) and apply them on the same input image, using SciPy signal module's convolve2d() function:

from scipy.signal import convolve2d
from scipy.misc import imread
from scipy.ndimage import gaussian_filter

def plot_kernel(kernel, s, name):
 pylab.imshow(kernel, cmap='YlOrRd') #cmap='jet') #'gray_r')
 ax = pylab.gca()
 ax.set_xticks(np.arange(-0.5, kernel.shape[0], 2.5)) 
 ax.set_yticks(np.arange(-0.5, kernel.shape[1], 2.5))
 pylab.colorbar()
 
def LOG(k=12, s=3):
 n = 2*k+1 # size of the kernel
 kernel = np.zeros((n,n))
 for i in range(n):
  for j in range(n):
   kernel[i,j] = -(1-((i-k)**2+(j-k)**2)/(2.*s**2))*np.exp(-((i-k)**2+(j-k)**2)/(2.*s**2))/(pi*s**4)
 kernel = np.round(kernel / np.sqrt((kernel**2).sum()),3)
 return kernel

def DOG(k=12, s=3):
 n = 2*k+1 # size of the kernel
 s1, s2 = s * np.sqrt(2), s / np.sqrt(2)
 kernel = np.zeros((n,n))
 for i in range(n):
    for j in range(n):
        kernel[i,j] = np.exp(-((i-k)**2+(j-k)**2)/(2.*s1**2))/(2*pi*s1**2) - np.exp(-((i-k)**2+(j-k)**2)/(2.*s2**2))/(2*pi*s2**2)
 kernel = np.round(kernel / np.sqrt((kernel**2).sum()),3)
 return kernel

s = 3 # sigma value for LoG
img = rgb2gray(imread('../images/me.jpg'))
kernel = LOG()
outimg = convolve2d(img, kernel)
pylab.figure(figsize=(20,20))
pylab.subplot(221), pylab.title('LOG kernel', size=20), plot_kernel(kernel, s, 'DOG')
pylab.subplot(222), pylab.title('output image with LOG', size=20)
pylab.imshow(np.clip(outimg,0,1), cmap='gray') # clip the pixel values in between 0 and 1
kernel = DOG()
outimg = convolve2d(img, DOG())
pylab.subplot(223), pylab.title('DOG kernel', size=20), plot_kernel(kernel, s, 'DOG')
pylab.subplot(224), pylab.title('output image with DOG', size=20)
pylab.imshow(np.clip(outimg,0,1), cmap='gray')
pylab.show()

The following images show the input image and the output images obtained with the LoG and DoG filters (with σ=3), along with the visualization of the corresponding kernels. From the kernel visualizations, it can be seen that LoG is going to act as a BPF on the input image (since it blocks both low and high frequencies). The band-pass nature of LoG can also be explained by the DoG approximation (the Gaussian filter being a LPF). Also, we can see that the output images obtained with LoG/DoG filters are quite similar:

We can see from these images that the LoG filter is quite useful for edge detection. As we shall see shortly, LoG is also useful for finding blobs in an image.