def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'domain': co.ListOfOptions(co.BasicOption(str)),
'constr': co.ListOfOptions(co.BasicOption(str), []),
'pts': co.ListOfOptions(co.BasicOption(float), []),
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'vertices': co.ListOfOptions(co.Point2Option()),
'nedge': co.BasicOption(int),
'bnd': co.ListOfOptions(co.BasicOption(int), [0, 0, 0])
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'points': comopt.ListOfOptions(comopt.Point2Option()),
'bnds': comopt.ListOfOptions(comopt.BasicOption(int), []),
'nedges': comopt.BasicOption(int, 100),
}
def _arguments_types(cls):
return {'name': co.BasicOption(str, None),
'source': co.ListOfOptions(co.BasicOption(str)),
'constr': co.ListOfOptions(co.BasicOption(str), []),
'pts': co.ListOfOptions(co.Point3Option(), []),
'pts_size': co.ListOfOptions(co.BasicOption(float), []),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'src': comopt.ListOfOptions(comopt.BasicOption(str)),
'fix': comopt.ListOfOptions(comopt.BasicOption(int), []),
'close': comopt.BasicOption(str, 'no'),
'shiftnext': comopt.BoolOption(False)
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'base': comopt.BasicOption(str),
'cconts': comopt.ListOfOptions(comopt.BasicOption(str), []),
'step': comopt.BasicOption(float),
'angle0': comopt.BasicOption(float, 1.),
'infdist': comopt.BasicOption(str),
'cpts': comopt.ListOfOptions(comopt.BasicOption(float), []),
'power': comopt.BasicOption(float, 2.)
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'p0': co.Point2Option((0., 0.)),
'p1': co.Point2Option((1., 1.)),
'nx': co.BasicOption(int, 3),
'ny': co.BasicOption(int, 3),
'custom_x': co.ListOfOptions(co.BasicOption(float), []),
'custom_y': co.ListOfOptions(co.BasicOption(float), []),
'bnds': co.ListOfOptions(co.BasicOption(int), [0, 0, 0, 0])
}
def _arguments_types(cls):
""" partition: increasing list of floats,
tip: 'no', 'radial'
bnd: boundary for left, bottom, right, top sections
"""
return {
'name': co.BasicOption(str, None),
'source': co.BasicOption(str),
'partition': co.ListOfOptions(co.BasicOption(float)),
'tip': co.BasicOption(str, 'no'),
'bnd': co.ListOfOptions(co.BasicOption(int), [0, 0, 0, 0])
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'p0': co.Point2Option(),
'rad': co.BasicOption(float, 1.),
'na': co.BasicOption(int, 8),
'nr': co.BasicOption(int, 4),
'coef': co.BasicOption(float, 1.),
'is_trian': co.BoolOption(True),
'custom_r': co.ListOfOptions(co.BasicOption(float), []),
'custom_a': co.ListOfOptions(co.BasicOption(float), []),
'bnd': co.BasicOption(int, 0),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'algo': comopt.BasicOption(str),
'step': comopt.ListOfOptions(comopt.BasicOption(float)),
'angle0': comopt.BasicOption(float, 1.),
'base': comopt.BasicOption(str),
'keepbnd': comopt.BoolOption(True),
'nedges': comopt.NoneOr(comopt.BasicOption(int), None),
'crosses': comopt.ListOfOptions(comopt.BasicOption(str), []),
'start': comopt.NoneOr(comopt.Point2Option(), None),
'end': comopt.NoneOr(comopt.Point2Option(), None),
'keep_pts': comopt.ListOfOptions(comopt.Point2Option(), [])
}
def _arguments_types(cls):
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'dx': comopt.BasicOption(float, 0.),
'dy': comopt.BasicOption(float, 0.),
'dz': comopt.BasicOption(float, 0.),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'src': comopt.BasicOption(str),
'plist': comopt.ListOfOptions(comopt.Point2Option()),
'project_to': comopt.BasicOption(str, 'vertex')
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'area': co.ListOfOptions(co.BasicOption(float)),
'crad': co.BasicOption(float),
'strict': co.BoolOption(False),
}
def _arguments_types(cls):
'p0 - center of rotation, angle (deg) - rotation angle'
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'p0': comopt.Point2Option(),
'angle': comopt.BasicOption(float)
}
def _arguments_types(cls):
""" [names] - list of sources contours
[new_names] - list of names for created contours
simplify - do simplification: make all nodes non-collinear
Edges will not be splitted if they have different
boundary types.
angle - minimum acute angle between edges lines
after simplification (deg)
separate - separate contour to ones with not-connected geometry
"""
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'new_names': comopt.ListOfOptions(comopt.BasicOption(str), []),
'separate': comopt.BoolOption(False),
'simplify': comopt.BoolOption(True),
'angle': comopt.BasicOption(float, 1.0),
}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'p0': comopt.Point2Option(),
'p1': comopt.Point2Option(),
'bnds': comopt.ListOfOptions(comopt.BasicOption(int),
[0, 0, 0, 0]),
}
def _arguments_types(cls):
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'p0': comopt.Point3Option((0., 0., 0.)),
'xpc': comopt.BasicOption(float, 100.),
'ypc': comopt.BasicOption(float, 100.),
'zpc': comopt.BasicOption(float, 100.),
}
def _arguments_types(cls):
return {'name': co.BasicOption(str, None),
'base': co.BasicOption(str),
'p1': co.Point2Option(),
'p2': co.Point2Option(),
'phi': co.ListOfOptions(co.BasicOption(float)),
'bt1': co.BasicOption(int, 0),
'bt2': co.BasicOption(int, 0),
'center_tri': co.BoolOption(True)
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'p0': co.Point2Option(),
'radinner': co.BasicOption(float),
'radouter': co.BasicOption(float),
'na': co.BasicOption(int),
'nr': co.BasicOption(int),
'coef': co.BasicOption(float, 1.),
'bnd': co.ListOfOptions(co.BasicOption(int), [0, 0])
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'algo': co.BasicOption(str),
'left': co.BasicOption(str),
'bot': co.BasicOption(str),
'right': co.NoneOr(co.BasicOption(str), None),
'top': co.NoneOr(co.BasicOption(str), None),
'her_w': co.ListOfOptions(co.BasicOption(float), [0., 0., 0., 0.]),
'return_invalid': co.BoolOption(False),
}
def _arguments_types(cls):
""" name - new grid name,
grid_name - source grid name,
cont_names - contours names,
is_inner - exclude inner (True) or outer (False) contour area
"""
return {
'name': co.BasicOption(str, None),
'grid_name': co.BasicOption(str),
'cont_names': co.ListOfOptions(co.BasicOption(str)),
'is_inner': co.BoolOption(),
}
def _arguments_types(cls):
""" name - modified grid name,
base - identifier of the basic grid
target - identifier of contour
base_points - points of the basic grid contour
target_poitns - points of the target contour
snap - snapping algo ("no", "add_vertices", "shift_vertices")
btypes - source of boundary features ("from_grid", "from_contour")
algo ('inverse_laplace', 'direct_laplace')
"""
return {
'name': co.BasicOption(str, None),
'base': co.BasicOption(str),
'target': co.BasicOption(str),
'base_points': co.ListOfOptions(co.Point2Option()),
'target_points': co.ListOfOptions(co.Point2Option()),
'snap': co.BasicOption(str, 'no'),
'btypes': co.BasicOption(str, 'from_contour'),
'algo': co.BasicOption(str, 'inverse_laplace'),
'is_reversed': co.BoolOption(False),
'return_invalid': co.BoolOption(False),
}
def __init__(self):
super(BuildBoundaryGrid.Option,
self).__init__(source=co.BasicOption(str),
partition=co.ListOfOptions(
co.BasicOption(float)),
direction=co.BasicOption(int),
mesh_cont=co.BasicOption(int, 0),
mesh_cont_step=co.BasicOption(float, 1.),
step_start=co.BasicOption(float, 1.),
step_end=co.BasicOption(float, 1.),
algo_acute=co.BasicOption(float, 45.),
algo_right=co.BasicOption(float, 120.),
algo_straight=co.BasicOption(float, 240.),
algo_reentr=co.BasicOption(float, 300.),
start=co.NoneOr(co.Point2Option(), None),
end=co.NoneOr(co.Point2Option(), None),
force_conf=co.BoolOption(False))
def _arguments_types(cls):
""" name - name of the new grid,
fix_bnd - whether to fix all boundary points (=False)
keepsrc - whether to remove source grids (=True)
empty_holes - keep all empty zone in 2nd grid (=False)
base - name of base grid,
plus - list of UniteOptions: entries define each next imposition
"""
return {
'name': co.BasicOption(str, None),
'fix_bnd': co.BoolOption(False),
'empty_holes': co.BoolOption(False),
'base': co.BasicOption(str),
'plus': co.ListOfOptions(UniteGrids.Option()),
'angle0': co.BasicOption(float, 1.),
'filler': co.BasicOption(str, '3')
}
def _arguments_types(cls):
"""
btop, bbot are either single value array or
int array value for each 2d cell;
bside is * None if boundary should be taken from grid2;
* [single_value] if one boundary type for everything
* [ed0_0, ed0_1, ... ed0_n, ed1_0, ed1_1, ..., edm_n]:
values for each grid2 edge for each z section
starting from bottom to top
zvals is strictly increasing
"""
return {'name': co.BasicOption(str, None),
'base': co.BasicOption(str),
'zvals': co.ListOfOptions(co.BasicOption(float)),
'bbot': co.ListCompressedOption([0]),
'btop': co.ListCompressedOption([0]),
'bside': co.NoneOr(co.BasicOption(int), None)
}
def _arguments_types(cls):
""" names - list of sources
"""
return {'names': comopt.ListOfOptions(comopt.BasicOption(str))}
def _arguments_types(cls):
return {
'name': comopt.BasicOption(str, None),
'sources': comopt.ListOfOptions(comopt.BasicOption(str)),
}
def _arguments_types(cls):
return {'names': comopt.ListOfOptions(comopt.BasicOption(str))}
def _arguments_types(cls):
return {
'names': comopt.ListOfOptions(comopt.BasicOption(str)),
'p1': comopt.Point2Option(),
'p2': comopt.Point2Option(),
}
def _arguments_types(cls):
return {
'name': co.BasicOption(str, None),
'opt': co.ListOfOptions(cls.Option())
}
