4. Ich finde den Fehler nicht!Maske-Matrizen

Ich finde den Fehler nicht!Maske-Matrizen

  • K

    ^Hallo an allen,
    ich will auf einem Matrix(Cols * Rows) jedes mal einen 3*3 Bereich vom Matrix(Cols*ROws) und folgendes machen!Die entnommene Elemente von der MAtrix werden sortiert(wie spielt keine Rolle) und der mittlere Wert (nicht Mittelwert)
    genommen und wieder an der alten Steelle der Matrix(da wo es war ,nur jetzt ein anderer Wert) zufuegen.D.h seien die eingelesen Werte
    2,4,45,55,22,13,9
    Nun werde sie sortiert : 2,4,9,13,22,,45,55
    Jetzt wird an der Stelle von 55 der Wert 13 geschrieben.Der COde ist geschrieben aber ich bekomme nicht ganz das richtige Ergebnis:
    Der COde ist
    N=3 (N/2 ist wegen Randbedingungen ,nict rausgehen)
    In->Data( Eingangsmatrix)
    Out->Data( Ausgangsmatrix)
    Rows= 584
    COls=528,AR[121]
    Speicher fuer Out wuerde schon allokiert und das Ausgangsmatrix(seine Groesse)
    wurde schon gleich mit dem Einganmgsmatrix(seine Groesse) gestellt.

    //Aussere Matrix
	for(y=N/2; y<In->Rows-N/2; y++)
	  for(x=N/2; x<In->Cols-N/2; x++)
	{
        //3*3 Matrizen im Bild absuchen und Werte speichern
			z=0;
             for(i=-N/2; i<=N/2; i++)

	        	for(j=-N/2; j<=N/2; j++)

			{
			AR[z]=*(In->Data+x+i+(long)(y+j)*In->Cols);
					z++;
			} 
                               //Sortieren(RIchtig)
				for(j=1; j<=N*N-1; j++)
			         {
					A=AR[j];
					i=j-1;
					while(i>=0 && AR[i]>A)
					{
						AR[i+1]=AR[i];
						i=i-1;
					}
					AR[i+1]=A
                                    }
                //Hier ist die Zuweisung was oben erwaehnt habe  
				*(Out->Data+x+(long)y*In->Cols)=AR[N*N]
 }

    Ich finde den Code richtig aber irgendwie bekomme ich das gewuenschte Ergebnis nicht!
    Koennte mir jemand helfen,aber bitte ausfuehrich und in C ,ob der Code nicht so optimal ist spielt keine Rolle,es geht eigentlich um Verstaendnis an erste Stelle!
    Danke

    0
  • W

    hallo kilomat
    du hat es ja mit deinen matrizen... warst du nicht auch der mit dem bildfilter falten...

    Ohne mich jetzt dein code quälen zu wollen... hast du vorher einen speicher neu allokiert wo du den krempel reinschreibst... wenn du direkt in dem array rummülst bekommst du bestimmt nicht das raus was du haben willst da eine ersetzung auf die nachbarpixel bei der nächsten berechnung konsequenzen hat...

    an sonten ist das quasi fast nochmal der gleiche brei wie schon bei dem falten der matrix mit einer 3x3 matrix was ich dir schon mal gepostet habe, nur das du anstatt aufsummieren sortieren musst...

    0
  • K

    Hallo wieder,
    was meinst du mit dem array ,ich habe doch es am anfang als int AR[121], also Speicher allokiert dafuer !
    Oder meinst du fuer Out->Data, fuer das habe ich auch
    Out->Data=(unsigned char*)calloc(In->Rows,In->Cols)

    Oder erklaere mir bitte wie du das meinst,letztes mal hast du mir wieder so zu sagen das gleich gesagt aber schreib mir bitte dieses mal was du meinst ,ich meine in meinem Code drin wenn es geht !,Ich bitte dich darum
    Danke kilomat

    0
  • W

    also dein code ist mir schon ziemlich schleierhaft...

    for(y=N/2; y<In->Rows-N/2; y++)
      for(x=N/2; x<In->Cols-N/2; x++)

    wenn du das komplette bild jeweils durchlaufen willst und immer den mittleren wert von der gerade übergepappten matrix haben willst würde ich die schleife so schreiben...

    N=3; //unter der annahme wir machen das mit 3x3 und einer ungerade quadratischen maxtrix
