def get_plotting_vtx(vertex_lst):
leftmost, rightmost, top, bottom = Point_2(), Point_2(), Point_2(
), Point_2()
CGAL_Convex_hull_2.ch_n_point(vertex_lst, top) # maximal y coordinate.
CGAL_Convex_hull_2.ch_e_point(vertex_lst,
rightmost) # maximal x coordinate.
CGAL_Convex_hull_2.ch_s_point(vertex_lst, bottom) # minimal y coordinates
CGAL_Convex_hull_2.ch_w_point(vertex_lst, leftmost) # minimal x coordinate
lt, rt = leftmost.x(), rightmost.x()
tp, btm = top.y(), bottom.y()
draw_pt_list = []
for pair in product([lt, rt], [tp, btm]):
draw_pt_list.append(pair)
# left_btm_x, left_btm_y= draw_pt_list[1]
delta_x = (lt + rt) / 2 - 0
delta_y = (tp + btm) / 2 - 0
ch_height = tp - btm
ch_width = rt - lt
return ch_height, ch_width, delta_x, delta_y
def to_cgal_point(pt):
if isinstance(pt, Point_2):
return pt
elif isinstance(pt, Point):
return Point_2(pt.x, pt.y)
elif isinstance(pt, (tuple, list)):
assert len(pt) == 2
return Point_2(*pt)
else:
raise TypeError("Don't know how to make a CGAL Point_2 from", pt)
def point_location(sector, target):
try:
points = []
for p in sector[::-1]:
points.append(Point_2(p[0],p[1]))
target = Point_2(targets[0], targets[1])
v = bounded_side_2(points, target)
return v
except:
return -1
def create():
DT = Constrained_Delaunay_triangulation_2()
pnts = [Point_2(0.0, 0.0), Point_2(1.0, 0.0), Point_2(1.0, 1.0)]
vhs = [DT.insert(pnt) for pnt in pnts]
DT.insert_constraint(vhs[0], vhs[1])
DT.insert_constraint(vhs[1], vhs[2])
DT.remove_incident_constraints(vhs[1])
return DT
def main():
# Construct two non-intersecting nested polygons
polygon1 = [
Point_2(0, 0),
Point_2(2, 0),
Point_2(2, 2),
Point_2(0, 2)
]
polygon2 = [
Point_2(0.5, 0.5),
Point_2(1.5, 0.5),
Point_2(1.5, 1.5),
Point_2(0.5, 1.5)
]
# Insert the polygons into a constrained triangulation
cdt = Constrained_Delaunay_triangulation_2()
insert_polygon(cdt, polygon1)
insert_polygon(cdt, polygon2)
# Mark facest that are inside the domain bounded by the polygon
face_info = mark_domain(cdt)
plot_triangulated_polygon(cdt, face_info)
def to_CGAL_points(points):
CGAL_pts = []
for pt in points:
CGAL_pt = Point_2(pt[0], pt[1])
CGAL_pts.append(CGAL_pt)
return CGAL_pts
def test_cgal_link_walk():
DT = Constrained_Delaunay_triangulation_2()
xys = np.array([[0, 0], [1, 0], [0, 1], [1, 2]], 'f8')
# in some versions, Point_2 is picky that it gets doubles,
# not ints.
pnts = [Point_2(xy[0], xy[1]) for xy in xys]
vhs = [DT.insert(p) for p in pnts]
DT.insert_constraint(vhs[0], vhs[2])
##
res0 = cgal_line_walk.line_walk(DT, vhs[0], vhs[1])
assert not DT.is_constrained(res0[0][1])
res1 = cgal_line_walk.line_walk(DT, vhs[0], vhs[2])
assert DT.is_constrained(res1[0][1])
assert len(cgal_line_walk.line_conflicts(DT, p1=[5, 5], p2=[5, 6])) == 0
assert len(cgal_line_walk.line_conflicts(DT, p1=[0.5, -0.5],
p2=[0.5, 0.5])) == 0
assert len(cgal_line_walk.line_conflicts(DT, p1=[-0.5, 0.5], p2=[0.5, 0.5
])) > 0
res3 = cgal_line_walk.line_conflicts(DT, p1=[0, -1], p2=[2, 1])
assert len(res3) > 0
assert res3[0][0] == 'v'
def get_sub_segments(p0, p1):
cdt = Constrained_Delaunay_triangulation_2()
for s0, s1 in zip(p0, p1):
cdt.insert_constraint(Point_2(s0[0], s0[1]), Point_2(s1[0], s1[1]))
d = {v: i for i, v in enumerate(cdt.finite_vertices())}
subsegments = []
for edge in cdt.finite_edges():
if cdt.is_constrained(edge):
v0 = edge[0].vertex(cdt.ccw(edge[1]))
v1 = edge[0].vertex(cdt.cw(edge[1]))
subsegments.append((d[v0], d[v1]))
points = [(p.x(), p.y()) for p in cdt.points()]
return points, subsegments
def graphWithOpenCV(G, pos, k, extraPt):
title = "2D Lattice and a Single Voronoi Domain using OpenCV"
vorPts = []
img = np.ones((int(W * 0.65), int(W * 0.85), 3), dtype=np.uint8) * 255
j = W // (np.ceil(np.sqrt(k)).astype(int) * 1.6)
center = _center(k)
x = (pos[(center, center)][0] + extraPt.x())
y = (pos[(center, center)][1] + extraPt.y())
pts = getVoronoiDomainVertices(G, pos, Point_2(float(x), float(y)))
for e in G.edges:
start = (int(j * pos[e[0]][0]), int(j * pos[e[0]][1]))
end = (int(j * pos[e[1]][0]), int(j * pos[e[1]][1]))
_drawEdge(img, start, end)
for n in G.nodes:
_drawNode(img, (int(j * pos[n][0]), int(j * pos[n][1])))
_drawNode(img, (int(j * x), int(j * y)), True)
var = {vorPts.append((int(j * p.x()), int(j * p.y()))) for p in pts}
cv.polylines(img, [np.array(vorPts)], True, (255, 165, 0), 2)
img = img[::-1, :, :]
cv.imwrite(title + '.png', img)
cv.imshow(title, img)
def after_add_node(self, g, func_name, return_value, **k):
n = return_value
my_k = {}
# re: _index
xy = k['x']
pnt = Point_2(k['x'][0], k['x'][1])
vh = self.g.nodes['vh'][n] = self.DT.insert(pnt)
self.vh_info[vh] = n
def np2cgal(numpy_point):
from CGAL.CGAL_Kernel import \
Segment_2,\
Polygon_2,\
Point_2,\
Bbox_2,\
Iso_rectangle_2,\
do_intersect
return Point_2(numpy_point[0], numpy_point[1])
def test_2d():
print("2D Tests")
p1 = Point_2(0, 0)
p2 = Point_2(1, 2)
v1 = Vector_2(1, 1)
v2 = Vector_2(1, 2)
# operations on points
assertion(p1 + v2 == p2, 1)
assertion(p1 - v2 < p2, 2)
assertion(p2 - p1 == v2, 3)
assertion(p2 - ORIGIN == v2, 3.1)
assertion(p2 > p1, 4)
assertion(p2 >= p2, 5)
assertion(p2 <= p2, 6)
assertion(p2 != p1, 7)
# operations on vector
assertion(v1 + v2 == Vector_2(2, 3), 8)
assertion(v1 - v2 == Vector_2(0, -1), 9)
assertion(v2 * v1 == 3, 10)
assertion(v2 * 2 == Vector_2(2, 4), 11)
assertion(2 * v2 == Vector_2(2, 4), "11 bis")
assertion(v1 / 2 == Vector_2(0.5, 0.5), 12)
assertion(v1 / 2.0 == Vector_2(0.5, 0.5), 12)
assertion(-v2 == Vector_2(-1, -2), 13)
assertion(v2 != v1, 14)
# operations on ORIGIN/NULL_VECTOR
assertion(ORIGIN - p2 == -v2, 14)
assertion(ORIGIN + v2 == p2, 15)
assertion(p1 == ORIGIN, 15.1)
assertion(p1 - p1 == NULL_VECTOR, 15.2)
# test inplace operations
pt_tmp = p1.deepcopy()
pt_tmp += v2
assertion(pt_tmp == p2, 16)
vect_tmp = Vector_2(2, 3)
vect_tmp -= v1
assertion(vect_tmp == v2, 17)
def dt_insert(self, n, x=None):
"""
specify x to override the location, otherwise it comes from
the grid.
"""
if x is None:
x = self.g.nodes['x'][n]
pnt = Point_2(x[0], x[1])
assert self.g.nodes['vh'][n] in [0, None]
vh = self.g.nodes['vh'][n] = self.DT.insert(pnt)
self.vh_info[vh] = n
def insert(self, *args):
if len(args) == 2:
x, y = args
w = 1
elif len(args) == 3:
x, y, w = args
else:
print(args)
return
pt = Point_2(x, y)
self._V.insert(Weighted_point_2(pt, w))
def __init__(self, points, alpha):
if len(points) < 4:
raise ValueError('Not enough points to compute an alpha shape.')
self.area = 0
self.alpha = alpha
self.points = [Point_2(*p) for p in points]
self.tri = Delaunay_triangulation_2()
self.tri.insert(self.points)
self.triangles = []
self._add_triangles(self.tri.finite_faces())
self.saved = None
self.points_added = False
def execute_cgal(pts, res, origin, size):
"""Performs CGAL-NN on the input points.
First it removes any potential duplicates from the
input points, as these would cause issues with the
dictionary-based attribute mapping.
Then, it creates CGAL Point_2 object from these points,
inserts them into a CGAL Delaunay_triangulation_2, and
performs interpolation using CGAL natural_neighbor_coordinate_2
by finding the attributes (Z coordinates) via the dictionary
that was created from the deduplicated points.
"""
from CGAL.CGAL_Kernel import Point_2
from CGAL.CGAL_Triangulation_2 import Delaunay_triangulation_2
from CGAL.CGAL_Interpolation import natural_neighbor_coordinates_2
s_idx = np.lexsort(pts.T); s_data = pts[s_idx,:]
mask = np.append([True], np.any(np.diff(s_data[:,:2], axis = 0), 1))
deduped = s_data[mask]
cpts = list(map(lambda x: Point_2(*x), deduped[:,:2].tolist()))
zs = dict(zip([tuple(x) for x in deduped[:,:2]], deduped[:,2]))
tin = Delaunay_triangulation_2()
for pt in cpts: tin.insert(pt)
ras = np.zeros([res[1], res[0]])
yi = 0
for y in np.arange(origin[1], origin[1] + res[1] * size, size):
xi = 0
for x in np.arange(origin[0], origin[0] + res[0] * size, size):
nbrs = [];
qry = natural_neighbor_coordinates_2(tin, Point_2(x, y), nbrs)
if qry[1] == True:
z_out = 0
for nbr in nbrs:
z, w = zs[(nbr[0].x(), nbr[0].y())], nbr[1] / qry[0]
z_out += z * w
ras[yi, xi] = z_out
else: ras[yi, xi] = -9999
xi += 1
yi += 1
return ras
def gen_grid(ncols=10, nrows=3):
vhs = np.zeros((nrows, ncols), object)
DT = Constrained_Delaunay_triangulation_2()
for row in range(nrows):
for col in range(ncols):
vhs[row, col] = DT.insert(Point_2(col, row))
for row in range(nrows - 1):
for col in range(ncols):
DT.insert_constraint(vhs[row, col], vhs[row + 1, col])
for row in range(nrows):
for col in range(ncols - 1):
DT.insert_constraint(vhs[row, col], vhs[row, col + 1])
return vhs, DT
def interpolate(pt):
tr = cdt.locate(Point_2(pt[0], pt[1]))
v1 = tr.vertex(0).point().x(), tr.vertex(0).point().y()
v2 = tr.vertex(1).point().x(), tr.vertex(1).point().y()
v3 = tr.vertex(2).point().x(), tr.vertex(2).point().y()
vxs = [v1, v2, v3]
if (pt[0], pt[1]) in vxs:
try: zs[(pt[0], pt[1])]
except: return False
tr_area = triangle_area(v1, v2, v3)
if tr_area == False: return False
ws = [triangle_area((pt[0], pt[1]), v2, v3) / tr_area,
triangle_area((pt[0], pt[1]), v1, v3) / tr_area,
triangle_area((pt[0], pt[1]), v2, v1) / tr_area]
try: vx_zs = [zs[vxs[i]] for i in range(3)]
except: return False
return vx_zs[0] * ws[0] + vx_zs[1] * ws[1] + vx_zs[2] * ws[2]
def alpha_shape_with_cgal(coords, alpha):
"""
Compute the alpha shape of a set of points.
Retrieved from http://blog.thehumangeo.com/2014/05/12/drawing-boundaries-in-python/
:param coords : Coordinates of points
:param alpha: List of alpha values to influence the gooeyness of the border. Smaller numbers don't fall inward as much as larger numbers.
Too large, and you lose everything!
:return: Shapely.MultiPolygons which is the hull of the input set of points
"""
logger = logging.getLogger("my_hull")
try:
from CGAL import CGAL_Alpha_shape_2
from CGAL.CGAL_Kernel import Point_2, Polygon_2, Vector_2
except:
logger.error("CGAL library must be install to use this option, use an other HULL_METHOD")
raise
alpha_value = np.mean(alpha)
# Convert to CGAL point
points = [Point_2(pt[0], pt[1]) for pt in coords]
# Compute alpha shape
a = CGAL_Alpha_shape_2.Alpha_shape_2()
a.make_alpha_shape(points)
a.set_alpha(alpha_value)
a.set_mode(CGAL_Alpha_shape_2.REGULARIZED)
alpha_shape_edges = [a.segment(it) for it in a.alpha_shape_edges()]
alpha_shape_vertices = [(vertex.point().x(), vertex.point().y()) for vertex in a.alpha_shape_vertices()]
if len(alpha_shape_vertices) == 0:
poly_shp = Polygon()
else:
rings = find_rings(alpha_shape_vertices, alpha_shape_edges)
polygons_list = find_polygons(rings)
if not polygons_list:
poly_shp = Polygon()
elif len(polygons_list) > 1 :
poly_shp = MultiPolygon(polygons_list)
else :
poly_shp = Polygon(polygons_list[0])
return poly_shp
def main():
# Construct two non-intersecting nested polygons
polygon1 = [Point_2(0, 0), Point_2(2, 0), Point_2(2, 2), Point_2(0, 2)]
polygon2 = [
Point_2(0.5, 0.5),
Point_2(1.5, 0.5),
Point_2(1.5, 1.5),
Point_2(0.5, 1.5)
]
polyhedron1 = [
Point_3(1, 1, -1),
Point_3(1, -1, -1),
Point_3(-1, -1, -1),
Point_3(-1, -1, 1),
Point_3(-1, 1, 1),
Point_3(-1, 1, -1),
Point_3(1, 1, 1),
Point_3(1, -1, 1)
]
# Insert the polygons into a constrained triangulation
cdt = Constrained_Delaunay_triangulation_2()
insert_polygon(cdt, polygon1)
insert_polygon(cdt, polygon2)
# Insert the polyhedron into a triangulation
cdt2 = Delaunay_triangulation_3()
insert_polyhedron(cdt2, polyhedron1)
# Mark facest that are inside the domain bounded by the polygon
face_info = mark_domain(cdt)
#plot_triangulated_polygon(cdt, face_info)
fig = plt.figure(figsize=(10, 10))
ax = fig.gca(projection='3d')
ax.set_xlim3d(-1.1, 1.1)
ax.set_ylim3d(-1.1, 1.1)
ax.set_zlim3d(-1.1, 1.1)
plot_triangulated_polyhedron(ax, cdt2)
def getVoronoiDomainVertices(G, pos, extraLoc):
points, vert = [], []
for n in G.nodes:
points.append(Point_2(pos[n][0], pos[n][1]))
points.append(extraLoc)
vd = Voronoi_diagram_2(points)
assert (vd.is_valid())
lr = vd.locate(extraLoc)
if lr.is_face_handle():
ec_start = lr.get_face_handle().outer_ccb()
if ec_start.hasNext():
done = ec_start.next()
while 1:
i = ec_start.next()
v = _getNextVoronoiVertex(i, False)
if v is not False:
vert.append(v)
if i == done:
break
return np.array(vert)
def build_cgal_cdt(self):
"""
Builds the constrained delaunay triangulation in CGAL
"""
# Now find the real triangulation using CGAL
print "Building constrained Delaunay triangulation"
DT = Constrained_Delaunay_triangulation_2()
self.DT = DT
#dtri.x = self.X[:,0]
#dtri.y = self.X[:,1]
vh = np.zeros((len(self.X), ), 'object')
self.vh_info = {}
print "Adding points"
for n, xy in enumerate(self.X): #range(len(dtri.x)):
pnt = Point_2(xy[0], xy[1]) # dtri.x[n], dtri.y[n]
vh[n] = DT.insert(pnt)
self.vh_info[vh[n]] = n
print "Adding constraints"
for a, b in self.edges:
DT.insert_constraint(vh[a], vh[b])
# Now populate tri with the triangulation that's in DT
if cgal_bindings == 'old':
self.DT_Nedges = len(DT.edges)
self.DT_Nfaces = len(DT.faces)
else:
# New bindings don't explicitly expose number_of_edges because
# it's actually part of the triangulation datastructure.
# naive approach:
self.DT_Nedges = 0
for e in DT.finite_edges():
self.DT_Nedges += 1
self.DT_Nfaces = DT.number_of_faces()
from __future__ import print_function
from CGAL.CGAL_Kernel import Point_2
from CGAL.CGAL_Triangulation_2 import Triangulation_2
from CGAL.CGAL_Triangulation_2 import Triangulation_2_Vertex_circulator
from CGAL.CGAL_Triangulation_2 import Triangulation_2_Vertex_handle
points = []
points.append(Point_2(1, 0))
points.append(Point_2(3, 2))
points.append(Point_2(4, 5))
points.append(Point_2(9, 8))
points.append(Point_2(7, 4))
points.append(Point_2(5, 2))
points.append(Point_2(6, 3))
points.append(Point_2(10, 1))
t = Triangulation_2()
t.insert(points)
vc = t.incident_vertices(t.infinite_vertex())
if vc.hasNext():
done = vc.next()
iter = Triangulation_2_Vertex_handle()
while (1):
iter = vc.next()
print(iter.point())
if iter == done:
break
import matplotlib.pyplot as plt
from fealpy.mesh.TriangleMesh import TriangleMesh
from CGAL.CGAL_Kernel import Point_2, Segment_2
from CGAL.CGAL_Triangulation_2 import Constrained_Delaunay_triangulation_2
import meshio
def insert_segments(cdt, segs):
'''Insert some segments into cdt, here the segs maybe instected
'''
pass
p0 = Point_2(0.1, 0.1)
p1 = Point_2(0.8, 0.9)
p2 = Point_2(0.1, 0.8)
p3 = Point_2(0.8, 0.2)
cdt = Constrained_Delaunay_triangulation_2()
cdt.insert_constraint(p0, p1)
cdt.insert_constraint(p2, p3)
d = {j: i for i, j in enumerate(cdt.finite_vertices())}
vs = [v for v in cdt.finite_vertices()]
for edge in cdt.finite_edges():
if cdt.is_constrained(edge):
v0 = edge[0].vertex(cdt.ccw(edge[1]))
v1 = edge[0].vertex(cdt.cw(edge[1]))
print((d[v0], d[v1]))
def compute_alpha_shape(points, alpha):
"""
Uses CGAL to compute the alpha shape (a concave hull) of a set of points.
The alpha shape will not contain any interiors.
Parameters
----------
points : (Mx2) array
The x and y coordinates of the points
alpha : float
Influences the shape of the alpha shape. Higher values lead to more
edges being deleted.
Returns
-------
alpha_shape : polygon
The computed alpha shape as a shapely polygon
"""
points_cgal = [Point_2(*p) for p in points]
as2 = Alpha_shape_2(points_cgal, 0, REGULAR)
as2.set_alpha(alpha)
edges = []
for e in as2.alpha_shape_edges():
segment = as2.segment(e)
edges.append([[segment.vertex(0).x(),
segment.vertex(0).y()],
[segment.vertex(1).x(),
segment.vertex(1).y()]])
edges = np.array(edges)
e1s = edges[:, 0].tolist()
e2s = edges[:, 1].tolist()
polygons = []
while len(e1s) > 0:
polygon = []
current_point = e2s[0]
polygon.append(current_point)
del e1s[0]
del e2s[0]
while True:
try:
i = e1s.index(current_point)
except ValueError:
break
current_point = e2s[i]
polygon.append(current_point)
del e1s[i]
del e2s[i]
polygons.append(polygon)
polygons = [Polygon(p) for p in polygons if len(p) > 2]
# largest_polygon = max(polygons, key=lambda p: p.area)
# alpha_shapes = [{'exterior': largest_polygon, 'interiors': []}]
#
# for p in polygons:
# for a in alpha_shapes:
# if a['exterior'] != p and a['exterior'].contains(p):
# a['interiors'].append(p)
# elif a['exterior'] != p:
# alpha_shape.append({'exterior': p, 'interiors': []})
alpha_shape = MultiPolygon(polygons).buffer(0)
return alpha_shape
Constrained_Delaunay_triangulation_2_Edge)
from CGAL.CGAL_Kernel import (Point_2, Segment_2)
# 1. The CGAL constrained delaunay triangulation wrapped in the bindings
# appears to allow intersections, constructing an approximate new vertex
##
# Do I get access to the intersection flag?
# probably not, it's a template parameter
DT = Constrained_Delaunay_triangulation_2()
xy = [[0, 0], [1, 0], [1, 1], [0, -1], [2, 0], [2, 1], [2, 2]]
points = [Point_2(x, y) for x, y in xy]
vh = [DT.insert(p) for p in points]
DT.insert_constraint(vh[0], vh[1])
DT.insert_constraint(vh[1], vh[2])
DT.insert_constraint(vh[1], vh[4])
# DT.insert_constraint(vh3,vh2) # causes a new vertex to be created
# #
def plot_dt(DT, ax=None):
segs = []
weights = []
from __future__ import print_function
from CGAL.CGAL_Kernel import Point_2
from CGAL.CGAL_Triangulation_2 import Constrained_Delaunay_triangulation_2
from CGAL.CGAL_Triangulation_2 import Constrained_Delaunay_triangulation_2_Vertex_handle
from CGAL import CGAL_Mesh_2
cdt = Constrained_Delaunay_triangulation_2()
#construct a constrained triangulation
va = cdt.insert(Point_2(5., 5.))
vb = cdt.insert(Point_2(-5., 5.))
vc = cdt.insert(Point_2(4., 3.))
vd = cdt.insert(Point_2(5., -5.))
ve = cdt.insert(Point_2(6., 6.))
vf = cdt.insert(Point_2(-6., 6.))
vg = cdt.insert(Point_2(-6., -6.))
vh = cdt.insert(Point_2(6., -6.))
cdt.insert_constraint(va, vb)
cdt.insert_constraint(vb, vc)
cdt.insert_constraint(vc, vd)
cdt.insert_constraint(vd, va)
cdt.insert_constraint(ve, vf)
cdt.insert_constraint(vf, vg)
cdt.insert_constraint(vg, vh)
cdt.insert_constraint(vh, ve)
print("Number of vertices before: ", cdt.number_of_vertices())
#make it conforming Delaunay
CGAL_Mesh_2.make_conforming_Delaunay_2(cdt)
from __future__ import print_function
from CGAL.CGAL_Kernel import Polygon_2
from CGAL.CGAL_Kernel import Point_2
from CGAL import CGAL_Polyline_simplification_2
from CGAL.CGAL_Polyline_simplification_2 import Stop_below_count_ratio_threshold
from CGAL.CGAL_Polyline_simplification_2 import Squared_distance_cost
from CGAL.CGAL_Polyline_simplification_2 import PS2_Constrained_Delaunay_triangulation_plus_2
from CGAL.CGAL_Polyline_simplification_2 import PS2_Constrained_Delaunay_triangulation_plus_2_Constraint_id
from CGAL.CGAL_Polyline_simplification_2 import PS2_Constrained_Delaunay_triangulation_plus_2_Vertex_handle
ptlst = []
ptlst.append(Point_2(0, 0))
ptlst.append(Point_2(0, 1))
ptlst.append(Point_2(1, 1))
# test polygon function
poly = Polygon_2(ptlst)
poly_simplified = CGAL_Polyline_simplification_2.simplify(
poly, Squared_distance_cost(), Stop_below_count_ratio_threshold(0.5))
# test point version
outlist = []
CGAL_Polyline_simplification_2.simplify(ptlst, Squared_distance_cost(),
Stop_below_count_ratio_threshold(0.5),
outlist)
# test cdt version
polyline1 = []
polyline1.append(Point_2(0, 0))
from CGAL.CGAL_Kernel import Point_2
from CGAL import CGAL_Convex_hull_2
from OpenGL.GLUT import *
from OpenGL.GL import *
from OpenGL.GLU import *
Titik = []
Titik.append(Point_2(0, 0))
Titik.append(Point_2(0, 1))
Titik.append(Point_2(1, 0))
Titik.append(Point_2(1, 1))
Titik.append(Point_2(1, 2))
Titik.append(Point_2(2, 0))
Titik.append(Point_2(2, 1))
Titik.append(Point_2(2, 2))
Titik.append(Point_2(3, 0))
Titik.append(Point_2(3, 1))
Titik.append(Point_2(4, 0))
hasil = []
CGAL_Convex_hull_2.ch_graham_andrew(Titik, hasil)
print('Titik yang convexhull :')
for i in hasil:
print('(', i.x(), ',', i.y(), ')')
def display():
glClear(GL_COLOR_BUFFER_BIT) #utk clear semua pixel
glBegin(
from __future__ import print_function
from CGAL.CGAL_HalfedgeDS import HalfedgeDS_modifier
from CGAL.CGAL_HalfedgeDS import HalfedgeDS
from CGAL.CGAL_HalfedgeDS import HalfedgeDS_decorator
from CGAL.CGAL_HalfedgeDS import ABSOLUTE_INDEXING
from CGAL.CGAL_Kernel import Point_2
# declare a modifier interfacing the incremental_builder
m = HalfedgeDS_modifier()
# define a triangle
m.begin_surface(3, 1)
m.add_vertex(Point_2(0, 0))
m.add_vertex(Point_2(0, 1))
m.add_vertex(Point_2(1, 0.5))
m.begin_facet()
m.add_vertex_to_facet(0)
m.add_vertex_to_facet(1)
m.add_vertex_to_facet(2)
m.end_facet()
hds = HalfedgeDS()
# create the triangle in P
hds.delegate(m)
print("(v,f,e) = ", hds.size_of_vertices(), hds.size_of_faces(),
divmod(hds.size_of_halfedges(), 2)[0])
# clear the modifier
m.clear()
# define another triangle, reusing vertices in the polyhedron