Hilfe! Performance-Problem!

Pius Hermit

Pius Hermit

Erfahrenes Mitglied
Liebe Leser/innen,
ich möchte folgende Schleifen implementieren:
Schleife 1{x: 0 bis n
Berechnung: Wurzel(r*r - Betrag(x-r)*Betrag(x-r))
Schleife 2{y: ...
r*arccos(1-x/r)
...nun wirds ganz langsam: RGBset(x,y, RGBget(f(x),f(y)))
}
}
Nun meine Frage: Hat jemand eine Ahnung, ob es irgendwo Abhandlungen über schnelle Mathematische Techniken (z.B. x = r * ... oder x = ...; x*= r)
gibt?
Und wichtiger: Ich habe "eigentlich", d.h. es wäre nur mit großem Aufwand umzuimplementieren, der gerechtfertigt sein müßte, 2 BufferedImage´s, von derem 1. ich
Pixel auslesen, und in deren 2. ich Pixel schreibe. Für Vorschläge wäre ich unheimlich dankbar
Gruß,
Ulrich
 
Sorry, ich bin´s nocheinmal: Ich habe keine Angst vor Assembler: Also wenn Ihr vielleicht einen Vorschlag zu Tricksereien oder CoProzessor_Programmierung... habt: Vielleicht gibt es da ja auch Plattformübergreifende Standards...
Danke,
Ulrich
 
Hallo nochmal,
die Performance der mathematischen Funktionen scheint relativ (!) OK zu sein, da gerade die set/get RGB-Methoden 95% der Rechenzeit ausmachen :(
Umwandlung des BuffImg in einen Array, Bearbeiten, Zurückwandeln war noch langsamer...Kennt sich jemand mit DirektX aus? Könnte man damit etwas beschleunigen?
 
Java ist Platformunabhängig, DirectX ist es nicht. Deshalb unterstützt Java von Haus aus OpenGL nicht(Vieleicht gibt es extra Bibliotheken vür DX).

Formuliere doch bitte erstmal klar eine Frage.
 
Zuletzt bearbeitet:
Assembler? Moment mal, ganz langsam ;-)

Poste mal Deinen Code! Wie funktioniert beispielsweise RGBget bzw. RGBset?
 
Hier nun der Quellcode:
Code: 
	public void erzeugeKugel() {
		long t1 = System.currentTimeMillis();
		int bogen = Math.min(
				(int) (i.getWidth()/2), i.getHeight());
		int radius = (int)(bogen/Math.PI);
		int durchmesser = 2*radius;
		j = new BufferedImage(durchmesser, durchmesser, 
				BufferedImage.TYPE_INT_RGB);
//		int w = i.getWidth();
//		int h = i.getHeight();
//		int[] db1 = new int[w*h];
//		int[] db2 = new int[w*h];
////		i.getRGB(0, 0, durchmesser, durchmesser, db1, 0, w); 
		long t2 = System.currentTimeMillis();
		int x1, y1, x2, y2, n = 0;
		for (int x = 0; x < durchmesser; x++) 
			for (int y = 0;	y < f1(x, radius); y++){
				j.setRGB(x, f2(x, y, radius), 
						i.getRGB(g(x,radius), 
								g(f2(x, y, radius),radius)));
//					x1 = g(x, radius);
//					y1 = g(f2(x, y, radius), radius);
//					x2 = x;
//					y2 = f2(x, y, radius);
//					if (y < f1(x,radius)){
////						System.out.println(i.getHeight()+" , "+i.getWidth()+" , "+i.getData().getDataBuffer().getSize());
//					n = db1[x1*(durchmesser)+y1];}
//					else n =0;
//					db2[x2*(durchmesser)+y2] = n;
				}
//		j.setRGB(0, 0, durchmesser, durchmesser, db2, 0, durchmesser);
		long t3 = System.currentTimeMillis();
		System.out.println("t1: "+(t2-t1)+" ,t2: "+(t3-t2));
	}
(Hoffe das klappt mit den Code-TAGS!)

Ich habe gehört, dass es möglich ist, die Plattformunanhängigkeitseigenschaft auch durch
dll´s zu erreichen. Aus diesem Grunde überlegte ich, für die 3 Großen Plattformen
Apple, Unix und MS jeweils Unterprogramme für schnelle Grafik zu schreiben. Dabei dachte ich an C++ (was ich noch nicht beherrsche, leider nur C) oder Assembler.
Das Problem sind ja die RGB-Methode, welche ich nicht schneller hinbekomme. S.o. habe ich zwischenzeitlich mit int[] experimentiert: Selbst, wenn es laufen würde, wäre es zu langsam. Aber danke schon einmal für die bisherigen Antworten,
Gruß,
Ulrich
 
>Ich habe gehört, dass es möglich ist, die Plattformunanhängigkeitseigenschaft auch durch
dll´s zu erreichen

Ich habe nicht dergleichen je gehört. Vieleicht irre ich mich ja, aber dll sind wieder Windows Sachen, also glaub ich kaum, dass diese zur Platformunabhängigkeit beitragen (möglich dass du da was mit J#- .net Framework und dem richtigen Java durcheinander bringst)
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück