def record_result_data_on_json(self, startTime, endTime,
result_dict_values, summary_of_result,
result_path):
# Create result file path
num_of_dirs = len(os.listdir(result_path)) + 1
created_date = datetime.datetime.now().date()
created_time = datetime.datetime.now().time()
dir_path_to_write_result = os.path.join(
result_path, '{:0>4}_RESULT_{}_{:0>2}-{:0>2}-{:0>2}'.format(
num_of_dirs, created_date, created_time.hour,
created_time.minute, created_time.second))
config.makeDir(dir_path_to_write_result)
self.result_directories.append(
dir_path_to_write_result.split('\\')[-1])
# Write result image files
keys = self.smallImages.keys()
for key in keys:
cv2.imwrite(dir_path_to_write_result + '/' + key + '.jpg',
self.smallImages[key])
# Fill result data
data = {
'START': startTime,
'END': endTime,
'SUMMARY': summary_of_result,
'VALUES': result_dict_values
}
print('#FILE WRITE', data)
json_file_path_to_write_result = os.path.join(dir_path_to_write_result,
'RESULT.json')
with open(json_file_path_to_write_result, 'w') as outfile:
json.dump(data, outfile, indent=4, separators=(',', ': '))
def show_Result(self):
print("##-SHOW RESULT BUTTON CLICKED")
## You write the To-do method here and Set result
self.graphicsView.setText("RESULT DATA")
keys = self.smallImages.keys()
result_path = self.absPath + self.deviceName + '/result'
config.makeDir(result_path)
print('Sides:', keys)
for key in keys:
cv2.imwrite(result_path + '/' + key + '.jpg',
self.smallImages[key])
def img_capture(self):
print('##-CAPTURE BUTTON PRESSED')
self.ROI = roi_unit.readROI(
os.path.join(self.absPath, self.deviceName, 'locationInfo.txt'),
config.WINDOW_RATIO)
side = 'side' + str(self.sideNum)
if side not in self.ROI:
print("No screws on " + side)
return
print(self.ROI)
predictPath = os.path.join(self.absPath, self.deviceName, 'predict')
config.makeDir(predictPath)
pOImagePath = os.path.join(predictPath, 'images')
config.makeDir(pOImagePath)
pCImagePath = os.path.join(predictPath, 'imagesCanny')
config.makeDir(pCImagePath)
print(self.ROI[side])
self.img = image_process.test_image_capture(self.ROI[side],
pOImagePath, pCImagePath,
self.sideNum)
cv2.imwrite(predictPath + '/' + side + '.jpg', self.img)
self.imgview = QImage(self.img.data, self.img.shape[1],
self.img.shape[0], QImage.Format_RGB888)
self.graphicsView.setPixmap(QPixmap.fromImage(self.imgview))
def copy_images(path):
print('##-COPY IMAGES FOR TRAINING')
sides = os.listdir(path)
new_path = path + '/t_images'
if not os.path.isdir(new_path): os.mkdir(new_path)
if 'model' in sides: sides.remove('model')
if 't_images' in sides: sides.remove('t_images')
if 'locationInfo.txt' in sides: sides.remove('locationInfo.txt')
if 'Origin.jpg' in sides: sides.remove('Origin.jpg')
for side in sides:
side_path = path + '/' + side
classes = os.listdir(side_path)
print("Copy image classes: ", classes, "in", side)
for element in classes:
dir_path = side_path + '/' + element
eleN_path = new_path + '/' + element
config.makeDir(eleN_path)
extend.extend(eleN_path, dir_path)
'''
def do_Capture(self):
print("##-IMAGE CAPTURE START")
path = self.absPath
config.makeDir(path)
path += self.dirName
config.makeDir(path)
side = self.side + str(self.sideNum)
config.makeDir(path + '/' + side)
print("##IMAGE PROCESS PATH IS : " + path)
imageProcess.image_capture(path, side, self.cameraNum, True)
print(1)
def do_CorrectCapture(self):
print("##-IMAGE CAPTURE START")
root_path = self.absPath
config.makeDir(root_path)
device_path = os.path.join(root_path, self.dirName)
config.makeDir(device_path)
sideStr = 'side' + str(self.sideNum)
side_path = os.path.join(device_path, sideStr)
config.makeDir(side_path)
print("##IMAGE PROCESS PATH IS : " + side_path)
captured_image = image_process.image_capture(dir_path=device_path,
current_side=sideStr,
sideNum=self.sideNum,
correct_ROIs=True)
self.selectImg.extend(captured_image)
def img_capture(self):
print('##-CAPTURE BUTTON PRESSED')
self.ROI = roiUnit.readROI(
self.absPath + self.deviceName + '/locationInfo.txt',
config.WINDOW_RATIO)
predictPath = self.absPath + self.deviceName + '/predict'
config.makeDir(predictPath)
pOImagePath = self.absPath + self.deviceName + '/predict/images'
config.makeDir(pOImagePath)
pCImagePath = self.absPath + self.deviceName + '/predict/imagesCanny'
config.makeDir(pCImagePath)
side = self.sideName + str(self.sideNum)
print(self.ROI[side])
self.img = imageProcess.test_image_capture(self.ROI[side], pOImagePath,
pCImagePath, self.cameraNum)
cv2.imwrite(predictPath + '/' + side + '.jpg', self.img)
self.imgview = QImage(self.img.data, self.img.shape[1],
self.img.shape[0], QImage.Format_RGB888)
self.graphicsView.setPixmap(QPixmap.fromImage(self.imgview))
def do_startTest(self):
print("##-TEST BUTTON CLICKED")
startTime = datetime.datetime.now()
print(startTime)
self.startEndTimes = [startTime]
path = os.path.join(self.absPath, self.deviceName)
img_list = os.listdir(path + '/predict')
classes = os.listdir(path + '/t_images')
self.correctList = [[0, 0] for _ in range(5)]
incor_class = {}
for label in classes:
if label.split('_')[-1] == 'incor':
value = label.split('_')[1]
if value in incor_class:
incor_class[value].append(label)
else:
incor_class[value] = [label]
self.smallImages = {}
for image in img_list:
if not os.path.isdir(path + '/predict/' + image):
self.smallImages[image.split('.')[0]] = cv2.imread(
path + '/predict/' + image)
img_list = os.listdir(path + '/predict/imagesCanny')
print('images to predict:', img_list)
imageDir = path + '/predict/images'
modelFullPath = path + '/model/retrained_graph.pb'
labelsFullPath = path + '/model/retrained_labels.txt'
tensorName = self.deviceName
print('#Predicting')
results = predict.run_inference_on_image(modelFullPath, labelsFullPath,
imageDir, tensorName)
# results is a [{}, {}, ..] list of dictionaries
summary_of_result = {'total': {'CORRECT': 0, 'INCORRECT': 0}}
dict_of_result_values = []
for result in results:
image = result['imageName']
sideNo = int(result['imageName'][4])
print('#Predict Result[{}]'.format(image))
matchRates = result['results']
try:
camera_position, origin_class, predicted_class, maxmimum_score, isCorrect = getResult(
image, matchRates)
except Exception as e:
print(e)
dict_of_result_values.append({
'image name': image,
'camera position': camera_position,
'class': origin_class,
'predicted': predicted_class,
'maximum score': str(maxmimum_score),
'result': isCorrect
})
print('result:', isCorrect, end='\n')
if camera_position not in summary_of_result:
summary_of_result[camera_position] = {
'CORRECT': 0,
'INCORRECT': 0
}
if origin_class not in summary_of_result['total']:
summary_of_result['total'][origin_class] = {
'CORRECT': 0,
'INCORRECT': 0
}
summary_of_result[camera_position][isCorrect] += 1
summary_of_result['total'][isCorrect] += 1
summary_of_result['total'][origin_class][isCorrect] += 1
start, end, side = self.getArea(image)
if isCorrect == 'CORRECT':
cv2.rectangle(self.smallImages[side], start, end, config.GREEN,
1)
else:
cv2.rectangle(self.smallImages[side], start, end, config.RED,
1)
print("Test finished")
endTime = datetime.datetime.now()
print(endTime)
self.startEndTimes.append(endTime)
self.graphicsView.setText("RESULT DATA")
keys = self.smallImages.keys()
result_path = os.path.join(self.absPath, self.deviceName, 'result')
config.makeDir(result_path)
'''
print('Sides:', keys)
for key in keys:
cv2.imwrite(result_path + '/' + key + '.jpg', self.smallImages[key])
'''
self.record_result_data_on_json(
startTime=str(startTime),
endTime=str(endTime),
result_dict_values=dict_of_result_values,
summary_of_result=summary_of_result,
result_path=result_path)
self.curDeviceNo += 1
self.resultsDeviceNo = self.curDeviceNo - 1
self.update_buttons_and_labels()
self.showImagesResult()
def image_capture(dirPath, side, cameraNum, doWriteROI):
print(dirPath)
if doWriteROI: file = open(dirPath + '/' + 'locationInfo.txt', "a+")
roiList = readfile(dirPath + "/" + side)
img_path_list = []
selected_img = roiList
inputbox = inputBox.App("Enter the Object Name")
origin = getImage(cameraNum, config.WINDOW_SIZE)
cv2.imwrite(dirPath + "/Origin.jpg", origin)
origin_path = dirPath + "/Origin.jpg"
img = getImage(cameraNum, config.TESTWINDOW_SIZE)
fromCenter = False
dirPath = dirPath + '/' + side
elements = {}
first_img = copy.copy(img)
fileName_idx = 1
while True:
if (len(selected_img) > 0):
for rect in (selected_img):
if (rect[4] == True) or (rect[4] == 'True'):
cv2.rectangle(img, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(0, 255, 0), 3)
else:
cv2.rectangle(img, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]),
(255, 0, 0), 3)
r = cv2.selectROI("Select ROI", img, fromCenter)
while True:
# imCrop = img[int(r[1]):int(r[1] + r[3]), int(r[0]):int(r[0] + r[2])]
if cv2.waitKey(1) & 0xFF == ord('q'):
inputbox.do_UI()
objName = inputbox.getValue()
if objName in elements: elements[objName] += 1
else: elements[objName] = 0
x = r[0]
y = r[1]
w = r[2]
h = r[3]
dirName = side + '_' + objName + '_' + str(elements[objName])
if doWriteROI == True: dirName += '_cor'
else: dirName += '_incor'
temppath = dirPath + '/' + dirName
fileName = temppath + '/' + side + '_' + objName
config.makeDir(temppath)
# cv2.imwrite(temppath + '/' + filename, imCrop)
coord = convert(r, config.WINDOW_RATIO)
Crop.crop(origin_path, coord,
fileName + '_' + str(elements[objName]))
img_path_list.append(temppath)
selected_img.append([x, y, w, h, doWriteROI])
if doWriteROI:
file.write("%s_%s_%s_%s_%s_%s_%s\n" %
(x, y, w, h, side, objName, elements[objName]))
file.flush()
print("##-COMPLETE SAVE FILE : " + objName)
break
elif cv2.waitKey(1) & 0xFF == ord('d'):
_size = len(img_path_list)
if (_size > 0):
print("##-IMAGE DELETE")
_path = img_path_list.pop()
print(_path)
config.delete_folder(pathlib.Path(_path))
# os.remove()
selected_img.pop()
img = copy.copy(first_img) #before img
fileName_idx -= 1
else:
print("##-IMAGE DELETE - FAILED(No File)")
break
elif cv2.waitKey(1) & 0xFF == ord('s'):
print("##-IMAGE PROCESS COMPELTE")
cv2.destroyAllWindows()
writefile(dirPath, selected_img)
if (doWriteROI):
file.close()
return
def recapture_image(device_dir_path, current_side, sideNum):
print("INTO RECAPTURE")
side_dir_path = device_dir_path + '/' + current_side
# Make list of rois to display
selected_rois_to_draw = get_rect_list_from_locationinfo(device_dir_path)
if len(selected_rois_to_draw) == 0:
print("No existing ROI's found! Nothing to recapture.")
return
# Creating dialog objects used when saving
savedialog = QMessageBox()
savedialog.setStandardButtons(QMessageBox.Save | QMessageBox.Cancel
| QMessageBox.Apply)
savedialog.setDefaultButton(QMessageBox.Save)
savedialog.setText("Save recapture, Cancel, Quit?")
savedialog.button(QMessageBox.Apply).setText("Quit")
correctdialog = correctincorrect_dialog.correctIncorrectDialog()
# Reading locations of existing ROI's used when matching with selected rectangle
correct_locs = []
file = open(device_dir_path + '/' + 'locationInfo.txt', "r")
locationInfolines = []
for line in file:
if line.split('_')[4] == current_side:
correct_locs.append([int(x) for x in line.split("_")[0:4]])
locationInfolines.append(line)
file.close()
# Original picture is later cropped according to ROI
original_image = get_image_from_camera(sideNum,
size_conf=config.WINDOW_SIZE)
cv2.imwrite(device_dir_path + "/Origin.jpg", original_image)
# Image used to select ROI's on
img = get_image_from_camera(sideNum, size_conf=config.TESTWINDOW_SIZE)
# Creating frequency dict used for file names when making new images
image_folder_names = os.listdir(side_dir_path)
print(image_folder_names)
class_correct_incorrect_frequencies = {}
for folder in image_folder_names:
class_and_is_correct = folder.split('_')[1] + folder.split('_')[-1]
if class_and_is_correct in class_correct_incorrect_frequencies:
class_correct_incorrect_frequencies[class_and_is_correct] += 1
else:
class_correct_incorrect_frequencies[class_and_is_correct] = 1
print("##-RECAPTURE SETUP COMPLETE")
while True:
# Drawing ROI's
if len(selected_rois_to_draw) > 0:
draw_rois(current_side, img, selected_rois_to_draw)
# Get ROI
selected_roi = cv2.selectROI("Select ROI", img, False)
if sum(selected_roi) == 0:
savedialog.button(QMessageBox.Save).setDisabled(True)
else:
savedialog.button(QMessageBox.Save).setEnabled(True)
savedialog.setDefaultButton(QMessageBox.Save)
# Set ROI to closest existing ROI
closest_dist = 99999999
closest_idx = -1
# If user has dragged
if selected_roi[2] >= 5 and selected_roi[3] >= 5:
for i, rect in enumerate(correct_locs):
dist = abs(rect[0] - selected_roi[0]) + abs(rect[1] -
selected_roi[1])
if dist < closest_dist:
closest_dist = dist
closest_rect = rect
closest_idx = i
# If user has clicked:
else:
for i, uncentered_rect in enumerate(correct_locs):
centered_rect = list(
calculate_rectangle_center(
uncentered_rect)) + uncentered_rect[2:]
dist = abs(centered_rect[0] -
selected_roi[0]) + abs(centered_rect[1] -
selected_roi[1])
if dist < closest_dist:
closest_dist = dist
closest_rect = uncentered_rect
closest_idx = i
# Asking what the user wants to do
button_pressed = savedialog.exec()
# If save:
if button_pressed == QMessageBox.Save:
class_name = locationInfolines[closest_idx].split("_")[-2]
side_and_class_prefix = current_side + "_" + class_name
# Create file names, paths, dictionary of existing images
is_incorrect = correctdialog.exec()
correctness_string = 'incor' if is_incorrect else 'cor'
try:
unique_object_name = side_and_class_prefix + '_' + str(
class_correct_incorrect_frequencies[class_name +
correctness_string])
except KeyError:
unique_object_name = side_and_class_prefix + '_' + '0'
class_correct_incorrect_frequencies[class_name +
correctness_string] = 0
class_correct_incorrect_frequencies[class_name +
correctness_string] += 1
file_directory = side_dir_path + '/' + unique_object_name + '_' + correctness_string
file_path_including_name = file_directory + '/' + unique_object_name
# Create directory and image
coord = convert_coord(closest_rect, size_conf=config.WINDOW_RATIO)
config.makeDir(file_directory)
crop_image.reduce_and_save_image(
origin_image=(device_dir_path + "/Origin.jpg"),
crop_coords=coord,
saved_base_path=file_path_including_name)
# Else if close:
elif button_pressed == QMessageBox.Apply:
cv2.destroyAllWindows()
file.close()
return
def image_capture(dir_path, current_side, sideNum, correct_ROIs):
# Correct Capture button pressed
if correct_ROIs:
file = open(dir_path + '/' + 'locationInfo.txt', "a+")
# Incorrect Capture button pressed
else:
correct_locs = []
try:
file = open(dir_path + '/' + 'locationInfo.txt', "r")
except FileNotFoundError:
print("No existing ROI's found! Can't capture incorrect areas.")
return
for line in file:
if line.split('_')[4] == current_side:
correct_locs.append([int(x) for x in line.split("_")[0:4]])
file.close()
if len(correct_locs) == 0:
print("No existing ROI's found! Can't capture incorrect areas.")
return
selected_rois_to_draw = get_rect_list_from_locationinfo(dir_path)
# Creating dialog objects for later use
actiondialog = roiactiondialog.ROIActionDialog()
objectinputbox = roiobjectinputdialog.ROIobjectInputDialog()
# Original picture is later cropped according to ROI
original_image = get_image_from_camera(sideNum,
size_conf=config.WINDOW_SIZE)
cv2.imwrite(dir_path + "/Origin.jpg", original_image)
# Image used to select ROI's on
img = get_image_from_camera(sideNum, size_conf=config.TESTWINDOW_SIZE)
# Creating frequency dict used for file names when making new images
class_frequencies = {}
image_folder_names = os.listdir(dir_path + '/' + current_side)
print(image_folder_names)
for folder in image_folder_names:
class_name = folder.split('_')[1]
correct_folder = folder.split('_')[-1] == "cor"
if correct_ROIs and correct_folder or (not correct_ROIs
and not correct_folder):
if class_name in class_frequencies:
class_frequencies[class_name] += 1
else:
class_frequencies[class_name] = 0
first_img = copy.copy(img)
"""
selected_rois_to_draw is a list of rectangles
r is the currently selected region
Logic:
1. Draw everything
2. Take rectangle, wait until enter (cv2.selectROI only ends when you've pressed enter)
3. Selection box pops up (after the enter)
"""
while True:
# Drawing ROI's
if len(selected_rois_to_draw) > 0:
draw_rois(current_side, img, selected_rois_to_draw)
# Get ROI
r = cv2.selectROI("Select ROI", img, False)
if sum(r) == 0:
actiondialog.button(QMessageBox.Save).setDisabled(True)
else:
actiondialog.button(QMessageBox.Save).setEnabled(True)
actiondialog.setDefaultButton(QMessageBox.Save)
# If correct, if "fixed ROI size" is turned on, set to the given size
if correct_ROIs and config.ROI_SIZE_FIXED:
x, y, w, h = r[:4]
Coords = namedtuple('Coords', 'x y')
mid_point = Coords(round(x + w / 2), round(y + h / 2))
x = max(mid_point.x - round(config.ROI_FIXED_WIDTH / 2), 0)
y = max(mid_point.y - round(config.ROI_FIXED_HEIGHT / 2), 0)
w = min(config.ROI_FIXED_WIDTH, config.WINDOW_SIZE['width'] - x)
h = min(config.ROI_FIXED_HEIGHT, config.WINDOW_SIZE['height'] - y)
r = list(r)
r[:4] = (x, y, w, h)
# If incorrect, set ROI to closest correct ROI
if not correct_ROIs and config.SELECT_CLOSEST_CORRECT_ROI_WHEN_SELECTING_INCORRECT_ROI:
print(r)
closest_dist = 99999999
# If user has dragged
if r[2] >= 5 and r[3] >= 5:
for rect in correct_locs:
dist = abs(rect[0] - r[0]) + abs(rect[1] - r[1])
if dist < closest_dist:
closest_dist = dist
closest_rect = rect
# If user has clicked
else:
for uncentered_rect in correct_locs:
centered_rect = list(
calculate_rectangle_center(
uncentered_rect)) + uncentered_rect[2:]
dist = abs(centered_rect[0] -
r[0]) + abs(centered_rect[1] - r[1])
# Debug use: print("UNCENTERED RECT:", uncentered_rect, "||||CENTERED_RECT:", centered_rect, "||||DIST:", dist)
if dist < closest_dist:
closest_dist = dist
closest_rect = uncentered_rect
r = list(closest_rect)
# Save button default. If no ROI is selected, disable the save button
# Asking what the user wants to do
button_pressed = actiondialog.exec()
# imCrop = img[int(r[1]):int(r[1] + r[3]), int(r[0]):int(r[0] + r[2])]
# Giving a name to the ROI and saving it
if button_pressed == QMessageBox.Save:
obj_name = objectinputbox.itemNames[objectinputbox.exec()]
if obj_name in class_frequencies:
class_frequencies[obj_name] += 1
else:
class_frequencies[obj_name] = 0
x, y, w, h = r[:4]
dir_name = current_side + '_' + obj_name + '_' + str(
class_frequencies[obj_name])
if correct_ROIs:
dir_name += '_cor'
else:
dir_name += '_incor'
temp_path = dir_path + '/' + current_side + '/' + dir_name
file_name = temp_path + '/' + current_side + '_' + obj_name
config.makeDir(temp_path)
# cv2.imwrite(temp_path + '/' + filename, imCrop)
coord = convert_coord(r, size_conf=config.WINDOW_RATIO)
crop_image.reduce_and_save_image(origin_image=(dir_path +
"/Origin.jpg"),
crop_coords=coord,
saved_base_path=file_name + '_' +
str(class_frequencies[obj_name]))
img_path_list.append(temp_path)
selected_rois_to_draw.append(
[x, y, w, h, correct_ROIs, current_side])
if correct_ROIs:
file.write("%s_%s_%s_%s_%s_%s_%s\n" %
(x, y, w, h, current_side, obj_name,
class_frequencies[obj_name]))
file.flush()
print("##-COMPLETE SAVE FILE : " + obj_name)
# Deleting last ROI
elif button_pressed == QMessageBox.Discard:
_size = len(img_path_list)
if correct_ROIs and img_path_list[-1].split('_')[-1] == 'incor':
print(
"Last saved incorrect ROI! Can't delete from correct capture mode!"
)
elif not correct_ROIs and img_path_list[-1].split(
'_')[-1] == 'cor':
print(
"Last saved correct ROI! Can't delete from incorrect capture mode!"
)
elif _size > 0:
print("##-IMAGE DELETE")
_path = img_path_list.pop()
print(_path)
obj_name = _path.split('_')[-3]
class_frequencies[obj_name] -= 1
config.delete_folder(pathlib.Path(_path))
# os.remove()
selected_rois_to_draw.pop()
img = copy.copy(first_img) # before img
if correct_ROIs:
file.close()
delete_last_line_from_roi_text_file(dir_path + '/' +
'locationInfo.txt')
file = open(dir_path + '/' + 'locationInfo.txt', "a+")
else:
print("##-IMAGE DELETE - FAILED(No File)")
# Exiting
elif button_pressed == QMessageBox.Apply:
print("##-IMAGE PROCESS COMPLETE")
cv2.destroyAllWindows()
file.close()
return selected_rois_to_draw
