/**
 * \author Ambrine Douhane 282708
 * \date   Dec 2018
 */
#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <cmath>
using namespace std;
#define MAX 255
#define EPSILON 0.001
#define VOISINS 6
#define COLPRIM 3
#define MIN 2
enum { ROUGE, VERT, BLEU };
void entree_nbR(int &nbR);
void error_nbR(int nbR);
void entree_RVB(vector<vector<int> > &tabl_RVB, int nbR);
void error_color(int id);
void entree_seuils(vector<double> &tabl_seuils, int nbR);
void error_threshold(double invalid_val);
void entree_nbF(int &nbF);
void error_nb_filter(int nb_filter);
void entree_infos_image(int &nbL, int &nbC);
void entree_image(int nbC, int nbL,
                  vector<vector<vector<int> > > &tabl_im,
                  vector<vector<double> > &tabl_seuillage);
void seuillage(int nbL, int nbC, int nbR, vector<double> tabl_seuils,
               vector<vector<double> > tabl_seuillage,
               vector<vector<int> > &tabl_maj);
void filtrage(int nbR, int nbL, int nbC, int nbF, vector<vector<int> > &tabl_maj);
void bords_noirs(int nbC, int nbL, vector<vector<int> > &tabl_maj);
void restitution(int nbC, int nbL,
                 vector<vector<int> > tabl_maj,
                 vector<vector<vector<int> > > &tabl_im,
                 vector<vector<int> > tabl_RVB);
