Kortste lijn naar rechthoek.

[ZpAz]

Helaas is mijn wiskundeknobbel nooit gegroeid tot een bruikbaar formaat, dus ik zit nu ergens mee vast. Ik heb het in de bovenstaande schema uitgewerkt.

Ik weet mijn coordinaten (punt A) en weet de coordinaten van de hoeken van rechthoek B. Wat ik wil weten is de korste afstand van punt A naar rechthoek B in een rechte lijn.

edit: @hieronder, ja, hier had ik zo te zien wel duidelijker in mogen zijn, ik zoek inderdaad een formule / manier in code om het op te lossen.

[ Voor 17% gewijzigd door ZpAz op 02-10-2013 19:34 ]

[hugoy]

Bedoel je wat hier de formule van is of welk punt op de rechthoek dit zou zijn?

[Grandmasg]

afstand = wortel ( (ax - bx)^2 + (ay -by)^2 )
Dat op alle hoeken checken en klaar

edit: Wikipedia: Afstand

[ Voor 32% gewijzigd door Grandmasg op 02-10-2013 19:35 ]

[ZpAz]

Grandmasg schreef op woensdag 02 oktober 2013 @ 19:34:
afstand = wortel ( (ax - bx)^2 + (ay -by)^2 )
Dat op alle hoeken checken en klaar

Nu is mijn wiskunde als in TS te lezen niet al te best. Maar kijkt dit niet enkel welke hoek het dichtste bij is? Het kan ook zijn dat het midden van de lijn tussen twee hoeken van de rechthoek dichterbij is toch?

edit: De bovenstaande link bevat waarschijnlijk de formule die ik zoek onder: Wikipedia: Afstand maar het had er net zo goed in Chinees kunnen staan, ik kan zulke formules niet lezen.

[ Voor 25% gewijzigd door ZpAz op 02-10-2013 19:39 ]

[Grandmasg]

Misschien is dit iets ...

http://stackoverflow.com/...-point-and-a-line-segment

[JeromeB]

zoiets?:

code:

afstand_y = min(abs(vertikale_lijn_1-punt_y),abs(vertikale_lijn_2-punt_y))
afstand_x = min(abs(horizontale_lijn_1-punt_x),abs(horizontale_lijn_2-punt_x))
afstand = (afstand_y^2+afstand_x^2)^(1/2)

edit:

beter:

code:

afstand_y = min(abs(horizontale_lijn_1_y-punt_y),abs(horizontale_lijn_2_y-punt_y))
afstand_x = min(abs(vertikale_lijn_1_x-punt_x),abs(vertikale_lijn_2_x-punt_x))
afstand = (afstand_y^2+afstand_x^2)^(1/2)

[ Voor 35% gewijzigd door JeromeB op 02-10-2013 19:57 ]

[2Keys]

Dan kan je c uit rekenen neem ik aan ;p

[Verwijderd]

Kijk hoeveel X-eenheden (of nul) het punt zich links of rechts van de rechthoek bevind.
Kijk hoeveel Y-eenheden het punt zich boven of onder de rechthoek bevind.

Pak daar de absolute waarden van, en laat daar de stelling van Pythagoras op los.

Als de rechthoek een AABB (axis aligned bounding box) is is dat simpel Bij rotaties moet je met dot products of cosinus aan de gang. Alsnog niet erg lastig.

code:

vec2 point;
vec2 box;
int width;
int height;

int xDiff = max( 0, abs( point.x - box.x ) - width );
int yDiff = max( 0, abs( point.y - box.y ) - height );
int distance = sqrt( x * x + y * y );

untested.

[ Voor 46% gewijzigd door Verwijderd op 02-10-2013 19:56 ]

[ZpAz]

Verwijderd schreef op woensdag 02 oktober 2013 @ 19:50:
Kijk hoeveel X-eenheden (of nul) het punt zich links of rechts van de rechthoek bevind.
Kijk hoeveel Y-eenheden het punt zich boven of onder de rechthoek bevind.

Pak daar de absolute waarden van, en laat daar de stelling van Pythagoras op los.

Als de rechthoek een AABB (axis aligned bounding box) is is dat simpel Bij rotaties moet je met dot products of cosinus aan de gang. Alsnog niet erg lastig.

