Hands-On Image Processing with Python

Cover
Title Page
Copyright and Credits
Dedication
About Packt
Contributors
Table of Contents
Preface
Chapter 1: Getting Started with Image Processing
	What is image processing and some applications
		What is an image and how it is stored on a computer
		What is image processing?
		Some applications of image processing
	The image processing pipeline
	Setting up different image processing libraries in Python
		Installing pip
		Installing some image processing libraries in Python
		Installing the Anaconda distribution
		Installing Jupyter Notebook
	Image I/O and display with Python
		Reading, saving, and displaying an image using PIL
			Providing the correct path to the images on the disk
		Reading, saving, and displaying an image using Matplotlib
			Interpolating while displaying with Matplotlib imshow()
		Reading, saving, and displaying an image using scikit-image
			Using scikit-image's astronaut dataset
			Reading and displaying multiple images at once
		Reading, saving, and displaying an image using scipy misc
			Using scipy.misc's face dataset
	Dealing with different image types and file formats and performing basic image manipulations
		Dealing with different image types and file formats
			File formats
				Converting from one file format to another
			Image types (modes)
				Converting from one image mode into another
			Some color spaces (channels)
				Converting from one color space into another
			Data structures to store images
				Converting image data structures
		Basic image manipulations
			Image manipulations with numpy array slicing 
				Simple image morphing - α-blending of two images using cross-dissolving
			Image manipulations with PIL
				Cropping an image
				Resizing an image
				Negating an image
				Converting an image into grayscale
				Some gray-level transformations
				Some geometric transformations
				Changing pixel values of an image
				Drawing on an image
				Drawing text on an image
				Creating a thumbnail
				Computing the basic statistics of an image
				Plotting the histograms of pixel values for the RGB channels of an image
				Separating the RGB channels of an image 
				Combining multiple channels of an image
				α-blending two images
				Superimposing two images
				Adding two images
				Computing the difference between two images
				Subtracting two images and superimposing two image negatives
			Image manipulations with scikit-image
				Inverse warping and geometric transformation using the warp() function
				Applying the swirl transform
				Adding random Gaussian noise to images
				Computing the cumulative distribution function of an image 
			Image manipulation with Matplotlib
				Drawing contour lines for an image
			Image manipulation with the scipy.misc and scipy.ndimage modules
	Summary
	Questions
	Further reading
Chapter 2: Sampling, Fourier Transform, and Convolution
	Image formation – sampling and quantization
		Sampling
			Up-sampling
				Up-sampling and interpolation 
			Down-sampling
				Down-sampling and anti-aliasing
		Quantization
			Quantizing with PIL
	Discrete Fourier Transform
		Why do we need the DFT?
		The Fast Fourier Transform algorithm to compute the DFT
			The FFT with the scipy.fftpack module
				Plotting the frequency spectrum
			The FFT with the numpy.fft module
				Computing the magnitude and phase of a DFT
	Understanding convolution
		Why convolve an image?
		Convolution with SciPy signal's convolve2d
			Applying convolution to a grayscale image
				Convolution modes, pad values, and boundary conditions
			Applying convolution to a color (RGB) image
		Convolution with SciPy ndimage.convolve
		Correlation versus convolution
			Template matching with cross-correlation between the image and template
	Summary
	Questions
	Further reading
Chapter 3: Convolution and Frequency Domain Filtering
	Convolution theorem and frequency domain Gaussian blur
		Application of the convolution theorem
			Frequency domain Gaussian blur filter with numpy fft
				Gaussian kernel in the frequency domain
			Frequency domain Gaussian blur filter with scipy signal.fftconvolve()
			Comparing the runtimes of SciPy convolve() and fftconvolve() with the Gaussian blur kernel
	Filtering in the frequency domain (HPF, LPF, BPF, and notch filters)
		What is a filter?
		High-Pass Filter (HPF)
			How SNR changes with frequency cut-off
		Low-pass filter (LPF)
			LPF with scipy ndimage and numpy fft
				LPF with fourier_gaussian
			LPF with scipy fftpack
			How SNR changes with frequency cutoff
		Band-pass filter (BPF) with DoG
		Band-stop (notch) filter
			Using a notch filter to remove periodic noise from images
		Image restoration
			Deconvolution and inverse filtering with FFT
			Image deconvolution with the Wiener filter
			Image denoising with FFT
				Filter in FFT
				Reconstructing the final image
	Summary
	Questions
	Further reading
