surfaces/surf/geometry.py

from __future__ import division
import pprint

'''
http://en.wikipedia.org/wiki/Polygon_mesh

Polygon meshes may be represented in a variety of ways, using different methods
to store the vertex, edge and face data. These include:
  - Face-vertex
  - Winged-edge
  - Half-edge
  - Quad-edge
  - Corner-tables
  - Vertex-vertex
  - Face-vertex

We have chosen to use a winged-edge style mesh for our purpopses.

'''

def cross(a, b):
    i = a.y * b.z - a.z * b.y
    j = a.z * b.x - a.x * b.z
    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, x=0.0, y=0.0, z=0.0):
        '''
        '''
        self.x = x
        self.y = y
        self.z = z
    
    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 __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
    
    def __mul__(self, other):
        if isinstance(other, Vertex):
            return cross(self, other)
        elif isinstance(other, (float, int)):
            return Vertex(self.x * other, self.y * other, self.z * other)
        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):
    '''
    '''
    
    next_id = 0
    def __init__(self, polygon, parent_id=None, vs=None, es=None, fs=None):
        '''
        '''
        self.polygon = polygon
        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 neighbor_face_id(self, neighbor_face_id):
        '''Get neighboring face id
        '''
        if neighbor_face_id == self.face_ids[0]:
            return self.face_ids[1]
        else:
            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,
    and a quad face has four edges.
    '''
    
    next_id = 0
    def __init__(self, polygon, parent_id=None, es=None):
        '''
        '''
        self.polygon = polygon
        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,
            'edges': self.edges,
            'faces': self.faces,
        }
        return pprint.pformat(d)
    
    __str__ = __unicode__
    __repr__ = __unicode__