Category: Machine Learning

Scikit Image – Writing Images Writing or Saving images play a crucial role in image processing and computer vision tasks. It is necessary to save images when performing image processing operations such as cropping, resizing, rotating, or applying various filters. Writing an image refers to the process of saving or storing an image as an external file on a disk or in memory. During this process, we usually specify the desired file format (such as JPEG, PNG, TIFF, etc.) and provide the file name or path. In the scikit-image library, the io module offers a function called imsave() specifically for writing and storing images as external files. This function is useful for saving the results of image manipulation operations. The io.imsave() method By using imsave() method, writing the image to an external file with the desired file format, file name, and desired location can be possible. Following is the syntax of this method − skimage.io.imsave(fname, arr, plugin=None, check_contrast=True, **plugin_args) The function takes the following parameters − fname − A string representing the file name or path where the image will be saved. The format of the file is obtained from the extension of file name. arr − The NumPy array of shape (M,N) or (M,N,3) or (M,N,4) containing the image data to be saved. plugin (optional) − A string specifying the plugin to use for saving the image. If the plugin parameter is not provided, the function will automatically try different plugins, starting with imageio, until a suitable one is found. However, if the file name (fname) has a “.tiff” extension, the tifffile plugin will be used by default. check_contrast (optional) − A boolean indicating whether to check the contrast of the image and print warning. The default value is True. **plugin_args (optional) − Additional keyword arguments that are passed to the specified plugin. Example 1 The following example writes an array of random data to an external image file (.jpg) using the imsave() method. import numpy as np from skimage import io # Generate an image with random numbers image_data = np.random.randint(0, 256, size=(256, 256, 3), dtype=np.uint8) # Save the random image as a JPG file io.imsave(”Output/Random_image.jpg”, image_data) print(“The image was saved successfully.”) Output The image was saved successfully. If we navigate to the directory where the image was saved, we will be able to observe the saved “Random_image.jpg” image as shown below − Example 2 The following example writes an image array to a TIFF file (.tiff) using the imsave() method. import numpy as np from skimage import io # Read an image image_data = io.imread(”Images/logo-w.png”) print(“The input image properties:”) print(”Type:”, type(image_data)) print(”Shape:”, image_data.shape) # Save the image as a tiff file io.imsave(”Output/logo.tiff”, image_data) print(“The image was saved successfully…”) Output The input image properties: Type: < class ”numpy.ndarray” > Shape: (225, 225, 4) The image was saved successfully… The following image represents the saved “logo.tiff” file in the directory where the image was saved. Example 3 The following example demonstrates how to save an image to a JPEG file (.jpeg) with low quality using the imsave() method. import numpy as np from skimage import io # Read an image image = io.imread(”Images/Flower1.jpg”) # Save the image as a JPEG file io.imsave(”Output/flower.jpeg”, image, plugin=”pil”, quality=10) # Display the image array properties print(“The input image properties:”) print(”Type:”, type(image)) print(”Shape:”, image.shape) print(“The image was saved successfully…”) Output The input image properties: Type: < class ”numpy.ndarray”> Shape: (4000, 6000, 3) The image was saved successfully… The following images represent details of both input (Flower1.jpg) and saved (flower.jpeg) files in the respective directories. Input file Saved file

