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: