Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

bwlookup

Filtrado no lineal mediante tablas de búsqueda

Sintaxis

J = bwlookup(BW,lut)

Descripción

J = bwlookup(BW,lut) realiza una operación de filtrado de vecindad no lineal de 2 por 2 o 3 por 3 en una imagen binaria o en escala de grises y devuelve los resultados en la imagen de salida.IJ El procesamiento de vecindad determina un valor de índice entero utilizado para tener acceso a los valores de la tabla de búsqueda.lut El valor capturado se convierte en el valor de píxel de la imagen de salida en la posición de destino.lutJ

Opcionalmente, puede realizar el filtrado usar una GPU (requiere ).Parallel Computing Toolbox™

Ejemplos

Realizar la erosión a lo largo de los bordes de la imagen binaria

Construya el vector de forma que la operación de filtrado coloque a en la ubicación de píxel de destino en la imagen de entrada solo cuando los cuatro píxeles de la vecindad 2 por 2 de BW estén establecidos en .lut11

lutfun = @(x)(sum(x(:))==4); lut = makelut(lutfun,2)

lut = 16×1

     0
     0
     0
     0
     0
     0
     0
     0
     0
     0
      ⋮

Cargue una imagen binaria.

BW1 = imread('text.png');

Realice el procesamiento de vecindad de 2 por 2 con vector de 16 elementos.lut

BW2 = bwlookup(BW1,lut);

Mostrar imágenes ampliadas antes y después.

figure;  h1 = subplot(1,2,1); imshow(BW1), axis off; title('Original Image') h2 = subplot(1,2,2); imshow(BW2); axis off; title('Eroded Image') % 16X zoom to see effects of erosion on text set(h1,'Ylim',[1 64],'Xlim',[1 64]); set(h2,'Ylim',[1 64],'Xlim',[1 64]);

Argumentos de entrada

BW — Imagen de entrada

imagen binaria

Imagen de entrada transformada por operación de filtrado de vecindad no lineal, especificada como una imagen binaria. Para la entrada numérica, los píxeles distintos de cero se consideran ( ).1true

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

lut — Tabla de búsqueda de valores de píxeles de salida

Vector de 16 elementos | Vector de 512 elementos

Tabla de búsqueda de valores de píxel de salida, especificada como un vector de 16 o 512 elementos. El tamaño de determina cuál de las dos operaciones de vecindad se realiza.lut

• Si contiene 16 elementos de datos, la matriz de vecindad es 2 por 2.lut

• Si contiene 512 elementos de datos, la matriz de vecindad es 3 por 3.lut

Tipos de datos: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

Argumentos de salida

J — Imagen de salida

imagen binaria | imagen en escala de grises

Imagen de salida, devuelta como una escala de grises o una imagen binaria cuya distribución de los valores de píxel están determinadas por el contenido de la tabla de búsqueda, .lut La imagen de salida tiene el mismo tamaño que la imagen de entrada y el mismo tipo de datos que .JIlut

Algoritmos

El primer paso en cada iteración de la operación de filtrado realizada por implica calcular el vector en función del patrón de píxeles binarios de la matriz de vecindad en la imagen.bwlookupindexlutI El valor en el que se accede a , , se inserta en la imagen de salida en la ubicación del píxel de destino.lutindexlut(index)J Esto hace que la imagen sea el mismo tipo de datos que vector .Jlut

Dado que hay una correspondencia 1 a 1 en ubicaciones de píxeles de destino, la imagen tiene el mismo tamaño que la imagen.JI Si la ubicación del píxel de destino está en un borde de la imagen y si cualquier parte de la matriz de vecindad 2 por 2 o 3 por 3 se extiende más allá del borde de la imagen, estas ubicaciones que no son de imagen se rellenan con 0 para realizar la operación de filtrado.I

Las siguientes figuras muestran la asignación de patrones binarios 0 y 1 en las matrices de vecindad a su representación binaria. Agregar 1 a los rendimientos de representación binaria que se utiliza para acceder a .indexlut

