diff --git a/surf/geometry.py b/surf/geometry.py index 97a9595..aa93ca8 100644 --- a/surf/geometry.py +++ b/surf/geometry.py @@ -24,35 +24,38 @@ def cross(a, b): k = a.x * b.y - a.y * b.x return Vertex(i, j, k) + class Vertex(object): ''' A vertex is a position along with other information such as color, normal 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.parent_id = parent_id self.x = x self.y = y self.z = z - self.edges = [] - + self.edge_ids = es or [] + self.id = Vertex.next_id + Vertex.next_id += 1 + def __eq__(self, other): if(self.x == other.x and self.y == other.y and self.z == other.z): return True else: return False - - def __repr__(self): - return "[%.2f, %.2f, %.2f]" % (self.x, self.y, self.z) - + def __add__(self, other): # for now just assume type(other) = Vertex... bad, I know return Vertex(self.x + other.x, self.y + other.y, self.z + other.z) - + def __radd__(self, other): return other + self - # return self.__add__(other) - + def __mul__(self, other): if isinstance(other, Vertex): return cross(self, other) @@ -61,54 +64,175 @@ class Vertex(object): else: raise TypeError("{0} has an unexpected type: {1}".format( other, type(other))) - + def __rmul__(self, other): return self.__mul__(other) - + def __div__(self, other): # same assumption as __mult__ return Vertex(self.x / other, self.y / other, self.z / other) __truediv__ = __div__ - + def __neg__(self): 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): ''' ''' - def __init__(self, polygon): + next_id = 0 + def __init__(self, polygon, parent_id=None, vs=None, es=None, fs=None): + ''' + ''' self.polygon = polygon - self.vertices = [] - self.faces = [] - self.edges = [] + self.parent_id = parent_id + self.vertex_ids = vs or [] + 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 ''' - if neighborFace == self.faces[0]: - return self.faces[1] + if neighbor_face_id == self.face_ids[0]: + return self.face_ids[1] 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): ''' - 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. ''' - def __init__(self, polygon): + + next_id = 0 + def __init__(self, polygon, parent_id=None, es=None): + ''' + ''' 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): ''' ''' - + def __init__(self, vs=None, es=None, fs=None): self.vertices = vs or [] self.edges = es 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): d = { 'vertices': self.vertices, @@ -118,4 +242,5 @@ class Polygon(object): return pprint.pformat(d) __str__ = __unicode__ - __repr__ = __unicode__ \ No newline at end of file + __repr__ = __unicode__ + diff --git a/surf/subd/cc.py b/surf/subd/cc.py index cd7de8e..48fae4e 100644 --- a/surf/subd/cc.py +++ b/surf/subd/cc.py @@ -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): - vertex_objs = [self.polygon.vertices[v_id] for v_id in self.vertices] +def mid_point(edge): + vertex_objs = [edge.vertices[v_id] for v_id in edge.vertices] return sum(vertex_objs, Vertex()) / len(self.vertices) def sub_edges(self): temp_p = Polygon() temp_p.edges = [Edge(), Edge()] - temp_p.vertices = + # temp_p.vertices = sub_edges[0].vertices = [self.vertices[0], self.edge_vertex] sub_edges[1].vertices = [self.edge_vertex, self.vertices[1]] 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 face vertices and its two original end vertices. ''' - # two neighboring face vertices: - neighboringFaceVertices = [p.faces[f_id].centroid for f_id in self.faces] - neighboringFaceVertices.extend(self.vertices) - xs = [vertex.x for vertex in neighboringFaceVertices] - ys = [vertex.y for vertex in neighboringFaceVertices] - zs = [vertex.z for vertex in neighboringFaceVertices] - x = sum(xs) / len(xs) - y = sum(ys) / len(ys) - z = sum(zs) / len(zs) - self.__edge_vertex = Vertex(x, y, z) - self.__edge_vertex.edges.extend(self.__sub_edges) - return self.__edge_vertex - -def centroid(self): - if not self.__centroid: - # gather all face vertex coords - face_vertices = list(set([vertex - for edge in self.edges for vertex in edge.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 + + edge_ids = poly.edge_ids_with_parent(edge.id) + + if edge_ids: + return edge_ids + else: + # otherwise split it + xs = [] + ys = [] + zs = [] + for face in edge.faces: + centroid_v = centroid(face, None) + xs.append(centroid_v.x) + ys.append(centroid_v.y) + zs.append(centroid_v.z) + + for vertex in edge.vertices: + xs.append(vertex.x) + ys.append(vertex.y) + zs.append(vertex.z) + x = sum(xs) / len(xs) y = sum(ys) / len(ys) z = sum(zs) / len(zs) - - self.__centroid = Vertex(x, y, z) - return self.__centroid + + e0 = Edge(poly) + 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): - self.__setupSubDivisions() - return self.__sub_faces + setup_sub_divisions() + return sub_faces() def interior_edges(self): - self.__setupSubDivisions() + setup_sub_divisions() return self.__interior_edges -def __setupSubDivisions(self): +def setup_sub_divisions(polygon, face): ''' v0 ev0 v1 *------e0-----* @@ -67,69 +107,86 @@ def __setupSubDivisions(self): *------e2-----* v3 ev2 v2 ''' - if not self.__sub_faces: - # create empty sub_faces that will be filled with edge references - # below - # these need to at least exist so the interior edges have - # something to reference - self.__sub_faces = [Face() for edge in self.edges] + + # create empty sub_faces that will be filled with edge references + # below + # these need to at least exist so the interior edges have + # something to reference + + + + sub_faces = [Face(polygon) for edge in face.edge_ids] - if not self.__interior_edges: - # set up empty edge objects to be filled below - self.__interior_edges = [Edge() for edge in self.edges] + + # set up empty edge objects to be filled below + interior_edges = [Edge(polygon) for edge in face.edge_ids] - # each interior edge connects the exterior edge vertex (mid-point) - # to the faceVertex (centroid) - for index in range(len(self.edges)): - prevIndex = (index - 1) % len(self.edges) - nextIndex = (index + 1) % len(self.edges) + # # each interior edge connects the exterior edge vertex (mid-point) + # # to the faceVertex (centroid) + # for edge_id in range(len(face.edges)): + # prevIndex = (edge_id - 1) % len(face.edges) + # nextIndex = (edge_id + 1) % len(face.edges) - # end vertices are face centroid and currEdge edge_vertex - self.__interior_edges[index].vertices = [ - self.edges[index].edge_vertex, self.centroid - ] + # # end vertices are face centroid and currEdge edge_vertex + # interior_edges[edge_id].vertices = [ + # face.edges[edge_id], + # edge_vertex, self.centroid + # ] - # wing edges are the current edge's sub_edges (ordered same as - # vertex order) and the prev and next interior edges - self.__interior_edges[index].edges = [ - self.edges[index].sub_edges[0], - self.edges[index].sub_edges[1], - self.__interior_edges[prevIndex], - self.__interior_edges[nextIndex] - ] + # # wing edges are the current edge's sub_edges (ordered same as + # # vertex order) and the prev and next interior edges + # self.__interior_edges[index].edges = [ + # self.edges[index].sub_edges[0], + # self.edges[index].sub_edges[1], + # self.__interior_edges[prevIndex], + # self.__interior_edges[nextIndex] + # ] - # edge faces are the new sub_faces (current and next faces), the - # current will be define below - # and the next will be defined on the next iteration (or - # already defined on the last iteration) - self.__interior_edges[index].faces = [ - self.__sub_faces[index], - self.__sub_faces[nextIndex] - ] + # # edge faces are the new sub_faces (current and next faces), the + # # current will be define below + # # and the next will be defined on the next iteration (or + # # already defined on the last iteration) + # self.__interior_edges[index].faces = [ + # self.__sub_faces[index], + # self.__sub_faces[nextIndex] + # ] - # now reference the current edge back into the faces, - # and the edge.sub_edges, and the edge.edge_vertex + # # now reference the current edge back into the faces, + # # and the edge.sub_edges, and the edge.edge_vertex - # current subFace (same index as current interior edge) - # set its edges to reference the same edges used to setup the - # interior edge - # order will be pretty important on these steps... - self.__sub_faces[index].edges = [ - self.edges[index].sub_edges[0], - self.__interior_edges[index], - self.__interior_edges[prevIndex], - self.edges[prevIndex].sub_edges[1] - ] + # # current subFace (same index as current interior edge) + # # set its edges to reference the same edges used to setup the + # # interior edge + # # order will be pretty important on these steps... + # self.__sub_faces[index].edges = [ + # self.edges[index].sub_edges[0], + # self.__interior_edges[index], + # self.__interior_edges[prevIndex], + # self.edges[prevIndex].sub_edges[1] + # ] - # just set one of the vertex edges, the other belongs to - # another face and will get added when that face is run - self.edges[index].edge_vertex.edges.append( - self.__interior_edges[index]) + # # just set one of the vertex edges, the other belongs to + # # another face and will get added when that face is run + # self.edges[index].edge_vertex.edges.append( + # self.__interior_edges[index]) - self.edges[index].sub_edges[0].faces.append( - self.__sub_faces[index]) - self.edges[index].sub_edges[0].faces.append( - self.__sub_faces[index]) + # self.edges[index].sub_edges[0].faces.append( + # self.__sub_faces[index]) + # self.edges[index].sub_edges[0].faces.append( + # 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): ''' @@ -146,65 +203,89 @@ def refine(poly): edges touching P, where each edge midvertex is the average of its two 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 - # interior edges and setup their references correctly... <- not completely - # finished... - p = Polygon() - edges = [] - vertices = [] - 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 - for face in poly.faces: - for subFace in face.sub_faces: - faces.append(subFace) - for edge in subFace.edges: - edges.append(edge) - for vertex in edge.vertices: - vertices.append(vertex) + # p.faces = faces + # p.vertices = vertices + # p.edges = edges - newVertices = [] - for vertex in poly.vertices: - 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) + # # plotting these in excel seems to show the correct values (at first + # # glace...) - 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) - - 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) + # # 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) diff --git a/surf/util.py b/surf/util.py index 53f607a..daf2386 100644 --- a/surf/util.py +++ b/surf/util.py @@ -2,7 +2,7 @@ from geometry import Vertex, Edge, Face, Polygon def cube(): - """ + ''' This function returns a populated Polygon object. The object is a cube with a vertex at the origin, and another at (1, 1, 1). @@ -74,93 +74,87 @@ def cube(): v5 - e5, e9, e8 v6 - e2, e9, e10 v7 - e7, e10, e11 - """ + ''' + 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)) - p.vertices.append(Vertex(p, 1.0, 1.0, 1.0)) - p.vertices.append(Vertex(p, 1.0, 0.0, 1.0)) - p.vertices.append(Vertex(p, 0.0, 0.0, 1.0)) - - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - p.edges.append(Edge(p)) - - p.faces.append(Face(p)) - p.faces.append(Face(p)) - p.faces.append(Face(p)) - p.faces.append(Face(p)) - p.faces.append(Face(p)) - p.faces.append(Face(p)) - - p.vertices[0].edges = [0, 3, 4] - p.vertices[1].edges = [0, 5, 1] - p.vertices[2].edges = [1, 6, 2] - p.vertices[3].edges = [2, 7, 3] - p.vertices[4].edges = [4, 11, 8] - p.vertices[5].edges = [5, 9, 8] - p.vertices[6].edges = [6, 9, 10] - p.vertices[7].edges = [7, 10, 11] - - # face list - p.faces[0].edges = [0, 1, 2, 3] - p.faces[1].edges = [1, 5, 9, 6] - p.faces[2].edges = [2, 6, 10, 7] - p.faces[3].edges = [4, 3, 7, 11] - p.faces[4].edges = [8, 5, 0, 4] - p.faces[5].edges = [10, 9, 8, 11] - - #winged edges ordered by face, then by vertex reference - p.edges[0].vertices = [0, 1] - p.edges[1].vertices = [1, 2] - p.edges[2].vertices = [2, 3] - p.edges[3].vertices = [3, 0] - p.edges[4].vertices = [0, 4] - p.edges[5].vertices = [5, 1] - p.edges[6].vertices = [2, 6] - p.edges[7].vertices = [7, 3] - p.edges[8].vertices = [4, 5] - p.edges[9].vertices = [5, 6] - p.edges[10].vertices = [7, 6] - p.edges[11].vertices = [4, 7] - p.edges[0].edges = [3, 1, 4, 5] - p.edges[1].edges = [0, 2, 5, 6] - p.edges[2].edges = [1, 3, 6, 7] - p.edges[3].edges = [4, 7, 0, 2] - p.edges[4].edges = [11, 3, 0, 8] - p.edges[5].edges = [8, 0, 9, 1] - p.edges[6].edges = [1, 9, 2, 10] - p.edges[7].edges = [11, 3, 10, 2] - p.edges[8].edges = [4, 5, 11, 9] - p.edges[9].edges = [5, 6, 8, 10] - p.edges[10].edges = [7, 6, 11, 9] - p.edges[11].edges = [4, 7, 8, 10] - p.edges[0].faces = [0, 4] - p.edges[1].faces = [0, 1] - p.edges[2].faces = [0, 2] - p.edges[3].faces = [3, 0] - p.edges[4].faces = [3, 4] - p.edges[5].faces = [4, 1] - p.edges[6].faces = [1, 2] - p.edges[7].faces = [3, 2] - p.edges[8].faces = [4, 5] - p.edges[9].faces = [1, 5] - p.edges[10].faces = [2, 5] - p.edges[11].faces = [3, 5] - + # setup vertices + p.vertices = [ + Vertex(p, 0, 1.0, 1.0, 0.0), + Vertex(p, 1, 1.0, 0.0, 0.0), + Vertex(p, 2, 0.0, 1.0, 0.0), + Vertex(p, 3, 0.0, 0.0, 0.0), + Vertex(p, 4, 0.0, 1.0, 1.0), + Vertex(p, 5, 1.0, 1.0, 1.0), + Vertex(p, 6, 1.0, 0.0, 1.0), + Vertex(p, 7, 0.0, 0.0, 1.0)] + + p.vertices[0].edge_ids = [0, 3, 4] + p.vertices[1].edge_ids = [0, 5, 1] + p.vertices[2].edge_ids = [1, 6, 2] + p.vertices[3].edge_ids = [2, 7, 3] + p.vertices[4].edge_ids = [4, 11, 8] + p.vertices[5].edge_ids = [5, 9, 8] + p.vertices[6].edge_ids = [6, 9, 10] + p.vertices[7].edge_ids = [7, 10, 11] + + # setup edges + p.edges = [Edge(p, i) for i in range(12)] + + # winged edges ordered by face, then by vertex reference + # setup edge end vertex ids + p.edges[0].vertex_ids = [0, 1] + p.edges[1].vertex_ids = [1, 2] + p.edges[2].vertex_ids = [2, 3] + p.edges[3].vertex_ids = [3, 0] + p.edges[4].vertex_ids = [0, 4] + p.edges[5].vertex_ids = [5, 1] + p.edges[6].vertex_ids = [2, 6] + p.edges[7].vertex_ids = [7, 3] + p.edges[8].vertex_ids = [4, 5] + p.edges[9].vertex_ids = [5, 6] + p.edges[10].vertex_ids = [7, 6] + p.edges[11].vertex_ids = [4, 7] + + # setup edges winged edge ids + p.edges[0].edge_ids = [3, 1, 4, 5] + p.edges[1].edge_ids = [0, 2, 5, 6] + p.edges[2].edge_ids = [1, 3, 6, 7] + p.edges[3].edge_ids = [4, 7, 0, 2] + p.edges[4].edge_ids = [11, 3, 0, 8] + p.edges[5].edge_ids = [8, 0, 9, 1] + p.edges[6].edge_ids = [1, 9, 2, 10] + p.edges[7].edge_ids = [11, 3, 10, 2] + p.edges[8].edge_ids = [4, 5, 11, 9] + p.edges[9].edge_ids = [5, 6, 8, 10] + p.edges[10].edge_ids = [7, 6, 11, 9] + p.edges[11].edge_ids = [4, 7, 8, 10] + + # setup edge adjacent face ids + p.edges[0].face_ids = [0, 4] + p.edges[1].face_ids = [0, 1] + p.edges[2].face_ids = [0, 2] + p.edges[3].face_ids = [3, 0] + p.edges[4].face_ids = [3, 4] + p.edges[5].face_ids = [4, 1] + p.edges[6].face_ids = [1, 2] + p.edges[7].face_ids = [3, 2] + p.edges[8].face_ids = [4, 5] + p.edges[9].face_ids = [1, 5] + p.edges[10].face_ids = [2, 5] + p.edges[11].face_ids = [3, 5] + + # setup faces + p.faces = [Face(p, i) for i in range(6)] + + # setup face edge ids + p.faces[0].edge_ids = [0, 1, 2, 3] + p.faces[1].edge_ids = [1, 5, 9, 6] + p.faces[2].edge_ids = [2, 6, 10, 7] + p.faces[3].edge_ids = [4, 3, 7, 11] + p.faces[4].edge_ids = [8, 5, 0, 4] + p.faces[5].edge_ids = [10, 9, 8, 11] + # Polygon stores all the actual data. # Every other class only stores indices to # the original data. This could be slightly @@ -170,15 +164,15 @@ def cube(): # These are all the same vertex, just testing to make # sure I did it right. - print p.vertices[1].x - edge_v_id = p.edges[1].vertices[0] - print p.vertices[edge_v_id].x + # print p.vertices[1].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] - edge_v_id = p.edges[face_edge_id].vertices[0] - print p.vertices[edge_v_id].x + # face_edge_id = p.faces[0].edge_ids[1] + # edge_v_id = p.edges[face_edge_id].vertex_ids[0] + # print p.vertices[edge_v_id].x return p -print cube() +# print cube() diff --git a/test00.py b/test00.py new file mode 100755 index 0000000..e560142 --- /dev/null +++ b/test00.py @@ -0,0 +1,24 @@ +from surf.util2 import cube +from surf.subd import cc2 + +poly = cube() +# print poly + +refined_poly = cc2.refine(poly) +# print refined_poly +# +# +# import pylab +# import mpl_toolkits.mplot3d.axes3d as p3 +# +# fig = pylab.figure() +# ax = p3.Axes3D(fig) +# for edge in newPolygon.edges: +# xs = [vertex.x for vertex in edge.vertices] +# ys = [vertex.y for vertex in edge.vertices] +# zs = [vertex.z for vertex in edge.vertices] +# ax.plot_wireframe(xs, ys, zs) +# ax.set_xlabel('X') +# ax.set_ylabel('Y') +# ax.set_zlabel('Z') +# pylab.show()