Hướng dẫn bilinear interpolation python image resize - thay đổi kích thước hình ảnh python nội suy song tuyến tính

Question

Tôi đang cố gắng thực hiện kích thước kích thước hình ảnh bằng cách sử dụng phép nội suy song tuyến. Những gì tôi có cho đến nay là một chức năng cho chính nội suy có vẻ hoạt động tốt, nhưng chức năng thay đổi kích thước dường như chỉ hoạt động đúng trên các góc:

Nội dung chính Show

Phép nội suy tuyến tính
Nội suy song phương
Backward Pass của thay đổi kích thước song song
Nội suy nào là tốt nhất để thay đổi kích thước hình ảnh?
Nội suy song song trong xử lý hình ảnh là gì?
Thay đổi kích thước song song là gì?
Thay đổi kích thước nội suy là gì?

def bilinear_interpolation(image, y, x):
height = len(image)
width = len(image[0])

x1 = min(math.floor(x), width - 1)
y1 = min(math.floor(y), height - 1)
x2 = min(math.ceil(x), width - 1)
y2 = min(math.ceil(y), height - 1)

a = image[y1][x1]
b = image[y2][x1]
c = image[y1][x2]
d = image[y2][x2]

new_pixel = a * (1 - x) * (1 - y)
new_pixel += b * y * (1 - x)
new_pixel += c * x * (1 - y)
new_pixel += d * x * y
return round(new_pixel)
def resize(image, new_height, new_width):

new_image = [[0 for _ in range(new_width)] for _ in range(new_height)]

for y in range(new_height):
    for x in range(new_width):
        x_ = (x / (new_width - 1)) * len(image[0])
        y_ = (y / (new_height - 1)) * len(image)

        new_image[y][x] = bilinear_interpolation(image, y_, x_)

return new_image

Vì vậy, đối với ma trận:

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

tôi đã nhận

[[1, 4], [9, 12], [13, 16]]

thay vì

[[1, 4], [7, 10], [13, 16]]

Cảm ơn trước.

Thay đổi kích thước một hình ảnh (hoặc bản đồ tính năng) thành một kích thước không gian mong muốn là một hoạt động phổ biến khi xây dựng các ứng dụng tầm nhìn máy tính dựa trên các mạng thần kinh tích chập. Ví dụ: một số mô hình phân đoạn ngữ nghĩa (như FCN hoặc Deeplab) tạo ra một bản đồ tính năng với sải chân lớn (nghĩa là chiều cao và chiều rộng của bản đồ tính năng là 1/s của hình ảnh, trong đó s = 16 hoặc 32), mà Phải được thay đổi kích thước trở lại kích thước không gian chính xác của hình ảnh gốc để cung cấp dự đoán pixelwise.

Nội suy song tuyến là một thuật toán trực quan để thay đổi kích thước hình ảnh. Đó là một khái quát của phép nội suy tuyến tính chỉ hoạt động trên mảng 1-D. Trong bài đăng này, chúng tôi sẽ thảo luận về trực giác đằng sau các thuật toán xen kẽ (tuyến tính hoặc song tuyến) và cung cấp các triển khai Numpy để bạn sẽ hiểu chính xác cách chúng hoạt động. Chúng tôi cũng sẽ điều tra làm thế nào để tính toán đường chuyền ngược của thay đổi kích thước song tuyến khi chúng tôi đào tạo một mạng lưới thần kinh sử dụng thao tác này.backward pass of bilinear resizing when we train a neural network which uses this operation.

Phép nội suy tuyến tính

Trước tiên chúng ta sẽ thảo luận về phép nội suy tuyến tính phổ biến hơn và dễ hiểu hơn.

Hãy nói rằng chúng tôi có hai điểm trên một đường thẳng với tọa độ và, và chúng được liên kết với các giá trị và. Bây giờ nếu chúng ta có điểm thứ ba với tọa độ ở đâu, làm thế nào để chúng ta nội suy các giá trị của cooridnate và tọa độ?

Hướng dẫn bilinear interpolation python image resize - thay đổi kích thước hình ảnh python nội suy song tuyến tính

Nội suy tuyến tính giữa hai ponits.

Việc nội suy tuyến tính tính toán nó như một mức trung bình có trọng số của các giá trị liên quan đến hai điểm, trong đó các trọng số tỷ lệ thuận với khoảng cách giữa và và và.

hoặc

ở đâu .

