hi Leute,
ich habe einen C++/C-Code geschrieben und ist unübersichtlich, deshal möchte es umschreiben! hat da jemand lust mir zu helfen? ich werde sehr sehr dankbar!
(der obere Teil mit den vielen schleifen möchte ich umschreiben! das Ziel ist in einem Raster, desen Felder mit 0 und (-)Zahlen belegt ist(die neg. Werte stammen aus z-Koordinate von Punkten in 3D raum), durch eine Schablone bestimmte Punktwolken zu filtern und der Feld mit dem höhsten (-)wert in eine Liste maske[] speichert! )
hier ist die Code:
void findeschwerpunkt(vtkPolyData * polydata, int dateinummer)
{
float grenzen[6];
int xdim,ydim, xdimmitte, ydimmitte;
int xidx, yidx;
int arr_x, arr_y;
vektor *kugelmitte;
float mittelpunkt[kugelanzahl][3]; // Anzahlkugeln..hier 4
kugelmitte = new vektor [kugelanzahl]; //neu
vektor mitte1, mitte2, mitte3, mitte4;
// geometrische Grenzen in x und y Richtung auslesen
polydata->GetBounds(grenzen); //(xmin,xmax, ymin,ymax, zmin,zmax).
xmin = grenzen[0] - 20;
xmax = grenzen[1] + 20;
ymin = grenzen[2] - 20;
ymax = grenzen[3] + 20;
// Akkumulator mit Raster 1mm für x-y Ebene einrichten
xdim = xmax - xmin;
ydim = ymax - ymin;
xdimmitte = xdim * 0.5;
ydimmitte = ydim * 0.5;
//dynamische Speicherallokation
float **ppAkkum = new float*[xdim];
for ( int i = 0; i
//Akkumulator auf 0 initialisieren
for (int y_index = 0; y_index {
for (int x_index = 0; x_index {
ppAkkum[x_index][y_index]= 0.0;
}
}
punktanzahl = polydata->GetNumberOfPoints();
//Punktkoordinate lesen
for (int n = 0; n {
polydata->GetPoint(n, koords);
xkoord = koords[0]; ykoord = koords[1]; zkoord = koords[2];
arr_x = round(xkoord) - xmin; //Koordinate der Kreispunkte dem Array anpassen
arr_y = round(ykoord) - ymin;
ppAkkum[arr_x][arr_y] = zkoord ; //Schreibt in jeden Feld der Z-Wert hinein
}
int zaehler = 0;
int y_maskemax;
int x_maskemax;
vektor maske[20]; // erzeugt Maske-Liste, die die Schwerpunkte diesen Punktwolken beinhaltet,
// die man als Kandidat für Kugelmarker gilten
// der Raster wird Zeile zu Zeile Spalte zu Spalte untersucht
for (yidx= 0; yidx {
for (xidx = 0; xidx {
int sum =0;
float maske_max_z = -100000000.0;
// mit einer (zeilenanzahl x spaltenanzahl) -Maske die Akkumulator durch gehen!
// z.B. 13x13
for (int yf = yidx; yf {
for (int xf = xidx; xf {
// bei den Feldern die einem (-) Wert haben wird weiter untersucht
// und den gespeicherten max. z-Wert ermittelt
if (ppAkkum[xf][yf] {
// Anzahl der Felde wird erhöht, die einen Wert von sum = sum + 1;
// der aktuellen max z-WErt wird ermittelt
if (ppAkkum[xf][yf] > maske_max_z)
{
// die max. z-Wert und die x- und y-Koordinate werden auch gemerkt
maske_max_z = ppAkkum[xf][yf];
x_maskemax = xf;
y_maskemax = yf;
}
}
}
}
int punktzaehler =0;
// hat man in dem aktuellen Maske einen Punkt gefunden so wird die Maske weiter untersucht
if (sum != 0)
{
for (int yf = yidx; yf {
for (int xf = xidx; xf {
// alle Felder der aktuellen Maske wird überprüft!
// wenn im Randfeldern der Meske einen Wert von 0 gespeichert ist oder
// z-Werte gespeichert sind die sich von den z-Wertern unterscheiden, die
// in innen der Maske sich befinden, dann werden die Punkte diese Maske gezählt
if ((ppAkkum[xf][yidx] == 0 || abs(ppAkkum[xf][yidx] - maske_max_z) > 10 ) &&
(ppAkkum[xidx][yf] == 0 || abs(ppAkkum[xidx][yf] - maske_max_z) > 10) &&
(ppAkkum[xidx + zeilenanzahl-1][yf] == 0 || abs(ppAkkum[xidx + zeilenanzahl-1][yf] - maske_max_z) > 10) &&
(ppAkkum[xf][yidx + spaltenanzahl-1] == 0 || abs(ppAkkum[xf][yidx + spaltenanzahl-1] - maske_max_z) > 10) )
{
punktzaehler = punktzaehler+1;
}
}
}
}
// ist in der aktuellen Maske alle Bedingungen erfühlt ...
if (sum != 0 && punktzaehler == (zeilenanzahl * spaltenanzahl))
{
// ..werden alle Felder nochmal durch gegangen..
for (int yf = yidx; yf {
for (int xf = xidx; xf {
if ((ppAkkum[xf][yidx] == 0 || abs(ppAkkum[xf][yidx] - maske_max_z) > 10 ) &&
(ppAkkum[xidx][yf] == 0 || abs(ppAkkum[xidx][yf] - maske_max_z) > 10) &&
(ppAkkum[xidx + zeilenanzahl-1][yf] == 0 || abs(ppAkkum[xidx + zeilenanzahl-1][yf] - maske_max_z) > 10) &&
(ppAkkum[xf][yidx + spaltenanzahl-1] == 0 || abs(ppAkkum[xf][yidx + spaltenanzahl-1] - maske_max_z) > 10) )
{
if (ppAkkum[xf][yf] != 0)
{
// ist der Aktuelle Feld, der mit dem max z-Wert,
if ((xf == x_maskemax) && (yf == y_maskemax))
{
// so wird in die Maske-Liste die Informationen aus diesem Feld
// gespeichert, und damit hat man den Schwerpunkt der Maske gefunden
maske[zaehler].x = xf;
maske[zaehler].y = yf;
maske[zaehler].z = ppAkkum[xf][yf];
maske[zaehler].summe= sum;
zaehler= zaehler +1;
}
}
}
}
}
}
// schliesslich werden die Punkte auf 0 gesetzt, damit sie nicht nochmal gefunden werden!
if (sum != 0 && punktzaehler == (zeilenanzahl * spaltenanzahl))
{
for (int yf = yidx; yf {
for (int xf = xidx; xf {
if ((ppAkkum[xf][yidx] == 0 || abs(ppAkkum[xf][yidx] - maske_max_z) > 10 ) &&
(ppAkkum[xidx][yf] == 0 || abs(ppAkkum[xidx][yf] - maske_max_z) > 10) &&
(ppAkkum[xidx + zeilenanzahl-1][yf] == 0 || abs(ppAkkum[xidx + zeilenanzahl-1][yf] - maske_max_z) > 10) &&
(ppAkkum[xf][yidx + spaltenanzahl-1] == 0 || abs(ppAkkum[xf][yidx + spaltenanzahl-1] - maske_max_z) > 10) )
{
if (ppAkkum[xf][yf] != 0)
{
ppAkkum[xf][yf] = 0;
}
}
}
}
}
}
}
// noch einer Filter, für die Punktmengen, die in der nähe von den Markern stehen und viele Punkte haben
// aber keiner Marker sind
for( i = 0; i { // an Hand der x- und y-koordinate wird festgestellt, ob der Punkt in der nähe einem Marker ist
for( int l = 0; l {
if ( ( abs(maske[l].x - maske[l + 1].x) {
//und an Hand der z-wert wird entschieden welcher Punkt zu einem Marker gehört
//der mit dem kleinern z-Wert wird zum ignorieren markiert (auf 0 gesetzt damit die Bubblesort-Fkt. ihn ignoriert )
if ( maske[l].z else maske[l+1].summe = 0;
}
}
}
// die Schwerpunkte-Liste muss sortiert werden
Bubblesort(maske,zaehler);
// die Kugelschwerpunkte(SP) sind gefunden und werden die ersten (kugelanzahl = 4)bearbeitet
for ( int j=0; j {
//Schritt 1: für SP wird die Koordinaten auf der Oberfläche gefunden
findeSPid(polydata, maske[j].x , maske[j].y);
//Schritt 2: von dem Oberflächenpunkt aus gehen wir in Richtung Kugelmitte r tief..und berechnen MP
findeMPdurchOberflpkt(polydata, mittelpunkt[j]);
//Schritt 3: Schließlich aus dem Punkt wird mit SphereFit den richtigen MP gefunden..
findekugelmittelpunkt(mittelpunkt[j],kugelmitte[j]);
}
vektor kugel_neu[kugelanzahl];
// Bestimmung von x-, y-Min und -Max
double maxkx = -1000000.0; double maxky = -1000000.0;
double minikx = 1000000.0; double miniky = 1000000.0;
for ( int m=0; m {
if(kugelmitte[m].x > maxkx) maxkx = kugelmitte[m].x;
if(kugelmitte[m].y > maxky) maxky = kugelmitte[m].y;
if(kugelmitte[m].y if(kugelmitte[m].x }
// Mitte des Abstandes zw. Min und Max
double mitte2kugel_x;
double mitte2kugel_y;
mitte2kugel_x = minikx + (maxkx - minikx) * 0.5;
mitte2kugel_y = miniky + (maxky - miniky) * 0.5;
// Geometrische Einordnung der Kugeln! Teilung in 4 Quartalen
for ( i=0; i {
//unten links
if( (kugelmitte[i].x //oben links
if( (kugelmitte[i].x mitte2kugel_y)) kugel_neu[1] = kugelmitte[i];
//oben rechts
if( (kugelmitte[i].x > mitte2kugel_x) && (kugelmitte[i].y > mitte2kugel_y)) kugel_neu[2] = kugelmitte[i];
//unten rechts
if( (kugelmitte[i].x > mitte2kugel_x) && (kugelmitte[i].y
}
// die gefundenen Mittelpunkten werden in 2 Listen gespeichert: 1. Liste beinhaltet die Punkte die
// bei der Transformation verschoben werden
// 2. Liste beinhaltet die Punkte, zu ihnen die Punkte aus der ersten Liste verschoben werden
int start,ziel;
switch (dateinummer)
{
case 1:
marker_ids1->Initialize();
anzahlMarkerpunkte= 0;
for ( start = 0; start {
// in eine Liste werden die Mittelpunkt der Marker gespeichert, damit sie als Transformations
// Parameter benutzt zu werden. die hier erzeugten Liste beinhaltet die Punkte, die
// verschoben werden.
startpunkte->InsertPoint(start, kugel_neu[start].x, kugel_neu[start].y, kugel_neu[start].z );
// die Kugeln müssen entfernt werden, deshalb brauche ich die Id ihrer Punkte
findemarkerPunkte(kugel_neu[start], marker_ids1);
}
break;
case 2:
marker_ids2->Initialize();
anzahlMarkerpunkte= 0;
for ( ziel = 0; ziel {
// wird eine Liste erzeugt mit den Markermittelpunkte, die in ihrem Position bleiben und
// bei der Transformatio nicht verschoben werden
zielpunkte->InsertPoint(ziel, kugel_neu[ziel].x, kugel_neu[ziel].y, kugel_neu[ziel].z );
// analos wie beim ersten Scan werden die Markerpunkte gefunden
findemarkerPunkte(kugel_neu[ziel], marker_ids2);
}
break;
}
delete[] ppAkkum;
return;
} // ende findeschwerpunkt