Chapter 4: Image Enhancement
	Point-wise intensity transformations – pixel transformation
		Log transform
		Power-law transform
		Contrast stretching
			Using PIL as a point operation
			Using the PIL ImageEnhance module
		Thresholding
			With a fixed threshold
			Half-toning
			Floyd-Steinberg dithering with error diffusion
	Histogram processing – histogram equalization and matching
		Contrast stretching and histogram equalization with scikit-image
		Histogram matching
			Histogram matching for an RGB image
	Linear noise smoothing
		Smoothing with PIL
			Smoothing with ImageFilter.BLUR
			Smoothing by averaging with the box blur kernel
			Smoothing with the Gaussian blur filter
		Comparing smoothing with box and Gaussian kernels using SciPy ndimage
	Nonlinear noise smoothing
		Smoothing with PIL
			Using the median filter
			Using max and min filter
		Smoothing (denoising) with scikit-image
			Using the bilateral filter
			Using non-local means
		Smoothing with scipy ndimage
	Summary
	Questions
	Further reading
Chapter 5: Image Enhancement Using Derivatives
	Image derivatives – Gradient and Laplacian
		Derivatives and gradients
			Displaying the magnitude and the gradient on the same image
		Laplacian
			Some notes about the Laplacian
		Effects of noise on gradient computation
	Sharpening and unsharp masking
		Sharpening with Laplacian
		Unsharp masking
			With the SciPy ndimage module
	Edge detection using derivatives and filters (Sobel, Canny, and so on)
		With gradient magnitude computed using the partial derivatives
			The non-maximum suppression algorithm
		Sobel edge detector with scikit-image
		Different edge detectors with scikit-image – Prewitt, Roberts, Sobel, Scharr, and Laplace
		The Canny edge detector with scikit-image
		The LoG and DoG filters
			The LoG filter with the SciPy ndimage module
			Edge detection with the LoG filter
				Edge detection with the Marr and Hildreth's algorithm using the zero-crossing computation
		Finding and enhancing edges with PIL
	Image pyramids (Gaussian and Laplacian) – blending images
		A Gaussian pyramid with scikit-image transform pyramid module
		A Laplacian pyramid with scikit-image transform's pyramid module
		Constructing the Gaussian Pyramid
		Reconstructing an image only from its Laplacian pyramid
		Blending images with pyramids
	Summary
	Questions
	Further reading
Chapter 6: Morphological Image Processing
	The scikit-image morphology module
		Binary operations
			Erosion
			Dilation
			Opening and closing
			Skeletonizing
			Computing the convex hull
			Removing small objects
			White and black top-hats
			Extracting the boundary 
		Fingerprint cleaning with opening and closing
		Grayscale operations
	The scikit-image filter.rank module
		Morphological contrast enhancement
		Noise removal with the median filter
		Computing the local entropy
	The SciPy ndimage.morphology module
		Filling holes in binary objects
		Using opening and closing to remove noise
		Computing the morphological Beucher gradient
		Computing the morphological Laplace
	Summary
	Questions
	Further reading
Chapter 7: Extracting Image Features and Descriptors
	Feature detectors versus descriptors
	Harris Corner Detector
		With scikit-image
			With sub-pixel accuracy
		An application – image matching
			Robust image matching using the RANSAC algorithm and Harris Corner features
	Blob detectors with LoG, DoG, and DoH
		Laplacian of Gaussian (LoG)
		Difference of Gaussian (DoG)
		Determinant of Hessian (DoH)
	Histogram of Oriented Gradients
		Algorithm to compute HOG descriptors
		Compute HOG descriptors with scikit-image
	Scale-invariant feature transform
		Algorithm to compute SIFT descriptors
		With opencv and opencv-contrib
		Application – matching images with BRIEF, SIFT, and ORB
			Matching images with BRIEF binary descriptors with scikit-image
			Matching with ORB feature detector and binary descriptor using scikit-image
			Matching with ORB features using brute-force matching with python-opencv
			Brute-force matching with SIFT descriptors and ratio test with OpenCV
	Haar-like features
		Haar-like feature descriptor with scikit-image
		Application – face detection with Haar-like features
			Face/eye detection with OpenCV using pre-trained classifiers with Haar-cascade features
	Summary
	Questions
	Further reading