Scikit Image – Image Collections In computer vision and image processing, an image collection is a term used to describe a group or set of images that are considered together as a single entity for the purpose of managing and processing multiple images simultaneously. It can be used to store and manage a group of related images, such as a sequence of frames from a video, or a collection of images from various sources. And it simplifies the management and processing of multiple images, making it easier to handle image processing and computer vision tasks. ImageCollection class in skimage In the scikit-image library, the image collection is represented by an ImageCollection class that provides functionality for loading, managing, and manipulating a collection of image files. It allows you to specify a pattern or a list of filenames, load the corresponding images into memory, and access them conveniently. Following is the syntax of this class − class skimage.io.ImageCollection(load_pattern, conserve_memory=True, load_func=None, **load_func_kwargs) Here are the parameters of the class − load_pattern − A string or a list of strings representing the pattern of the file name to load. The filename path can be absolute or relative. conserve_memory (optional) − A boolean value. If set to True, only one image will be kept in memory at a time. If set to False, images will be cached after loading to improve subsequent access speed. load_func (optional) − A callable object that is used to read the image files. By default, it uses the imread function from the scikit-image library. However, you can specify a different function if needed. **load_func_kwargs (optional) − Additional keyword arguments that are passed to the load_func function. It creates an ImageCollection object that allows you to perform various operations on the loaded images, such as iterating over the collection, accessing individual images, and applying operations to the entire collection. Example 1 The following example will demonstrate how to load all the JPEG files in the specified directory. And the resulting ImageCollection object will be stored in the collection variable. from skimage import io # Load all the JPEG files in a directory collection = io.ImageCollection(”Images_/*.jpg”) print(”Type:”,type(collection)) print(”Total loaded JPEG files are”,len(collection)) Output The output shows the type of the collection object and the number of loaded JPEG files. Type: < class ”skimage.io.collection.ImageCollection”> Total loaded JPEG files are 5 Example 2 The following example demonstrate how to access the expanded file names using the files attribute of the ImageCollection object. from skimage import io # Load all the JPEG and PNG files in a directory collection = io.ImageCollection([”Images_/*.jpg”, ”Images_/*.png”]) # Access the expanded file list file_list = collection.files # Print the list of files one by one print(“Files:”) for image in file_list: print(image) Output Files: Images_Blank.png Images_Blank_img.png Images_ColorDots.png Images_Trees.jpg Images_WhiteDots2.jpg Images_WhiteDots4.jpg Images_Zoo.jpg Images_balloons_noisy.png Images_binary image.png Images_tree.jpg You can also use a direct function called io.imread_collection() in the skimage.io module for reading the collection of images. The imread_collection() function The imread_collection() function is used to load a collection of images. and it will return an ImageCollection object, representing the loaded image collection. Here”s the syntax and the parameters of the function − skimage.io.imread_collection(load_pattern, conserve_memory=True, plugin=None, **plugin_args) Following are the parameters of this function − load_pattern − A string or a list of strings representing the pattern of the file name to load. The filename path can be absolute or relative. conserve_memory (optional) − A Boolean value. If set to True, only one image will be kept in memory at a time. If set to False, images will be cached after loading to improve subsequent access speed. plugin_args (optional) − Additional keyword arguments that will be passed to the chosen plugin. The imread_collection() is a convenient wrapper function that internally creates an ImageCollection object for loading a collection of images. Other than using the ImageCollection class directly, It is good to use the imread_collection() function for simple use cases when you need to quickly load images based on a pattern or a list of filenames. Example 1 The following example demonstrates how to load all the tiff files in a specific directory. from skimage import io # Load all the tiff images collection = io.imread_collection(”Images_/*.tiff”, plugin=”tifffile”) print(”Dipaly the tifffile collection:”) print(collection) Output Dipaly the tifffile collection: [”Images_\file_example_TIFF_1MB.tiff”, ”Images_\file_example_TIFF_10MB.tiff”] Example 2 The following example will load a collection of tiff and JPEG images by specifying the list of strings(patterns). from skimage import io # Load a collection of JPEG and tifffile images collection = io.imread_collection([”Image Collection/*.jpg”, ”Image Collection/*.tiff”]) print(”Dipaly the JPEG and tifffile collection:”) print(collection) Output Dipaly the JPEG and tifffile collection: [”Image Collection\Trees.jpg”, ”Image Collection\WhiteDots2.jpg”, ”Image Collection\WhiteDots4.jpg”, ”Image Collection\Zoo.jpg”, ”Image Collection\file_example_TIFF_1MB.tiff”, ”Image Collection\file_example_TIFF_10MB.tiff”, ”Image Collection\tree.jpg”] The Imread_collection_wrapper() function The imread_collection_wrapper is a decorator function, that is used to create a custom version of the imread_collection() function. This wrapper function encapsulates the logic of creating an ImageCollection object with the specified image reading function. Following is the syntax of this Function − skimage.io.imread_collection_wrapper(imread) The imshow_collection() function The imshow_collection() function is used to display a collection of images. It takes an ImageCollection object as input and displays the images contained in the collection. Here, the syntax and the parameters of the function − skimage.io.imshow_collection(ic, plugin=None, **plugin_args) Following are the parameters − ic − An ImageCollection object representing the collection of images to display. plugin (optional) − A string specifying the name of the plugin to use for image display. By default, different plugins are attempted until a suitable one is found. plugin_args − Additional keyword arguments that are passed to the selected plugin for image display. Example The following example demonstrates how to use the imshow_collection() function to display a collection of images. from skimage import io # Load all the JPEG and PNG files in a directory collection = io.ImageCollection(”Images_/*.jpg”) # Access the expanded file list file_list = collection.files # Print the list of files one by one print(“Files:”) for image in file_list: print(image) # Display the collection of images io.imshow_collection(collection) io.show() Output Running the above code gives us the following result −

