Category: mahotas

Mahotas – Daubechies Wavelet Daubechies wavelets are perpendicular wavelets, which refer to mathematical functions that can represent an image using waves. Daubechies wavelets have a non−zero value only within a finite interval and are characterized by a maximum number of vanishing moments. Vanishing moments of a wavelet refers to the number of moments that is equal to zero. Moments are integrals (area under a curve) of the wavelet function multiplied by powers of x. A wavelet with more vanishing moments better represents smooth signals, while a wavelet with fewer vanishing moments better represents signals with discontinuities. Daubechies Wavelet in Mahotas In Mahotas, we can apply Daubechies wavelet transformation on an image using the mahotas.daubechies() function. It supports multiple Daubechies wavelets ranging from D2 to D20, where the integer represents the number of vanishing moments in a wavelet. The transformations involve breaking the image into low−frequency (smooth features) and high−frequency coefficients (detailed features). This allows different frequencies of the image to be analyzed independently. The mahotas.daubechies() function The mahotas.daubechies() function takes a grayscale image as input, and returns the wavelet coefficients as a new image. The wavelet coefficients are a tuple of arrays that correspond to the smooth and the detailed features of the image. Syntax Following is the basic syntax of the daubechies() function in mahotas − mahotas.daubechies(f, code, inline=False) Where, f − It is the input image. code − It specifies the type of wavelet to use, can be ”D2”, ”D4”,….., ”D20”. inline (optional) − It specifies whether to return a new image or modify input image (default is False). Example In the following example, we are applying Daubechies wavelet transformation on an image using the mh.daubechies() 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 grayscale image = mh.colors.rgb2gray(image) # Applying Daubechies transformation daubechies_transform = mh.daubechies(image, ”D20”) # 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 Daubechies transformed image axes[1].imshow(daubechies_transform, cmap=”gray”) axes[1].set_title(”Daubechies Transformed 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 − Multiple Daubechies Wavelets Another way of applying Daubechies wavelet transformation is by using multiple Daubechies wavelets. Multiple Daubechies wavelets refers to a set of wavelets having different vanishing moments. In mahotas, to apply multiple Daubechies wavelets we first create a list of different wavelets. Then, we traverse over each wavelet in the list. Finally, we apply the different wavelets to the input image using the mh.daubechies() function. For example, let’s say we have a list of three wavelets − D6, D12, and D18. The three wavelets will have 6, 12, and 18 vanishing moments respectively. Hence, three output images will be generated, each having a different Daubechies wavelet applied to it. Example In the example mentioned below, we are applying multiple Daubechies wavelets transformations on 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) # Creating list of multiple Daubechies wavelets daubechies_wavelets = [”D6”, ”D12”, ”D18”] # Creating subplots to display images for each Daubechies wavelet fig, axes = mtplt.subplots(1, len(daubechies_wavelets) + 1) axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Applying Daubechies transformation for each Daubechies wavelet for i, daubechies in enumerate(daubechies_wavelets): daubechies_transform = mh.daubechies(image, daubechies) axes[i + 1].imshow(daubechies_transform, cmap=”gray”) axes[i + 1].set_title(f”Wavelet={daubechies}”) axes[i + 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 − Daubechies Wavelet on a Random Image We can also perform Daubechies transformation by using Daubechies wavelets on a random image of two dimension. A random two−dimensional image refers to an image having a random intensity value for each pixel. The intensity value can range from 0 (black) to 255 (white). In mahotas, to perform Daubechies wavelet transformation on a random image, we first specify the dimensions (length and width) of the 2−D image. Then, we pass these dimension along with the intensity range (0 to 255) to np.random.randint() function to create the random image. Since the channel value is not specified, the created image is a grayscale image. After that, we apply Daubechies wavelet transformation by specifying the wavelet we want to use. Example In here, we are applying Daubechies wavelet transformation on a randomly generated two−dimensional image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Specifying the dimensions length, width = 1000, 1000 # Creating a random two-dimensional image image = np.random.randint(0, 256, (length, width)) # Applying Daubechies transformation daubechies_transform = mh.daubechies(image, ”D2”) # 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 Daubechies transformed image axes[1].imshow(daubechies_transform, cmap=”gray”) axes[1].set_title(”Daubechies Transformed 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 – Labeled Max Array A labeled max array refers to an array that stores the maximum intensity value of each region in a . To find the maximum intensity value of a region, every pixel in that region is examined. Then, the intensity value of the brightest pixel is selected as the maximum intensity value. In simple terms, labeled max arrays are used to find the brightest regions of an image. For example, let”s assume we have a region which consists of three pixels. The intensity value of the three pixels is 0.5, 0.2, and 0.8 respectively. Then the maximum intensity value of the region will be 0.8. Labeled Max Array in Mahotas In Mahotas, we can use the mahotas.labeled.labeled_max() function to create a labeled max array. The function iteratively searches for the brightest pixel in a region. Then it stores the intensity value of the brightest pixel in an array. The resultant array is a labeled max array, having the maximum intensity value of each region of the image. The mahotas.labeled.labeled_max() function The mahotas.labeled.labeled_max() function takes an image and a labeled image as inputs. It returns an array that contains the maximum intensity value of each labeled region. Syntax Following is the basic syntax of the labeled_max() function in mahotas − mahotas.labeled.labeled_max(array, labeled, minlength=None) Where, array − It is the input image. labeled − It is the labeled image. minlength (optional) − It specifies the minimum number of regions to include in the output array (default is None). Example In the following example, we are finding the labeled max arrays in a labeled image using the labeled_max() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the images image = mh.imread(”sea.bmp”) # Converting it to grayscale image = mh.colors.rgb2gray(image).astype(np.uint8) # Applying thresholding threshold = mh.thresholding.rc(image) threshold_image = image > threshold # Labeling the image label, num_objects = mh.label(threshold_image) # Getting the labeled max array labeled_max = mh.labeled.labeled_max(image, label) # Printing the labeled max array print(”Labeled max array:”, labeled_max) # 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 labeled image axes[1].imshow(label, cmap=”gray”) axes[1].set_title(”Labeled 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 − Labeled max array: [107 111 129 … 141 119 109] The image obtained is as follows − Labeled Max Arrays of a Random Boolean Image We can also find the labeled max arrays of a random Boolean image. A random boolean image refers to an image where each pixel has a value of either 0 or 1. The foreground pixels are represented by ”1”, and the background pixels are represented by ”0”. In mahotas, to find the labeled max arrays of a random Boolean image, we first need to generate a random boolean image of a specific size using the np.zeros() function. This image initially consists of only background pixels. We then assign integer values to a few portions of the image to create distinct regions. Then, we find the labeled max arrays of the image using the labeled_max() function. Example In the example mentioned below, we are finding the labeled max arrays of a random boolean image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Creating a random image image = np.zeros((10, 10), bool) # Assigning values to the regions image[:2, :2] = 1 image[4:6, 4:6] = 1 image[8:, 8:] = 1 # Labeling the image label, num_objects = mh.label(image) # Random sampling random_sample = np.random.random_sample(image.shape) # Getting the labeled max array labeled_max = mh.labeled.labeled_max(random_sample, label) # Printing the labeled max array print(”Labeled max array”) for i, intensity in enumerate(labeled_max): print(”Region”, i, ”:”, intensity) # 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 labeled image axes[1].imshow(label) axes[1].set_title(”Labeled 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 − Labeled max array Region 0 : 0.9950607583625318 Region 1 : 0.8626363785944107 Region 2 : 0.6343883551171169 Region 3 : 0.8162320509314726 We get the following image as output −