Chapter 8: Image Segmentation
	What is image segmentation?
	Hough transform – detecting lines and circles
	Thresholding and Otsu's segmentation
	Edges-based/region-based segmentation
		Edge-based segmentation
		Region-based segmentation
			Morphological watershed algorithm
	Felzenszwalb, SLIC, QuickShift, and Compact Watershed algorithms 
		Felzenszwalb's efficient graph-based image segmentation
		SLIC
			RAG merging
		QuickShift
		Compact Watershed
		Region growing with SimpleITK 
	Active contours, morphological snakes, and GrabCut algorithms
		Active contours
		Morphological snakes
		GrabCut with OpenCV
	Summary
	Questions
	Further reading
Chapter 9: Classical Machine Learning Methods in Image Processing
	Supervised versus unsupervised learning
	Unsupervised machine learning – clustering, PCA, and eigenfaces
		K-means clustering for image segmentation with color quantization
		Spectral clustering for image segmentation
		PCA and eigenfaces 
			Dimension reduction and visualization with PCA
				2D projection and visualization
			Eigenfaces with PCA
				Eigenfaces
				Reconstruction
				Eigen decomposition
	Supervised machine learning – image classification
		Downloading the MNIST (handwritten digits) dataset
		Visualizing the dataset
		Training kNN, Gaussian Bayes, and SVM models to classify MNIST 
			k-nearest neighbors (KNN) classifier
				Squared Euclidean distance
				Computing the nearest neighbors
				Evaluating the performance of the classifier
			Bayes classifier (Gaussian generative model)
				Training the generative model – computing the MLE of the Gaussian parameters
				Computing the posterior probabilities to make predictions on test data and model evaluation
			SVM classifier
	Supervised machine learning – object detection
		Face detection with Haar-like features and cascade classifiers with AdaBoost – Viola-Jones
			Face classification using the Haar-like feature descriptor
				Finding the most important Haar-like features for face classification with the random forest ensemble classifier
		Detecting objects with SVM using HOG features
			HOG training
			Classification with the SVM model
			Computing BoundingBoxes with HOG-SVM
			Non-max suppression
	Summary
	Questions
	Further reading
Chapter 10: Deep Learning in Image Processing - Image Classification
	Deep learning in image processing
		What is deep learning?
		Classical versus deep learning
		Why deep learning?
	CNNs
		Conv or pooling or FC layers – CNN architecture and how it works
			Convolutional layer
			Pooling layer
			Non-linearity – ReLU layer
			FC layer
			Dropout
	Image classification with TensorFlow or Keras
		Classification with TF
		Classification with dense FC layers with Keras
			Visualizing the network
			Visualizing the weights in the intermediate layers 
		CNN for classification with Keras
			Classifying MNIST
			Visualizing the intermediate layers 
	Some popular deep CNNs
		VGG-16/19
			Classifying cat/dog images with VGG-16 in Keras
				Training phase
				Testing (prediction) phase
		InceptionNet
		ResNet
	Summary
	Questions
	Further reading
Chapter 11: Deep Learning in Image Processing - Object Detection, and more
	Introducing YOLO v2 
		Classifying and localizing images and detecting objects
		Proposing and detecting objects using CNNs
		Using YOLO v2 
			Using a pre-trained YOLO model for object detection
	Deep semantic segmentation with DeepLab V3+
		Semantic segmentation
		DeepLab V3+
			DeepLab v3 architecture
			Steps you must follow to use DeepLab V3+ model for semantic segmentation
	Transfer learning – what it is, and when to use it
		Transfer learning with Keras
	Neural style transfers with cv2 using a pre-trained torch model
		Understanding the NST algorithm
		Implementation of NST with transfer learning
			Ensuring NST with content loss
			Computing the style cost
			Computing the overall loss
		Neural style transfer with Python and OpenCV
	Summary
	Questions
	Further reading
Chapter 12: Additional Problems in Image Processing
	Seam carving
		Content-aware image resizing with seam carving
		Object removal with seam carving
	Seamless cloning and Poisson image editing
	Image inpainting
	Variational image processing
		Total Variation Denoising
		Creating flat-texture cartoonish images with total variation denoising
	Image quilting
		Texture synthesis
		Texture transfer
	Face morphing
	Summary
	Questions
	Further reading
Other Books You May Enjoy
Index