Classical Computer Vision: Value Domain

    Let's now focus on the Value Domain of image processing.

    In this domain, we can just apply filter and simplification to images, since we are dealing with each pixel individually, in an out of context fashion.

    Let's explore some of the techniques available in this domain

Image Windowing

    One of the most interesting techniques we have in the value domain is image windowing. Let's take medical radiodensity images as an example that the use of this resource is imperative.

    Since we are unable to recognize 4000 shades of gray right on the spot, we can use this technique to focus on a single property of the image we are analyzing. Therefore, we  limit the number of Hounsfield units (which is the gray scale that describes radiodensity images) that a human or a computer is processing. 

    In practical terms, is a change of perspective. Sometimes we are analyzing the soft tissue, which has a density greater than water, but lower than bones. Sometimes we are focusing on fat, which is less dense than water, but more dense than lungs. 

    A muscle ranges from +35 to +55 in Hounsfield scale, while the lungs range from -700 to -600. So, if we're analyzing the muscles around the lungs, we could safely ignore any gray shades that are way below +35 or way above +55. For example, we could chose a scale from -10 to +100, completely ignoring the lungs and focusing on muscles, lymph nodes (+10 to +20), some fluids... etc etc. 

    The way we do windowing is simple:

    First we define a window center, which is the center value of our new gray scale. Next, we define the width of that scale.

    Now, we have a scale_min and scale_max values:

    scale_min = window_center - window_width // 2

    scale_max = window_center + window_width // 2

    Next, we change the values for every pixel that is out of that scale to either min or max. If the value is lower than min, define it to min. If it's greater than max, redefine it to max.

import pydicom

import numpy as np

import matplotlib.pyplot as plt

from skimage.color import rgb2gray

file_path = "/workspaces/IA/src/medical/data/CT2/23060"

output_path = "./"

medical_image = pydicom.read_file(file_path)

def transform_to_hu(medical_image, image):

intercept = medical_image.RescaleIntercept

slope = medical_image.RescaleSlope

hu_image = image * slope + intercept

return hu_image

def window_image(image, window_center, window_width):

img_min = window_center - window_width // 2

img_max = window_center + window_width // 2

window_image = image.copy()

window_image[window_image < img_min] = img_min

window_image[window_image > img_max] = img_max

return window_image

original_img = medical_image.pixel_array

original_img = transform_to_hu(medical_image, original_img)

print(original_img.shape)

print(original_img.min())

print(original_img.max())

fig, ax = plt.subplots(ncols=3, nrows=1, sharex=True, sharey=True, figsize=(16, 10))

print (ax.shape)

ax[0].imshow(original_img, cmap=plt.cm.gray)

ax[0].set_title('Original')

ax[1].imshow(window_image(original_img, 40, 80), cmap=plt.cm.gray)

ax[1].set_title('Brain (40 - 80)')

ax[2].imshow(window_image(original_img, 400, 1000), cmap=plt.cm.gray)

ax[2].set_title('Bone (400 - 1000')

plt.tight_layout()

plt.show()

Image Scale

    Image scaling is the technique in which we change the size of the image matrix of floats. We could be doing an upscaling (increasing the size of the image) or a downscaling (decreasing the size of the image).

    When we are increasing the image, we are essentially either duplicating the pixels, for example, when duplicating the X, Y size, for each pixel I read it four time (twice in X and twice in Y), or we are resampling the image.

    Resample the image means using an algorithm to infer the new pixels, avoiding a simple "copy" of them.

    When decreasing the image, we need to deal with the aliasing problem. According to the Nyquist sample theorem, every time we sample a signal, we need a minimal sample rate to avoid information lost. 

import matplotlib.pyplot as plt

from skimage import data, color

from skimage.transform import rescale, resize, downscale_local_mean

image = color.rgb2gray(data.astronaut())

image_rescaled = rescale(image, 0.25, anti_aliasing=False)

image_resized = resize(image, (image.shape[0] // 4, image.shape[1] // 4),

anti_aliasing=True)

image_downscaled = downscale_local_mean(image, (4, 3))

fig, axes = plt.subplots(nrows=2, ncols=2)

ax = axes.ravel()

ax[0].imshow(image, cmap='gray')

ax[0].set_title("Original image")

ax[1].imshow(image_rescaled, cmap='gray')

ax[1].set_title("Rescaled image (aliasing)")

ax[2].imshow(image_resized, cmap='gray')

ax[2].set_title("Resized image (no aliasing)")

ax[3].imshow(image_downscaled, cmap='gray')

ax[3].set_title("Downscaled image (no aliasing)")

ax[0].set_xlim(0, 512)

ax[0].set_ylim(512, 0)

plt.tight_layout()

plt.show()