Trọng lượng cho tỷ lệ thuận với khoảng cách của (chứ không phải), trong khi trọng lượng cho tỷ lệ thuận với sự xa cách của nó với (chứ không phải). Khi di chuyển đến, giá trị của nó trở thành; Tương tự, trở thành khi di chuyển đến.

Resize resize resize mảng 1-D

Cho rằng chúng tôi biết cách thực hiện nội suy giữa hai điểm, hãy xem xét một kịch bản chung hơn: chúng tôi có một mảng 1-D

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

3 có kích thước

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

4 (ví dụ

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

5) và chúng tôi muốn kéo dài hoặc thu nhỏ mảng đến kích thước khác nhau

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

6 ( ví dụ

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

7), trong đó các giá trị trong mảng mới

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8 bằng cách nào đó được tính toán từ mảng gốc theo kiểu tuyến tính.

Hình ảnh Chúng tôi đặt các điểm

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

5 trên một đường thẳng, nơi chúng được đặt cách nhau bởi khoảng cách 1.0. Bây giờ hình ảnh có một đường thẳng khác chạy song song với nó, nơi chúng ta đặt các điểm của mảng mới. Lưu ý rằng chúng tôi tạo các tọa độ của phần tử đầu tiên và cuối cùng của mảng mới giống như các đối tác của họ trong mảng orignal (tức là 0,0 và 4.0).

Làm thế nào để chúng ta có được các giá trị của mảng

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8? Chà, thật hợp lý khi để

[[1, 4], [9, 12], [13, 16]]

1 và

[[1, 4], [9, 12], [13, 16]]

2, bởi vì chúng có cùng tọa độ. Đối với những điểm trong mảng mới mà chúng tôi không có điểm tương ứng trong mảng ban đầu (tức là

[[1, 4], [9, 12], [13, 16]]

3 và

[[1, 4], [9, 12], [13, 16]]

4), chúng tôi có thể ánh xạ chúng đến mảng ban đầu nơi chúng sẽ có tọa độ có giá trị phân đoạn (

[[1, 4], [9, 12], [13, 16]]

5 và

[[1, 4], [9, 12], [13, 16]]

6). Sau đó

[[1, 4], [9, 12], [13, 16]]

7 và

[[1, 4], [9, 12], [13, 16]]

8 có thể được tính toán bằng cách sử dụng phương pháp nội suy tuyến tính từ

[[1, 4], [9, 12], [13, 16]]

9,

[[1, 4], [7, 10], [13, 16]]

0 và

[[1, 4], [7, 10], [13, 16]]

0,

[[1, 4], [7, 10], [13, 16]]

2.

Bây giờ câu hỏi giảm xuống làm thế nào để chúng ta ánh xạ các tọa độ từ mảng mới

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8 sang mảng ban đầu

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

3. Chúng tôi nhận thấy rằng ánh xạ phụ thuộc vào tỷ lệ độ dài của các khoảng thời gian số nguyên của Hồi giáo - trong trường hợp này, nó ____ ____25 (tức là

[[1, 4], [7, 10], [13, 16]]

6). Đối với phần tử trong mảng

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8 với Index

[[1, 4], [7, 10], [13, 16]]

8, tọa độ được ánh xạ của nó trong mảng

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

3 là

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

0 và chúng tôi tính toán nội suy bằng cách sử dụng các giá trị của hai phần tử lân cận

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

1 và

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

2.

Thay đổi kích thước mảng 1-D.

Đặt cùng nhau, chúng tôi có thuật toán để thay đổi kích thước tuyến tính 1-D mảng:

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

Nội suy song phương

Giống như thay đổi kích thước tuyến tính một mảng 1-D, thay đổi kích thước một mảng 2 chiều dựa trên nội suy song tuyến, có thể được chia thành các hoạt động thay đổi kích thước tuyến tính theo kích thước (chiều cao) và (chiều rộng). Giả sử chúng ta có bốn điểm với tọa độ ,, và có giá trị liên quan ,, và.

Nội suy song tuyến giữa bốn điểm.

Trước tiên chúng tôi tính toán giá trị nội suy của và theo chiều rộng,

Sau đó, chúng tôi sẽ thực hiện nội suy tuyến tính giữa hai giá trị nội suy và trong kích thước chiều cao,

ở đâu và .

Song song kích thước mảng 2-D

Xương đôi một mảng 2-D rất giống như thay đổi kích thước tuyến tính một mảng 1-D. Trước tiên chúng ta cần tìm các tỷ lệ (bây giờ là hai chiều),

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

trong đó

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

