Title: OpenCV: Resolving NoneType errors - PyImageSearch

URL Source: https://pyimagesearch.com/2016/12/26/opencv-resolving-nonetype-errors/

Published Time: 2016-12-26T15:00:11+00:00

Markdown Content:
![Image 1: nonetype_output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20376'%3E%3C/svg%3E)

Each week I receive and respond to at least 2-3 emails and 3-4 blog post comments regarding `NoneType` errors in OpenCV and Python.

For beginners, these errors can be hard to diagnose — by definition they aren’t very informative.

Since this question is getting asked so often I decided to dedicate an entire blog post to the topic.

While `NoneType` errors can be caused for a nearly unlimited number of reasons, in my experience, both as a computer vision developer and chatting with other programmers here on PyImageSearch, in over 95% of the cases, `NoneType` errors in OpenCV are caused by either:

1.  An invalid image path passed to `cv2.imread` .
2.  A problem reading a frame from a video stream/video file via `cv2.VideoCapture` and the associated `.read` method.

**To learn more about `NoneType` errors in OpenCV (and how to avoid them), _just keep reading_.**

![Image 2](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20128%20128'%3E%3C/svg%3E)

#### Looking for the source code to this post?

[Jump Right To The Downloads Section](#download-the-code)

In the first part of this blog post I’ll discuss exactly _what_ `NoneType` errors are in the Python programming language.

I’ll then discuss the two primary reasons you’ll run into `NoneType` errors when using OpenCV and Python together.

Finally, I’ll put together an _actual example_ that not only _causes_ a `NoneType` error, but also _resolves_ it as well.

### What is a NoneType error?

When using the Python programming language you’ll inevitably run into an error that looks like this:

AttributeError: 'NoneType' object has no attribute ‘something’

Where `something` can be replaced by whatever the name of the actual attribute is.

We see these errors when we _think_ we are working with an instance of a particular Class or Object, but in reality we have the [Python built-in type](https://docs.python.org/2/library/types.html#types.NoneType) `None` .

As the name suggests, `None` represents the _absence_ of a value, such as when a function call returns an unexpected result or fails entirely.

Here is an example of generating a `NoneType` error from the Python shell:

\>>> foo = None
>>> foo.bar = True
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'bar'
>>>

Here I create a variable named `foo` and set it to `None` .

I then try to set the `bar` attribute of `foo` to `True` , but since `foo` is a `NoneType` object, Python will not allow this — hence the error message.

### Two reasons for 95% of OpenCV NoneType errors

When using OpenCV and Python bindings, you’re bound to come across `NoneType` errors at some point.

In my experience, **_over 95% of the time_** these `NoneType` errors can be traced back to either an issue with `cv2.imread` or `cv2.VideoCapture` .

I have provided details for each of the cases below.

#### Case #1: cv2.imread

If you are receiving a `NoneType` error _and_ your code is calling `cv2.imread` , then the likely cause of the error is an **_invalid file path_** supplied to `cv2.imread` .

The `cv2.imread` function does not explicitly throw an error message if you give it an invalid file path (i.e., a path to a nonexistent file). Instead, `cv2.imread` will simply return `None` .

Anytime you try to access an attribute of a `None` image loaded from disk via `cv2.imread` you’ll get a `NoneType` error.

Here is an example of trying to load a nonexistent image from disk:

$ python
>>> import cv2
>>> path = "path/to/image/that/does/not/exist.png"
>>> image = cv2.imread(path)
>>> print(image.shape)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'shape'

As you can see, `cv2.imread` gladly accepts the image path (even though it doesn’t exist), realizes the image path is invalid, and returns `None` . This is especially confusing for Python programmers who are used to these types of functions throwing exceptions.

As an added bonus, I’ll also mention the `AssertionFailed` exception.

If you try to pass an invalid image (i.e., `NoneType` image) into _another OpenCV function_, Python + OpenCV will complain that the image doesn’t have any width, height, or depth information — and how could it, the “image” is a `None` object after all!

Here is an example of an error message you might see when loading a nonexistent image from disk and followed by immediately calling an OpenCV function on it:

\>>> import cv2
>>> path = "path/to/image/that/does/not/exist.png"
>>> image = cv2.imread(path)
>>> gray = cv2.cvtColor(image, cv2.COLOR\_BGR2GRAY)
OpenCV Error: Assertion failed (scn == 3 || scn == 4) in cvtColor, file /tmp/opencv20150906-42178-3d0iam/opencv-2.4.12/modules/imgproc/src/color.cpp, line 3739
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
cv2.error: /tmp/opencv20150906-42178-3d0iam/opencv-2.4.12/modules/imgproc/src/color.cpp:3739: error: (-215) scn == 3 || scn == 4 in function cvtColor

>>>

These types of errors can be harder to debug since there are _many_ reasons why an `AssertionError` could be thrown. But in most cases, your first step should be be ensuring that your image was correctly loaded from disk.

A final, more rare problem you may encounter with `cv2.imread` is that your image _does exist_ on disk, but you didn’t compile OpenCV with the given image I/O libraries installed.

For example, let’s say you have a .JPEG file on disk and you _knew_ you had the correct path to it.

You then try to load the JPEG file via `cv2.imread` and notice a `NoneType` or `AssertionError` .

How can this be?

The file exists!

In this case, you likely forgot to compile OpenCV with JPEG file support enabled.

In Debian/Ubuntu systems, this is caused by a lack of `libjpeg` being installed.

For macOS systems, you likely forgot to install the `jpeg` library via Homebrew.

To resolve this problem, regardless of operating system, you’ll need to re-compile and re-install OpenCV. Please see [this page](https://pyimagesearch.com/opencv-tutorials-resources-guides/) for more details on how to compile and install OpenCV on your particular system.

#### Case #2: cv2.VideoCapture and .read

Just like we see `NoneType` errors and `AssertionError` exceptions when using `cv2.imread` , you’ll also see these errors when working with video streams/video files as well.

To access a video stream, OpenCV uses the `cv2.VideoCapture` which accepts a single argument, either:

1.  A **_string_** representing the path to a video file on disk.
2.  An **_integer_** representing the _index_ of a webcam on your computer.

Working with video streams and video files with OpenCV is more complex than simply loading an image via `cv2.imread` , but the same rules apply.

If you try to call the `.read` method of an instantiated `cv2.VideoCapture` (regardless if it’s a video file or webcam stream) and notice a `NoneType` error or `AssertionError` , then you likely have a problem with either:

1.  The path to your input video file (it’s probably incorrect).
2.  Not having the proper video codecs installed, in which case you’ll need to install the codecs, followed by re-compiling and re-installing OpenCV (see [this page](https://pyimagesearch.com/opencv-tutorials-resources-guides/) for a complete list of tutorials).
3.  Your webcam not being accessible via OpenCV. This could be for any number of reasons, including missing drivers, an incorrect index passed to `cv2.VideoCapture` , or simply your webcam is not properly attached to your system.

Again, working with video files is more complex than working with simple image files, so make sure you’re _systematic_ in resolving the issue.

First, try to access your webcam via a separate piece of software than OpenCV.

Or, try to load your video file in a movie player.

If both of those work, you likely have a problem with your OpenCV install.

Otherwise, it’s most likely a codec or driver issue.

### An example of creating and resolving an OpenCV NoneType error

To demonstrate a `NoneType` error in action I decided to create a _highly simplified_ Python + OpenCV script that represents what you might see elsewhere on the PyImageSearch blog.

Open up a new file, name it `display_image.py` , and insert the following code:

\# import the necessary packages
import argparse
import cv2

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add\_argument("-i", "--image", required=True,
	help="path to the image file")
args = vars(ap.parse\_args())

# load the image from disk and display the width, height,
# and depth
image = cv2.imread(args\["image"\])
(h, w, d) = image.shape
print("w: {}, h: {}, d: {}".format(w, h, d))

# show the image
cv2.imshow("Image", image)
cv2.waitKey(0)

All this script does is:

*   Parse command line arguments.
*   (Attempts to) load an image from disk.
*   Prints the width, height, and depth of the image to the terminal.
*   Displays the image to our screen.

For _most_ Python developers who are familiar with the command line, this script won’t give you any trouble.

But if you’re new to the command line and are unfamiliar/uncomfortable with command line arguments, you can **_easily_** run into a `NoneType` error if you’re not careful.

How, you might say?

The answer lies in not properly using/understanding command line arguments.

Over the past few years of running this blog, I’ve seen _many_ emails and blog post comments from readers who are trying to modify the `.add_argument` function to supply the path to their image file.

**DON’T DO THIS — you don’t have to change a _single line_ of argument parsing code.**

Instead, what you _should_ do is spend the next 10 minutes reading through this excellent article that explains _what_ command line arguments are and _how_ to use them in Python:

[https://pyimagesearch.com/2018/03/12/python-argparse-command-line-arguments/](https://pyimagesearch.com/2018/03/12/python-argparse-command-line-arguments/)

This is _required reading_ if you expect to follow tutorials here on the PyImageSearch blog.

Working with the command line, and therefore command line arguments, are a big part of what it means to be a computer scientist — _**a lack of command line skills is only going to harm you**._ You’ll thank me later.

Going back to the example, let’s check the contents of my local directory:

$ ls -l
total 800
-rw-r--r--  1 adrianrosebrock  staff     541 Dec 21 08:45 display\_image.py
-rw-r--r--  1 adrianrosebrock  staff  403494 Dec 21 08:45 jemma.png

As we can see, I have two files:

1.  `display_image.py` : My Python script that I’ll be executing shortly.
2.  `jemma.png` : The photo I’ll be loading from disk.

If I execute the following command I’ll see the `jemma.png` image displayed to my screen, along with information on the dimensions of the image:

$ python display\_image.py --image jemma.png
w: 376, h: 500, d: 3

![Image 3: Figure 1: Loading and displaying an image to my screen with OpenCV and Python.](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20600%20462'%3E%3C/svg%3E)

**Figure 1:** Loading and displaying an image to my screen with OpenCV and Python.

However, let’s try to load an image path that _does not_ exist:

$ python display\_image.py --image i\_dont\_exist.png
Traceback (most recent call last):
  File "display\_image.py", line 17, in <module>
    (h, w, d) = image.shape
AttributeError: 'NoneType' object has no attribute 'shape'

Sure enough, there is our `NoneType`  error.

In this case, it was caused because I did not supply a valid image path to `cv2.imread` .

### What's next? We recommend [PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend).

**Course information:**  
84 total classes • 114+ hours of on-demand code walkthrough videos • Last updated: February 2024  
★★★★★ 4.84 (128 Ratings) • 16,000+ Students Enrolled

**I strongly believe that if you had the right teacher you could _master_ computer vision and deep learning.**

Do you think learning computer vision and deep learning has to be time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in computer science?

That’s _not_ the case.

All you need to master computer vision and deep learning is for someone to explain things to you in _simple, intuitive_ terms. _And that’s exactly what I do_. My mission is to change education and how complex Artificial Intelligence topics are taught.

If you're serious about learning computer vision, your next stop should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you’ll learn how to _successfully_ and _confidently_ apply computer vision to your work, research, and projects. Join me in computer vision mastery.

**Inside PyImageSearch University you'll find:**

*   ✓ **84 courses** on essential computer vision, deep learning, and OpenCV topics
*   ✓ **84 Certificates** of Completion
*   ✓ **114+ hours** of on-demand video
*   ✓ **Brand new courses released _regularly_**, ensuring you can keep up with state-of-the-art techniques
*   ✓ **Pre-configured Jupyter Notebooks in Google Colab**
*   ✓ Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environment configuration required!)
*   ✓ Access to **centralized code repos for _all_ 536+ tutorials** on PyImageSearch
*   ✓ **Easy one-click downloads** for code, datasets, pre-trained models, etc.
*   ✓ **Access** on mobile, laptop, desktop, etc.

[Click here to join PyImageSearch University](https://pyimagesearch.com/pyimagesearch-university/?utm_source=blogPost&utm_medium=bottomBanner&utm_campaign=What%27s%20next%3F%20I%20recommend)

Summary
-------

In this blog post I discussed `NoneType`  errors and `AssertionError`  exceptions in OpenCV and Python.

In the vast majority of these situations, these errors can be attributed to either the `cv2.imread`  or `cv2.VideoCapture`  methods.

Whenever you encounter one of these errors, _**make sure you can load your image/read your frame**_ before continuing. In over 95% of circumstances, your image/frame was not properly read.

Otherwise, if you are using command line arguments and are unfamiliar with them, there is a chance that you aren’t using them properly. In that case, make sure you educate yourself by [reading this tutorial on command line arguments](https://pyimagesearch.com/2018/03/12/python-argparse-command-line-arguments/) — you’ll thank me later.

Anyway, I hope this tutorial has helped you in your journey to OpenCV mastery!

If you’re just getting started studying computer vision and OpenCV, I would highly encourage you to take a look at my book, _[Practical Python and OpenCV](https://pyimagesearch.com/practical-python-opencv/)_, which will help you grasp the fundamentals.

_**Otherwise, make sure you enter your email address in the form below to be notified when future blog posts and tutorials are published!**_

![Image 4](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20410%20567'%3E%3C/svg%3E)

#### Download the Source Code and FREE 17-page Resource Guide

Enter your email address below to get a .zip of the code and a **FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning.** Inside you'll find my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!