ejercicio de c++ con arrays

[morisco_17]

Hola muy buenas, tengo un problema con el siguiente ejercicio:

Una laboratorio de investigación celular necesita desarrollar un software para la detección de
células madre no embrionarias procedentes de cultivos celulares en placas de Petri. Para ello, el
laboratorio toma imágenes digitales de las placas con objeto de realizar una detección de las células
obtenidas y determinar su número y sus características. Se dispone de imágenes consideradas como
una matriz bidimensional de píxeles cuyo valor numérico indica la intensidad de la correspondiente
región de la foto (0 indica negro, y 255 indica blanco). Una imagen puede tener hasta 512 filas y
hasta 512 columnas.
Para detectar una célula madre se considerará que:
• Una célula madre ocupa región de 2x2 pixels cuyo promedio de intensidad es igual o mayor
de 240.
• La detección de las células madre en la imagen se realiza comenzando por la esquina
superior izquierda y siguiendo un orden de izquierda a derecha y de arriba hacia abajo.
• Un píxel no puede pertenecer a dos células madre distintas. Es decir, una vez que se ha
marcado un píxel como perteneciente a una célula, ya no se tomará en cuenta para la
detección de otras células.
Se pide implementar un programa en C++ para la detección de células madre en una imagen. Debe
diseñarse la función DetectarCelulas que recibe como argumento una imagen y que se
encarga de mostrar por la pantalla:
• La intensidad promedio y posición de la esquina superior izquierda de cada célula detectada.
• El número total de células detectadas.
• La intensidad promedio de todas las células detectadas.


Debe aparecer por pantalla lo siguiente como resultado de la ejecución del programa:
Célula madre en pos (1,2) con promedio de intensidad 242.50
Célula madre en pos (1,4) con promedio de intensidad 246.25
Célula madre en pos (3,3) con promedio de intensidad 240.00
Célula madre en pos (4,6) con promedio de intensidad 250.00
Célula madre en pos (5,1) con promedio de intensidad 240.00
5 células madre con un promedio de de intensidad 243.75

Yo he dividido el programa en 3 partes:

- El algoritmo principal:

Código C++:

#include <iostream>
 
using namespace std;
 
// Constante global, que indica el numero maximo de de filas y de columnas que puede tener el array.
 
const int TAM=512;
 
// Se definen dos arrays con un tamaño de fila y de columna de 512 como maximo. Uno tipo float para almacenar los numeros de la celula, y otro tipo
// bool para almecenar si la casilla está o no ya seleccionada por otra celula.
 
typedef float Timagen[TAM][TAM];
typedef bool Tmarcar[TAM][TAM];
 
struct TCelula {
 
    Tmarcar marcel;
    Timagen imacel;
};
 
bool marcarcelula (TCelula &p);
void DetectarCelulas (TCelula &p);
 
int main() {
 
    int ancho, alto, intensidadmaxima;
    
    Timagen imagen;
 
    cout << "Dime el ancho de la imagen: ";
    cin >> ancho;
 
    if (ancho>TAM) {
        
        cout << "El ancho no puede ser mayor a 512. Vuelva a introducir el ancho: ";
        cin >> ancho;
    }
    
    cout << "Dime el alto de la imagen: ";
    cin >> alto;
 
    if (alto>TAM) {
    
        cout << "El alto de la imagen no puede ser mayor de 512. Vuelva a introducir el alto: ";
        cin >> alto;
    }
 
    intensidadmaxima=255;
 
    for (int j=0; j<alto; j++) {
    
        for (int i=0; i<ancho; i++) {
            
            cout << "Introduce el valor del pixel en la posicion (" << j << "," << i << "): " << endl;
            cin >> imagen[j][i];
            
            if (imagen[j][i] > intensidadmaxima) {
            
                cout << "Introduce el valor del pixel en la posicion (" << j << "," << i << ") dentro del rango: " << endl;
                cin >> imagen[j][i];
            }
            
        }
    }
    ---Aqui irian luego las llamadas a las funciones.
 
    return 0;
}
 

- Un subalgoritmo que busca una celula madre 2x2 con una intensidad promedio de 240 y la marca a true o false. Y aqui es donde tengo el problema: que no se como asociar el valor bool al valor de intensidad para poder operar con el.

Código C++:

bool marcarcelula (TCelula &p) {
 
    bool marca;
 
    marca=false;
    
    float marcado;
 
    for (int y=0; y<TAM; y++) {
    
        for (int x=0; x<TAM; x++) {
 
            while (p.marcel[y][x] = false) {
                
                for (int j=0; j<TAM; j++) {
                    
                    for (int i=0; i<TAM; i++) {
 
                        marcado=p.imacel[j][i]+p.imacel[j][i+1]+p.imacel[j+1][i]+p.imacel[j+1][i+1];
    
                        if (marcado>240) {
    
                            p.marcel[y][x] = true;
                            p.marcel[y][x+1] = true;
                            p.marcel[y+1][x] = true;
                            p.marcel[y+1][x+1] =true;
                        }
                    }
                }
            }
        }
    }
    return marca;
}
 

- Subalgoritmo detectar celula:

Código C++:

