(Procesamiento de imágenes digitales MATLAB+Python) Capítulo 11 Descripción y análisis de imágenes - Secciones 7 y 8: Descripción de texturas y otras descripciones

1: descripción de la textura

Descripción de textura : es una técnica utilizada para describir la apariencia de la superficie de un modelo 3D. Mapea imágenes o patrones bidimensionales en la superficie de un modelo tridimensional aplicando mapeo de texturas para darle al modelo una apariencia más realista y rica. Las descripciones de texturas pueden contener una variedad de información, como color, iluminación, reflejos, transparencia, etc. Al definir las coordenadas de textura en los vértices o polígonos del modelo y asignar la textura a la posición correspondiente, el modelo puede mostrar el efecto de la textura durante el proceso de renderizado. Los formatos comunes de descripción de texturas incluyen:

• Textura de mapa de bits : utilizando formatos de archivos de imagen comunes (como JPEG, PNG, etc.) como texturas, puede obtener directamente fotografías o imágenes del mundo real.
• Textura vectorial : textura descrita mediante gráficos vectoriales, que se pueden escalar y editar sin pérdidas, adecuada para situaciones en las que es necesario mantener una buena claridad.
• Mapa normal : al modificar las normales de la superficie del modelo, simula el efecto de la estructura microcóncava-convexa en la superficie del objeto para mejorar el detalle del modelo.
• Mapa de relieve : simula el efecto de la estructura irregular en la superficie de un objeto cambiando la dirección normal de la superficie del modelo.
• Mapa de entorno : se utiliza para simular los efectos de reflexión y refracción del entorno alrededor de un objeto para aumentar el realismo del modelo.

(1) Método de matriz de probabilidad conjunta

Una definicion

Método matricial de probabilidad conjunta : es un método estadístico utilizado para el análisis de datos y el reconocimiento de patrones . Se utiliza principalmente para analizar la distribución de probabilidad conjunta entre múltiples variables y describir la relación entre estas variables mediante la construcción de una matriz de probabilidad conjunta . Este método se basa en la idea de distribución de probabilidad conjunta y convierte datos multidimensionales en una matriz bidimensional. Cada elemento de la matriz representa el valor de probabilidad conjunta de la variable correspondiente. Al observar y analizar esta matriz, se puede revelar información como correlaciones, dependencias y patrones entre diferentes variables. Los pasos específicos son los siguientes

• Recopile datos de muestra : primero, debe recopilar un conjunto de datos de muestra que contenga múltiples variables, como datos de observación o datos experimentales.
• Construya una matriz de probabilidad conjunta : con base en los datos de la muestra, calcule la matriz de probabilidad conjunta entre cada variable. Las filas y columnas de la matriz representan diferentes variables respectivamente, y cada elemento de la matriz representa la probabilidad conjunta de la combinación de valor de variable correspondiente.
• Analice la matriz : al observar y analizar la matriz de probabilidad conjunta, puede descubrir información como patrones, correlaciones y dependencias. Se pueden utilizar indicadores estadísticos, herramientas de visualización u otros métodos analíticos para interpretar mejor la matriz.

Específicamente, toma el punto medio de la imagen $(x,y)$ y otro punto que se desvía de él$(x+\nabla x,y+\nabla y)$ , sea el valor de gris de este par de puntos$(f_{},F_{})$，令点$(x,y)$ se mueve por toda la pantalla para obtener varios$(f_{},F_{})$ valor. Deje que el nivel de valor de gris sea$L$ , entonces$F_{}$con $F_{}$Hay un total de combinaciones $l^2$ tipos. Para toda la pantalla, cuente cada valor$(f_{},F_{}),$ luego organícelo en una matriz cuadrada y luego use$(f_{},F_{})$ , normalízalos a la probabilidad de ocurrencia$pag(f_{},F_{})$ , la matriz cuadrada se llama matriz de probabilidad conjunta

B: Características basadas en matriz de probabilidad conjunta

Segundo momento del ángulo :

$$unSM=\underset{F_{}}{}\underset{F_{}}{}{\left[pag.\left(f_{},F_{}\right)\right]}^2$$

Coeficiente de correlación :

