def save_image_to_numpy(self) -> np.array:
"""
save image to a numpy array and return it
"""
err = ctypes.c_int(AC_OK)
size = c_ac.acGetResultDataLength(self.ac_object, ctypes.pointer(err))
if err.value != AC_OK:
raise ACError(err.value)
data = (ctypes.c_ubyte * size)()
ptr = ctypes.pointer(data)
ptr = ctypes.pointer(ptr)
err = c_ac.acSaveImageRGBBytes(self.ac_object, ptr)
if err != AC_OK:
raise ACError(err)
np_array = np.ctypeslib.as_array(data)
shape = (ctypes.c_int * 3)()
err = c_ac.acGetResultShape(self.ac_object, ctypes.pointer(shape))
if err != AC_OK:
raise ACError(err)
np_array = np_array.reshape((shape[0], shape[1], shape[2]))
return np_array
def load_video(self, src_path: str):
"""
load a video from disk
"""
if self.parameters.videoMode is False:
raise ACError(AC_ERROR_VIDEO_MODE_UNINIT)
err = c_ac.acLoadVideo(self.ac_object, ctypes.c_char_p(src_path.encode(os_encoding)))
if err != AC_OK:
raise ACError(err)
def save_image(self, dst_path: str):
"""
save image to disk
"""
err = c_ac.acSaveImage(self.ac_object, ctypes.c_char_p(dst_path.encode(os_encoding)))
if err != AC_OK:
raise ACError(err)
def load_image_from_numpy(self,
np_array: np.array,
input_type: int = AC_INPUT_RGB):
"""
load an image from numpy array, supported type is RGB and YUV444
"""
input_as_yuv444 = input_type == AC_INPUT_YUV444
input_as_rgb32 = input_type == AC_INPUT_RGB32 or input_type == AC_INPUT_BGR32
if input_type == AC_INPUT_RGB or input_type == AC_INPUT_RGB32:
self.input_type = AC_INPUT_RGB
rows, cols, _ = np_array.shape
data = np_array.ctypes.data_as(ctypes.POINTER(ctypes.c_ubyte))
err = c_ac.acLoadImageRGBPackedB(
self.ac_object,
ctypes.c_int(rows),
ctypes.c_int(cols),
data,
ctypes.c_int64(0),
ctypes.c_int(input_as_yuv444),
ctypes.c_int(input_as_rgb32),
)
if err != AC_OK:
raise ACError(err)
def load_image(self, src_path: str):
"""
load an image from disk
"""
err = c_ac.acLoadImage(self.ac_object, ctypes.c_char_p(src_path.encode(os_encoding)))
if err != AC_OK:
raise ACError(err)
def show_image(self):
"""
quickly show image which has been inputted
"""
err = c_ac.acShowImage(self.ac_object, ctypes.c_int(self.input_type))
if err != AC_OK:
raise ACError(err)
def init_GPUCNN(self):
"""
initialize GPU for GPUCNN mode
"""
err = c_ac.acInitGPUCNN()
if err != AC_OK:
raise ACError(err)
def set_arguments(self, parameters: Parameters):
err = c_ac.acSetArguments(
self.ac_object, ctypes.byref(self.__get_c_parameters(parameters)))
if err != AC_OK:
raise ACError(err)
self.parameters = parameters
def save_video(self):
"""
compete output video, should be called after calling process
"""
err = c_ac.acSaveVideo(self.ac_object)
if err != AC_OK:
raise ACError(err)
def __init__(
self,
managerList: ManagerList = None,
parameters: Parameters = Parameters(),
type: ProcessorType = ProcessorType.CPU_ACNet,
):
err = ctypes.c_int(AC_OK)
self.ac_object = c_ac.acGetInstance2(
ctypes.c_uint(
managerList.get_managers() if managerList is not None else 0),
ctypes.byref(managerList.get_manager_data())
if managerList is not None else None,
ctypes.byref(self.__get_c_parameters(parameters)),
ctypes.c_int(type),
ctypes.pointer(err),
)
if err.value != AC_OK:
raise ACError(err.value)
self.parameters = parameters
self.ac_object = ctypes.c_void_p(self.ac_object)
self.input_type = AC_INPUT_BGR
self.processor_type = type
self.process_status = AC_PROCESS_STOP
def stop_video_process(self):
"""
stop video processing
"""
err = c_ac.acStopVideoProcess(self.ac_object)
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_STOP
def continue_video_process(self):
"""
continue video processing
"""
err = c_ac.acContinueVideoProcess(self.ac_object)
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_RUNNING
def pause_video_process(self):
"""
pause video processing
"""
err = c_ac.acPauseVideoProcess(self.ac_object)
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_PAUSED
def process(self):
"""
process image or video
"""
self.process_status = AC_PROCESS_RUNNING
err = c_ac.acProcess(self.ac_object)
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_STOP
def process_with_progress(self):
"""
process video with progress displaying
"""
self.process_status = AC_PROCESS_RUNNING
err = c_ac.acProcessWithPrintProgress(self.ac_object)
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_STOP
def process_with_progress_callback(self, func):
"""
process video with callback function:
func(v :float) -> None
v: progress value (0 to 1)
"""
self.process_status = AC_PROCESS_RUNNING
c_callback = ctypes.CFUNCTYPE(None, ctypes.c_double)
err = c_ac.acProcessWithProgress(self.ac_object, c_callback(func))
if err != AC_OK:
raise ACError(err)
self.process_status = AC_PROCESS_STOP
def set_save_video_info(
self, dst_path: str, codec: Codec = Codec.MP4V, fps: float = 0
):
"""
set output video saving path and codec, should be called before calling process
set fps to 0 for automatic detection
"""
err = c_ac.acSetSaveVideoInfo(
self.ac_object,
ctypes.c_char_p(dst_path.encode(os_encoding)),
ctypes.c_int(codec),
ctypes.c_double(fps),
)
if err != AC_OK:
raise ACError(err)
def __init__(
self,
initGPU: bool = False,
initGPUCNN: bool = False,
platformID: int = 0,
deviceID: int = 0,
parameters: Parameters = Parameters(),
type: ProcessorType = ProcessorType.AUTO,
):
if type == ProcessorType.AUTO:
# init it to CPUCNN
type = ProcessorType.CPUCNN
initGPU = False
initGPUCNN = False
# Test all GPUs
_, platforms, devices = AC.get_GPU_list()
for p_id in range(platforms):
for d_id in range(devices[p_id]):
support_flag = AC.check_GPU_support(p_id, d_id)
if support_flag:
type = ProcessorType.GPUCNN
initGPUCNN = True
ac_parameters_p = ctypes.byref(self.__get_c_parameters(parameters))
err = ctypes.c_int(AC_OK)
self.ac_object = c_ac.acGetInstance(
ctypes.c_int(initGPU),
ctypes.c_int(initGPUCNN),
ctypes.c_uint(platformID),
ctypes.c_uint(deviceID),
ac_parameters_p,
ctypes.c_int(type),
ctypes.pointer(err),
)
if err.value != AC_OK:
raise ACError(err.value)
self.parameters = parameters
self.ac_object = ctypes.c_void_p(self.ac_object)
self.input_type = AC_INPUT_BGR
self.processor_type = type
self.GPUID = (platformID, deviceID)
self.process_status = AC_PROCESS_STOP
def set_video_mode(self, flag: bool = True):
err = c_ac.acSetVideoMode(self.ac_object, ctypes.c_int(flag))
if err != AC_OK:
raise ACError(err)
self.parameters.videoMode = flag