for(y=N/2;y<Rows-N/2;++y)
  for(x=N/2;x<Lines-N/2;++x)
   //und hier für das aktuelle pixel jeweils rundrum ausschneiden und sortieren um dann den mitteleren wert zu nehmen...

    an sonsten peil ich nicht was du genau überhaupt willst... ich dachte immer ich schreib schon wilden code aber bei deinem steig ich so ziemlich gar nicht durch was du dir wie wo denkst...

    0
  • K

    Also ich erklaere das kurz,
    ich habe das Bild als eine Struktur definiert:
    [code]
    struct Image{
    int Rows ; //x Zeilen
    int Cols ; //y Spalten
    unsigned char *Data //Zeiger auf das Bild
    };

    Dann wurde in dieser FUnktion zwei Zeiger *In(Eingangsbild) und *Out(Ausgangsbild) auf diese Struktur definiert!Wenn ich z.b einen 3*3 Matrix habe sagen wir,sequentiell geschrieben
    A,B,C
    D,E,F
    G,H,I

    und willst das Pixel F ansprchen ,dann wird es so gemacht

    (In->Data +x +(yIn->Cols))
    In->Data zeigt immer am Anfang also A

    wobei x:Zeilenindex y:Spaltenindex.
    Zurueck an deiner Anfrage was du geschrieben hast ist es bei mir genauso nur das ich den Zeiger benutze,und da ich ich ihn in der Funktion aufrufe /definiere ist es In->Data!

    Du hast danach geschrieben
    N=3; //unter der annahme wir machen das mit 3x3 und einer ungerade quadratischen maxtrix
    for(y=N/2;y<Rows-N/2;++y)
    for(x=N/2;x<Lines-N/2;++x)
    //und hier für das aktuelle pixel jeweils rundrum ausschneiden und sortieren um dann den mitteleren wert zu
    ==>Tue ich das nicht mit dem Array ?Oder sollte es anders aussehen?

    Ich meine dann speichere die einzelne gelesene 3*3 Werte in dem Array und sortiere ich sie!ICh bekomme zwar ein Ergebnis aber der in kleine regemaessige Abstaende ,ich meine das Bild kleine schwarze Luecke - - - - -
    - - - -

    Ich danke fuer dein Geduld und Hilfe
    kilomat

    0
  • W

    ok also ich erklär mal ausführlicher wie ich das meine...

    nehmen wir an du hast ein 1d-array in dem zeilenweise dein bild drin steht...
    so und jetzt willst du da quasi ein schablone drüberlaufen lassen aus der du jeweils immer den median herausholst und als wert in dein neues bild einträgst..

    so deshalb lassen wir jetzt für jedes Pixel (vom rand abgesehen.. da kann man sich ja was überlegen wie man den handhaben will oder ob man den weglässt...) die fensterfunktion rüberlaufen und suchen nach dem median

    //speicher für das bild allokieren was rauskommen soll...

for(y=N/2;y<In->Rows-N/2;++y)  //für jede zeile des bildes
  for(x=N/2;x<In->Lines-N/2;++x) //für jedes Pixel einer zeile des bildes
    //und hier ist folgendes zu implementieren...
    //1)in einer schleife (bzw 2 schleifen) die werte rund um das aktuelle pixel ausschneiden und in ein array kopieren (bei ner 3x3 matrix müsstest du also nur ein 9 felder grosses array bereithalten)
    //werte sortieren und den wert an stelle N/2 ins Out-array eintragen... 
    //fertig...
    0
  • K

    Diese Anweisung macht es aber was du meinst oder micht?

    for(i=-N/2; i<=N/2; i++)

                for(j=-N/2; j<=N/2; j++)

            {
            AR[z]=*(In->Data+x+i+(long)(y+j)*In->Cols);
                    z++;
            }

    Sei N=3 ==> N/2=1
    Ich meine ich habe ein paar Werte reingesetzt und es ist richtig,
    der geht von o bis der 6-Pixel und bei der erste Iteration von j, der AR[0]=Spricht Pixel (0,0) ,AR[1]=Pixel(0,1),..... AR[6]=Pixel[0,6)
    und bei der zweiten Iteration verschiebt sich das ganze um eine Spalte nach Rechts und gehts von Anfang an!Aber jedes mal werden die verschiedene Pixel gespeichert(AR[z])!Aber jetzt faellt mir was ein, ich habe das Array als
    AR[121],also 121 Werte allokiert das ist ja wohl eigentlich sehr wenig oder? Es muesste doch In->Rows*In->Cols sein oder?Was meinst du?Wenn es so ist (Rows*Cols) warum stuerzt da Programm nicht ab ,oder es ist das was du gemeint hast das es es geht bis 121 und dann werden die Werte ueberschrieben!Nein es ist doch rictig oder,ich meine es ist 7*7 (N=7) =49 Werte die gespeichert erden muessen ?Kilomat

    0
  • W

    oh man ich versteh immer nur die hälfte von dem was du redest...

    also nochmal zu der datenstruktur...
    du brauchst zum einen dein bild was einen speicherbreich von rowlines zur verfügung hat...
    dann brauchst du nochmal so einen grossen speicherbereich row    lines in dem du das neu bild reinschreibst... du kannst nicht direkt ins alte bild schreiben sonst kommt murx bei raus, weil sonst werte überschrieben werden die noch nicht überschrieben werden dürfen...

    so und in abhänigkeit von N (also der grösse der fensterung) brauchst du noch ein array der grösse N*N...
    das ist alles...

    warum an welcher stelle bei dir da irgendwas nicht funzt? *kopfkratz* das musst du doch besser wissen als ich...
    aber vom prinzip her ist das so wie du das mit den beiden inneren schleifen gepostet hast (ist halt genauso wie ich schon sagte das gleiche nochmal in grün wie schon beim letzten mal)

    0
Anmelden zum Antworten