Category: mahotas

Mahotas – Convolution of Image Convolution in image processing is used to perform various filter operations on an image. Here are some of them − Extract features − It is used to detect the features such as edges, corners, blobs, etc. by applying specific filters. Filtering − It is used to perform smoothing and sharpening operationson an image. Compression − we can compress the image by removing the redundant information in the image. Convolution of an Image in Mahotas In Mahotas, you can perform convolution on an image using the convolve() function. This function takes two arguments− the input image and the kernel; where, the kernel is a small matrix that defines the operation to be applied during convolution, such as blurring, sharpening, edge detection, or any other desired effect. Using the convolve() Function The convolve() function is used to perform convolution on an image. Convolution is a mathematical operation that takes two arrays− image and convolution kernel, and produces a third array (output image). The convolution kernel is a small array of numbers that is used to filter the image. The convolution operation is performed by multiplying the corresponding elements of the image and the kernel, and then adding the results together. The output of the convolution operation is a new image that has been filtered by the kernel. Following syntax to perform convolution in mahotas − convolve(image, kernel, mode=”reflect”, cval=0.0, out=None) where, image − It is the input image. kernel − It is the convolution kernel. mode − It specifies how to handle the edges of the image. It can be reflect, nearest constant, ignore, wrap, or mirror. Reflect is selected as default. cval − It specifies the value to use for pixels that are outside of the image. out − It specifies the output image. If the out argument is not specified, a new image will be created. Example In the following example, we first resize the input image ”nature.jpeg” to a ”4×4” shape using mh.imresize() function. Then, we create a ”4×4” kernel with all values set to 1. Finally, we use the mh.convolve() function to perform convolution − import mahotas as mh import numpy as np # Load the image image = mh.imread(”nature.jpeg”, as_grey=True) # Resize the image to 4×4 image = mh.imresize(image, (4, 4)) # Create a 4×4 kernel kernel = np.ones((4, 4)) # Perform convolution result = mh.convolve(image, kernel) print (result) Output Following is the output of the above code − [[3155.28 3152.84 2383.42 1614. ] [2695.96 2783.18 2088.38 1393.58] [1888.48 1970.62 1469.53 968.44] [1081. 1158.06 850.68 543.3 ]] Convolution with a Gaussian Kernel A Gaussian kernel in Mahotas is a small matrix of numbers that is used to blur or smoothen an image. The Gaussian kernel applies a weighted average to each pixel, where the weights are determined by a bell−shaped curve called the Gaussian distribution. The kernel gives higher weights to nearby pixels and lower weights to distant ones. This process helps to reduce noise and enhance features in the image, resulting in a smoother and more visually pleasing output. Following is the basic syntax of Gaussian kernel in mahotas − mahotas.gaussian_filter(array, sigma) Where, array − It is the input array. sigma − It is the standard deviation for Gaussian kernel. Example Following is an example of convolving an image with gaussian filter. Here, we are resizing the image, converting it to grayscale, applying a Gaussian filter to blur the image, and then displaying the original and blurred images side by side − import mahotas as mh import matplotlib.pyplot as mtplt # Load the image image = mh.imread(”sun.png”) # Convert to grayscale if needed if len(image.shape) > 2: image = mh.colors.rgb2gray(image) # Resize the image to 128×128 image = mh.imresize(image, (128, 128)) # Create the Gaussian kernel kernel = mh.gaussian_filter(image, 1.0) # Reduce the size of the kernel to 20×20 kernel = kernel[:20, :20] # Blur the image blurred_image = mh.convolve(image, kernel) # Creating a figure and subplots fig, axes = mtplt.subplots(1, 2) # Displaying original image axes[0].imshow(image) axes[0].axis(”off”) axes[0].set_title(”Original Image”) # Displaying blurred image axes[1].imshow(blurred_image) axes[1].axis(”off”) axes[1].set_title(”Gaussian Filter Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output Output of the above code is as follows − Convolution with Padding Convolution with padding in Mahotas resfers to adding extra pixels or border around the edges of an image. before performing the convolution operation. The purpose of padding is to create a new image with increased dimensions, without losing information from the original image”s edges. Padding ensures that the kernel can be applied to all pixels, including those at the edges, resulting in a convolution output with the same size as the original image. Example Here, we have defined a custom kernel as a NumPy array to emphasize the edges of the image − import numpy as np import mahotas as mh import matplotlib.pyplot as mtplt # Create a custom kernel kernel = np.array([[0, -1, 0],[-1, 5, -1], [0, -1, 0]]) # Load the image image = mh.imread(”sea.bmp”, as_grey=True) # Add padding to the image padding = np.pad(image, 150, mode=”wrap”) # Perform convolution with padding padded_image = mh.convolve(padding, kernel) # Creating a figure and subplots fig, axes = mtplt.subplots(1, 2) # Displaying original image axes[0].imshow(image) axes[0].axis(”off”) axes[0].set_title(”Original Image”) # Displaying padded image axes[1].imshow(padded_image) axes[1].axis(”off”) axes[1].set_title(”Padded Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output After executing the above code, we get the following output − Convolution with a Box Filter for Blurring Convolution with a box filter in Mahotas is a technique that can be used for blurring images. A box filter is a simple filter where each element in the filter kernel has the same value, resulting in a uniform weight distribution. Convolution with a box filter involves sliding the kernel over the image and taking the average of the pixel values in the region covered by the kernel. This average value is then used to replace the center pixel value in the output image. The process is repeated for all