Mahotas – Computing Linear Binary Patterns Linear Binary Patterns (LBP) is used to analyze the patterns in an image. It compares the intensity value of a central pixel in the image with its neighboring pixels, and encodes the results into binary patterns (either 0 or 1). Imagine you have a grayscale image, where each pixel represents a shade of gray ranging from black to white. LBP divides the image into small regions. For each region, it looks at the central pixel and compares its brightness with the neighboring pixels. If a neighboring pixel is brighter or equal to the central pixel, it”s assigned a value of 1; otherwise, it”s assigned a value of 0. This process is repeated for all the neighboring pixels, creating a binary pattern. Computing Linear Binary Patterns in Mahotas In Mahotas, we can use the features.lbp() function to compute linear binary patterns in an image. The function compares the brightness of the central pixel with its neighbors and assigns binary values (0 or 1) based on the comparisons. These binary values are then combined to create a binary pattern that describes the texture in each region. By doing this for all regions, a histogram is created to count the occurrence of each pattern in the image. The histogram helps us to understand the distribution of textures in the image. The mahotas.features.lbp() function The mahotas.features.lbp() function takes a grayscale image as an input and returns binary value of each pixel. The binary value is then used to create a histogram of the linear binary patterns. The x−axis of the histogram represents the computed LBP value while the y−axis represents the frequency of the LBP value. Syntax Following is the basic syntax of the lbp() function in mahotas − mahotas.features.lbp(image, radius, points, ignore_zeros=False) Where, image − It is the input grayscale image. radius − It specifies the size of the region considered for comparing pixel intensities. points − It determines the number of neighboring pixels that should be considered when computing LBP for each pixel. ignore_zeros (optional) − It is a flag which specifies whether to ignore zero valued pixels (default is false). Example In the following example, we are computing linear binary patterns using the mh.features.lbp() 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 grayscale image = mh.colors.rgb2gray(image) # Computing linear binary patterns lbp = mh.features.lbp(image, 5, 5) # 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 linear binary patterns axes[1].hist(lbp) axes[1].set_title(”Linear Binary Patterns”) axes[1].set_xlabel(”LBP Value”) axes[1].set_ylabel(”Frequency”) # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Following is the output of the above code − Ignoring the Zero Valued Pixels We can ignore the zero valued pixels when computing linear binary patterns. Zero valued pixels are referred to the pixels having an intensity value of 0. They usually represent the background of an image but may also represent noise. In grayscale images, zero valued pixels are represented by the color ”black”. In mahotas, we can set the ignore_zeros parameter to the boolean value ”True” to exclude zero valued pixels in the mh.features.lbp() function. Example The following example shows computation of linear binary patterns by ignoring the zero valued pixels. 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) # Computing linear binary patterns lbp = mh.features.lbp(image, 20, 10, ignore_zeros=True) # 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 linear binary patterns axes[1].hist(lbp) axes[1].set_title(”Linear Binary Patterns”) axes[1].set_xlabel(”LBP Value”) axes[1].set_ylabel(”Frequency”) # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Output of the above code is as follows − LBP of a Specific Region We can also compute the linear binary patterns of a specific region in the image. Specific regions refer to a portion of an image having any dimension. It can be obtained by cropping the original image. In mahotas, to compute linear binary patterns of a specific region, we first need to find the region of interest from the image. To do this, we specify the starting and ending pixel values for the x and y coordinates respectively. Then we can compute the LBP of this region using the lbp() function. For example, if we specify the values as [300:800], then the region will start from 300 pixels and go up to 800 pixels in the vertical direction (y−axis). Example Here, we are computing the LBP of a specific portion of the specified grayscale image. 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) # Specifying a region of interest image = image[300:800] # Computing linear binary patterns lbp = mh.features.lbp(image, 20, 10) # 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 linear binary patterns axes[1].hist(lbp) axes[1].set_title(”Linear Binary Patterns”) axes[1].set_xlabel(”LBP Value”) axes[1].set_ylabel(”Frequency”) # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output After executing the above code, we get the following output −