Scikit Image – Image Processing Image processing, in general, refers to the analysis and manipulation of digital images to enhance their quality, extract useful information, or perform various operations on the image data. It involves applying algorithms and techniques to images in order to alter or extract features, remove noise, or enhance visual appearance. The tasks involved in image processing include − Input/Output and Image Display − This involves handling the input and output of images, as well as displaying them on a screen or other output devices. Basic Image Manipulations − This includes fundamental operations such as cropping, flipping, rotating, and other similar transformations. Image Filtering − This task involves applying filters to images to achieve specific effects. Common filtering operations include denoising (removing noise), sharpening (enhancing the edges and details), and other similar operations. Image Segmentation − It focuses on dividing an image into different regions or objects. It involves labeling each pixel or group of pixels to identify which object they belong to. This is useful for tasks like object detection or boundary extraction. Classification − Image classification involves categorizing or labeling images based on their content. This task uses machine learning or pattern recognition algorithms to automatically assign images to predefined classes or categories. Feature Extraction − Extracting meaningful characteristics or patterns from images, such as edges, textures, or color features. These are the fundamental tasks in image processing and are used extensively in various applications such as computer vision, medical imaging, remote sensing, and many other fields. Image processing in Python Image processing in Python can be performed using various libraries and tools. Following are some popular packages for Python image processing − scikit-image − It is an open-source library that provides a wide range of algorithms for image-processing tasks such as filtering, segmentation, feature extraction, and more. It is designed to be user-friendly and integrates well with other scientific Python libraries. scipy.ndimage − This package, part of the SciPy library, offers various functions for n-dimensional image processing. It includes operations like filtering, interpolation, morphology, and measurements. It is particularly useful for scientific and medical image analysis. OpenCV − Open Source Computer Vision Library, is a highly popular and extensive computer vision library that provides a great collection of image processing and computer vision algorithms. And it is widely used for tasks like object detection, image recognition, and video processing. Pillow − Pillow is a powerful Python imaging library that provides a wide range of image processing functionalities. It supports image reading and writing in various formats, basic manipulations, filters, color space conversions, and more. scipy.ndimage − This package, part of the SciPy library, offers various functions for n-dimensional image processing. It includes operations like filtering, interpolation, morphology, and measurements. It is particularly useful for scientific and medical image analysis. These libraries provide a wide range of tools and algorithms for image processing in Python. Depending on your specific requirements, you can choose the most suitable library or combine multiple libraries to achieve your desired image processing tasks.

Scikit Image – Image datatypes A datatype, in the context of computer programming, refers to the classification or categorization of data based on its properties and the operations that can be performed on it. It determines how the computer interprets, stores, and manipulates the data. Different programming languages have their own set of data types, and each data type has its properties. Common data types include integers, floating-point numbers, characters, strings, booleans, and arrays. Datatypes in Python Scikit Image In scikit-image, images are represented as numpy arrays and support a variety of data types, also known as “dtypes.” The library sets certain ranges for dtype to avoid distorting image intensities. The following are the commonly used dtypes and their corresponding ranges in scikit-image − uint8 − Unsigned 8-bit integer, ranging from 0 to 255. uint16 − Unsigned 16-bit integer, ranging from 0 to 65535. uint32 − Unsigned 32-bit integer, ranging from 0 to 2^32 – 1. float − Floating-point values, typically ranging from -1 to 1 or 0 to 1. int8 − Signed 8-bit integer, ranging from -128 to 127. int16 − Signed 16-bit integer, ranging from -32768 to 32767. int32 − Signed 32-bit integer, ranging from -2^31 to 2^31 – 1. Note that float images should typically be restricted to the range -1 to 1, even though the float dtype itself can exceed this range. On the other hand, integer dtypes can span the entire range of their respective data types. It”s important to stick to these ranges to avoid data loss or incorrect interpretations of pixel intensities. Image data type conversion functions In scikit-image, there are few functions available in skimage.util module to convert image data types and ensure the proper rescaling of image intensities. These functions are designed to handle the conversion and rescaling while preserving the data range of the image. Following are the image data type conversion functions in scikit-image − Img_as_float Img_as_ubyte Img_as_uint Img_as_int These functions provide a convenient way to convert images to the desired data type while maintaining the correct range of intensities. Also, it is important to avoid using the astype function directly on an image, as it can violate assumptions about the dtype range. Instead, you can use the above conversion functions to ensure proper dtype conversion and intensity rescaling. Example 1 The following example demonstrates the difference between using the astype() method and the img_as_float() function for converting the data type of an image array in scikit-image. from skimage import util import numpy as np # Create an image with 8-bit unsigned integers image = np.random.randint(0, 256, size=(1, 4), dtype=np.uint8) print(“Image array:”, image) # Convert the image to float using astype() print(”Converted to float using astype :”,image.astype(float)) # These float values are out of range. # Convert the image to float using img_as_float() print(“Converted to float using img_as_float:”,util.img_as_float(image)) Output Image array: [[173 104 167 25]] Converted to float using astype : [[173. 104. 167. 25.]] Converted to float using img_as_float: [[0.67843137 0.40784314 0.65490196 0.09803922]] By using the img_as_float() function, the image array is correctly converted to the floating point data type with the intensity values properly scaled within the valid range. This ensures proper datatype conversion and intensity rescaling. Example 2 The following example demonstrates the conversion of a floating-point image array to an 8-bit unsigned integer representation using the img_as_ubyte() function from the skimage.util module. from skimage import util import numpy as np # Create an image with floating point numbers image = np.array([0, 0.1, 0, 0.8, 0.3, 1], dtype=float) print(“Image array:”, image) # Convert the image data to 8-bit Unsigned integers print(“Converted to 8-bit uint using img_as_ubyte:”,util.img_as_ubyte(image)) Output Image array: [0. 0.1 0. 0.8 0.3 1.] Converted to 8-bit uint using img_as_ubyte: [0 26 0 204 76 255]

