supervisely 6.73.410__py3-none-any.whl → 6.73.470__py3-none-any.whl

supervisely_lib/__init__.py

@@ -1,6 +1,11 @@
 import sys
+
 import supervisely
 from supervisely import *
 
 sys.modules['supervisely_lib'] = supervisely
-sys.modules['supervisely_lib.api.api'] = supervisely.api
+
+for module_name in list(sys.modules.keys()):
+    if module_name.startswith("supervisely."):
+        new_name = module_name.replace("supervisely.", "supervisely_lib.", 1)
+        sys.modules[new_name] = sys.modules[module_name]

supervisely/app/widgets/experiment_selector/style.css

@@ -1,27 +0,0 @@
-.custom-models-selector-table {
-  border-collapse: collapse;
-}
-.custom-models-selector-table tr:nth-child(2n) {
-  background-color: #f6f8fa;
-}
-.custom-models-selector-table td,
-.custom-models-selector-table th {
-  border: 1px solid #dfe2e5;
-  padding: 6px 13px;
-  text-align: center;
-  line-height: 20px;
-}
-
-.custom-models-selector-table td {
-  text-align: left;
-}
-
-.custom-models-selector-table tr td:nth-child(4) {
-  text-align: center;
-}
-
-.el-radio-group.multi-line label.el-radio {
-  display: block;
-  margin-left: 0px;
-  margin-bottom: 5px;
-}

supervisely/app/widgets/experiment_selector/template.html

@@ -1,61 +0,0 @@
-<link rel="stylesheet" href="./sly/css/app/widgets/custom_models_selector/style.css" />
-
-<div {% if widget._changes_handled==true %} @change="post('/{{{widget.widget_id}}}/value_changed')" {% endif %}>
-
-    <div v-if="Object.keys(data.{{{widget.widget_id}}}.rowsHtml).length === 0"> You don't have any custom models</div>
-    <div v-else>
-
-        <div v-if="data.{{{widget.widget_id}}}.taskTypes.length > 1">
-            <sly-field title="Task Type">
-                <el-radio-group class="multi-line mt10" :value="state.{{{widget.widget_id}}}.selectedTaskType" {% if
-                    widget._task_type_changes_handled==true %}
-                    @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0; post('/{{{widget.widget_id}}}/task_type_changed')}"
-                    {% else %}
-                    @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0;}"
-                    {% endif %}>
-
-                    <el-radio v-for="(item, idx) in {{{widget._task_types}}}" :key="item" :label="item">
-                        {{ item }}
-                    </el-radio>
-                </el-radio-group>
-            </sly-field>
-        </div>
-
-        <div>
-
-            <table class="custom-models-selector-table">
-                <thead>
-                    <tr>
-                        <th v-for="col in data.{{{widget.widget_id}}}.columns">
-                            <div> {{col}} </div>
-                        </th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <tr
-                        v-for="row, ridx in data.{{{widget.widget_id}}}.rowsHtml[state.{{{widget.widget_id}}}.selectedTaskType]">
-                        <td v-for="col, vidx in row">
-                            <div v-if="vidx === 0" style="display: flex;">
-                                <el-radio style="display: flex;" v-model="state.{{{widget.widget_id}}}.selectedRow"
-                                    :label="ridx">&#8205;</el-radio>
-
-                                <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data"
-                                    :state="state"></sly-html-compiler>
-
-                            </div>
-
-                            <div v-else>
-
-                                <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data"
-                                    :state="state">
-                                </sly-html-compiler>
-
-                            </div>
-
-                        </td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>

supervisely/nn/tracker/bot_sort/__init__.py

@@ -1,21 +0,0 @@
-import torch  # pylint: disable=import-error
-
-try:
-    import fastreid
-except ImportError:
-    import sys
-    from pathlib import Path
-
-    fast_reid_repo_url = "https://github.com/supervisely-ecosystem/fast-reid.git"
-    fast_reid_parent_path = Path(__file__).parent
-    fast_reid_path = fast_reid_parent_path.joinpath("fast_reid")
-    if not fast_reid_path.exists():
-        import subprocess
-
-        subprocess.run(["git", "clone", fast_reid_repo_url, str(fast_reid_path.resolve())])
-
-    sys.path.insert(0, str(fast_reid_path.resolve()))
-
-    import fastreid
-
-from supervisely.nn.tracker.bot_sort.sly_tracker import BoTTracker

supervisely/nn/tracker/bot_sort/fast_reid_interface.py

