def get_pointcloud_values(path):
number_of_points = 0.0
confidence_min = 0.0
confidence_avg = 0.0
confidence_std = 0.0
confidence_max = 0.0
error = False
error_message = ""
try:
pointcloud = utils.load_pcd_as_ndarray(path)
number_of_points = len(pointcloud)
confidence_min = float(np.min(pointcloud[:, 3]))
confidence_avg = float(np.mean(pointcloud[:, 3]))
confidence_std = float(np.std(pointcloud[:, 3]))
confidence_max = float(np.max(pointcloud[:, 3]))
except Exception as e:
print("\n", path, e)
error = True
error_message = str(e)
except ValueError as e:
print("\n", path, e)
error = True
error_message = str(e)
values = {}
values["number_of_points"] = number_of_points
values["confidence_min"] = confidence_min
values["confidence_avg"] = confidence_avg
values["confidence_std"] = confidence_std
values["confidence_max"] = confidence_max
values["error"] = error
values["error_message"] = error_message
return values
def process_ply_entry(entry):
path, qr_code, height, weight = entry
print(path)
if os.path.exists(path) == False:
print("\n", "File {} does not exist!".format(path), "\n")
return
try:
pointcloud = utils.load_pcd_as_ndarray(path)
targets = np.array([height, weight])
pickle_filename = os.path.basename(path).replace(".ply", ".p")
qrcode_path = os.path.join(base_path, "ply", qr_code)
# print('qr code path: ' + qrcode_path)
# if not os.path.exists(qrcode_path):
os.mkdir(qrcode_path)
print('creating path')
pickle_output_path = os.path.join(qrcode_path, pickle_filename)
pickle.dump((pointcloud, targets),
open(pickle_output_path, "wb"))
except BaseException as e:
print(e)
pass
def execute_command_preprocess(preprocess_pcds=True, preprocess_jpgs=False):
print("Preprocessing data-set...")
# Create the base-folder.
datetime_path = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
base_path = os.path.join(preprocessed_root_path, datetime_path)
os.mkdir(base_path)
os.mkdir(os.path.join(base_path, "pcd"))
os.mkdir(os.path.join(base_path, "jpg"))
# Process the filtered PCDs.
if preprocess_pcds == True:
entries = execute_command_filterpcds()["results"]
print("Found {} PCDs. Processing...".format(len(entries)))
bar = progressbar.ProgressBar(max_value=len(entries))
for index, entry in enumerate(entries):
bar.update(index)
path = entry["path"]
if os.path.exists(path) == False:
print("\n", "File {} does not exist!".format(path), "\n")
continue
pointcloud = utils.load_pcd_as_ndarray(path)
targets = np.array(
[float(value) for value in entry["targets"].split(",")])
qrcode = entry["qrcode"]
pickle_filename = entry["id"].replace(".pcd", ".p")
qrcode_path = os.path.join(base_path, "pcd", qrcode)
if os.path.exists(qrcode_path) == False:
os.mkdir(qrcode_path)
pickle_output_path = os.path.join(qrcode_path, pickle_filename)
pickle.dump((pointcloud, targets), open(pickle_output_path, "wb"))
bar.finish()
# Process the filtered JPGs.
if preprocess_jpgs == True:
entries = execute_command_filterjpgs()["results"]
print("Found {} JPGs. Processing...".format(len(entries)))
bar = progressbar.ProgressBar(max_value=len(entries))
for index, entry in enumerate(entries):
bar.update(index)
path = entry["path"]
if os.path.exists(path) == False:
print("\n", "File {} does not exist!".format(path), "\n")
continue
image = cv2.imread(path)
targets = np.array(
[float(value) for value in entry["targets"].split(",")])
qrcode = entry["qrcode"]
pickle_filename = entry["id"].replace(".jpg", ".p")
qrcode_path = os.path.join(base_path, "jpg", qrcode)
if os.path.exists(qrcode_path) == False:
os.mkdir(qrcode_path)
pickle_output_path = os.path.join(qrcode_path, pickle_filename)
pickle.dump((image, targets), open(pickle_output_path, "wb"))
bar.finish()
def process_pcd_entry(entry):
path = entry["artifact_path"]
if os.path.exists(path) == False:
print("\n", "File {} does not exist!".format(path), "\n")
return
pointcloud = utils.load_pcd_as_ndarray(path)
targets = np.array([entry["height"], entry["weight"]])
qrcode = entry["qr_code"]
pickle_filename = os.path.basename(entry["artifact_path"]).replace(".pcd", ".p")
qrcode_path = os.path.join(base_path, "pcd", qrcode)
if os.path.exists(qrcode_path) == False:
os.mkdir(qrcode_path)
pickle_output_path = os.path.join(qrcode_path, pickle_filename)
pickle.dump((pointcloud, targets), open(pickle_output_path, "wb"))
def process_artifacts(artifacts):
# Create database connection.
db_connector = dbutils.connect_to_main_database()
# Load the model first.
model = load_model(model_path)
model_name = model_path.split("/")[-2]
# Evaluate and create SQL-statements.
bar = progressbar.ProgressBar(max_value=len(artifacts))
for artifact_index, artifact in enumerate(artifacts):
bar.update(artifact_index)
# Execute SQL statement.
try:
# Load the artifact and evaluate.
artifact_id, pcd_path, target_height, qrcode = artifact
pcd_array = utils.load_pcd_as_ndarray(pcd_path)
pcd_array = utils.subsample_pointcloud(pcd_array, 10000)
mse, mae = model.evaluate(np.expand_dims(pcd_array, axis=0),
np.array([target_height]),
verbose=0)
if qrcode in qrcodes_train:
misc = "training"
else:
misc = "nottraining"
# Create an SQL statement.
sql_statement = ""
sql_statement += "INSERT INTO artifact_quality (type, key, value, artifact_id, misc)"
sql_statement += " VALUES(\'{}\', \'{}\', \'{}\', \'{}\', \'{}\');".format(
model_name, "mae", mae, artifact_id, misc)
# Call database.
result = db_connector.execute(sql_statement)
except psycopg2.IntegrityError:
print("Already in DB. Skipped.", pcd_path)
except ValueError:
print("Skipped.", pcd_path)
bar.finish()
def execute_command_preprocess():
print("Preprocessing data-set...")
# Create the base-folder.
datetime_path = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
base_path = os.path.join(preprocessed_root_path, datetime_path)
os.mkdir(base_path)
entries = execute_command_filterpcds()["results"]
print("Found {} PCDs. Processing...".format(len(entries)))
bar = progressbar.ProgressBar(max_value=len(entries))
for index, entry in enumerate(entries):
bar.update(index)
pointcloud = utils.load_pcd_as_ndarray(entry["path"])
targets = np.array(
[float(value) for value in entry["targets"].split(",")])
qrcode = entry["qrcode"]
pickle_filename = entry["id"].replace(".pcd", ".p")
qrcode_path = os.path.join(base_path, qrcode)
if os.path.exists(qrcode_path) == False:
os.mkdir(qrcode_path)
pickle_output_path = os.path.join(qrcode_path, pickle_filename)
pickle.dump((pointcloud, targets), open(pickle_output_path, "wb"))
bar.finish()
def process_artifacts(artifacts, process_index):
# Create database connection.
db_connector = dbutils.connect_to_main_database()
# Load the model first.
model_weights_path = [
x for x in glob.glob((os.path.join(model_path, "*")))
if x.endswith("-model-weights.h5")
][0]
model_details_path = [
x for x in glob.glob((os.path.join(model_path, "*")))
if x.endswith("-details.p")
][0]
model_name = model_path.split("/")[-1]
model_details = pickle.load(open(model_details_path, "rb"))
pointcloud_target_size = model_details["dataset_parameters"][
"pointcloud_target_size"]
pointcloud_subsampling_method = model_details["dataset_parameters"][
"pointcloud_subsampling_method"]
target_key = model_details["dataset_parameters"]["output_targets"][0]
model = load_model(model_weights_path, pointcloud_target_size)
# Evaluate and create SQL-statements.
for artifact_index, artifact in enumerate(
tqdm(artifacts, position=process_index)):
# Unpack fields.
artifact_id, pcd_path = artifact
# Check if there is already an entry.
select_sql_statement = ""
select_sql_statement += "SELECT COUNT(*) FROM artifact_result"
select_sql_statement += " WHERE artifact_id='{}'".format(
artifact_id)
select_sql_statement += " AND model_name='{}'".format(model_name)
select_sql_statement += " AND target_key='{}'".format(target_key)
results = db_connector.execute(select_sql_statement,
fetch_one=True)[0]
# There is an entry. Skip
if results != 0:
continue
# Execute SQL statement.
try:
# Load the artifact and evaluate.
pcd_path = pcd_path.replace("/whhdata/qrcode",
"/localssd/qrcode")
pcd_array = utils.load_pcd_as_ndarray(pcd_path)
pcd_array = utils.subsample_pointcloud(
pcd_array,
pointcloud_target_size,
subsampling_method=pointcloud_subsampling_method)
value = model.predict(np.expand_dims(pcd_array, axis=0),
verbose=0)[0][0]
# Create an SQL statement.
sql_statement = ""
sql_statement += "INSERT INTO artifact_result (model_name, target_key, value, artifact_id)"
sql_statement += " VALUES(\'{}\', \'{}\', \'{}\', \'{}\');".format(
model_name, target_key, value, artifact_id)
# Call database.
result = db_connector.execute(sql_statement)
except psycopg2.IntegrityError as e:
#print("Already in DB. Skipped.", pcd_path)
pass
except ValueError as e:
#print("Skipped.", pcd_path)
pass
def store_results(scan_path, db_connection_file, destination_folder):
#db_connection_file = str(sys.argv[2])
#destination_folder = str(sys.argv[3])
# Get the path to the scan.
#scan_path = sys.argv[1]
scan_path_split = scan_path.split("/")
scan_qrcode = scan_path_split[-3]
scan_timestamp = scan_path_split[-1]
# Get the paths to the artifacts.
glob_search_path = os.path.join(scan_path, "pc", "*.pcd")
pcd_paths = glob.glob(glob_search_path)
if len(pcd_paths) == 0:
print("No artifacts found. Aborting...")
exit(1)
# Prepare results dictionary.
results = Bunch()
results.scan = Bunch()
results.scan.qrcode = scan_qrcode
results.scan.timestamp = scan_timestamp
results.model_results = []
main_connector = dbutils.connect_to_main_database(db_connection_file)
# Select models from model table where active=True in json_metadata
select_models = "SELECT * FROM model WHERE (json_metadata->>'active')::BOOLEAN IS true;"
models = main_connector.execute(select_models, fetch_all=True)
# Go through the models from the models-file.
#with open("/home/mmatiaschek/whhdata/models.json") as json_file:
for model in models:
model_name = model[0]
# Locate the weights of the model.
weights_search_path = os.path.join("/home/smahale/whhdata/models",
model_name, "*")
weights_paths = [
x for x in glob.glob(weights_search_path) if "-weights" in x
]
if len(weights_paths) == 0:
continue
weights_path = weights_paths[0]
entry = model[3]
# Get the model parameters.
input_shape = entry["input_shape"]
output_size = entry["output_size"]
hidden_sizes = entry["hidden_sizes"]
#hidden_sizes = [512, 256, 128]
subsampling_method = entry["subsampling_method"]
# Load the model.
#print(weights_path, input_shape, output_size, hidden_sizes)
try:
model = modelutils.load_pointnet(weights_path, input_shape,
output_size, hidden_sizes)
except:
print("Failed!", weights_path)
continue
#print("Worked!", weights_path)
# Prepare the pointclouds.
pointclouds = []
for pcd_path in pcd_paths:
pointcloud = utils.load_pcd_as_ndarray(pcd_path)
pointcloud = utils.subsample_pointcloud(
pointcloud,
target_size=input_shape[0],
subsampling_method="sequential_skip")
pointclouds.append(pointcloud)
pointclouds = np.array(pointclouds)
# Predict.
predictions = model.predict(pointclouds)
# Prepare model result.
model_result = Bunch()
model_result.model_name = model_name
# Store measure result.
model_result.measure_result = Bunch()
model_result.measure_result.mean = str(np.mean(predictions))
model_result.measure_result.min = str(np.min(predictions))
model_result.measure_result.max = str(np.max(predictions))
model_result.measure_result.std = str(np.std(predictions))
# Store artifact results.
model_result.artifact_results = []
for pcd_path, prediction in zip(pcd_paths, predictions):
artifact_result = Bunch()
#artifact_result.path = pcd_path
artifact_result.path = '/'.join(pcd_path.split('/')[4:])
artifact_result.prediction = str(prediction[0])
model_result.artifact_results.append(artifact_result)
results.model_results.append(model_result)
results_json_string = json.dumps(results)
#print(results_json_string)
results_json_object = json.loads(results_json_string)
filename = "{0}/{1}-{2}-{3}-{4}.json".format(destination_folder,
pcd_paths[0].split('/')[3],
scan_qrcode, scan_timestamp,
random.randint(10000, 99999))
# Add the results to a json file in destination_folder
with open(filename, 'w') as json_file:
json.dump(results_json_object, json_file, indent=2)
