Gain insights into automated inspection with computer vision. Learn image analysis, feature detection, edge detection, transformations, and neural networks to build industrial inspection systems for quality assurance.

Automated Inspection with Computer Vision.png

AICV_jupyterOpenCV.tar.gz

load_image

annotation

color_spaces

thresholding

smoothing

masking

jup_smooth

morphology

blob_detection

jup_fiducials

edge_detection

jupyter_masking_edge_detection

corner_detection

jupyter_corner_detection

homographies

jup_homographies

topography

jup_topography

tensor_manipulation

neural_network_building_blocks

training_neural_network

jup_train_nn

cnn_building_blocks

cnn_for_classification

pretrained_classification_cnn

jup_train_classification_cnn

transfer_learning

jup_finetune_classification_CNN

cnn_for_object_detection

jup_pretrained_object_detection

cnn_for_semantic_segmentation

jup_pretrained_semantic_segmentation

annotation_formats

spa_train_mlp

prj_jup_create_train_mlp_classification

Computer vision is essential for developers who wish to learn practical skills, e.g., in industrial manufacturing, automated inspection of products is crucial for quality assurance.

In this course, you’ll apply computer vision and machine learning to analyze images for automated inspection. You’ll start by learning image I/O operations, thresholding, smoothing, and masking. You’ll learn feature detection using template matching and morphology. You’ll use the Sobel and Canny Edge Detectors, Harris Corner Detector, and Hough transform. You’ll learn about 2D transformations, including perspective and affine transformation, and 3D-to-2D projections. You’ll perform topography with a laser line to inspect the 3D shape of an object. Lastly, you’ll train convolutional neural networks for object detection and image segmentation and annotate datasets using CVAT.

By the end of this course, you will have the skills to build inspection systems for industrial applications using computer vision and machine learning.

Automated Inspection with Computer Vision

Let's consider the following image, read from a file:

```image = cv2.imread(filepath, cv2.IMREAD_GRAYSCALE)```

If the dimensions of the image are: height = `480`, width = `640`, what would be the value of ```image.shape```?

Let’s consider the following image, read from a file:
<code>image = cv2.imread(filepath, cv2.IMREAD_GRAYSCALE)</code>
If the dimensions of the image are: height = <code>480</code>, width = <code>640</code>, what would be the value of <code>image.shape</code>?

```converted_img.shape == grayscale_img.shape```

When we display ```converted_img```, it looks exactly like ```grayscale_img```.

For any pixel `(x, y)`:

```converted_img[y, x, 0] == converted_img[y, x, 1] == converted_img[y, x, 2]```

The ```converted_img``` variable has only values of `0` and `255`.

**(Select all that apply.)** Let's assume we have a grayscale image called ```grayscale_img```. We define another image, ```converted_img```, in the following line:

```converted_img = cv2.cvtColor(grayscale_img, code=cv2.COLOR_GRAY2BGR)```

Which statement is *true* about ```converted_img?```

(Select all that apply.) Let’s assume we have a grayscale image called <code>grayscale_img</code>. We define another image, <code>converted_img</code>, in the following line:
<code>converted_img = cv2.cvtColor(grayscale_img, code=cv2.COLOR_GRAY2BGR)</code>
Which statement is true about <code>converted_img?</code>

Let's assume we have a BGR color image called ```bgr_img```. We define another color image called ```converted_img``` in the following line:

```converted_img = cv2.cvtColor(bgr_img, code=cv2.COLOR_BGR2HLS)```

What is the name of the color information encoded in ```converted_img[:, :, 2]```?

Let’s assume we have a BGR color image called <code>bgr_img</code>. We define another color image called <code>converted_img</code> in the following line:
<code>converted_img = cv2.cvtColor(bgr_img, code=cv2.COLOR_BGR2HLS)</code>
What is the name of the color information encoded in <code>converted_img[:, :, 2]</code>?

It is a grayscale image that has a gray level of `255` at the pixels where ```image``` is above `128`, and `0` otherwise.

It is a grayscale image that has a gray level of 0 at the pixels where ```image``` is `255`, and `128` otherwise

It is a grayscale image that has a gray level of `128` at the pixels where ```image``` is `255`, and `0` otherwise

It is a grayscale image that has a gray level of `0` at the pixels where ```image``` is above `128`, and `255` otherwise.

Consider the following function call:

```retval, mask = cv2.threshold(src=image, thresh=128, maxval=255, type=cv2.THRESH_BINARY_INV)```

How would you describe the image ```mask```?

Consider the following function call:
<code>retval, mask = cv2.threshold(src=image, thresh=128, maxval=255, type=cv2.THRESH_BINARY_INV)</code>
How would you describe the image <code>mask</code>?

A global threshold is computed automatically.

The Otsu algorithm finds the threshold that separates the image in two classes with the maximum intra-class variance. 

The value of the ```thresh``` argument is ignored.

**(Select all that apply.)** We can apply a thresholding operation to a grayscale image with the Otsu algorithm with the following call:

```retval, thresholded_img = cv2.threshold(src=grayscale_img, thresh=None, maxval=255, type=cv2.THRESH_OTSU)```

Which statement is *true* about the Otsu's algorithm?

(Select all that apply.) We can apply a thresholding operation to a grayscale image with the Otsu algorithm with the following call:
<code>retval, thresholded_img = cv2.threshold(src=grayscale_img, thresh=None, maxval=255, type=cv2.THRESH_OTSU)</code>
Which statement is true about the Otsu’s algorithm?

When there is a strong intensity gradient in an image due to lighting conditions, what type of thresholding would work best?

When there is a strong intensity gradient in an image due to lighting conditions, what type of thresholding would work best?

It controls the size of the neighborhood around the central pixel, where the average gray level is computed.

It controls the number of pixels that are skipped horizontally and vertically during the scan.

It controls the shift with respect to the neighborhood average gray level to set the local threshold.

It controls the width of the zero-padding border applied to the input image.

In the ```cv2.adaptiveThreshold()``` function, what is the effect of the ```blockSize``` argument?

In the <code>cv2.adaptiveThreshold()</code> function, what is the effect of the <code>blockSize</code> argument?

Color Spaces, Thresholding, Adaptive Threshold

Color Spaces, Thresholding, Adaptive Threshold

Test your knowledge of color spaces, thresholding, and adaptive threshold.

Introduction

Getting Started with Images

Image I/O and Annotations

Color Spaces and Thresholding

Convert Color Spaces, Threshold

Smoothing and Masking

Detection of Features

Image Registration

3D Vision

Getting Started with Neural Networks

Convolutional Neural Networks

Project: Create and Train a CNN for Classification

Object Detection and Semantic Segmentation

Dataset Annotation

Final Remarks

Quiz: Color Spaces, Thresholding, and Adaptive Threshold