/* Beispielloesung fuer Uebungsblatt, AI 1, WS 2006/07
 
   Version mit drei zweidimensionalen Arrays
 
   nh - 01/2007
 */

import IOulm.*;

public class Bayer1 {
   
   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 greenMosaic[][] = new int[SIZE][SIZE]; // gruene Matrix
   public static int redMosaic[][] = new int[SIZE][SIZE];   // rote Matrix
   public static int blueMosaic[][] = new int[SIZE][SIZE];  // blaue Matrix
   
   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) {
            greenMosaic[i][j] = -1;
            redMosaic[i][j] = -1;
            blueMosaic[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
                  greenMosaic[i][j] = Urc.getInt();
               } else {
                  redMosaic[i][j] = Urc.getInt();
               }
            } else {
               if (j % 2 == 0) {
                  blueMosaic[i][j] = Urc.getInt();
               } else {
                  greenMosaic[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...
                  greenMosaic[i][j] = (greenMosaic[i-1][j] +
                                       greenMosaic[i+1][j] +
                                       greenMosaic[i][j-1] +
                                       greenMosaic[i][j+1]) / 4;
                  // ...und blau
                  blueMosaic[i][j] = (blueMosaic[i-1][j-1] +
                                      blueMosaic[i-1][j+1] +
                                      blueMosaic[i+1][j-1] +
                                      blueMosaic[i+1][j+1]) / 4;
               } else { // wir sind auf einem gruenen Pixel...
                  // ... und berechnen nun noch rot
                  redMosaic[i][j] = (redMosaic[i][j-1] +
                                     redMosaic[i][j+1]) / 2;
                  // ... und blau
                  blueMosaic[i][j] = (blueMosaic[i-1][j] +
                                      blueMosaic[i+1][j]) / 2;
               }
            } else { // Reihen 2, 4, 6
               if (j%2 == 1) { // wir sind auf einem gruenen Pixel
                  // ... und berechnen nun noch rot
                  redMosaic[i][j] = (redMosaic[i-1][j] +
                                     redMosaic[i+1][j]) / 2;
                  // ... und blau
                  blueMosaic[i][j] = (blueMosaic[i][j-1] +
                                      blueMosaic[i][j+1]) / 2;
               } else { // wir sind auf einem blauen Pixel
                  // und berechnen noch gruen...
                  greenMosaic[i][j] = (greenMosaic[i-1][j] +
                                       greenMosaic[i+1][j] +
                                       greenMosaic[i][j-1] +
                                       greenMosaic[i][j+1]) / 4;
                  // ... und rot
                  redMosaic[i][j] = (redMosaic[i-1][j-1] +
                                     redMosaic[i-1][j+1] +
                                     redMosaic[i+1][j-1] +
                                     redMosaic[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
               redMosaic[0][j] = redMosaic[0][j+1];
               redMosaic[SIZE-1][j] = redMosaic[SIZE-1][j+1];
            } else if (j == SIZE-1) { // Spezialfall: letztes Element in Zeile
               redMosaic[0][j] = redMosaic[0][j-1];
               redMosaic[SIZE-1][j] = redMosaic[SIZE-1][j-1];
            } else {
               redMosaic[0][j] = (redMosaic[0][j-1] + redMosaic[0][j+1]) / 2;
               redMosaic[SIZE-1][j] =
                       (redMosaic[SIZE-1][j-1] + redMosaic[SIZE-1][j+1]) / 2;
            }
            // ... und blau!
            blueMosaic[0][j] = blueMosaic[1][j];
            blueMosaic[SIZE-1][j] = blueMosaic[SIZE-2][j];
         } else { // zweite, vierte, usw...
            // wir sind auf rot und benoetigen...
            // ... gruen ...
            greenMosaic[0][j] = (greenMosaic[0][j-1] + 
	                         greenMosaic[0][j+1] +
				 greenMosaic[1][j]) / 3;
            greenMosaic[SIZE-1][j] = (greenMosaic[SIZE-1][j-1] + 
	                              greenMosaic[SIZE-1][j+1] + 
				      greenMosaic[SIZE-2][j]) / 3;
            
            // ... und blau
            blueMosaic[0][j] = (blueMosaic[1][j-1] + blueMosaic[1][j+1]) / 2;
            blueMosaic[SIZE-1][j] =
                    (blueMosaic[SIZE-2][j-1] + blueMosaic[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 ...
            greenMosaic[i][0] = (greenMosaic[i-1][0] +
                    greenMosaic[i+1][0] +
                    greenMosaic[i][1]) / 3;
            greenMosaic[i][SIZE-1] = (greenMosaic[i-1][SIZE-1] +
                    greenMosaic[i+1][SIZE-1] +
                    greenMosaic[i][SIZE-2]) / 3;
            // ... und rot
            redMosaic[i][0] = (redMosaic[i-1][1] + redMosaic[i+1][1]) / 2;
            redMosaic[i][SIZE-1] = (redMosaic[i-1][SIZE-2] +
                                    redMosaic[i+1][SIZE-2]) / 2;
         } else {
            // wir stehen auf gruen...
            // ... und benoetigen blau ...
            if (i==0) { // Speziallfall: erste Zeile
               blueMosaic[i][0] = blueMosaic[i+1][0];
               blueMosaic[i][SIZE-1] = blueMosaic[i+1][SIZE-1];
            } else if (i==SIZE-1) { // Spezialfall letzte Zeile
               blueMosaic[i][0] = blueMosaic[i-1][0];
               blueMosaic[i][SIZE-1] = blueMosaic[i-1][SIZE-1];
            } else {
               blueMosaic[i][0] = (blueMosaic[i-1][0] + blueMosaic[i+1][0]) / 2;
               blueMosaic[i][SIZE-1] = (blueMosaic[i-1][SIZE-1] +
                                        blueMosaic[i+1][SIZE-1]) / 2;
            }
            // ... und rot
            redMosaic[i][0] = redMosaic[i][1];
            redMosaic[i][SIZE-1] = redMosaic[i][SIZE-2];
         }
         i++;
      }
      
      // alles ausgeben
      i=0;
      while(i<SIZE) {
         j=0;
         while(j<SIZE) {
            Write.String("G" + greenMosaic[i][j] +
                         " R" + redMosaic[i][j] +
                         " B" + blueMosaic[i][j]);
            if (j < SIZE-1) {
	       Write.String("  -  ");
            }
            j++;
         }
         Write.Ln();
         i++;
      }
   }
}