Aa kijk, één die ik begrijp! De "box" is "axis aligned" inderdaad altijd. Ik zal hier eens mee stoeien. De eerder gegeven Stack Overflow post lijkt ook in de juiste richting te leiden, maar hoe de aangegeven voorbeelden daar in elkaar zitten kom ik nog niet helemaal uit.

ABS & Pythagoras lijkt mij een geschikte keuze. En als hij niet "schuin" boven 1 van de hoeken staat is de kortste afstand een rechte lijn. Ik denk dat ik daar wel uit kom.

---

Verwijderd schreef op woensdag 02 oktober 2013 @ 19:50:

code:

vec2 point;
vec2 box;
int width;
int height;

int xDiff = max( 0, abs( point.x - box.x ) - width );
int yDiff = max( 0, abs( point.y - box.y ) - height );
int distance = sqrt( x * x + y * y );

untested.

Aa wacht, als ik je code zo handmatig nareken lijkt dit inderdaad goed te zijn. Dankje!

[ Voor 24% gewijzigd door ZpAz op 02-10-2013 20:12 ]

[Caelorum]

Maar je wilt dus de kortste lijn naar 1 van de hoeken van de rechthoek? Dat is namelijk wel wat anders dan de kortste lijn naar de rechthoek. Die kan namelijk zoals ZpAz al zei ook een (loodrechte?) lijn van een punt op de rechthoek naar punt A zijn.
Laat maar ^^ het is al laat...

[ Voor 7% gewijzigd door Caelorum op 02-10-2013 20:00 ]

[ZpAz]

Naar de rechthoek zelf, niet zo zeer een punt.

@hierboven Te laat, het kan niet meer gelaten worden.

edit: "Solution points" awarded to Darkstone!

Hold on, nog aan het rekenen...

[ Voor 85% gewijzigd door ZpAz op 02-10-2013 20:15 ]

[GlowMouse]

Het juiste antwoord staat er nog niet bij. JeromeBs antwoord klopt niet als afstand_x/y 0 zou moeten zijn, Darkstones antwoord klopt wel

[ Voor 38% gewijzigd door GlowMouse op 02-10-2013 20:22 ]

[ZpAz]

Naar de rechthoek zelf, niet zo zeer een punt.

@hierboven Te laat, het kan niet meer gelaten worden.

edit: "Solution points" awarded to Darkstone!

Hold on, nog aan het rekenen…

edit:

Of ik reken verkeerd of hij klopt niet.

Als mijn rechthoek zit op 10,10 met een hoogte en breedte van 10 en mijn punt zit op 1,1 dan krijg ik het volgende met rekenen.

code:

vec2 point;
vec2 box;
int width;
int height;

int xDiff = max( 0, abs( 1 - 10 ) - 10 ); // 1 - 10 = -9, -9 abs = 9, 9 - 10 = -1, max = 0
int yDiff = max( 0, abs( point.y - box.y ) - height ); // 1 - 10 = -9, -9 abs = 9, 9 - 10 = -1, max = 0
int distance = sqrt( 0 * 0 + 0 * 0 ); == 0

[Verwijderd]

Hij is inderdaad fout, ik denk dat je halfwidth moet gebruiken in plaats van width. Anders zelf nog wat puzzelen

[GlowMouse]

Wat wil je dan dat eruit komt bij 10,10 en 1,1?

[ZpAz]

GlowMouse schreef op woensdag 02 oktober 2013 @ 20:23:
Wat wil je dan dat eruit komt bij 10,10 en 1,1?

Ik verwacht iets rond de 9? Of heb ik dit nu fout.

[Daos]

Acht rechthoeken om je rechthoek heen denken. De vier rechtboven, rechtonder, rechtlinks en rechtrechts hebben een oplossing die haaks op je rechthoek staan. Bij de vier diagonaalvlakken is de kortste afstand naar het hoekpunt.

[GlowMouse]

ZpAz schreef op woensdag 02 oktober 2013 @ 20:25:
[...]


Ik verwacht iets rond de 9? Of heb ik dit nu fout.

Het punt zit in de rechthoek, dus de afstand is 0.

[Verwijderd]

