sciveo 0.1.75__tar.gz → 0.1.76__tar.gz

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

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

{sciveo-0.1.75 → sciveo-0.1.76}/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.76/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.76/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.76/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.76/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.76/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.76/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.76/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.76/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.76/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)

sciveo-0.1.76/sciveo/media/capture/games/asteroids/volume_bar.py

@@ -0,0 +1,24 @@
+import math
+import cv2
+
+
+class VolumeBar:
+  def __init__(self, p1, max_vol, name, color):
+    self.w = 100
+    self.h = 10
+    self.p1 = p1
+    self.max_vol = max_vol
+    self.name = name
+    self.color = color
+
+    self.p2 = [p1[0] + self.w, p1[1] + self.h]
+
+  def __call__(self, frame, vol):
+    self.draw(frame, vol)
+
+  def draw(self, frame, vol):
+    vol = min(self.max_vol, vol)
+    p3 = [int(self.p1[0] + self.w * vol / self.max_vol), self.p1[1] + self.h]
+    cv2.putText(frame, self.name, (self.p2[0] + 3, self.p2[1]), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(255, 255, 255), thickness=1)
+    cv2.rectangle(frame, self.p1, p3, self.color, -1)
+    cv2.rectangle(frame, self.p1, self.p2, (255, 255, 255), 1)

sciveo-0.1.76/sciveo/version.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.1.76'

{sciveo-0.1.75 → sciveo-0.1.76}/sciveo.egg-info/PKG-INFO

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

{sciveo-0.1.75 → sciveo-0.1.76}/sciveo.egg-info/SOURCES.txt

@@ -34,6 +34,18 @@ sciveo/media/capture/motion_detection.py
 sciveo/media/capture/nvr.py
 sciveo/media/capture/readers.py
 sciveo/media/capture/rtsp.py
+sciveo/media/capture/games/__init__.py
+sciveo/media/capture/games/asteroids/__init__.py
+sciveo/media/capture/games/asteroids/asteroid.py
+sciveo/media/capture/games/asteroids/base_move.py
+sciveo/media/capture/games/asteroids/circle.py
+sciveo/media/capture/games/asteroids/game.py
+sciveo/media/capture/games/asteroids/geometrics.py
+sciveo/media/capture/games/asteroids/gravity_ball.py
+sciveo/media/capture/games/asteroids/laser.py
+sciveo/media/capture/games/asteroids/rocket.py
+sciveo/media/capture/games/asteroids/space_asteroids.py
+sciveo/media/capture/games/asteroids/volume_bar.py
 sciveo/media/ml/__init__.py
 sciveo/media/ml/base.py
 sciveo/media/ml/encoders/__init__.py

sciveo-0.1.75/sciveo/version.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.1.75'