3 và

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

4 là kích thước của mảng 2-D mới.

Giả sử chúng ta muốn tính toán giá trị nội suy cho điểm tại tọa độ

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

5 trong đó

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

6 và

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

7. Tọa độ được ánh xạ của nó trong mảng 2-D ban đầu được tính toán là

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

8. Sau đó, tọa độ của bốn điểm gần nhất với

import math
  
def linear_resize(in_array, size):
  """
  `in_array` is the input array.
  `size` is the desired size.
  """
  ratio = (len(in_array) - 1) / (size - 1)
  out_array = []

  for i in range(size):
    low = math.floor(ratio * i)
    high = math.ceil(ratio * i)
    weight = ratio * i - low

    a = in_array[low]
    b = in_array[high]

    out_array.append(a * (1 - weight) + b * weight)

  return out_array

5 là

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

0,

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

1,

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

2,

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

3, trong đó

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

Đặt cùng nhau, chúng tôi có thuật toán để thay đổi kích thước hai chiều hai chiều:

import math

def bilinear_resize(image, height, width):
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height):
    for j in range(width):

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

Chúng tôi xác minh tính chính xác của việc triển khai của chúng tôi bằng cách so sánh nó với việc thực hiện tham chiếu trong TensorFlow.

Đầu tiên chúng ta cần tạo một mảng 2-D được điền với các giá trị ngẫu nhiên:

array([[114., 195., 254., 217.,  33., 160.],
       [110.,  91., 184., 143., 190., 124.],
       [212., 163., 245.,  39.,  83., 188.],
       [ 23., 206.,  62.,   7.,   5., 206.],
       [152., 177., 118., 155., 245.,  41.]], dtype=float32)

Và chúng tôi sẽ thay đổi kích thước nó thành một mảng 2 chiều với 2 hàng và 10 cột.

Lợi nhuận của chúng tôi

array([[114.      , 159.      , 201.55556 , 234.33333 , 245.77777 ,
        225.22223 , 155.66667 ,  53.444443,  89.44444 , 160.      ],
       [152.      , 165.88889 , 170.44444 , 137.66667 , 126.22222 ,
        146.77777 , 185.      , 235.      , 154.33333 ,  41.      ]],
      dtype=float32)

giống như đầu ra của

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

4 (lên đến độ chính xác số).

Cuối cùng, hãy để thử nghiệm triển khai của chúng tôi để thay đổi kích thước một hình ảnh thực

Trái: Hình ảnh gốc có kích thước 425 x 775. Phải: Hình ảnh kích thước kích thước 500 x 500.

Phiên bản vectorized

Lưu ý: Hàm

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

5 sử dụng Python cho vòng lặp, chạy rất chậm. Chúng ta có thể tận dụng tính toán vector hóa của Numpy trên các mảng để tăng tốc độ.

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

0

Backward Pass của thay đổi kích thước song song

Hãy nhớ rằng thay đổi kích thước song tuyến về cơ bản là một hàm trong đó đầu vào là một mảng 2 chiều của hình dạng

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

6 và đầu ra là một mảng 2 chiều của hình dạng

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

7. Khi thực hiện quá trình backpropagation, chúng tôi lấy làm gradient

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

8 được đặt lại từ lớp hạ lưu-một mảng 2 chiều có hình dạng giống như đầu ra (tức là

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

9) và chúng tôi tính toán độ dốc của hình dạng

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

6 để được đưa vào lớp ngược dòng của nó.

Lưu ý rằng trong đường chuyền chuyển tiếp (

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

1), chúng tôi đã tính toán đầu ra - hình ảnh thay đổi kích thước - như là sự kết hợp tuyến tính của

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

3,

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8,

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

4 và

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

5, mỗi kết hợp tương ứng với một tập hợp con của các mục nhập của đầu vào

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

6. Độ dốc W.R.T đến

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

3,

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

8,

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

4,

x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

5 chỉ đơn giản là hệ số của chúng,

import math

def bilinear_resize(image, height, width):
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height):
    for j in range(width):

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

1,

import math

def bilinear_resize(image, height, width):
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height):
    for j in range(width):

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

2,

import math

def bilinear_resize(image, height, width):
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height):
    for j in range(width):

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

3 và

import math

