sciveo 0.1.26__tar.gz → 0.1.27__tar.gz

{sciveo-0.1.26 → sciveo-0.1.27}/PKG-INFO

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

{sciveo-0.1.26/sciveo/media/ml → sciveo-0.1.27/sciveo}/__init__.py

@@ -20,8 +20,6 @@ try:
   from sciveo.tools.daemon import TasksDaemon, __upload_content__
   from sciveo.content.runner import ProjectRunner
   from sciveo.content.dataset import Dataset
-  from sciveo.monitoring.start import MonitorStart
-  from sciveo.network.tools import NetworkTools
   from sciveo.version import __version__
 
 
@@ -46,10 +44,12 @@ try:
 
   # Monitoring start
   def monitor(**kwargs):
+    from sciveo.monitoring.start import MonitorStart
     MonitorStart(**kwargs)()
 
   # Network tools
   def network(**kwargs):
+    from sciveo.network.tools import NetworkTools
     return NetworkTools(**kwargs)
 
 except ImportError as e:

{sciveo-0.1.26 → sciveo-0.1.27}/sciveo/cli.py

@@ -14,9 +14,6 @@ import os
 import argparse
 
 from sciveo.tools.logger import *
-from sciveo.tools.timers import Timer
-from sciveo.monitoring.start import MonitorStart
-from sciveo.network.tools import NetworkTools
 from sciveo.tools.configuration import GlobalConfiguration
 
 
@@ -35,8 +32,10 @@ def main():
   args = parser.parse_args()
 
   if args.command == 'monitor':
+    from sciveo.monitoring.start import MonitorStart
     MonitorStart(period=args.period, block=args.block)()
   elif args.command == 'scan':
+    from sciveo.network.tools import NetworkTools
     NetworkTools(timeout=args.timeout, localhost=args.localhost).scan_port(port=args.port, network=args.net)
   elif args.command == 'init':
     home = os.path.expanduser('~')

sciveo-0.1.27/sciveo/ml/evaluation/object_detection.py

@@ -0,0 +1,33 @@
+#
+# 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.
+#
+# 2024
+#
+
+import math
+import numpy as np
+
+from sciveo.ml.images.object_detection import *
+
+
+"""
+
+Object Detection Evaluation
+
+"""
+
+
+class EvaluateObjectDetection:
+  def __init__(self, X, Y_true, Y_predicted):
+    self.X = X
+    self.Y_true = Y_true
+    self.Y_predicted = Y_predicted
+
+  def evaluate(self):
+    pass
+

sciveo-0.1.27/sciveo/ml/images/object_detection.py

