/* Beispielloesung fuer Uebungsblatt, AI 1, WS 2006/07
 
   Bonusaufgabe: Version mit einem dreidimensionalen Arrays
 
   nh - 01/2007
 */

import IOulm.*;

public class Bayer2 {
   
   public static int SIZE = 5;    // Groesse unseres Bildsensors (5x5 Pixel)
   public static int GREEN = 0;   // Konstantenvereinbarung fuer Farbe
   public static int RED= 1;
   public static int BLUE = 2;
   public static int NUMBER_OF_COLORS = 3;
   
   public static int mosaic[][][] = new int[NUMBER_OF_COLORS][SIZE][SIZE];
   
   public static void main(String[] args) {
      // Alle Arrays mit -1 initialisieren
      // Zwar waeren die Arrays "von Hause aus" mit 0 initialisiert,
      // jedoch kann sich bei der Berechnung der Farben ja durchaus
      // der Wert "0" ergeben. Um diesen von einer versehentlichen
      // Nicht-Beruecksichtigung eines Pixels unterscheiden zu koennen,
      // initialisieren wir alle Matrizen mit -1, denn dieser Wert ist
      // rechnerisch nicht zu erreichen
      int i=0;
      while(i<SIZE) {
         int j=0;
         while(j<SIZE) {
	    mosaic[GREEN][i][j] = -1;
	    mosaic[RED][i][j] = -1;
	    mosaic[BLUE][i][j] = -1;
            j++;
         }
         i++;
      }
      
      // Einlesen der Daten von der Standardeingabe
      i=0;
      while(i<SIZE) {
         int j=0;
         while(j<SIZE) {
            if(!Urc.readInt()) {
               Write.Line("Fehler beim Einlesen des Wertes ("
                       + i + ", " + j + ")");
               System.exit(1);
            }
            if (i % 2 == 0) {  // Reihen 1, 3, 5, etc (im Array an -1 denken!)
               if (j % 2 == 0) { // Entsprechend fuer die Spalten
                  mosaic[GREEN][i][j] = Urc.getInt();
               } else {
                  mosaic[RED][i][j] = Urc.getInt();
               }
            } else {
               if (j % 2 == 0) {
                  mosaic[BLUE][i][j] = Urc.getInt();
               } else {
                  mosaic[GREEN][i][j] = Urc.getInt();
               }
            }
            j++;
         }
         i++;
      }
      
      // Quadrat OHNE RAND berechnen
      i=1;
      while (i<SIZE-1) {
         int j=1;
         while (j<SIZE-1) {
            // in den Reihen 1, 3, 5, usw. (Achtung: intern -1 !)
            if (i%2 == 0) {
               // in den Spalten 2, 4, 6 usw. (Achtung: intern -1!)
               if (j%2 == 1) { // wir sind auf einem roten Pixel...
                  // ... und berechnen noch gruen...
                  mosaic[GREEN][i][j] = (mosaic[GREEN][i-1][j] +
                                       mosaic[GREEN][i+1][j] +
                                       mosaic[GREEN][i][j-1] +
                                       mosaic[GREEN][i][j+1]) / 4;
                  // ...und blau
                  mosaic[BLUE][i][j] = (mosaic[BLUE][i-1][j-1] +
                                      mosaic[BLUE][i-1][j+1] +
                                      mosaic[BLUE][i+1][j-1] +
                                      mosaic[BLUE][i+1][j+1]) / 4;
               } else { // wir sind auf einem gruenen Pixel...
                  // ... und berechnen nun noch rot
                  mosaic[RED][i][j] = (mosaic[RED][i][j-1] +
                                     mosaic[RED][i][j+1]) / 2;
                  // ... und blau
                  mosaic[BLUE][i][j] = (mosaic[BLUE][i-1][j] +
                                      mosaic[BLUE][i+1][j]) / 2;
               }
            } else { // Reihen 2, 4, 6
               if (j%2 == 1) { // wir sind auf einem gruenen Pixel
                  // ... und berechnen nun noch rot
                  mosaic[RED][i][j] = (mosaic[RED][i-1][j] +
                                     mosaic[RED][i+1][j]) / 2;
                  // ... und blau
                  mosaic[BLUE][i][j] = (mosaic[BLUE][i][j-1] +
                                      mosaic[BLUE][i][j+1]) / 2;
               } else { // wir sind auf einem blauen Pixel
                  // und berechnen noch gruen...
                  mosaic[GREEN][i][j] = (mosaic[GREEN][i-1][j] +
                                       mosaic[GREEN][i+1][j] +
                                       mosaic[GREEN][i][j-1] +
                                       mosaic[GREEN][i][j+1]) / 4;
                  // ... und rot
                  mosaic[RED][i][j] = (mosaic[RED][i-1][j-1] +
                                     mosaic[RED][i-1][j+1] +
                                     mosaic[RED][i+1][j-1] +
                                     mosaic[RED][i+1][j+1]) / 4;
               }
            }
            j++;
         }
         i++;
      }
      
      // Und nun noch den Rand als Spezialfall abfahren
      // zunaechst die erste und letzte Zeile
      int j = 0;
      while (j<SIZE) {
         // Spalten abfahren 
         if (j%2 == 0) { // erste, dritte, usw. 
            // wir sind auf gruen und benoetigen...
            // ... rot...
            if (j==0) { // Spezialfall: erstes Element in der Zeile
               mosaic[RED][0][j] = mosaic[RED][0][j+1];
               mosaic[RED][SIZE-1][j] = mosaic[RED][SIZE-1][j+1];
            } else if (j == SIZE-1) { // Spezialfall: letztes Element in Zeile
               mosaic[RED][0][j] = mosaic[RED][0][j-1];
               mosaic[RED][SIZE-1][j] = mosaic[RED][SIZE-1][j-1];
            } else {
               mosaic[RED][0][j] = (mosaic[RED][0][j-1] + mosaic[RED][0][j+1]) / 2;
               mosaic[RED][SIZE-1][j] =
                       (mosaic[RED][SIZE-1][j-1] + mosaic[RED][SIZE-1][j+1]) / 2;
            }
            // ... und blau!
            mosaic[BLUE][0][j] = mosaic[BLUE][1][j];
            mosaic[BLUE][SIZE-1][j] = mosaic[BLUE][SIZE-2][j];
         } else { // zweite, vierte, usw...
            // wir sind auf rot und benoetigen...
            // ... gruen ...
            mosaic[GREEN][0][j] = (mosaic[GREEN][0][j-1] + 
	                         mosaic[GREEN][0][j+1] +
				 mosaic[GREEN][1][j]) / 3;
            mosaic[GREEN][SIZE-1][j] = (mosaic[GREEN][SIZE-1][j-1] + 
	                              mosaic[GREEN][SIZE-1][j+1] + 
				      mosaic[GREEN][SIZE-2][j]) / 3;
            
            // ... und blau
            mosaic[BLUE][0][j] = (mosaic[BLUE][1][j-1] + mosaic[BLUE][1][j+1]) / 2;
            mosaic[BLUE][SIZE-1][j] =
                    (mosaic[BLUE][SIZE-2][j-1] + mosaic[BLUE][SIZE-2][j+1]) / 2;
         }
         j++;
      }
      // und nun noch die erste und letzte Spalte (ohne erste / letzte Zeile)
      i = 1;
      while (i<SIZE-1) {
         if (i%2 == 1) {
            // wir stehen auf blau...
            // ... und benoetigen gruen ...
            mosaic[GREEN][i][0] = (mosaic[GREEN][i-1][0] +
                    mosaic[GREEN][i+1][0] +
                    mosaic[GREEN][i][1]) / 3;
            mosaic[GREEN][i][SIZE-1] = (mosaic[GREEN][i-1][SIZE-1] +
                    mosaic[GREEN][i+1][SIZE-1] +
                    mosaic[GREEN][i][SIZE-2]) / 3;
            // ... und rot
            mosaic[RED][i][0] = (mosaic[RED][i-1][1] + mosaic[RED][i+1][1]) / 2;
            mosaic[RED][i][SIZE-1] = (mosaic[RED][i-1][SIZE-2] +
                                    mosaic[RED][i+1][SIZE-2]) / 2;
         } else {
            // wir stehen auf gruen...
            // ... und benoetigen blau ...
            if (i==0) { // Speziallfall: erste Zeile
               mosaic[BLUE][i][0] = mosaic[BLUE][i+1][0];
               mosaic[BLUE][i][SIZE-1] = mosaic[BLUE][i+1][SIZE-1];
            } else if (i==SIZE-1) { // Spezialfall letzte Zeile
               mosaic[BLUE][i][0] = mosaic[BLUE][i-1][0];
               mosaic[BLUE][i][SIZE-1] = mosaic[BLUE][i-1][SIZE-1];
            } else {
               mosaic[BLUE][i][0] = (mosaic[BLUE][i-1][0] + mosaic[BLUE][i+1][0]) / 2;
               mosaic[BLUE][i][SIZE-1] = (mosaic[BLUE][i-1][SIZE-1] +
                                        mosaic[BLUE][i+1][SIZE-1]) / 2;
            }
            // ... und rot
            mosaic[RED][i][0] = mosaic[RED][i][1];
            mosaic[RED][i][SIZE-1] = mosaic[RED][i][SIZE-2];
         }
         i++;
      }
      
      // alles ausgeben
      i=0;
      while(i<SIZE) {
         j=0;
         while(j<SIZE) {
            Write.String("G" + mosaic[GREEN][i][j] +
                         " R" + mosaic[RED][i][j] +
                         " B" + mosaic[BLUE][i][j]);
            if (j < SIZE-1) {
	       Write.String("  -  ");
            }
            j++;
         }
         Write.Ln();
         i++;
      }
   }
}