Beispiel #1
0
def testTresorAvecCameraTable():
    camera = CameraFixe()
    photo = camera.prendrePhoto()
    cv2.imwrite("photo.jpg",photo)
    localisateurTresor = LocalisationTresor()
    listeTresor = localisateurTresor.trouverTresorParTable(photo,True)
    print listeTresor
Beispiel #2
0
def testTrouverTresor():
    photo = cv2.imread("../photos/Situations/situationTable3.jpg" )
    localisationRobot = LocalisationRobot()
    localisationRepere = LocalisationRepere()
    repere,ratio = localisationRepere.trouverRepere(photo)
    robot,orientation = localisationRobot.trouverRobot(photo)
    localisationTresor = LocalisationTresor()
    photoTresor = cv2.imread("../photos/Situations/situation3_90.jpg")
    tresor = localisationTresor.trouverTresorParRobot(photoTresor, orientation, 90, robot[0], robot[1], repere[0], repere[1], ratio, True)
 def setUp(self):
     self.localisationRobot = LocalisationRobot()
     self.localisationIles = LocalisationIle()
     self.localisationRepere = LocalisationRepere()
     self.localisationTresor = LocalisationTresor()
class TestFonctionnel_Vision(unittest.TestCase):

    numberOfShapes = 4
    carreIndex = 0
    triangleIndex = 0
    cercleIndex = 0
    pentagoneIndex = 0
    nombreDePhotoDIle = 20
    nombreDePhotoDuRobot = 16
    decalagePositionIles = 10

    photosPath = "../photos/"
    caracteristiquePath = "../data_photos/"

    boolCouleurCarreVisible = False
    boolCouleurTriangleVisible = False
    boolCouleurCercleVisible = False
    boolCouleurPentagoneVisible = False

    nomDuFichierALire = ""
    dataDuFichierLu = None

    listCaracteristiquesCarreLu = ""
    listCaracteristiquesTriangleLu = ""
    listCaracteristiquesCercleLu = ""
    listCaracteristiquesPentagoneLu = ""

    couleurCarreLu = ""
    xPositionCarreLu = 0
    yPositionCarreLu = 0

    couleurTriangleLu = 0
    xPositionTriangleLu = 0
    yPositionTriangleLu = 0

    couleurCercleLu = ""
    xPositionCercleLu = 0
    yPositionCercleLu = 0

    couleurPentagoneLu = ""
    xPositionPentagoneLu = 0
    yPositionPentagoneLu = 0

    listFormes = None
    listCouleurs = None
    listPosition = None
    repere = None

    couleurCarreTrouvee = ""
    xPositionCarreTrouvee = 0
    yPositionCarreTrouvee = 0

    couleurTriangleTrouvee = ""
    xPositionTriangleTrouvee = 0
    yPositionTriangleTrouvee = 0

    couleurCercleTrouvee = ""
    xPositionCercleTrouvee = 0
    yPositionCercleTrouvee = 0

    couleurPentagoneTrouvee = ""
    xPositionPentagoneTrouvee = 0
    yPositionPentagoneTrouvee = 0

    xPositionRobotLue = 0
    yPositionRobotLue = 0
    xPositionRobotTrouvee = 0
    yPositionRobotTrouvee = 0
    positionRobotTrouvee = (0, 0)
    orientationRobotLue = 0
    orientationRobotTrouvee = 0

    listCaracteristiquesTresorLu = ""

    positionXTresorPlusProcheLue = 0
    positionYTresorPlusProcheLue = 0

    def setUp(self):
        self.localisationRobot = LocalisationRobot()
        self.localisationIles = LocalisationIle()
        self.localisationRepere = LocalisationRepere()
        self.localisationTresor = LocalisationTresor()

    def test_ValiderPositionRobotTrouvee(self):
        for i in range(1, self.nombreDePhotoDuRobot):

            # Lecture fichier data
            nomPhoto = "table_OrientationRobot" + str(i) + ".jpg"

            self.loadRobotDataPhotos(nomPhoto)

            # Trouver data sur photo
            photo = cv2.imread(self.photosPath + nomPhoto, cv2.IMREAD_COLOR)
            nomPhoto = nomPhoto.replace("../photos\\", "")

            self.positionRobotTrouvee, self.orientationRobotTrouvee = self.localisationRobot.trouverRobot(photo)

            self.xPositionRobotTrouvee = self.positionRobotTrouvee[0]
            self.yPositionRobotTrouvee = self.positionRobotTrouvee[1]
            self.orientationRobotTrouvee = self.orientationRobotTrouvee

            try:
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionRobot(self.xPositionRobotLue, self.xPositionRobotTrouvee)
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionRobot(self.yPositionRobotLue, self.yPositionRobotTrouvee)
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_orientationRobot(
                        self.orientationRobotLue, self.orientationRobotTrouvee
                    )
                )
                print "{0} Ok".format(nomPhoto)
            except AssertionError:
                print "{0}: Mauvaise position ou orientation".format(nomPhoto)
                print "x voulue, x trouve: {0}, {1}".format(self.xPositionRobotLue, self.xPositionRobotTrouvee)
                print "y voulue, y trouve: {0}, {1}".format(self.yPositionRobotLue, self.yPositionRobotTrouvee)
                print "orientation voulue, orientation trouve: {0}, {1}".format(
                    self.orientationRobotLue, self.orientationRobotTrouvee
                )

    def test_ValiderCaracteristiquesIlesTrouveesParFonctionTrouverIles(self):

        for i in range(1, self.nombreDePhotoDIle):

            # Lecture fichier data
            nomPhoto = "table_iles_robot" + str(i) + ".jpg"
            # print nomPhoto

            self.loadIlesDataPhotos(nomPhoto)

            # Trouver data sur photo
            photo = cv2.imread(self.photosPath + nomPhoto, cv2.IMREAD_COLOR)
            nomPhoto = nomPhoto.replace("../photos\\", "")

            try:
                self.listFormes, self.listCouleurs, self.listPosition = self.localisationIles.trouverIles(photo)

            except Exception as e:
                print "{0}: {1}".format(nomPhoto, e.message)
                continue

            self.assignerIndexFormes()
            self.loadIlesDataTrouvee()

            try:
                # CARRE
                self.assertEquals(
                    self.couleurCarreTrouvee,
                    self.couleurCarreLu,
                    self.messageErreurCouleur(nomPhoto, self.couleurCarreLu, self.couleurCarreTrouvee),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.xPositionCarreLu, self.xPositionCarreTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "xPositionCarreLu",
                        self.xPositionCarreLu,
                        "xPositionCarreTrouvee",
                        self.xPositionCarreTrouvee,
                    ),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.yPositionCarreLu, self.yPositionCarreTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "yPositionCarreLu",
                        self.yPositionCarreLu,
                        "yPositionCarreTrouvee",
                        self.yPositionCarreTrouvee,
                    ),
                )

                # TRIANGLE
                self.assertEquals(
                    self.couleurTriangleTrouvee,
                    self.couleurTriangleLu,
                    self.messageErreurCouleur(nomPhoto, self.couleurTriangleLu, self.couleurTriangleTrouvee),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.xPositionTriangleLu, self.xPositionTriangleTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "xPositionTriangleLu",
                        self.xPositionTriangleLu,
                        "xPositionTriangleTrouvee",
                        self.xPositionTriangleTrouvee,
                    ),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.yPositionTriangleLu, self.yPositionTriangleTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "yPositionTriangleLu",
                        self.yPositionTriangleLu,
                        "yPositionTriangleTrouvee",
                        self.yPositionTriangleTrouvee,
                    ),
                )

                # CERCLE
                self.assertEquals(
                    self.couleurCercleTrouvee,
                    self.couleurCercleLu,
                    self.messageErreurCouleur(nomPhoto, self.couleurCercleLu, self.couleurCercleTrouvee),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.xPositionCercleLu, self.xPositionCercleTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "xPositionCercleLu",
                        self.xPositionCercleLu,
                        "xPositionCercleTrouvee",
                        self.xPositionCercleTrouvee,
                    ),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(self.yPositionCercleLu, self.yPositionCercleTrouvee),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "yPositionCercleLu",
                        self.yPositionCercleLu,
                        "yPositionCercleTrouvee",
                        self.yPositionCercleTrouvee,
                    ),
                )

                # PENTAGONE
                self.assertEquals(
                    self.couleurPentagoneTrouvee,
                    self.couleurPentagoneLu,
                    self.messageErreurCouleur(nomPhoto, self.couleurPentagoneLu, self.couleurPentagoneTrouvee),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(
                        self.xPositionPentagoneLu, self.xPositionPentagoneTrouvee
                    ),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "xPositionPentagoneLu",
                        self.xPositionPentagoneLu,
                        "xPositionPentagoneTrouvee",
                        self.xPositionPentagoneTrouvee,
                    ),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionIle(
                        self.yPositionPentagoneLu, self.yPositionPentagoneTrouvee
                    ),
                    self.messageErreurPositionIles(
                        nomPhoto,
                        "yPositionPentagoneLu",
                        self.yPositionPentagoneLu,
                        "yPositionPentagoneTrouvee",
                        self.yPositionPentagoneTrouvee,
                    ),
                )

                print "{0} Ok".format(nomPhoto)
            except AssertionError as e:
                print "AssertionError: " + e.message
                continue

    def test_ValiderDetectionDesTresor(self):

        for i in range(1, 10):
            nomPhoto = "../photos/Situations/situationTable" + str(i) + ".jpg"
            photoTable = cv2.imread(nomPhoto, cv2.IMREAD_COLOR)

            photos = glob.glob("../photos/Situations/*.jpg")
            photoRobot = cv2.imread(photos[i - 1], cv2.IMREAD_COLOR)

            orientationCamera = photos[i - 1].replace("../photos/Situations\\", "")[11:].replace(".jpg", "")
            (positionRobotX, positionRobotY), orientationRobot = self.localisationRobot.trouverRobot(photoTable)
            (positionRepereX, positionRepereY), ratio = self.localisationRepere.trouverRepere(photoTable)

            positionTresorXTrouvee, positionTresorYTrouvee, distance, cote = self.localisationTresor.trouverTresor(
                image=photoRobot,
                orientationRobot=orientationRobot,
                orientationCamera=0,  # float(orientationCamera),
                positionXRobot=positionRobotX,
                positionYRobot=positionRobotY,
                repereX=positionRepereX,
                repereY=positionRepereY,
                ratio=ratio,
            )  # ,

            self.loadTresorDataPhotos(i)

            print "OrientationRobot: " + str(orientationRobot)
            print "OrientationCamera: " + str(orientationCamera)
            print "PositionRobotX: " + str(positionRobotX)
            print "PositionRobotY: " + str(positionRobotY)
            print "PositionXTresorLue: " + str(self.positionXTresorPlusProcheLue)
            print "PositionYTresorLue: " + str(self.positionYTresorPlusProcheLue)
            print "PositionXTresorTrouvee: " + str(positionTresorXTrouvee)
            print "PositionYTresorTrouvee: " + str(positionTresorYTrouvee)

            try:
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionTresor(
                        self.positionXTresorPlusProcheLue, positionTresorXTrouvee
                    ),
                    self.messageErreurPositionTresor(
                        nomPhoto, self.positionXTresorPlusProcheLue, positionTresorXTrouvee
                    ),
                )
                self.assertTrue(
                    self.sontEgauxAvecMargeDerreur_positionTresor(
                        self.positionYTresorPlusProcheLue, positionTresorYTrouvee
                    ),
                    self.messageErreurPositionTresor(
                        nomPhoto, self.positionYTresorPlusProcheLue, positionTresorYTrouvee
                    ),
                )
            except AssertionError as e:
                print "AssertionError: " + e.message
                continue

    # Utility functions
    def CouleursTousVisibles(self):
        return (
            self.boolCouleurCarreVisible
            and self.boolCouleurTriangleVisible
            and self.boolCouleurCercleVisible
            and self.boolCouleurPentagoneVisible
        )

    def loadIlesDataPhotos(self, nomPhoto):

        nomPhoto = nomPhoto.replace(".jpg", "")
        nomDuFichierALire = self.caracteristiquePath + "dataIles_" + nomPhoto + ".txt"
        dataDuFichierLu = open(nomDuFichierALire, "r")

        self.listCaracteristiquesCarreLu = dataDuFichierLu.readline().split()
        self.listCaracteristiquesTriangleLu = dataDuFichierLu.readline().split()
        self.listCaracteristiquesCercleLu = dataDuFichierLu.readline().split()
        self.listCaracteristiquesPentagoneLu = dataDuFichierLu.readline().split()

        self.couleurCarreLu = self.listCaracteristiquesCarreLu[1]
        self.xPositionCarreLu = self.listCaracteristiquesCarreLu[2]
        self.yPositionCarreLu = self.listCaracteristiquesCarreLu[3]

        self.couleurTriangleLu = self.listCaracteristiquesTriangleLu[1]
        self.xPositionTriangleLu = self.listCaracteristiquesTriangleLu[2]
        self.yPositionTriangleLu = self.listCaracteristiquesTriangleLu[3]

        self.couleurCercleLu = self.listCaracteristiquesCercleLu[1]
        self.xPositionCercleLu = self.listCaracteristiquesCercleLu[2]
        self.yPositionCercleLu = self.listCaracteristiquesCercleLu[3]

        self.couleurPentagoneLu = self.listCaracteristiquesPentagoneLu[1]
        self.xPositionPentagoneLu = self.listCaracteristiquesPentagoneLu[2]
        self.yPositionPentagoneLu = self.listCaracteristiquesPentagoneLu[3]

    def loadRobotDataPhotos(self, nomPhoto):
        nomDuFichierALire = self.caracteristiquePath + "dataRobot_" + nomPhoto + ".txt"
        dataDuFichierLu = open(nomDuFichierALire, "r")

        data = dataDuFichierLu.readline().split()
        self.xPositionRobotLue = data[0]
        self.yPositionRobotLue = data[1]
        self.orientationRobotLue = data[2]

    def assignerIndexFormes(self):
        for i in range(self.numberOfShapes - 1):
            self.carreIndex = self.listFormes.index("carre")
            self.triangleIndex = self.listFormes.index("triangle")
            self.cercleIndex = self.listFormes.index("cercle")
            self.pentagoneIndex = self.listFormes.index("pentagon")

    def loadIlesDataTrouvee(self):
        self.couleurCarreTrouvee = self.listCouleurs[self.carreIndex]
        self.xPositionCarreTrouvee = self.listPosition[self.carreIndex][0]
        self.yPositionCarreTrouvee = self.listPosition[self.carreIndex][1]

        self.couleurTriangleTrouvee = self.listCouleurs[self.triangleIndex]
        self.xPositionTriangleTrouvee = self.listPosition[self.triangleIndex][0]
        self.yPositionTriangleTrouvee = self.listPosition[self.triangleIndex][1]

        self.couleurCercleTrouvee = self.listCouleurs[self.cercleIndex]
        self.xPositionCercleTrouvee = self.listPosition[self.cercleIndex][0]
        self.yPositionCercleTrouvee = self.listPosition[self.cercleIndex][1]

        self.couleurPentagoneTrouvee = self.listCouleurs[self.pentagoneIndex]
        self.xPositionPentagoneTrouvee = self.listPosition[self.pentagoneIndex][0]
        self.yPositionPentagoneTrouvee = self.listPosition[self.pentagoneIndex][1]

    def loadTresorDataPhotos(self, iteration):

        nomDuFichierALire = self.caracteristiquePath + "dataRobot_situationTable" + str(iteration) + ".jpg.txt"
        dataDuFichierLu = open(nomDuFichierALire, "r")

        self.listCaracteristiquesTresorLu = dataDuFichierLu.readline().split()

        self.positionXTresorPlusProcheLue = self.listCaracteristiquesTresorLu[0]
        self.positionYTresorPlusProcheLue = self.listCaracteristiquesTresorLu[1]

    def sontEgauxAvecMargeDerreur_positionIle(self, valeurAttendue, valeurTrouvee):
        decalage = 10
        return int(valeurAttendue) - decalage <= valeurTrouvee <= int(valeurAttendue) + decalage

    def sontEgauxAvecMargeDerreur_positionRobot(self, valeurAttendue, valeurTrouvee):
        decalage = 10
        return int(valeurAttendue) - decalage <= valeurTrouvee <= int(valeurAttendue) + decalage

    def sontEgauxAvecMargeDerreur_orientationRobot(self, valeurAttendue, valeurTrouvee):
        decalage = 4
        return float(valeurAttendue) - decalage <= valeurTrouvee <= float(valeurAttendue) + decalage

    def sontEgauxAvecMargeDerreur_positionTresor(self, valeurAttendue, valeurTrouvee):
        decalage = 10
        return int(valeurAttendue) - decalage <= valeurTrouvee <= int(valeurAttendue) + decalage

    def messageErreurPositionIles(
        self, nomPhoto, nomValeurAttendue, valeurAttendue, nomValeurRetournee, valeurRetournee
    ):
        message = "{0}: {1} (+/- {2}): {3}, {4} (+/- {2}): {5}".format(
            nomPhoto, nomValeurAttendue, self.decalagePositionIles, valeurAttendue, nomValeurRetournee, valeurRetournee
        )

        return message

    def messageErreurCouleur(self, nomPhoto, valeurAttendue, valeurRetournee):
        message = "{0}: valeur attendu: {1}, valeur retournee: {2}".format(nomPhoto, valeurAttendue, valeurRetournee)

        return message

    def messageErreurPositionTresor(self, nomPhoto, valeurAttendue, valeurRetournee):
        message = "{0}: valeur attendu: {1}, valeur retournee: {2}".format(nomPhoto, valeurAttendue, valeurRetournee)

        return message