Image Processing Part 5: Arithmetic, Bitwise, And Masking

• Blog
• Docs
• Get Support
• Contact Sales

• Tutorials
• Questions
• Product Docs
• Cloud Chats
• Search Community

Report this

What is the reason for this report?This undefined is spamThis undefined is offensiveThis undefined is off-topicThis undefined is otherSubmit

Table of contents

1. Setting up the environment
2. Arithmetic Operations on Images using Python
3. Bitwise Operations
4. Masking of images using Python OpenCV
5. Conclusion
6. References

1. Tutorials
2. Python
3. Image Processing Part 5: Arithmetic, Bitwise, and Masking

TutorialImage Processing Part 5: Arithmetic, Bitwise, and MaskingPublished on August 4, 2022PythonPython Modules

By Meghna Gangwar

Table of contentsPopular topics

In this 5th part of the image processing series, we discuss more on the Arithmetic and bitwise operations, and masking of images in Python.

It is recommended that the previous articles be run through, before starting off on your masked learning adventure here.

Setting up the environment

The following lines of code are used in all of the applications given below. We’ll include those here instead so you don’t have to read through a huge block of code.

Helps reduce clutter :)

# importing numpy to work with pixels import numpy as np # importing argument parsers import argparse # importing the OpenCV module import cv2 # initializing an argument parser object ap = argparse.ArgumentParser() # adding the argument, providing the user an option # to input the path of the image ap.add_argument("-i", "--image", required=True, help="Path to the image") # parsing the argument args = vars(ap.parse_args()) # reading the image location through args # and reading the image using cv2.imread image = cv2.imread(args["image"])

Arithmetic Operations on Images using Python

Arithmetic Operations allow us to enhance a lot of aspects of an image.

We can work with lighting, shadows, the red, blue, and green color enhancement.

A lot of image filters on applications use the same method to alter and beautify photographs as well.

So, let’s get started with all of the code!

First, in order to understand whether the limit can go over 255 or 0, we can conduct a simple test, which provides us with 255 and 0.

# printing out details of image min, max and the wrap around print("max of 255 :", str(cv2.add(np.uint8([200]), np.uint8([100])))) print("min of 0 :", str(cv2.subtract(np.uint8([50]), np.uint8([100])))) print("wrap around :", str(np.uint8([200]) + np.uint8([100]))) print("wrap around :", str(np.uint8([50]) - np.uint8([100])))

In this example, we are increasing the intensity of all the pixels in the image by 100.

# adding pixels of value 255 (white) to the image M = np.ones(image.shape, dtype="uint8") * 100 added = cv2.add(image, M) cv2.imshow("Added", added) cv2.waitKey(0)

This is done by constructing a matrix with the same size as our images using the NumPy module, and adding it with our image.

In case we wish to darken an image, we subtract from the pixel values of the image, as shown below,

# adding pixels of value 0 (black) to the image M = np.ones(image.shape, dtype="uint8") * 50 subtracted = cv2.subtract(image, M) cv2.imshow("Subtracted", subtracted) cv2.waitKey(0)

This should provide you with two different variations of the original image, one lighter, and the other darker.

Bitwise Operations

We use Bitwise operations a lot of the times while attempting to mask images.

This feature of OpenCV allows us to filter out the part of the image that is relevant to us.

Setting up

To work on Bitwise operations, we’ll first need two variables or images that we can conduct the operations on.

So, let’s create a bitwise square and a bitwise circle through which we can use the bitwise operations.

Note that bitwise operations require the images to be black and white.

# creating a square of zeros using a variable rectangle = np.zeros((300, 300), dtype="uint8") cv2.rectangle(rectangle, (25, 25), (275, 275), 255, -1) cv2.imshow("Rectangle : ", rectangle) # creating a circle of zeros using a variable circle = np.zeros((300, 300), dtype="uint8") cv2.circle(circle, (150, 150), 150, 255, -1) cv2.imshow("Circle : ", circle)

The output images that you receive should look like this,

Combine with the AND operation

Bitwise addition refers to the addition of two different images, and decide which is to be displayed using an AND operation on each pixel of the images.

# the bitwise_and function executes the AND operation # on both the images bitwiseAnd = cv2.bitwise_and(rectangle, circle) cv2.imshow("AND", bitwiseAnd) cv2.waitKey(0)

Bitwise addition of both the circle and the square gives us an output which should look like this,

Given a choice with the OR operation

Bitwise OR provides us with a product of the two images with an OR operation performed on each pixel of the images.

# the bitwise_or function executes the OR operation # on both the images bitwiseOr = cv2.bitwise_or(rectangle, circle) cv2.imshow("OR", bitwiseOr) cv2.waitKey(0)

Upon performing the operation Bitwise OR, you should receive something like this,

Exclusivity with the XOR operation

Another operation that is provided by the cv2 module is the XOR operation, which we can use through the bitwise_xor function.

# the bitwise_xor function executes the XOR operation # on both the images bitwiseXor = cv2.bitwise_xor(rectangle, circle) cv2.imshow("XOR", bitwiseXor) cv2.waitKey(0)

Negation using the NOT operation

Lastly, we have the negation operation, which is performed using the bitwise_not function.

