Пересечение двух движущихся объектов ITERATIVE и QUADRATI C разность методов - PullRequest
Новая
       5

Пересечение двух движущихся объектов ITERATIVE и QUADRATI C разность методов

0 голосов
/ 07 января 2020

Я хочу вычислить время пересечения двух движущихся объектов.

C - это мой объект-преследователь, а A - целевой объект. Входные данные должны быть такими:

C_position C_speed

A_position A_speed

A_direction

1.) Для этого сценария я использую квадратичное c уравнение. 

import math

def intersect(chaser,target):

    dist= distance(chaser,target)
    dir=direction(chaser,target)

    alpha= math.pi + dir - target['dir']

    if chaser["vel"]== target["vel"]:
        if math.cos(alpha)<0:
            return None
        return (dir + alpha) % (math.pi * 2)

    a= chaser["vel"]**2 - target["vel"]**2

    b=2*dist*target["vel"]*math.cos(alpha)

    c= -(dist**2)



    if dist<0:
        return None

    delta=math.sqrt((b**2)-(4*a*c))

    time=(-b + delta)/(2*a)
    time_2=(-b - delta)/(2*a)

    x=target["x"]+target["vel"]*time*math.cos(target["dir"])
    y=target["y"]+target["vel"]*time*math.sin(target["dir"])

    x_2 = target["x"] + target["vel"] * time_2 * math.cos(target["dir"])
    y_2= target["y"] + target["vel"] * time_2 * math.sin(target["dir"])

    angle=direction(chaser,{"x":x,"y":y})
    return  x,y,time,x_2,y_2,time_2,angle



def distance(p,q):

    return math.sqrt((p["x"]-q["x"])**2 + (p["y"]-q["y"])**2)

def direction(p,q):

    return math.atan2(q["y"]-p["y"],q["x"]-p["x"])



chaser={"x":0,"y":0,"vel":50}
target={"x":125,"y":175,"vel":25,"dir":1.96}

print(intersect(chaser,target))
direction(chaser,target)

2.) Во втором сценарии используйте итеративное и снова метод quadrati c, входные данные должны быть такими:

C_position C_speed

A_position A_speed

B_position (показывает направление A)

Для этого сценария используйте этот код: 

import math

class Object:
    ax = None
    ay = None
    bx = None
    by = None
    cx = None
    cy = None

    def __init__(self,speed_a,speed_c,a={"x":ax,"y":ay},b={"x":bx,"y":by},c={"x":cx,"y":cy}):
        self.a = a
        self.b = b
        self.c = c
        self.speed_a = speed_a
        self.speed_c = speed_c

    def findTheBetterIntersection(self,a, b, c):

        atobtime = self.getMaxTime(a,b,self.speed_a)

        if (atobtime <= self.getMaxTime(c,b,self.speed_c)):

            return b["x"],b["y"],self.getMaxTime(c,b,self.speed_c)

        t=self.getOptimalIntersectionTime(a,b,c,atobtime)

        t2=self.getTimeQuadratic(a,b,c)

        coords=self.getCoordAtTime(a,b,self.speed_a,t)

        return {"x":coords["x"],"y":coords["y"]} ,t ,t2


    def getTimeQuadratic(self,a,b,c):

        azero=self.translateToZero(a,c)
        bzero=self.translateToZero(b,c)
        czero=c
        czero["x"]=0
        czero["y"]=0

        cTime=self.getMaxTime(a,b,self.speed_a)

        v = {"x":(b["x"]-a["x"]/cTime),"y":(b["y"]- a["y"]/cTime)}

        quadC=math.pow(azero["x"],2) + math.pow(azero["y"],2)

        quadB=(2 * azero["x"] * v["x"] + 2 * azero["y"] * v["y"])

        quadA=math.pow(v["x"],2) + math.pow(v["y"],2) - math.pow(self.speed_c,2)

        delta=math.pow(quadB,2) - (4 * quadA * quadC)

        if  delta>0:

            x1 = (-quadB + math.sqrt(math.pow(quadB, 2) - (4 * quadA * quadC))) / (2 * quadA)
            x2 = (-quadB - math.sqrt(math.pow(quadB, 2) - (4 * quadA * quadC))) / (2 * quadA)

            if x2 > x1 and x2 > 0:
                return x2

            return x1
        else:
            return None


    def translateToZero(self,source,dest):

        s= {"x":source["x"] - dest["x"],"y":source["y"] - dest["y"]}

        return s


    def getOptimalIntersectionTime(self,a,b,c,time):

        coordATime=self.getCoordAtTime(a,b,self.speed_a,time)

        coordCTime=self.getCoordAtTime(c,coordATime,self.speed_c,time)

        cMaxTime=self.getMaxTime(c,coordATime,self.speed_c)

        if self.getDistance(coordATime,coordCTime) <= 1:
            return time

        if time < cMaxTime :
            return self.getOptimalIntersectionTime(a,b,c,time*1.5)

        else:
            return self.getOptimalIntersectionTime(a,b,c,time*0.5)




    def getMaxTime(self,coordinates,direction,speed):

        time=self.getDistance(coordinates,direction)/speed

        if time <=0 :
            return 0.000001

        return time

    def getCoordAtTime(self,coordinates,direction,speed,time):

        if not direction:
            return coordinates

        current =  time/self.getMaxTime(coordinates,direction,speed)

        return {"x":math.floor(coordinates["x"] + (direction["x"] - coordinates["x"])* current)  ,

                "y":math.floor(coordinates["y"] + (direction["y"] - coordinates["y"])* current)}


    def getDistance(self,a,b):

        return math.sqrt(math.pow(b["x"]-a["x"],2) + math.pow(b["y"] - a["y"],2))


object = Object(25,50,{"x":125,"y":150},{"x":-3.4975,"y":9.2521},{"x":0,"y":0})

print(object.findTheBetterIntersection({"x":125,"y":150},{"x":-3.4975,"y":9.2521},{"x":0,"y":0}))

Я хочу проверить свой ответ, чтобы преобразовать 1,96 радиуса в полярные координаты с r = 10. Как бы то ни было, ответы различаются.

Можете ли вы объяснить ниже, пожалуйста,

Почему первый и второй код итеративный метод дает разные результаты?

Почему итерационный и квадратичный c метод второго кода дает разные результаты?

(Ссылки : Найди лучшее пересечение сечение двух движущихся объектов

пересечение двух движущихся объектов с координатами широты / долготы )

...