def from_points_edges(points, eds):
""" eds = [[p0, p1, cleft, cright, btype], ....] """
npoints = ct.c_int(len(points))
points = list_to_c(concat(points), float)
neds = ct.c_int(len(eds))
eds = list_to_c(concat(eds), int)
ret = ct.c_void_p()
ccall(cport.g2_from_points_edges, npoints, points, neds, eds,
ct.byref(ret))
return ret
def closest_points(obj, pts, proj):
npts = ct.c_int(len(pts))
pts = list_to_c(concat(pts), 'float')
ret = (ct.c_double * len(pts))()
ccall(cport.c2_closest_points, obj, npts, pts, proj, ret)
it = iter(ret)
return [[a, b] for a, b in zip(it, it)]
def contour_partition(obj, step, algo, a0, keepbnd,
nedges, crosses, keeppts, start, end):
""" step: [double]*n, where n dependes on algo:
algo = "const" => n = 1,
algo = "ref_points" => n = 3*k
algo = "ref_weights/lengths" => n = 2*k
nedges: None or forced number of resulting edges
"""
# options
nstep = ct.c_int(len(step))
step = list_to_c(step, "float")
a0 = ct.c_double(a0)
keepbnd = ct.c_int(keepbnd)
nedges = ct.c_int(nedges) if nedges is not None else ct.c_int(-1)
ncrosses = ct.c_int(len(crosses))
crosses = list_to_c(crosses, "void*")
nkeeppts = ct.c_int(len(keeppts))
keeppts = list_to_c(concat(keeppts), float)
start = list_to_c(start, float) if start is not None else None
end = list_to_c(end, float) if end is not None else None
# call
ret = ct.c_void_p()
ccall(cport.c2_partition, obj, algo,
nstep, step, a0, keepbnd, nedges,
ncrosses, crosses,
nkeeppts, keeppts,
start, end,
ct.byref(ret))
return ret
def build_tri_grid(verts, nedge, bnds):
verts = list_to_c(concat(verts), float)
nedge = ct.c_int(nedge)
bnds = list_to_c(supplement(bnds, 3), int)
ret = ct.c_void_p()
ccall(cport.g2_tri_grid, verts, nedge, bnds, ct.byref(ret))
return ret
def build_from_points(pts, force_closed, bnds):
bnds = list_to_c(supplement(bnds, len(pts)), int)
force_closed = ct.c_int(force_closed)
npts = ct.c_int(len(pts))
pts = list_to_c(concat(pts), float)
ret = ct.c_void_p()
ccall(cport.c2_frompoints, npts, pts, bnds, force_closed, ct.byref(ret))
return ret
def spline(pts, bnds, nedges):
bnds = list_to_c(supplement(bnds, len(pts)), int)
npts = ct.c_int(len(pts))
pts = list_to_c(concat(pts), float)
nedges = ct.c_int(nedges)
ret = ct.c_void_p()
ccall(cport.c2_spline, npts, pts, nedges, bnds, ct.byref(ret))
return ret
def map_grid(base_obj, target_obj, base_points, target_points, snap,
bt_from_contour, algo, is_reversed, rinvalid, cb):
npoints = min(len(base_points), len(target_points))
base_points = base_points[:npoints]
target_points = target_points[:npoints]
npoints = ct.c_int(npoints)
base_points = list_to_c(concat(base_points), float)
target_points = list_to_c(concat(target_points), float)
bt_from_contour = ct.c_int(bt_from_contour)
is_reversed = ct.c_int(is_reversed)
rinvalid = ct.c_int(rinvalid)
ret = ct.c_void_p()
ccall_cb(cport.g2_map_grid, cb, base_obj, target_obj, npoints, base_points,
target_points, snap, bt_from_contour, algo, is_reversed, rinvalid,
ct.byref(ret))
return ret
def from_points_cells(points, cls, bedges):
"""
cls = [[p1, p2, p3, ...], [p1, p2, ....]]
bedges: [[p1, p2, btype], ...]
"""
npoints = ct.c_int(len(points))
points = list_to_c(concat(points), float)
ncells = ct.c_int(len(cls))
cellsizes = list_to_c(map(len, cls), int)
cellvert = list_to_c(concat(cls), int)
nbedges = ct.c_int(len(bedges))
bedges = list_to_c(concat(bedges), int)
ret = ct.c_void_p()
ccall(cport.g2_from_points_cells, npoints, points, ncells, cellsizes,
cellvert, nbedges, bedges, ct.byref(ret))
return ret
def revolve(g2obj, vec, phivals, center_tri, bt1, bt2):
vec = list_to_c(concat(vec), float)
nphivals = ct.c_int(len(phivals))
phivals = list_to_c(phivals, float)
center_tri = ct.c_int(center_tri)
bt1 = ct.c_int(bt1)
bt2 = ct.c_int(bt2)
ret = ct.c_void_p()
ccall(cport.g3_revolve, g2obj, vec, nphivals, phivals, center_tri, bt1,
bt2, ct.byref(ret))
return ret
def tetrahedral_fill(sobjs, constrs, pts, pt_sizes, cb):
nsobjs = ct.c_int(len(sobjs))
sobjs = list_to_c(sobjs, 'void*')
nconstrs = ct.c_int(len(constrs))
constrs = list_to_c(constrs, 'void*')
npts = ct.c_int(len(pts))
pts = list_to_c(concat(pts), float)
pt_sizes = list_to_c(pt_sizes, float)
ret = ct.c_void_p()
ccall_cb(cport.g3_tetrahedral_fill, cb, nsobjs, sobjs, nconstrs, constrs,
npts, pts, pt_sizes, ct.byref(ret))
return ret
def closest_points(obj, pts, proj):
npts = ct.c_int(len(pts))
pts = list_to_c(concat(pts), 'float')
ret = (ct.c_double * len(pts))()
if proj == "vertex":
proj = ct.c_int(0)
elif proj == "edge":
proj = ct.c_int(1)
else:
raise ValueError
ccall(cport.g2_closest_points, obj, npts, pts, proj, ret)
it = iter(ret)
return [[a, b] for a, b in zip(it, it)]
def extract_subcontours(obj, plist):
nplist = ct.c_int(len(plist))
plist = list_to_c(concat(plist), float)
ret = (ct.c_void_p * (nplist.value - 1))()
ccall(cport.c2_extract_subcontours, obj, nplist, plist, ret)
return list(ret)