예제 #1
0
    def testNetworkOneImage(self, enableViz=False):
        if self.testingImageIndex < self.numTestingImages:
            saccadeList = []
            saccadeImgsList = []
            saccadeHistList = []
            saccadeDetailList = []
            inferredCategoryList = []
            originalImage = None

            self.networkTM.executeCommand(["reset"])
            for i in range(SACCADES_PER_IMAGE_TESTING):
                self.net.run(1)
                if originalImage is None:
                    originalImage = deserializeImage(
                        yaml.load(
                            self.networkSensor.getParameter("originalImage")))
                    imgCenter = (
                        originalImage.size[0] / 2,
                        originalImage.size[1] / 2,
                    )
                saccadeList.append({
                    "offset1": (yaml.load(
                        self.networkSensor.getParameter("prevSaccadeInfo"))
                                ["prevOffset"]),
                    "offset2": (yaml.load(
                        self.networkSensor.getParameter("prevSaccadeInfo"))
                                ["newOffset"])
                })
                inferredCategoryList.append(
                    self.networkClassifier.getOutputData(
                        "categoriesOut").argmax())

                if enableViz:
                    detailImage = deserializeImage(
                        yaml.load(
                            self.networkSensor.getParameter("outputImage")))
                    detailImage = detailImage.resize(
                        (self.detailedSaccadeWidth,
                         self.detailedSaccadeHeight), Image.ANTIALIAS)
                    saccadeDetailList.append(ImageTk.PhotoImage(detailImage))

                    imgWithSaccade = originalImage.convert("RGB")
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Left
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Right
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Top
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Bottom

                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Left
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Right
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Top
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Bottom

                    saccadeImgsList.append(ImageTk.PhotoImage(imgWithSaccade))

                    saccadeHist = originalImage.convert("RGB")
                    for i, saccade in enumerate(saccadeList):
                        ImageDraw.Draw(saccadeHist).rectangle(
                            (imgCenter[0] + saccade["offset2"][0] -
                             _FOVEA_SIZE / 2, imgCenter[0] +
                             saccade["offset2"][1] - _FOVEA_SIZE / 2,
                             imgCenter[0] + saccade["offset2"][0] +
                             _FOVEA_SIZE / 2, imgCenter[0] +
                             saccade["offset2"][1] + _FOVEA_SIZE / 2),
                            fill=(0, (255 / SACCADES_PER_IMAGE_TESTING *
                                      (SACCADES_PER_IMAGE_TESTING - i)),
                                  (255 / SACCADES_PER_IMAGE_TESTING * i)))
                    saccadeHist = saccadeHist.resize(
                        (self.detailedSaccadeWidth,
                         self.detailedSaccadeHeight), Image.ANTIALIAS)
                    saccadeHistList.append(ImageTk.PhotoImage(saccadeHist))

            inferredCategory = self._getMostCommonCategory(
                inferredCategoryList)
            isCorrectClassification = False
            if self.networkSensor.getOutputData(
                    "categoryOut") == inferredCategory:
                isCorrectClassification = True
                self.numCorrect += 1
            print("Iteration: {iter}; Category: {cat}".format(
                iter=self.testingImageIndex,
                cat=self.networkSensor.getOutputData("categoryOut")))
            self.testingImageIndex += 1

            if enableViz:
                return (saccadeImgsList, saccadeDetailList, saccadeHistList,
                        inferredCategoryList,
                        self.networkSensor.getOutputData("categoryOut"),
                        isCorrectClassification)
            return (True, isCorrectClassification)

        else:
            return False
