[Java] Point to line distance.

[Verwijderd]

Dames, Heren

Ik ben bezig met een gps applicatie en moet nu kijken of een punt binnen een radius rondom de route valt.

Ik ben bezig geweest met "point to line distance" en heb verschillende methoden geprobeerd.

zie hier

code:

public RouteCoordinate[] calculate(RouteCoordinate me, RouteCoordinate routeBegin, RouteCoordinate routeEnd)
    {
        RouteCoordinate[] returnCoordinate = new RouteCoordinate[2];
        RouteCoordinate newEnd = new RouteCoordinate();
        RouteCoordinate newMe = new RouteCoordinate();
        RouteCoordinate triggerPoint1 = new RouteCoordinate(0,0);
        RouteCoordinate triggerPoint2 = new RouteCoordinate(0,0);
        
        triggerPoint1 = new RouteCoordinate(routeBegin.x,routeEnd.y);
        double yDistance1 = Math.abs(routeBegin.y - triggerPoint1.y);                               // lengte a
        double xDistance1 = Math.abs(routeEnd.x - triggerPoint1.x);                                 // lengte b
        double routeDistance1 = Math.sqrt(Math.pow(yDistance1, 2.0) + Math.pow(xDistance1, 2.0));   // lengte c
        newEnd = new RouteCoordinate((int)routeBegin.x, (routeBegin.y + (int)Math.round(routeDistance1)) );
        double angleAlpha = Math.atan(xDistance1 / yDistance1);
        
        triggerPoint2 = new RouteCoordinate(routeBegin.x,me.y);
        double yDistance2 = Math.abs(routeBegin.y - triggerPoint2.y);                               // lengte d
        double xDistance2 = Math.abs(me.x - triggerPoint2.x);                                       // lengte e
        double lengthF = Math.sqrt(Math.pow(yDistance2, 2.0) + Math.pow(xDistance2, 2.0));          // lengte f
        double angleBeta = Math.atan(xDistance2 / yDistance2);
        double angleDelta = angleBeta - angleAlpha;
        
        double lengthG = lengthF * Math.sin(angleDelta);
        double lengthH = Math.sqrt(Math.pow(lengthF,2) - Math.pow(lengthG,2));
        
        newMe = new RouteCoordinate(routeBegin.x - (int)Math.round(lengthG),routeBegin.y + (int)Math.round(lengthH));
        

        returnCoordinate[0] = newEnd;
        returnCoordinate[1] = newMe;
            
        return returnCoordinate;
    }

Dit alles gaat goed totdat ik mijn huidige positie een x positie geef die groter is dan mijn routebegin.x

dan wordt mijn positie niet mee gedraait met de route.

Enig idee hoe ik dit kan oplossen?
Ik heb het forum doorzocht en ik ben een "x" aantal posts tegen gekomen maar dat klopt binnen mijn code allemaal niet..

Ik heb mijn gps coordinaten omgezet naar pixel posities
en ik reken dus ook met pixel posites. vandaar de cast naar een int.

[.oisyn]

point to line distance is vrij simpel. Als je het startpunt Q en (eenheids)richtingsvector V van je lijn hebt, dan is het punt op de lijn wat het dichtst bij punt P ligt gelijk aan Q + ((P - Q)∙V)∙V. Het gedeelte (P - Q)∙V geeft een scalar die aangeeft hoe ver dit punt op de lijn ligt, gezien vanuit het startpunt. Is deze waarde kleiner dan 0 dan ligt het punt dus vóór het startpunt op het lijnstuk, en dan is Q natuurlijk zelf het dichtstbijzijnde punt op het lijnstuk. Hetzelfde geldt natuurlijk als de waarde groter is dan de lengte van je lijnstuk, dan moet je het eindpunt op je lijnstuk nemen voor de afstandsberekening.

[Verwijderd]

Zou je dit misschien in een formule kunnen aangeven en mijn variablen gebruiken?
dan snap ik er misschien iets meer van.