Mahotas – Saving an Image Once you have loaded an image and performed various operations on it, you would need to save the image to preserve modifications. Saving an image refers to the storing of an image in a specific file formats such as PNG, JPEG, or TIFF, among others. This allows you to keep a copy of the image for future use, whether it”s for analysis, processing, or simply viewing. Saving an Image in Mahotas We use the imsave() function to save images in mahotas. The process of saving an image involves two steps− converting the image array to an appropriate format and then saving it to disk. Using the imsave() Function The imsave() function allows you to save an image represented as an array into a file. It supports multiple file formats, including PNG, JPEG, BMP, and more. By specifying the desired filename and the image array as arguments to imsave(), you can easily store the image data on disk. Following is the syntax of imsave() function in Mahotas − mahotas.imsave(filename, arr, format=None) Where, filename − It is a string representing the filename or path of the file where the image will be saved. arr − It is a NumPy array representing the image data that will be saved. Format − It is an optional string representing the file format to use for saving the image. If not specified, Mahotas will attempt to infer the format based on the file extension of the provided ”filename”. Let”s start by saving an image in PNG Format. Saving an Image as PNG We can pass the image with the ”.png” extension to the imsave() function in order to save an image as PNG format. Example Following is the baic example of saving an image as PNG format in Mahotas − import mahotas as ms image = ms.imread(”sun.png”) # saving the image to a file ms.imsave(”sun_saved.png”, image) print (“The image data is saved.”) Output After executing the above code, you will find the resulting PNG file ”sun_saved.png” saved in the current working directory − The image data is saved. Saving an Image as TIFF We can also save the image as TIFF formart by passing the image with the ”.tiff” extension to the imsave() function. Example In here, we are initially loading the image in BMP format, and then saving it as a new image in TIFF format with the filename ”sea_save.tiff” − import mahotas as ms # Loading the image in BMP format image_bmp = ms.imread(”sea.bmp”) # Saving the image in TIFF format ms.imsave(”sea_save.tiff”, image_bmp) print (“The filename sea_save.tiff is saved.”) Output After executing the above code, you will find the resulting TIFF file ”sea_saved.tiff” saved in the current working directory − The filename sea_save.tiff is saved. Saving a Grayscale Image in JPEG Format The Grayscale images are black and white images, where each pixel represents the intensity or brightness of that particular point. It does not have any color information. Think of it as a black and white photograph. To save a grayscale image in Mahotas, we need to first need to specify the dimensions of the image and generate random pixel values for each point in the image. Then, we need to create the grayscale image using these pixel values and display it. Example Following is an example to save a grayscale image in JPEG format. Here, we are generating a random grayscale image using NumPy, with dimensions 256×256 and pixel values ranging from 0 to 39 (inclusive)− import mahotas as mh import numpy as np # Creating a random grayscale image image = np.random.randint(40, 100, size=(256, 256), dtype=np.uint8) # Saving the image file_path = ”natures.jpeg” mh.imsave(file_path, image) print(“Grayscale image is saved.”) Output Once we execute the above code, we will find the resulting JPEG file ”natures.jpeg” saved in the current working directory − Grayscale image is saved. Let us look at difference between both the images. Input Image Following is the original image (before saving) − Output Image After executing the above code, the image saved is as follows −