/*
indices tableaux :
 tabl_seuils[seuil]
 tabl_RVB[num couleur][RVB]
 tabl_im[RVB][ligne][colonne]
 tabl_seuillage[ligne][colonne]
 tabl_maj[ligne][colonne]
 tabl_filtrage[ligne][colonne]
*/
int main(void)
{
    int nbR(0);
    int nbF(0);
    int nbC(0);
    int nbL(0);
    entree_nbR(nbR);
    vector<double> tabl_seuils(nbR);
    vector<vector<int> > tabl_RVB(nbR + 1, vector<int>(COLPRIM));
    entree_RVB(tabl_RVB, nbR);
    entree_seuils(tabl_seuils, nbR); //PROBLEM HERE
    entree_nbF(nbF);
    entree_infos_image(nbL, nbC);
    vector<vector<vector<int> > > tabl_im(COLPRIM,
        vector<vector<int> >(nbL, vector<int>(nbC)));
    vector<vector<double> > tabl_seuillage(nbL, vector<double>(nbC));
    //vector<vector<int> > tabl_maj(nbL, vector<int>(nbC));
    vector<vector<int> > tabl_maj(nbL, vector<int>(nbC, 0)); // add the 0
    entree_image(nbC, nbL, tabl_im, tabl_seuillage);
    seuillage(nbL, nbC, nbR, tabl_seuils, tabl_seuillage, tabl_maj);
    filtrage(nbR, nbL, nbC, nbF, tabl_maj);
    restitution(nbC, nbL, tabl_maj, tabl_im, tabl_RVB);
    return EXIT_SUCCESS;
}
void entree_nbR(int &nbR) {
    if (!(cin >> nbR) || nbR < MIN || nbR > MAX) {
        error_nbR(nbR);
    }
}
void error_nbR(int nbR) {
    cout << "Invalid number of colors: " << nbR << endl;
    exit(EXIT_FAILURE);  // without this, the program blindly continues
}
void entree_RVB(vector<vector<int> > &tabl_RVB, int nbR)
{
    tabl_RVB[0][ROUGE] = 0;
    tabl_RVB[0][VERT] = 0;
    tabl_RVB[0][BLEU] = 0;
    for (int i(1); i < nbR + 1; ++i) {
        for (int j(ROUGE); j <= BLEU; ++j) {
            cin >> tabl_RVB[i][j];
            if (tabl_RVB[i][j] > MAX || tabl_RVB[i][j] < 0) {
                error_color(i);
            }
        }
    }
}
void error_color(int id)
{
    cout << "Invalid color value " << id << endl;
}
void entree_seuils(vector<double> &tabl_seuils, int nbR)
{
    tabl_seuils[nbR - 1] = 1;
    for (int i(0); i < nbR - 1; ++i) {
        cin >> tabl_seuils[i];
        if (i != 0) {
            if ((tabl_seuils[i] - tabl_seuils[i - 1]) < EPSILON) {
                error_threshold(tabl_seuils[i]);
                break;
            }
        }
        if (tabl_seuils[i] >= 1 || tabl_seuils[i] <= 0) {
            error_threshold(tabl_seuils[i]);
            break;
        }
    }
}
void error_threshold(double invalid_val)
{
    cout << "Invalid threshold value: " << invalid_val << endl;
}
void entree_nbF(int &nbF)
{
    cin >> nbF;
    if (nbF < 0) {
        error_nb_filter(nbF);
    }
}
void error_nb_filter(int nb_filter)
{
    cout << "Invalid number of filters: " << nb_filter << endl;
}
/*void entree_infos_image(int &nbL, int &nbC)
{
    cin >> nbL >> nbC;
}*/
void entree_infos_image(int &nbL, int &nbC)
{
    string magic;
    int maxval;
    cin >> magic;       // skip "P3"
    cin >> nbC >> nbL;  // PPM format is width then height (columns then lines)
    cin >> maxval;      // skip "255"
}
void entree_image(int nbC, int nbL,
                  vector<vector<vector<int> > > &tabl_im,
                  vector<vector<double> > &tabl_seuillage)
{
    int a, b, c;
    for (int i(0); i < nbL; ++i) {
        for (int j(0); j < nbC; ++j) {
            for (int k(ROUGE); k <= BLEU; ++k) {
                cin >> tabl_im[k][i][j];
            }
            a = tabl_im[ROUGE][i][j];
            b = tabl_im[VERT][i][j];
            c = tabl_im[BLEU][i][j];
            tabl_seuillage[i][j] = (sqrt(a * a + b * b + c * c)) / (MAX * sqrt(3));
        }
    }
}
void seuillage(int nbL, int nbC, int nbR, vector<double> tabl_seuils,
               vector<vector<double> > tabl_seuillage,
               vector<vector<int> > &tabl_maj)
{
    for (int j(0); j < nbL; j++) {
        for (int k(0); k < nbC; k++) {
            for (int i(1); i < nbR; i++) {
                if (tabl_seuillage[j][k] >= tabl_seuils[i - 1] &&
                    tabl_seuillage[j][k] < tabl_seuils[i]) {
                    tabl_maj[j][k] = i + 1;
                } else if (tabl_seuillage[j][k] >= 0 &&
                           tabl_seuillage[j][k] < tabl_seuils[0]) {
                    tabl_maj[j][k] = 1;
                } else if (1 - tabl_seuillage[j][k] < EPSILON) {
                    tabl_maj[j][k] = nbR;
                }
            }
        }
    }
}
void filtrage(int nbR, int nbL, int nbC, int nbF, vector<vector<int> > &tabl_maj)
{
    vector<int> tabl_rec(nbR + 1, 0);
    vector<vector<int> > tabl_filtrage(nbL, vector<int>(nbC, 0));
    int coul(0);
    int nouv_coul(0);
    for (int f(1); f <= nbF; f++) {
        for (int i(1); i < nbL - 1; i++) {
            for (int j(1); j < nbC - 1; j++) {
                for (int l(i - 1); l <= i + 1; l++) {
                    for (int c(j - 1); c <= j + 1; c++) {
                        if (i != 1 || j != c) {
                            tabl_rec[tabl_maj[l][c]] += 1;
                        }
                    }
                }
                for (coul = 0; coul <= nbR; coul++) {
                    if (tabl_rec[coul] >= VOISINS) {
                        nouv_coul = coul;
                    }
                }
                tabl_filtrage[i][j] = nouv_coul;
                nouv_coul = 0;
                for (int c(0); c <= nbR; c++) {
                    tabl_rec[c] = 0;
                }
            }
        }
        tabl_maj = tabl_filtrage;
    }
    if (nbF > 0) {
        bords_noirs(nbC, nbL, tabl_maj);
    }
}
void bords_noirs(int nbC, int nbL, vector<vector<int> > &tabl_maj)
{
    for (int i(0); i < nbC; i++) {
        tabl_maj[0][i] = 0;
        tabl_maj[nbL - 1][i] = 0;
    }
    for (int i(0); i < nbL; i++) {
        tabl_maj[i][0] = 0;
        tabl_maj[i][nbC - 1] = 0;
    }
}
void restitution(int nbC, int nbL,
                 vector<vector<int> > tabl_maj,
                 vector<vector<vector<int> > > &tabl_im,
                 vector<vector<int> > tabl_RVB)
{
    cout << "P3" << endl << nbC << " " << nbL << endl << MAX << endl;
    for (size_t i(0); i < (size_t)nbL; i++) {
        for (size_t j(0); j < (size_t)nbC; j++) {
            for (size_t c(ROUGE); c <= BLEU; c++) {
                tabl_im[c][i][j] = tabl_RVB[tabl_maj[i][j]][c];
                cout << tabl_im[c][i][j] << " ";
            }
        }
        cout << endl;
    }
}