sm/surfaces
1
0
Fork 0
Code Issues Pull Requests Activity

not working, but some work done to fix cc methods

Browse Source
This commit is contained in:
William Blattman 2012-04-16 00:11:27 -07:00
parent 9a37d67ae7
commit 2bbeeb0b07
4 changed files with 472 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
surf/geometry.py
View File

@ -24,35 +24,38 @@ def cross(a, b):
k = a.x * b.y - a.y * b.x k = a.x * b.y - a.y * b.x
return Vertex(i, j, k) return Vertex(i, j, k)
class Vertex(object): class Vertex(object):
''' '''
A vertex is a position along with other information such as color, normal A vertex is a position along with other information such as color, normal
vector and texture coordinates. vector and texture coordinates.
''' '''
def __init__(self, polygon, x=0, y=0, z=0): next_id
def __init__(self, polygon, parent_id=None, x=None, y=None, z=None, es=None):
'''
'''
self.polygon = polygon self.polygon = polygon
self.parent_id = parent_id
self.x = x self.x = x
self.y = y self.y = y
self.z = z self.z = z
self.edges = [] self.edge_ids = es or []
self.id = Vertex.next_id
Vertex.next_id += 1
def __eq__(self, other): def __eq__(self, other):
if(self.x == other.x and self.y == other.y and self.z == other.z): if(self.x == other.x and self.y == other.y and self.z == other.z):
return True return True
else: else:
return False return False
def __repr__(self):
return "[%.2f, %.2f, %.2f]" % (self.x, self.y, self.z)
def __add__(self, other): def __add__(self, other):
# for now just assume type(other) = Vertex... bad, I know # for now just assume type(other) = Vertex... bad, I know
return Vertex(self.x + other.x, self.y + other.y, self.z + other.z) return Vertex(self.x + other.x, self.y + other.y, self.z + other.z)
def __radd__(self, other): def __radd__(self, other):
return other + self return other + self
# return self.__add__(other)
def __mul__(self, other): def __mul__(self, other):
if isinstance(other, Vertex): if isinstance(other, Vertex):
return cross(self, other) return cross(self, other)
@ -61,54 +64,175 @@ class Vertex(object):
else: else:
raise TypeError("{0} has an unexpected type: {1}".format( raise TypeError("{0} has an unexpected type: {1}".format(
other, type(other))) other, type(other)))
def __rmul__(self, other): def __rmul__(self, other):
return self.__mul__(other) return self.__mul__(other)
def __div__(self, other): def __div__(self, other):
# same assumption as __mult__ # same assumption as __mult__
return Vertex(self.x / other, self.y / other, self.z / other) return Vertex(self.x / other, self.y / other, self.z / other)
__truediv__ = __div__ __truediv__ = __div__
def __neg__(self): def __neg__(self):
return Vertex(-self.x, -self.y, -self.z) return Vertex(-self.x, -self.y, -self.z)
def __unicode__(self):
d = {
'id': self.id,
'parent_id': self.parent_id,
'coords': [self.x, self.y, self.z]
}
return pprint.pformat(d)
__str__ = __unicode__
__repr__ = __unicode__
class Edge(object): class Edge(object):
''' '''
''' '''
def __init__(self, polygon): next_id = 0
def __init__(self, polygon, parent_id=None, vs=None, es=None, fs=None):
'''
'''
self.polygon = polygon self.polygon = polygon
self.vertices = [] self.parent_id = parent_id
self.faces = [] self.vertex_ids = vs or []
self.edges = [] self.edge_ids = es or []
self.face_ids = fs or []
self.id = Edge.next_id
Edge.next_id += 1
def neighborFace(self, neighborFace): def neighbor_face_id(self, neighbor_face_id):
'''Get neighboring face id '''Get neighboring face id
''' '''
if neighborFace == self.faces[0]: if neighbor_face_id == self.face_ids[0]:
return self.faces[1] return self.face_ids[1]
else: else:
return self.faces[0] return self.face_ids[0]
def __unicode__(self):
d = {
'id': self.id,
'vertex_ids': self.vertex_ids,
'edge_ids': self.edge_ids,
'face_ids': self.face_ids,
}
return pprint.pformat(d)
__str__ = __unicode__
__repr__ = __unicode__
@property
def vertices(self):
return [self.polygon.vertex(v_id) for v_id in self.vertex_ids]
@property
def faces(self):
return [self.polygon.face(f_id) for f_id in self.face_ids]
def winged_edges_at_vertex(self, index):
edge_ids = []
for edge in self.edges:
if self.vertex_ids[index] in edge.vertex_ids:
edge_ids.append(edge.id)
return edge_ids
class Face(object): class Face(object):
''' '''
A face is a closed set of edges, in which a triangle face has three edges, A face is a closed set of edges,
in which a triangle face has three edges,
and a quad face has four edges. and a quad face has four edges.
''' '''
def __init__(self, polygon):
next_id = 0
def __init__(self, polygon, parent_id=None, es=None):
'''
'''
self.polygon = polygon self.polygon = polygon
self.edges = [] self.parent_id = parent_id
self.edge_ids = es or []
self.id = Face.next_id
Face.next_id += 1
def __unicode__(self):
d = {'id': self.id, 'edge_ids': self.edge_ids}
return pprint.pformat(d)
__str__ = __unicode__
__repr__ = __unicode__
def edge(self, edge_id):
return self.polygon.edge(edge_id)
@property
def edges(self):
return [self.polygon.edge(e_id) for e_id in self.edge_ids]
@property
def vertices(self):
vertices = []
for edge_id in self.edge_ids:
edge = self.polygon.edge(edge_id)
vertices.extend(edge.vertices)
return list(set(vertices))
@property
def centroid(self):
'''
'''
# gather all face vertex coords
face_vertices = self.vertices
xs = [vertex.x for vertex in face_vertices]
ys = [vertex.y for vertex in face_vertices]
zs = [vertex.z for vertex in face_vertices]
# average each vertex component
x = sum(xs) / len(xs)
y = sum(ys) / len(ys)
z = sum(zs) / len(zs)
return [x, y, z]
class Polygon(object): class Polygon(object):
''' '''
''' '''
def __init__(self, vs=None, es=None, fs=None): def __init__(self, vs=None, es=None, fs=None):
self.vertices = vs or [] self.vertices = vs or []
self.edges = es or [] self.edges = es or []
self.faces = fs or [] self.faces = fs or []
def face(self, face_id):
for face in self.faces:
if face.id == face_id:
return face
return None
def edge(self, edge_id):
for edge in self.edges:
if edge.id == edge_id:
return edge
return None
def vertex(self, vertex_id):
for vertex in self.vertices:
if vertex.id == vertex_id:
return vertex
return None
def edge_ids_with_parent(self, parent_edge_id):
child_edge_ids = []
for edge in self.edges:
if edge.parent_id == parent_edge_id:
child_edge_ids.append(edge.id)
return child_edge_ids
def __unicode__(self): def __unicode__(self):
d = { d = {
'vertices': self.vertices, 'vertices': self.vertices,
@ -118,4 +242,5 @@ class Polygon(object):
return pprint.pformat(d) return pprint.pformat(d)
__str__ = __unicode__ __str__ = __unicode__
__repr__ = __unicode__ __repr__ = __unicode__

375
surf/subd/cc.py
View File

@ -1,61 +1,101 @@
from surf.geometry import Vertex, Polygon from surf.geometry import Vertex, Edge, Face, Polygon
from copy import deepcopy
import pprint
def mid_point(self): def mid_point(edge):
vertex_objs = [self.polygon.vertices[v_id] for v_id in self.vertices] vertex_objs = [edge.vertices[v_id] for v_id in edge.vertices]
return sum(vertex_objs, Vertex()) / len(self.vertices) return sum(vertex_objs, Vertex()) / len(self.vertices)
def sub_edges(self): def sub_edges(self):
temp_p = Polygon() temp_p = Polygon()
temp_p.edges = [Edge(), Edge()] temp_p.edges = [Edge(), Edge()]
temp_p.vertices = # temp_p.vertices =
sub_edges[0].vertices = [self.vertices[0], self.edge_vertex] sub_edges[0].vertices = [self.vertices[0], self.edge_vertex]
sub_edges[1].vertices = [self.edge_vertex, self.vertices[1]] sub_edges[1].vertices = [self.edge_vertex, self.vertices[1]]
return self.__sub_edges return self.__sub_edges
def edge_vertex(self): def centroid(face, poly):
'''
'''
# gather all face vertex coords
face_vertices = face.vertices
xs = [vertex.x for vertex in face_vertices]
ys = [vertex.y for vertex in face_vertices]
zs = [vertex.z for vertex in face_vertices]
# average each vertex component
x = sum(xs) / len(xs)
y = sum(ys) / len(ys)
z = sum(zs) / len(zs)
return Vertex(poly, x, y, z)
def edge_divide(edge, poly):
''' '''
Set each edge vertices to be the average of the two neighboring Set each edge vertices to be the average of the two neighboring
face vertices and its two original end vertices. face vertices and its two original end vertices.
''' '''
# two neighboring face vertices:
neighboringFaceVertices = [p.faces[f_id].centroid for f_id in self.faces] edge_ids = poly.edge_ids_with_parent(edge.id)
neighboringFaceVertices.extend(self.vertices)
xs = [vertex.x for vertex in neighboringFaceVertices] if edge_ids:
ys = [vertex.y for vertex in neighboringFaceVertices] return edge_ids
zs = [vertex.z for vertex in neighboringFaceVertices] else:
x = sum(xs) / len(xs) # otherwise split it
y = sum(ys) / len(ys) xs = []
z = sum(zs) / len(zs) ys = []
self.__edge_vertex = Vertex(x, y, z) zs = []
self.__edge_vertex.edges.extend(self.__sub_edges) for face in edge.faces:
return self.__edge_vertex centroid_v = centroid(face, None)
xs.append(centroid_v.x)
def centroid(self): ys.append(centroid_v.y)
if not self.__centroid: zs.append(centroid_v.z)
# gather all face vertex coords
face_vertices = list(set([vertex for vertex in edge.vertices:
for edge in self.edges for vertex in edge.vertices])) xs.append(vertex.x)
xs = [vertex.x for vertex in face_vertices] ys.append(vertex.y)
ys = [vertex.y for vertex in face_vertices] zs.append(vertex.z)
zs = [vertex.z for vertex in face_vertices]
# average each vertex component
x = sum(xs) / len(xs) x = sum(xs) / len(xs)
y = sum(ys) / len(ys) y = sum(ys) / len(ys)
z = sum(zs) / len(zs) z = sum(zs) / len(zs)
self.__centroid = Vertex(x, y, z) e0 = Edge(poly)
return self.__centroid e1 = Edge(poly)
edge_vertex = Vertex(poly, x, y, z)
edge_vertex.edge_ids = [e0.id, e1.id]
e0.vertex_ids = [edge.vertices[0].id, edge_vertex.id]
e1.vertex_ids = [edge_vertex.id, edge.vertices[1].id]
e0.edge_ids = edge.winged_edges_at_vertex(0)
e0.edge_ids.append(e1.id)
e1.edge_ids = edge.winged_edges_at_vertex(1)
e1.edge_ids.append(e0.id)
e0.parent_id = edge.id
e1.parent_id = edge.id
# add all these to the new polygon
poly.edge_ids.append(e0.id)
poly.edge_ids.append(e1.id)
poly.vertices.append(edge_vertex.id)
return e0.id, e1.id, edge_vertex.id
def sub_faces(self): def sub_faces(self):
self.__setupSubDivisions() setup_sub_divisions()
return self.__sub_faces return sub_faces()
def interior_edges(self): def interior_edges(self):
self.__setupSubDivisions() setup_sub_divisions()
return self.__interior_edges return self.__interior_edges
def __setupSubDivisions(self): def setup_sub_divisions(polygon, face):
''' '''
v0 ev0 v1 v0 ev0 v1
*------e0-----* *------e0-----*
@ -67,69 +107,86 @@ def __setupSubDivisions(self):
*------e2-----* *------e2-----*
v3 ev2 v2 v3 ev2 v2
''' '''
if not self.__sub_faces:
# create empty sub_faces that will be filled with edge references # create empty sub_faces that will be filled with edge references
# below # below
# these need to at least exist so the interior edges have # these need to at least exist so the interior edges have
# something to reference # something to reference
self.__sub_faces = [Face() for edge in self.edges]
sub_faces = [Face(polygon) for edge in face.edge_ids]
if not self.__interior_edges:
# set up empty edge objects to be filled below # set up empty edge objects to be filled below
self.__interior_edges = [Edge() for edge in self.edges] interior_edges = [Edge(polygon) for edge in face.edge_ids]
# each interior edge connects the exterior edge vertex (mid-point) # # each interior edge connects the exterior edge vertex (mid-point)
# to the faceVertex (centroid) # # to the faceVertex (centroid)
for index in range(len(self.edges)): # for edge_id in range(len(face.edges)):
prevIndex = (index - 1) % len(self.edges) # prevIndex = (edge_id - 1) % len(face.edges)
nextIndex = (index + 1) % len(self.edges) # nextIndex = (edge_id + 1) % len(face.edges)
# end vertices are face centroid and currEdge edge_vertex # # end vertices are face centroid and currEdge edge_vertex
self.__interior_edges[index].vertices = [ # interior_edges[edge_id].vertices = [
self.edges[index].edge_vertex, self.centroid # face.edges[edge_id],
] # edge_vertex, self.centroid
# ]
# wing edges are the current edge's sub_edges (ordered same as # # wing edges are the current edge's sub_edges (ordered same as
# vertex order) and the prev and next interior edges # # vertex order) and the prev and next interior edges
self.__interior_edges[index].edges = [ # self.__interior_edges[index].edges = [
self.edges[index].sub_edges[0], # self.edges[index].sub_edges[0],
self.edges[index].sub_edges[1], # self.edges[index].sub_edges[1],
self.__interior_edges[prevIndex], # self.__interior_edges[prevIndex],
self.__interior_edges[nextIndex] # self.__interior_edges[nextIndex]
] # ]
# edge faces are the new sub_faces (current and next faces), the # # edge faces are the new sub_faces (current and next faces), the
# current will be define below # # current will be define below
# and the next will be defined on the next iteration (or # # and the next will be defined on the next iteration (or
# already defined on the last iteration) # # already defined on the last iteration)
self.__interior_edges[index].faces = [ # self.__interior_edges[index].faces = [
self.__sub_faces[index], # self.__sub_faces[index],
self.__sub_faces[nextIndex] # self.__sub_faces[nextIndex]
] # ]
# now reference the current edge back into the faces, # # now reference the current edge back into the faces,
# and the edge.sub_edges, and the edge.edge_vertex # # and the edge.sub_edges, and the edge.edge_vertex
# current subFace (same index as current interior edge) # # current subFace (same index as current interior edge)
# set its edges to reference the same edges used to setup the # # set its edges to reference the same edges used to setup the
# interior edge # # interior edge
# order will be pretty important on these steps... # # order will be pretty important on these steps...
self.__sub_faces[index].edges = [ # self.__sub_faces[index].edges = [
self.edges[index].sub_edges[0], # self.edges[index].sub_edges[0],
self.__interior_edges[index], # self.__interior_edges[index],
self.__interior_edges[prevIndex], # self.__interior_edges[prevIndex],
self.edges[prevIndex].sub_edges[1] # self.edges[prevIndex].sub_edges[1]
] # ]
# just set one of the vertex edges, the other belongs to # # just set one of the vertex edges, the other belongs to
# another face and will get added when that face is run # # another face and will get added when that face is run
self.edges[index].edge_vertex.edges.append( # self.edges[index].edge_vertex.edges.append(
self.__interior_edges[index]) # self.__interior_edges[index])
self.edges[index].sub_edges[0].faces.append( # self.edges[index].sub_edges[0].faces.append(
self.__sub_faces[index]) # self.__sub_faces[index])
self.edges[index].sub_edges[0].faces.append( # self.edges[index].sub_edges[0].faces.append(
self.__sub_faces[index]) # self.__sub_faces[index])
pass
def subdivide_face(poly, face):
# '''
# '''
# # find face centroid
# fc = face.centroid
# # find edge vertices
# for edge in face.edges:
# x, y, z = edge_mid_vertex(edge)
pass
def refine(poly): def refine(poly):
''' '''
@ -146,65 +203,89 @@ def refine(poly):
edges touching P, where each edge midvertex is the average of its two edges touching P, where each edge midvertex is the average of its two
endvertex vertices. Move each original vertex to the vertex endvertex vertices. Move each original vertex to the vertex
''' '''
# create a new storage container for the items
new_poly = Polygon()
# for now just test with the first face
start_face = poly.faces[0]
# go through the face vertices and add them to the new polygon
for vertex in start_face.vertices:
# truly, this needs to be a 'copy' of the vertex, I'll fix that later
new_poly.vertices.append(vertex)
# find the face centroid
# and add the face centroid to the new polygon
start_centroid = centroid(start_face, new_poly)
new_poly.vertices.append(start_centroid)
# for each edge on the face,
for edge in start_face.edges:
# divide that edge into two new edges with an edge vertex
# set their parent object as the original edge
new_e0_id, new_e1_id, edge_v_id = edge_divide(edge, new_poly)
# create a new edge connecting the centroid to the edge_vertex
centroid_to_edge = Edge(new_poly)
new_poly.edges.append(centroid_to_edge)
# set the new edge's vertex references
centroid_to_edge.vertex_ids = [edge_v_id, start_centroid.id]
# set the new edge's winged_edge references
centroid_to_edge.edge_ids = poly.edges ==> get edge by id not yet implemented... edge_v_id.edges
# set the edge vertex edge references
edge_v_id.edges.append(centroid_to_edge.id)
# set the centroid's edge reference
start_centroid.edge_ids.append(centroid_to_edge.id)
# now walk through the edges connected to the centroid
start_centroid.edges[0]
# need to get an adjacent edge, based on the the shared vertex of the
# original polygon... centroid to edge_vertex to shared point...
# start_face.neighbors
# f = sum(list(
# set(face_vertices)), Vertex()) / len(list(set(face_vertices)))
# r = sum(list(
# set(edge_mid_points)), Vertex()) / len(list(set(edge_mid_points)))
# p = vertex
# n = len(vertex.edges)
# v = (f + 2.0 * r + (n - 3.0) * p) / n
# newVertices.append(v)
# each face knows how to subdivide and create a set of subfaces, including # for vertex, newVertex in zip(poly.vertices, newVertices):
# interior edges and setup their references correctly... <- not completely # vertex.x = newVertex.x
# finished... # vertex.y = newVertex.y
p = Polygon() # vertex.z = newVertex.z
edges = [] # # so now what.........
vertices = [] # # (F + 2R + (n-3) P) / n
faces = [] # #
# # F = average of all face vertices touching P
# # R = average of all edge vertices touching P
# # P original point
# # n = number of edges connecting to P
for face in poly.faces: # p.faces = faces
for subFace in face.sub_faces: # p.vertices = vertices
faces.append(subFace) # p.edges = edges
for edge in subFace.edges:
edges.append(edge)
for vertex in edge.vertices:
vertices.append(vertex)
newVertices = [] # # plotting these in excel seems to show the correct values (at first
for vertex in poly.vertices: # # glace...)
face_vertices = []
edge_mid_points = []
for edge in vertex.edges:
edge_mid_points.append(edge.mid_point)
for face in edge.faces:
face_vertices.append(face.centroid)
f = sum(list( # # so now what.........
set(face_vertices)), Vertex()) / len(list(set(face_vertices))) # # (F + 2R + (n-3) P) / n
r = sum(list( # #
set(edge_mid_points)), Vertex()) / len(list(set(edge_mid_points))) # # F = average of all face vertices touching P
p = vertex # # R = average of all edge vertices touching P
n = len(vertex.edges) # # P original point
v = (f + 2.0 * r + (n - 3.0) * p) / n # # n = face vertices or edge vertices (should be the same number)
newVertices.append(v) # return Polygon(vertices, edges, faces)
for vertex, newVertex in zip(poly.vertices, newVertices):
vertex.x = newVertex.x
vertex.y = newVertex.y
vertex.z = newVertex.z
# so now what.........
# (F + 2R + (n-3) P) / n
#
# F = average of all face vertices touching P
# R = average of all edge vertices touching P
# P original point
# n = number of edges connecting to P
p.faces = faces
p.vertices = vertices
p.edges = edges
# plotting these in excel seems to show the correct values (at first
# glace...)
# so now what.........
# (F + 2R + (n-3) P) / n
#
# F = average of all face vertices touching P
# R = average of all edge vertices touching P
# P original point
# n = face vertices or edge vertices (should be the same number)
return Polygon(vertices, edges, faces)

180
surf/util.py
View File

@ -2,7 +2,7 @@ from geometry import Vertex, Edge, Face, Polygon
def cube(): def cube():
""" '''
This function returns a populated Polygon object. The object is a cube with This function returns a populated Polygon object. The object is a cube with
a vertex at the origin, and another at (1, 1, 1). a vertex at the origin, and another at (1, 1, 1).
@ -74,93 +74,87 @@ def cube():
v5 - e5, e9, e8 v5 - e5, e9, e8
v6 - e2, e9, e10 v6 - e2, e9, e10
v7 - e7, e10, e11 v7 - e7, e10, e11
""" '''
p = Polygon() p = Polygon()
p.vertices.append(Vertex(p, 1.0, 1.0, 0.0))
p.vertices.append(Vertex(p, 1.0, 0.0, 0.0))
p.vertices.append(Vertex(p, 0.0, 1.0, 0.0))
p.vertices.append(Vertex(p, 0.0, 0.0, 0.0))
p.vertices.append(Vertex(p, 0.0, 1.0, 1.0)) # setup vertices
p.vertices.append(Vertex(p, 1.0, 1.0, 1.0)) p.vertices = [
p.vertices.append(Vertex(p, 1.0, 0.0, 1.0)) Vertex(p, 0, 1.0, 1.0, 0.0),
p.vertices.append(Vertex(p, 0.0, 0.0, 1.0)) Vertex(p, 1, 1.0, 0.0, 0.0),
Vertex(p, 2, 0.0, 1.0, 0.0),
p.edges.append(Edge(p)) Vertex(p, 3, 0.0, 0.0, 0.0),
p.edges.append(Edge(p)) Vertex(p, 4, 0.0, 1.0, 1.0),
p.edges.append(Edge(p)) Vertex(p, 5, 1.0, 1.0, 1.0),
p.edges.append(Edge(p)) Vertex(p, 6, 1.0, 0.0, 1.0),
p.edges.append(Edge(p)) Vertex(p, 7, 0.0, 0.0, 1.0)]
p.edges.append(Edge(p))
p.edges.append(Edge(p)) p.vertices[0].edge_ids = [0, 3, 4]
p.edges.append(Edge(p)) p.vertices[1].edge_ids = [0, 5, 1]
p.edges.append(Edge(p)) p.vertices[2].edge_ids = [1, 6, 2]
p.edges.append(Edge(p)) p.vertices[3].edge_ids = [2, 7, 3]
p.edges.append(Edge(p)) p.vertices[4].edge_ids = [4, 11, 8]
p.edges.append(Edge(p)) p.vertices[5].edge_ids = [5, 9, 8]
p.vertices[6].edge_ids = [6, 9, 10]
p.faces.append(Face(p)) p.vertices[7].edge_ids = [7, 10, 11]
p.faces.append(Face(p))
p.faces.append(Face(p)) # setup edges
p.faces.append(Face(p)) p.edges = [Edge(p, i) for i in range(12)]
p.faces.append(Face(p))
p.faces.append(Face(p)) # winged edges ordered by face, then by vertex reference
# setup edge end vertex ids
p.vertices[0].edges = [0, 3, 4] p.edges[0].vertex_ids = [0, 1]
p.vertices[1].edges = [0, 5, 1] p.edges[1].vertex_ids = [1, 2]
p.vertices[2].edges = [1, 6, 2] p.edges[2].vertex_ids = [2, 3]
p.vertices[3].edges = [2, 7, 3] p.edges[3].vertex_ids = [3, 0]
p.vertices[4].edges = [4, 11, 8] p.edges[4].vertex_ids = [0, 4]
p.vertices[5].edges = [5, 9, 8] p.edges[5].vertex_ids = [5, 1]
p.vertices[6].edges = [6, 9, 10] p.edges[6].vertex_ids = [2, 6]
p.vertices[7].edges = [7, 10, 11] p.edges[7].vertex_ids = [7, 3]
p.edges[8].vertex_ids = [4, 5]
# face list p.edges[9].vertex_ids = [5, 6]
p.faces[0].edges = [0, 1, 2, 3] p.edges[10].vertex_ids = [7, 6]
p.faces[1].edges = [1, 5, 9, 6] p.edges[11].vertex_ids = [4, 7]
p.faces[2].edges = [2, 6, 10, 7]
p.faces[3].edges = [4, 3, 7, 11] # setup edges winged edge ids
p.faces[4].edges = [8, 5, 0, 4] p.edges[0].edge_ids = [3, 1, 4, 5]
p.faces[5].edges = [10, 9, 8, 11] p.edges[1].edge_ids = [0, 2, 5, 6]
p.edges[2].edge_ids = [1, 3, 6, 7]
#winged edges ordered by face, then by vertex reference p.edges[3].edge_ids = [4, 7, 0, 2]
p.edges[0].vertices = [0, 1] p.edges[4].edge_ids = [11, 3, 0, 8]
p.edges[1].vertices = [1, 2] p.edges[5].edge_ids = [8, 0, 9, 1]
p.edges[2].vertices = [2, 3] p.edges[6].edge_ids = [1, 9, 2, 10]
p.edges[3].vertices = [3, 0] p.edges[7].edge_ids = [11, 3, 10, 2]
p.edges[4].vertices = [0, 4] p.edges[8].edge_ids = [4, 5, 11, 9]
p.edges[5].vertices = [5, 1] p.edges[9].edge_ids = [5, 6, 8, 10]
p.edges[6].vertices = [2, 6] p.edges[10].edge_ids = [7, 6, 11, 9]
p.edges[7].vertices = [7, 3] p.edges[11].edge_ids = [4, 7, 8, 10]
p.edges[8].vertices = [4, 5]
p.edges[9].vertices = [5, 6] # setup edge adjacent face ids
p.edges[10].vertices = [7, 6] p.edges[0].face_ids = [0, 4]
p.edges[11].vertices = [4, 7] p.edges[1].face_ids = [0, 1]
p.edges[0].edges = [3, 1, 4, 5] p.edges[2].face_ids = [0, 2]
p.edges[1].edges = [0, 2, 5, 6] p.edges[3].face_ids = [3, 0]
p.edges[2].edges = [1, 3, 6, 7] p.edges[4].face_ids = [3, 4]
p.edges[3].edges = [4, 7, 0, 2] p.edges[5].face_ids = [4, 1]
p.edges[4].edges = [11, 3, 0, 8] p.edges[6].face_ids = [1, 2]
p.edges[5].edges = [8, 0, 9, 1] p.edges[7].face_ids = [3, 2]
p.edges[6].edges = [1, 9, 2, 10] p.edges[8].face_ids = [4, 5]
p.edges[7].edges = [11, 3, 10, 2] p.edges[9].face_ids = [1, 5]
p.edges[8].edges = [4, 5, 11, 9] p.edges[10].face_ids = [2, 5]
p.edges[9].edges = [5, 6, 8, 10] p.edges[11].face_ids = [3, 5]
p.edges[10].edges = [7, 6, 11, 9]
p.edges[11].edges = [4, 7, 8, 10] # setup faces
p.edges[0].faces = [0, 4] p.faces = [Face(p, i) for i in range(6)]
p.edges[1].faces = [0, 1]
p.edges[2].faces = [0, 2] # setup face edge ids
p.edges[3].faces = [3, 0] p.faces[0].edge_ids = [0, 1, 2, 3]
p.edges[4].faces = [3, 4] p.faces[1].edge_ids = [1, 5, 9, 6]
p.edges[5].faces = [4, 1] p.faces[2].edge_ids = [2, 6, 10, 7]
p.edges[6].faces = [1, 2] p.faces[3].edge_ids = [4, 3, 7, 11]
p.edges[7].faces = [3, 2] p.faces[4].edge_ids = [8, 5, 0, 4]
p.edges[8].faces = [4, 5] p.faces[5].edge_ids = [10, 9, 8, 11]
p.edges[9].faces = [1, 5]
p.edges[10].faces = [2, 5]
p.edges[11].faces = [3, 5]
# Polygon stores all the actual data. # Polygon stores all the actual data.
# Every other class only stores indices to # Every other class only stores indices to
# the original data. This could be slightly # the original data. This could be slightly
@ -170,15 +164,15 @@ def cube():
# These are all the same vertex, just testing to make # These are all the same vertex, just testing to make
# sure I did it right. # sure I did it right.
print p.vertices[1].x
edge_v_id = p.edges[1].vertices[0] # print p.vertices[1].x
print p.vertices[edge_v_id].x # edge_v_id = p.edges[1].vertex_ids[0]
# print p.vertices[edge_v_id].x
face_edge_id = p.faces[0].edges[1] # face_edge_id = p.faces[0].edge_ids[1]
edge_v_id = p.edges[face_edge_id].vertices[0] # edge_v_id = p.edges[face_edge_id].vertex_ids[0]
print p.vertices[edge_v_id].x # print p.vertices[edge_v_id].x
return p return p
print cube() # print cube()

12
test00.py
View File

@ -1,11 +1,11 @@
from surf.util import cube from surf.util2 import cube
from surf.subd import cc from surf.subd import cc2
polygon = cube() poly = cube()
print polygon # print poly
refined_poly = cc.refine(polygon) refined_poly = cc2.refine(poly)
print refined_poly # print refined_poly
# #
# #
# import pylab # import pylab