c4dynamics 1.0.80__py3-none-any.whl → 1.1.0__py3-none-any.whl

c4dynamics/detectors/yolo3_opencv.py

@@ -0,0 +1,369 @@
+import os
+import cv2
+import numpy as np
+from c4dynamics import fdatapoint 
+import pkg_resources 
+
+MODEL_SIZE = (416, 416, 3)
+
+
+class yolov3:
+    
+    _nms_th = 0.5 
+    _confidence_th = 0.5 
+ 
+    def __init__(self): # , **kwargs): 
+
+        v3path = os.path.join('resources', 'detectors', 'yolo', 'v3')
+
+        weights_path = pkg_resources.resource_filename('c4dynamics'
+                            , os.path.join(v3path, 'yolov3.weights'))
+        cfg_path     = pkg_resources.resource_filename('c4dynamics'
+                            , os.path.join(v3path, 'yolov3.cfg'))
+        coconames    = pkg_resources.resource_filename('c4dynamics'
+                            , os.path.join(v3path, 'coco.names'))
+
+        self.net = cv2.dnn.readNetFromDarknet(cfg_path, weights_path)
+        self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
+        ln = self.net.getLayerNames()
+        self.ln = [ln[i - 1] for i in self.net.getUnconnectedOutLayers()]
+
+        with open(coconames, 'r') as f:
+            self.class_names = f.read().strip().split('\n')
+        
+        # self.__dict__.update(kwargs)
+        
+
+
+    @property 
+    def nms_th(self):
+        '''
+        Non-Maximum Suppression (NMS) threshold.
+
+        Gets or sets for the Non-Maximum Suppression (NMS) threshold. Default: `nms_th = 0.5`. 
+
+        
+        Parameters (Setter)
+        -------------------
+        val : float
+            The new threshold value for NMS during object detection.
+
+        Returns (Getter)
+        ----------------
+
+        out : float
+            The threshold value used for NMS during object detection.
+            Objects with confidence scores below this threshold are suppressed. 
+
+            
+        Example
+        -------
+        
+        .. code:: 
+            
+            >>> imagename = 'planes.jpg'
+            >>> imgpath = os.path.join(os.getcwd(), 'examples', 'resources', imagename)
+            >>> yolo3 = c4d.detectors.yolov3()
+            >>> nms_thresholds = [0.1, 0.5, 0.9]
+            >>> for i, nms_threshold in enumerate(nms_thresholds, 1)
+            ...   yolo3.nms_th = nms_threshold
+            ...   img = cv2.imread(imgpath)
+            ...   pts = yolo3.detect(img)
+            ...   for p in pts:
+            ...     cv2.rectangle(img, p.box[0], p.box[1], [0, 0, 0], 2)
+            ...   plt.subplot(1, 3, i)
+            ...   plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+            ...   plt.title(f"NMS Threshold: {nms_threshold}")
+            ...   plt.axis('off')
+
+        .. figure:: /_static/images/yolo3_nms_th.png                  
+
+
+        A high value (0.9) for the Non-Maximum Suppression (NMS) threshold here  
+        leads to an increased number of bounding boxes around a single object.
+        When the NMS threshold is high, it means that a significant overlap is 
+        required for two bounding boxes to be considered redundant, 
+        and one of them will be suppressed.
+        To address this issue, it's essential to choose an appropriate 
+        NMS threshold based on the characteristics of your dataset and the 
+        level of overlap between objects. 
+        A lower NMS threshold (e.g., 0.4 or 0.5) 
+        is commonly used to suppress redundant boxes effectively 
+        while retaining accurate detections. 
+        Experimenting with different 
+        threshold values and observing their impact on the results is crucial 
+        for optimizing the performance of object detection models.
+
+
+
+        '''
+        return self._nms_th 
+
+    @nms_th.setter
+    def nms_th(self, val):
+        self._nms_th = val
+        
+    @property 
+    def confidence_th(self):
+        '''
+        Confidence threshold used in the object detection.
+
+        Gets or sets for the confidence threshold. Default: `confidence_th = 0.5`. 
+
+
+        Parameters (Setter)
+        -------------------
+        val : float
+            The new confidence threshold for object detection.
+
+        Returns (Getter)
+        ----------------
+        out : float
+            The confidence threshold for object detection.
+            Detected objects with confidence scores below this threshold are filtered out.
+
+
+        Example
+        -------
+
+        .. code:: 
+
+            >>> imagename = 'planes.jpg'
+            >>> imgpath = os.path.join(os.getcwd(), 'examples', 'resources', imagename)
+            >>> yolo3 = c4d.detectors.yolov3()
+            >>> confidence_thresholds = [0.9, 0.95, 0.99]
+            ... for i, confidence_threshold in enumerate(confidence_thresholds, 1):  
+            ...   yolo3.confidence_th = confidence_threshold
+            ...   img = cv2.imread(imgpath)
+            ...   pts = yolo3.detect(img)
+            ...   for p in pts:
+            ...     cv2.rectangle(img, p.box[0], p.box[1], [0, 0, 0], 2)
+            ...   plt.subplot(1, 3, i)
+            ...   plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+            ...   plt.title(f"Confidence Threshold: {confidence_threshold}")
+            ...   plt.axis('off')
+
+
+        .. figure:: /_static/images/yolo3_confidence_th.png
+
+
+        A single object being missed, particularly when setting the confidence threshold to 0.99, 
+        suggests that the model is highly confident in its predictions. 
+        This level of performance is typically achievable when the model 
+        has been trained on a diverse and representative dataset, 
+        encompassing a wide variety of object instances, backgrounds, 
+        and conditions. 
+
+
+        '''
+
+        return self._confidence_th 
+
+    @confidence_th.setter
+    def confidence_th(self, val):
+        self._confidence_th = val
+        
+
+
+    def detect(self, frame):
+        '''
+        Detects objects in a frame using the YOLOv3 model.
+
+        At each sample, the detector performs the following steps:
+
+        1. Preprocesses the frame by creating a blob, normalizing pixel values, and swapping Red and Blue channels.
+
+        2. Sets input to the YOLOv3 model and performs a forward pass to obtain detections.
+
+        3. Extracts detected objects based on a confidence threshold, calculates bounding box coordinates, and filters results using Non-Maximum Suppression (NMS).
+
+        Parameters
+        ----------
+        frame : numpy.array or list
+            An input frame for object detection.
+
+        Returns
+        -------
+        out : list[fdatapoint]
+            A list of :class:`fdatapoint` objects representing detected objects, 
+            each containing bounding box coordinates and class labels.
+
+        Examples
+        --------
+
+        The datasets used in the examples are available in the 
+        `Source Repository <https://github.com/C4dynamics/C4dynamics>`
+        under example/resources. 
+
+
+        Import required packages
+        ^^^^^^^^^^^^^^^^^^^^^^^^
+        
+        .. code:: 
+        
+            >>> import os 
+            >>> import cv2      # opencv-python 
+            >>> import numpy as np 
+            >>> import c4dynamics as c4d 
+            >>> from matplotlib import pyplot as plt
+
+            
+
+
+
+        Object detecion in a single frame 
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+        .. code:: 
+
+            >>> imagename = 'planes.jpg'
+            >>> img = cv2.imread(os.path.join(os.getcwd(), 'examples', 'resources', imagename))
+            >>> yolo3 = c4d.detectors.yolov3()
+            >>> pts = yolo3.detect(img)
+            >>> for p in pts:
+            ...   cv2.rectangle(img, p.box[0], p.box[1], np.random.randint(0, 255, 3).tolist(), 3)
+            >>> fig, ax = plt.subplots()
+            >>> ax.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+        .. figure:: /_static/images/yolo3_image.png
+
+
+        Object detecion in a video 
+        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+        .. code::
+        
+            >>> videoname = 'aerobatics.mp4'
+            >>> videoin   = os.path.join('examples', 'resources', videoname)
+            >>> videoout  = os.path.join(os.getcwd(), videoname)
+            >>> cvideo      = cv2.VideoCapture(videoin)
+            >>> cvideo_out  = cv2.VideoWriter(videoout, cv2.VideoWriter_fourcc(*'mp4v')
+            ...                 , int(cvideo.get(cv2.CAP_PROP_FPS))
+            ...                     , [int(cvideo.get(cv2.CAP_PROP_FRAME_WIDTH))
+            ...                        , int(cvideo.get(cv2.CAP_PROP_FRAME_HEIGHT))])
+            >>> yolo3 = c4d.detectors.yolov3()
+            >>> while cvideo.isOpened():
+            ...     ret, frame = cvideo.read()
+            ...     if not ret: break
+            ...     pts = yolo3.detect(frame)
+            ...     for p in pts:
+            ...         cv2.rectangle(frame, p.box[0], p.box[1], [0, 0, 0], 2)# np.random.randint(0, 255, 3).tolist(), 2)    
+            ...     cvideo_out.write(frame)
+            >>> cvideo_out.release()
+
+        .. figure:: /_static/images/aerobatics.gif
+
+
+        The output structure
+        ^^^^^^^^^^^^^^^^^^^^
+
+        The output of the detect() function is a list of :class:`fdatapoint` object.
+        The :class:`fdatapoint` has unique attributes to manipulate the detected object class and  
+        bounding box. 
+
+        .. code::
+
+            >>> print('{:^10} | {:^10} | {:^10} | {:^16} | {:^16} | {:^10} | {:^14}'.format(
+            ...     '# object', 'center x', 'center y', 'box top-left'
+            ...         , 'box bottom-right', 'class', 'frame size'))
+            >>> for i, p in enumerate(pts):
+            ...     tlb = '(' + str(p.box[0][0]) + ', ' + str(p.box[0][1]) + ')'
+            ...     brb = '(' + str(p.box[1][0]) + ', ' + str(p.box[1][1]) + ')'
+            ...     fsize = '(' + str(p.fsize[0]) + ', ' + str(p.fsize[1]) + ')'
+            ...     print('{:^10d} | {:^10.3f} | {:^10.3f} | {:^16} | {:^16} | {:^10} | {:^14}'.format(
+            ...                 i, p.x, p.y, tlb, brb, p.iclass, fsize))
+            ...     c = np.random.randint(0, 255, 3).tolist()
+            ...     cv2.rectangle(img, p.box[0], p.box[1], c, 2)
+            ...     point = (int((p.box[0][0] + p.box[1][0]) / 2 - 75), p.box[1][1] + 22)
+            ...     cv2.putText(img, p.iclass, point, cv2.FONT_HERSHEY_SIMPLEX, 1, c, 2)
+            >>> fig, ax = plt.subplots()
+            >>> ax.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+            >>> ax.set_axis_off()
+             # object  |  center x  |  center y  |   box top-left   | box bottom-right |   class    |  frame size  
+                0      |   0.584    |   0.376    |    (691, 234)    |    (802, 306)    | aeroplane  |  (1280, 720)  
+                1      |   0.457    |   0.473    |    (528, 305)    |    (642, 376)    | aeroplane  |  (1280, 720)  
+                2      |   0.471    |   0.322    |    (542, 196)    |    (661, 267)    | aeroplane  |  (1280, 720)  
+                3      |   0.546    |   0.873    |    (645, 588)    |    (752, 668)    | aeroplane  |  (1280, 720) 
+
+        .. figure:: /_static/images/yolo3_outformat.png
+
+
+        '''
+        #
+        # Step 1: Preprocess the Frame
+        #   - Create a blob (binary large object) from the input frame with the 
+        #       specified dimensions
+        #   - Normalize pixel values to a range of 0 to 1
+        #   - Specify the dimensions of the input layer of the YOLOv3 model
+        #   - Swap Red and Blue channels (BGR to RGB)
+        #   - Set crop to False to preserve the original aspect ratio
+        ##
+        blob = cv2.dnn.blobFromImage(frame, 1 / 255.0, (MODEL_SIZE[0], MODEL_SIZE[1]), swapRB = True, crop = False)
+
+        #
+        # Step 2: Set Input to the YOLOv3 Model and Perform Forward Pass
+        #   - Set the blob as the input to the YOLOv3 model
+        #   - Get the names of the output layers of the model
+        #   - Perform a forward pass through the model to obtain detections
+        ##
+        self.net.setInput(blob)
+        detections = self.net.forward(self.ln)
+        
+        #
+        # Step 3: Extract Detected Objects
+        #   - Iterate through the detected objects in the forward pass results
+        #   - Filter objects based on confidence threshold
+        #   - Calculate bounding box coordinates and convert to integers
+        #   - Append bounding box coordinates and class labels to respective lists
+        ##
+        raw = []
+        boxes = []
+        classIDs = []
+        confidences = []
+        h, w = frame.shape[:2]
+
+        for detection in detections:
+            for d in detection:
+                
+                scores = d[5:]
+                classID = np.argmax(scores)
+                confidence = scores[classID]
+                
+                if scores[classID] > self._confidence_th:  # Adjust the confidence threshold as needed
+
+                    box = d[:4] * [w, h, w, h] # relative (xc, yc, w, h) to pixels 
+                    # (center_x, center_y, width, height) = box.astype('int')
+
+                    x = box[0] - box[2] / 2 # top left x 
+                    y = box[1] - box[3] / 2 # top left y 
+
+                    boxes.append([x, y, box[2], box[3]]) # top left x, top left y, width, height
+                    confidences.append(float(confidence))
+                    classIDs.append(classID) 
+                    raw.append(d[:4]) 
+
+
+        indices = cv2.dnn.NMSBoxes(boxes, confidences, self._confidence_th, self._nms_th)
+        
+        box_out = []
+        class_out = []
+        points_out = []
+
+
+        if len(indices) > 0:
+            for i in indices.flatten():
+                # (x, y) = (boxes[i][0], boxes[i][1])
+                # (w, h) = (boxes[i][2], boxes[i][3])
+                #               x top left, y top left,   x bottom right,           y bottom right 
+                box_out.append([boxes[i][0], boxes[i][1], boxes[i][0] + boxes[i][2], boxes[i][1] + boxes[i][3]])
+                
+                class_out.append(self.class_names[classIDs[i]])
+
+                points_out.append(fdatapoint(raw[i], self.class_names[classIDs[i]], (w, h)))
+
+        box_out = np.array(box_out)
+        
+        return points_out # box_out, class_out,  
+
+
+

c4dynamics/detectors/{yolo_tf.py → yolo3_tf.py}

@@ -19,7 +19,7 @@ CONFIDENCE_THRESHOLD      = 0.5
 class yolo():
     
     '''
-    The yolo_detector class is a wrapper for object detection using the YOLO 
+    The yolo3_detector class is a wrapper for object detection using the YOLO 
     (You Only Look Once) model. 
 
     1. __init__(self, height=0, width=0): 
@@ -42,7 +42,7 @@ class yolo():
 
 
 
-    The yolo_detector class encapsulates the functionality of object detection using the YOLO model, 
+    The yolo3_detector class encapsulates the functionality of object detection using the YOLO model, 
     providing methods to perform detection, extract measurements, 
     and visualize the results on the frame. The class works in conjunction 
     with the YOLO model, which is loaded externally and used for the actual detection process.
@@ -54,7 +54,7 @@ class yolo():
     def __init__(self, model, height = 0, width = 0):
         self.model = model # load_model(modelpath, compile = False)
 
-        with open(os.path.join(os.getcwd(), 'c4dynamics', 'src', 'main', 'resources', 'detectors', 'yolo', 'v3', 'coco.names'), 'r') as f:
+        with open(os.path.join(os.getcwd(), 'c4dynamics', 'resources', 'detectors', 'yolo', 'v3', 'coco.names'), 'r') as f:
             self.class_names = f.read().splitlines()
 
         self.width = width

c4dynamics/filters/e_kalman.py

@@ -15,9 +15,9 @@ class e_kalman:
   # H = 0   # measurement matrix 
   # R = 0   # measurement noise matrix 
   
-  tau = 0
+  # tau = 0
 
-  def __init__(obj, x0, p0noise, tau): # vp, 
+  def __init__(obj, x0, p0noise, dt): # vp, 
     '''    '''
     
     obj.x = np.reshape(x0, ((3, 1)))
@@ -37,7 +37,7 @@ class e_kalman:
     obj.H = np.zeros((n))
     obj.H[0] = 1
     obj.R = p0noise[0]**2 
-    obj.tau = tau 
+    obj.dt = dt 
     
       
       
@@ -51,7 +51,7 @@ class e_kalman:
     b input matrix 
     u control input 
     '''