GlowMouse schreef op woensdag 02 oktober 2013 @ 20:27:
[...]

Het punt zit in de rechthoek, dus de afstand is 0.

De rechthoek begint op (10, 10) is is +10 breed en +10 groot. En punt (1, 1) zit volgens jou in de rechthoek? What?

[ZpAz]

GlowMouse schreef op woensdag 02 oktober 2013 @ 20:27:
[...]

Het punt zit in de rechthoek, dus de afstand is 0.

Punt 1.1 zou toch buiten de rechthoek 10.10 zitten met breedte en hoogte van 10? De andere hoeken zijn dan 10.20, 20.10 en 20.20

Hier in een plaatje.



edit:

Ik scrollde even omhoog, en volgens mij is dit hem.

JeromeB schreef op woensdag 02 oktober 2013 @ 19:48:
beter:

code:

afstand_y = min(abs(horizontale_lijn_1_y-punt_y),abs(horizontale_lijn_2_y-punt_y))
afstand_x = min(abs(vertikale_lijn_1_x-punt_x),abs(vertikale_lijn_2_x-punt_x))
afstand = (afstand_y^2+afstand_x^2)^(1/2)

Dan gaan de solution points naar JeromeB!

Volgens hieronder toch nog niet. Ik trek ze weer in.

[ Voor 44% gewijzigd door ZpAz op 02-10-2013 20:40 ]

[JeromeB]

Nee, dat is hem toch niet. Omdat ik volgensmij ook reken vanaf de punten.

[ Voor 48% gewijzigd door JeromeB op 02-10-2013 20:40 ]

[ZpAz]

JeromeB schreef op woensdag 02 oktober 2013 @ 20:39:
Nee, dat is hem toch niet. Omdat ik volgensmij ook reken vanaf de punten.

Op het voorbeeld hierboven (het plaatje) lijkt de jouwe wel goed te komen volgens mij.

[GlowMouse]

Verwijderd schreef op woensdag 02 oktober 2013 @ 20:32:
[...]


De rechthoek begint op (10, 10) is is +10 breed en +10 groot. En punt (1, 1) zit volgens jou in de rechthoek? What?

Ik dacht dat je met axis aligned bounding box bedoelde dat het andere hoekpunt (0,0) moest zijn. Dan snap ik namelijk niet hoe je over box.x en box.y kunt praten.

Het antwoord is met jouw formule namelijk vrij simpel, alleen moet je het assenstelsel even zo kiezen dat (0,0) het hoekpunt linksonder is.

[JeromeB]

Ja, maar plaats het punt eens voorbij de 1e vertikale lijn ... dan klopt het niet meer.

[ZpAz]

GlowMouse schreef op woensdag 02 oktober 2013 @ 20:42:
[...]

Ik dacht dat je met axis aligned bounding box bedoelde dat het andere hoekpunt (0,0) moest zijn. Dan snap ik namelijk niet hoe je over box.x en box.y kunt praten.

Het antwoord is met jouw formule namelijk vrij simpel, alleen moet je het assenstelsel even zo kiezen dat (0,0) het hoekpunt linksonder is.

Het zou voor de formule toch niet uit moeten maken of 0,0 nu linksboven of linksonder zit?

JeromeB schreef op woensdag 02 oktober 2013 @ 20:39:
Nee, dat is hem toch niet. Omdat ik volgensmij ook reken vanaf de punten.

Volgens mij werkt hij als je niet "rechtboven" of "recht naast" een lijn van de rechthoek zit. Maar als je dat wel zit dan is de rechte lijn de oplossing.

[ Voor 24% gewijzigd door ZpAz op 02-10-2013 20:48 ]

[JeromeB]

Dat klopt ja, dan krijg je zoiets, maar ik heb het gevoel dat het makkelijker moet kunnen:

code:

afstand_y =
if (horizontale_lijn1_y <= punt_y <= horizontale_lijn2_y) 0
else min(abs(horizontale_lijn_1_y-punt_y),abs(horizontale_lijn_2_y-punt_y))


afstand_x =
if (vertikale_lijn1_x <= punt_x <= vertikale_lijn2_x) 0
else min(abs(vertikale_lijn_1_x-punt_x),abs(vertikale_lijn_2_x-punt_x))

