def __init__(self, acl_resource, model_width, model_height):
self._acl_resource = acl_resource
self._model_width = model_width
self._model_height = model_height
#Use dvpp to process images, when using opencv or PIL,
# you don't need to create a dvpp instance
self._dvpp = Dvpp(acl_resource)
def init(self):
"""
init
"""
self._dvpp = Dvpp()
self._model = Model(self._model_path)
return constants.SUCCESS
def init(self):
"""
Initialize
"""
self._dvpp = Dvpp()
# Load model
self._model = Model(self._model_path)
return const.SUCCESS
class Classify(object):
"""
Class for portrait segmentation
"""
def __init__(self, model_path, model_width, model_height):
self._model_path = model_path
self._model_width = model_width
self._model_height = model_height
self._img_width = 0
self._img_height = 0
self._model = None
self._dvpp = None
def init(self):
"""
Initialize
"""
self._dvpp = Dvpp()
# Load model
self._model = Model(self._model_path)
return const.SUCCESS
@utils.display_time
def pre_process(self, image):
"""
preprocess
"""
image_dvpp = image.copy_to_dvpp()
yuv_image = self._dvpp.jpegd(image_dvpp)
resized_image = self._dvpp.resize(yuv_image, self._model_width,
self._model_height)
return resized_image
@utils.display_time
def inference(self, input_data):
"""
model inference
"""
return self._model.execute(input_data)
@utils.display_time
def post_process(self, infer_output, image_file):
"""
Post-processing, analysis of inference results
"""
output_path = os.path.join(OUTPUT_DIR, os.path.basename(image_file))
infer_result = infer_output[0]
vals = infer_result.flatten()
pre_index = vals.argsort()[-1]
origin_img = Image.open(image_file)
draw = ImageDraw.Draw(origin_img)
font = ImageFont.load_default()
draw.text((10, 50), CLS[pre_index], font=font, fill=255)
origin_img.save(output_path)
class Cartoonization(object):
"""
class for Cartoonization
"""
def __init__(self, model_path, model_width, model_height):
self._model_path = model_path
self._model_width = model_width
self._model_height = model_height
self.device_id = 0
self._dvpp = None
self._model = None
def init(self):
"""
Initialize
"""
# Initialize dvpp
self._dvpp = Dvpp()
# Load model
self._model = Model(self._model_path)
return const.SUCCESS
@utils.display_time
def pre_process(self, image):
"""
image preprocess
"""
image_dvpp = image.copy_to_dvpp()
yuv_image = self._dvpp.jpegd(image_dvpp)
crop_and_paste_image = self._dvpp.crop_and_paste_get_roi(yuv_image, image.width, image.height, \
self._model_width, self._model_height)
return crop_and_paste_image
@utils.display_time
def inference(self, resized_image):
"""
model inference
"""
return self._model.execute(resized_image)
@utils.display_time
def post_process(self, infer_output, image_file, origin_image):
"""
post process
"""
data = ((np.squeeze(infer_output[0]) + 1) * 127.5)
img = cv2.cvtColor(data, cv2.COLOR_RGB2BGR)
img = cv2.resize(img, (origin_image.width, origin_image.height))
output_path = os.path.join("../outputs", os.path.basename(image_file))
cv2.imwrite(output_path, img)
def main():
if (len(sys.argv) != 2):
print("The App arg is invalid")
exit(1)
acl_resource = AclResource()
acl_resource.init()
model = Model(MODEL_PATH)
dvpp = Dvpp(acl_resource)
image_dir = sys.argv[1]
images_list = [
os.path.join(image_dir, img) for img in os.listdir(image_dir)
if os.path.splitext(img)[1] in const.IMG_EXT
]
#Create a directory to store the inference results
if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")):
os.mkdir(os.path.join(SRC_PATH, "../outputs"))
image_info = construct_image_info()
for image_file in images_list:
image = AclImage(image_file)
resized_image = pre_process(image, dvpp)
print("pre process end")
result = model.execute([
resized_image,
])
post_process(result, image_file)
print("process " + image_file + " end")
def main():
"""main"""
#acl init
if (len(sys.argv) != 2):
print("The App arg is invalid")
exit(1)
acl_resource = AclResource()
acl_resource.init()
model = Model(MODEL_PATH)
dvpp = Dvpp(acl_resource)
#From the parameters of the picture storage directory, reasoning by a picture
image_dir = sys.argv[1]
images_list = [
os.path.join(image_dir, img) for img in os.listdir(image_dir)
if os.path.splitext(img)[1] in const.IMG_EXT
]
if not os.path.isdir(os.path.join(SRC_PATH, "../outputs")):
os.mkdir(os.path.join(SRC_PATH, "../outputs"))
#infer picture
for pic in images_list:
#get pic data
orig_shape, l_data = preprocess(pic)
#inference
result_list = model.execute([l_data])
#postprocess
postprocess(result_list, pic, orig_shape, pic)
print("Execute end")
def main():
"""
Program execution with picture directory parameters
"""
if (len(sys.argv) != 2):
print("The App arg is invalid")
exit(1)
acl_resource = AclResource()
acl_resource.init()
model = Model(MODEL_PATH)
dvpp = Dvpp(acl_resource)
#From the parameters of the picture storage directory, reasoning by a picture
image_dir = sys.argv[1]
images_list = [os.path.join(image_dir, img)
for img in os.listdir(image_dir)
if os.path.splitext(img)[1] in const.IMG_EXT]
#Create a directory to store the inference results
if not os.path.isdir('../outputs'):
os.mkdir('../outputs')
image_info = construct_image_info()
for image_file in images_list:
#read picture
image = AclImage(image_file)
#preprocess image
resized_image = pre_process(image, dvpp)
print("pre process end")
#reason pictures
result = model.execute([resized_image, image_info])
#process resresults
post_process(result, image, image_file)
def _thread_entry(self, args_list):
self._context, ret = acl.rt.create_context(0)
utils.check_ret("acl.rt.create_context", ret)
self._cap = video.AclVideo(self._stream_name)
self._dvpp = Dvpp()
self._status = STATUS_PREPROC_RUNNING
frame_cnt = 0
while self._status == STATUS_PREPROC_RUNNING:
ret, image = self._cap.read()
if ret or (image is None):
if ret == const.VIDEO_DECODE_FINISH:
log_info("Video %s decode finish"%(self._stream_name))
self._status = STATUS_PREPROC_EXIT
else:
log_info("Video %s decode failed"%(self._stream_name))
self._status = STATUS_PREPROC_ERROR
break
if (int(frame_cnt) % 5 == 0):
self._process_frame(image)
time.sleep(0.0)
self._thread_exit()
def main():
"""main"""
if (len(sys.argv) != 2):
print("The App arg is invalid")
exit(1)
acl_resource = AclResource()
acl_resource.init()
model = Model(MODEL_PATH)
dvpp = Dvpp(acl_resource)
image_dir = sys.argv[1]
images_list = [
os.path.join(image_dir, img) for img in os.listdir(image_dir)
if os.path.splitext(img)[1] in const.IMG_EXT
]
# Create a directory to save inference results
if not os.path.isdir('./outputs'):
os.mkdir('./outputs')
# Create a directory to save the intermediate results of the large image detection
if not os.path.isdir('./bigpic'):
os.mkdir('./bigpic')
# Create a directory to save the results of the big picture cropping inference
outCrop = os.path.join('./bigpic', 'output')
if not os.path.isdir(outCrop):
os.mkdir(outCrop)
# Create a directory, save the large and cropped pictures
cropImg = os.path.join('./bigpic', 'cropimg')
if not os.path.isdir(cropImg):
os.mkdir(cropImg)
image_info = construct_image_info()
for image_file in images_list:
imagename = get_file_name(image_file)
tempfile = os.path.splitext(imagename)[0]
imgdic = {}
imgdic['name'] = imagename
obj_res = []
img = cv2.imread(image_file, -1)
(width, height, depth) = img.shape
if width > 1000 and height > 1000:
# Create a directory to save the divided pictures of each big picture
crop_target = os.path.join(cropImg, tempfile)
if not os.path.isdir(crop_target):
os.mkdir(crop_target)
# Create a directory to save the inference results of each large image
out_target = os.path.join(outCrop, tempfile)
if not os.path.isdir(out_target):
os.mkdir(out_target)
# Large image clipping function
crop_picture(image_file, crop_target)
cropimg_list = [
os.path.join(crop_target, imgs)
for imgs in os.listdir(crop_target)
if os.path.splitext(imgs)[1] in const.IMG_EXT
]
# After the execution of the crop function is over,
# the small picture after the big picture crop should be saved in a folder crop_target
for cropimg_file in cropimg_list:
print("the crop filename is :\t", cropimg_file)
image = AclImage(cropimg_file)
resized_image = pre_process(image, dvpp)
result = model.execute([resized_image, image_info])
resdic = post_process_big(result, image, cropimg_file,
out_target)
obj_res.extend(resdic)
imgdic['object_result'] = obj_res
merge_picture(out_target, tempfile)
# Read in the picture, if the picture size is less than 1000x1000,
# it will be read in and processed normally
else:
print("detect the small picture")
image = AclImage(image_file)
resized_image = pre_process(image, dvpp)
print("pre process end")
result = model.execute([resized_image, image_info])
resdic = post_process(result, image, image_file)
obj_res.extend(resdic)
imgdic['object_result'] = obj_res
class Gesture(object):
"""
define gesture class
"""
def __init__(self, model_path, model_width, model_height):
self.device_id = 0
self.context = None
self.stream = None
self._model_path = model_path
self._model_width = model_width
self._model_height = model_height
self._dvpp = None
self._model = None
def init(self):
"""
Initialize
"""
# Initialize dvpp
self._dvpp = Dvpp()
# Load model
self._model = Model(self._model_path)
return const.SUCCESS
def pre_process(self, image):
"""
pre_precess
"""
image_dvpp = image.copy_to_dvpp()
yuv_image = self._dvpp.jpegd(image_dvpp)
print("decode jpeg end")
resized_image = self._dvpp.resize(yuv_image, self._model_width,
self._model_height)
print("resize yuv end")
return resized_image
def inference(self, resized_image):
"""
inference
"""
return self._model.execute(resized_image)
def post_process(self, infer_output, image_file):
"""
post_process
"""
print("post process")
data = infer_output[0]
vals = data.flatten()
top_k = vals.argsort()[-1:-2:-1]
print("images:{}".format(image_file))
print("======== top5 inference results: =============")
for n in top_k:
object_class = get_gesture_categories(n)
print("label:%d confidence: %f, class: %s" %
(n, vals[n], object_class))
if len(top_k):
object_class = get_gesture_categories(top_k[0])
output_path = os.path.join(os.path.join(SRC_PATH, "../outputs"),
os.path.basename(image_file))
origin_img = Image.open(image_file)
draw = ImageDraw.Draw(origin_img)
font = ImageFont.load_default()
draw.text((10, 50), object_class, font=font, fill=255)
origin_img.save(output_path)
class Preprocess():
def __init__(self, stream_name, channel, resize_width, resize_height):
self._stream_name = str(stream_name)
self._channel = int(channel)
self._resize_width = resize_width
self._resize_height = resize_width
self._status = STATUS_PREPROC_INIT
self._display = False
self._dvpp = None
self._cap = None
self._context = None
self._image_queue = queue.Queue(64)
def _start(self):
thread_id, ret = acl.util.start_thread(self._thread_entry, [])
utils.check_ret("acl.util.start_thread", ret)
log_info("Start sub thread ok, wait init...")
while self._status == STATUS_PREPROC_INIT:
time.sleep(0.001)
log_info("Status changed to ", self._status)
while self._start == STATUS_PREPROC_RUNNING:
if self._image_queue.qsize() > 0:
break
time.sleep(0.001)
return self._status != STATUS_PREPROC_ERROR
def _thread_entry(self, args_list):
self._context, ret = acl.rt.create_context(0)
utils.check_ret("acl.rt.create_context", ret)
self._cap = video.AclVideo(self._stream_name)
self._dvpp = Dvpp()
self._status = STATUS_PREPROC_RUNNING
frame_cnt = 0
while self._status == STATUS_PREPROC_RUNNING:
ret, image = self._cap.read()
if ret or (image is None):
if ret == const.VIDEO_DECODE_FINISH:
log_info("Video %s decode finish"%(self._stream_name))
self._status = STATUS_PREPROC_EXIT
else:
log_info("Video %s decode failed"%(self._stream_name))
self._status = STATUS_PREPROC_ERROR
break
if (int(frame_cnt) % 5 == 0):
self._process_frame(image)
time.sleep(0.0)
self._thread_exit()
def _process_frame(self, frame):
resized_image = self._dvpp.resize(frame, self._resize_width,
self._resize_height)
if resized_image is None:
log_error("dvpp resize image failed")
return
jpg_image = None
if self._display:
jpg_image = self._dvpp.jpege(frame)
if jpg_image is None:
log_error("dvpp jpege failed")
return
data = PreProcData(self._channel, frame.width, frame.height,
resized_image, jpg_image, self._display)
self._image_queue.put(data)
def _thread_exit(self):
self._status = STATUS_PREPROC_EXIT
log_info("Channel %d thread exit..."%(self._channel))
if self._dvpp != None:
del self._dvpp
self._dvpp = None
if self._cap != None:
del self._cap
self._cap = None
if self._context != None:
acl.rt.destroy_context(self._context)
self._context = None
log_info("Channel %d thread exit ok"%(self._channel))
def set_display(self, display):
self._display = display
def is_finished(self):
return self._status > STATUS_PREPROC_RUNNING
def get_data(self):
ret = True
if self._status == STATUS_PREPROC_EXIT:
return False, None
elif self._status == STATUS_PREPROC_INIT:
ret = self._start()
if ret == False:
log_error("decode channel %d failed"%(self._channel))
return False, None
if self._image_queue.empty():
return True, None
preproc_data = self._image_queue.get_nowait()
if preproc_data is None:
ret = False
return ret, preproc_data
def __del__(self):
self._thread_exit()
class VggSsd(object):
"""vggssd"""
def __init__(self, acl_resource, model_width, model_height):
self._acl_resource = acl_resource
self._model_width = model_width
self._model_height = model_height
#Use dvpp to process images, when using opencv or PIL,
# you don't need to create a dvpp instance
self._dvpp = Dvpp(acl_resource)
def __del__(self):
if self._dvpp:
del self._dvpp
print("Release yolov3 resource finished")
def pre_process(self, image):
"""Use dvpp to scale the image to the required size of the model"""
resized_image = self._dvpp.resize(image, self._model_width,
self._model_height)
if resized_image is None:
print("Resize image failed")
return None
#Output the scaled image and image information as inference input data
return [
resized_image,
]
def post_process(self, infer_output, origin_img):
"""Analyze inference output data"""
detection_result_list = self._analyze_inference_output(
infer_output, origin_img)
#Convert yuv image to jpeg image
jpeg_image = self._dvpp.jpege(origin_img)
return jpeg_image, detection_result_list
def _analyze_inference_output(self, infer_output, origin_img):
#vgg ssd has two outputs, the first output
# infer_output[0] is the number of detected objects, and the shape is (1,8)
box_num = int(infer_output[0][0, 0])
#The second output infer_output[1] is the detected object information, the shape is (1, 200, 8)
box_info = infer_output[1][0]
detection_result_list = []
for i in range(box_num):
#Detected object confidence
score = box_info[i, SCORE]
if score < 0.9:
break
detection_item = presenter_datatype.ObjectDetectionResult()
detection_item.confidence = score
#Person face position frame coordinates, normalized coordinates,
# need to be multiplied by the width and height of the picture to convert to the coordinates on the picture
detection_item.box.lt.x = int(box_info[i, TOP_LEFT_X] *
origin_img.width)
detection_item.box.lt.y = int(box_info[i, TOP_LEFT_Y] *
origin_img.height)
detection_item.box.rb.x = int(box_info[i, BOTTOM_RIGHT_X] *
origin_img.width)
detection_item.box.rb.y = int(box_info[i, BOTTOM_RIGHT_Y] *
origin_img.height)
#Organize the confidence into a string
detection_item.result_text = str(
round(detection_item.confidence * 100, 2)) + "%"
detection_result_list.append(detection_item)
return detection_result_list
class CrowdCount(object):
"""
crowdCount
"""
def __init__(self, model_path, model_width, model_height):
self.device_id = 0
self.context = None
self.stream = None
self._model = None
self.run_mode = None
self._model_path = model_path
self._model_width = model_width
self._model_height = model_height
self._dvpp = None
self._model = None
def init(self):
"""
init
"""
self._dvpp = Dvpp()
self._model = Model(self._model_path)
return constants.SUCCESS
def pre_process(self, image):
"""
image preprocess
"""
image_dvpp = image.copy_to_dvpp()
yuv_image = self._dvpp.jpegd(image_dvpp)
crop_and_paste_image = \
self._dvpp.crop_and_paste(yuv_image, image.width, image.height, self._model_width, self._model_height)
return crop_and_paste_image
def inference(self, input_data):
"""
model inference
"""
return self._model.execute(input_data)
def post_process(self, infer_output, image_file):
"""
Post-processing, analysis of inference results
"""
orig = cv2.imread(image_file, 1)
orig = cv2.resize(orig, (1200, 800))
data = infer_output[0]
vals = data.flatten()
res = np.sum(vals, axis=0)
result = round(res / 1000.0)
data_2 = data.reshape(800, 1408)
heatMap = data_2[:800, :1200]
heatMap = heatMap.astype(np.uint8)
heatMap = cv2.GaussianBlur(heatMap, (5, 5), cv2.BORDER_DEFAULT)
cv2.normalize(heatMap, heatMap, 0, 255, cv2.NORM_MINMAX, cv2.CV_8UC1)
heatMap = cv2.applyColorMap(heatMap, cv2.COLORMAP_JET)
add_img = cv2.addWeighted(orig, 1, heatMap, 0.5, 0.0)
cv2.putText(add_img, str(result), (30, 60), cv2.FONT_HERSHEY_PLAIN, 5, (0, 0, 255), 8)
output_path = os.path.join("./outputs", os.path.basename(image_file))
cv2.imwrite(output_path, add_img)