Mahotas – Displaying Shape of an Image When working with image data, there are scenarios when we need to display the shape of an image. Displaying the shape of an image refers to revealing the dimensions and characteristics of the image, such as its width, height, and color channels; where height corresponds to the number of rows, width corresponds to the number of columns, and channels indicate the number of color channels in the image (e.g., 3 for RGB images). Displaying the Shape of an Image in Mahotas In mahotas, we can display the shape of an image using the shape attribute of a NumPy array, which represents the image. By accessing this attribute, we can obtain the dimensions of the image and determine the appropriate operations to perform based on its shape. Let us discuss different steps and functions offered by Mahotas to extract and visualize the shape information, along with practical examples. Step1: Importing and Loading Images To begin, first we need to import the Mahotas library and load the image we want to analyze. Once Mahotas is installed, we can start working with image shape analysis. Step 2: Displaying the shape of an image To display the shape of an image in mahotas, we can use the shape attribute of a NumPy array. The shape attribute returns a tuple of integers representing the dimensions of the array. In the case of an image, it will provide information about its width, height, and channels. image_shape = image.shape print(“Image Shape:”, image_shape) This will print the shape of the loaded image in the format (height, width, channels). Step 3: Extracting Individual Dimensions When we talk about extracting individual dimensions of the shape in Mahotas, we are referring to obtaining specific information about the size and color components of an image. In simpler terms, an image has different properties like its height, width, and the number of color channels (such as red, green, and blue). Extracting individual dimensions means isolating and getting these specific pieces of information separately. height = image_shape[0] width = image_shape[1] channels = image_shape[2] print(“Height:”, height) print(“Width:”, width) print(“Channels:”, channels) By executing this code, we will access the dimensions of the image using indexing where, The first index corresponds to the height, The second index corresponds to the width The third index corresponds to the number of channels. This will give the individual dimensions of the image. Step 4: Checking for Grayscale Images The Grayscale images are black and white images, where each pixel represents the intensity or brightness of that particular point. It does not have any color information. Think of it as a black and white photograph. Sometimes, we encounter grayscale images, which have only one channel instead of the usual three channels for color images (Red, Green, and Blue). To determine if an image is grayscale, we can check if the number of channels is equal to 1. is_grayscale = channels == 1 if is_grayscale: print(“The image is grayscale.”) else: print(“The image is not grayscale.”) By executing this code, you will find out whether the loaded image is grayscale or not. Based on the result, we can proceed with the appropriate analysis. Step 5: Displaying the Shape Information on the Image Now, let”s explore how to display shape information on the image itself. We can draw shapes or add text overlays to highlight specific shape characteristics. This can be useful when presenting or saving the image with annotated shape information. import matplotlib.pyplot as plt # Create a figure and axes fig, ax = plt.subplots() # Display the image ax.imshow(image) # Add text for shape information ax.text(10, 20, f”Shape: {image_shape}”, color=”white”, fontsize=10, bbox=dict(facecolor=”black”)) # Remove axis ticks ax.set_xticks([]) ax.set_yticks([]) # Show the figure plt.show() When we will execute this code, it will display the image with the shape information overlaid on it. The shape information will be positioned at the specified coordinates, and the text will be displayed in white color on a black bounding box, making it more visible on the image. Complete Example Now, let us look at the complete code that encompasses all the steps discussed above − # Installing the library import mahotas as ms import matplotlib.pyplot as mtplt # Loading the image image = ms.imread(”sun.png”) # Displaying the shape of an image image_shape = image.shape print(“Image Shape:”, image_shape) # Extracting individual dimensions height = image_shape[0] width = image_shape[1] channels = image_shape[2] print(“Height:”, height) print(“Width:”, width) print(“Channels:”, channels) # Checking if the image is grayscale is_grayscale = channels == 1 if is_grayscale: print(“The image is grayscale.”) else: print(“The image is not grayscale.”) # Create a figure and axis fig, ax = mtplt.subplots() # Display the image ax.imshow(image) # Add text for shape information ax.text(350, 200, f”Shape: {image_shape}”, color=”white”, fontsize=8, bbox=dict(facecolor=”green”)) # Remove axis ticks ax.set_xticks([]) ax.set_yticks([]) # Display the image ax.imshow(image) # Add text overlay for dimensions text = f”Dimensions: {width}x{height}x{channels}” if not is_grayscale else f”Dimensions: {width}x{height} (Grayscale)” ax.text(18, 100, text, color=”red”, fontsize=12, fontweight=”bold”) # Remove axis ticks and labels ax.axis(”off”) # Show the image with shape information mtplt.show() Output After executing the above code, we get the following output− Image Shape: (1280, 843, 3) Height: 1280 Width: 843 Channels: 3 The image is not grayscale.

