def get(self):
parser = reqparse.RequestParser()
parser.add_argument('filePath', type=str)
parser.add_argument('segmentationMethod', type=str)
parser.add_argument('noiseMethod', type=str)
args = parser.parse_args()
srcPath = args['filePath']
segmentationMethod = args['segmentationMethod']
noiseMethod = args['noiseMethod']
srcImage = cv2.imread(srcPath, cv2.CV_8UC1)
segmentationResults, mask, maskPreview = segmentation(srcImage, segmentationMethod, noiseMethod)
maskFilePath = getNewFilePath(srcPath, 'segmentation-mask')
maskedImagePath = getNewFilePath(srcPath, 'segmentation-mask-prev')
cv2.imwrite(maskFilePath, mask)
cv2.imwrite(maskedImagePath, maskPreview)
return {
'workingImage': srcPath,
'mask': maskFilePath,
'imageMasked': maskedImagePath,
**segmentationResults,
}
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('normalizedImage', type=str)
parser.add_argument('normalizedMask', type=str)
parser.add_argument('minWaveLength', type=float)
parser.add_argument('sigmaOnf', type=float)
args = parser.parse_args()
normalizedImagePath = args['normalizedImage']
normalizedMaskPath = args['normalizedMask']
minWaveLength = args['minWaveLength']
sigmaOnf = args['sigmaOnf']
normalizedImage = cv2.imread(normalizedImagePath, cv2.CV_8UC1)
normalizedMask = cv2.imread(normalizedMaskPath, cv2.CV_8UC1)
imageTemplate, maskTemplate = encode(normalizedImage, normalizedMask,
minWaveLength, 1, sigmaOnf)
imageTemplatePath = getNewFilePath(normalizedImagePath,
'encoding-loggabor-img-template')
maskTemplatePath = getNewFilePath(normalizedImagePath,
'encoding-loggabor-mask-template')
cv2.imwrite(imageTemplatePath, imageTemplate)
cv2.imwrite(maskTemplatePath, maskTemplate)
return {
'imageTemplate': imageTemplatePath,
'maskTemplate': maskTemplatePath
}
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('filePath', type=str)
parser.add_argument('mask', type=str)
parser.add_argument('irisCenterX', type=int)
parser.add_argument('irisCenterY', type=int)
parser.add_argument('irisR', type=int)
parser.add_argument('pupilCenterX', type=int)
parser.add_argument('pupilCenterY', type=int)
parser.add_argument('pupilR', type=int)
parser.add_argument('height', type=int)
parser.add_argument('width', type=int)
args = parser.parse_args()
srcPath = args['filePath']
maskPath = args['mask']
irisCenterX = args['irisCenterX']
irisCenterY = args['irisCenterY']
irisR = args['irisR']
pupilCenterX = args['pupilCenterX']
pupilCenterY = args['pupilCenterY']
pupilR = args['pupilR']
height = args['height']
width = args['width']
srcImage = cv2.imread(srcPath, cv2.CV_8UC1)
mask = cv2.imread(maskPath, cv2.CV_8UC1)
normalizedImage, normalizedMask, normalizedImageMasked = normalize_daugman(
srcImage, mask, irisCenterX, irisCenterY, irisR, pupilCenterX,
pupilCenterY, pupilR, width, height)
normalizedImagePath = getNewFilePath(srcPath, 'normalize-daug-img')
normalizedMaskPath = getNewFilePath(maskPath, 'normalize-daug-mask')
normalizedImageMaskedPath = getNewFilePath(srcPath,
'normalize-daug-mask-prev')
cv2.imwrite(normalizedImagePath, normalizedImage)
cv2.imwrite(normalizedMaskPath, normalizedMask)
cv2.imwrite(normalizedImageMaskedPath, normalizedImageMasked)
return {
'workingImage': srcPath,
'workingMask': maskPath,
'normalizedImage': normalizedImagePath,
'normalizedMask': normalizedMaskPath,
'normalizedImageMasked': normalizedImageMaskedPath,
}
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('filePath', type=str)
parser.add_argument('kernelSize', type=int)
args = parser.parse_args()
srcPath = args['filePath']
kernelSize = args['kernelSize']
srcImage = cv2.imread(srcPath, cv2.CV_8UC1)
processedImage = filter2D(srcImage, kernelSize)
newFilePath = getNewFilePath(srcPath, 'preprocessing-filter2D')
cv2.imwrite(newFilePath, processedImage)
return {'workingImage': srcPath, 'processedImage': newFilePath}
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('filePath', type=str)
args = parser.parse_args()
srcPath = args['filePath']
srcImage = cv2.imread(srcPath, cv2.CV_8UC1)
processedImage = histogramNorm(srcImage)
newFilePath = getNewFilePath(srcPath, 'preprocessing-histogram')
cv2.imwrite(newFilePath, processedImage)
return {
'workingImage': srcPath,
'processedImage': newFilePath
}
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('filePath', type=str)
parser.add_argument('kernelWidth', type=int)
parser.add_argument('kernelHeight', type=int)
parser.add_argument('sigmaX', type=int)
parser.add_argument('sigmaY', type=int)
args = parser.parse_args()
srcPath = args['filePath']
kernelWidth = args['kernelWidth']
kernelHeight = args['kernelHeight']
sigmaX = args['sigmaX']
sigmaY = args['sigmaY']
srcImage = cv2.imread(srcPath, cv2.CV_8UC1)
processedImage = gauss(srcImage, kernelWidth, kernelHeight, sigmaX,
sigmaY)
newFilePath = getNewFilePath(srcPath, 'preprocessing-gauss')
cv2.imwrite(newFilePath, processedImage)
return {'workingImage': srcPath, 'processedImage': newFilePath}
def processSingleImage(imagePath, processConfig, cachedResults=False):
orgImage = cv2.imread(imagePath, cv2.CV_8UC1)
image = orgImage.copy()
# Creating new entry
proxyImagePath = generateNewProxyImagePath(imagePath)
cv2.imwrite(proxyImagePath, orgImage)
# Preprocessing the image
preprocessingImages = []
preprocessingImagesPaths = []
preprocessingEntries = processConfig[processSteps.PREPROCESSING]
numberOfPreprocessingEntries = len(preprocessingEntries)
shouldBePreprocessed = numberOfPreprocessingEntries > 0
if shouldBePreprocessed:
for i in range(numberOfPreprocessingEntries):
currentPreprocessingEntry = preprocessingEntries[i]
currentPreprocessingMethod, methodParams = getMethodHandlerAndMethodParams(
processSteps.PREPROCESSING, currentPreprocessingEntry)
image = currentPreprocessingMethod(image, **methodParams)
preprocessingImagePath = getNewFilePath(proxyImagePath,
'preprocessing')
cv2.imwrite(preprocessingImagePath, image)
preprocessingImages.append(image)
preprocessingImagesPaths.append(preprocessingImagePath)
# Performing segmentation
segmentationArgs = processConfig[processSteps.SEGMENTATION]
segmentationMethod = METHODS[processSteps.SEGMENTATION]
if (cachedResults and imagePath in cachedResults):
print('Getting cached results for {}'.format(imagePath))
currentCache = cachedResults[imagePath]['processingImageData']
segmentationResults = currentCache['segmentationResults']
mask = cv2.imread(currentCache['imagePaths']['mask'], cv2.CV_8UC1)
maskPreview = cv2.imread(currentCache['imagePaths']['imageMasked'],
cv2.CV_8UC1)
else:
segmentationResults, mask, maskPreview = segmentationMethod(
image, **segmentationArgs)
maskPath = getNewFilePath(proxyImagePath, 'segmentation-mask')
maskPreviewPath = getNewFilePath(proxyImagePath,
'segmentation-mask-preview')
cv2.imwrite(maskPath, mask)
cv2.imwrite(maskPreviewPath, maskPreview)
# Performing normalization
normalizationMethod, normalizationParams = getMethodHandlerAndMethodParams(
processSteps.NORMALIZATION, processConfig[processSteps.NORMALIZATION])
normalizedImage, normalizedMask, normalizedImageMasked = normalizationMethod(
image, mask, **segmentationResults, **normalizationParams)
normalizedImagePath = getNewFilePath(proxyImagePath, 'normalization-image')
normalizedMaskPath = getNewFilePath(proxyImagePath, 'normalization-mask')
normalizedImageMaskedPath = getNewFilePath(proxyImagePath,
'normalization-mask-preview')
cv2.imwrite(normalizedImagePath, normalizedImage)
cv2.imwrite(normalizedMaskPath, normalizedMask)
cv2.imwrite(normalizedImageMaskedPath, normalizedImageMasked)
# Performing encoding
encodingMethod, encodingParams = getMethodHandlerAndMethodParams(
processSteps.ENCODING, processConfig[processSteps.ENCODING])
if processConfig[processSteps.ENCODING]['method'] == 'LOG_GABOR':
encodingParams = {**encodingParams, 'mult': 1}
irisTemplate, maskTemplate = encodingMethod(normalizedImage,
normalizedMask,
**encodingParams)
irisTemplatePath = getNewFilePath(proxyImagePath, 'encoding-iris-template')
maskTemplatePath = getNewFilePath(proxyImagePath, 'encoding-mask-template')
cv2.imwrite(irisTemplatePath, irisTemplate)
cv2.imwrite(maskTemplatePath, maskTemplate)
return {
'images': {
'originalImage': orgImage,
'preprocessedImages': preprocessingImages,
'mask': mask,
'imageMasked': maskPreview,
'normalizedImage': normalizedImage,
'normalizedMask': normalizedMask,
'normalizedImageMasked': normalizedImageMasked,
'irisTemplate': irisTemplate,
'maskTemplate': maskTemplate,
},
'imagePaths': {
'originalImage': imagePath,
'preprocessingImages': preprocessingImagesPaths,
'mask': maskPath,
'imageMasked': maskPreviewPath,
'normalizedImage': normalizedImagePath,
'normalizedMask': normalizedMaskPath,
'normalizedImageMasked': normalizedImageMaskedPath,
'irisTemplate': irisTemplatePath,
'maskTemplate': maskTemplatePath,
},
'segmentationResults': segmentationResults,
}