variable Matrix über Array legen

Hallo,

ich habe ein Problem und hoffe jemand, dass mir jemand helfen kann. Und Zwar habe ich ein zweidimensionales Array mit bekannter Anzahl an Zeilen und Spalten.

Nun möchte ich über dieses Array eine Matrix legen (zum Beispiel: eine 3x3 oder 5x5 oder 7x7 Matrix). Die Matrix soll anschließend über das ganze Array gehen und jeweils aus den in der Matrix eingeschlossenen Werte den Durchschnitt bilden.

Im Anhang ist ein Bild, da ist das ganze eventuell noch mal deutlicher.

Habe das ganze mal wie folgt versucht aber es funktioniert nicht wirklich.
Es wird nur eine Zeile oder Spalte gemacht.
Falls jemand noch eine Information zur Größe braucht iheight ist 420, iwidth ist 336

public void glaze(byte[] imageContent, int imaxValue, int iheight, int iwidth, int Kernel, String format)		// Kernel soll bei eine 3x3 Matrix zum beispiel 3 sein
		{
			byte[,] zweiArray = zweidimArray(imageContent, iheight, iwidth);		//iheight und iwidth ist Höhe und Breite

			int average = 0;
			byte[] imageContentGlaze;
			imageContentGlaze = new byte[imageContent.Length];
			int Maske = Kernel * Kernel;
			int k = 0;
			int index = 0;
			int l = 0;

			for (int l = 0; l < iwidth; l++)			
			{
				l++;
				average = average + zweiArray[k, l];

				if (l == (Kernel - 1))
				{
					k++;
					l = l - (Kernel);
				}

				if (k == (Kernel + index))	
				{
					k = k - (Kernel - 1);		
					l = 0;
					l = l - 1;

					average = average / Maske;
					imageContentGlaze[index] = System.Convert.ToByte(average);
					index++;
					average = 0;
					
				}

			}
		}

Oder weiß jemand vielleicht einen viel besseren (leichtern) Ansatz?

Gruß Marc

Ohne jetzt deinen ganzen Ansatz komplett nachvollzogen zu haben, scheinen mir da doch einige Ungereimtheiten drin zu sein.

Zum einen benutzt du eine lokale Variable l sowie l als Index für die for-schleife. Abgesehen davon das sich der Code so nicht kompilieren lässt, ist so auch nicht ganz nachzuvollziehen welches l wann genutzt werden soll.

Soll die Matrix über das gesamte 2-dimensionale Array laufen, sind wohl auch zwei verschachtelte for-schleifen angebracht, im Moment durchläufst Du ja nur einmal die Breite deines Arrays (wobei Du dann auch noch in jedem Schritt nur einen Wert deiner Matrix hinzurechnest).

Falls ich dich nicht ganz missverstanden habe, möchtest Du z.B. eine 3x3 Matrix von oben links über alle Spalten/Zeilen wandern lassen und jeweils den Mittelwert der 9 Werte berechnen.

Das könnte dann so in diese Richtung aussehen.

// zweidimensionales Array durchlaufen
for (int y=0; y<hoehe-matrixHoehe; ++y) {
  for (int x=0; x<breite-matrixBreite; ++x) {
    // Die Matrix an sich durchlaufen
    for (int ym=0; ym<matrixHoehe; ++ym) {
      for (int xm=0; xm<matrixBreite; ++xm) {
          // Wert aus dem Array
          zweiDim[x+xm, y+ym]
       }
      }
    }
  }
}

So würdest Du zumindest schon mal das gesamte Array durchlaufen und die Werte "über denen deine Matrix momentan liegt" bekommen.

warum umständlich, wenns einfach geht?

T[] ExtractArray<T>(T[,] array,xstart,ystart,width,height)
{
T[,] result=new T[width,height]
for(int y=0;y<height;y++)
for(int x=0;x<width;x++)
{
result[x,y]=array[x+xstart,y+ystart];
}
return result;
}

Hallo MarC611,

siehe auch LowLevelGraphicsLibrary: Neighbouring Modell

herbivore

Hallo,

erst einmal danke für Eure bisherige Hilfe.

Ich habe die Version von Kileak ausprobiert und das ganze sieht jetzt so aus:

int index = 0;
			int index1 = 0;
			int anzahlFelder = Kernel * Kernel;
			int average = 0;


			//zweidimensionales Array durchlaufen
			for (int y = 0; y <= iheight - Kernel; ++y)
			{
				for (int x = 0; x <= iwidth - Kernel; ++x)
				{
					// Die Matrix an sich durchlaufen
					for (int ym = 0; ym < Kernel; ++ym)
					{
						for (int xm = 0; xm < Kernel; ++xm)
						{
							// Wert aus dem Array
							//byte test = zweiArray[x + xm, y + ym];
							byte test = zweiArray[y + ym, x + xm];

							average = average + System.Convert.ToInt16(test);

							index1++;

							if (index1 == anzahlFelder)
							{
								average = average / anzahlFelder;

								ausgabeArray[index] = System.Convert.ToByte(average);
								index1 = 0;
								average = 0;
								index++;
							}
						}
					}
				}
			}

Das Problem ist allerdings, dass ich so noch nicht alle Werte bekomme da die Randwerte fehlen.
Das heißt die die Matrix muss also zum Beispiel weiter nach rechts (über den Rand laufen) um alle Werte zu bekommen.
Das heißt ich habe in meinem Ausgabe Array weniger Werte als in meinem ursrünglichen zweidimensionalem Array.

Das gleiche gilt auch für die Höhe.

Ich habe paar Möglichkeiten ausprobiert jedoch bisher noch ohne Erfolg.

Hat jemand einen Vorschlag oder ne Idee wie ich das lösen könnte?

Hallo MarC611,

tue so, als wäre das Ausgangs Array an den Kanten und Ecken gespiegelt. Dann kannst du auch an den Kanten und Ecken genauso viele Werte zusammenrechnen, wie im inneren.

herbivore