Método de perfil de proyección

En procesamiento de imágenes, el perfil de proyección se refiere a la proyección de la suma de aciertos/positivos a lo largo de un eje de una imagen bidimensional. El método de perfil de proyección se utiliza principalmente para la segmentación de objetos de texto presentes en documentos de texto.

Solución:

Nota : el perfil de proyección se calcula para una imagen con umbral o una imagen binarizada donde una imagen con umbral es una imagen en escala de grises con valores de píxel de 0 o 255. Los píxeles de la imagen se reemplazan por 1 y 0 para valores de píxel de 0 y 255 respectivamente.

El perfil de proyección se calcula por separado para diferentes ejes. El perfil de proyección a lo largo del eje vertical se denomina perfil de proyección vertical. El perfil de proyección vertical se calcula para cada columna como la suma de todos los valores de píxeles de fila dentro de la columna. El perfil de proyección horizontal es el perfil de proyección de una imagen a lo largo del eje horizontal. El perfil de proyección horizontal se calcula para cada fila como la suma de todos los valores de píxeles de columna dentro de la fila.

Implementación de código para perfil de proyección horizontal:

#include <bits/stdc++.h>
using namespace std;
  
// Function to generate horizontal projection profile
vector<int> getHorizontalProjectionProfile(
    vector<vector<int> > image, int rows, int cols)
{
  
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            // Convert black spots to ones
            if (image[i][j] == 0)
            {
                image[i][j] = 1;
            }
            // Convert white spots to zeros
            else if (image[i][j] == 255)
            {
                image[i][j] = 0;
            }
        }
    }
  
    vector<int> horizontal_projection(rows, 0);
  
    // Calculate sum of 1's for every row
    for (int i = 0; i < rows; i++)
    {
        // Sum all 1's
        for (int j = 0; j < cols; j++)
        {
            horizontal_projection[i] += image[i][j];
        }
    }
  
    return horizontal_projection;
}
// Driver Function
int main()
{
    int rows = 5, cols = 3;
    vector<vector<int> > image = { { 0, 0, 0 },
        { 0, 255, 255 },
        { 0, 0, 0 },
        { 0, 255, 255 },
        { 0, 0, 0 }
    };
  
    vector<int> horizontal_projection = getHorizontalProjectionProfile(
                                            image, rows, cols);
  
for (auto it : horizontal_projection)
    {
        cout << it << " ";
    }
    return 0;
}

import numpy as np
  
# Function to generate horizontal projection profile
def getHorizontalProjectionProfile(image):
  
    # Convert black spots to ones
    image[image == 0]   = 1
    # Convert white spots to zeros
    image[image == 255] = 0
  
    horizontal_projection = np.sum(image, axis = 1) 
  
    return horizontal_projection
  
  
# Driver Function
if __name__ == '__main__':
  
    rows = 5
    cols = 3
    image = np.array([[0, 0, 0],
            [0, 255, 255],
            [0, 0, 0],
            [0, 255, 255],
            [0, 0, 0]])
      
    horizontal_projection = getHorizontalProjectionProfile(image.copy())
  
    print(*horizontal_projection)

3 1 3 1 3

Implementación de código para perfil de proyección vertical:

#include <bits/stdc++.h>
using namespace std;
  
// Function to generate vertical projection profile
vector<int> getVerticalProjectionProfile(
    vector<vector<int> > image, int rows, int cols)
{
  
    for (int i = 0; i < rows; i++)
    {
        for (int j = 0; j < cols; j++)
        {
            // Convert black spots to ones
            if (image[i][j] == 0)
            {
                image[i][j] = 1;
            }
            // Convert white spots to zeros
            else if (image[i][j] == 255)
            {
                image[i][j] = 0;
            }
        }
    }
  
    vector<int> vertical_projection(cols, 0);
  
    // Calculate sum of 1's for every column
    for (int j = 0; j < cols; j++)
    {
        // Sum all 1's
        for (int i = 0; i < rows; i++)
        {
            vertical_projection[j] += image[i][j];
        }
    }
  
    return vertical_projection;
}
  
// Driver Function
int main()
{
    int rows = 5, cols = 3;
    vector<vector<int> > image = { { 0, 0, 0 },
        { 0, 255, 255 },
        { 0, 0, 0 },
        { 0, 255, 255 },
        { 0, 0, 0 }
    };
  
    vector<int> vertical_projection = getVerticalProjectionProfile(
                                          image, rows, cols);
  
for (auto it : vertical_projection)
    {
        cout << it << " ";
    }
    return 0;
}

import numpy as np
  
# Function to generate vertical projection profile
def getVerticalProjectionProfile(image):
  
    # Convert black spots to ones 
    image[image == 0]   = 1
    # Convert white spots to zeros 
    image[image == 255] = 0
  
    vertical_projection = np.sum(image, axis = 0)
  
    return vertical_projection
  
# Driver Function
if __name__ == '__main__':
  
    rows = 5
    cols = 3
    image = np.array([[0, 0, 0],
            [0, 255, 255],
            [0, 0, 0],
            [0, 255, 255],
            [0, 0, 0]])
  
    vertical_projection = getVerticalProjectionProfile(image.copy())
  
    print(*vertical_projection)

5 3 3

Complejidad de tiempo : O(filas*columnas)
Complejidad de espacio : O(filas*columnas)