sciveo 0.1.75__tar.gz → 0.1.77__tar.gz

{sciveo-0.1.75 → sciveo-0.1.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciveo
-Version: 0.1.75
+Version: 0.1.77
 Description-Content-Type: text/markdown
 Provides-Extra: mon
 Provides-Extra: net

{sciveo-0.1.75 → sciveo-0.1.77}/sciveo/cli.py

@@ -39,14 +39,15 @@ def main():
   parser.add_argument('--auth', type=str, default=config['secret_access_key'], help='Auth secret access key')
   parser.add_argument('--timeout', type=float, default=1.0, help='Timeout')
   parser.add_argument('--net', type=str, default=None, help='Network like 192.168.10.0/24')
+  parser.add_argument('--url', type=str, default=None, help='URL')
   parser.add_argument('--host', type=str, default=None, help='Host ip or name')
   parser.add_argument('--port', type=int, default=22, help='Host port number, used for network ops')
   parser.add_argument('--ports', type=str, default="[]", help='Host ports list')
   parser.add_argument('--localhost', type=bool, default=False, help='Add localhost to list of hosts')
   parser.add_argument('--input-path', type=str, default=None, help='Input Path')
   parser.add_argument('--output-path', type=str, default=None, help='Output Path')
-  parser.add_argument('--width', type=str, default=None, help='width')
-  parser.add_argument('--height', type=str, default=None, help='height')
+  parser.add_argument('--width', type=int, default=None, help='width')
+  parser.add_argument('--height', type=int, default=None, help='height')
   parser.add_argument('--fps', type=int, help='FPS')
   parser.add_argument('--stream', type=str, default=None, help='Stream')
   parser.add_argument('--rate', type=int, help='Rate number')
@@ -101,7 +102,14 @@ def main():
   elif args.command == 'rtsp':
     if args.src is None and args.src_id is None:
       from sciveo.media.capture.nvr import RTSPVideoPlayer
-      player = RTSPVideoPlayer(f"rtsp://{args.host}:{args.port}/{args.stream}")
+      if args.url is not None:
+        url = args.url
+      elif args.host is not None and args.stream is not None:
+        url = f"rtsp://{args.host}:{args.port}/{args.stream}"
+      else:
+        warning("Invalid URL")
+        return
+      player = RTSPVideoPlayer(url)
       player.run()
     else:
       from sciveo.media.capture.gst_server import CamFactory, ColorBarFactory

{sciveo-0.1.75 → sciveo-0.1.77}/sciveo/db/read_table.py

@@ -158,6 +158,10 @@ class BaseTable:
     return df_new
 
   def save(self, file_path=None):
+    if self.latest_df.empty:
+      info("Empty", self.latest_df)
+      return
+
     if self.save_path is not None and self.last_id is not None:
       from_id = int(self.latest_df[self.id_col].min())
       to_id = int(self.latest_df[self.id_col].max())
@@ -185,20 +189,3 @@ class BaseTable:
 
   def __exit__(self, exc_type, exc_val, exc_tb):
     self.close()
-
-
-if __name__ == "__main__":
-  with BaseTable("video_record_predictions", batch_size=10_000, save_path="/home/ml/video_predictions/data") as T:
-
-    T.update(last_id=1_000_000)
-    T.load()
-    if not T.df.empty:
-      debug(T.df.columns)
-      debug(T.df[["key", "people", "is_valid", "updated_at", "data"]].head())
-
-    while(True):
-      df = T.update()
-      if df.empty:
-        info("Finished", T.df.shape)
-        break
-      info("read", df.shape, df[["key", "people"]].head())

sciveo-0.1.77/sciveo/media/capture/draw.py

@@ -0,0 +1,81 @@
+#
+# Pavlin Georgiev, Softel Labs
+#
+# This is a proprietary file and may not be copied,
+# distributed, or modified without express permission
+# from the owner. For licensing inquiries, please
+# contact pavlin@softel.bg.
+#
+# 2025
+#
+
+import cv2
+import numpy as np
+from datetime import datetime
+from sciveo.tools.logger import *
+
+
+class DrawNone:
+  def __call__(self, frame, tag):
+    return frame
+
+class DrawDateTime:
+  def __init__(self, position=(10, 10), color=(255, 255, 255), thickness=3, font_scale_factor=0.001, font=cv2.FONT_HERSHEY_SIMPLEX):
+    """
+    position: tuple (x, y) displacement from top-left
+    color: BGR tuple
+    thickness: line thickness
+    font_scale_factor: relative to frame height (0.0015 is reasonable)
+    font: cv2 font
+    """
+    self.position = position
+    self.color = color
+    self.thickness = thickness
+    self.font = font
+    self.font_scale_factor = font_scale_factor
+
+  def __call__(self, frame, tag):
+    """
+    Draws date/time (or custom text) on the frame.
+
+    frame: np.ndarray
+    text: optional text to draw; if None, current date/time is used
+    position, color, thickness: optional overrides
+    """
+    if frame is None or len(frame.shape) < 2:
+      return frame  # invalid frame
+
+    h, w = frame.shape[:2]
+
+    font_scale = max(0.2, h * self.font_scale_factor)
+
+    date_text = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    draw_text = f"{tag} {date_text}"
+
+    # Adjust position to avoid going out of frame
+    x = min(max(self.position[0], 0), w - 1)
+    y = min(max(self.position[1] + int(font_scale * 20), int(font_scale * 20)), h - 1)
+
+    cv2.putText(frame, draw_text, (x, y), self.font, font_scale, self.color, self.thickness, cv2.LINE_AA)
+    return frame
+
+
+
+if __name__ == "__main__":
+
+  cap = cv2.VideoCapture(0)
+  drawer = DrawDateTime(tag="test cam", position=(10, 10))
+
+  while True:
+    ret, frame = cap.read()
+    if not ret:
+      break
+
+    frame = drawer(frame)
+
+    cv2.imshow("Frame", frame)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+      break
+
+  cap.release()
+  cv2.destroyAllWindows()

sciveo-0.1.77/sciveo/media/capture/games/asteroids/asteroid.py

@@ -0,0 +1,34 @@
+import math
+import cv2
+import numpy as np
+
+from geometrics import *
+from base_move import *
+
+
+class Asteroid(BaseMoveConstantVelocity):
+  def __init__(self, x0, y0, vx0, vy0, r0, color=(255, 0, 0), size_contour=20):
+    super().__init__(x0, y0, vx0, vy0, color)
+
+    self.r0 = r0
+    self.r = r0
+    self.size_contour = size_contour
+
+    self.generate_contour()
+
+  def draw(self, frame):
+    # self.generate_contour()
+    list_points = []
+    for p in self.list_points:
+      list_points.append((int(self.x + p[0]), int(self.y + p[1])))
+    cv2.drawContours(frame, [np.array(list_points)], 0, self.color, 1)
+    cv2.circle(frame, (int(self.x), int(self.y)), int(self.r), (0, 0, 200), thickness=1)
+
+  def generate_contour(self):
+    self.list_points = []
+    for i in range(self.size_contour):
+      r = self.r0 * np.sqrt(np.random.uniform(0.3, 1.0))
+      # angle = np.random.uniform() * 2 * PI
+      angle = i * 2 * PI / self.size_contour
+      p = (r * math.cos(angle), r * math.sin(angle))
+      self.list_points.append(p)

sciveo-0.1.77/sciveo/media/capture/games/asteroids/base_move.py

@@ -0,0 +1,26 @@
+import math
+
+from geometrics import *
+
+
+class BaseMoveConstantVelocity:
+  def __init__(self, x0, y0, vx0, vy0, color=(0, 0, 255)):
+    self.x = x0
+    self.y = y0
+    self.vx = vx0
+    self.vy = vy0
+    self.color = color
+
+  def move(self, frame):
+    w = frame.shape[1]
+    h = frame.shape[0]
+
+    self.x += self.vx
+    self.y += self.vy
+
+    self.x, self.y = frame_bounds_rewind(w, h, self.x, self.y)
+
+    self.draw(frame)
+
+  def draw(self, frame):
+    pass

sciveo-0.1.77/sciveo/media/capture/games/asteroids/circle.py

@@ -0,0 +1,31 @@
+import math
+
+from base_move import *
+
+
+class Circle(BaseMoveConstantVelocity):
+  def __init__(self, x0, y0, r, vx0, vy0, color=(0, 0, 255)):
+    super().__init__(x0, y0, vx0, vy0, color)
+    self.r = r
+
+  def move(self, frame):
+    w = frame.shape[1]
+    h = frame.shape[0]
+
+    self.x += self.vx
+    self.y += self.vy
+
+    self.x, self.y = frame_bounds_rewind(w - self.r, h - self.r, self.x, self.y)
+
+    self.draw(frame)
+
+  def draw(self, frame):
+    angle = 0.0
+    while(angle <= 2 * math.pi):
+      x1 = self.x + self.r * math.cos(angle)
+      y1 = self.y + self.r * math.sin(angle)
+      x1 = int(x1)
+      y1 = int(y1)
+      angle += 0.01
+
+      frame[y1, x1] = self.color

sciveo-0.1.77/sciveo/media/capture/games/asteroids/game.py

@@ -0,0 +1,11 @@
+from space_asteroids import SpaceAsteroids
+
+
+def main():
+
+  space = SpaceAsteroids(1200, 800, rocket_lives=20)
+  space.run()
+
+
+if __name__=='__main__':
+  main()

sciveo-0.1.77/sciveo/media/capture/games/asteroids/geometrics.py

@@ -0,0 +1,36 @@
+import math
+import cv2
+
+
+PI = 3.141592653589793
+
+def to_radians(angle):
+  return angle * PI / 180
+
+def line_perpendicular(p1, p2, l):
+  x1, y1 = p1
+  x2, y2 = p2
+
+  x3 = x2 - x1
+  y3 = y2 - y1
+
+  mag = math.sqrt(x3 * x3 + y3 * y3)
+  x3 /= mag
+  y3 /= mag
+
+  x4 = x2 - y3 * l
+  y4 = y2 + x3 * l
+  x5 = x2 + y3 * l
+  y5 = y2 - x3 * l
+  return (int(x4), int(y4)), (int(x5), int(y5))
+
+def frame_bounds_rewind(w, h, x, y):
+  if x > w:
+    x = 0
+  if x < 0:
+    x = w
+  if y > h:
+    y = 0
+  if y < 0:
+    y = h
+  return x, y

sciveo-0.1.77/sciveo/media/capture/games/asteroids/gravity_ball.py

@@ -0,0 +1,32 @@
+import cv2
+
+class GravityBall:
+  def __init__(self, r, x=0, y=0, gx=0.2, gy=0.1, color=(255, 0, 0)):
+    self.color = color
+    self.r = r
+
+    self.x = 0
+    self.y = 0
+
+    self.vx = 0
+    self.vy = 0
+    self.gx = gx
+    self.gy = gy
+
+  def move(self, frame):
+    w = frame.shape[1]
+    h = frame.shape[0]
+
+    self.vx += self.gx
+    self.vy += self.gy
+    self.x += self.vx
+    self.y += self.vy
+
+    if self.x + self.r >= w:
+      self.x = w - self.r
+      self.vx = - self.vx
+    if self.y + self.r >= h:
+      self.y = h - self.r
+      self.vy = - self.vy
+
+    cv2.circle(frame, (int(self.x), int(self.y)), self.r, self.color, thickness=-1)

sciveo-0.1.77/sciveo/media/capture/games/asteroids/laser.py

@@ -0,0 +1,42 @@
+import cv2
+import math
+import numpy as np
+
+from geometrics import to_radians
+from base_move import *
+
+
+class Laser(BaseMoveConstantVelocity):
+  def __init__(self, x0, y0, angle):
+    super().__init__(x0, y0, 0, 0, (0, 0, 255))
+    # self.path = 0
+    # self.x0 = x0
+    # self.y0 = y0
+
+    self.l = 10
+    self.angle = angle
+
+    self.points()
+
+    self.v = 2.5
+    self.vx = self.v * math.cos(to_radians(self.angle))
+    self.vy = self.v * math.sin(to_radians(self.angle))
+
+  def points(self):
+    angle = to_radians(self.angle)
+    self.p1 = (int(self.x), int(self.y))
+    self.p2 = (int(self.x + self.l * math.cos(angle)), int(self.y + self.l * math.sin(angle)))
+    # self.path = math.sqrt((self.x - self.x0) ** 2 + (self.y - self.y0) ** 2)
+
+  def move(self, frame):
+    w = frame.shape[1]
+    h = frame.shape[0]
+
+    self.x += self.vx
+    self.y += self.vy
+
+    self.points()
+
+    cv2.line(frame, self.p1, self.p2, self.color, 2)
+
+    return self.x >= 0 and self.x <= w and self.y >= 0 and self.y <= h

sciveo-0.1.77/sciveo/media/capture/games/asteroids/rocket.py

@@ -0,0 +1,160 @@
+import math
+import cv2
+import numpy as np
+
+from geometrics import *
+from laser import *
+from volume_bar import *
+from base_move import *
+
+
+class RocketBase(BaseMoveConstantVelocity):
+  def __init__(self, x0, y0):
+    super().__init__(x0, y0, 0, 0, (255, 0, 0))
+    self.l = 10000000000
+    self.angle = 0
+
+  def check_collision(self, x, y, r):
+    return False
+
+  def rotate(self, angle):
+    self.angle += angle
+
+  def accelerate(self, a):
+    pass
+
+  def fire(self):
+    pass
+
+  def alive(self):
+    return True
+
+  def laser_positions(self):
+    return []
+
+
+class SimpleRocket(RocketBase):
+  def __init__(self, x0=0, y0=0, color=(255, 0, 0)):
+    super().__init__(x0, y0)
+    self.color = color
+    self.r = 10
+
+    self.vx = 0
+    self.vy = 0
+
+  def accelerate(self, gx, gy):
+    self.vx += gx
+    self.vy += gy
+
+  def draw(self, frame):
+    cv2.circle(frame, (int(self.x), int(self.y)), self.r, self.color, thickness=-1)
+    cv2.putText(frame, "V ({},{})".format(round(self.vx, 2), round(self.vy, 2)), (5, 20), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(255, 255, 255), thickness=1)
+
+
+class Rocket(RocketBase):
+  def __init__(self, x0=0, y0=0, color=(255, 0, 0), txt_pos=(5, 20), l=10, laser_count=100, fuel=20):
+    super().__init__(x0, y0)
+    self.color = color
+    self.txt_pos = txt_pos
+    self.l = l
+
+    self.thruster_default = 30
+    self.thruster = 0
+    self.fuel = fuel
+
+    self.a = 0
+    self.ax = 0
+    self.ay = 0
+
+    self.vx = 0
+    self.vy = 0
+
+    self.laser_count = laser_count
+    self.lasers = []
+
+    self.fuel_bar = VolumeBar((400, 20), self.fuel, name="FUEL", color=(255, 0, 0))
+    self.laser_bar = VolumeBar((400, 50), self.laser_count, name="LASER", color=(0, 0, 255))
+
+  def accelerate(self, a):
+    if self.fuel < a:
+      a = self.fuel
+    self.fuel -= a
+
+    angle = to_radians(self.angle)
+    self.ax = a * math.cos(angle)
+    self.ay = a * math.sin(angle)
+    self.a = a
+
+    self.vx += self.ax
+    self.vy += self.ay
+
+    self.thruster = self.thruster_default
+
+  def draw(self, frame):
+    angle = to_radians(self.angle)
+    p0 = (int(self.x), int(self.y))
+    p1 = (int(self.x + self.l * math.cos(angle)), int(self.y + self.l * math.sin(angle)))
+    p2 = (int(self.x - self.l * math.cos(angle)), int(self.y - self.l * math.sin(angle)))
+    p3, p4 = line_perpendicular(p1, p2, self.l)
+
+    cv2.line(frame, p1, p2, self.color, 2)
+    # cv2.line(frame, p3, p4, self.color, 4)
+    cv2.line(frame, p3, p1, (0, 0, 255), 3)
+    cv2.line(frame, p4, p1, (0, 255, 0), 3)
+    cv2.line(frame, p3, p0, self.color, 2)
+    cv2.line(frame, p4, p0, self.color, 2)
+
+    if self.thruster > 0:
+      l = self.a * 200
+      p1 = p2
+      da = 0.3
+      p2 = [int(p1[0] - l * math.cos(angle - da)), int(p1[1] - l * math.sin(angle - da))]
+      p3 = [int(p1[0] - l * math.cos(angle + da)), int(p1[1] - l * math.sin(angle + da))]
+      cv2.drawContours(frame, [np.array([p1, p2, p3])], 0, (0, 0, 255), -1)
+      self.thruster -= 1
+
+    txt = "V ({},{}) A[{}]".format(round(self.vx, 3), round(self.vy, 3), self.angle)
+    cv2.putText(frame, txt, self.txt_pos, fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.3, color=(255, 255, 255), thickness=1)
+
+    self.move_lasers(frame)
+
+    self.fuel_bar(frame, self.fuel)
+    self.laser_bar(frame, self.laser_count)
+
+  def move_lasers(self, frame):
+    for laser in self.lasers:
+      if not laser.move(frame):
+        self.lasers.remove(laser)
+
+  def fire(self):
+    if self.laser_count > 0:
+      self.laser_count -= 1
+      self.lasers.append(Laser(self.x, self.y, self.angle))
+
+  def laser_positions(self):
+    positions = []
+    for laser in self.lasers:
+      positions.append([laser.p1, laser.p2, laser.angle])
+    return positions
+
+  def remove_laser(self, idx):
+    if idx < len(self.lasers):
+      del self.lasers[idx]
+
+  def check_collision(self, x, y, r):
+    # d = np.linalg.norm(np.array([x, y]) - np.array([self.x, self.y]))
+    d = math.sqrt((x - self.x) ** 2 + (y - self.y) ** 2)
+    return d < r + self.l
+
+
+class RocketExplosion(RocketBase):
+  def __init__(self, x0, y0):
+    super().__init__(x0, y0)
+    self.r = 3
+
+  def move(self, frame):
+    cv2.circle(frame, (int(self.x), int(self.y)), int(self.r), (0, 0, 255), thickness=-1)
+    self.r += 0.8
+
+  def alive(self):
+    return self.r < 100

sciveo-0.1.77/sciveo/media/capture/games/asteroids/space_asteroids.py

@@ -0,0 +1,155 @@
+import cv2
+import numpy as np
+
+from rocket import *
+from asteroid import *
+from volume_bar import *
+
+
+class SpaceAsteroids:
+  def __init__(self, w, h, rocket_lives=10):
+    self.W = w
+    self.H = h
+    self.rocket_lives = rocket_lives
+
+    self.rocket = Rocket(x0=50, y0=50, color=(255, 255, 0), txt_pos=(5, 30), laser_count=200)
+    self.rocket_lives_bar = VolumeBar((200, 20), self.rocket_lives, name="LIVE", color=(0, 255, 0))
+
+    self.asteroids_removed = 0
+    self.asteroids = []
+    self.init_asteroids()
+    self.asteroids_bar = VolumeBar((200, 40), len(self.asteroids) * 2, name="ASTEROIDS", color=(0, 255, 255))
+
+  def init_asteroids(self):
+    dv = 1.1
+    while(len(self.asteroids) < 30):
+      x0 = np.random.randint(200, self.W)
+      y0 = np.random.randint(200, self.H)
+      r0 = np.random.randint(5, 100)
+      is_usable = True
+      for asteroid in self.asteroids:
+        d = math.sqrt((asteroid.x - x0) ** 2 + (asteroid.y - y0) ** 2)
+        if d < (asteroid.r + r0) * 1.2:
+          is_usable = False
+          break
+
+      if is_usable:
+        self.asteroids.append(
+          Asteroid(
+            x0, y0,
+            np.random.uniform(-dv, dv),
+            np.random.uniform(-dv, dv),
+            r0,
+            color=(255, 255, 255),
+            size_contour=10
+          )
+        )
+
+  def run(self):
+    vrotate = 0
+
+    while(True):
+      k = cv2.waitKey(1)
+      if k == 27:    # Esc key to stop
+        break
+
+      if k == ord('u'):
+        self.rocket.accelerate(0.1)
+      if k == ord('i'):
+        self.rocket.accelerate(0.2)
+      if k == ord('o'):
+        self.rocket.accelerate(0.3)
+      if k == ord('m'):
+        self.rocket.fire()
+      if k == ord('j'):
+        vrotate = -2
+      if k == ord('k'):
+        vrotate = 0
+      if k == ord('l'):
+        vrotate = 2
+
+      self.rocket.rotate(vrotate)
+
+      frame = np.zeros(shape=[self.H, self.W, 3], dtype=np.uint8)
+
+      self.rocket.move(frame)
+
+      for asteroid in self.asteroids:
+        asteroid.move(frame)
+
+      for i in range(len(self.asteroids)):
+        for j in range(i + 1, len(self.asteroids)):
+          d = math.sqrt((self.asteroids[i].x - self.asteroids[j].x) ** 2 + (self.asteroids[i].y - self.asteroids[j].y) ** 2)
+          if d < self.asteroids[i].r + self.asteroids[j].r:
+            vx1 = ((self.asteroids[i].r - self.asteroids[j].r) * self.asteroids[i].vx + 2 * self.asteroids[j].r * self.asteroids[j].vx) / (self.asteroids[i].r + self.asteroids[j].r)
+            vy1 = ((self.asteroids[i].r - self.asteroids[j].r) * self.asteroids[i].vy + 2 * self.asteroids[j].r * self.asteroids[j].vy) / (self.asteroids[i].r + self.asteroids[j].r)
+            vx2 = ((self.asteroids[j].r - self.asteroids[i].r) * self.asteroids[j].vx + 2 * self.asteroids[i].r * self.asteroids[i].vx) / (self.asteroids[i].r + self.asteroids[j].r)
+            vy2 = ((self.asteroids[j].r - self.asteroids[i].r) * self.asteroids[j].vy + 2 * self.asteroids[i].r * self.asteroids[i].vy) / (self.asteroids[i].r + self.asteroids[j].r)
+            self.asteroids[i].vx = vx1
+            self.asteroids[i].vy = vy1
+            self.asteroids[j].vx = vx2
+            self.asteroids[j].vy = vy2
+
+      laser_positions = self.rocket.laser_positions()
+      for asteroid in self.asteroids:
+        for i, laser in enumerate(laser_positions):
+          d1 = math.sqrt((asteroid.x - laser[0][0]) ** 2 + (asteroid.y - laser[0][1]) ** 2)
+          d2 = math.sqrt((asteroid.x - laser[1][0]) ** 2 + (asteroid.y - laser[1][1]) ** 2)
+          if d1 < asteroid.r or d2 < asteroid.r:
+            self.asteroids.remove(asteroid)
+            self.rocket.remove_laser(i)
+            self.asteroids_removed += 1
+
+            if asteroid.r > 10:
+              angle1 = to_radians(laser[2] + 90)
+              angle2 = to_radians(laser[2] - 90)
+              self.asteroids.append(
+                Asteroid(
+                  asteroid.x + math.cos(angle1) * (asteroid.r / 1.9),
+                  asteroid.y + math.sin(angle1) * (asteroid.r / 1.9),
+                  math.cos(angle1) * asteroid.vx,
+                  math.sin(angle1) * asteroid.vy,
+                  asteroid.r / 2,
+                  color=(255, 255, 255),
+                  size_contour=10
+                )
+              )
+              self.asteroids.append(
+                Asteroid(
+                  asteroid.x + math.cos(angle2) * (asteroid.r / 1.9),
+                  asteroid.y + math.sin(angle2) * (asteroid.r / 1.9),
+                  math.cos(angle2) * asteroid.vx,
+                  math.sin(angle2) * asteroid.vy,
+                  asteroid.r / 2,
+                  color=(255, 255, 255),
+                  size_contour=10
+                )
+              )
+
+            break
+
+      for asteroid in self.asteroids:
+        if self.rocket.check_collision(asteroid.x, asteroid.y, asteroid.r):
+          self.asteroids.remove(asteroid)
+          self.rocket = RocketExplosion(self.rocket.x, self.rocket.y)
+          self.rocket_lives -= 1
+          break
+
+      if not self.rocket.alive():
+        if self.rocket_lives > 0:
+          self.rocket = Rocket(x0=self.rocket.x, y0=self.rocket.y, color=(255, 255, 0), txt_pos=(5, 30), laser_count=len(self.asteroids) * 10)
+        else:
+          break
+
+      if len(self.asteroids) == 0 and self.rocket_lives > 0:
+        self.rocket = Rocket(x0=400, y0=400, color=(255, 255, 0), txt_pos=(5, 30), l=50)
+        txt = "Winner"
+        self.rocket_lives = -1
+      else:
+        txt = "Asteroids {} / {}".format(self.asteroids_removed, len(self.asteroids))
+      cv2.putText(frame, txt, (5, 20), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.4, color=(255, 255, 255), thickness=1)
+
+      self.rocket_lives_bar(frame, self.rocket_lives)
+      self.asteroids_bar(frame, len(self.asteroids))
+
+      cv2.imshow('asteroids', frame)