ascendhuawei
116 lines
3.8 KiB
Python
116 lines
3.8 KiB
Python
import numpy as np
|
|
from PIL import Image
|
|
import copy
|
|
|
|
import acl
|
|
#from utils import *
|
|
from atlas_utils.constants import *
|
|
|
|
|
|
class AclImage():
|
|
def __init__(self, image, width=0, height=0,
|
|
size=0, memory_type=MEMORY_NORMAL):
|
|
self._data = None
|
|
self._np_array = None
|
|
self._memory_type = memory_type
|
|
self.width = 0
|
|
self.height = 0
|
|
self.channels = 0
|
|
self.size = 0
|
|
|
|
if isinstance(image, str):
|
|
self._instance_by_image_file(image)
|
|
elif str(type(image))=="<class 'numpy.ndarray'>":
|
|
self._instance_by_numpy_array(image,width,height)
|
|
elif isinstance(image, int):
|
|
self._instance_by_buffer(image, width, height, size)
|
|
else:
|
|
print("Create instance failed for unknow image data type")
|
|
|
|
def _instance_by_numpy_array(self, image,width,height):
|
|
self._data = image
|
|
self._type = IMAGE_DATA_NUMPY
|
|
self.size = self._data.itemsize * self._data.size
|
|
self.width = width
|
|
self.height = height
|
|
|
|
def _instance_by_image_file(self, image_path):
|
|
self._data = np.fromfile(image_path, dtype=np.byte)
|
|
self._type = IMAGE_DATA_NUMPY
|
|
self.size = self._data.itemsize * self._data.size
|
|
image = Image.open(image_path)
|
|
self.width, self.height = image.size
|
|
|
|
def _instance_by_buffer(self, image_buffer, width, height, size):
|
|
self.width = width
|
|
self.height = height
|
|
self.size = size
|
|
self._data = image_buffer
|
|
self._type = IMAGE_DATA_BUFFER
|
|
|
|
def tobytes(self):
|
|
if self._type == IMAGE_DATA_NUMPY:
|
|
return self._data
|
|
else:
|
|
return acl.util.ptr_to_numpy(self._data, (self.size, ), NPY_BYTE).tobytes()
|
|
|
|
def data(self):
|
|
if self._type == IMAGE_DATA_NUMPY:
|
|
return acl.util.numpy_to_ptr(self._data)
|
|
else:
|
|
return self._data
|
|
|
|
def copy_to_device(self, run_mode):
|
|
device_ptr = None
|
|
if run_mode == ACL_HOST:
|
|
device_ptr = copy_data_host_to_device(self.data(), self.size)
|
|
else:
|
|
device_ptr = copy_data_device_to_device(self.data(), self.size)
|
|
if device_ptr is None:
|
|
print("Copy image to device failed ")
|
|
return None
|
|
|
|
print("image copyt to device ", device_ptr, "%d, %d, %d"%(self.width,
|
|
self.height, self.size))
|
|
return AclImage(device_ptr, self.width,
|
|
self.height, self.size, MEMORY_DEVICE)
|
|
|
|
def copy_as_nparray(self):
|
|
if self._type == IMAGE_DATA_BUFFER:
|
|
#np_output = np.zeros(self.size, dtype=np.byte)
|
|
#if not np_output.flags['C_CONTIGUOUS']:
|
|
# np_output = np.ascontiguousarray(np_output)
|
|
np_output_ptr, ret = acl.rt.malloc(self.size, ACL_MEM_MALLOC_NORMAL_ONLY)
|
|
print("image ", np_output_ptr)
|
|
ret = acl.rt.memcpy(np_output_ptr, self.size, self._data, self.size, 3)
|
|
if (ret != ACL_ERROR_NONE):
|
|
print("Copy mage to np array failed for memcpy error ", ret)
|
|
return None
|
|
return copy.deepcopy(acl.util.ptr_to_numpy(np_output_ptr, (self.size, ), NPY_BYTE))
|
|
else:
|
|
return self._data.copy()
|
|
|
|
def destroy(self):
|
|
if (self._data is None) or (self.size == 0):
|
|
print("Release image abnormaly, data is None")
|
|
return
|
|
|
|
if self._memory_type == MEMORY_DEVICE:
|
|
acl.rt.free(self._data)
|
|
elif self._memory_type == MEMORY_HOST:
|
|
acl.rt.free_host(self._data)
|
|
elif self._memory_type == MEMORY_DVPP:
|
|
acl.media.dvpp_free(self._data)
|
|
|
|
self._data = None
|
|
self.size = 0
|
|
|
|
def __del__(self):
|
|
self.destroy()
|
|
|
|
|
|
|
|
|
|
|
|
|