Mahotas – Computer Vision Computer vision, a subfield of artificial intelligence and computer science, focuses on enabling computers to gain a high−level understanding of visual information from images or videos. Inspired by human visual perception, computer vision aims to replicate and surpass human visual capabilities using algorithms, machine learning, and deep learning techniques. Computer vision is an interdisciplinary approach that uses computer science, engineering, mathematics, and databases to make a machine understand the visual data over the years. The availability of large datasets, deep learning, and training machine learning models made computer vision more functional. One such open−source computer vision and image processing library is mahotas. Mahotas is a computer vision library containing image processing operations such as filtering, morphological operations and classification as well as other modern computer vision functions. In this tutorial, we will explore the fundamental concepts, key techniques, and real−world applications of computer vision. Understanding Computer Vision Computer vision involves developing algorithms and models that allow computers to interpret and understand visual data. It encompasses a wide range of tasks, including image classification, object detection and tracking, image segmentation, facial recognition, scene understanding, and 3D reconstruction. The ultimate goal is to enable computers to extract meaningful information from visual data and make intelligent decisions based on that information. Foundations of Computer Vision Computer Vision draws its inspiration from the human visual system, aiming to replicate and even surpass human visual perception in certain tasks. The field finds its roots in the 1960s when researchers began exploring techniques for image recognition and pattern detection. Early approaches focused on handcrafted features and rule−based systems, but with the advent of machine learning and deep learning, computer vision experienced a revolutionary shift. Image Representation− The cornerstone of computer vision lies in how visualinformation is represented and processed. Pixels in images are transformed into numerical data, which can be analyzed and interpreted by algorithms. Feature Extraction− In image analysis, feature extraction plays a vital role in identifying relevant patterns and structures. Early methods included edge detection and corner detection, while modern approaches utilize deep learning to learn abstract features. Machine Learning and Deep Learning− Machine learning algorithms, particularly deep learning neural networks, have been instrumental in the rapid progress of computer vision. Convolutional Neural Networks (CNNs) have achieved remarkable success in tasks like image classification, object detection, and segmentation. Applications of Computer Vision The applications of computer vision are diverse and continually expanding as technology advances. Here are some key areas where computer vision has made a significant impact − Image Classification− Computer vision enables machines to classify objects and scenes in images with remarkable accuracy. From identifying everyday objects to recognizing specific species in nature, image classification has a wide range of applications. Object Detection− Object detection goes beyond classification by not only recognizing objects but also localizing them within the image. It is crucial in tasks such as surveillance, autonomous vehicles, and augmented reality. Image Segmentation− Image segmentation involves dividing an image into meaningful regions, facilitating further analysis and understanding. It is utilized in medical imaging, scene understanding, and video processing. Facial Recognition− Facial recognition technology has numerous applications, including biometric authentication, surveillance, and social media tagging. Optical Character Recognition (OCR)− OCR enables machines to recognize and convert printed or handwritten text in images into editable and searchable digital formats. It is widely used in document digitization and automation. Challenges in Computer Vision While computer vision has made tremendous strides, it still faces several challenges, some of which are − Limited Data− Deep learning models thrive on vast amounts of labeled data, and obtaining annotated datasets for every application can be cumbersome and expensive. Interpretability− Deep learning models are often considered “black boxes,” making it difficult to understand how they arrive at their decisions, which can be crucial in critical applications like healthcare and security. Robustness− Computer vision algorithms must be robust to variations in lighting conditions, viewpoints, and occlusions to perform reliably in real−world scenarios.

Mahotas – XYZ to LAB Conversion We have discussed about XYZ and LAB color space in our previous tutorial. Now let us discuss about the conversion of XYZ color space to LAB color space. To convert XYZ to LAB, we need to perform some calculations using specific formulas. These formulas involve adjusting the XYZ values based on a reference white point, which represents a standard for viewing colors. The adjusted values are then transformed into LAB components using mathematical equations. In simple terms, the XYZ to LAB conversion allows us to represent colors in a way that aligns better with how our eyes perceive them, making it easier to analyze and compare colors accurately. XYZ to LAB Conversion in Mahotas In Mahotas, we can convert an XYZ image to an LAB image using the colors.xyz2lab() function. The XYZ to LAB conversion in mahotas involves the following steps − Normalize XYZ values − First, we need to normalize the XYZ values by dividing them by the white point values. The white point represents the reference color that is considered pure white. This normalization step ensures that the color values are relative to the white point. Calculate LAB values − Once the XYZ values are normalized, mahotas uses a specific transformation matrix to convert them to LAB. This transformation takes into account the nonlinearities in human color perception and adjust the color values accordingly. Obtain LAB values − Finally, mahotas provides the LAB values for the color you started with. The resulting LAB values can then be used to describe the color in terms of its lightness and the two color axes. L component − The L component in LAB represents the lightness of the color and ranges from 0 to 100. Higher values indicate brighter colors, while lower values indicate darker colors. A and B components − The A and B components in LAB represent the color information. The A component ranges from green (-) to red (+), while the B component ranges from blue (-) to yellow (+). These components provide information about the color characteristics of the XYZ values. Using the mahotas.colors.xyz2lab() Function The mahotas.colors.xyz2lab() function takes an XYZ image as input and returns the LAB version of the image. The resulting LAB image retains the structure and overall content of the original XYZ image but updates the color of each pixel. Syntax Following is the basic syntax of the xyz2lab() function in mahotas − mahotas.colors.xyz2lab(xyz, dtype={float}) where, xyz − It is the input image in XYZ color space. dtype (optional − It is the data type of the returned image (default is float). Example In the following example, we are converting an XYZ image to a LAB image using the mh.colors.xyz2lab() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sun.png”) # Converting RGB to XYZ xyz_image = mh.colors.rgb2xyz(image) # Converting XYZ to LAB lab_image = mh.colors.xyz2lab(xyz_image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the XYZ image axes[0].imshow(xyz_image) axes[0].set_title(”XYZ Image”) axes[0].set_axis_off() # Displaying the LAB image axes[1].imshow(lab_image) axes[1].set_title(”LAB Image”) axes[1].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Following is the output of the above code − XYZ to LAB Conversion of a Random Image We can convert a randomly generated XYZ image to LAB color space by first creating an image with any desired dimensions. Next, assign random values to the X, Y, and Z channels for each pixel. The X, Y, and Z channels represent different color components. Once you have the XYZ image, you can then convert it to an LAB image. The resulting image will be in the LAB color space with distinct lightness and color channels. Example The following example shows conversion of a randomly generated XYZ image to an LAB image − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Function to create XYZ image def create_xyz_image(width, height): xyz_image = np.zeros((height, width, 3), dtype=np.float32) for y in range(height): for x in range(width): # Assign XYZ values to the pixel xyz_image[y, x, 0] = 0.035319468 xyz_image[y, x, 1] = 0.655582062 xyz_image[y, x, 2] = 0.157362328 return xyz_image # Defining the dimensions of the image width = 512 height = 512 # Generating the XYZ image xyz_image = create_xyz_image(width, height) # Converting XYZ to LAB lab_image = mh.colors.xyz2lab(xyz_image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the XYZ image axes[0].imshow(xyz_image) axes[0].set_title(”XYZ Image”) axes[0].set_axis_off() # Displaying the LAB image axes[1].imshow(lab_image) axes[1].set_title(”LAB Image”) axes[1].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Output of the above code is as follows −