-    obj.x = obj.x + f(obj.x) * obj.tau
+    obj.x = obj.x + f(obj.x) * obj.dt
     obj.P = np.linalg.multi_dot([Phi, obj.P, Phi.T]) + Q   
     
     return obj.x

c4dynamics/filters/kalman.py

@@ -1,42 +1,58 @@
 import numpy as np
 
 class kalman:
-    # x = 0 # state vector. 
-    # P = 0   # covariance matrix
-    # Q = 0   # process noise matrix
-    # H = 0   # measurement matrix 
-    # R = 0   # measurement noise matrix 
-
-    def __init__(obj, x0, P0, A, H, Q, R, b = None): 
+    # x = 0   # state vector. 
+    # P = 0   # covariance matrix, nxn
+    # Q = 0   # process noise covariance matrix, nxn 
+    # H = 0   # measurement matrix, pxn 
+    # R = 0   # measurement noise covariance matrix, pxp 
     
-        obj.x = x0
-        obj.P = P0  # Initial error covariance matrix
-        obj.A = A    # State transition matrix
-        obj.H = H    # Measurement matrix
-        obj.Q = Q    # Process noise covariance matrix
-        obj.R = R    # Measurement noise covariance matrix
-        
-        obj.b = b    
+    Kinf = None 
+
+    def __init__(self, P0, A, H, Q, R, dt, b = None, steadystate = False): 
+        self.P  = P0   # Initial error covariance matrix
+        self.A  = A    # State transition matrix
+        self.H  = H    # Measurement matrix
+        self.Q  = Q    # Process noise covariance matrix
+        self.R  = R    # Measurement noise covariance matrix
+        self.dt = dt 
+        self.b  = b  
+        self.F = np.eye(len(A)) + dt * A
+
+        if steadystate: 
+            R_inv = np.linalg.inv(R)
+            # Compute the solution to the Riccati equation
+            P = np.linalg.solve(-(A.T @ R_inv @ H.T @ H @ A) + A.T @ R_inv @ A, -Q)
+            self.Kinf = P @ H.T @ R_inv
+
       