Mahotas – Gaussian Filtering Gaussian filtering is a technique used to blur or smoothen an image. It reduces the noise in the image and softens the sharp edges. Imagine your image as a grid of tiny dots, and each dot represents a pixel. Gaussian filtering works by taking each pixel and adjusting its value based on the surrounding pixels. It calculates a weighted average of the pixel values in its neighborhood, placing more emphasis on the closer pixels and less emphasis on the farther ones. By repeating this process for every pixel in the image, the Gaussian filter blurs the image by smoothing out the sharp transitions between different areas and reducing the noise. The size of the filter determines the extent of blurring. A larger filter size means a broader region is considered, resulting in more significant blurring. In simpler terms, Gaussian filtering makes an image look smoother by averaging the nearby pixel values, giving more importance to the closer pixels and less to the ones farther away. This helps to reduce noise and make the image less sharp. Gaussian Filtering in Mahotas In Mahotas, we can perform Gaussian filtering on an image using the mahotas.gaussian_filter() function. This function applies a blurring effect to an image by using a special matrix called a Gaussian kernel. A Gaussian kernel is a special matrix with numbers arranged in a specific way. Each number in the kernel represents a weight. The kernel is placed over each pixel in the image, and the values of the neighboring pixels are multiplied by their corresponding weights in the kernel. The multiplied values are then summed, and assigned as the new value to the central pixel. This process is repeated for every pixel in the image, resulting in a blurred image where the sharp details and noise are reduced. The mahotas.gaussian_filter() function The mahotas.gaussian_filter() function takes a grayscale image as an input and returns a blurred version of the image as output. The amount of blurring is determined by the sigma value. The higher the sigma value, more will be the blurring applied to the output image. Syntax Following is the basic syntax of the gaussian_filter() function in mahotas − mahotas.gaussian_filter(array, sigma, order=0, mode=”reflect”, cval=0., out={np.empty_like(array)}) Where, array − It is the input image. sigma − It determines the standard deviation of the Gaussian kernel. order (optional) − It specifies the order of the Gaussian filter. Its value can be 0, 1, 2, or 3 (default is 0). mode (optional) − It specifies how the border should be handled (default is ”reflect”). cval (optional) − It represents the padding value applied when mode is ”constant”(default is 0). out (optional) − It specifies where to store the output image (default is an array of same size as array). Example In the following example, we are applying Gaussian filtering on an image using the mh.gaussian_filter() 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) # Applying gaussian filtering gauss_filter = mh.gaussian_filter(image, 4) # 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 gaussian filtered image axes[1].imshow(gauss_filter) axes[1].set_title(”Gaussian Filtered 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 − Filtering with Different Order We can perform Gaussian filtering on an image with different order. Order in Gaussian filtering determines the degree of smoothness (blurring) applied on the image. Higher the order value, more will be the smoothing effect applied on the image. Higher orders are useful when dealing with very noisy images. However, higher orders also increase the processing time as the filter is applied multiple times. An order of 0 applies Gaussian filter once, an order of 1, 2, or 3 applies Gaussian filter twice, thrice and four times respectively. In mahotas, to perform gaussian filtering with different order, we pass any value other than 0 as the order parameter to the gaussian_filter() function. Example In the example mentioned below, we are applying Gaussian filtering on an image with different orders. 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) # Applying gaussian filtering gauss_filter = mh.gaussian_filter(image, 3, 1) # 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 gaussian filtered image axes[1].imshow(gauss_filter) axes[1].set_title(”Gaussian Filtered 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 − Filtering with ”Mirror” Mode When applying filters to images, it is important to determine how to handle the borders of the image. The mirror mode is a common approach that handles border pixels by mirroring the image content at the borders. This means that the values beyond the image boundaries are obtained by mirroring the nearest pixels within the image. This is done by mirroring the existing pixels along the edges. This mirroring technique ensures a smooth transition between the actual image and the mirrored image, resulting in better continuity. Example In here, we are applying Gaussian filtering on an image with ”mirror” mode. 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) # Applying gaussian filtering gauss_filter = mh.gaussian_filter(image, 3, 0, mode=”mirror”) # 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 gaussian filtered image axes[1].imshow(gauss_filter) axes[1].set_title(”Gaussian Filtered 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 – Rank Filter A rank filter is a technique used to modify an image by changing the values of its pixels based on their relative ranks (positions). It focuses on the pixel values rather than their actual intensities. For each pixel in the image, the rank filter examines the values of all the pixels within its neighborhood and arranges them in ascending or descending order. It then selects a specific pixel value from the sorted list based on its position or rank. For example, if the rank filter is set to select the median value, it would choose the middle pixel value from the sorted list. If it is set to select the minimum or maximum value, it would choose the first or last value, respectively. Rank Filter in Mahotas We can perform rank filter in mahotas using the mahotas.rank_filter() function. A rank filter in mahotas compares pixel intensity values within a neighborhood and assigns a new value to each pixel based on its rank in the sorted list of intensities. To elaborate, let”s see how a rank filter works in mahotas − Imagine you have a grayscale image made up of many pixels, each with a certain intensity value ranging from black to white. Now, let”s focus on a particular pixel in the image. The rank filter will examine a neighborhood around this pixel. Within this neighborhood, the rank filter will compare the intensity values of all the pixels. It will arrange these pixels based on their intensity values in ascending or descending order, depending on the filter”s configuration. Once the intensity values are ordered, the rank filter will assign a new value to the central pixel based on its rank in the ordered list. This new value is usually the median, minimum, or maximum intensity value within the neighborhood. By repeating this process for each pixel in the image, the rank filter can help in various image enhancement tasks. The mahotas.rank_filter() function The rank_filter() function in mahotas accepts three arguments: the image to be filtered, the structuring element and the size of the neighborhood. The neighborhood is a rectangular region around each pixel, and its size is specified by the number of pixels in each dimension. For example, a neighborhood of size 3×3 would include the eight neighbors of the pixels. The rank_filter() function returns a new image with the same dimensions as the original image. The values in the new image are the ranks of the corresponding pixels in the original image. Syntax Following is the basic syntax of the rank_filter() function in mahotas − mahotas.rank_filter(f, Bc, rank, mode=”reflect”, cval=0.0, out=None) Where, f − It is the input image array to which the rank filter will be applied. Bc − The structuring element that defines the neighborhood around each pixel. rank − It determines the rank of the pixel value to be selected from the sorted list within the neighborhood. The rank can be an integer or a list of integers if multiple ranks are desired. mode (optional) − Determines how the boundaries of the input image are handled. It can take one of the following values: ”ignore”, ”constant”, ”nearest”, ”mirror”, or ”wrap”. The default value is ”reflect”. cval (optional) − The value to be used when mode=”constant”. The default value is 0.0. out (optional) − An array to store the output of the rank filter. If not provided, a new array is created. Example Following is the basic example to filter the image using the rank_filter() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Creating a sample grayscale image image = mh.imread(”nature.jpeg”, as_grey = True) # Applying minimum filter filtered_image = mh.rank_filter(image, mh.disk(6), rank=0) print(filtered_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 rank filtered featured image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Rank Filtered”) axes[1].axis(”off”) mtplt.show() Output After executing the above code, we get the following output − [[193.71 193.71 193.71 … 206.17 206.17 207.17] [193.71 193.71 193.71 … 206.17 206.17 207.17] [193.71 193.71 193.71 … 206.17 206.17 207.17] … [ 74.59 62.44 53.62 … 4.85 4.85 4.85] [ 85.37 74.59 62.44 … 4.85 4.85 4.85] [ 90.05 79.3 73.18 … 4.85 4.85 4.85]] The image displayed is as shown below − Rank Filter on an RGB Image Color images are composed of three color channels: red, green, and blue (RGB). By applying rank filtering to each channel separately, we can enhance the features specific to each color channel. To apply rank filter on an RGB image in mahotas, we first extract the channels from the RGB image by specifying the channel value. The channel values are accessed using the indices 0, 1, and 2 for red, green, and blue channels, respectively. Then, we apply the rank filter on each channel and stack them together to reconstruct the final RGB image. Example In here, we are applying a median filter with different neighborhood sizes on each channel separately of an RGB image − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image = mh.imread(”nature.jpeg”) # Applying a median filter with different neighborhood sizes on each channel separately filtered_image = np.stack([mh.rank_filter(image[:, :, 0], mh.disk(2), rank=4), mh.rank_filter(image[:, :, 1], mh.disk(1), rank=4), mh.rank_filter(image[:, :, 2], mh.disk(3), rank=4)], axis=2) # 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 rank filtered featured image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Rank Filtered”) axes[1].axis(”off”) mtplt.show() Output Following is the output of the above code − Using ”Wrap” Mode When performing rank filtering on an image, the pixels at the edges or boundaries often lack sufficient neighboring pixels to calculate the rank accurately. To address this issue, the ”wrap” mode in Mahotas wraps the image values around to the opposite side. This means that the pixel values from one end of the image are considered as the neighbors for the pixels at the opposite end. This creates a seamless transition from one side to the

