Image

// Declare an image object
CFLImage fli;
// Load an image
CResult res = fli.Load(L"D:\\ExampleImage.png");

// Declare an image object
CFLImage fli = new CFLImage();
// Load an image
CResult res = fli.Load("D:\\ExampleImage.png");

# Declare an image object
fli = CFLImage()
# Load an image
res = fli.Load("D:\\ExampleImage.png")

// Insert an image file into the front page
CResult res = fli.LoadFront(L"D:\\ImageToPushFront.png");

// Insert an image file into the front page
CResult res = fli.LoadFront("D:\\ImageToPushFront.png");

# Insert an image file into the front page
res = fli.LoadFront("D:\\ImageToPushFront.png")

// Insert an image file into the last page
CResult res = fli.LoadBack(L"D:\\ImageToPushBack.png");

// Insert an image file into the last page
CResult res = fli.LoadBack("D:\\ImageToPushBack.png");

# Insert an image file into the last page
res = fli.LoadBack("D:\\ImageToPushBack.png")

// Load an image file to the desired page index
CResult res = fli.LoadInsert(L"D:\\ImageToInsert.png", 1);

// Load an image file to the desired page index
CResult res = fli.LoadInsert("D:\\ImageToInsert.png", 1);

# Load an image file to the desired page index
res = fli.LoadInsert("D:\\ImageToInsert.png", 1)

// Declare an image object
CFLImage fli;
// Set parameters
int32_t i32Width = 2660; // image width
int32_t i32Height = 2560; // image height
EPixelFormat ePixelFormat = EPixelFormat_C1_U8;
int32_t i32AlignByte = 4; // The alignment byte
int64_t i64OffsetFromBegin = 0; // The offset from the beginning of the data.
int64_t i64OffsetFromEnd = 0; // The offset from the end of the data, starting from the end of the file.

// Load a raw image
CResult res = fli.LoadRaw(L"D:\\ExampleRawImage.raw", i32Width, i32Height, ePixelFormat, i32AlignByte, i64OffsetFromBegin, i64OffsetFromEnd);

// Declare an image object
CFLImage fli = new CFLImage();
// Set parameters
int i32Width = 2660; // image width
int i32Height = 2560; // image height
EPixelFormat ePixelFormat = EPixelFormat.C1_U8;
int i32AlignByte = 4; // The alignment byte
long i64OffsetFromBegin = 0; // The offset from the beginning of the data.
long i64OffsetFromEnd = 0; // The offset from the end of the data, starting from the end of the file.

// Load a raw image
CResult res = fli.LoadRaw("D:\\ExampleRawImage.raw", i32Width, i32Height, ePixelFormat, i32AlignByte, i64OffsetFromBegin, i64OffsetFromEnd);

# Declare an image object
fli = CFLImage()
# Set parameters
i32Width = 2660 # image width
i32Height = 2560 # image height
ePixelFormat = EPixelFormat.C1_U8
i32AlignByte = 4 # The alignment byte
i64OffsetFromBegin = 0 # The offset from the beginning of the data.
i64OffsetFromEnd = 0 # The offset from the end of the data, starting from the end of the file.

# Load a raw image
res = fli.LoadRaw("D:\\ExampleRawImage.raw", i32Width, i32Height, ePixelFormat, i32AlignByte, i64OffsetFromBegin, i64OffsetFromEnd)

CFLImage fli;
uint8_t* pU8Buffer = fli.GetBuffer();

CFLImage fli = new CFLImage();

var buffer = fli.GetBuffer(); 

// 만약 byte[]로 복사해서 쓰고 싶다면:
byte[] managedBuffer = new byte[buffer.Length];
buffer.CopyTo(managedBuffer, 0);

fli = CFLImage()
# 반환값: System.Array[System.Byte]
arrayBuff = fli.GetBuffer()

// CFLImage 객체 생성
CFLImage fli;

// 이미지 로드
CResult res = fli.Load(L"D:/C4_F32_Image.flif");

// 이미지 버퍼 포인터 얻기
uint8_t* pU8Buffer = fli.GetBuffer();

// 이미지 depth 얻기
int32_t i32Depth = fli.GetDepth();

