def __init__(self,
indexOfProcessMat=0,
targetNumberOfRows=110,
targetNumberOfColumns=32,
useDeletingVerticalSpaces=True,
useDeletingHorizontalSpaces=True,
findCountersMode=cv2.RETR_LIST,
findCountersMethode=cv2.CHAIN_APPROX_NONE,
colorOfBorder=0,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "ObjectCentering:__init__")
self.__indexOfProcessMat = indexOfProcessMat
self.__targetNumberOfRows = targetNumberOfRows
self.__targetNumberOfColumns = targetNumberOfColumns
self.__useDeletingVerticalSpaces = useDeletingVerticalSpaces
self.__useDeletingHorizontalSpaces = useDeletingHorizontalSpaces
self.__findCountersMode = findCountersMode
self.__findCountersMethode = findCountersMethode
self.__colorOfBorder = colorOfBorder
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finsihed __init__()", "ObjectCentering:__init__")
def __init__(self,
cnnModelFn,
preditcionToClassificationFn,
modelDir="/tmp/cnn_model",
learnRate=0.001):
"""
Constructor, initialisiert Membervariablen.
:param cnnModelFn : function Ein CnnModel mit den Methoden train, predict, evaluate.
:param predictedClassesToClassificationFn : function Eine Funktion um die Klassifizierung der cnnModelFn zu interpretieren,
:param modelDir : string Pfad unter welchem das trainierte CnnModel gespeichert wird.
:example:
CnnModelSuit(cnnNotetypeModel, predictedClassesToNotetypeClassificationFn, "my/path/to/a/model/Dir")
"""
# Set model params
modelParams = {"learning_rate": learnRate}
#Setting up the Loggers
tf.logging.set_verbosity(tf.logging.INFO)
self.__logger = State().getLogger("DetectionCore_Component_Logger")
#The Function to interprete the Classification Vector
self.preditcionToClassificationFn = preditcionToClassificationFn
#The Cnn to be trained and to classify the inputs
self.__cnnClassifier = tf.estimator.Estimator(model_fn=cnnModelFn,
model_dir=modelDir,
params=modelParams)
# Set up logging for predictions
# Log the values in the "Softmax" tensor with label "probabilities"
self.__tensorsToLog = {"probabilities": "softmax_tensor"}
self.__loggingHook = tf.train.LoggingTensorHook(
tensors=self.__tensorsToLog, every_n_iter=50)
def __init__(self,
maxGradeOfLinesInPx=2,
marginTop=0.5,
marginBottom=0.5,
cannyThreshold1=50,
cannyThreshold2=150,
cannyApertureSize=3,
houghLinesRho=1,
houghLinesTheta=np.pi / 180,
houghLinesThreshold=200,
minDistanceToNextNoteRow=30,
minHeightOfNoteRow=20,
showImagesInWindow=True):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()", "NoteSheetScaleConstCalculator:__init__")
self.__averageHeight = 0
self.__maxGradeOfLinesInPx = maxGradeOfLinesInPx
self.__marginTop = marginTop
self.__marginBottom = marginBottom
self.__cannyThreshold1 = cannyThreshold1
self.__cannyThreshold2 = cannyThreshold2
self.__cannyApertureSize = cannyApertureSize
self.__houghLinesRho = houghLinesRho
self.__houghLinesTheta = houghLinesTheta
self.__houghLinesThreshold = houghLinesThreshold
self.__minDistanceToNextNoteRow = minDistanceToNextNoteRow
self.__minHeightOfNoteRow = minHeightOfNoteRow
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()", "NoteSheetScaleConstCalculator:__init__")
def __init__(self, config):
"""
Konstruktor
:param config:
"""
self.__logger = State().getLogger("Input_Component_Logger")
self.__logger.info("Starting __init__()", "Input:__init__")
self.__matParser = None
self.__lableParser = None
self.__matXMLPairCounter = 0
self.__matFileNamesForTestDataCreation = 0
self.__xmlFileNamesForTestDataCreation = 0
self.__createTraindataPdfDir = config["pathToCreateTrainDataFolder"]
self.__createTraindataXmlDir = config[
"pathToCreateTrainDataLabelFolder"]
self.__traindataDir = config["pathToTrainDataFolder"]
self.__pathToFileToClassify = config["pathToClassifiactionImage"]
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_1.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_10.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_15.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_rest_9.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_middle_5.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_middle_7.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_elements.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_38.pdf"
# self.__pathToFileToClassify = "./Input_Component\\Input\\clear_basic_41.pdf"
self.__logger.info("Finished __init__()", "Input:__init__")
def __init__(self, config):
"""
Konstruktor der BeatTemplateClassifier Klasse.
Initialisiert alle Membervariablen.
:param config: Die Config für diesen TemplateMatcher
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__templateFolder = config["templateFolder"]
self.__templateMethod = config["templateMethod"]
self.__removeIfFound = config["removeIfFound"]
self.__timeTemplates = []
self.__timeTemplates.append(self.__loadTemplate(2, 4))
self.__timeTemplates.append(self.__loadTemplate(3, 4))
self.__timeTemplates.append(self.__loadTemplate(4, 4))
self.__timeTemplates.append(self.__loadTemplate(5, 4))
self.__timeTemplates.append(self.__loadTemplate(6, 4))
self.__timeTemplates.append(self.__loadTemplate(3, 8))
self.__timeTemplates.append(self.__loadTemplate(6, 8))
self.__timeTemplates.append(self.__loadTemplate(9, 8))
self.__timeTemplates.append(self.__loadTemplate(12, 8))
self.__timeRatio = 47 / 97
self.__timeThreshold = 0.57 # max: 0.70 min: 0.44 mid: 0.57
for template in self.__timeTemplates:
self.__logger.info(
"Loaded Time Signature " + str(template[1]) + "/" +
str(template[2]) + " Template",
"TimeTemplateClassifier::__init__", template[0])
def init(self):
"""
Baut mithilfe eines PipeContructors, die Pipe zur Klassifizierung auf.
:return: successful : boolean Initialisierung erfolgreich?
:example:
pipeController.init()
"""
print("PipeController: Starting init() components with Config" +
self.__configFilePath)
"""Hier kann der ConfigInput mit einer anderen Realisierung des IConfigInput ausgetauscht werden."""
self.__configInput = ConfigInput(self.__configFilePath)
self.__config = self.__configInput.execute()
self.__controllerConfig = self.__config.getConfigForComponent(
"PipeController")
"""Todo: Check if Config ok """
"""Hier kann der ConfigInput mit einer anderen Realisierung des IConfigInput ausgetauscht werden."""
self.__state = State()
self.__state.init(self.__config.getConfigForComponent("State"))
self.__logger = State().getLogger("PipeController_Component_Logger")
"""Todo: Check if init ok """
"""Hier kann der PipeConstructor mit einer anderen Realisierung des IPipeConstructors ausgetauscht werden."""
self.__pipeConstructor = PipeConstructor(self.__config)
self.__pipe = self.__pipeConstructor.constructPipe()
"""Todo: Check if pipe ok """
self.__logger.info(
"Finished init() components with Config-Path: " +
self.__configFilePath, "PipeController:init")
return True
def __init__(self,
indexOfProcessMat=0,
maxGradeOfLinesInPx=2,
minDistanceToNextNoteRow=20,
marginTop=0.5,
marginBottom=0.5,
cannyThreshold1=50,
cannyThreshold2=150,
cannyApertureSize=3,
houghLinesRho=1,
houghLinesTheta=np.pi / 180,
houghLinesThreshold=200,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "NoteLineDetector:__init__")
self.__indexOfProcessMat = indexOfProcessMat
self.__maxGradeOfLinesInPx = maxGradeOfLinesInPx
self.__minDistanceToNextNoteRow = minDistanceToNextNoteRow
self.__marginTop = marginTop
self.__marginBottom = marginBottom
self.__cannyThreshold1 = cannyThreshold1
self.__cannyThreshold2 = cannyThreshold2
self.__cannyApertureSize = cannyApertureSize
self.__houghLinesRho = houghLinesRho
self.__houghLinesTheta = houghLinesTheta
self.__houghLinesThreshold = houghLinesThreshold
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()", "NoteLineDetector:__init__")
def __init__(self,
delimitWidthMax=30,
delimitWidthMin=20,
delimitHeightMin=20,
templateThreshold=0.55,
templateMethod=cv2.TM_CCOEFF_NORMED,
findCountersMode=cv2.RETR_LIST,
findCountersMethode=cv2.CHAIN_APPROX_NONE):
"""
Konstruktor für den ClefDetector.
:param delimitWidthMax: Maximale Breite eines Notenschlüssels.
:param delimitWidthMin: Minimale Breite eines Notenschlüssels.
:param delimitHeightMin: Minimale Höhe eines Notenschlüssels.
:param templateThreshold: Der Wert den das Template-Matching mindestens erreichen muss, damit ein Bildauschnitt als der jeweilige Notenschlüssel erkannt wird
:param templateMethod: Methode des Template-Matchers
:param findCountersMode: Modus des Konturfindungs-Algorithmus
:param findCountersMethode: Methode des Konturfindungs-Algorithmus
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "ClefDetector:__init__")
self.__delimitWidthMax = delimitWidthMax
self.__delimitWidthMin = delimitWidthMin
self.__delimitHeightMin = delimitHeightMin
self.__templateThreshold = templateThreshold
self.__templateMethod = templateMethod
self.__findCountersMode = findCountersMode
self.__findCountersMethode = findCountersMethode
self.__logger.info("Finished __init__()", "ClefDetector:__init__")
def __init__(self, config):
"""
Konstruktor der KeyTemplateClassifier Klasse.
Initialisiert alle Membervariablen.
:param config: Die Config für diesen TemplateMatcher
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__templateFolder = config["templateFolder"]
self.__templateMethod = config["templateMethod"]
self.__bTemplate = self.__loadTemplate(-1)
self.__bRatio = 29 / 97
self.__bThreshold = 0.61 # Max: 0.65 Min: 0.57 Mid: 0.61
self.__CrossTemplate = self.__loadTemplate(1)
self.__CrossRatio = 36 / 97
self.__CrossThreshold = 0.635 # Max: 0.68 Min: 0.59 Mid: 0.635
self.__logger.info(
"Loaded Key " + str(self.__bTemplate[1]) + " Template",
"KeyTemplateClassifier::__init__", self.__bTemplate[0])
self.__logger.info(
"Loaded Key " + str(self.__CrossTemplate[1]) + " Template",
"KeyTemplateClassifier::__init__", self.__CrossTemplate[0])
def __init__(self, outputPath=None, fillwithrests=True):
if (outputPath == None):
self.__outputPath = "output_musicxml.xml"
else:
self.__outputPath = outputPath
self.compare_lenght = 0.0
self.__fillwithrests = fillwithrests
self.__logger = State().getLogger("Output_Component_Logger")
def __init__(self, config):
"""
Constructor, initialisiert Membervariablen
:param Config : config Die Konfiguration.
:example:
PipeConstructor(config)
"""
self.__logger = State().getLogger("PipeController_Component_Logger")
self.__logger.info("Starting __init__()", "PipeConstructor:__init__")
self.__config = config
self.__logger.info("Finished __init__()", "PipeConstructor:__init__")
def __init__(self, showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"BitwiseNotPreprocessor:__init__")
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"BitwiseNotPreprocessor:__init__")
class GaussianBlurNoiseFilterPreprocessor(IPreprocessingUnit):
def __init__(self,
ksize,
sigmaX,
sigmaY=0,
borderType=cv2.BORDER_DEFAULT,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"GaussianBlurNoiseFilterPreprocessor:__init__")
self.__ksize = ksize
self.__sigmaX = sigmaX
self.__sigmaY = sigmaY
self.__borderType = borderType
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"GaussianBlurNoiseFilterPreprocessor:__init__")
def preProcess(self, mat):
"""
Führt den Rauschfilter gaussian blur auf eine Bildmatrix aus.
Parameters
----------
mat : Mat
Die Matrix auf welche der Rauschfilter gaussian blur ausgeführt werden soll.
Returns
-------
gaussianBlurMat : Mat
Die Ergebniss-Matrix auf die der Rauschfilter gaussian blur ausgeführt wurde.
Example
-------
>>> gaussianBlurNoiseFilterPreprocessor.preProcess()
"""
self.__logger.info("Starting preProcess()",
"GaussianBlurNoiseFilterPreprocessor:preProcess")
gaussianBlurMat = cv2.GaussianBlur(src=mat,
ksize=self.__ksize,
sigmaX=self.__sigmaX,
sigmaY=self.__sigmaY,
borderType=self.__borderType)
# Anzeigen des Ergebnisses Note
if (self.__showImagesInWindow):
cv2.imshow("GaussianBlurNoiseFilterPreprocessor", gaussianBlurMat)
cv2.waitKey(0)
self.__logger.info("Finished preProcess() with following Image: ",
"GaussianBlurNoiseFilterPreprocessor:preProcess",
gaussianBlurMat)
return gaussianBlurMat
class ScaleNoteSheetPreprocessor(IPreprocessingUnit):
def __init__(self,
averageHeight,
targetLineHeight=100,
interpolation=cv2.INTER_CUBIC,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"ScaleNoteSheetPreprocessor:__init__")
self.__averageHeight = averageHeight
self.__targetLineHeight = targetLineHeight
self.__interpolation = interpolation
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"ScaleNoteSheetPreprocessor:__init__")
def preProcess(self, mat):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
Example
-------
>>> ScaleNoteSheetPreprocessor.preProcess(mat)
"""
self.__logger.info("Starting preProcess()",
"ScaleNoteSheetPreprocessor:preProcess")
# Berechnung der neuen Bildgroesse
currentImageHeight = mat.shape[0]
currentImageWidth = mat.shape[1]
newImageHeight = int(currentImageHeight / (-self.__averageHeight) *
self.__targetLineHeight)
newImageWidth = int(currentImageWidth / (-self.__averageHeight) *
self.__targetLineHeight)
# Fuehrt eine Skalierung auf die angegeben Groesse aus
resizeMat = cv2.resize(mat, (newImageWidth, newImageHeight),
interpolation=self.__interpolation)
# Binarisieren des Bildes, da durch die Skalierung und das damit
# stattfindende Interpolieren zwischen Schwarz und Weiß verschiedene Graustufen entstehen
_, resultMat = cv2.threshold(resizeMat, 127, 255, cv2.THRESH_BINARY)
# Anzeigen des Ergebnisses Note
if (self.__showImagesInWindow):
cv2.imshow("ScaleNoteSheetPreprocessor", resultMat)
cv2.waitKey(0)
self.__logger.info("Finished preProcess() with following Image: ",
"ScaleNoteSheetPreprocessor:preProcess", resultMat)
return resultMat
def __init__(self, orderedPreprocessingUnits):
"""
Constructor, initialisiert Membervariablen
Parameters
----------
orderedPreprocessingUnits: list
Eine geordnete Liste von PreprrcessingUnits in Ausführungsreihenfolge.
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()", "Preprocessor:__init__()")
self.__orderedPrePorcessingUnits = orderedPreprocessingUnits
self.__logger.info("Finished __init__()", "Preprocessor:__init__()")
def __init__(self,
targetNumberOfRows=110,
targetNumberOfColumns=32,
interpolation=cv2.INTER_LINEAR,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "ImageResizer:__init__")
self.__targetNumberOfRows = targetNumberOfRows
self.__targetNumberOfColumns = targetNumberOfColumns
self.__interpolation = interpolation
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finsihed __init__()", "ImageResizer:__init__")
def __init__(self, config):
"""
Constructor, initialisiert Membervariablen
:param Config: config Die Konfiguration.
:example:
DetectionCore(config)
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "DetectionCore:__init__")
self.__fullClassifier = SheetMusicTemplateClassifier(
config["SheetMusicClassifier"])
"""
Todo:
self.__classificationCombiner = some ClassificationCombiner
Mehr fullClassifier können hier erstellt werden
"""
self.__logger.info("Finished __init__()", "DetectionCore:__init__")
def __init__(self,
averageHeight,
targetLineHeight=100,
interpolation=cv2.INTER_CUBIC,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"ScaleNoteSheetPreprocessor:__init__")
self.__averageHeight = averageHeight
self.__targetLineHeight = targetLineHeight
self.__interpolation = interpolation
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"ScaleNoteSheetPreprocessor:__init__")
def __init__(self, configPath):
"""
Constructor, initialisiert Membervariablen
Parameters
----------
configPath : string
Path to config file.
Example
-------
>>> ConfigInput("/path/to/config")
"""
self.__logger = State().getLogger("ConfigInput_Component_Logger")
self.__logger.info(
"Starting __init__() with ConfigPath: " + configPath,
"Input:__init__")
self.__configParser = JsonParser(configPath)
self.__logger.info(
"Finished __init__() with ConfigPath: " + configPath,
"Input:__init__")
def __init__(self,
ksize,
sigmaX,
sigmaY=0,
borderType=cv2.BORDER_DEFAULT,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"GaussianBlurNoiseFilterPreprocessor:__init__")
self.__ksize = ksize
self.__sigmaX = sigmaX
self.__sigmaY = sigmaY
self.__borderType = borderType
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"GaussianBlurNoiseFilterPreprocessor:__init__")
def __init__(self,
indexOfProcessMat=0,
anchorPoint=(-1, -1),
kernelWidth=1,
kernelHeight=3,
morphOfKernel=cv2.MORPH_RECT,
showImagesInWindow=True):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()",
"HorizontalLineRemoveDetector:__init__")
self.__indexOfProcessMat = indexOfProcessMat
self.__anchorPoint = anchorPoint
self.__kernelWidth = kernelWidth
self.__kernelHeight = kernelHeight
self.__morphOfKernel = morphOfKernel
self.__logger.info("Starting __init__()",
"HorizontalLineRemoveDetector:__init__")
self.__showImagesInWindow = showImagesInWindow
def __init__(self,
indexOfProcessMatWithoutLines=0,
indexOfProcessMatWithLines=1,
maxGradeOfLinesInPx=2,
marginTop=0.5,
marginBottom=0.5,
cannyThreshold1=50,
cannyThreshold2=150,
cannyApertureSize=3,
houghLinesRho=1,
houghLinesTheta=np.pi / 180,
houghLinesThreshold=5,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()",
"NoteHeightBlobClassifier:__init__")
self.__indexOfProcessMatWithoutLines = indexOfProcessMatWithoutLines
self.__indexOfProcessMatWithLines = indexOfProcessMatWithLines
self.__firstLineHeight = 0
self.__stepHeight = 0
self.__maxGradeOfLinesInPx = maxGradeOfLinesInPx
self.__marginTop = marginTop
self.__marginBottom = marginBottom
self.__cannyThreshold1 = cannyThreshold1
self.__cannyThreshold2 = cannyThreshold2
self.__cannyApertureSize = cannyApertureSize
self.__houghLinesRho = houghLinesRho
self.__houghLinesTheta = houghLinesTheta
self.__houghLinesThreshold = houghLinesThreshold
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finsihed __init__()",
"NoteHeightBlobClassifier:__init__")
def __init__(self,
templateThreshold=0.75,
templateMethod=cv2.TM_CCOEFF_NORMED,
findCountersMode=cv2.RETR_LIST,
findCountersMethode=cv2.CHAIN_APPROX_NONE):
"""
Konstruktor für den KeyDetector.
:param templateThreshold: Der Wert den das Template-Matching mindestens erreichen muss, damit ein Bildauschnitt als der jeweilige Key erkannt wird
:param templateMethod: Methode des Template-Matchers
:param findCountersMode: Modus des Konturfindungs-Algorithmus
:param findCountersMethode: Methode des Konturfindungs-Algorithmus
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "KeyDetector:__init__")
self.__templateThreshold = templateThreshold
self.__templateMethod = templateMethod
self.__findCountersMode = findCountersMode
self.__findCountersMethode = findCountersMethode
self.__logger.info("Finished __init__()", "KeyDetector:__init__")
def __init__(self, config):
"""
Konstruktor der ClefTemplateClassifier Klasse.
Initialisiert alle Membervariablen.
:param config: Die Config für diesen TemplateMatcher
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__templateFolder = config["templateFolder"]
self.__templateMethod = config["templateMethod"]
self.__removeIfFound = config["removeIfFound"]
self.__clefTemplates = []
self.__clefRatios = []
self.__clefThresholds = []
# Violin
self.__clefTemplates.append(self.__loadTemplate("G", 2))
self.__clefRatios.append(83 / 97)
self.__clefThresholds.append(0.52) # max: 0.77 min: 0.27 mid: 0.52
# Bass
self.__clefTemplates.append(self.__loadTemplate("F", 4))
self.__clefRatios.append(36 / 97)
self.__clefThresholds.append(0.64) # max: 0.76 min: 0.52 mid: 0.64
# Alt
self.__clefTemplates.append(self.__loadTemplate("C", 3))
self.__clefRatios.append(50 / 97)
self.__clefThresholds.append(0.535) # max: 0.58 min: 0.49 mid: 0.535
for template in self.__clefTemplates:
self.__logger.info(
"Loaded Clef " + template[1] + str(template[2]) + " Template",
"ClefTemplateClassifier::__init__", template[0])
class BitwiseNotPreprocessor(IPreprocessingUnit):
def __init__(self, showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("Preprocessing_Component_Logger")
self.__logger.info("Starting __init__()",
"BitwiseNotPreprocessor:__init__")
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()",
"BitwiseNotPreprocessor:__init__")
def preProcess(self, mat):
"""
Führt eine Inversierung (bit-weises not) auf eine Bildmatrix aus.
Parameters
----------
mat : Mat
Die Matrix auf welche die Operation ausgeführt werden soll.
Returns
-------
bitwiseNot : Mat
Die Ergebniss-Matrix auf die die Operation ausgeführt wurde.
Example
-------
>>> bitwiseNotPreprocessor.preProcess()
"""
self.__logger.info("Starting preProcess()",
"BitwiseNotPreprocessor:preProcess")
bitwiseNot = cv2.bitwise_not(mat)
# Anzeigen des Ergebnisses Note
if (self.__showImagesInWindow):
cv2.imshow("BitwiseNotPreprocessor", bitwiseNot)
cv2.waitKey(0)
self.__logger.info("Finished preProcess() with following Image: ",
"GaussianBlurNoiseFilterPreprocessor:preProcess",
bitwiseNot)
return bitwiseNot
def __init__(self,
indexOfProcessMat=0,
minNoteWidth_WithStem=15,
maxNoteWidth_WithStem=8,
minNoteHeight_WithStem=30,
maxNoteHeight_WithStem=80,
minNoteWidth_WithoutStem=8,
maxNoteWidth_WithoutStem=30,
minNoteHeight_WithoutStem=8,
maxNoteHeight_WithoutStem=23,
noteImageWidth=20,
findCountersMode=cv2.RETR_LIST,
findCountersMethode=cv2.CHAIN_APPROX_NONE,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "NoteDetector:__init__")
self.__indexOfProcessMat = indexOfProcessMat
self.__minNoteWidth_WithStem = minNoteWidth_WithStem
self.__maxNoteWidth_WithStem = maxNoteWidth_WithStem
self.__minNoteHeight_WithStem = minNoteHeight_WithStem
self.__maxNoteHeight_WithStem = maxNoteHeight_WithStem
self.__minNoteWidth_WithoutStem = minNoteWidth_WithoutStem
self.__maxNoteWidth_WithoutStem = maxNoteWidth_WithoutStem
self.__minNoteHeight_WithoutStem = minNoteHeight_WithoutStem
self.__maxNoteHeight_WithoutStem = maxNoteHeight_WithoutStem
self.__noteImageWidth = noteImageWidth
self.__findCountersMode = findCountersMode
self.__findCountersMethode = findCountersMethode
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finsihed __init__()", "NoteDetector:__init__")
def __init__(self,
modelDir,
gdLearnRateForTypeModel,
gdLearnRateForHightModel,
trainSteps,
evalInterval,
evalDataSize,
testDataSize,
trainTypeModel=True,
trainHightModel=True):
"""
Constructor, initialisiert Membervariablen.
:param modelDir : string Pfad unter welchem die trainierten CnnModelle gespeichert werden.
:example:
CnnNoteClassifier("my/path/to/a/model/Dir")
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__noteTypeCnn = CnnModelSuit(
cnnNotetypeModel, predictionToNotetypeClassificationFn,
modelDir + "/noteTypeModel", gdLearnRateForTypeModel)
self.__noteHightCnn = CnnModelSuit(
cnnNoteHightModel, predictionToNoteHightClassificationFn,
modelDir + "/noteHightModel", gdLearnRateForHightModel)
self.__gdLearnRateForTypeModel = gdLearnRateForTypeModel
self.__gdLearnRateForHightModel = gdLearnRateForHightModel
self.__trainSteps = trainSteps
self.__evalInterval = evalInterval
self.__evalDataSize = evalDataSize
self.__testDataSize = testDataSize
self.__trainTypeModel = trainTypeModel
self.__trainHightModel = trainHightModel
def __init__(self,
indexOfProcessMat=0,
tactLineWidthMax=8,
tactLineHeightMin=40,
minWidthOfTactLine=10,
findCountersMode=cv2.RETR_LIST,
findCountersMethode=cv2.CHAIN_APPROX_NONE,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "TactDetector:__init__")
self.__indexOfProcessMat = indexOfProcessMat
self.__tactLineWidthMax = tactLineWidthMax
self.__tactLineHeightMin = tactLineHeightMin
self.__minWidthOfTactLine = minWidthOfTactLine
self.__findCountersMode = findCountersMode
self.__findCountersMethode = findCountersMethode
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finished __init__()", "TactDetector:__init__")
def __init__(self,
fillRows=True,
fillColumns=True,
targetNumberOfRows=110,
targetNumberOfColumns=32,
appendRowsTop=False,
appendColumnsRight=True,
showImagesInWindow=False):
"""
To-Do:
Bitte Kommentar bzw. Dokumentaion erstellen!
"""
self.__logger = State().getLogger("DetectionCore_Component_Logger")
self.__logger.info("Starting __init__()", "ImageFiller:__init__")
self.__fillRows = fillRows
self.__fillColumns = fillColumns
self.__targetNumberOfRows = targetNumberOfRows
self.__targetNumberOfColumns = targetNumberOfColumns
self.__appendRowsTop = appendRowsTop
self.__appendColumnsRight = appendColumnsRight
self.__showImagesInWindow = showImagesInWindow
self.__logger.info("Finsihed __init__()", "ImageFiller:__init__")
class ConfigInput(IConfigInput):
def __init__(self, configPath):
"""
Constructor, initialisiert Membervariablen
Parameters
----------
configPath : string
Path to config file.
Example
-------
>>> ConfigInput("/path/to/config")
"""
self.__logger = State().getLogger("ConfigInput_Component_Logger")
self.__logger.info(
"Starting __init__() with ConfigPath: " + configPath,
"Input:__init__")
self.__configParser = JsonParser(configPath)
self.__logger.info(
"Finished __init__() with ConfigPath: " + configPath,
"Input:__init__")
def execute(self):
"""
Führt den entsprechenden Einlesevorgang über einen Parser durch und erstellt die Config.
Parameters
----------
Returns
-------
config : Config
Die erstellte Konfiguration.
Example
-------
>>> configInput.execute()
"""
self.__logger.info("Starting execute()", "Input:execute")
config = self.__configParser.parse()
self.__logger.info("Finished execute()", "Input:execute")
return config