afstand = (afstand_y^2+afstand_x^2)^(1/2)

[ Voor 3% gewijzigd door JeromeB op 02-10-2013 21:00 . Reden: klein foutje ]

[Verwijderd]

Ik snap al wat er fout is aan mijn versie. In plaats van de positie van de box moet je het middelpunt van de box gebruiken. In plaats van de width/hight van de box moet je de helft daarvan gebruiken. Dan klopt de formule.

Uit het voorbeeld komt dan een X-diff van 9 en Y-diff van 9. Pythagoras geeft 12.72792206.

JeromeB schreef op woensdag 02 oktober 2013 @ 20:54:
Dat klopt ja, dan krijg je zoiets, maar ik heb het gevoel dat het makkelijker moet kunnen:

code:

afstand_y =
if (horizontale_lijn1_y <= punt_y <= horizontale_lijn2_y) 0
else min(abs(horizontale_lijn_1_y-punt_y),abs(horizontale_lijn_2_y-punt_y))


afstand_x =
if (vertikale_lijn1_x <= punt_x <= vertikale_lijn2_x) 0
else min(abs(vertikale_lijn_1_x-punt_x),abs(vertikale_lijn_2_x-punt_x))

afstand = (afstand_y^2+afstand_x^2)^(1/2)

Dat zal lekker performen

[ Voor 48% gewijzigd door Verwijderd op 02-10-2013 21:01 ]

[GlowMouse]

De laatste twee posts geven goede antwoorden.

[ZpAz]

Verwijderd schreef op woensdag 02 oktober 2013 @ 21:00:
Ik snap al wat er fout is aan mijn versie. In plaats van de positie van de box moet je het middelpunt van de box gebruiken. In plaats van de width/hight van de box moet je de helft daarvan gebruiken. Dan klopt de formule.

Uit het voorbeeld komt dan een X-diff van 9 en Y-diff van 9. Pythagoras geeft 12.72792206.

Huh, als ik het probeer krijg ik een x-diff en y-diff van 6.5. Bij punt 1.1, box op 10.10 en breedte en hoogte van 10. Het middenpunt is dan 15.15 lijkt mij.

code:

vec2 point;
vec2 box;
int width;
int height;

int xDiff = max( 0, abs( 1 - 15 ) - 7.5 ); // 6.5
int yDiff = max( 0, abs( 1 - 15 ) - 7.5 ); // 6.5
int distance = sqrt( 6.5 * 6.5 + 6.5 * 6.5 ); // 9.1923...

Of doe ik weer wat fout.

[GlowMouse]

ZpAz schreef op woensdag 02 oktober 2013 @ 21:10:
[...]


Huh, als ik het probeer krijg ik een x-diff en y-diff van 6.5. Bij punt 1.1, box op 10.10 en breedte en hoogte van 10. Het middenpunt is dan 15.15 lijkt mij.

code:

vec2 point;
vec2 box;
int width;
int height;

int xDiff = max( 0, abs( 1 - 15 ) - 7.5 ); // 6.5
int yDiff = max( 0, abs( 1 - 15 ) - 7.5 ); // 6.5
int distance = sqrt( 6.5 * 6.5 + 6.5 * 6.5 ); // 9.1923...

Of doe ik weer wat fout.

De halve hoogte van de rechthoek is 5, niet 7.5.

[HMS]

Uhm, is Euclidean distance niet het makkelijkste hier?

Van: Wikipedia: Euclidean distance

Neem punt p = (px, py) en q = (qx, qy)
dan is afstand(p,q) = sqrt((px-qx)^2 + (pq-qy)^2)

Of in pseudo code:

code:

class Point {
  int x;
  int y;
}

public int distance(Point p, Point q) {
  return Math.Sqrt(Math.Pow((p.x - q.x), 2) + Math.Pow((p.y - q.y), 2))
}

edit: Het gebruik van integers is natuurlijk arbitrair, ik zou voor doubles ofzo gaan. Maar weet niet wat er gebruikt wordt nu.

[ Voor 12% gewijzigd door HMS op 02-10-2013 21:15 ]

[ZpAz]

