8 Nachbarpixel prüfen

[Münchner]

Hallo Leute,

ich steck fest.

Ich hab eine 3x3 Matrix und möchte vom mittleren Punkt aus die Differenzen zu allen umliegenden Punkten berechnen.
Jetzt könnt ich natürlich vom Mittelpunkt aus zu jedem anderen Punkt die Differenz bilden.
Geht das irgendwie relativ, also Mittelpunkt - Werte an der Stelle {-1,-1},{1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1}.
Kann mir jemand nen Tipp geben wie man sowas umsetzt.
Grüße
Münchner

public class DACHTTEST2 {
	public static void main (String args[]){
	int macht[][] = new int[3][3];
	macht[0][0]=1;
	macht[0][1]=2;
	macht[0][2]=3;		// Zeile 0
	macht[1][0]=4;
	macht[1][1]=5;
	macht[1][2]=6;		// Zeile 1
	macht[2][0]=7;
	macht[2][1]=8;
	macht[2][2]=9;		// Zeile 2
	
	    
	

	
	for(int i = 0; i< macht.length; i++ )
	{	
		for (int j = 0; j < macht[i].length; j++)
		{
			int pixel = macht[i][j];
			System.out.println(pixel);
		}

		
	}
	
	int erg = macht[1][1]- macht[0][1];
	System.out.println(erg );
	
	
	}
	
}

 

[Volvagia]

Bei einer 3x3 Matrix ist die Differenz zum Mittelpunkt doch immer 1, außer beim Mp natürlich. ???:L

 

[Münchner]

Ne die Pixeldifferenz mein ich ned. Jedes Pixel hat einen Pixel value, so wie in nem Grauwertbild beispielsweise. Und ich möchte jetzt beispielsweise die geringste Grauwertdifferenz rausfinden, indem ich die benachbarten Pixel nach ihren Werten abfrag.

 

[Volvagia]

So?

private static final Point[] NEIGHTBORS = new Point[] {
	new Point(-1, -1),
	new Point(-1, 0),
	new Point(-1, 1),
	
	new Point(0, -1),
	new Point(0, 1),
	
	new Point(1, -1),
	new Point(1, 0),
	new Point(1, 1),
};

private static int[][] macht;

public static void main(String[] args)
{
	defineMacht();
	
	int highesDiv = checkPxDifference(1, 1);
	System.out.println(highesDiv);
}
private static void defineMacht()
{
    macht = new int[3][3];
    macht[0][0]=1;
    macht[0][1]=2;
    macht[0][2]=3;
    
    macht[1][0]=4;
    macht[1][1]=5;
    macht[1][2]=6;
    
    macht[2][0]=7;
    macht[2][1]=8;
    macht[2][2]=9;		
}
private static int checkPxDifference(int x, int y)
{
	int maxDif = 0;
	int myValue = macht[x][y];
	
	for(Point p:NEIGHTBORS)
	{
		int pxX = x + p.x;
		int pxY = y + p.y;
		
		try
		{
			int pxValue = macht[pxX][pxY];
			int dif = Math.abs(myValue - pxValue);
			maxDif = Math.max(maxDif, dif);
		}
		catch (ArrayIndexOutOfBoundsException e) {}
	}
	return(maxDif);
}

 

[faetzminator]

Irgendwie so was?
Guckt einfach nach der geringsten Differenz und speichert diese.

int macht[][] = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

int diff = Integer.MAX_VALUE;
for (int i = 0; i < macht.length; i++) {
    for (int j = 0; j < macht[i].length; j++) {
        if (i != 1 || j != 1) {
            int result = Math.abs(macht[1][1] - macht[i][j]);
            if (result < diff) {
                diff = result;
            }
        }
    }
}

System.out.println(diff);

 

[Marco13]

...		
		try
		{
			int pxValue = macht[pxX][pxY];
			int dif = Math.abs(myValue - pxValue);
			maxDif = Math.max(maxDif, dif);
		}
		catch (ArrayIndexOutOfBoundsException e) {}
}

:shock: :autsch: :noe: Lieber eine "isValid(int x, int y)"-Methode schreiben....
EDIT: Wobei man die evtl. auch nicht brauchen würde, je nachdem, wie das angewendet werden soll...

 

[Volvagia]

:shock: :autsch: :noe: Lieber eine "isValid(int x, int y)"-Methode schreiben....

Zu Befehl, mein Javaral.