Mahotas – Features Mahotas is a popular image processing library. It has numerous functions on image processing and analysis. Some of its functionalities are given below − Feature Detection Mahotas can detect several features in the image using various functions like blob Detection, Harris corner detection, and SIFT features. These features are used in understanding the image, and extracting useful information and interesting patterns in the image. Image Filtering Mahotas is provided with many filtering functions such as mean filter, median filter, majority filter, rank filter etc. It also consists of filtering algorithms such as Gaussian and sobel filters. These filters are applied to the image to reduce noise and process the image as desired without losing its quality. Image Segmentation Mahotas can perform image segmentation very effectively. Some of the image segmentation functions includes− image thresholding, Watershed segmentation, distance transform etc. These algorithms divide the image into foreground and background to identify the objects in the image. Image Measurements Mahotas uses a variety of functions to measure various properties of the image including area, perimeter of the objects, centroid and bounding box. These measurements are used to find the size and orientation of the objects, further used in image analysis. Image Input Output One of the vital mahotas feature is that it can process images in various formats such as PNG, JPEG, TIFF, WEBP, BMP, and TIFF-based microscopy formats (LSM and STK). Mahotas can also write the outputs in the above mentioned formats. However these are not built−in formats in mahotas, but other libraries integrated with mahotas can support these formats. Other functions such as convex points calculations, Zernike & Haralick, TAS features, convolution, Sobel edge detection, Watershed, morphological processing, image thresholding, LBP etc. provides additional support in a wide range of image processing applications such as object recognition, medical image analysis and video processing. Connected Component Analysis Connected component analysis is a fundamental operation in image analysis that involves identifying and labeling connected regions in binary images. Mahotas provides functions to perform connected component analysis, allowing users to extract individual objects or regions of interest from the image. This operation is commonly used in applications like object counting, particle analysis, and image segmentation. Mathematical Morphology Mahotas offers a range of mathematical morphology operations, which allow users to analyze the shapes and structures within images. These operations include skeletonization, distance transform, and watershed transform. Skeletonization extracts the “skeleton” or centerline of objects in the image, while the distance transform provides information about the distance of each pixel to the nearest object boundary. The watershed transform is used for image segmentation based on the concept of water flow in a topographic map. Morphological Operations Mahotas includes a variety of morphological operations such as erosion, dilation, opening, and closing. These operations are fundamental in image segmentation, shape analysis, and feature extraction. Mahotas” efficient implementation of these operations enables users to process images quickly and accurately. Image Classification Mahotas supports image classification, enabling users to train machine learning models on extracted image features. By combining Mahotas” feature extraction capabilities with machine learning libraries like scikit−learn, users can perform tasks such as image recognition, object classification, and scene categorization.

