File size: 5,894 Bytes
7d9e4fc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
import atexit
import json
import logging
import os
import sys
import numpy as np
import open3d as o3d
from termcolor import colored
__all__ = [
"setup_logger",
]
def save_detection_list_to_json(detection_list, output_file):
def serialize_numpy(obj):
if isinstance(obj, np.ndarray):
return obj.tolist()
return obj
def serialize_open3d(obj):
if isinstance(obj, o3d.geometry.AxisAlignedBoundingBox):
return {
"type": "AxisAlignedBoundingBox",
"min_bound": obj.min_bound.tolist(),
"max_bound": obj.max_bound.tolist(),
}
elif isinstance(obj, o3d.geometry.OrientedBoundingBox):
return {
"type": "OrientedBoundingBox",
"center": obj.center.tolist(),
"extent": obj.extent.tolist(),
"R": obj.R.tolist(),
}
elif isinstance(obj, o3d.geometry.PointCloud):
return {
"type": "PointCloud",
"points": np.asarray(obj.points).tolist(),
"colors": np.asarray(obj.colors).tolist() if obj.has_colors() else None,
"normals": np.asarray(obj.normals).tolist() if obj.has_normals() else None,
}
return obj
def serialize_detection(detection):
serialized = {}
for key, value in detection.items():
if key in ["axis_aligned_bbox", "oriented_bbox", "pcd"]:
serialized[key] = serialize_open3d(value)
elif isinstance(value, np.ndarray):
serialized[key] = serialize_numpy(value)
elif isinstance(value, (list, dict, str, int, float, bool, type(None))):
serialized[key] = value
else:
serialized[key] = str(value) # Convert other types to string
return serialized
serialized_list = [serialize_detection(detection) for detection in detection_list]
with open(output_file, "w") as f:
json.dump(serialized_list, f, indent=2)
print(f"Detection list saved to {output_file}")
class SkipImageException(Exception):
def __init__(self, message="Known exception, skip the image."):
# Call the base class constructor with the parameters it needs
super().__init__(message)
class _ColorfulFormatter(logging.Formatter):
def __init__(self, *args, **kwargs):
self._root_name = kwargs.pop("root_name") + "."
self._abbrev_name = kwargs.pop("abbrev_name", "")
if len(self._abbrev_name):
self._abbrev_name = self._abbrev_name + "."
super().__init__(*args, **kwargs)
def formatMessage(self, record):
record.name = record.name.replace(self._root_name, self._abbrev_name)
log = super().formatMessage(record)
if record.levelno == logging.WARNING:
prefix = colored("WARNING", "red", attrs=["blink"])
elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
prefix = colored("ERROR", "red", attrs=["blink", "underline"])
else:
return log
return prefix + " " + log
def setup_logger(output=None, distributed_rank=0, *, name="metricdepth", color=True, abbrev_name=None):
"""Initialize the detectron2 logger and set its verbosity level to "DEBUG".
Args:
output (str): a file name or a directory to save log. If None, will not save log file.
If ends with ".txt" or ".log", assumed to be a file name.
Otherwise, logs will be saved to `output/log.txt`.
abbrev_name (str): an abbreviation of the module, to avoid log names in logs.
Set to "" not log the root module in logs.
By default, will abbreviate "detectron2" to "d2" and leave other
modules unchanged.
Returns:
logging.Logger: a logger
"""
logger = logging.getLogger()
logger.setLevel(logging.INFO) # NOTE: if more detailed, change it to logging.DEBUG
logger.propagate = False
if abbrev_name is None:
abbrev_name = "d2"
plain_formatter = logging.Formatter("[%(asctime)s] %(name)s %(levelname)s %(message)s ", datefmt="%m/%d %H:%M:%S")
# stdout logging: master only
if distributed_rank == 0:
ch = logging.StreamHandler(stream=sys.stdout)
ch.setLevel(logging.INFO) # NOTE: if more detailed, change it to logging.DEBUG
if color:
formatter = _ColorfulFormatter(
colored("[%(asctime)s %(name)s]: ", "green") + "%(message)s",
datefmt="%m/%d %H:%M:%S",
root_name=name,
abbrev_name=str(abbrev_name),
)
else:
formatter = plain_formatter
ch.setFormatter(formatter)
logger.addHandler(ch)
# file logging: all workers
if output is not None:
if output.endswith(".txt") or output.endswith(".log"):
filename = output
else:
filename = os.path.join(output, "log.txt")
if distributed_rank > 0:
filename = filename + f".rank{distributed_rank}"
os.makedirs(os.path.dirname(filename), exist_ok=True)
fh = logging.StreamHandler(_cached_log_stream(filename))
fh.setLevel(logging.INFO) # NOTE: if more detailed, change it to logging.DEBUG
fh.setFormatter(plain_formatter)
logger.addHandler(fh)
return logger
from iopath.common.file_io import PathManager as PathManagerBase
PathManager = PathManagerBase()
# cache the opened file object, so that different calls to 'setup_logger
# with the same file name can safely write to the same file.
def _cached_log_stream(filename):
# use 1K buffer if writting to cloud storage
io = PathManager.open(filename, "a", buffering=1024 if "://" in filename else -1)
atexit.register(io.close)
return io
|