Operating on images using OpenCV-Python
by Alberto Boschetti, Luca Massaron, Bastiaan Sjardin, John Hearty, Prateek Joshi
Python: Real World Machine Learning
- Python: Real World Machine Learning
- Table of Contents
- Python: Real World Machine Learning
- Python: Real World Machine Learning
- Credits
- Preface
- I. Module 1
- 1. The Realm of Supervised Learning
- Introduction
- Preprocessing data using different techniques
- Label encoding
- Building a linear regressor
- Computing regression accuracy
- Achieving model persistence
- Building a ridge regressor
- Building a polynomial regressor
- Estimating housing prices
- Computing the relative importance of features
- Estimating bicycle demand distribution
- 2. Constructing a Classifier
- Introduction
- Building a simple classifier
- Building a logistic regression classifier
- Building a Naive Bayes classifier
- Splitting the dataset for training and testing
- Evaluating the accuracy using cross-validation
- Visualizing the confusion matrix
- Extracting the performance report
- Evaluating cars based on their characteristics
- Extracting validation curves
- Extracting learning curves
- Estimating the income bracket
- 3. Predictive Modeling
- 4. Clustering with Unsupervised Learning
- Introduction
- Clustering data using the k-means algorithm
- Compressing an image using vector quantization
- Building a Mean Shift clustering model
- Grouping data using agglomerative clustering
- Evaluating the performance of clustering algorithms
- Automatically estimating the number of clusters using DBSCAN algorithm
- Finding patterns in stock market data
- Building a customer segmentation model
- 5. Building Recommendation Engines
- Introduction
- Building function compositions for data processing
- Building machine learning pipelines
- Finding the nearest neighbors
- Constructing a k-nearest neighbors classifier
- Constructing a k-nearest neighbors regressor
- Computing the Euclidean distance score
- Computing the Pearson correlation score
- Finding similar users in the dataset
- Generating movie recommendations
- 6. Analyzing Text Data
- Introduction
- Preprocessing data using tokenization
- Stemming text data
- Converting text to its base form using lemmatization
- Dividing text using chunking
- Building a bag-of-words model
- Building a text classifier
- Identifying the gender
- Analyzing the sentiment of a sentence
- Identifying patterns in text using topic modeling
- 7. Speech Recognition
- 8. Dissecting Time Series and Sequential Data
- Introduction
- Transforming data into the time series format
- Slicing time series data
- Operating on time series data
- Extracting statistics from time series data
- Building Hidden Markov Models for sequential data
- Building Conditional Random Fields for sequential text data
- Analyzing stock market data using Hidden Markov Models
- 9. Image Content Analysis
- Introduction
- Operating on images using OpenCV-Python
- Detecting edges
- Histogram equalization
- Detecting corners
- Detecting SIFT feature points
- Building a Star feature detector
- Creating features using visual codebook and vector quantization
- Training an image classifier using Extremely Random Forests
- Building an object recognizer
- 10. Biometric Face Recognition
- Introduction
- Capturing and processing video from a webcam
- Building a face detector using Haar cascades
- Building eye and nose detectors
- Performing Principal Components Analysis
- Performing Kernel Principal Components Analysis
- Performing blind source separation
- Building a face recognizer using Local Binary Patterns Histogram
- 11. Deep Neural Networks
- Introduction
- Building a perceptron
- Building a single layer neural network
- Building a deep neural network
- Creating a vector quantizer
- Building a recurrent neural network for sequential data analysis
- Visualizing the characters in an optical character recognition database
- Building an optical character recognizer using neural networks
- 12. Visualizing Data
- 1. The Realm of Supervised Learning
- II. Module 2
- 1. Unsupervised Machine Learning
- 2. Deep Belief Networks
- 3. Stacked Denoising Autoencoders
- 4. Convolutional Neural Networks
- 5. Semi-Supervised Learning
- 6. Text Feature Engineering
- 7. Feature Engineering Part II
- 8. Ensemble Methods
- 9. Additional Python Machine Learning Tools
- A. Chapter Code Requirements
- III. Module 3
- 1. First Steps to Scalability
- 2. Scalable Learning in Scikit-learn
- 3. Fast SVM Implementations
- 4. Neural Networks and Deep Learning
- The neural network architecture
- Neural networks and regularization
- Neural networks and hyperparameter optimization
- Neural networks and decision boundaries
- Deep learning at scale with H2O
- Deep learning and unsupervised pretraining
- Deep learning with theanets
- Autoencoders and unsupervised learning
- Summary
- 5. Deep Learning with TensorFlow
- 6. Classification and Regression Trees at Scale
- 7. Unsupervised Learning at Scale
- 8. Distributed Environments – Hadoop and Spark
- 9. Practical Machine Learning with Spark
- A. Introduction to GPUs and Theano
- A. Bibliography
- Index
Let's take a look at how to operate on images using OpenCV-Python. In this recipe, we will see how to load and display an image. We will also look at how to crop, resize, and save an image to an output file.
- Create a new Python file, and import the following packages:
import sys import cv2 import numpy as np
- Specify the input image as the first argument to the file, and read it using the image read function. We will use
forest.jpg, as follows:# Load and display an image -- 'forest.jpg' input_file = sys.argv[1] img = cv2.imread(input_file)
- Display the input image, as follows:
cv2.imshow('Original', img) - We will now crop this image. Extract the height and width of the input image, and then specify the boundaries:
# Cropping an image h, w = img.shape[:2] start_row, end_row = int(0.21*h), int(0.73*h) start_col, end_col= int(0.37*w), int(0.92*w)
- Crop the image using NumPy style slicing and display it:
img_cropped = img[start_row:end_row, start_col:end_col] cv2.imshow('Cropped', img_cropped) - Resize the image to
1.3times its original size and display it:# Resizing an image scaling_factor = 1.3 img_scaled = cv2.resize(img, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_LINEAR) cv2.imshow('Uniform resizing', img_scaled) - The previous method will uniformly scale the image on both dimensions. Let's assume that we want to skew the image based on specific output dimensions. We use the following code:
img_scaled = cv2.resize(img, (250, 400), interpolation=cv2.INTER_AREA) cv2.imshow('Skewed resizing', img_scaled) - Save the image to an output file:
# Save an image output_file = input_file[:-4] + '_cropped.jpg' cv2.imwrite(output_file, img_cropped) cv2.waitKey()
- The
waitKey()function displays the images until you hit a key on the keyboard. - The full code is given in the
operating_on_images.pyfile that is already provided to you. If you run the code, you will see the following input image:
- The second output is the cropped image:
- The third output is the uniformly resized image:
- The fourth output is the skewed image:
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.