Mahotas – Installation We all have learnt earlier that Mahotas provides a wide range of tools for working with images including filtering, feature detection, segmentation, and more. If you are interested in using Mahotas in your Python projects, you will need to install it on your system. We can install Mahotas in several ways, including using pip, conda, or installing from source. In this tutorial, we will cover the steps required to install Mahotas on your machine using different methods. By the end of this tutorial, you will have Mahotas up and running on your system, ready to use for your image processing and computer vision tasks. Using Pip Pip is a package manager for Python that allows us to easily install and manage thirdparty libraries and packages. If we have Python and pip installed on our system, we can install Mahotas by running the following command in our terminal or command prompt− pip install mahotas This will download and install the latest version of Mahotas from the Python Package Index (PyPI) and install it on our system as shown in the output below− C:UsersLenovo>pip install mahotas Collecting mahotas Using cached mahotas-1.4.13-cp310-cp310-win_amd64.whl (1.7 MB) Requirement already satisfied: numpy in c:userslenovoappdatalocalprogramspythonpython310libsite-packages (from mahotas) (1.24.3) Installing collected packages: mahotas Successfully installed mahotas-1.4.13 Using Conda Conda is another package manager for Python that is often used for scientific computing and data analysis. If we are using the Anaconda distribution of Python, we can install Mahotas by running the following command in our terminal or Anaconda prompt− conda install -c conda-forge mahotas This will download and install Mahotas from the conda−forge channel (open−source packages) and install it in our Anaconda environment as shown in the output below− (base) C:UsersLenovo>conda install -c conda-forge mahotas Collecting package metadata (current_repodata.json): done Solving environment: The environment is inconsistent, please check the package plan carefully The following packages are causing the inconsistency: – defaults/win-64::anaconda-client==1.10.0=py39haa95532_0 – defaults/win-64::anaconda-navigator==2.1.4=py39haa95532_0 . . . The following packages will be UPDATED: ca-certificates pkgs/main::ca-certificates-2022.07.19~ –> conda-forge::cacertificates- 2023.5.7-h56e8100_0 openssl 1.1.1q-h2bbff1b_0 –> 1.1.1th2bbff1b By using the Conda−Forge channel, we can access a wide variety of packages and stay upto−date with the latest developments in the scientific computing and data analysis communities. If we don”t want to install conda-forge channel to our conda configuration permanently, we can use the command as shown below to install only mahotas package − conda install -c https://conda.anaconda.org/conda-forge mahotas From Source If we want to install a specific version of Mahotas or need to modify the source code, we can download the source distribution from PyPL − and install it manually. Steps to install mahotas from source To install from source, first we need to download the source distribution and extract it to a directory on our system. Then, we need to open a terminal or command prompt and navigate to the directory where we extracted the source code. Let us learn to install mahotas from source step-by-step − Step1 Install the required dependencies − Mahotas requires NumPy, SciPy, and OpenCV to be installed. We can install these packages using pip or our package manager. For example, using pip − pip install numpy scipy opencv-python Or, If you prefer to use your package manager (on Linux), use the below command − sudo apt-get install python-numpy python-scipy python-opencv Step 2 Download the Mahotas source code − You can download the source code from the official website − . Once you have downloaded the source code, extract it to a directory of your choice. Step 3 Build and install Mahotas − Open a terminal or command prompt and navigate to the directory where you extracted the Mahotas source code. Run the following command to build Mahotas − python mahotassource.py build Step 4 Once the build process completes successfully, run the following command to install Mahotas − sudo python mahotassource.py install After these steps, Mahotas should be installed on your system. You can test it by importing it in a Python script − import mahotas That”s it! You have successfully installed Mahotas from source. These were some of the most common methods of installing Mahotas, depending on your environment and preferences. Choose the method that works best for you and start using Mahotas for your computer vision and image processing tasks.

