blink kernels (5) - Blink Reference Guide

Blink Reference Guide

https://learn.foundry.com/nuke/developers/13.2/BlinkKernels/Blink.html

Blink Reference Guide — Guide to Writing Blink Kernels

Introduction

Blink 개요

• 설명: 빠른 이미지 처리를 위한 C++ 유사 언어
• 특징: 표준 C++ 문법 기반 (일부 키워드 수정)
• 컴파일: LLVM 컴파일러 사용으로 장치에 맞는 코드 생성

지원하는 코드 유형

1. 표준 C++ (CPU용)
2. SIMD 최적화 C++ (CPU용)
3. OpenCL (GPU용)
4. CUDA (GPU용)

런타임 컴파일 장점

• 유연한 코드 생성: 모든 경우를 위한 코드 생성 불필요
  • 필요한 입력 및 출력 유형에 맞는 코드만 생성
• 하드웨어 최적화: 런타임 시 사용 가능한 하드웨어에 맞는 코드 생성
  • 예: SIMD 코드의 경우, CPU가 AVX를 지원하면 AVX 사용, 그렇지 않으면 SSE2 사용
• 성능 향상: 코드 디스크 캐시로 반복 컴파일 오버헤드 감소

활용 예시: BlinkScript 노드 (Nuke)

• 용도: Nuke에서 이미지 처리 코드 테스트 및 프로토타이핑
• 특징: Nuke의 노드 그래프 내에서 Blink 연산을 결합하여 테스트 가능

Kernel Basics

Blink 프레임워크의 핵심 개념은 **Blink "커널"**입니다.

• 커널 정의: 반복 공간(iteration space) 내에서 각 위치에서 실행되는 간단한 코드 조각
• 활용 예시: 이미지 처리 시 반복 공간은 보통 생성할 출력 이미지의 경계가 됨
  • 커널이 출력 이미지의 모든 위치에서 실행되어 최종 이미지를 생성

Creating a Kernel

Blink 커널 작성 방식

Blink 커널은 C++ 클래스와 유사한 형태로 작성됩니다. Kernel 클래스를 상속하며, 템플릿 매개변수로 Granularity를 받습니다. 예시는 다음과 같습니다:

kernel BasicKernel : ImageComputationKernel<Granularity>
{
  // 커널 본문 (Kernel body)
};

커널 본문 구성 요소

1. 이미지 사양 (Image Specification)
   • 커널에서 읽거나 쓰는 이미지를 정의
   • 관례적으로 커널의 첫 번째 멤버로 위치함
2. 단일 process() 메서드
   • 반복 공간(iteration space) 내 각 지점마다 호출됨
   • 입력 이미지에서 데이터를 읽고, 출력 이미지에 데이터를 기록

Kernel Granularity

Blink 커널의 반복 방식

Blink 커널은 컴포넌트별(componentwise) 또는 픽셀별(pixelwise) 방식으로 반복될 수 있습니다.

1. 컴포넌트별 반복 (componentwise)
   • 커널이 반복 공간의 각 지점에서 각 컴포넌트마다 한 번씩 실행됨
   • Granularity 옵션: eComponentWise
   • 각 입력 이미지에서 현재 컴포넌트의 값만 접근 가능하며, 출력 이미지에도 현재 컴포넌트 값만 기록 가능
2. 픽셀별 반복 (pixelwise)
   • 커널이 반복 공간의 각 지점에서 한 번만 실행됨
   • Granularity 옵션: ePixelWise
   • 모든 컴포넌트 값을 읽고 쓸 수 있음

Image Specification

Blink 커널 이미지 사양 (Image Specification)

Blink 커널에서 이미지를 지정할 때는 다음과 같은 형식을 사용합니다:

Image<ReadSpec, AccessPattern, EdgeMethod> myImage;

템플릿 매개변수 설명

1. ReadSpec
   • eRead: 읽기 전용
   • eWrite: 쓰기 전용
   • eReadWrite: 읽기 및 쓰기 가능
2. 이미지 데이터 접근 권한을 설정합니다.
3. AccessPattern
   • eAccessPoint: 현재 위치의 픽셀만 접근
   • eAccessRanged1D: 현재 위치를 기준으로 한 1차원 범위 접근
   • eAccessRanged2D: 현재 위치를 기준으로 한 2차원 범위 접근
   • eAccessRandom: 반복 공간 내 임의의 픽셀 접근