-    def predict(obj, u = None):
+    def predict(self, x, u = None):
         #
-        # Predict step
+        # Predict 
         ##
-        obj.x = obj.A @ obj.x
+        x = self.F @ x
 
-        if u is not None:
-            obj.x += obj.B @ u
+        if u is not None and self.b is not None:
+            x += self.b @ u
 
-        obj.P = obj.A @ obj.P @ obj.A.T + obj.Q
+        if self.Kinf is not None:
+            self.P = self.F @ self.P @ self.F.T + self.Q
+        
+        return x 
         
  
-    def correct(obj, z):
+    def correct(self, x, z):
         # 
-        # Correct step
+        # Correct 
+        # // assumes called immediately after a predict. 
         ## 
-        K = obj.P @ obj.H.T @ np.linalg.inv(obj.H @ obj.P @ obj.H.T + obj.R)
-        obj.x += K @ (z - obj.H @ obj.x)
-        obj.P = obj.P - K @ obj.H @ obj.P
+        if self.Kinf is None:
+            K = self.P @ self.H.T @ np.linalg.inv(self.H @ self.P @ self.H.T + self.R)
+            self.P = self.P - K @ self.H @ self.P
+
+        x += K @ (z - self.H @ x)
+
 
+        return x 
 
 

c4dynamics/sensors/seeker.py

