Meßdaten mit openGL graphisch darstellen

[jower]

Hallo,
ich habe folgendes Problem,
ich habe 3D Meßwerte, die ich auch später als Bild weiterverarbeiten will. Also Objekte segmentieren und so weiter. Die Daten lege ich im Moment in einer 2D Bildmatrix ab (class 2DVector von Microsoft), mit der dritten Dimension als wert an der Stelle x,y. Das Auslesen aus dem 2DVector feld dauert auf jeden Fall zu lange. Kann man das vielleicht beschleunigen?

Ich möchte diese Daten jetzt über OpenGL darstellen. DA meine Methode nicht schnell ist würde mich interessieren, wie Ihr 3D messwerte ablegen würdet?

ich hoffe, die Problemstellung ist nicht allzu ungenau, da ich von Graphikprogrammierung noch keine Ahnung habe.
Gruß Jower

[ChockoCookie]

jower schrieb:

...da ich von Graphikprogrammierung noch keine Ahnung habe...

In dem Fall wäre es uU besser auf ein Programm zurückzugreifen, das Messdaten graphisch darstellen kann. Spontan fällt mir da zB GnuPlot ein.

[jower]

danke,

nur ist es so, dass ich ständig neue Meßwerte erhalte und diese dann sozusagen live darstellen will.
mit OpenGL krieg ich das auch schon ganz gut hin, nur dauert das alles zu lange.
ich habe momentan eine Darstellungwiederholrate von vielleicht 1 mal / sek. . Messwerte auslesen könnte ich aber schneller.
Wie gesagt, da ich die Daten weiterverwenden will, muß ich sie in eine Struktur bringen. Das mach ich über ein 2D Vectorfeld. Das reinschreiben klappt ausreichnend flott. das Auslesen der Daten aus dem 2D Vectorfeld dauert aber so lange.
Deswegen wollte ich mal in die Runde fragen, wie man so Daten ablegen sollte, damit man sie auch schnell für die Darstellung auslesen kann.
Ich bin gerade am überlegen, ob ich nicht eine zusätzliche Struktur nur für die Darstellung mache.

Gruß Jower

[TGGC]

Was hat das Auslesen mit der Darstellung zu tun?

Bye, TGGC (Demo or Die)

[Sgt. Nukem]

Damit die unkreativen unter sich das besser vorstellen können, poste doch mal den Code, wo Du in den Vector Deine Daten reinschreibst, und wie Du sie wieder ausliest. Dann kann man 1) gucken, ob es 'ne schnellere Alternative gibt, und 2) ob Du vielleicht durch zu viele whiles und fors Zeit verplemperst.

[jower]

Okay, hier der Code, wo ich die Daten in den Vector schreibe. Wie gesagt ich verwende als 2DVectorklasse, die von MSDN. Zu finden ist hier: http://msdn.microsoft.com/library/default.asp?url=/archive/en-us/dnaraskdr/html/askgui04162002.asp
aus lauter Verzweifelung habe ich die Klasse umgeschrieben, so dass es keine Templateklasse mehr ist.

for (unsigned short i=7; i<size; i+=2, phigrad+=doc->m_gradResolution){
		val = response->MakeUnsignedShort(response->GetDataElement8(i),
					(response->GetDataElement8(i+1)&63)); // only first 0-12 bíts
		val = (unsigned short)(val*doc->m_zoom);
	        phi = phifaktor * phigrad;				
		x = (signed int)(val*cos(phi)*cos(scnlayerAngle));
		y = (signed int)(val*cos(phi)*sin(scnlayerAngle));
		z = (unsigned int)(val*abs(sin(phi)));
		doc->m_data.m_data.SetAt(y,x,z);
	}

die Messwerte darzustellen versuch ich dann hier:

int z = 0;
	unsigned short r,g,b;
	unsigned int size_x = m_data.m_data.GetX();
	unsigned int size_y = m_data.m_data.GetY();
	glBegin( GL_POINTS );
 	for ( int y = -(int)(size_y/2); y < (int)(size_y/2); y+=1) {
	    for ( int x = -(int)(size_x/2); x < (int)(size_x/2); x+=1) {	
 		z = (int)(m_data.m_data.GetAt(y,x));	
		if (!z==0){
			//ValToRGB( z, r, g, b);
			//glColor3ub( (GLubyte)r, (GLubyte)g, (GLubyte)b );
			glColor3ub( (GLubyte)z, (GLubyte)z, (GLubyte)z );
			glVertex2i( static_cast<GLint>(x), static_cast<GLint>(y));
		}
	    }
	}
	glEnd();
	glPopMatrix();

mit einem Profiler habe ich festgestellt, dass der Zugriff

z = (int)(m_data.m_data.GetAt(y,x));

knapp 5 mikroSek. braucht. das ist wohl irgendwie zu langsam.

hat einer eine Idee? ich weiß nicht woran es liegen kann, oder bin ich einfach nur zu verpeilt. gruß jower

[DEvent]

aus lauter Verzweifelung habe ich die Klasse umgeschrieben, so dass es keine Templateklasse mehr ist.

was heist "umgeschrieben" ? wieso hast du den das getan? Template-Klassen werden alle geinlined, eine Template-Klasse ist IMHO schneller als eine polymorphe. Da braucht man nämlich sowas nicht mehr zu tun:

z = (int)(m_data.m_data.GetAt(y,x));

weil die Methode dann gleich einen int zurückgibt.
Was mir einfallen würde, keine GetAt() zu verwenden sondern lieber Iteratoren. Weil Iterator bei einem Vector sind einfach Pointer und wenn man die einzelnen ELemente durchgeht, wird einfach nur die Adresse worauf der Pointer zeigt um ein sizeof(Element) addiert.
GetAt() ist sicherlich mit Sicherheitsüberprüfungen gesichert.

Was noch besser wäre, ist eine eigene Container-Klasse zu schreiben, die die Daten so im Speicher hat, das OpenGL die Daten direkt verwenden kann. Vllt. mit glVertexPointer() arbeiten oder mit VertexBuffers.
OpenGL kann ja direkt mit Zeigern auf Vertices arbeiten, so das man nicht einzelt glVertex() oder glColor() aufrufen muss.

Ein anderer Punkt um es zu beschläunigen wäre vielleicht Display-Lists.

Naja war jetzt nur auf die schnelle, hoffentlich habe ich dir paar Ideen gegeben.

[jower]

ja danke , bin gerade dabei, das mit den Iteratoren auszuprobieren. vielleicht bringt das ja was.

Die Messwerte sollen weiterverarbeitet/ausgewertet werden, weshalb ich die Containerklasse für die Messwerte nicht allzu sehr an die OpenGL anpassen will. Die Darstellung der Messwerte ist eher als so eine Art beiläufige Visualisierung zu sehen, die neben der HAuptaufgabe des Programms der Weiterverarbeitung/ Auswertung ablaufen soll.

Für die Auswertung der Messwerte wäre es sinnvoll, diese als 2D Bildformat zu haben. Ist das für die OpenGLprogrammierung sinnvoll?
Oder macht es da mehr Sinn eine Andere Datenstruktur zu nehmen?

gruß Jower