Mahotas – Haar Transform Haar transform is a technique used to convert an image from pixel intensity values to wavelet coefficients. Wavelet coefficients are numerical values representing the contribution of different frequencies to an image. In Haar transform, an image is broken into a set of orthonormal basis functions called Haar wavelets. An orthonormal basis function refers to a mathematical function that satisfies two important properties : it is perpendicular (or orthogonal) to other basis functions, and its coefficients have a length of 1. The basis functions are generated from a single wavelet by scaling and shifting. Scaling refers to changing the duration of the wavelet function, while shifting involves moving the wavelet function along the x−axis. Haar Transform in Mahotas In Mahotas, we can perform Haar transformation by using the mahotas.haar() function on an image. Following is the basic approach to perform Haar transformation on an image − Image Partitioning − The first step involves dividing the input image into nonoverlapping blocks of equal size. Averaging and Differencing − Next, the low and high frequency coefficients are computed within each block. The low frequency coefficient represents the smooth, global features of the image and is calculated as the average of pixel intensities. The high frequency coefficient represents the sharp, local features of the image and is calculated by finding differences between neighboring pixels. Subsampling − The resultant low and high frequency coefficients are then down sampled (degraded) by discarding alternate values in each row and column. Steps 2 and 3 are repeated until are repeated until the entire image has been transformed. The mahotas.haar() function The mahotas.haar() function takes a grayscale image as input and returns the wavelet coefficients as an image. The wavelet coefficients are a tuple of arrays. The first array contains the low−frequency coefficients, and the second array contains the high−frequency coefficients. Syntax Following is the basic syntax of the haar() function in mahotas − mahotas.haar(f, preserve_energy=True, inline=False) Where, f − It is the input image. preserve_energy (optional) − It specifies whether to preserve the energy of the output image (default is True). inline (optional) − It specifies whether to return a new image or modify input image (default is False). Example In the following example, we are applying Haar transformation on an image using the mh.haar() 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 grayscale image = mh.colors.rgb2gray(image) # Applying Haar transformation haar_transform = mh.haar(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 Haar transformed image axes[1].imshow(haar_transform, cmap=”gray”) axes[1].set_title(”Haar Transformed 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 − Without Preserving Energy We can also perform Haar transformation on an image without preserving energy. The energy of the image refers to its brightness, and it can change when an image is being transformed from one domain to another. In mahotas, the preserve_energy parameter of the mh.haar() function determines whether to preserve the energy of the output image. If we don’t want to preserve the energy, we can set this parameter to False. Hence, the brightness of the output image will be different from the brightness of the input image. If this parameter is set to True, then the output image and the input image will have the same brightness. Example In the example mentioned below, we are performing Haar transformation on an image without preserving its energy. 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) # Applying Haar transformation haar_transform = mh.haar(image, preserve_energy=False) # 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 Haar transformed image axes[1].imshow(haar_transform, cmap=”gray”) axes[1].set_title(”Haar Transformed 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 − Inline Haar Transformation We can also perform inline Haar transformation on an input image. Inline refers to applying transformation on the original image itself without creating a new image. This allows us to save space when applying transformations on an image. In mahotas, inline Haar transformation can be achieved by setting the inline parameter to boolean value True in the mh.haar() function. This way, a new image need not be created to store the output. Example In here, we are performing inline Haar transformation on an input 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) # Applying Haar transformation mh.haar(image, preserve_energy=False, inline=True) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the transformed image axes.imshow(image, cmap=”gray”) axes.set_title(”Haar Transformed Image”) axes.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 − Note − Since the input image is getting overridden during transformation, the output screen will only contain a single image as seen above.