// 이미지의 value type 에 따른 분기
// 이미지의 픽셀 값 타입에 따라 버퍼 포인터를 다른 자료형으로 캐스팅해서 사용
switch(fli.GetValueType())
{
case EValueType_FloatingPoint:
	{
		if(i32Depth == 64)
		{
			double* pF64Buffer = (double*)pU8Buffer;
			// do something...
		}
		else if(i32Depth == 32)
		{
			float* pF32Buffer = (float*)pU8Buffer;
			// do something...
		}
	}
	break;
case EValueType_Signed:
	{
		if(i32Depth == 64)
		{
			int64_t* pI64Buffer = (int64_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth == 32)
		{
			int32_t* pI32Buffer = (int32_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth > 8)
		{
			int16_t* pI16Buffer = (int16_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth == 8)
		{
			int8_t* pI8Buffer = (int8_t*)pU8Buffer;
			// do something...
		}
	}
	break;
case EValueType_Unsigned:
	{
		if(i32Depth == 64)
		{
			uint64_t* pU64Buffer = (uint64_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth == 32)
		{
			uint32_t* pU32Buffer = (uint32_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth > 8)
		{
			uint16_t* pU16Buffer = (uint16_t*)pU8Buffer;
			// do something...
		}
		else if(i32Depth == 8)
		{
			// do something with uint8_t* pU8Buffer
		}
	}
	break;
}

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 이미지 로드
res = fli.Load("D:/C4_F32_Image.flif");

// 이미지 버퍼 얻기
byte[] buffer = fli.GetBuffer();
int depth = fli.GetDepth(); // 비트 단위 (ex: 32, 64)
int byteDepth = depth / 8;
EValueType valueType = fli.GetValueType();

long i64Width = fli.GetWidth();
long i64Height = fli.GetHeight();
int i32Channels = fli.GetChannels();

long i64PixelCount = i64Width * i64Height * i32Channels;

for(long y = 0; y < i64Height; y++)
{
  for(long x = 0; x < i64Width; x++)
  {
    for(int c = 0; c < i32Channels; c++)
    {
      int i = (int)((y * i64Width) + x) * i32Channels + c;
      int offset = i * byteDepth;

      // 이미지의 value type 에 따른 분기
      // 이미지의 픽셀 값 타입에 따라 버퍼 포인터를 다른 자료형으로 캐스팅해서 사용
      switch(valueType)
      {
      case EValueType.FloatingPoint:
        if(depth == 32)
        {
          // float (4 bytes)
          float val = BitConverter.ToSingle(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 64)
        {
          // double (8 bytes)
          double val = BitConverter.ToDouble(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        break;

      case EValueType.Signed:
        if(depth == 8)
        {
          sbyte val = (sbyte)Marshal.ReadByte(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 16)
        {
          short val = Marshal.ReadInt16(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 32)
        {
          int val = Marshal.ReadInt32(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 64)
        {
          long val = Marshal.ReadInt64(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        break;

      case EValueType.Unsigned:
        if(depth == 8)
        {
          byte val = Marshal.ReadByte(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 16)
        {
          ushort val = (ushort)Marshal.ReadInt16(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 32)
        {
          uint val = (uint)Marshal.ReadInt32(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        else if(depth == 64)
        {
          ulong val = (ulong)Marshal.ReadInt64(buffer, offset);
          Console.WriteLine($"[{x}, {y}] Ch{c} = {val}");
        }
        break;
      }
    }
  }
}

import struct

# CFLImage 객체 생성
fli = CFLImage()

# 이미지 로드
res = fli.Load("D:/C4_F32_Image.flif")

# 기본 정보
buffer = fli.GetBuffer()
depth = fli.GetDepth()  # ex: 32, 64
byte_depth = depth // 8
value_type = fli.GetValueType()

width = fli.GetWidth()
height = fli.GetHeight()
channels = fli.GetChannels()

# Pixel 순회
for y in range(height):
  for x in range(width):
    for c in range(channels):
      i = ((y * width) + x) * channels + c
      offset = i * byte_depth
    
      # 바이트 슬라이스
      # 명시적으로 바이트 배열로 변환
      b = bytes([buffer[offset + i] for i in range(byte_depth)])
    
      # 값 해석
      if value_type == EValueType.FloatingPoint:
        if depth == 32:
          val = struct.unpack('<f', b)[0]
        elif depth == 64:
          val = struct.unpack('<d', b)[0]
        else:
          continue
      elif value_type == EValueType.Signed:
        if depth == 8:
          val = struct.unpack('<b', b)[0]
        elif depth == 16:
          val = struct.unpack('<h', b)[0]
        elif depth == 32:
          val = struct.unpack('<i', b)[0]
        elif depth == 64:
          val = struct.unpack('<q', b)[0]
        else:
          continue
      elif value_type == EValueType.Unsigned:
        if depth == 8:
          val = struct.unpack('<B', b)[0]
        elif depth == 16:
          val = struct.unpack('<H', b)[0]
        elif depth == 32:
          val = struct.unpack('<I', b)[0]
        elif depth == 64:
          val = struct.unpack('<Q', b)[0]
        else:
          continue
      else:
        continue
    
      print(f"[{x}, {y}] Ch{c} = {val}")

CFLImage fli;
res = fli.Load(L"D:/C4_F32_Image.flif");
uint8_t* pU8Buffer = fli.GetBuffer();
int32_t i32Depth = fli.GetDepth();
int64_t i64W = fli.GetWidth(); // 이미지의 너비 (픽셀 단위)
int64_t i64H = fli.GetHeight(); // 이미지의 높이 (픽셀 단위)
int64_t i64WidthStepByte = fli.GetWidthStepByte(); // 한 줄(row)을 저장하는 데 필요한 바이트 수

switch(fli.GetValueType())
{
case EValueType_FloatingPoint:
    {
        if(i32Depth == 64)
        {
            for(int64_t y = 0; y < i64H; ++y)
            {
                double* pF64Buffer = (double*)pU8Buffer;

                for(int64_t x = 0; x < i64W; ++x)
                {
                    double f64PixelValue = *(pF64Buffer + x);
                    *(pF64Buffer + x) = f64PixelValue * 0.5;
                    // do something...
                }
                // 한 줄 내리기
                pU8Buffer += i64WidthStepByte;
            }
        }
        else if(i32Depth == 32)
        {
            for(int64_t y = 0; y < i64H; ++y)
            {
                float* pF32Buffer = (float*)pU8Buffer;

                for(int64_t x = 0; x < i64W; ++x)
                {
                    float f32PixelValue = *(pF32Buffer + x);
                    *(pF32Buffer + x) = f32PixelValue * 0.5f;
                    // do something...
                }
                // 한 줄 내리기
                pU8Buffer += i64WidthStepByte;
            }
        }
    }
    break;
    // and so on...
}

CFLImage fli = new CFLImage();
res = fli.Load("D:/C4_F32_Image.flif");

// 이미지 버퍼 얻어 오기
IntPtr pBuffer = fli.GetBufferPtr();
int depth = fli.GetDepth(); // 비트 단위 (ex: 32, 64)
int byteDepth = depth / 8;
EValueType valueType = fli.GetValueType();

long i64Width = fli.GetWidth();   // 이미지 너비
long i64Height = fli.GetHeight(); // 이미지 높이
int i32Channels = fli.GetChannels(); // 이미지 채널

long i64PixelCount = i64Width * i64Height * i32Channels;
byte[] buffer = new byte[4]; // float = 4바이트

// 버퍼에 직접 값 쓰기 (Marshal.WriteByte)
for(int y = 0; y < i64Height; y++)
{
  for(int x = 0; x < i64Width; x++)
  {
    for(int c = 0; c < i32Channels; c++)
    {
      int i = (int)((y * i64Width) + x) * i32Channels + c;
      int offset = i * byteDepth;

      // float (4 bytes)
      Marshal.Copy(pBuffer + offset, buffer, 0, 4);

      // x 번째 픽셀값에 0.5를 곱하여 어둡게 만들기
      byte[] newBytes = BitConverter.GetBytes(BitConverter.ToSingle(buffer, 0) * 0.5f);
      Marshal.Copy(newBytes, 0, pBuffer + offset, 4);
    }
  }
}

# 이미지 로드
fli = CFLImage()
res = fli.Load("D:/C4_F32_Image.flif")

# 기본 정보
pBuffer = fli.GetBufferPtr()  # IntPtr
depth = fli.GetDepth()        # 32 (float)
byte_depth = depth // 8       # 4
value_type = fli.GetValueType()

width = fli.GetWidth()
height = fli.GetHeight()
channels = fli.GetChannels()

# 전체 픽셀 순회
for y in range(height):
  for x in range(width):
    for c in range(channels):
      i = ((y * width) + x) * channels + c
      offset = i * byte_depth

      # 버퍼에서 float32 4바이트 읽기
      raw_ptr = int(pBuffer.ToInt64()) + offset
      float_bytes = ctypes.string_at(raw_ptr, 4)
      value = struct.unpack('<f', float_bytes)[0]

      # 0.5 곱하기
      new_value = value * 0.5
      new_bytes = struct.pack('<f', new_value)

      # 다시 버퍼에 쓰기
      ctypes.memmove(raw_ptr, new_bytes, 4)

CFLImage fli;
// 4채널 32비트 floating point 이미지 로드
fli.Load(L"D:\\C4_F32_Image.png");

// 각 줄의 시작 주소 테이블
uint8_t** pU8YOffsetTable = fli.GetYOffsetTable();
// 각 픽셀의 시작 위치 오프셋 테이블
int64_t* pU64XOffsetTable = fli.GetXOffsetTable();
// 이미지 버퍼
uint8_t* pU8Buffer = fli.GetBuffer();

for(int64_t y = 0; y < fli.GetHeight(); ++y)
{
	// YOffsetTable을 통해 y 번째 줄의 시작 주소를 얻기
	uint8_t* pU8CurrY = pU8YOffsetTable[y];

	for(int64_t x = 0; x < fli.GetWidth(); ++x)
	{
		// XOffsetTable을 통해 x 번째 픽셀의 시작 주소를 얻기
    // 로드한 이미지는 f32 타입의 이미지이므로 float으로 캐스팅
		float* pF32CurrPixelValue = (float*)(pU8CurrY + pU64XOffsetTable[x]);

    // 로드한 이미지는 4채널 이미지이므로
		// x 번째 픽셀의 0, 1, 2 채널 값에 0.5를 곱하여 어둡게 만들기
		pF32CurrPixelValue[0] = pF32CurrPixelValue[0] * 0.5f;
		pF32CurrPixelValue[1] = pF32CurrPixelValue[1] * 0.5f;
		pF32CurrPixelValue[2] = pF32CurrPixelValue[2] * 0.5f;
	}
}

// 현재 C#에서 지원하지 않는 기능입니다.

# 현재 Python에서 지원하지 않는 기능입니다.

// CFLImage 객체 생성
CFLImage fli;

// 멀티페이지 이미지 로드
if (fli.Load(L"multi_page_image.flif").IsFail())
    return;
  
fli.ClearPage(2); // 2번 페이지 버퍼 및 정보를 클리어

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 멀티페이지 이미지 로드
if (fli.Load("multi_page_image.flif").IsFail())
    return;
  
fli.ClearPage(2); // 2번 페이지 버퍼 및 정보를 클리어

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("multi_page_image.flif").IsFail():
  return
  
fli.ClearPage(2) # 2번 페이지 버퍼 및 정보를 클리어

// CFLImage 객체 생성
CFLImage fli;

// 멀티페이지 이미지 로드
if (fli.Load(L"multi_page_image.flif").IsFail())
    return;
  
fli.RemovePage(2); // 2번 페이지를 제거

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 멀티페이지 이미지 로드
if (fli.Load("multi_page_image.flif").IsFail())
    return;
  
fli.RemovePage(2); // 2번 페이지를 제거

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("multi_page_image.flif").IsFail():
  return
  
# 2번 페이지를 제거
fli.RemovePage(2) 

// CFLImage 객체 생성
CFLImage fli;

// 멀티페이지 이미지 로드
if (fli.Load(L"multi_page_image.flif").IsFail())
    return;

// 제거할 페이지 인덱스 지정 (0-based 인덱스)
CFLArray<int32_t> flaPageIndex;
flaPageIndex.PushBack(2);
flaPageIndex.PushBack(3);
flaPageIndex.PushBack(4);

// RemovePages 호출
fli.RemovePages(flaPageIndex); // 2, 3, 4번 페이지를 제거

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 멀티페이지 이미지 로드
if(fli.Load("multi_page_image.flif").IsFail())
  return;

// 제거할 페이지 인덱스 지정 (0-based 인덱스)
List<int> pageIndicesToRemove = new List<int> { 2, 3, 4 }; // 2, 3, 4번 페이지를 제거

// RemovePages 호출
fli.RemovePages(pageIndicesToRemove);

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("multi_page_image.flif").IsFail():
  return

# 제거할 페이지 인덱스 지정 (0-based 인덱스)
indices_to_remove = List[int]()
# 2, 3, 4번 페이지를 제거
indices_to_remove.Add(2)
indices_to_remove.Add(3)
indices_to_remove.Add(4)  

# RemovePages 호출
fli.RemovePages(indices_to_remove)

// CFLImage 객체 생성
CFLImage fli;
int32_t i32W = 128; // 이미지 너비
int32_t i32H = 128; // 이미지 높이

// 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, CMultiVarUL(222), EPixelFormat_C1_U8);

// CFLImage 객체 생성
CFLImage fli = new CFLImage();
int i32W = 128; // 이미지 너비
int i32H = 128; // 이미지 높이

// 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, new CMultiVar<double>(222), EPixelFormat.C1_U8);

# CFLImage 객체 생성
fli = CFLImage()

i32W = 128 # 이미지 너비
i32H = 128 # 이미지 높이

# 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, CMultiVar[Double](222), EPixelFormat.C1_U8)

// CFLImage 객체 생성
CFLImage fli;
int32_t i32W = 128; // 이미지 너비
int32_t i32H = 128; // 이미지 높이
int32_t i32Channel = 3; // 이미지 채널
uint8_t* pU8Buffer = new uint8_t[i32W * i32H * i32Channel];

for(int32_t y = 0; y < i32H; ++y)
{
    uint8_t* pU8CurrBuffer = pU8Buffer + y * i32W * i32Channel;

    for(int32_t x = 0; x < i32W; ++x)
    {
        float f32Ratio = (float)x / (float)i32W;
        *pU8CurrBuffer = (uint8_t)(f32Ratio * 255.f); // Blue
        *(pU8CurrBuffer + 1) = 200; // Green
        *(pU8CurrBuffer + 2) = 255 - (uint8_t)(f32Ratio * 255.f); // Red

        pU8CurrBuffer += 3;
    }
}

// 이미지 생성
fli.Create(i32W, i32H, pU8Buffer, EPixelFormat_C3_U8);

// CFLImage 객체 생성
CFLImage fli = new CFLImage();
int i32W = 128; // 이미지 너비
int i32H = 128; // 이미지 높이
int i32Channel = 3; // 이미지 채널

// unmanaged 메모리 할당 (IntPtr로 받음)
IntPtr ptr = Marshal.AllocHGlobal(i32W * i32H * i32Channel);

// 버퍼에 직접 값 쓰기 (Marshal.WriteByte)
for(int y = 0; y < i32H; y++)
{
  for(int x = 0; x < i32W; x++)
  {
    float ratio = (float)x / i32W;
    int offset = (y * i32W + x) * i32Channel;

    Marshal.WriteByte(ptr, offset, (byte)(ratio * 255));              // Blue
    Marshal.WriteByte(ptr, offset + 1, 200);                          // Green
    Marshal.WriteByte(ptr, offset + 2, (byte)(255 - ratio * 255));    // Red
  }
}

// 이미지 생성
fli.Create(i32W, i32H, ref ptr, EPixelFormat.C3_U8);

// 해제
Marshal.FreeHGlobal(ptr);

import ctypes

# CFLImage 객체 생성
fli = CFLImage()

# 이미지 설정
i32W = 128
i32H = 128
i32Channels = 3

# ctypes 버퍼 생성 (연속 메모리 할당)
buffer = (ctypes.c_ubyte * (i32W * i32H * i32Channels))()

# 버퍼 데이터 채우기 (BGR 순서)
for y in range(i32H):
  for x in range(i32W):
    ratio = x / i32W
    offset = (y * i32W + x) * i32Channels
    buffer[offset] = int(ratio * 255)        # Blue
    buffer[offset + 1] = 200                 # Green
    buffer[offset + 2] = 255 - int(ratio * 255)  # Red

# ctypes 포인터 → System.IntPtr
ptr_value = ctypes.cast(buffer, ctypes.c_void_p).value
intptr = IntPtr(ptr_value)

# 이미지 생성
fli.Create(Int64(i32W), Int64(i32H), intptr, EPixelFormat.C3_U8)

// CFLImage 객체 생성
CFLImage fli;

// 멀티페이지 이미지 로드
if (fli.Load(L"multi_page_image.flif").IsFail())
    return;

// 페이지 생성
fli.CreatePage(1); // insert index = 1

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 멀티페이지 이미지 로드
if(fli.Load("multi_page_image.flif").IsFail())
  return;

// 페이지 생성
fli.CreatePage(1); // insert index = 1

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("multi_page_image.flif").IsFail():
  return

# 페이지 생성
fli.CreatePage(1) # insert index = 1

// CFLImage 객체 생성
CFLImage fli;

// 멀티페이지 이미지 로드
if (fli.Load(L"multi_page_image.flif").IsFail())
    return;

// 페이지 생성
fli.CreatePage(1); // insert index = 1

// 1번 페이지 선택
int32_t i32PageIndex = 1;
fli.SelectPage(i32PageIndex);

int32_t i32W = 128; // 이미지 너비
int32_t i32H = 128; // 이미지 높이

// 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, CMultiVarUL(222), EPixelFormat_C1_U8);

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 멀티페이지 이미지 로드
if(fli.Load("multi_page_image.flif").IsFail())
  return;

// 페이지 생성
fli.CreatePage(1); // insert index = 1

// 1번 페이지 선택
int i32PageIndex = 1;
fli.SelectPage(i32PageIndex);

int i32W = 128; // 이미지 너비
int i32H = 128; // 이미지 높이

// 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, new CMultiVar<double>(222), EPixelFormat.C1_U8);

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("multi_page_image.flif").IsFail():
  return

# 페이지 생성
fli.CreatePage(1) # insert index = 1

# 1번 페이지 선택
i32PageIndex = 1
fli.SelectPage(i32PageIndex)

i32W = 128 # 이미지 너비
i32H = 128 # 이미지 높이

# 1채널 uint8 포맷으로 이미지를 생성 및 모든 픽셀 값을 222로 채우기
fli.Create(i32W, i32H, CMultiVar[Double](222), EPixelFormat.C1_U8)

// CFLImage 객체 생성
CFLImage fli;

// 이미지 로드
if (fli.Load(L"D://Image.png").IsFail())
    return;

// 도형 정의(사각형)
CFLRect<int32_t> flrB(169, 113, 240, 196);
flrB.SetName(L"B"); // label 설정
CFLRect<int32_t> flrC(50, 283, 121, 365);
flrC.SetName(L"C"); // label 설정

// 이미지에 도형과 label 추가
fli.PushBackFigure(CFigureUtilities::ConvertFigureObjectToString(flrB));
fli.PushBackFigure(CFigureUtilities::ConvertFigureObjectToString(flrC));

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 이미지 로드
if(fli.Load("D://Image.png").IsFail())
  return;

// 도형 정의(사각형)
CFLRect<int> flrB = new CFLRect<int>(169, 113, 240, 196);
flrB.SetName("B"); // label 설정
CFLRect<int> flrC = new CFLRect<int>(50, 283, 121, 365);
flrC.SetName("C"); // label 설정

// 이미지에 도형과 label 추가
fli.PushBackFigure(CFigureUtilities.ConvertFigureObjectToString(flrB));
fli.PushBackFigure(CFigureUtilities.ConvertFigureObjectToString(flrC));

# CFLImage 객체 생성
fli = CFLImage()

# 멀티페이지 이미지 로드
if fli.Load("D://Image.png").IsFail():
  return

# 도형 정의(사각형)
flrB = CFLRect[Int32](169, 113, 240, 196)
flrB.SetName("B") # label 설정
flrC = CFLRect[Int32](50, 283, 121, 365)
flrC.SetName("C") # label 설정

# 이미지에 도형과 label 추가
fli.PushBackFigure(CFigureUtilities.ConvertFigureObjectToString(flrB))
fli.PushBackFigure(CFigureUtilities.ConvertFigureObjectToString(flrC))

// 도형 정의(사각형)
CFLRect<int32_t> flrA(72, 46, 143, 128);
flrA.SetName(L"A");// label 설정

// 0번 인덱스에 도형과 label 추가
fli.InsertFigureAt(0, CFigureUtilities::ConvertFigureObjectToString(flrA));

// 도형 정의(사각형)
CFLRect<int> flrA = new CFLRect<int>(72, 46, 143, 128);
flrA.SetName("A"); // label 설정

// 0번 인덱스에 도형과 label 추가
fli.InsertFigureAt(0, CFigureUtilities.ConvertFigureObjectToString(flrA));

# 도형 정의(사각형)
flrA = CFLRect[Int32](72, 46, 143, 128)
flrA.SetName("A") # label 설정

# 0번 인덱스에 도형과 label 추가
fli.InsertFigureAt(0, CFigureUtilities.ConvertFigureObjectToString(flrA))

// 1번 인덱스 도형을 삭제
fli.DeleteFigureAt(1);

// 1번 인덱스 도형을 삭제
fli.DeleteFigureAt(1);

# 1번 인덱스 도형을 삭제
fli.DeleteFigureAt(1)

// 현재 선택된 페이지 안의 모든 도형을 삭제
fli.ClearFigures();
// 3번 페이지 안의 모든 도형을 삭제
fli.ClearFigures(3);
// 모든 페이지에서 도형을 전부 삭제
fli.ClearFiguresAllPages();

// 현재 선택된 페이지 안의 모든 도형을 삭제
fli.ClearFigures();
// 3번 페이지 안의 모든 도형을 삭제
fli.ClearFigures(3);
// 모든 페이지에서 도형을 전부 삭제
fli.ClearFiguresAllPages();

# 현재 선택된 페이지 안의 모든 도형을 삭제
fli.ClearFigures()
# 3번 페이지 안의 모든 도형을 삭제
fli.ClearFigures(3)
# 모든 페이지에서 도형을 전부 삭제
fli.ClearFiguresAllPages()

CFLRegion flrg;
flrg.PushBack(CFLPoint<double>(75.4, 123.0));
flrg.PushBack(CFLPoint<double>(106.9, 38.0));
flrg.PushBack(CFLPoint<double>(140.9, 121.7));
flrg.SetName(L"A");
// 0번 인덱스 도형을 변경
fli.SetFigureAt(0, CFigureUtilities::ConvertFigureObjectToString(flrg));

// 도형 정의(다각형)
CFLRegion flrg = new CFLRegion();
flrg.PushBack(new CFLPoint<double>(75.4, 123.0));
flrg.PushBack(new CFLPoint<double>(106.9, 38.0));
flrg.PushBack(new CFLPoint<double>(140.9, 121.7));
flrg.SetName("A");

// 0번 인덱스 도형을 변경
fli.SetFigureAt(0, CFigureUtilities.ConvertFigureObjectToString(flrg));

# 도형 정의(다각형)
flrg = CFLRegion()
flrg.PushBack(CFLPoint[Double](75.4, 123.0))
flrg.PushBack(CFLPoint[Double](106.9, 38.0))
flrg.PushBack(CFLPoint[Double](140.9, 121.7))
flrg.SetName("A")

# 0번 인덱스 도형을 변경
fli.SetFigureAt(0, CFigureUtilities.ConvertFigureObjectToString(flrg))

// 이미지에 저장된 도형 개수만큼 loop 반복
for(int32_t i = 0; i < fli.GetFigureCount(); i++)
{
    // i 번째 도형 얻어 오기
    CFLFigure* pFlf = CFigureUtilities::ConvertFigureStringToObject(fli.GetFigure(i));

    if(!pFlf)
        continue;

    // 도형의 이름(label) 얻기
    CFLString<wchar_t> strName = pFlf->GetName();    
    // do something...

    // 메모리 해제
    delete pFlf;
    pFlf = nullptr;
}

// 이미지에 저장된 도형 개수만큼 loop 반복
for(int i = 0; i < fli.GetFigureCount(); i++)
{
  // i 번째 도형 얻어 오기
  CFLFigure pFlf = CFigureUtilities.ConvertFigureStringToObject(fli.GetFigure(i));

  if(pFlf == null)
    continue;

  // 도형의 이름(label) 얻기
  String strName = pFlf.GetName();
  // do something...
}

# 이미지에 저장된 도형 개수만큼 loop 반복
for i in range (0, fli.GetFigureCount()):
  # i 번째 도형 얻어 오기
  pFlf = CFigureUtilities.ConvertFigureStringToObject(fli.GetFigure(i))

  if pFlf == None:
    continue

  # 도형의 이름(label) 얻기
  strName = pFlf.GetName()
  # do something...

// CFLImage 객체 생성
CFLImage fli;

// 이미지 로드
fli.Load(L"D://Image.png");

// 이미지의 Extra Data 개수만큼 loop 반복
for(int32_t i = 0; i < fli.GetExtraDataCount(); i++)
{
    // i번째 Extra Data 얻기
    CFLImageExtraDataBase* pEd = fli.GetExtraData(i);

    if(!pEd)
        continue;

    // Extra Data의 타입 얻기
    EImageExtraDataType eExtraDataType = pEd->GetExtraDataType();

    switch(eExtraDataType)
    {      
    // Fourier transform 이미지에 대한 추가 정보
    case FLImaging::Base::EImageExtraDataType_FourierTransform:
        {
            CFLImageExtraDataFT* pExtraDataFT = dynamic_cast<CFLImageExtraDataFT*>(pEd);

            if(!pExtraDataFT)
                break;

            int64_t i64OrigW = pExtraDataFT->GetOriginalWidth();
            int64_t i64OrigH = pExtraDataFT->GetOriginalHeight();
            EPixelFormat ePFOrig = pExtraDataFT->GetOriginalPixelFormat();
            bool bShiftState = pExtraDataFT->GetShiftState();
            double f64MaxVal = pExtraDataFT->GetMaxValue();
        }
        break;
    // Real-valued Fourier transform 이미지에 대한 추가 정보
    case FLImaging::Base::EImageExtraDataType_RealValuedFourierTransform:
        {
            CFLImageExtraDataRFT* pExtraDataRFT = dynamic_cast<CFLImageExtraDataRFT*>(pEd);

            if(!pExtraDataRFT)
                break;

            int64_t i64OrigW = pExtraDataRFT->GetOriginalWidth();
            int64_t i64OrigH = pExtraDataRFT->GetOriginalHeight();
            EPixelFormat ePFOrig = pExtraDataRFT->GetOriginalPixelFormat();
            bool bShiftState = pExtraDataRFT->GetShiftState();
            double f64MaxVal = pExtraDataRFT->GetMaxValue();
        }
        break;
    // 이미지의 컬러에 대한 추가 정보
    case FLImaging::Base::EImageExtraDataType_Color:
        {
            CFLImageExtraDataColor* pExtraDataColor = dynamic_cast<CFLImageExtraDataColor*>(pEd);

            if(!pExtraDataColor)
                break;

            EColorSequence eCS = pExtraDataColor->GetColorSequence();
        }
        break;
    // Discrete Wavelet Transform 에 대한 추가 정보
    case FLImaging::Base::EImageExtraDataType_DiscreteWaveletTransform:
        {
            CFLImageExtraDataWT* pExtraDataWT = dynamic_cast<CFLImageExtraDataWT*>(pEd);

            if(!pExtraDataWT)
                break;

            int64_t i64OrigW = pExtraDataWT->GetOriginalWidth();
            int64_t i64OrigH = pExtraDataWT->GetOriginalHeight();
            EPixelFormat ePFOrig = pExtraDataWT->GetOriginalPixelFormat();
            int32_t i32AlignByte = pExtraDataWT->GetOriginalAlignByte();
            int64_t i64WSB = pExtraDataWT->GetOriginalWidthStepByte();
            int64_t i64DecompositionLevel = pExtraDataWT->GetDecompositionLevel();
            int32_t i32BasisFunction = pExtraDataWT->GetBasisFunction();
        }
        break;
    // Discrete Cosine Transform 에 대한 추가 정보
    case FLImaging::Base::EImageExtraDataType_DiscreteCosineTransform:
        {
            CFLImageExtraDataCT* pExtraDataCT = dynamic_cast<CFLImageExtraDataCT*>(pEd);

            if(!pExtraDataCT)
                break;

            int64_t i64OrigW = pExtraDataCT->GetOriginalWidth();
            int64_t i64OrigH = pExtraDataCT->GetOriginalHeight();
            EPixelFormat ePFOrig = pExtraDataCT->GetOriginalPixelFormat();
            int32_t i32AlignByte = pExtraDataCT->GetOriginalAlignByte();
            int64_t i64WSB = pExtraDataCT->GetOriginalWidthStepByte();
            double f64MaxVal = pExtraDataCT->GetMaxValue();
        }
        break;
    }
}

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 이미지 로드
if(fli.Load("D://Image.png").IsFail())
  return;

// 이미지의 Extra Data 개수만큼 loop 반복
for(int i = 0; i < fli.GetExtraDataCount(); i++)
{
  // i번째 Extra Data 얻기
  CFLImageExtraDataBase pEd = fli.GetExtraData(i);

  if(pEd == null)
    continue;

  // Extra Data의 타입 얻기
  EImageExtraDataType eExtraDataType = pEd.GetExtraDataType();

  switch(eExtraDataType)
  {
  // Fourier transform 이미지에 대한 추가 정보
  case EImageExtraDataType.FourierTransform:
    {
      CFLImageExtraDataFT pExtraDataFT = pEd as CFLImageExtraDataFT;

      if(pExtraDataFT == null)
        break;

      long i64OrigW = pExtraDataFT.GetOriginalWidth();
      long i64OrigH = pExtraDataFT.GetOriginalHeight();
      EPixelFormat ePFOrig = pExtraDataFT.GetOriginalPixelFormat();
      bool bShiftState = pExtraDataFT.GetShiftState();
      double f64MaxVal = pExtraDataFT.GetMaxValue();
    }
    break;
  // Real-valued Fourier transform 이미지에 대한 추가 정보
  case EImageExtraDataType.RealValuedFourierTransform:
    {
      CFLImageExtraDataRFT pExtraDataRFT = pEd as CFLImageExtraDataRFT;

      if(pExtraDataRFT == null)
        break;

      long i64OrigW = pExtraDataRFT.GetOriginalWidth();
      long i64OrigH = pExtraDataRFT.GetOriginalHeight();
      EPixelFormat ePFOrig = pExtraDataRFT.GetOriginalPixelFormat();
      bool bShiftState = pExtraDataRFT.GetShiftState();
      double f64MaxVal = pExtraDataRFT.GetMaxValue();
    }
    break;
  // 이미지의 컬러에 대한 추가 정보
  case EImageExtraDataType.Color:
    {
      CFLImageExtraDataColor pExtraDataColor = pEd as CFLImageExtraDataColor;

      if(pExtraDataColor == null)
        break;

      EColorSequence eCS = pExtraDataColor.GetColorSequence();
    }
    break;
  // Discrete Wavelet Transform 에 대한 추가 정보
  case EImageExtraDataType.DiscreteWaveletTransform:
    {
      CFLImageExtraDataWT pExtraDataWT = pEd as CFLImageExtraDataWT;

      if(pExtraDataWT == null)
        break;

      long i64OrigW = pExtraDataWT.GetOriginalWidth();
      long i64OrigH = pExtraDataWT.GetOriginalHeight();
      EPixelFormat ePFOrig = pExtraDataWT.GetOriginalPixelFormat();
      int i32AlignByte = pExtraDataWT.GetOriginalAlignByte();
      long i64WSB = pExtraDataWT.GetOriginalWidthStepByte();
      long i64DecompositionLevel = pExtraDataWT.GetDecompositionLevel();
      int i32BasisFunction = pExtraDataWT.GetBasisFunction();
    }
    break;
  // Discrete Cosine Transform 에 대한 추가 정보
  case EImageExtraDataType.DiscreteCosineTransform:
    {
      CFLImageExtraDataCT pExtraDataCT = pEd as CFLImageExtraDataCT;

      if(pExtraDataCT == null)
        break;

      long i64OrigW = pExtraDataCT.GetOriginalWidth();
      long i64OrigH = pExtraDataCT.GetOriginalHeight();
      EPixelFormat ePFOrig = pExtraDataCT.GetOriginalPixelFormat();
      int i32AlignByte = pExtraDataCT.GetOriginalAlignByte();
      long i64WSB = pExtraDataCT.GetOriginalWidthStepByte();
      double f64MaxVal = pExtraDataCT.GetMaxValue();
    }
    break;
  }
}

# CFLImage 객체 생성
fli = CFLImage()

# 이미지 로드
if fli.Load("D://Image.png").IsFail():
  return

# 이미지의 Extra Data 개수만큼 loop 반복
for i in range(0, fli.GetExtraDataCount()):
  # i번째 Extra Data 얻기
  pEd = fli.GetExtraData(i)

  if pEd == None:
    continue

  # Extra Data의 타입 얻기
  eExtraDataType = pEd.GetExtraDataType()
  
  # Fourier transform 이미지에 대한 추가 정보
  if eExtraDataType == EImageExtraDataType.FourierTransform:
    pExtraDataFT = CFLImageExtraDataFT(pEd)

    if pExtraDataFT == None:
      break

    i64OrigW = pExtraDataFT.GetOriginalWidth()
    i64OrigH = pExtraDataFT.GetOriginalHeight()
    ePFOrig = pExtraDataFT.GetOriginalPixelFormat()
    bShiftState = pExtraDataFT.GetShiftState()
    f64MaxVal = pExtraDataFT.GetMaxValue()

  # Real-valued Fourier transform 이미지에 대한 추가 정보
  elif eExtraDataType == EImageExtraDataType.RealValuedFourierTransform:
    pExtraDataRFT = CFLImageExtraDataRFT(pEd)

    if pExtraDataRFT == None:
      break

    i64OrigW = pExtraDataRFT.GetOriginalWidth()
    i64OrigH = pExtraDataRFT.GetOriginalHeight()
    ePFOrig = pExtraDataRFT.GetOriginalPixelFormat()
    bShiftState = pExtraDataRFT.GetShiftState()
    f64MaxVal = pExtraDataRFT.GetMaxValue()
    
  # 이미지의 컬러에 대한 추가 정보
  elif eExtraDataType == EImageExtraDataType.Color:
    pExtraDataColor = CFLImageExtraDataColor(pEd)

    if pExtraDataColor == None:
      break

    eCS = pExtraDataColor.GetColorSequence()
    
  # Discrete Wavelet Transform 에 대한 추가 정보
  elif eExtraDataType == EImageExtraDataType.DiscreteWaveletTransform:
    pExtraDataWT = CFLImageExtraDataWT(pEd)

    if pExtraDataWT == None:
      break

    i64OrigW = pExtraDataWT.GetOriginalWidth()
    i64OrigH = pExtraDataWT.GetOriginalHeight()
    ePFOrig = pExtraDataWT.GetOriginalPixelFormat()
    i32AlignByte = pExtraDataWT.GetOriginalAlignByte()
    i64WSB = pExtraDataWT.GetOriginalWidthStepByte()
    i64DecompositionLevel = pExtraDataWT.GetDecompositionLevel()
    i32BasisFunction = pExtraDataWT.GetBasisFunction()
    
  # Discrete Cosine Transform 에 대한 추가 정보
  elif eExtraDataType == EImageExtraDataType.DiscreteCosineTransform:
    pExtraDataCT = CFLImageExtraDataCT(pEd)

    if pExtraDataCT == None:
      break

    i64OrigW = pExtraDataCT.GetOriginalWidth()
    i64OrigH = pExtraDataCT.GetOriginalHeight()
    ePFOrig = pExtraDataCT.GetOriginalPixelFormat()
    i32AlignByte = pExtraDataCT.GetOriginalAlignByte()
    i64WSB = pExtraDataCT.GetOriginalWidthStepByte()
    f64MaxVal = pExtraDataCT.GetMaxValue()

// CFLImage 객체 생성
CFLImage fli;

// 이미지 로드
fli.Load(L"D://Image.png");

// 이미지의 채널 얻어 오기
int32_t i32Channel = fli.GetChannels();

// Extra data 선언
CFLImageExtraDataColor extDataColor;

// Extra data 설정
if(i32Channel == 4)
    extDataColor.SetColorSequence(EColorSequence_RGBA);
else if(i32Channel == 3)
    extDataColor.SetColorSequence(EColorSequence_RGB);

// Extra data를 이미지에 추가
fli.AddExtraData(extDataColor);

// CFLImage 객체 생성
CFLImage fli = new CFLImage();

// 이미지 로드
if(fli.Load("D://Image.png").IsFail())
  return;

// 이미지의 채널 얻어 오기
int i32Channel = fli.GetChannels();

// Extra data 선언
CFLImageExtraDataColor extDataColor = new CFLImageExtraDataColor();

// Extra data 설정
if(i32Channel == 4)
  extDataColor.SetColorSequence(EColorSequence.RGBA);
else if(i32Channel == 3)
  extDataColor.SetColorSequence(EColorSequence.RGB);

// Extra data를 이미지에 추가
fli.AddExtraData(extDataColor);

# CFLImage 객체 생성
fli = CFLImage()

# 이미지 로드
if fli.Load("D://Image.png").IsFail():
  return
      
# 이미지의 채널 얻어 오기
i32Channel = fli.GetChannels()

# Extra data 선언
extDataColor = CFLImageExtraDataColor()

# Extra data 설정
if i32Channel == 4:
  extDataColor.SetColorSequence(EColorSequence.RGBA)
elif i32Channel == 3:
  extDataColor.SetColorSequence(EColorSequence.RGB)

# Extra data를 이미지에 추가
fli.AddExtraData(extDataColor)

// 현재 선택된 페이지에서 0번째 Extra data를 제거
fli.DeleteExtraData(0);
// 현재 선택된 페이지에서 Extra data를 모두 제거
fli.ClearExtraData();

// 현재 선택된 페이지에서 0번째 Extra data를 제거
fli.DeleteExtraData(0);
// 현재 선택된 페이지에서 Extra data를 모두 제거
fli.ClearExtraData();

# 현재 선택된 페이지에서 0번째 Extra data를 제거
fli.DeleteExtraData(0)
# 현재 선택된 페이지에서 Extra data를 모두 제거
fli.ClearExtraData()