Mahotas – Loading an Image To perform any operation on an image, we first need to load it into memory. Once the image is loaded, we can access its pixels and apply various operations on it. Loading an image refers to reading an image file from a storage device (such as hard drive, USB drive, or network location) into memory. Loading an Image in Mahotas To load an image using Mahotas, we can use the imread() function, which reads an image file and returns it as a NumPy array. A NumPy array is a grid of values, all of the same type, and indexed by a tuple of nonnegative integers. In the case of an image, the array represents the pixel values of the image. Using the imread() Function The imread() function is the core method in Mahotas for reading and loading images. It accepts a file path as input and returns a NumPy array representing the loaded image. This function can read various image file formats, such as JPEG, PNG, BMP, TIFF, etc. Following is the basic syntax of imread() function in Mahotas − mahotas.imread(”image.file_format”) Where, ”image.file_format” is the actual path and format of the image you want to load. Example In the following example, we are using the imread() function to load an image file named “nature.jpeg” from the current directory. The resulting image is stored in the ”image” variable as a NumPy array − import mahotas as mh from pylab import imshow, show # Loading the image using Mahotas image = mh.imread(”nature.jpeg”) # displaying the original image imshow(image) show() Output Output of the above code is as follows − Loading Different Image Formats The image format refers to the different file formats used to store and encode images digitally. Each format has its own specifications, characteristics, and compression methods. Mahotas provides a wide range of image formats, including common formats like JPEG, PNG, BMP, TIFF, and GIF. We can pass the file path of an image in any of these formats to the imread() function. Example In this example, we demonstrate the versatility of Mahotas by loading images in different formats using the imread() function. Each loaded image is stored in a separate variable − import mahotas as ms import matplotlib.pyplot as mtplt # Loading JPEG image image_jpeg = ms.imread(”nature.jpeg”) # Loading PNG image image_png = ms.imread(”sun.png”) # Loading BMP image image_bmp = ms.imread(”sea.bmp”) # Loading TIFF image image_tiff = ms.imread(”tree.tiff”) # Creating a figure and subplots fig, axes = mtplt.subplots(2, 2) # Displaying JPEG image axes[0, 0].imshow(image_jpeg) axes[0, 0].axis(”off”) axes[0, 0].set_title(”JPEG Image”) # Displaying PNG image axes[0, 1].imshow(image_png) axes[0, 1].axis(”off”) axes[0, 1].set_title(”PNG Image”) # Displaying BMP image axes[1, 0].imshow(image_bmp) axes[1, 0].axis(”off”) axes[1, 0].set_title(”BMP Image”) # Displaying TIFF image axes[1, 1].imshow(image_tiff) axes[1, 1].axis(”off”) axes[1, 1].set_title(”TIFF Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output The image displayed is as follows − Loading Color Images The color images are the ones we typically see, containing various colors. They are composed of three color channels− red, green, and blue. Each pixel”s color is determined by the combination of these three channels. Color images can represent a wide range of colors and are similar to what we see with our eyes. Loading color images in Mahotas means reading an image file that contains color information. The resulting image is represented as a 3D array, where each element represents the color values for each pixel in the red, green, and blue channels. Following is the basic syntax for loading grayscale Images in Mahotas − mahotas.imread(”image.file_format”) Where, ”image.file_format” is the actual path and format of the image you want to load. Example Following is an example of loading a color image in Mahotas − import mahotas as ms import matplotlib.pyplot as mtplt # Loading colored image colored_image = ms.imread(”nature.jpeg”) # Displaying colored image mtplt.imshow(colored_image) mtplt.axis(”off”) mtplt.show() Output Output of the above code is as follows − Loading Color and Grayscale image To load a grayscale image in mahotas, we need to pass the ”as_grey=True” parameter to the imread() function. Example In the following example, we are trying to load a grayscale image and a color image together using Mahotas − import mahotas as ms import matplotlib.pyplot as mtplt # Loading color image color_image = ms.imread(”tree.tiff”) # Loading grayscale image grayscale_image = ms.imread(”tree.tiff”, as_grey=True) # Creating a figure and subplots fig, axes = mtplt.subplots(1, 2) # Displaying colored image axes[0].imshow(color_image) axes[0].axis(”off”) axes[0].set_title(”Colored Image”) # Displaying grayscale image axes[1].imshow(grayscale_image, cmap=”gray”) axes[1].axis(”off”) axes[1].set_title(”Grayscaled Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output The output is as shown below −

Mahotas – History Mahotas is a powerful Python library for image processing and computer vision. It has gained widespread recognition and popularity among researchers, developers, and data scientists. The rich set of functionalities, efficient performance, and ease of use in mahotas have made it a valuable tool in various applications. In this tutorial, we will embark on a journey through the history of Mahotas, tracing its origins, major milestones, and the impact it has had on the field of image analysis. Origins and Early Development The development of Mahotas began in the late 2000s by Luis Pedro Coelho, a well known researcher in computer vision and image processing. It started when Coelho identified the need for a versatile and efficient image processing library. Coelho aimed to create a tool that would bridge the gap between Python and C++, providing researchers with the computational power of C++ and the ease of use of Python. Thus, the journey of Mahotas begun, with Coelho”s vision driving its initial development. Release and Growth Mahotas was officially released as an open−source project in 2010. It successfully marked a significant milestone in the field of image processing. Its initial release included a core set of functionalities that laid the foundation for subsequent developments. The library quickly garnered attention from the computer vision community, due to its comprehensive functionality and efficient implementation. Continuous Development and Expansion Since its beginning, Mahotas has witnessed continuous development and expansion. Researchers and developers from all around the world contributed to its growth due to the open−source nature of the project. This collaborative effort of the researchers led to the incorporation of new features, bug fixes, and performance improvements, making Mahotas a robust and reliable library for image processing. Integration with Scientific Python Ecosystem One of the key factors behind Mahotas” success is its seamless integration with the Scientific Python ecosystem. Mahotas is designed to work hand in hand with other popular libraries such as NumPy, SciPy, and scikit−image. This integration provides users with a comprehensive set of tools for data manipulation, scientific computing, and image analysis. The interoperability of Mahotas with these libraries has expanded its capabilities and enhanced its usability in various research domains. Adoption and Impact Over the years, Mahotas has gained significant adoption and made a substantial impact on the field of image analysis. Researchers and practitioners from diverse disciplines, including biomedicine, remote sensing, robotics, and industrial inspection, have utilized Mahotas for their image processing needs. Its efficient algorithms and functions have enabled groundbreaking research and applications, pushing the boundaries of what is possible in image analysis. Community and Support Mahotas owes much of its success to its vibrant and supportive community. The opensource nature of the project has fostered a collaborative environment where researchers and developers actively contribute to its development and improvement. The community provides valuable feedback, reports bugs, suggests new features, and shares their experiences and use cases, creating a rich ecosystem around Mahotas. Continuous Innovation and Future Prospects The development of Mahotas does not stand still. As new technologies and methodologies emerge, the Mahotas team continues to innovate and improve the library. The integration of deep learning techniques, advancements in 3D image processing, and the exploration of explainable AI are just a few areas where Mahotas can continue to evolve and make significant contributions. Additionally, the expanding use of Mahotas in real−time applications, edge computing, and embedded systems opens up new possibilities for its application in a variety of domains.