Mahotas – Speeded-Up Robust Features Speeded−Up Robust Features (SURF) is an algorithm that is used to detect distinctive features (keypoints) in images. SURF identifies keypoints by analyzing the intensity changes in an image at multiple scales. It assigns orientations to these points and generates descriptors that capture their unique characteristics. The descriptors are computed in a pattern within local regions around the keypoints. These descriptors can then be used for various applications. SURF uses two primary techniques − surf dense and surf integral. Both techniques have been discussed in detail in the upcoming chapters. SURF Surf SURF surf is a technique that combines the detection and description of keypoints of an image. It generates descriptors that encode the properties of these keypoints. The function takes an image as input and returns a set of SURF descriptors. Syntax Following is the basic syntax of the surf.surf() function in mahotas − mahotas.features.surf.surf(f, nr_octaves=4, nr_scales=6, initial_step_size=1, threshold=0.1, max_points=1024, descriptor_only=False) Where, f − It is the input image. nr_octaves (optional) − It defines the number of octaves to be used in the SURF algorithm. An octave represents an image at different level of resolution (default is 4). nr_scales (optional) − It determines the number of scales per octave. The scales are used to detect features at different levels of detail (default is 6). initial_step_size (optional) − It determines the initial step size between consecutive scales. A smaller step size allows for detection of detailed features (default is 1). threshold (optional) − It is the threshold value that is used to filter out weak SURF features (default is 0.1). max_points (optional) − It defines the maximum number of SURF points that will be returned (default is 1024). descriptor_only (optional) − It is a flag that determines whether to return only the descriptors or the descriptors and keypoints. When set to True, only the descriptors of the detected features will be returned. If set to False, both the keypoints and descriptors will be returned (default is False). We can see the surf image below − SURF Dense SURF Dense is a technique used by the SURF algorithm. The keypoints are densely sampled across an image in SURF dense. In other words, instead of searching for specific interesting points, SURF Dense calculates the descriptors for a grid of pixels in the image. This helps to capture information about the entire image. In the following image, we can see SURF dense image − SURF Integral The SURF integral technique enhances the SURF algorithm”s calculation efficiency by utilizing integral images. Integral images pre−calculate the cumulative sum of pixel intensities up to specific areas of an image. This pre−calculation eliminates redundant calculations, enabling faster and more efficient feature detection and description. As a result, the SURF algorithm becomes well−suited for real−time applications and handling large−scale datasets. The following is the image for SURF integral − Example In the following example, we are performing different SURF functions on an image as discussed above − import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt image = mh.imread(”tree.tiff”, as_grey=True) # SURF dense surf_dense = surf.dense(image, 100) mtplt.imshow(surf_dense) mtplt.title(”SURF Dense Image”) mtplt.axis(”off”) mtplt.show() # SURF integral surf_integral = surf.integral(image) mtplt.imshow(surf_integral) mtplt.title(”SURF Integral Image”) mtplt.axis(”off”) mtplt.show() # SURF surf surf_surf = surf.surf(image) mtplt.imshow(surf_surf) mtplt.title(”SURF Surf Image”) mtplt.axis(”off”) mtplt.show() Output The output obtained is as shown below − SURF Dense Image: SURF Integral Image: SURF Surf Image: We will discuss about the SURF Dense and the SURF Integral techniques in detail in the further chapters.

