Forum Replies Created
- Posts
Olá Diogenes!
Você quis dizer que sua IDE não está auto-completando os nomes de classes, métodos, campos e palavras-chave enquanto você digita isso? Na maioria das IDEs esta função é ativada ao pressionar CTRL + Espaço.
Se estiver usando o Pycharm, segue o link de uma seção que abrange várias técnicas de preenchimento de código:
Olá Nelson!
A biblioteca librosa possue a função librosa.effects.trim para remover o silêncio em arquivos de áudio.
Sobre sua outra pergunta, em ‘como lidar com gravações longas utilizando a mesma estratégia de janelas deslizantes’, mais a frente aqui no curso tem um exemplo que trata exatamente isso. É um conteúdo complementar, segue o link da aula: Complementar: previsão por frames
Oi Nelson!
A ideia em converter para dB é justamente isso: Ao invés de fazermos uma comparação linearmente, estamos fazendo logaritmicamente. Ao invés de compararmos as unidades, comparamos os decibeis das unidades, pois a percepção sensorial humana da diferença entre algumas grandezas e fenômenos que encontramos no mundo não funciona linearmente, e sim logaritmicamente, então percebemos mudanças logaritmicas como se elas fossem lineares.
Por exemplo:
* Duas pessoas conversando: 50dB SPL
* Rua com tráfego barulhento: 85dB SPL
* Sirene: 120dB SPL
Diferenças:
* Entre a rua e as pessoas conversando: 35dB SPL
* A sirene e a rua barulhenta: 35dB SPL
* A sirene e as pessoas conversando: 60dB SPL
Considerando a explicação acima, quando usamos MFCC, a ideia central é que a escala mel é uma escala de transformação não linear onde transforma a faixa de frequência do áudio em uma faixa de valor diferente – cuja diferença soaria idêntica ao usuário final, independentemente dos valores. Usamos dB apenas para melhorar a representação visual do resultado, trabalhando com escalas logarítmicas. A explicação mais detalhada sobre MFCCs está na aula Carregamento e Processamento de Áudio / Coeficientes Cepstral de Frequência Mel (MFCC).
Olá Nelson!
Considerando a aplicação em MFCCs, o motivo de trabalharmos com a técnica de Normalização Média Cepstral (CMN – Cepstral Mean Normalization) é para reduzir o ruído e variações que ocorrem nos canais de cada arquivo de áudio, pois as condições do canal são diferentes para cada arquivo de áudio. Assim, cada recurso de áudio extraído é padronizado com sua própria média.
Antes de aplicar CMN:
Após aplicar CMN:
Isso mesmo Pedro, a função analisa os movimentos da direita para a esquerda, e o import Class_HORIZONTAL as Object é apenas um pseudocódigo equivalente ao import validator, exato!
Isso mesmo Pedro, perfeita a sua pergunta!
Precisa ajustar esta função na classe ou criar uma nova função, segue o script:
Também estou mandando abaixo o código completo com os ajustes necessários para analisar um objeto que se move na horizontal.
import numpy as np import cv2 import Class_HORIZONTAL as Object import time LINE_DOWN_COLOR = (232,162,0) BOUNDING_BOX_COLOR = (188,188,188) TRACKER_COLOR = (255,255,255) CENTROID_COLOR = (0, 128, 255) LINE_LIMIT_COLOR = (0, 128, 255) SAVE_IMAGE = True IMAGE_DIR = "./out" VIDEO_SOURCE = "teste.mp4" VIDEO_OUT = "result_H.mp4" # Limites da ROI a1, a2 = 370, 470 l1, l2 = 750, 900 font = cv2.FONT_HERSHEY_SIMPLEX cap = cv2.VideoCapture(VIDEO_SOURCE) hasFrame, frame = cap.read() fourcc = cv2.VideoWriter_fourcc(*"MP4V") writer = cv2.VideoWriter(VIDEO_OUT, fourcc, 25, (frame.shape[1], frame.shape[0]), True) # Exibir as propriedades do vídeo de entrada for i in range(19): print(i, cap.get(i)) h = a2 w = l2 frameArea = h*w areaTH = frameArea/250 print('Area Threshold', areaTH) # Linhas de entrada/saída line_down = int(1*(w/8)) in_down = int(l2) down_limit = int(l1+50) print("Blue line x:", str(line_down)) pt1 = [in_down, a1] pt2 = [in_down, a2] pts_L1 = np.array([pt1, pt2], np.int32) pts_L1 = pts_L1.reshape((-1, 1, 2)) pt7 = [down_limit, a1] pt8 = [down_limit, a2] pts_L4 = np.array([pt7, pt8], np.int32) pts_L4 = pts_L4.reshape((-1, 1, 2)) # Background Subtractor fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows=False) # Filtros morfológicos kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2, 2)) kernelOp = np.ones((3, 3), np.uint8) kernelOp2 = np.ones((5, 5), np.uint8) kernelCl = np.ones((11, 11), np.uint8) def save_frame(frame, file_name, flip=True): # flip BGR to RGB if flip: cv2.imwrite(file_name, np.flip(frame, 2)) else: cv2.imwrite(file_name, frame) def main(): # # Variáveis cnt_down = 0 Objects = [] max_p_age = 5 pid = 1 frame_number = -1 while(cap.isOpened()): ret, frame = cap.read() roi = frame[a1:a2, l1:l2] cv2.rectangle(frame, (l1, a1), (l2, a2), BOUNDING_BOX_COLOR, 1) frame_number += 1 for i in Objects: i.age_one() # marcar cada detecção como um objeto ######################### # Estágio de pré-processamento # ######################### # Aplica bgs fgmask = fgbg.apply(roi) fgmask2 = fgbg.apply(roi) # Usando o método de binarização para remover sombras try: ret, imBin = cv2.threshold(fgmask, 200, 255, cv2.THRESH_BINARY) ret, imBin2 = cv2.threshold(fgmask2, 200, 255, cv2.THRESH_BINARY) # Opening (erode->dilate) mask = cv2.morphologyEx(imBin, cv2.MORPH_OPEN, kernelOp) mask2 = cv2.morphologyEx(imBin2, cv2.MORPH_OPEN, kernelOp) # Closing (dilate -> erode) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernelCl) mask2 = cv2.morphologyEx(mask2, cv2.MORPH_CLOSE, kernelCl) mask = cv2.dilate(mask, kernel, iterations=2) mask2 = cv2.dilate(mask2, kernel, iterations=2) except: print('OBJECT:', cnt_down) break (img, contours0, hierarchy) = cv2.findContours( mask2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours0: area = cv2.contourArea(cnt) if area > areaTH: M = cv2.moments(cnt) cx = int(M['m10']/M['m00']) cy = int(M['m01']/M['m00']) x, y, w, h = cv2.boundingRect(cnt) new = True if cx in range(down_limit): for i in Objects: if abs(x-i.getX()) <= w and abs(y-i.getY()) <= h: new = False i.updateCoords(cx, cy) if i.going_DOWN(line_down) == True: cnt_down += 1 if SAVE_IMAGE: save_frame(roi, IMAGE_DIR + "/mask_%04d.png" % frame_number, flip=False) print("ID:", i.getId(),'crossed going down at', time.strftime("%c")) break if i.getState() == '1': if i.getDir() == 'down' and i.getX() < down_limit: i.setDone() if i.timedOut(): index = Objects.index(i) Objects.pop(index) del i if new == True: p = Object.MyObject(pid, cx, cy, max_p_age) Objects.append(p) pid += 1 cv2.circle(roi, (cx, cy), 5, CENTROID_COLOR, -1) img = cv2.rectangle(roi, (x, y), (x+w, y+h), TRACKER_COLOR, 2) for i in Objects: cv2.putText(roi, str(i.getId()), (i.getX(), i.getY()), font, 0.3, i.getRGB(), 1, cv2.LINE_AA) str_down = 'OBJECTS: ' + str(cnt_down) frame = cv2.polylines(frame, [pts_L1], False, LINE_DOWN_COLOR, thickness=2) frame = cv2.polylines(frame, [pts_L4], False, LINE_LIMIT_COLOR, thickness=2) cv2.putText(frame, str_down, (10, 50), font, 1, (255, 255, 255), 3, cv2.LINE_AA) cv2.putText(frame, str_down, (10, 50), font, 1, (232,162,0), 2, cv2.LINE_AA) cv2.imshow('Frame', frame) # cv2.imshow('Mask', mask) writer.write(frame) k = cv2.waitKey(30) & 0xff if k == 27: break writer.release() cap.release() cv2.destroyAllWindows() main()Olá Pedro!
Cada linha é definida usando 2 pontos de coordenadas, o ponto onde a linha irá iniciar e o ponto onde a linha irá terminar. O ponto inicial são as coordenadas representadas como tuplas de dois valores, ou seja, valor da coordenada X , valor da coordenada Y. Para o ponto final também são coordenadas X e Y.
Para traçar linhas na vertical, basta passar as coordenadas dos pontos na vertical.
Por exemplo usando a função cv2.line() desenhe uma linha do ponto A(x1, y1) ao ponto B(x2, y2), onde A e B representam quaisquer dois pontos na imagem. Olhe para o canto superior esquerdo da imagem, você encontrará a origem do sistema de coordenadas xy.
- O eixo x representa a direção horizontal ou as colunas da imagem.
- O eixo y representa a direção vertical ou as linhas da imagem.
O primeiro parâmetro que devemos alimentar na função é a imagem na qual queremos desenhá-la.
O segundo parâmetro que devemos especificar é onde a linha começa. Isso é especificado através do atributo pt1 (representando o ponto 1). Queremos que nossa linha, neste exemplo, comece no ponto (100.300).
O terceiro parâmetro que devemos especificar é onde a linha termina. Isso é especificado através do atributo pt2 (representando o ponto 2). Neste exemplo, queremos que nossa linha termine em (400.300). Isso resulta em um comprimento horizontal de 300.
Agora que você tem as linhas delimitadoras na vertical, então precisa adaptar o algoritmo para analisar os movimentos que transitam verticalmente, ou seja, que se movem da esquerda para a direita ou vice-versa. Por exemplo se o objeto estiver se movendo da direira para a esquerda, quando ele cruzar a linha limite de saída você pode considerar como parâmetro a coordenada y do objeto detectado para definir quando ele cruzou a linha (quando um objeto se move na vertical, da direita para a esquerda, o valor da coordenada y vai diminuindo, já se o movimento for ao contrário então o valor da coordenada y do objeto detectado vai aumentando).
Olá Manuel!
Muito obrigado pelo feedback!
O motivo de trabalharmos com a técnica de Normalização Média Cepstral (CMN – Cepstral Mean Normalization) é para reduzir o ruído e variações que ocorrem nos canais de cada arquivo de áudio, pois as condições do canal são diferentes para cada arquivo de áudio. Assim, cada recurso de áudio extraído é padronizado com sua própria média.
Antes de aplicar CMN:
Após aplicar CMN:
Olá Pedro!
Fiz o teste aplicando somente o Optical Flow e parece que devido aos insetos estarem desfocados desde o início do vídeo, o algoritmo não consegue indetificar os contornos/arestas. Já nos objetos que estão mais nítidos (marca da câmera, tempo de vídeo, camisa branca ao fundo) ele consegue identificar. Segue o vídeo .
Minha sugestão seria gravar um vídeo mais focado nos insetos (se estes forem o objetivo).
Também se puder compartilhar a ideia do projeto, assim podemos pensar em mais soluções. Caso não queira compartilhar aqui no fórum, pode mandar no meu e-mail: daltonluizvargas@hotmail.com
import numpy as np import cv2 import sys from random import randint ################################################################################## # Escolha do Vídeo VIDEO_SOURCE = "videos/persons.mp4" #Definindo as variáveis de cor/fonte aleatoriamente (R,G,B) TEXT_COLOR = (randint(0, 255), randint(0,255),randint(0,255)) TRACKER_COLOR = (randint(0, 255), randint(0,255),randint(0,255)) FONT = cv2.FONT_HERSHEY_SIMPLEX # Escolha do Background BGS_TYPES = ["MOG2", "KNN"] BGS_TYPE = BGS_TYPES[1] ################################################################################## # Escolha do Kernel def getKernel(KERNEL_TYPE): if KERNEL_TYPE == "dilation": kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3)) if KERNEL_TYPE == "opening": kernel = np.ones((3,3), np.uint8) if KERNEL_TYPE == "closing": kernel = np.ones((3,3), np.uint8) return kernel ################################################################################## # Criação dos Filtros def getFilter(img, filter): if filter == 'closing': return cv2.morphologyEx(img, cv2.MORPH_CLOSE, getKernel("closing"), iterations=2) if filter == 'opening': return cv2.morphologyEx(img, cv2.MORPH_OPEN, getKernel("opening"), iterations=2) if filter == 'dilation': return cv2.dilate(img, getKernel("dilation"), iterations=2) if filter =='combine': closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, getKernel("closing"), iterations=2) opening = cv2.morphologyEx(closing, cv2.MORPH_OPEN, getKernel("opening"), iterations=2) dilation = cv2.dilate(opening, getKernel("dilation"), iterations=2) return dilation ################################################################################## def getBGSubtractor(BGS_TYPE): if BGS_TYPE == "MOG2": return cv2.createBackgroundSubtractorMOG2() if BGS_TYPE == "KNN": return cv2.createBackgroundSubtractorKNN() print("Detector inválido") sys.exit(1) ################################################################################## # Carregando o vídeo cap = cv2.VideoCapture(VIDEO_SOURCE) bg_subtractor = getBGSubtractor(BGS_TYPE) minArea = 150 ################################################################################## # Configuração dos parametros Shitomasi e Lucas Kanade def SK(): parameters_shitomasi = dict(maxCorners=100, # máx de nós qualityLevel=0.05, # aumenta pra achar mais e diminui pra achar menos minDistance=30) # distancia entre pontos parameters_lucas_kanade = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.05)) colors = np.random.randint(0, 255, (100, 3)) ret, frame = cap.read() frame_gray_init = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) edges = cv2.goodFeaturesToTrack(frame_gray_init, mask=None, **parameters_shitomasi) mask = np.zeros_like(frame) # print(edges) #localização dos pontos inicias marcados # print(len(edges)) # contagem de pontos indentificados # print(mask) # print(np.shape(mask)) #dimensão do vídeo while (cap.isOpened): ok, frame = cap.read() if not ok: print("ERRO...") break bg_mask = bg_subtractor.apply(frame) fg_mask = getFilter(bg_mask, 'combine') result = cv2.bitwise_and(frame, frame, mask=fg_mask) frame_gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY) new_edges, status, errors = cv2.calcOpticalFlowPyrLK(frame_gray_init, frame_gray, edges, None, **parameters_lucas_kanade) news = new_edges[status == 1] olds = edges[status == 1] for i, (new, old) in enumerate(zip(news, olds)): a, b = new.ravel() c, d = old.ravel() # Não entendi esta parte # a, b, c, d = int(a), int(b), int(c), int(d) mask = cv2.line(mask, (a, b), (c, d), colors[i].tolist(), 2) frame = cv2.circle(result, (a, b), 5, colors[i].tolist(), -1) img = cv2.add(result, mask) cv2.imshow('BGS + Optical flow', img) if cv2.waitKey(1) == 13: break frame_gray_init = frame_gray.copy() edges = news.reshape(-1, 1, 2) # Acionamento do main() SK()Opa!
Fiz a correção e teste com seu script, segue o link de um vídeo de demontração:
Na próxima mensagem vou postar o script.
