IZP Projekt 3

/*
 * Soubor:  proj3.c
 * Datum:   30.11.2008
 * Autor:   David Sabata, xsabat01@stud.fit.vutbr.cz
 * Projekt: Maticove operace, projekt c.3 pro IZP
 * Popis:   Program provadi operace s maticemi, a to konkretne soucet, soucin,
 *          maticovy vyraz (soucet dvou soucinu), hledani sedloveho bodu a 
 *          pocet spicek v matici, zadane souborem. 
 */
 
 
// práce se vstupem/výstupem
#include <stdio.h>
 
// obecné funkce jazyka C
#include <stdlib.h>
 
// kvůli funkci strcmp
#include <string.h>
 
// limity promenych
#include <limits.h>
 
// typ bool, konstanty true, false
#include <stdbool.h>
 
// Kody chyb a stavu programu
enum tcodes
{
   EOK = 0,    // Zadna chyba
   EEXIT,      // Obecna chyba - nema zadny text, jen pro predani die()
   ECLWRONG,   // Chybne vstupni parametry
   EMALLOC,    // Chyba pri alokaci
   EFOPEN,     // Chyba pri otevirani souboru
   EFCLOSE,    // Chyba pri uzavirani souboru
   EFINP,      // Neplatna data v souboru
   EFSIZE,     // Nepodarilo se nacist rozmery matice
};
 
// Pole textovych retezcu vypisovanych funkci printError
const char *EMSG[] =
{
   // EOK
   "Vse v poradku",
   // EEXIT - Obecna chyba - nema zadny text, jen pro predani die()
   "",
   // ECLWRONG
   "Chybne parametry prikazoveho radku!",
   // EMALLOC
   "Nepodarilo se alokovat pamet",
   // EFOPEN
   "Nepodarilo se otevrit soubor",
   // EFCLOSE
   "Nepodarilo se uzavrit soubor",
   // EFINP
   "Soubor obsahuje neplatna data",
   // EFSIZE
   "Ze souboru se nepodarilo nacist rozmery matice",
};
 
// Akce - navratova hodnota funkce co kontroluje parametry
enum actions
{
   AHELP,
   AADD,
   AMULT,
   AEXPR,
   ASADDLE,
   APEAKS,   
};
 
// Struktura pro matice
typedef struct tmatrix
{
   int rows, cols;
   int **matrix;
} TMatrix;
 
// Radky pomocnych matic pri hledani sedloveho bodu - maxima a minima
enum saddle_rows
{
  ROWMIN,
  ROWMAX
};
 
////////////////////////////////////////////////////////////////////////////////
void printHelp();
void printError(int error);
void die(int error);
int loadParams(int argc, char *argv[]);
bool allocMatrix(TMatrix *mat);
void freeMatrix(TMatrix *mat);
bool loadMatrix(TMatrix *mat, char *filename);
void printMatrix(TMatrix *mat);
 
bool addMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3);
bool multMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3);
bool exprMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3);
bool isMxValid(TMatrix *mat);
bool hasSaddle(TMatrix *mat);
void fillMatrix(TMatrix *mat, int val, int row);
int peaksMatrix(TMatrix *mat);
////////////////////////////////////////////////////////////////////////////////
/**
 * Hlavní program.
 */
int main(int argc, char *argv[])
{
   int action = loadParams(argc, argv);
   TMatrix mat1 = {.cols = 0, .rows = 0, .matrix = NULL};
   TMatrix mat2 = {.cols = 0, .rows = 0, .matrix = NULL};
   TMatrix mat3 = {.cols = 0, .rows = 0, .matrix = NULL};
 
   switch (action)
   {
      case AHELP:
         printHelp();
         break;
      //------------------------------------------------------------------------   
      case AADD:
      case AMULT:
      case AEXPR:         
         // Nacist z prvniho souboru
         if (loadMatrix(&mat1, argv[2]) == false)
            die(EEXIT);         
         // Nacist z druheho souboru
         if (loadMatrix(&mat2, argv[3]) == false)
         {
            // Pri chybe jeste uvolnit uz alokovanou matici
            freeMatrix(&mat1);
            die(EEXIT);
         }
 
         // Operace s maticema
         bool result;
         if (action == AADD) result = addMatrix(&mat1, &mat2, &mat3);
         if (action == AMULT) result = multMatrix(&mat1, &mat2, &mat3);
         if (action == AEXPR) result = exprMatrix(&mat1, &mat2, &mat3);
 
         // Osetreni chyb v operacich (nedefinovany vysledek neni chyba)
         if (result == false)
         {
            // Uvolnit pamet a ukoncit, hlasku uz vypsala funkce pro operaci
            freeMatrix(&mat1);
            freeMatrix(&mat2);
            die(EEXIT);
         } 
 
         // Vypocet se povedl - vypsat vysledek
         // Pokud vysledek operace nebyl definovany, vypiseme pouze false
         if (isMxValid(&mat3) == false)
            printf("false\n");
         else
            printMatrix(&mat3);
 
         // Uvolnit pamet a nechat program ukoncit
         freeMatrix(&mat1);
         freeMatrix(&mat2);
         freeMatrix(&mat3);
 
         break;
      //------------------------------------------------------------------------      
      case ASADDLE:
         // Nacist ze souboru
         if (loadMatrix(&mat1, argv[2]) == false)
            die(EEXIT); 
         // Hledame
         if (hasSaddle(&mat1) == true)
            printf("true\n");
         else 
            printf("false\n");            
         // Uklidit
         freeMatrix(&mat1);
 
         break;   
      //------------------------------------------------------------------------
      case APEAKS:
         // Nacist ze souboru
         if (loadMatrix(&mat1, argv[2]) == false)
            die(EEXIT); 
 
         // Vypsat pocet spicek
         int pom = peaksMatrix(&mat1);
         printf("%i\n", pom);           
 
         freeMatrix(&mat1);
 
         break;
   }
 
   return EXIT_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////
 
/**
 * Vytiskne napovedu 
 */
void printHelp()
{   
   printf(
      "Program pro operace s maticemi\n"
      "Autor: David Sabata (c)2008\n\n"
      "Program nacte dve matice ze souboru a provede s nimi operaci\n"
      "soucet (A+B), soucin (A*B), pripadne slozeny vyraz (A*B)+(A*B).\n"
      "Dale umoznuje testovat matici na existenci sedloveho bodu a umi\n"
      "spocitat pocet spicek v matici.\n"
      "Vstupnimi parametry je jeden nebo dva nazvy souboru, obsahujici\n"
      "matice, se kterymi se bude pracovat.\n\n"
      "Popis parametru:\n"
      "-h\t\t\tvypis teto napovedy\n"
      "-add mat1.txt mat2.txt\tsoucet matic\n"
      "-mult mat1.txt mat2.txt\tsoucin matic\n"
      "-expr mat1.txt mat2.txt\tmaticovy vyraz\n"
      "-saddle mat1.txt\ttest sedloveho bodu\n"
      "-peaks mat1.txt\t\tpocet spicek\n"
   );
}
 
 
/**
 * Vytiskne chybu 
 * @param code kod chyby nebo stavu programu
 */
void printError(int error)
{  
   if (error != EEXIT)
      fprintf(stderr, "Chyba: %s\n", EMSG[error]);
}
 
/**
 * Vytiskne chybu a ukonci program
 * (funkce pro vypis chyby a ukonceni s chybou jsou oddelene
 *  protoze nekdy je treba pri vyskytu chyby jeste uzavrit soubor
 *  ci dealokovat pamet; die se vola v pripade kdy uz je "uklizeno") 
 * @param code kod chyby nebo stavu programu
 */
void die(int error)
{   
   printError(error);
   exit(EXIT_FAILURE);
}
 
 
/**
 * Nacte parametry a vyhodnoti akci, pripadne chybu
 * @param argc int pocet parametru
 * @param argv char pole parametru
 * @return int akce ktera se ma provest   
 */ 
int loadParams(int argc, char *argv[])
{
   // Napoveda
   if (argc == 2 && strcmp("-h", argv[1]) == 0) 
      return AHELP;
 
   // Scitani
   if (argc == 4 && strcmp("-add", argv[1]) == 0) 
      return AADD;
 
   // Nasobeni
   if (argc == 4 && strcmp("-mult", argv[1]) == 0) 
      return AMULT;
 
   // Vyraz
   if (argc == 4 && strcmp("-expr", argv[1]) == 0) 
      return AEXPR;      
 
   // Sedlovy bod
   if (argc == 3 && strcmp("-saddle", argv[1]) == 0) 
      return ASADDLE;    
 
   // Spicky
   if (argc == 3 && strcmp("-peaks", argv[1]) == 0) 
      return APEAKS;    
 
   // Cokoliv jineho je chyba, vytiskneme hlasku o nespravnych parametrech,
   // coz zaroven ukonci program. Hodnota v returnu je pouze formalita. 
   die(ECLWRONG);
 
   return -1;
}
 
 
 
/**
 * Alokuje matici na hromade a vraci jeji strukturu
 * (jakmile se podari alokovat celou matici, bude k jeji
 *  dealokaci slouzit freeMatrix) 
 * V pripade chyby vola vypsani hlasky a vraci false 
 * @param mat TMatrix matice ktera se bdue alokovat
 * @return bool
 */    
bool allocMatrix(TMatrix *mat)
{   
 
   // Alokace radku
   mat->matrix = malloc(mat->rows * sizeof(int *));
   // Kontrola uspechu
   if (mat->matrix == NULL)
   {
      printError(EMALLOC);
      return false;
   }
 
   // Alokace sloupcu (bunek)
   for (int i = 0; i < mat->rows; i++)
   {
      mat->matrix[i] = malloc(mat->cols * sizeof(int));
      // Kontrola uspechu
      if (mat->matrix[i] == NULL)
      {
         // Uvolneni pameti
         for (; i>=0; i--)
            free(mat->matrix[i]);
         // Jeste vyssi uroven
         free(mat->matrix);
         // Vypsat hlasku a vratit neuspech
         printError(EMALLOC);
         return false;
      }
   }
 
   return true;
}
 
 
/**
 * Uvolni alokovanou matici z pameti
 * @param mat TMatrix matice k uvolneni
 */   
void freeMatrix(TMatrix *mat)
{
   // Uvolnit sloupce
   for (int i = 0; i < mat->rows; i++)
      free(mat->matrix[i]);
 
   // Uvolnit radky
   free(mat->matrix);
}
 
 
 
/**
 * Nacte matici ze souboru a vrati ji jako plnohodnotnou strukturu
 * v pripade chyby vola vypsani hlasky a vraci false 
 * @param filename char * soubor s matici
 * @return bool
 */   
bool loadMatrix(TMatrix *mat, char *filename)
{
   FILE *fp;
   // Otevreni souboru a kontrola
   fp = fopen(filename, "r");
   if (fp == NULL)
   {
      printError(EFOPEN);
      return false;
   }
 
   int check; // Kontrola - pocet nactenych hodnot
 
   // Nacteni rozmeru matice
   check = fscanf(fp, "%i %i", &mat->rows, &mat->cols);
   if (check < 2)
   {
      // Uzavrit soubor
      if (fclose(fp) == EOF)
         printError(EFCLOSE);      
      // Vypsat hlasku o problemu
      printError(EFSIZE);
      // Vratit signal nahoru ze nastal problem
      return false;
   }
 
   // Vytvoreni matice
   if (allocMatrix(mat) == false)   
   {
      // Uzavrit soubor
      if (fclose(fp) == EOF)
         printError(EFCLOSE);      
      // Vratit signal nahoru ze nastal problem
      return false;
   }
 
   int   pos = 0, // Pozice v matici, na kterou zapisujeme
         data;    // Nactene cislo
 
   // Smycka nacitani hodnot
   while ((check = fscanf(fp, "%i", &data)) != EOF) 
   {
      // "Necislo" znamena chybu
      if (check == 0)
      {
         // Uzavrit soubor
         if (fclose(fp) == EOF)
            printError(EFCLOSE);
         // Uvolnit pamet
         freeMatrix(mat);
         // Vypsat hlasku
         printError(EFINP);
         // Vratit neuspech
         return false;            
      }
 
      // Ulozeni nactene hodnoty do matice   
      mat->matrix[pos / mat->cols][pos % mat->cols] = data;
      // Posunuti ukazatele na dalsi prvek
      pos++;
   } 
 
   // Uzavrit soubor
   if (fclose(fp) == EOF)
      printError(EFCLOSE);      
   // Vratit uspech
   return true;
}
 
 
 
/**
 * Vytiskne matici na standardni vystup
 * na prvnim radku pouze hodnoty poctu radku a sloupcu
 * na dalsich radcich samotna matice
 * @param mat TMatrix matice k vypsani
 */    
void printMatrix(TMatrix *mat)
{
   // Vypis radku a sloupcu
   printf("%i %i", mat->rows, mat->cols);
   // Vypis hodnot
   for (int r = 0; r < mat->rows; r++)
   {
      printf("\n");
      for (int c = 0; c < mat->cols; c++)
      {
         printf("%i ", mat->matrix[r][c]);
      }      
   }
   // Pro hezci vystup odradkovani
   printf("\n");
}
 
 
/**
 * Scita matice mat1 + mat2 a vysledek ulozi do matice mat3, kterou predtim
 * alokuje, vraci bool jako zpravu o chybe/uspechu (nelegalni vysledek neni
 * to same jako chyba!)
 * @param mat1 TMatrix scitanec
 * @param mat2 TMatrix scitanec
 * @param mat3 TMatrix soucet
 */     
bool addMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3)
{
   // Kontrola legalnosti operace - soucet vyzaduje stejne rozmery
   // pri nelegalni alokujeme vyslednou matici 0x0, podle cehoz pak
   // fce isMxValid() zjistuje, ze je vysledek operace neplatny
   if (mat1->rows != mat2->rows || mat1->cols != mat2->cols)
   {
      mat3->rows = 0;
      mat3->cols = 0;
      // Stale muze nastat chyba, hlaska uz se ale vypsala
      // a tady nic uvolnovat nemusime
      if (allocMatrix(mat3) == false)
         return false;      
      // Vypocet byl z technickeho pohledu uspesny
      return true;
   }
 
   // Alokovat matici potrebnych rozmeru
   mat3->rows = mat1->rows;
   mat3->cols = mat1->cols;
   if (allocMatrix(mat3) == false)
      return false;
 
   int c, r;
 
   // Samotny vypocet
   for (int i = 0; i < (mat1->cols * mat1->rows); i++)
   {
      r = i / mat3->cols;
      c = i % mat3->cols;
      mat3->matrix[r][c] = mat1->matrix[r][c]+mat2->matrix[r][c];
   }   
 
   return true;
}
 
 
 
 
/**
 * Nasobi matice mat1 * mat2 a vysledek ulozi do matice mat3, kterou predtim
 * alokuje, vraci bool podle uspechu provedeni funkce (nelegalni vysledek 
 * neznamena chybu!)
 * @param mat1 TMatrix nasobek
 * @param mat2 TMatrix nasobek
 * @param mat3 TMatrix soucin
 */     