@@ -1,152 +0,0 @@
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-import torch  # pylint: disable=import-error
-import torch.nn.functional as F  # pylint: disable=import-error
-from fastreid.config import get_cfg  # pylint: disable=import-error
-from fastreid.modeling.meta_arch import build_model  # pylint: disable=import-error
-from fastreid.utils.checkpoint import Checkpointer  # pylint: disable=import-error
-
-# from torch.backends import cudnn
-
-
-# cudnn.benchmark = True
-
-
-def setup_cfg(config_file, opts):
-    # load config from file and command-line arguments
-    cfg = get_cfg()
-    cfg.merge_from_file(config_file)
-    cfg.merge_from_list(opts)
-    cfg.MODEL.BACKBONE.PRETRAIN = False
-
-    cfg.freeze()
-
-    return cfg
-
-
-def postprocess(features):
-    # Normalize feature to compute cosine distance
-    features = F.normalize(features)
-    features = features.cpu().data.numpy()
-    return features
-
-
-def preprocess(image, input_size):
-    if len(image.shape) == 3:
-        padded_img = np.ones((input_size[1], input_size[0], 3), dtype=np.uint8) * 114
-    else:
-        padded_img = np.ones(input_size) * 114
-    img = np.array(image)
-    r = min(input_size[1] / img.shape[0], input_size[0] / img.shape[1])
-    resized_img = cv2.resize(
-        img,
-        (int(img.shape[1] * r), int(img.shape[0] * r)),
-        interpolation=cv2.INTER_LINEAR,
-    )
-    padded_img[: int(img.shape[0] * r), : int(img.shape[1] * r)] = resized_img
-
-    return padded_img, r
-
-
-class FastReIDInterface:
-    def __init__(self, config_file, weights_path, device, batch_size=8):
-        super(FastReIDInterface, self).__init__()
-        if device != "cpu":
-            self.device = "cuda"
-        else:
-            self.device = "cpu"
-
-        self.batch_size = batch_size
-
-        self.cfg = setup_cfg(config_file, ["MODEL.WEIGHTS", weights_path])
-
-        self.model = build_model(self.cfg)
-        self.model.eval()
-
-        Checkpointer(self.model).load(weights_path)
-
-        if self.device != "cpu":
-            self.model = self.model.eval().to(device="cuda").half()
-        else:
-            self.model = self.model.eval()
-
-        self.pH, self.pW = self.cfg.INPUT.SIZE_TEST
-
-    def inference(self, image, detections):
-
-        if detections is None or np.size(detections) == 0:
-            return []
-
-        H, W, _ = np.shape(image)
-
-        batch_patches = []
-        patches = []
-        for d in range(np.size(detections, 0)):
-            tlbr = detections[d, :4].astype(np.int_)
-            tlbr[0] = max(0, tlbr[0])
-            tlbr[1] = max(0, tlbr[1])
-            tlbr[2] = min(W - 1, tlbr[2])
-            tlbr[3] = min(H - 1, tlbr[3])
-            patch = image[tlbr[1] : tlbr[3], tlbr[0] : tlbr[2], :]
-
-            # the model expects RGB inputs
-            patch = patch[:, :, ::-1]
-
-            # Apply pre-processing to image.
-            patch = cv2.resize(
-                patch, tuple(self.cfg.INPUT.SIZE_TEST[::-1]), interpolation=cv2.INTER_LINEAR
-            )
-            # patch, scale = preprocess(patch, self.cfg.INPUT.SIZE_TEST[::-1])
-
-            # plt.figure()
-            # plt.imshow(patch)
-            # plt.show()
-
-            # Make shape with a new batch dimension which is adapted for network input
-            patch = torch.as_tensor(patch.astype("float32").transpose(2, 0, 1))
-            patch = patch.to(device=self.device).half()
-
-            patches.append(patch)
-
-            if (d + 1) % self.batch_size == 0:
-                patches = torch.stack(patches, dim=0)
-                batch_patches.append(patches)
-                patches = []
-
-        if len(patches):
-            patches = torch.stack(patches, dim=0)
-            batch_patches.append(patches)
-
-        features = np.zeros((0, 2048))
-        # features = np.zeros((0, 768))
-
-        for patches in batch_patches:
-
-            # Run model
-            patches_ = torch.clone(patches)
-            pred = self.model(patches)
-            pred[torch.isinf(pred)] = 1.0
-
-            feat = postprocess(pred)
-
-            nans = np.isnan(np.sum(feat, axis=1))
-            if np.isnan(feat).any():
-                for n in range(np.size(nans)):
-                    if nans[n]:
-                        # patch_np = patches[n, ...].squeeze().transpose(1, 2, 0).cpu().numpy()
-                        patch_np = patches_[n, ...]
-                        patch_np_ = torch.unsqueeze(patch_np, 0)
-                        pred_ = self.model(patch_np_)
-
-                        patch_np = torch.squeeze(patch_np).cpu()
-                        patch_np = torch.permute(patch_np, (1, 2, 0)).int()
-                        patch_np = patch_np.numpy()
-
-                        plt.figure()
-                        plt.imshow(patch_np)
-                        plt.show()
-
-            features = np.vstack((features, feat))
-
-        return features

