Category: mahotas

Mahotas – XYZ to RGB Conversion We learnt about XYZ color space, RGB color space, and RGB to XYZ conversion in our previous tutorial. Now let us discuss about the conversion of XYZ color space to RGB color space. When we convert from XYZ to RGB, we are taking the XYZ values of a color, which represent its perceptual properties, and transforming them into red, green, and blue values. This conversion allows us to represent the color in a format that is suitable for display on a particular device or screen. XYZ to RGB Conversion in Mahotas In Mahotas, we can convert an XYZ image to an RGB image using the colors.xyz2rgb() function. The XYZ to RGB conversion in Mahotas involves the following steps − Normalize the XYZ values − Normalize the X, Y, and Z values so that they range between 0 and 1. This step ensures that the XYZ values are relative to a reference white point and allows for consistent color calculations. Convert normalized XYZ to linear RGB − Next, use a conversion matrix to convert the normalized XYZ values to linear RGB values. The conversion matrix specifies how the XYZ coordinates contribute to the red, green, and blue components of the resulting color. The matrix multiplication is performed to obtain the linear RGB values. Apply gamma correction − Gamma correction adjusts the brightness of the RGB values to match the response of the human visual system. Scale the RGB values − After gamma correction, the RGB values are typically in the range of 0 to 1. To represent the colors in the 8−bit range (0−255), you need to scale the RGB values. Multiply each of the gamma−corrected RGB values by 255 to bring them to the appropriate scale. Result − Once the scaling is applied, you have obtained the RGB color values. These values represent the intensities of the red, green, and blue channels of the resulting color. Using the mahotas.colors.xyz2rgb() Function The mahotas.colors.xyz2rgb() function takes an XYZ image as input and returns the RGB color space version of the image. The resulting RGB image retains the structure and content of the original XYZ image, however some color detail is lost. Syntax Following is the basic syntax of the xyz2rgb() function in mahotas − mahotas.colors.xyz2rgb(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 an RGB image using the mh.colors.xyz2rgb() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”nature.jpeg”) # Converting it to XYZ xyz_image = mh.colors.rgb2xyz(image) # Converting back to RGB (lossy) rgb_image = mh.colors.xyz2rgb(xyz_image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original XYZ image axes[0].imshow(xyz_image) axes[0].set_title(”XYZ Image”) axes[0].set_axis_off() # Displaying the RGB image axes[1].imshow(rgb_image) axes[1].set_title(”RGB 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 − Using Transformation Matrix We can use a transformation matrix to convert an XYZ image to an RGB image. The transformation matrix has a set of values that are used to transform a XYZ pixel to RGB pixel. The XYZ pixels are converted to RGB pixels by doing matrix multiplication between the transformation matrix and the XYZ image. We achieve this by using the dot() function in the numpy library. The values of each pixel are then normalized from the range of 0 to 1 (intensity range of XYZ color) to the range of 0 to 255 (intensity range of RGB colors) by multiplying by 255 and then dividing by the maximum intensity of that pixel to obtain the RGB image. Example The following example shows conversion of an XYZ image to an RGB image using transformation matrix − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Function to convert XYZ to RGB def xyz_to_rgb(xyz_image): # XYZ to RGB conversion matrix xyz_to_rgb_matrix = np.array([[3.2406, -1.5372, -0.4986], [-0.9689, 1.8758, 0.0415],[0.0557, -0.2040, 1.0570]]) # Perform the XYZ to RGB conversion using matrix multiplication rgb_image = np.dot(xyz_image, xyz_to_rgb_matrix.T) # Scale the RGB values from the range [0, 1] to [0, 255] rgb_image = (rgb_image * 255.0 / np.max(rgb_image)).astype(np.uint8) return rgb_image # Loading the image image = mh.imread(”tree.tiff”) # Converting it to XYZ xyz_image = mh.colors.rgb2xyz(image) # Converting back to RGB (lossy) rgb_image = xyz_to_rgb(xyz_image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original XYZ image axes[0].imshow(xyz_image) axes[0].set_title(”XYZ Image”) axes[0].set_axis_off() # Displaying the RGB image axes[1].imshow(rgb_image) axes[1].set_title(”RGB 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 – SURF Integral SURF, which stands for Speeded−Up Robust Features, is an algorithm used to detect features. The SURF integral is a key concept within this algorithm. To understand the SURF integral, let”s start with the idea of an image. An image is composed of pixels, which are tiny dots that store information about the intensity of the image at that particular location. Now, imagine dividing the image into a small local neighborhood. The SURF integral is a way to efficiently calculate the total pixel value for each local neighborhood. SURF Integral in Mahotas In Mahotas, we can use the mahotas.features.surf.integral() function to compute the SURF integral of an image. Following is the basic approach of how the function works − Initialization − First, the function initializes the integral image by setting all the pixel values to zero. Integral images refer to images that store the sum of all pixels up to a certain point. Recursive Sum Calculation − The function then proceeds to calculate the sum of pixels for each point in the integral image. It does this recursively, meaning it calculates the sum for each point based on the previous sums. As the integral images store the sum of all pixels up to a specific point, they can significantly increase the speed of computing SURF descriptors. Since the function uses recursion, it can be slow for computing the sum of large images. The mahotas.features.surf.integral() function The mahotas.features.surf.integral() function takes a grayscale image as input and returns an integral image as output. The returned result is a new image, typically in the form of a NumPy array, where each pixel value corresponds to the sum of pixel intensities up to that pixel location. Syntax Following is the basic syntax of the surf.integral() function in mahotas − mahotas.features.surf.integral(f, in_place=False, dtype=<class ”numpy.float64”>) Where, f − It is the input image. in_place (optional) − It a flag which determines whether to overwrite the input image (default is ”False”). dtype (optional) − It specifies the data type of the output image (default is float64). Example In the following example, we are calculating the SURF integral of an image using the mh.features.surf.integral() function. import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sea.bmp”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Getting the SURF integral surf_integral = surf.integral(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf integral axes[1].imshow(surf_integral) axes[1].set_title(”SURF Integral”) 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 − SURF Integral of a Random Image We can also compute SURF integral of a randomly generate two−dimensional image. A two−dimensional random image refers to an image where each pixel is assigned a random intensity value. The intensity value can range from 0 (black) to 255 (white). In mahotas, to create a 2−D random image we first specify its dimensions. Then, we pass these dimensions along with the intensity range of the pixels to np.random.randint() function. After that we can compute the SURF integral of the image using the surf.integral() function. Example In the example mentioned below, we are computing the SURF integral of a randomly generated 2−D image. import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt # Specifying dimensions of image l, w = 1000, 1000 # Creating a random 2-D image image = np.random.randint(0, 256, (l, w)) # Getting the SURF integral surf_integral = surf.integral(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf integral axes[1].imshow(surf_integral) axes[1].set_title(”SURF Integral”) 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 − SURF Integral of a Threshold Image In addition to random 2−D images, we can also compute the SURF integral of a threshold image. A threshold image is a binary image where the pixels are classified into the foreground or the background. The foreground pixels are white and represented by the value 1, while the background pixels are black and represented by value 0. In mahotas, we first threshold the input image using any thresholding algorithm. Let us assume . This can be done by using the mh.thresholding.bernsen() function on a grayscale image. Then, we can compute the SURF integral of threshold image using the surf.integral() function. Example In here, we are calculating SURF integral of a threshold image. import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”tree.tiff”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Thresholding the image image = mh.thresholding.bernsen(image, 5, 5) # Getting the SURF integral surf_integral = surf.integral(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf integral axes[1].imshow(surf_integral) axes[1].set_title(”SURF Integral”) axes[1].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output After executing the above code, we get the following output −