void DetectarCelulas (TCelula &p) {
 
 
 
    float intenpro, intentotal, sumaintensidad;
 
    float celdet;
 
    celdet=0;
 
    intentotal=0;
 
    for (int y=0; y<TAM; y++) {
    
        for (int x=0; x<TAM; x++) {
 
            if ((p.marcel[y][x] = true) && (p.marcel[y][x+1] = true) && (p.marcel[y+1][x] = true) && (p.marcel[y+1][x+1] = true)) {
            
                for (int j=0; j<TAM; j++) {
                    
                    for (int i=0; i<TAM; i++) {
 
    
                        intenpro = ((p.imacel[j][i] + p.imacel[j][i+1] + p.imacel[j+1][i] + p.imacel[j+1][i+1])/4);
                
                        cout << "Celula madre en posicion (" << j << "," << i << ") con promedio de intensidad " << intenpro << endl;
 
                        celdet++;
 
                        sumaintensidad=sumaintensidad+intenpro;
                    }
                }
            }
        }
    }
 
    intentotal=sumaintensidad/celdet;
 
    cout << "Se han encontrado " << celdet << " celulas madre, con un promedio de intensidad de " << intentotal << endl;
}
 

Espero que lo hayais entendido, si no es asi decirlo y os lo intentare explicar mejor lo que quiero hacer para ver si me podeis dar una solucion.

Muchas gracias.

[morisco_17]

A nadie se le ocurre como puede resolverse el problema?

[sam90]

Mira yo lo haria con dos for para recorrer de izquierda a derecha y de arriba abajo. Este ultimo seria el primero y el otro estaria adentro. Imaginemos que esas son las coordenadas x , y

for( y = 0 ; y < TAMY - 1 ; y ++)
for( x = 0 ; x < TAMX - 1 ; x ++)

Despues tendria una funcion llamada promedio que devuelve el promedio entre cuatro numeros entonces dentro del For haria:

if (promedio(matriz[y][x] , matriz[y+1][x] , matriz[y][ x + 1] , matriz[y+1][x+1] ) >= 240 )

Ahora dentro de ese if usaria una pila o una lista enlazada para almacenar las celulas. O simplemente un array lo suficientemente grande. Utilizaria una structura para manejar la informacion de manera sencilla:

struct celula {
int x , y:
int promedio;
}
struct celula Lcelula[500];

Dentro del if seria algo asi

Lcelula [i].x = x;
Lcelula [i].y = y;
Lcelula [i].promedio = ....
i++;

Al terminar los dos for tenes un array con las celulas y la variable i te dice la cantidad de celulas.

Esa seria mi idea. Espero que algo te sirva. Cualquier duda comenta.

Para evitar el uso repetido de los pixeles simplemente podes multiplicar la intensidad de cada pixel por -1 para que al probar con el pixel nuevamente el promedio de negativo y escape de esa opciones.
Lo bueno de multiplicar por menos uno es que facilmente podes restaurar la matriz original.

Saludos.

PD: Tenes en cuenta que pasaron 50 minutos desde un mensaje tuyo y el siguiente. Tenes que ser mas paciente.

[reethok]

Veo que ya te respondieron.

Bueno, sólo me gustaría agregar que usé tu ejercicio (adaptado a mis necesidades) para trabajar con pixeles, te dejo el código por si quieres revisarlo. Requiere que haya una imagen llamada "image.png" en la misma carpeta, y crea una imagen llamada "resultado.png", dónde se resaltan las células madres en blanco y el resto se pone de negro.

Código C++:

#include <SFML/Graphics.hpp>
 
#include <string>
using std::string;
 
sf::Image &cargarImagen(const string &filename)
{
    sf::Image img;
    img.LoadFromFile(filename);
    return img;
}
 
void guardarImagen(const sf::Image &imagen, const string &filename)
{
    imagen.SaveToFile(filename);
}
 
 
void procesarImagen(const sf::Image &imagen)
{
    sf::Image resultado;
    sf::Color blanco(255, 255, 255);
    int x = imagen.GetWidth();
    int y = imagen.GetHeight();
    short arreglo[2000][2000] = {0};
 
    resultado.Create(imagen.GetWidth(), imagen.GetHeight(), sf::Color(0, 0, 0, 255));
 
    for(int i = 1; i < x-1; i++)
    {
        for(int j = 1; j < y-1; j++)
        {
            if(arreglo[i][j] == 0 && arreglo[i][j+1] == 0 && arreglo[i+1][j] == 0
                && arreglo[i+1][j+1] == 0)
            {
                sf::Color a1 = imagen.GetPixel(i, j);
                sf::Color a2 = imagen.GetPixel(i, j+1);
                sf::Color a3 = imagen.GetPixel(i+1, j);
                sf::Color a4 = imagen.GetPixel(i+1, j+1);
 
                    // saturación de colores,
                    // Negro = 0, 0, 0, por ende,
                    // 240 de tu ejercicio = 15 en pixeles
                    // y 15 * 3 colores * 4 pixeles = 180
                if((a1.r + a1.g + a1.b + a2.r + a2.g + a2.b +
                    a3.r + a3.g + a3.b + a4.r + a4.g + a4.b <= 180)) 
 
                {
                    arreglo[i][j] = arreglo[i][j+1] = arreglo[i+1][j] = arreglo[i+1][j+1] = 1;
                    resultado.SetPixel(i, j, blanco);
                    resultado.SetPixel(i, j+1, blanco);
                    resultado.SetPixel(i+1, j, blanco);
                    resultado.SetPixel(i+1, j+1, blanco);
                }
            }
        }
    }
 
    resultado.SaveToFile("resultado.png");
}
 
int main()
{
    sf::Image imagen;
 
    imagen.LoadFromFile("image.png");
    procesarImagen(imagen);
    return 0;
}