Scikit Image – Reading Images Reading images is a fundamental step when performing operations like cropping, resizing, rotating, or applying filters using image processing tools. The process of reading images involves capturing the pixel values and metadata from an image file and representing them in a suitable data structure, such as a NumPy array or matrix. In the Scikit-image library, the io module provides a function imread() for loading image files into memory as NumPy arrays. Once the image is loaded into memory as a NumPy array, we can get access to a wide range of image processing functions available in Scikit-image to perform tasks like filtering, segmentation, feature extraction, and much more. The imread() method The io.imread() method in Scikit-image is capable of reading images in various formats, including JPEG, PNG, TIFF, BMP, and more. The function internally utilizes different libraries based on the specific image format, such as imageio, PIL, or tifffile. Syntax Following is the syntax and parameters of this method − skimage.io.imread(fname, as_gray=False, plugin=None, **plugin_args) Fname − A string representing the file name or path or a URL of the image. as_gray (optional) − If set to True, it converts color images to grayscale represented as 64-bit floats. Images that are already in grayscale format are not converted. plugin (optional) − A string specifying the plugin to use for reading the image. If the plugin parameter is not provided, the function will automatically try different plugins, starting with imageio, until a suitable one is found. However, if the file name (fname) has a “.tiff” extension, the tifffile plugin will be used by default. **plugin_args (optional) − Additional keyword arguments that are passed to the specified plugin. Return Value The method returns a NumPy array that represents the image. The array contains the pixel values, and its shape corresponds to the dimensions of the image. The color bands or channels of the image are stored in the third dimension of the array. For instance, a grayscale image would have dimensions MxN, an RGB image would have dimensions MxNx3, and an RGBA image would have dimensions MxNx4. Example 1 The following example demonstrates how to load an image using the file name. import skimage from skimage import io # Read an image image = io.imread(”Images/logo.png”) # Display image properties from the image array print(”The following are the properties of the loaded image:”) print(“Image shape:”, image.shape) print(“Image data type:”, image.dtype) print(“Number of color channels:”, image.shape[2]) Input Image Output The following are the properties of the loaded image: Image shape: (225, 225, 4) Image data type: uint8 Number of color channels: 4 Example 2 The following example demonstrates how to load an image using the image URL. import skimage from skimage import io # Read an image image = io.imread(”https://www.tutorialspoint.com/images/logo.png”) # Display image properties from the image array print(”The following are the properties of the loaded image:”) print(“Image shape:”, image.shape) print(“Image data type:”, image.dtype) print(“Number of color channels:”, image.shape[2]) Input Image Output The following are the properties of the loaded image: Image shape: (140, 568, 3) Image data type: uint8 Number of color channels: 3 Example 3 The following example demonstrates how to convert color images to grayscale by using the as_gray parameter of the imread() method. import skimage from skimage import io # Read an image image = io.imread(”https://www.tutorialspoint.com/images/logo.png”, as_gray=True) # Display image properties from the image array print(”The following are the properties of the loaded image:”) print(“Image shape:”, image.shape) print(“Image data type:”, image.dtype) Output The following are the properties of the loaded image: Image shape: (140, 568) Image data type: float64