예제 #2
0
  def testNetworkOneImage(self, enableViz=False):
    if self.testingImageIndex < self.numTestingImages:
      saccadeList = []
      saccadeImgsList = []
      saccadeHistList = []
      saccadeDetailList = []
      inferredCategoryList = []
      originalImage = None

      self.networkTM.executeCommand(["reset"])
      for i in range(SACCADES_PER_IMAGE_TESTING):
        self.net.run(1)
        if originalImage is None:
          originalImage = deserializeImage(
              yaml.load(self.networkSensor.getParameter("originalImage")))
          imgCenter = (originalImage.size[0] / 2,
                       originalImage.size[1] / 2,)
        saccadeList.append({
            "offset1":
                (yaml.load(
                    self.networkSensor
                    .getParameter("prevSaccadeInfo"))
                 ["prevOffset"]),
            "offset2":
                (yaml.load(
                    self.networkSensor
                    .getParameter("prevSaccadeInfo"))
                 ["newOffset"])})
        inferredCategoryList.append(
            self.networkClassifier.getOutputData("categoriesOut").argmax())

        if enableViz:
          detailImage = deserializeImage(
              yaml.load(self.networkSensor.getParameter("outputImage")))
          detailImage = detailImage.resize((self.detailedSaccadeWidth,
                                            self.detailedSaccadeHeight),
                                           Image.ANTIALIAS)
          saccadeDetailList.append(ImageTk.PhotoImage(detailImage))

          imgWithSaccade = originalImage.convert("RGB")
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Left
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Right
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Top
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Bottom

          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Left
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Right
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Top
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Bottom

          saccadeImgsList.append(ImageTk.PhotoImage(imgWithSaccade))

          saccadeHist = originalImage.convert("RGB")
          for i, saccade in enumerate(saccadeList):
            ImageDraw.Draw(saccadeHist).rectangle(
                (imgCenter[0] + saccade["offset2"][0] - _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][1] - _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][0] + _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][1] + _FOVEA_SIZE/2),
                fill=(0,
                      (255/SACCADES_PER_IMAGE_TESTING*(SACCADES_PER_IMAGE_TESTING-i)),
                      (255/SACCADES_PER_IMAGE_TESTING*i)))
          saccadeHist = saccadeHist.resize((self.detailedSaccadeWidth,
                                            self.detailedSaccadeHeight),
                                           Image.ANTIALIAS)
          saccadeHistList.append(ImageTk.PhotoImage(saccadeHist))

      inferredCategory = self._getMostCommonCategory(inferredCategoryList)
      isCorrectClassification = False
      if self.networkSensor.getOutputData("categoryOut") == inferredCategory:
        isCorrectClassification = True
        self.numCorrect += 1
      print ("Iteration: {iter}; Category: {cat}"
             .format(iter=self.testingImageIndex,
                     cat=self.networkSensor.getOutputData("categoryOut")))
      self.testingImageIndex += 1

      if enableViz:
        return (saccadeImgsList, saccadeDetailList, saccadeHistList,
                inferredCategoryList,
                self.networkSensor.getOutputData("categoryOut"),
                isCorrectClassification)
      return (True, isCorrectClassification)

    else:
      return False
예제 #3
0
    def runNetworkOneImage(self, enableViz=False):
        """ Runs a single image through the network stepping through all saccades

    :param bool enableViz: If true, visualizations are generated and returned
    :return: If enableViz, return a tuple (saccadeImgsList, saccadeDetailList,
      saccadeHistList). saccadeImgsList is a list of images with the fovea
      highlighted. saccadeDetailList is a list of resized images showing the
      contents of the fovea. saccadeHistList shows the fovea history.
      If not enableViz, returns True
      Regardless of enableViz, if False is returned, all images have been
      saccaded over.
    """
        if self.trainingImageIndex < self.numTrainingImages:

            saccadeList = []
            saccadeImgsList = []
            saccadeHistList = []
            saccadeDetailList = []
            originalImage = None

            self.networkTM.executeCommand(["reset"])

            for i in range(SACCADES_PER_IMAGE_TRAINING):
                self.net.run(1)
                if originalImage is None:
                    originalImage = deserializeImage(
                        yaml.load(
                            self.networkSensor.getParameter("originalImage")))
                    imgCenter = (
                        originalImage.size[0] / 2,
                        originalImage.size[1] / 2,
                    )
                saccadeList.append({
                    "offset1": (yaml.load(
                        self.networkSensor.getParameter("prevSaccadeInfo"))
                                ["prevOffset"]),
                    "offset2": (yaml.load(
                        self.networkSensor.getParameter("prevSaccadeInfo"))
                                ["newOffset"])
                })

                if enableViz:
                    detailImage = deserializeImage(
                        yaml.load(
                            self.networkSensor.getParameter("outputImage")))
                    detailImage = detailImage.resize(
                        (self.detailedSaccadeWidth,
                         self.detailedSaccadeHeight), Image.ANTIALIAS)
                    saccadeDetailList.append(ImageTk.PhotoImage(detailImage))

                    imgWithSaccade = originalImage.convert("RGB")
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Left
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Right
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Top
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset2"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset2"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
                        fill=(255, 0, 0),
                        width=1)  # Bottom

                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Left
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Right
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Top
                    ImageDraw.Draw(imgWithSaccade).line(
                        (imgCenter[0] + saccadeList[i]["offset1"][0] +
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2),
                         imgCenter[0] + saccadeList[i]["offset1"][0] -
                         (_FOVEA_SIZE / 2), imgCenter[1] +
                         saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
                        fill=(0, 255, 0),
                        width=1)  # Bottom

                    saccadeImgsList.append(ImageTk.PhotoImage(imgWithSaccade))

                    saccadeHist = originalImage.convert("RGB")
                    for i, saccade in enumerate(saccadeList):
                        ImageDraw.Draw(saccadeHist).rectangle(
                            (imgCenter[0] + saccade["offset2"][0] -
                             _FOVEA_SIZE / 2, imgCenter[0] +
                             saccade["offset2"][1] - _FOVEA_SIZE / 2,
                             imgCenter[0] + saccade["offset2"][0] +
                             _FOVEA_SIZE / 2, imgCenter[0] +
                             saccade["offset2"][1] + _FOVEA_SIZE / 2),
                            fill=(0, (255 / SACCADES_PER_IMAGE_TRAINING *
                                      (SACCADES_PER_IMAGE_TRAINING - i)),
                                  (255 / SACCADES_PER_IMAGE_TRAINING * i)))
                    saccadeHist = saccadeHist.resize(
                        (self.detailedSaccadeWidth,
                         self.detailedSaccadeHeight), Image.ANTIALIAS)
                    saccadeHistList.append(ImageTk.PhotoImage(saccadeHist))

            self.trainingImageIndex += 1
            print("Iteration: {iter}; Category: {cat}".format(
                iter=self.trainingImageIndex,
                cat=self.networkSensor.getOutputData("categoryOut")))

            if enableViz:
                return (saccadeImgsList, saccadeDetailList, saccadeHistList,
                        self.networkSensor.getOutputData("categoryOut"))
            return True

        else:
            return False