bool multMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3)
{
   // Kontrola legalnosti operace - soucet vyzaduje matice m,n a n,p
   // pri nelegalni alokujeme vyslednou matici 0x0, podle cehoz pak
   // fce isMxValid() zjistuje, ze je vysledek operace neplatny
   if (mat1->cols != mat2->rows)
   {
      mat3->rows = 0;
      mat3->cols = 0;
      // Stale muze nastat chyba, hlaska uz se ale vypsala
      // a tady nic uvolnovat nemusime
      if (allocMatrix(mat3) == false)
         return false;      
      // Vypocet byl z technickeho pohledu uspesny
      return true;
   }
 
   // Alokovat matici potrebnych rozmeru
   mat3->rows = mat1->rows;
   mat3->cols = mat2->cols;
   if (allocMatrix(mat3) == false)
      return false;
 
   int r, c, sum;
 
   // Vlastni vypocet
   for (int pos = 0; pos < (mat3->rows * mat3->cols); pos++)
   {
      r = pos / mat3->cols;
      c = pos % mat3->cols;
      sum = 0;
 
      for (int i = 0; i < mat1->cols; i++)
         sum += mat1->matrix[r][i] * mat2->matrix[i][c];
 
      mat3->matrix[r][c] = sum;      
   }
 
   return true;
}
 
 
 
