import numpy as np import cv2 as cv import math import argparse class AudioDrawing: ''' Used for drawing audio graphics ''' def __init__(self, args): self.inputType = args.inputType self.draw = args.draw self.graph = args.graph self.audio = cv.samples.findFile(args.audio) self.audioStream = args.audioStream self.windowType = args.windowType self.windLen = args.windLen self.overlap = args.overlap self.enableGrid = args.enableGrid self.rows = args.rows self.cols = args.cols self.xmarkup = args.xmarkup self.ymarkup = args.ymarkup self.zmarkup = args.zmarkup self.microTime = args.microTime self.frameSizeTime = args.frameSizeTime self.updateTime = args.updateTime self.waitTime = args.waitTime if self.initAndCheckArgs(args) is False: exit() def Draw(self): if self.draw == "static": if self.inputType == "file": samplingRate, inputAudio = self.readAudioFile(self.audio) elif self.inputType == "microphone": samplingRate, inputAudio = self.readAudioMicrophone() duration = len(inputAudio) // samplingRate # since the dimensional grid is counted in integer seconds, # if the input audio has an incomplete last second, # then it is filled with zeros to complete remainder = len(inputAudio) % samplingRate if remainder != 0: sizeToFullSec = samplingRate - remainder zeroArr = np.zeros(sizeToFullSec) inputAudio = np.concatenate((inputAudio, zeroArr), axis=0) duration += 1 print("Update duration of audio to full second with ", sizeToFullSec, " zero samples") print("New number of samples ", len(inputAudio)) if duration <= self.xmarkup: self.xmarkup = duration + 1 if self.graph == "ampl": imgAmplitude = self.drawAmplitude(inputAudio) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate) cv.imshow("Display window", imgAmplitude) cv.waitKey(0) elif self.graph == "spec": stft = self.STFT(inputAudio) imgSpec = self.drawSpectrogram(stft) imgSpec = self.drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft) cv.imshow("Display window", imgSpec) cv.waitKey(0) elif self.graph == "ampl_and_spec": imgAmplitude = self.drawAmplitude(inputAudio) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, inputAudio, samplingRate) stft = self.STFT(inputAudio) imgSpec = self.drawSpectrogram(stft) imgSpec = self.drawSpectrogramColorbar(imgSpec, inputAudio, samplingRate, stft) imgTotal = self.concatenateImages(imgAmplitude, imgSpec) cv.imshow("Display window", imgTotal) cv.waitKey(0) elif self.draw == "dynamic": if self.inputType == "file": self.dynamicFile(self.audio) elif self.inputType == "microphone": self.dynamicMicrophone() def readAudioFile(self, file): cap = cv.VideoCapture(file) params = [cv.CAP_PROP_AUDIO_STREAM, self.audioStream, cv.CAP_PROP_VIDEO_STREAM, -1, cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_16S] params = np.asarray(params) cap.open(file, cv.CAP_ANY, params) if cap.isOpened() == False: print("Error : Can't read audio file: '", self.audio, "' with audioStream = ", self.audioStream) print("Error: problems with audio reading, check input arguments") exit() audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX)) numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS)) print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH))))) print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels) print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS)) frame = [] frame = np.asarray(frame) inputAudio = [] while (1): if (cap.grab()): frame = [] frame = np.asarray(frame) frame = cap.retrieve(frame, audioBaseIndex) for i in range(len(frame[1][0])): inputAudio.append(frame[1][0][i]) else: break inputAudio = np.asarray(inputAudio) print("Number of samples: ", len(inputAudio)) samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) return samplingRate, inputAudio def readAudioMicrophone(self): cap = cv.VideoCapture() params = [cv.CAP_PROP_AUDIO_STREAM, 0, cv.CAP_PROP_VIDEO_STREAM, -1] params = np.asarray(params) cap.open(0, cv.CAP_ANY, params) if cap.isOpened() == False: print("Error: Can't open microphone") print("Error: problems with audio reading, check input arguments") exit() audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX)) numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS)) print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH))))) print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels) print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS)) cvTickFreq = cv.getTickFrequency() sysTimeCurr = cv.getTickCount() sysTimePrev = sysTimeCurr frame = [] frame = np.asarray(frame) inputAudio = [] while ((sysTimeCurr - sysTimePrev) / cvTickFreq < self.microTime): if (cap.grab()): frame = [] frame = np.asarray(frame) frame = cap.retrieve(frame, audioBaseIndex) for i in range(len(frame[1][0])): inputAudio.append(frame[1][0][i]) sysTimeCurr = cv.getTickCount() else: print("Error: Grab error") break inputAudio = np.asarray(inputAudio) print("Number of samples: ", len(inputAudio)) samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) return samplingRate, inputAudio def drawAmplitude(self, inputAudio): color = (247, 111, 87) thickness = 5 frameVectorRows = 500 middle = frameVectorRows // 2 # usually the input data is too big, so it is necessary # to reduce size using interpolation of data frameVectorCols = 40000 if len(inputAudio) < frameVectorCols: frameVectorCols = len(inputAudio) img = np.zeros((frameVectorRows, frameVectorCols, 3), np.uint8) img += 255 # white background audio = np.array(0) audio = cv.resize(inputAudio, (1, frameVectorCols), interpolation=cv.INTER_LINEAR) reshapeAudio = np.reshape(audio, (-1)) # normalization data by maximum element minCv, maxCv, _, _ = cv.minMaxLoc(reshapeAudio) maxElem = int(max(abs(minCv), abs(maxCv))) # if all data values are zero (silence) if maxElem == 0: maxElem = 1 for i in range(len(reshapeAudio)): reshapeAudio[i] = middle - reshapeAudio[i] * middle // maxElem for i in range(1, frameVectorCols, 1): cv.line(img, (i - 1, int(reshapeAudio[i - 1])), (i, int(reshapeAudio[i])), color, thickness) img = cv.resize(img, (900, 400), interpolation=cv.INTER_AREA) return img def drawAmplitudeScale(self, inputImg, inputAudio, samplingRate, xmin=None, xmax=None): # function of layout drawing for graph of volume amplitudes # x axis for time # y axis for amplitudes # parameters for the new image size preCol = 100 aftCol = 100 preLine = 40 aftLine = 50 frameVectorRows = inputImg.shape[0] frameVectorCols = inputImg.shape[1] totalRows = preLine + frameVectorRows + aftLine totalCols = preCol + frameVectorCols + aftCol imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8) imgTotal += 255 # white background imgTotal[preLine: preLine + frameVectorRows, preCol: preCol + frameVectorCols] = inputImg # calculating values on x axis if xmin is None: xmin = 0 if xmax is None: xmax = len(inputAudio) / samplingRate if xmax > self.xmarkup: xList = np.linspace(xmin, xmax, self.xmarkup).astype(int) else: # this case is used to display a dynamic update tmp = np.arange(xmin, xmax, 1).astype(int) + 1 xList = np.concatenate((np.zeros(self.xmarkup - len(tmp)), tmp[:]), axis=None) # calculating values on y axis ymin = np.min(inputAudio) ymax = np.max(inputAudio) yList = np.linspace(ymin, ymax, self.ymarkup) # parameters for layout drawing textThickness = 1 gridThickness = 1 gridColor = (0, 0, 0) textColor = (0, 0, 0) font = cv.FONT_HERSHEY_SIMPLEX fontScale = 0.5 # horizontal axis under the graph cv.line(imgTotal, (preCol, totalRows - aftLine), (preCol + frameVectorCols, totalRows - aftLine), gridColor, gridThickness) # vertical axis for amplitude cv.line(imgTotal, (preCol, preLine), (preCol, preLine + frameVectorRows), gridColor, gridThickness) # parameters for layout calculation serifSize = 10 indentDownX = serifSize * 2 indentDownY = serifSize // 2 indentLeftX = serifSize indentLeftY = 2 * preCol // 3 # drawing layout for x axis numX = frameVectorCols // (self.xmarkup - 1) for i in range(len(xList)): a1 = preCol + i * numX a2 = frameVectorRows + preLine b1 = a1 b2 = a2 + serifSize if self.enableGrid is True: d1 = a1 d2 = preLine cv.line(imgTotal, (a1, a2), (d1, d2), gridColor, gridThickness) cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness) cv.putText(imgTotal, str(int(xList[i])), (b1 - indentLeftX, b2 + indentDownX), font, fontScale, textColor, textThickness) # drawing layout for y axis numY = frameVectorRows // (self.ymarkup - 1) for i in range(len(yList)): a1 = preCol a2 = totalRows - aftLine - i * numY b1 = preCol - serifSize b2 = a2 if self.enableGrid is True: d1 = preCol + frameVectorCols d2 = a2 cv.line(imgTotal, (a1, a2), (d1, d2), gridColor, gridThickness) cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness) cv.putText(imgTotal, str(int(yList[i])), (b1 - indentLeftY, b2 + indentDownY), font, fontScale, textColor, textThickness) imgTotal = cv.resize(imgTotal, (self.cols, self.rows), interpolation=cv.INTER_AREA) return imgTotal def STFT(self, inputAudio): """ The Short-time Fourier transform (STFT), is a Fourier-related transform used to determine the sinusoidal frequency and phase content of local sections of a signal as it changes over time. In practice, the procedure for computing STFTs is to divide a longer time signal into shorter segments of equal length and then compute the Fourier transform separately on each shorter segment. This reveals the Fourier spectrum on each shorter segment. One then usually plots the changing spectra as a function of time, known as a spectrogram or waterfall plot. https://en.wikipedia.org/wiki/Short-time_Fourier_transform """ time_step = self.windLen - self.overlap stft = [] if self.windowType == "Hann": # https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows Hann_wind = [] for i in range (1 - self.windLen, self.windLen, 2): Hann_wind.append(i * (0.5 + 0.5 * math.cos(math.pi * i / (self.windLen - 1)))) Hann_wind = np.asarray(Hann_wind) elif self.windowType == "Hamming": # https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows Hamming_wind = [] for i in range (1 - self.windLen, self.windLen, 2): Hamming_wind.append(i * (0.53836 - 0.46164 * (math.cos(2 * math.pi * i / (self.windLen - 1))))) Hamming_wind = np.asarray(Hamming_wind) for index in np.arange(0, len(inputAudio), time_step).astype(int): section = inputAudio[index:index + self.windLen] zeroArray = np.zeros(self.windLen - len(section)) section = np.concatenate((section, zeroArray), axis=None) if self.windowType == "Hann": section *= Hann_wind elif self.windowType == "Hamming": section *= Hamming_wind dst = np.empty(0) dst = cv.dft(section, dst, flags=cv.DFT_COMPLEX_OUTPUT) reshape_dst = np.reshape(dst, (-1)) # we need only the first part of the spectrum, the second part is symmetrical complexArr = np.zeros(len(dst) // 4, dtype=complex) for i in range(len(dst) // 4): complexArr[i] = complex(reshape_dst[2 * i], reshape_dst[2 * i + 1]) stft.append(np.abs(complexArr)) stft = np.array(stft).transpose() # convert elements to the decibel scale np.log10(stft, out=stft, where=(stft != 0.)) return 10 * stft def drawSpectrogram(self, stft): frameVectorRows = stft.shape[0] frameVectorCols = stft.shape[1] # Normalization of image values from 0 to 255 to get more contrast image # and this normalization will be taken into account in the scale drawing colormapImageRows = 255 imgSpec = np.zeros((frameVectorRows, frameVectorCols, 3), np.uint8) stftMat = np.zeros((frameVectorRows, frameVectorCols), np.float64) cv.normalize(stft, stftMat, 1.0, 0.0, cv.NORM_INF) for i in range(frameVectorRows): for j in range(frameVectorCols): imgSpec[frameVectorRows - i - 1, j] = int(stftMat[i][j] * colormapImageRows) imgSpec = cv.applyColorMap(imgSpec, cv.COLORMAP_INFERNO) imgSpec = cv.resize(imgSpec, (900, 400), interpolation=cv.INTER_LINEAR) return imgSpec def drawSpectrogramColorbar(self, inputImg, inputAudio, samplingRate, stft, xmin=None, xmax=None): # function of layout drawing for the three-dimensional graph of the spectrogram # x axis for time # y axis for frequencies # z axis for magnitudes of frequencies shown by color scale # parameters for the new image size preCol = 100 aftCol = 100 preLine = 40 aftLine = 50 colColor = 20 ind_col = 20 frameVectorRows = inputImg.shape[0] frameVectorCols = inputImg.shape[1] totalRows = preLine + frameVectorRows + aftLine totalCols = preCol + frameVectorCols + aftCol + colColor imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8) imgTotal += 255 # white background imgTotal[preLine: preLine + frameVectorRows, preCol: preCol + frameVectorCols] = inputImg # colorbar image due to drawSpectrogram(..) picture has been normalised from 255 to 0, # so here colorbar has values from 255 to 0 colorArrSize = 256 imgColorBar = np.zeros((colorArrSize, colColor, 1), np.uint8) for i in range(colorArrSize): imgColorBar[i] += colorArrSize - 1 - i imgColorBar = cv.applyColorMap(imgColorBar, cv.COLORMAP_INFERNO) imgColorBar = cv.resize(imgColorBar, (colColor, frameVectorRows), interpolation=cv.INTER_AREA) # imgTotal[preLine: preLine + frameVectorRows, preCol + frameVectorCols + ind_col: preCol + frameVectorCols + ind_col + colColor] = imgColorBar # calculating values on x axis if xmin is None: xmin = 0 if xmax is None: xmax = len(inputAudio) / samplingRate if xmax > self.xmarkup: xList = np.linspace(xmin, xmax, self.xmarkup).astype(int) else: # this case is used to display a dynamic update tmpXList = np.arange(xmin, xmax, 1).astype(int) + 1 xList = np.concatenate((np.zeros(self.xmarkup - len(tmpXList)), tmpXList[:]), axis=None) # calculating values on y axis # according to the Nyquist sampling theorem, # signal should posses frequencies equal to half of sampling rate ymin = 0 ymax = int(samplingRate / 2.) yList = np.linspace(ymin, ymax, self.ymarkup).astype(int) # calculating values on z axis zList = np.linspace(np.min(stft), np.max(stft), self.zmarkup) # parameters for layout drawing textThickness = 1 textColor = (0, 0, 0) gridThickness = 1 gridColor = (0, 0, 0) font = cv.FONT_HERSHEY_SIMPLEX fontScale = 0.5 serifSize = 10 indentDownX = serifSize * 2 indentDownY = serifSize // 2 indentLeftX = serifSize indentLeftY = 2 * preCol // 3 # horizontal axis cv.line(imgTotal, (preCol, totalRows - aftLine), (preCol + frameVectorCols, totalRows - aftLine), gridColor, gridThickness) # vertical axis cv.line(imgTotal, (preCol, preLine), (preCol, preLine + frameVectorRows), gridColor, gridThickness) # drawing layout for x axis numX = frameVectorCols // (self.xmarkup - 1) for i in range(len(xList)): a1 = preCol + i * numX a2 = frameVectorRows + preLine b1 = a1 b2 = a2 + serifSize cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness) cv.putText(imgTotal, str(int(xList[i])), (b1 - indentLeftX, b2 + indentDownX), font, fontScale, textColor, textThickness) # drawing layout for y axis numY = frameVectorRows // (self.ymarkup - 1) for i in range(len(yList)): a1 = preCol a2 = totalRows - aftLine - i * numY b1 = preCol - serifSize b2 = a2 cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness) cv.putText(imgTotal, str(int(yList[i])), (b1 - indentLeftY, b2 + indentDownY), font, fontScale, textColor, textThickness) # drawing layout for z axis numZ = frameVectorRows // (self.zmarkup - 1) for i in range(len(zList)): a1 = preCol + frameVectorCols + ind_col + colColor a2 = totalRows - aftLine - i * numZ b1 = a1 + serifSize b2 = a2 cv.line(imgTotal, (a1, a2), (b1, b2), gridColor, gridThickness) cv.putText(imgTotal, str(int(zList[i])), (b1 + 10, b2 + indentDownY), font, fontScale, textColor, textThickness) imgTotal = cv.resize(imgTotal, (self.cols, self.rows), interpolation=cv.INTER_AREA) return imgTotal def concatenateImages(self, img1, img2): # first image will be under the second image totalRows = img1.shape[0] + img2.shape[0] totalCols = max(img1.shape[1], img2.shape[1]) # if images columns do not match, the difference is filled in white imgTotal = np.zeros((totalRows, totalCols, 3), np.uint8) imgTotal += 255 imgTotal[:img1.shape[0], :img1.shape[1]] = img1 imgTotal[img2.shape[0]:, :img2.shape[1]] = img2 return imgTotal def dynamicFile(self, file): cap = cv.VideoCapture(file) params = [cv.CAP_PROP_AUDIO_STREAM, self.audioStream, cv.CAP_PROP_VIDEO_STREAM, -1, cv.CAP_PROP_AUDIO_DATA_DEPTH, cv.CV_16S] params = np.asarray(params) cap.open(file, cv.CAP_ANY, params) if cap.isOpened() == False: print("ERROR! Can't to open file") return audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX)) numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS)) samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH))))) print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels) print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS)) step = int(self.updateTime * samplingRate) frameSize = int(self.frameSizeTime * samplingRate) # since the dimensional grid is counted in integer seconds, # if duration of audio frame is less than xmarkup, to avoid an incorrect display, # xmarkup will be taken equal to duration if self.frameSizeTime <= self.xmarkup: self.xmarkup = self.frameSizeTime buffer = [] section = np.zeros(frameSize, dtype=np.int16) currentSamples = 0 while (1): if (cap.grab()): frame = [] frame = np.asarray(frame) frame = cap.retrieve(frame, audioBaseIndex) for i in range(len(frame[1][0])): buffer.append(frame[1][0][i]) buffer_size = len(buffer) if (buffer_size >= step): section = list(section) currentSamples += step del section[0:step] section.extend(buffer[0:step]) del buffer[0:step] section = np.asarray(section) if currentSamples < frameSize: xmin = 0 xmax = (currentSamples) / samplingRate else: xmin = (currentSamples - frameSize) / samplingRate + 1 xmax = (currentSamples) / samplingRate if self.graph == "ampl": imgAmplitude = self.drawAmplitude(section) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax) cv.imshow("Display amplitude graph", imgAmplitude) cv.waitKey(self.waitTime) elif self.graph == "spec": stft = self.STFT(section) imgSpec = self.drawSpectrogram(stft) imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax) cv.imshow("Display spectrogram", imgSpec) cv.waitKey(self.waitTime) elif self.graph == "ampl_and_spec": imgAmplitude = self.drawAmplitude(section) stft = self.STFT(section) imgSpec = self.drawSpectrogram(stft) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax) imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax) imgTotal = self.concatenateImages(imgAmplitude, imgSpec) cv.imshow("Display amplitude graph and spectrogram", imgTotal) cv.waitKey(self.waitTime) else: break def dynamicMicrophone(self): cap = cv.VideoCapture() params = [cv.CAP_PROP_AUDIO_STREAM, 0, cv.CAP_PROP_VIDEO_STREAM, -1] params = np.asarray(params) cap.open(0, cv.CAP_ANY, params) if cap.isOpened() == False: print("ERROR! Can't to open file") return audioBaseIndex = int(cap.get(cv.CAP_PROP_AUDIO_BASE_INDEX)) numberOfChannels = int(cap.get(cv.CAP_PROP_AUDIO_TOTAL_CHANNELS)) print("CAP_PROP_AUDIO_DATA_DEPTH: ", str((int(cap.get(cv.CAP_PROP_AUDIO_DATA_DEPTH))))) print("CAP_PROP_AUDIO_SAMPLES_PER_SECOND: ", cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) print("CAP_PROP_AUDIO_TOTAL_CHANNELS: ", numberOfChannels) print("CAP_PROP_AUDIO_TOTAL_STREAMS: ", cap.get(cv.CAP_PROP_AUDIO_TOTAL_STREAMS)) frame = [] frame = np.asarray(frame) samplingRate = int(cap.get(cv.CAP_PROP_AUDIO_SAMPLES_PER_SECOND)) step = int(self.updateTime * samplingRate) frameSize = int(self.frameSizeTime * samplingRate) self.xmarkup = self.frameSizeTime currentSamples = 0 buffer = [] section = np.zeros(frameSize, dtype=np.int16) cvTickFreq = cv.getTickFrequency() sysTimeCurr = cv.getTickCount() sysTimePrev = sysTimeCurr self.waitTime = self.updateTime * 1000 while ((sysTimeCurr - sysTimePrev) / cvTickFreq < self.microTime): if (cap.grab()): frame = [] frame = np.asarray(frame) frame = cap.retrieve(frame, audioBaseIndex) for i in range(len(frame[1][0])): buffer.append(frame[1][0][i]) sysTimeCurr = cv.getTickCount() buffer_size = len(buffer) if (buffer_size >= step): section = list(section) currentSamples += step del section[0:step] section.extend(buffer[0:step]) del buffer[0:step] section = np.asarray(section) if currentSamples < frameSize: xmin = 0 xmax = (currentSamples) / samplingRate else: xmin = (currentSamples - frameSize) / samplingRate + 1 xmax = (currentSamples) / samplingRate if self.graph == "ampl": imgAmplitude = self.drawAmplitude(section) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax) cv.imshow("Display amplitude graph", imgAmplitude) cv.waitKey(self.waitTime) elif self.graph == "spec": stft = self.STFT(section) imgSpec = self.drawSpectrogram(stft) imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax) cv.imshow("Display spectrogram", imgSpec) cv.waitKey(self.waitTime) elif self.graph == "ampl_and_spec": imgAmplitude = self.drawAmplitude(section) stft = self.STFT(section) imgSpec = self.drawSpectrogram(stft) imgAmplitude = self.drawAmplitudeScale(imgAmplitude, section, samplingRate, xmin, xmax) imgSpec = self.drawSpectrogramColorbar(imgSpec, section, samplingRate, stft, xmin, xmax) imgTotal = self.concatenateImages(imgAmplitude, imgSpec) cv.imshow("Display amplitude graph and spectrogram", imgTotal) cv.waitKey(self.waitTime) else: break def initAndCheckArgs(self, args): if args.inputType != "file" and args.inputType != "microphone": print("Error: ", args.inputType, " input method doesnt exist") return False if args.draw != "static" and args.draw != "dynamic": print("Error: ", args.draw, " draw type doesnt exist") return False if args.graph != "ampl" and args.graph != "spec" and args.graph != "ampl_and_spec": print("Error: ", args.graph, " type of graph doesnt exist") return False if args.windowType != "Rect" and args.windowType != "Hann" and args.windowType != "Hamming": print("Error: ", args.windowType, " type of window doesnt exist") return False if args.windLen <= 0: print("Error: windLen = ", args.windLen, " - incorrect value. Must be > 0") return False if args.overlap <= 0: print("Error: overlap = ", args.overlap, " - incorrect value. Must be > 0") return False if args.rows <= 0: print("Error: rows = ", args.rows, " - incorrect value. Must be > 0") return False if args.cols <= 0: print("Error: cols = ", args.cols, " - incorrect value. Must be > 0") return False if args.xmarkup < 2: print("Error: xmarkup = ", args.xmarkup, " - incorrect value. Must be >= 2") return False if args.ymarkup < 2: print("Error: ymarkup = ", args.ymarkup, " - incorrect value. Must be >= 2") return False if args.zmarkup < 2: print("Error: zmarkup = ", args.zmarkup, " - incorrect value. Must be >= 2") return False if args.microTime <= 0: print("Error: microTime = ", args.microTime, " - incorrect value. Must be > 0") return False if args.frameSizeTime <= 0: print("Error: frameSizeTime = ", args.frameSizeTime, " - incorrect value. Must be > 0") return False if args.updateTime <= 0: print("Error: updateTime = ", args.updateTime, " - incorrect value. Must be > 0") return False if args.waitTime < 0: print("Error: waitTime = ", args.waitTime, " - incorrect value. Must be >= 0") return False return True if __name__ == "__main__": parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter, description='''this sample draws a volume graph and/or spectrogram of audio/video files and microphone\nDefault usage: ./Spectrogram.exe''') parser.add_argument("-i", "--inputType", dest="inputType", type=str, default="file", help="file or microphone") parser.add_argument("-d", "--draw", dest="draw", type=str, default="static", help="type of drawing: static - for plotting graph(s) across the entire input audio; dynamic - for plotting graph(s) in a time-updating window") parser.add_argument("-g", "--graph", dest="graph", type=str, default="ampl_and_spec", help="type of graph: amplitude graph or/and spectrogram. Please use tags below : ampl - draw the amplitude graph; spec - draw the spectrogram; ampl_and_spec - draw the amplitude graph and spectrogram on one image under each other") parser.add_argument("-a", "--audio", dest="audio", type=str, default='Megamind.avi', help="name and path to file") parser.add_argument("-s", "--audioStream", dest="audioStream", type=int, default=1, help=" CAP_PROP_AUDIO_STREAM value") parser.add_argument("-t", '--windowType', dest="windowType", type=str, default="Rect", help="type of window for STFT. Please use tags below : Rect/Hann/Hamming") parser.add_argument("-l", '--windLen', dest="windLen", type=int, default=256, help="size of window for STFT") parser.add_argument("-o", '--overlap', dest="overlap", type=int, default=128, help="overlap of windows for STFT") parser.add_argument("-gd", '--grid', dest="enableGrid", type=bool, default=False, help="grid on amplitude graph(on/off)") parser.add_argument("-r", '--rows', dest="rows", type=int, default=400, help="rows of output image") parser.add_argument("-c", '--cols', dest="cols", type=int, default=900, help="cols of output image") parser.add_argument("-x", '--xmarkup', dest="xmarkup", type=int, default=5, help="number of x axis divisions (time asix)") parser.add_argument("-y", '--ymarkup', dest="ymarkup", type=int, default=5, help="number of y axis divisions (frequency or/and amplitude axis)") # ? parser.add_argument("-z", '--zmarkup', dest="zmarkup", type=int, default=5, help="number of z axis divisions (colorbar)") # ? parser.add_argument("-m", '--microTime', dest="microTime", type=int, default=20, help="time of recording audio with microphone in seconds") parser.add_argument("-f", '--frameSizeTime', dest="frameSizeTime", type=int, default=5, help="size of sliding window in seconds") parser.add_argument("-u", '--updateTime', dest="updateTime", type=int, default=1, help="update time of sliding window in seconds") parser.add_argument("-w", '--waitTime', dest="waitTime", type=int, default=10, help="parameter to cv.waitKey() for dynamic update, takes values in milliseconds") args = parser.parse_args() AudioDrawing(args).Draw()