Category: mahotas

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 – 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 – 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 −

Mahotas – Sobel Edge Detection Sobel edge detection is an algorithm used to identify the edges in an image. Edges represent boundaries between different regions. It works by calculating the gradient of the image intensity at each pixel. In simpler terms, it measures the change in pixel values to determine regions of high variation, which correspond to edges in an image. Sobel Edge Detection in Mahotas In Mahotas, we can use the mahotas.sobel() function to detect edges in an image. The Sobel function uses two separate filters, one for horizontal changes (Gx) and another for vertical changes (Gy). These filters are applied to the image by them with the pixel values of the image. This calculates the gradients in the horizontal and the vertical directions. Once the gradients in both directions are obtained, the Sobel function combines them to calculate the overall gradient magnitude at each pixel. This is done using the Pythagorean theorem, which calculates the square root of the sum of the squares of the horizontal and vertical gradients. $$\mathrm{M:=:sqrt{(Gx^{2}:+:Gy^{2})}}$$ The resulting gradient magnitude (M) of the image represents the strength of the edges in the original image. Higher values indicate stronger edges, while lower values correspond to smoother regions. The mahotas.sobel() function The mahotas.sobel() function takes a grayscale image as an input and returns a binary image as output, where the edges are computed using Sobel edge detection algorithm. The white pixels in the resultant image represent the edges, while the black pixels represent the other areas. Syntax Following is the basic syntax of the sobel() function in mahotas − mahotas.sobel(img, just_filter=False) Where, img − It is the input grayscale image. just_filter (optional) − It is a flag which specifies whether to threshold the filtered image (default value is false). Example In the following example we are using Sobel edge detection algorithm to detect edges using the mh.sobel() 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 sobel gradient to detect edges sobel = mh.sobel(image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the edges axes[1].imshow(sobel) axes[1].set_title(”Sobel Edge Detection”) 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 Thresholding output Image We can also perform Sobel edge detection algorithm without thresholding the output image. Thresholding refers to conversion of an image into a binary image by classifying the pixels into the foreground or the background. The conversion occurs by comparing the intensity value of the pixels with the threshold (fixed) value. In mahotas, the just_filter parameter in the sobel() function determines whether to threshold the output image. We can set this parameter to ”True” to prevent the thresholding of the output image. If the filter is set to ”False” then the thresholding occurs on the output image. Example In the example mentioned below, we are not thresholding the output image when using the Sobel edge detection algorithm. 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 sobel gradient to detect edges sobel = mh.sobel(image, just_filter=True) # 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 edges axes[1].imshow(sobel) axes[1].set_title(”Sobel Edge Detection”) 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 − On a Threshold Image Sobel edge detection can also be performed on a threshold image. A threshold image is a binary image where the pixels are classified into the foreground or the background. The foreground pixels are white and represented by the value 1, while the background pixels are black and represented by the value 0. In mahotas, we first threshold the input image using any thresholding algorithm. Let us assume . This can be done by using the mh.thresholding.bernsen() function on a grayscale image. Then, we apply the Sobel edge detection algorithm to detect edges of the threshold image. Example In here, we are detecting edges of an image using Sobel edge detection algorithm on a threshold 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) # Applying threshold on the image threshold_image = mh.thresholding.bernsen(image, 17, 19) # Applying sobel gradient to detect edges sobel = mh.sobel(threshold_image) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the edges axes[1].imshow(sobel) axes[1].set_title(”Sobel Edge Detection”) 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 – SURF Dense Points SURF (Speeded Up Robust Features) is an algorithm used to detect and describe points of interest in images. These points are called “dense points” or “keypoints” because they are densely present across the image, unlike sparse points which are only found in specific areas. The SURF algorithm analyzes the entire image at various scales and identifies areas where the intensity changes significantly. These areas are considered as potential keypoints. They are areas of interest that contain unique and distinctive patterns. SURF Dense Points in Mahotas In Mahotas, we use the mahotas.features.surf.dense() function to compute the descriptors at SURF dense points. Descriptors are essentially feature vectors that describe the local characteristics of pixels in an image, such as their intensity gradients and orientations. To generate these descriptors, the function creates a grid of points across the image, with each point separated by a specific distance. At each point in the grid, an “interest point” is determined. These interest points are locations where detailed information about the image is captured. Once the interest points are identified, the dense SURF descriptors are computed. The mahotas.features.surf.dense() function The mahotas.features.surf.dense() function takes a grayscale image as an input and returns an array containing the descriptors. This array typically has a structure where each row corresponds to a different interest point, and the columns represent the values of the descriptor features for that point. Syntax Following is the basic syntax of the surf.dense() function in mahotas − mahotas.features.surf.dense(f, spacing, scale={np.sqrt(spacing)}, is_integral=False, include_interest_point=False) Where, f − It is the input grayscale image. spacing − It determines the distance between the adjacent keypoints. scale (optional) − It specifies the spacing used when computing the descriptors (default is square root of spacing). is_integral (optional) − It is a flag which indicates whether input image is integer or not (default is ”False”). include_interest_point (optional) − It is also a flag that indicates whether to return the interest points with the SURF points (default is ”False”). Example In the following example, we are computing the SURF dense points of an image using the mh.features.surf.dense() function. import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”sun.png”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Getting the SURF dense points surf_dense = surf.dense(image, 120) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf dense points axes[1].imshow(surf_dense) axes[1].set_title(”SURF Dense Point”) 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 − By Adjusting the Scale We can adjust the scale to compute the descriptors of SURF dense points at different spaces. The scale determines the size of the region that is examined around an interest point. Smaller scales are good for capturing local details while larger scales are good for capturing global details. In mahotas, the scale parameter of the surf.dense() function determines the scaling used when computing the descriptors of SURF dense points. We can pass any value to this parameter to check the impact of scaling on SURF dense points. Example In the example mentioned below, we are adjusting the scale to compute descriptors of SURF dense points − import mahotas as mh from mahotas.features import surf 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) # Getting the SURF dense points surf_dense = surf.dense(image, 100, np.sqrt(25)) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf dense points axes[1].imshow(surf_dense) axes[1].set_title(”SURF Dense Point”) 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 − By Including Interest Points We can also include interest points of an image when computing the descriptors of SURF dense points. Interest points are areas where the intensity value of pixels” changes significantly. In mahotas, to include interest points of an image, we can set the include_interest_point parameter to the boolean value ”True”, when computing the descriptors of SURF dense points. Example In here, we are including interest points when computing the descriptors of SURF dense points of an image. import mahotas as mh from mahotas.features import surf import numpy as np import matplotlib.pyplot as mtplt # Loading the image image = mh.imread(”tree.tiff”) # Converting it to grayscale image = mh.colors.rgb2gray(image) # Getting the SURF dense points surf_dense = surf.dense(image, 100, include_interest_point=True) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 2) # Displaying the original image axes[0].imshow(image) axes[0].set_title(”Original Image”) axes[0].set_axis_off() # Displaying the surf dense points axes[1].imshow(surf_dense) axes[1].set_title(”SURF Dense Point”) 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 – Reversing Haar Transform Reversing Haar transform refers to the technique of reconstructing the original image from a Haar transformed image. Before understanding reverse Haar transformation, let us learn about . Haar transformation is a technique that converts an image from pixel intensity values to wavelet coefficients (values that represent different frequencies of an image). In Haar transformation, the image is broken into a set of called Haar wavelets. Reversing Haar transformation converts the wavelet coefficients into pixel intensity values by combining the Haar wavelets in a specific manner (as discussed below). Reversing Haar Transform in Mahotas In Mahotas, we can perform reverse Haar transformation by using the mahotas.ihaar() function. Following is the basic approach to perform the inverse Haar transformation − First, obtain the Haar wavelet coefficients from Haar transformation. Next, multiply each coefficient by a scaling factor and the Haar wavelet. For the Haar wavelet, the scaling factor is usually $mathrm{1/sqrt{2}}$ for the approximation coefficients and 1 for the detail coefficients. Then, sum up these scaled coefficients for both the high frequency (detail) and the low frequency (approximation) coefficients. Finally, combine the reconstructed coefficients and perform normalization if the pixel values are not within the range of 0 to 255. Once these steps are completed, the original image is reconstructed from the Haar transformed image. The mahotas.ihaar() function The mahotas.ihaar() function takes a Haar transformed image as an input and returns the original grayscale image as output. The reverse image is a perfect reconstruction of the original image since Haar transformation is a reversible process. Syntax Following is the basic syntax of the ihaar() function in mahotas − mahotas.ihaar(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 the input image (default is False). Example In the following example, we are using the mh.ihaar() function to reverse the effect of Haar transformation 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) # Applying Haar transformation haar_transform = mh.haar(image) # Reversing Haar transformation reverse_haar = mh.ihaar(haar_transform) # 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 Haar transformed image axes[1].imshow(haar_transform, cmap=”gray”) axes[1].set_title(”Haar Transformed Image”) axes[1].set_axis_off() # Displaying the reversed image axes[2].imshow(reverse_haar, cmap=”gray”) axes[2].set_title(”Reverse Haar 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 − Without Preserving Energy We can also reverse the effects of Haar transformation on an image without preserving its energy. The energy of the image refers to its brightness and it can change when an image is being transformed. In mahotas, we can set the preserve_energy parameter to ”False” in the mh.ihaar() function to prevent the energy preservation. Hence, the brightness of the output image will be different from the original 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 reverse 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) # Reversing Haar transformation reverse_haar = mh.ihaar(haar_transform, preserve_energy=False) # 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 Haar transformed image axes[1].imshow(haar_transform, cmap=”gray”) axes[1].set_title(”Haar Transformed Image”) axes[1].set_axis_off() # Displaying the reversed image axes[2].imshow(reverse_haar, cmap=”gray”) axes[2].set_title(”Reverse Haar 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 − Inline Reverse Haar Transformation Another way we can reverse Haar transformation is by performing inline reverse Haar transformation. Inline refers to applying the transformation on the original image itself without creating a new image, thus saving space during transformation. In mahotas, inline reverse Haar transformation can be achieved by setting the inline parameter to the boolean value ”True” in the mh.ihaar() function. Example Here, we are performing inline reverse Haar transformation on a Haar transformed image. 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) # Reversing Haar transformation mh.ihaar(mh.haar(image), inline=True) # Creating a figure and axes for subplots fig, axes = mtplt.subplots(1, 1) # Displaying the reversed image axes.imshow(image, cmap=”gray”) axes.set_title(”Reverse Haar 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 −