Mahotas – Mean Value of Image Mean value of an image refers to the average brightness of all the pixels of an image. Brightness is a property of an image that determines how light or dark an image appears to the human eye. It is determined by the pixel intensity value; higher pixel intensity values represent brighter areas, while lower pixel intensity values represent darker areas. The mean value of an image is widely used in image segmentation, which involves dividing an image into distinct regions. It can also be used in image thresholding which refers to converting an image into binary image consisting of foreground and background pixels. Mean Value of Image in Mahotas Mahotas does not have a built-in function to find the mean of value of an image. However, we can find the mean value of an image by using mahotas and numpy library together. We can use the mean() function in the numpy library to find the mean pixel intensity value of an image. The mean() function works by iteratively going over each pixel and summing its intensity value. Once all the pixels have been traversed, it divides the sum by the total number of pixels. The mean pixel intensity value of an image can be calculated using the following formula − Mean = Sum of all pixel values / Total number of pixels For example, let”s assume that an image is composed of 2 pixels each with an intensity value of 5. Then the mean can be calculated as follows − Mean = 10 / 2 Mean = 5 The numpy.mean() function The numpy.mean() function takes an image as input and returns the average brightness of all its pixels as a decimal number. The mean function works on any type of input image such as RGB, grayscale or labeled. Syntax Following is the basic syntax of the mean() function in numpy − numpy.mean(image) Where, image − It is the input image. Example In the following example, we are finding the average pixel intensity value of an image using the np.mean() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sun.png”) # Finding the mean value mean_value = np.mean(image) # Printing the mean value print(”Mean value of the image is =”, mean_value) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the original image axes.imshow(image) axes.set_title(”Original Image”) axes.set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Following is the output of the above code − Mean value of the image is = 105.32921300415184 The image obtained is as shown below − Mean Value of each Channel We can also find the mean value of each channel of an RGB image in Mahotas. RGB images to refer to images having three−color channels − Red, Green, and Blue. Each pixel in an RGB image has three intensity values, one for each color channel. The channel value of red is 0, green is 1 and blue is 2. These values can be used to separate an RGB image into its individual color components. In mahotas, to find the mean pixel intensity value of each channel of an RGB image, we first separate the RGB image into separate channels. This is achieved by specifying the channel value. Once the channels are separated, we can find their mean value individually. Example In the example mentioned below, we are finding the mean pixel intensity value of each channel of an RGB image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”nature.jpeg”) # Getting the red channel. red_channel = image[:, :, 0] # Getting the green channel. green_channel = image[:, :, 1] # Getting the blue channel. blue_channel = image[:, :, 2] # Finding the mean value of each channel mean_red = np.mean(red_channel) mean_green = np.mean(green_channel) mean_blue = np.mean(blue_channel) # Printing the mean value of each channel print(”Mean value of the Red channel is =”, mean_red) print(”Mean value of the Green channel is =”, mean_green) print(”Mean value of the Blue channel is =”, mean_blue) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the original image axes.imshow(image) axes.set_title(”Original Image”) axes.set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Output of the above code is as follows − Mean value of the Red channel is = 135.4501688464837 Mean value of the Green channel is = 139.46532482847343 Mean value of the Blue channel is = 109.7802007397084 The image produced is as follows − Mean Value of Grayscale Image We can find the mean value of a grayscale image as well. Grayscale images refer to the image having only a single−color channel. Each pixel of a grayscale image is represented by a single intensity value. The intensity value of a grayscale image can range from 0 (black) to 255 (white). Any value between 0 and 255 will produce a shade of gray. Lower values will produce darker shades while higher values will produce lighter shades. In mahotas, we first convert an input RGB image to grayscale using the mh.colors.rgb2gray() function. Then, we find its mean pixel intensity value using the mean() function. Example In this example, we are finding the mean pixel intensity value of a grayscale image. 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 grayscale_image = mh.colors.rgb2gray(image) # Finding the mean value of the grayscale image mean_value = np.mean(grayscale_image) # Printing the mean value of the image print(”Mean value of the grayscale image is =”, mean_value) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the grayscale image axes.imshow(grayscale_image, cmap=”gray”) axes.set_title(”Grayscale Image”) axes.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 − Mean value of the grayscale

