Visão geral do curso:
Índice
1. Compreensão dos recursos da imagem
2. Descrição do recurso de forma
1. Compreensão dos recursos da imagem
Recursos de imagem são modelos específicos ou estruturas específicas em imagens que são únicas e fáceis de rastrear e comparar.
- A extração e correspondência de recursos de imagem é uma questão fundamental na visão computacional e desempenha um papel importante em aplicações específicas, como detecção de alvos, reconhecimento de objetos, reconstrução 3D, registro de imagens e compreensão de imagens.
- Os recursos de imagem incluem principalmente recursos de cor da imagem , recursos de textura , recursos de forma e recursos de relacionamento espacial .
(1) Características de cor
- O recurso de cor é um recurso global que descreve as propriedades da superfície da cena correspondente à imagem ou região da imagem
- Método de descrição de recurso de cor
- histograma de cores
- espaço colorido
- distribuição de cores
(2) Recursos de textura
- O recurso de textura também é um tipo de recurso global, que também descreve as propriedades da superfície da cena correspondente à imagem ou região da imagem. No entanto, como a textura é apenas uma característica da superfície de um objeto, ela não pode refletir totalmente as propriedades essenciais do objeto, portanto, é impossível obter conteúdo de imagem de alto nível apenas usando recursos de textura.
(3) Recursos de forma
- Existem dois tipos de métodos de representação para recursos de forma, um é o de contorno e o outro é o de área . O recurso de contorno da imagem é direcionado principalmente para o limite externo do objeto, enquanto o recurso regional da imagem descreve o recurso de forma local na imagem.
(4) Recursos de relacionamento espacial
- O recurso de relação espacial refere-se à posição espacial mútua ou relação de direção relativa entre vários alvos segmentados na imagem.
- Esses relacionamentos também podem ser classificados em relacionamentos de junção/adjacência, relacionamentos de sobreposição/sobreposição e relacionamentos de contenção/independência, etc.
2. Descrição do recurso de forma
2.1 Princípio do HOG
Extração de recursos HOG
- O recurso Histogram of Oriented Gradients (HOG) é um descritor de recursos usado para detecção de objetos em visão computacional e processamento de imagens . (usado principalmente para extrair recursos de forma )
- Ele forma recursos calculando e contando o histograma de gradiente de regiões locais da imagem.
- Características Hog combinadas com classificadores SVM têm sido amplamente utilizadas no reconhecimento de imagens, principalmente na detecção de pedestres com grande sucesso. (Use HOG para extrair recursos e use SVM para classificar)
- A ideia principal: Em uma imagem, a forma do alvo pode ser bem descrita pelo gradiente ou pela distribuição de densidade de direção da borda.
Processo de implementação HOG
- Escala de cinza (pense na imagem como uma imagem tridimensional de x, y, z (escala de cinza))
- Padronize o espaço de cores da imagem de entrada usando o método de correção Gama (normalização)
- Calcule o gradiente (magnitude e orientação) de cada pixel da imagem
- Divida a imagem em pequenas células
- Conte o histograma de gradiente de cada célula (o número de gradientes diferentes) para obter o descritor da célula
- Combine cada poucas células em um bloco para obter o descritor de bloco
- Conecte os descritores de recursos HOG de todos os blocos na imagem da imagem para obter o recurso HOG. O vetor de recursos é o recurso usado para detecção ou classificação do alvo.
#=================================HOG 特征===============================#
# flag = 0
flag = 1
if flag == 1:
# 判断矩形i是否完全包含在矩形o中
def is_inside(o, i):
ox, oy, ow, oh = o
ix, iy, iw, ih = i
return ox > ix and oy > iy and ox + ow < ix + iw and oy + oh < iy + ih
# 对人体绘制颜色框
def draw_person(image, person):
x, y, w, h = person
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 255), 2)
img = cv2.imread("people.jpg")
hog = cv2.HOGDescriptor() # 启动检测器对象
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) # 指定检测器类型为人体
found, w = hog.detectMultiScale(img,0.1,(2,2)) # 加载并检测图像
print(found)
print(w)
# 丢弃某些完全被其它矩形包含在内的矩形
found_filtered = []
for ri, r in enumerate(found):
for qi, q in enumerate(found):
if ri != qi and is_inside(r, q):
break
else:
found_filtered.append(r)
print(found_filtered)
# 对不包含在内的有效矩形进行颜色框定
for person in found_filtered:
draw_person(img, person)
cv2.imshow("people detection", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
2.2 Harris
(1) Detecção de canto de Harris
- Pontos de canto: No mundo real, os pontos de canto correspondem a cantos de objetos, interseções de estradas, entroncamentos em T, etc. Do ponto de vista da análise de imagem, existem duas definições para definir pontos de canto:
- Um ponto de canto pode ser a intersecção de duas arestas
- Pontos de canto são pontos característicos com duas direções principais na vizinhança
- Método de cálculo de canto:
- O primeiro calcula pela borda da imagem, a quantidade de cálculo é grande e a mudança local da imagem terá um impacto maior no resultado
- O último método baseado na escala de cinza da imagem detecta cantos calculando a curvatura e o gradiente dos pontos
- Características dos pontos de canto:
- Interseção entre contornos
- Para a mesma cena, mesmo que o ângulo de visão mude, geralmente possui características de propriedades estáveis
- Os pixels nas proximidades deste ponto têm uma grande mudança na direção do gradiente e na magnitude do gradiente.
- Cantos com melhor desempenho:
- Detecte os cantos "reais" na imagem
- Desempenho de posicionamento preciso
- Alta taxa de detecção de repetição
- Ruído Robustez
- maior eficiência computacional
(2) Processo de implementação da Harris
- Calcule o gradiente da imagem nas direções X e Y
- Calcula o produto de gradientes em duas direções de uma imagem
- Use a função Gaussiana para executar a ponderação Gaussiana nos três para gerar A, B, C da matriz M
- Calcule o valor de resposta de Harris R de cada pixel e defina R como zero se for menor que um certo limite t
- A supressão não máxima é realizada em uma vizinhança 3 × 3 ou 5 × 5, e o ponto máximo local é o ponto de canto na imagem
(3) Aplicação do código Harris
A função cv2.cornerHarris() em Open pode ser usada para detecção de canto.
Os parâmetros são os seguintes:
- img: a imagem de entrada cujo tipo de dados é float32
- blockSize: o tamanho do campo a ser considerado na detecção de canto
- ksize: O tamanho da janela usado na derivação de Sobel
- k: Parâmetro livre na equação de detecção de canto de Harris, o parâmetro de valor é [0,04, 0,06]
#=================================Harris 角点===============================#
# flag = 0
flag = 1
if flag == 1:
img = cv2.imread('harris2.png')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = np.float32(gray)
dst_block9_ksize19 = cv2.cornerHarris(gray, 9, 19, 0.04)
img1 = np.copy(img)
img1[dst_block9_ksize19 > 0.01 * dst_block9_ksize19.max()] = [0, 0, 255]
dst_block5_ksize19 = cv2.cornerHarris(gray, 5, 19, 0.04)
img2 = np.copy(img)
img2[dst_block5_ksize19 > 0.01 * dst_block5_ksize19.max()] = [0, 0, 255]
dst_block9_ksize5 = cv2.cornerHarris(gray, 9, 5, 0.04)
img3 = np.copy(img)
img3[dst_block9_ksize5 > 0.01 * dst_block9_ksize5.max()] = [0, 0, 255]
dst_block9_ksize31 = cv2.cornerHarris(gray, 9, 31, 0.04)
img4 = np.copy(img)
img4[dst_block9_ksize31 > 0.01 * dst_block9_ksize31.max()] = [0, 0, 255]
dst_block9_ksize19_k6 = cv2.cornerHarris(gray, 9, 19, 0.06)
img5 = np.copy(img)
img5[dst_block9_ksize19_k6 > 0.01 * dst_block9_ksize19_k6.max()] = [0, 0, 255]
dst_block9_ksize19_k6_1e_5 = cv2.cornerHarris(gray, 9, 19, 0.06)
img6 = np.copy(img)
img6[dst_block9_ksize19_k6_1e_5 > 0.00001 * dst_block9_ksize19_k6_1e_5.max()] = [0, 0, 255]
titles = ["Original", "block9_ksize19", "dst_block5_ksize19", "dst_block9_ksize5", "dst_block9_ksize31",
"dst_block9_ksize19_k6", "dst_block9_ksize19_k6_1e_5"]
imgs = [img, img1, img2, img3, img4, img5, img6]
for i in range(len(titles)):
plt.subplot(3, 3, i + 1), plt.imshow(imgs[i]), plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
# cv2.imshow('src',img)
# cv2.imshow('dst',img5)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
2.3 SIFT
(1) Algoritmo SIFT
- SIFT, o algoritmo de transformação de recursos invariantes em escala , é um algoritmo usado no campo do processamento de imagens. O SIFT possui invariância de escala, pode detectar pontos-chave na imagem e é um descritor de recursos locais.
- Suas aplicações incluem reconhecimento de objetos, percepção e navegação de mapas de robôs, costura de influência, construção de modelo 3D, reconhecimento de gestos, rastreamento de influência e comparação de movimento.
(2) Características do SIFT
- Unicidade: Ou seja, os pontos de recurso podem ser separados e possuem alta variabilidade, semelhante a impressões digitais, adequadas para resumir e combinar em dados massivos
- Abundância: muitos recursos são fornecidos
- Alta velocidade: é rápido
- Extensível: pode ser usado em conjunto com outros vetores de recursos
(3) Recursos do SIFT
- Rotação, dimensionamento, invariância de translação
- Resolva a correspondência de chaves da transformação afim de imagem e transformação de projeção
- Efeito de luz é pequeno
- A oclusão do alvo é menos afetada
- Pouco impacto de ruído e cenário
(4) Etapas do algoritmo SIFT
- Scale Space Extrema Detection Point Detection
- Posicionamento do ponto-chave: remova alguns pontos de recurso ruins e os pontos de recurso preservados podem atender à estabilidade e outras condições
- Parâmetros de direção do ponto-chave: obtenha a vizinhança do espaço da escala onde o ponto-chave está localizado, calcule o gradiente e a direção da área e crie um histograma de direção de acordo com os resultados calculados, o pico do histograma é o principal parâmetro de direção
- Descritor de ponto-chave: Cada ponto-chave usa um conjunto de vetores (posição, escala, direção) para descrever esse ponto-chave para que não mude com a influência da iluminação, ângulo de visão, etc.
- Correspondência de pontos-chave: estabelece conjuntos de descritores de pontos-chave para o gráfico de modelo e o gráfico em tempo real, respectivamente, e julga se dois pontos-chave são iguais comparando os descritores de pontos-chave
#=================================SIFT===============================#
# flag = 0
flag = 1
if flag == 1:
img = cv2.imread('harris2.png')
gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
sift = cv2.xfeatures2d.SIFT_create()
kp = sift.detect(gray,None)#找到关键点
img=cv2.drawKeypoints(gray,kp,img)#绘制关键点
cv2.imshow('sp',img)
cv2.waitKey(0)
cv2.destroyAllWindows()3. Recursos de textura
(1) Introdução ao LBP
- LBP (Local Binary Pattern) é um operador usado para descrever as características de textura local de uma imagem; tem vantagens significativas, como invariância de rotação e invariância de tons de cinza
(2) Princípio de LBP
- O operador LBP é definido em uma janela 3×3, com o pixel central da janela como limite, comparado com o valor cinza dos 8 pixels adjacentes, se o valor do pixel circundante for maior que o valor do pixel central, a posição é marcado como 1 ; caso contrário, marcado como 0. Dessa forma, pode-se obter um número binário de 8 bits (geralmente convertido em decimal, ou seja, código LBP, um total de 256 tipos), e esse valor é usado como o valor LBP do pixel no centro da janela para refletir a textura desta informação de área 3×3.
- Fórmula matemática:
- Entre eles, p representa o p-ésimo pixel na janela 3×3, exceto o pixel central
- l(c) representa o valor de cinza do pixel central, l(p) representa o valor de cinza do p-ésimo pixel na vizinhança
- A fórmula de s(x) é a seguinte:
- LBP registra a diferença entre o pixel central e os pixels vizinhos
- Quando a iluminação muda, o valor do pixel cinza aumenta e diminui ao mesmo tempo, a mudança de LBP não é óbvia
- O LBP não é sensível a mudanças de iluminação, e o que o LBP detecta é apenas a informação de textura da imagem
#=================================LBP===============================#
# flag = 0
flag = 1
if flag == 1:
def LBP(src):
'''
:param src:灰度图像
:return:
'''
height = src.shape[0]
width = src.shape[1]
dst = src.copy()
lbp_value = np.zeros((1, 8), dtype=np.uint8)
# print(lbp_value)
neighbours = np.zeros((1, 8), dtype=np.uint8)
# print(neighbours)
for x in range(1, width - 1):
for y in range(1, height - 1):
neighbours[0, 0] = src[y - 1, x - 1]
neighbours[0, 1] = src[y - 1, x]
neighbours[0, 2] = src[y - 1, x + 1]
neighbours[0, 3] = src[y, x - 1]
neighbours[0, 4] = src[y, x + 1]
neighbours[0, 5] = src[y + 1, x - 1]
neighbours[0, 6] = src[y + 1, x]
neighbours[0, 7] = src[y + 1, x + 1]
center = src[y, x]
for i in range(8):
if neighbours[0, i] > center:
lbp_value[0, i] = 1
else:
lbp_value[0, i] = 0
lbp = lbp_value[0, 0] * 1 + lbp_value[0, 1] * 2 + lbp_value[0, 2] * 4 + lbp_value[0, 3] * 8 \
+ lbp_value[0, 4] * 16 + lbp_value[0, 5] * 32 + lbp_value[0, 6] * 64 + lbp_value[0, 7] * 128
# print(lbp)
dst[y, x] = lbp
return dst
img = cv2.imread('people.jpg', 0)
print(img.shape)
cv2.imshow('src', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
new_img = LBP(img)
cv2.imshow('dst', new_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
4. Correspondência de modelo
(1) Introdução de correspondência de modelo
- A correspondência de modelo é o método de reconhecimento de padrão mais primitivo e básico, que estuda onde a imagem de um alvo específico está localizada na imagem e, em seguida, localiza a imagem.
- Na imagem a ser detectada, o grau de correspondência entre a imagem modelo e a subimagem sobreposta é calculado da esquerda para a direita e de cima para baixo, quanto maior o grau de correspondência, maior a possibilidade de as duas serem iguais.
(2) Função : resultado = cv2.matchTemplate(image, templ, method)
- O parâmetro imagem indica a imagem a ser pesquisada
- O parâmetro templ representa a imagem do modelo, que não deve ser maior que a imagem original e ter o mesmo tipo de dados
- O parâmetro method indica o método para calcular o grau de correspondência
(3) Método de correspondência
- TM_SQDIFF_NORMED é a correspondência de diferença quadrada padrão, que é correspondida calculando a diferença quadrada entre as duas imagens. A melhor correspondência é 0 e, quanto pior a correspondência, maior o valor de correspondência.
- TM_CCORR_NORMED é uma correspondência de correlação padrão, que usa a operação de multiplicação entre o modelo e a imagem. Quanto maior o número, maior o grau de correspondência e 0 significa o pior efeito de correspondência. Este método exclui a influência de mudanças lineares no brilho na similaridade cálculos.
- TM_CCOEFF_NORMED é um coeficiente de correspondência padrão de correlação. Além de subtrair seus respectivos valores médios dos dois gráficos, eles também devem ser divididos por suas respectivas variâncias. Corresponde ao modelo em relação à sua média para sua correlação com sua média, 1 para uma correspondência perfeita, -1 para uma correspondência ruim e 0 para nenhuma correlação (sequência aleatória).
Função : minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc()
- O parâmetro minVal indica o valor mínimo retornado
- O parâmetro maxVal indica o valor máximo retornado
- O parâmetro minLoc indica a posição mínima retornada
- O parâmetro maxLoc indica a posição máxima retornada
# =================================模板检测===============================#
# flag = 0
flag = 1
if flag == 1:
def template_demo(tpl, target):
methods = [cv2.TM_SQDIFF_NORMED, cv2.TM_CCORR_NORMED, cv2.TM_CCOEFF_NORMED] # 3种模板匹配方法
th, tw = tpl.shape[:2]
for md in methods:
# print(md)
result = cv2.matchTemplate(target, tpl, md)
# print(result.shape)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
print(min_val, max_val, min_loc, max_loc)
if md == cv2.TM_SQDIFF_NORMED:
tl = min_loc
else:
tl = max_loc
br = (tl[0] + tw, tl[1] + th) # br是矩形右下角的点的坐标
cv2.rectangle(target, tl, br, (0, 0, 255), 2)
cv2.namedWindow("match-" + np.str(md), cv2.WINDOW_NORMAL)
cv2.imshow("match-" + np.str(md), target)
tpl = cv2.imread("sample2.jpg")
print(tpl.shape)
target = cv2.imread("target1.jpg")
print(target.shape)
cv2.waitKey(0)
cv2.destroyAllWindows()
cv2.namedWindow('template image', cv2.WINDOW_NORMAL)
cv2.imshow("template image", tpl)
cv2.namedWindow('target image', cv2.WINDOW_NORMAL)
cv2.imshow("target image", target)
template_demo(tpl, target)
cv2.waitKey(0)
cv2.destroyAllWindows()5. Detecção de rosto
- De um modo geral, um sistema completo de reconhecimento facial consiste em quatro componentes principais, ou seja, detecção facial, alinhamento facial, extração de recursos humanos e reconhecimento facial.
- Operação de pipeline de quatro partes:
- A detecção de rosto encontra a localização de um rosto em uma imagem
- O registro facial encontra a posição dos óculos, nariz, boca e outros órgãos faciais no rosto
- Informações abstratas da imagem facial em informações de string por meio da extração de recursos faciais
- O reconhecimento facial compara a imagem do rosto de destino com o rosto existente para calcular a semelhança e confirmar a identidade correspondente do rosto
# =================================人脸检测===============================#
# flag = 0
flag = 1
if flag == 1:
# 读入图像
img = cv2.imread("3.png")
# 加载人脸特征，该文件在 python安装目录\Lib\site-packages\cv2\data 下
face_cascade = cv2.CascadeClassifier(r'haarcascade_frontalface_default.xml')
# 将读取的图像转为COLOR_BGR2GRAY，减少计算强度
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# 检测出的人脸个数
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.15, minNeighbors=4, minSize=(5, 5))
print("Face : {0}".format(len(faces)))
print(faces)
# 用矩形圈出人脸的位置
for (x, y, w, h) in faces:
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.namedWindow("Faces")
cv2.imshow("Faces", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
# ==================================人脸检测===============================#
flag = 0
# flag = 1
if flag == 1:
predictor_model = 'shape_predictor_68_face_landmarks/shape_predictor_68_face_landmarks.dat'
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(predictor_model)
# cv2读取图像
test_film_path = "3.png"
img = cv2.imread(test_film_path)
# 取灰度
img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
# 人脸数rects
rects = detector(img_gray, 0)
print(rects[0])
for i in range(len(rects)):
landmarks = np.matrix([[p.x, p.y] for p in predictor(img, rects[i]).parts()])
print(landmarks, type(landmarks))
for idx, point in enumerate(landmarks):
# 68点的坐标
pos = (point[0, 0], point[0, 1])
# print(idx+1, pos)
# 利用cv2.circle给每个特征点画一个圈，共68个
cv2.circle(img, pos, 3, color=(0, 255, 0))
# 利用cv2.putText输出1-68
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img, str(idx + 1), pos, font, 0.5, (0, 0, 25 5), 1, cv2.LINE_AA)
# cv2.imwrite("result.png", img)
cv2.imshow("img", img)
cv2.waitKey(0)
cv2.destroyAllWindows()Abra o conjunto de dados do código CV
Clique no cartão para seguir a conta oficial [Irmã leva você para jogar AI]
Responda "abrir CV" para receber