@@ -83,7 +83,7 @@ class seeker(c4d.rigidbody):
       bias = bias.std \\cdot randn
 
     The `bias.std` has a default value of `0.1deg` and it can 
-    be set by the **kwargs at the stage of constructing the seeker instance:
+    be set by the \**kwargs at the stage of constructing the seeker instance:
     
     .. code::
 
@@ -153,7 +153,7 @@ class seeker(c4d.rigidbody):
       scalefactor = scalefactor.std \\cdot randn
 
     The `scalefactor.std` has a default value of 0.05 and it can 
-    be set by the **kwargs at the stage of constructing the seeker instance:
+    be set by the \**kwargs at the stage of constructing the seeker instance:
 
     .. code::
 

c4dynamics/utils/cprint.py

@@ -8,7 +8,7 @@ TXTCOLORS =     { 'k': '30', 'black':   '30'
                 , 'w': '37', 'white':   '37'
                     }
 
-def print(txt, color = 'white', bold = False, italic = False):
+def cprint(txt, color = 'white', bold = False, italic = False):
 
     settxt = '\033['
 
@@ -19,5 +19,5 @@ def print(txt, color = 'white', bold = False, italic = False):
 
     settxt += TXTCOLORS[color] 
         
-    print(settxt + 'm' + txt + '\033[0m')
+    print(settxt + 'm' + str(txt) + '\033[0m')
 