/**
 * Vyraz (mat1*mat2) + (mat1*mat2)
 * @param mat1 TMatrix vstupni matice
 * @param mat2 TMatrix vstupni matice
 * @param mat3 TMatrix vystup
 */     
bool exprMatrix(TMatrix *mat1, TMatrix *mat2, TMatrix *mat3)
{
   // Pomocna matice pro soucin
   TMatrix mat4 = {.rows = 0, .cols = 0, .matrix = NULL};
 
   // Soucin
   if (multMatrix(mat1, mat2, &mat4) == false)
      return false;
 
   // Soucet soucinu
   if (addMatrix(&mat4, &mat4, mat3) == false)
      return false;
 
   // Uklid pomocne matice
   freeMatrix(&mat4);
 
   return true;   
}
 
 
/**
 * Kontroluje, jestli matice obsahuje platny vysledek - pokud je matice 
 * vysledkem nedefinovane operace (napr. nasobeni matic s nespravnymi rozmery)
 * je jeji rozmer 0x0
 * @param mat TMatrix kontrolovana matice
 */
bool isMxValid(TMatrix *mat)
{ 
   if (mat->cols == 0)
      return false;
   else
      return true;
}   
 
 
/**
 * Zjistuje jestli v matici existuje sedlovy bod
 * @param mat TMatrix matice k testovani
 */  
