Kurvenpunkte

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

      Hey Leute,

      ich habe ein kleines Problem. Ich benötige 1.5 mio. Kurvenpunkte. Alles random abstände die nicht grösser als 1 sein dürfen. Auf der Y Achse max grösse 100 und X Achse ist egal. Kann eine Parabel sein aber auch eine Sinuskurve. Das ist egal. Die Daten werden dann einfach durch den Douglas-Peucker-Algorithmus geschickt, der schon fertig ist. Es fehlen nur noch die demo daten.

      Kann einer mir verraten wie man sinnvolle Kurvendaten erzeugt.
      Pseudo Code würde auch reichen.

      Schonmal vielen Dank im vorraus ;)

      Nimm doch einfach ne Sinusfunktion und speichere das Ergebnis in einem array of Point (einfacher x,y Punkt).

      Deine Sinus Funktion muss ja nach Vorgabe wie folgt aussehen:
      f(x) = 100 * sin(x) (Wertebereich ist dann -100 bis 100)

      So und du brauchst 1,5 mio. punkte, also musst du 1,5 mio mal rechnen -> du brauchst ne schleife die 1,5 mio. mal durch läuft. Da deine Punkte maximal Abstand 1 haben dürfen, musst du das auch noch checken. Ist der Abstand größer wie 1 musst du die x-Achseninkremetierung niedriger machen.

      Pseudo code:

      Quellcode

      1. results = Point[];
      2. x = 0;
      3. inc = 0,5;
      4. i = 0;
      5. while (i <= 1,5 mio.) {
      6. y = 100 * sin(x);
      7. //jetzt muss gecheckt werden, ob der Punkt einen kleineren Abstand als 1 hat, siehe Satz von Pythagoras
      8. if (i != 0 && distBerechnungNachPythagoras > 1) {
      9. x -= inc; //x auf vorherigen wert zurück setzen
      10. inc *= 0,2 //inkrementierung verkleinern
      11. }
      12. else {
      13. //erster eintrag oder test bestanden
      14. results[i] = new Point(x, y);
      15. x += inc //x wert erhöhen
      16. i += 1; //ergebniszähler erhöhen
      17. }
      18. }
      Alles anzeigen

      Danke an xNiGhTMaR3x für die Signatur und Avatar =)
      Alles klar. Deine Lösung werde ich mal nachher ausprobieren.

      Ein Kollege hat mir eben noch das hier gegeben. Finde ich sehr verwirrend.

      Quellcode

      1. void DPWorker::Generate (int inCount) {
      2. emit SignalGeneratingPolyline ();
      3. QTime t;
      4. t.start ();
      5. mGeneratedCoords.resize (inCount*2);
      6. mSimplifiedCoords.clear ();
      7. qreal miny = inCount;
      8. qreal maxy = -inCount;
      9. const qreal PI = std::atan (1.0) * 4;
      10. qreal step = 2 * PI / inCount;
      11. int a = 1 + (rand () % 2); // [1, 3]
      12. int b = 2 + (rand () % 3); // [2, 5]
      13. int c = 3 + (rand () % 7); // [3, 10]
      14. // generate a random line
      15. for (int i=0; i<inCount; i++) {
      16. mGeneratedCoords [i*2] = i;
      17. qreal tmp1 = cos (step * i * a) / 3;
      18. qreal tmp2 = sin (step * i * b) / 5;
      19. qreal tmp3 = sin (step * i * c) / 10;
      20. mGeneratedCoords [i*2+1] = tmp1 + tmp2 + tmp3;
      21. miny = qMin (miny, mGeneratedCoords [i*2+1]);
      22. maxy = qMax (maxy, mGeneratedCoords [i*2+1]);
      23. }
      24. // translate the line to (0,0) and scale the line to (2 * inCount, inCount)
      25. qreal scaley = (inCount-1) / (maxy-miny);
      26. for (int i=0; i<inCount; i++) {
      27. mGeneratedCoords [i*2+1] = (mGeneratedCoords [i*2+1] - miny) * 0.5 * scaley;
      28. }
      29. //mGeneratedCoords.push_back(0);
      30. emit SignalGeneratedPolyline (t.elapsed (), mGeneratedCoords);
      31. }
      Alles anzeigen

      Das sieht in der Tat verwirrend aus ;)

      Mir ist gerade eingefallen, dass du keine 1,5 mio. Punkte berechnen musst bei der Sinusfunktion. Du musst die Werte nur bis 2 PI berechnen, danach wiederholen die sich ja immer wieder. D.h. wenn du einmal deine Werte bis 2 PI hast, musst du auf das X von einem Punkt nur 2 PI drauf rechnen und schon hast du deinen nächsten Punkt. Ist weniger Rechenaufwand :)

      Danke an xNiGhTMaR3x für die Signatur und Avatar =)