4. 커널이 이미지의 픽셀에 접근하는 방식을 지정합니다. 기본값은 eAccessPoint입니다.
5. EdgeMethod
   • eEdgeClamped: 이미지 경계 값이 반복됨
   • eEdgeConstant: 경계 밖은 0 값 반환
   • eEdgeNone: 경계 밖 값은 정의되지 않으며, 경계 체크를 하지 않음 (효율적 접근)
6. 이미지 경계를 벗어났을 때의 동작 방식을 설정합니다. 기본값은 eEdgeNone입니다.

The process() Method

process() 메서드의 서명(Signature)

process() 메서드는 **반복 공간(iteration space)**의 각 위치에서 실행되는 함수로, 세 가지 형태의 서명을 가질 수 있습니다.

1. void process()
   • 반복 공간 내 위치에 상관없이 동일한 처리를 수행하는 커널에서 사용합니다.
2. void process(int2 pos)
   • 반복 공간에서의 위치 좌표가 필요한 커널에서 사용합니다.
   • pos.x와 pos.y를 통해 현재 위치의 x, y 좌표를 얻을 수 있습니다.
3. void process(int3 pos)
   • eComponentWise 그레인(granularity)에서만 사용 가능합니다.
   • pos.x, pos.y는 현재 위치의 좌표를 나타내고, pos.z는 현재 컴포넌트를 나타냅니다.

참고: 여러 서명의 process() 메서드를 정의할 경우, 첫 번째 정의된 것만 사용됩니다.

A Basic Kernel Example

이미지 복사 커널 예시

다음은 입력 이미지 src를 출력 이미지 dst로 단순히 복사하는 CopyKernel 예시입니다.

1. 컴포넌트별 반복 버전 (eComponentWise)

kernel CopyKernel : ImageComputationKernel<eComponentWise>
{
  Image<eRead, eAccessPoint, eEdgeClamped> src;
  Image<eWrite> dst;

  void process()
  {
    dst() = src();
  }
};

• 접근 방법: src()와 dst()로 현재 위치 및 컴포넌트에서 이미지를 접근
• 특징: 컴포넌트별 반복 방식이므로 각 컴포넌트가 개별적으로 복사됨

2. 픽셀별 반복 버전 (ePixelWise)

kernel CopyKernel : ImageComputationKernel<ePixelWise>
{
  Image<eRead, eAccessPoint, eEdgeClamped> src;
  Image<eWrite> dst;

  void process()
  {
    dst() = src();
  }
}

• 접근 방법: src()는 SampleType(src) 유형의 값을 반환하여 각 컴포넌트에 대한 벡터로 출력됨
• 특징: 픽셀 단위로 처리되어 모든 컴포넌트를 한 번에 복사 가능

3. 개별 컴포넌트 접근 버전 (픽셀별 반복)

kernel CopyKernel : ImageComputationKernel<ePixelWise>
{
  Image<eRead, eAccessPoint, eEdgeClamped> src;
  Image<eWrite> dst;

  void process()
  {
    for (int component = 0; component < dst.kComps; component++)
      dst(component) = src(component);
  }
};

• 접근 방법: dst(component)와 src(component)로 특정 컴포넌트를 지정하여 접근
• 특징: dst.kComps를 사용해 dst 이미지의 컴포넌트 수를 얻어 반복을 통해 개별 컴포넌트를 복사

이러한 예시를 통해 각 반복 방식과 컴포넌트 접근 방법을 쉽게 이해할 수 있습니다.

Kernel Variables

Variable Visibility

Blink 커널 변수 가시성

Blink 커널에서는 두 가지 가시성 수준의 변수를 사용할 수 있습니다:

1. param 변수
   • 외부에서 접근 가능한 변수 (C++의 public 멤버 변수와 유사)
   • 커널 외부에서 값을 설정하거나 읽을 수 있음
2. local 변수
   • 커널 내부에서만 사용 가능한 변수 (C++의 private 멤버 변수와 유사)
   • 커널 외부에서는 접근할 수 없음

예시 코드

class MyKernel : public Kernel<eComponentWise>
{
  Image<eWrite> dst;

  param:
    float myParameter1;  // 외부에서 접근 가능한 매개변수
    int myParameter2;

  local:
    int myVariable1;     // 내부 전용 변수
    float myVariable2;

  void process()
  {
    dst() = (float)(myParameter2 * myVariable1) + myParameter2 * myVariable2;
  }
};

