Wiskunde, graden naar afstand

[ZpAz]

Mijn grootste struikelblok, wiskunde, zit me nu ook weer in de weg. Ik ben bezig met een view te maken die je kan vouwen in iOS. Zoals hier te zien.

Dit is mij gelukt, ik kan de view offscreen renderen, opdelen in plaatjes en roteren e.d. works like a charm, maar nu zit ik met een ander punt waar ik vast loop.

Ik zal een plaatje toevoegen om het te illustreren.



In bovenstaand plaatje zie je het geheel van de zijkant, de horizonale lijn is zeg maar het scherm vanaf de zijkant gezien, met de 'gevouwde' view er boven op. De gestreepte lijntjes zijn denkbare lijnen, als ik enkel de eerste vouw zou maken (dus die op punt 0) naar een waarde tussen 0 en -90 graden (hij staat nu ongeveer op -45 graden) dan zouden de andere views 'omhoog' komen.

In 3D is dat hier te zien.

De volgende vouw is dus een vouw in graden de andere kant op, en de volgende wordt weer de andere kant op gevouwd. (Ik hoop dat dat duidelijk is). De allereerste view (links in het plaatje) wordt dus geroteerd tussen een as van 0 en -90 graden (deze begint namelijk 'plat'), de volgende tussen 0 en 180 graden, de opvolgende tussen 0 en -180 graden, de volgende tussen 0 en 180 graden en weer de volgende tussen 0 en -180 graden enzovoort enzovoort.

Nu heb ik het zo gemaakt dat als ik de vouw methode een cijfer tussen 0 en 1 geef hij vouwt, 0 is helemaal ingeklapt (dus dan staat hij voor de eerste op -90 graden, dan op 180 graden, dan -180, dan 180 enz.) en bij 1 is hij helemaal uitgeklapt, dan staat alles op 0 graden. En bij 0.5 er tussenin (-45, 90, -90... enz)

So far so good. Nu heb ik een touch systeem ingesteld dat als ik op punt 0 ben hij 0 terug geeft en punt 1 hij 1 terug geeft, halverwege het scherm aanraken geeft hij dus een 0.5 terug.

Nu dacht ik nou, dan gooi ik die waarde gewoon in de vouwfunctie en als ik dan heen en weer ga met mijn vinger vouwt of de view in of uit. Wat op zich werkt als te zien in deze video.*