Mahotas – Loading Image as Grey The grayscale images are a kind of black−and−white images or gray monochrome, consisting of only shades of gray. The contrast ranges from black to white, which is the weakest intensity to the strongest respectively. The grayscale image only contains the brightness information and no color information. This is the reason of white being the maximum luminance (brightness) and black being the zero luminance, and everything in between consists shades of gray. Loading Grayscale Images In Mahotas, loading grayscale images involves reading an image file that only contains intensity values for each pixel. The resulting image is represented as a 2D array, where each element represents the intensity of a pixel. Following is the basic syntax for loading grayscale Images in Mahotas − mahotas.imread(”image.file_format”, as_grey=True) Where, ”image.file_format” is the actual path and format of the image you want to load and ”as_grey=True” is passed as an argument to indicate that we want to load the image as grayscale. Example Following is an example of loading a grayscale image in Mahotas − import mahotas as ms import matplotlib.pyplot as mtplt # Loading grayscale image grayscale_image = ms.imread(”nature.jpeg”, as_grey=True) # Displaying grayscale image mtplt.imshow(grayscale_image, cmap=”gray”) mtplt.axis(”off”) mtplt.show() Output After executing the above code, we get the output as shown below − Loading Different Image Formats as Grayscale The image format refers to the different file formats used to store and encode images digitally. Each format has its own specifications, characteristics, and compression methods. Mahotas provides a wide range of image formats, including common formats like JPEG, PNG, BMP, TIFF, and GIF. We can pass the file path of a grayscale image in any of these formats to the imread() function. Example In this example, we demonstrate the versatility of Mahotas by loading grayscale images in different formats using the imread() function. Each loaded image is stored in a separate variable − import mahotas as ms import matplotlib.pyplot as mtplt # Loading JPEG image image_jpeg = ms.imread(”nature.jpeg”, as_grey = True) # Loading PNG image image_png = ms.imread(”sun.png”,as_grey = True) # Loading BMP image image_bmp = ms.imread(”sea.bmp”,as_grey = True) # Loading TIFF image image_tiff = ms.imread(”tree.tiff”,as_grey = True) # Creating a figure and subplots fig, axes = mtplt.subplots(2, 2) # Displaying JPEG image axes[0, 0].imshow(image_jpeg) axes[0, 0].axis(”off”) axes[0, 0].set_title(”JPEG Image”) # Displaying PNG image axes[0, 1].imshow(image_png) axes[0, 1].axis(”off”) axes[0, 1].set_title(”PNG Image”) # Displaying BMP image axes[1, 0].imshow(image_bmp) axes[1, 0].axis(”off”) axes[1, 0].set_title(”BMP Image”) # Displaying TIFF image axes[1, 1].imshow(image_tiff) axes[1, 1].axis(”off”) axes[1, 1].set_title(”TIFF Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output The image displayed is as follows − Using the Color Mode ”L” The “L” color mode represents luminance, which is a measure of the brightness of a color. It is derived from the RGB (Red, Green, Blue) color model, in which the intensity values of the red, green and blue channels are combined to calculate the grayscale intensity. The “L” mode discards the color information and represents the image using only the grayscale intensity values. To load image as grey by specifying the color mode as “L” in mahotas, we need to pass the parameter as_grey=”L” to the imread() function. Example In here, we are loading a grayscale image and specifying the color mode as ”L” − import mahotas as ms import matplotlib.pyplot as mtplt # Loading grayscale image image = ms.imread(”sun.png”) grayscale_image = ms.imread(”sun.png”, as_grey = ”L”) # Creating a figure and subplots fig, axes = mtplt.subplots(1, 2) # Displaying original image axes[0].imshow(image) axes[0].axis(”off”) axes[0].set_title(”Original Image”) # Displaying grayscale image axes[1].imshow(grayscale_image, cmap=”gray”) axes[1].axis(”off”) axes[1].set_title(”Grayscaled Image”) # Adjusting the spacing and layout mtplt.tight_layout() # Showing the figure mtplt.show() Output Following is the output of the above code −