GlowMouse schreef op woensdag 02 oktober 2013 @ 21:12:
[...]

De halve hoogte van de rechthoek is 5, niet 7.5.

Stom Je hebt gelijk. Dank iedereen voor de hulp! Die van Darkstone voldoet!

In mijn hoofd deelde ik waarschijnlijk het gegeven middenpunt.

[ Voor 13% gewijzigd door ZpAz op 02-10-2013 21:15 ]

[GlowMouse]

HMS schreef op woensdag 02 oktober 2013 @ 21:12:
Uhm, is Euclidean distance niet het makkelijkste hier?

Ja, daarom werken we daarmee.Nee, de Manhattan distance is iets eenvoudiger.

[ Voor 12% gewijzigd door GlowMouse op 02-10-2013 21:16 ]

[HMS]

GlowMouse schreef op woensdag 02 oktober 2013 @ 21:15:
[...]

Ja, daarom werken we daarmee.

Ik zal de volgende keer het hele topic moeten doorlezen, maar ik zag het zo snel nergens bij naam genoemd worden.

GlowMouse schreef op woensdag 02 oktober 2013 @ 21:15:
[...]

Ja, daarom werken we daarmee.Nee, de Manhattan distance is iets eenvoudiger.

Maar ik denk dat ZpAz graag een rechte lijn wil tussen de punten.

[ Voor 34% gewijzigd door HMS op 02-10-2013 21:17 ]

[ZpAz]

Dit is de uiteindelijke code geworden.

Objective-C:

- (float)getHoverDistance:(CGPoint)location fromBounds:(CGRect)bounds
{
    CGPoint center = CGPointMake(bounds.origin.x + bounds.size.width / 2, bounds.origin.y + bounds.size.height / 2);
    
    float distanceX = MAX(0, ABS(location.x - center.x) - bounds.size.width / 2);
    float distanceY = MAX(0, ABS(location.y - center.y) - bounds.size.height / 2);
    return sqrtf(pow(distanceY, 2) + pow(distanceX, 2));
}

En waarvoor het gebruikt is een "actie" popup menuutje voor een spel Als je in de buurt komt van de actie wordt het icoontje groter. Zie hier.

[JeromeB]

Waarom zou je in dat geval de exacte afstand tot een rechthoek willen weten? Is het niet gewoon makkelijker om de afstand van een punt tot een cirkel te berekenen?

[ZpAz]

JeromeB schreef op woensdag 02 oktober 2013 @ 21:41:
Waarom zou je in dat geval de exacte afstand tot een rechthoek willen weten? Is het niet gewoon makkelijker om de afstand van een punt tot een cirkel te berekenen?

Nja, er komt mogelijk ook nog wat tekst naast elke item en dan wordt het meer een rechthoek dan een vierkant / cirkel. Daarnaast zijn dit niet de uiteindelijke graphics. Die moeten allemaal nog gemaakt worden Dus hoe het er precies uit komt te zien weet ook ik nog niet.

[MSalters]

De efficiente oplossing is de ruimte in 9 delen opdelen, met behulp van een 4 bits code:

bit 0 geeft aan of een punt links van de linkerkant ligt.
bit 1 geeft aan of een punt boven de bovenkant ligt.
bit 2 geeft aan of een punt rechts van de rechterkant ligt.
bit 3 geeft aan of een punt onder de onderkant ligt.

Maximaal 4 vergelijkingen dus, en soms minder (bit 2 hoef je alleen te bepalen als bit 0 false is)

Vervolgens kun je een switch() doen op het resultaat. 7 van de cases zijn onmogelijk, je krijgt dus 9 echte mogelijkheden.
case 0 : binnen rechthoek.
case 1: afstand = x - left;
case 2: afstand = y - top;
case 3: afstand = distance(x-left, y-top); // distance(x,y) = sqrt(x*x + y*y)

etcetera.

[Verwijderd]

En waarom zou dat efficienter zijn? Ik zie 8 branches of een jump table (= traaaag) plus de hoeveelheid berekeningen die je nodig hebt om de 'bits' te berekenen. Volgens mij duurt het berekenen van de 'bits' al langer dan het berekenen van de x en y offset zelf.

[Zoijar]

