megadetector 5.0.23__py3-none-any.whl → 5.0.24__py3-none-any.whl

megadetector/utils/ct_utils.py

@@ -28,8 +28,8 @@ image_extensions = ['.jpg', '.jpeg', '.gif', '.png']
 
 def truncate_float_array(xs, precision=3):
     """
-    Vectorized version of truncate_float(...), truncates the fractional portion of each
-    floating-point value to a specific number of floating-point digits.
+    Truncates the fractional portion of each floating-point value in the array [xs] 
+    to a specific number of floating-point digits.
 
     Args:
         xs (list): list of floats to truncate
@@ -42,6 +42,37 @@ def truncate_float_array(xs, precision=3):
     return [truncate_float(x, precision=precision) for x in xs]
 
 
+def round_float_array(xs, precision=3):
+    """
+    Truncates the fractional portion of each floating-point value in the array [xs] 
+    to a specific number of floating-point digits.
+
+    Args:
+        xs (list): list of floats to round
+        precision (int, optional): the number of significant digits to preserve, should be >= 1            
+            
+    Returns:
+        list: list of rounded floats    
+    """
+    
+    return [round_float(x,precision) for x in xs]
+
+
+def round_float(x, precision=3):
+    """
+    Convenience wrapper for the native Python round()
+    
+    Args:
+        x (float): number to truncate
+        precision (int, optional): the number of significant digits to preserve, should be >= 1
+    
+    Returns:
+        float: rounded value
+    """
+    
+    return round(x,precision)
+    
+    
 def truncate_float(x, precision=3):
     """
     Truncates the fractional portion of a floating-point value to a specific number of 
@@ -63,26 +94,7 @@ def truncate_float(x, precision=3):
         float: truncated version of [x]
     """
 
-    assert precision > 0
-
-    if np.isclose(x, 0):
-        
-        return 0
-    
-    elif (x > 1):
-        
-        fractional_component = x - 1.0
-        return 1 + truncate_float(fractional_component)
-    
-    else:
-        
-        # Determine the factor, which shifts the decimal point of x
-        # just behind the last significant digit.
-        factor = math.pow(10, precision - 1 - math.floor(math.log10(abs(x))))
-        
-        # Shift decimal point by multiplication with factor, flooring, and
-        # division by factor.
-        return math.floor(x * factor)/factor
+    return math.floor(x * (10 ** precision)) / (10 ** precision)
 
 
 def args_to_object(args, obj):
@@ -187,7 +199,8 @@ def write_json(path, content, indent=1):
 
 def convert_yolo_to_xywh(yolo_box):
     """
-    Converts a YOLO format bounding box to [x_min, y_min, width_of_box, height_of_box].
+    Converts a YOLO format bounding box [x_center, y_center, w, h] to 
+    [x_min, y_min, width_of_box, height_of_box].
 
     Args:
         yolo_box (list): bounding box of format [x_center, y_center, width_of_box, height_of_box]
@@ -202,37 +215,21 @@ def convert_yolo_to_xywh(yolo_box):
     return [x_min, y_min, width_of_box, height_of_box]
 
 
-def convert_xywh_to_tf(api_box):
+def convert_xywh_to_xyxy(api_box):
     """
-    Converts an xywh bounding box (the format used in MD output) to the [y_min, x_min, y_max, x_max] 
-    format that the TensorFlow Object Detection API uses.
+    Converts an xywh bounding box (the MD output format) to an xyxy bounding box (the format
+    produced by TF-based MD models).
 
     Args:
-        api_box: bbox output by the batch processing API [x_min, y_min, width_of_box, height_of_box]
+        api_box (list): bbox formatted as [x_min, y_min, width_of_box, height_of_box]
 
     Returns:
-        list: bbox with coordinates represented as [y_min, x_min, y_max, x_max]
+        list: bbox formatted as [x_min, y_min, x_max, y_max]
     """
-    
+
     x_min, y_min, width_of_box, height_of_box = api_box
     x_max = x_min + width_of_box
     y_max = y_min + height_of_box
-    return [y_min, x_min, y_max, x_max]
-
-
-def convert_xywh_to_xyxy(api_bbox):
-    """
-    Converts an xywh bounding box (the MD output format) to an xyxy bounding box.
-
-    Args:
-        api_bbox (list): bbox formatted as [x_min, y_min, width_of_box, height_of_box]
-
-    Returns:
-        list: bbox formatted as [x_min, y_min, x_max, y_max]
-    """
-
-    x_min, y_min, width_of_box, height_of_box = api_bbox
-    x_max, y_max = x_min + width_of_box, y_min + height_of_box
     return [x_min, y_min, x_max, y_max]
 
 
@@ -706,7 +703,130 @@ def is_function_name(s,calling_namespace):
         callable(locals().get(s)) or \
         callable(calling_namespace.get(s)) or \
         callable(getattr(builtins, s, None))
+
         
+# From https://gist.github.com/fralau/061a4f6c13251367ef1d9a9a99fb3e8d
+def parse_kvp(s,kv_separator='='):
+    """
+    Parse a key/value pair, separated by [kv_separator].  Errors if s is not
+    a valid key/value pair string.
+    
+    Args:
+        s (str): the string to parse
+        kv_separator (str, optional): the string separating keys from values.
+    
+    Returns:
+        tuple: a 2-tuple formatted as (key,value)
+    """
+    
+    items = s.split(kv_separator)
+    assert len(items) > 1, 'Illegal key-value pair'
+    key = items[0].strip()
+    if len(items) > 1:
+        value = kv_separator.join(items[1:])
+    return (key, value)
+
+
+def parse_kvp_list(items,kv_separator='=',d=None):
+    """
+    Parse a list key-value pairs into a dictionary.  If items is None or [],
+    returns {}.
+    
+    Args:
+        items (list): the list of KVPs to parse
+        kv_separator (str, optional): the string separating keys from values.
+        d (dict, optional): the initial dictionary, defaults to {}
+        
+    Returns:
+        dict: a dict mapping keys to values
+    """
+    
+    if d is None:
+        d = {}
+
+    if items is None or len(items) == 0:
+        return d
+    
+    for item in items:
+        key, value = parse_kvp(item)
+        d[key] = value
+        
+    return d
+
+
+def dict_to_kvp_list(d,
+                     item_separator=' ',
+                     kv_separator='=',
+                     non_string_value_handling='error'):
+    """
+    Convert a string <--> string dict into a string containing list of list of
+    key-value pairs.  I.e., converts {'a':'dog','b':'cat'} to 'a=dog b=cat'.  If
+    d is None, returns None.  If d is empty, returns ''.
+    
+    Args:
+        d (dict): the dictionary to convert, must contain only strings
+        item_separator (str, optional): the delimiter between KV pairs
+        kv_separator (str, optional): the separator betweena a key and its value
+        non_string_value_handling (str, optional): what do do with non-string values,
+            can be "omit", "error", or "convert"
+    
+    Returns:
+        str: the string representation of [d]
+    """
+    
+    if d is None:
+        return None
+    
+    if len(d) == 0:
+        return ''
+    
+    s = ''
+    for k in d.keys():
+        assert isinstance(k,str), 'Input {} is not a str <--> str dict'.format(str(d))
+        v = d[k]
+        if not isinstance(v,str):
+            if non_string_value_handling == 'error':
+                raise ValueError('Input {} is not a str <--> str dict'.format(str(d)))
+            elif non_string_value_handling == 'omit':
+                continue
+            elif non_string_value_handling == 'convert':
+                v = str(v)
+            else:
+                raise ValueError('Unrecognized non_string_value_handling value: {}'.format(
+                    non_string_value_handling))
+        if s is None:
+            s = ''
+        else:
+            s += item_separator
+        s += k + kv_separator + v
+    
+    return s
+    
+
+def parse_bool_string(s):
+    """
+    Convert the strings "true" or "false" to boolean values.  Case-insensitive, discards
+    leading and trailing whitespace.  If s is already a bool, returns s.
+    
+    Args:
+        s (str or bool): the string to parse, or the bool to return
+        
+    Returns:
+        bool: the parsed value
+    """
+    
+    if isinstance(s,bool):
+        return s
+    s = s.lower().strip()
+    if s == 'true':
+        return True
+    elif s == 'false':
+        return False
+    else:
+        raise ValueError('Cannot parse bool from string {}'.format(str(s)))
+    
+
+#%% Test driver
 
 def __module_test__():
     """

megadetector/utils/gpu_test.py

@@ -0,0 +1,107 @@
+"""
+
+gpu_test.py
+
+Simple script to verify CUDA availability, used to verify a CUDA environment
+for TF or PyTorch
+
+"""
+
+#%% Torch/TF test functions
+
+def torch_test():
+    """
+    Print diagnostic information about Torch/CUDA status, including Torch/CUDA versions
+    and all available CUDA device names.
+    
+    Returns:
+        int: The number of CUDA devices reported by PyTorch.
+    """
+    
+    try:
+        import torch
+    except Exception as e: #noqa
+        print('PyTorch unavailable, not running PyTorch tests.  PyTorch import error was:\n{}'.format(
+            str(e)))
+        return
+
+    print('Torch version: {}'.format(str(torch.__version__)))
+    print('CUDA available (according to PyTorch): {}'.format(torch.cuda.is_available()))
+    if torch.cuda.is_available():
+        print('CUDA version (according to PyTorch): {}'.format(torch.version.cuda))
+        print('CuDNN version (according to PyTorch): {}'.format(torch.backends.cudnn.version()))
+
+    device_ids = list(range(torch.cuda.device_count()))
+        
+    if len(device_ids) > 0:        
+        cuda_str = 'Found {} CUDA devices:'.format(len(device_ids))
+        print(cuda_str)
+        
+        for device_id in device_ids:
+            device_name = 'unknown'
+            try:
+                device_name = torch.cuda.get_device_name(device=device_id)
+            except Exception as e: #noqa
+                pass
+            print('{}: {}'.format(device_id,device_name))
+    else:
+        print('No CUDA GPUs reported by PyTorch')
+        
+    try:
+        if torch.backends.mps.is_built and torch.backends.mps.is_available():
+            print('PyTorch reports that Metal Performance Shaders are available')
+    except Exception:
+        pass 
+    return len(device_ids)
+
+
+def tf_test():
+    """
+    Print diagnostic information about TF/CUDA status.
+    
+    Returns:
+        int: The number of CUDA devices reported by PyTorch.    
+    """
+    
+    try:
+        import tensorflow as tf
+    except Exception as e: #noqa
+        print('TensorFlow unavailable, not running TF tests.  TF import error was:\n{}'.format(
+            str(e)))
+        return
+    
+    from tensorflow.python.platform import build_info as build
+    print(f"TF version: {tf.__version__}")
+    print(f"CUDA build version reported by TensorFlow: {build.build_info['cuda_version']}")
+    print(f"CuDNN build version reported by TensorFlow: {build.build_info['cudnn_version']}")
+
+    try:
+        from tensorflow.python.compiler.tensorrt import trt_convert as trt
+        print("Linked TensorRT version: {}".format(trt.trt_utils._pywrap_py_utils.get_linked_tensorrt_version()))
+    except Exception:
+        print('Could not probe TensorRT version')
+        
+    gpus = tf.config.list_physical_devices('GPU')
+    if gpus is None:
+        gpus = []
+        
+    if len(gpus) > 0:
+        print('TensorFlow found the following GPUs:')
+        for gpu in gpus:
+            print(gpu.name)
+            
+    else:
+        print('No GPUs reported by TensorFlow')
+        
+    return len(gpus)
+ 
+
+#%% Command-line driver
+    
+if __name__ == '__main__':    
+    
+    print('*** Running Torch tests ***\n')
+    torch_test()
+    
+    print('\n*** Running TF tests ***\n')
+    tf_test()