def bilinear_resize(image, height, width):
  """
  `image` is a 2-D numpy array
  `height` and `width` are the desired spatial dimension of the new 2-D array.
  """
  img_height, img_width = image.shape[:2]

  resized = np.empty([height, width])

  x_ratio = float(img_width - 1) / (width - 1) if width > 1 else 0
  y_ratio = float(img_height - 1) / (height - 1) if height > 1 else 0

  for i in range(height):
    for j in range(width):

      x_l, y_l = math.floor(x_ratio * j), math.floor(y_ratio * i)
      x_h, y_h = math.ceil(x_ratio * j), math.ceil(y_ratio * i)

      x_weight = (x_ratio * j) - x_l
      y_weight = (y_ratio * i) - y_l

      a = image[y_l, x_l]
      b = image[y_l, x_h]
      c = image[y_h, x_l]
      d = image[y_h, x_h]

      pixel = a * (1 - x_weight) * (1 - y_weight) \ 
              + b * x_weight * (1 - y_weight) + \
              c * y_weight * (1 - x_weight) + \
              d * x_weight * y_weight

      resized[i][j] = pixel

  return resized

4, nhân với

ratio_y = (img_height - 1) / (height - 1)
ratio_x = (img_width - 1) / (width - 1)

8. Thực hiện chi tiết như dưới đây:

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

1

Như chúng ta có thể thấy, khi tính toán đường chuyền ngược của thay đổi kích thước song tuyến, chúng ta không cần lưu trữ giá trị của đường chuyền phía trước.

Cuối cùng, chúng tôi xác minh tính chính xác của đường chuyền ngược bằng một số trường hợp kiểm tra:

[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

2

Nội suy nào là tốt nhất để thay đổi kích thước hình ảnh?

Nếu bạn đang mở rộng hình ảnh, bạn nên muốn sử dụng nội suy inter_linear hoặc inter_cubic. Nếu bạn đang thu hẹp hình ảnh, bạn nên muốn sử dụng phép nội suy Inter_area. Nội suy khối là tính toán phức tạp hơn, và do đó chậm hơn so với nội suy tuyến tính.INTER_AREA interpolation. Cubic interpolation is computationally more complex, and hence slower than linear interpolation.

Nội suy song song trong xử lý hình ảnh là gì?

Trong tầm nhìn máy tính và xử lý hình ảnh, phép nội suy song tuyến được sử dụng để lấy mẫu lại hình ảnh và kết cấu.Một thuật toán được sử dụng để ánh xạ vị trí pixel màn hình đến một điểm tương ứng trên bản đồ kết cấu.Trung bình có trọng số của các thuộc tính (màu sắc, độ trong suốt, v.v.)used to resample images and textures. An algorithm is used to map a screen pixel location to a corresponding point on the texture map. A weighted average of the attributes (color, transparency, etc.)

Thay đổi kích thước song song là gì?

Thay đổi kích thước hình ảnh bằng phương pháp nội suy tuyến tính.Hàm này thay đổi kích thước hình ảnh bằng phương pháp nội suy tuyến tính.Kích thước hình ảnh có thể được giảm hoặc tăng theo mỗi hướng, tùy thuộc vào kích thước hình ảnh đích.. This function changes the image size using the linear interpolation method. The image size may be either reduced or increased in each direction, depending on the destination image size.

Thay đổi kích thước nội suy là gì?

Nội suy hình ảnh xảy ra khi bạn thay đổi kích thước hoặc biến dạng hình ảnh của bạn từ lưới pixel này sang lưới khác.Thay đổi kích thước hình ảnh là cần thiết khi bạn cần tăng hoặc giảm tổng số pixel, trong khi việc ánh xạ lại có thể xảy ra khi bạn đang sửa cho méo ống kính hoặc xoay hình ảnh.occurs when you resize or distort your image from one pixel grid to another. Image resizing is necessary when you need to increase or decrease the total number of pixels, whereas remapping can occur when you are correcting for lens distortion or rotating an image.

programming python Bilinear interpolation Python Image interpolation Python Resize bilinear tensorflow Bilinear interpolation downscaling Bicubic interpolation Python Bilinear scaling

Hướng dẫn bilinear interpolation python image resize - thay đổi kích thước hình ảnh python nội suy song tuyến tính

Phép nội suy tuyến tính

Resize resize resize mảng 1-D

Nội suy song phương

Song song kích thước mảng 2-D

Phiên bản vectorized

Backward Pass của thay đổi kích thước song song

Nội suy nào là tốt nhất để thay đổi kích thước hình ảnh?

Nội suy song song trong xử lý hình ảnh là gì?

Thay đổi kích thước song song là gì?

Thay đổi kích thước nội suy là gì?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội