Category: mahotas

Mahotas – Template Matching Template matching is a technique that is used to locate a specific image (a template) within a larger image. In simple terms, the goal is to find a place where the smaller image matches the larger image. Template matching involves comparing the template image with different regions of the bigger image. The different properties of the template image such as size, shape, color, and intensity value are matched against the bigger image during comparison. The comparison occurs until a region with the best match is found between the template image and the bigger image. Template Matching in Mahotas In Mahotas, we can use the mahotas.template_match() function to perform template matching. The function compares the template image to every region of the bigger image having the same size as the template image. The function uses the sum of squared differences (SSD) method to perform template matching. The SSD method works in the following way − The first step is to calculate the difference between the pixel values of the template image and the larger image. In the next step, the differences are squared. Finally, the squared differences are summed for all pixels in the larger image. The final SSD values determine the similarity between the template image and the larger image. The smaller the value, the greater is the match between the template image and the larger image. The mahotas.template_match() function The mahotas.template_match() function takes an image and a template image as input. It returns a region from the larger image that best matches the input template image. The best match is the region which has the lowest SSD value. Syntax Following is the basic syntax of the template_match() function in mahotas − mahotas.template_match(f, template, mode=”reflect”, cval=0.0, out=None) Where, f − It is the input image. template − It is the pattern that will be matched against the input image. mode (optional) − It determines how input image is extended when the template is applied near its boundaries (default is ”reflect”). cval (optional) − It is the constant value used in padding when mode is ”constant” (default is 0.0). out (optional) − It defines the array in which the output image is stored (default is None). Example In the following example, we are performing template matching using the mh.template_match() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the images image = mh.imread(”tree.tiff”, as_grey=True) template = mh.imread(”cropped tree.tiff”, as_grey=True) # Applying template matching algorithm template_matching = mh.template_match(image, template) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 3) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the template image axes[1].imshow(template, cmap=”gray”) axes[1].set_title(”Template Image”) axes[1].set_axis_off() # Displaying the matched image axes[2].imshow(template_matching, cmap=”gray”) axes[2].set_title(”Matched Image”) axes[2].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Following is the output of the above code − Matching by Wrapping Boundaries We can wrap the boundaries of an image when performing template matching in Mahotas. Wrapping boundaries refers to folding the image boundaries to the opposite side of the image. Thus, the pixels that are outside the boundary are repeated on the other side of the image. This helps us in handling the pixels that are outside of the image boundaries during template matching. In mahotas, we can wrap the boundaries of an image when performing template matching by specifying the value ”wrap” to the mode parameter of the template_match() function. Example In the example mentioned below, we are performing template matching by wrapping the boundaries of an image. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the images image = mh.imread(”sun.png”, as_grey=True) template = mh.imread(”cropped sun.png”, as_grey=True) # Applying template matching algorithm template_matching = mh.template_match(image, template, mode=”wrap”) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 3) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the template image axes[1].imshow(template, cmap=”gray”) axes[1].set_title(”Template Image”) axes[1].set_axis_off() # Displaying the matched image axes[2].imshow(template_matching, cmap=”gray”) axes[2].set_title(”Matched Image”) axes[2].set_axis_off() # Adjusting spacing between subplots mtplt.tight_layout() # Showing the figures mtplt.show() Output Output of the above code is as follows − Matching by Ignoring Boundaries We can also perform template matching by ignoring the boundaries of an image. The pixels that are beyond the boundaries of an image are excluded when performing template matching by ignoring boundaries. In mahotas, we specify the value ”ignore” to the mode parameter of template_match() function to ignore the boundaries of an image, when performing template matching. Example In here, we are ignoring the boundaries of an image when performing template matching. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the images image = mh.imread(”nature.jpeg”, as_grey=True) template = mh.imread(”cropped nature.jpeg”, as_grey=True) # Applying template matching algorithm template_matching = mh.template_match(image, template, mode=”ignore”) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 3) # Displaying the original image axes[0].imshow(image, cmap=”gray”) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the template image axes[1].imshow(template, cmap=”gray”) axes[1].set_title(”Template Image”) axes[1].set_axis_off() # Displaying the matched image axes[2].imshow(template_matching, cmap=”gray”) axes[2].set_title(”Matched Image”) axes[2].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 – Highlighting Image Maxima Highlighting image maxima refers to displaying the brightest areas of an image. Image maxima, also known as regional maxima, is the area having the highest pixel intensity value amongst all other areas of an image. The image maxima consider the entire image when searching for the brightest areas. An image can have multiple regional maxima, but all of them will have the same level of brightness. This is because only the brightest value is considered as the image maxima. Highlighting Image Maxima in Mahotas In Mahotas, we can use the mahotas.regmax() function to highlight maxima in an image. Image maxima represent high intensity regions; hence they are identified by looking at an image”s intensity peaks. Following is the basic approach used by the function to highlight the image maxima − First, it compares the intensity value of each local maxima region to its neighbors. If a brighter neighbor is found, the function sets it to be the new image maxima. This process continues until all the regions have been compared to the image maxima. The mahotas.regmax() function The mahotas.regmax() function takes a grayscale image as input. It returns an image where the 1s represent the image maxima points, while the 0s represent normal points. 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 highlighting image maxima using the mh.regmax() 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) # 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 highlighted image 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 − Highlighting Maxima by using custom Structuring Element We can also highlight the image maxima by using a custom structuring element. A structuring element is an array consisting of only ones and zeroes. It defines the connectivity pattern of the neighborhood pixels. Pixels with the value 1 are included in connectivity analysis while the pixels with the value 0 are excluded. 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 regmax() function to highlight the image maxima. Example In this example, we are highlighting the image maxima by using a custom structuring element. 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) # Creating a custom structuring element se = np.array([[0, 1, 0],[1, 1, 1],[0, 1, 0]]) # Getting the regional maxima regional_maxima = mh.regmax(image, Bc=se) # 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 highlighted image 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 above code, we get the following output −

