909 lines
37 KiB
Python
909 lines
37 KiB
Python
#!/usr/bin/python
|
|
# -*- coding:utf-8 -*-
|
|
# -*-mode:python ; tab-width:4 -*- ex:set tabstop=4 shiftwidth=4 expandtab: -*-
|
|
#
|
|
|
|
import os
|
|
import sys
|
|
from ctypes import *
|
|
|
|
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.')
|
|
|
|
|
|
# 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
|
|
|
|
|
|
# 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_)
|
|
|
|
|
|
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 Buffer
|
|
: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 = ffc_coefficients.get_length()
|
|
|
|
status = dll.DxFlatFieldCorrection(input_address_p, output_address_p, actual_bits_c, width_c, height_c,
|
|
byref(ffc_coefficients.get_ctype_array()), byref(ffc_coefficients_len_c))
|
|
|
|
return status
|