4. Index des gespiegelten Kästchen einer Matrix

Index des gespiegelten Kästchen einer Matrix

  • C

    Hi,
    wusste jemand einen Algorithmus womit ich die Indizes der gespiegelten Kästchen einer Matrix berechen kann. Zum Beispiel bei einer 3x3 Matrix: von 1,0 soll ich auf 1,2 oder 0,2 auf 2,0 und 0,0 auf 2,2 usw? 🤡. Ich will einfach den Wert von einer Kästchen auf der gespiegelten zu übertragen und dass ohne tausenden von abfragen.
    Ich habe es mit diverse formeln mit Modulo versucht klappt aber nicht für alle Kästchen. Es ist auch etwas verirrend denn die Funktion sollte sich auf keinem der Diagonalen ausrchten sondern wirklich der Gespiegelte Kübchen visieren.

    0
  • N

    Nach deinem Beispiel willst du wohl eine art Punktspiegelung mit der Matrixmitte.

    Du hast ja mit der Matrix quasi ein Koordinatensystem gegeben. Eine Punktspiegelung eines Punktes am Koordinatenursprung heißt, man dreht das Vorzeichen der X und Y-Koordinaten um, also aus P(3,4) wird P'(-3,-4).

    Eine Spiegelung an einem anderen Punkt S(xs,ys) heißt, wir verschieben erst das Koordinatensystem auf S, Spiegeln per vorzeichenumdrehen wie oben und verschieben das Koordinatensystem zurück.

    Heißt, P(xp,yp) an S(xs,ys) zu spiegeln bedeutet wir rechnen xp-xs und yp-ys (Koordinatenverschiebung sodass S bei (0,0) liegt), dann Vorzeichen umdrehen und zurück. Also P'=((xp-xs)(-1)+xs,(yp-ys)(-1)+ys).

    Bei deiner 3*3-Matrix wäre der Spiegelpunkt S=(3/2,3/2), also kannst du nicht mehr mit ints rechnen weil 3/2 keine ganze Zahl ist. Du kannst aber einfach das Koordinatensystem "aufblasen", also alle Koordinaten verdoppeln, alles mit ints spiegeln und dann wieder kollabieren lassen indem alle Koordinaten halbiert werden.

    Es ergibt sich dann als Endformel Matrix'[x][y]=Matrix[((x*2-xmax)*(-1)+xmax)/2][((y*2-ymax)*(-1)+ymax)/2].

    (xmax,ymax) ist der Spiegelpunkt im verdoppelten Koordinatensystem, wobei xmax und ymax die Dimensionen der Matrix sind.

    Du kannst dir noch zusätzlich die Matrixkopie Matrix' und die Hälfte der Berechnungen sparen indem du die Werte tauschst.

    Dann sollte sowas rauskommen:

    const int xmax = 5, ymax = 7;
int matrix[xmax][ymax];
... //fülle matrix mit Werten

void spiegelmatrix(int matrix[][], int xmax, int ymax){
    for(int x = 0; x<=(xmax+1)/2; x++){ //nur die erste hälfte muss berechnet werden,
                                   //die zweite ergibt sich wegen tausch mit der ersten automatisch
        for(int y = 0; x==xmax/2+1?ymax/2:ymax; y++){
            int t;
            matrix[x][y] = t;
            matrix[x][y] = matrix[((x*2-xmax)*(-1)+xmax)/2][((y*2-ymax)*(-1)+ymax)/2];
            matrix[((x*2-xmax)*(-1)+xmax)/2][((y*2-ymax)*(-1)+ymax)/2] = t;
        }
    }
}

spiegelmatrix(matrix, xmax, ymax);

... //gebe gespiegelte matrix aus

    Betrachte das als Pseudocode, richtiges C ist es jedenfalls nicht. Wahrscheinlich habe ich auch ein paar Vorzeichenfehler, aber das merkst du dann schon ^^

    Statt int matrix[xmax][ymax] kannst du auch xmax und ymax vom Nutzer einlesen lassen und dann per int **matrix = malloc(sizeof(int)*xmax*ymax) deine Matrix dynamisch bauen. Die Schreibweise mit den []-Klammern funktioniert dann genauso.

    Edit: Stimmt nicht was ich geschrieben habe. Die Grenzen in den for-Schleifen sind falsch. x muss von 0 bis xmax laufen, y muss an der Diagonalen von (0,ymax) bis (xmax,0) laufen, wobei man mit der Diagonalen aufpassen muss. Da muss ich nen Moment nachdenken und den hab ich grad nicht, muss los.

    Edit2: Ok jetzt aber. x muss von 0 bis (xmax+1)/2 gehen. +1 damit bei einem ungeraden xmax die Mittelspalte auch bearbeitet wird.
    y muss im Falle dass wir in der Mittelspalte sind bis ymax/2 gehen und sonst bis ymax. Der Test ob wir in der Mittelspalte sind wäre ein if(x==(xmax+1)/2) y=ymax/2; else y=ymax, aber dann hätten ungerade Matrizen Mittelspalten links der Mitte, was falsch wäre. Mit if(x==(xmax+2)/2) funktioniert es aber. Bei einer ungeraden Spaltenanzahl bleibt die Mittelspalte, bei einer geraden Spaltenanzahl ergibt sich als Mittelspalte die Spalte rechts der Mitte, die wir aber wegen x<=(xmax+1)/2 sowieso nicht bearbeiten.
    Die if-Abfrage lässt sich sehr nett mit dem ?:-Operator basteln. (xmax+2)/2 lässt sich zu xmax/2+1 vereinfachen.

    Ich denke jetzt ist es richtig genug dass du den Rest auch selbst schaffst 😉

    0
  • ?

    cevasark schrieb:

    Ich will einfach den Wert von einer Kästchen auf der gespiegelten zu übertragen und dass ohne tausenden von abfragen.

    wenn x,y der index des original-kästchens ist (0...2,0...2 bei einer 3*3 matrix), dann ist der index des gespiegelten kästchens: 2-x,2-y (2...0,2...0). also: alle x,y-elemente nehmen und in eine neue matrix nach breite-x, länge-y kopieren. bei 'ner quadratischen matrix mit ungeradzahliger kantenlänge bleibt dabei das mittlere element an seinem platz.
    🙂

    0
Anmelden zum Antworten