[YouTube: http://www.youtube.com/watch?v=fGAgag-zDTY&feature=youtu.be]
*In de video gaat hij crappy als hell, op de iPhone is het smooth en normaal, ligt denk ik aan de simulator, opnemen en het feit dat mijn MBP dat niet tegelijk trekt

Anyways mijn probleem is te zien in de video, als ik laten we zeggen halverwege ben met mijn muis (dus op 0.5), loopt de positie van het vouwen iets achter, als ik helemaal rechts ben met de muis (dus op 1) heeft het vouw systeem weer 'ingelopen' en eindigt het wel gelijk.

Nu verwacht ik dat ik iets met sinus / cosinus moet doen om dit lekker te laten lopen zodat mijn 0 tot 1 positie coordinaten overeenkomt met de 0 tot 1 graden in mijn rotatie. Maar wat.

---

Als ik het probleem zo bekijk is mijn vraagstelling te moeilijk en moet het ook zo kunnen, als ik het terug breng naar 1 item die roteert, dan krijg je volgens mij dit.



Waar de afstand 0 in het midden van de circel zit, en 0.5 helemaal rechts, (reken je niet vanaf het midden maar vanaf links, de gehele doorsnede dan heb je een afstand van 1). Ik weet de positie op die lijn, wat is de bijbehorende graad.

[ Voor 7% gewijzigd door ZpAz op 20-03-2013 17:55 ]

[Coocoocachoo]

Als ik het goed begrijp moet je functie als volgt:
GRADEN_IN_0_TOT_1 = INVERSE_COSINE(1 - LOCATIE_TOT_WAAR_UITGEVOUWEN)/(0.5*PI)

De cosinus beschrijft de verhouding tussen de horizontale lijn en de lengte van het gevouwen stuk, door daar de inverse van te nemen krijg je de hoek in radialen. Omdat jij de hoek inverteerd trek ik de locatie waartot moet uitgevouwen worden eerst van 1 af (ik inverteer hem). Om dan van radialen naar jouw schaal van 0-1 over 0-90graden te gaan moet je door 0.5*pi delen.

Let er op dat ik uit ga van radialen, als de inverse cosinus functie dat niet doet moet je ipv delen door 0.5 Pi door 90 graden delen.

Gedraagt het systeem zich met deze functie zoals je wilt?

[ZpAz]

Hallo, jou heb ik hier nog niet eerder gezien

Helaas, dat werkt ook niet. Het gedrag is dan ongeveer hetzelfde als voorheen maar dan versneld. Misschien dit effect wat dat oplevert omgedraaid, dat dat werkt. Maar ik zou zo niet weten hoe dat gaat.

[ Voor 88% gewijzigd door ZpAz op 20-03-2013 17:09 ]

[G33rt]

Dat plaatje lijkt me vrij ongelukkig, aangezien je bij helemaal uitgevouwen een vlakke lijn hebt, om dat alles netjes uitgeklapt is? Het label 1 langs de x-as kan toch niet goed zijn?

[ZpAz]

G33rt schreef op woensdag 20 maart 2013 @ 16:59:
Dat plaatje lijkt me vrij ongelukkig, aangezien je bij helemaal uitgevouwen een vlakke lijn hebt, om dat alles netjes uitgeklapt is? Het label 1 langs de x-as kan toch niet goed zijn?

Je hebt gelijk, ik heb het plaatje aangepast.

[haarbal]

Dan zou ik nu nog even de afstanden en hoeken toevoegen die je in je programma gebruikt.

[ZpAz]

haarbal schreef op woensdag 20 maart 2013 @ 17:05:
Dan zou ik nu nog even de afstanden en hoeken toevoegen die je in je programma gebruikt.

Sorry, ik volg hem niet helemaal. Volgens mij heb ik die informatie toch toegevoegd? Het eerste gedeelte wordt gevouwen onder een hoek van 0 tot - 90 graden, de volgende van 0 tot 180, dan 0 tot -180 dan 0 tot 180, weer 0 tot -180 enz.

Helemaal 'links' op de kaart is 0, helemaal rechts op de kaart is 1. Een getal tussen 0 en 1 levert een waarde voor de graden op, bijvoorbeeld 0.5 levert 45 graden op voor het eerste stuk, dan 90 of -90 aan de hand van of het een even of oneven stuk is.

[haarbal]

dus je input is een getal tussen 0 en 1 en de output naar je prog is graden?

[ Voor 9% gewijzigd door haarbal op 20-03-2013 17:09 ]

[ZpAz]

Correct. 0 levert 'de stand in graden' op dat het helemaal dicht is gevouwen en 1 levert de stand op dat het helemaal is uitgevouwen.

[G33rt]

Prima. Dan is het niet zo moeilijk. De hoek zal natuurlijk afhangen van het aantal vouwen dat je hebt.

Lengte voor één segmentje (driehoekje) is x/N, waar N het aantal segmenten is.
De linkerhelft van het eerste segmentje (de omhooggaande lijn) is dus langs de x-as op positie x/2N.
Per constructie is de schuine zijde 1/2N: volledig uitgeklapt heb je 2N schuine zijdes die de hele lijn moeten afdekken.
Dat wil zeggen dat cos(alpha) = (x/2N) / (1/2N) = x.
Met andere woorden, alpha = arccos(x).

En natuurlijk loopt jouw oplossing dan achter om vervolgens in te halen:



Jouw oplossing trekt een rechte lijn van (0, pi/2) naar (1,0). De goede oplossing is de blauwe stippelijn.

[ Voor 24% gewijzigd door G33rt op 20-03-2013 17:22 ]

[Coocoocachoo]

ZpAz schreef op woensdag 20 maart 2013 @ 16:48:
Hallo, jou heb ik hier nog niet eerder gezien

Helaas, dat werkt ook niet. Het gedrag is dan ongeveer hetzelfde als voorheen maar dan versneld. Misschien dit effect wat dat oplevert omgedraaid, dat dat werkt. Maar ik zou zo niet weten hoe dat gaat.

hoi

Wat bedoel je precies met versneld?
En welke hoek geef je de eerste vouw nu met mijn formule?

G33rt schreef op woensdag 20 maart 2013 @ 17:11:
Prima. Dan is het niet zo moeilijk. De hoek zal natuurlijk afhangen van het aantal vouwen dat je hebt.

Lengte voor één segmentje is x/N, waar N het aantal segmenten is.
De linkerhelft van het eerste segmentje (de omhooggaande lijn) is dus langs de x-as op positie x/2N.
Per constructie is de schuine zijde 1/2N: volledig uitgeklapt heb je 2N schuine zijdes die de hele lijn moeten afdekken.
Dat wil zeggen dat cos(alpha) = (x/2N) / (1/2N) = x.
Met andere woorden, alpha = arccos(x).

Met arccos(x) (gecorigeerd naar een schaal van 0-1) krijg je alleen 1 bij input 0 en 0 bij input 1 terwijl hij het precies andersom wilt.
Daarom had ik 1-x gebruikt, maar als mijn hersenen aan het eind van de werkdag nog iets doen moet die 1- natuurlijk buiten de arccos, dus wordt de formule:
GRADEN_IN_0_TOT_1 = 1 - INVERSE_COSINE(LOCATIE_TOT_WAAR_UITGEVOUWEN)/(0.5*PI)

Als dat nog steeds niet klopt dat trek ik me terug en ga ik me in een hoekje schamen

[ Voor 51% gewijzigd door Coocoocachoo op 20-03-2013 17:21 . Reden: reactie op G33rt toegevoegd ]

[G33rt]

Ik begrijp niet helemaal wat je bedoelt. arccos(0) = pi/2, en dat is precies wat hij wil. De vouw staat dan verticaal. De hoek waar ik mee gerekend heb is de hoek ten opzichte van de horizontale as (vandaar cos(x)), niet ten opzichte van de verticale.

[ Voor 3% gewijzigd door G33rt op 20-03-2013 17:31 ]

[ZpAz]

Ik heb mijn vraag aangepast, zie TS onder de streep. Volgens mij is dat namelijk wat ik wil bereiken als het versimpeld wordt.

[haarbal]

Je wilt gewoon dat de rand van de pagina zit waar je vinger zit. Maar goed, hoe gedraagt die vouwfunctie zich? wat wil die als input hebben? Goed, dat zal wel ergens te vinden zijn.

[G33rt]

ZpAz, dat is inderdaad wat je wilt bereiken. Als je vinger in het midden is (x=0.5, ik ga uit van een cirkel met straal 1, oorsprong dus aan de linkerkant) en je hebt één vouw, is de piek van die vouw op x=0.25. De beide stukken van de vouw zijn 0.5 lang. Dat is gewoon een driehoekje waar je hoeken in kunt uitrekenen, en dat is redelijk eenvoudig te generaliseren naar N vouwen.

[P-Storm]

Wil je altijd eindigen met de vouw compleet? Dan moet je inderdaad kijken naar G33rt zijn oplossing.

Volgens mij krijg je dan wel een raar effect wanneer er een vouw erbij komt, maar dat zul je moeten uitproberen

Zoals het filmpje het aangeeft zijn er al N aantal vouwen en is dit aantal vast, dat scheelt ook met nieuwe randen opeens verschijnen.

Je zult een functie moeten defineren wat mathlap als Traingle Wave noemt.

Ik zit zelf te denken hoe je dat makkelijker kan doen met if branches ipv een regel wiskunde .

edit:
Gevonden

code:

abs((t*N - floor(t*N + 1/2)))

Wolfram alpha link
Met N aantal vouwen op het stuk [0,1]

[ Voor 67% gewijzigd door P-Storm op 20-03-2013 18:49 ]

[ZpAz]

In mijn code is het aantal vouwen niet vast, maar is dat wel relevant?

Als je dit plaatje hebt.



Weet ik volgens mij x en y (omdat hij om zijn eigen as moet draaien is x het inverse is van y volgens mij) en x weet ik door wat ik aanraak. Hoe kan ik als ik x en y weet t krijgen.

[ Voor 25% gewijzigd door ZpAz op 21-03-2013 11:49 ]

[haarbal]

ZpAz schreef op woensdag 20 maart 2013 @ 15:40:
Nu dacht ik nou, dan gooi ik die waarde gewoon in de vouwfunctie en als ik dan heen en weer ga met mij vinger vouwt of de view in of uit.

Heb je ergens al opgezocht wat die vouwfunctie precies doet? welke input hij hebben moet etc.

[ZpAz]

haarbal schreef op woensdag 20 maart 2013 @ 18:56:
[...]

Heb je ergens al opgezocht wat die vouwfunctie precies doet? welke input hij hebben moet etc.

Ik heb hem zelf geschreven. In TS staat volgens mij hoe hij werkt. Aan de hand van de cijfer tussen 0 en 1 pak ik momenteel graden door dit te doen:

0 is 0 % 1 is 100%, er is 0 graden en 90 graden, bij 90 graden heb ik 100%. 45 graden is 50% en alles wat daar tussen zit, maar dat moet dus anders.

[G33rt]

ZpAz schreef op woensdag 20 maart 2013 @ 18:53:
In mijn code is het aantal vouwen niet vast, maar is dat wel relevant?

Als je dit plaatje hebt.

[afbeelding]

Weet ik volgens mij x en y (omdat hij om zijn eigen as moet draaien is x gelijk aan y volgens mij) en x weet ik door wat ik aanraak. Hoe kan ik als ik x en y weet t krijgen.

Je plaatje geeft het antwoord: x = cos(t) en y = sin(t). Dat is precies de oplossing die ik je daarstraks gaf.

En nee, het aantal vouwen is niet relevant. N valt uit de vergelijking, want x -> x/N en y -> y/N dus de hoek blijft hetzelfde.

[ Voor 9% gewijzigd door G33rt op 20-03-2013 19:05 ]

[Coocoocachoo]

G33rt schreef op woensdag 20 maart 2013 @ 17:30:
Ik begrijp niet helemaal wat je bedoelt. arccos(0) = pi/2, en dat is precies wat hij wil. De vouw staat dan verticaal. De hoek waar ik mee gerekend heb is de hoek ten opzichte van de horizontale as (vandaar cos(x)), niet ten opzichte van de verticale.

Ik begreep uit het volgende uit de OP:

Nu heb ik het zo gemaakt dat als ik de vouw methode een cijfer tussen 0 en 1 geef hij vouwt, 0 is helemaal ingeklapt (dus dan staat hij voor de eerste op -90 graden, dan op 180 graden, dan -180, dan 180 enz.) en bij 1 is hij helemaal uitgeklapt, dan staat alles op 0 graden. En bij 0.5 er tussenin (-45, 90, -90... enz)

So far so good. Nu heb ik een touch systeem ingesteld dat als ik op punt 0 ben hij 0 terug geeft en punt 1 hij 1 terug geeft, halverwege het scherm aanraken geeft hij dus een 0.5 terug.

Dat hij een formule/functie wilde hebben die afhankelijk van een input tussen 0 en 1 (het horizontale "percentage") een getal tussen 0 en 1 terug zou geven waaraan de hoek van de eerste vouw wordt berekend. Bij input 0 hoort dan ook output 0, wat dat is de ingeklapte status. Vandaar mijn invertering (1-) en deling door pi/2.

Als je van een "normale" gradenverdeling uitgaat vanaf de horizontale as en de vouwmethode een radiaal als input kan geven is arccos(x) inderdaad voldoende.

[ZpAz]

Thanks mensen, het probleem kon inderdaad opgelost worden met acos.

C:

        if(currentJointLayerIndex == 0)
        {
            //90
            angle = acos(amountForAngle);
        }
        else if(currentJointLayerIndex % 2 == 1)
        {
            //180
            angle = -(acos(amountForAngle) * 2);
        }
        else
        {
            //-180
            angle = (acos(amountForAngle) * 2);
        }

Dit werkt als ik elk item evenveel roteer, maar ik probeer nu het effect te krijgen dat bijvoorbeeld de versten het eerste uitvouwen (papier vouwt als je het aantrekt normaal ook niet gelijktijdig uit). Maar dan gaat hij niet helemaal lekker.

Momenteel doe ik dat zo:

C:

        float amount = (((float)currentJointLayerIndex) / (float)[self.jointLayers count]);
        float amountForAngle = (foldPosition * (amount + 1));
        amountForAngle = (amountForAngle > 1) ? 1 : amountForAngle;
        amountForAngle = (amountForAngle < 0) ? 0 : amountForAngle;
        
        float angle;
        if(currentJointLayerIndex == 0)
        {
            //90
            angle = acos(amountForAngle);
        }
        else if(currentJointLayerIndex % 2 == 1)
        {
            //180
            angle = -(acos(amountForAngle) * 2);
        }
        else
        {
            //-180
            angle = (acos(amountForAngle) * 2);
        }

Wat dat doet is elke 'amountForAngle' die ik aan de acos voer een percentage te zijn van wat het is voor die vouw, maar alles bij elkaar opgeteld is wel 100%. Maar dan loopt hij niet helemaal lekker meer. Volgens mij heeft dat weer te maken met het feit dat niet elke graad 'dezelfde' afstand oplevert.

Zie dit filmpje voor hoe het dan loopt. Het eerste gedeelte lijkt wel goed te gaan. Als ik trouwens dit daarvoor doe:

edit: Ik moet natuurlijk die procent niet doen van de parameter die ik meestuur maar van de angle die ik terug krijg denk ik.

[ Voor 6% gewijzigd door ZpAz op 21-03-2013 15:49 . Reden: syntax error ]

[Coocoocachoo]

Ondanks dat mijn eerdere hulppogingen niet volledig succesvol waren waag ik toch weer een poging:

Ik vind het lastig om het filmpje goed te interpreteren aangezien hij niet helemaal vloeiend loopt, maar als ik je wens goed snap wil je dat de meest rechter vouw verder uitvouwt dan de meest linker.
Om dan toch nog op hetzelfde eindpunt uit te komen moet de oppervlakte onder de vouwen (horizontale as) gelijk blijven. Dit doe je door de gemiddelde hoek hetzelfde te houden (de kleinere hoeken compenseren met grotere hoeken).
Het makkelijkste om dit te realiseren is n*x bij de amountForAngle op te tellen, waarbij n het aantal vouwen van de middelste vouw is (dus links ervan is negatief) en x een klein getal waar je mee moet spelen om te kijken welke waarde het effect het best weergeeft.
Zo verloopt het echter wel lineair terwijl ik denk dat het in het echt eerder exponentieel is, dan wordt je formule echter wel lastiger om de gemiddelde hoek nog steeds te behouden.