supervisely/nn/tracker/bot_sort/matching.py

@@ -1,127 +0,0 @@
-import lap  # pylint: disable=import-error
-import numpy as np
-from cython_bbox import bbox_overlaps as bbox_ious  # pylint: disable=import-error
-from scipy.spatial.distance import cdist
-
-from supervisely.nn.tracker.utils import kalman_filter
-
-
-def linear_assignment(cost_matrix, thresh):
-    if cost_matrix.size == 0:
-        return (
-            np.empty((0, 2), dtype=int),
-            tuple(range(cost_matrix.shape[0])),
-            tuple(range(cost_matrix.shape[1])),
-        )
-    matches, unmatched_a, unmatched_b = [], [], []
-    cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
-    for ix, mx in enumerate(x):
-        if mx >= 0:
-            matches.append([ix, mx])
-    unmatched_a = np.where(x < 0)[0]
-    unmatched_b = np.where(y < 0)[0]
-    matches = np.asarray(matches)
-    return matches, unmatched_a, unmatched_b
-
-
-def ious(atlbrs, btlbrs):
-    """
-    Compute cost based on IoU
-    :type atlbrs: list[tlbr] | np.ndarray
-    :type atlbrs: list[tlbr] | np.ndarray
-
-    :rtype ious np.ndarray
-    """
-    ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=float)
-    if ious.size == 0:
-        return ious
-
-    ious = bbox_ious(
-        np.ascontiguousarray(atlbrs, dtype=float), np.ascontiguousarray(btlbrs, dtype=float)
-    )
-
-    return ious
-
-
-def iou_distance(atracks, btracks):
-    """
-    Compute cost based on IoU
-    :type atracks: list[STrack]
-    :type btracks: list[STrack]
-
-    :rtype cost_matrix np.ndarray
-    """
-
-    if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) or (
-        len(btracks) > 0 and isinstance(btracks[0], np.ndarray)
-    ):
-        atlbrs = atracks
-        btlbrs = btracks
-    else:
-        atlbrs = [track.tlbr for track in atracks]
-        btlbrs = [track.tlbr for track in btracks]
-    _ious = ious(atlbrs, btlbrs)
-    cost_matrix = 1 - _ious
-
-    return cost_matrix
-
-
-def embedding_distance(tracks, detections, metric="cosine"):
-    """
-    :param tracks: list[STrack]
-    :param detections: list[BaseTrack]
-    :param metric:
-    :return: cost_matrix np.ndarray
-    """
-
-    cost_matrix = np.zeros((len(tracks), len(detections)), dtype=float)
-    if cost_matrix.size == 0:
-        return cost_matrix
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=float)
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=float)
-
-    cost_matrix = np.maximum(
-        0.0, cdist(track_features, det_features, metric)
-    )  # / 2.0  # Nomalized features
-    return cost_matrix
-
-
-def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False, lambda_=0.98):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    gating_dim = 2 if only_position else 4
-    gating_threshold = kalman_filter.chi2inv95[gating_dim]
-    # measurements = np.asarray([det.to_xyah() for det in detections])
-    measurements = np.asarray([det.to_xywh() for det in detections])
-    for row, track in enumerate(tracks):
-        gating_distance = kf.gating_distance(
-            track.mean, track.covariance, measurements, only_position, metric="maha"
-        )
-        cost_matrix[row, gating_distance > gating_threshold] = np.inf
-        cost_matrix[row] = lambda_ * cost_matrix[row] + (1 - lambda_) * gating_distance
-    return cost_matrix
-
-
-def fuse_iou(cost_matrix, tracks, detections):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    reid_sim = 1 - cost_matrix
-    iou_dist = iou_distance(tracks, detections)
-    iou_sim = 1 - iou_dist
-    fuse_sim = reid_sim * (1 + iou_sim) / 2
-    det_scores = np.array([det.score for det in detections])
-    det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
-    # fuse_sim = fuse_sim * (1 + det_scores) / 2
-    fuse_cost = 1 - fuse_sim
-    return fuse_cost
-
-
-def fuse_score(cost_matrix, detections):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    iou_sim = 1 - cost_matrix
-    det_scores = np.array([det.score for det in detections])
-    det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
-    fuse_sim = iou_sim * det_scores
-    fuse_cost = 1 - fuse_sim
-    return fuse_cost