Mahotas – Removing Bordered Labelled Removing bordered labeled refers to removing border regions in a labeled image. A labeled image consists of distinct regions that are assigned unique labels. A border region of a labeled image refers to regions present along the edges (boundaries) of an image. Border regions often make it difficult to analyze an image and, in some cases, represent significant noise. Hence, it is important to remove border regions to improve accuracy of image segmentation algorithms and to reduce the overall size of the image. Removing Bordered Labeled in Mahotas In Mahotas, we can use mahotas.labeled.remove_bordering() function to remove border labels from an image. It analyzes the image to check for presence of any border label. If it finds a border label, it determines the value associated with that border label. The value of the border label is then updated to 0, to remove it from the image. Since, value 0 is associated with the background, all the border labels become part of the background. Sometimes, a border label can be far away from the image boundary. If we want to retain these border labels, we need to specify the minimum distance between a border region and the boundary. Any border region that exceeds this distance will be retained by the function. The mahotas.labeled.remove_bordering() function The mahotas.labeled.remove_bordering() function takes a labeled image as an input and returns a labeled image as output without having any border regions. The function remove borders of all sizes, hence the output image consumes significantly less space than the input image. Syntax Following is the basic syntax of the remove_bordering() function in mahotas − mahotas.labeled.remove_bordering(labeled, rsize=1, out={np.empty_like(im)}) Where, labeled − It is the input labeled image. rsize (optional) − It determines the minimum distance that regions must have from the image boundary in order to avoid being removed (default is 1). out (optional) − It specifies where to store the output image (default is an array of same size as labeled). Example In the following example, we are removing border regions from an image by using the mh.labeled.remove_bordering() 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 gaussian filtering image = mh.gaussian_filter(image, 4) # Thresholding the image image = image > image.mean() # Labeling the image labeled, num_objects = mh.label(image) # Removing bordering labels remove_border = mh.labeled.remove_bordering(labeled) # 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 image without borders axes[1].imshow(remove_border) axes[1].set_title(”Border Removed 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 − Removing Regions at a Specific Distance We can also remove bordered regions that are at a specific distance, away from the image boundary. This allows us to remove any region that may have been considered as the bordered region because of its closeness to the image boundary. In mahotas, the rsize parameter determines how far away a border region must be to be retained in the image. We need to set an integer value for this parameter and then pass it to the mh.labeled.remove_bordering() function. For example, let’s say we have set ‘200’ as the value for rsize. Then, only the bordered regions that are at least 200 pixels away from the image boundary will be retained. Example In the example mentioned below, we are removing border regions that are within a specific distance of the image boundary. 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 image = mh.gaussian_filter(image, 4) # Thresholding the image image = image > image.mean() # Labeling the image labeled, num_objects = mh.label(image) # Removing bordering labels remove_border = mh.labeled.remove_bordering(labeled, rsize=200) # 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 image without borders axes[1].imshow(remove_border) axes[1].set_title(”Border Removed 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 − Removing Regions from a Specific part of an Image Another way of removing bordered regions is to remove them from a specific part of an image. Specific parts of an image refer to a small portion of the larger image obtained by cropping the larger image. In mahotas, to remove regions from a specific part of an image, we first identify a region of interest from the original image. Then, we crop the identified part of the image. We then remove the border regions from this part. For example, if we specify the values as [:800, :800], then the region will start from 0 pixel and go up to 800 pixels in both the vertical (y−axis) and horizontal (x−axis) direction. Example In here, we are removing bordered regions from a specific part of an 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) image = image[:800, :800] # Applying gaussian filtering image = mh.gaussian_filter(image, 4) # Thresholding the image image = image > image.mean() # Labeling the image labeled, num_objects = mh.label(image) # Removing bordering labels remove_border = mh.labeled.remove_bordering(labeled) # 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 image without borders axes[1].imshow(remove_border) axes[1].set_title(”Border Removed 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 – Sizes of Labelled Region Sizes of labeled regions refer to the number of pixels present in different regions of a labeled image. A labeled image refers to an image in which a unique label (value) is assigned to distinct regions (a group of pixels) of an image. Usually, an image has two primary regions − the foreground and the background. The size of each region depends on the total number of regions present in the image. If more number of regions are present, then the size of each region will be smaller. Conversely if less number of regions are present, then the size of each region will be bigger. Sizes of Labeled Region in Mahotas In Mahotas, we can use the mahotas.labeled.labeled_size() function to calculate the size of each region in a labeled image. The function works in the following way − It first counts the number of labeled regions in the image. Then, it traverses through all the labeled regions and calculates the total number of pixels present in each region. Once all the regions have been traversed the size of each region is returned by the function. The mahotas.labeled.labeled_size() function The mahotas.labeled.labeled_size() function takes a labeled image as an input and returns a list containing the size of each region in pixels. We can traverse through the list of values to get the size of each region. Syntax Following is the basic syntax of the labeled_size() function in mahotas − mahotas.labeled.labeled_size(labeled) where, labeled − It is the input labeled image. Example In the following example, we are finding the sizes of labeled regions of an image using the mh.labeled.labeled_size() function. import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sea.bmp”) # Labeling the image labeled, num_objects = mh.label(image) # Getting the sizes of labeled regions labeled_size = mh.labeled.labeled_size(labeled) # Printing the sizes of labeled regions for i, labeled_size in enumerate(labeled_size, 1): print(f”Size of Region {i} is = {labeled_size} pixels”) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the original image axes.imshow(image) axes.set_title(”Labeled 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 − Size of Region 1 is = 4263 pixels Size of Region 2 is = 2234457 pixels Following is the image obtained − Sizes in Grayscale Image We can also possible to find the sizes of labeled regions in a grayscale image. Grayscale images refer to the image having only a single−color channel, where each pixel is represented by a single intensity value. The intensity value of a pixel determines the shade of gray. 0 will result in black pixels, 255 will result in white pixels, while any other value will result in pixels having an intermediate shade. In mahotas, to get the sizes of labeled regions of a grayscale image, we first convert an input RGB image to grayscale using the colors.rgb2gray() function. Then, we label the grayscale image and traverse over each region to calculate its size. Example In the example mentioned below, we are finding the size of labeled regions of a grayscale 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 image = mh.colors.rgb2gray(image) # Labeling the image labeled, num_objects = mh.label(image) # Getting the sizes of labeled regions labeled_size = mh.labeled.labeled_size(labeled) # Printing the sizes of labeled regions for i, labeled_size in enumerate(labeled_size, 1): print(f”Size of Region {i} is = {labeled_size} pixels”) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the original image axes.imshow(image, cmap=”gray”) 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 − Size of Region 1 is = 8 pixels Size of Region 2 is = 1079032 pixels The image produced is as follows − Sizes in a Random Boolean Image In addition to grayscale images, we can also get the sizes of labeled regions in a random boolean image. A random Boolean image refers to an image where each pixel has a value of either 1 or 0, where pixels with the value ”1” are referred to as the foreground and pixels with the value ”0” are referred to as the background. In mahotas, we first generate a random Boolean image of a specific dimension using the np.zeros() function. The generated random image initially has all its pixel values set to 0 (consists of only the background region). We then assign integer values to few portions of the image to create distinct regions. Then, we label the image and traverse over each region to get its size in pixels. Example In here, we are getting the size of different labels of a randomly generated 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) # Creating regions image[:2, :2] = 1 image[4:6, 4:6] = 1 image[8:, 8:] = 1 # Labeling the image labeled, num_objects = mh.label(image) # Getting the sizes of labeled regions labeled_size = mh.labeled.labeled_size(labeled) # Printing the sizes of labeled regions for i, labeled_size in enumerate(labeled_size, 1): print(f”Size of Region {i} is = {labeled_size} pixels”) # 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 After executing the above code, we get the following output − Size of Region 1 is = 88 pixels Size of Region 2 is = 4 pixels Size of Region 3 is = 4 pixels Size of Region 4 is = 4 pixels The image obtained is as shown below −