• param 블록: myParameter1, myParameter2는 외부에서 접근 가능한 매개변수
• local 블록: myVariable1, myVariable2는 커널 내부 전용 변수

이와 같이 param과 local로 변수를 나누어 선언하여 가시성을 설정할 수 있습니다.

Variable Types

Blink 커널에서 변수 타입

Blink에서는 param과 local 변수에 다양한 타입을 사용할 수 있습니다. 기본 C++ 타입뿐만 아니라 벡터 및 특수 타입도 지원합니다.

1. 기본 C++ 타입

• float, int, bool 등 기본 C++ 타입을 사용할 수 있습니다.
• 배열 타입도 지원됩니다: float[], int[], bool[] 등.

2. 벡터 타입

다음과 같은 표준 벡터 타입을 사용할 수 있습니다:

• int2, int3, int4 (정수형 벡터)
• float2, float3, float4 (부동소수점 벡터)
• int1, float1 (단일 값 벡터)

벡터 타입에서 개별 컴포넌트 접근:

• 벡터의 각 컴포넌트는 .x, .y, .z, .w로 접근할 수 있습니다. 예시:
  • vec.x는 벡터의 첫 번째 컴포넌트를 접근
  • vec.y는 두 번째 컴포넌트

3. 특수 타입: recti 및 rectf

• recti: 정수 좌표로 표현된 직사각형
• rectf: 부동소수점 좌표로 표현된 직사각형

예시:

recti myRect(int x1, int y1, int x2, int y2);

• myRect는 (x1, y1)을 좌측 하단, (x2, y2)를 우측 상단으로 하는 직사각형을 나타냅니다.
• 직사각형의 좌표는 다음과 같이 접근할 수 있습니다:
  • myRect.x1, myRect.y1, myRect.x2, myRect.y2

The Define Method

define() 메서드와 defineParam() 함수

define() 메서드는 커널 파라미터에 대한 추가 정보를 제공하는 데 사용됩니다. 이 메서드는 defineParam() 함수만 호출해야 하며, 이를 통해 커널의 파라미터를 외부에서 참조할 수 있도록 정의할 수 있습니다.

defineParam() 함수의 형태:

defineParam(paramName, "externalParamName", defaultValue)

• paramName: 커널 내에서 사용하는 파라미터 이름
• "externalParamName": 외부에서 참조할 이름 (문자열로 입력)
• defaultValue: 파라미터의 기본값

예시

예를 들어, size라는 실수형 파라미터를 외부에서는 Radius로 참조하고, 기본값은 10.0f로 설정하려면, 다음과 같이 정의할 수 있습니다:

defineParam(size, "Radius", 10.0f);

define() 메서드 호출

• define() 메서드는 커널이 처음 생성될 때 한 번만 호출되며, 커널의 파라미터를 정의합니다. defineParam()을 사용하여 파라미터의 이름, 외부 참조명, 기본값 등을 설정합니다.

Image Access

이미지 접근 및 init() 메서드 설정

커널의 process() 함수에서 이미지에 접근하는 방식은 **커널의 그레인(granularity)**과 **이미지 사양(image specification)**에 따라 달라집니다. 특정 유형의 이미지 접근은 커널의 init() 메서드에서 먼저 설정해야 할 필요가 있습니다.

1. 커널 그레인(granularity)

• eComponentWise: 각 이미지의 컴포넌트별로 반복하며 접근
• ePixelWise: 각 픽셀 단위로 반복하며 접근

2. 이미지 사양(image specification)

• 이미지가 읽기, 쓰기 또는 읽기/쓰기에 대해 어떻게 접근할지, 엣지 처리 방식이 무엇인지에 따라 다릅니다.
• 예를 들어, eRead나 eWrite, eReadWrite와 같은 읽기/쓰기 접근 방식, eAccessPoint, eAccessRanged1D, eAccessRandom 등의 접근 패턴을 설정할 수 있습니다.

3. init() 메서드의 역할

• init() 메서드는 이미지의 접근을 설정하는 초기화 작업을 수행하는 곳입니다. 이 메서드에서 필요한 이미지 접근 방식을 설정하고 준비해야 합니다.

The Init Method

init() 메서드