Mahotas – Making Image Wavelet Center Image wavelet centering refers to shifting the wavelet coefficients of an image to the wavelet center, a point at which the wavelet reaches its maximum amplitude. Wavelet coefficients are numerical values representing the contribution of different frequencies to an image. Wavelet coefficients are obtained by breaking an image into individual waves using a wavelet transformation. By centering the coefficients, the low and high frequencies can be aligned with the central frequencies to remove noise from an image. Making Image Wavelet Center in Mahotas In Mahotas, we can use the mahotas.wavelet_center() function to make an image wavelet centered to reduce noise. The function performs two major steps to make the image wavelet centered, they are as follows − First it decomposes the signals of the original image into wavelet coefficients. Next, it takes the approximation coefficients, which are coefficients with low frequencies, and aligns them with central frequencies. By doing the alignment of frequencies, the average intensity of the image is removed, hence removing noise. The mahotas.wavelet_center() function The mahotas.wavelet_center() function takes an image as input, and returns a new image with the wavelet center at the origin. It decomposes (breaks−down) the original input image using a wavelet transformation and then shifts the wavelet coefficients to the center of the frequency spectrum. The function ignores a border region of the specified pixel size when finding the image wavelet center. Syntax Following is the basic syntax of the wavelet_center() function in mahotas − mahotas.wavelet_center(f, border=0, dtype=float, cval=0.0) where, f − It is the input image. border (optional) − It is the size of the border area (default is 0 or no border). dtype (optional) − It is the data type of the returned image (default is float). cval (optional) − It is the value used to fill the border area (default is 0). Example In the following example, we are making an image wavelet centered using the mh.wavelet_center() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sun.png”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Centering the image centered_image = mh.wavelet_center(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the centered image axes[1].imshow(centered_image, cmap=”gray”) axes[1].set_title(”Centered 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 − Centering using a Border We can perform image wavelet centering using a border to manipulate the output image. A border area refers to a region surrounding an object in the image. It separates the object from background region or neighboring objects. In mahotas, we can define an area that should not be considered when doing wavelet centering by setting the pixel values to zero. This is done by passing a value to the border parameter of the mahotas.wavelet_center() function. The function ignores as many pixels as specified in the parameter when doing image wavelet centering. For example, if border parameter is set to 500, then 500 pixels on all sides will be ignored when centering the image wavelet. Example In the example mentioned below, we are ignoring a border of certain size when centering an image wavelet. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sea.bmp”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Centering the image with border centered_image = mh.wavelet_center(image, border=500) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the centered image axes[1].imshow(centered_image, cmap=”gray”) axes[1].set_title(”Centered 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 − Centering by applying Padding We can also do centering by applying padding to fill the border area with a shade of gray. Padding refers to the technique of adding extra pixel values around the edges of an image to create a border. In mahotas, padding can be applied by specifying a value to the cval parameter of the mahotas.wavelet_center() function. It allows us to fill the border region with a color, with the value ranging from 0 (black) to 255 (white). Note − Padding can only be applied if a border area is present. Hence, the value or border parameter should not be 0. Example In here, we are ignoring a border of specific pixel size and applying padding to center an image wavelet. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”nature.jpeg”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Centering the image with border centered_image = mh.wavelet_center(image, border=100, cval=109) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the centered image axes[1].imshow(centered_image, cmap=”gray”) axes[1].set_title(”Centered Image”) axes[1].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output After executing the above code, we get the following output −

Mahotas – Majority Filter The majority filter is used to remove the noise from an image. It works by looking at a pixel in an image and considering its neighboring pixels. The majority filter calculates the most common pixel value among its neighbors and replaces the original pixel value with that common value. Imagine you have a black−and−white image where white represents the object you”re interested in and black represents the background. However, due to various reasons, there might be some small black dots (noise) scattered around the object. So to reduce the noise, it counts how many neighboring pixels are black and how many are white. Then, it replaces the original pixel value with the color (black or white) that appears most frequently among its neighbors. Majority Filter in Mahotas To apply the majority filter in mahotas, we can use the majority_filter() function. The majority filter in Mahotas uses a structuring element to examine pixels in a neighborhood. The structuring element counts the pixel values within the neightborhood and replaces the value of each pixel with the most common value to reduce noise. The size of the structuring element determines the extent of smoothing. A larger neighborhood results in stronger smoothing effect, while reducing some finer details, whereas a smaller neightborhood results in less smoothing but maintains more details. The mahotas.majority_filter() function The majority_filter() function applies the majority filter to the input image using the specified neighborhood size. It replaces each pixel value with the majority value among its neighbors. The filtered image is stored in the output array. Syntax Following is the basic syntax of the majority filter in mahotas − mahotas.majority_filter(img, N=3, out={np.empty(img.shape, bool)}) Where, img − It is the input image. N − It is the size of the filter. It must be an odd integer. The default value is 3. Out (optional) − It specifies the output array where the filtered image will be stored. It must be an empty boolean array with the same size as the input image. Example Following is the basic example to filter the image using the majority_filter() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image=mh.imread(”picture.jpg”, as_grey = True) filtered_image = mh.majority_filter(image) # Displaying the original image fig, axes = mtplt.subplots(1, 2, figsize=(9, 4)) axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].axis(”off”) # Displaying the majority filtered image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Majority Filtered”) axes[1].axis(”off”) mtplt.show() Output After executing the above code, we get the following output − By Specifying Window Size To specify the window size in Mahotas, we need to pass it as a parameter to the majority_filter() function. The window size is the number of pixels that will be used to determine the majority value for each pixel in the image. The size of window must be an odd integer. This is because the majority filter works by finding the most common value in a neighborhood of pixels. If the window size is even, there will be two pixels with the same value in the center of the window, and the majority filter will not be able to determine which value is the most common. Example import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image=mh.imread(”picture.jpg”, as_grey = True) # Specify a filter size filter_size = 19 # Apply majority filter with the specified filter size filtered_image = mh.majority_filter(image, N=filter_size) # Displaying the original image fig, axes = mtplt.subplots(1, 2, figsize=(9, 4)) axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].axis(”off”) # Displaying the majority filtered image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Majority Filtered”) axes[1].axis(”off”) mtplt.show() Output Following is the output of the above code − By Storing Result in an Output Array We can store the result of the majority filter in an output array as well using Mahotas. To achieve this, we first need to create an empty array using the NumPy library. This array is initialized with the same shape as the input image to store the resultant filtered image. The data type of the array is specified as bool, assuming a Boolean image. Finally, we store the resultant filtered image in the output array by passing it as a parameter to the majority_filter() function. Example In here, we are trying to apply majority filter to a grayscale image and store the result in a specific output array − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image=mh.imread(”pic.jpg”, as_grey = True) # Create an output array for the filtered image output = np.empty(image.shape, dtype=bool) # Apply majority filter with a 3×3 neighborhood # store the result in the output array mh.majority_filter(image, N=3, out=output) # Displaying the original image fig, axes = mtplt.subplots(1, 2, figsize=(9, 4)) axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].axis(”off”) # Displaying the majority filtered image axes[1].imshow(output, cmap=”gray”) axes[1].set_title(”Majority Filtered”) axes[1].axis(”off”) mtplt.show() Output Output of the above code is as follows −

Mahotas – Getting Border of Labels Getting the border of labels refers to extracting the border pixels of a . A border can be defined as a region whose pixels are located at the edges of an image. A border represents the transition between different regions of an image. Getting borders of labels involves identifying the border regions in the labeled image and separating them from the background. Since a labeled image consists of only the foreground pixels and the background pixels, the borders can be easily identified as they are present adjacent to the background regions. Getting Border of labels in Mahotas In Mahotas, we can use the mahotas.labeled.borders() function to get the border of labels. It analyzes the neighboring pixels of the labeled image and considers the connectivity patterns to get the borders. The mahotas.labeled.borders() function The mahotas.labeled.borders() function takes a labeled image as input and returns an image with the highlighted borders. In the resultant image, the border pixels have a value of 1 and are part of the foreground. Syntax Following is the basic syntax of the borders() function in mahotas − mahotas.labeled.borders(labeled, Bc={3×3 cross}, out={np.zeros(labeled.shape, bool)}) Where, labeled − It is the input labeled image. Bc (optional) − It is the structuring element used for connectivity. out (optional) − It is the output array (defaults to new array of same shape as labeled). Example In the following example, we are getting the borders of labels using the mh.labeled.borders() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”nature.jpeg”, as_grey=True) # Applying thresholding image = image > image.mean() # Converting it to a labeled image labeled, num_objects = mh.label(image) # Geting border of labels borders = mh.labeled.borders(labeled) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the labeled image axes[0].imshow(labeled) axes[0].set_title(”Labeled Image”) axes[0].set_axis_off() # Displaying the borders axes[1].imshow(borders) axes[1].set_title(”Border Labels”) 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 − Getting Borders by using a Custom Structuring Element We can also get borders of labels by using a custom structuring element. A structuring element is an array which consists of only 1s and 0s. It is used to define the connectivity structure of the neighboring pixels. Pixels that are included in the connectivity analysis have the value 1, while the pixels that are excluded have the value 0. In mahotas, we create a custom structuring element using the mh.disk() function. Then, we set this custom structuring element as the Bc parameter in the borders() function to get the borders of labels. Example Here, we are getting borders of labels using a custom structuring element. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sea.bmp”, as_grey=True) # Applying thresholding image = image > image.mean() # Converting it to a labeled image labeled, num_objects = mh.label(image) # Geting border of labels borders = mh.labeled.borders(labeled, mh.disk(5)) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the labeled image axes[0].imshow(labeled) axes[0].set_title(”Labeled Image”) axes[0].set_axis_off() # Displaying the borders axes[1].imshow(borders) axes[1].set_title(”Border Labels”) 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 – Polygon Utilities Polygon utilities are a collection of tools designed to handle polygons. A polygon refers to a closed shape defined by a sequence of connected vertices. These utilities offer functionalities to perform various tasks related to polygons, such as manipulation, area calculation, point−in−polygon tests, and more. Internally, the polygon utilities in Mahotas utilize algorithms and techniques from computational geometry to achieve their functionalities. These underlying algorithms ensure accurate and efficient polygon manipulation and analysis. Overall, the polygon utilities in Mahotas serve as a toolbox for working with polygons in image processing tasks, offering essential functionalities and algorithms to manipulate, analyze, and perform operations on these shapes efficiently. Polygon Utilities Functions in Mahotas Following are the different polygon utility functions available in mahotas − S.No Function & Description 1 convexhull() This function creates the smallest shape that encloses a set of points while maintaining its convexity (convex hull). 2 fill_convexhull() This function fills the interior of the convex hull generated by a set of points. 3 fill_polygon() This function fills the interior of a polygon defined by a set of points. 4 line() This function draws a straight line between two specified points. Now, let”s briefly understand these four functions and see their examples. The convexhull() function The convexhull() function generates the convex hull of a set of points in an image. Convex hull is the smallest polygon that encloses the given points. The function generates the convex hull by identifying the vertices of the polygon and ensuring that all internal angles are less than or equal to 180 degrees. Syntax Following is the basic syntax of the convexhull() function in mahotas − mahotas.polygon.convexhull(bwimg) where, bwimg − It is the input binary image. Example In the example below, we are getting the hull of an image using the convexhull() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image = np.zeros((10, 10), bool) image[2, 5] = 1 image[3, 6] = 1 image[4, 9] = 1 # Computing convex hull convex_hull = mh.polygon.convexhull(image) # Printing the value of the hull print(convex_hull) # Displaying the convex hull mtplt.imshow(convex_hull) mtplt.title(”Convex Hull”) # Showing the figures mtplt.show() Output Following is the output of the above code − [[2 5] [3 6] [4 9]] The image obtained is as follows − The fill_convexhull() function The fill_convexhull() function fills the interior of the convex hull with a color generated by a set of points in an image. The function ensures that all the pixels within the convex hull are assigned a specific color. Syntax Following is the basic syntax of the fill_convexhull() function in mahotas − mahotas.polygon.fill_convexhull(bwimg) where, bwimg − It is the input binary image. Example Here, we are filling the hull with color using the fill_convexhull() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image = np.zeros((10, 10), bool) image[2, 5] = 1 image[3, 6] = 1 image[4, 9] = 1 # Filling convex hull fill_convexhull = mh.polygon.fill_convexhull(image) # Displaying the filled convex hull mtplt.imshow(fill_convexhull) mtplt.title(”Filled Convex Hull”) # Showing the figures mtplt.show() Output After executing the above code, we get the following output − The fill_polygon() function Similarly, the fill_polygon() function is used to fill the interior of a polygon with a specific color in an image. It takes the points representing the polygon shape and performs a filling operation within the boundary of the polygon. Syntax Following is the basic syntax of the fill_polygon() function in mahotas − mahotas.polygon.fill_polygon([(y0, x0), (y1, x1), …, ], canvas, color=1) where, [(y0, x0), (y1, x1), …, ] − These are list of (y, x) coordinates that define the shape of the polygon. canvas − It is the image in which the polygon will be filled. color (optional) − It determines the colors of the pixels inside the polygon (default is 1). Example In this example, we are filling a polygon with color using the fill_polygon() function. import numpy as np import matplotlib.pyplot as mtplt import mahotas.polygon as mp # Create a 100×100 image with all zeros canvas = np.zeros((100, 100), dtype=np.uint8) # Define the polygon as a list of (y, x) points polygon = [(0, 0), (50, 0), (50, 50), (0, 50)] # Fill the polygon in the canvas. mp.fill_polygon(polygon, canvas, color=255) # Display the image plt.imshow(canvas, cmap=”gray”) plt.show() Output We get the following image as output − The line() function The line() function is used to draw a straight line between two specified points (the start and the end) in an image. The points are represented by their x and y coordinates. x0 and y0 are the coordinates of starting point, and x1 and y1 are coordinates of ending point. Syntax Following is the basic syntax of the line() function in mahotas − mahotas.polygon.line((y0, x0), (y1, x1), canvas, color=1) where, (y0, x0) − It is a tuple which specifies the starting coordinates of the line. (y1, x1) − It is a tuple which specifies the ending coordinates of the line. canvas − It is the image in which the line will be filled. color (optional) − It determines the colors of the pixels inside the polygon (default is 1). Example In the following example, we are drawing a colored line using the line() function. import numpy as np import matplotlib.pyplot as mtplt import mahotas.polygon as mp # Create a 100×100 image with all zeros canvas = np.zeros((100, 100), dtype=np.uint8) # Draw a line in the canvas mp.line((0, 0), (99, 99), canvas, color=255) # Display the image mtplt.imshow(canvas) mtplt.show() Output Following is the output of the above code −

Mahotas – Zernike Features Zernike features are a set of mathematical values that describe the shape of objects in an image. These value reflects specific details about the shape, such as its roundness, symmetry, or the presence of certain patterns. The Zernike features have some special properties that make them useful for shape analysis. For example, they can describe the shape regardless of its size, meaning that the features remain the same even if the shape is rotated or scaled. This property helps in recognizing objects under different conditions. Zernike features work by breaking down the shape into smaller pieces using mathematical functions called Zernike polynomials. These polynomials act like building blocks, and by combining them, we can recreate and represent the shape of the object. Zernike Features in Mahotas To calculate the Zernike features in mahotas, we can use the mahotas.features.zernike() function. In Mahotas, Zernike features are calculated by performing the following steps − Step1 − Generate a set of Zernike polynomials, which are special mathematical functions representing various shapes and contours. These polynomials act as building blocks for analyzing the object”s shape. Step2 − Compute Zernike moments by projecting the shape of the object onto the Zernike polynomials. These moments capture important shape characteristics. Step3 − Extract the Zernike features from the computed moments, which represent the essential shape information. The mahotas.features.zernike() function The mahotas.features.zernike() function takes three arguments: the image object, the maximum radius for the Zernike polynomials, and the number of features (degree) to compute. The function returns a 1−D array of the Zernike features for the image. The degree of a Zernike moment is a measure of the complexity of the moment. The higher the degree, the more complex the moment. Syntax Following is the basic syntax of the mahotas.features.zernike() function − mahotas.features.zernike(im, degree, radius, cm={center_of_mass(im)}) Where, im − It is the input image on which the Zernike moments will be computed. degree − It specifies the maximum number of the Zernike moments to be calculated. radius − It defines the radius of the circular region, in pixels, over which the Zernike moments will be calculated. The area outside the circle defined by this radius, centered around the center of mass, is ignored. cm (optional) − It specifies the center of mass of the image. By default, the center of mass of the image is used. Example Following is the basic example to calculate the Zernike features for shape recognition of an image − import mahotas as mh # Load images of shapes image1 = mh.imread(”sun.png”, as_grey=True) # Compute Zernike features features = mh.features.zernike(image1, degree=8, radius=10) # Printing the features for shape recognition print(features) Output After executing the above code, we get the output as follows − [0.31830989 0.00534998 0.00281258 0.0057374 0.01057919 0.00429721 0.00178094 0.00918145 0.02209622 0.01597089 0.00729495 0.00831211 0.00364554 0.01171028 0.02789188 0.01186194 0.02081316 0.01146935 0.01319499 0.03367388 0.01580632 0.01314671 0.02947629 0.01304526 0.00600012] Using Custom Center of Mass The center of mass of an image is the point in the image where the mass is evenly distributed. The custom center of mass is a point in an image that is not necessarily the center of mass of the image. This can be useful in cases where you want to use a different center of mass for your calculations. For example, you might want to use the custom center of mass of an object in an image to calculate the Zernike moments of the object. To calculate the Zernike moments of an image using a custom center of mass in mahotas, we need to pass the cm parameter to the mahotas.features.zernike() function. The cm parameter takes a tuple of two numbers, which represent the coordinates of the custom center of mass. Example In here, we are trying to calculate the Zernike features of an image using the custom center of mass − import mahotas import numpy as np # Load the image image = mahotas.imread(”nature.jpeg”, as_grey = True) # Calculate the center of mass of the image center_of_mass = np.array([100, 100]) # Calculate the Zernike features of the image, using the custom center of mass zernike_features = mahotas.features.zernike(image, degree= 5, radius = 5, cm=center_of_mass) # Print the Zernike features print(zernike_features) Output Following is the output of the above code − [3.18309886e-01 3.55572603e-04 3.73132619e-02 5.98944983e-04 3.23622041e-04 1.72293481e-04 9.16757235e-02 3.35704966e-04 7.09426259e-02 1.17847972e-04 2.12625026e-04 3.06537827e-04] Calculating Zernike Features of Multiple Images We can also calculate the Zernike features of multiple images in different formats. Following is the approach to achieve this − Creates an empty list. Use a for loop to iterate over the list of images. Calculate the Zernike features of each image. The features.zernike() function returns a vector of Zernike moments, which is then appended to the list of Zernike features. Example Now, we are trying to calculate the Zernike features of multiple images of different formats altogether − import mahotas import numpy as np # Load the images images = [mahotas.imread(”sun.png”, as_grey = True), mahotas.imread(”nature.jpeg”, as_grey = True), mahotas.imread(”tree.tiff”, as_grey = True)] # Calculate the Zernike features of the images zernike_features = [] for image in images: zernike_features.append(mahotas.features.zernike(image, degree=2, radius = 2)) # Print the Zernike features print(zernike_features) Output Output of the above code is as follows − [array([0.31830989, 0.05692079, 0.10311168, 0.01087613]), array([0.31830989, 0.02542476, 0.11556386, 0.01648607]), array([0.31830989, 0.12487805, 0.07212079, 0.03351757])]

Mahotas – Zernike Moments Like Zernike features, Zernike moments are also a set of mathematical values that describe the shape of objects in an image. They provide specific details about the shape, like how round or symmetrical it is, or if there are any particular patterns present. Zernike moments have some special properties as discussed below − Size Invariance − They can describe the shape regardless of its size. So, even if you have a small or large object, the Zernike moments will still capture its shape accurately. Rotation Invariance − If you rotate the object in the image, the Zernike moments will remain the same. Scaling Invariance − If you resize the object in the image, the Zernike moments will remain the same. Zernike moments break down the shape into smaller pieces using special mathematical functions called Zernike polynomials. These polynomials act like building blocks. By combining different Zernike polynomials, we can recreate and represent the unique features of the object”s shape. Zernike Moments in Mahotas To calculate the Zernike moments in mahotas, we can use the mahotas.features.zernike_moments() function. In Mahotas, Zernike moments are calculated by generating a set of Zernike polynomials, which are special mathematical functions representing various shapes and contours. These polynomials act as building blocks for analyzing the object”s shape. After that, compute Zernike moments by projecting the shape of the object onto the Zernike polynomials. These moments capture important shape characteristics. The mahotas.features.zernike_moments() function The mahotas.features.zernike_moments() function takes two arguments: the image object and the maximum radius for the Zernike polynomials. The function returns a 1−D array of the Zernike moments for the image. Syntax Following is the basic syntax of the mahotas.features.zernike_moments() function − mahotas.features.zernike_moments(im, radius, degree=8, cm={center_of_mass(im)}) Where, im − It is the input image on which the Zernike moments will be computed. radius − It defines the radius of the circular region, in pixels, over which the Zernike moments will be calculated. The area outside the circle defined by this radius, centered around the center of mass, is ignored. degree (optional) − It specifies the maximum number of the Zernike moments to be calculated. By default, the degree value is 8. cm (optional) − It specifies the center of mass of the image. By default, the center of mass of the image is used. Example Following is the basic example to calculate the Zernike moments of an image with a default degree value − import mahotas as mh # Load images of shapes image = mh.imread(”sun.png”, as_grey=True) # Compute Zernike moments moments = mh.features.zernike_moments(image, radius=10) # Compare the moments for shape recognition print(moments) Output After executing the above code, we get the output as follows − [0.31830989 0.00534998 0.00281258 0.0057374 0.01057919 0.00429721 0.00178094 0.00918145 0.02209622 0.01597089 0.00729495 0.00831211 0.00364554 0.01171028 0.02789188 0.01186194 0.02081316 0.01146935 0.01319499 0.03367388 0.01580632 0.01314671 0.02947629 0.01304526 0.00600012] Using Custom Center of Mass The center of mass of an image is the point in the image where the mass is evenly distributed. The custom center of mass is a point in an image that is not necessarily the center of mass of the image. This can be useful in cases where you want to use a different center of mass for your calculations. For example, you might want to use the custom center of mass of an object in an image to calculate the Zernike moments of the object. To calculate the Zernike moments of an image using a custom center of mass in mahotas, we need to pass the cm parameter to the mahotas.features.zernike_moments() function. The cm parameter takes a tuple of two numbers, which represent the coordinates of the custom center of mass. Example In here, we are trying to calculate the Zernike moments of an image using the custom center of mass − import mahotas import numpy as np # Load the image image = mahotas.imread(”nature.jpeg”, as_grey = True) # Calculate the center of mass of the image center_of_mass = np.array([100, 100]) # Calculate the Zernike moments of the image, using the custom center of mass zernike_moments = mahotas.features.zernike_moments(image, radius = 5, cm=center_of_mass) # Print the Zernike moments print(zernike_moments) Output Following is the output of the above code − [3.18309886e-01 3.55572603e-04 3.73132619e-02 5.98944983e-04 3.23622041e-04 1.72293481e-04 9.16757235e-02 3.35704966e-04 7.09426259e-02 1.17847972e-04 2.12625026e-04 3.06537827e-04 1.94379185e-01 1.32093249e-04 8.54616882e-02 1.83274207e-04 1.86728282e-04 3.08004108e-04 4.79437809e-04 1.97726337e-04 3.61630733e-01 5.27467687e-04 8.25534856e-02 7.75593823e-06 1.99419391e-01] Using a Specific Order The order of a Zernike moment is a measure of the complexity of the shape that it can represent. The higher the order, the more complex the shape that the moment can represent. To compute the Zernike moments of an image with a specific order in mahotas, we need to pass the degree parameter to the mahotas.features.zernike_moments() function. Example In the following example, we are trying to compute the Zernike moments of an image with a specified order. import mahotas import numpy as np # Load the image image = mahotas.imread(”nature.jpeg”, as_grey = True) # Calculate the Zernike moments of the image, using the specific order zernike_moments = mahotas.features.zernike_moments(image,1, 4) # Print the Zernike moments print(zernike_moments) Output Output of the above code is as shown below − [0.31830989 0.17086131 0.03146824 0.1549947 0.30067136 0.5376049 0.30532715 0.33032683 0.47908119]

Mahotas – Regional Maxima of Image Regional maxima refer to a point where the intensity value of pixels is the highest within an image. In an image, regions which form the regional maxima are the brightest amongst all other regions. Regional maxima are also known as global maxima. Regional maxima consider the entire image, while local maxima only consider a local neighborhood, to find the pixels with highest intensity. Regional maxima are a subset of local maxima, so all regional maxima are a local maxima but not all local maxima are regional maxima. An image can contain multiple regional maxima, but all regional maxima will be of equal intensity. This happens because only the highest intensity value is considered for regional maxima. Regional Maxima of Image in Mahotas In Mahotas, we can find the regional maxima in an image using the mahotas.regmax() function. Regional maxima are identified through intensity peaks within an image because they represent high intensity regions. The regional maxima points are highlighted as white while other points are colored in black. The mahotas.regmax() function The mahotas.regmax() function extracts regional maxima from an input grayscale image. It outputs an image where the 1”s represent presence of regional maxima points and 0”s represent normal points. The regmax() function uses a morphological reconstruction−based approach to find the regional maxima. In this approach, the intensity value of each local maxima region is compared with its neighbors. If a neighbor is found to have a higher intensity, it becomes the new regional maxima. This process continues until there no region of higher intensity is left, indicating that the regional maxima has been reached. Syntax Following is the basic syntax of the regmax() function in mahotas − mahotas.regmax(f, Bc={3×3 cross}, out={np.empty(f.shape, bool)}) Where, f − It is the input grayscale image. Bc (optional) − It is the structuring element used for connectivity. out(optional) − It is the output array of Boolean data type (defaults to new array of same size as f). Example In the following example, we are getting the regional maxima of an image using mh.regmax() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”tree.tiff”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Getting the regional maxima regional_maxima = mh.regmax(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the regional maxima axes[1].imshow(regional_maxima, cmap=”gray”) axes[1].set_title(”Regional Maxima”) 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 − Using Custom Structuring Element We can also use a custom structuring element to get the regional maxima from an image. A structuring element is a binary array of odd dimensions consisting of ones and zeroes that defines the connectivity pattern of the neighborhood pixels during image labeling. The ones indicate the neighboring pixels that are included in the connectivity analysis, while the zeros represent the neighbors that are excluded or ignored. In mahotas, while extracting regional maxima regions we can use a custom structuring element to define the connectivity of neighboring pixels. We do this by first creating an odd dimension structuring element using the numpy.array() function. Then, we input this custom structuring element to the Bc parameter in the regmax() function. For example, let”s consider the custom structuring element: [[0, 0, 0, 0, 1], [0, 0, 1, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 1, 0, 0, 0]]. This structuring element implies horizontal connectivity, i.e., only the pixels horizontally left or right of another pixel are considered its neighbors. Example In this example, we are using a custom structuring element to get the regional maxima of an image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sun.png”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Setting custom structuring element struct_element = np.array([[0, 0, 0, 0, 1], [0, 0, 1, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 1, 0, 0, 0]]) # Getting the regional maxima regional_maxima = mh.regmax(image, Bc=struct_element) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the regional maxima axes[1].imshow(regional_maxima, cmap=”gray”) axes[1].set_title(”Regional Maxima”) 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 − Using a Specific Region of an Image We can also find the regional maxima of a specific region of an image. A specific region of an image refers to a small part of a larger image. The specific region can be extracted by cropping the original image to remove unnecessary areas. In mahotas, we can find the regional maxima within a portion of an image. First, we crop the original image by specifying the required dimensions of the x and y axis. Then we use the cropped image and get the regional maxima using the regmax() function. For example, let’s say we specify [:800, 70:] as the dimensions of x and y axis respectively. Then, the cropped image will be in range of 0 to 800 pixels for x−axis and 70 to max dimension for y−axis. Example In this example, we are getting the regional maxima within a specific region of an image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”nature.jpeg”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Using specific region of the image image = image[:800, 70:] # Getting the regional maxima regional_maxima = mh.regmax(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the regional maxima axes[1].imshow(regional_maxima, cmap=”gray”) axes[1].set_title(”Regional Maxima”) axes[1].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output After executing the

Mahotas – RGB to LAB Conversion The LAB color space is a color model that approximates human perception of color. It separates color information into three channels − L (Lightness) − The L channel represents the perceived lightness (brightness) of the color. It ranges from 0 (darkest black) to 100 (brightest white). A (Green-Red axis) − Represents the color’s position on the green−red axis. Negative values indicate green, and positive values indicates red. B (Blue-Yellow axis) − Represents the color’s position on the blue-yellow axis. Negative values indicate blue, and positive values indicate yellow. In the process of converting from RGB to LAB, each RGB pixel value is normalized to a range of 0 and 1. Then, various mathematical transformations are applied, like adjusting the brightness, making the colors more accurate to how we perceive them, and converting them to LAB values. These adjustments help us represent colors in a way that matches how humans see them. RGB to LAB Conversion in Mahotas In Mahotas, we can convert an RGB image to an LAB image using the colors.rgb2lab() function. The RGB to LAB conversion in Mahotas involves the following steps − Normalize RGB values − The RGB values of each pixel are first adjusted to a standardized range between 0 and 1. Gamma correction − Gamma correction is applied to the normalized RGB values to adjust the brightness levels of the image. Linearize RGB values − The gamma-corrected RGB values are transformed into a linear RGB color space, ensuring a linear relationship between the input and output values. Convert to XYZ color space − Using a transformation matrix, the linear RGB values are converted to the XYZ color space, which represents the image”s color information. Calculate LAB values − From the XYZ values, LAB values are calculated using specific formulas, accounting for how our eyes perceive colors. The LAB color space separates brightness (L) from color components (A and B). Apply reference white values − The LAB values are adjusted based on reference white values to ensure accurate color representation. LAB representation − The resulting LAB values represent the image”s color information. The L channel represents lightness, while the A and B channels represent color information along two axes. Using the mahotas.colors.rgb2lab() Function The mahotas.colors.rgb2lab() function takes an RGB image as input and returns the LAB color space version of the image. The resulting LAB image retains the structure and content of the original RGB image while providing enhanced color representation. Syntax Following is the basic syntax of the rgb2lab() function in mahotas − mahotas.colors.rgb2lab(rgb, dtype={float}) where, rgb − It is the input image in RGB 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 RGB image to an LAB image using the mh.colors.rgb2lab() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sea.bmp”) # Converting it to LAB lab_image = mh.colors.rgb2lab(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original RGB image axes[0].imshow(image) axes[0].set_title(”RGB 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 − RGB to LAB Conversion of a Random Image We can convert a randomly generated RGB image to LAB color space by − First, defining the desired size of the image specifying its width and height. We also determine the color depth, usually 8−bit, which ranges from 0 to 255. Next, we generate random RGB values for each pixel in the image using the “random.randint()” function from NumPy. Once we have the RGB image, we proceed to convert it to the LAB color space. The resulting image will be in the LAB color space, where the image”s lightness and color information are separated into distinct channels. Example The following example shows conversion of a randomly generated RGB image to an image in LAB color space − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Creating a random RGB image image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) # Converting it to LAB lab_image = mh.colors.rgb2lab(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original RGB image axes[0].imshow(image) axes[0].set_title(”RGB 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 −