You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1474 lines
59 KiB
1474 lines
59 KiB
#!/usr/bin/python
|
|
# -*- coding:utf-8 -*-
|
|
# -*-mode:python ; tab-width:4 -*- ex:set tabstop=4 shiftwidth=4 expandtab: -*-
|
|
#
|
|
|
|
from ctypes import *
|
|
import sys
|
|
import os
|
|
|
|
if sys.platform == 'linux2' or sys.platform == 'linux':
|
|
if os.path.exists('/usr/lib/libdximageproc.so') :
|
|
filepath = '/usr/lib/libdximageproc.so'
|
|
else:
|
|
filepath = '/usr/lib/libgxiapi.so'
|
|
try:
|
|
dll = CDLL(filepath)
|
|
except OSError:
|
|
print('Cannot find libdximageproc.so or libgxiapi.so.')
|
|
else:
|
|
try:
|
|
if (sys.version_info.major == 3 and sys.version_info.minor >= 8) or (sys.version_info.major > 3):
|
|
dll = WinDLL('DxImageProc.dll', winmode=0)
|
|
else:
|
|
dll = WinDLL('DxImageProc.dll')
|
|
except OSError:
|
|
print('Cannot find DxImageProc.dll.')
|
|
|
|
def string_encoding(string):
|
|
"""
|
|
:breif Python3.X: String encoded as bytes
|
|
:param string
|
|
:return:
|
|
"""
|
|
if sys.version_info.major == 3:
|
|
string = string.encode()
|
|
return string
|
|
|
|
# image format handle
|
|
class DxImageFormatConvertHandle:
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
# status definition
|
|
class DxStatus:
|
|
OK = 0 # Operation is successful
|
|
PARAMETER_INVALID = -101 # Invalid input parameter
|
|
PARAMETER_OUT_OF_BOUND = -102 # The input parameter is out of bounds
|
|
NOT_ENOUGH_SYSTEM_MEMORY = -103 # System out of memory
|
|
NOT_FIND_DEVICE = -104 # not find device
|
|
STATUS_NOT_SUPPORTED = -105 # operation is not supported
|
|
CPU_NOT_SUPPORT_ACCELERATE = -106 # CPU does not support acceleration
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
# Bayer layout
|
|
class DxPixelColorFilter:
|
|
NONE = 0 # Isn't bayer format
|
|
RG = 1 # The first row starts with RG
|
|
GB = 2 # The first line starts with GB
|
|
GR = 3 # The first line starts with GR
|
|
BG = 4 # The first line starts with BG
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
|
|
# image actual bits
|
|
class DxActualBits:
|
|
BITS_8 = 8 # 8bit
|
|
BITS_10 = 10 # 10bit
|
|
BITS_12 = 12 # 12bit
|
|
BITS_14 = 14 # 14bit
|
|
BITS_16 = 16 # 16bit
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
# image mirror method
|
|
class DxImageMirrorMethod:
|
|
HORIZONTAL_MIRROR = 0
|
|
VERTICAL_MIRROR = 1
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
# mono8 image process structure
|
|
class MonoImgProcess(Structure):
|
|
_fields_ = [
|
|
('defective_pixel_correct', c_bool), # Pixel correct switch
|
|
('sharpness', c_bool), # Sharpness switch
|
|
('accelerate', c_bool), # Accelerate switch
|
|
('sharp_factor', c_float), # Sharpen the intensity factor
|
|
('pro_lut', c_void_p), # Lookup table
|
|
('lut_length', c_uint16), # Lut Buffer length
|
|
('array_reserved', c_ubyte * 32), # Reserved
|
|
]
|
|
|
|
def __str__(self):
|
|
return "MonoImgProcess\n%s" % "\n".join("%s:\t%s" % (n, getattr(self, n[0])) for n in self._fields_)
|
|
|
|
|
|
# Raw8 Image process structure
|
|
class ColorImgProcess(Structure):
|
|
_fields_ = [
|
|
('defective_pixel_correct', c_bool), # Pixel correct switch
|
|
('denoise', c_bool), # Noise reduction switch
|
|
('sharpness', c_bool), # Sharpness switch
|
|
('accelerate', c_bool), # Accelerate switch
|
|
('arr_cc', c_void_p), # Color processing parameters
|
|
('cc_buf_length', c_uint8), # Color processing parameters length(sizeof(VxInt16)*9)
|
|
('sharp_factor', c_float), # Sharpen the intensity factor
|
|
('pro_lut', c_void_p), # Lookup table
|
|
('lut_length', c_uint16), # The length of the lookup table
|
|
('cv_type', c_uint), # Interpolation algorithm
|
|
('layout', c_uint), # Bayer format
|
|
('flip', c_bool), # Image flip flag
|
|
('array_reserved', c_ubyte * 32), # Reserved
|
|
]
|
|
|
|
def __str__(self):
|
|
return "ColorImgProcess\n%s" % "\n".join("%s:\t%s" % (n, getattr(self, n[0])) for n in self._fields_)
|
|
|
|
|
|
# Field correction process structure
|
|
class FieldCorrectionProcess(Structure):
|
|
_fields_ = [
|
|
('bright_buf', c_void_p), # Bright image buffer
|
|
('dark_buf', c_void_p), # Dark image buffer
|
|
('width', c_uint32), # image width
|
|
('height', c_uint32), # image height
|
|
('actual_bits', c_uint), # image actual bits
|
|
('bayer_type', c_uint), # Bayer Type
|
|
]
|
|
|
|
def __str__(self):
|
|
return "FieldCorrectionProcess\n%s" % "\n".join("%s:\t%s" % (n, getattr(self, n[0])) for n in self._fields_)
|
|
|
|
|
|
# color transform factor
|
|
class ColorTransformFactor(Structure):
|
|
_fields_ = [
|
|
('fGain00', c_float), # red contribution to the red pixel (multiplicative factor)
|
|
('fGain01', c_float), # green contribution to the red pixel (multiplicative factor)
|
|
('fGain02', c_float), # blue contribution to the red pixel (multiplicative factor)
|
|
('fGain10', c_float), # red contribution to the green pixel (multiplicative factor)
|
|
('fGain11', c_float), # green contribution to the green pixel (multiplicative factor)
|
|
('fGain12', c_float), # blue contribution to the green pixel (multiplicative factor)
|
|
('fGain20', c_float), # red contribution to the blue pixel (multiplicative factor)
|
|
('fGain21', c_float), # green contribution to the blue pixel (multiplicative factor)
|
|
('fGain22', c_float), # blue contribution to the blue pixel (multiplicative factor)
|
|
]
|
|
|
|
def __str__(self):
|
|
return "ColorTransformFactor\n%s" % "\n".join("%s:\t%s" % (n, getattr(self, n[0])) for n in self._fields_)
|
|
|
|
# Field correction process structure
|
|
class StaticDefectCorrection(Structure):
|
|
_fields_ = [
|
|
('width', c_uint32), # image width
|
|
('height', c_uint32), # image height
|
|
('OffsetX', c_uint32), # image off x
|
|
('OffSetY', c_uint32), # image off y
|
|
('WidthMax', c_uint32), # image width max
|
|
('bayer_type', c_uint), # Bayer Type
|
|
('actual_bits', c_uint), # image actual bits
|
|
]
|
|
|
|
def __str__(self):
|
|
return "FieldCorrectionProcess\n%s" % "\n".join("%s:\t%s" % (n, getattr(self, n[0])) for n in self._fields_)
|
|
|
|
if hasattr(dll, 'DxGetLut'):
|
|
def dx_get_lut(contrast_param, gamma, lightness):
|
|
"""
|
|
:brief calculating lookup table of 8bit image
|
|
:param contrast_param: contrast param,range(-50~100)
|
|
:param gamma: gamma param,range(0.1~10)
|
|
:param lightness: lightness param,range(-150~150)
|
|
:return: status State return value, See detail in DxStatus
|
|
lut lookup table
|
|
lut_length lookup table length(unit:byte)
|
|
"""
|
|
contrast_param_c = c_int32()
|
|
contrast_param_c.value = contrast_param
|
|
|
|
gamma_c = c_double()
|
|
gamma_c.value = gamma
|
|
|
|
lightness_c = c_int32()
|
|
lightness_c.value = lightness
|
|
|
|
lut_length_c = c_uint16()
|
|
lut_length_c.value = 0
|
|
|
|
# Get length of the lookup table
|
|
dll.DxGetLut(contrast_param_c, gamma_c, lightness_c, None, byref(lut_length_c))
|
|
|
|
# Create buff to get LUT data
|
|
lut_c = (c_uint8 * lut_length_c.value)()
|
|
status = dll.DxGetLut(contrast_param_c, gamma_c, lightness_c, byref(lut_c), byref(lut_length_c))
|
|
|
|
return status, lut_c, lut_length_c.value
|
|
|
|
CC_PARAM_ARRAY_LEN = 18
|
|
|
|
if hasattr(dll, "DxCalcCCParam"):
|
|
def dx_calc_cc_param(color_cc_param, saturation):
|
|
"""
|
|
:brief calculating array of image processing color adjustment
|
|
:param color_cc_param: color correction param address(get from camera)
|
|
:param saturation: saturation factor,Range(0~128)
|
|
:return: status: State return value, See detail in DxStatus
|
|
cc_param: color adjustment calculating array
|
|
"""
|
|
color_cc_param_c = c_int64()
|
|
color_cc_param_c.value = color_cc_param
|
|
|
|
saturation_c = c_int16()
|
|
saturation_c.value = saturation
|
|
|
|
length_c = c_uint8()
|
|
# DxCalcCCParam length = sizeof(int16)*9 = 2 * 9 = 18
|
|
length_c.value = CC_PARAM_ARRAY_LEN
|
|
|
|
# Create buff to get cc data
|
|
cc_param_c = (c_int16 * length_c.value)()
|
|
|
|
status = dll.DxCalcCCParam(color_cc_param_c, saturation_c, byref(cc_param_c), length_c)
|
|
|
|
return status, cc_param_c
|
|
|
|
|
|
if hasattr(dll, "DxCalcUserSetCCParam"):
|
|
def dx_calc_user_set_cc_param(color_transform_factor, saturation):
|
|
"""
|
|
:brief calculating array of image processing color adjustment
|
|
:param color_transform_factor: color correction param address(user set),
|
|
type should be list or tuple, size = 3*3=9
|
|
:param saturation: saturation factor,Range(0~128)
|
|
:return: status: State return value, See detail in DxStatus
|
|
cc_param: color adjustment calculating array
|
|
"""
|
|
color_transform_factor_c = ColorTransformFactor()
|
|
color_transform_factor_c.fGain00 = color_transform_factor[0]
|
|
color_transform_factor_c.fGain01 = color_transform_factor[1]
|
|
color_transform_factor_c.fGain02 = color_transform_factor[2]
|
|
color_transform_factor_c.fGain10 = color_transform_factor[3]
|
|
color_transform_factor_c.fGain11 = color_transform_factor[4]
|
|
color_transform_factor_c.fGain12 = color_transform_factor[5]
|
|
color_transform_factor_c.fGain20 = color_transform_factor[6]
|
|
color_transform_factor_c.fGain21 = color_transform_factor[7]
|
|
color_transform_factor_c.fGain22 = color_transform_factor[8]
|
|
|
|
saturation_c = c_int16()
|
|
saturation_c.value = saturation
|
|
|
|
length_c = c_uint8()
|
|
# DxCalcCCParam length = sizeof(int16)*9 = 2 * 9 = 18
|
|
length_c.value = CC_PARAM_ARRAY_LEN
|
|
|
|
# Create buff to get cc data
|
|
cc_param_c = (c_int16 * length_c.value)()
|
|
|
|
status = dll.DxCalcUserSetCCParam(byref(color_transform_factor_c), saturation_c, byref(cc_param_c), length_c)
|
|
|
|
return status, cc_param_c
|
|
|
|
|
|
if hasattr(dll, "DxGetGammatLut"):
|
|
def dx_get_gamma_lut(gamma_param):
|
|
"""
|
|
:brief calculating gamma lookup table (RGB24)
|
|
:param gamma_param: gamma param,range(0.1 ~ 10)
|
|
:return: status: State return value, See detail in DxStatus
|
|
gamma_lut: gamma lookup table
|
|
lut_length: gamma lookup table length(unit:byte)
|
|
"""
|
|
gamma_param_c = c_double()
|
|
gamma_param_c.value = gamma_param
|
|
|
|
lut_length_c = c_int()
|
|
status = dll.DxGetGammatLut(gamma_param_c, None, byref(lut_length_c))
|
|
|
|
gamma_lut = (c_ubyte * lut_length_c.value)()
|
|
status = dll.DxGetGammatLut(gamma_param_c, byref(gamma_lut), byref(lut_length_c))
|
|
|
|
return status, gamma_lut, lut_length_c.value
|
|
|
|
|
|
if hasattr(dll, "DxGetContrastLut"):
|
|
def dx_get_contrast_lut(contrast_param):
|
|
"""
|
|
:brief ccalculating contrast lookup table (RGB24)
|
|
:param contrast_param: contrast param,range(-50 ~ 100)
|
|
:return: status: State return value, See detail in DxStatus
|
|
contrast_lut: contrast lookup table
|
|
lut_length: contrast lookup table length(unit:byte)
|
|
"""
|
|
contrast_param_c = c_int()
|
|
contrast_param_c.value = contrast_param
|
|
|
|
lut_length_c = c_int()
|
|
status = dll.DxGetContrastLut(contrast_param_c, None, byref(lut_length_c))
|
|
|
|
contrast_lut = (c_ubyte * lut_length_c.value)()
|
|
status = dll.DxGetContrastLut(contrast_param_c, byref(contrast_lut), byref(lut_length_c))
|
|
|
|
return status, contrast_lut, lut_length_c.value
|
|
|
|
|
|
if hasattr(dll, 'DxRaw8toRGB24'):
|
|
def dx_raw8_to_rgb24(input_address, output_address, width, height, convert_type, bayer_type, flip):
|
|
"""
|
|
:brief Convert Raw8 to Rgb24
|
|
:param input_address: The input raw image buff address, buff size = width * height
|
|
:param output_address: The output rgb image buff address, buff size = width * height * 3
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:param convert_type: Bayer convert type, See detail in DxBayerConvertType
|
|
:param bayer_type: pixel color filter, See detail in DxPixelColorFilter
|
|
:param flip: Output image flip flag
|
|
True: turn the image upside down
|
|
False: do not flip
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
convert_type_c = c_uint()
|
|
convert_type_c.value = convert_type
|
|
|
|
bayer_type_c = c_uint()
|
|
bayer_type_c.value = bayer_type
|
|
|
|
flip_c = c_bool()
|
|
flip_c.value = flip
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxRaw8toRGB24(input_address_p, output_address_p,
|
|
width_c, height_c, convert_type_c, bayer_type_c, flip_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, 'DxRaw8toRGB24Ex'):
|
|
def dx_raw8_to_rgb24_ex(input_address, output_address, width, height, convert_type, bayer_type, flip, channel_order):
|
|
"""
|
|
:brief Convert Raw8 to Rgb24
|
|
:param input_address: The input raw image buff address, buff size = width * height
|
|
:param output_address: The output rgb image buff address, buff size = width * height * 3
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:param convert_type: Bayer convert type, See detail in DxBayerConvertType
|
|
:param bayer_type: pixel color filter, See detail in DxPixelColorFilter
|
|
:param flip: Output image flip flag
|
|
True: turn the image upside down
|
|
False: do not flip
|
|
:param channel_order: RGB channel order of output image
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
convert_type_c = c_uint()
|
|
convert_type_c.value = convert_type
|
|
|
|
bayer_type_c = c_uint()
|
|
bayer_type_c.value = bayer_type
|
|
|
|
flip_c = c_bool()
|
|
flip_c.value = flip
|
|
|
|
channel_order_c = c_uint()
|
|
channel_order_c.value = channel_order
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxRaw8toRGB24Ex(input_address_p, output_address_p,
|
|
width_c, height_c, convert_type_c, bayer_type_c, flip_c, channel_order_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, 'DxRaw16toRaw8'):
|
|
def dx_raw16_to_raw8(input_address, out_address, width, height, valid_bits):
|
|
"""
|
|
:brief Raw16 converted to Raw8
|
|
:param input_address: The input image buff address, buff size = width * height * 2
|
|
:param out_address: The output image buff address, buff size = width * height
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:param valid_bits: Data valid digit, See detail in DxValidBit
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
valid_bits_c = c_uint()
|
|
valid_bits_c.value = valid_bits
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
out_address_p = c_void_p()
|
|
out_address_p.value = out_address
|
|
|
|
status = dll.DxRaw16toRaw8(input_address_p, out_address_p,
|
|
width_c, height_c, valid_bits_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, 'DxRotate90CW8B'):
|
|
def dx_raw8_rotate_90_cw(input_address, out_address, width, height):
|
|
"""
|
|
:brief To rotate the 8-bit image clockwise by 90 degrees
|
|
:param input_address: The input image buff address, buff size = width * height
|
|
:param out_address: The output image buff address, buff size = width * height
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
out_address_p = c_void_p()
|
|
out_address_p.value = out_address
|
|
|
|
status = dll.DxRotate90CW8B(input_address_p, out_address_p,
|
|
width_c, height_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, 'DxRotate90CCW8B'):
|
|
def dx_raw8_rotate_90_ccw(input_address, out_address, width, height):
|
|
"""
|
|
:brief To rotate the 8-bit image counter clockwise by 90 degrees
|
|
:param input_address: The input image buff address, buff size = width * height
|
|
:param out_address: The output image buff address, buff size = width * height
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
out_address_p = c_void_p()
|
|
out_address_p.value = out_address
|
|
|
|
status = dll.DxRotate90CCW8B(input_address_p, out_address_p,
|
|
width_c, height_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxImageImprovment"):
|
|
def dx_image_improvement(input_address, output_address, width, height,
|
|
color_correction_param, contrast_lut, gamma_lut):
|
|
"""
|
|
:brief image quality improvement
|
|
:param input_address: input buffer address, buff size = width * height *3
|
|
:param output_address: input buffer address, buff size = width * height *3
|
|
:param width: image width
|
|
:param height: image height
|
|
:param color_correction_param: color correction param(get from camera)
|
|
:param contrast_lut: contrast lookup table
|
|
:param gamma_lut: gamma lookup table
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
color_correction_param_c = c_int64()
|
|
color_correction_param_c.value = color_correction_param
|
|
|
|
status = dll.DxImageImprovment(input_address_p, output_address_p, width_c, height_c,
|
|
color_correction_param_c, contrast_lut, gamma_lut)
|
|
return status
|
|
|
|
if hasattr(dll, "DxImageImprovmentEx"):
|
|
def dx_image_improvement_ex(input_address, output_address, width, height,
|
|
color_correction_param, contrast_lut, gamma_lut, channel_order):
|
|
"""
|
|
:brief image quality improvement
|
|
:param input_address: input buffer address, buff size = width * height *3
|
|
:param output_address: input buffer address, buff size = width * height *3
|
|
:param width: image width
|
|
:param height: image height
|
|
:param color_correction_param: color correction param(get from camera)
|
|
:param contrast_lut: contrast lookup table
|
|
:param gamma_lut: gamma lookup table
|
|
:param channel_order: RGB channel order of output image
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
color_correction_param_c = c_int64()
|
|
color_correction_param_c.value = color_correction_param
|
|
|
|
channel_order_c = c_uint()
|
|
channel_order_c.value = channel_order
|
|
|
|
status = dll.DxImageImprovmentEx(input_address_p, output_address_p, width_c, height_c,
|
|
color_correction_param_c, contrast_lut, gamma_lut, channel_order_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxBrightness"):
|
|
def dx_brightness(input_address, output_address, image_size, factor):
|
|
"""
|
|
:brief Brightness adjustment (RGB24 or mono8)
|
|
:param input_address: input buffer address
|
|
:param output_address: output buffer address
|
|
:param image_size: image size
|
|
:param factor: brightness factor,range(-150 ~ 150)
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
image_size_c = c_uint32()
|
|
image_size_c.value = image_size
|
|
|
|
factor_c = c_int32()
|
|
factor_c.value = factor
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxBrightness(input_address_p, output_address_p, image_size_c, factor_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxContrast"):
|
|
def dx_contrast(input_address, output_address, image_size, factor):
|
|
"""
|
|
:brief Contrast adjustment (RGB24 or mono8)
|
|
:param input_address: input buffer address
|
|
:param output_address: output buffer address
|
|
:param image_size: image size
|
|
:param factor: contrast factor,range(-50 ~ 100)
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
image_size_c = c_uint32()
|
|
image_size_c.value = image_size
|
|
|
|
factor_c = c_int32()
|
|
factor_c.value = factor
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxContrast(input_address_p, output_address_p, image_size_c, factor_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxSaturation"):
|
|
def dx_saturation(input_address, output_address, image_size, factor):
|
|
"""
|
|
:brief Saturation adjustment (RGB24)
|
|
:param input_address: input buffer address, buff size = width * height * 3
|
|
:param output_address: output buffer address, buff size = width * height * 3
|
|
:param image_size: image size (width * height)
|
|
:param factor: saturation factor,range(0 ~ 128)
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
image_size_c = c_uint32()
|
|
image_size_c.value = image_size
|
|
|
|
factor_c = c_int32()
|
|
factor_c.value = factor
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxSaturation(input_address_p, output_address_p, image_size_c, factor_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxAutoRawDefectivePixelCorrect"):
|
|
def dx_auto_raw_defective_pixel_correct(inout_address, width, height, bit_num):
|
|
"""
|
|
:brief Auto raw defective pixel correct,Support image from Raw8 to Raw16, the bit number is actual
|
|
bit number, when it is more than 8, the actual bit can be every number between 9 to 16.
|
|
And if image format is packed, you need convert it to Raw16.
|
|
This function should be used in each frame.
|
|
:param inout_address: input & output buffer address
|
|
:param width: image width
|
|
:param height: image height
|
|
:param bit_num: image bit number (for example:if image 10bit, nBitNum = 10,
|
|
if image 12bit, nBitNum = 12,
|
|
range:8 ~ 16)
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
bit_num_c = c_int32()
|
|
bit_num_c.value = bit_num
|
|
|
|
inout_address_p = c_void_p()
|
|
inout_address_p.value = inout_address
|
|
|
|
status = dll.DxAutoRawDefectivePixelCorrect(inout_address_p, width_c, height_c, bit_num_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxSharpen24B"):
|
|
def dx_sharpen_24b(input_address, output_address, width, height, factor):
|
|
"""
|
|
:brief Sharpen adjustment (RGB24)
|
|
:param input_address: input buffer address, buff size = width * height * 3
|
|
:param output_address: output buffer address, buff size = width * height * 3
|
|
:param width: image width
|
|
:param height: image height
|
|
:param factor: sharpen factor, range(0.1~5.0)
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
factor_c = c_float()
|
|
factor_c.value = factor
|
|
|
|
status = dll.DxSharpen24B(input_address_p, output_address_p, width_c, height_c, factor_c)
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxGetWhiteBalanceRatio"):
|
|
def dx_get_white_balance_ratio(input_address, width, height):
|
|
"""
|
|
:brief Get white balance ratios(RGB24), In order to calculate accurately, the camera should
|
|
shoot objective "white" area,or input image is white area.
|
|
:param input_address: input buffer address, buff size = width * height * 3
|
|
:param width: image width
|
|
:param height: image height
|
|
:return: status: State return value, See detail in DxStatus
|
|
(r_ratio, g_ratio, b_ratio): rgb ratio tuple
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
r_ratio_c = c_double()
|
|
r_ratio_c.value = 0
|
|
|
|
g_ratio_c = c_double()
|
|
g_ratio_c.value = 0
|
|
|
|
b_ratio_c = c_double()
|
|
b_ratio_c.value = 0
|
|
|
|
status = dll.DxGetWhiteBalanceRatio(input_address_p, width_c, height_c, byref(r_ratio_c),
|
|
byref(g_ratio_c), byref(b_ratio_c))
|
|
|
|
return status, (r_ratio_c.value, g_ratio_c.value, b_ratio_c.value)
|
|
|
|
|
|
if hasattr(dll, "DxImageMirror"):
|
|
def dx_image_mirror(input_address, output_address, width, height, mirror_mode):
|
|
"""
|
|
:brief image mirror(raw8)
|
|
:param input_address: input buffer address
|
|
:param output_address: output buffer address
|
|
:param width: image width
|
|
:param height: image height
|
|
:param mirror_mode: mirror mode
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
mirror_mode_c = c_uint()
|
|
mirror_mode_c.value = mirror_mode
|
|
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
status = dll.DxImageMirror(input_address_p, output_address_p, width_c, height_c, mirror_mode_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRaw8ImgProcess"):
|
|
def dx_raw8_image_process(input_address, output_address, width, height, color_img_process_param):
|
|
"""
|
|
:brief Raw8 image process
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height * 3
|
|
:param width: image width
|
|
:param height: image height
|
|
:param color_img_process_param: Raw8 image process param, refer to DxColorImgProcess
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
color_img_process_param_c = ColorImgProcess()
|
|
color_img_process_param_c.defective_pixel_correct = color_img_process_param.defective_pixel_correct
|
|
color_img_process_param_c.denoise = color_img_process_param.denoise
|
|
color_img_process_param_c.sharpness = color_img_process_param.sharpness
|
|
color_img_process_param_c.accelerate = color_img_process_param.accelerate
|
|
if color_img_process_param.cc_param is None:
|
|
color_img_process_param_c.arr_cc = None
|
|
color_img_process_param_c.cc_buf_length = 0
|
|
else:
|
|
color_img_process_param_c.arr_cc = addressof(color_img_process_param.cc_param.get_ctype_array())
|
|
color_img_process_param_c.cc_buf_length = color_img_process_param.cc_param.get_length()
|
|
color_img_process_param_c.sharp_factor = color_img_process_param.sharp_factor
|
|
if color_img_process_param.pro_lut is None:
|
|
color_img_process_param_c.pro_lut = None
|
|
color_img_process_param_c.lut_length = 0
|
|
else:
|
|
color_img_process_param_c.pro_lut = addressof(color_img_process_param.pro_lut.get_ctype_array())
|
|
color_img_process_param_c.lut_length = color_img_process_param.pro_lut.get_length()
|
|
color_img_process_param_c.cv_type = color_img_process_param.convert_type
|
|
color_img_process_param_c.layout = color_img_process_param.color_filter_layout
|
|
color_img_process_param_c.flip = color_img_process_param.flip
|
|
|
|
status = dll.DxRaw8ImgProcess(input_address_p, output_address_p, width_c,
|
|
height_c, byref(color_img_process_param_c))
|
|
|
|
return status
|
|
|
|
|
|
if hasattr(dll, "DxMono8ImgProcess"):
|
|
def dx_mono8_image_process(input_address, output_address, width, height, mono_img_process_param):
|
|
"""
|
|
:brief mono8 image process
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height
|
|
:param width: image width
|
|
:param height: image height
|
|
:param mono_img_process_param: mono8 image process param, refer to DxMonoImgProcess
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
mono_img_process_param_c = MonoImgProcess()
|
|
mono_img_process_param_c.defective_pixel_correct = mono_img_process_param.defective_pixel_correct
|
|
mono_img_process_param_c.sharpness = mono_img_process_param.sharpness
|
|
mono_img_process_param_c.accelerate = mono_img_process_param.accelerate
|
|
mono_img_process_param_c.sharp_factor = mono_img_process_param.sharp_factor
|
|
if mono_img_process_param.pro_lut is None:
|
|
mono_img_process_param_c.pro_lut = None
|
|
mono_img_process_param_c.lut_length = 0
|
|
else:
|
|
mono_img_process_param_c.pro_lut = addressof(mono_img_process_param.pro_lut.get_ctype_array())
|
|
mono_img_process_param_c.lut_length = mono_img_process_param.pro_lut.get_length()
|
|
|
|
status = dll.DxMono8ImgProcess(input_address_p, output_address_p, width_c,
|
|
height_c, byref(mono_img_process_param_c))
|
|
|
|
return status
|
|
|
|
if hasattr(dll, 'DxGetFFCCoefficients'):
|
|
def dx_get_ffc_coefficients(bright_img, dark_img, actual_bits, bayer_type, width, height, target_value):
|
|
"""
|
|
:brief Get Flat Field Correction Coefficients
|
|
(only support raw8 raw10 raw12)
|
|
:param bright_img: bright image
|
|
:param dark_img: dark image
|
|
:param actual_bits: image actual bits
|
|
:param bayer_type: bayer type
|
|
:param width: image width
|
|
:param height: image height
|
|
:param target_value: correction target Value
|
|
:return status: State return value, See detail in DxStatus
|
|
ffc_coefficients: flat field correction coefficients Buffer
|
|
ffc_coefficients_length: flat field correction coefficients Buffer length
|
|
"""
|
|
field_correction_process_c = FieldCorrectionProcess()
|
|
field_correction_process_c.bright_buf = bright_img
|
|
field_correction_process_c.dark_buf = dark_img
|
|
field_correction_process_c.width = width
|
|
field_correction_process_c.height = height
|
|
field_correction_process_c.actual_bits = actual_bits
|
|
field_correction_process_c.bayer_type = bayer_type
|
|
|
|
ffc_coefficients_len_c = c_int()
|
|
ffc_coefficients_len_c.value = 0
|
|
|
|
if target_value is None:
|
|
# Get length of ffc coefficients
|
|
dll.DxGetFFCCoefficients(field_correction_process_c, None, byref(ffc_coefficients_len_c), None)
|
|
|
|
# Create buff to get coefficients data
|
|
ffc_coefficients_c = (c_ubyte * ffc_coefficients_len_c.value)()
|
|
status = dll.DxGetFFCCoefficients(field_correction_process_c, byref(ffc_coefficients_c),
|
|
byref(ffc_coefficients_len_c), None)
|
|
else:
|
|
target_value_c = c_int()
|
|
target_value_c.value = target_value
|
|
|
|
# Get length of ffc coefficients
|
|
dll.DxGetFFCCoefficients(field_correction_process_c, None, byref(ffc_coefficients_len_c),
|
|
byref(target_value_c))
|
|
|
|
# Create buff to get coefficients data
|
|
ffc_coefficients_c = (c_ubyte * ffc_coefficients_len_c.value)()
|
|
status = dll.DxGetFFCCoefficients(field_correction_process_c, byref(ffc_coefficients_c),
|
|
byref(ffc_coefficients_len_c), byref(target_value_c))
|
|
|
|
return status, ffc_coefficients_c, ffc_coefficients_len_c.value
|
|
|
|
|
|
if hasattr(dll, "DxFlatFieldCorrection"):
|
|
def dx_flat_field_correction(input_address, output_address, actual_bits, width, height, ffc_coefficients):
|
|
"""
|
|
:brief Flat Field Correction Process
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height
|
|
:param actual_bits: image actual bits
|
|
:param width: image width
|
|
:param height: image height
|
|
:param ffc_coefficients: flat field correction coefficients data array
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
actual_bits_c = c_uint()
|
|
actual_bits_c.value = actual_bits
|
|
|
|
ffc_coefficients_len_c = c_int()
|
|
ffc_coefficients_len_c.value = len(ffc_coefficients)
|
|
|
|
status = dll.DxFlatFieldCorrection(input_address_p, output_address_p, actual_bits_c, width_c, height_c,
|
|
byref(ffc_coefficients), byref(ffc_coefficients_len_c))
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRaw12PackedToRaw16"):
|
|
def dx_raw12_packed_to_raw16(input_address, output_address, width, height):
|
|
"""
|
|
:brief Convert Raw12Packed to Raw16
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height
|
|
:param width: image width
|
|
:param height: image height
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRaw12PackedToRaw16(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRaw10PackedToRaw16"):
|
|
def dx_raw10_packed_to_raw16(input_address, output_address, width, height):
|
|
"""
|
|
:brief Convert Raw10Packed to Raw16
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height
|
|
:param width: image width
|
|
:param height: image height
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRaw10PackedToRaw16(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRGB48toRGB24"):
|
|
def dx_rgb48_to_rgb24(input_address, output_address, width, height, valid_bit):
|
|
"""
|
|
:brief Convert RGB48 to RGB24
|
|
:param input_address: input buffer address, buff size = width * height
|
|
:param output_address: output buffer address, buff size = width * height
|
|
:param width: image width
|
|
:param height: image height
|
|
:param valid_bit: image valid bit
|
|
:return: status: State return value, See detail in DxStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
valid_bit_c = c_uint()
|
|
valid_bit_c.value = valid_bit
|
|
|
|
status = dll.DxRGB48toRGB24(input_address_p, output_address_p, width_c, height_c, valid_bit_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, 'DxRaw16toRGB48'):
|
|
def dx_raw16_to_rgb48(input_address, output_address, width, height, actual_bits, convert_type, bayer_type, flip):
|
|
"""
|
|
:brief Convert Raw16 to RGB48
|
|
:param input_address: The input raw image buff address, buff size = width * height
|
|
:param output_address: The output rgb image buff address, buff size = width * height * 3
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:param actual_bits: image actual bits
|
|
:param convert_type: Bayer convert type, See detail in DxBayerConvertType
|
|
:param bayer_type: pixel color filter, See detail in DxPixelColorFilter
|
|
:param flip: Output image flip flag
|
|
True: turn the image upside down
|
|
False: do not flip
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
actual_bits_c = c_uint()
|
|
actual_bits_c.value = actual_bits
|
|
|
|
convert_type_c = c_uint()
|
|
convert_type_c.value = convert_type
|
|
|
|
bayer_type_c = c_uint()
|
|
bayer_type_c.value = bayer_type
|
|
|
|
flip_c = c_bool()
|
|
flip_c.value = flip
|
|
|
|
status = dll.DxRaw16toRGB48(input_address_p, output_address_p,
|
|
width_c, height_c, actual_bits_c, convert_type_c, bayer_type_c, flip_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxRaw8toARGB32'):
|
|
def dx_raw8_to_rgb32(input_address, output_address, width, height, stride, convert_type, bayer_type, flip, alpha):
|
|
"""
|
|
:brief Convert Raw8 to ARGB32
|
|
:param input_address: The input raw image buff address, buff size = width * height
|
|
:param output_address: The output rgb image buff address, buff size = width * height * 3
|
|
:param width: Image width
|
|
:param height: Image height
|
|
:param stride: Android surface stride
|
|
:param convert_type: Bayer convert type, See detail in DxBayerConvertType
|
|
:param bayer_type: pixel color filter, See detail in DxPixelColorFilter
|
|
:param flip: Output image flip flag
|
|
True: turn the image upside down
|
|
False: do not flip
|
|
:param alpha: value of channel Alpha
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
stride_c = c_uint32()
|
|
stride_c.value = stride
|
|
|
|
convert_type_c = c_uint()
|
|
convert_type_c.value = convert_type
|
|
|
|
bayer_type_c = c_uint()
|
|
bayer_type_c.value = bayer_type
|
|
|
|
flip_c = c_bool()
|
|
flip_c.value = flip
|
|
|
|
alpha_c = c_uint32()
|
|
alpha_c.value = alpha
|
|
|
|
status = dll.DxRaw8toARGB32(input_address_p, output_address_p,
|
|
width_c, height_c, stride_c, convert_type_c, bayer_type_c, flip_c, alpha_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxStaticDefectCorrection'):
|
|
def dx_static_defect_correction(input_address, output_address, defect_correction, defect_pos_buffer_address,
|
|
defect_pos_buffer_size):
|
|
"""
|
|
:brief Image defect pixel correction
|
|
:param input_address: The input raw image buff address, buff size = width * height
|
|
:param output_address: The output rgb image buff address, buff size = width * height * 3
|
|
:param defect_correction: Image parameter used to do defect correction
|
|
:param defect_pos_buffer_address: Defect Pixel position file buffer
|
|
:param defect_pos_buffer_size: Defect Pixel position file buffer size
|
|
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
defect_correction_c = defect_correction
|
|
|
|
defect_pos_buffer_address_p = c_void_p()
|
|
defect_pos_buffer_address_p.value = defect_pos_buffer_address
|
|
|
|
defect_pos_buffer_size_c = c_uint32()
|
|
defect_pos_buffer_size_c.value = defect_pos_buffer_size
|
|
|
|
status = dll.DxStaticDefectCorrection(input_address_p, output_address_p,
|
|
defect_correction_c, defect_pos_buffer_address_p,
|
|
defect_pos_buffer_size_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxCalcCameraLutBuffer'):
|
|
def dx_calc_camera_lut_buffer(contrast_param, gamma, light_ness, lut_address,
|
|
lut_length_address):
|
|
"""
|
|
:brief calculating lookup table of camera
|
|
:param contrast_param: contrast param,range(-50~100)
|
|
:param gamma: gamma param,range(0.1~10)
|
|
:param light_ness: lightness param,range(-150~150)
|
|
:param lut_address: lookup table
|
|
:param lut_length_address: lookup table length(unit:byte)
|
|
|
|
Lookup table length should be obtained through the interface GXGetBufferLength.
|
|
"""
|
|
contrast_param_c = c_int32()
|
|
contrast_param_c.value = contrast_param
|
|
|
|
gamma_c = c_double()
|
|
gamma_c.value = gamma
|
|
|
|
lightness_c = c_int32()
|
|
lightness_c.value = light_ness
|
|
|
|
lut_address_c = c_void_p()
|
|
lut_address_c.value = lut_address
|
|
|
|
status = dll.DxCalcCameraLutBuffer(contrast_param_c, gamma_c,
|
|
lightness_c, lut_address_c,
|
|
lut_length_address)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxReadLutFile'):
|
|
def dx_read_lut_file(lut_file_path, lut_address, lut_length_address):
|
|
"""
|
|
:brief read lut file
|
|
:param lut_file_path: Lut file path. Lut file(xxx.lut) can be obtained from Lut
|
|
Create Tool Plugin,which can be get by select Plugin->Lut
|
|
Create Tool Plugin from the menu bar in GalaxyView.
|
|
:param lut_address: Lookup table. Users need to apply for memory in advance.The
|
|
memory size is also lookup table length(nLutLength),should be
|
|
obtained through the interface GXGetBufferLength,
|
|
e.g. GXGetBufferLength(m_hDevice, GX_BUFFER_LUT_VALUEALL,&nLutLength),
|
|
:param lut_length_address: Lookup table length(unit:byte),which should be obtained through
|
|
the interface GXGetBufferLength, e.g.
|
|
GXGetBufferLength(m_hDevice, GX_BUFFER_LUT_VALUEALL,&nLutLength),
|
|
:return: status State return value, See detail in DxStatus
|
|
data_array Array of output images, buff size = width * height * 3
|
|
"""
|
|
|
|
lut_address_p = c_void_p()
|
|
lut_address_p.value = lut_address
|
|
|
|
status = dll.DxReadLutFile(lut_file_path, lut_address_p,
|
|
lut_length_address)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertCreate'):
|
|
def dx_image_format_convert_create():
|
|
"""
|
|
:brief Create handle for Image Format Convert
|
|
:param handle [in] Image Format convert handle
|
|
"""
|
|
handle = c_void_p()
|
|
status = dll.DxImageFormatConvertCreate(pointer(handle))
|
|
return status, handle
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertDestroy'):
|
|
def dx_image_format_convert_destroy(handle):
|
|
"""
|
|
:brief Destroy handle for Image Format Convert
|
|
:param handle [in] Image Format convert handle
|
|
"""
|
|
status = dll.DxImageFormatConvertDestroy(handle)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvert'):
|
|
def dx_image_format_convert(handle, input_address, input_length, output_address, output_length, fixel_format, width,
|
|
height, flip):
|
|
"""
|
|
:brief Image Format Convert Process
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
|
|
fixel_format_c = c_uint()
|
|
fixel_format_c.value = fixel_format
|
|
|
|
flip_c = c_bool()
|
|
flip_c.value = flip
|
|
|
|
status = dll.DxImageFormatConvert(handle, input_address_p, input_length, output_address_p,
|
|
output_length, fixel_format_c, width_c, height_c, flip_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertSetOutputPixelFormat'):
|
|
def dx_image_format_convert_set_output_pixel_format(handle, pixel_format):
|
|
"""
|
|
:brief Set Bayer Pixel Format Convert Type
|
|
:param handle [in] Image Format convert handle
|
|
:param pixel_format [in] Pixel Format
|
|
"""
|
|
|
|
pixel_format_c = c_uint()
|
|
pixel_format_c.value = pixel_format
|
|
|
|
status = dll.DxImageFormatConvertSetOutputPixelFormat(handle, pixel_format_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertSetAlphaValue'):
|
|
def dx_image_format_convert_set_alpha_value(handle, alpha_value):
|
|
"""
|
|
:brief Set Bayer Pixel Format Convert Type
|
|
:param handle [in] Image Format convert handle
|
|
:param alpha_value [in] Alpha channel value(range of 0~255)
|
|
"""
|
|
|
|
alpha_value_c = c_uint()
|
|
alpha_value_c.value = alpha_value
|
|
|
|
status = dll.DxImageFormatConvertSetAlphaValue(handle, alpha_value_c)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertSetInterpolationType'):
|
|
def dx_image_format_convert_set_interpolation_type(handle, cvt_type):
|
|
"""
|
|
:brief Set Bayer Pixel Format Convert Type
|
|
:param handle [in] Image Format convert handle
|
|
:param cvt_type [in] Bayer Pixel Format convert RGB type
|
|
"""
|
|
|
|
status = dll.DxImageFormatConvertSetInterpolationType(handle, cvt_type)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertSetValidBits'):
|
|
def dx_image_format_convert_set_valid_bits(handle, valid_bits):
|
|
"""
|
|
:brief Set Valid Bits
|
|
:param handle [in] Image Format convert handle
|
|
:param valid_bits [in] Valid Bits value
|
|
"""
|
|
|
|
status = dll.DxImageFormatConvertSetValidBits(handle, valid_bits)
|
|
return status
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertGetOutputPixelFormat'):
|
|
def dx_image_format_convert_get_output_pixel_format(handle):
|
|
"""
|
|
:brief Set Output Pixel type
|
|
:param handle [in] Image Format convert handle
|
|
:param pixel_format [out] Pixel Format
|
|
"""
|
|
|
|
pixel_format_c = c_uint()
|
|
|
|
status = dll.DxImageFormatConvertGetOutputPixelFormat(handle, byref(pixel_format_c))
|
|
return status, pixel_format_c.value
|
|
|
|
if hasattr(dll, 'DxImageFormatConvertGetBufferSizeForConversion'):
|
|
def dx_image_format_convert_get_buffer_size_for_conversion(handle, pixel_format, width, height):
|
|
"""
|
|
:brief Set Output Pixel type
|
|
:param handle [in] Image Format convert handle
|
|
:param pixel_format [in] Pixel Format
|
|
:param width [in] Image Width
|
|
:param height [in] Image Height
|
|
:param buffer_size_address [out] Image buffer size
|
|
"""
|
|
pixel_format_c = c_uint()
|
|
pixel_format_c.value = pixel_format
|
|
|
|
width_c = c_uint()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint()
|
|
height_c.value = height
|
|
|
|
buffer_size_c = c_int()
|
|
|
|
status = dll.DxImageFormatConvertGetBufferSizeForConversion(handle, pixel_format_c, width_c,
|
|
height_c, byref(buffer_size_c))
|
|
return status, buffer_size_c.value
|
|
|
|
if hasattr(dll, "DxRotate90CW8B"):
|
|
def dx_rotate_90_cw8b(input_address, output_address, width, height):
|
|
"""
|
|
:brief To rotate the 8-bit image clockwise by 90 degrees
|
|
:param pInputBuffer [in] input buffer
|
|
:param pOutputBuffer [out]output buffer(new buffer)
|
|
:param nWidth [in] image width
|
|
:param nHeight [in] image height
|
|
|
|
:return emStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRotate90CW8B(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRotate90CCW8B"):
|
|
def dx_rotate_90_ccw8b(input_address, output_address, width, height):
|
|
"""
|
|
:brief To rotate the 8-bit image counter by 90 degrees
|
|
:param pInputBuffer [in] input buffer
|
|
:param pOutputBuffer [out]output buffer(new buffer)
|
|
:param nWidth [in] image width
|
|
:param nHeight [in] image height
|
|
|
|
:return emStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRotate90CCW8B(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRotate90CW16B"):
|
|
def dx_rotate_90_cw16b(input_address, output_address, width, height):
|
|
"""
|
|
:brief To rotate the 16-bit image clockwise by 90 degrees
|
|
:param pInputBuffer [in] input buffer
|
|
:param pOutputBuffer [out]output buffer(new buffer)
|
|
:param nWidth [in] image width
|
|
:param nHeight [in] image height
|
|
|
|
:return emStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRotate90CW16B(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxRotate90CCW16B"):
|
|
def dx_rotate_90_ccw16b(input_address, output_address, width, height):
|
|
"""
|
|
:brief To rotate the 16-bit image counter by 90 degrees
|
|
:param pInputBuffer [in] input buffer
|
|
:param pOutputBuffer [out]output buffer(new buffer)
|
|
:param nWidth [in] image width
|
|
:param nHeight [in] image height
|
|
|
|
:return emStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxRotate90CCW16B(input_address_p, output_address_p, width_c, height_c)
|
|
|
|
return status
|
|
|
|
if hasattr(dll, "DxImageMirror16B"):
|
|
def dx_image_mirror_16b(input_address, output_address, width, height, mirro_mode):
|
|
"""
|
|
:brief image mirror(Raw16 or 16bit image)
|
|
:param pInputBuff [in] input buffer
|
|
:param pOutputBuf [out]output buffer
|
|
:param nWidth [in] image width
|
|
:param nHeight [in] image height
|
|
:param emMirrorMode [in] mirror mode
|
|
|
|
:return emStatus
|
|
"""
|
|
input_address_p = c_void_p()
|
|
input_address_p.value = input_address
|
|
|
|
output_address_p = c_void_p()
|
|
output_address_p.value = output_address
|
|
|
|
width_c = c_uint32()
|
|
width_c.value = width
|
|
|
|
height_c = c_uint32()
|
|
height_c.value = height
|
|
|
|
status = dll.DxImageMirror16B(input_address_p, output_address_p, width_c, height_c, mirro_mode)
|
|
|
|
return status |