def __init__(self):
self.renderer = None
self.window = None
self.interactor = None
self.image = None
self.logger = logging.getLogger(get_logger_name())
self.initialize_graphics()
def read_header_file(cls, params):
'''Read a header (.hdr) file.
'''
logger = logging.getLogger(get_logger_name())
file_name = params.header_file_name
# Remove 'format' tag from xml file.
f = open(file_name, "r")
lines = f.readlines()
# Create string from xml file and parse it.
xml_string = "".join(lines)
tree = et.ElementTree(et.fromstring(xml_string))
root = tree.getroot()
transform = root.find('transform_lps')
logger.info("transform: " + str(transform.attrib))
header = Header()
header.t00 = float(transform.attrib['t00'])
header.t01 = float(transform.attrib['t01'])
header.t02 = float(transform.attrib['t02'])
header.t10 = float(transform.attrib['t10'])
header.t11 = float(transform.attrib['t11'])
header.t12 = float(transform.attrib['t12'])
header.t20 = float(transform.attrib['t20'])
header.t21 = float(transform.attrib['t21'])
header.t22 = float(transform.attrib['t22'])
return header
def __init__(self, mesh, graphics, params):
self.mesh = mesh
self.params = params
self.graphics = graphics
self.geometry = None
self.branch_geometry = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self, params):
self.params = params
self.surface = None
self.centerlines = None
self.surface_caps = None
self.graphics = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self):
self.renderer = None
self.window = None
self.interactor = None
self.colors = vtk.vtkNamedColors()
self.logger = logging.getLogger(get_logger_name())
self.initialize_graphics()
def __init__(self, params):
self.params = params
self.file_base_name = None
self.surface = None
self.graphics = None
self.boundary_edge_components = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self, params):
self.params = params
self.surface = None
self.mesh_from_vtp = None
self.graphics = None
self.boundary_faces = None
self.boundary_edges = None
self.boundary_edge_components = None
self.boundary_face_components = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self, params):
self.params = params
self.volume = None
self.graphics = None
self.paths = None
self.logger = logging.getLogger(get_logger_name())
self.greyscale_lut = None
self.hue_lut = None
self.sat_lut = None
self.colors = vtk.vtkNamedColors()
def __init__(self):
self.inlet_face_name = None
self.inlet_center = None
self.outlet_centers = None
self.outlet_face_names = None
self.geometry = None
self.branch_geometry = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self, params):
self.params = params
self.nodes = {}
self.segments = {}
self.graphics = None
self.logger = logging.getLogger(get_logger_name())
self.points = vtk.vtkPoints()
self.vertices = vtk.vtkCellArray()
self.points_polydata = None
self.lines_polydata = None
def __init__(self, params):
self.params = params
self.surface = None
self.center = None
self.mesh_from_vtp = None
self.graphics = None
self.boundary_faces = None
self.boundary_edges = None
self.boundary_edge_components = None
self.boundary_face_components = None
self.hue_lut = None
self.area_list = None
self.scalar_range = None
self.logger = logging.getLogger(get_logger_name())
def __init__(self, params):
self.params = params
self.renderer = None
self.window = None
self.interactor = None
self.segment_actors = {}
self.solver = None
self.picked_segment = None
self.picked_segments = []
self.picked_actors = []
self.colors = vtk.vtkNamedColors()
self.logger = logging.getLogger(get_logger_name())
self.initialize_graphics()
def __init__(self, params):
self.params = params
self.nodes = None
self.segments = None
self.times = None
self.min_time_index = None
self.max_time_index = None
self.graphics = None
self.logger = logging.getLogger(get_logger_name())
try:
self.points = vtk.vtkPoints()
self.vertices = vtk.vtkCellArray()
except:
self.points = None
self.vertices = None
self.params.display_geometry = False
self.points_polydata = None
self.lines_polydata = None
self.lines_segment_names = None
def __init__(self):
self.centerlines = None
self.logger = logging.getLogger(get_logger_name())
self.num_cells = None
self.num_paths = None
self.path_elems = None
self.group_elems = None
self.materials = None
self.num_seg = None
self.seg_list = None
self.group_seg = None
self.group_terminal = None
self.group_length = None
self.group_Ain = None
self.group_Aout = None
self.connectivity = None
self.seg_connectivity = None
self.seg_head = None
self.seg_rear = None
self.nodes = None
self.num_elements = None
self.user_outlet_paths = None
self.bc_list = None
self.bc_map = None
self.inflow_data = None
self.outlet_face_names = None
self.outlet_face_names_index = None
self.centerlines = None
self.centerlines_geometry = None
# Some constansts for writing the solver file.
self.solver_file_msg = "\n\n### DO NOT CHANGE THIS SECTION - generated automatically"
self.space = " "
self.endl = "\n"
#!/usr/bin/env python
"""This script extracts slices from a 3D image volume.
"""
import argparse
import sys
import os
import logging
from manage import get_logger_name, init_logging, get_log_file_name
from parameters import Parameters
from header import Header
from image import Image
from graphics import Graphics
from path import Path
logger = logging.getLogger(get_logger_name())
class Args(object):
""" This class defines the command line arguments to the generate-1d-mesh script.
"""
PREFIX = "--"
HEADER_FILE = "header_file_name"
IMAGE_FILE = "image_file_name"
PATH_FILE = "path_file_name"
def cmd(name):
""" Create an argparse command argument.
"""
return Args.PREFIX + name.replace("_", "-")
def parse_args():
def read_path_file(cls, params, graphics):
"""
Read a path (.pth) file.
"""
logger = logging.getLogger(get_logger_name())
file_name = params.path_file_name
# Remove 'format' tag from xml file.
f = open(file_name, "r")
lines = f.readlines()
# Create string from xml file and parse it.
xml_string = "".join(lines)
tree = et.ElementTree(et.fromstring(xml_string))
#tree = et.parse(file_name)
root = tree.getroot()
## Create paths.
#
paths = []
for path_t in root.iter('path'):
path_id = path_t.attrib["id"]
logger.info("Path ID: %s" % path_id)
path = Path(path_id, graphics)
pid = 1
for path_element_t in path_t.iter('path_element'):
#pid = path_element_t.attrib["id"]
path_element = PathElement(pid)
logger.info(" Element ID: %s" % pid)
pid += 1
for control_pts in path_element_t.iter('control_points'):
for point in control_pts.iter('point'):
x = point.attrib['x']
y = point.attrib['y']
z = point.attrib['z']
path_element.control_points.append([float(x),float(y),float(z)])
#_for point in control_pts
logger.info(" Number of control points: %d" % len(path_element.control_points))
#_for control_pts in path_element_t.iter('control_points'):
for path_pts in path_element_t.iter('path_points'):
for path_pt in path_pts.iter('path_point'):
pid = path_pt.attrib['id']
path_element.ids.append(pid)
for pos in path_pt.iter('pos'):
x = pos.attrib['x']
y = pos.attrib['y']
z = pos.attrib['z']
path_element.points.append([float(x),float(y),float(z)])
for tangent in path_pt.iter('tangent'):
x = tangent.attrib['x']
y = tangent.attrib['y']
z = tangent.attrib['z']
path_element.tangents.append([float(x),float(y),float(z)])
for rotation in path_pt.iter('rotation'):
x = rotation.attrib['x']
y = rotation.attrib['y']
z = rotation.attrib['z']
path_element.rotations.append([float(x),float(y),float(z)])
#_for path_pt in path_pts.iter('path_point')
#_for path_pts in path_element_t.iter('path_points')
logger.info(" Number of path points: %d" % len(path_element.points))
path.elements.append(path_element)
#_for path_element_t in path_t.iter('path_element')
length = path.get_length()
logger.info("Path length: %g" % length)
paths.append(path)
#_for path_t in root.iter('path')
return paths
def __init__(self, id, graphic):
self.id = id
self.elements = []
self.graphics = graphic
self.logger = logging.getLogger(get_logger_name())