ZpAz schreef op woensdag 02 oktober 2013 @ 21:31:
Dit is de uiteindelijke code geworden.

Objective-C:

- (float)getHoverDistance:(CGPoint)location fromBounds:(CGRect)bounds
{
    CGPoint center = CGPointMake(bounds.origin.x + bounds.size.width / 2, bounds.origin.y + bounds.size.height / 2);
    
    float distanceX = MAX(0, ABS(location.x - center.x) - bounds.size.width / 2);
    float distanceY = MAX(0, ABS(location.y - center.y) - bounds.size.height / 2);
    return sqrtf(pow(distanceY, 2) + pow(distanceX, 2));
}

Ik weet niet of dat optimized is/wordt, maar pow(x,2) is waarschijnlijk geen goed idee. x*x is potentieel een stuk sneller. Niet dat het veel zal uitmaken hier.

Overigens kan je vaak de sqrt er ook nog uitgooien door te vergelijken met c*c... ligt er een beetje aan.

---
(unpredictable) branches zijn iha killing idd. Dan kan je beter een extra zooi MADs hebben.

[ Voor 11% gewijzigd door Zoijar op 03-10-2013 12:18 ]

[Bartjuh]

Het grappige is dat een zeer vergelijkbaar probleem (algemener probleem) ook wordt opgelost in de lineaire algebra, namelijk least squares.

[Soultaker]

Zoijar schreef op donderdag 03 oktober 2013 @ 12:14:
Ik weet niet of dat optimized is/wordt, maar pow(x,2) is waarschijnlijk geen goed idee. x*x is potentieel een stuk sneller.

In 1975 ja. Tegenwoordig optimaliseert de compiler dat soort dingen gewoon.

Kun je trouwens niet gewoon hypotf(distanceX, distanceY) doen? Of heeft Objective-C die functie niet?

[ Voor 15% gewijzigd door Soultaker op 03-10-2013 18:10 ]

[Verwijderd]

Ik neem aan dat dat kan, maar als je integer math gebruikt kan je dat beter niet doen. hypotf levert 2 int-naar-float conversies op, sqrtf() slechts 1.

[JeromeB]

Verwijderd schreef op donderdag 03 oktober 2013 @ 11:46:
En waarom zou dat efficienter zijn? Ik zie 8 branches of een jump table (= traaaag) plus de hoeveelheid berekeningen die je nodig hebt om de 'bits' te berekenen. Volgens mij duurt het berekenen van de 'bits' al langer dan het berekenen van de x en y offset zelf.

Ik weet niet precies wat MSalters voor egen heeft wat betreft bits, maar hij heeft wel gelijk wat betreft het opdelen in 9 ruimtes. Een voorbeeldje:

code:

afstand = 

if ( punt_x < vertikale_lijn_1_x)
{
    if(punt_y < horizontale_lijn1_y) { ( (vertikale_lijn_1_x - punt_x)^2 + (horizontale_lijn_1_y - punt_y)^2 ) ^ (1/2) }
    else if (punt_y > horizontale_lijn2_y) { ( (vertikale_lijn_1_x - punt_x)^2 + (punt_y - horizontale_lijn_2_y)^2 ) ^ (1/2) }
    else { vertikale_lijn_1_x - punt_x }
}
else (punt_x > vertikale_lijn_2_x)
{
    if(punt_y < horizontale_lijn1_y) { ( (punt_x - vertikale_lijn_2_x)^2 + (horizontale_lijn_2_y - punt_y)^2 ) ^ (1/2) }
    else if (punt_y > horizontale_lijn2_y) { ( (punt_x - vertikale_lijn_2_x)^2 + (punt_y - horizontale_lijn_2_y)^2 ) ^ (1/2) }
    else { punt_x - vertikale_lijn_2_x }
}
else
{
    if(punt_y < horizontale_lijn1_y) { horizontale_lijn_1_y - punt_y }
    else if (punt_y > horizontale_lijn2_y) { punt_y - horizontale_lijn2_y }
    else { 0 }
}

Dat zijn dus maximaal 4 vergelijkingen, maar soms ook minder. Bij jouw oplossing wordt altijd twee keer een max en twee keer een abs uitgevoerd. Dat is op de meeste architecturen 4 vergelijkingen.