bool hasSaddle(TMatrix *mat)
{           
   // Vytvorime dve pomocne matice; jedna bude uchovavat maxima a minima
   // v radcich (rozmery 2 x pocet radku) a druha maxima a minima ve sloupcich
   // (rozmery 2 x pocet sloupcu puvodni matice)
   TMatrix pomR = {.rows = 2, .cols = mat->rows, .matrix = NULL};
   allocMatrix(&pomR);
   TMatrix pomS = {.rows = 2, .cols = mat->cols, .matrix = NULL};
   allocMatrix(&pomS);
 
   // Naplnit pomocne matice zakladnima hodnotama
   fillMatrix(&pomR, INT_MAX, 0);
   fillMatrix(&pomR, INT_MIN, 1);
   fillMatrix(&pomS, INT_MAX, 0);
   fillMatrix(&pomS, INT_MIN, 1);
 
   // Prohledavani radku
   for (int row = 0; row < mat->rows; row++)
   {
      // Najit na radku nejmensi a nejvetsi prvek
      for (int col = 0; col < mat->cols; col++)
      {
         // Zapamatovat hodnotu nejmensiho prvku
         if (mat->matrix[row][col] < pomR.matrix[ROWMIN][row])
            pomR.matrix[ROWMIN][row] = mat->matrix[row][col];            
 
         // Zapamatovat hodnotu nejvetsiho prvku
         if (mat->matrix[row][col] > pomR.matrix[ROWMAX][row])
            pomR.matrix[ROWMAX][row] = mat->matrix[row][col];        
      }        
   }   
 
   // Prohledavani sloupcu
   for (int col = 0; col < mat->cols; col++)
   {
      // Najit ve sloupci nejmensi a nejvetsi prvek
      for (int row = 0; row < mat->rows; row++)
      {
         // Zapamatovat hodnotu nejmensiho prvku
         if (mat->matrix[row][col] < pomS.matrix[ROWMIN][col])
            pomS.matrix[ROWMIN][col] = mat->matrix[row][col];
 
         // Zapamatovat hodnotu nejvetsiho prvku
         if (mat->matrix[row][col] > pomS.matrix[ROWMAX][col])
            pomS.matrix[ROWMAX][col] = mat->matrix[row][col];
      }   
   }
 
   bool saddleFound = false;
   int col, row;   
 
   // Projdeme jeste jednou puvodni matici a budeme kontrolovat jestli
   // se nektery prvek vyskytuje v obou pomocnych maticich, coz znamena
   // ze je sedlovy bod
   for (int i = 0; i < (mat->rows * mat->cols); i++)
   {
      row = i / mat->cols;
      col = i % mat->cols;
 
      // Preskocit okrajove body
      if ( row == 0 || row == (mat->rows - 1) || 
           col == 0 || col == (mat->cols - 1) )
         continue;
 
      // Porovnat body obou pomocnych matic
      if ( (mat->matrix[row][col] == pomR.matrix[ROWMIN][row] && 
            mat->matrix[row][col] == pomS.matrix[ROWMAX][col]) 
            ||
           (mat->matrix[row][col] == pomR.matrix[ROWMAX][row] && 
            mat->matrix[row][col] == pomS.matrix[ROWMIN][col]) )
      {
         saddleFound = true;         
         break;
      }      
   }   
 
   // Uklidit a vratit vysledek
   freeMatrix(&pomR);
   freeMatrix(&pomS);
 
   if (saddleFound == true)
      return true;
   else 
      return false;
}
 
 
/**
 * Naplni matici zadanou hodnotou; parametrem row lze specifikovat, ktery
 * radek se hodnotou naplni; pokud je row=-1 naplni se cela matice 
 * @param mat TMatrix matice
 * @param int val hodnota kterou se bude plnit
 * @param int row radek, ktery se bude plnit 
 */   