private static final Point[] NEIGHTBORS = new Point[] {
	new Point(-1, -1),
	new Point(-1, 0),
	new Point(-1, 1),
	
	new Point(0, -1),
	new Point(0, 1),
	
	new Point(1, -1),
	new Point(1, 0),
	new Point(1, 1),
};

private static int[][] macht;
	
public static void main(String[] args)
{
	defineMacht();
	
	int highesDiv = checkPxDifference(2, 1);
	System.out.println(highesDiv);
}
private static void defineMacht()
{
    macht = new int[3][3];
    macht[0][0]=1;
    macht[0][1]=2;
    macht[0][2]=3;
    
    macht[1][0]=4;
    macht[1][1]=5;
    macht[1][2]=6;
    
    macht[2][0]=7;
    macht[2][1]=8;
    macht[2][2]=9;		
}
private static int checkPxDifference(int myX, int myY)
{
	int maxDif = 0;
	int myValue = macht[myX][myY];
	
	for(Point p:NEIGHTBORS)
	{
		int pxX = myX + p.x;
		int pxY = myY + p.y;
		
		if(!isValid(pxX, pxY))
			continue;

		int pxValue = macht[pxX][pxY];
		
		int dif = Math.abs(myValue - pxValue);
		maxDif = Math.max(maxDif, dif);
	}
	return(maxDif);
}
private static boolean isValid(int x, int y)
{
	return(x >= 0 && y >= 0 &&
			x < macht.length && y < macht[0].length);
}

 

[Münchner]

@Volvagia: Ja genau sowas, vielen Dank für den ausführlichen Code.
@faetzminator: Dir auch vielen Dank, den werd ich auch probieren.

Ich kannte demn Typ point gar nicht, scho wieder was gelernt

 

[Marco13]

Zu Befehl, mein Javaral.

Spüre ich da einen subtile Hauch von Ironie?
Abgesehen davon war da ja noch das EDIT: Ich verstehe nicht ganz, warum du das mit den Points machst (und damit auch nicht, warum du die isValid überhaupt brauchst). Das ist vielleicht praktisch, wenn man die Umgebung für jedes Feld der 3x3-Matrix berechnen will (also z.B. auch die Umbegung von 0,0 oder 2,0) - aber es ging doch NUR(!?) um den Mittelpunkt?! Da wäre die Lösung von faetzminator wohl die nächstliegende...

 

[Münchner]

woa soll schnell bin ich ned...

 

[Volvagia]

Ne, war ganz lieb gemeint.
Ich habe mal irgendwo, ich denke es war ein Buch gelesen, dass ein Algorithmus sich nicht auf so detailierte Fragen wie z. B. "Wie finde ich die Differenz zwischen den Mittelpunkt eines Arrays und den umliegenden existierenden Feldern", sondern "Wie finde ich die größte Differenz zwischen allen Nachbarn und einen Array-Feldes heraus" stützen sollte.

Stand in etwa so drinnen: Nicht "wie sortiert man 10 Zahlen", sondern "wie sortiert man Zahlen". Ich denke, das liegt an der Wiederverwendbarkeit von Algos.

 

[Münchner]

ok, soweit so gut.

Ja das ist richtig, mit der Umsetzung von faetzminator bin ich für einen Mittelpunkt gut bedient.
Allerdings bin ich mit den Points aus der Umsetzung von Volvagia flexibler, weil es durchaus sein kann, dass ich den Mittelpunkt irgendwann verlagern will.

 

[Marco13]

@Volvagia: Klar, allgemeiner ist immer besser. (Oder? - Anderes Thema ).

Speziell hier hatte ich auch erst gedacht, dass das doch vermutlich später nicht nur auf einem 3x3-Array laufen soll, sondern vielleicht auch ein 3x3-Fenster von einem 10x10-Array - dann wäre die Lösung mit den Points auch wieder einfacher anzupassen. Aber Bei einen n x n-Fenster in einem m x n-Array würde das dann plötzlich wieder umschlagen - die Points-Lösung wäre dafür praktisch nicht anwendbar, und mit einer Schleife (d.h. 4 Schleifen) wäre es trivial. Speziell weil die Points ja auch so gleichmäßig sind (einfach von -1 bis +1 in x- und y-Richtung). Für sowas wie die Sprungmöglichkeiten eines Springers auf einem Schachbrett wäre das wieder was anderes.

 

[Crian]

[c]private static final Point[] NEIGHTBORS = new Point[] { [/c]

Das Wort heißt entweder "neighbours" (im britischen Englisch, was ich hier verwenden würde) oder "neighbors" (im amerikanischen). Aber "neightbors" ist auf jeden Fall falsch.