Verder is het lastig te zeggen welke oplossingen beter performen zonder dat je de onderliggende architectuur kent en de situatie (de inputs). Ik kan bijvoorbeeld een (flauwe) situatie bedenken waarin mijn eerste oplossing beter performt dan jouw oplossing.

[Verwijderd]

Een abs() is zo goed als gratis op een float bij x86.

Wie bied een SSE oplossing?

Edit: abs() kan ook branchles met ints: http://stackoverflow.com/...sembly-abs-implementation.
edit: en max() ook: http://graphics.stanford....acks.html#IntegerMinOrMax

Dan blijven er 0 branches over. Niet dat branches altijd slecht zijn, maar toch.

[ Voor 73% gewijzigd door Verwijderd op 03-10-2013 18:55 ]

[ZpAz]

Soultaker schreef op donderdag 03 oktober 2013 @ 18:08:
[...]

In 1975 ja. Tegenwoordig optimaliseert de compiler dat soort dingen gewoon.

Kun je trouwens niet gewoon hypotf(distanceX, distanceY) doen? Of heeft Objective-C die functie niet?

Yeah, die is er ook zo te zien. Ik wist niet dat dat bestond.

[I-King]

Kun je niet een rechthoek om de rechthoek tekenen (geschaald of met een offset), waarna je dan kijkt of het punt binnen die nieuwe rechthoek ligt? Kijken of x tussen min en max zit en y binnen min en max zit.
Exacte afstand boeit in jouw geval minder heb ik het idee.

Ik ben geen programmeur, maar dit leek mij wel een aardige oplossing.

if ( xleft-offset < x < xright+offset) && (ybottom-offset < y < ytop+offset ) {
enlarge{};
}

[RobIII]

Verwijderd schreef op donderdag 03 oktober 2013 @ 18:31:
Ik neem aan dat dat kan, maar als je integer math gebruikt kan je dat beter niet doen. hypotf levert 2 int-naar-float conversies op, sqrtf() slechts 1.

Verwijderd schreef op donderdag 03 oktober 2013 @ 18:46:
Een abs() is zo goed als gratis op een float bij x86.

Wie bied een SSE oplossing?

Edit: abs() kan ook branchles met ints: http://stackoverflow.com/...sembly-abs-implementation.
edit: en max() ook: http://graphics.stanford....acks.html#IntegerMinOrMax

Dan blijven er 0 branches over. Niet dat branches altijd slecht zijn, maar toch.

Gast, seriously, we hoeven niet allemaal de onderste CPU cycle uit de kan Misschien dat je heel even eens iets anders moet gaan doen dan CPU-cycle-copuleren en weer terug komen in de real world* Ik denk dat dit t/m een stuk of ...tig van die wiebeldingetjes prima performed hoor Tegen de tijd dat je hier CPU cycles moet gaan tellen is je UI al aardig onoverzichtelijk lijkt me

* Niet dat er, an sich, iets mis mee is (en ik vind 't leuk dat je er zoveel lol aan beleeft), maar 't gaat hier in dit topic wel wat te ver denk ik en begint behoorlijk op "premature optimization" te lijken if you know what I mean.

[ Voor 18% gewijzigd door RobIII op 03-10-2013 22:03 ]

[ZpAz]

I-King schreef op donderdag 03 oktober 2013 @ 20:35:
Kun je niet een rechthoek om de rechthoek tekenen (geschaald of met een offset), waarna je dan kijkt of het punt binnen die nieuwe rechthoek ligt? Kijken of x tussen min en max zit en y binnen min en max zit.
Exacte afstand boeit in jouw geval minder heb ik het idee.

Ik ben geen programmeur, maar dit leek mij wel een aardige oplossing.

if ( xleft-offset < x < xright+offset) && (ybottom-offset < y < ytop+offset ) {
enlarge{};
}

In het filmpje die gepost was moet er nog wat getweaked worden, maar het idee is hoe dichterbij een "knop" hoe groter de "knop". De afstand wordt gebruikt voor de schaal van de knop. Binnen bepaalde grenzen uiteraard.

[ Voor 5% gewijzigd door ZpAz op 03-10-2013 21:18 ]