bin.closest_hc Namespace Reference

Classes
class	MyError

Functions
def	read_pts (modname, n=3, vtx=False)
def	read_data (fname, n=1, order=None)
def	output_list (listing, filename, ext, out_num=False)
def	branch_limits (branch, tol)
def	split_mesh (bivent, branch, scale, RL, nsearch=4)
def	search_cartesian (haystack, targets, n)
def	search_hcoords (lv, rv, targets, n, coord, limit, nsearch=4)
def	scale_pts (pts, scale)
def	average_angles (heart, idx, weight, p, branch)
def	correct_ang (p, branch)
def	gauss (x, var)
def	weights (dist, var)
def	average (A, idx, w)
def	dual_base (F, pull)
def	orthonormal_basis (F)
def	project (F, data, pull)
def	output_orthonormalbases (F, out)
def	interpolate_vector (data, Fs, indx, dist, n, pull, var=None)
def	interpolate_point (vec, indx, dist, n, branch, var=None)
def	push_pull (d, F, pull=False)
def	interpolate_gradient (data, Fs, indx, dist, n, pull, var=None)
def	interpolate_scalar (data, indx, dist, n, angle, var=None)
def	make_one_sided (hpts, idx, d, sindx, sval)
def	check_inputs (opts)

Variables
	parser = argparse.ArgumentParser(description='map points/data across coordinate systems')
	help
	type
	float
	default
	nargs
	choices
	int
	None
	action
	opts = parser.parse_args()
def	hpts = read_pts( opts.heart_coords, 4 )
def	branch_lims = branch_limits( opts.branch_cut, opts.branch_tol )
int	ntarg = 3
	rv
	lv
def	target_pts = read_pts( opts.coords, ntarg )
	d
	idx
string	var = 'gauss' else None
string	pull = 'to-H' in opts.operation
def	transferred
def	pts = hpts if pull else read_pts(opts.Cartesian)

Function Documentation

average()

def bin.closest_hc.average	(		A,
			idx,
			w
	)

average_angles()

def bin.closest_hc.average_angles	(		heart,
			idx,
			weight,
			p,
			branch
	)

branch_limits()

def bin.closest_hc.branch_limits	(		branch,
			tol
	)

check_inputs()

def bin.closest_hc.check_inputs

(

opts

)

correct_ang()

def bin.closest_hc.correct_ang	(		p,
			branch
	)

dual_base()

def bin.closest_hc.dual_base	(		F,
			pull
	)

gauss()

def bin.closest_hc.gauss	(		x,
			var
	)

interpolate_gradient()

def bin.closest_hc.interpolate_gradient	(		data,
			Fs,
			indx,
			dist,
			n,
			pull,
			var = None
	)

interpolate_point()

def bin.closest_hc.interpolate_point	(		vec,
			indx,
			dist,
			n,
			branch,
			var = None
	)

interpolate_scalar()

def bin.closest_hc.interpolate_scalar	(		data,
			indx,
			dist,
			n,
			angle,
			var = None
	)

interpolate_vector()

def bin.closest_hc.interpolate_vector	(		data,
			Fs,
			indx,
			dist,
			n,
			pull,
			var = None
	)

make_one_sided()

def bin.closest_hc.make_one_sided	(		hpts,
			idx,
			d,
			sindx,
			sval
	)

orthonormal_basis()

def bin.closest_hc.orthonormal_basis

(

F

)

output_list()

def bin.closest_hc.output_list	(		listing,
			filename,
			ext,
			out_num = False
	)

output_orthonormalbases()

def bin.closest_hc.output_orthonormalbases	(		F,
			out
	)

project()

def bin.closest_hc.project	(		F,
			data,
			pull
	)

push_pull()

def bin.closest_hc.push_pull	(		d,
			F,
			pull = False
	)

read_data()

def bin.closest_hc.read_data	(		fname,
			n = 1,
			order = None
	)

read_pts()

def bin.closest_hc.read_pts	(		modname,
			n = 3,
			vtx = False
	)

scale_pts()

def bin.closest_hc.scale_pts	(		pts,
			scale
	)

search_cartesian()

def bin.closest_hc.search_cartesian	(		haystack,
			targets,
			n
	)

search_hcoords()

def bin.closest_hc.search_hcoords	(		lv,
			rv,
			targets,
			n,
			coord,
			limit,
			nsearch = 4
	)

split_mesh()

def bin.closest_hc.split_mesh	(		bivent,
			branch,
			scale,
			RL,
			nsearch = 4
	)

weights()

def bin.closest_hc.weights	(		dist,
			var
	)

Variable Documentation

action

bin.closest_hc.action

branch_lims

def bin.closest_hc.branch_lims = branch_limits( opts.branch_cut, opts.branch_tol )

choices

bin.closest_hc.choices

d

bin.closest_hc.d

default

bin.closest_hc.default

float

bin.closest_hc.float

help

bin.closest_hc.help

hpts

def bin.closest_hc.hpts = read_pts( opts.heart_coords, 4 )

idx

bin.closest_hc.idx

int

bin.closest_hc.int

lv

bin.closest_hc.lv

nargs

bin.closest_hc.nargs

None

bin.closest_hc.None

ntarg

int bin.closest_hc.ntarg = 3

opts

bin.closest_hc.opts = parser.parse_args()

parser

bin.closest_hc.parser = argparse.ArgumentParser(description='map points/data across coordinate systems')

pts

def bin.closest_hc.pts = hpts if pull else read_pts(opts.Cartesian)

pull

string bin.closest_hc.pull = 'to-H' in opts.operation

rv

bin.closest_hc.rv

target_pts

def bin.closest_hc.target_pts = read_pts( opts.coords, ntarg )

transferred

def bin.closest_hc.transferred

Initial value:

=  interpolate_gradient( read_data(opts.data,3),
                    read_data(opts.F,3,opts.F_fields),
                    idx, d, opts.numfind, pull, var)

type

bin.closest_hc.type

var

string bin.closest_hc.var = 'gauss' else None