The NOT operation only requires a single image as we’re not adding or subtracting anything here.

We still use it on both here however, that’s also an option.

# the bitwise_not function executes the NOT operation # on both the images bitwiseNot = cv2.bitwise_not(rectangle, circle) cv2.imshow("NOT", bitwiseNot) cv2.waitKey(0)

The circle is inside the square in this case, and as such is not visible,

Masking of images using Python OpenCV

Masking is used in Image Processing to output the Region of Interest, or simply the part of the image that we are interested in.

We tend to use bitwise operations for masking as it allows us to discard the parts of the image that we do not need.

So, let’s get started with masking!

The process of masking images

We have three steps in masking.

1. Creating a black canvas with the same dimensions as the image, and naming it as mask.
2. Changing the values of the mask by drawing any figure in the image and providing it with a white color.
3. Performing the bitwise ADD operation on the image with the mask.

Following the same process, let’s create a few masks and use them on our image.

First, let’s work with a rectangle mask.

# creating a mask of that has the same dimensions of the image # where each pixel is valued at 0 mask = np.zeros(image.shape[:2], dtype="uint8") # creating a rectangle on the mask # where the pixels are valued at 255 cv2.rectangle(mask, (0, 90), (290, 450), 255, -1) cv2.imshow("Mask", mask) # performing a bitwise_and with the image and the mask masked = cv2.bitwise_and(image, image, mask=mask) cv2.imshow("Mask applied to Image", masked) cv2.waitKey(0)

Now, let’s try it out with a circle mask.

# creating a mask of that has the same dimensions of the image # where each pixel is valued at 0 mask = np.zeros(image.shape[:2], dtype="uint8") # creating a rectangle on the mask # where the pixels are valued at 255 cv2.circle(mask, (145, 200), 100, 255, -1) cv2.imshow("Mask", mask) # performing a bitwise_and with the image and the mask masked = cv2.bitwise_and(image, image, mask=mask) cv2.imshow("Mask applied to Image", masked) cv2.waitKey(0)

If everything works out just fine, we should receive outputs which look something like this,

Conclusion

We’re finally getting started with the core of Image Processing, and understanding bitwise operations and masking in it is important.

It helps us to block out parts or only take in parts of the image that we are interested in, so, quite a useful concept.

We’re proceeding at a decent pace, but, in case you wish to time skip and get to the end, be my guest!

Here’s articles which let you look into OpenCV and Facial Recognition, and a Java implementation of Android and CameraX OpenCV.

References

• Official OpenCV Website
• Introduction to starting out with OpenCV
• My GitHub Repository for Image Processing
• Arithmetic Operations Code
• Bitwise Operations Code
• Masking Code

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

About the author

Meghna GangwarAuthorCategory:TutorialTags:PythonPython ModulesWhile we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Still looking for an answer?

Ask a questionSearch for more helpWas this helpful?YesNoComments(0)Follow-up questions(0)This work is licensed under a Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International License.

Deploy on DigitalOcean

Click below to sign up for DigitalOcean's virtual machines, Databases, and AIML products.Sign up

Popular Topics

1. AI/ML
2. Ubuntu
3. Linux Basics
4. JavaScript
5. Python
6. MySQL
7. Docker
8. Kubernetes
9. All tutorials
10. Talk to an expert

Featured tutorials

1. SOLID Design Principles Explained: Building Better Software Architecture
2. How To Remove Docker Images, Containers, and Volumes
3. How to Create a MySQL User and Grant Privileges (Step-by-Step)

• All tutorials
• All topic tags

Join the Tech Talk

Success! Thank you! Please check your email for further details.

Please complete your information!

• Table of contents
• Setting up the environment
• Arithmetic Operations on Images using Python
• Bitwise Operations
• Masking of images using Python OpenCV
• Conclusion
• References

• Deploy on DigitalOcean

  Click below to sign up for DigitalOcean's virtual machines, Databases, and AIML products.Sign up

  Popular Topics

  1. AI/ML
  2. Ubuntu
  3. Linux Basics
  4. JavaScript
  5. Python
  6. MySQL
  7. Docker
  8. Kubernetes
  9. All tutorials
  10. Talk to an expert

  Featured tutorials

  1. SOLID Design Principles Explained: Building Better Software Architecture
  2. How To Remove Docker Images, Containers, and Volumes
  3. How to Create a MySQL User and Grant Privileges (Step-by-Step)
  • All tutorials
  • All topic tags

Become a contributor for community

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Sign Up

DigitalOcean Documentation

Full documentation for every DigitalOcean product.

Learn more

Resources for startups and SMBs

The Wave has everything you need to know about building a business, from raising funding to marketing your product.

Learn more

Get our newsletter

Stay up to date by signing up for DigitalOcean’s Infrastructure as a Newsletter.

SubmitSubmit

New accounts only. By submitting your email you agree to our Privacy Policy

The developer cloud

Scale up as you grow — whether you're running one virtual machine or ten thousand.

View all products

Get started for free

Sign up and get $200 in credit for your first 60 days with DigitalOcean.*

Get started

*This promotional offer applies to new accounts only.

© 2025 DigitalOcean, LLC.Sitemap.