content: from SimpleCV.Color import Color
  from SimpleCV.base import time, cv, np
  from SimpleCV.Features.Features import Feature, FeatureSet
  from SimpleCV.ImageClass import Image
  
  
  class TrackSet(FeatureSet):
      """
      **SUMMARY**
  
      TrackSet is a class extended from FeatureSet which is a class
      extended from Python's list. So, TrackSet has all the properties
      of a list as well as all the properties of FeatureSet.
  
      In general, functions dealing with attributes will return
      numpy arrays.
  
      This class is specifically made for Tracking.
  
      **EXAMPLE**
  
      >>> image = Image("/path/to/image.png")
      >>> ts = image.track("camshift", img1=image, bb)  #ts is the track set
      >>> ts.draw()
      >>> ts.x()
      """
      try:
          import cv2
      except ImportError:
          warnings.warn("OpenCV >= 2.3.1 required.")
      
      def __init__(self):
          self.kalman = None
          self.predict_pt = (0,0)
          self.__kalman()
  
      def append(self, f):
          """
          **SUMMARY**
  
          This is a substitute function for append. This is used in
          Image.track(). To get z, vel, etc I have to use this.
          This sets few parameters up and appends Tracking object to
          TrackSet list.
          Users are discouraged to use this function.
  
          **RETURNS**
              Nothing.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> ts.append(CAMShift(img,bb,ellipse))
          """
          list.append(self,f)
          ts = self
          if ts[0].area <= 0:
              return
          f.sizeRatio = float(ts[-1].area)/float(ts[0].area)
          f.vel = self.__pixelVelocity()
          f.rt_vel = self.__pixleVelocityRealTime()
          self.__setKalman()
          self.__predictKalman()
          self.__changeMeasure()
          self.__correctKalman()
          f.predict_pt = self.predict_pt
          f.state_pt = self.state_pt
  
      # Issue #256 - (Bug) Memory management issue due to too many number of images.
      def trimList(self, num):
          """
          **SUMMARY**
  
          Trims the TrackSet(lists of all the saved objects) to save memory. It is implemented in
          Image.track() by default, but if you want to trim the list manually, use this.
  
          **RETURNS**
  
          Nothing.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... if len(ts) > 30:
                  ... ts.trimList(10)
              ... img = img1
          """
          ts = self
          for i in range(num):
              ts.pop(0)
  
      def areaRatio(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the areaRatio of each feature.
          where areaRatio is the ratio of the size of the current bounding box to
          the size of the initial bounding box
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.areaRatio
  
          """
          return np.array([f.areaRatio for f in self])
  
      def drawPath(self, color=Color.GREEN, thickness=2):
          """
          **SUMMARY**
  
          Draw the complete path traced by the center of the object on current frame
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *thickness* - Thickness of the tracing path.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawPath() # For continuous tracing
              ... img = img1
          >>> ts.drawPath() # draw the path at the end of tracking
          """
  
          ts = self
          img = self[-1].image
          for i in range(len(ts)-1):
              img.drawLine((ts[i].center),(ts[i+1].center), color=color, thickness=thickness)
  
      def draw(self, color=Color.GREEN, rad=1, thickness=1):
          """
          **SUMMARY**
  
          Draw the center of the object on the current frame.
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *rad* - Radius of the circle to be plotted on the center of the object.
          * *thickness* - Thickness of the boundary of the center circle.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.draw() # For continuous tracking of the center
              ... img = img1
          """
          f = self[-1]
          f.image.drawCircle(f.center, rad, color, thickness)
  
      def drawBB(self, color=Color.GREEN, thickness=3):
          """
          **SUMMARY**
  
          Draw the bounding box over the object on the current frame.
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *thickness* - Thickness of the boundary of the bounding box.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawBB() # For continuous bounding box
              ... img = img1
          """
          f = self[-1]
          f.image.drawRectangle(f.bb_x, f.bb_y, f.w, f.h, color, thickness)
  
      def trackLength(self):
          """
          **SUMMARY**
  
          Get total number of tracked frames.
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *int* * -Number of tracked image frames
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.trackLength()
          """
          return len(self)
  
      def trackImages(self, cv2_numpy=False):
          """
          **SUMMARY**
  
          Get all the tracked images in a list
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *list* * - A list of all the tracked SimpleCV.ImageClass.Image
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> imgset = ts.trackImages()
          """
          if cv2_numpy:
              return [f.cv2numpy for f in self]
          return [f.image for f in self]
  
      def BBTrack(self):
          """
          **SUMMARY**
  
          Get all the bounding box in a list
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *list* * - All the bounding box co-ordinates in a list
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.BBTrack()
          """
          return [f.bb for f in self]
  
      def __pixelVelocity(self):
          """
          **SUMMARY**
  
          Get Pixel Velocity of the tracked object in pixel/frame.
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *tuple* * - (Velocity of x, Velocity of y)
  
          """
          ts = self
          if len(ts) < 2:
              return (0,0)
          dx = ts[-1].x - ts[-2].x
          dy = ts[-1].y - ts[-2].y
          return (dx, dy)
  
      def pixelVelocity(self):
          """
          **SUMMARY**
  
          Get each Pixel Velocity of the tracked object in pixel/frames.
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *numpy array* * - array of pixel velocity tuple.
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.pixelVelocity()
          """
          return np.array([f.vel for f in self])
  
      def __pixleVelocityRealTime(self):
          """
          **SUMMARY**
  
          Get each Pixel Velocity of the tracked object in pixel/second.
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *tuple* * - velocity tuple
          """
          ts = self
          if len(ts) < 2:
              return (0,0)
          dx = ts[-1].x - ts[-2].x
          dy = ts[-1].y - ts[-2].y
          dt = ts[-1].time - ts[-2].time
          return (float(dx)/dt, float(dy)/dt)
  
      def pixleVelocityRealTime(self):
          """
          **SUMMARY**
  
          Get each Pixel Velocity of the tracked object in pixel/frames.
  
          **PARAMETERS**
  
          No Parameters required.
  
          **RETURNS**
  
          * *numpy array* * - array of pixel velocity tuple.
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.pixelVelocityRealTime()
          """
          return np.array([f.rt_vel for f in self])
  
      def showCoordinates(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          Show the co-ordinates of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showCoordinates() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          if not pos:
              imgsize = img.size()
              pos = (imgsize[0]-120, 10)
          if not size:
              size = 16
          text = "x = %d  y = %d" % (f.x, f.y)
          img.drawText(text, pos[0], pos[1], color, size)
  
      def showSizeRatio(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          Show the sizeRatio of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showZ() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          if not pos:
              imgsize = img.size()
              pos = (imgsize[0]-120, 30)
          if not size:
              size = 16
          text = "size = %f" % (f.sizeRatio)
          img.drawText(text, pos[0], pos[1], color, size)
  
      def showPixelVelocity(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          show the Pixel Veloctiy (pixel/frame) of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showPixelVelocity() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          vel = f.vel
          if not pos:
              imgsize = img.size()
              pos = (imgsize[0]-120, 50)
          if not size:
              size = 16
          text = "Vx = %.2f Vy = %.2f" % (vel[0], vel[1])
          img.drawText(text, pos[0], pos[1], color, size)
          img.drawText("in pixels/frame", pos[0], pos[1]+size, color, size)
  
      def showPixelVelocityRT(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          show the Pixel Veloctiy (pixels/second) of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showPixelVelocityRT() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          vel_rt = f.rt_vel
          if not pos:
              imgsize = img.size()
              pos = (imgsize[0]-120, 90)
          if not size:
              size = 16
          text = "Vx = %.2f Vy = %.2f" % (vel_rt[0], vel_rt[1])
          img.drawText(text, pos[0], pos[1], color, size)
          img.drawText("in pixels/second", pos[0], pos[1]+size, color, size)
  
      def processTrack(self, func):
          """
          **SUMMARY**
  
          This method lets you use your own function on the entire imageset.
  
          **PARAMETERS**
          * *func* - some user defined function for SimpleCV.ImageClass.Image object
  
          **RETURNS**
  
          * *list* - list of the values returned by the function when applied on all the images
  
          **EXAMPLE**
  
          >>> def foo(img):
              ... return img.meanColor()
          >>> mean_color_list = ts.processTrack(foo)
          """
          return [func(f.image) for f in self]
  
      def getBackground(self):
          """
          **SUMMARY**
  
          Get Background of the Image. For more info read
          http://opencvpython.blogspot.in/2012/07/background-extraction-using-running.html
  
          **PARAMETERS**
          No Parameters
  
          **RETURNS**
  
          Image - SimpleCV.ImageClass.Image
  
          **EXAMPLE**
  
          >>> while (some_condition):
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> ts.getBackground().show()
          """
          imgs = self.trackImages(cv2_numpy=True)
          f = imgs[0]
          avg = np.float32(f)
          for img in imgs[1:]:
              f = img
              cv2.accumulateWeighted(f,avg,0.01)
              res = cv2.convertScaleAbs(avg)
          return Image(res, cv2image=True)
  
      def __kalman(self):
          self.kalman = cv.CreateKalman(4, 2, 0)
          self.kalman_state = cv.CreateMat(4, 1, cv.CV_32FC1)  # (phi, delta_phi)
          self.kalman_process_noise = cv.CreateMat(4, 1, cv.CV_32FC1)
          self.kalman_measurement = cv.CreateMat(2, 1, cv.CV_32FC1)
  
      def __setKalman(self):
          ts = self
          if len(ts) < 2:
              self.kalman_x = ts[-1].x
              self.kalman_y = ts[-1].y
          else:
              self.kalman_x = ts[-2].x
              self.kalman_y = ts[-2].y
  
          self.kalman.state_pre[0,0]  = self.kalman_x
          self.kalman.state_pre[1,0]  = self.kalman_y
          self.kalman.state_pre[2,0]  = self.predict_pt[0]
          self.kalman.state_pre[3,0]  = self.predict_pt[1]
  
          self.kalman.transition_matrix[0,0] = 1
          self.kalman.transition_matrix[0,1] = 0
          self.kalman.transition_matrix[0,2] = 1
          self.kalman.transition_matrix[0,3] = 0
          self.kalman.transition_matrix[1,0] = 0
          self.kalman.transition_matrix[1,1] = 1
          self.kalman.transition_matrix[1,2] = 0
          self.kalman.transition_matrix[1,3] = 1
          self.kalman.transition_matrix[2,0] = 0
          self.kalman.transition_matrix[2,1] = 0
          self.kalman.transition_matrix[2,2] = 1
          self.kalman.transition_matrix[2,3] = 0
          self.kalman.transition_matrix[3,0] = 0
          self.kalman.transition_matrix[3,1] = 0
          self.kalman.transition_matrix[3,2] = 0
          self.kalman.transition_matrix[3,3] = 1
  
          cv.SetIdentity(self.kalman.measurement_matrix, cv.RealScalar(1))
          cv.SetIdentity(self.kalman.process_noise_cov, cv.RealScalar(1e-5))
          cv.SetIdentity(self.kalman.measurement_noise_cov, cv.RealScalar(1e-1))
          cv.SetIdentity(self.kalman.error_cov_post, cv.RealScalar(1))
  
      def __predictKalman(self):
          self.kalman_prediction = cv.KalmanPredict(self.kalman)
          self.predict_pt  = (self.kalman_prediction[0,0], self.kalman_prediction[1,0])
  
      def __correctKalman(self):
          self.kalman_estimated = cv.KalmanCorrect(self.kalman, self.kalman_measurement)
          self.state_pt = (self.kalman_estimated[0,0], self.kalman_estimated[1,0])
  
      def __changeMeasure(self):
          ts = self
          self.kalman_measurement[0, 0] = ts[-1].x
          self.kalman_measurement[1, 0] = ts[-1].y
  
      def predictedCoordinates(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the predicted coordinates of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.predictedCoordinates()
  
          """
          return np.array([f.predict_pt for f in self])
  
      def predictX(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the predicted x (vertical) coordinate of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.predictX()
  
          """
          return np.array([f.predict_pt[0] for f in self])
  
      def predictY(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the predicted y (vertical) coordinate of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.predictY()
  
          """
          return np.array([f.predict_pt[1] for f in self])
  
      def drawPredicted(self, color=Color.GREEN, rad=1, thickness=1):
          """
          **SUMMARY**
  
          Draw the predcited center of the object on the current frame.
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *rad* - Radius of the circle to be plotted on the center of the object.
          * *thickness* - Thickness of the boundary of the center circle.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawPredicted() # For continuous tracking of the center
              ... img = img1
          """
          f = self[-1]
          f.image.drawCircle(f.predict_pt, rad, color, thickness)
  
      def drawCorrected(self, color=Color.GREEN, rad=1, thickness=1):
          """
          **SUMMARY**
  
          Draw the predcited center of the object on the current frame.
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *rad* - Radius of the circle to be plotted on the center of the object.
          * *thickness* - Thickness of the boundary of the center circle.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawPredicted() # For continuous tracking of the center
              ... img = img1
          """
          f = self[-1]
          f.image.drawCircle(f.state_pt, rad, color, thickness)
  
      def drawPredictedPath(self, color=Color.GREEN, thickness=2):
          """
          **SUMMARY**
  
          Draw the complete predicted path of the center of the object on current frame
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *thickness* - Thickness of the tracing path.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawPredictedPath() # For continuous tracing
              ... img = img1
          >>> ts.drawPredictedPath() # draw the path at the end of tracking
          """
  
          ts = self
          img = self[-1].image
          for i in range(1, len(ts)-1):
              img.drawLine((ts[i].predict_pt),(ts[i+1].predict_pt), color=color, thickness=thickness)
  
      def showPredictedCoordinates(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          Show the co-ordinates of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showPredictedCoordinates() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          if not pos:
              imgsize = img.size()
              pos = (5, 10)
          if not size:
              size = 16
          text = "Predicted: x = %d  y = %d" % (f.predict_pt[0], f.predict_pt[1])
          img.drawText(text, pos[0], pos[1], color, size)
  
      def showCorrectedCoordinates(self, pos=None, color=Color.GREEN, size=None):
          """
          **SUMMARY**
  
          Show the co-ordinates of the object in text on the current frame.
  
          **PARAMETERS**
          * *pos* - A tuple consisting of x, y values. where to put to the text
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *size* - Fontsize of the text
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.showCorrectedCoordinates() # For continuous bounding box
              ... img = img1
          """
          ts = self
          f = ts[-1]
          img = f.image
          if not pos:
              imgsize = img.size()
              pos = (5, 40)
          if not size:
              size = 16
          text = "Corrected: x = %d  y = %d" % (f.state_pt[0], f.state_pt[1])
          img.drawText(text, pos[0], pos[1], color, size)
  
      def correctX(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the corrected x coordinate of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.correctX()
  
          """
          return np.array([f.state_pt[0] for f in self])
  
      def correctY(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the corrected y coordinate of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.correctY()
  
          """
          return np.array([f.state_pt[1] for f in self])
  
      def correctedCoordinates(self):
          """
          **SUMMARY**
  
          Returns a numpy array of the corrected coordinates of each feature.
  
          **RETURNS**
  
          A numpy array.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... img = img1
          >>> print ts.predictedCoordinates()
  
          """
          return np.array([f.state_pt for f in self])
  
      def drawCorrectedPath(self, color=Color.GREEN, thickness=2):
          """
          **SUMMARY**
  
          Draw the complete corrected path of the center of the object on current frame
  
          **PARAMETERS**
  
          * *color* - The color to draw the object. Either an BGR tuple or a member of the :py:class:`Color` class.
          * *thickness* - Thickness of the tracing path.
  
          **RETURNS**
  
          Nada. Nothing. Zilch.
  
          **EXAMPLE**
  
          >>> while True:
              ... img1 = cam.getImage()
              ... ts = img1.track("camshift", ts1, img, bb)
              ... ts.drawCorrectedPath() # For continuous tracing
              ... img = img1
          >>> ts.drawPredictedPath() # draw the path at the end of tracking
          """
  
          ts = self
          img = self[-1].image
          for i in range(len(ts)-1):
              img.drawLine((ts[i].state_pt),(ts[i+1].state_pt), color=color, thickness=thickness)
  