Búsqueda de vecindario de 2 por 2

Para 2 por 2 vecindarios, es 16.length(lut) Hay cuatro píxeles en cada vecindad, y dos estados posibles para cada píxel, por lo que el número total de permutaciones es 2⁴ N.o 16.

Para ilustrar, este ejemplo muestra cómo el patrón de píxeles de una matriz de 2 por 2 determina qué entrada se coloca en la ubicación del píxel de destino.lut

1. Cree un vector aleatorio de 16 elementos que contenga datos.lutuint8

   scurr = rng;    % save current random number generator seed state rng('default') % always generate same set of random numbers lut = uint8( round( 255*rand(16,1) ) ) % generate lut rng(scurr);  % restore

   lut =    208   231    32   233   161    25    71   139   244   246    40   248   244   124   204    36

2. Cree una imagen de 2 por 2 y suponga para este ejemplo que la ubicación del píxel de destino es ubicación.I(1,1)

   I = [1 0; 0 1]

   I =       1     0      0     1

3. Al hacer referencia a la figura de asignación codificada por color anterior, la representación binaria para esta vecindad de 2 por 2 se puede calcular como se muestra en el fragmento de código siguiente. El lógico 1 at corresponde al azul en la figura que se asigna al bit menos significativo (LSB) en la posición 0 en la representación binaria de 4 bits (,2I(1,1)⁰N.o 1). El 1 lógico es rojo que se asigna al bit más significativo (MSB) en la posición 3 en la representación binaria de 4 bits (2I(2,2)³8) .

   % I(1,1): blue square; sets bit position 0 on right  % I(2,2): red  square; sets bit position 3 on left binNot = '1 0 0 1';   % binary representation of 2x2 neighborhood matrix  X = bin2dec( binNot ); % convert from binary to decimal index = X + 1     % add 1 to compute index value for uint8 vector lut A11 = lut(index)    % value at A(1,1)

   index =      10  A11 =    246

4. El cálculo anterior predice que la imagen de salida A debe contener el valor 246 en la posición de destino.A(1,1)

   A = bwlookup(I,lut)   % perform filtering

   A =    246   32   161  231

   de hecho es igual a 246.A(1,1)

Búsqueda de barrio de 3 por 3

Para 3 por 3 vecindarios, es 512.length(lut) Hay nueve píxeles en cada vecindad, y dos estados posibles para cada píxel, por lo que el número total de permutaciones es 2⁹ N.o 512.

El proceso para calcular la representación binaria del procesamiento de vecindad 3 por 3 es el mismo que para 2 por 2 vecindarios.

Capacidades ampliadas

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Usage notes and limitations:

• bwlookup apoya la generación de código C (requiere MATLAB^® Coder™). Tenga en cuenta que si elige la plataforma de destino genérica,MATLAB Host Computer bwlookup genera código que usa una biblioteca compartida precompilada específica de la plataforma. El uso de una biblioteca compartida conserva las optimizaciones de rendimiento, pero limita las plataformas de destino para las que se puede generar código. Para obtener más información, consulte .Generación de código mediante una biblioteca compartida

• Al generar código, especifique una imagen de entrada de clase .logical

Generación de código de GPU

Genere código CUDA® para GPU NVIDIA® mediante GPU Coder™.

Notas de uso y limitaciones:

• Al generar código, especifique una imagen de entrada de clase .logical

Arreglos GPU

Acelere código mediante la ejecución en una unidad de procesamiento gráfico (GPU) mediante Parallel Computing Toolbox™.

Esta función es totalmente compatible con matrices de GPU. Para obtener más información, consulte .Procesamiento de imágenes en una GPU

Consulte también

makelut

Introducido en R2012b

×

Abrir ejemplo

Existe una versión modificada de este ejemplo en su sistema. ¿Prefiere abrir esta versión?

No, sobrescribir la versión modificada Sí