Mahotas – Local Binary Patterns Local Binary Patterns (LBP) is a method that generates a binary pattern. It compares the intensity values of a central pixel with its neighbors. Each pixel in the neighborhood is assigned a value of 1 if it is greater than or equal to the center pixel”s intensity, and 0 otherwise. The binary patterns are used to compute statistical measures or histogram representations that capture the texture information in the image. The resulting descriptors can be utilized in various applications, such as texture classification, object recognition, and image retrieval. Local Binary Patterns uses a technique known as Linear Binary Patterns. The Linear Binary Pattern considers a linear (straight) neighborhood for creating a binary pattern. Let us discuss briefly about linear binary patterns below. Linear Binary Patterns Linear Binary Patterns are used to describe the texture of an image. It works by comparing the intensity values of pixels in a neighborhood around a central pixel and encoding the result as a binary number. In simpler terms, LBP looks at the pattern formed by the pixel values around a particular pixel and represents that pattern with a series of 0s and 1s. Here, we look at linear binary patterns of an image − Example In the example mentioned below, we are trying to perform the above discussed function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image = mh.imread(”nature.jpeg”, as_grey=True) # Linear Binary Patterns lbp = mh.features.lbp(image, 5, 5) mtplt.hist(lbp) mtplt.title(”Linear Binary Patterns”) mtplt.xlabel(”LBP Value”) mtplt.ylabel(”Frequency”) mtplt.show() Output After executing the above code, we obtain the following output − We will discuss about the linear binary patterns in detail in the further chapter.

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 −