def postProjectConfigurationVariant(project_hash):
project = get_project(project_hash)
variant = project.get_variant()
if request.form.get("action") == "save":
if request.form.get("variant_name") != None:
variant["name"] = request.form["variant_name"]
if request.form.get("variant_primary") != None:
variant["primary_value"] = request.form["variant_primary"]
elif request.form.get("action") == "add":
if request.form.get("variant_value") != None:
if (len(request.form["variant_value"].strip()) > 0):
variant["values"].append(request.form["variant_value"])
elif request.form.get("action") == "delete":
if request.form.get("variant_selected") != None:
if (len(request.form["variant_selected"].strip()) > 0):
variant["values"].remove(request.form["variant_selected"])
if variant["primary_value"] == request.form[
"variant_selected"]:
variant["primary_value"] = ""
project.set_variant(variant)
return redirect("/projects/" + project_hash + "/config")
def postProjectConfigurationParameters(project_hash):
project = get_project(project_hash)
parameters = project.get_parameters()
if "add" in request.form.get("action"):
parameter_key = request.form.get("action").replace("add-", "")
value_map_name = request.form.get("map_name-" + parameter_key)
value_map_value = request.form.get("map_value-" + parameter_key)
parsed_map_value = parse_numeric(value_map_value)
if parameter_key in parameters.keys() and \
value_map_name != "" and parsed_map_value is not None:
parameter_data = parameters[parameter_key]
parameter_data["value_map"][value_map_name] = parsed_map_value
project.save_parameter_data(parameter_key, parameter_data)
elif "delete" in request.form.get("action"):
parameter_key = request.form.get("action").split("---")[1]
value_map_name = request.form.get("action").split("---")[2]
if parameter_key in parameters.keys():
parameter_data = parameters[parameter_key]
del parameter_data["value_map"][value_map_name]
project.save_parameter_data(parameter_key, parameter_data)
# project.set_variant(variant)
return redirect("/projects/" + project_hash + "/config")
def getTasks(project_hash):
import cli.project
project = get_project(project_hash)
waypoint_tasks, waypoint_tasks_data = getWaypointTasks(project)
project_name = get_project_name(project_hash)
project_dto = {"hash": project_hash, "name": project_name}
status_filter_parameter = request.args.get('status')
if status_filter_parameter is not None:
if status_filter_parameter in [
"all", "open", "in-progress", "complete"
]:
session["tasks_status_filter"] = status_filter_parameter
if "tasks_status_filter" in session:
status_filter = session["tasks_status_filter"]
else:
status_filter = "all"
if status_filter != "all":
filtered_task_list = []
for waypoint_task in waypoint_tasks:
if waypoint_task.get("status") == status_filter:
filtered_task_list.append(waypoint_task)
waypoint_tasks = filtered_task_list
return render_template('tasks/tasks.html',
project=project_dto,
tasks=waypoint_tasks,
tasks_status_metrics=waypoint_tasks_data,
status_filter=status_filter)
def getStarredList(project_hash):
""" List of images in sample set """
import cells.images
import cli.operations
project = get_project(project_hash)
project_dto = {
"hash": project_hash,
"name": project.get_project_name()
}
starred_images = project.get_starred_images()
input_image_directory = project.get_input_image_directory()
project_images = cells.images.get_image_list(input_image_directory)
page_data = {
"title": "",
"active_nav_tab": "starred"
}
return render_template('compute/starred.html', project=project_dto,
starred_images=starred_images,
project_images=project_images, page_data=page_data)
def getComputeSettings(project_hash):
"""
Filter ->
Trace ->
Shapes
Classification
Nucleus
:param project_hash:
:return:
"""
project = get_project(project_hash)
project_dto = {
"hash": project_hash,
"name": project.get_project_name()
}
page_data = {
"title": "",
"active_nav_tab": "settings"
}
return render_template('compute/settings.html', project=project_dto,
page_data=page_data)
def getResultsIndex(project_hash):
project = get_project(project_hash)
project_dto = {
"hash": project_hash,
"name": project.get_project_name()
}
page_data = {
"title": "",
"active_nav_tab": "index"
}
output_directory = project.get_output_directory()
output_dto = {
# "cell-data": {"status": 0},
#"feature-data": {"status": 0, "files": []},
#"feature-data-filtered": {"status": 0, "files": []},
#"path-data": {"status": 0, "files": []},
#"path-data-filtered": {"status": 0, "files": []},
"cell-data-v2": {"status": 0, "files": []},
#"fastclass-data": {"status": 0, "files": []},
"fastclass-feature-data-filtered": {"status": 0, "files": []},
#"fastclass-feature-data": {"status": 0, "files": []},
}
for output_entry_name in os.listdir(output_directory):
for output_key in output_dto.keys():
if output_entry_name == "do-" + output_key:
output_dto[output_key]["status"] = 2
elif output_entry_name == "do-" + output_key + ".lock":
output_dto[output_key]["status"] = 1
for output_key in output_dto.keys():
output_inner_directory = project.get_output_directory(output_key)
if os.path.isdir(output_inner_directory):
gen_dates = []
for filename in os.listdir(output_inner_directory):
file_parts = filename.split("-")
if file_parts[0] not in gen_dates and "." not in file_parts[0]:
gen_dates.append(file_parts[0])
if len(gen_dates) > 0:
latest = sorted(gen_dates)[-1]
for filename in os.listdir(output_inner_directory):
file_parts = filename.split("-")
if file_parts[0] == latest:
output_dto[output_key]["files"].append(filename)
output_dto[output_key]["files"].sort()
return render_template('results/index.html', project=project_dto,
page_data=page_data, output=output_dto)
def getProject(project_hash):
import cells.images
import cli.operations
project = get_project(project_hash)
project_name = get_project_name(project_hash)
project_dto = {"hash": project_hash, "name": project_name}
input_image_directory = project.get_input_image_directory()
variant = project.get_variant()
dimensions = project.get_dimensions()
image_data = cells.images.get_image_collection(input_image_directory,
variant, dimensions)
# Get input image count
total_images = 0
stain_image_counts = {}
for image_data_row in image_data:
file_name = image_data_row["file_name"]
image_stain = None
for test_stain in variant.get("values", []):
if test_stain in file_name:
stain_image_counts[test_stain] = stain_image_counts.get(
test_stain, 0) + 1
image_stain = test_stain
break
if image_stain is None:
stain_image_counts["None"] = stain_image_counts.get("None", 0) + 1
total_images = total_images + 1
# Task Data
waypoint_tasks, waypoint_tasks_data = get_waypoint_tasks(project)
# Cell Data
cell_collection = cli.operations.get_cell_collection(project, image_data)
project_data_dto = {
"image_count": total_images,
"variant_data": stain_image_counts,
"task_data": waypoint_tasks_data,
"cell_count": len(cell_collection)
}
print project.get_project_hash()
return render_template('projects/overview.html',
project=project_dto,
project_data=project_data_dto)
def download_data_file(project_hash, output_type, filename):
project = get_project(project_hash)
entity_map = project.get_chain().get_entity_map()
output_directory = project.get_output_directory(output_type)
output_file = os.path.join(output_directory, filename)
return send_file(output_file, as_attachment=True)
def generate_data_file(project_hash, output_type):
project = get_project(project_hash)
entity_map = project.get_chain().get_entity_map()
output_directory = project.get_output_directory()
with open(os.path.join(output_directory, "do-" + output_type), "w") as f:
f.write(".")
return redirect("/projects/" + project_hash + "/results")
def postGetPath():
import cv2
import numpy
from skimage import graph
import cells.images.filter
project_hash = request.form['project_hash']
project = get_project(project_hash)
task_hash = request.form['task_hash']
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
task_key = task_hash_decoded.split("::")[1]
image_name = task_key
image_file = os.path.join(project.get_input_image_directory(), image_name)
point_1_x = int(request.form['point_1_x'])
point_1_y = int(request.form['point_1_y'])
point_2_x = int(request.form['point_2_x'])
point_2_y = int(request.form['point_2_y'])
start_r, start_c = point_1_y, point_1_x
end_r, end_c = point_2_y, point_2_x
start_point = point_1_y, point_1_x
end_point = point_2_y, point_2_x
input_image = cv2.imread(image_file)
cost_image = cells.images.filter.generate_cost_image_perimeter(input_image)
# image_intensity = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)
#cost_image = image_intensity.copy()
#cost_image = (numpy.max(cost_image) - cost_image)
print start_point, end_point
path_segment, cost = graph.route_through_array(cost_image, start_point,
end_point)
path = []
x_y_path = []
for e in path_segment:
path.append(e)
x_y_path.append([e[1], e[0]])
return jsonify(x_y_path)
def postProjectConfigurationDimension(project_hash, dimension_name):
project = get_project(project_hash)
if request.form.get("action") == "save":
form_data = request.form["data"]
data = json.loads(form_data)
project.save_dimension_data(dimension_name, data)
return redirect("/projects/" + project_hash + "/dimensions/" +
dimension_name)
elif request.form.get("action") == "delete":
project.delete_dimension(dimension_name)
return redirect("/projects/" + project_hash + "/config")
def createProjectConfigurationDimension(project_hash):
project = get_project(project_hash)
existing_dimensions = project.get_dimensions()
dimension_name = request.form.get("dimension_name")
dimension_type = request.form.get("dimension_type")
if (dimension_name is None or dimension_name in existing_dimensions.keys()
or len(dimension_name) < 4):
return redirect("/projects/" + project_hash + "/config")
else:
project.add_dimension(dimension_name, dimension_type)
return redirect("/projects/" + project_hash + "/dimensions/" +
dimension_name)
def getSizedImage(project_hash, width, height, image_name):
import cv2
width, height = int(width), int(height)
project = get_project(project_hash)
input_image_directory = project.get_input_image_directory()
image_path = os.path.join(input_image_directory, image_name)
input_image = cv2.imread(image_path)
resized_image = cv2.resize(input_image, (width, height))
retval, buffer = cv2.imencode('.png', resized_image)
response = make_response(buffer.tobytes())
response.headers['Content-Type'] = 'image/png'
return response
def getProjectConfigurationDimension(project_hash, dimension_name):
project = get_project(project_hash)
dimensions = project.get_dimensions()
dimension = dimensions.get(dimension_name)
project_dto = {"hash": project_hash, "name": project.get_project_name()}
dimension_dto = {
"name": dimension_name,
"type": dimension.get("type"),
"data": dimension.get("data", [])
}
page_data = {"title": "", "active_nav_tab": "config"}
return render_template('projects/dimension.html',
project=project_dto,
dimension=dimension_dto,
page_data=page_data)
def postStarredList(project_hash):
""" Add/Remove Image """
project = get_project(project_hash)
# image_filename = request.form["filename"]
if request.form.get("action") == "add":
selected_images = request.form.getlist("selected_image")
for selected_image in selected_images:
project.add_starred_image(selected_image)
project.save()
elif request.form.get("action") == "remove":
selected_image = request.form.get("selected_image")
project.remove_starred_image(selected_image)
project.save()
return redirect("/projects/" + project_hash + "/compute/starred")
def postProjectJobSettings(project_hash):
project = get_project(project_hash)
job_settings = project.get_job_settings()
for job_type_name in project.get_chain().job_types:
is_active = request.form.get("is_active-" + job_type_name)
print is_active
limit = request.form.get("limit-" + job_type_name)
starred_only = request.form.get("starred_only-" + job_type_name)
if is_active is None:
continue
job_data = job_settings[job_type_name]
job_data["is_active"] = (True if is_active == "1" else False)
job_data["limit"] = (None if limit == "0" else int(limit))
job_data["starred_only"] = (True if starred_only == "1" else False)
project.save_job_settings(job_type_name, job_data)
return redirect("/projects/" + project_hash + "/compute/system")
def getProjectConfiguration(project_hash):
project = get_project(project_hash)
project_name = get_project_name(project_hash)
project_dto = {"hash": project_hash, "name": project_name}
project_configuration_dto = {
"variant":
project.get_variant(),
"dimensions":
project.get_dimensions(),
"parameters":
project.get_parameters(),
"dep": [{
"name": "Experiment Date",
"type": "function",
"data": "parse_date"
}, {
"name": "Experiment Name",
"type": "mapping",
"data": [
{
"tokens": [],
"value": ""
},
]
}]
}
page_data = {"title": "", "active_nav_tab": "config"}
return render_template('projects/config.html',
project=project_dto,
configuration=project_configuration_dto,
page_data=page_data)
def getSystemData(project_hash):
import cli.steps.trace
import cli.jobs.job
project = get_project(project_hash)
project_dto = {
"hash": project_hash,
"name": project.get_project_name()
}
# Job Configuration
job_config_dto = []
job_settings = project.get_job_settings()
for job_type_name in project.get_chain().job_types:
job_config_dto.append({
"job_type_name": job_type_name,
"is_active": job_settings[job_type_name]["is_active"],
"limit": job_settings[job_type_name]["limit"],
"starred_only": job_settings[job_type_name]["starred_only"],
})
job_manager = cli.jobs.job.JobManager(project)
job_headers = job_manager.get_job_headers()
trace_job_metrics = job_manager.get_job_metrics()
operation_data = {
"heartbeat": None,
"heartbeat_elapsed": None,
}
for key in trace_job_metrics.keys():
operation_data[key] = {
"done": 0,
"total": 0,
"cpu_time": trace_job_metrics[key]["cpu_time"],
"avg_time": trace_job_metrics[key]["avg_time"]
}
for job_header in job_headers:
job_type = job_header["job_type"]
if job_header["status"] == "done":
operation_data[job_type]["done"] = \
operation_data[job_type].get("done", 0) + 1
operation_data[job_type]["total"] = \
operation_data[job_type].get("total", 0) + 1
heartbeat_file = os.path.join(project.get_system_directory(), "heartbeat")
if os.path.isfile(heartbeat_file):
with open(heartbeat_file, "r") as f:
heartbeat = f.read()
operation_data["heartbeat"] = heartbeat
heartbeat_dt = dateutil.parser.parse(heartbeat)
hb_elapsed = datetime.datetime.now() - heartbeat_dt
operation_data["heartbeat_elapsed"] = hb_elapsed.total_seconds()
page_data = {
"title": "",
"active_nav_tab": "system"
}
return render_template('compute/system.html', project=project_dto,
operation_data=operation_data,
job_configs=job_config_dto,
page_data=page_data)
def generate_perimeter_detail_data_file_filtered(project_hash):
project = get_project(project_hash)
entity_map = project.get_chain().get_entity_map()
output_directory = project.get_output_directory("cell-data")
output_file_key = ("path_data_filtered_export-%s.csv" %
str(datetime.datetime.now().strftime("%Y%m%d%H%M%S")))
output_file = os.path.join(output_directory, output_file_key)
variant = project.get_variant()
dimensions = project.get_dimensions()
dimension_ordered_keys = dimensions.keys()
output_rows = []
output_row = ["File Name"]
if variant.get("name") is not None:
output_row.append(variant.get("name"))
for dimension_name in dimension_ordered_keys:
output_row.append(dimension_name)
output_row.extend(["Cell Id"])
output_row.extend(["r", "c", "Point Intensity"])
output_row.extend(["norm_vec_r", "norm_vec_c"])
output_row.extend(["filter_threshold"])
output_row.extend(["width_threshold", "junction_average_intensity",
"parametric_point_1", "parametric_point_2"])
output_row.extend(["nn_entropy"])
output_rows.append(output_row)
artifact_j_detail_directory = project.get_artifacts_directory("junction-detail")
for entity_map_row in entity_map:
detail_file_key = entity_map_row["cell_id"] + ".json"
detail_file = os.path.join(artifact_j_detail_directory, detail_file_key)
if os.path.isfile(detail_file):
with open(detail_file, "r") as f:
detail_data = json.load(f)
else:
continue
for detail_row in detail_data:
output_row = [entity_map_row["file_name"]]
if variant.get("name") is not None:
output_row.append(entity_map_row.get("variant"))
for dimension_name in dimension_ordered_keys:
output_row.append(
entity_map_row.get("dimensions", {}).get(dimension_name,
""))
output_row.extend([entity_map_row["cell_id"]])
#output_row.extend([entity_map_row["cell_id"],
# entity_map_row["cell_number"], ])
output_row.extend([detail_row.get("r", ""),
detail_row.get("c", "")])
output_row.extend([detail_row.get("point_intensity", "")])
output_row.extend([detail_row.get("norm_vec_r", ""),
detail_row.get("norm_vec_c", "")])
output_row.extend([detail_row.get("filter_threshold", "")])
output_row.extend([detail_row.get("width_threshold", ""),
detail_row.get("junction_average_intensity", ""),
detail_row.get("parametric_point_1", ""),
detail_row.get("parametric_point_2", "")])
output_row.extend([detail_row.get("nn_entropy", "")])
output_rows.append(output_row)
with open(output_file, 'w') as csv_file:
csv_writer = csv.writer(csv_file)
for output_row in output_rows:
csv_writer.writerow(output_row)
return send_file(output_file, as_attachment=True)
def getProjectProblems(project_hash):
import cells.images
project = get_project(project_hash)
project_name = get_project_name(project_hash)
project_dto = {"hash": project_hash, "name": project_name}
problems = []
input_image_directory = project.get_input_image_directory()
variant = project.get_variant()
dimensions = project.get_dimensions()
if variant.get("name") is None or variant.get("name") == "":
problems.append({
"level":
"info",
"css":
"info",
"summary":
"You have not configured a variant (stain) and values for this project"
})
image_data = cells.images.get_image_collection(input_image_directory,
variant, dimensions)
# TODO: A variant value is not found in any images
stain_image_counts = {}
missing_variant_images = []
for image_data_row in image_data:
file_name = image_data_row["file_name"]
image_stain = None
for test_stain in variant.get("values", []):
if test_stain in file_name:
stain_image_counts[test_stain] = stain_image_counts.get(
test_stain, 0) + 1
image_stain = test_stain
break
if image_stain is None:
missing_variant_images.append(file_name)
for variant_value in variant.get("values", []):
if stain_image_counts.get(variant_value, 0) == 0:
problems.append({
"level":
"warning",
"css":
"warning",
"summary":
"The variant/stain '%s' did not match any images." %
variant_value
})
# Image has no variant
for missing_variant_image in missing_variant_images:
problems.append({
"level":
"warning",
"css":
"warning",
"summary":
"Image '%s' does not have a variant." % missing_variant_image
})
# Image has missing related variant image(s)
for image_data_row in image_data:
file_name = image_data_row["file_name"]
image_stain = None
for test_stain in variant.get("values", []):
if test_stain in file_name:
stain_image_counts[test_stain] = stain_image_counts.get(
test_stain, 0) + 1
image_stain = test_stain
break
missing_variants = []
if image_stain is not None:
for variant_value in variant.get("values", []):
related_file_name = file_name.replace(image_stain,
variant_value)
related_file = os.path.join(input_image_directory,
related_file_name)
if not os.path.isfile(related_file):
missing_variants.append(variant_value)
for missing_variant in missing_variants:
if missing_variant == variant.get("primary_value"):
problems.append({
"level":
"error",
"css":
"danger",
"summary":
"Missing variant with value '%s' for image '%s'. No output will be generated for this file."
% (missing_variant, file_name),
})
else:
problems.append({
"level":
"warning",
"css":
"warning",
"summary":
"Missing variant with value '%s' for image '%s'." %
(missing_variant, file_name)
})
page_data = {"title": "", "active_nav_tab": "problems"}
return render_template('projects/problems.html',
project=project_dto,
problems=problems,
page_data=page_data)
def getProjectDataSummary(project_hash):
import cells.images
import cli.operations
project = get_project(project_hash)
project_name = get_project_name(project_hash)
project_dto = {"hash": project_hash, "name": project_name}
input_image_directory = project.get_input_image_directory()
variant = project.get_variant()
dimensions = project.get_dimensions()
image_data = cells.images.get_image_collection(input_image_directory,
variant, dimensions)
# Get input image count
total_images = 0
variant_counts = {}
for image_data_row in image_data:
file_name = image_data_row["file_name"]
image_stain = None
for test_stain in variant.get("values", []):
if test_stain in file_name:
variant_counts[test_stain] = variant_counts.get(test_stain,
0) + 1
image_stain = test_stain
break
if image_stain is None:
variant_counts["None"] = variant_counts.get("None", 0) + 1
total_images = total_images + 1
dimension_counts = {}
for key, value in dimensions.iteritems():
dimension_counts[key] = {}
for image_data_row in image_data:
for key in dimensions.keys():
dimension_value = image_data_row.get("dimensions", {}).get(key)
dimension_counts[key][dimension_value] = \
dimension_counts[key].get(dimension_value, 0) + 1
# Get counts for cells
cell_collection = cli.operations.get_cell_collection(project, image_data)
cell_variant_counts = {}
for key in variant_counts.keys():
cell_variant_counts[key] = 0
cell_dimension_counts = {}
for key, value in dimensions.iteritems():
cell_dimension_counts[key] = {}
for cell_data_row in cell_collection:
variant_value = cell_data_row.get("variant")
cell_variant_counts[variant_value] = cell_variant_counts.get(
variant_value, 0) + 1
for key in dimensions.keys():
dimension_value = cell_data_row.get("dimensions", {}).get(key)
cell_dimension_counts[key][dimension_value] = \
cell_dimension_counts[key].get(dimension_value, 0) + 1
variant_name = project.get_variant()["name"]
project_data_dto = {
"image_count": total_images,
"variant_name": variant_name,
"variant_data": variant_counts,
"cell_variant_data": cell_variant_counts,
"dimension_counts": dimension_counts,
"cell_dimension_counts": cell_dimension_counts
}
page_data = {"title": "", "active_nav_tab": "data"}
return render_template('projects/data.html',
project=project_dto,
project_data=project_data_dto,
page_data=page_data)
def postTask(project_hash, task_hash):
import cells.waypoints.seeding
import cells.images
if request.form["task_action"] == "save":
project = get_project(project_hash)
input_waypoints_directory = project.get_artifacts_directory(
"waypoints")
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
image_name = task_hash_decoded.split("::")[1]
working_file_name = image_name + ".tsv-working"
working_file = os.path.join(input_waypoints_directory,
working_file_name)
waypoints = []
waypoints_raw = json.loads(request.form["waypoints"])
for point in waypoints_raw:
waypoints.append([point.get("y"), point.get("x")])
cells.waypoints.seeding.append_waypoints(working_file,
waypoints,
created_from=image_name)
elif request.form["task_action"] == "done":
project = get_project(project_hash)
input_waypoints_directory = project.get_artifacts_directory(
"waypoints")
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
image_name = task_hash_decoded.split("::")[1]
working_file_name = image_name + ".tsv-working"
working_file = os.path.join(input_waypoints_directory,
working_file_name)
finished_file = working_file.replace(".tsv-working", ".tsv")
if not os.path.isfile(working_file):
raise Exception("Tried to save a working file that didn't exist.")
if os.path.isfile(finished_file):
raise Exception("Tried to overwrite a finished waypoints file.")
shutil.move(working_file, finished_file)
elif request.form["task_action"] == "reopen":
project = get_project(project_hash)
input_waypoints_directory = project.get_artifacts_directory(
"waypoints")
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
image_name = task_hash_decoded.split("::")[1]
working_file_name = image_name + ".tsv-working"
working_file = os.path.join(input_waypoints_directory,
working_file_name)
finished_file = working_file.replace(".tsv-working", ".tsv")
if not os.path.isfile(finished_file):
raise Exception("Tried to save a finished file that didn't exist.")
if os.path.isfile(working_file):
raise Exception(
"Tried to overwrite an existing working waypoints file.")
shutil.move(finished_file, working_file)
elif request.form["task_action"] == "delete":
project = get_project(project_hash)
input_waypoints_directory = project.get_artifacts_directory(
"waypoints")
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
image_name = task_hash_decoded.split("::")[1]
working_file_name = image_name + ".tsv-working"
working_file = os.path.join(input_waypoints_directory,
working_file_name)
wp_row_raw = request.form["wp_row"]
if wp_row_raw is not None:
wp_row = int(wp_row_raw)
if wp_row > 0:
cells.waypoints.seeding.delete_waypoints(working_file, wp_row)
return redirect("/projects/" + project_hash + "/tasks/" + task_hash)
def generateCellDataFile(project_hash):
project = get_project(project_hash)
entity_map = project.get_chain().get_entity_map()
output_directory = project.get_output_directory("cell-data")
output_file_key = ("cell_data_export-%s.csv" %
str(datetime.datetime.now().strftime("%Y%m%d%H%M%S")))
output_file = os.path.join(output_directory, output_file_key)
variant = project.get_variant()
dimensions = project.get_dimensions()
dimension_ordered_keys = dimensions.keys()
output_rows = []
output_row = ["File Name", "File Root"]
if variant.get("name") is not None:
output_row.append(variant.get("name"))
for dimension_name in dimension_ordered_keys:
output_row.append(dimension_name)
output_row.extend(["Cell Id", "Cell Number",])
output_row.extend(["Image Width", "Image Height"])
output_row.extend(["Image Mean Intensity",
"Image Max Intensity",
"Image Min Intensity"])
output_row.extend(["Perimeter (Count)",
"Perimeter (Calc)",
"Perimeter (um)"])
output_row.extend(["Area", "Area (um^2)"])
output_row.extend(["Solidity",
"Circularity",
"Convex Area",
"Aspect Ratio"])
output_row.extend(["Perim. Mean Intensity",
"Perim. Max Intensity",
"Perim. Min Intensity"])
output_row.extend(["Coverage (%)",
"Linear (%)",
"Punct (%)",
"Perp (%)",
"Punct. + Perp (%)"])
output_row.extend(["Hull Aspect Ratio (a/b)",
"Hull Aspect Ratio (< 1)"])
output_rows.append(output_row)
shapes_artifact_directory = project.get_artifacts_directory("shape-factors")
image_data_artifact_directory = \
project.get_artifacts_directory("image-data")
hullar_artifact_directory = project.get_artifacts_directory("hull-ar")
for entity_map_row in entity_map:
output_row = [entity_map_row["file_name"],
entity_map_row["file_root"]]
if variant.get("name") is not None:
output_row.append(entity_map_row.get("variant"))
for dimension_name in dimension_ordered_keys:
output_row.append(
entity_map_row.get("dimensions", {}).get(dimension_name, ""))
output_row.extend([entity_map_row["cell_id"],
entity_map_row["cell_number"],])
image_data_key = entity_map_row["file_name"] + ".json"
image_data_file = os.path.join(image_data_artifact_directory,
image_data_key)
if os.path.isfile(image_data_file):
with open(image_data_file, "r") as f:
image_data = json.load(f)
# Image Data (w, h)
output_row.extend([image_data.get("width", ""),
image_data.get("height", "")])
# Image Data (Intensity)
output_row.extend([image_data.get("mean_intensity", ""),
image_data.get("max_intensity", ""),
image_data.get("min_intensity", "")])
else:
# Image Data (w, h)
output_row.extend(["", ""])
# Image Data (Intensity)
output_row.extend(["", "", ""])
## Shape Factors
shape_file_key = entity_map_row["cell_id"] + ".json"
shapes_file = os.path.join(shapes_artifact_directory, shape_file_key)
if os.path.isfile(shapes_file):
with open(shapes_file, "r") as f:
shape_data = json.load(f)
# Perimeter
output_row.extend([shape_data.get("perimeter_pixels", ""),
shape_data.get("perimeter_measured", ""),
shape_data.get("perimeter_um", "")])
# Area
output_row.extend([shape_data.get("area_measured", ""),
shape_data.get("area_um", "")])
# Others
output_row.extend([shape_data.get("solidity", ""),
shape_data.get("circularity", ""),
shape_data.get("convex_area", ""),
shape_data.get("aspect_ratio", "")])
else:
# Perimeter
output_row.extend(["", "", ""])
# Area
output_row.extend(["", ""])
# Others
output_row.extend(["", "", "", ""])
# Perimeter Intensity Data
output_row.extend(["", "", ""])
classify_artifact_directory = project.get_artifacts_directory("class-edge")
classify_file_key = entity_map_row["cell_id"] + ".json"
classify_file = os.path.join(classify_artifact_directory, classify_file_key)
if os.path.isfile(classify_file):
with open(classify_file, "r") as f:
classify_data = json.load(f)
output_row.extend([classify_data.get("percent_coverage", ""),
classify_data.get("percent_linear", ""),
classify_data.get("percent_punctate", ""),
classify_data.get("percent_perpendicular", ""),
classify_data.get("percent_punct_perp", "")])
else:
output_row.extend(["", "", "", "", ""])
## Shape Factors - Hull AR
shape_file_key = entity_map_row["cell_id"] + ".json"
hullar_file = os.path.join(hullar_artifact_directory,
shape_file_key)
if os.path.isfile(hullar_file):
with open(hullar_file, "r") as f:
hullar_data = json.load(f)
output_row.extend([hullar_data.get("hull_aspect_ratio_ab", ""),
hullar_data.get("hull_aspect_ratio", "")])
else:
output_row.extend(["", ""])
output_rows.append(output_row)
with open(output_file, 'w') as csv_file:
csv_writer = csv.writer(csv_file)
for output_row in output_rows:
csv_writer.writerow(output_row)
#output_rows.append([
# "Cell Id",
# "File Name",
# "Max Perim. Intensity",
# "Min Perim. Intensity",
# "Avg Perim. Intensity",
# "Sttdev Perim. Intensity",
# "Threshold",
# "Goodness",
# "Coverage (%)",
# "Linear (%)",
# "Punct. + Perp. (%)"
#])
return send_file(output_file, as_attachment=True)
def getTask(project_hash, task_hash):
if request.method == 'POST':
return postTask(project_hash, task_hash)
else:
import cells.waypoints.seeding
import cli.project
import cv2
project = get_project(project_hash)
# waypoint_tasks, waypoint_tasks_data = getWaypointTasks(project)
project_header = {"hash": project_hash}
task_hash_decoded = base64.urlsafe_b64decode(task_hash.encode("ascii"))
task_type = task_hash_decoded.split("::")[0]
task_key = task_hash_decoded.split("::")[1]
image_name = task_key
# Load Image Data
image_file = os.path.join(project.get_input_image_directory(),
image_name)
input_image = cv2.imread(image_file)
height, width, channels = input_image.shape
input_waypoints_directory = project.get_artifacts_directory(
"waypoints")
working_file_name = image_name + ".tsv-working"
working_file = os.path.join(input_waypoints_directory,
working_file_name)
completed_file_name = image_name + ".tsv"
completed_file = os.path.join(input_waypoints_directory,
completed_file_name)
task_status = "open"
if os.path.isfile(working_file):
task_status = "in-progress"
elif os.path.isfile(completed_file):
task_status = "complete"
# Load waypoints
if task_status == "complete":
image_waypoints = cells.waypoints.seeding.load_waypoints(
completed_file)
elif task_status == "in-progress":
image_waypoints = cells.waypoints.seeding.load_waypoints(
working_file)
else:
image_waypoints = []
row = 1
for waypoints_row in image_waypoints:
waypoints_row["row"] = row
row += 1
# Get png versions of images
working_image_wp_url = getCachedWaypointImage_v2(
input_image, image_waypoints, image_name)
working_image_url = getCachedImage(project, image_name)
view_type_parameter = request.args.get('vt')
if view_type_parameter == "review":
view_type = "review"
else:
view_type = "waypoints"
task_data = {
"hash": task_hash,
"status": task_status,
"image_name": task_key,
"image_width": height,
"image_height": width,
"image_wp_url": working_image_wp_url,
"image_url": working_image_url
}
return render_template('tasks/task.html',
project=project_header,
task=task_data,
image_url=working_image_url,
image_waypoints=image_waypoints,
view_type=view_type)
# List available projects and then quit if no project is specified
if options.project_hash is None:
print "Available project hashes: "
for project_directory_name in os.listdir(projects_root):
if not os.path.isdir(
os.path.join(projects_root, project_directory_name)):
continue
hash = project_directory_name
print " - " + hash
exit()
else:
project = get_project(options.project_hash)
job_manager = cli.jobs.job.JobManager(project)
# List available jobs
if options.job_type is None:
print "Registered job types: "
job_types = job_manager.get_job_types()
for job_type in job_types:
print " - " + job_type
elif options.job_type is not None and options.job_hash is None:
job_headers = job_manager.get_job_headers(job_type=options.job_type)
if options.job_search is not None:
