Test Grafo

#! /usr/bin/env python
#coding=utf-8

import math

import networkx as nx
import matplotlib.pyplot as plt

class Nodo(object):
    def __init__(self, id, x=None, y=None):
        self.id = id
        self.tipo = None
        self.x = x
        self.y = y

    def __eq__(self, otro_nodo):
        if otro_nodo is None:
            return False
        return self.x == otro_nodo.x and self.y == otro_nodo.y

    #def __eq__(self, otro_nodo):
    #    if otro_nodo is None:
    #        return False
    #    return self.id == otro_nodo.id

    def __hash__(self):
        return hash((self.x, self.y))

    #def __hash__(self):
    #    return self.id

class NodoSimple(Nodo):
    def __init__(self, id, x, y):
        Nodo.__init__(self, id, x, y)
        self._incidencia = []
        self.tipo = 1


class Grafo(nx.Graph):
    def obtener_nodos_simples(self):
        return [x for x in self.nodes_iter() if x.tipo==1]


class GestorGrafo(object):
    def __init__(self):
        self._grafo = Grafo()

    def _agregar_nodos_simples(self):
        archivo = open('grafo.csv', 'r')

        for n, r in enumerate(archivo):
            r = r.strip('\n').split(',')
            nodo1 = NodoSimple(int(r[2]),
                    float(r[3]),
                    float(r[4]))
            nodo2 = NodoSimple(int(r[5]),
                    float(r[6]),
                    float(r[7]))

            self._grafo.add_edge(nodo1,
                    nodo2,
                    segmento=int(r[1]),
                    weight=100)
        archivo.close()

    def construir_grafo(self):
        self._agregar_nodos_simples()
        #self._agregar_nodos_incidentes()

    def calcular(self):
        self._grafo.calcular_incidencias()

    def graficar(self):
        pos = nx.spring_layout(self._grafo)
        nx.draw_networkx_nodes(self._grafo,
                pos=pos,
                node_size=300,
                nodelist=self._grafo.obtener_nodos_simples())

        nx.draw_networkx_edges(self._grafo, pos=pos, alpha=0.5, width=3)
        plt.show()

    def arcos(self):
        for e in self._grafo.edges_iter():
            nodo1 = e[0]
            nodo2 = e[1]
            print 'arco %d-%d ->'%(nodo1.id, nodo2.id), nodo1.id, id(nodo1), nodo2.id, id(nodo2)

    def nodos_simples(self):
        for n in self._grafo.obtener_nodos_simples():
            print n.id, id(n)


def main():
    gestor_grafo = GestorGrafo()
    gestor_grafo.construir_grafo()
    #gestor_grafo.calcular()
    #gestor_grafo.graficar()
    gestor_grafo.nodos_simples()
    gestor_grafo.arcos()


main()