Mahotas – Riddler-Calvard Method The Riddler−Calvard method is a technique used for segmenting an image into foreground and background regions. It groups the pixels of the image to minimize the within−cluster variance when calculating threshold value. The within−cluster variance measures how spread out the pixel values are within a group. A low within−cluster variance indicates that the pixel values are close together, while a high within−cluster variance indicates that the pixel values are spread out. Riddler-Calvard Method in Mahotas In Mahotas, we use the thresholding.rc() function to calculate the threshold value of an image using the Riddler−Calvard technique. The function operates in the following manner − It calculates the mean and variance of the two clusters − the foreground and the background. The mean value is the average value of all the pixels and the variance is a measure of spread of the pixels. Next, it chooses a threshold value that minimizes the within−cluster variance. It then assigns each pixel to the cluster with the lower variance. Steps 2 and 3 continuously repeated until the threshold value is calculated. This value is then used to segment an image into the foreground and the background. The mahotas.thresholding.rc() function The mahotas.thresholding.rc() function takes a grayscale image as input and returns its threshold value calculated using the Riddler−Calvard technique. The pixels of the grayscale image are then compared to the threshold value to create a binary image. Syntax Following is the basic syntax of the rc() function in mahotas − mahotas.thresholding.rc(img, ignore_zeros=False) Where, img − It is the input grayscale image. 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 using the mh.thresholding.rc() function to find the threshold value. 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).astype(np.uint8) # Calculating threshold value using Riddler-Calvard method rc_threshold = mh.thresholding.rc(image) # Creating image from the threshold value final_image = image > rc_threshold # 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 threshold image axes[1].imshow(final_image, cmap=”gray”) axes[1].set_title(”Riddler-Calvard Threshold 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 − Ignoring the Zero Valued Pixels We can also find the Riddler−Calvard threshold value by ignoring the zero valued pixels. The zero valued pixels are pixels that have an intensity value of 0. They usually represent the background pixels of an image, but in some images, they may also represent noise. In grayscale images, zero valued pixels are pixels represented by the color ”black”. To exclude zero valued pixels when calculating the threshold value in mahotas, we can set the ignore_zeros parameter to the boolean value ”True”. Example In the example mentioned below, we are ignoring pixels with value zero when calculating the threshold value using the Riddler−Calvard method. 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).astype(np.uint8) # Calculating threshold value using Riddler-Calvard method rc_threshold = mh.thresholding.rc(image, ignore_zeros=True) # Creating image from the threshold value final_image = image > rc_threshold # 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 threshold image axes[1].imshow(final_image, cmap=”gray”) axes[1].set_title(”Riddler-Calvard Threshold 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 – 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 – Median Filter The median filter is another commonly used technique for noise reduction in an image. It works by calculating the middle (median) value among the neighboring pixels and replaces the original pixel value with that middle value. To understand the median filter, let”s consider the same black−and−white image scenario with small black dots representing noise. Each pixel in the image has a binary value − white (representing the object of interest) or black (representing the background). For each pixel, the median filter takes the pixel values of its neighboring pixels within the window. It then arranges them in ascending order based on their intensity value. After that, it selects the middle value, which is the median, and replaces the original pixel value with that median value. Median Filter in Mahotas To apply the median filter in Mahotas, you can use the median_filter() function. The median filter function in Mahotas uses a structuring element to examine pixels in a neighborhood. The structuring element replaces the value of each pixel by calculating the middle value within its neighborhood. The size of the structuring element determines the extent of smoothing applied by the median filter. A larger neighborhood will result in a stronger smoothing effect, while reducing finer details of the image. On the other hand, a smaller neighborhood will result in less smoothing but maintains more details. The mahotas.median_filter() function The median_filter() function applies the median filter to the input image using the specified neighborhood size. It replaces each pixel value with the median value calculated among its neighbors. The filtered image is stored in the output array. Syntax Following is the basic syntax of the median filter function in mahotas − mahotas.median_filter(img, Bc={square}, mode=”reflect”, cval=0.0, out={np.empty(f.shape, f.dtype}) Where, img − It is the input image. Bc − It is the structuring element that defines the neighbourhood. By default, it is a square of side 3. mode (optional) − It specifies how the function handles the borders of the image. It can take different values such as ”reflect”, ”constant”, ”nearest”, ”mirror” or ”wrap”. By default, it is set to ”reflect”. cval (optional) − The value to be used when mode=”constant”. The default value is 0.0. out (optional) − It specifies the output array where the filtered image will be stored. It must be of the same shape and data type as the input image. Example Following is the basic example to filter the image using the median_filter() function − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image=mh.imread(”tree.tiff”, as_grey = True) structuring_element = mh.disk(12) filtered_image = mh.median_filter(image, structuring_element) # 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 median filtered image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Median Filtered”) axes[1].axis(”off”) mtplt.show() Output After executing the above code, we get the following output − Median Filter with Reflect Mode When we apply the median filter to an image, we need to consider the neighboring pixels around each pixel to calculate the median. However, at the edges of the image, there are pixels that don”t have neighbors on one or more sides. To address this issue, we use the ”reflect” mode. Reflect mode creates a mirror−like effect along the edges of the image. It allows us to virtually extend the image by duplicating its pixels in a mirrored manner. This way, we can provide the median filter with neighboring pixels even at the edges. By reflecting the image values, the medan filter can now consider these mirrored pixels as if they were real neighbors. It calculates the median value using these virtual neighbors, resulting in a more accurate smoothing process at the image edges. Example In here, we are trying to calculate the median filter with the reflect mode − import mahotas as mh import numpy as np import matplotlib.pyplot as mtplt image=mh.imread(”nature.jpeg”, as_grey = True) structuring_element = mh.morph.dilate(mh.disk(12), Bc=mh.disk(12)) filtered_image = mh.median_filter(image, structuring_element, mode=”reflect”) # 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 median filtered image axes[1].imshow(filtered_image, cmap=”gray”) axes[1].set_title(”Median Filtered”) axes[1].axis(”off”) mtplt.show() Output Output of the above code is as follows − By Storing Result in an Output Array We can store the result of the median 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 and data type as the input image to store the resultant filtered image. Finally, we store the resultant filtered image in the output array by passing it as a parameter to the median_filter() function. Example Now, we are trying to apply median 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) # store the result in the output array mh.median_filter(image, Bc=mh.disk(12), 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 median filtered image axes[1].imshow(output, cmap=”gray”) axes[1].set_title(”Median Filtered”) axes[1].axis(”off”) mtplt.show() Output Following is the output of the above code −