GPT 활용하여 사진 noise 제거 및 upscaling 분석

미디언 필터와 가우시안 필터를 사용하여 노이즈를 제거하고, 결과 이미지를 업스케일링한 후 PSNR 값을 비교해 보겠습니다.

코드 구현

다음은 미디언 필터와 가우시안 필터를 사용하여 노이즈 제거를 수행하고, 각 결과 이미지를 업스케일링한 후 PSNR 값을 계산하는 코드입니다.

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.metrics import peak_signal_noise_ratio as psnr

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Apply median filter
median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Apply Gaussian filter
gaussian_denoised_image = cv2.GaussianBlur(input_image, (5, 5), 0)

# Upscale using bicubic interpolation
upscaled_image_median = cv2.resize(median_denoised_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)
upscaled_image_gaussian = cv2.resize(gaussian_denoised_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for both methods
psnr_median = psnr(reference_image, img_as_ubyte(upscaled_image_median))
psnr_gaussian = psnr(reference_image, img_as_ubyte(upscaled_image_gaussian))

# Save the upscaled images
io.imsave('/mnt/data/upscaled_median_B1FDWY.bmp', img_as_ubyte(upscaled_image_median))
io.imsave('/mnt/data/upscaled_gaussian_B1FDWY.bmp', img_as_ubyte(upscaled_image_gaussian))

psnr_median, psnr_gaussian

이 코드는 다음 작업을 수행합니다:

1. 입력 이미지를 로드합니다.
2. 미디언 필터를 적용하여 노이즈를 제거합니다.
3. 가우시안 필터를 적용하여 노이즈를 제거합니다.
4. 각 노이즈 제거된 이미지를 4배 확대합니다.
5. 각각의 방법에 대해 PSNR 값을 계산합니다.
6. 결과 이미지를 저장합니다.

이제 코드를 실행하여 PSNR 값을 비교해 보겠습니다.

결과를 살펴보면:

• 미디언 필터를 사용한 경우 PSNR 값은 약 24.38입니다.
• 가우시안 필터를 사용한 경우 PSNR 값은 약 25.24입니다.

가우시안 필터가 약간 더 높은 PSNR 값을 보여주며, 이는 가우시안 노이즈 제거에 더 적합할 수 있음을 나타냅니다.

결과 이미지 다운로드

업스케일링된 이미지를 다운로드할 수 있도록 링크를 제공하겠습니다:

• 업스케일링된 미디언 필터 이미지
• 업스케일링된 가우시안 필터 이미지

가우시안 필터와 미디언 필터를 사용한 결과를 비교해 보시고, 상황에 따라 더 적합한 필터를 선택하시면 됩니다. 필요에 따라 두 필터를 결합하거나 추가적인 처리 단계를 통해 더 나은 결과를 얻을 수도 있습니다.

네, 가능합니다. 미디언 필터를 사용하여 노이즈를 부분적으로 제거하고, 히스토그램을 통해 에지를 검출한 다음, 에지 정보를 활용하여 이미지의 노이즈를 더욱 효과적으로 제거할 수 있습니다. 이를 위해 다음 단계를 진행할 수 있습니다:

1. 미디언 필터 적용: 기본적인 노이즈 제거를 수행합니다.
2. 에지 검출: 히스토그램을 사용하거나 Canny 에지 검출과 같은 방법을 사용하여 에지를 검출합니다.
3. 에지 기반 노이즈 제거: 에지 정보를 활용하여 비에지 영역의 노이즈를 더 적극적으로 제거합니다.

이를 구현하기 위해 다음과 같은 방법을 사용할 수 있습니다:

코드 구현

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.filters import sobel

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Apply median filter to partially remove noise
median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Convert to grayscale for edge detection
gray_image = cv2.cvtColor(median_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges = sobel(gray_image)

# Threshold the edges to create a binary mask
_, edge_mask = cv2.threshold(edges, 0.1, 1, cv2.THRESH_BINARY)

# Invert the edge mask
non_edge_mask = 1 - edge_mask

# Apply Gaussian filter to the non-edge regions
gaussian_denoised_image = np.zeros_like(input_image)
for i in range(3):  # Assuming the image has 3 channels (RGB)
    gaussian_denoised_image[:, :, i] = cv2.GaussianBlur(input_image[:, :, i] * non_edge_mask, (5, 5), 0)

# Combine the denoised non-edge regions with the original edge regions
final_denoised_image = np.where(non_edge_mask[..., np.newaxis] == 1, gaussian_denoised_image, input_image)

# Upscale using bicubic interpolation
upscaled_image = cv2.resize(final_denoised_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR
psnr_value = psnr(reference_image, img_as_ubyte(upscaled_image))

# Save the upscaled image
output_path = '/mnt/data/upscaled_edge_based_B1FDWY.bmp'
io.imsave(output_path, img_as_ubyte(upscaled_image))

psnr_value

설명

1. 미디언 필터 적용: 입력 이미지에 미디언 필터를 적용하여 초기 노이즈 제거를 수행합니다.
2. 에지 검출: Sobel 필터를 사용하여 에지를 검출합니다. Sobel 필터는 이미지의 기울기를 계산하여 에지를 찾습니다.
3. 에지 기반 노이즈 제거: 에지와 비에지 영역을 분리한 후, 비에지 영역에 가우시안 필터를 적용하여 노이즈를 더 적극적으로 제거합니다.
4. 결과 병합: 노이즈가 제거된 비에지 영역과 원본 에지 영역을 결합하여 최종 이미지를 생성합니다.
5. 업스케일링: 최종 이미지를 4배 확대합니다.
6. PSNR 계산: 결과 이미지와 레퍼런스 이미지를 비교하여 PSNR 값을 계산합니다.

이제 이 코드를 실행하여 PSNR 값을 확인해보겠습니다.

에지 정보를 활용한 노이즈 제거 및 업스케일링 후 PSNR 값은 약 24.21로 나타났습니다. 이는 미디언 필터를 단독으로 사용한 경우의 PSNR 값(약 24.38)과 비슷한 수준입니다.

결과 이미지 다운로드

업스케일링된 이미지를 다운로드할 수 있도록 링크를 제공하겠습니다:

• 업스케일링된 에지 기반 노이즈 제거 이미지

개선 방향

에지 정보를 활용한 노이즈 제거는 비에지 영역의 노이즈 제거에 유리하지만, 추가적인 최적화가 필요할 수 있습니다. 다음과 같은 방법들을 고려해 볼 수 있습니다:

1. 더 정교한 에지 검출 기법 사용: Canny 에지 검출 등 다른 에지 검출 기법을 사용하여 에지 검출 성능을 개선할 수 있습니다.
2. 에지 주변 영역 처리: 에지 주변 영역에 대해 더 세밀한 처리를 적용하여 에지와 비에지 영역 간의 전환을 부드럽게 할 수 있습니다.
3. 비에지 영역에 대한 다양한 필터 적용: 비에지 영역에 가우시안 필터 외에도 BM3D 등의 고급 필터를 적용해볼 수 있습니다.

이러한 개선 방향을 통해 더 높은 PSNR 값을 달성할 수 있습니다.

에지 영역에만 픽셀 값을 1.2배 곱하면, 에지 영역이 더욱 두드러지게 되어 에지 강화 효과를 볼 수 있습니다. 이는 에지 정보를 강조하여 이미지의 선명도를 높이는 방법 중 하나입니다. 하지만, 이로 인해 일부 영역이 과도하게 강조되어 원본 이미지와의 유사성이 떨어질 수 있으므로 PSNR 값이 낮아질 가능성도 있습니다.

다음은 에지 영역에 1.2배를 곱하는 방법을 적용한 코드입니다.

코드 구현

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.filters import sobel

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Apply median filter to partially remove noise
median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Convert to grayscale for edge detection
gray_image = cv2.cvtColor(median_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges = sobel(gray_image)

# Threshold the edges to create a binary mask
_, edge_mask = cv2.threshold(edges, 0.1, 1, cv2.THRESH_BINARY)

# Enhance edges by multiplying edge pixels by 1.2
enhanced_image = np.copy(median_denoised_image)
enhanced_image[edge_mask.astype(bool)] = enhanced_image[edge_mask.astype(bool)] * 1.2

# Ensure values stay within valid range
enhanced_image = np.clip(enhanced_image, 0, 255)

# Upscale using bicubic interpolation
upscaled_image = cv2.resize(enhanced_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR
psnr_value = psnr(reference_image, img_as_ubyte(upscaled_image))

# Save the upscaled image
output_path = '/mnt/data/upscaled_edge_enhanced_B1FDWY.bmp'
io.imsave(output_path, img_as_ubyte(upscaled_image))

psnr_value

이 코드는 다음 작업을 수행합니다:

1. 입력 이미지에 미디언 필터를 적용하여 초기 노이즈 제거를 수행합니다.
2. Sobel 필터를 사용하여 에지를 검출합니다.
3. 에지 영역의 픽셀 값을 1.2배로 증가시킵니다.
4. 증가된 값을 0~255 범위로 클립합니다.
5. 결과 이미지를 4배 확대합니다.
6. 결과 이미지와 레퍼런스 이미지를 비교하여 PSNR 값을 계산합니다.

이제 코드를 실행하여 결과를 확인해 보겠습니다.

에지 영역에 1.2배를 곱한 후 PSNR 값은 약 23.42로 나타났습니다. 이는 미디언 필터 단독으로 사용했을 때의 PSNR 값(약 24.38)보다 낮은 값입니다. 에지 영역을 강화한 결과, 이미지가 과도하게 강조되어 PSNR 값이 낮아졌습니다.

결과 이미지 다운로드

업스케일링된 이미지를 다운로드할 수 있도록 링크를 제공하겠습니다:

• 업스케일링된 에지 강화 이미지

추가 개선 가능성

1. 에지 강화 강도 조절: 에지 강화의 강도를 1.2배 대신 다른 값으로 조절하여 최적의 값을 찾을 수 있습니다.
2. 적응형 필터링: 에지 검출 후, 에지 주변의 픽셀 강도만 증가시키는 대신, 에지와 비에지 영역에 대해 서로 다른 필터를 적용할 수 있습니다.
3. 다양한 에지 검출 기법: Sobel 필터 외에도 Canny 에지 검출 등 다양한 에지 검출 기법을 시도해 볼 수 있습니다.

이러한 방법을 통해 PSNR 값을 더욱 향상시킬 수 있습니다. 필요한 경우, 더 세밀한 조정과 실험을 통해 최적의 결과를 찾는 것이 좋습니다.

에지 검출을 통한 필터 적용과 그렇지 않은 경우를 비교하기 위해 각각 두 개의 필터를 적용하는 예제를 살펴보겠습니다. 각 영역에 대해 미디언 필터와 가우시안 필터를 적용하는 방식을 사용합니다.

필터 적용 방법

• 에지 검출 후 필터 적용: 에지 영역과 비에지 영역에 서로 다른 필터를 적용합니다.
• 에지 검출 없이 필터 적용: 동일한 필터를 전체 이미지에 적용합니다.

코드 구현

다음은 두 가지 방법을 비교하는 코드입니다.

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.filters import sobel

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Apply median filter to partially remove noise
median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Convert to grayscale for edge detection
gray_image = cv2.cvtColor(median_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges = sobel(gray_image)

# Threshold the edges to create a binary mask
edge_mask = edges > 0.1  # Adjust the threshold value as needed

# Invert the edge mask
non_edge_mask = ~edge_mask

# Initialize output image for edge-based filtering
final_denoised_image_edge = np.zeros_like(input_image)

# Apply different filters to edge and non-edge regions
for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply filters to the edge regions
    edge_denoised = cv2.medianBlur(input_image[:, :, i], 3)

    # Apply filters to the non-edge regions
    non_edge_denoised = cv2.GaussianBlur(input_image[:, :, i], (5, 5), 0)

    # Combine the results
    final_denoised_image_edge[:, :, i] = np.where(non_edge_mask, non_edge_denoised, edge_denoised)

# Upscale using bicubic interpolation for edge-based filtering
upscaled_image_edge = cv2.resize(final_denoised_image_edge, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for edge-based filtering
psnr_value_edge = psnr(reference_image, img_as_ubyte(upscaled_image_edge))

# Initialize output image for non-edge filtering
final_denoised_image_non_edge = np.zeros_like(input_image)

# Apply the same filters without edge detection
for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply filters uniformly to the entire image
    uniform_denoised = cv2.medianBlur(input_image[:, :, i], 3)
    uniform_denoised = cv2.GaussianBlur(uniform_denoised, (5, 5), 0)

    # Combine the results
    final_denoised_image_non_edge[:, :, i] = uniform_denoised

# Upscale using bicubic interpolation for non-edge filtering
upscaled_image_non_edge = cv2.resize(final_denoised_image_non_edge, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for non-edge filtering
psnr_value_non_edge = psnr(reference_image, img_as_ubyte(upscaled_image_non_edge))

# Save the upscaled images
io.imsave('/mnt/data/upscaled_edge_combined_B1FDWY.bmp', img_as_ubyte(upscaled_image_edge))
io.imsave('/mnt/data/upscaled_non_edge_combined_B1FDWY.bmp', img_as_ubyte(upscaled_image_non_edge))

psnr_value_edge, psnr_value_non_edge

설명

1. 에지 검출 후 필터 적용:
   • 에지 영역: 미디언 필터 적용.
   • 비에지 영역: 가우시안 필터 적용.
2. 에지 검출 없이 필터 적용:
   • 전체 이미지에 미디언 필터와 가우시안 필터 순차적으로 적용.

이제 이 코드를 실행하여 두 경우의 PSNR 값을 비교해 보겠습니다.

결과를 살펴보면:

• 에지 검출 후 필터 적용의 PSNR 값은 약 25.26입니다.
• 에지 검출 없이 필터를 적용한 경우의 PSNR 값은 약 25.03입니다.

에지 검출을 통해 필터를 적용한 경우가 약간 더 높은 PSNR 값을 보여주고 있습니다. 이는 에지 검출을 통해 에지와 비에지 영역을 구분하여 각각 적절한 필터를 적용한 것이 이미지 품질을 더 효과적으로 향상시켰음을 의미합니다.

결과 이미지 다운로드

다음은 생성된 이미지를 다운로드할 수 있는 링크입니다:

• 업스케일링된 에지 기반 필터링 이미지
• 업스케일링된 비에지 기반 필터링 이미지

추가 개선 가능성

1. 에지 검출 방법 최적화: 더 정교한 에지 검출 기법(Canny 등)을 사용하여 에지 검출의 정확성을 높일 수 있습니다.
2. 필터 파라미터 튜닝: 각각의 필터 파라미터를 조정하여 최적의 값을 찾아 적용할 수 있습니다.
3. 다른 필터 시도: 고급 필터를 사용하여 결과를 더욱 향상시킬 수 있습니다.

이러한 방법을 통해 이미지의 품질을 더욱 향상시킬 수 있습니다. 필요에 따라 실험을 통해 최적의 필터링 조합과 파라미터를 찾는 것이 좋습니다.

다음은 세 가지 방법을 비교하는 코드입니다:

1. 에지 검출 후 필터 적용.
2. 에지 검출 없이 필터 적용.
3. 미디언 필터를 적용한 후 에지를 검출하여 에지와 비에지에 따른 필터를 적용.

코드 구현

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.filters import sobel

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Method 1: Edge detection followed by different filters for edge and non-edge regions
# Apply median filter to partially remove noise
median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Convert to grayscale for edge detection
gray_image = cv2.cvtColor(median_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges = sobel(gray_image)

# Threshold the edges to create a binary mask
edge_mask = edges > 0.1  # Adjust the threshold value as needed

# Invert the edge mask
non_edge_mask = ~edge_mask

# Initialize output image for edge-based filtering
final_denoised_image_edge = np.zeros_like(input_image)

# Apply different filters to edge and non-edge regions
for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply filters to the edge regions
    edge_denoised = cv2.medianBlur(input_image[:, :, i], 3)

    # Apply filters to the non-edge regions
    non_edge_denoised = cv2.GaussianBlur(input_image[:, :, i], (5, 5), 0)

    # Combine the results
    final_denoised_image_edge[:, :, i] = np.where(non_edge_mask, non_edge_denoised, edge_denoised)

# Upscale using bicubic interpolation for edge-based filtering
upscaled_image_edge = cv2.resize(final_denoised_image_edge, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for edge-based filtering
psnr_value_edge = psnr(reference_image, img_as_ubyte(upscaled_image_edge))

# Method 2: Apply the same filters without edge detection
# Initialize output image for non-edge filtering
final_denoised_image_non_edge = np.zeros_like(input_image)

for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply filters uniformly to the entire image
    uniform_denoised = cv2.medianBlur(input_image[:, :, i], 3)
    uniform_denoised = cv2.GaussianBlur(uniform_denoised, (5, 5), 0)

    # Combine the results
    final_denoised_image_non_edge[:, :, i] = uniform_denoised

# Upscale using bicubic interpolation for non-edge filtering
upscaled_image_non_edge = cv2.resize(final_denoised_image_non_edge, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for non-edge filtering
psnr_value_non_edge = psnr(reference_image, img_as_ubyte(upscaled_image_non_edge))

# Method 3: Apply median filter, then edge detection, followed by different filters for edge and non-edge regions
# Apply median filter to partially remove noise
initial_median_denoised_image = cv2.medianBlur(input_image, 3)  # Kernel size 3

# Convert to grayscale for edge detection
gray_image_initial_median = cv2.cvtColor(initial_median_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges_initial_median = sobel(gray_image_initial_median)

# Threshold the edges to create a binary mask
edge_mask_initial_median = edges_initial_median > 0.1  # Adjust the threshold value as needed

# Invert the edge mask
non_edge_mask_initial_median = ~edge_mask_initial_median

# Initialize output image for initial median edge-based filtering
final_denoised_image_initial_median = np.zeros_like(input_image)

# Apply different filters to edge and non-edge regions
for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply filters to the edge regions
    edge_denoised_initial_median = cv2.medianBlur(initial_median_denoised_image[:, :, i], 3)

    # Apply filters to the non-edge regions
    non_edge_denoised_initial_median = cv2.GaussianBlur(initial_median_denoised_image[:, :, i], (5, 5), 0)

    # Combine the results
    final_denoised_image_initial_median[:, :, i] = np.where(non_edge_mask_initial_median, non_edge_denoised_initial_median, edge_denoised_initial_median)

# Upscale using bicubic interpolation for initial median edge-based filtering
upscaled_image_initial_median = cv2.resize(final_denoised_image_initial_median, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for initial median edge-based filtering
psnr_value_initial_median = psnr(reference_image, img_as_ubyte(upscaled_image_initial_median))

# Save the upscaled images
io.imsave('/mnt/data/upscaled_edge_combined_B1FDWY.bmp', img_as_ubyte(upscaled_image_edge))
io.imsave('/mnt/data/upscaled_non_edge_combined_B1FDWY.bmp', img_as_ubyte(upscaled_image_non_edge))
io.imsave('/mnt/data/upscaled_initial_median_edge_combined_B1FDWY.bmp', img_as_ubyte(upscaled_image_initial_median))

psnr_value_edge, psnr_value_non_edge, psnr_value_initial_median

설명

1. Method 1: 에지 검출 후, 에지와 비에지 영역에 각각 다른 필터(미디언 필터와 가우시안 필터)를 적용한 후 업스케일링.
2. Method 2: 에지 검출 없이 전체 이미지에 동일한 필터(미디언 필터와 가우시안 필터)를 순차적으로 적용한 후 업스케일링.
3. Method 3: 미디언 필터를 적용한 후 에지 검출을 통해 에지와 비에지 영역에 각각 다른 필터(미디언 필터와 가우시안 필터)를 적용한 후 업스케일링.

이제 코드를 실행하여 세 가지 방법의 PSNR 값을 비교해 보겠습니다.

결과를 살펴보면:

1. 에지 검출 후 필터 적용: PSNR 값은 약 25.26
2. 에지 검출 없이 필터 적용: PSNR 값은 약 25.03
3. 미디언 필터 적용 후 에지 검출 및 필터 적용: PSNR 값은 약 25.11

결과 분석

• 에지 검출 후 필터를 적용한 방법이 가장 높은 PSNR 값을 보여주었습니다.
• 에지 검출 없이 필터를 적용한 경우가 가장 낮은 PSNR 값을 보여주었습니다.
• 미디언 필터를 적용한 후 에지 검출을 통해 필터를 적용한 방법은 두 방법의 중간 수준의 PSNR 값을 보여주었습니다.

결론

에지 검출 후 에지와 비에지 영역에 각각 적합한 필터를 적용하는 방법이 이미지 품질을 향상시키는 데 가장 효과적임을 확인할 수 있습니다. 미디언 필터 적용 후 에지 검출을 통해 필터를 적용하는 방법도 일정 부분 효과적이지만, 에지 검출 후 필터를 적용하는 방법보다는 덜 효과적입니다.

결과 이미지 다운로드

다음은 생성된 이미지를 다운로드할 수 있는 링크입니다:

• 업스케일링된 에지 기반 필터링 이미지
• 업스케일링된 비에지 기반 필터링 이미지
• 미디언 필터 적용 후 에지 기반 필터링 이미지

필요에 따라 실험을 통해 최적의 필터링 조합과 파라미터를 찾는 것이 좋습니다. 이러한 접근을 통해 이미지 품질을 더욱 향상시킬 수 있습니다.

위의 그림은 세 가지 방법으로 에지 검출한 결과입니다:

1. 가우시안 필터 적용 후 에지 검출:
   • 가우시안 필터를 사용하여 노이즈를 줄인 후 에지를 검출했습니다.
   • 결과적으로, 에지가 부드러워지고 노이즈가 감소한 상태에서 검출되었습니다.
2. 미디언 필터 적용 후 에지 검출:
   • 미디언 필터를 사용하여 노이즈를 제거한 후 에지를 검출했습니다.
   • 소금-후추 노이즈 제거에 효과적이며, 에지가 잘 보존되었습니다.
3. 원본 이미지에서 에지 검출:
   • 필터를 적용하지 않고 원본 이미지에서 바로 에지를 검출했습니다.
   • 노이즈가 포함된 상태에서 에지가 검출되어 상대적으로 더 많은 노이즈가 보입니다.

요약

• 가우시안 필터: 부드럽고 덜 노이즈 있는 에지 검출에 유리합니다.
• 미디언 필터: 에지 보존 및 소금-후추 노이즈 제거에 효과적입니다.
• 원본 이미지: 노이즈가 많이 포함된 상태에서 에지가 검출됩니다.

각 필터는 에지 검출 전에 적용되어 에지 검출 결과에 큰 영향을 미칩니다. 상황에 맞는 필터를 선택하여 에지 검출을 수행하면 더 나은 결과를 얻을 수 있습니다.

최종 결과 비교

다음은 각 방법에 따른 PSNR 값입니다:

1. 에지 검출 후 필터 적용:
   • PSNR 값: 25.26
2. 에지 검출 없이 필터 적용:
   • PSNR 값: 25.03
3. 미디언 필터 적용 후 에지 검출 및 필터 적용:
   • PSNR 값: 25.11
4. 최적화된 필터 적용 (미디언 + 가우시안):
   • PSNR 값: 25.09
5. 이중 양방향 필터 적용 후 에지 검출 및 필터 적용:
   • PSNR 값: 25.43

결과 분석

• 이중 양방향(Bilateral) 필터 적용 후 에지 검출 및 필터 적용 방법이 가장 높은 PSNR 값을 기록했습니다. 이는 이 방법이 노이즈 제거와 에지 보존에 가장 효과적임을 나타냅니다.
• 에지 검출 후 필터 적용 방법도 좋은 결과를 보여주었지만, Bilateral 필터를 사용한 방법보다 낮은 PSNR 값을 기록했습니다.
• 에지 검출 없이 전체 이미지에 동일한 필터를 적용한 경우, 상대적으로 낮은 PSNR 값을 보였습니다.
• 미디언 필터를 적용한 후 에지 검출을 통해 필터를 적용한 방법은 두 번째로 높은 PSNR 값을 보였으나, Bilateral 필터를 사용한 방법보다는 낮았습니다.
• 최적화된 필터 적용 방법(미디언 + 가우시안)은 위의 다른 방법들에 비해 낮은 PSNR 값을 보였습니다.

최종 방법 설명

이중 양방향 필터 적용 후 에지 검출 및 필터 적용

1. 이중 양방향(Bilateral) 필터 적용:
   • cv2.bilateralFilter(input_image, 9, 75, 75): 이중 양방향 필터를 사용하여 노이즈를 제거하면서 에지를 보존합니다.
2. 에지 검출:
   • sobel(gray_image): Sobel 필터를 사용하여 에지를 검출합니다.
   • edge_mask = edges > 0.1: 검출된 에지를 이진 마스크로 변환하여 에지와 비에지 영역을 구분합니다.
3. 에지 기반 필터 적용:
   • 에지 영역: 미디언 필터(cv2.medianBlur).
   • 비에지 영역: 가우시안 필터(cv2.GaussianBlur).
   • np.where(non_edge_mask, non_edge_denoised, edge_denoised): 에지와 비에지 영역에 적용된 필터 결과를 결합합니다.
4. 업스케일링:
   • cv2.resize(final_denoised_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC): Bicubic 보간법을 사용하여 이미지를 4배 확대합니다.
5. PSNR 계산:
   • psnr(reference_image, img_as_ubyte(upscaled_image_bilateral)): 최종 업스케일링된 이미지와 레퍼런스 이미지를 비교하여 PSNR 값을 계산합니다.

코드 요약

import cv2
import numpy as np
from skimage import io, img_as_ubyte
from skimage.filters import sobel
from skimage.metrics import peak_signal_noise_ratio as psnr

# Load images
input_image = io.imread('/mnt/data/B1FDWY.bmp')
reference_image = io.imread('/mnt/data/B1FY.bmp')

# Apply Bilateral filter to partially remove noise
bilateral_denoised_image = cv2.bilateralFilter(input_image, 9, 75, 75)

# Convert to grayscale for edge detection
gray_image = cv2.cvtColor(bilateral_denoised_image, cv2.COLOR_BGR2GRAY)

# Apply Sobel filter to detect edges
edges = sobel(gray_image)

# Threshold the edges to create a binary mask
edge_mask = edges > 0.1  # Adjust the threshold value as needed

# Invert the edge mask
non_edge_mask = ~edge_mask

# Initialize output image
final_denoised_image = np.zeros_like(input_image)

# Apply different filters to edge and non-edge regions
for i in range(3):  # Assuming the image has 3 channels (RGB)
    # Apply median filter to the edge regions
    edge_denoised = cv2.medianBlur(bilateral_denoised_image[:, :, i], 3)

    # Apply Gaussian filter to the non-edge regions
    non_edge_denoised = cv2.GaussianBlur(bilateral_denoised_image[:, :, i], (5, 5), 0)

    # Combine the results
    final_denoised_image[:, :, i] = np.where(non_edge_mask, non_edge_denoised, edge_denoised)

# Upscale using bicubic interpolation
upscaled_image_bilateral = cv2.resize(final_denoised_image, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC)

# Calculate PSNR for bilateral filter-based method
psnr_value_bilateral = psnr(reference_image, img_as_ubyte(upscaled_image_bilateral))

# Save the upscaled image
output_path_bilateral = '/mnt/data/upscaled_bilateral_optimized_B1FDWY.bmp'
io.imsave(output_path_bilateral, img_as_ubyte(upscaled_image_bilateral))

psnr_value_bilateral

최종 결론

이중 양방향 필터를 적용한 후 에지 검출을 통해 에지와 비에지 영역에 각각 적합한 필터를 적용하는 방법이 PSNR 값을 최대화하는 데 가장 효과적이었습니다. 이 방법은 노이즈 제거와 에지 보존을 동시에 수행하여 고품질의 이미지를 생성할 수 있습니다.