2D-Grafik Fehler beim Farbe auslesen

[kunstwurst]

Hallo, ich arbeite gerade mit schwarz-weiss Interferenz-Bildern und ein teil der Auswertung beinhaltet die suche nach dem "Massenmittelpunkt" (Mittelpunkt vom großem hellem Fleck auf dem Bild)
Es funktioniert auch gut, allerdings nur solange ich nicht zu viele Grautöne habe, denn sonst findet es den gesuchten punkt oft im negativen bereich. An einem Konkretem Beispiel:

http://i55.tinypic.com/2555so3.jpg <= läuft, Mitte ist irgendwo bei 320/260
http://i53.tinypic.com/2hz1zya.jpg <= auch in der Gegend
http://i56.tinypic.com/2r55jep.png <= irgendwo am Rand bei 80/0 (dies ist übrigens die differenz der obigen beiden Bildern)

Ich hab absolut keine Ahnung mehr woran das liegen könnte vielleicht verhalten sich die RGB werte bei .bmp's mit 24 bit farbtiefe anders als bei 8 bit-.bmp's oder andere Sachen die einem nicht eingeweihtem nicht sofort auffallen

Ach ja und hier der Code. Übersichtlichkeitshalber wurde auf Effizienz verzichtet, aber ob das jetzt eine halbe oder eine ganze sekunde pro bild braucht ist mir im moment egal

// rechnet die differenz von zwei bildern und bestimmt den mittelpunkt, input: bild hintergrund
import java.io.*;
import java.awt.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.lang.Math;
import java.text.*;


public class differenz
{

public static void main(String args[]) throws IOException{
BufferedImage mypic= ImageIO.read(new File(args[0]));
BufferedImage zeropic= ImageIO.read(new File(args[1]));
int Xmid=0;
int Ymid=0;
int sum=0;
int[][] mydata= new int[640][480];
int[][] zerodata= new int[640][480];
int[][] diff= new int[640][480];


for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	int clr=mypic.getRGB(i,j); 
	int  blu  =  clr &  0xff;
	mydata[i][j]=blu;	
	}
}//bild1 zu array

for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	int clr=zeropic.getRGB(i,j); 
	int  blu  =  clr &  0xff; //grau=blau
	zerodata[i][j]=blu;	
	}
}//bild2 zu array

for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	diff[i][j]=mydata[i][j]-zerodata[i][j];
	}
}//differenz

int min=diff[0][0];
for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	if(diff[i][j]<min)min=diff[i][j]  ;
	}
}//minimum suchen
System.out.println(min); //das ist der richtige wert

for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	diff[i][j]-=min;
	}
}//dunkelstheit auf null setzen

for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	sum+=diff[i][j]; //gesamtsumme der grauwerte
	Xmid+=(i+1)*diff[i][j]; //gewichtete x-position
	Ymid+=(j+1)*diff[i][j];	//gewichtete y-pos.
	}
}
Xmid=Xmid/sum-1; Ymid=Ymid/sum-1; //ergebniss...manchmal völlig daneben
//Mitte suchen
System.out.println(Xmid+" "+Ymid); 
System.out.println(sum); //dieser Wert stimmt auch

}
}

 

[Marco13]

Woh... schwer nachzuvollziehen, was da überhaupt abläuft... aber ein kleiner Punkt
Xmid=Xmid/sum-1
sollte das nicht
Xmid=Xmid/(sum-1)
sein, und ist dir klar, dass bei sowas wie 99/100 der Wert 0 rauskommt?

 

[kunstwurst]

1) das "-1" ist eigentlich nicht nötig, ich hab nur vergessen das rauszumachen, das war nur eine indexverschiebung damit ich die erste zeile/spalte nicht mit 0 gewichte, läuft aber auf das gleiche heraus.

2) hast recht auch mit kommentaren ist es vielleicht doch zu viel zum durchschauen, hier hab ich das mal reduziert auf den teil der nicht funktioniert

import java.io.*;
import java.awt.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;

public class test
{
public static void main(String args[]) throws IOException{
BufferedImage mypic= ImageIO.read(new File(args[0]));
int sum=0;
int Xmid=0;
int Ymid=0;

for(int i=0; i<640; i++){
	for(int j=0; j<480; j++){
	int clr=mypic.getRGB(i,j); 
	int  blu  =  clr &  0xff;
	sum+=blu;
	Xmid+=i*blu;
	Ymid+=j*blu;
	}
}

System.out.println(Xmid/sum +" " +Ymid/sum);
}
}

3) mir ist klar das bei ganzzahlendivision der wert abgerundet wird, allerdings ist Xmid etwa 300 mal größer, 0 kann also nicht rauskommen, und so kann ich mir das explizite runden sparen.

4) die lösung ist mir heute morgen eingefallen. Anfangs dachte ich, das läge am zahlenbereich aber die maximale Farbsumme ist Smax=640*480*255=78.336*10^6, was nur ein bruchteil von dem 2^31 großem int, also hab ich den gedanken verworfen. Was ich vergessen habe, ist dass die gewichteten vektoren bis zu
Ymax=Smax*480/2 und
Xmax=Smax*640/2=2.5*10^10
Sprengen den Int-Zahlenbereich. Hätte mir eigentlich sofort bei negativen werten auffallen sollen. deswegen hat es auch nur bei dunklen bildern funktioniert. Mit long statt int läüft jetzt alles prima

 

[kunstwurst]

Uhm, das kann jetzt als Erledigt markiert werden aber ich darf das wohl als gast nicht machen