$$\begin{array}{c}COR=\frac{{\sum }_{F_{}}{\sum }_{F_{}}\left(f_{}-metro{\_}_{F_{}}\right)\left(f_{}-metro{\_}_{F_{}}\right)pag(f_{},f_{}}{{pag}_{F_{}}{pag}_{F_{}}}\\ {metro}_{F_{}}={\sum }_{F_{}}{F}_{}{\sum }_{F_{}}pag\left(f_{},F_{}\right){metro}_{F_{}}={\sum }_{F_{}}{F}_{}{\sum }_{F_{}}pag\left(f_{},F_{}\right)\\ {pag}_{F_{}}^{}={\sum }_{F_{}}{\left(f_{}-{metro}_{F_{}}\right)}^2{\sum }_{F_{}}pag\left(f_{},F_{}\right){pag}_{F_{}}^{}={\sum }_{F_{}}{\left(f_{}-{metro}_{F_{}}\right)}^2{\sum }_{F_{}}pag(f_{},F_{}\end{array}$$

Contraste :

$$ESTAFA=\underset{k}{}{k}^2\left[\underset{\begin{array}{c}{F}_{}\\ F_{}\\ k\in |F_{}-f_{}\end{array}}{}pag\left(f_{},F_{}\right)\right]$$

Momento diferencial recíproco :

$$YODM=\underset{F_{}}{}\underset{F_{}}{}\frac{pag(f_{},F_{}}{1+|f{\_}_{}-F_{}|}$$

Entropía :

$$otorrinolaringólogo=-\underset{F_{}}{}\underset{F_{}}{}pag\left(f_{},F_{}\right){iniciarsesión}_{}pag\left(f_{},F_{}\right)$$

c: programa

De la siguiente manera, abra una imagen en escala de grises, genere una matriz de probabilidad conjunta y calcule los parámetros. Se puede encontrar que después del suavizado, el contraste de la imagen se reduce, la autocorrelación aumenta y el momento angular de segundo orden y el momento de diferencia recíproca aumentan.

---

matlab :

clear,clc,close all;
Iorigin=imread('morphplane.jpg');
Iorigin=255-Iorigin;
Irotate=imrotate(Iorigin,15,'bilinear');
Iresize=imresize(Iorigin,0.4,'bilinear');
Imirror=fliplr(Iorigin);

bwo=im2bw(Iorigin);
bwr=im2bw(Irotate);
bws=im2bw(Iresize);
bwm=im2bw(Imirror);

huo=invmoments(bwo);
hur=invmoments(bwr);
hus=invmoments(bws);
hum=invmoments(bwm);   

    
function Hu=invmoments(bw)
[N,M]=size(bw);
M00=0;
M10=0;
M01=0;
for x=1:M
    for y=1:N
        M00=M00+bw(y,x);
        M10=M10+x*bw(y,x);
        M01=M01+y*bw(y,x);
    end
end
centerx=M10/M00;
centery=M01/M00;
u02=0;u20=0;u11=0;u21=0;u12=0;u30=0;u03=0;
for x=1:M
    for y=1:N
        u20=u20+bw(y,x)*(x-centerx)^2;
        u02=u02+bw(y,x)*(y-centery)^2;
        u11=u11+bw(y,x)*(x-centerx)*(y-centery);
        u30=u30+bw(y,x)*(x-centerx)^3;
        u03=u03+bw(y,x)*(y-centery)^3;
        u21=u21+bw(y,x)*(x-centerx)^2*(y-centery);
        u12=u12+bw(y,x)*(y-centery)^2*(x-centerx);
    end
end
n20=u20/(M00^2);n02=u02/(M00^2);n11=u11/(M00^2);
n21=u21/(M00^2.5);n12=u12/(M00^2.5);
n03=u03/(M00^2.5);n30=u30/(M00^2.5);
Hu(1)=n20+n02;
Hu(2)=(n20-n02)^2+4*n11^2;
Hu(3)=(n30-3*n12)^2+(3*n21-n03)^2;
Hu(4)=(n30+n12)^2+(n21+n03)^2;
Hu(5)=(n30-3*n12)*(n30+n12)*((n30+n12)^2-3*(n21+n03)^2)...
    +(3*n21-n03)*(n21+n03)*(3*(n30+n12)^2-(n21+n03)^2);
Hu(6)=(n20-n02)*((n03+n12)^2-(n21+n03)^2)+4*n11*(n30+n12)*(n21+n03);
Hu(7)=(3*n21-n03)*(n30+n12)*((n30+n12)^2-3*(n21+n03)^2)...
    -(n30-3*n12)*(n21+n03)*(3*(n30+n12)^2-(n21+n03)^2);
end

pitón :

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

def invmoments(bw):
    N, M = bw.shape
    M00 = np.sum(bw)
    M10 = np.sum(np.multiply(np.arange(M), bw))
    M01 = np.sum(np.multiply(np.arange(N).reshape(N, 1), bw))

    centerx = M10 / M00
    centery = M01 / M00

    u02 = 0
    u20 = 0
    u11 = 0
    u21 = 0
    u12 = 0
    u30 = 0
    u03 = 0

    for x in range(M):
        for y in range(N):
            u20 += bw[y, x] * (x - centerx) ** 2
            u02 += bw[y, x] * (y - centery) ** 2
            u11 += bw[y, x] * (x - centerx) * (y - centery)
            u30 += bw[y, x] * (x - centerx) ** 3
            u03 += bw[y, x] * (y - centery) ** 3
            u21 += bw[y, x] * (x - centerx) ** 2 * (y - centery)
            u12 += bw[y, x] * (y - centery) ** 2 * (x - centerx)

    n20 = u20 / (M00 ** 2)
    n02 = u02 / (M00 ** 2)
    n11 = u11 / (M00 ** 2)
    n21 = u21 / (M00 ** 2.5)
    n12 = u12 / (M00 ** 2.5)
    n03 = u03 / (M00 ** 2.5)
    n30 = u30 / (M00 ** 2.5)

    Hu = np.zeros(7)
    Hu[0] = n20 + n02
    Hu[1] = (n20 - n02) ** 2 + 4 * n11 ** 2
    Hu[2] = (n30 - 3 * n12) ** 2 + (3 * n21 - n03) ** 2
    Hu[3] = (n30 + n12) ** 2 + (n21 + n03) ** 2
    Hu[4] = (n30 - 3 * n12) * (n30 + n12) * ((n30 + n12) ** 2 - 3 * (n21 + n03) ** 2) + \
            (3 * n21 - n03) * (n21 + n03) * (3 * (n30 + n12) ** 2 - (n21 + n03) ** 2)
    Hu[5] = (n20 - n02) * ((n03 + n12) ** 2 - (n21 + n03) ** 2) + \
            4 * n11 * (n30 + n12) * (n21 + n03)
    Hu[6] = (3 * n21 - n03) * (n30 + n12) * ((n30 + n12) ** 2 - 3 * (n21 + n03) ** 2) - \
            (n30 - 3 * n12) * (n21 + n03) * (3 * (n30 + n12) ** 2 - (n21 + n03) ** 2)

    return Hu

Iorigin = np.array(Image.open('morphplane.jpg').convert('L'))
Iorigin = 255 - Iorigin
Irotate = Image.fromarray(Iorigin).rotate(15, resample=Image.BILINEAR)
Iresize = Image.fromarray(Iorigin).resize((int(Iorigin.shape[1] * 0.4), int(Iorigin.shape[0] * 0.4)),
                                         resample=Image.BILINEAR)
Imirror = np.fliplr(Iorigin)

bwo = np.array(Image.fromarray(Iorigin).convert('1'))
bwr = np.array(Irotate.convert('1'))
bws = np.array(Iresize.convert('1'))
bwm = np.array(Image.fromarray(Imirror).convert('1'))

huo = invmoments(bwo)
hur = invmoments(bwr)
hus = invmoments(bws)
hum = invmoments(bwm)

plt.figure(figsize=(12, 4))

plt.subplot(141)
plt.imshow(Iorigin, cmap='gray')
plt.title('Original)

(2) Método estadístico de diferencia en escala de grises

Una definicion

Método estadístico de diferencia de escala de grises : es un método utilizado para el análisis de textura de la imagen y describe las características de textura de la imagen calculando la diferencia de escala de grises entre los píxeles de la imagen. Este método se utiliza ampliamente en campos como el procesamiento de imágenes, la clasificación de imágenes y el reconocimiento de objetivos. Los pasos específicos son los siguientes

• Determine el tamaño de la ventana : Primero, debe determinar el tamaño de la ventana. El tamaño de la ventana afectará la precisión y la cantidad de cálculo de los resultados del cálculo.
• Calcule la matriz de diferencia de escala de grises : para cada píxel de la imagen, calcule la diferencia entre él y los píxeles vecinos en función del valor de escala de grises de los píxeles de la ventana circundante. Los métodos diferenciales comúnmente utilizados incluyen diferencial horizontal, diferencial vertical, diferencial diagonal, etc.
• Matriz estadística de diferencia en escala de grises : cuente la frecuencia o probabilidad de cada valor de diferencia en escala de grises en la matriz de diferencia en escala de grises y obtenga el histograma estadístico de diferencia en escala de grises
• Extraer características de textura : según el histograma estadístico de diferencia en escala de grises, se puede extraer una serie de características de textura, como media, varianza, energía, contraste, correlación, etc.
• Clasificación y reconocimiento : utilice características de textura extraídas para tareas de clasificación y reconocimiento. Los métodos comunes incluyen máquina de vectores de soporte (SVM), red neuronal artificial (ANN), etc.

B: Parámetros que describen las características de la imagen.

Contraste :

$$ESTAFA=\underset{i}{}{i}^{2p}{\_}_{}\left(yo\right)$$

Segundo momento en dirección angular :

$$unSM=\sum {\left[{pag.}_{}\left(yo\right)\right]}^2$$

Entropía :

$$otorrinolaringólogo=-\underset{i}{}{pag}_{}\left(yo\right)lg{pag}_{}\left(yo\right)$$

Promedio :

$$YOAN=\frac{}{metro}\underset{i}{}yo{p}_{}\left(yo\right)$$

(3) Método estadístico de longitud de carrera

Una definicion

Método estadístico de longitud de ejecución : es un algoritmo de compresión de datos sin pérdidas de uso común y también se puede utilizar para el análisis de características de textura en el procesamiento de imágenes. En las estadísticas de longitud de ejecución, se codifican secuencias consecutivas de valores de píxeles idénticos para reducir el espacio de almacenamiento de datos o el ancho de banda de transmisión. Los pasos específicos son los siguientes

• Escaneo de datos : escanee la imagen línea por línea o columna por columna y registre la ubicación de cada cambio en el valor de píxel.
• Codificación de longitud de ejecución : Codifique una secuencia continua de valores de píxeles de acuerdo con la posición donde cambia el valor de píxel y registre la posición inicial y la longitud de cada secuencia continua.
• Almacenamiento de resultados de codificación : los resultados de codificación se almacenan en un formato determinado, generalmente utilizando una matriz o lista bidimensional para guardar la posición inicial y la longitud de cada secuencia continua.
• Proceso de decodificación : decodifica según el resultado de la codificación y restaura la imagen original reconstruyendo una secuencia continua de valores de píxeles.

Por ejemplo, en la siguiente figura, 4 niveles de gris, para 2 direcciones (0°, 45°), definen la matriz de longitud de trazo correspondiente ${METRO}_{rl}$

B: Funciones que utilizan longitud de ejecución en escala de grises

Compensación de carrera corta :

$$SER=\frac{{\sum }_{}{\sum }_{}(\frac{{METRO}_{rl}(f,n}{{norte}^2}}{{\sum }_{}{\sum }_{}{METRO}_{rl}(f,norte)}$$

Compensación de carrera larga :

$$LRE=\frac{{\sum }_{}{\sum }_{}\left(M_{rl}\right(f,norte){norte}^2}{{\sum }_{}{\sum }_{}{METRO}_{rl}(f,norte)}$$

Falta de uniformidad del nivel de grises :

$$GLD\_\_=\frac{{\sum }_{}{\left[{\sum }_{}\left(M_{rl}(f,norte)\right)\right]}^{}}{{\sum }_{}{\sum }_{}{METRO}_{rl}(f,norte)}$$

No uniformidad en la longitud del trazo :

$$RLD\_\_=\frac{{\sum }_{}{\left[{\sum }_{}\left(M_{rl}(f,norte)\right)\right]}^{}}{{\sum }_{}{\sum }_{}{METRO}_{rl}(f,norte)}$$

Porcentaje de viaje :

$$PR=\frac{{\sum }_{}{\sum }_{}{METRO}_{rl}(f,norte}{norte}$$

c: programa

A continuación, programa para calcular la matriz de longitud de viaje en dirección de 45° y los parámetros de la imagen de la corteza.

---

matlab :

% f=[0 1 2 3 0 1 2;1 2 3 0 1 2 3;2 3 0 1 2 3 0;3 0 1 2 3 0 1;0 1 2 3 0 1 2;1 2 3 0 1 2 3;2 3 0 1 2 3 0];
% f=[0 1 2 3 0 1 2;1 2 3 0 1 2 3;2 3 0 1 2 3 0;3 0 1 2 3 0 1];
% f=[0 1 2 3; 1 2 3 0 ;2 3 0 1 ;3 0 1 2;0 1 2 3;1 2 3 0;2 3 0 1];
f=rgb2gray(imread('texture1.bmp'));
% f=rgb2gray(imread('smoothtexture.jpg'));
f=f+1;
top=max(f(:));
[h,w]=size(f);
N=min(h,w);
MRL=zeros(top,N);
length=1;
for x=1:w
    newx=x;
    newy=1;
    for y=1:min(h,x)
        oldx=newx;
        oldy=newy;
        newx=newx-1;
        newy=y+1;
        if newx>0 && newy<=h && f(newy,newx)==f(oldy,oldx)
            length=length+1;
        else
            MRL(f(oldy,oldx),length)=MRL(f(oldy,oldx),length)+1;
            length=1;
        end
    end
end
for y=2:h
    newx=w;
    newy=y;
    for x=w:-1:1
        oldx=newx;
        oldy=newy;
        newx=x-1;
        newy=oldy+1;
        if newx>0 && newy<=h && f(newy,newx)==f(oldy,oldx)
            length=length+1;
        else
            MRL(f(oldy,oldx),length)=MRL(f(oldy,oldx),length)+1;
            length=1;
            break;
        end
    end
end
SRE=0;LRE=0;GLD=0;RLD=0;RP=0;total=0;GLDp=0;
for n=1:N
    RLDp=0;    
    for f=1:top
        if MRL(f,n)~=0
            total=total+MRL(f,n);
            SRE=SRE+MRL(f,n)/(n^2);
            LRE=LRE+MRL(f,n)*(n^2);
            RLDp=RLDp+MRL(f,n);
            RP=RP+MRL(f,n);
        end
    end
    RLD=RLD+RLDp^2;
end
for f=1:top
    GLDp=0;
    for n=1:N
        if MRL(f,n)~=0
            GLDp=GLDp+MRL(f,n);
        end
    end
    GLD=GLD+GLDp^2;
end
SRE=SRE/total;
LRE=LRE/total;
RLD=RLD/total;
RP=RP/(h*w);
GLD=GLD/total;

pitón :

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

# 读取图像
image = Image.open('morphplane.jpg')
Iorigin = np.array(image)

# 转换为灰度图像
f = np.array(image.convert('L'))

f = f + 1
top = np.max(f)
h, w = f.shape
N = min(h, w)
MRL = np.zeros((top, N))
length = 1

for x in range(w):
    newx = x
    newy = 0
    for y in range(min(h, x+1)):
        oldx = newx
        oldy = newy
        newx -= 1
        newy += 1
        if newx >= 0 and newy < h and f[newy, newx] == f[oldy, oldx]:
            length += 1
        else:
            MRL[f[oldy, oldx], length] += 1
            length = 1

for y in range(1, h):
    newx = w
    newy = y
    for x in range(w-1, -1, -1):
        oldx = newx
        oldy = newy
        newx -= 1
        newy += 1
        if newx >= 0 and newy < h and f[newy, newx] == f[oldy, oldx]:
            length += 1
        else:
            MRL[f[oldy, oldx], length] += 1
            length = 1
            break

SRE = 0
LRE = 0
GLD = 0
RLD = 0
RP = 0
total = 0
GLDp = 0

for n in range(N):
    RLDp = 0
    for i in range(1, top+1):
        if MRL[i, n] != 0:
            total += MRL[i, n]
            SRE += MRL[i, n] / (n**2)
            LRE += MRL[i, n] * (n**2)
            RLDp += MRL[i, n]
            RP += MRL[i, n]
    RLD += RLDp**2

for i in range(1, top+1):
    GLDp = 0
    for n in range(N):
        if MRL[i, n] != 0:
            GLDp += MRL[i, n]
    GLD += GLDp**2

SRE /= total
LRE /= total
RLD /= total
RP /= (h * w)
GLD /= total

# 图像展示部分
plt.subplot(121)
plt.imshow(Iorigin)
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(f, cmap='gray')
plt.title('Grayscale Image')
plt.axis('off')

plt.show()

(4) Características del dolor lumbar

Una definicion

Característica LBP : es un método utilizado para la descripción de la textura de la imagen y la extracción de características. Define una vecindad local en cada píxel de la imagen , compara los píxeles de la vecindad con el píxel central y genera un código binario basado en el resultado de la comparación. La función LBP puede capturar la frecuencia y distribución de diferentes patrones de textura en la imagen. Los pasos de cálculo son los siguientes.

• Seleccione un píxel como píxel central
• Determine un área vecina centrada en el píxel central, generalmente un área cuadrada o circular centrada en el píxel central
• Compare el valor de gris de cada píxel vecino con el píxel central. Si el valor del píxel es mayor o igual que el valor de gris del píxel central, la posición se marca como 1; de lo contrario, se marca como 0.
• Convierta la codificación binaria a un número decimal para obtener el valor LBP del píxel central
• Repita los pasos 1 a 4 en cada píxel de la imagen para calcular las características LBP de toda la imagen.

Mediante la extracción de características de LBP, podemos obtener la siguiente información.

• Modo de textura : las funciones de LBP pueden describir diferentes modos de textura en la imagen, como suave, rugosa, delicada, etc.
• Estructura de textura : las características de LBP pueden reflejar la distribución y disposición de las texturas en la imagen, como cuadrícula, mancha, etc.
• Estadísticas de textura : al contar la frecuencia y distribución de los valores LBP en toda la imagen o área local, se pueden obtener algunas estadísticas de textura, como histograma, media, varianza, etc.

La función LBP tiene las siguientes ventajas

• Simple y efectivo : el cálculo de las características de LBP es simple y rápido, y tiene una gran solidez ante los cambios de iluminación y el ruido de la imagen.
• No depende de la información de color : las características LBP se calculan utilizando únicamente valores de escala de grises, no se ven afectadas por los cambios de color y son adecuadas tanto para imágenes en color como en escala de grises.
• Ampliamente aplicable : las funciones LBP se pueden utilizar en diversos campos de aplicación, como clasificación de imágenes, reconocimiento de texturas, reconocimiento facial, detección de peatones, etc.

B: Programa

De la siguiente manera, calcule el mapa de características LBP de la imagen a continuación

---

matlab :

clear,clc,close all;
image=imread('lena.bmp');
[N,M]=size(image);
lbp=zeros(N,M);
for j=2:N-1
    for i=2:M-1
        neighbor=[j-1 i-1;j-1 i;j-1 i+1;j i+1;j+1 i+1;j+1 i;j+1 i-1;j i-1];
        count=0;
        for k=1:8
            if image(neighbor(k,1),neighbor(k,2))>image(j,i)
                count=count+2^(8-k);
            end
        end
        lbp(j,i)=count;
    end
end
lbp=uint8(lbp);
figure,imshow(lbp),title('LBP特征图');
% imwrite(lbp,'lenalbp.jpg');
subim=lbp(1:8,1:8);
imhist(subim),title('第一个子区域直方图');
                

pitón :

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取图像
image = cv2.imread('lena.bmp', 0)

N, M = image.shape
lbp = np.zeros((N, M), dtype=np.uint8)

for j in range(1, N-1):
    for i in range(1, M-1):
        neighbor = [
            [j-1, i-1], [j-1, i], [j-1, i+1],
            [j, i+1], [j+1, i+1], [j+1, i],
            [j+1, i-1], [j, i-1]
        ]
        count = 0
        for k in range(8):
            if image[neighbor[k][0], neighbor[k][1]] > image[j, i]:
                count += 2 ** (7 - k)
        lbp[j, i] = count

plt.imshow(lbp, cmap='gray')
plt.title('LBP特征图')
plt.axis('off')
plt.show()

subim = lbp[:8, :8]
plt.hist(subim.flatten(), bins=256, range=[0, 256])
plt.title('第一个子区域直方图')
plt.show()

2: Otras descripciones

(1) Histograma de dirección del gradiente

Una definicion

Histograma de línea de gradiente : es un método para la descripción de características de la imagen, que se utiliza principalmente en tareas de visión por computadora, como clasificación de imágenes, reconocimiento de objetos y detección de objetivos. Calcula la dirección del gradiente de cada píxel de la imagen, cuenta la distribución de la dirección del gradiente y construye un histograma para representar las características de la imagen. Los pasos de cálculo son los siguientes.

• Convierta la imagen a escala de grises si no es escala de grises
• Suaviza la imagen, como por ejemplo usando un filtro gaussiano, para reducir el impacto del ruido.
• Calcule el gradiente horizontal (dirección x) y vertical (dirección y) de cada píxel. Se pueden utilizar operadores como Sobel y Prewitt para el cálculo del gradiente.
• Para cada píxel, calcule la magnitud y la dirección del gradiente en función de sus gradientes horizontales y verticales.
• Divida la imagen en varias áreas o bloques y realice estadísticas sobre la dirección del gradiente de los píxeles en cada área.
• Construya un histograma de dirección de gradiente basado en los resultados estadísticos. Generalmente, el espacio de dirección del gradiente se divide en varios rangos de ángulos fijos, por ejemplo, 0°~180° se divide en 8 intervalos.
• El número de direcciones del gradiente en cada área se utiliza como valor del histograma para obtener el histograma de dirección del gradiente final.

El histograma de dirección del degradado puede extraer información de bordes y texturas en la imagen, y codificar y representar esta información. Al contar la distribución de diferentes direcciones de gradiente, se pueden describir las características de estructura y textura de la imagen. En las tareas de clasificación de imágenes y reconocimiento de objetos, los histogramas de dirección del gradiente generalmente se usan como características de la imagen, y luego se usan algoritmos de aprendizaje automático para el entrenamiento y la clasificación. Tiene las siguientes ventajas

• No se ve afectado por los cambios de iluminación: el histograma de dirección del gradiente solo se basa en la información del gradiente del píxel y no se ve afectado por los cambios de iluminación.
• Sensible a los cambios locales: el histograma de dirección del gradiente cuenta la distribución de la dirección del gradiente en un área local, por lo que es muy sensible a la detección de características de textura locales.
• Dimensiones de características controlables: al ajustar el número de intervalos que dividen el espacio de dirección del gradiente, las dimensiones de las características del histograma de dirección del gradiente se pueden controlar para adaptarse a las necesidades de diferentes tareas.

B: Programa

A continuación, las características HOG de la imagen estadística.

---

matlab :

clear,clc,close all;
Image=double(imread('lena.bmp'));
[N,M]=size(Image);
Image=sqrt(Image);
Hy=[-1 0 1];       
Hx=Hy';            
Gy=imfilter(Image,Hy,'replicate');    
Gx=imfilter(Image,Hx,'replicate');   
Grad=sqrt(Gx.^2+Gy.^2);             
Phase=zeros(N,M);   
Eps=0.0001;
for i=1:M
     for j=1:N 
         if abs(Gx(j,i))<Eps && abs(Gy(j,i))<Eps  
             Phase(j,i)=270;
         elseif abs(Gx(j,i))<Eps && abs(Gy(j,i))>Eps 
             Phase(j,i)=90;
         else
             Phase(j,i)=atan(Gy(j,i)/Gx(j,i))*180/pi; 
             if Phase(j,i)<0                                        
                 Phase(j,i)=Phase(j,i)+180; 
             end             
         end
     end
end
step=8;               
K=9;               
angle=180/K;       
Cell=cell(1,1);              
Celli=1;                      
Cellj=1;
for i=1:step:M         
    Cellj=1;
    for j=1:step:N     
        Gtmp=Grad(j:j+step-1,i:i+step-1);
        Gtmp=Gtmp/sum(sum(Gtmp));       
        Hist=zeros(1,K);              
        for x=1:step
            for y=1:step
                ang=Phase(j+y-1,i+x-1); 
                if ang<=180
                    Hist(floor(ang/angle)+1)=Hist(floor(ang/angle)+1)+Gtmp(y,x);   
                end
            end
        end
        Cell{
    
    Cellj,Celli}=Hist;      
        Cellj=Cellj+1;               
    end
    Celli=Celli+1;                   
end

[CellN,CellM]=size(Cell);
feature=cell(1,(CellM-1)*(CellN-1));
for i=1:CellM-1
   for j=1:CellN-1           
        f=[];
        f=[f Cell{
    
    j,i}(:)' Cell{j,i+1}(:)' Cell{
    
    j+1,i}(:)' Cell{j+1,i+1}(:)'];
        f=f./sum(f);
        feature{
    
    (i-1)*(CellN-1)+j}=f;
   end
end

pitón :

clear,clc,close all;
Image=double(imread('lena.bmp'));
[N,M]=size(Image);
Image=sqrt(Image);
Hy=[-1 0 1];       
Hx=Hy';            
Gy=imfilter(Image,Hy,'replicate');    
Gx=imfilter(Image,Hx,'replicate');   
Grad=sqrt(Gx.^2+Gy.^2);             
Phase=zeros(N,M);   
Eps=0.0001;
for i=1:M
     for j=1:N 
         if abs(Gx(j,i))<Eps && abs(Gy(j,i))<Eps  
             Phase(j,i)=270;
         elseif abs(Gx(j,i))<Eps && abs(Gy(j,i))>Eps 
             Phase(j,i)=90;
         else
             Phase(j,i)=atan(Gy(j,i)/Gx(j,i))*180/pi; 
             if Phase(j,i)<0                                        
                 Phase(j,i)=Phase(j,i)+180; 
             end             
         end
     end
end
step=8;               
K=9;               
angle=180/K;       
Cell=cell(1,1);              
Celli=1;                      
Cellj=1;
for i=1:step:M         
    Cellj=1;
    for j=1:step:N     
        Gtmp=Grad(j:j+step-1,i:i+step-1);
        Gtmp=Gtmp/sum(sum(Gtmp));       
        Hist=zeros(1,K);              
        for x=1:step
            for y=1:step
                ang=Phase(j+y-1,i+x-1); 
                if ang<=180
                    Hist(floor(ang/angle)+1)=Hist(floor(ang/angle)+1)+Gtmp(y,x);   
                end
            end
        end
        Cell{
    
    Cellj,Celli}=Hist;      
        Cellj=Cellj+1;               
    end
    Celli=Celli+1;                   
end

[CellN,CellM]=size(Cell);
feature=cell(1,(CellM-1)*(CellN-1));
for i=1:CellM-1
   for j=1:CellN-1           
        f=[];
        f=[f Cell{
    
    j,i}(:)' Cell{j,i+1}(:)' Cell{
    
    j+1,i}(:)' Cell{j+1,i+1}(:)'];
        f=f./sum(f);
        feature{
    
    (i-1)*(CellN-1)+j}=f;
   end
end

(2) Características similares a las de Haar

Una definicion

Característica similar a Haar : es un método de descripción de características utilizado para la clasificación de imágenes y la detección de objetivos . Se propuso por primera vez en el algoritmo de detección de rostros de Viola-Jones y se ha utilizado ampliamente. Se basa en la diferencia del valor de gris de la imagen para representar las características del área de la imagen local. Los pasos de cálculo son los siguientes.

• Plantilla que define un rectángulo que puede ser un área contigua en sentido horizontal, vertical o diagonal.
• La plantilla se coloca en diferentes posiciones y escalas de la imagen, y se calcula la diferencia en los valores de escala de grises de las áreas blanca (resaltada) y negra (sombra) dentro de la plantilla.
• Calcule valores propios basados ​​​​en diferencias de valores de gris. Las características comunes similares a las de Haar incluyen: la diferencia entre dos rectángulos adyacentes, la suma de tres rectángulos adyacentes, etc.

La idea principal de las características similares a Haar es capturar la textura local y la información de los bordes en la imagen calculando la diferencia en el valor de gris de diferentes áreas rectangulares. Específicamente, la diferencia en el valor de gris entre áreas brillantes y oscuras se puede usar para representar bordes en la imagen, mientras que la diferencia en el valor de gris entre áreas adyacentes se puede usar para representar la textura en la imagen. Sus ventajas son las siguientes.

• Simple : el cálculo de funciones similar a Haar es simple y eficiente, adecuado para aplicaciones en tiempo real.
• Invariancia de traducción : las características similares a Haar son invariantes a la traducción de la imagen, es decir, la característica puede detectar el mismo patrón en cualquier posición de la imagen.
• Adaptabilidad a múltiples escalas : las funciones similares a Haar pueden adaptarse a objetivos de diferentes tamaños cambiando el tamaño de la plantilla.

Sus desventajas son las siguientes.

• Limitaciones : Las características similares a Haar son principalmente adecuadas para describir características visuales de bajo nivel, como bordes y texturas, y son difíciles de representar de manera efectiva formas y estructuras de texturas complejas.
• Pobre invariancia : las características similares a Haar tienen poca invariancia ante factores como la iluminación, la rotación y los cambios de escala.

B: Programa

como sigue

---

matlab :

clear,clc,close all;
Image=double(imread('carphone.jpg'));
[N,M]=size(Image);
win=24;

pitón :

import cv2
import matplotlib.pyplot as plt

# Read image
image = cv2.imread('carphone.jpg', cv2.IMREAD_GRAYSCALE)
image = image.astype(float)

# Get image size
N, M = image.shape

# Define window size
win = 24

# Display image
plt.imshow(image, cmap='gray')
plt.axis('off')
plt.show()