@@ -0,0 +1,90 @@
+#
+# 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.
+#
+# 2024
+#
+
+import math
+import numpy as np
+
+from sciveo.ml.images.tools import *
+
+
+"""
+Object Detection Bounding Boxes (bbox) of type [x, y, w, h]
+
+If need to use [x1, y1, x2, y2] need to use the inverted convertor bbox_convert_inverted().
+
+IoU between 2 object detections: iou(bbox1, bbox2)
+
+"""
+
+# convert from [x, y, w, h] -> [x1, y1, x2, y2]
+def bbox_convert(bbox):
+  x1 = bbox[0]
+  y1 = bbox[1]
+  x2 = x1 + bbox[2]
+  y2 = y1 + bbox[3]
+  return [x1, y1, x2, y2]
+
+# convert from [x1, y1, x2, y2] -> [x, y, w, h]
+def bbox_convert_inverted(bbox):
+  x = bbox[0]
+  y = bbox[1]
+  w = bbox[2] - x
+  h = bbox[3] - y
+  return [x, y, w, h]
+
+def bbox_norm(bbox, w, h):
+  return (bbox[0] / w, bbox[1] / h, bbox[2] / w, bbox[3] / h)
+
+def bbox_denorm(bbox, w, h):
+  return (int(bbox[0] * w), int(bbox[1] * h), int(bbox[2] * w), int(bbox[3] * h))
+
+def bbox_center(bbox):
+  return (int(bbox[0] + bbox[2] / 2), int(bbox[1] + bbox[3] / 2))
+
+def bbox_area(bbox):
+  return bbox[2] * bbox[3]
+
+def iou(bbox1, bbox2):
+  x1 = max(bbox1[0], bbox2[0])
+  y1 = max(bbox1[1], bbox2[1])
+  x2 = min(bbox1[0] + bbox1[2], bbox2[0] + bbox2[2])
+  y2 = min(bbox1[1] + bbox1[3], bbox2[1] + bbox2[3])
+
+  if x1 < x2 and y1 < y2:
+    a = (x2 - x1) * (y2 - y1)
+  else:
+    a = 0
+
+  a1 = bbox_area(bbox1)
+  a2 = bbox_area(bbox2)
+  return a / (a1 + a2 - a)
+
+def bbox_distance(bbox1, bbox2):
+  return points_distance(bbox_center(bbox1), bbox_center(bbox2))
+
+
+"""
+
+Simple Draw object detectios helpers
+
+"""
+def image_shape(image):
+  return image.shape[1], image.shape[0]
+
+# Draw label bounding boxes of type [x, y, w, h], if [x1, y1, x2, y2] then set convert=False
+def draw_label_bboxes(image, bboxes, color, convert=True):
+  w, h = image_shape(image)
+  for bbox in bboxes:
+    if convert:
+      bbox = bbox_convert(bbox)
+    bbox = bbox_denorm(bbox, w, h)
+    cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]), color, 2, 1)
+  return image

sciveo-0.1.27/sciveo/ml/images/tools.py

@@ -0,0 +1,83 @@
+#
+# 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.
+#
+# 2024
+#
+
+import math
+import numpy as np
+
+
+def points_distance(p1, p2):
+  p1 = np.array(p1)
+  p2 = np.array(p2)
+  return np.linalg.norm(p1 - p2)
+
+def validate_point(p, w, h):
+  x = max(p[0], 0)
+  x = min(x, w)
+  y = max(p[1], 0)
+  y = min(y, h)
+  return (x, y)
+
+# Calc diameter point from a circle point and circle center
+def diameter_point(p1, p2):
+  x = 2 * p2[0] - p1[0]
+  y = 2 * p2[1] - p1[1]
+  return (x, y)
+
+# Center point for a line section (with some ratio for general purpose)
+def line_section_center_point(p1, p2, ratio=0.5):
+  x = int(p1[0] + ratio * (p2[0] - p1[0]))
+  y = int(p1[1] + ratio * (p2[1] - p1[1]))
+  return (x, y)
+
+# Line equation ax + by + c = 0 coefficients
+def line_coeff(l):
+  a = l[0][1] - l[1][1]
+  b = l[1][0] - l[0][0]
+  c = l[0][0] * l[1][1] - l[1][0] * l[0][1]
+  return a, b, c
+
+# 2 Lines intersection point (None, None) when parallel
+def lines_intersection(l1, l2):
+  a1, b1, c1 = line_coeff(l1)
+  a2, b2, c2 = line_coeff(l2)
+
+  d = (a1 * b2 - a2 * b1)
+  if d != 0.0:
+    x = (b1 * c2 - b2 * c1) / d
+    y = (c1 * a2 - c2 * a1) / d
+  else:
+    x, y = None, None
+  return x, y
+
+# Check if p is between p1 and p2 on a line
+def line_point_between(p, p1, p2):
+  return (
+        p[0] >= min(p1[0], p2[0]) and p[0] <= max(p1[0], p2[0])
+    and p[1] >= min(p1[1], p2[1]) and p[1] <= max(p1[1], p2[1])
+  )
+
+# Check a point p is intersection for 2 line segments l1 and l2
+def is_point_segments_intersection(p, l1, l2):
+  return line_point_between(p, l1[0], l1[1]) and line_point_between(p, l2[0], l2[1])
+
+# Angle from radians to degrees convertor
+def angle_rad2deg(angle):
+  return math.fabs(angle * 180 / math.pi)
+
+# Angle between lines in radians
+def lines_angle(l1, l2):
+  v1 = (l1[0][0] - l1[1][0], l1[0][1] - l1[1][1])
+  v2 = (l2[0][0] - l2[1][0], l2[0][1] - l2[1][1])
+  return math.atan2(v1[0], v1[1]) - math.atan2(v2[0], v2[1])
+
+# Angle between lines in degrees
+def lines_angle_deg(l1, l2):
+  return angle_rad2deg(lines_angle(l1, l2))

