############################################################################################

#

# Project:       Peter Moss Acute Myeloid & Lymphoblastic Leukemia AI Research Project

# Repository:    ALL Detection System 2019

# Project:       Facial Authentication Server

#

# Author:        Adam Milton-Barker (AdamMiltonBarker.com)

# Contributors:

# Title:         Classifier Class

# Description:   Classifier for the ALL Detection System 2019.

# License:       MIT License

# Last Modified: 2020-07-21

#

############################################################################################

import cv2, os, sys, time

import numpy as np

from mvnc import mvncapi as mvnc

from Classes.Helpers import Helpers

from Classes.Movidius import Movidius

class Classifier():

    """ ALL Detection System 2019 Classifier Class

    Classifier for the ALL Detection System 2019.

    """

    def __init__(self):

        """ Initializes the Classifier Class. """

        self.Helpers = Helpers("Classifier")

        self.confs = self.Helpers.confs

        self.Movidius = Movidius()

        self.Movidius.checkNCS()

        self.Movidius.loadInception()

        self.Helpers.logger.info("Classifier class initialization complete.")

Classifier = Classifier()

def main(argv):

    humanStart, clockStart = Classifier.Helpers.timerStart()

    Classifier.Helpers.logger.info(

        "ALL Detection System 2019 Classifier started.")

    files = 0

    correct = 0

    incorrect = 0

    low = 0

    lowCorrect = 0

    lowIncorrect = 0

    rootdir = Classifier.confs["Classifier"]["TestImagePath"]

    for testFile in os.listdir(rootdir):

        if os.path.splitext(testFile)[1] in Classifier.confs["Classifier"]["ValidIType"]:

            files += 1

            fileName = rootdir + "/" + testFile

            img = cv2.imread(fileName).astype(np.float32)

            Classifier.Helpers.logger.info(

                "Loaded test image " + fileName)

            dx, dy, dz = img.shape

            delta = float(abs(dy-dx))

            if dx > dy:

                img = img[int(0.5*delta):dx-int(0.5*delta), 0:dy]

            else:

                img = img[0:dx, int(0.5*delta):dy-int(0.5*delta)]

            img = cv2.resize(img, (Classifier.Movidius.reqsize,

                                   Classifier.Movidius.reqsize))

            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

            for i in range(3):

                img[:, :, i] = (

                    img[:, :, i] - Classifier.Movidius.mean) * Classifier.Movidius.std

            detectionStart, detectionStart = Classifier.Helpers.timerStart()

            Classifier.Movidius.ncsGraph.LoadTensor(

                img.astype(np.float16), 'user object')

            output, userobj = Classifier.Movidius.ncsGraph.GetResult()

            detectionClockEnd, difference, detectionEnd = Classifier.Helpers.timerEnd(

                detectionStart)

            top_inds = output.argsort()[::-1][:5]

            if output[top_inds[0]] >= Classifier.confs["Classifier"]["InceptionThreshold"] and Classifier.Movidius.classes[top_inds[0]] == "1":

                if "_1." in fileName:

                    correct += 1

                    Classifier.Helpers.logger.info(

                        "ALL correctly detected with confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

                else:

                    incorrect += 1

                    Classifier.Helpers.logger.warning(

                        "ALL incorrectly detected with confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

            elif output[top_inds[0]] >= Classifier.confs["Classifier"]["InceptionThreshold"] and Classifier.Movidius.classes[top_inds[0]] == "0":

                if "_0." in fileName:

                    correct += 1

                    Classifier.Helpers.logger.info(

                        "ALL correctly not detected with confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

                else:

                    incorrect += 1

                    Classifier.Helpers.logger.warning(

                        "ALL incorrectly not detected with confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

            elif output[top_inds[0]] <= Classifier.confs["Classifier"]["InceptionThreshold"] and Classifier.Movidius.classes[top_inds[0]] == "1":

                if "_1." in fileName:

                    correct += 1

                    low += 1

                    lowCorrect += 1

                    Classifier.Helpers.logger.info(

                        "ALL correctly detected with LOW confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

                else:

                    incorrect += 1

                    low += 1

                    lowIncorrect += 1

                    Classifier.Helpers.logger.warning(

                        "ALL incorrectly detected with LOW confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

            elif output[top_inds[0]] <= Classifier.confs["Classifier"]["InceptionThreshold"] and Classifier.Movidius.classes[top_inds[0]] == "0":

                if "_0." in fileName:

                    correct += 1

                    low += 1

                    lowCorrect += 1

                    Classifier.Helpers.logger.info(

                        "ALL correctly not detected with LOW confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

                else:

                    low += 1

                    incorrect += 1

                    lowIncorrect += 1

                    Classifier.Helpers.logger.warning(

                        "ALL incorrectly not detected with LOW confidence of " + str(output[top_inds[0]]) + " in " + str(difference) + " seconds.")

    clockEnd, difference, humanEnd = Classifier.Helpers.timerEnd(clockStart)

    Classifier.Helpers.logger.info("Testing ended. " + str(correct) + " correct, " + str(incorrect) +

                                   " incorrect, " + str(low) + " low confidence: (" + str(lowCorrect) + " correct, " + str(lowIncorrect) + " incorrect)")

    Classifier.Movidius.ncsDevice.CloseDevice()

if __name__ == "__main__":

    main(sys.argv[1:])