?
YES!
ich brauche es gar nicht mehr danke
es funktioniet jetzt auch so. es wird kein punkt mehr doppelt ausgegeben. aber um ehrlich zu sein weiss ich nicht genau warum, denn eigenltich habe ich nichts anders gemacht^^
#include <iostream>//ich packe meinen koffer und secke ein: alle bibliotheken die ich brauche ;)
#include <cmath>
#include <fstream>
using namespace std;
ofstream out("flocke.txt");//hier wird der pfad der datei, ihr name und das format festgelegt
class pcoord //ein punkt wird mit den argumenten der x und y koordinaten als class definiert
{
public:
double x;
double y;
};
pcoord * flocke(pcoord*, int, double, int);//die funktion flocke wird definiert
int main()
{
int rek=0;// die rekursionstiefe
int anz=0;// die anzahl der vorgegebenen punkte
double p=0.0;// der streckfaktor p
cout<< "Willkommen!\nUm Ihre hoechst-eigene Schneeflocke zu erstellen, folgen sie den Anweisungen:\n\n" <<endl;
while(1)//schleife zur eingabe der anzahl der punkte; so lange man weniger als 2 punkte angibt gehts nicht weiter
{
cout<< "Sie muessen mindestens zwei Punkte angeben!" <<endl;
cout<< "Geben Sie eine Anzahl von Punkten ein: " <<endl;
cin>> anz;
if (anz<2)
;
else
break;
}
pcoord * B = new pcoord[anz];//das feld B wird deklariert welches alle angegebenen punkte enthaelt
for(int i=0; i<anz; i++)
{
cout<< "Geben Sie die Koordinaten des " << i+1 << ". Punktes an:" <<endl;//die koordinaten der einzelnen punkte werden abgefragt
cout<< "X-Koordinate: " <<endl;
cin >> B[i].x;
cout<< "Y-Koordinate: " <<endl;
cin >> B[i].y;
}
cout<< "Geben Sie den Streckfaktor an: " <<endl;//streckfaktor und rekursionstife werden abgefragt
cin >> p;
cout<< "Geben Sie die Rekursionstiefe an: " <<endl;
cin >> rek;
out << B[0].x << "\t" << B[0].y << endl;//der erste punkt soll ausgegeben werden, da er aus mir unerklärlichen gründen wegfaellt
for(int i=0; i+1<anz; i++)//hier soll die funktion auf die jeweils aufeinanderfolgenden punkte angewendet werden. also zunaechst auf den ersten und
{ //und zweiten, dann aud denn zweiten und dritten usw...
pcoord * A = new pcoord[2];//ein punktefeld mit 2 elementen wird erstellt, da die funktion nur auf 2 punkte anwendbar ist
A[0].x = B[i].x;//nach der reihe werden dann die angegebenen punkte durchgegangen
A[0].y = B[i].y;
A[1].x = B[i+1].x;
A[1].y = B[i+1].y;
flocke(A, rek, p, anz);
delete[] A;//der benutzte speicher wird gelöscht
}
delete[] B;//der benutzte speicher wird gelöscht
}//hier endet die main
pcoord * flocke(pcoord *A, int rek, double p, int anz)//jetzt wird gesagt was in der funktion flocke geschehen soll
{
if(rek>0)//wenn die rekursionstiefe >0 ist sollen die neu-entstehenden punkte berechnet werdern. dies ist auch gleichzeitig die abbbruchbedingung
{ //für die funktion
pcoord *punkte = new pcoord[5];//deklarierung eines neuen punktefeldes in dem die koordinaten der entstehenden punkte stehen
punkte[0].x = A[0].x;//der erste punkt bleibt
punkte[0].y = A[0].y;
punkte[1].x = A[0].x+(A[1].x-A[0].x)/3;//der zweite punkt liegt auf 1/3 der strecke S
punkte[1].y = A[0].y+(A[1].y-A[0].y)/3;
punkte[2].x = A[0].x+(A[1].x-A[0].x)/2+(A[0].y-A[1].y)*p/3*sin(M_PI/3);//der dritte punkt liegt auf der haelfte der strecke S und ist um die laenge von h nach oben
punkte[2].y = A[0].y+(A[1].y-A[0].y)/2+(A[1].x-A[0].x)*p/3*sin(M_PI/3);//verschoben
punkte[3].x = A[0].x+(A[1].x-A[0].x)*2/3;//der vierte punkt liegt auf 2/3 der strecke S
punkte[3].y = A[0].y+(A[1].y-A[0].y)*2/3;
punkte[4].x = A[1].x;//der fuenfte punkt ist der vorherige zweite punkt
punkte[4].y = A[1].y;
rek=rek-1;//die rekursionstiefewird um 1 erniedrigt, damit sich flocke nur bis zu einem bestimmten grad wieder neu ausführt
if(rek>0)//wenn die rekursionstiefe immernoch groesser als 1 ist fuehrt sich flocke erneut aus ansonsten endet die rekursion hier
{
for(int i=0; i<4; i++)//die funktion flocke soll sich nun auf die 4 neu entstandenen strecken ausführen
{
A[0].x = punkte[i].x;//der erste punkt A[0] soll nun der erste neu berechnete punkt sein
A[0].y = punkte[i].y;
A[1].x = punkte[i+1].x;//der zweite punkt soll der zweite neu berechnete punkt sein
A[1].y = punkte[i+1].y;
flocke(A, rek, p, anz);
}
}
else//wenn die rekursionstiefe 0 ist werden die koordinaten der neu berechneten punkte ausgegeben
{
for(int i = 1; i < 5; i++)
{
out << punkte[i].x << "\t" << punkte[i].y << endl;
}
}
delete[] punkte;//der benutzte speicher wird gelöscht
}
}
naja wer sich mal ne flocke erstellen möchte...nur zu