sciveo-0.1.27/sciveo/ml/images/transforms.py

@@ -0,0 +1,260 @@
+#
+# 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.
+#
+# 2024
+#
+
+import numpy as np
+import cv2
+
+
+class BaseImageTransformer:
+  def __init__(self, param=0):
+    self.param = param
+
+  def result(self, image, labels):
+    if labels is None:
+      return image
+    else:
+      return image, labels
+
+
+class RandomTransformer(BaseImageTransformer):
+  def __init__(self, class_name, lower, upper, proba):
+    self.class_name = class_name
+    self.lower = lower
+    self.upper = upper
+    self.proba = proba
+    self.transformer = class_name(1.0)
+
+  def __call__(self, image, labels=None):
+    p = np.random.uniform(0, 1)
+    if p >= (1.0 - self.proba):
+      self.transformer.param = np.random.uniform(self.lower, self.upper)
+      return self.transformer(image, labels)
+    else:
+      return self.result(image, labels)
+
+
+class ConvertColor(BaseImageTransformer):
+  def __init__(self, current='RGB', to='HSV', keep_3ch=True):
+    if not ((current in {'RGB', 'HSV'}) and (to in {'RGB', 'HSV', 'GRAY'})): raise NotImplementedError
+    self.current = current
+    self.to = to
+    self.keep_3ch = keep_3ch
+
+  def __call__(self, image, labels=None):
+    if self.current == 'RGB' and self.to == 'HSV':
+      image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+    elif self.current == 'RGB' and self.to == 'GRAY':
+      image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+      if self.keep_3ch:
+        image = np.stack([image] * 3, axis=-1)
+    elif self.current == 'HSV' and self.to == 'RGB':
+      image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)
+    elif self.current == 'HSV' and self.to == 'GRAY':
+      image = cv2.cvtColor(image, cv2.COLOR_HSV2GRAY)
+      if self.keep_3ch:
+        image = np.stack([image] * 3, axis=-1)
+    return self.result(image, labels)
+
+
+class ConvertDataType(BaseImageTransformer):
+  def __init__(self, to='uint8'):
+    if not (to == 'uint8' or to == 'float32'): raise ValueError("uint8 or float32 only")
+    self.to = to
+
+  def __call__(self, image, labels=None):
+    if self.to == 'uint8':
+      image = np.round(image, decimals=0).astype(np.uint8)
+    else:
+      image = image.astype(np.float32)
+    return self.result(image, labels)
+
+
+class ConvertTo3Channels(BaseImageTransformer):
+  def __init__(self):
+    pass
+
+  def __call__(self, image, labels=None):
+    if image.ndim == 2:
+      image = np.stack([image] * 3, axis=-1)
+    elif image.ndim == 3:
+      if image.shape[2] == 1:
+        image = np.concatenate([image] * 3, axis=-1)
+      elif image.shape[2] == 4:
+        image = image[:,:,:3]
+    return self.result(image, labels)
+
+
+class Hue(BaseImageTransformer):
+  def __init__(self, delta):
+    if not (-180 <= delta <= 180): raise ValueError("delta shoulbe in [-180, 180]")
+    super().__init__(delta)
+
+  def __call__(self, image, labels=None):
+    image[:, :, 0] = (image[:, :, 0] + self.param) % 180.0
+    return self.result(image, labels)
+
+
+class Saturation(BaseImageTransformer):
+  def __init__(self, factor):
+    if factor <= 0.0: raise ValueError("It must be `factor > 0`.")
+    super().__init__(factor)
+
+  def __call__(self, image, labels=None):
+    image[:,:,1] = np.clip(image[:,:,1] * self.param, 0, 255)
+    return self.result(image, labels)
+
+
+class Brightness(BaseImageTransformer):
+  def __init__(self, delta):
+    super().__init__(delta)
+
+  def __call__(self, image, labels=None):
+    image = np.clip(image + self.param, 0, 255)
+    return self.result(image, labels)
+
+
+class Contrast(BaseImageTransformer):
+  def __init__(self, factor):
+    if factor <= 0.0: raise ValueError("factor <= 0.0")
+    super().__init__(factor)
+
+  def __call__(self, image, labels=None):
+    image = np.clip(127.5 + self.param * (image - 127.5), 0, 255)
+    return self.result(image, labels)
+
+
+class Gamma(BaseImageTransformer):
+  def __init__(self, gamma):
+    if gamma <= 0.0: raise ValueError("gamma <= 0.0")
+    self.gamma = gamma
+    self.gamma_inv = 1.0 / gamma
+    self.lut = np.array([((i / 255.0) ** self.gamma_inv) * 255 for i in np.arange(0, 256)]).astype("uint8")
+
+  def __call__(self, image, labels=None):
+    image = cv2.LUT(image, self.lut)
+    return self.result(image, labels)
+
+
+class RandomGamma(BaseImageTransformer):
+  def __init__(self, lower=0.25, upper=2.0, prob=0.5):
+    if lower >= upper: raise ValueError("lower >= upper")
+    self.lower = lower
+    self.upper = upper
+    self.prob = prob
+
+  def __call__(self, image, labels=None):
+    p = np.random.uniform(0,1)
+    if p >= (1.0-self.prob):
+      gamma = np.random.uniform(self.lower, self.upper)
+      change_gamma = Gamma(gamma=gamma)
+      return change_gamma(image, labels)
+    else:
+      return self.result(image, labels)
+
+
+class HistogramEqualization(BaseImageTransformer):
+  def __init__(self):
+    pass
+
+  def __call__(self, image, labels=None):
+    image[:,:,2] = cv2.equalizeHist(image[:,:,2])
+    return self.result(image, labels)
+
+
+class RandomHistogramEqualization(BaseImageTransformer):
+  def __init__(self, prob=0.5):
+    self.prob = prob
+    self.equalize = HistogramEqualization()
+
+  def __call__(self, image, labels=None):
+    p = np.random.uniform(0,1)
+    if p >= (1.0-self.prob):
+      return self.equalize(image, labels)
+    else:
+      return self.result(image, labels)
+
+
+class ChannelSwap(BaseImageTransformer):
+  def __init__(self, order):
+    self.order = order
+
+  def __call__(self, image, labels=None):
+    image = image[:,:,self.order]
+    return self.result(image, labels)
+
+
+class RandomChannelSwap(BaseImageTransformer):
+  def __init__(self, prob=0.5):
+    self.prob = prob
+    self.permutations = [(0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
+    self.swap_channels = ChannelSwap(order=(0, 1, 2))
+
+  def __call__(self, image, labels=None):
+    p = np.random.uniform(0,1)
+    if p >= (1.0-self.prob):
+      i = np.random.randint(5)
+      self.swap_channels.order = self.permutations[i]
+      return self.swap_channels(image, labels)
+    else:
+      return self.result(image, labels)
+
+
+class BlackWhite(BaseImageTransformer):
+  def __init__(self, param=0):
+    super().__init__(param)
+
+  def __call__(self, image, labels=None):
+    image = np.transpose(np.tile(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (3, 1, 1)), [1, 2, 0])
+    return self.result(image, labels)
+
+
+class GaussianNoise(BaseImageTransformer):
+  def __init__(self, variance=64, mean=0):
+    super().__init__(variance)
+    self.mean = mean
+
+  def __call__(self, image, labels=None):
+    if image.ndim < 3:
+      image = np.expand_dims(image, axis=-1)
+    image = image.astype(np.float32)
+
+    sigma = self.param ** 0.5
+    noise = np.random.normal(self.mean, sigma, (image.shape[0], image.shape[1]))
+    noise = np.transpose(np.tile(noise, (image.shape[-1], 1, 1)), [1, 2, 0])
+
+    image += noise
+
+    image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, dtype=-1)
+    image = image.astype(np.uint8)
+
+    return self.result(image, labels)
+
+
+class Pixelisator(BaseImageTransformer):
+  def __init__(self, k):
+    super().__init__(k)
+
+  def __call__(self, image, labels=None):
+    w = image.shape[0]
+    h = image.shape[1]
+    k = 1.0 / self.param
+    image = cv2.resize(image, (int(w * k), int(h * k)))
+    image = cv2.resize(image, (w, h))
+    return self.result(image, labels)
+
+
+class Blur(BaseImageTransformer):
+  def __init__(self, k):
+    super().__init__(k)
+
+  def __call__(self, image, labels=None):
+    image = cv2.blur(image, (int(self.param), int(self.param)))
+    return self.result(image, labels)

sciveo-0.1.27/sciveo/version.py

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

{sciveo-0.1.26 → sciveo-0.1.27}/sciveo.egg-info/PKG-INFO

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

{sciveo-0.1.26 → sciveo-0.1.27}/sciveo.egg-info/SOURCES.txt

@@ -86,6 +86,14 @@ sciveo/media/pipelines/processors/video/video_frames.py
 sciveo/media/pipelines/processors/video/video_resample.py
 sciveo/media/pipelines/web/__init__.py
 sciveo/media/pipelines/web/server.py
+sciveo/ml/__init__.py
+sciveo/ml/evaluation/__init__.py
+sciveo/ml/evaluation/object_detection.py
+sciveo/ml/images/__init__.py
+sciveo/ml/images/object_detection.py
+sciveo/ml/images/tools.py
+sciveo/ml/images/transforms.py
+sciveo/ml/nlp/__init__.py
 sciveo/monitoring/__init__.py
 sciveo/monitoring/monitor.py
 sciveo/monitoring/start.py

sciveo-0.1.26/sciveo/__init__.py

@@ -1,56 +0,0 @@
-#
-# 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.
-#
-# 2023
-#
-
-from builtins import ImportError
-
-try:
-
-  import os
-  import time
-
-  from sciveo.tools.logger import *
-  from sciveo.tools.daemon import TasksDaemon, __upload_content__
-  from sciveo.content.runner import ProjectRunner
-  from sciveo.content.dataset import Dataset
-  from sciveo.monitoring.start import MonitorStart
-  from sciveo.network.tools import NetworkTools
-  from sciveo.version import __version__
-
-
-  TasksDaemon.current = TasksDaemon(num_threads=int(os.environ.get("SCIVEO_TASKS_NUM_THREADS", 1)))
-
-
-  # New Experiment
-  def open():
-    if ProjectRunner.current is not None:
-      return ProjectRunner.current.project
-    else:
-      error("there is no started project")
-
-  def start(project, function, configuration={}, **kwargs):
-    TasksDaemon.current.start()
-    ProjectRunner.current = ProjectRunner(project=project, function=function, configuration=configuration, **kwargs)
-    ProjectRunner.current.run()
-
-  # Dataset info
-  def dataset(info={}):
-    return Dataset.get(info)
-
-  # Monitoring start
-  def monitor(**kwargs):
-    MonitorStart(**kwargs)()
-
-  # Network tools
-  def network(**kwargs):
-    return NetworkTools(**kwargs)
-
-except ImportError as e:
-  pass