def setup_data(
reconstruction: Dict[str, Any],
global_parameters: Dict[str, Any]
) -> Tuple[str, Data]:
""" Construct a Data for extracting features from a single reconstruction.
Parameters
----------
reconstruction : The reconstruction to be setup. Must specify an swc_path
global_parameters : any cross-reconstruction feature parameters
Returns
-------
identifier : a label for this reconstruction
data suitable for feature extraction
"""
parameters: Dict[str, Any] = {}
identifier = reconstruction.get("identifier", reconstruction.get("swc_path"))
swc_path = reconstruction.pop("swc_path")
morphology = morphology_from_swc(swc_path)
parameters.update(hydrate_parameters(global_parameters))
parameters.update(hydrate_parameters(reconstruction))
return identifier, Data(morphology, **parameters)
def collect_inputs(args: Dict[str,Any]) -> Dict[str,Any]:
"""
Parameters
----------
args: dict of InputParameters
Returns
-------
dict with string keys:
morphology: Morphology object
soma_marker_z: z value from the marker file
soma_depth: soma depth
cut_thickness: slice thickness
"""
morphology = morphology_from_swc(args["swc_path"])
soma_marker = get_soma_marker_from_marker_file(args["marker_path"])
soma_depth = args["soma_depth"]
cut_thickness = args["cut_thickness"]
return {
"morphology": morphology,
"soma_marker_z": soma_marker["z"],
"soma_depth": soma_depth,
"cut_thickness": cut_thickness,
}
def collect_inputs(working_bucket: str, run_prefix: str,
morphology_scaled_key: str,
gradient_field_key: str) -> Dict[str, Any]:
"""
Gather from AWS the inputs required to run the depth field module.
Parameters
----------
working_bucket : The name of this pipeline's working bucket
run_prefix : This run's resources (within the working bucket) have keys
beginning with this prefix.
morphology_scaled_key : identifier for the scaled corrected morphology
gradient_field_key: identifier for the gradient field
Returns
-------
morphology : Morphology object of scale corrected reconstruction
gradient_field : xarray object of the gradient field
"""
# boto3 get bytes from s3 working buckets
gradient_field_response = s3.get_object(Bucket=working_bucket,
Key=gradient_field_key)
gradient_field = xr.open_dataarray(gradient_field_response["Body"].read())
swc_file_response = s3.get_object(Bucket=working_bucket,
Key=morphology_scaled_key)
morphology = morphology_from_swc(swc_file_response["Body"])
return morphology, gradient_field
def run_layered_point_depths(
swc_path: str,
depth: Dict,
layers: List[Dict],
step_size: float,
max_iter: int,
output_path: str
):
morpho = morphology_from_swc(swc_path)
gradient_field: xr.DataArray = xr.open_dataarray(depth["gradient_field_path"])
depth_field: xr.DataArray = xr.open_dataarray(depth["depth_field_path"])
setup_layers(layers)
step_size = depth["pia_sign"] * step_size
if depth["soma_origin"]:
soma = morpho.get_soma()
translate_field(
gradient_field,
soma["x"],
soma["y"],
inplace=True
)
translate_field(
depth_field,
soma["x"],
soma["y"],
inplace=True
)
depth_interp = setup_interpolator(
depth_field, None, method="linear",
bounds_error=False, fill_value=None)
dx_interp = setup_interpolator(
gradient_field, "dx", method="linear",
bounds_error=False, fill_value=None)
dy_interp = setup_interpolator(
gradient_field, "dy", method="linear",
bounds_error=False, fill_value=None)
outputs = []
for node in morpho.nodes():
outputs.append(get_node_intersections(
node,
depth_interp,
dx_interp,
dy_interp,
layers,
step_size,
max_iter
))
depths = LayeredPointDepths.from_dataframe(pd.DataFrame(outputs))
depths.to_csv(output_path)
gradient_field.close()
depth_field.close()
return {"output_path": output_path}
def collect_inputs(working_bucket: str, run_prefix: str,
reconstruction_id: int) -> Dict[str, Any]:
"""
Gather from AWS the inputs required to run the scale correction module.
Parameters
----------
working_bucket : str
name of this pipeline's working bucket
run_prefix : str
identifier for the run
reconstruction_id: int
identifier for reconstruction being processed
Returns
-------
dict with string keys:
morphology: Morphology object
soma_marker_z: z value from the marker file
soma_depth: soma depth
cut_thickness: slice thickness
"""
input_json_key = f"{run_prefix}/{reconstruction_id}.json"
input_json_response = s3.get_object(Bucket=working_bucket,
Key=input_json_key)
input_data = json.load(input_json_response["Body"])
swc_key = f"{run_prefix}/{input_data['swc_file']}"
soma_marker_key = f"{run_prefix}/{input_data['marker_file']}"
swc_response = s3.get_object(
Bucket=working_bucket,
Key=swc_key,
)
soma_marker_response = s3.get_object(
Bucket=working_bucket,
Key=soma_marker_key,
)
morphology = morphology_from_swc(swc_response["Body"])
soma_marker = compute_scale_correction.get_soma_marker_from_marker_file(
soma_marker_response["Body"])
return {
"morphology": morphology,
"soma_marker_z": soma_marker["z"],
"soma_depth": input_data["cell_depth"],
"cut_thickness": input_data["cut_thickness"],
}
def test_morphology_from_data_file_by_node_type(node_types=None):
morphology = swc.morphology_from_swc(test_file)
nodes = morphology.get_node_by_types(node_types)
for node in nodes:
# unfortunately, pandas automatically promotes numeric types to float in to_dict
node['parent'] = int(node['parent'])
node['id'] = int(node['id'])
node['type'] = int(node['type'])
node_id_cb = lambda node: node['id']
parent_id_cb = lambda node: node['parent']
axon_only_morphology = Morphology(nodes, node_id_cb, parent_id_cb)
return axon_only_morphology
def test_end_to_end(self):
cmd = [
'python', '-m', 'neuron_morphology.transforms.affine_transformer.'
'apply_affine_transform'
]
for key, value in self.input.items():
cmd.append(f'--{key}')
cmd.append(f'{value}')
sp.check_call(cmd)
transformed_swc = os.path.join(self.test_dir, self.output_swc_name)
tf_morph = morphology_from_swc(transformed_swc)
for node in tf_morph.nodes():
assert np.allclose([node['x'], node['y'], node['z']],
self.transformed_vector[node['id']])
def run_upright_angle(
gradient_path: str,
swc_path: str,
node: Optional[List[float]] = None,
):
try:
gradient_field = xr.open_dataarray(gradient_path)
except IOError:
raise IOError(
f"Cannot find file with the gradient field in {gradient_path}")
morph = morphology_from_swc(swc_path)
output = calculate_transform(gradient_field, morph, node)
output["upright_transform_dict"] = output.pop(
"upright_transform").to_dict()
return output
def collect_inputs(working_bucket: str, run_prefix: str,
reconstruction_id: int, upright_swc_key: str):
md_json_key = f"{run_prefix}/{reconstruction_id}.json"
md_json_response = s3.get_object(Bucket=working_bucket, Key=md_json_key)
metadata = json.load(md_json_response["Body"])
marker_key = f"{run_prefix}/{metadata['marker_file']}"
ccf_key = 'top_view_paths_10.h5'
swc_response = s3.get_object(
Bucket=working_bucket,
Key=upright_swc_key,
)
marker_response = s3.get_object(
Bucket=working_bucket,
Key=marker_key,
)
ccf_response = s3.get_object(
Bucket=working_bucket,
Key=ccf_key,
)
morphology = morphology_from_swc(swc_response["Body"])
soma_marker = read_soma_marker(marker_response["Body"])
ccf_data = BytesIO(ccf_response["Body"].read())
ccf_soma_location = dict(zip(['x', 'y', 'z'], metadata["ccf_soma_xyz"]))
slice_transform = AffineTransform.from_list(metadata['slice_transform'])
return {
'morphology': morphology,
'soma_marker': soma_marker,
'ccf_soma_location': ccf_soma_location,
'slice_transform': slice_transform,
'slice_image_flip': metadata['slice_image_flip'],
'ccf_path': ccf_data,
}
def main():
parser = ArgSchemaParser(schema_type=InputParameters,
output_schema_type=OutputParameters)
args = cp.deepcopy(parser.args)
logging.getLogger().setLevel(args.pop("log_level"))
if 'slice_transform_dict' in args:
slice_transform = aff.AffineTransform.from_dict(
args['slice_transform_dict'])
elif 'slice_transform_list' in args:
slice_transform = aff.AffineTransform.from_list(
args['slice_transform_list'])
else:
raise ValueError('must provide either an slice_transform_dict '
'or an slice_transform_list')
morphology = morphology_from_swc(args['swc_path'])
soma_marker = read_soma_marker(args['marker_path'])
ccf_soma_location = dict(zip(['x', 'y', 'z'], args["ccf_soma_location"]))
(tilt_correction, tilt_transform) = run_tilt_correction(
morphology,
soma_marker,
ccf_soma_location,
slice_transform,
args["slice_image_flip"],
args['ccf_path'],
)
output = {
'tilt_transform_dict': tilt_transform.to_dict(),
'tilt_correction': tilt_correction,
'inputs': parser.args
}
parser.output(output)
def main():
mod = ArgSchemaParser(schema_type=ApplyAffineSchema,
output_schema_type=OutputParameters)
args = mod.args
if 'affine_dict' in args:
affine_transform = AffineTransform.from_dict(args['affine_dict'])
elif 'affine_list' in args:
affine_transform = AffineTransform.from_list(args['affine_list'])
else:
raise ValueError('must provide either an affine_dict or affine_list')
morph_in = morphology_from_swc(args['input_swc'])
morph_out = affine_transform.transform_morphology(morph_in)
morphology_to_swc(morph_out, args['output_swc'])
output = {
'inputs': args,
'transformed_swc': args['output_swc'],
}
mod.output(output)
def main():
args = vars(parse_arguments(sys.argv[1:]))
if args['dir'] is None and args['swc'] is None and args['marker'] is None:
print(
"You need to provide one of the following arguments: directory, swc file, marker file"
)
sys.exit(1)
reconstruction_files = []
swc_file = None
marker_file = None
if args['dir']:
for file_name in args['dir']:
if glob.has_magic(file_name):
reconstruction_files += glob.glob(file_name)
else:
reconstruction_files.append(file_name)
swc_files = [f for f in reconstruction_files if f.endswith('.swc')]
marker_files = [
f for f in reconstruction_files if f.endswith('.marker')
]
if len(swc_files) > 1 or len(marker_files) > 1:
print(
"You cannot choose a directory with more than one swc or marker file"
)
sys.exit(1)
else:
if len(swc_files) == 0:
print(
"No swc file in the directory. No swc validation was done."
)
sys.exit(1)
else:
matching_morphology_name = marker_files[0].replace(
'.marker', '.swc')
if matching_morphology_name != swc_files[0]:
print(
"No matching .swc file found. No marker validation was done for:\n %s \n\n"
% marker_files[0])
sys.exit(1)
swc_file = swc_files[0]
marker_file = marker_files[0]
else:
swc_file = args['swc']
marker_file = args['marker']
report = Report()
try:
morpho = swc.morphology_from_swc(swc_file)
morpho.validate(strict=True)
report.add_swc_results(swc_file, [])
except InvalidMorphology as im:
report.add_swc_results(swc_file, im.validation_errors)
morphology = None
try:
morphology = swc.morphology_from_swc(swc_file)
morphology.validate(strict=False)
except InvalidMorphology as im:
report.add_marker_results(marker_file, [
MarkerValidationError(
"Unable to parse matching SWC file "
"to validate the marker file.", {}, "Fatal")
])
if morphology:
stats = statistics.morphology_statistics(morphology)
report.add_swc_stats(swc_file, stats)
if marker_file:
try:
results = validation.validate_marker(
marker.read_marker_file(marker_file), morphology)
report.add_marker_results(marker_file, results)
except InvalidMarkerFile as imf:
report.add_marker_results(marker_file, imf.validation_errors)
print(report.to_json())
if report.has_results():
sys.exit(1)
def collect_morphology(bucket: str, swc_key: str):
swc_response = s3.get_object(
Bucket=bucket,
Key=swc_key,
)
return morphology_from_swc(swc_response["Body"])