init() 메서드는 process() 함수가 실행되기 전에 호출되며, 주로 이미지 접근을 설정하거나 로컬 변수 초기화를 수행하는 데 사용됩니다. 이 메서드는 커널의 초기 설정을 처리하는 역할을 하며, 이미지에 대한 접근 방식이나 로컬 변수의 초기화가 필요한 경우에만 정의하면 됩니다.

주요 역할:

• 이미지 접근 설정: init() 메서드에서 이미지에 대한 접근 방법을 설정할 수 있습니다. 예를 들어, 이미지의 엣지 처리 방식이나 접근 패턴을 설정합니다.
• 로컬 변수 초기화: 커널 내에서 사용되는 로컬 변수를 초기화합니다.

init() 메서드를 정의하지 않아도 되는 경우:

• 설정 또는 초기화가 필요 없는 경우: 이미지 접근이나 변수를 초기화할 필요가 없으면, init() 메서드를 정의할 필요가 없습니다. 이 경우 process() 함수만으로도 커널을 정의할 수 있습니다.

Configuring ranged image access

Ranged 이미지 접근 및 init() 설정

Ranged 이미지 접근 (eAccessRanged1D, eAccessRanged2D)은 반드시 init() 함수 내에서 설정해야 합니다. 이를 통해 이미지의 범위(range)를 지정하고 접근 방식에 따라 초기화 작업을 수행할 수 있습니다.

1. setAxis() 함수

• eAccessRanged1D 접근 방식을 사용할 때, 범위가 수평(horizontal) 또는 수직(vertical) 인지 명시해야 합니다.
• 이를 위해 setAxis() 함수가 사용됩니다.

사용법:

setAxis(Axis axis);

axis 값은 다음 중 하나여야 합니다:

• eX (수평, horizontal)
• eY (수직, vertical)

2. setRange() 함수

• eAccessRanged1D와 eAccessRanged2D에서 범위를 설정하려면 setRange() 함수가 사용됩니다. 이 함수는 범위의 최소값(rangeMin)과 최대값(rangeMax)을 설정합니다.

사용법:

setRange(int rangeMin, int rangeMax);

• 이 함수는 1D 범위를 설정할 때 사용되며, 범위는 양쪽 끝을 포함한 값을 지정합니다.

3. 2D 접근의 경우 (eAccessRanged2D)

• eAccessRanged2D에서는 두 축에 대해 별도로 범위를 지정할 수 있습니다. 범위는 **수평(x축)**과 수직(y축) 에 대해 각각 설정할 수 있습니다.

사용법:

setRange(int xMin, int yMin, int xMax, int yMax);

이 방식은 비대칭 범위를 설정할 수 있어, x축과 y축에 대해 각각 다른 최소값과 최대값을 지정할 수 있습니다.

4. eAccessPoint와 eAccessRandom 접근 방식

• *eAccessPoint*와 eAccessRandom 접근 방식은 init() 함수에서 별도로 설정할 필요가 없습니다. 이들 접근 방식은 이미지의 특정 지점이나 무작위로 접근하는 방식이므로 초기화 작업이 필요하지 않습니다.

---

요약

• *eAccessRanged1D*와 eAccessRanged2D 접근 방식에서는 범위 설정을 init() 함수에서 해야 하며, 이를 위해 setAxis() 및 setRange() 함수를 사용합니다.
• *eAccessPoint*와 eAccessRandom 접근 방식은 초기화가 필요 없습니다.

Setting local variables

init() 함수에서 이미지와 로컬 변수 사용

init() 함수는 커널의 이미지 접근 설정뿐만 아니라 로컬 변수 초기화에도 사용될 수 있습니다. 이를 통해 반복되는 계산을 피하고, 커널 실행 시 필요한 계산을 한 번만 수행하여 성능을 최적화할 수 있습니다.

이미지 정보 사용

init() 함수에서는 커널 실행 시 사용될 이미지의 다양한 정보를 활용할 수 있습니다. 이미지 스펙과 파라미터 값이 이미 결정된 상태에서, 이를 기반으로 로컬 변수 계산을 할 수 있습니다. 이미지 관련 정보는 **init()**과 process() 함수 모두에서 접근할 수 있습니다.

사용할 수 있는 이미지 속성:

