def main_process(self):
"""
"""
input_name = "import/" + self.param["input_layer"]
output_name = "import/" + self.param["output_layer"]
if len(self.input_data) == 0:
print('[classifier] ERROR: no input_data found')
self.terminate_flag = True
for img_array in self.input_data:
if self.param["convert_to_rgb"]:
img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
tensor = self.sess.run(self.tensor_op,
feed_dict={'inarray:0': img_array})
input_operation = self.graph.get_operation_by_name(input_name)
output_operation = self.graph.get_operation_by_name(output_name)
inf_results = self.sess.run(output_operation.outputs[0],
{input_operation.outputs[0]: tensor})
inf_results = np.squeeze(inf_results)
orders, labinfo = self.create_labinfo(inf_results)
res = lab_tools.output_pred_classification(
input_path=self.orig_input_path,
conf=inf_results[orders[0]],
label=self.labels[orders[0]],
img_size=(img_array.shape[1], img_array.shape[0]),
labinfo=labinfo)
self.results.append(res)
def main_process(self):
""" Main function of dyda component. """
if isinstance(self.input_data, dict):
self.logger.debug("Input data is dict")
if not lab_tools.if_result_match_lab_format(self.input_data):
self.terminate_flag = False
self.logger.error("Can only accept lab format dictionary")
return False
input_data = self.input_data
else:
self.logger.debug("Input data is other type (expect ndarray)")
if isinstance(self.input_data, list):
if len(self.input_data) == 1:
input_img = self.input_data[0]
else:
input_img = self.input_data[0]
self.logger.warning(
"More than one input img array detected")
else:
input_img = self.input_data
width = input_img.shape[1]
height = input_img.shape[0]
input_data = lab_tools.output_pred_classification("", 1.0, "roi")
input_data["annotations"][0]["top"] = 0
input_data["annotations"][0]["bottom"] = height
input_data["annotations"][0]["left"] = 0
input_data["annotations"][0]["right"] = width
self.results = boxes.shrink_boxes(copy.deepcopy(input_data),
self.shrink_perc,
shift_to_pad=self.shift_to_pad)
def main_process(self):
""" Main function of dyda component. """
self.reset_output()
if not isinstance(self.input_data, list):
self.input_data = [self.input_data]
self.package = True
else:
self.package = False
# let input_data will always be list of list
if not any(isinstance(i, list) for i in self.input_data):
self.input_data = [self.input_data]
self.package_2 = True
else:
self.package_2 = False
# open and load the pickle file only at first frame
if self.first_time:
if self.pickle_path == "":
self.pickle_path = self.snapshot_folder.replace(
"FaceMatchAnalyzer",
"FaceEncodingImageProcessor/encodings.pickle")
with open(self.pickle_path, 'rb') as rfp:
self.known_faces = pickle.load(rfp)
self.first_time = False
for encodings in self.input_data:
temp_results = []
for encoding in encodings:
matches = compare_faces(self.known_faces["encodings"],
encoding,
tolerance=self.tolerance)
if True not in matches:
whose_face = "unknown"
else:
candidates = [
i for (i, j) in zip(self.known_faces['names'], matches)
if j
]
whose_face = max(set(candidates), key=candidates.count)
temp_results.append(
lab_tools.output_pred_classification("", -1, whose_face))
self.results.append(temp_results)
if self.package_2:
self.unpack_single_results()
self.uniform_output()
def main_process(self):
""" Main function of dyda component. """
self.results = []
self.output_data = []
if len(self.input_data) == 0:
self.logger.error("no input_data found")
self.terminate_flag = True
_input_data = copy.deepcopy(self.input_data)
for img_array in _input_data:
label = 'ok'
if image.is_rgb(img_array):
(h, w, ch) = img_array.shape
gray = image.conv_gray(img_array)
else:
(h, w) = img_array.shape
gray = img_array
corners_avg = [
np.average(gray[self.space_h:self.space_h + self.dh,
self.space_w:self.space_w + self.dw]),
np.average(gray[self.space_h:self.space_h + self.dh, w -
(self.space_w + self.dw):w - self.space_w]),
np.average(gray[h - (self.space_h + self.dh):h - self.space_h,
self.space_w:self.space_w + self.dw]),
np.average(gray[h - (self.space_h + self.dh):h - self.space_h,
w - (self.space_w + self.dw):w - self.space_w])
]
if self.thre_type == "lt":
min_avg = min(corners_avg)
conf = 1.0
if min_avg < self.thre:
label = 'ng'
# linear scale pixel average range between 50~thre to 1~0.6
conf = (self.thre - 0.4 * min_avg - 35) / (self.thre - 50)
else:
max_avg = max(corners_avg)
conf = 1.0
if max_avg > self.thre:
label = 'ng'
# linear scale pixel average range from thre~230 to 0.6~1
conf = (0.4 * max_avg - self.thre + 138) / (230 -
self.thre)
res = lab_tools.output_pred_classification(input_path="",
conf=conf,
label=label,
img_size=(w, h),
labinfo=[])
# this classifier only select one type of ng
if label == 'ok':
res['annotations'] = []
self.results.append(res)
def main_process(self):
super(PathLabelConverterLab, self).main_process()
labels = copy.deepcopy(self.results)
self.results = []
for label in labels:
self.results.append(
lab_tools.output_pred_classification("", 1.0, label)
)
self.unpack_single_results()
def main_process(self):
""" define main_process of dyda component """
self.output_data = []
self.results = []
for img in self.input_data:
diff_img = self.get_diff_img(img)
res = lab_tools.output_pred_classification(
input_path=self.orig_input_path,
label=self.get_output_result(diff_img),
# FIXME: fake conf
conf=random.uniform(0.7, 0.95))
self.results.append(res)
def main_process(self):
""" define main_process of dyda component """
for img_array in self.input_data:
algo_output = self.get_testing_result(img_array)
res = lab_tools.output_pred_classification(
input_path=self.orig_input_path,
conf=algo_output["conf"],
label=algo_output["label"],
img_size=(img_array.shape[1], img_array.shape[0]))
self.results.append(res)
self.output_data.append(img_array)
def main_process(self):
""" Main function of dyda component. """
self.results = []
self.output_data = []
if len(self.input_data) == 0:
self.logger.error("no input_data found")
self.terminate_flag = True
_input_data = copy.deepcopy(self.input_data)
for img_array in _input_data:
label = 'ok'
if image.is_rgb(img_array):
(h, w, ch) = img_array.shape
else:
(h, w) = img_array.shape
img_array = image.resize_img(img_array,
size=(self.bkg_img.shape[1],
self.bkg_img.shape[0]))
l1_diff = tinycv.l1_norm_diff_cv2(img_array, self.bkg_img)
l1_diff_mean = np.mean(l1_diff, axis=self.mean_axis)
max_diff = np.max(l1_diff_mean[self.sel_min:self.sel_max])
label = 'ng'
conf = 1.0
if max_diff <= self.thre:
label = 'ok'
res = lab_tools.output_pred_classification(input_path="",
conf=conf,
label=label,
img_size=(w, h),
labinfo=[])
# this classifier only select ok samples
if label == 'ng':
res['annotations'] = []
self.results.append(res)
def main_process(self):
if len(self.input_data) == 0:
logger.debug('no input_data found')
self.terminate_flag = True
logger.debug('self.input_data len: {}'.format(len(self.input_data)))
for img_array in self.input_data:
orig_h, orig_w = img_array.shape[:-1]
img_array = self.process_input(img_array)
inf_results = self.inference(img_array)
top_result = self.process_output(inf_results)
# orders, labinfo = self.create_labinfo(inf_results)
res = lab_tools.output_pred_classification(
# input_path=self.orig_input_path,
input_path='',
conf=top_result['confidence'],
label=top_result['label'],
img_size=(orig_h, orig_w),
# labinfo=labinfo
labinfo={})
self.results.append(res)
logger.debug('self.results: {}'.format(self.results))
def test_main_process(self):
ref_data = [['others', '1.00'], ['others', '1.00'], ['others', '0.90'],
['person', '0.90'], ['others', '0.83'], ['others', '0.80']]
r1 = lab_tools.output_pred_classification("", 1.0, "others")
r2 = lab_tools.output_pred_classification("", 0.9, "person")
r3 = lab_tools.output_pred_classification("", 0.8, "others")
r4 = lab_tools.output_pred_classification("", 0.7, "others")
r5 = lab_tools.output_pred_classification("", 0.2, "person")
r6 = lab_tools.output_pred_classification("", 0.9, "others")
results = []
d = DeterminatorByAggregatedDataSingle()
for r in [r1, r2, r3, r4, r5, r6]:
d.input_data = r
d.run()
results.append([
d.results["annotations"][0]["label"],
"%0.2f" % d.results["annotations"][0]["confidence"]
])
report = dict_comparator.get_diff(ref_data, results)
self.assertEqual(report['extra_field'], [])
self.assertEqual(report['missing_field'], [])
self.assertEqual(report['mismatch_val'], [])
def main_process(self):
""" main_process of YTECDataConverter """
if len(self.input_data) != 2:
self.terminate_flag = True
self.logger.error(
"input_data should be a list of [image_array, metadata]."
)
return False
if isinstance(self.input_data[0], np.ndarray):
img_data = copy.deepcopy(self.input_data[0])
elif isinstance(self.input_data[0], list):
img_data = copy.deepcopy(self.input_data[0][0])
if len(self.input_data[0]) > 1:
self.logger.warning("Multiple input image arrays detected.")
if isinstance(self.input_data[1], dict):
metadata = self.input_data[1]
elif isinstance(self.input_data[0], list):
metadata = self.input_data[1][0]
if len(self.input_data[1]) > 1:
self.logger.warning("Multiple input metadata detected.")
if "metadata" not in metadata.keys():
self.terminate_flag = True
self.logger.error("annotations key is missing in metadata.")
return False
anno = metadata["metadata"]
try:
self.rect.reset_loc([
anno["top"], anno["bottom"], anno["left"], anno["right"]
])
except BaseException:
self.terminate_flag = True
self.logger.error("Fail to set location info")
return False
rot_angle = 0
if "degree" in anno.keys():
rot_angle = anno["degree"]
if rot_angle != 0:
rot_img = tinycv.rotate(img_data, rot_angle)
else:
rot_img = img_data
cropped = tinycv.crop_img_rect_rgb(rot_img, self.rect)
self.output_data = [cropped]
shape = cropped.shape
self.results = lab_tools.output_pred_classification(
"", 1.0, "raw", img_size=[shape[1], shape[0]]
)
self.results["folder"] = os.path.join(
copy.deepcopy(self.snapshot_folder), "output_data"
)
self.results["filename"] = copy.deepcopy(self.metadata[0]) + ".jpg.0"
self.results["annotations"][0]["top"] = 0
self.results["annotations"][0]["left"] = 0
self.results["annotations"][0]["bottom"] = shape[0]
self.results["annotations"][0]["right"] = shape[1]
self.results["annotations"][0]["rot_angle"] = 0
return True
def main_process(self):
""" Main function of dyda component. """
self.results = []
self.output_data = []
if len(self.input_data) == 0:
print('[classifier] ERROR: no input_data found')
self.terminate_flag = True
_input_data = copy.deepcopy(self.input_data)
for img_array in _input_data:
# label initialization
result = 'ok'
# resize
img_box = image.resize_img(
img_array,
(self.param['resize_width'], self.param['resize_height']))
# rgb to gray
im_g = cv2.cvtColor(img_box, cv2.COLOR_RGB2GRAY)
# image binarization global
thre = int(np.mean(im_g.mean(axis=1)))
ret, im_b = cv2.threshold(im_g, thre, 1, cv2.THRESH_BINARY)
# morphological opening
kernel_size = int(
np.round(self.param['resize_width'] *
self.param['kernel_ratio']))
iter_num = self.param['iter_num']
kernel = np.ones((kernel_size, kernel_size), np.uint8)
im_o = cv2.erode(im_b.astype(np.uint8), kernel, iter_num)
im_o = cv2.dilate(im_o, kernel, iter_num)
# connected components labeling
cc_label = measure.label(im_o, background=0)
cc_label = cc_label.astype(np.uint8)
# fragment detection
label_idx = self.param['fragment_num']
label = self.extract_label(label_idx, cc_label)
pixel_num = sum(sum(label))
score = [[], []]
if pixel_num > 0:
result = 'ng'
score[1].append(1)
# projection feature
for i in range(self.param['fragment_num']):
feature = self.projection_feature(i, cc_label)
class_idx = self.clf.predict([feature])[0]
if class_idx == 1:
result = 'ng'
score[class_idx].append(
self.clf.predict_proba([feature])[0][class_idx])
# generate final results
if result == 'ng':
final_score = max(score[1])
else:
final_score = min(score[0])
res = lab_tools.output_pred_classification(
input_path="",
conf=final_score,
label=result,
img_size=(img_array.shape[1], img_array.shape[0]),
labinfo=[])
width = res["size"]["width"]
height = res["size"]["height"]
# Default space is 40 in tinycv, allow it to be adjusted based
# on the size of the images
space = max([40, int(width / 20), int(height / 20)])
output_data = tinycv.patch_bb_dyda(img_array,
res,
color=[0, 128, 0],
space=space)
self.results.append(res)
self.output_data.append(output_data)