void fillMatrix(TMatrix *mat, int val, int row)
{
   int i, end;
 
   if (row > -1 && row < mat->rows)
   {
      i = mat->cols * row;
      end = mat->cols * (row + 1);
   }
   else
   {
      i = 0;
      end = mat->rows * mat->cols;
   }
 
   for (; i < end; i++)
      mat->matrix[i / mat->cols][i % mat->cols] = val;             
}
 
 
/**
 * Vraci pocet spicek v matici
 * @param mat TMatrix matice
 */  
int peaksMatrix(TMatrix *mat)
{
   int peaks = 0;
   int cols = mat->cols;
   int rows = mat->rows;
   int col, row, act;
 
   // Pomocna matice ve ktere se budou ukladat uz zkontrolovane body
   TMatrix pom = {.rows = mat->rows, .cols = mat->cols, .matrix = NULL};
   if (allocMatrix(&pom) == false)
      return false;
 
   // Naplnime pomocnou matici nulama, tzn. bod neni zkontrolovany
   // hodnota -1 znamena vsechny radky
   fillMatrix(&pom, 0, -1);
 
   // Prochazime vsechny body a pocitame spicky; pokud najdeme spicku
   // oznacime za zkontrolovane i jeji osmiokoli, protoze tam dalsi
   // spicka byt nemuze
   for (int i = 0; i < (mat->rows * mat->cols); i++)
   {
      row = i / mat->cols;
      col = i % mat->cols;
      // Preskocit uz zkontrolovane
      if (pom.matrix[row][col] == 1)
         continue;
 
      act = mat->matrix[row][col];
 
      //Otestovat
      if (  (row-1 >= 0 && mat->matrix[row-1][col] >= act) ||
            (row+1 < rows && mat->matrix[row+1][col] >= act) ||
            (col-1 >= 0 && mat->matrix[row][col-1] >= act) ||
            (col+1 < cols && mat->matrix[row][col+1] >= act) ||
            (row-1 >= 0 && col-1 >= 0 && mat->matrix[row-1][col-1] >= act) ||
            (row-1 >= 0 && col+1 < cols && mat->matrix[row-1][col+1] >= act) ||
            (row+1 < rows && col-1 >= 0 && mat->matrix[row+1][col-1] >= act) ||
            (row+1 < rows && col+1 < cols &&
               mat->matrix[row+1][col+1] >= act)   )
      { // Neni spicka, oznacit jako zkontrolovany         
         pom.matrix[row][col] = 1;
      }
      else
      { // Je spicka, pricist, oznacit jako zkontrolovany a oznacit i osmiokoli
         peaks++;   
         pom.matrix[row][col] = 1;                  
 
         // Znaceni tri bodu nad stredem
         if (row-1 >= 0)
         {
            if (col-1 >= 0)
               pom.matrix[row-1][col-1] = 1;               
            if (col+1 < cols)
               pom.matrix[row-1][col+1] = 1;   
 
            pom.matrix[row-1][col] = 1;
         }            
         // Znaceni dvou bodu vedle stredu
         if (col-1 >= 0)
            pom.matrix[row][col-1] = 1;
         if (col+1 < cols)
            pom.matrix[row][col+1] = 1;
         // Znaceni tri bodu pod stredem
         if (row+1 < rows)
         {
            if (col-1 >= 0)
               pom.matrix[row+1][col-1] = 1;
            if (col+1 < cols)
               pom.matrix[row+1][col+1] = 1;
 
            pom.matrix[row+1][col] = 1;
         }             
      }         
   }// for
 
   freeMatrix(&pom);
 
   return peaks;
}