• image.kMin: 이미지 데이터의 모든 컴포넌트에서 가능한 최소값.
• image.kMax: 이미지 데이터의 모든 컴포넌트에서 가능한 최대값.
• image.kWhitePoint: 이미지 데이터에서 흰색으로 간주되는 최소값. 예를 들어, 부동소수점 이미지에서는 1이 일반적인 흰색점이지만, 1보다 큰 값도 유효한 “슈퍼화이트” 값으로 취급됩니다.
• image.kComps: 이미지의 컴포넌트 수. 예를 들어, RGB 이미지는 3개의 컴포넌트를 가집니다.
• image.kClamps: 이미지 데이터가 클램프(clamp)되는지 여부. 예를 들어, 부동소수점 데이터는 어떤 값도 허용되므로 image.kClamps는 false입니다.
• image.bounds: 이미지의 경계 정보. image.bounds.x1, image.bounds.y1 (하단 왼쪽 좌표), image.bounds.x2, image.bounds.y2 (상단 오른쪽 좌표)를 통해 이미지를 정의할 수 있습니다.

타입 정보:

• ValueType(image): 이미지 컴포넌트의 데이터 타입. 예를 들어, float 타입.
• SampleType(image): 픽셀 데이터의 타입. 예를 들어, ValueType(image)가 float이고 이미지 컴포넌트가 3개라면, SampleType(image)는 float3입니다.

로컬 변수 초기화 예시

init() 함수에서 이러한 이미지 속성을 사용하여 로컬 변수를 초기화하고, 이후 process() 함수에서 반복 계산을 방지할 수 있습니다.

kernel MyKernel : ImageComputationKernel<ePixelWise>
{
  Image<eRead, eAccessPoint> src;
  Image<eWrite> dst;

  local:
    float threshold;

  void init()
  {
    // 이미지의 kMin과 kMax 값을 이용하여 임계값 계산
    threshold = (src.kMin + src.kMax) / 2.0f;
  }

  void process()
  {
    // 임계값을 기준으로 이미지를 처리
    dst() = (src() > threshold) ? 1.0f : 0.0f;
  }
};

위 예시에서 init() 함수는 이미지의 **최소값(kMin)**과 **최대값(kMax)**을 사용하여 **임계값(threshold)**을 계산하고, 이를 **로컬 변수(threshold)**에 저장합니다. 이렇게 함으로써 process() 함수에서 반복 계산을 피할 수 있습니다.

요약

• init() 함수에서 이미지를 사용하여 초기화 작업을 할 수 있으며, 이를 통해 로컬 변수를 설정하여 성능을 최적화할 수 있습니다.
• 이미지에 대한 다양한 속성(kMin, kMax, kWhitePoint, bounds, 등)을 활용해 계산을 초기화하고, **process()*에서 반복되는 작업을 피할 수 있습니다.

Image Access from the Kernel Method

이미지 접근 방식 및 파라미터

process() 함수 내에서 읽기 및 쓰기 이미지 접근은 **커널의 세분화(granularity)**와 **이미지 사양(image specification)**에 따라 다양한 방식으로 수행됩니다. 접근 방식은 각 접근 모드에 필요한 파라미터에 따라 달라집니다.

1. eAccessPoint

• 매개변수: 이미지 사양에 관련된 매개변수가 필요하지 않습니다.
• 사용법: image()로 호출하면 현재 위치에서 단일 픽셀에 대한 접근이 이루어집니다.

2. eAccessRanged1D

• 매개변수: 첫 번째 매개변수는 이미지 내에서 접근할 위치의 오프셋을 지정하는 정수 값입니다. 이 오프셋은 **현재 반복 공간(iteration space)**에서의 상대적인 위치입니다.
• 사용법: image(int offset)로 호출하여, 현재 위치에서 지정된 오프셋에 해당하는 이미지를 접근합니다.

3. eAccessRanged2D

• 매개변수: 첫 번째와 두 번째 매개변수는 각각 x축과 y축에 대한 정수 오프셋입니다. 이 오프셋들은 현재 반복 공간에서 상대적인 위치를 나타냅니다.
• 사용법: image(int horizontalOffset, int verticalOffset)로 호출하여, 지정된 2D 오프셋을 기반으로 이미지를 접근합니다.

4. eAccessRandom

• 매개변수: 두 개의 매개변수는 각각 x와 y 좌표를 나타냅니다. 이는 반복 공간의 위치와 관계없이, 이미지에서 특정 (x, y) 좌표에 접근하는 방식입니다.
• 사용법: image(int x, int y)로 호출하여, (x, y) 좌표에 해당하는 픽셀에 접근합니다.

5. ePixelWise (컴포넌트 접근)