Wiskunde is leuk maar niet mijn hobby

ik snap wat je bedoelt maar ik kan me het nu even niet inbeelden.

[.oisyn]

De formule staat er al, en mijn variabelen met de jouwe substitueren kun je best zelf .

Q, P en V zijn gewoon vectoren, en hebben dus een x en een y component, net zoals jouw RouteCoordinate. Vectoren optellen gaat gewoon zoals je zou verwachten, dus A+B = (A.x+B.x, A.y+B.y). Vermenigvuldigen met een scalar (een waarde met 1 dimensie, dus bijvoorbeeld een double) gaat op de manier A∙s = (A.x*s, B.x*s). Het in-product is het 'vermenigvuldigen' van 2 vectoren en dat levert een scalar op. A∙B = A.x*B.x + A.y*B.y

Dus in pseudo-code

Java:

vector D = new vector(Q.x - P.x, Q.y - P.y);  // D = Q - P
vector T;
double t = D.x * V.x + D.y * V.y;  // t = D*V = (Q - P)*V
if (t < 0)
{
    // gebruik startpunt van het lijnstuk
    T = Q;
}
else if (t > lengteLijnstuk)
{
    // gebruik eindpunt van het lijnstuk
    T = Q2;
}
else
{
    // bereken dichtsbijzijnde punt op het lijnstuk
    T = new vector(Q.x + V.x * t, Q.y + V.y * t);  // T = Q + t*V = Q + ((Q - P)*V) * V
}

// doe hier afstandsberekening tussen P en T.

die V is natuurlijk de richting van Q naar Q2 (start- en eindpunten van je lijnstuk), maar met lengte 1. Die kun je bepalen door Q van Q2 af te trekken, en dat vervolgens te delen door de lengte.

Java:

vector V = new vector(Q2.x - Q.x, Q2.y - Q.y);
double lengteLijnstuk = Math.sqrt(V.x*V.x + V.y*V.y);
V.x /= lengteLijnstuk;
V.y /= lengteLijnstuk;

Heb je ook meteen de lengteLijnstuk die je nodig hebt in de formule

[ Voor 20% gewijzigd door .oisyn op 21-12-2006 13:00 ]

[Verwijderd]

Thanks ik ga het eens even proberen alvast bedankt

[Verwijderd]

Is het zo dat de eerste V mijn positie is
en de 2e keer dat je V aanroept.

in lengtelijnstuk.

dat het dan een andere is ?

[.oisyn]

Alle V's zijn uiteraard dezelfde variabele

[Verwijderd]

Aargh mijn huidige positie weet ik al waarom moet ik die dan opnieuw berekenen?

V ben ik
Q is het beginpunt
P is het eindpunt

waarom bereken jij V opnieuw dan ?

[.oisyn]

Als je het startpunt Q en (eenheids)richtingsvector V van je lijn hebt, dan is het punt op de lijn wat het dichtst bij punt P ligt gelijk aan Q + ((P - Q)∙V)∙V

Q en Q2 zijn het start- en eindpunt van je lijnstuk. P is het punt waarvan je de afstand tot het lijnstuk wilt berekenen.

[ Voor 26% gewijzigd door .oisyn op 21-12-2006 13:57 ]

[Verwijderd]

Ok thanks dan moet het nu wel lukken
M''n wiskunde knobbel heeft dringend wat hulp nodig geloof ik

[Kuhlie]

Misschien heb je hier ook wat aan: http://java.sun.com/j2se/...st(java.awt.geom.Point2D)

[ Voor 3% gewijzigd door Kuhlie op 22-12-2006 12:58 ]

[.oisyn]

Helaas, dat is een punt-lijn afstand, geen punt-lijnstuk afstand. Z'n route bestaat niet uit lijnen maar uit lijnstukken. ptSegDist() is beter bruikbaar

[ Voor 11% gewijzigd door .oisyn op 22-12-2006 14:06 ]