{"id":86870,"date":"2023-02-08T09:00:12","date_gmt":"2023-02-08T03:30:12","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=86870"},"modified":"2023-02-08T09:00:12","modified_gmt":"2023-02-08T03:30:12","slug":"image-processing-in-python","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/","title":{"rendered":"Image Processing in Python"},"content":{"rendered":"

The necessity for researchers who can process and analyze picture data <\/span>has increased as computer systems have become quicker and more potent, and cameras and other imaging devices have become more prevalent in many different spheres of life. Automating this processing and analysis may be useful or even required. It is because of a computer program, due to the potential for large volumes of data to be involved, high-resolution images that occupy a lot of virtual memory or disc space, or collections of several photographs that need to be processed at once.<\/span><\/p>\n

Image Processing:<\/span> What is it?<\/span><\/h3>\n

Image processing, as the name suggests, entails processing the image, which may involve a variety of approaches before we achieve our objective.<\/span><\/p>\n

The output can either take the form of an image or a feature corresponding to that image. This can be applied to decision-making and additional analysis.<\/span><\/p>\n

What, though, is an image?<\/span><\/p>\n

A picture can be represented by the 2D function F(x,y), where x and y are spatial coordinates. The amplitude of F at a specific value of x,y is used to determine the intensity of a picture at a given location.<\/span> We refer to it as a digital image if x, y, and the amplitude value is finite. Pixels are grouped in columns and rows in an array.<\/span><\/p>\n

The components of an image that include information about color and intensity are called pixels.<\/span> In 3D representations of images, X, Y, and Z are changed into spatial coordinates.<\/span> A matrix-shaped arrangement of pixels is used.<\/span><\/p>\n

Python libraries for image processing<\/span><\/h3>\n

Many libraries are available in Python for image processing, including:<\/span><\/p>\n

1. Scikit-Image<\/span><\/h4>\n

It is an image preparation library that is open-source. With just a few built-in functions, it can execute complicated manipulations on images using machine learning.<\/span><\/p>\n

Even for individuals who are brand-new to Python, this module is straightforward and works with NumPy arrays. Among the operations that scikit image may perform are:<\/span><\/p>\n

    \n
  • Use the try-all threshold() method on the picture to implement thresholding operations. Seven global thresholding techniques will be used. The filters module contains this.<\/span><\/li>\n
  • Utilize the sobel() method in the filters module to accomplish edge detection. We must first convert the image to grayscale because this method demands a 2D grayscale image as an input.<\/span><\/li>\n
  • Use the filters module’s gaussian() function to achieve gaussian smoothing.<\/span><\/li>\n<\/ul>\n

    2. OpenCV\u00a0<\/span><\/h4>\n

    Open Source Computer Vision Library is what it stands for. This collection contains more than 2000 optimized algorithms for machine learning and computer vision. OpenCV can be used in image processing in several ways, some of which are given below:<\/span><\/p>\n

      \n
    • Converting images between color spaces, such as between BGR and grayscale, BGR and HSV, etc.<\/span><\/li>\n
    • Applying thresholding techniques to picture data, such as basic and adaptive thresholding.<\/span><\/li>\n
    • Blurring and applying custom filters to images are examples of image smoothing.<\/span><\/li>\n<\/ul>\n

      3. NumPy<\/span><\/h4>\n

      You may also use this library to perform basic picture operations like flipping, feature extraction, and analysis.<\/span><\/p>\n

      Images can be represented using Numpy multidimensional arrays, which is why their type is NdArrays. For example, a three-dimensional NumPy array is a color image. The RGB channels of the multidimensional array can be divided.<\/span><\/p>\n

      The image can be subjected to the following operations using NumPy (the image is loaded into a variable named test img using imread).<\/span><\/p>\n

        \n
      • Use np.flipud(test img) to flip the image vertically.<\/span><\/li>\n
      • Use np.fliplr(test img) to flip the picture horizontally.<\/span><\/li>\n
      • Use test img[::-1] to flip the image (the image is named img name> after being stored as a NumPy array).<\/span><\/li>\n<\/ul>\n

        4. PIL\/pillow<\/span><\/h4>\n

        The friendly PIL fork created by Alex Clark and Contributors is called Pillow. PIL stands for Python Image Library. It is among the strong libraries. Many image formats are supported, including PPM, JPEG, TIFF, GIF, PNG, and BMP.<\/span><\/p>\n

        It can let you conduct numerous operations on photographs, including rotating, resizing, cropping, grayscaling, etc. Let’s examine a few of those procedures.<\/span><\/p>\n

        This library has a module called Image that can perform manipulation operations.<\/span><\/p>\n

          \n
        • The open() method can be used to load an image.<\/span><\/li>\n
        • Use the show() function to display a picture.<\/span><\/li>\n
        • Utilize the format attribute to learn the file format.<\/span><\/li>\n<\/ul>\n

          5. Mahotas<\/span><\/h4>\n

          This library has more than 100 functions for computer vision and image processing. Its algorithms are frequently implemented in C++. Mahones has few dependencies because it is an independent module in and of itself.<\/span><\/p>\n

          There is no need for a NumPy module because it simply depends on C++ compilers to do numerical calculations.<\/span><\/p>\n

          Let’s examine a few of the operations that Mahotas can be used for:<\/span><\/p>\n

            \n
          • To read an image use the imread() function.<\/span><\/li>\n
          • Use the mean() method to determine the image’s mean.<\/span><\/li>\n
          • The shortest path length from a particular vertex (v) to any other vertex (w) of a connected graph is used to determine the eccentricity of an image. Use the eccentricity() method in the features module to determine an image’s eccentricity.<\/span><\/li>\n
          • Use the morph module’s erode() and dilate() methods to apply distortion and erosion to a picture.<\/span><\/li>\n
          • Use the locmax() function to determine the image’s local maxima.<\/span><\/li>\n<\/ul>\n

            Install the necessary library in Python<\/span><\/h3>\n

            Installing the necessary libraries, such as OpenCV, pillow, or others, that we intend to employ for image processing will be our first step. Pip can be used to install the necessary libraries, such as<\/span><\/p>\n

            $pip install pillow\n<\/pre>\n
            Python Open() and show image ()<\/span><\/h3>\n
            Images can be turned in any direction, whether clockwise or otherwise. Therefore, we only need to build a rotation matrix that includes the rotation location, rotational force, and scaling factor.<\/span><\/p>\n
            #Import required library\nfrom PIL import Image\n\n#Open Image\nim = Image.open(\"TechVidvan.jpg\")\n\n#Image rotate & show\nim.rotate(45).show()\n<\/pre>\n
            Im, the variable mentioned above, is a pillow object. We can retrieve some data on the opened image.<\/span><\/p>\n
            >>> im\n<PIL.JpegImagePlugin.JpegImageFile image mode = RGB size = 1080x489 at 0x65AB990<\n>>> im.size\n(1080, 667)\n>>> im.format\n'JPEG'\n>>>\n<\/pre>\n
            Python Image Processing Algorithms<\/span><\/h3>\n
            1. Morphological Image Processing<\/h4>\n
            Because binary regions created by straightforward thresholding can be damaged by noise, morphological image processing attempts to clean up the flaws in the binary images. Using opening and closing processes also aids in bringing the image into focus.<\/span><\/p>\n
            Grayscale pictures can be used as an extension for morphological operations. It consists of non-linear procedures connected to the organization of an image’s features. It depends on the numerical values of the pixels and their related ordering. This method compares the related neighborhood pixels with a small template called a structuring element placed in various potential positions throughout the image. A little 0 and 1-dimensional matrix is a structuring element.<\/span><\/p>\n
            Let’s look at the two core morphological image processing procedures, dilation, and erosion:<\/span><\/p>\n
              \n
            • The dilation technique increases the object borders’ pixel count.<\/span><\/li>\n
            • The erosion procedure eliminates the pixels from the object borders.<\/span><\/li>\n<\/ul>\n
              2. Gaussian Image Processing<\/h4>\n
              The outcome of blurring a picture with a Gaussian function is a gaussian blur, commonly referred to as gaussian smoothing.<\/span><\/p>\n
              It is employed to lessen details and visual noise. This blurring creates a similar visual impression to see a picture through a translucent screen. It can be used as a data augmentation method in deep learning or for image improvement at various scales in computer vision.<\/span><\/p>\n
              Splitting the process into two passes is advisable to take advantage of the separable quality of the Gaussian blur. The same one-dimensional kernel is applied in the second pass to blur the remaining direction. The outcome is identical to a single pass convolving with a two-dimensional kernel. Let’s look at an illustration to further grasp what gaussian filters do to an image.<\/span><\/p>\n
              3. Fourier Transform in image processing<\/h4>\n
              The Fourier transform breaks an image into sine and cosine components.<\/span><\/p>\n
              We shall consider the discrete Fourier transform as we are discussing images.<\/span><\/p>\n
              Let’s think about a sinusoid, which consists of three elements:<\/span><\/p>\n
                \n
              • The magnitude and contrast-related terms<\/span><\/li>\n
              • Brightness-related spatial frequency<\/span><\/li>\n
              • Phase: connected to information about color<\/span><\/li>\n<\/ul>\n
                4. Edge Detection in image processing<\/h4>\n
                Edge detection is a method of image processing that locates the edges of objects in pictures. It operates by looking for changes in brightness.<\/span><\/p>\n
                Since most of the shape information is included in the edges, this helps obtain valuable information from the image. Traditional edge detection techniques find brightness discontinuities.<\/span><\/p>\n
                When detecting the changes in grey levels in a picture, it can react quickly if some noise is found. Edges are referred to as the local gradient maxima.<\/span><\/p>\n
                5. Wavelet Image Processing<\/h4>\n
                The Fourier transform that we saw is only applicable to frequency. Wavelets take into account both time and frequency. The non-stationary signals are a good fit for this transformation.<\/span><\/p>\n
                We know that edges are among the most significant aspects of an image, and using conventional filters has been shown to blur the image while removing noise. In addition, low-frequency components can have good frequency resolution thanks to the wavelet transform’s architecture.<\/span><\/p>\n
                Converting a picture to grayscale ()<\/span><\/h3>\n
                We can convert our original colored image into a grayscale version.<\/span><\/p>\n
                >>> TechVidvan_gray = Image.open('TechVidvan.jpg').convert('L')\n>>> TechVidvan_gray.show()\n<\/pre>\n
                The aforementioned sample is from the Python PIL library. For image processing, we can also utilize additional libraries like open-cv, matplotlib, and NumPy. The programs listed below are examples of using a robust library for image processing.<\/span><\/p>\n
                Displaying a grayscale image:<\/strong><\/p>\n
                #Import required library\nimport cv2\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\nim = cv2.imread('TechVidvan.jpg',cv2.IMREAD_GRAYSCALE)\ncv2.imshow('image',im)\ncv2.waitKey(0)\ncv2.destroyAllWindows()\n<\/pre>\n
                Changing a Picture in Python<\/span><\/h3>\n
                An image is translated when it is moved within a specific frame of reference.<\/span><\/p>\n
                import cv2\nimport numpy as np\n \nPic_Name = 'TechVidvan.jpg'\n# Create a translation matrix.\n# Shift would be (x, y), therefore matrix would be\nM = np.float32([[2, 0, 200], [0, 4, 100]])\n \ntry:\n \n    # Next, put the image back on the disc.\n    img = cv2.imread(Pic_Name)\n    (rows, cols) = img.shape[:2]\n    # translation matrix.\n    res = cv2.warpAffine(img, M, (cols, rows))\n \n    # Next, put the image back on the disc.\n    cv2.imwrite('result.jpg', res)\n \nexcept IOError:\n    print ('file reading error')\n<\/pre>\n
                Edge recognition in a picture in Python<\/span><\/h3>\n
                Sharp edges in the image must be found during the image detection procedure. When it comes to object localization or object detection, edge detection is crucial. Because edges have such a wide range of applications, there are many algorithms for identifying them. Canny Edge Detection is one such approach that we’ll use.<\/span><\/p>\n
                import cv2\nimport numpy as np\n \nPic_Name = 'TechVidvan.jpg'\ntry:\n    #Image to be read from the disc.\n    img = cv2.imread(Pic_Name)\n \n    # Canny edge detection.\n    edges = cv2.Canny(img, 200, 400)\n \n    # Next, put the image back on the disc.\n    cv2.imwrite('TechVidvan_logo.jpg', edges)\nexcept IOError:\n    print ('file reading error')\n<\/pre>\n
                Conclusion<\/span><\/h3>\n
                Several image processing packages, including OpenCV, Mahotas, PIL, and sci-kit-learn, can carry out these tasks. Deep learning’s use of Broadway nomenclature and advancements in image processing are changing the world. Because researchers are creating new techniques to optimize the image processing field, learning doesn’t stop here. Keep moving forward with TechVidvan.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
                The necessity for researchers who can process and analyze picture data has increased as computer systems have become quicker and more potent, and cameras and other imaging devices have become more prevalent in many...<\/p>\n","protected":false},"author":1,"featured_media":86976,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1053],"tags":[4843],"class_list":["post-86870","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-image-processing-in-python"],"yoast_head":"\nImage Processing in Python - TechVidvan<\/title>\n<meta name=\"description\" content=\"Several image processing packages including OpenCV, Mahotas, PIL, sci-kit-learn, NumPy are available in Python. Learn more about them.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Image Processing in Python - TechVidvan\" \/>\n<meta property=\"og:description\" content=\"Several image processing packages including OpenCV, Mahotas, PIL, sci-kit-learn, NumPy are available in Python. Learn more about them.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/\" \/>\n<meta property=\"og:site_name\" content=\"TechVidvan\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/TechVidvan\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-02-08T03:30:12+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"960\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:site\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Image Processing in Python - TechVidvan","description":"Several image processing packages including OpenCV, Mahotas, PIL, sci-kit-learn, NumPy are available in Python. Learn more about them.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/","og_locale":"en_US","og_type":"article","og_title":"Image Processing in Python - TechVidvan","og_description":"Several image processing packages including OpenCV, Mahotas, PIL, sci-kit-learn, NumPy are available in Python. Learn more about them.","og_url":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/","og_site_name":"TechVidvan","article_publisher":"https:\/\/www.facebook.com\/TechVidvan\/","article_published_time":"2023-02-08T03:30:12+00:00","og_image":[{"width":960,"height":628,"url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp","type":"image\/webp"}],"author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@vidvantech","twitter_site":"@vidvantech","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#article","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22"},"headline":"Image Processing in Python","datePublished":"2023-02-08T03:30:12+00:00","mainEntityOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/"},"wordCount":1620,"commentCount":0,"publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp","keywords":["Image Processing in Python"],"articleSection":["Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/","url":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/","name":"Image Processing in Python - TechVidvan","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/#website"},"primaryImageOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#primaryimage"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp","datePublished":"2023-02-08T03:30:12+00:00","description":"Several image processing packages including OpenCV, Mahotas, PIL, sci-kit-learn, NumPy are available in Python. Learn more about them.","breadcrumb":{"@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#primaryimage","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2023\/01\/python-libraries-for-image-processing.webp","width":960,"height":628,"caption":"python libraries for image processing"},{"@type":"BreadcrumbList","@id":"https:\/\/techvidvan.com\/tutorials\/image-processing-in-python\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/techvidvan.com\/tutorials\/"},{"@type":"ListItem","position":2,"name":"Image Processing in Python"}]},{"@type":"WebSite","@id":"https:\/\/techvidvan.com\/tutorials\/#website","url":"https:\/\/techvidvan.com\/tutorials\/","name":"TechVidvan Blogs","description":"","publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/techvidvan.com\/tutorials\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/techvidvan.com\/tutorials\/#organization","name":"TechVidvan","url":"https:\/\/techvidvan.com\/tutorials\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","width":200,"height":50,"caption":"TechVidvan"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/TechVidvan\/","https:\/\/x.com\/vidvantech"]},{"@type":"Person","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22","name":"TechVidvan Team","description":"The TechVidvan Team delivers practical, beginner-friendly tutorials on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our experts are here to help you upskill and excel in today\u2019s tech industry."}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/86870","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/comments?post=86870"}],"version-history":[{"count":0,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/86870\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media\/86976"}],"wp:attachment":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media?parent=86870"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/categories?post=86870"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/tags?post=86870"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}