ePixelWise 세분화 방식에서는 **컴포넌트 인덱스(c)**를 추가로 지정할 수 있습니다. 이 매개변수는 접근하려는 특정 컴포넌트의 인덱스를 나타냅니다.

• eAccessPoint 컴포넌트 접근: image(int c) — 단일 컴포넌트 접근
• eAccessRanged1D 컴포넌트 접근: image(int offset, int c) — 1D 범위에서 컴포넌트 접근
• eAccessRanged2D 컴포넌트 접근: image(int horizontalOffset, int verticalOffset, int c) — 2D 범위에서 컴포넌트 접근
• eAccessRandom 컴포넌트 접근: image(int x, int y, int c) — 특정 (x, y) 위치에서 컴포넌트 접근

예시 코드

1. eAccessPoint 접근:
2. image() // 현재 위치에서 이미지 접근
3. eAccessRanged1D 접근:
4. image(offset) // 수평(또는 수직) 오프셋에 해당하는 위치의 이미지 접근
5. eAccessRanged2D 접근:
6. mage(horizontalOffset, verticalOffset) // 2D 오프셋에 해당하는 이미지 접근
7. eAccessRandom 접근:
8. image(x, y) // 지정된 (x, y) 좌표에서 이미지 접근
9. ePixelWise 컴포넌트 접근:
10. image(c) // 지정된 컴포넌트 인덱스에 접근

결론

process() 함수 내에서 이미지 접근은 커널의 세분화 방식에 따라 다르며, 각 접근 방식은 적절한 이미지 사양과 관련된 파라미터를 필요로 합니다. ePixelWise와 같은 세분화에서는 컴포넌트 접근을 위한 추가적인 인덱스를 지정할 수 있어 더 세밀한 제어가 가능합니다.

Return Types for Image Access

모든 이미지 액세스는 참조로 이루어집니다. 픽셀 단위 액세스의 경우 액세스할 구성 요소를 지정하지 않으면 요청한 위치의 모든 구성 요소에 대한 값이 포함된 벡터에 대한 참조를 돌려받게 됩니다. 벡터는 유형 이미지.SampleType이 됩니다. 구성 요소를 지정하거나 구성 요소 단위 액세스를 지정한 경우 유형 이미지.ValueType의 구성 요소에 대한 참조를 돌려받게 됩니다.

Bilinear Interpolation

이미지 접근을 위한 빌리니어 보간법

빌리니어 보간법은 이미지 내에서 정수 좌표가 아닌 위치에서 픽셀이나 컴포넌트 값을 추정하는 데 사용됩니다. 주로 이미지 크기 조정, 회전 등과 같이 픽셀 사이의 중간 위치를 계산해야 할 때 유용합니다.

빌리니어 함수 사용법

• 픽셀별(Pixelwise) 커널: 픽셀별 커널에서는 bilinear 함수를 사용하여 실수 좌표 (x, y)에 대해 보간을 수행합니다. 이 함수는 해당 위치에서 이미지의 모든 컴포넌트에 대해 보간된 값을 반환합니다.
  • 반환 타입: SampleType(img1) — 이미지의 모든 컴포넌트에 대해 하나의 값을 가지는 벡터 타입입니다.
• linear(Image img1, float x, float y)
• 컴포넌트별(Componentwise) 커널: 컴포넌트별 커널에서는 각 컴포넌트마다 독립적으로 빌리니어 보간을 수행합니다. 이 경우 반환 타입은 이미지의 각 컴포넌트에 해당하는 값 타입입니다.
  • 반환 타입: ValueType(img1) — 각 컴포넌트에 대한 단일 값 타입입니다.
• bilinear(Image img1, float x, float y)
• 컴포넌트 지정 보간: 픽셀별 커널에서는 특정 컴포넌트에 대해서만 보간을 수행할 수도 있습니다.
  • 여기서 c는 컴포넌트 인덱스를 의미하며, 특정 컴포넌트에 대해서만 보간을 수행합니다.
• bilinear(Image img1, float x, float y, int c)

정리

• 픽셀별 커널: 모든 컴포넌트에 대해 보간된 값을 반환.
• 컴포넌트별 커널: 각 컴포넌트에 대해 독립적으로 보간된 값을 반환.
• 특정 컴포넌트에 대한 보간: c 인덱스를 사용하여 특정 컴포넌트에 대해 보간할 수 있음