예제 #4
0
  def runNetworkOneImage(self, enableViz=False):
    """ Runs a single image through the network stepping through all saccades

    :param bool enableViz: If true, visualizations are generated and returned
    :return: If enableViz, return a tuple (saccadeImgsList, saccadeDetailList,
      saccadeHistList). saccadeImgsList is a list of images with the fovea
      highlighted. saccadeDetailList is a list of resized images showing the
      contents of the fovea. saccadeHistList shows the fovea history.
      If not enableViz, returns True
      Regardless of enableViz, if False is returned, all images have been
      saccaded over.
    """
    if self.trainingImageIndex < self.numTrainingImages:

      saccadeList = []
      saccadeImgsList = []
      saccadeHistList = []
      saccadeDetailList = []
      originalImage = None

      self.networkTM.executeCommand(["reset"])

      for i in range(SACCADES_PER_IMAGE_TRAINING):
        self.net.run(1)
        if originalImage is None:
          originalImage = deserializeImage(
              yaml.load(self.networkSensor.getParameter("originalImage")))
          imgCenter = (originalImage.size[0] / 2,
                       originalImage.size[1] / 2,)
        saccadeList.append({
            "offset1":
                (yaml.load(
                    self.networkSensor
                    .getParameter("prevSaccadeInfo"))
                 ["prevOffset"]),
            "offset2":
                (yaml.load(
                    self.networkSensor
                    .getParameter("prevSaccadeInfo"))
                 ["newOffset"])})

        if enableViz:
          detailImage = deserializeImage(
              yaml.load(self.networkSensor.getParameter("outputImage")))
          detailImage = detailImage.resize((self.detailedSaccadeWidth,
                                            self.detailedSaccadeHeight),
                                           Image.ANTIALIAS)
          saccadeDetailList.append(ImageTk.PhotoImage(detailImage))

          imgWithSaccade = originalImage.convert("RGB")
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Left
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Right
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] - (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Top
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset2"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset2"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset2"][1] + (_FOVEA_SIZE / 2)),
              fill=(255, 0, 0), width=1) # Bottom

          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Left
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Right
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] - (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Top
          ImageDraw.Draw(imgWithSaccade).line(
              (imgCenter[0] + saccadeList[i]["offset1"][0] + (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2),
               imgCenter[0] + saccadeList[i]["offset1"][0] - (_FOVEA_SIZE / 2),
               imgCenter[1] + saccadeList[i]["offset1"][1] + (_FOVEA_SIZE / 2)),
              fill=(0, 255, 0), width=1) # Bottom

          saccadeImgsList.append(ImageTk.PhotoImage(imgWithSaccade))

          saccadeHist = originalImage.convert("RGB")
          for i, saccade in enumerate(saccadeList):
            ImageDraw.Draw(saccadeHist).rectangle(
                (imgCenter[0] + saccade["offset2"][0] - _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][1] - _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][0] + _FOVEA_SIZE/2,
                 imgCenter[0] + saccade["offset2"][1] + _FOVEA_SIZE/2),
                fill=(0,
                      (255/SACCADES_PER_IMAGE_TRAINING*(SACCADES_PER_IMAGE_TRAINING-i)),
                      (255/SACCADES_PER_IMAGE_TRAINING*i)))
          saccadeHist = saccadeHist.resize((self.detailedSaccadeWidth,
                                            self.detailedSaccadeHeight),
                                           Image.ANTIALIAS)
          saccadeHistList.append(ImageTk.PhotoImage(saccadeHist))

      self.trainingImageIndex += 1
      print ("Iteration: {iter}; Category: {cat}"
             .format(iter=self.trainingImageIndex,
                     cat=self.networkSensor.getOutputData("categoryOut")))

      if enableViz:
        return (saccadeImgsList, saccadeDetailList, saccadeHistList,
                self.networkSensor.getOutputData("categoryOut"))
      return True

    else:
      return False