{c4dynamics-1.0.80.dist-info → c4dynamics-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: c4dynamics
-Version: 1.0.80
+Version: 1.1.0
 Summary: The framework for algorithms engineering with Python.
 Author: C4dynamics
 Author-email: zivmeri@gmail.com

c4dynamics-1.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+c4dynamics/__init__.py,sha256=jRGCKDenpYKlbCL60cstxocenk5AXjavhKowj4KR9vo,1526
+c4dynamics/body/__init__.py,sha256=JLUVlqcSCqjMAe9fzcdTNCwtay6FJnJfTNpEtJTiaM8,16
+c4dynamics/body/datapoint.py,sha256=Nvqezfi1m1BbPHvqJkh15pJ1Yc4s80j1uz1IQYsA22o,39764
+c4dynamics/body/rigidbody.py,sha256=QDWE2W8HAs4TBKXa5oOgwiHQiD8I1Uid0XoQEmEtggY,7683
+c4dynamics/detectors/__init__.py,sha256=AKLw6rH3wsPC7zLD3qAnytDy9W4XvcsfllJyDobkFa4,82
+c4dynamics/detectors/yolo3_opencv.py,sha256=AMJ89ZlxN3frjInteohkJkOOkMh2s7M2pZHr75kBUYw,14400
+c4dynamics/detectors/yolo3_tf.py,sha256=sSm0yBsL7qrodlnK0N6mL1EuyMgiPJt1kaDsrxXvTSk,5040
+c4dynamics/eqm/__init__.py,sha256=Lq5AYYI9wTF5aPVV2CePIDdb-aS4SmqC8_5bKsKDxNk,9193
+c4dynamics/eqm/derivs.py,sha256=rnC7Y_IHakA-S1m9WjhvSOlC0ISbGeQCzU7qogos6FI,4150
+c4dynamics/eqm/integrate.py,sha256=ppVu1y0OYa5GI_KZESPQCM4Oky1fSJNOHwW7glOuA9E,9193
+c4dynamics/filters/__init__.py,sha256=KGgAM_W4SLfv7yw6TfzytruHuwbMLXAlMxLzalgJlb4,643
+c4dynamics/filters/e_kalman.py,sha256=3ELC3iXdo6ItI041IZqJO2EdNn8lmPmYNav8jaUemlU,2421
+c4dynamics/filters/filtertype.py,sha256=9Tbyd_IpRrqXfzs_mLTvDSw3NPxb_Tue_6DyLBZs-ZI,188
+c4dynamics/filters/kalman.py,sha256=E-z5TMVIdgqXKhYCEzFWlMNR2HEieAPBR_f5OdAYXMs,1681
+c4dynamics/filters/lowpass.py,sha256=Z33-eWaIyFdmWUj2KjEaaD6jznt0bZjC5PsF9H6RvlM,473
+c4dynamics/filters/luenberger.py,sha256=0S5v9tQBLlDb1IWT0nhFx3xG8f03SB_9BhoD_hgjxq8,2295
+c4dynamics/resources/detectors/yolo/v3/coco.names,sha256=DzbNM53Ej4TWW02YPcDfglnbOo7Kuq6TpSDQGtMP9RA,703
+c4dynamics/resources/detectors/yolo/v3/yolov3.cfg,sha256=4mlbYgIt7E1oZJzoH3Wi-cKOx1-yPIlDL5RQHNqJ6N8,9129
+c4dynamics/resources/detectors/yolo/v3/yolov3.weights,sha256=Uj5OaeHQFTk6GwpEHO8dnHZZ4-stfhX3k_Bgohsy8pc,248007048
+c4dynamics/rotmat/__init__.py,sha256=x0BVKfGVlV9uYENxRU3xWyyvKCFbN0-aUjZ4XJi10PE,3376
+c4dynamics/rotmat/rotmat.py,sha256=aRbfBkMlLKFiiZ2cPxYxWQsDJ9lnJlyCcwHHAxBloDU,6052
+c4dynamics/sensors/__init__.py,sha256=EFgElESGRoP0qO_iyh0LeEFYbYnUt0dwDeVtPRRa4e4,654
+c4dynamics/sensors/lineofsight.py,sha256=4pkjXij60BXUkExAR1u3bQ6Dh8ZPsNoW7dynSNldF3E,2081
+c4dynamics/sensors/radar.py,sha256=xfBSryrzGi9PL8hjdFSS-t9wB2sWEFjffYUwSPHlGH8,4052
+c4dynamics/sensors/seeker.py,sha256=fDS_toUij_NNne8Lbx7taMenb9bGwYl1cAqu5dpWpz0,8091
+c4dynamics/utils/__init__.py,sha256=iRj7jQfEn3Bir_B8VTaeUPfm-X3JbyYYknqgmYYIu1o,155
+c4dynamics/utils/const.py,sha256=mgQu-GCWxLJYwEOrDJzQK01m95t05U69ge8q3RGgZIc,420
+c4dynamics/utils/cprint.py,sha256=4XVU8t74Ti6ykYI9NVkZ6Lz3cRiDWZ4A2F9xOxVu8dw,665
+c4dynamics/utils/gen_gif.py,sha256=eGrAyFLH7jx54SrX3zFAyOa74tlzDC3n6VSw-y8COVg,574
+c4dynamics/utils/gif_tools.py,sha256=CSGDqm2_zIf1n1U8DCUnxg2D-TpvHF-t0r8X827MLWs,3336
+c4dynamics/utils/images_loader.py,sha256=ihMtzy1__BV1gvH1Tz6EDJfahpgGV8hn-61Lhx1x0ws,1568
+c4dynamics/utils/import_subdirs.py,sha256=e7M039yyRAoDEu0rEaE02MJpi_oQIaNIIMXi808gWhU,1796
+c4dynamics/utils/math.py,sha256=esVQQGZST53raCPJNS5m1dBS6yqtbbDKzM0qZ32XQac,798
+c4dynamics/utils/tictoc.py,sha256=3Bnp8jSvizfwe-djhjNok7eZKw_ACYiRPGnC3GklFn0,189
+c4dynamics-1.1.0.dist-info/METADATA,sha256=crarHBNs7Y8h0kDo-9e4k6Qu31r5GDTNh4R4eDzMYig,8963
+c4dynamics-1.1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+c4dynamics-1.1.0.dist-info/top_level.txt,sha256=Pp3jXXljS2HbUDGItCnMueDc-7dI8pYDObXNtBhZVG0,11
+c4dynamics-1.1.0.dist-info/RECORD,,