Exemple #1
0
    def colideVerticeAresta(self, coord, raio, checaVertice = True):
        """Checa colisao entre o vertice(passado como parametro por meio das coordenadas e raio), os demais vertices e as arestas"""
        xca, yca, xcb, ycb = coord[0]-raio, coord[1]-raio, coord[0]+raio, coord[1]+raio
        if checaVertice:
            for x,y in self.vertices:
                xa, ya, xb, yb = x-raio, y-raio, x+raio, y+raio
                if xa <= xca <= xb and ya <= yca <= yb:
                    return (True,True)
                elif xa <= xcb <= xb and ya <= ycb <= yb:
                    return (True,True)
                elif xa <= xcb <= xb and ya <= yca <= yb:
                    return (True,True)
                elif xa <= xca <= xb and ya <= ycb <= yb:
                    return (True,True)

        #as quatros retas represetam o quadrado que envolve o vertice
        retaA = Reta((xca,yca,xcb,yca))
        retaB = Reta((xca,yca,xca,ycb))
        retaC = Reta((xcb,yca,xcb,ycb))
        retaD = Reta((xca,ycb,xcb,ycb))
        #################################################################
        for xra,yra,xrb,yrb,va,vb in self.arestas:
            #faz a checagem se houve algum cruzamento das retas
            retaX = Reta((xra,yra,xrb,yrb))
            if retaX.checaInter(retaA) or retaX.checaInter(retaB) or retaX.checaInter(retaC) or retaX.checaInter(retaD):
                return (True,va,vb)

        return (False,False)
Exemple #2
0
 def colidePontoAresta(self, coord, raio):
     """Checa se um ponto colide com alguma aresta do grafo"""
     for x,y in self.vertices:
         xca, yca, xcb, ycb = x-raio, y-raio, x+raio, y+raio
         retaA = Reta((xca,yca,xcb,yca))
         retaB = Reta((xca,yca,xca,ycb))
         retaC = Reta((xcb,yca,xcb,ycb))
         retaD = Reta((xca,ycb,xcb,ycb))
         retaX = Reta(coord)
         if retaX.checaInter(retaA) or retaX.checaInter(retaB) or retaX.checaInter(retaC) or retaX.checaInter(retaD):
             return True
     return False
    def encontra_raio(self, direcaoDesejada):
        # descobre se o robo vira para esquerda ou direita
        y = Reta.ponto_e_angulo(self.pos, self.orientacao.angulo()).encontra_y(self.posDesejada.x)
        theta = self.orientacao.delta_angulo_com(direcaoDesejada)

        if (theta < 0 and theta != None):
            normal = Vetor.gira(self.orientacao, -math.pi/2) # vira no sentido anti-horario / esquerda
        elif (theta > 0):
            normal = Vetor.gira(self.orientacao, math.pi/2) # vira no sentido horario / direita
        else:
            normal = None # linha reta ou vira sem sair do lugar

        # encontra raio de curvatura
        if (normal == None):
            if (direcaoDesejada.tamanho() == 0):
                raio = 0 # vira sem sair do lugar
            else:
                raio = -1 # linha reta
        else:
            phi = normal.angulo_com(direcaoDesejada)
            raio = direcaoDesejada.quadrado()/(2*direcaoDesejada.tamanho() * math.cos(phi))

            # encontra centro
            centro = Vetor.multiplica(normal, raio)
            centro = Vetor.soma(self.pos, centro)

            # print "centro.x: %s, centro.y: %s, raio: %s" % (centro.x, centro.y, raio)

            # corrige raio comparando com orientacao desejada
            # if (raio > 0):
            #    raio = self.corrige_raio(raio, centro)

        return raio
    def encontra_posicao_goleiro(self, campo, bola, adversario):
        self.orientacaoDesejada = Vetor.unitario(math.pi/2) # orientacao paralela a linha do gol
        self.posDesejada.x = campo.get_gol(self.lado).centro().x # no eixo x, centro do gol

        reta = Reta(adversario.get_pos(), bola.get_pos()) #reta que liga o adversario a bola
        if (reta.e_funcao_de_x()): # se a reta for funcao de x
            self.posDesejada.y = reta.encontra_y(self.posDesejada.x) # encontra o prolongamento da reta
        else: # se a reta for paralela a linha do gol
            self.posDesejada.y = self.pos.y # nao se move no eixo y

       #garante que o goleiro fique na frente do gol
        if (self.posDesejada.y < campo.minLgol):
            self.posDesejada.y = campo.minLgol
        if (self.posDesejada.y > campo.maxLgol):
            self.posDesejada.y = campo.maxLgol

        print "posicao desejada - x: %s, y: %s / orientacao desejada: %s" % (self.posDesejada.x, self.posDesejada.y, self.orientacaoDesejada.angulo())
Exemple #5
0
 def __init__(self, x1=0, y1=0, x2=0, y2=0, cor='black', esp=2):
     Reta.__init__(self, x1, y1, x2, y2)
     self.__cor = cor
     self.__esp = esp