Código feio/desnecessário em common

geocomp/common/segment.py, linha 13:

        if self.__cmp(self.init, self.to) < 0:
            self.upper = self.init
            self.lower = self.to
        else:
            self.upper = self.to
            self.lower = self.init

Esse código não faz nada, e é parte de problemas específicos. Não deveria estar nem na classe Segment (deveria estar numa subclasse) quanto na parte de código comum!

linha 24:

    def __eq__(self, other):
        if self is other:
            return True
        if type(self) != type(other):
            return False
        if self.init == other.init and self.to == other.to:
            return True
        if self.init == other.to and self.to == other.init:
            return True
        return False

Esse código está errado. Veja esse exemplo:

s1 = Segment(Point(0, 1), Point(1, 0))
s2 = Segment(Point(1, 0), Point(0, 1))
s1 == s2 # True
p = Point(1, 1)
left(s1.init, s1.to, p) # False
left(s2.init, s2.to, p) # True

Se ambos são iguais, como tem propriedades diferentes?

linha 50:

    def adj(self, p):
        if p == self.init:
            return self.to
        return self.init

Eu não sei porque esse código está aí. Não tem um nome claro, não tem variáveis claras, não está documentado... Se a função quer dizer ponto do segmento adjacente de p, ela produz muitos resultados errados.

linha 64:

    def __cmp(self, a, b):
        if a[1] > b[1]:
            return -1
        if b[1] > a[1]:
            return 1
        if a[0] < b[0]:
            return -1
        if b[0] < a[0]:
            return 1
        return 0

Esse código está ilegível.

1. Demorei pra entender que o que o código está recebendo são Points.
2. Esse método recebe self, quando deveria ser um @staticmethod.
3. É um método que leva em conta dois pontos e nada com o segmento, não deveria estar nessa classe.
4. É um método privado: pontos não conseguem se comparar usando esse método!

geocomp/common/point.py, linha 41:

    @property
    def x(self):
        return self.__coord[0]

    @x.setter
    def x(self, x):
        self.__coord[0] = x

    @property
    def y(self):
        if len(self.__coord) < 2:
            raise ValueError("Point has dimension 1")
        return self.__coord[1]

    @y.setter
    def y(self, y):
        if len(self.__coord) < 2:
            raise ValueError("Point has dimension 1")
        self.__coord[1] = y

    @property
    def z(self):
        if len(self.__coord) < 3:
            raise ValueError("Point does not have dimension 3")
        return self.__coord[2]

    @z.setter
    def z(self, z):
        if len(self.__coord) < 3:
            raise ValueError("Point does not have dimension 3")
        self.__coord[2] = z

    def __getitem__(self, i):
        if i < 0:
            raise ValueError("Negative dimension value")
        if i >= len(self.__coord):
            return 0
        return self.__coord[i]

Algumas coisas estão erradas nesse código:

1. self.__coord[0] pode não existir.
2. A checagem de boundary poderia ser deslocada para uma função separada:

    def __check_boundary(self, index):
        if index < 0 or index >= len(self.__coord):
            raise ValueError("Point does not have dimension {}".format(index))

Assim, os getters/setters são generalizados para:

    @property
    def x(self):
        self.__check_boundary(0)
        return self.__coord[0]
    
    def __getitem__(self, i):
        self.__check_boundary(i)
        return self.__coord[i]

linha 24:

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Point(self.x - other.x, self.y - other.y)

Embora eu goste desse código, não acho que adicionar e subtrair dois pontos faça sentido. É melhor fazer uma classe Vector e adicionar um Vector a um ponto.