Kurvenpunkte

jonasX · 5. Dezember 2012

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

dongdong · 6. Dezember 2012

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:

Code

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

Alles anzeigen

jonasX · 7. Dezember 2012

Alles klar. Deine Lösung werde ich mal nachher ausprobieren.

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

Code

void DPWorker::Generate (int inCount) {
emit SignalGeneratingPolyline ();
QTime t;
t.start ();
mGeneratedCoords.resize (inCount*2);
mSimplifiedCoords.clear ();
qreal miny = inCount;
qreal maxy = -inCount;
const qreal PI = std::atan (1.0) * 4;
qreal step = 2 * PI / inCount;
int a = 1 + (rand () % 2); // [1, 3]
int b = 2 + (rand () % 3); // [2, 5]
int c = 3 + (rand () % 7); // [3, 10]
// generate a random line
for (int i=0; i<inCount; i++) {
mGeneratedCoords [i*2] = i;
qreal tmp1 = cos (step * i * a) / 3;
qreal tmp2 = sin (step * i * b) / 5;
qreal tmp3 = sin (step * i * c) / 10;
mGeneratedCoords [i*2+1] = tmp1 + tmp2 + tmp3;
miny = qMin (miny, mGeneratedCoords [i*2+1]);
maxy = qMax (maxy, mGeneratedCoords [i*2+1]);
}
// translate the line to (0,0) and scale the line to (2 * inCount, inCount)
qreal scaley = (inCount-1) / (maxy-miny);
for (int i=0; i<inCount; i++) {
mGeneratedCoords [i*2+1] = (mGeneratedCoords [i*2+1] - miny) * 0.5 * scaley;
}
//mGeneratedCoords.push_back(0);
emit SignalGeneratedPolyline (t.elapsed (), mGeneratedCoords);
}

Alles anzeigen

dongdong · 7. Dezember 2012

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

Teilen