def to_face_graph(self, val=1):
""" Returns a Graph representation of the mesh faces by index.
:param val: number of coincident points for neighborness.
:type val: int
:returns: A Graph of face indexes.
:rtype: Graph
::
quadmesh.to_face_graph(2)
"""
from decodes.extensions.graph import Graph
graph = Graph()
graph.naked_nodes = []
for f1 in range(len(self.faces)):
for f2 in range(len(self.faces)):
if f1 != f2:
count = 0
for index in self.faces[f2]:
if index in self.faces[f1]:
count+=1
if count >= val:
graph.add_edge(f1,f2)
if len(graph.edges[f1]) < len(self.faces[f1]):
if f1 not in graph.naked_nodes:
graph.naked_nodes.append(f1)
return graph
def rebuild_edges(self):
# create a new empty graph and copy over existing nodes
ngraph = Graph()
# for every point in the old graph:
for p1 in self.nodes:
# for each of the other points nearest to this one:
for p2 in self.nearest_to(p1):
ngraph.add_edge(p1,p2,bidirectional=False)
# update the nodes and edges of this proximity graph
self.nodes = ngraph.nodes
self.edges = ngraph.edges
def rebuild_edges(self):
# create a new empty graph and copy over existing nodes
ngraph = Graph()
# for every point in the old graph:
for p1 in self.nodes:
# for each of the other points nearest to this one:
for p2 in self.nearest_to(p1):
ngraph.add_edge(p1, p2, bidirectional=False)
# update the nodes and edges of this proximity graph
self.nodes = ngraph.nodes
self.edges = ngraph.edges
def to_pt_graph(self):
""" Returns a Graph representation of the mesh points by index.
:returns: A Graph of point indexes.
:rtype: Graph
::
quadmesh.to_pt_graph()
"""
graph = Graph()
for index in range(len(self.pts)):
for face in self.faces:
for px in face:
if index in face and index!=px: graph.add_edge(index, px)
return graph
def __init__(self, bds, r):
self.r = r
self.r_sqr = r * r
self.cell_size = r / m.sqrt(2)
self.dom_x, self.dom_y = bds.ival_x, bds.ival_y
self.len_row = int(m.ceil(self.dom_x.b / self.cell_size))
self.len_col = int(m.ceil(self.dom_y.b / self.cell_size))
self.cells = {}
self.graph = Graph()
for xi in range(self.len_row):
for yi in range(self.len_col):
self.cells[(xi, yi)] = []
for cell in self.cells:
if cell[0] < self.len_row and cell[1] < self.len_col:
self.graph.add_edge(cell, (cell[0], cell[1] + 1))
self.graph.add_edge(cell, (cell[0] + 1, cell[1] + 1))
self.graph.add_edge(cell, (cell[0] + 1, cell[1]))
if 0 < cell[0]:
self.graph.add_edge(cell, (cell[0] - 1, cell[1] + 1))
def __init__(self, bds, r):
self.r = r
self.r_sqr = r*r
self.cell_size = r/m.sqrt(2)
self.dom_x, self.dom_y = bds.ival_x, bds.ival_y
self.len_row = int(m.ceil(self.dom_x.b/self.cell_size))
self.len_col = int(m.ceil(self.dom_y.b/self.cell_size))
self.cells = {}
self.graph = Graph()
for xi in range(self.len_row):
for yi in range(self.len_col):
self.cells[(xi,yi)] = []
for cell in self.cells:
if cell[0]<self.len_row and cell[1]<self.len_col:
self.graph.add_edge(cell, (cell[0], cell[1]+1))
self.graph.add_edge(cell, (cell[0]+1, cell[1]+1))
self.graph.add_edge(cell, (cell[0]+1, cell[1]))
if 0<cell[0]: self.graph.add_edge(cell, (cell[0]-1, cell[1]+1))
class Poisson_Sampler():
def __init__(self, bds, r):
self.r = r
self.r_sqr = r*r
self.cell_size = r/m.sqrt(2)
self.dom_x, self.dom_y = bds.ival_x, bds.ival_y
self.len_row = int(m.ceil(self.dom_x.b/self.cell_size))
self.len_col = int(m.ceil(self.dom_y.b/self.cell_size))
self.cells = {}
self.graph = Graph()
for xi in range(self.len_row):
for yi in range(self.len_col):
self.cells[(xi,yi)] = []
for cell in self.cells:
if cell[0]<self.len_row and cell[1]<self.len_col:
self.graph.add_edge(cell, (cell[0], cell[1]+1))
self.graph.add_edge(cell, (cell[0]+1, cell[1]+1))
self.graph.add_edge(cell, (cell[0]+1, cell[1]))
if 0<cell[0]: self.graph.add_edge(cell, (cell[0]-1, cell[1]+1))
def grid_coord(self, p):
return (int(m.floor(p.x/self.cell_size)), int(m.floor(p.y/self.cell_size)))
def in_bds(self, p):
return p.x in self.dom_x and p.y in self.dom_y
def in_nbd(self, p):
index = self.grid_coord(p)
if len(self.cells[index]):return True
for ci in self.graph.edges[index]:
if ci in self.cells:
for pt in self.cells[ci]:
if p.distance2(pt) <= self.r_sqr:
return True
return False
def run(self, max_cycles=5000, k=30):
def put_point(p):
process_list.append(p)
sample_points.append(p)
self.cells[self.grid_coord(p)].append(p)
def gen_random(p, r):
rr = random.uniform(r, 2*r)
rt = random.uniform(0, 2*m.pi)
return Point(p.x+rr*m.sin(rt), p.y+rr*m.cos(rt))
process_list = []
sample_points = []
x0 = Point(self.dom_x.eval(random.random()), self.dom_y.eval(random.random()))
put_point(x0)
cycles = 0
while len(process_list):
process_pt =random.choice(process_list)
process_list.remove(process_pt)
coord = self.grid_coord(process_pt)
for i in range(k):
check_pt = gen_random(process_pt, self.r)
if self.in_bds(check_pt) and not self.in_nbd(check_pt) :
put_point(check_pt)
cycles+=1
if cycles > max_cycles:
print 'stopped after {} cycles'.format(max_cycles)
break
return sample_points
class Poisson_Sampler():
def __init__(self, bds, r):
self.r = r
self.r_sqr = r * r
self.cell_size = r / m.sqrt(2)
self.dom_x, self.dom_y = bds.ival_x, bds.ival_y
self.len_row = int(m.ceil(self.dom_x.b / self.cell_size))
self.len_col = int(m.ceil(self.dom_y.b / self.cell_size))
self.cells = {}
self.graph = Graph()
for xi in range(self.len_row):
for yi in range(self.len_col):
self.cells[(xi, yi)] = []
for cell in self.cells:
if cell[0] < self.len_row and cell[1] < self.len_col:
self.graph.add_edge(cell, (cell[0], cell[1] + 1))
self.graph.add_edge(cell, (cell[0] + 1, cell[1] + 1))
self.graph.add_edge(cell, (cell[0] + 1, cell[1]))
if 0 < cell[0]:
self.graph.add_edge(cell, (cell[0] - 1, cell[1] + 1))
def grid_coord(self, p):
return (int(m.floor(p.x / self.cell_size)),
int(m.floor(p.y / self.cell_size)))
def in_bds(self, p):
return p.x in self.dom_x and p.y in self.dom_y
def in_nbd(self, p):
index = self.grid_coord(p)
if len(self.cells[index]): return True
for ci in self.graph.edges[index]:
if ci in self.cells:
for pt in self.cells[ci]:
if p.distance2(pt) <= self.r_sqr:
return True
return False
def run(self, max_cycles=5000, k=30):
def put_point(p):
process_list.append(p)
sample_points.append(p)
self.cells[self.grid_coord(p)].append(p)
def gen_random(p, r):
rr = random.uniform(r, 2 * r)
rt = random.uniform(0, 2 * m.pi)
return Point(p.x + rr * m.sin(rt), p.y + rr * m.cos(rt))
process_list = []
sample_points = []
x0 = Point(self.dom_x.eval(random.random()),
self.dom_y.eval(random.random()))
put_point(x0)
cycles = 0
while len(process_list):
process_pt = random.choice(process_list)
process_list.remove(process_pt)
coord = self.grid_coord(process_pt)
for i in range(k):
check_pt = gen_random(process_pt, self.r)
if self.in_bds(check_pt) and not self.in_nbd(check_pt):
put_point(check_pt)
cycles += 1
if cycles > max_cycles:
print 'stopped after {} cycles'.format(max_cycles)
break
return sample_points
