Intensity Transformation Operations on Images

Intensity (n) cường độ

Manipulation (n) thao tác

Spatial (adj) không gian

Domain (n) miền

Những thao tác thường được sử dụng trong việc chuyển đổi cường độ ảnh:

1. Image Negatives (Linear)

2. Log Transformation
3. Power – Law (Gamma) Transformations

4. Piecewise – Linear Transformation Functions

Log Transformation
Spatial Domain Processes (Quá trình chuyển đổi miền không gian)

Phương trình: g ( x , y )=T |f ( x , y)|

trong đó: f (x, y) ảnh đầu vào, g (x, y) ảnh ngõ ra

T: toán tử thực hiện trên f xác định vùng lân cận của điểm ảnh (x, y)

Image Negatives (Phủ định ảnh)

Về mặt toán học, mức cường độ ảnh có giá trị từ 0 đến (L - 1), thông thường L = 256.
Sau đó quá trình phủ định được mô tả: s= L−1−r

trong đó r là mức cường độ ban đầu và s là mức cường độ cuối của một pixel

Log Transformation

Về mặt toán học, log transformation được biểu diễn dưới dạng: s=c . log ( 1+r )

trong đó: s là cường độ ngõ ra

r >= 0 là cường độ ngõ vào của pixel

 255
c là hằng số co giãn (c= với m là giá trị lớn nhất của pixel ảnh). Nó dùng để
log ⁡(1+ m)
đảm bảo rằng giá trị không vượt quá (L - 1 = 255).

Thực tế thì phép biến đổi log transformation sẽ ánh xạ khoảng giá trị thấp của cường độ
ngõ vào thành khoảng giá trị rộng hơn của giá trị ngõ ra.

Ảnh ngõ vào

Code xử lý ảnh:

import cv2
import numpy as np
  
# Open the image.
img = cv2.imread('sample.jpg')
  
# Apply log transform.
c = 255/(np.log(1 + np.max(img)))
log_transformed = c * np.log(1 + img)
  
# Specify the data type.
log_transformed = np.array(log_transformed, dtype = np.uint8)
  
# Save the output.
cv2.imwrite('log_transformed.jpg', log_transformed)
 Ảnh ngõ ra sau khi dùng log transformation
Power – Law (Gamma) Transformation

Bleach (v) tẩy trắng

Về mặt toán học, power – law transformation được biểu diễn dưới dạng: s=c r γ. Hiệu
chỉnh γ rất quan trọng cho việc hiển thị ảnh một cách chính xác trên màn hình, ngoài ra
để ngăn chặn hiện tượng bị tẩy trắng hoặc bị tối đi khi xem trên các loại màn hình khác
nhau với chế các chế độ hiển thị khác nhau. Điều này xảy ra bởi mắt ta cảm nhận ảnh
theo dạng đường cong gamma khi máy ảnh chụp theo dạng tuyến tính.

Code thực hiện:

import cv2
import numpy as np
  
# Open the image.
img = cv2.imread('sample.jpg')
  
# Trying 4 gamma values.
for gamma in [0.1, 0.5, 1.2, 2.2]:
      
    # Apply gamma correction.
    gamma_corrected = np.array(255*(img / 255) ** gamma, dtype = 'uint8')
  
    # Save edited images.
    cv2.imwrite('gamma_transformed'+str(gamma)+'.jpg', gamma_corrected)
Kết quả thực hiện:

Gamma= 0.1

Gamma= 0.5

Gamma = 1.2
Gamma= 2.2

Corresponding (n) tương ứng

Quan sát kết quả thu được khi điều chỉnh gamma, ta thấy rằng khi giá trị gamma > 1
(tương ứng với “nth power” trên đồ thị), cường độ ảnh sẽ giảm và ảnh sẽ trở nên tối hơn.
Mặt khác khi gamma < 1 (tương ứng với “nth root” trên đồ thị) cường độ ảnh sẽ tang và
ảnh sẽ sang hơn.

Piecewise – Linear Transformation Functions (Các hàm chuyển đổi tuyến tính từng
mảnh)

Stretch (adj) kéo giãn

Những hàm chức năng này như tên gọi của chúng, về cơ bản chúng không hoàn toàn
tuyến tính trong tự nhiên. Tuy nhiên chúng thường tuyến tính trong những khoảng x nhất
định. Một trong những hàm chuyển đổi tuyến tính mảnh thông dụng là kéo giãn tương
phản.

Tương phản có thể được định nghĩa như sau:

Contrast = (I_max – I_min) / (I_max + I_min)

Quá trình này giúp mở rộng phạm vi của mức cường độ trong một bức ảnh để nó mở
rộng toàn bộ mức cường độ của máy ảnh/ hiển thị. Đồ thị bên dưới thể hiện đồ thị tương
ứng của phép giãn nở tương phản.

Với (r1,s1), (r2,s2) là hằng số, chức năng của hàm giãn nở sẽ làm giảm mức cường độ
của những pixel tối, và làm tăng cường độ của pixel sáng. Nếu r1 = s1 = 0 và r2 = s2 = L
– 1, hàm chức năng sẽ trở thành đường gạch nối trên đồ thị (không có ảnh hưởng gì).
Hàm tăng một cách đơn điệu để đảm bảo mức cường độ giữa các pixel.

Code hàm giãn nở tương phản:

import cv2
import numpy as np
  
# Function to map each intensity level to output intensity level.
def pixelVal(pix, r1, s1, r2, s2):
    if (0 <= pix and pix <= r1):
        return (s1 / r1)*pix
    elif (r1 < pix and pix <= r2):
        return ((s2 - s1)/(r2 - r1)) * (pix - r1) + s1
    else:
        return ((255 - s2)/(255 - r2)) * (pix - r2) + s2
  
# Open the image.
img = cv2.imread('sample.jpg')
  
# Define parameters.
r1 = 70 s1 = 0 r2 = 140 s2 = 255
  
# Vectorize the function to apply it to each value in the Numpy array.
pixelVal_vec = np.vectorize(pixelVal)
  
# Apply contrast stretching.
contrast_stretched = pixelVal_vec(img, r1, s1, r2, s2)
  
# Save edited image.
cv2.imwrite('contrast_stretch.jpg', contrast_stretched)
Output: