Warning: Pre-existing skeleton found." - "
The following nodes will be deleted from all instances:"
- f"
From base labels: {','.join(delete_nodes)}
The following nodes will be added to all instances:
"
- f"From new labels: {','.join(add_nodes)}
Nodes can be deleted or merged from the skeleton editor after " - "merging labels.
" + # Allow user to link mismatched nodes + query = ReplaceSkeletonTableDialog( + rename_nodes=rename_nodes, + delete_nodes=delete_nodes, + add_nodes=add_nodes, ) - query = QueryDialog(title=title, message=message) query.exec_() # Give the okay to add/delete nodes - okay = bool(query.result()) + linked_nodes: Optional[Dict[str, str]] = query.result() + if linked_nodes is not None: + delete_nodes = list(set(delete_nodes) - set(linked_nodes.values())) + add_nodes = list(set(add_nodes) - set(linked_nodes.keys())) + params["linked_nodes"] = linked_nodes + okay = True params["delete_nodes"] = delete_nodes params["add_nodes"] = add_nodes @@ -1935,10 +1956,46 @@ def ask(context: CommandContext, params: dict) -> bool: @staticmethod def do_action(context: CommandContext, params: dict): + """Replace skeleton with new skeleton. + + Note that we modify the existing skeleton in-place to essentially match the new + skeleton. However, we cannot rename the skeleton since `Skeleton.name` is used + for hashing (see `Skeleton.name` setter). + + Args: + context: CommandContext + params: dict + filename: str + delete_nodes: List[str] + add_nodes: List[str] + linked_nodes: Dict[str, str] + + Returns: + None + """ + + # TODO (LM): This is a hack to get around the fact that we do some dangerous + # in-place operations on the skeleton. We should fix this. + def try_and_skip_if_error(func, *args, **kwargs): + """This is a helper function to try and skip if there is an error.""" + try: + func(*args, **kwargs) + except Exception as e: + tb_str = traceback.format_exception( + etype=type(e), value=e, tb=e.__traceback__ + ) + logger.warning( + f"Recieved the following error while replacing skeleton:\n" + f"{''.join(tb_str)}" + ) # Load new skeleton filename = params["filename"] new_skeleton = OpenSkeleton.load_skeleton(filename) + if new_skeleton.description == None: + new_skeleton.description = f"Custom Skeleton loaded from {filename}" + context.state["skeleton_description"] = new_skeleton.description + context.state["skeleton_preview_image"] = new_skeleton.preview_image # Case 1: No skeleton exists in project if len(context.labels.skeletons) == 0: @@ -1958,7 +2015,7 @@ def do_action(context: CommandContext, params: dict): add_nodes: List[str] = params["add_nodes"] else: # Otherwise, load new skeleton and compare - (delete_nodes, add_nodes) = OpenSkeleton.compare_skeletons( + (rename_nodes, delete_nodes, add_nodes) = OpenSkeleton.compare_skeletons( skeleton, new_skeleton ) @@ -1966,22 +2023,28 @@ def do_action(context: CommandContext, params: dict): for src, dst in skeleton.symmetries: skeleton.delete_symmetry(src, dst) + # Link mismatched nodes + if "linked_nodes" in params.keys(): + linked_nodes = params["linked_nodes"] + for new_name, old_name in linked_nodes.items(): + try_and_skip_if_error(skeleton.relabel_node, old_name, new_name) + # Delete nodes from skeleton that are not in new skeleton for node in delete_nodes: - skeleton.delete_node(node) + try_and_skip_if_error(skeleton.delete_node, node) # Add nodes that only exist in the new skeleton for node in add_nodes: - skeleton.add_node(node) + try_and_skip_if_error(skeleton.add_node, node) # Add edges skeleton.clear_edges() for src, dest in new_skeleton.edges: - skeleton.add_edge(src.name, dest.name) + try_and_skip_if_error(skeleton.add_edge, src.name, dest.name) # Add new symmetry for src, dst in new_skeleton.symmetries: - skeleton.add_symmetry(src.name, dst.name) + try_and_skip_if_error(skeleton.add_symmetry, src.name, dst.name) # Set state of context context.state["skeleton"] = skeleton diff --git a/sleap/gui/dialogs/merge.py b/sleap/gui/dialogs/merge.py index ff0dca008..3dd90eb0e 100644 --- a/sleap/gui/dialogs/merge.py +++ b/sleap/gui/dialogs/merge.py @@ -2,20 +2,23 @@ Gui for merging two labels files with options to resolve conflicts. """ -import attr -from typing import Dict, List +import logging +from typing import Dict, List, Optional + +import attr +from qtpy import QtWidgets, QtCore from sleap.instance import LabeledFrame from sleap.io.dataset import Labels -from qtpy import QtWidgets, QtCore - USE_BASE_STRING = "Use base, discard conflicting new instances" USE_NEW_STRING = "Use new, discard conflicting base instances" USE_NEITHER_STRING = "Discard all conflicting instances" CLEAN_STRING = "Accept clean merge" +log = logging.getLogger(__name__) + class MergeDialog(QtWidgets.QDialog): """ @@ -301,6 +304,258 @@ def headerData( return None +class ReplaceSkeletonTableDialog(QtWidgets.QDialog): + """Qt dialog for handling skeleton replacement. + + Args: + rename_nodes: The nodes that will be renamed. + delete_nodes: The nodes that will be deleted. + add_nodes: The nodes that will be added. + skeleton_nodes: The nodes in the current skeleton. + new_skeleton_nodes: The nodes in the new skeleton. + + Attributes: + results_data: The results of the dialog. This is a dictionary with the keys + being the new node names and the values being the old node names. + delete_nodes: The nodes that will be deleted. + add_nodes: The nodes that will be added. + table: The table widget that displays the nodes. + + Methods: + add_combo_boxes_to_table: Add combo boxes to the table. + find_unused_nodes: Find unused nodes. + create_combo_box: Create a combo box. + get_table_data: Get the data from the table. + accept: Accept the dialog. + result: Get the result of the dialog. + + Returns: + If accepted, returns a dictionary with the keys being the new node names and the values being the + old node names. If rejected, returns None. + """ + + def __init__( + self, + rename_nodes: List[str], + delete_nodes: List[str], + add_nodes: List[str], + *args, + **kwargs, + ): + super().__init__(*args, **kwargs) + + # The only data we need + self.rename_nodes = rename_nodes + self.delete_nodes = delete_nodes + self.add_nodes = add_nodes + + # We want the skeleton nodes to be ordered with rename nodes first + self.skeleton_nodes = list(self.rename_nodes) + self.skeleton_nodes.extend(self.delete_nodes) + self.new_skeleton_nodes = list(self.rename_nodes) + self.new_skeleton_nodes.extend(self.add_nodes) + + self.results_data: Optional[Dict[str, str]] = None + + # Set table name + self.setWindowTitle("Replace Nodes") + + # Add table to dialog (if any nodes exist to link) + if (len(self.add_nodes) > 0) or (len(self.delete_nodes) > 0): + self.create_table() + else: + self.table = None + + # Add table and message to application + layout = QtWidgets.QVBoxLayout(self) + + # Dynamically create message + message = "Warning: Pre-existing skeleton found." + if len(self.delete_nodes) > 0: + message += ( + "
The following nodes will be deleted from all instances:"
+ f"
From base labels: {', '.join(self.delete_nodes)}
No nodes will be deleted.
" + if len(self.add_nodes) > 0: + message += ( + "The following nodes will be added to all instances:
"
+ f"From new labels: {', '.join(self.add_nodes)}
No nodes will be added.
" + if self.table is not None: + message += ( + "Old nodes to can be linked to new nodes via the table below.
" + ) + + label = QtWidgets.QLabel(message) + label.setWordWrap(True) + layout.addWidget(label) + if self.table is not None: + layout.addWidget(self.table) + + # Add button to application + button = QtWidgets.QPushButton("Replace") + button.clicked.connect(self.accept) + layout.addWidget(button) + + # Set layout (otherwise nothing will be shown) + self.setLayout(layout) + + def create_table(self: "ReplaceSkeletonTableDialog") -> QtWidgets.QTableWidget: + """Create the table widget.""" + + self.table = QtWidgets.QTableWidget(self) + + if self.table is None: + return + + # Create QTable Widget to display skeleton differences + self.table.setColumnCount(2) + self.table.setRowCount(len(self.new_skeleton_nodes)) + self.table.setHorizontalHeaderLabels(["New", "Old"]) + self.table.verticalHeader().setVisible(False) + self.table.horizontalHeader().setSectionResizeMode( + QtWidgets.QHeaderView.Stretch + ) + self.table.setEditTriggers(QtWidgets.QAbstractItemView.NoEditTriggers) + self.table.setSelectionMode(QtWidgets.QAbstractItemView.NoSelection) + self.table.setShowGrid(False) + self.table.setAlternatingRowColors(True) + + # Add data to table + column = 0 + for i, new_node in enumerate(self.new_skeleton_nodes): + row = i + self.table.setItem(row, column, QtWidgets.QTableWidgetItem(new_node)) + self.add_combo_boxes_to_table(init=True) + + def add_combo_boxes_to_table( + self: "ReplaceSkeletonTableDialog", + init: bool = False, + ): + """Adds combo boxes to table. + + Args: + init: If True, the combo boxes will be initialized with all + `self.delete_nodes`. If False, the combo boxes will be initialized with + all `self.delete_nodes` excluding nodes that have already been used by + other combo boxes. + """ + if self.table is None: + return + + for i in range(self.table.rowCount()): + # Get text from table item in column 1 + new_node_name = self.table.item(i, 0).text() + if init and (new_node_name in self.rename_nodes): + current_combo_text = new_node_name + else: + current_combo = self.table.cellWidget(i, 1) + current_combo_text = ( + current_combo.currentText() if current_combo else "" + ) + self.table.setCellWidget( + i, + 1, + self.create_combo_box(set_text=current_combo_text, init=init), + ) + + def find_unused_nodes(self: "ReplaceSkeletonTableDialog"): + """Finds set of nodes from `delete_nodes` that are not used by combo boxes. + + Returns: + List of unused nodes. + """ + if self.table is None: + return + + unused_nodes = set(self.skeleton_nodes) + for i in range(self.table.rowCount()): + combo = self.table.cellWidget(i, 1) + if combo is None: + break + elif combo.currentText() in unused_nodes: + unused_nodes.remove(combo.currentText()) + return list(unused_nodes) + + def create_combo_box( + self: "ReplaceSkeletonTableDialog", + set_text: str = "", + init: bool = False, + ): + """Creates combo box with unused nodes from `delete_nodes`. + + Args: + set_text: Text to set combo box to. + init: If True, the combo boxes will be initialized with all + `self.delete_nodes`. If False, the combo boxes will be initialized with + all `self.delete_nodes` excluding nodes that have already been used by + other combo boxes. + + Returns: + Combo box with unused nodes from `delete_nodes` plus an empty string and the + `set_text`. + """ + unused_nodes = self.delete_nodes if init else self.find_unused_nodes() + combo = QtWidgets.QComboBox() + combo.addItem("") + if set_text != "": + combo.addItem(set_text) + combo.addItems(sorted(unused_nodes)) + combo.setCurrentText(set_text) # Set text to current text + combo.currentTextChanged.connect( + lambda: self.add_combo_boxes_to_table(init=False) + ) + return combo + + def get_table_data(self: "ReplaceSkeletonTableDialog"): + """Gets data from table.""" + if self.table is None: + return {} + + data = {} + for i in range(self.table.rowCount()): + new_node = self.table.item(i, 0).text() + old_node = self.table.cellWidget(i, 1).currentText() + if (old_node != "") and (new_node != old_node): + data[new_node] = old_node + + # Sort the data s.t. skeleton nodes are renamed to new nodes first + data = dict( + sorted(data.items(), key=lambda item: item[0] in self.skeleton_nodes) + ) + + # This case happens if exclusively bipartite match (new) `self.rename_nodes` + # with set including (old) `self.delete_nodes` and `self.rename_nodes` + if len(data) > 0: + first_new_node, first_old_node = list(data.items())[0] + if first_new_node in self.skeleton_nodes: + # Reordering has failed! + log.debug(f"Linked nodes (new: old): {data}") + raise ValueError( + f"Cannot rename skeleton node '{first_old_node}' to already existing " + f"node '{first_new_node}'. Please rename existing skeleton node " + f"'{first_new_node}' manually before linking." + ) + return data + + def accept(self): + """Overrides accept method to return table data.""" + try: + self.results_data = self.get_table_data() + except ValueError as e: + QtWidgets.QMessageBox.critical(self, "Error", str(e)) + return # Allow user to fix error if possible instead of closing dialog + super().accept() + + def result(self): + """Overrides result method to return table data.""" + return self.get_table_data() if self.results_data is None else self.results_data + + def show_instance_type_counts(instance_list: List["Instance"]) -> str: """ Returns string of instance counts to show in table. @@ -316,23 +571,3 @@ def show_instance_type_counts(instance_list: List["Instance"]) -> str: ) user_count = len(instance_list) - prediction_count return f"{user_count} (user) / {prediction_count} (pred)" - - -if __name__ == "__main__": - - # file_a = "tests/data/json_format_v1/centered_pair.json" - # file_b = "tests/data/json_format_v2/centered_pair_predictions.json" - # file_a = "files/merge/a.h5" - # file_b = "files/merge/b.h5" - file_a = r"sleap_sandbox/skeleton_merge_conflicts/base_labels.slp" - # file_b = r"sleap_sandbox/skeleton_merge_conflicts/labels.renamed_node.slp") - # file_b = r"sleap_sandbox/skeleton_merge_conflicts/labels.new_node.slp" - file_b = r"sleap_sandbox/skeleton_merge_conflicts/labels.deleted_node.slp" - - base_labels = Labels.load_file(file_a) - new_labels = Labels.load_file(file_b) - - app = QtWidgets.QApplication() - win = MergeDialog(base_labels, new_labels) - win.show() - app.exec_() diff --git a/sleap/gui/no-preview.png b/sleap/gui/no-preview.png new file mode 100644 index 000000000..1aec2a76b Binary files /dev/null and b/sleap/gui/no-preview.png differ diff --git a/sleap/gui/widgets/views.py b/sleap/gui/widgets/views.py new file mode 100644 index 000000000..ec3477ed2 --- /dev/null +++ b/sleap/gui/widgets/views.py @@ -0,0 +1,103 @@ +"""GUI code for the views (e.g. Videos, Skeleton, Labeling Suggestions, etc.).""" + +from typing import Tuple +from qtpy.QtWidgets import ( + QWidget, + QHBoxLayout, + QVBoxLayout, + QToolButton, + QFrame, + QSizePolicy, + QComboBox, +) +from qtpy.QtCore import Qt +from qtpy.QtGui import QCursor + + +class CollapsibleWidget(QWidget): + """An animated collapsible QWidget. + + Derived from: https://stackoverflow.com/a/37119983/13281260 + """ + + def __init__(self, title: str, parent: QWidget = None): + super().__init__(parent=parent) + + # Create the header widget which contains the toggle button. + self.header_widget, self.toggle_button = self.create_header_widget(title) + + # Content area for setting an external layout to. + self.content_area = QWidget() + + # Tie everything together in a main layout. + main_layout = self.create_main_layout() + self.setLayout(main_layout) + + def create_toggle_button(self, title="") -> QToolButton: + """Create our custom toggle button.""" + + toggle_button = QToolButton() + toggle_button.setStyleSheet("QToolButton { border: none; }") + toggle_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) + toggle_button.setArrowType(Qt.ArrowType.RightArrow) + toggle_button.setText(title) + toggle_button.setCheckable(True) + toggle_button.setChecked(False) + toggle_button.setCursor(QCursor(Qt.PointingHandCursor)) + + toggle_button.clicked.connect(self.toggle_button_callback) + + return toggle_button + + def create_header_widget(self, title="") -> Tuple[QWidget, QToolButton]: + """Create header widget which includes `QToolButton` and `QFrame`.""" + + # Create our custom toggle button. + toggle_button = self.create_toggle_button(title) + + # Create the header line. + header_line = QFrame() + header_line.setFrameShape(QFrame.HLine) + header_line.setFrameShadow(QFrame.Plain) + header_line.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum) + header_line.setStyleSheet("color: #dcdcdc") + + # Created the layout for the header. + header_layout = QHBoxLayout() + header_layout.addWidget(toggle_button) + header_layout.addWidget(header_line) + header_layout.setContentsMargins(0, 0, 0, 0) + + # Create a widget to apply the header layout to. + header_widget = QWidget() + header_widget.setLayout(header_layout) + + return header_widget, toggle_button + + def create_main_layout(self) -> QVBoxLayout: + """Tie everything together in a main layout.""" + + main_layout = QVBoxLayout() + main_layout.addWidget(self.header_widget) + main_layout.addWidget(self.content_area) + main_layout.setContentsMargins(0, 0, 0, 0) + + return main_layout + + def toggle_button_callback(self, checked: bool): + self.toggle_button.setArrowType( + Qt.ArrowType.DownArrow if checked else Qt.ArrowType.RightArrow + ) + + # Hide children if we're collapsing + for child in self.content_area.findChildren(QWidget): + child.setVisible(checked) + + # Collapse combo box (otherwise, visiblity opens combo) + if checked: + combo = self.content_area.findChild(QComboBox) + combo.hidePopup() + + def set_content_layout(self, content_layout): + self.content_area.setLayout(content_layout) + self.toggle_button_callback(self.toggle_button.isChecked()) diff --git a/sleap/instance.py b/sleap/instance.py index 8eb24c1a2..c14038552 100644 --- a/sleap/instance.py +++ b/sleap/instance.py @@ -799,11 +799,11 @@ def fill_missing( """ self._fix_array() y1, x1, y2, x2 = self.bounding_box - y1, x1 = max(y1, 0), max(x1, 0) + y1, x1 = np.nanmax([y1, 0]), np.nanmax([x1, 0]) if max_x is not None: - x2 = min(x2, max_x) + x2 = np.nanmin([x2, max_x]) if max_y is not None: - y2 = min(y2, max_y) + y2 = np.nanmin([y2, max_y]) w, h = y2 - y1, x2 - x1 for node in self.skeleton.nodes: diff --git a/sleap/io/dataset.py b/sleap/io/dataset.py index 044d55758..6ebe27822 100644 --- a/sleap/io/dataset.py +++ b/sleap/io/dataset.py @@ -2618,6 +2618,7 @@ def video_callback( for i, filename in enumerate(filenames): if missing[i]: filenames[i] = new_paths[i] + missing[i] = False # Solely for testing since only gui will have a `CommandContext` context["changed_on_load"] = True diff --git a/sleap/nn/viz.py b/sleap/nn/viz.py index 6fe5bf4ba..4fd6e8272 100644 --- a/sleap/nn/viz.py +++ b/sleap/nn/viz.py @@ -4,7 +4,11 @@ import matplotlib import matplotlib.pyplot as plt import seaborn as sns +import base64 from typing import Union, Tuple, Optional, Text +from sleap import Instance +from io import BytesIO +from PIL import Image def imgfig( @@ -194,7 +198,7 @@ def plot_instance( ms=10, bbox=None, scale=1.0, - **kwargs + **kwargs, ): """Plot a single instance with edge coloring.""" if cmap is None: @@ -296,3 +300,87 @@ def plot_bbox(bbox, **kwargs): bbox = bbox.bounding_box y1, x1, y2, x2 = bbox plt.plot([x1, x2, x2, x1, x1], [y1, y1, y2, y2, y1], "-", **kwargs) + + +def generate_skeleton_preview_image( + instance: Instance, square_bb: bool = True, thumbnail_size=(128, 128) +) -> bytes: + """Generate preview image for skeleton based on given instance. + + Args: + instance: A `sleap.Instance` object for which to generate the preview image from. + square_bb: A boolean flag for whether or not the preview image should be a square image + thumbnail_size: A tuple of (w,h) for what the size of the thumbnail image should be + + Returns: + A byte string encoding of the preview image. + """ + + def get_square_bounding_box(bb): + """Convert rectangular bounding box to square bounding box. + + Args: + bb: A tuple representing a bounding box in `sleap.Instance.bounding_box` + with the format [y1, x1, y2, x2] + + Returns: + A square bounding box in `PIL.Image.crop()` with the format [x1, y1, x2, y2] + """ + + y1, x1, y2, x2 = bb + + # Get side lengths + dist_x = x2 - x1 + dist_y = y2 - y1 + + mid_x = x1 + dist_x / 2 + mid_y = y1 + dist_y / 2 + + # Get max side length to use as square side length + max_dist = max(dist_x, dist_y) + + # Get new coordinates + new_x1 = mid_x - max_dist / 2 + new_x2 = mid_x + max_dist / 2 + new_y1 = mid_y - max_dist / 2 + new_y2 = mid_y + max_dist / 2 + + assert new_x2 - new_x1 == new_y2 - new_y1, ValueError( + f"{new_x2-new_x1} != {new_y2-new_y1}" + ) + return (new_x1, new_y1, new_x2, new_y2) + + if square_bb: + x1, y1, x2, y2 = get_square_bounding_box(instance.bounding_box) + else: + y1, x1, y2, x2 = instance.bounding_box + bb = [x1, y1, x2, y2] + bb = [coor - 20 if idx < 2 else coor + 20 for idx, coor in enumerate(bb)] + + frame = plot_img(instance.video.get_frame(instance.frame_idx)) + + # Custom formula for scaling line width and marker size based on bounding box size. + max_dim = max(abs(y1 - y2), abs(x1 - x2)) + ms = int(max_dim / 7) + lw = int(max_dim / 30) + skeleton = plot_instance( + instance, skeleton=instance.skeleton, lw=lw, ms=ms, color_by_node=False + ) + + fig = skeleton[0][0].figure + ax = fig.gca() + ax.get_yaxis().set_visible(False) + ax.get_xaxis().set_visible(False) + fig.set(facecolor="white", frameon=False) + + img_buf = BytesIO() + plt.savefig(img_buf, format="png", facecolor="white") + im = Image.open(img_buf) + im = im.crop(bb) + im.thumbnail(thumbnail_size) + + img_stream = BytesIO() + im.save(img_stream, format="png") + img_bytes = img_stream.getvalue() # image in binary format + img_b64 = base64.b64encode(img_bytes) + return img_b64 diff --git a/sleap/skeleton.py b/sleap/skeleton.py index 064105a1f..e159aeb05 100644 --- a/sleap/skeleton.py +++ b/sleap/skeleton.py @@ -86,17 +86,22 @@ def matches(self, other: "Node") -> bool: class Skeleton: - """ - The main object for representing animal skeletons. + """The main object for representing animal skeletons. The skeleton represents the constituent parts of the animal whose pose is being estimated. - An index variable used to give skeletons a default name that should - be unique across all skeletons. + Attributes: + _skeleton_idx: An index variable used to give skeletons a default name that + should be unique across all skeletons. + preview_image: A byte string containing an encoded preview image for the + skeleton. + description: A text description of the skeleton. Used mostly for presets. """ _skeleton_idx = count(0) + preview_image: Optional[bytes] = None + description: Optional[str] = None def __init__(self, name: str = None): """Initialize an empty skeleton object. @@ -120,20 +125,23 @@ def __init__(self, name: str = None): def __repr__(self) -> str: """Return full description of the skeleton.""" return ( - f"Skeleton(name='{self.name}', " + f"Skeleton(name='{self.name}', ", + f"description='{self.description}', ", f"nodes={self.node_names}, " f"edges={self.edge_names}, " f"symmetries={self.symmetry_names}" - ")" + ")", ) def __str__(self) -> str: """Return short readable description of the skeleton.""" + description = self.description nodes = ", ".join(self.node_names) edges = ", ".join([f"{s}->{d}" for (s, d) in self.edge_names]) symm = ", ".join([f"{s}<->{d}" for (s, d) in self.symmetry_names]) return ( "Skeleton(" + f"description={description}, " f"nodes=[{nodes}], " f"edges=[{edges}], " f"symmetries=[{symm}]" @@ -797,8 +805,7 @@ def __len__(self) -> int: return len(self.nodes) def relabel_node(self, old_name: str, new_name: str): - """ - Relabel a single node to a new name. + """Relabel a single node to a new name. Args: old_name: The old name of the node. @@ -810,8 +817,7 @@ def relabel_node(self, old_name: str, new_name: str): self.relabel_nodes({old_name: new_name}) def relabel_nodes(self, mapping: Dict[str, str]): - """ - Relabel the nodes of the skeleton. + """Relabel the nodes of the skeleton. Args: mapping: A dictionary with the old labels as keys and new @@ -975,7 +981,12 @@ def to_json(self, node_to_idx: Optional[Dict[Node, int]] = None) -> str: indexed_node_graph = self._graph # Encode to JSON - json_str = jsonpickle.encode(json_graph.node_link_data(indexed_node_graph)) + dicts = { + "nx_graph": json_graph.node_link_data(indexed_node_graph), + "description": self.description, + "preview_image": self.preview_image, + } + json_str = jsonpickle.encode(dicts) return json_str @@ -1024,7 +1035,10 @@ def from_json( Returns: An instance of the `Skeleton` object decoded from the JSON. """ - graph = json_graph.node_link_graph(jsonpickle.decode(json_str)) + dicts = jsonpickle.decode(json_str) + if "nx_graph" not in dicts: + dicts = {"nx_graph": dicts, "description": None, "preview_image": None} + graph = json_graph.node_link_graph(dicts["nx_graph"]) # Replace graph node indices with corresponding nodes from node_map if idx_to_node is not None: @@ -1032,6 +1046,8 @@ def from_json( skeleton = Skeleton() skeleton._graph = graph + skeleton.description = dicts["description"] + skeleton.preview_image = dicts["preview_image"] return skeleton diff --git a/sleap/skeletons/bees.json b/sleap/skeletons/bees.json new file mode 100644 index 000000000..819c6a894 --- /dev/null +++ b/sleap/skeletons/bees.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for bees reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "Skeleton-1", "num_edges_inserted": 20}, "links": [{"edge_insert_idx": 0, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["thorax1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["head1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 1, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["abdomen1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 6, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 8, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 10, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 12, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 14, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 15, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 18, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 19, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 2, "key": 0, "source": {"py/id": 2}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["antennaL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 3, "key": 0, "source": {"py/id": 2}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["antennaR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 4, "key": 0, "source": {"py/id": 13}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["antennaL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 5, "key": 0, "source": {"py/id": 14}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["antennaR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 7, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 9, "key": 0, "source": {"py/id": 6}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 11, "key": 0, "source": {"py/id": 7}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 13, "key": 0, "source": {"py/id": 8}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 16, "key": 0, "source": {"py/id": 9}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 17, "key": 0, "source": {"py/id": 10}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR2", 1.0]}}, "type": {"py/id": 3}}], "multigraph": true, "nodes": [{"id": {"py/id": 1}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}, {"id": {"py/id": 13}}, {"id": {"py/id": 15}}, {"id": {"py/id": 14}}, {"id": {"py/id": 16}}, {"id": {"py/id": 5}}, {"id": {"py/id": 17}}, {"id": {"py/id": 6}}, {"id": {"py/id": 18}}, {"id": {"py/id": 7}}, {"id": {"py/id": 19}}, {"id": {"py/id": 8}}, {"id": {"py/id": 20}}, {"id": {"py/id": 9}}, {"id": {"py/id": 21}}, {"id": {"py/id": 10}}, {"id": {"py/id": 22}}, {"id": {"py/id": 11}}, {"id": {"py/id": 12}}]}, "preview_image": {"py/b64": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAABYpUlEQVR4nLW9aaxk6XmY95y1Tq236u69Tm8zzdk4HC7ikLIlUpQoSqKlSHYMwYadBHZgwIkTBAEC+0eM5FeQHwkQOLCdQLAdO7K1WbbMWKQpWhIpiyOTHHKGnJmetdd7u/vutS9n+b78OPWe+9bp6vEC+wAX996qs3zfu+/H+ZVf+RXrOA6+7+O6Lo7jIP/7vk+lUqFarWKtBSCKIqIownVdJpMJcRyTZRmz2YwkSciyjCRJSJIEay2tVotqtUocx4xGo+JzYOF5ruvieR7WWlzXLZ7h+z6O42CMIU1TjDEYY5hMJlhrybJs4cd1XcIwxHEcZrMZjuMgh7UWa23xPKB4ZhiGhGFIpVIhCALSNGU6nRbPSNOUNE2x1hZrcByn+D5JkgJmrusWe5RzZJ+O4+B5XgFbz/PIsqxYp+xTnqV/5LnGmAJ+nucV8JE1yf703n3fp1arEUVRca8sy/BloVmWLSBFFi+bieMYay2VSgXf94tFJEnCbDYjy7JiEfIAay1JkhSb1Ic8Qz9ffzabzQoCcF23eF4cxwUhLLuP7MF1XYIgKAhDnyuAFsA5jkOSJBhjqFar+L5PlmXFvgUZcp3srfy/fCYIL6/RGIPneQUBAzSbzYV7yXo10vXfQlDCKPIs/Vwhav1dmqYLOBCc+GmaLlCRvpEsXjjb932iKCIMQ4bDIdbaAhllCpX7jUajArlCJHoT+jkagHJeEATFZvVa5CgDXoCouUmIQp8nEkCeI/9XKpViPcYYkiRZIBqNEL3nxxGjlgRwymie5xFFEUEQLMBNCLF8D7lOf17+ThORwEs/XxhD48DXnKeRrwlCKMr3fYIgKG4myNEblENveDKZFASg7ydA19QsnwGFSBUi1ZzxuEOLTmNMISZlL7K2ZcQnakCrjjJx6d8CcPmtn6EJXHOsHEEQUKvVFsR1HMcL4l1L1TJsNZNo2GtpI7AWqRCGYXGO4NeVh2gxp2+gN+L7fvFZtVpd+F4DRS9Q7iV6TX6W3b+8CXmevmcZEGUkidqZTqcFQMt70+fq60VlCALKnF6+XvasVaUmwGV70ggQwpYffT/gEXWgcSPfaalUVt2aGMoMK3vwtcgQaaCptmw4iU5O0/QRyaE3WuYGMZS0uNXSpgxcDeQsy5hOp4zH4wV9rkXwMqNLG4bLOEXvTevNMpI1QpZJS9mvlhBivGqEayLWYl9LKM3xj5N0+jlyf8/zFs7RKg8o1qMluzEmJ4A0TQvDR24kVKOJQIAvBoXWM2UOedyiC9EzJwL9jDKw5Jo0TRmNRoU+l7VoQGlxqLle9ia6T4vhMlcJV+qjLAXKhCPPe5zkkD3pZ2k4lwlwmUG5bK1yXhAEhZgvH5oZNBNo1eRrxGjkaNdC32w8HheiRBalDRSNGI34MuXrDZddFr0BAY48fzabPXKenKvFol6P7/vF85YhXz9Lc7xGXHlfZf0u5wnB6fsACyLeWluI/bLkLKuWsuei9yj3edxe9OdiC+nD2rkRKP8Il8iN9QLkZuIO6kXpv7VqKKsR2YBGqgBHFqnvJf8nScJgMDj1XUvitaynhQv12uS5ss/HqR5N8GU1o+Gg9y56ugwDeZaGq3wmsYqyei1b8eW1ldWjeClatWq4aDwss6N8vSkN4GWcKZxU9g5EbGoRqRciSJG/kyQpAKO5dNk1sukkSUizDBxwHR/HWlwHjFlEdNlC1qpLP3MZl5T38DgxXDbwlu23LBn0d/pZ2h3V3F1GYNmP14anXK/3v2yP5ViLtRZfc98y90JvtryAshgsH/rhIoLkedoY0edpqVC4hp5HEASsBnWabgiuw1E6ZpjNcFkOcI1obWgJB5afK4cmFgHsMklWNvDk/mXJUj6/bAcJckWFadiUPaUPMp7LLraGpeM4BfOWpZVfFqFaT4go8n1/qSGkDStt1ZaNGb2BZRQp54v+lI0YY0izFN86fKJ2gW23ju/mG5zYhDcne7w/PQK7aHAJ8ZTVmVZDGpAaWAKYMqCXuVzaA/ggThega6KUkHiZETThaOSXVZI+XyO0gFuaLjxPws9aZQCnoWC5UTl0qnW61uGauvVCl0WsHieehPrLIk8ALve/Mq2y7oUYLJnN71V1Aj5aO884jbk3OykkgX5m2WjTCBGAlq1jTbxaJEuEThuL+r4aRvrQXsEyG0V7Q8vg+kF70mq6bMRrQ1EbgMIY4iW5ZUNPGxfaDdN/60OrB400DRgtTssEI4cEiLSIclyXpgnoJAEZFi2sDRbXcXiquoHnuI8YdsuepaWTTizp0HFZrBpjFiJ0ZalWNso0XISIys93HKdIdi0T11pSLSMoQbS2F2QNmmjlt0hwvQ+Bla83rClJbqY/Ex0SBMECUnX2qnyU71lWB3IPOVe7iEmWUrMVXAvmUS8RYy0rfpXIDZiYZEEGiCjUxCjcIQAR6SYSRzhHzhe9+ThxL8Rddu80QZS9Abmn67rEcVw8R87VlrwmuDJMtT6X32EYFv/L/XzfJwzDIpgmsJE1+WWq1xwhC9ALy7KMOI6LnEAURcUDNQfrey5Dtt6ctg2E6KIowhpDajNwHOBR4gLIrCE1GdaY+XmLa17mv4sUE0Bog7YsOsMwJE3Twv0tw6ssgsviXhAmxCe6uGzzSJRUch/LVJg8V/alDT+doZVnyu+y5BZiD4IgjwPIIuQGwhllsSoUqxEmGa3ZbEav12M2mxXSoGyp6kOLQ/lfb9B1XRwLJ3ZGTESA8wgJuI7Dg1mPcTorjEMBXJk7NSC1LhdAOI5T1BhosV6pVHBdl+l0ynQ6Le6vJWD5Ofr+ZckniJvNZgvny/PCMMTzPOI4LtLsOmMr52kC1vjQ0kbDV1xv7SVUKpXcCCyLZqEcyViJyBfpINSkNymEMB6P6ff7xQbLwBdu0N/JYiXVXKlUiu8mTsZuOOVyXMv9fhYNOuuA5/vYzDySOFlGfFrdiHiUvU0mkyLIpLnY8zzq9TpRFDEejxmPx0sNTJ321p6HEJnneQVBaddP21ECIylMmUwmheheJlllL3pfQRAUdRtlD0j2I9KjIAD5UhZfqVSo1WoLARrRW5PJhDAMiaKoAJhsstFo4Hkeg8GA8Xi8tLJFDnmW1BmIYaQXHCcx72YjjuOAi06Tph9R8fJQtLGGK9Eae4zZHZ8s9UqWAUiqcYTzZR1JkjAej4u96hCycE+j0cD3fcbjMXEcP+K6la102ZswkehvyCXqeDwu1iREIvdyXZdGo0EYhkVhiiZiHReQwptqtVowrcabFO4IDITIfBFLcmIYhjQajQVDTx7S7/cL76BSqTCdTqlWq1QqlcIAAahWqwWBdLvdYpNC4TrxJJxVTgpZawuVYq2lh+W13k32dh/w6a2n+NxTHyXOUjxcnqlsMvIyJrMp49F4oexM9iUAlbWWLXDhbG34StFGFEULxqAuiRO1oTlUfspMIs/KsozBYPAIQuT8SqWyQChSOjadTgtbQWClDedarUa9Xl9I6AmhSTJNq5HJZHIaCvZ9n2azuYAM7dZJJY52mbIsYzweM5vNCvEtwQbRn51OB9d1CyKQ+wZBQL1eLwhH2wC6ikfq8xxrmUyn3Hm4y727d3lm+wk2m6tkJmPVqXLW1rlbsaz4QaGCZJ2u6xalXtqNEikk+larJlnrcDhkMpkUiNEST2Aldo9es4hhrXOFEweDwUJNhJwjNQya8HRgTKqVtBqWQg85V9dsAIxGo6JuU9sLYkj61lpqtRq1Wq3QDQI0ce8gL5YQ90moVkuH8XjMZDKhUqkUCxXuFbEp5WFhGBbVMGKRCqXK8+U+2rjyPY9aJeLu4Q6/9u1/yV/53H+aPx+45q/yYDJg5ppCDc1mM8IwXJBmGrkaKJ7nLQSltIRIkqQoEo2iiGq1WnwvQJeiWBGtusxOYCmGpE5rC2HoQ4pqx+MxjUajkAjWLqZ/td0khCFrn0wmC8U34gmIahP8+e12u9CF2roVcWOMeayIXmZwCTfo2DPkakEWLRuQBYuEkVIsQYYUkWjV0ul06Ha7/N5b3+XTV5/nE5efIU4Tal7Ik/4q353eJ/D9guNljbJ54Vh5lqgD7UrpvWmLPk1ThsMhSZJQrVYX8hUiIcoSUiSaLmbVRqNwscBde2BJktDtdgsGlWfJ+YJMTcgCfwn66FiI9mBkT76IAnloebHCmeWQaWFFzqlJIzWO44UyaQGI9lV17EDUi+ZOvXh5hhDA0dER3X6ff/DNL/P0mUtEQYixhicqHe7NuhxkY0I/IAzDgptEzMZxXIhaLc6FE7Uk0IjSHpLYC1pyyvXa3RPClhiC1r9aDS3zijSyxuPcrhH7RRhOu5/yLB3BFSLU9pDAV44iEGStLfxOOTQBiFiWYhDtvpT9UwGE1OaJ/pLonHC2plI5ytFHSV6IGI+iiGazSbVS4cbuLf7Z9/6AP/upLzBLY1zH5Zlok68P3sf6Pq7jLnCTJjbhNkGscJLevyZUzTmyV5EGIqZl78IA5QpfHaLVtoG2f7SxLEQiP3EcE4Yh9Xp9gbHEfinDMScqkC05Dnje4jN8uYmI2seJeOFoURdC9bp4QRtQ2t+XDesFC7FpSi6XcMs90jQtnisAqFar+IMBv/6tr/HS1ee4vHGGJMvYqDS5Ml3lVjbAc71i7dLkURbxohoEMRLs0jDQQNUE7zhOYUBKeXeWZYX+1UykI5LyXIGdJq5ygKy8ljiOC69Ex2XKEU9jLFlmiCJDu53heZZ+H3o9F2vBdecqQIwl4TSNxDIhlIsSRH3IUY56ib7S3TZiF+jNl5EiXKn1sLg6URSxsrJS2AJHvRP+zu//Fv/zn/xLOQCt5ZnGGU6mCUObFNRefo78L+sXBhArvGyYCSz0XgXBIu00t5YTY/pa/becqyWx3F9LHDm0cVlWlfpZaWo4fz7lySdTosjiOJCmsLfn8NZbliwLcF2VDCpHtsoiSMSxtgXKcW1d7KEBVdaROvKlw8bLgjgiQbS4rtfrrK2tcXh4yGg04vff/A6/+/RH+fyHP8UsiYlcn6crG3wnfoDlVORphOnspf7RKuhxxzKdqol22b3lunJoWsdG5ByNE/23uLPao1kmAdLUsLmZ8uyzGa4LglrHgfPnLY4T853vJPT7g1MCWEalmii0cSZUKGFN4WQ4reXX58um9HlCNGVg6mfqz8QwEz+71WrR6XQ4Pj5mOBrxf3/tN/nopQ/RrjfJjGHba3LG7XM36y0A+4NEsxxlfb8M8fK/RobsVxvQmlMfB2O9N12QUz5f4KHXIpI5h6Xo+4xLlzI871T/y5GmsL1tmc32ePBgmMcBtFFQXpw8VBtlWhLIojUn6Gs0ULVkeVyzhv4tKkbOFQtYQqRnz54tIo3vPbjLr7z8Vf6rz/9pMmNwgOvBOnvxkOHc6NSiUotROeRZy9wtvQcdg9drF87X2bzHPUvUhuynyM7NjVH5fNkzRF25rkeWGdLUFPp+Y8Nw5oxlbc15BPlyeB5cuNAijldOI4HLqnnLh9YzYvTI59rwK4eQM4UAbTBqnac5SH8nwRV9jjy/1WqxurrK8fExYaXCd/dvcvPoPpc626QmY8WLeMJpcme8u2AHiFGqkSKcqNPBWoqV9a4Qvxb7es9aCmjYCeFomItUlVSwJoCycZin4kMcxyVNEzxvxtmzMVtbltVVSxSBtQ5mUagtHNZCGNao1ZxTAli2WC2SBHB6MZJA0ZGzMhcvE1n6OfJbI0KfJ0aZPFf/rlQqbG5uFu7dNIn5B9/8Mn/1C38ulx7Wcr2+xXfTd3gYzwg8f+GZZaOwbPdo6fYoEE9D2tptK+vkD7KtRB2J2pxOp4VLKtJPiMHaHLFxnNJoxKytGTY2UjqdjEolN/KMORX5rivXLK7bcWA6tdy/PyPLvNPGENnQ4xZcDiBot0mqfTVytPiSv3XsQABQ1vtl6SOcKmpHRLDj5Bm0TqdDr9fj5s2bzGYz/vD+ff7FuSf5uY/9KLMkpuIHvLRxjb//g9+lVq/jLckFlNWW7E1EdDm+XhbL2njU99VFGFqiaKko3pHsTzen5sZhBc9ziSKH7e2AS5cMW1vjuWXvYO2pkee64HkOSWI5OjJUKg6tVi4NrD0lijfeSOl2U4LA5jaAdkXKov+UAk/1ssSjy7qxvFk5X59XPjSR6bXorlZBfJqmhGG4QGQCwNFolMcWTMb/8/Uv8YnLz7C5skqaZXxo8yLXm9u8sv8+a+3VR3L+Is3ERS0/U/ahrf0ysWhJp0PNWqJoOEqOH+D4+BhjDLVaDXAAB8/zqVY9zpzxuHq1ysWLVZpNt+B0a505Uh08L7f8T04M9++n7OxkHB9Drebw7LM+Z854+L5Dv295++2EO3cyXHeeC9DFmHqB+m9ZvABJQrwiquRc0WVamojvLufo88vPKBui+hqdji374JIskTb0O+MH/L2v/zP+2n/yX5AZsFh++ulP8srtt+g6PVZarQU7RAhdE4Vep7aPyjpfooxyrYhu7ddrg0+e1ev1aLVa7O3t0e12qVSqDAZjms2IJ55o8txzLa5da7K2FuF5DnkDDPNnOnML33B0NGN3N2Z319LtuiSJg+Pkor7XM/zBH8REkYPv59+lqcXznLl6mPcGLuNgbcEKFy+zijXCNYIeZwPo++rPNdCW/WjDUhAkBNNoNFhdXWU4HOZGkuvxpe98nc8+8wk+9dTzzNKE7ZU1fupDP8Tf/aPfxnEuUJ0nuCS0LXvRSCoTyTLXthxH0R6AIF+ingKnvNN5Qr8/5PDwiCjyuXx5hRdfPMOzz66xtVUnCFyyzGKMJU0trusQBA5ZZjk+nnDnzpi7dxN6PR9jAjzPx/PA88QbOcXpdOpgTDonHA84tet8rau1lSsbFqQL5y+z8OW8MvcIh0h8XCNQP0dLGHlu+UcbgHp9AK1Wi6tXr5KmKbu7u8SzGaPZjP/zK7/C809co+KHxFnKjz/7Q/z+jVe4u/eAJ85ffES3L5NA2ugtE6KuPNaEkwM/D8fG8YzpdDpXCzGzWczJSRfXNZw5U+fnf/4pPvrRs1y4sEKl4pNlhiyzJImZI93DWsPJyZT33utx+3bM0ZHF95s0m+vU6w5JEi+o8TIzgcVaQ5bl65O6DWvtKQGIr625XpAvCC5bwxopy5JD8reO+QvAy+pFX7PMZtAiWBOgfLa2tsbTTz9NvV7n9u3bzOKYb7/7Or/6r/4Ff/HHf4FpMiP0A/6zP/Yz/C9f/gdMxhPwXAJrcJ1FNabvv8w11d/rCGUupi2elxtbo9F0Xpwy5ejoBNc1nDu3wqc/fZWPfGSbK1dWqVYDJG4fx1mBdLCcnEx5551Dbtzo8eBBirURq6urNJt1qtVowe3WuX/txZRD2oIP+dwXSpYgjxZr2kCTUK9OH2uACBHIddqQ0vpRvtP6sWwcCsFp90oWvMztlHPW19dZWVmh2WzyzjvvcG93h1/62m/yo89+jCtb50iylOtnL/G//en/hlmS8PbRDt+8/xYzk+KV8hIayZpINTFINVOeaTSsr1f48IdrdDq5zbOzM+a3fuuQyaTPZz5zlk984jxXr65Rr4dzpFviWCRobuD1+zPeeeeQb33rHm++echk4rK9vc3a2iqNRp16vb6AA1lXeVZTOXFVJmpJkTu/9Eu/ZK21DAYDut3uAgC0ChD/VBAvRqD8LZ6BjvtLhW+5WUIyZuPxeGGUiz50SLksPfTGNAHI86Uy+c6dO7z2g+/zx598gf/1z/93SHeB57o4OHiOyzv7O/zDG18ntikmOxXnZfe47MNLXD7vG8jY3o74/Odb1GqnxprnuQyHeQBsZSWaSwy5T+6yOY7DaJRw926f118/5v33B+zvj8kyi++7BIFPu92mXq8vFLLqIh5jzMI0s3Klk8BpmV1VVAVHUS5epFJVInfLRIfWfTqjVzYYRc9orhX/3/d9Gs0GfuAX5WRpmuI6p+7Xslr4sj9dlhCi49bX12k0GjSaTfxRVqSUsZZMDDYyntw8z6e6H+Jr917DnTN+OTWuCU1/lovdDM9z+eQn69RqFt05Z4whinwchzmn5xa867pMJil37oy5ceOEt9/u0e2mgEcQVFhbiwoE6jpG7U2I0So40lHJcmCtjHi9Pr+caZNavNlsVhBC2UXUBp+mQl3iLWFNXdKlkZllKaFTp1M/R9CMmCUTHpzc4WS0v5BKLVvZZZGmpZIW10KsZ8+f41Or16iGFRLzaHA8sxnX18/zu3dexdhHU96y3rJtJPsejSZ0Oi7r62dJ00fD5znRQBC4xHHGzs6QGze6vPvugKOjBGNy8S+urCY2ka5ltSxStJyHkfOkFawc5ygTgLUW//j4eMG/F5Eh4m06nTKZTBZ0inaZRPT68zo8qYzR9QXS3GCMwfPzXv/16jnWovM5xwP1oEWntsX9k/e5dfBm4caU/WkBig7GCIGI+JtMJoxGo1ySWIO/7kKpe1gfge9jLQvEKoc8Xwe+ZF1xHLO7e5/RKMXznsI8GucCcq7/xjd2eOWVQ/b3Z6Qp+L6H64r+zrN02tCVDiEt8aSqSVcwh2FY4ErDSYfwdW+GHIUqHw6HhVsQBEFRRSsLkdJt0dXa1RNkSOOD4+TjWTWHzGazohLWmLzRIyBitXMOBwczb/eWpZ3tXGFqRhz0d0ni9BFjRydIypuaTqeMRqOFZos0TdnrHsO5xyDHcTnqd5nOZghzaGNP/tdSD/Li1+PjY46ODnj66Y9hbYjjTLF2kdBcF6ZTw6/92vfZ2Tmm3W7heXmrmdbVst5Go0G9XieO46IGUNcp6hCz4+T9DILDVqtVMGB53WUVKk0kPpwGPbQPKbl+Y0xhzEkPgNwsCIKiYljrdgl+SKmUFGfKotrVTTzHK5CvDweH1do2w+SEwE8Zj8cFRetWJ70ZKaGWWjytmkLf542ju/zw4BnWWyv5mJn5IZb/b73yDUazEa1G8xGrX/SqXv9oNKLf7xPHMT/zMz/NT/zETzIe36JWu4cEWfJzIYpCvvrVG9y4cRvXdUiSPASs5ykLx4dhyGg0KmYzSzWV/hH4CiMIQUjHVq1Wo9VqFUwsBqPeUxAEhbQuCkKEquSGSZIUnC1GmZQ+z2azwgsQghEiEGtUD0rSOtpxIPSi5exILglcPCaTMb6X9yaKVCnbHrr+TsSjtthFVfXiEb/+xh/wi8/8KCutOtbJCW08nvA3vvSP+O03/pCr165havVHDCsdHJJ9TSYTgiDgM5/5DC+99BLGWEaji3heRrV6gO9L8svyu797k7/5N3+fNI3nKmQxXCwZPyn4lGQQnNo9Ug0tXT9CACJ1Za3GGIbDIdPpNDeA5/0ROh4goXmprSiSQRpRxphCbOtGQwG87lCRBejOIU2h2hZwHAeLZZqO+CCd7DkBhw9PGM0GtFfaRaGE5n6hel1SLgDTEb40TQk8n1ujPd5+dYdn1y7i1B2ms5i//vt/m3/5+susd1YZj0bUa7ViAmo5OCYcKxm8z3zmM7zwwgvFsz0v5N13G7zyyjep1fIp6jdu7PFHf/T+3AtaLCgRotJFJELAumdRmCrLMkaj0UJZuPQBaltBJKJ0R0kBrVRV60FfnueduoFyaIrXmxdbQM7Ri9f6clkxgyzYdV2wcDzaY7NxAd8LsSU1YK2hEbX4kQ//NL/7nX/Oa99/lVq1zvr6OltbWwtirxz5EgLV84x93yeshAR+QP24yuTBDItl6M5onl3jI+6HGY/yhtDJZFJIGq1vdX4/DEN+7Md+jOeee26hPevgYJ9vf/s77O5O2dm5z61bt5hOJzhOvidjTt2ysgFbhrs+R6vTWq1WqGbHcRgMBnQ6HRqNxiORW9c9bRKZTCZ0Op2iG0vHCnyd0Cn71kKtIlqq1epCZk/bAxrRsollFrTjuEySAbePbnBp7WkCv3JqATIX3daw0ujwU5/+U7jG49tv/CEnJ8dkJmNtdXWOjMWAh6xbjCHd4Op5Hr7jUe1VsC659Ilcnrp4ndWzG+w9fEi3210o5wIW1FmWZURRxBe+8AWeeuqphWKOnZ0dXn/9dTzPZWNjDcexuK7lzp07jEajAl4a+DrdrX30stGmGU0HoQTOWZbPGpC+TmE+eZ4kn0ajEY1Go8CNfPfIhBCtt2WxuoNGPoNTt0n7q2U3St+zQLOB/f4Og0mXtfo2UVhjmkwwNuPC6jU8NyAzGZWgwp/47C+ytXaWeJZw9ux5XNdh5/AWB/1dmPvY1ubDq1dWVlhbWytaqgt3CSA2+GZOhEDqZlQbNbYqPpX5FJDRaLQQT9DtadVqlS9+8YtcvXp1oVDkjTfe4Dvf+U7xMgaJELbbbY6Ojgr7RGCs0+m6LE27mJqZRBXplHNZSltrF+55Kk1P1YLOeuqEXTEptCyqtSWdJEnRBiXUK8DRlKiv14cu/dbEMIkH3Jl25//neezBpMuT2y9QDeoYm9/zUx/57FyU5gi/uHWNN25+jxv3vkMQBLTbbTY3N4vonzxTuDlJE7JBjJvm2HeswyiZcHhyROgHRVWTbkYVqSXc9bM/+7NcvHixQITnebz88st87WtfK7wkQVaapgwGA1zXpdlsFvfR1wpsNZdrVapFuhhuov6E8eSe1uahfCEAGbChYzaivstHYQQuIGfOrK7rYp3TjhTpEdQL11W0y7i9/F05kufgoj86Ge3zg3vf5Kntj7BSW8daQ5olC9e4rsNzVz7K8WCPLJhw+fJlOp1OEQyRRtPhcJjnBYYDzNEMx1zKCcB1OJn0efudt/Cd0+nn0kotMZHhcMja2ho/93M/x/b29kJI+8tf/jJf/vKXC+knRCB+e7VaZXt7m8FgwGAwABbrJzSyy1KznDWVPUEuQWpzYzVJEkajEZPJpCAGMVLlyMPR0UJnt2Zcf+FBOFgDmWvwQxdcF5NacOzCzYUAxMoWqtb9bgtIdh5N5jzucB2XSTzijZ1v8ez5T7JSW1tiKOYc+tSF59iPbxJF0YJHMJvNiuTW/v4+Dw/22DYreNtu8Yz7xw+5cectIr9S3FOL2TiOuXjxIj//8z9fFJ4KMf/Tf/pP+epXv1oYZeIp6TZuHSEVEaxnIcgztQouz/HxPK8waLVrO5vNikFdeqROEs/I0grxbEZYCYtnaO+unEX1F2LsFlrXarQ/XCXo+NjYMroV03ttQpZQJGi0368BIxRetm61Xvo3HUKIGSmpiXOiXHKesfkLqbqDoPCbhSOGwyHD4ZCHDx/y8OFDJvGUjWYD3/Ex5ADvTnM3yXd83DkXayv77Nmz/MzP/AwrKyvFHrMs4zd+4zf4+te/XnC7nh4iyJzNZsXkkCIJJeue62AxIiuVCq1Wa0Gcy2/f9wvvS+YL6HcmSL9mGAZUooizF59kc/s8JplxvH+PNJ5SdrfL9t7pK2OMw/rHG2x9to3jOWAsOFDZDojO+Dz8cp94FheAWFb7p6mtXMKlLd3HLWjhc2R2/3KJ4TgQDx3crEKczsgSw3g8LmYTnZyccHJykq/Fc6m6IZ7jYqzBGotT9dne3sbEeTBJ9uB5HtevX+dzn/scURQVRD+bzfjVX/1VXn755QKhgjRRAWInCVEIp4obp6unpbhVhksIkUkUUNw+KTsXm0vmGwnDZWlKe3WLL/ziX+bSUy/iVypMnJiD7j36J3t0791mcuf9R+rDhYjyOEBmiTZCNn54JTe2dFYrs9QvVWh9uEryg4w0WCwgLceZRRroKJU8UPu/y4hBE4U1hv3+Dput8zhuybuY+9ZH76aMR+sEV/dJgnGRVh4MBgyHwwKgo+6Yig1yW8OCwZB6i5lMCao8++yz/MiP/EgBeKkv+OVf/mVeeeWVwtCT/LwEaZIkKaJwtVqNZrNZGJWDwaBAnk7cyHUiwVZXVzl37hyDwYCTk5Oi7Xw6nS5ECaUELPA92u02P/ef/w9ceuoF4nRGL5qSVqDZvkjryiXOf+wlRg93OfjG72DHgwLmAs+8PTyz1J+o4NdcTLIkpZlB88kKvVspJpkXKvLoMENBtI40lf1ZQbAOWGi9KZGvyWTC3v4BZurywpOfxPf8whawBu6/16N3OMOxFeK3zjBdn9KnR7/bZzAYFu8o7PV67B8fENRePI1RYBmlE5I417nr6+vU63Wef/55PvWpTxXqzfM8hsMhv/7rv85rr71WeBVyH91JLGpRwtO6Hb3VahXqRZJjOlYv6qTdbs/3PqZajeaRyYhWMw/pen7AaDQhySCMGrTXtzl/9TnOX32WOJ4yrhuSCjgWTF4ACEBt+yxrL/0IR1//yoKLXxCAtRYv+oBuWGMJV31Wv+iR3LVMbhnSI4tJDFmaFWpGGyu67kyrBvm/HDGUz8bjMb1ej5OTE8bjMe++8w43773LC099gkajwXQ24fBBD3t/GwcXXAupT7R3Dd9LeHDwNt1ul+n0dFRKlhkafl5zLxnI7qSfr4l8zS+++CKf/OQni/V5nke/3+e3f/u32d3dLd7vp2cBiCEmvQmSDNOWvqiFfr9fDNQUFZAkCVmaYrGsdjborLTo9fs4uFSrTZqrZ2ivbtLeOEtrdZPqyipBvUlQq+NXqxB6ZK6lb2KMazFejvzyYZKE2plzDFc3iY/2wDm1yeZ1VzA9SFiSnFNUAF7TwX/eoXI9JNk3cCNgfAPSQYb1LF7VW6AuayyO485F9qMrEwIRzhqPxxwdHbG/v8/JyUmRjzg8OuT9nTfZ2NgkDAPCMGCtc5Vm/yncLMA6BnDYzJ5jEhi+OfrHzMyUwMuHSWyd22Z7ZaNYQ2pS9nqHxDamEoR88pOf5KWXXloIqhwdHfE7v/M7PHz4sJj94zhOMehKJ5101A1Ox+FI51KaJPS6J/R7I3zfp9WokxmoVuusrp+h1Vln+9wlNs9fotLsENSbRCttwnodJwqwnotxwTgG41hmGKakWFJB3+NMpeJwPB+/3iA9PsBRSS7fdV3c0GV0J2Z8f0b9fGVRDTjkRiFgM4tNcwKqnHPZPNeg/Ykq/XfH9G6MyU5yqeC4LoHn4Nfm184syQwcf3FRIk7jOKbX63F4eMj+/j6DwWChiCRNU46CY6Ioz4qByyR6iPEnNE6uE2YtDBmGjEutj1C/1mG89i6NjYDhYJRbyNMtMpOXZcU2pT8eMHOm/OwX/wQvvfTSKUB8n93dXb7yla8wGAwKuyYIgmIwZNl987w8x+HObZPJeJQHbyoRg/6AJLM0Omc401ln+8JlOlvnqK+uU++sUWm18GsRhD7GsRg3b2QxGKbWPorkRdSc/swNnOxxhJCl2OkYz/dx515ZmqanEsDMDLtfPuLcT61RO1thXilNMszo/mBEuBJQv1TBq7pgLPMgHWHLY+OHWqx9pMnkYczw7Rj6hrWPVPC3fYwL7tAyeStl8K5lHpgt9P1oNGJ3dzd31+aDF8W61r38IiHEws6SChP3mH71ZVb61+l4lzE2I7MJ69ULOOkZ3PAhtvE+nuNTTaL5nFnAd3juxQ/zxIcu84mPf2Ihrn/r1i2+9KUvFSPayl2+DpClCencfnABG4ZUaw0qtSaNlVVWNrZpb56ls32W2uo6ldYKYaOOV63g+F6OaCev1U/nP5Y4F98lKVxGsgP5M8ld4QSYGMMwM3iOw1bgPUIEgetwczylN52xnQP/tC8A5jrac5geJNz61T0alyKi9ZB0mjG8NWF2mOKHAe3zTWqXQ2pXfYJVD8dzcqmQWHChdr5C7XwFMgveadOiWXWo/XCIFyUcv5aBmyO13+9z+/Zt7t27x3g8LnSnzuvrIpXZbFakRI0xeI5H5kz5fv/LbJrneKrz6VzHOxnMXMx7Z2huWOLaLlHs4GbzLsk6fPaP/xirm+sLGb333nuPr3zlK8xmM6pRhElTbJaRxjOS2YwwCPHaEZ2tCzQ666xun6N95hydM+eor64RrazgVyPcMMC6DgaDlaYMa8lsCmbxfQsLSHYgr1c+PVJrSaxlbCzDzNDNMk6yjOPUcJJmdLOMkTEMjaHmuPyZtRbXo0ohLFzgYZzya4MZH6tUOTcdgSrvX3hpFC5kM0P3zRGOMwYcHBf8io/veSQnGd3DCYMfOFTO+NSfDIku+HjVPIhkNenpukoLmQPhcz6V24ZJ1zAY5mXbOzs7RdWP7/sLUy3lECIQQ1G7lNNJnul6O/0GZ6+s0R59iHQGjmux1sF/cI5s3ee9Z9tUW23S1BA0JqysZpg0LYB/fHDAzffeI/ADTORQqTepr3SoddaotNcImyvU1zaIVlqEjSZeJcTxPWyR7jVzjgZsDCU8ayQ7Csl2juTYWIbGMDCGbppxnGacZDmSe1nGyFgmxpByKsgclDvt+nSt4e8d9vhoPeJ6JcRzHO7MEr41nnCcGWpJjLEGx56W9fnaLXDy1YEHrvfoCw5wwA0cTGKZ3EmZ3s2odHyiSz7VKz7BWn7OUoPEApFD7YxDbz/j8PiEg4OD4iXUYgvoki5YbMYsG12S685n6EW0r1jOraTc/5ZD0vdwMKRnQqpf/CR7G6dVSDaz1Ed9Lkx7OK7HIDE8IGLjk59l5VM+Xq1OUK/hRzUcPw+JS6razgNJKSkkpbenoES1cxqDM0BiLDObc2ovNXQzw1Gac3M3y+hlhrG1TG3OO9ZxsPM7iGXveh6etfhZhmcySBK82RR/NsGfTEhaKwzWt/iDwZg/HIyLZ+P5bA57rHWPSHwXX5Dv+/mUMB2fFt9cCkW1myaAdz3JN0PaN4x/kBG/C9F5j+YPe1h/OREkxuGHL6akkxm/cjjh1f6AaZIRerk4itOYdN5X53sOvneaSNK6WLjfGIPJMqpRhScuXmS1ucLGhQAvHPHwWy6TQYXwp85Q3axik0XlOqm1uBnVwXHIHBdnyyNwIBBqtXldAplZkGaig905koW2DZaZsUytiGrDSWY4ygzHmaFvDH1jmdj8POlNcKzFs4YgS3GThGqS4EyGeOMxkUmpJjFNa1j1XcLphPTkmP7DByTdE+xoQEi+5qpjcc5e4Luf/wV661s4WS4nHMelNh3zqbe/hzebYLx6vmZbpPEXX1eiU5AFxyjOE0u4qA9wc/1vMpds1+J0DXbTXVQBcyB5xnI+S9i46PDh7Qv8q2ci/tE3bvKHN/aohi6ff2GLM2t1prOUl98+4K3dHqHnYE1GPJ0w6J1QDX0828bFgDUY12f1/FU2PvQR3pk2ee2dhAdDuFeZcu1ci5e26pjkUf/WBcx8jqADYLK5WC2J6vkHxoJxHKYWxtYyyGwuorOMozTjOMkYZCnDNGOWZWRJjI1j3DjGnU1xRwPC6ZiVJKaWJlSTmGA6pp6lhElMkMQ0XIe663C8v8funTv4jsOVJy6ytrbOdDal2+1ycHjIrD8gyVIc18OrVrGuixtFVO7v8KHf+LscfPyP0bt4Fev7bHSPePbO26z2j5m6HrN52lheBeCvrKwUhRMSndJlx3A6SFJauHT1iqROXdclTl2mbxmqGy6Zy6lF64B14ZlBzMYsAwuVwOVzL57lc89v8e13D6mHHs9cWUU6K3u9Cf/7b77G3/m9WwSVCrOojdvYYr95kXH1Im+nHQZOyGg9wPg1fn/HJ8kMqYnBgSzzaV7L9aB5jJPsoJpNXZcMSCzMINfHScpJnNBNU7pxTHc8Zjga5cMoRiPsaIA3R2I9S2lOx3TGI5xBH3c6wZlOYDrBT1PS2RSbZUSBz8b6Ou12m5NulzhJ8P2AerPBmTNnqVSrVB3I4piDgwMO+gNOxpNianmSJKTG4Lgerucxm6fpB8NhHm2cTrn2za+xevMNomoVL03JrCF2XFxMYUwnSZJLeYmX60pePTRZV9zKZ+Ib688AgsDSe9/DixzC511sNc/kORlw22De6zPYMDSbldxFSPIo4ic+tDm3hgzSW7XSiPif/syL3N36Eb4yuEqlWiXxI3qOm9OVzZNVjgOOyYWw60A4F1xT62KS9LHxEQeIjeVh94hpmrF/csxoMmHQ67H/4D5mOqHuuQTxFHc6ITs5hpMjgl6P1miIkyR4DlSCkJVmE9d1SLMMx3XF0SXNMqwDYVSlvbFRtIn3ZzGzbo96vYGdJ4vcOOH2vXtFarlerzMcDjk6OloYkysGsUhoyRgKg9ZqtTxS6Lm41mI8D2vy3IqIfekcGo1GuQ2gw7I5bE8HEOrKmkJ8uqfDlSUOXlT/+paj16F6zyM6E+CGPu4AJoeWrx6G/MrX3+FjZ+CnP7rNuc1mrmPTJSHIzOD4Hn/hIz7/8tXVvJTbGhybFZX3dk4BxuSeJzYnCC/wuTA75he+9I/JPvrXoNl6ZGCe4wf03n6d/h99g1a9zuzNN2gGAZdXO7z3zrtkScLa6irWcUizlMFwiDcYEKQJWRBgPC/3p8OQcZaRxfn9dQU15CPumRusvV6vUK/dbpdWq4XneZycnCBlbTIHWAo9xNiVQ/ctRlFErVYrUsXVapVGozEv/nQxSwpxdMWX53n4kmuWD3QQZqFWQADnnHbnLKsEStOUlJTkyGPWhyAEz8+D1Nam3Nkf8nvfussv/Ys3+cJHz/Fffv4659fruZItHwYu1mMi3zK1Po7j53WAxuCaFM9MCUzMVjPkfKfGRs1lre6ylox4/pf/IWffeo23/v4WO3/5vyX0fZhzKJ5Pf/8ho9e+TdOkMB5x9eJFVtfWaDWbXH/6GXq9XhGfsLMZfpIS1Q1BFBVRSl2jJ+lcOK24kayflIhJjcBsNiuKR2SOsUQ8R6MR0qMpvrp0ZOnMqxjvx8fH9Ho9ms0mq6urrKysLLzmp0wAutfQcRz8arVaVK7K8UElSpoAtGegw6Ou62KxpDbBpgZ/HnA8Pj6m3+vi2pS94yl/40tvsN4I+Ct/8gWYLZlq6DgkSUp2cBs7OMFOTqiZMefaEZ3IwYtHmOmA82c2+dEP/zCd9TXcyZTW//X3iN5/k7hW5+o/+TWqBwe89xf/El6nQzLoM7n5Nr27t2E2xc7fNua4LisrKzz33HOsra3x4MEDTk5OCo6rVqtkWcbJyUmBEGk9k4noohb1SzPErZVKJdG9usxOKo6r1SrG5C+vkokqooIFkZJOTpKEk5MTJpMJjUajyDhqz01XAhVufokofClDks3omIAuDi1TlRCEtgn0byEIoWJdzy8uZBQ4fP0H9/lLP/0coec8UrRA6PN7L7/GyW/+EhXX4LkOWbVKcO0anYsXCWsRYydkZ2eXH7z9Lh8LKmz/v79M+OoPyMIwv5/vE3XqdPbv4J08YPjumwz+1deorm4yPXcF64dgcwC9//77TKdTPvzhD3Pjxg0ODg6KQlhJUeviTV1hK21ygnwhBskWCkJ127wQkmQXJSYiKnWZBE6SpCAQz/NYXV2l0+kUBbFSdPK42guR9EVVsCBdPAApXNApW1m4bmmShYm40wjXaeEy5emF+Z7Dv373kG995zX+2KdfJM+EmDyrEri8/d4e/8c/+z4eBlwP67pMU0N3MGIjTqnWA2o1l0kcc/Ptt/mRP/rX1F9//RT5WcbJF7/IyU//FPHhAYExtJ98msGd95nev0s1TZievYypNWC+9t3dXQ4PD7lz585C21nZThJr2nEcGo0GURQVnhFQvHXNdV2Gw2FhuEl8ReAmsNGwFldbI1Lq+8fjcaHrG40G7Xab1dVVarVaoXIEN+UC3mU48SX3LdyrDTuRCssQWa4EKkcUhSBEVOqFFEWRuGzWMq6dfBNuHML2c5jKCg9HKV//wQP+xv93g4NBQhgEGHtafDIYDDg6OsqB3GhQDSt85vXX2T4+IZsPgXCNYf9zP8bdlz5JdTzGd718Hp8FLl6Dw328yYja3XeYnnmCtLUGNieCOI5ZX1/n6OioiEBKeZc2yIQxdKmXHp/nOE5RpgYU3pYuChXu13WVcr2uHxQ7od1uF32CzWaTVqtVvL6mUL8KVx9UdQXkXsCyLwoRoRpAy7Xry2562iu3OD5O2sh1a1OcWX7sfMx2y8CDN+HoHX7rvRr//ddDUjw6Ky3WOiuMx6cvQLLWMhgOOT4+pr26SlSr8YW793ix2yOdqyk3M4y/8JPEf/IXyHZ2OJhb31Kivb65RePJpxm8+RpOmlDdeZ/Z5ox4/QzY0xc3bm9vc3h4yOHhYRGmFrEudfYC+CzLiiSVqAvtSpd7APTbRARWumNY1ygKc9brdVZXV4vml2azufA+wschW67XjbzymR9F0UL8XUqRy/pdblQ+dPGnfK+NQdH7YRiysrLCxsZG/v7BNKPmGn7xynx8nOthM8s/ej3heGBZb9eJZ9OFenhjDNM0JZ1OmcUx6WzGS6+/zot375HOCdlLU969fp3eD3+alemUeq3GZN7WvrGxwerqKpUoorK5Tnq4x/RgDxyHysO7uNYw2TiXp1vn+5aS8OPj48Ky161Z2j7SXb06hN3v94u3jZa7q/QsZIGV4EBefCXE1W63i0FY+kVeeljHQupa6X8tkeXwPA9/f3+ftbW1ottHiEBToabSsjooE4c2NoCCK7Isy6tztrY4PjxhFsdcuJLiPOGxb2HTTXn7wOWPHvpEPguvXQFI0pQky/jJK5f5cx/7GJfPnsFPUho/eJ3u/QdgDL61fHdjg1+PKoT//J9z/uxZrly5wsrKSiEmoyifv9MbDBl2tnAOHuZxBdclOLjPne6A5oVLNOYWOcC5c+eIoog33niDyWSyIK415wVBUHClIEPmCIgIFxjp8nmNNGnJlypjKQbVBKDnNZYNxWVSQBhRM7RIYn9nZ4dut8u5c+eKKlbtNoghov3dZYcuBZND2wliBG1vnGH0kT3G23scbNX4826dTmr4U9MhR9+aMJhCNTwFjCx+liT815/4OH/9iz+DG4anxQbnz1G7eIGHv/0V3jt7lpefe5bWdEo8mfDgwQMODw9pt9s8+eSTrK6uFgbd4eEhx8bB9WtsmikmrzBkbXTC917rcfXJJ9lYXy/E5vr6Oi+++CLf/e53OTo6Kip8m81mMaalXq8X7liWZfnbzbrdBYteAkHyo6untZqURlwxGiVUr9u+NAHpz8pEIGpJ93UU3p0xhm63y2w2Y2VlpShF1v1/mvPlZmWfUiO8nMsXEZWlhmnlmHc//B79wOKYvI7gyHP5WysrNJ+r0nptSJxkuL4Ss77PS2fP8Fd/8vN5OVOy2CrWeuZp7kwm/OtWm9VWk3V72q/Q7/c5ODjgwYMHRdFptVplc3OTeqPBXeNRiTNaoY8B1is+25MJ33v1Na4/eY0nnniikGDNZpOXXnqJV199lfv394EQz6sUP3o6Sq/XY2dnh4ODg4XqYXEDxfUWWMv7D2QOoBiTwniaEeF0qmrZONfMqINzup5CXNIoivI4gLWW0TzJ4Xkely5d4sKFC4VRIjcQ7nfd0wHJus9soa6ARZcvyzIcY3m3/QZH3hQ/O40reICbWpJnA6788BnG73lY1xQ61/o+f+pDHyKq1YpcQYnE6XzoQ0ST6cJwBaDQo7du3WJvb68g4r29PcKTEyapYdep0CLvHM0sPN2uMa44fPfVV9nf3+fFF18sOCcMK3z0o5/g6rVvcvHCHivtQ0ajJnfvnGM0qhf+vYysESSLTSQGZr1eL5pIZC6T9BVqppK/HcdZaP/WUcfyIXEXbWtI8KnsfhbDosX/T5KEnZ2d4kXEov81MnXXS1n3lG0BbXykJDyonJBX0i0eDpA4hsazHa5WLhLbuAiUxMawsdp5NFAkh7XUfZ9qGBLMGyH1vqRZ89KlS0WziETlPM8jqlYxe3dwjvbBdfGxXAksN9KUb3/72xwdHfGjP/qjRFGVLDNcvfoqly7fwnWz+ZL6PPPMPt/+9jPcvnkWS1x4CxKc0Z0/7Xa7aGGX0KwOLpWJQP7XrqYQgDbyBN4SfhZprKWFMEhBAOWYf61WwxjDrVu3OHPmDM1mcwHx2teUHx1BfASxhWUqJTKP7z8Ai+M6BEFYFKUYYwiMoTebPZ4AHIfuZELmerRqNWrzkSgSPDHGsLq6uuBa6YFXrufhNGqkwz42npHhsOE7XIx8HgA3b93CcRw+/vFPce3aCRefeA1jHLJM9uIQBCkf//hb3LsTc/uOYTKZMRrN5tIz37+1kKYZs1lMGMaPMJbmbHj0ncLSgrbM4CvbA0Jw5cBQ+fwiDqDHrbhuPsbszp07rK2tsba2VlCdpirdKawnWJR1UuE7m5CNWZvDsL8Uj55x6PTqWOe0R951XRxr+YOHe/zE1iYb7ZXFxJGTh5C/cXDAQVjJ37pdqRRNGvV6vVTC7S2UoTlOXp83dTwmrXUahzuAQ2YMnzizxk5vSD9OOD454ZXvfocXPzrG8yBNy4aWQxDE/MyfeIeTE5du1+H4CA4P4eTEYzDw6PUgjh3G4xFxbPD9CZVKiO97hGFAtRrh+958huDii6m05X5aEWWxNg/WYQ04GVmWLkhtHdbXRFXYI5rqjDHFG7Ll4sPDQ2azGVtbWwsTKLW7KGJMf6fFjOu6+K7P2I45DMalutd5SZWX8cR+m2p3DTxw7CkxTcdj3rl/n79tMv7Hz34GNcAAk6Z85c5dXu71CcKQ+9ZydHSE67pFf57E6T3Po9frFQ2kuuv3pNulP0254IY0sxnN1XU+dPkKn/js55glKbf3Dvijd2/heQ8ozwIs9mEdGg1Ls5ly6ZLYRGBtSpLkc/vH4yn9vke/79Htepyc+AwHAdNplTiukWUN0rRGEIQY45DP+HdxXW9+L+Z1miHGTKlWH+I4fabTKt1uG2McfN/BdRcniMKjU1WttfhSZq3TwtK7JlZot5tP8dja2lpodRbpIaJVCEBUgi4xc6zDG803OIgO8excJzkGLNQyjzN7m2zfuoS183zA/JhMJkXWKxOOn/9+Zfc+v/3gITfTlMDPU8X69XAyMHI2mxUJG4nSSbeuVCLPZjPiNOUuIZ/aWuPpF17AC/KcggOc3Vjj+oULTPxDjL2HNFXpw3HAcexc1DsLGst1oV63NBqWra0MLSTTFJLEYTbzmEwCppOIybTGZFxnMqkymdTIsiZBkGCtj7UBtfoBZ8/+HrXafVzXYIzH8fEab934GKPRKnk94OJLO8uegzEGv9lsLkQBpexaoncyBXw4HGKMYWtra8EXFSLRuQQdDnYch4pX4Z53j7dbb+PaeeAIy8eOP8ZavEoUu5hewNAdk7jxHJin4+riOCZLUz6yuVkQgLWWf7K7y80kpVWt4paCK3KOGIKSw9e5dQGMnOsCTlTlwvWn8fwgb7CcH5kxrNTqBMmLWLMzR7TSwa4lmbkcHFao1TKiKCMMDZ5nEdUr5xv1zh85ggDCMKPZTMlL8o9xHIsxDsa4pKlPkkSkaZUkadFoPCSKehjjY0yO2I2NPSqVl/n2tz5LmtYWkF2GizBoMSZO6gL1STLOVKhnMBgQxzGrq6u02+0FFZBv7NFJHiYzxE7M99rfI3VTPOuRORlXh1e51n0yL7z0XeyKpdasF92zMqM4jmPSLCPyPJ7eWM+h5zj0plOOkpR6GBLNxXzZ6JGNSnClVqstSIByt29mLVvNBiv12iN7yYk2wx0+yc7tZzh7+QaumwEOjmOJkwrfeeU6N97sUKmkVKsZlcqMKBpTr09oNGfU61MajZRaNaUSZfh+Pk1sbsbMCcLBGOcRNRMECUEQ4zg94AHWehizKIWyzKfVOuHc+bvcuvkMrnuadNJ40od/dHS04I4IIkUiSIetWKA6Lbm9vU21Wl3Q9bpuEMC1Lt+vf5/DSi76jWNoxA2ePniaOImxriVwTse5SUmTEFsYhlSiiPPNBhfb7XktoMOD2QxTrdJSUz2WBaLKse96vU6j0SimeEjSBsBmhiDIJ4YY+6jHYbH4nsv93U+x3z3Dme17hJUxg0GDu3fPc3Lc5swZd77EvFSt2425f3/MZDLG2owgMFQqGVE1o9lIaDYTms0ZzeaMWm1KJYqJohjfN7huilO0+zpzqeE+1gbJ9+vQbh+Rv4BiMSAnhrE2Dv2bN2+yvr7OxsZGEZSQqhShGAkIiU8dBAFHR0dMp9NiPp0xpphTa0zeEuUalzvuHd6sv1mIfsc6PHf0HNW4SmITyCDlNESpCxqstfmIlFqNH+q0qc5TvQAPM0NjZYVIzSDQSQ/t2uq/pYpZQq21Wq3Y33Q6YziNidMEz/MXiEeun6UJmbWMupfodS+RZSlJkmJMShieNpIK89RqIe12rZBos1mMtTCdeMwmDvv70o7u4nmGKIJmy2d93adeiwkrA8KwRxgOCcMRvj8iCGYLyC2TaeBH80LR8UJ+Z5kd4E+nU27evEmWZVy7dq0Yi6IDCeUxJXJxHMccHx8Xka8sy/j4xz9Op9MhnsUM0yHfan+LzM1wrUvmZFwZXOHy5DJZkOGb01Sz2BASapa3iQwGAzLH4cqF87klNdfLu2lKmHe2FEgXkS7r1MUUsOhXC0BEPQiCR+Mxd497PLW1QVLKnjnAu4cn9KcJYWH7ZFib5PLBnqaFtYusp4CLetM5ldMETZVarU5UqTEZ+0zG+sXcGdbOSNMZ29s3ePL6K5js0dlL1sJ0+iRra2tMJgGj0WhBzekUdBRF+OfOnePhw4fs7OwwnU65cOFCQcGVSmXhfXdanEgUTXRvGIaMx2N2d3YJvRDf8Xmt8dqC6G8mTV7ovYDrnfqiOmolBptwi8QkXOBKo15w/ywzHBpL4Pv50Md08VWtyxIlcn8BuBReiCcg57XbbX5wcMJsMuHpC+cIfJ8kPS0vz92xeOGe5SicGJuyR+0NiZTVVdfipkpVUX6dwXHsPOaQkr+QyiXLKuzsfIjVtYesr9/DGA9rczvEcTL6/afo969jzKzIJsr4OyFyTZC+67pcvHiRXq/HwcEB/X6fs2fPsra2VszNSdPTse2CFOaAlwWHYUgURAxGA75777sEFwLeary1IPo/NvgYzaxJ6qRFY6MgSU++0hOzvDBkvVbjQqNR6P+TLKFnDDbLiFWOQrwAyXppxOisZJZlhTurK3BcN3+36slwxN/6+je40G7x3NVL/PjHPpK3qQHXNtocJIapyoEIYMv70Sl0YMG1loISyfLJ2stW+2ms386lTIIxPm+/9RkmT7zK+vodfH9GmkYcHV7m8PDTVCoBrnv6at5Wq8V0Oi0KUmVmcJZl+AcHB3Q6HTY2NqjVahweHnL79m36/T7PP/98UWkqtXHC+Rppnufh4TFqj7h37R6D1iAX+/Nm58zJuD69ztX4KjN3hjWnOlsyX4J8SVgYY3B9n5bn8eMXztOUOj/HYSdNmRqDo9SR5jRNnAsi3Fl8e5kEgmTsiwC+3+sxHo95rdvl9bu7nF1f56NPXiFJU+q+z9l6xK3B5JEBduXAi5ZqAj+Jucg5kiiSSGq5plLuq6uD8ntWufn+p9ndeRHPj/P5gHEN182I416RBJN7CeK1q+55Hn6j0ZjP1MkNurNnz3J0dESv1+O9997jhRdeKESn6DXdoh2GIY51mDVnvPv8u8S1GNe4KthjCeKAszfPEjdivMDDpo82o2oXznVd/DBkMwz5C5cucr3VWsgDdFyPijVMcygvIECMMJ0j19/p3/Is4TQh9OPj47y8OwiwOPzOK6/y/OWLOORDGS62ajycJsyUnVGWNJoY5HOdm5Ay8DIB6UMTtxCNqBhrDY4DcRxBXMVxmLulFC18+iUTcn8d7s+yDPf8+fPFGNTDw0Om0ykbGxtcuHCB4+NjXnnlFV599VUODg4WXg/jum7Rnh1PY/Yu7uXIz9yFzmDHOhjfsDPa4datW/R6vaVILxDv+1SiiGoU8WeeuMj1lZXFJJC1XI0q/FizWbhqwhXa2i0DUwCgEV8Wu0EQMJlM6Pf7ha4MA58bd3f4wc07ufgG6oHPmfpianbZM5etQYjNcZxCGgg8l61XfpeLR04Pg+OYBa9A1iIl5DLhVe9Z3Hs3SRLW1ta4fPkytVqNXq9Ht9slCALOnz9PkiQ8ePCAW7duLQwvlIIFYwzjdMygPcB5jH9qfMNwdch0PGVn55QQZFMaOZ7n4QcBl1tNnms2Tit/SseLjTornvcIEYh00ofOuD0OKYJEmfWngZVlGV/9zqskaZoHbbBcqFcI3dwuKGfzys/SzxRCldx++XsNCx23F+9IG3OP24sc2iXW0k/gZK3F7fV6HB8f4/s+Fy9eZGNjg9FoxP3795nNZmxubhZ59Fu3bhXBGdGl9dr8RRKPc0tLhzF5A8Tu7i53794tRsPopJTjeazmnauP2xkNz6PheQsjdcrVtnLosm0BXrluQQOtrI/DIOD9vT3e2X2AP0/KNAKf7VoFUwo8LfO19b00oT+OMLUq0cjXL99adp0mFu1e6zUIDgrXW0aV7u/vMx6P2djY4MqVKwRBwN7eHgcHB4RhyLlz5/A8jzfeeIMbN26wv79Pmqa0O206jQ7NXrNI45YPxzjUjmpYTuPvjuPQ7XZ5//33uX//PtNp/jKlSqVCGARM7fIqZDlmxuSGII8C7nF1CY+zA/T1ZYPMdV1cJ69R+MHOQ1JxJbFcaFSJfMnSLUbdlmVF5Z66sGMZcZYPMVglGFe2b8r7lGuEUJapjiJ/43n5+HFr8zSqSIPLly9z7tw5kiTh4cOHpGk6f3Fxk8FgwM7ODrdv3+bmzZsMhgM272wSjkOMp3jSycV/+36ble4KGY++z1ayjffu3ePg4CCPQLouB8DubHaa/VvcJe9NZ3SNIfDcR/S+pvayOF0mrvV58r5BcQ2DIKDZarGxvs5JkrE/HOczByw0Q5/tWsS83GUpoelYQTkBpV1qjTT9v/5cI70s5fT5+pq8jO30PUNyrRCSv7e3x9raGvV6ndFoVMTga7Va8fnBwQGHh4dEUUSz2eT8+fN0u116vR63b9/mYfSQtfYa58w5jj58xGhlhHEN7tRl5d4KZ2+exfd9pukUDEs5w3GcYsZvo9GgsbLCl7D82Y11WvNUryB/L475an9QBImWJW7KtW+ntLP4TDkkDC0199pXr1QqrK+v0+50uDeasdmoFdc90apztzsgtXnaWEuhx3GpRlZZDXwQUvVatYfwQedqA1NnPoX4/J2dnSL4I0GfOI6LSuF2u83ly5fp9Xo8fPiQBw8esLKyQrvdZmVlBbEhTk5O2B5uc214jWwlY+bMcAYO7sBl5sxI/dN3AcumtV+rXaZ+v89wOOQgDOlOpnxue4uLYYjB8t50xjd7PQbG4ilu01G+Zfq9jPgyAYhEOH/+PFevXuXWrVuF7wx5oKtWrXKSZHRnCZ1KgLGWlUrA2WaN273hfG7QYsmcJs4yossS4XHif9lnWsQ/Tn2IJCvbPPpaX6ZWSHZP3i4ls/dns1nRgVqr1djf3+fo6IjRaESn02F1dZUwDDk8PGT34S4nvRM2NzZZW10jqkY4gUNmsmKChbzgQLKL1tpC/5cXmcUxbz54wO3BgI1OJ38xhDFkmSl8cp04khi35kBBQBnIWkdrQDYaDV588UXgVLLs7e3lI15bLVzP5+5wQrtyWhhzpd1kdzDGQEEEYktowi4TgayjbI/Ic3VSS+9JG8wfJGX0c2VQdTkqWswJFNE/Ho9ZXV0tOl7jOGZvb4/hcMjq6ioXLlyg3W7z8OFDDg4OiKKIVqvFuXPnaLfbHBwccOvOLfYP99nY2KDT6RTpWnmWWOoSmZLPdXBI6/XJcMjO/IVOruvS6XSKNHRZemiuEnfw31UVNJtNGo0G3//+94u4vvRNBEHAQwcuNiI6lRBjLe0o5Eyjys5wssB9so8ypy4r5S4juZxnkLVpotIVxMvuJc+SV/3Ic/UzFgZFxnHMw4cPGQ6HbGxs0G63iyIKkQaNRoOVlRUuX77M0dERBwcH7O/vF6ngS5cucXJywtHREXfu3OH4+Jj19fWii1X3HY5GoyKWUBaNZWvXKABMJpMiry8tX7IHnajSxpbmeK0/9atYhSAkiiZIkIqo/f39/O2dQcCd/pjOxumLmK60G9wfjheIWH5rPV3OTOqQtf5ZRiQaqRLKlRy/liwLRS7zc4sKaHfxFfN++QFZlhXjTHq9XjF4QOwDeSOljCSp1+scHh4W491brVYxquTw8JBer8fdu3dpNBpsbW0V3KvfTSzJG0FG2WrWfwvB9Hq9YmysNFpIalfqGwW4GullUbzMW0jTlGaziUxPEaAeHx8XOZO9sU93FtOe2wKr1YitWsT90RTvMdJGEK/1sCCpnKksc6per67sEULRRKCRrHGrYwTFfORHyIzTXrKjoyMmkwntdpt2u12EgaUOQPrhzpw5Q6vV4uDggMFgwGg0otlssr6+TqfTyUfD9Pvs7u4yGo0K6bK+vo7r5m3bWtwtC4vq1qZyRlIklPTUidqR8zXitb2gk1lCjNLx1Ol02N7e5ujoqECivI+o0+mQZIbb/REf2eggUbBrqyscTOKF6GTZEF0IeJWs/rLYf5w0KO+nbCtogi9Lh7LR7S+zMvWCZFrVYDAoWpOLEPC8uUISGxcuXChm/h8fHxfdshsbG7RaLY6Pjzk8PGQ8zseYFjnpeRJG+6fLLPhlQNXfS52fTPqWVm7xPsrGl3DCsqFKnucV/RAiSWTYU5qmuA48HE7ptWJW5rbAarXCZr3K/eH4dJKZXUxIlbl5ma9fRpKI+jKxiGSC0xd6aXWom0m15JGcx4IN8DhLEijUQhzHDAaDIj4ghoUUHEg7Wb1eL+b/Hx8fE0URKysrnD9/vjj36tWrhTrodrscHx8v9BkKxwvgHucilfW7AEP6+a21hb0ghRg6GlgmIiEK13WL9wJpY1IKSq0xJDjc7o94YW4LOMCVlTp7o8kjdg0s2iJCnFqyCZLLVVJaBcp9NAw0cYknpAlZ1iGSTryw4n0BH4R8fXPZ/Gg0WlALGuiVSqWIEzSbzQK5OpBUr9fZ29srbIHNzU2iKOKtt94qKFevqUhclMSn6HpNCLpIRQAkNo20cRe98aoDF07TqCI6ZRyLSCxRjUmSYKzFdR0eDKdcXklohbktsFarsFEN2emP8d1FLpf1aILQE1Q0ESzzBJb5+eW/Nazk/iKxhTCkAmk8Hi+3Af5NfqXU6/V6PdrtNhsbG4WuSdMUqTRutVqFvj8+Pi68BnnblrRqdzodZrMZ77//fuFNNJvNAjna3dOt0mKkPQ7AcoihKfl4UQuVSqVwd8Vd000tjUaDs2fP8vDhwwWDTUroPc8jMZY7vRHPb7SBfN7/lXaT7jRmlmUkaTrPJQQFosMwLNYhsJa0sMRLZCKZhruW1MuktiYc2aMukBFpEARB4YI71WrVaoD9m6RB+QiCgJWVFVZXV4tXlOqSqCiKCvErRZ7CkXJtrVZjNBrR7/eLOXsyq0AXbWoXS8bbldO2QijlcixYLFuX+8ga19bWipo8qRwOgoD79+/z8ssvF5O+wjDkypUrXL16tSD6wPP49Nk1GoFfDJxOrWUwS3i3O+AozqjO5wCI5NH2gEao7EMyf+WhUmXPQPYhkkteZqlfZSvnC5EJQSRJglOv1+0yP/xxxuHjCESQJuNYtA8uCSd5rbvjOBwdHXH//v1CNLdaLYIgKIxOmWgtG5Iybt2pJAGOspEnfrxwvQBPH5oIpOJGpILUOzQaDVzX5Xvf+x737t0r+iOefPJJrl+/XjzLAM+stniy0yST+wpirOWt4YyjOMOZMwycvppep4/l0AQtKW5RT9pQ1Jzuum5RWKqnlAkOBA/FK3dEulSrVVtG7AcRgI7clY0vAaCMShELX0SrEMnW1lZRIr27u8vOzg5xHBfdO3rShqZs6asXu0MAo9ejp3fp6SZlxMuhG2K0wSZSpNFocHJyws7OTqFPL126xJNPPllUQmMMnzq7TjsKH2kocYFRZvjBYIbj5c8SO0IIWBI2mqsFqdomkHFxWtIJcwjR6j1q41IIQKSb4NKJoujfspSDAkiPOzQli+WvJYIgRBOCvKVLZt5KmbSMRNWbkKLKZrNZhGV1gYRwg/aLRczDYom4nK/rB8v7LJ8v3pBkDbe2tqhEEc3A5zMXt+EDtOf3e1OGJu//0giS31oCa0NOJ8yAR8bTikGrJ6Nowpf7aS9A9uc4zn9YAij72gC1Wo2VlRVarVahY7XlKy9W9DyveP3q8fExk8mkUB1ShjYajYryZlEPQRA8MldHEKddKR2Tl7XqgYzLDEmtUgQR8hrYouPGD9huNfgLP/7HHw8X4NXumF6Sj7tdZsBp91TG8sieZO1ynZYYsFgDWE6Nl4NA+hrXdZd7Af++R1mviusoiBXrXnzgNE3pdruFN1Cr1Yow8mAwKMK94/GYlZWVBUvZmLx9rdvtFmqg3W4XnKCNQKmkkf9FXJZFf9k9M8YUfZAiRfL3E1WKnAbW0ptM6I+ndBpVMlOWJDBNDb3JFOv5WHs6O1nn6bXNJOsX1SkEWH79vCZgsRE04uUQmJSHU/47S4B/Ww9BBzrKOlVGq+lXtWtEhGFYxPXTNGU4HBb1AfK9SARjTPFm7uFwWLh1EhLWySexJzT36bedyBqF+5IkKQpUBGFyvRiMUiXt+QE/8tx1fuL5p3P1I1zmOLiOwzfeucmr9x4S+F4xN0gacivKO9AhaS3KZb0iEWS9ovO1nSD70IQldpEYnnoP/1EIACisdT0rQBd/CqJlWpZQvLSiCQJFbcxmsyLPIIMfJKgkhpV4BmKti+fR6XRwXbcY16Y5QbhNgCnpU0lkGWMKDhKXVoxUbYR2Oh3++LPX+aGrl2hEuds6ms343p1dXrm980hkUyNcdLkYwOKClgNfcuhZQSIhlhnl8reWuLKOoiP839UGWHYsIwzhbC2WyrXtwgESqtVt3nKdGISS9hWp0O12GQ6HBbHI9dKrIPaCBHREPcj9y23SWkXISxx6vV7xvbX5OwNWVlYWAAwU0qVaq7HWbHBmtYPjOByPxvSn+SSSx7GO7FXgpUfxCWFq+FYqFdbW1mg2mwALkkK8FLle9qdnNOuK5f+oBPC478SoES4QDhQOeBwhiLgV409yECcnJ4xGo2KiiYR6hVgmkwnj8bgIHAlQ6/X6QrGKvBRa+87SMiZr0Y0ksjdBkOQe6vUGxho836c297nLHCkIkEPrf/1bn6t1t34tjTYMJcIq42/kvgK3TqdTGNMCv38rAijHCMrfld0YfW45tavDkzopo1WDGISyUa0XZbPi/4pIl1TtcDgsYg4iOfQcIHn7FuQeSrvdpl6vF1a36Evxu8UTEd+51+sVY2Z01ZKkpcU20YMfNectS+7ITIZyHcQyotHwg8VaAiEenS6HU6YTYhfJaK39D0sA+v/HHboOXn6WRfOE44UY9BRNsXjlHPkBGI/HdLvdYkgzULiS9Xq9uH44HBaTwgQxQRDQbrcLohPEdDodms0mnucVyS2xI/TaZf+yNr238oBGDSPx7T8I9vq3EJ3AWkdyy7ZNGXcy66FQO/++KkBvRBOBcFB5Rr6+rkwEZQIQhAj36HCw7q4V/Sft3sLxEnSSPj+ZNyDGj8QktE0hYlHqHLIsKwzU9fV11tbWCmO1mFqm4gG6MEPiEXq/2vXUBpv8Lot9OcqFMnKuSMyyStI40Z/pOIlIMMdxcCqVytJQcPmGZcTr82URYp2Wkxj6KCdwygSggVZ+vvjCYv3r1mp5pmQJRSpIPl8KVSRu4DhOUZAi/fKiSuRHjEDJC2xubtJsNhfWI3sXohOXUVSIqAPR0XrPGnZlAhCu1sapfqmUiPQyfPT/+reGsY6EFgTwuONxBl75cwnxCiB1KrNMAFp3ykJ0VU6ZAHRoF069BylJE30rXCiupEgPIRiZhdzv9zk+Pi56H4QzpMhUADsYDApvQGwLQVYURUUGVH60LSPehHDrMiYCClunPJZHYKrPLXsKovbE+tdqYZmq1qFlkZqPEMAHSYIPOk/Ev0SvHnetlgDlQsbyYssSoByy1QahFK6KB6CDKcJN9Xp94eURoiIODw/pdrsFYCXYtLKysiBmRTIIYYgtIipK1JAYjWWi0FJR9nL16lU2NzfZ39/n/v37BfLEcBOC0xk9gYku/yrHDMoBNlg0wIsg039IAtAx62WHiCIR02tra0VCp9/vL7hhZa+i/HvZswURYvQJAiC3SWazWcEtUvUrqWXR6+XX5Mpa5X56mslkMilK2aTBRmwAYGESWaPReCRMHUVRMZOp1+txcnICUJTfb25uFoGp4+Pj4i1l5czhMltAAnH6ey1BZBrLAgEsE+uPIwD9eVlUfdAhiG21Wjz33HNUq1UODw+5e/fuQj+fNpLKruWyNWo1IRUv8mo1cSf1ffUQTLHCBTAitgVIOuIn4ezTV7Tm95QqHplIKh6GEJN4GZK88n2/GB3fbrcXXgkrtkyj0Sj2KPcXg1IIVdYkNohmQOF4HXcBFuyK/x86dQpQEO4VQAAAAABJRU5ErkJggg=="}} \ No newline at end of file diff --git a/sleap/skeletons/flies13.json b/sleap/skeletons/flies13.json new file mode 100644 index 000000000..7a2c02422 --- /dev/null +++ b/sleap/skeletons/flies13.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for flies13 reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "Skeleton-0", "num_edges_inserted": 46}, "links": [{"edge_insert_idx": 44, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["head1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeL1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 45, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 34, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["thorax1", 1.0]}}, "target": {"py/id": 1}, "type": {"py/id": 3}}, {"edge_insert_idx": 35, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["abdomen1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 36, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 37, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 38, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 39, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 40, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 41, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 42, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 43, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR1", 1.0]}}, "type": {"py/id": 3}}, {"key": 0, "source": {"py/id": 7}, "target": {"py/id": 8}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [2]}]}}, {"key": 0, "source": {"py/id": 8}, "target": {"py/id": 7}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 9}, "target": {"py/id": 10}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 10}, "target": {"py/id": 9}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 11}, "target": {"py/id": 12}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 12}, "target": {"py/id": 11}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 13}, "target": {"py/id": 14}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 14}, "target": {"py/id": 13}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 2}, "target": {"py/id": 4}, "type": {"py/id": 15}}, {"key": 0, "source": {"py/id": 4}, "target": {"py/id": 2}, "type": {"py/id": 15}}], "multigraph": true, "nodes": [{"id": {"py/id": 1}}, {"id": {"py/id": 5}}, {"id": {"py/id": 6}}, {"id": {"py/id": 7}}, {"id": {"py/id": 8}}, {"id": {"py/id": 9}}, {"id": {"py/id": 10}}, {"id": {"py/id": 11}}, {"id": {"py/id": 12}}, {"id": {"py/id": 13}}, {"id": {"py/id": 14}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}]}, "preview_image": {"py/b64": "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"}} \ No newline at end of file diff --git a/sleap/skeletons/fly32.json b/sleap/skeletons/fly32.json new file mode 100644 index 000000000..c75361ce5 --- /dev/null +++ b/sleap/skeletons/fly32.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for fly32 reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "M:/talmo/data/leap_datasets/BermanFlies/2018-05-03_cluster-sampled.k=10,n=150.labels.mat", "num_edges_inserted": 25}, "links": [{"edge_insert_idx": 0, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["head1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeL1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 1, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 2, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["neck1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 3, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["thorax1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 23, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 24, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["wingR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 4, "key": 0, "source": {"py/id": 6}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["abdomen1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 5, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 6, "key": 0, "source": {"py/id": 11}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 7, "key": 0, "source": {"py/id": 12}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR4", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 8, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 9, "key": 0, "source": {"py/id": 15}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 10, "key": 0, "source": {"py/id": 16}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegR4", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 11, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 12, "key": 0, "source": {"py/id": 19}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 13, "key": 0, "source": {"py/id": 20}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR4", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 14, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 15, "key": 0, "source": {"py/id": 23}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 16, "key": 0, "source": {"py/id": 24}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL4", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 17, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 18, "key": 0, "source": {"py/id": 27}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 19, "key": 0, "source": {"py/id": 28}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["midlegL4", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 20, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL2", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 21, "key": 0, "source": {"py/id": 31}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL3", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 22, "key": 0, "source": {"py/id": 32}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL4", 1.0]}}, "type": {"py/id": 3}}], "multigraph": true, "nodes": [{"id": {"py/id": 1}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}, {"id": {"py/id": 5}}, {"id": {"py/id": 6}}, {"id": {"py/id": 9}}, {"id": {"py/id": 10}}, {"id": {"py/id": 11}}, {"id": {"py/id": 12}}, {"id": {"py/id": 13}}, {"id": {"py/id": 14}}, {"id": {"py/id": 15}}, {"id": {"py/id": 16}}, {"id": {"py/id": 17}}, {"id": {"py/id": 18}}, {"id": {"py/id": 19}}, {"id": {"py/id": 20}}, {"id": {"py/id": 21}}, {"id": {"py/id": 22}}, {"id": {"py/id": 23}}, {"id": {"py/id": 24}}, {"id": {"py/id": 25}}, {"id": {"py/id": 26}}, {"id": {"py/id": 27}}, {"id": {"py/id": 28}}, {"id": {"py/id": 29}}, {"id": {"py/id": 30}}, {"id": {"py/id": 31}}, {"id": {"py/id": 32}}, {"id": {"py/id": 33}}, {"id": {"py/id": 7}}, {"id": {"py/id": 8}}]}, "preview_image": {"py/b64": "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"}} \ No newline at end of file diff --git a/sleap/skeletons/gerbils.json b/sleap/skeletons/gerbils.json new file mode 100644 index 000000000..66264a3a6 --- /dev/null +++ b/sleap/skeletons/gerbils.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for gerbils reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "Skeleton-0", "num_edges_inserted": 13}, "links": [{"key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeL1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["eyeR1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [2]}]}}, {"key": 0, "source": {"py/id": 2}, "target": {"py/id": 1}, "type": {"py/id": 3}}, {"key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earL1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earR1", 1.0]}}, "type": {"py/id": 3}}, {"key": 0, "source": {"py/id": 5}, "target": {"py/id": 4}, "type": {"py/id": 3}}, {"edge_insert_idx": 2, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["spinestart1", 1.0]}}, "target": {"py/id": 1}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 3, "key": 0, "source": {"py/id": 6}, "target": {"py/id": 4}, "type": {"py/id": 7}}, {"edge_insert_idx": 4, "key": 0, "source": {"py/id": 6}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["nose1", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 5, "key": 0, "source": {"py/id": 6}, "target": {"py/id": 2}, "type": {"py/id": 7}}, {"edge_insert_idx": 6, "key": 0, "source": {"py/id": 6}, "target": {"py/id": 5}, "type": {"py/id": 7}}, {"edge_insert_idx": 1, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["spine1", 1.0]}}, "target": {"py/id": 6}, "type": {"py/id": 7}}, {"edge_insert_idx": 0, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["spine2", 1.0]}}, "target": {"py/id": 9}, "type": {"py/id": 7}}, {"edge_insert_idx": 7, "key": 0, "source": {"py/id": 10}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["spineend1", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 8, "key": 0, "source": {"py/id": 11}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailstart1", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 9, "key": 0, "source": {"py/id": 12}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tail1", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 10, "key": 0, "source": {"py/id": 13}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tail2", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 11, "key": 0, "source": {"py/id": 14}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tail3", 1.0]}}, "type": {"py/id": 7}}, {"edge_insert_idx": 12, "key": 0, "source": {"py/id": 15}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailend1", 1.0]}}, "type": {"py/id": 7}}], "multigraph": true, "nodes": [{"id": {"py/id": 8}}, {"id": {"py/id": 1}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}, {"id": {"py/id": 5}}, {"id": {"py/id": 6}}, {"id": {"py/id": 9}}, {"id": {"py/id": 10}}, {"id": {"py/id": 11}}, {"id": {"py/id": 12}}, {"id": {"py/id": 13}}, {"id": {"py/id": 14}}, {"id": {"py/id": 15}}, {"id": {"py/id": 16}}]}, "preview_image": {"py/b64": "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"}} \ No newline at end of file diff --git a/sleap/skeletons/mice_hc.json b/sleap/skeletons/mice_hc.json new file mode 100644 index 000000000..1931f8166 --- /dev/null +++ b/sleap/skeletons/mice_hc.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for mice_hc reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "Skeleton-0", "num_edges_inserted": 4}, "links": [{"edge_insert_idx": 0, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["nose1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earL1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 1, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 2, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailstart1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 3, "key": 0, "source": {"py/id": 5}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailend1", 1.0]}}, "type": {"py/id": 3}}], "multigraph": true, "nodes": [{"id": {"py/id": 1}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}, {"id": {"py/id": 5}}, {"id": {"py/id": 6}}]}, "preview_image": {"py/b64": "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"}} \ No newline at end of file diff --git a/sleap/skeletons/mice_of.json b/sleap/skeletons/mice_of.json new file mode 100644 index 000000000..93f6f0438 --- /dev/null +++ b/sleap/skeletons/mice_of.json @@ -0,0 +1 @@ +{"description": "Template Skeleton for mice_of reference dataset.", "nx_graph": {"directed": true, "graph": {"name": "Skeleton-1", "num_edges_inserted": 20}, "links": [{"edge_insert_idx": 3, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["neck1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegL1", 1.0]}}, "type": {"py/reduce": [{"py/type": "sleap.skeleton.EdgeType"}, {"py/tuple": [1]}]}}, {"edge_insert_idx": 4, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["forelegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 16, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["nose1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 17, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 18, "key": 0, "source": {"py/id": 1}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["earL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 6, "key": 0, "source": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailstart1", 1.0]}}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegR1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 7, "key": 0, "source": {"py/id": 8}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["hindlegL1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 8, "key": 0, "source": {"py/id": 8}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tail1", 1.0]}}, "type": {"py/id": 3}}, {"edge_insert_idx": 19, "key": 0, "source": {"py/id": 8}, "target": {"py/id": 1}, "type": {"py/id": 3}}, {"edge_insert_idx": 9, "key": 0, "source": {"py/id": 11}, "target": {"py/object": "sleap.skeleton.Node", "py/state": {"py/tuple": ["tailend1", 1.0]}}, "type": {"py/id": 3}}], "multigraph": true, "nodes": [{"id": {"py/id": 5}}, {"id": {"py/id": 1}}, {"id": {"py/id": 7}}, {"id": {"py/id": 6}}, {"id": {"py/id": 2}}, {"id": {"py/id": 4}}, {"id": {"py/id": 8}}, {"id": {"py/id": 10}}, {"id": {"py/id": 9}}, {"id": {"py/id": 11}}, {"id": {"py/id": 12}}]}, "preview_image": {"py/b64": "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"}} \ No newline at end of file diff --git a/sleap/util.py b/sleap/util.py index 1335bcac4..d3a3073c2 100644 --- a/sleap/util.py +++ b/sleap/util.py @@ -1,35 +1,34 @@ -""" -A miscellaneous set of utility functions. Try not to put things in here -unless they really have no other place. +"""A miscellaneous set of utility functions. + +Try not to put things in here unless they really have no other place. """ +import base64 +from collections import defaultdict +from io import BytesIO +import json import os +from pathlib import Path import re import shutil - -from collections import defaultdict -from pkg_resources import Requirement, resource_filename - -from pathlib import Path -from urllib.parse import unquote, urlparse +from typing import Any, Dict, Hashable, Iterable, List, Optional from urllib.request import url2pathname +from urllib.parse import unquote, urlparse +import attr import h5py as h5 import numpy as np -import attr +from PIL import Image +from pkg_resources import Requirement, resource_filename import psutil -import json import rapidjson import yaml -from typing import Any, Dict, Hashable, Iterable, List, Optional - import sleap.version as sleap_version def json_loads(json_str: str) -> Dict: - """ - A simple wrapper around the JSON decoder we are using. + """A simple wrapper around the JSON decoder we are using. Args: json_str: JSON string to decode. @@ -44,8 +43,7 @@ def json_loads(json_str: str) -> Dict: def json_dumps(d: Dict, filename: str = None): - """ - A simple wrapper around the JSON encoder we are using. + """A simple wrapper around the JSON encoder we are using. Args: d: The dict to write. @@ -65,8 +63,7 @@ def json_dumps(d: Dict, filename: str = None): def attr_to_dtype(cls: Any): - """ - Converts classes with basic types to numpy composite dtypes. + """Converts classes with basic types to numpy composite dtypes. Arguments: cls: class to convert @@ -95,8 +92,7 @@ def attr_to_dtype(cls: Any): def usable_cpu_count() -> int: - """ - Gets number of CPUs usable by the current process. + """Gets number of CPUs usable by the current process. Takes into consideration cpusets restrictions. @@ -114,8 +110,7 @@ def usable_cpu_count() -> int: def save_dict_to_hdf5(h5file: h5.File, path: str, dic: dict): - """ - Saves dictionary to an HDF5 file. + """Saves dictionary to an HDF5 file. Calls itself recursively if items in dictionary are not `np.ndarray`, `np.int64`, `np.float64`, `str`, or bytes. @@ -162,8 +157,7 @@ def save_dict_to_hdf5(h5file: h5.File, path: str, dic: dict): def frame_list(frame_str: str) -> Optional[List[int]]: - """ - Converts 'n-m' string to list of ints. + """Converts 'n-m' string to list of ints. Args: frame_str: string representing range @@ -183,8 +177,7 @@ def frame_list(frame_str: str) -> Optional[List[int]]: def uniquify(seq: Iterable[Hashable]) -> List: - """ - Returns unique elements from list, preserving order. + """Returns unique elements from list, preserving order. Note: This will not work on Python 3.5 or lower since dicts don't preserve order. @@ -203,8 +196,7 @@ def uniquify(seq: Iterable[Hashable]) -> List: def weak_filename_match(filename_a: str, filename_b: str) -> bool: - """ - Check if paths probably point to same file. + """Check if paths probably point to same file. Compares the filename and names of two directories up. @@ -228,8 +220,7 @@ def weak_filename_match(filename_a: str, filename_b: str) -> bool: def dict_cut(d: Dict, a: int, b: int) -> Dict: - """ - Helper function for creating subdictionary by numeric indexing of items. + """Helper function for creating subdictionary by numeric indexing of items. Assumes that `dict.items()` will have a fixed order. @@ -254,8 +245,7 @@ def get_package_file(filename: str) -> str: def get_config_file( shortname: str, ignore_file_not_found: bool = False, get_defaults: bool = False ) -> str: - """ - Returns the full path to the specified config file. + """Returns the full path to the specified config file. The config file will be at ~/.sleap/