file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/clipboard.py | # Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import List
from .model import FileBrowserItem
_clipboard_items: List = []
_is_clipboard_cut = False
def save_items_to_clipboard(items: List[FileBrowserItem], is_cut: bool = False):
global _clipboard_items
_clipboard_items.clear()
if isinstance(items, list):
_clipboard_items = items
elif isinstance(items, FileBrowserItem):
_clipboard_items = [items]
if _clipboard_items:
global _is_clipboard_cut
_is_clipboard_cut = is_cut
def get_clipboard_items() -> List[FileBrowserItem]:
return _clipboard_items
def is_clipboard_cut() -> bool:
return _is_clipboard_cut
def is_path_cut(path: str) -> bool:
if _is_clipboard_cut:
return any(path == item.path for item in _clipboard_items)
return False
def clear_clipboard():
# used when cut items are pasted, we need to clear the clipboard and cut status.
global _clipboard_items
_clipboard_items.clear()
global _is_clipboard_cut
_is_clipboard_cut = False
| 1,446 | Python | 27.939999 | 84 | 0.716459 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/widget.py | # Copyright (c) 2018-2021, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["FileBrowserWidget"]
from queue import Empty
import omni.kit.app
import carb
import omni.ui as ui
from carb import log_error, log_warn
from typing import Callable, List, Optional
from functools import partial
from . import LAYOUT_SINGLE_PANE_SLIM, LAYOUT_SINGLE_PANE_WIDE, LAYOUT_SPLIT_PANES, LAYOUT_DEFAULT, LAYOUT_SINGLE_PANE_LIST
from . import TREEVIEW_PANE, LISTVIEW_PANE
from . import ALERT_INFO, ALERT_WARNING, ALERT_ERROR
from .model import FileBrowserModel, FileBrowserItem, FileBrowserItemFactory
from .tree_view import FileBrowserTreeView
from .grid_view import FileBrowserGridView
from .zoom_bar import ZoomBar, SCALE_MAP
from .date_format_menu import DATETIME_FORMAT_SETTING
from .style import UI_STYLES, ICON_PATH
from .clipboard import get_clipboard_items, is_clipboard_cut
class FileBrowserWidget:
"""
The basic UI widget for navigating a filesystem as a tree view. The filesystem can either be from
your local machine or the Omniverse server.
Args:
title (str): Widget title. Default None.
Keyword Args:
layout (int): The overall layout of the window, one of: {LAYOUT_SPLIT_PANES, LAYOUT_SINGLE_PANE_SLIM,
LAYOUT_SINGLE_PANE_WIDE, LAYOUT_DEFAULT}. Default LAYOUT_SPLIT_PANES.
splitter_offset (int): Position of vertical splitter bar. Default 300.
tooltip (bool): Display tooltips when hovering over items. Default False.
allow_multi_selection (bool): Allow multiple items to be selected at once. Default True.
mouse_pressed_fn (Callable): Function called on mouse press. Function signature:
void mouse_pressed_fn(pane: int, button: int, key_mode: int, item: :obj:`FileBrowserItem`)
mouse_double_clicked_fn (Callable): Function called on mouse double click. Function signature:
void mouse_double_clicked_fn(pane: int, button: int, key_mode: int, item: :obj:`FileBrowserItem`)
selection_changed_fn (Callable): Function called when selection changed. Function signature:
void selection_changed_fn(pane: int, selections: list[:obj:`FileBrowserItem`])
drop_fn (Callable): Function called to handle drag-n-drops. Function signature:
void drop_fn(dst_item: :obj:`FileBrowserItem`, src_path: str)
filter_fn (Callable): This user function should return True if the given tree view item is
visible, False otherwise. Function signature: bool filter_fn(item: :obj:`FileBrowserItem`)
show_grid_view (bool): If True, initializes the folder view to display icons. Default False.
show_recycle_widget (bool): If True, show recycle view in the left bottom corner. Default False.
grid_view_scale (int): Scales grid view, ranges from 0-5. Default 2.
on_toggle_grid_view_fn (Callable): Callback after toggle grid view is executed. Default None.
on_scale_grid_view_fn (Callable): Callback after scale grid view is executed. Default None.
icon_provider (Callable): This callback provides an icon to replace the default one in the tree
view. Signature: str icon_provider(item: :obj:`FileBrowserItem`, expanded: bool).
thumbnail_provider (Callable): This callback returns the path to the item's thumbnail. If not specified,
then a default thumbnail is used. Signature: str thumbnail_provider(item: :obj:`FileBrowserItem`).
badges_provider (Callable): This callback provides the list of badges to layer atop the thumbnail
in the grid view. Callback signature: [str] badges_provider(item: :obj:`FileBrowserItem`)
treeview_identifier (str): widget identifier for treeview, only used by tests.
enable_zoombar (bool): Enables/disables zoombar. Default True.
"""
def __init__(self, title: str, **kwargs):
import carb.settings
self._tree_view = None
self._grid_view = None
self._table_view = None
self._zoom_bar = None
self._theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._drop_fn = kwargs.get("drop_fn", None)
self._filter_fn = kwargs.get("filter_fn", None)
# Create model to group other models, used by the tree view
self._models = FileBrowserModel(name=title, drop_fn=self._drop_fn, filter_fn=self._filter_fn)
self._models.root.icon = f"{ICON_PATH}/{self._theme}/cloud.svg"
# Create the model for the list view
self._listview_model = FileBrowserModel(drop_fn=self._drop_fn, filter_fn=self._filter_fn)
# OM-70157: Added this selections for listview here, because we cannot aggregate and re-apply selection from
# grid view/list view if the switch grid view scale and toggle happened within one frame (i.e. if the user
# is dragging the zoombar from one end to another within one frame), because the grid view items are built
# one frame delay, the selection will be lost from the scale and switch; thus this is recorded at a higher
# level on this widget, as a source of truth for selections for both list view and grid view;
self._listview_selections = []
self._currently_visible_model = None
self._style = UI_STYLES[self._theme]
self._layout = kwargs.get("layout", LAYOUT_DEFAULT)
self._splitter_offset = kwargs.get("splitter_offset", 300)
self._tooltip = kwargs.get("tooltip", False)
self._tree_root_visible = kwargs.get("tree_root_visible", True)
self._allow_multi_selection = kwargs.get("allow_multi_selection", True)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._selection_changed_fn = kwargs.get("selection_changed_fn", None)
self._show_grid_view = kwargs.get("show_grid_view", False)
self._grid_view_scale = kwargs.get("grid_view_scale", 2)
# OM-66270: Add callback to record show grid view settings in between sessions
self._on_toggle_grid_view_fn = kwargs.get("on_toggle_grid_view_fn", None)
self._on_scale_grid_view_fn = kwargs.get("on_scale_grid_view_fn", None)
self._icon_provider = kwargs.get("icon_provider", None)
self._thumbnail_provider = kwargs.get("thumbnail_provider", None)
self._badges_provider = kwargs.get("badges_provider", None)
self._treeview_identifier = kwargs.get('treeview_identifier', None)
self._enable_zoombar = kwargs.get("enable_zoombar", True)
self._datetime_format_updated_subscription = None
self._build_ui()
@property
def show_udim_sequence(self):
return self._listview_model.show_udim_sequence
@show_udim_sequence.setter
def show_udim_sequence(self, value: bool):
self._listview_model.show_udim_sequence = value
def _build_ui(self):
if self._layout in [LAYOUT_SPLIT_PANES, LAYOUT_SINGLE_PANE_LIST, LAYOUT_DEFAULT]:
self._tree_view = self._build_split_panes_view()
else:
slim_view = self._layout == LAYOUT_SINGLE_PANE_SLIM
self._tree_view = self._build_tree_view(
self._models,
slim_view=slim_view,
selection_changed_fn=partial(self._on_selection_changed, TREEVIEW_PANE),
)
def on_datetime_format_changed(_: carb.dictionary.Item, event_type: carb.settings.ChangeEventType):
if event_type == carb.settings.ChangeEventType.CHANGED:
self.refresh_ui(listview_only=True)
self._datetime_format_updated_subscription = omni.kit.app.SettingChangeSubscription(
DATETIME_FORMAT_SETTING, on_datetime_format_changed)
def _build_split_panes_view(self) -> FileBrowserTreeView:
show_grid_view = self._show_grid_view
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
with ui.HStack(style=self._style):
with ui.ZStack(width=0, visible=self._layout != LAYOUT_SINGLE_PANE_LIST):
# Create navigation view as side pane
self._models.single_column = True
with ui.HStack():
with ui.VStack():
tree_view = self._build_tree_view(
self._models,
header_visible=False,
files_visible=False,
slim_view=True,
selection_changed_fn=partial(self._on_selection_changed, TREEVIEW_PANE),
)
ui.Spacer(width=2)
with ui.Placer(offset_x=self._splitter_offset, draggable=True, drag_axis=ui.Axis.X):
ui.Rectangle(width=4, style_type_name_override="Splitter")
with ui.ZStack():
self._grid_view = self._build_grid_view(self._listview_model)
self._table_view = self._build_table_view(self._listview_model)
if self._enable_zoombar:
with ui.VStack():
ui.Spacer()
self._zoom_bar = ZoomBar(
show_grid_view=self._show_grid_view,
grid_view_scale=self._grid_view_scale,
on_toggle_grid_view_fn=self.toggle_grid_view,
on_scale_grid_view_fn=self.scale_grid_view
)
ui.Spacer(height=2)
# OM-49484: Add a notification frame to list view stack, that could be used for showing notification
self._notification_frame = ui.Frame()
self.toggle_grid_view(show_grid_view)
return tree_view
def _build_tree_view(
self,
model: FileBrowserModel,
header_visible: bool = True,
files_visible: bool = True,
slim_view: bool = True,
selection_changed_fn: Callable = None,
) -> FileBrowserTreeView:
if slim_view:
model._single_column = True
with ui.ZStack(style=self._style):
ui.Rectangle(style_type_name_override="TreeView")
view = FileBrowserTreeView(
model,
header_visible=header_visible,
files_visible=files_visible,
tooltip=self._tooltip,
root_visible=self._tree_root_visible,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, TREEVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, TREEVIEW_PANE),
selection_changed_fn=selection_changed_fn,
icon_provider=self._icon_provider,
treeview_identifier=f"{self._treeview_identifier}_folder_view",
)
view.build_ui()
return view
def _build_table_view(self, model: FileBrowserModel) -> FileBrowserTreeView:
# Create detail view as table view
view = FileBrowserTreeView(
model,
root_visible=False,
tooltip=self._tooltip,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, LISTVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, LISTVIEW_PANE),
selection_changed_fn=partial(self._on_selection_changed, LISTVIEW_PANE),
icon_provider=self._icon_provider,
treeview_identifier=self._treeview_identifier,
)
view.build_ui()
return view
def _build_grid_view(self, model: FileBrowserModel) -> FileBrowserGridView:
# Create detail view as table view
view = FileBrowserGridView(
model,
root_visible=False,
tooltip=self._tooltip,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, LISTVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, LISTVIEW_PANE),
selection_changed_fn=partial(self._on_selection_changed, LISTVIEW_PANE),
drop_fn=self._drop_fn,
thumbnail_provider=self._thumbnail_provider,
badges_provider=self._badges_provider,
treeview_identifier=f"{self._treeview_identifier}_grid_view",
)
view.build_ui()
return view
def _on_mouse_pressed(self, pane: int, button: int, key_mod: int, item: FileBrowserItem, x: float = 0, y: float = 0):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(pane, button, key_mod, item, x=x, y=y)
def _on_mouse_double_clicked(self, pane: int, button: int, key_mod: int, item: FileBrowserItem, x: float = 0, y: float = 0):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(pane, button, key_mod, item, x=x, y=y)
if item and item.is_folder:
self._tree_view.select_and_center(item)
def _on_selection_changed(self, pane: int, selected: List[FileBrowserItem]):
if self._selection_changed_fn:
self._selection_changed_fn(pane, selected)
if pane == TREEVIEW_PANE and selected:
item = selected[-1]
if item.populated:
# If entering an already populated folder, sync up to any folder changes that may
# have been missed.
self._models.sync_up_item_changes(item)
# Refresh the folder in the list view
self._listview_model.root = item
self.show_model(self._listview_model)
# Clear out list view selections
self._listview_selections = []
# Finally, set folder to auto-refresh
self._auto_refresh_folder(item)
if pane == LISTVIEW_PANE:
# update list view selection on list view model
self._listview_selections = selected
def _auto_refresh_folder(self, item: FileBrowserItem):
if item:
self._models.auto_refresh_item(item)
self._models.add_item_changed_fn(lambda model, item: self.refresh_ui(item, listview_only=True))
def get_root(self, pane: int = None) -> FileBrowserItem:
if not pane:
return self._models.root
elif pane == TREEVIEW_PANE:
return self._tree_view.model.root
elif pane == LISTVIEW_PANE:
return self._listview_model.root
return None
def toggle_grid_view(self, show_grid_view: bool):
current_selections = self.get_selections(pane=LISTVIEW_PANE)
if not (self._grid_view and self._table_view):
return
if show_grid_view:
self._grid_view.visible = True
self._table_view.visible = False
else:
self._grid_view.visible = False
self._table_view.visible = True
# OM-70157: maintain current selection when toggling between grid view and list view
self.set_selections(current_selections, pane=LISTVIEW_PANE)
# OM-86768: refresh UI if cut clipboard is not empty to maintain the cut style
if is_clipboard_cut() and get_clipboard_items():
self.refresh_ui(listview_only=True)
self._show_grid_view = show_grid_view
# OM-66270: Record show grid view settings in between sessions
if self._on_toggle_grid_view_fn:
self._on_toggle_grid_view_fn(show_grid_view)
def hide_notification(self):
self._notification_frame.visible = False
self._grid_view.visible = self.show_grid_view
self._table_view.visible = not self.show_grid_view
def show_notification(self):
self._notification_frame.visible = True
self._grid_view.visible = False
self._table_view.visible = False
@property
def show_grid_view(self):
return self._show_grid_view
def scale_grid_view(self, scale: float):
if not self._grid_view:
return
if scale < 0.5:
self.toggle_grid_view(False)
else:
self.toggle_grid_view(True)
self._grid_view.scale_view(scale)
self._grid_view.build_ui(restore_selections=self._listview_selections)
# OM-66270: Record grid view scale settings in between sessions
if self._on_scale_grid_view_fn:
scale_level = None
# infer scale level from SCALE_MAP
if scale in SCALE_MAP.values():
scale_level = list(SCALE_MAP.keys())[list(SCALE_MAP.values()).index(scale)]
self._on_scale_grid_view_fn(scale_level)
def create_grouping_item(self, name: str, path: str, parent: FileBrowserItem = None) -> FileBrowserItem:
child = FileBrowserItemFactory.create_group_item(name, path)
if child:
item = parent or self._models.root
item.add_child(child)
self._models._item_changed(parent)
return child
def add_model_as_subtree(self, model: FileBrowserModel, parent: FileBrowserItem = None):
if model:
parent = parent or self._models.root
parent.add_child(model.root)
# TODO: Remove it
self.refresh_ui()
def delete_child_by_name(self, item_name: str, parent: FileBrowserItem = None):
if item_name:
parent = parent or self._models.root
parent.del_child(item_name)
# TODO: Remove it
self.refresh_ui()
def delete_child(self, item: FileBrowserItem, parent: FileBrowserItem = None):
if item:
self.delete_child_by_name(item.name, parent)
def link_views(self, src_widget: object):
"""
Links this widget to the given widget, i.e. the 2 widgets will therafter display the same
models but not necessarily share the same view.
Args:
src_widget (:obj:`FilePickerWidget`): The source widget.
"""
if self._tree_view and src_widget._tree_view:
src_model = src_widget._tree_view.model
if src_model:
self._tree_view.set_root(src_model.root)
def set_item_alert(self, item: FileBrowserItem, alert_level: int, msg: str):
if item:
item.alert = (alert_level, msg)
self.refresh_ui(item)
def set_item_info(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_INFO, msg)
def set_item_warning(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_WARNING, msg)
def set_item_error(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_ERROR, msg)
def clear_item_alert(self, item: FileBrowserItem):
if item:
item.alert = None
self.refresh_ui(item)
def refresh_ui(self, item: FileBrowserItem = None, listview_only: bool = False):
"""
Redraws the subtree rooted at the given item. If item is None, then redraws entire tree.
Args:
item (:obj:`FileBrowserItem`): Root of subtree to redraw. Default None, i.e. root.
"""
if not listview_only:
if self._tree_view:
self._tree_view.refresh_ui(item)
if self._grid_view:
self._grid_view.refresh_ui(item)
if self._table_view:
self._table_view.refresh_ui()
def set_selections(self, selections: [FileBrowserItem], pane: int = TREEVIEW_PANE):
"""
Selected given items in given pane.
ARGS:
selections (list[:obj:`FileBrowserItem`]): list of selections.
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE, or None for both. Default None.
"""
if not pane or pane == TREEVIEW_PANE:
if selections:
self._tree_view.tree_view.selection = selections
else:
# Note: OM-23294 - Segfaults when selections cleared
# self._tree_view.tree_view.clear_selection()
pass
if not pane or pane == LISTVIEW_PANE:
if selections:
self._table_view.tree_view.selection = selections
else:
# Note: OM-23294 - Segfaults when selections cleared
self._table_view.tree_view.clear_selection()
pass
if self._grid_view:
self._grid_view.selections = selections
self._listview_selections = selections
def get_selected_item(self, pane: int = TREEVIEW_PANE) -> FileBrowserItem:
"""
Returns last of selected item from the specified pane.
ARGS:
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE. Returns the union if None is specified.
Returns:
`FileBrowserItem` or None
"""
selections = self.get_selections(pane)
return selections[-1] if len(selections) > 0 else None
def get_selections(self, pane: int = TREEVIEW_PANE) -> [FileBrowserItem]:
"""
Returns list of selected items from the specified pane.
ARGS:
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE. Returns the union if None is specified.
Returns:
list[:obj:`FileBrowserItem`]
"""
if not pane or pane == TREEVIEW_PANE:
selections = self._tree_view.selections
else:
selections = []
if not pane or pane == LISTVIEW_PANE:
selections.extend(self._listview_selections)
# Ensure selections are unique
return list(set(selections))
def select_and_center(self, selection: FileBrowserItem, pane: int = TREEVIEW_PANE):
"""
Selects and centers the tree view on the given item, expanding the tree if needed.
Args:
selection (:obj:`FileBrowserItem`): The selected item.
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE.
"""
if not pane or pane == TREEVIEW_PANE:
self._tree_view.select_and_center(selection)
if self._grid_view:
self._grid_view.scroll_top()
if self._table_view:
self._table_view.scroll_top()
# clear out listview model selections when selecting treeview items
self._listview_selections = []
if not pane or pane == LISTVIEW_PANE:
if self._grid_view.visible:
self._grid_view.select_and_center(selection)
if self._table_view.visible:
self._table_view.select_and_center(selection)
self._listview_selections = [selection]
def set_expanded(self, item: FileBrowserItem, expanded: bool, recursive: bool = False):
"""
Sets the expansion state of the given item.
Args:
item (:obj:`FileBrowserItem`): The item to effect.
expanded (bool): True to expand, False to collapse.
recursive (bool): Apply state recursively to descendent nodes. Default False.
"""
if self._tree_view:
self._tree_view.set_expanded(item, expanded, recursive)
def show_model(self, model: FileBrowserModel):
if model:
new_model = model
new_model.copy_presets(self._listview_model)
else:
new_model = self._listview_model
if new_model != self._currently_visible_model:
# Hack to remove model to avoid memory leaks
# TODO: Find out how to create a model with no circular dependencies
if self._currently_visible_model and self._currently_visible_model != self._listview_model:
self._currently_visible_model.destroy()
self._currently_visible_model = new_model
if self._grid_view:
self._grid_view.model = self._currently_visible_model
if self._table_view:
self._table_view.model = self._currently_visible_model
def destroy(self):
"""
Destructor. Called by extension before destroying this object. It doesn't happen automatically.
Without this hot reloading doesn't work.
"""
if self._tree_view:
self._tree_view.destroy()
self._tree_view = None
if self._grid_view:
self._grid_view.destroy()
self._grid_view = None
if self._table_view:
self._table_view.destroy()
self._table_view = None
if self._listview_model:
self._listview_model.destroy()
self._listview_model = None
self._listview_selections.clear()
if self._notification_frame:
self._notification_frame = None
if self._zoom_bar:
self._zoom_bar.destroy()
self._zoom_bar = None
if self._models:
self._models.destroy()
self._models = None
self._currently_visible_model = None
self._style = None
self._drop_fn = None
self._filter_fn = None
self._mouse_pressed_fn = None
self._mouse_double_clicked_fn = None
self._selection_changed_fn = None
self._icon_provider = None
self._thumbnail_provider = None
self._badges_provider = None
self._datetime_format_updated_subscription = None
| 25,916 | Python | 43.8391 | 128 | 0.617919 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/singleton.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
def Singleton(class_):
"""A singleton decorator"""
instances = {}
def getinstance(*args, **kwargs):
if class_ not in instances:
instances[class_] = class_(*args, **kwargs)
return instances[class_]
return getinstance
| 697 | Python | 32.238094 | 76 | 0.725968 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/abstract_column_delegate.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["ColumnItem", "AbstractColumnDelegate"]
import omni.ui as ui
import abc
class ColumnItem:
"""
It's not clear which data we need to pass to build_widget. It's path, but
there are potentially other interesting information the column has. To
keep API unchanged over the time, we pass data in a struct. It also allow
to pass custom data with deriving from this class.
"""
def __init__(self, path):
self._path = path
@property
def path(self):
return self._path
class AbstractColumnDelegate(metaclass=abc.ABCMeta):
"""
An abstract object that is used to put the widget to the file browser
asynchronously.
"""
@property
def initial_width(self):
"""The width of the column"""
return ui.Fraction(1)
def build_header(self):
"""Build the header"""
pass
@abc.abstractmethod
async def build_widget(self, item: ColumnItem):
"""
Build the widget for the given path. Works inside Frame in async
mode. Once the widget is created, it will replace the content of the
frame. It allow to await something for a while and create the widget
when the result is available.
"""
pass
| 1,686 | Python | 29.672727 | 77 | 0.685647 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_zoom_bar.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.kit.app
from unittest.mock import patch
from ..widget import FileBrowserWidget
from ..grid_view import FileBrowserGridViewDelegate
class TestZoomBar(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate.update_grid"""
async def setUp(self):
self._throttle_frames = 2
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(self._throttle_frames + 1):
await omni.kit.app.get_app().next_update_async()
async def test_zoom_switches_to_table_view(self):
"""Testing FileBrowserWidget.scale_grid_view changes to treeview for small scale factors"""
under_test = FileBrowserWidget("test", show_grid_view=True)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.scale_grid_view(0.25)
self.assertTrue(under_test._table_view.visible)
self.assertFalse(under_test._grid_view.visible)
under_test.scale_grid_view(0.5)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.scale_grid_view(2.0)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.destroy()
under_test = None
async def test_zoom_rebuilds_grid_view(self):
"""Testing FileBrowserWidget.scale_grid_view re-builds the grid view"""
with patch.object(FileBrowserGridViewDelegate, "build_grid") as mock_build_grid,\
patch.object(FileBrowserGridViewDelegate, "update_grid") as mock_update_grid:
test_scale = 1.75
under_test = FileBrowserWidget("test", show_grid_view=True)
mock_build_grid.reset_mock()
mock_update_grid.reset_mock()
under_test.scale_grid_view(test_scale)
await self._after_redraw_async()
self.assertEqual(under_test._grid_view._delegate.scale, test_scale)
mock_build_grid.assert_called_once()
mock_update_grid.assert_called_once()
| 2,599 | Python | 38.393939 | 99 | 0.689496 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_thumbnails.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import os
import asyncio
import omni.kit.test
import omni.kit.app
import omni.client
import omni.ui as ui
from unittest.mock import patch, Mock
from typing import List, Dict
from functools import partial
from ..grid_view import FileBrowserGridViewDelegate
from ..card import FileBrowserItemCard
from ..model import FileBrowserModel, FileBrowserItem, FileBrowserItemFactory
from ..thumbnails import find_thumbnails_for_files_async, list_thumbnails_for_folder_async
from .. import MISSING_IMAGE_THUMBNAILS_EVENT, THUMBNAILS_GENERATED_EVENT
from . import AsyncMock
class TestRefreshThumbnails(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate rendering thumbnails"""
async def setUp(self):
self.test_dir = "omniverse://ov-test"
self.test_thumbnail_dict = {
f"{self.test_dir}/foo.tif": f"{self.test_dir}/.thumbs/foo.tif.png",
f"{self.test_dir}/bar.png": f"{self.test_dir}/.thumbs/bar.png.png",
}
async def tearDown(self):
pass
def _build_test_model(self, paths: List[str]) -> FileBrowserModel:
model = FileBrowserModel("ov-test", self.test_dir)
for path in paths:
model.root.add_child(
FileBrowserItemFactory.create_dummy_item(os.path.basename(path), path))
return model
async def _mock_get_folder_thumbnails_impl(self) -> Dict:
return self.test_thumbnail_dict
async def _mock_get_folder_thumbnails_empty(self) -> Dict:
return {}
async def _mock_find_thumbnails_impl(self, paths: str, generate_missing: bool = False) -> Dict:
return {path: self.test_thumbnail_dict.get(path) for path in paths}
async def test_update_grid_succeeds(self):
"""Testing FileBrowserGridViewDelegate.update_grid successfully renders custom thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_impl),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail:
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Confirm that cards with existing thumbnails redraw themselves
self.assertEqual(mock_refresh_thumbnail.call_count, len(paths))
async def test_thumbnails_not_found(self):
"""Testing FileBrowserGridViewDelegate.update_grid correctly handles no thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_empty),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail:
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Confirm that no matching thumbnails were found
mock_refresh_thumbnail.assert_not_called()
async def test_update_cards_on_thumbnails_generated(self):
"""Testing FileBrowserGridViewDelegate.update_cards_on_thumbnails_generated correctly handles new thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_empty),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail,\
patch("omni.kit.widget.filebrowser.grid_view.find_thumbnails_for_files_async", side_effect=self._mock_find_thumbnails_impl):
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream.push(THUMBNAILS_GENERATED_EVENT, payload={'paths': [paths[0]]})
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_refresh_thumbnail.assert_called_with(self.test_thumbnail_dict.get(paths[0]))
event_stream.push(THUMBNAILS_GENERATED_EVENT, payload={'paths': [paths[1]]})
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_refresh_thumbnail.assert_called_with(self.test_thumbnail_dict.get(paths[1]))
class TestFindThumbnailsForFiles(omni.kit.test.AsyncTestCase):
"""Testing find_thumbnails_for_files_async api func"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_find_thumbnails_succeeds(self):
"""Testing find_thumbnails_for_files_async returns expected thumbnails in dict"""
async def mock_stat_async_impl(path: str):
return omni.client.Result.OK, None
with patch("omni.client.stat_async", side_effect=mock_stat_async_impl):
test_urls = ["omniverse://ov-foo/foo.usd", "omniverse://ov-bar/bar.usd", "omniverse://ov-baz/baz.usd" ]
results = await find_thumbnails_for_files_async(test_urls)
# Confirm thumbnail files found
self.assertEqual(len(test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.png"
self.assertEqual(thumbnail_url, expected)
async def test_find_thumbnails_returns_auto_files(self):
"""Testing find_thumbnails_for_files_async returns auto thumbnails when those are available"""
async def mock_stat_async_auto(path: str):
return (omni.client.Result.OK, None) if ".auto." in path else (omni.client.Result.ERROR_NOT_FOUND, None)
with patch("omni.client.stat_async", side_effect=mock_stat_async_auto):
test_urls = ["omniverse://ov-foo/foo.usd", "omniverse://ov-bar/bar.usd", "omniverse://ov-baz/baz.usd" ]
results = await find_thumbnails_for_files_async(test_urls)
# Confirm thumbnail files found
self.assertEqual(len(test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.auto.png"
self.assertEqual(thumbnail_url, expected)
async def test_find_thumbnails_generates_missing_when_not_found(self):
"""Testing find_thumbnails_for_files_async submits missing thumbnails for generation"""
async def mock_stat_async_not_found(path: str):
return omni.client.Result.ERROR_NOT_FOUND, None
with patch("omni.client.stat_async", side_effect=mock_stat_async_not_found):
test_image_urls = ["omniverse://ov-foo/foo.png", "omniverse://ov-baz/baz.jpg"]
test_urls = test_image_urls + ["omniverse://ov-bar/bar.usd"]
mock_sub_callback = Mock()
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(MISSING_IMAGE_THUMBNAILS_EVENT, mock_sub_callback)
results = await find_thumbnails_for_files_async(test_urls)
# Check that subscription callback was triggered, and that only image files are submitted for
# thumbnail generation.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_image_urls)})
# Call again with additional inputs
test_more_image_urls = ["omniverse://ov-cow/cow.tif"]
test_urls += test_more_image_urls
mock_sub_callback.reset_mock()
results = await find_thumbnails_for_files_async(test_urls)
# This time, assert that only the new files are submitted for thumbnail generation. I.e. we don't
# want the same files to be submitted more than once.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_more_image_urls)})
class TestListThumbnailsForFolder(omni.kit.test.AsyncTestCase):
"""Testing list_thumbnails_for_folder_async api func"""
async def setUp(self):
self.test_folder = "omniverse://ov-test/folder"
self.test_files = ["foo.usd", "bar.jpg", "baz.png" ]
self.test_urls = [f"{self.test_folder}/{f}" for f in self.test_files]
self.test_thumbnails = [f"{self.test_folder}/.thumbs/256x256/{f}.png" for f in self.test_files]
self.test_auto_thumbnails = [f"{self.test_folder}/.thumbs/256x256/{f}.auto.png" for f in self.test_files]
async def tearDown(self):
pass
class MockStats:
def __init__(self, is_folder: bool = False):
self.flags = 0
if is_folder:
self.flags |= omni.client.ItemFlags.CAN_HAVE_CHILDREN
class MockListEntry:
def __init__(self, url: str):
self.relative_path = os.path.basename(url)
async def _mock_stat_async_impl(self, url: str):
if os.path.basename(url) == "folder":
return omni.client.Result.OK, self.MockStats(is_folder=True)
return omni.client.Result.OK, self.MockStats(is_folder=False)
async def _mock_list_async_impl(self, url: str):
if url.endswith(".thumbs/256x256"):
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_thumbnails]
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_urls]
async def _mock_list_async_impl_auto(self, url: str):
if url.endswith(".thumbs/256x256"):
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_auto_thumbnails]
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_urls]
async def _mock_list_async_timeout(self, url: str):
raise asyncio.TimeoutError
async def test_list_thumbnails_succeeds(self):
"""Testing list_thumbnails_for_folder_async returns expected thumbnails in dict"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_impl):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm thumbnail files found
self.assertEqual(len(self.test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.png"
self.assertEqual(thumbnail_url, expected)
async def test_list_thumbnails_auto(self):
"""Testing list_thumbnails_for_folder_async returns auto thumbnails in dict"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_impl_auto):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm auto thumbnail files found
self.assertEqual(len(self.test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.auto.png"
self.assertEqual(thumbnail_url, expected)
async def test_list_thumbnails_auto_precedence(self):
"""Testing that when list_thumbnails_for_folder_async returns multiple thumbnails, the non-auto one takes precedence"""
test_file = "foo.usd"
test_url = f"{self.test_folder}/{test_file}"
async def mock_list_async_impl(url: str):
if url.endswith(".thumbs/256x256"):
thumbnail_folder = f"{self.test_folder}/.thumbs/256x256"
# Return both auto and non-auto thumbnails
return omni.client.Result.OK, [self.MockListEntry(f"{thumbnail_folder}/{test_file}.auto.png"), self.MockListEntry(f"{thumbnail_folder}/{test_file}.png")]
else:
return omni.client.Result.OK, [self.MockListEntry(test_url)]
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=mock_list_async_impl):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm non-auto thumbnail precedes auto thumbnail
expected = f"{self.test_folder}/.thumbs/256x256/{test_file}.png"
self.assertEqual(results.get(test_url), expected)
async def test_get_thumbnails_timeout(self):
"""Testing list_thumbnails_for_folder_async times out"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_timeout):
results = await list_thumbnails_for_folder_async(self.test_folder)
self.assertEqual(results, {})
async def test_get_thumbnails_generates_missing_when_not_found(self):
"""Testing list_thumbnails_for_folder_async submits missing thumbnails for generation"""
test_image_files = ["bar.jpg", "baz.png" ]
test_image_urls = [f"{self.test_folder}/{f}" for f in test_image_files]
test_urls = test_image_urls + [f"{self.test_folder}/foo.usd"]
async def mock_list_async_impl(url: str):
if url.endswith(".thumbs/256x256"):
# Thumbnails not found
return omni.client.Result.OK, []
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in test_urls]
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=mock_list_async_impl):
mock_sub_callback = Mock()
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(MISSING_IMAGE_THUMBNAILS_EVENT, mock_sub_callback)
results = await list_thumbnails_for_folder_async(self.test_folder)
# Check that subscription callback was triggered, and that only image files are submitted for
# thumbnail generation.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertEqual(event.payload.get_dict(), {'urls': tuple(test_image_urls)})
# Call again with additional inputs
test_more_image_urls = [f"{self.test_folder}/cow.tif"]
test_urls += test_more_image_urls
mock_sub_callback.reset_mock()
results = await list_thumbnails_for_folder_async(self.test_folder)
# This time, assert that only the new files are submitted for thumbnail generation. I.e. we don't
# want the same files to be submitted more than once.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_more_image_urls)}) | 17,144 | Python | 51.753846 | 169 | 0.650782 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_datetime_format.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.kit.app
import carb.settings
from functools import partial
from ..date_format_menu import DatetimeFormatMenu, DATETIME_FORMAT_SETTING, get_datetime_format
class TestDatetimeFormat(omni.kit.test.AsyncTestCase):
"""Testing DatetimeFormatMenu"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
async def test_datetime_format_change(self):
""" Test datetime format setting changes"""
self._datetime_format = "MM/DD/YYYY"
self._format_changed = False
def format_change_callback(owner):
owner._format_changed = True
datetime_menu = DatetimeFormatMenu(partial(format_change_callback, self))
datetime_menu.visible = True
# test datetime format value
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, self._datetime_format)
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%m/%d/%Y")
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, "DD-MM-YYYY")
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%d-%m-%Y")
# test datetime format setting change callback is work as expected
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, "DD/MM/YYYY")
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%x")
self.assertTrue(self._format_changed)
| 2,033 | Python | 37.377358 | 95 | 0.694048 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_widget.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory
from ..widget import FileBrowserWidget
async def after_redraw_async(frames=1):
for _ in range(frames + 1):
await omni.kit.app.get_app().next_update_async()
class TestWidget(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserWidget basic fuction"""
async def setUp(self):
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
async def test_widget_refreshes_views(self):
"""Testing FileBrowserWidget._auto_refresh_item updates views"""
from .. import TREEVIEW_PANE, LISTVIEW_PANE
import omni.ui as ui
window_flags = ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_DOCKING
self._window = ui.Window("test_window", width=1200, height=900, flags=window_flags)
with self._window.frame:
test_url = "C://watched"
test_url2 = "C://watched2"
udim_url = "C://texture_1001.jpg"
udim_url2 = "C://texture_1002.jpg"
model = FileBrowserModel("C:", "C:")
watched = FileBrowserItemFactory.create_group_item("watched", test_url)
udim_item = FileBrowserItemFactory.create_udim_item("udim", udim_url, 0,1,1)
udim_item2 = FileBrowserItemFactory.create_udim_item("udim2", udim_url2,1,2,1)
udim_item.populate_udim(model.root)
model.root.add_child(watched)
model.root.add_child(udim_item)
model.root.add_child(udim_item2)
under_test = FileBrowserWidget("test")
under_test.add_model_as_subtree(model)
under_test._on_selection_changed(TREEVIEW_PANE, [watched])
# teat some widget's attribute and method
under_test.show_udim_sequence=True
self.assertTrue(under_test.show_udim_sequence)
self.assertEqual(under_test.get_root(), under_test._models.root)
self.assertEqual(under_test.get_root(TREEVIEW_PANE), under_test._tree_view.model.root)
self.assertEqual(under_test.get_root(LISTVIEW_PANE), under_test._listview_model.root)
# test notification and toggle
under_test.show_notification()
self.assertTrue(under_test._notification_frame.visible)
under_test.hide_notification()
self.assertFalse(under_test._notification_frame.visible)
under_test.toggle_grid_view(True)
self.assertTrue(under_test.show_grid_view)
# test create item
item_create_from_widget = under_test.create_grouping_item("watched2", test_url2)
self.assertEqual(item_create_from_widget.name, "watched2")
# test set item info
under_test.set_item_info(item_create_from_widget, "info")
self.assertEqual(item_create_from_widget.alert[1], "info")
under_test.set_item_warning(item_create_from_widget, "warning")
self.assertEqual(item_create_from_widget.alert[1], "warning")
await after_redraw_async(self._throttle_frames)
under_test.set_item_error(item_create_from_widget, "error")
self.assertEqual(item_create_from_widget.alert[1], "error")
await after_redraw_async(self._throttle_frames)
under_test.clear_item_alert(item_create_from_widget)
self.assertEqual(item_create_from_widget.alert, None)
await after_redraw_async(self._throttle_frames)
# test tree view select
under_test.set_selections([item_create_from_widget], TREEVIEW_PANE)
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
under_test.select_and_center(item_create_from_widget, TREEVIEW_PANE)
under_test.set_expanded(item_create_from_widget, True, True)
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
# test listview select
under_test.select_and_center(watched, LISTVIEW_PANE)
under_test.toggle_grid_view(False)
self.assertFalse(under_test.show_grid_view)
under_test.select_and_center(item_create_from_widget, LISTVIEW_PANE)
under_test._on_selection_changed(LISTVIEW_PANE, [item_create_from_widget])
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
under_test.delete_child(item_create_from_widget)
await after_redraw_async(self._throttle_frames)
| 5,317 | Python | 49.647619 | 98 | 0.661651 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/__init__.py | ## Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from unittest.mock import Mock
class AsyncMock(Mock):
"""Async equivalent of Mock class"""
def __call__(self, *args, **kwargs):
sup = super(AsyncMock, self)
async def coro():
return sup.__call__(*args, **kwargs)
return coro()
def __await__(self):
return self().__await__()
from .test_widget import *
from .test_populate import *
from .test_thumbnails import *
from .test_auto_refresh import *
from .test_grid_view import *
from .test_zoom_bar import *
from .test_datetime_format import *
from .test_drop import *
| 1,014 | Python | 31.741934 | 77 | 0.704142 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_populate.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import asyncio
import omni.client
import omni.kit.app
from typing import List, Callable
from functools import partial
from datetime import datetime
from unittest.mock import Mock, patch, ANY
from carb.events import IEventStream
from ..model import FileBrowserModel, FileBrowserItemFactory, FileBrowserItem
from ..nucleus_model import NucleusItemFactory, NucleusItem
from ..filesystem_model import FileSystemItemFactory, FileSystemItem
from .. import CONNECTION_ERROR_EVENT
from . import AsyncMock
class TestNucleusPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.NucleusItem"""
async def setUp(self):
self.test_listings = {"omniverse://ov-test": ["Lib", "NVIDIA", "Projects", "Users"]}
async def tearDown(self):
pass
class MockListEntry:
def __init__(self, path, size=0, access=0, flags=omni.client.ItemFlags.CAN_HAVE_CHILDREN):
self.relative_path = path
self.size = size
self.access = access
self.flags = flags
self.modified_time = datetime.now()
async def _mock_list_async_impl(self, url: str):
if url in self.test_listings:
entries = [self.MockListEntry(subdir) for subdir in self.test_listings[url]]
result = omni.client.Result.OK
else:
entries, result = [], omni.client.Result.ERROR_NOT_FOUND
return result, entries
async def _mock_list_async_exception(self, url: str):
raise RuntimeError("Runtime error")
async def _mock_list_async_error(self, url: str):
return omni.client.Result.ERROR, []
async def _mock_list_async_timeout(self, url: str, timeout = 1.0):
await asyncio.sleep(timeout+1)
async def test_listing_succeeds(self):
"""Testing NucleusItem.populate_async should succeed"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
mock_callback = AsyncMock(return_value=123)
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has been populated
self.assertTrue(item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(omni.client.Result.OK, item.children)
self.assertEqual(return_value, 123)
async def test_listing_raises_exception(self):
"""Testing NucleusItem.populate_async should catch Exception"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_exception
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, Exception)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Confirm that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_returns_error(self):
"""Testing NucleusItem.populate_async should return error"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_error
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, RuntimeWarning)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Check that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_times_out(self):
"""Testing NucleusItem.populate_async times out"""
with patch("omni.client.list_async") as mock_list_async:
timeout = 1.0
mock_list_async.side_effect = self._mock_list_async_timeout
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback, timeout=timeout)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, RuntimeWarning)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Check that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_called_just_once(self):
"""Testing NucleusItem.populate_async should not populate item if already populated"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
await item.populate_async(None)
# Check that item has been populated
self.assertTrue(bool(item.children) and item.populated)
# Populate again and again
await item.populate_async(None)
await item.populate_async(None)
# Check that the call to list_async ran only the first time
self.assertEqual(mock_list_async.call_count, 1)
class TestFileSystemPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileSystemItem"""
async def setUp(self):
self.test_listings = {"C:": ["Program Files", "ProgramData", "temp", "Users", "Windows"]}
async def tearDown(self):
pass
class MockDirEntry:
def __init__(self, path: str, file_attrs: int = 0, symlink: bool = False):
self.name = path
self.path = path
self._file_attrs = file_attrs
self._symlink = symlink
def stat(self):
from collections import namedtuple
MockStat = namedtuple("MockStat", "st_file_attributes st_size, st_mode, st_mtime")
return MockStat(self._file_attrs, 0, 0, 0)
def is_dir(self):
True
def is_symlink(self):
return self._symlink
class MockDirEntryIterator:
def __init__(self, subdirs = List[str]):
self._subdirs = subdirs
self._current = 0
def __iter__(self):
return self
def __next__(self):
if self._current < len(self._subdirs):
entry = TestFileSystemPopulate.MockDirEntry(self._subdirs[self._current])
self._current += 1
return entry
else:
raise StopIteration
def __enter__(self):
return self.__iter__()
def __exit__(self, e_type, e_val, e_traceback):
return False
def _mock_os_scandir_impl(self, path: str):
if path in self.test_listings:
subdirs = self.test_listings[path]
else:
subdirs = []
return self.MockDirEntryIterator(subdirs)
async def test_listing_succeeds(self):
"""Testing FileSystemItem.populate_async should succeed"""
with patch("os.scandir") as mock_os_scandir:
with patch("omni.kit.widget.filebrowser.FileSystemItem.keep_entry") as mock_keep_entry:
mock_os_scandir.side_effect = self._mock_os_scandir_impl
mock_keep_entry.return_value = True
mock_callback = AsyncMock(return_value=123)
test_path = "C:"
item = FileSystemItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has been populated
self.assertTrue(item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(None, item.children)
self.assertEqual(return_value, 123)
async def test_listing_returns_empty(self):
"""Testing FileSystemItem.populate_async returns empty"""
with patch("os.scandir") as mock_os_scandir:
with patch("omni.kit.widget.filebrowser.FileSystemItem.keep_entry") as mock_keep_entry:
mock_os_scandir.side_effect = self._mock_os_scandir_impl
mock_keep_entry.return_value = True
mock_callback = AsyncMock(return_value=123)
test_path = "O:"
item = FileSystemItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has not been populated
self.assertFalse(bool(item.children) and item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(None, ANY)
self.assertEqual(return_value, 123)
async def test_keep_entry(self):
"""Testing FileSystemItem.keep_entry returns True for valid entries"""
import stat
with patch("os.name", "nt"):
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("Desktop")))
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry(".thumbs", file_attrs=stat.FILE_ATTRIBUTE_HIDDEN)))
self.assertFalse(
FileSystemItem.keep_entry(self.MockDirEntry("System", file_attrs=stat.FILE_ATTRIBUTE_SYSTEM)))
with patch("os.name", "posix"):
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("home")))
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("link@", symlink=True)))
class TestFileBrowserPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileBrowserItem"""
async def setUp(self):
self.test_listings = {"omniverse://ov-test": ["Lib", "NVIDIA", "Projects", "Users"]}
self._timeout = 1.0
async def tearDown(self):
pass
async def _mock_populate_async_impl(self, item: FileBrowserItem, callback_async: Callable, timeout: float = 1.0):
if not item.populated:
if item.path in self.test_listings:
subdirs = self.test_listings[item.path]
else:
subdirs = []
for subdir in subdirs:
item.add_child(FileBrowserItemFactory.create_group_item(subdir, f"{item.path}/{subdir}"))
item.populated = True
return await callback_async(None, item.children)
async def _mock_populate_async_timeout(self, item: FileBrowserItem, callback_async: Callable, timeout: float = 1.0):
return await callback_async(asyncio.TimeoutError(), None)
async def test_populate_with_callback_succeeds(self):
"""Testing FileBrowserItem.populate_with_callback should invoke callback"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_impl
mock_callback = Mock()
test_path = "omniverse://ov-test"
item = FileBrowserItemFactory.create_group_item(test_path, test_path)
item.populate_with_callback(mock_callback, timeout=self._timeout)
# Wait for the thread to finish, then check that callback was invoked
await omni.kit.app.get_app().next_update_async()
mock_callback.assert_called_once_with(item.children)
async def test_populate_with_callback_times_out(self):
"""Testing FileBrowserItem.populate_with_callback times out"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_timeout
mock_callback = Mock()
test_path = "omniverse://ov-test"
item = FileBrowserItemFactory.create_group_item(test_path, test_path)
item.populate_with_callback(mock_callback, timeout=self._timeout)
# Wait for the thread to finish, then check that callback was not invoked
await omni.kit.app.get_app().next_update_async()
mock_callback.assert_not_called()
async def test_get_item_children_succeeds(self):
"""Testing FileBrowserModel.get_item_children should populate asynchronously"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_impl
mock_item_changed_callback = Mock()
test_path = "omniverse://ov-test"
model = FileBrowserModel(test_path, test_path, timeout=self._timeout)
model.add_item_changed_fn(mock_item_changed_callback)
item = model.root
self.assertFalse(item.populated)
# Check that the call immediately returns but with initially empty children list
children = model.get_item_children(item)
self.assertEqual(children, [])
# Wait til populate_async fulfills its task
await omni.kit.app.get_app().next_update_async()
# Check again and confirm item is now populated with expected children
self.assertTrue(item.populated)
children = model.get_item_children(item)
self.assertEqual([c.name for c in children], self.test_listings.get(test_path))
# Confirm item changed was called
await omni.kit.app.get_app().next_update_async()
mock_item_changed_callback.assert_called_once_with(model, item)
| 16,583 | Python | 42.98939 | 121 | 0.635711 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_auto_refresh.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from datetime import datetime
from typing import Callable
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory
from ..nucleus_model import NucleusItemFactory
from ..filesystem_model import FileSystemItemFactory
from ..widget import FileBrowserWidget
from ..tree_view import FileBrowserTreeView
from ..grid_view import FileBrowserGridView, FileBrowserGridViewDelegate
class MockListEntry:
def __init__(self, path, size=0, access=0, flags=omni.client.ItemFlags.CAN_HAVE_CHILDREN):
self.relative_path = path
self.size = size
self.access = access
self.flags = flags
self.modified_time = datetime.now()
self.deleted = False
class MockListSubscription:
def __init__(self, url, list_cb, list_change_cb):
self._url = url
self._list_cb = list_cb
self._list_change_cb = list_change_cb
self._events = []
self._cur_event = 0
def queue_event(self, result: omni.client.Result, event: omni.client.ListEvent, entry: MockListEntry):
self._events.append((result, event, entry))
def next_event(self, url: str) -> omni.client.ListEvent:
if url == self._url and self._cur_event < len(self._events):
result, event, entry = self._events[self._cur_event]
if self._list_change_cb:
self._list_change_cb(result, event, entry)
self._cur_event += 1
return event
else:
return None
async def after_redraw_async(frames=1):
for _ in range(frames + 1):
await omni.kit.app.get_app().next_update_async()
class TestAutoRefresh(omni.kit.test.AsyncTestCase):
"""Testing FileSystemItem.content_changed_async"""
async def setUp(self):
self.test_list_subscription = None
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
def _mock_list_subscribe_impl(self, url: str, list_cb: Callable, list_change_cb: Callable):
self.test_list_subscription = MockListSubscription(url, list_cb, list_change_cb)
async def test_auto_refresh_nucleus_folder(self):
"""Testing FileBrowserModel.auto_refresh_item monitors Nucleus folder for changes"""
with patch.object(omni.client, "list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "omniverse://ov-test/watched"
model = FileBrowserModel("ov-test", "omniverse://ov-test")
watched = NucleusItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Queue up events
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("bar.mdl"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("bar.mdl"))
# Created foo.usd
self.assertEqual(len(watched.children), 0)
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
# Created bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue("bar.mdl" in watched.children)
# Deleted foo.usd
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
self.assertTrue(watched.children["foo.usd"].is_deleted)
self.assertTrue(not watched.children["bar.mdl"].is_deleted)
# Deleted bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue(watched.children["bar.mdl"].is_deleted)
# Confirm item changes queued up and triggered only once after next frame
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_auto_refresh_filesystem_folder(self):
"""Testing FileBrowserModel.auto_refresh_item monitors Filesystem folder for changes"""
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "C://watched"
model = FileBrowserModel("C:", "C:")
watched = FileSystemItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Queue up events
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("bar.mdl"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("bar.mdl"))
# Created foo.usd
self.assertEqual(len(watched.children), 0)
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
# Created bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue("bar.mdl" in watched.children)
# Deleted foo.usd
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
self.assertTrue(not "foo.usd" in watched.children)
self.assertTrue("bar.mdl" in watched.children)
# Deleted bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 0)
self.assertTrue(not "bar.mdl" in watched.children)
# Confirm item changes queued up and triggered only once
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_auto_refresh_ignores_update_events(self):
"""Testing FileBrowserModel.auto_refresh_item responds to only CREATED and DELETED events (OM-29866)"""
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "omniverse://ov-test/watched"
model = FileBrowserModel("ov-test", "omniverse://ov-test")
watched = NucleusItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.assertEqual(len(watched.children), 0)
# CREATED event
mock_item_changed.reset_mock()
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
# UPDATED, etc. events
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UPDATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.LOCKED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UNLOCKED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.METADATA, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UNKNOWN, MockListEntry("foo.usd"))
mock_item_changed.reset_mock()
while True:
# UPDATED event
event = self.test_list_subscription.next_event(watched.path)
if event:
await after_redraw_async(self._throttle_frames)
self.assertTrue(event not in [omni.client.ListEvent.CREATED, omni.client.ListEvent.DELETED])
mock_item_changed.assert_not_called()
else:
break
# DELETED event
mock_item_changed.reset_mock()
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.next_event(watched.path)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
for child_name in watched.children:
item = watched.children[child_name]
item.is_deleted = True
self.assertEqual(item.is_deleted, True)
# Confirm item changes queued up and triggered only once
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_widget_refreshes_views(self):
"""Testing FileBrowserWidget._auto_refresh_item updates views"""
from .. import TREEVIEW_PANE
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserTreeView, "refresh_ui") as mock_refresh_tree_view,\
patch.object(FileBrowserGridView, "refresh_ui") as mock_refresh_grid_view:
test_url = "C://watched"
model = FileBrowserModel("C:", "C:")
watched = FileBrowserItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Make watched directory the current one
under_test = FileBrowserWidget("test")
under_test.add_model_as_subtree(model)
under_test._on_selection_changed(TREEVIEW_PANE, [watched])
# Queue up events
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
# Confirm change event triggers UI refresh
mock_refresh_tree_view.reset_mock()
mock_refresh_grid_view.reset_mock()
self.test_list_subscription.next_event(watched.path)
await after_redraw_async(self._throttle_frames)
mock_refresh_tree_view.assert_called()
mock_refresh_grid_view.assert_called()
async def test_gridview_redraws_only_once(self):
"""Testing FileBrowserGridView.refresh_ui updates grid view only once when refreshed many times"""
with patch.object(FileBrowserGridViewDelegate, "build_grid") as mock_delegate_build_grid,\
patch.object(FileBrowserGridViewDelegate, "update_grid") as mock_delegate_update_grid:
model = FileBrowserModel("ov-test", "omniverse://ov-test")
under_test = FileBrowserGridView(model)
mock_delegate_build_grid.assert_called_once_with(model)
# OM-78400 Clear out all refreshes from setting up the view before testing for additional ones
await after_redraw_async(self._throttle_frames)
mock_delegate_update_grid.reset_mock()
# Call refresh multiple times
under_test.refresh_ui()
under_test.refresh_ui()
under_test.refresh_ui()
# Confirm that refresh doesn't immediately rebuild the grid view. Instead, after some delay,
# builds the view only once.
mock_delegate_update_grid.assert_not_called()
await after_redraw_async(self._throttle_frames)
mock_delegate_update_grid.assert_called_once_with(model)
class TestSyncItemChanges(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileBrowserModel"""
async def setUp(self):
self.test_frame = 0
self.test_listings_by_frame = [["A", "B", "C"], ["B", "C", "D"]]
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
async def _mock_list_async_impl(self, url: str, include_deleted_option=omni.client.ListIncludeOption.INCLUDE_DELETED_FILES):
subdirs = []
if self.test_frame < len(self.test_listings_by_frame):
subdirs = self.test_listings_by_frame[self.test_frame]
self.test_frame += 1
entries = [MockListEntry(subdir) for subdir in subdirs]
result = omni.client.Result.OK
return result, entries
async def test_syncing_item_changes_succeeds(self):
"""Testing FileBrowserModel.sync_up_item_changes updates given folder"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
test_url = "C://watched"
watched = FileSystemItemFactory.create_group_item("watched", test_url)
under_test = FileBrowserModel("C:", "C:")
under_test.root.add_child(watched)
under_test.sync_up_item_changes(watched)
await omni.kit.app.get_app().next_update_async()
test_subdirs_0 = self.test_listings_by_frame[0]
self.assertEqual(test_subdirs_0, [name for name in watched.children])
under_test.sync_up_item_changes(watched)
await omni.kit.app.get_app().next_update_async()
test_subdirs_1 = self.test_listings_by_frame[1]
self.assertEqual(test_subdirs_1, [name for name in watched.children])
| 15,506 | Python | 49.02258 | 132 | 0.658326 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_drop.py | ## Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from unittest.mock import Mock
from ..model import FileBrowserModel, FileBrowserItemFactory
class TestDrop(omni.kit.test.AsyncTestCase):
"""Testing FileSystemItem.content_changed_async"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_drop_handler(self):
"""Test drop handler behaves as expected."""
from .. import TREEVIEW_PANE
mock_drop = Mock()
model = FileBrowserModel("C:", "C:", drop_fn=mock_drop)
src_paths = []
for i in range(100):
src_paths.append("C://foo_" + str(i +1))
src_items = []
for src in src_paths:
src_items.append(FileBrowserItemFactory.create_group_item(src.lstrip("C://"), src))
dst_item = FileBrowserItemFactory.create_group_item("dst", "C://dst")
# test drop_fn only called once when multiple items are triggering drop handler at the same time
for src_item in src_items:
model.drop(dst_item, src_item)
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_drop.assert_called_once_with(dst_item, "\n".join(src_paths))
mock_drop.reset_mock()
# test drop_fn called correctly when passing in string as source
src_paths_str = "C://foo\nC://bar\nC://baz"
model.drop(dst_item, src_paths_str)
mock_drop.assert_called_once_with(dst_item, src_paths_str) | 1,961 | Python | 37.470588 | 104 | 0.661397 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_grid_view.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
import omni.ui as ui
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory, FileBrowserItem
from ..grid_view import FileBrowserGridView, FileBrowserGridViewDelegate
class TestUpdateGridView(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate.update_grid"""
async def setUp(self):
self._throttle_frames = 2
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(self._throttle_frames + 1):
await omni.kit.app.get_app().next_update_async()
async def _mock_refresh_thumbnails_async(self, model: FileBrowserModel):
pass
def _get_badges(self, item: FileBrowserItem):
return []
async def test_update_grid_adds_new_items(self):
"""Testing FileBrowserGridView.update_grid updates the grid view successfully"""
with patch.object(FileBrowserGridViewDelegate, "refresh_thumbnails_async", side_effect=self._mock_refresh_thumbnails_async):
model = FileBrowserModel("ov-test", "omniverse://ov-test")
test_items = ["foo.usd", "bar.usd"]
test_items_path = []
for name in test_items:
model.root.add_child(FileBrowserItemFactory.create_dummy_item(name, f"{model.root.path}/{name}"))
test_items_path.append(f"{model.root.path}/{name}")
# Assert grid initially empty
under_test = FileBrowserGridView(model, testing=True)
delegate = under_test._delegate
self.assertTrue(delegate._grid is not None)
self.assertEqual(0, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(0, len(delegate._cards))
# Grid is populated after redraw
under_test.refresh_ui()
await self._after_redraw_async()
test_card = delegate._cards[test_items_path[0]]
test_card._get_badges_fn = self._get_badges
thumbnail = test_card._get_thumbnail(test_card._item)
self.assertIsNotNone(thumbnail)
test_card._item.alert = (1, "Info")
test_card.draw_badges()
self.assertEqual(len(test_items), len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(len(test_items), len(delegate._cards))
# Adding a file updates the grid
model.root.add_child(FileBrowserItemFactory.create_dummy_item("baz.usd", f"{model.root.path}/baz.usd"))
under_test.refresh_ui()
await self._after_redraw_async()
self.assertEqual(len(test_items)+1, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(len(test_items)+1, len(delegate._cards))
# Assert deleting orignal files leaves only the added file in place
for name in test_items:
model.root.del_child(name)
under_test.refresh_ui()
await self._after_redraw_async()
self.assertEqual(1, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(1, len(delegate._cards))
self.assertTrue(f"{model.root.path}/baz.usd" in delegate._cards)
async def test_cut_items_style_reflected(self):
"""Testing that items in cut clipboard are applied cut style."""
from ..clipboard import save_items_to_clipboard, is_path_cut
with patch.object(FileBrowserGridViewDelegate, "refresh_thumbnails_async", side_effect=self._mock_refresh_thumbnails_async):
model = FileBrowserModel("ov-test", "omniverse://ov-test")
test_names = ["foo.usd", "bar.usd", "baz.usd"]
for name in test_names:
model.root.add_child(FileBrowserItemFactory.create_dummy_item(name, f"{model.root.path}/{name}"))
# Assert grid initially empty
under_test = FileBrowserGridView(model, testing=True)
delegate = under_test._delegate
under_test.refresh_ui()
await self._after_redraw_async()
# with empty clipboard every item should be with normal name
for path, item in delegate._cards.items():
self.assertFalse(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "")
item.draw_badges()
# put item in clipboard
items = model.get_item_children(model.root)
cut_path = items[0].path
save_items_to_clipboard(items[0], is_cut=True)
await self._after_redraw_async()
under_test.refresh_ui()
# item in clipboard should be applied Cut style name
for path, item in delegate._cards.items():
if path == cut_path:
self.assertTrue(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "Cut")
else:
self.assertFalse(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "")
| 5,534 | Python | 45.512605 | 132 | 0.634261 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [2.3.10] - 2023-01-19
### Updated
- Fixed issue with NucleusItem calling `on_populated_async` with incorrect number of parameters
## [2.3.9] - 2023-01-11
### Updated
- Fixed issue with selections before cards created
## [2.3.8] - 2022-11-30
### Updated
- OM-63433: Use content_clipping to speed up item display in file picker
## [2.3.7] - 2022-11-17
### Updated
- Fixes access flags for filesystem entries.
## [2.3.6] - 2022-10-21
### Updated
- Updated signature of copy_item_async to accept source and destination path, instead of always using
the source relative path and destination root to compute the destination path.
## [2.3.4] - 2022-10-03
### Updated
- Commented out deprecation warnings.
## [2.3.3] - 2022-09-21
### Updated
- Switching between different date formats.
## [2.3.2] - 2022-09-12
### Updated
- Updates cards in grid view on thumbnails generated.
## [2.3.1] - 2022-09-01
### Updated
- Unique identifier names for tree view and list view panes.
## [2.3.0] - 2022-08-30
### Updated
- Refactored thumbnails provider
## [2.2.30] - 2022-07-19
### Updated
- Minor bug fix
## [2.2.29] - 2022-07-06
### Updated
- Fix regression to show context menu when right click on grid view.
## [2.2.28] - 2022-06-22
### Updated
- Multiple drag and drop support.
## [2.2.27] - 2022-05-26
### Updated
- Adds read-only badge to treeview items.
- Updated unit of file size to Mebibyte (instead of Megabyte)
## [2.2.25] - 2022-04-06
### Updated
- Fixes occasional startup error.
## [2.2.24] - 2022-02-18
### Updated
- Adds copy_presets method for FileBrowser models.
## [2.2.23] - 2022-02-15
### Updated
- Increases reconnect timeout to 10 mins.
## [2.2.22] - 2022-02-09
### Updated
- Fixes crash when browsing folders in grid view.
## [2.2.21] - 2022-01-20
### Updated
- Added `set_filter_fn` to the model class.
## [2.2.20] - 2022-01-05
### Updated
- Improved reconnection by skipping signout step, also increased timeout to 30 secs.
## [2.2.19] - 2021-11-24
### Updated
- Added `show_grid_view` to get grid or table view.
## [2.2.18] - 2021-11-16
### Updated
- Catches exception from tagging service that was crashing Kit.
## [2.2.17] - 2021-11-12
### Updated
- Fixes scaling of thumbnails.
## [2.2.16] - 2021-10-12
### Updated
- Notify on connection error.
## [2.2.15] - 2021-09-17
### Updated
- Added widget identifers
## [2.2.14] - 2021-09-07
### Updated
- Updated the reconnection to server flow.
## [2.2.13] - 2021-08-25
### Updated
- Fixes race condition that causes the table view to crash while auto-refreshing.
## [2.2.12] - 2021-08-12
### Updated
- Fixes multi-selection drag-n-drop from listview into viewport.
## [2.2.11] - 2021-08-09
### Updated
- Smoother update of thumbnails while populating a search filter.
## [2.2.10] - 2021-07-13
### Updated
- Moved zoom bar back from filepicker widget for better encapsulation.
## [2.2.9] - 2021-07-13
### Updated
- Update the directory path from either tree or list view.
Fixes failure when opening a file under a nested directory in the right-pane when a hierarchial view.
## [2.2.8] - 2021-06-16
### Updated
- Syncs up folder upon entering but do so incrementally instead of re-creating it.
- Change above also fixes crashing when navigating to a folder, due to a race condition for populating that folder.
## [2.2.7] - 2021-06-10
### Updated
- Ignore omni.client.ListEvent.CREATED on existing directories
## [2.2.6] - 2021-06-07
### Updated
- More thorough destruction of class instances upon shutdown.
## [2.2.5] - 2021-06-04
### Updated
- Added overwrite dialog when copying files
## [2.2.4] - 2021-05-12
### Updated
- Eliminates too many concurrent redraws of the grid view causing it to crash. This happens because
manually initiated redraws conflict the new auto refresh.
## [2.2.3] - 2021-04-16
### Updated
- Double clicking on file icon in treeview opens it.
- Lock badge repositioned to not obstruct label.
- Small files show proper size instead of 0.00 Mb.
## [2.2.2] - 2021-04-15
### Updated
- Fixes auto refresh crash when copying large number of files, by limiting number of grid view redraws to
at most once per frame.
## [2.2.1] - 2021-04-08
### Updated
- Auto refresh ignores update events, which breaks live sync mode.
## [2.2.0] - 2021-04-02
### Added
- Now auto refreshes current folder.
## [2.1.6] - 2021-03-25
### Updated
- Fixes thumbnail generator improperly skipped.
## [2.1.5] - 2021-02-16
### Updated
- Fixes thumbnails for search model.
## [2.1.4] - 2021-02-12
### Updated
- Fix for thumbnails not loading properly as part of the gather process.
## [2.1.3] - 2021-02-10
### Changes
- Updated StyleUI handling
## [2.1.2] - 2021-02-09
### Updated
- Added vertical spacing to the cards in grid view to accommodate larger font size.
## [2.1.1] - 2021-02-09
### Updated
- Fixed navigation slowness caused by processing of thumbnails.
## [2.1.0] - 2021-02-04
### Updated
- Extracted ZoomBar into its own widget and moved to omni.kit.window.filepicker extension.
## [2.0.1] - 2021-02-03
### Updated
- Refactored code for getting auto-generated thumbnails. The simplification allowed for easier testing.
- Fixed bug that was causing artifacts and mismatched thumbnails in grid view
### Added
- Unittests for navigating directories
## [2.0.0] - 2021-01-03
### Updated
- Implements omni.client.list_async to improve overall stability in case of network delays.
## [1.2.5] - 2020-12-10
### Updated
- Adds methods reconnect_url and stat_path_with_callback
- Removes method stat_path_async
## [1.2.4] - 2020-11-23
### Updated
- Fixes missing scroll bar in grid view.
## [1.2.3] - 2020-11-19
### Updated
- Supports multi-selection mouse press and double clicks.
## [1.2.2] - 2020-11-18
### Updated
- Updated to work with omni.client version 0.1.0
- Fixes: crash on double clicking in table view to open a folder.
- Fixes: cannot select item at bottom of table view.
## [1.2.1] - 2020-11-13
### Added
- Clear selections in list view whenever new directory is clicked.
## [1.2.0] - 2020-10-31
### Added
- Select and center in grid view.
## [1.1.0] - 2020-10-27
### Added
- Changed ui.Image to ui.ImageWithProvider almost everywhere in order to address UI lag.
## [0.2.5] - 2020-09-16
### Added
- Initial commit to master.
| 6,354 | Markdown | 24.833333 | 115 | 0.692949 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/README.md | # Kit Filebrowser Widget [omni.kit.widget.filebrowser]
The basic UI widget and set of supporting classes for navigating the filesystem through a tree view. The filesystem can either be from your local machine or the Omniverse server.
| 235 | Markdown | 57.999986 | 178 | 0.812766 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/index.rst | omni.kit.widget.filebrowser
###########################
Kit Filebrowser Widget.
.. toctree::
:maxdepth: 1
Overview
CHANGELOG
.. automodule:: omni.kit.widget.filebrowser
:platform: Windows-x86_64, Linux-x86_64
:members:
:show-inheritance:
:undoc-members:
.. autoclass:: FileBrowserWidget
:members:
.. autoclass:: FileBrowserModel
:members:
.. autoclass:: FileBrowserItem
:members:
.. autoclass:: FileSystemModel
:members:
.. autoclass:: NucleusModel
:members:
| 561 | reStructuredText | 16.562499 | 43 | 0.588235 |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/Overview.md | # Overview
| 11 | Markdown | 4.999998 | 10 | 0.727273 |
omniverse-code/kit/exts/omni.index.compute/ogn/docs/OgnTimestepSelector.rst | .. _omni_index_compute_timestepSelector_1:
.. _omni_index_compute_timestepSelector:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Timestep selector
:keywords: lang-en omnigraph node threadsafe compute timestep-selector
Timestep selector
=================
.. <description>
Selects a timestep from time input
.. </description>
Installation
------------
To use this node enable :ref:`omni.index.compute<ext_omni_index_compute>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"FPS (*inputs:fps*)", "``double``", "FPS", "1.0"
"Time (*inputs:time*)", "``double``", "Time", "-1.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Timestep (*outputs:timestep*)", "``int``", "Timestep", "-1"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.index.compute.timestepSelector"
"Version", "1"
"Extension", "omni.index.compute"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Timestep selector"
"Generated Class Name", "OgnTimestepSelectorDatabase"
"Python Module", "omni.index.compute"
| 1,544 | reStructuredText | 21.720588 | 99 | 0.549223 |
omniverse-code/kit/exts/omni.index.compute/ogn/docs/OgnIndexDistributedComputeTechnique.rst | .. _omni_index_compute_indexDistributedComputeTechnique_1:
.. _omni_index_compute_indexDistributedComputeTechnique:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: NVIDIA IndeX distributed compute technique
:keywords: lang-en omnigraph node compute index-distributed-compute-technique
NVIDIA IndeX distributed compute technique
==========================================
.. <description>
Integration with NVIDIA IndeX distributed compute technique
.. </description>
Installation
------------
To use this node enable :ref:`omni.index.compute<ext_omni_index_compute>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Active (*inputs:active*)", "``bool``", "If false then disable the node operation", "True"
"Compute buffers (*inputs:buffers*)", "``uint64[]``", "Input compute buffers", "[]"
"Multithreading (*inputs:threading*)", "``bool``", "Use multithreading", "True"
"Timestep (*inputs:timestep*)", "``int``", "Active timestep", "-1"
"Verbose (*inputs:verbose*)", "``int``", "Log verbose output", "0"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.index.compute.indexDistributedComputeTechnique"
"Version", "1"
"Extension", "omni.index.compute"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "NVIDIA IndeX distributed compute technique"
"Generated Class Name", "OgnIndexDistributedComputeTechniqueDatabase"
"Python Module", "omni.index.compute"
| 1,859 | reStructuredText | 29 | 99 | 0.597095 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/__init__.py | """There is no public API to this module."""
__all__ = []
from ._impl.extension import _PublicExtension # noqa: F401
| 119 | Python | 22.999995 | 59 | 0.663866 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/OgnTimestepSelectorDatabase.py | """Support for simplified access to data on nodes of type omni.index.compute.timestepSelector
Selects a timestep from time input
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTimestepSelectorDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.index.compute.timestepSelector
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.fps
inputs.time
Outputs:
outputs.timestep
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:fps', 'double', 0, 'FPS', 'FPS', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:time', 'double', 0, 'Time', 'Time', {ogn.MetadataKeys.DEFAULT: '-1.0'}, True, -1.0, False, ''),
('outputs:timestep', 'int', 0, 'Timestep', 'Timestep', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def fps(self):
data_view = og.AttributeValueHelper(self._attributes.fps)
return data_view.get()
@fps.setter
def fps(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.fps)
data_view = og.AttributeValueHelper(self._attributes.fps)
data_view.set(value)
@property
def time(self):
data_view = og.AttributeValueHelper(self._attributes.time)
return data_view.get()
@time.setter
def time(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.time)
data_view = og.AttributeValueHelper(self._attributes.time)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
@property
def timestep(self):
data_view = og.AttributeValueHelper(self._attributes.timestep)
return data_view.get()
@timestep.setter
def timestep(self, value):
data_view = og.AttributeValueHelper(self._attributes.timestep)
data_view.set(value)
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTimestepSelectorDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTimestepSelectorDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTimestepSelectorDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 5,555 | Python | 44.170731 | 118 | 0.657786 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/OgnIndexDistributedComputeTechniqueDatabase.py | """Support for simplified access to data on nodes of type omni.index.compute.indexDistributedComputeTechnique
Integration with NVIDIA IndeX distributed compute technique
"""
import numpy
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnIndexDistributedComputeTechniqueDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.index.compute.indexDistributedComputeTechnique
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.active
inputs.buffers
inputs.threading
inputs.timestep
inputs.verbose
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:active', 'bool', 0, 'Active', 'If false then disable the node operation', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:buffers', 'uint64[]', 0, 'Compute buffers', 'Input compute buffers', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:threading', 'bool', 0, 'Multithreading', 'Use multithreading', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:timestep', 'int', 0, 'Timestep', 'Active timestep', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
('inputs:verbose', 'int', 0, 'Verbose', 'Log verbose output', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def active(self):
data_view = og.AttributeValueHelper(self._attributes.active)
return data_view.get()
@active.setter
def active(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.active)
data_view = og.AttributeValueHelper(self._attributes.active)
data_view.set(value)
@property
def buffers(self):
data_view = og.AttributeValueHelper(self._attributes.buffers)
return data_view.get()
@buffers.setter
def buffers(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.buffers)
data_view = og.AttributeValueHelper(self._attributes.buffers)
data_view.set(value)
self.buffers_size = data_view.get_array_size()
@property
def threading(self):
data_view = og.AttributeValueHelper(self._attributes.threading)
return data_view.get()
@threading.setter
def threading(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.threading)
data_view = og.AttributeValueHelper(self._attributes.threading)
data_view.set(value)
@property
def timestep(self):
data_view = og.AttributeValueHelper(self._attributes.timestep)
return data_view.get()
@timestep.setter
def timestep(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timestep)
data_view = og.AttributeValueHelper(self._attributes.timestep)
data_view.set(value)
@property
def verbose(self):
data_view = og.AttributeValueHelper(self._attributes.verbose)
return data_view.get()
@verbose.setter
def verbose(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.verbose)
data_view = og.AttributeValueHelper(self._attributes.verbose)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnIndexDistributedComputeTechniqueDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnIndexDistributedComputeTechniqueDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnIndexDistributedComputeTechniqueDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 7,131 | Python | 45.311688 | 150 | 0.65685 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/TestOgnIndexDistributedComputeTechnique.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.index.compute.ogn.OgnIndexDistributedComputeTechniqueDatabase import OgnIndexDistributedComputeTechniqueDatabase
test_file_name = "OgnIndexDistributedComputeTechniqueTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_index_compute_indexDistributedComputeTechnique")
database = OgnIndexDistributedComputeTechniqueDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:active"))
attribute = test_node.get_attribute("inputs:active")
db_value = database.inputs.active
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:buffers"))
attribute = test_node.get_attribute("inputs:buffers")
db_value = database.inputs.buffers
expected_value = []
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:threading"))
attribute = test_node.get_attribute("inputs:threading")
db_value = database.inputs.threading
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timestep"))
attribute = test_node.get_attribute("inputs:timestep")
db_value = database.inputs.timestep
expected_value = -1
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:verbose"))
attribute = test_node.get_attribute("inputs:verbose")
db_value = database.inputs.verbose
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
| 3,770 | Python | 52.112675 | 130 | 0.700265 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/TestOgnTimestepSelector.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.index.compute.ogn.OgnTimestepSelectorDatabase import OgnTimestepSelectorDatabase
test_file_name = "OgnTimestepSelectorTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_index_compute_timestepSelector")
database = OgnTimestepSelectorDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:fps"))
attribute = test_node.get_attribute("inputs:fps")
db_value = database.inputs.fps
expected_value = 1.0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:time"))
attribute = test_node.get_attribute("inputs:time")
db_value = database.inputs.time
expected_value = -1.0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs:timestep"))
attribute = test_node.get_attribute("outputs:timestep")
db_value = database.outputs.timestep
| 2,556 | Python | 49.137254 | 98 | 0.696401 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/__init__.py | """====== GENERATED BY omni.graph.tools - DO NOT EDIT ======"""
import omni.graph.tools._internal as ogi
ogi.import_tests_in_directory(__file__, __name__)
| 155 | Python | 37.999991 | 63 | 0.645161 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/bindings/_omni_index_compute.pyi | """pybind11 omni.index.compute bindings"""
from __future__ import annotations
import omni.index.compute.bindings._omni_index_compute
import typing
__all__ = [
"IOmniGraphIndex",
"acquire_interface",
"release_interface"
]
class IOmniGraphIndex():
pass
def acquire_interface(plugin_name: str = None, library_path: str = None) -> IOmniGraphIndex:
pass
def release_interface(arg0: IOmniGraphIndex) -> None:
pass
| 435 | unknown | 21.947367 | 92 | 0.712644 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core.tests as ogts
import omni.index.compute as ogidx
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphIndexApi(ogts.OmniGraphTestCase):
_UNPUBLISHED = ["bindings", "ogn", "tests"]
async def test_api(self):
_check_module_api_consistency(ogidx, self._UNPUBLISHED) # noqa: PLW0212
_check_module_api_consistency(ogidx.tests, is_test_module=True) # noqa: PLW0212
async def test_api_features(self):
"""Test that the known public API features continue to exist"""
_check_public_api_contents(ogidx, [], self._UNPUBLISHED, only_expected_allowed=True) # noqa: PLW0212
_check_public_api_contents(ogidx.tests, [], [], only_expected_allowed=True) # noqa: PLW0212
| 935 | Python | 48.263155 | 109 | 0.657754 |
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/tests/__init__.py | """There is no public API to this module."""
__all__ = []
scan_for_test_modules = True
"""The presence of this object causes the test runner to automatically scan the directory for unit test cases"""
| 201 | Python | 32.666661 | 112 | 0.716418 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_order_manager.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import Callable, Dict
import carb.settings
MANIPULATOR_ORDERS_SETTING_PATH = "/persistent/exts/omni.kit.manipulator.selector/orders"
class ManipulatorOrderManager:
def __init__(self):
self._on_orders_changed_fns_id = 0
self._on_orders_changed_fns: Dict[Callable] = {}
self._settings = carb.settings.get_settings()
self._sub = self._settings.subscribe_to_tree_change_events(
MANIPULATOR_ORDERS_SETTING_PATH, self._on_setting_changed
)
self._orders_dict: Dict[str, int] = {}
self._refresh_orders()
def destroy(self):
if self._sub:
self._settings.unsubscribe_to_change_events(self._sub)
self._sub = None
def __del__(self):
self.destroy()
@property
def orders_dict(self) -> Dict[str, int]:
return self._orders_dict
def subscribe_to_orders_changed(self, fn: Callable) -> int:
self._on_orders_changed_fns_id += 1
self._on_orders_changed_fns[self._on_orders_changed_fns_id] = fn
return self._on_orders_changed_fns_id
def unsubscribe_to_orders_changed(self, id: int):
self._on_orders_changed_fns.pop(id, None)
def _on_setting_changed(self, tree_item, changed_item, event_type):
self._refresh_orders()
def _refresh_orders(self):
self._orders_dict = self._settings.get_settings_dictionary(MANIPULATOR_ORDERS_SETTING_PATH)
for fn in self._on_orders_changed_fns.values():
fn()
| 1,938 | Python | 33.624999 | 99 | 0.672859 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/extension.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import Dict
import omni.ext
from .manipulator_order_manager import ManipulatorOrderManager
from .manipulator_selector import ManipulatorSelector
_selectors: Dict[str, ManipulatorSelector] = {}
_order_manager: ManipulatorOrderManager = None
# Each UsdContext has a ManipulatorSelector to subscribe to selection event
def get_manipulator_selector(usd_context_name: str) -> ManipulatorSelector:
global _selectors
global _order_manager
if usd_context_name not in _selectors:
selector = ManipulatorSelector(_order_manager, usd_context_name)
_selectors[usd_context_name] = selector
return selector
return _selectors[usd_context_name]
class ManipulatorPrim(omni.ext.IExt):
def on_startup(self, ext_id):
global _order_manager
assert _order_manager is None
_order_manager = ManipulatorOrderManager()
def on_shutdown(self):
global _selectors
global _order_manager
for selector in _selectors.values():
selector.destroy()
_selectors.clear()
if _order_manager:
_order_manager.destroy()
_order_manager = None
| 1,594 | Python | 31.55102 | 76 | 0.725847 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_selector.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from __future__ import annotations
from typing import TYPE_CHECKING, Dict, Set
import carb.events
import carb.settings
import omni.usd
from pxr import Sdf
if TYPE_CHECKING:
from .manipulator_base import ManipulatorBase, ManipulatorOrderManager
class ManipulatorSelector:
def __init__(self, order_manager: ManipulatorOrderManager, usd_context_name: str):
self._order_manager = order_manager
self._usd_context_name = usd_context_name
self._manipulators: Dict[str, Set[ManipulatorBase]] = {}
self._usd_context = omni.usd.get_context(usd_context_name)
self._stage_event_sub = self._usd_context.get_stage_event_stream().create_subscription_to_pop_by_type(
int(omni.usd.StageEventType.SELECTION_CHANGED),
self._on_stage_selection_event,
name="ManipulatorSelector stage event",
)
self._order_sub = self._order_manager.subscribe_to_orders_changed(self._on_orders_changed)
self._refresh()
def destroy(self):
self._stage_event_sub = None
if self._order_sub:
self._order_manager.unsubscribe_to_orders_changed(self._order_sub)
self._order_sub = None
def __del__(self):
self.destroy()
def register_manipulator_instance(self, name: str, manipulator: ManipulatorBase):
needs_sort = False
if name not in self._manipulators:
self._manipulators[name] = set()
needs_sort = True
self._manipulators[name].add(manipulator)
if needs_sort:
self._sort()
self._refresh()
def unregister_manipulator_instance(self, name: str, manipulator: ManipulatorBase):
manipulator_set = self._manipulators.get(name, set())
manipulator_set.remove(manipulator)
self._refresh()
def _sort(self) -> bool:
orders_dict = self._order_manager.orders_dict
# sort by order
sorted_manipulators = dict(sorted(self._manipulators.items(), key=lambda item: orders_dict.get(item[0], 0)))
# compare keys to check order difference (direct dicts compare are equal if their content is same but in
# different order)
if sorted_manipulators != self._manipulators or list(sorted_manipulators.keys()) != list(
self._manipulators.keys()
):
self._manipulators = sorted_manipulators
return True
return False
def _refresh(self):
if self._usd_context.get_stage_state() == omni.usd.StageState.OPENED:
self._on_selection_changed()
def _on_stage_selection_event(self, event: carb.events.IEvent):
self._on_selection_changed()
def _on_selection_changed(self):
selection = self._usd_context.get_selection().get_selected_prim_paths()
selection_sdf = [Sdf.Path(path) for path in selection]
for _, manipulators in self._manipulators.items():
handled = False
for manipulator in manipulators:
if manipulator.on_selection_changed(self._usd_context.get_stage(), selection_sdf):
manipulator.enabled = True
handled = True
else:
manipulator.enabled = False
if handled:
# Set selection_sdf to None to signal subsequent manipulator the selection has been handled
# This is different from being empty []
selection_sdf = None
def _on_orders_changed(self):
if self._sort():
self._refresh()
| 3,991 | Python | 35.623853 | 116 | 0.646204 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/__init__.py | from .extension import *
from .manipulator_base import ManipulatorBase
| 71 | Python | 22.999992 | 45 | 0.830986 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_base.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import asyncio
from abc import ABC, abstractmethod
from typing import List, Union
from pxr import Sdf, Usd
from .extension import get_manipulator_selector
class ManipulatorBase(ABC):
"""
Base class for prim manipulator that works with ManipulatorSelector.
Instead of subscribing to UsdStageEvent for selection change, manipulator should inherit this class and implements
all abstractmethods to support choosing between multiple types of prim manipulators based on their order and enable
criterions.
The order of the manipulator is specified at carb.settings path `/persistent/exts/omni.kit.manipulator.selector/orders/<name>"`
"""
def __init__(self, name: str, usd_context_name: str):
"""
Constructor.
Args:
name (str): name of the manipulator. It must match the <name> in the setting path specifies order.
usd_context_name (str): name of the UsdContext this manipulator operates on.
"""
self._name = name
self._selector = get_manipulator_selector(usd_context_name)
self._register_task = None
self._registered = None
# do an async registration so that the child class __init__ has a chance to finish first.
self._delayed_register()
def destroy(self):
if self._register_task and not self._register_task.done():
self._register_task.cancel()
self._register_task = None
if self._registered:
self._selector.unregister_manipulator_instance(self._name, self)
self._registered = False
def __del__(self):
self.destroy()
@abstractmethod
def on_selection_changed(self, stage: Usd.Stage, selection: Union[List[Sdf.Path], None], *args, **kwargs) -> bool:
"""
Function called when selection changes or types of prim manipulators are added or removed.
Args:
stage (Usd.Stage): the usd stage of which the selection change happens. It is the same as the stage of the
UsdContext this manipulator works on.
selection (Union[List[Sdf.Path], None]): the list of selected prim paths. If it is None (different from []),
it means another manipulator with higher priority has handled the
selection and this manipulator should yield.
Return:
True if selected prim paths can be handled by this manipulator and subsequent manipulator with higher order
should yield.
False if selected prim paths can not be handled. Function should always return False if `selection` is None.
"""
raise NotImplementedError("Derived class must implement on_selection_changed")
return False
@property
@abstractmethod
def enabled(self) -> bool:
"""
Returns if this manipulator is enabled.
"""
raise NotImplementedError('Derived class must implement "enabled" getter')
return False
@enabled.setter
@abstractmethod
def enabled(self, value: bool):
"""
Sets if this manipulator is enabled. A disabled manipulator should hide itself.
"""
raise NotImplementedError('Derived class must implement "enabled" setter')
def _delayed_register(self):
async def register_manipulator():
self._selector.register_manipulator_instance(self._name, self)
self._registered = True
self._register_task = asyncio.ensure_future(register_manipulator())
| 4,038 | Python | 38.990099 | 131 | 0.662704 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/test_manipulator.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import List, Union
from omni.kit.manipulator.prim.prim_transform_manipulator import PrimTransformManipulator
from omni.kit.manipulator.transform import get_default_style
from omni.kit.manipulator.transform.settings_constants import c
from omni.kit.viewport.registry import RegisterScene
from pxr import Sdf, Usd, UsdGeom
# Creates a test manipulator that is white and half in size when selecting a mesh
class PrimTransformManipulatorMeshTest(PrimTransformManipulator):
def __init__(self, usd_context_name: str = "", viewport_api=None):
super().__init__(
usd_context_name=usd_context_name,
viewport_api=viewport_api,
name="omni.kit.manipulator.test_mesh_prim",
size=0.5,
)
def _create_local_global_styles(self):
super()._create_local_global_styles()
global_style = get_default_style()
global_style["Translate.Axis::x"]["color"] = 0xFFFFFFFF
global_style["Translate.Axis::y"]["color"] = 0xFFFFFFFF
global_style["Translate.Axis::z"]["color"] = 0xFFFFFFFF
self._styles[c.TRANSFORM_MODE_GLOBAL] = global_style
def on_selection_changed(self, stage: Usd.Stage, selection: Union[List[Sdf.Path], None], *args, **kwargs) -> bool:
if selection is None:
self.model.on_selection_changed([])
return False
self.model.on_selection_changed(selection)
for path in selection:
prim = stage.GetPrimAtPath(path)
if prim.IsA(UsdGeom.Mesh):
return True
return False
class PrimTransformManipulatorScene:
def __init__(self, desc: dict):
usd_context_name = desc.get("usd_context_name")
self.__transform_manip_override = PrimTransformManipulatorMeshTest(
usd_context_name=usd_context_name, viewport_api=desc.get("viewport_api")
)
def destroy(self):
if self.__transform_manip_override:
self.__transform_manip_override.destroy()
self.__transform_manip_override = None
# PrimTransformManipulator & TransformManipulator don't have their own visibility
@property
def visible(self):
return True
@visible.setter
def visible(self, value):
pass
@property
def categories(self):
return ("manipulator",)
@property
def name(self):
return "Test Mesh Prim Transform"
class TransformManipulatorRegistry:
def __init__(self):
self._scene = RegisterScene(PrimTransformManipulatorScene, "omni.kit.manipulator.test_mesh_prim")
def __del__(self):
self.destroy()
def destroy(self):
self._scene = None
| 3,111 | Python | 32.826087 | 118 | 0.677274 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/__init__.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .test_manipulator_selector import TestSelector
| 481 | Python | 42.818178 | 76 | 0.81289 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/test_manipulator_selector.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.kit.test
import inspect
import logging
import os
from pathlib import Path
from omni.kit.test.teamcity import is_running_in_teamcity
import sys
import unittest
import carb
import carb.input
import carb.settings
import omni.kit.commands
import omni.kit.ui_test as ui_test
import omni.kit.undo
import omni.kit.viewport.utility
import omni.usd
from omni.kit.manipulator.prim.settings_constants import Constants as prim_c
from omni.kit.manipulator.transform.settings_constants import c
from omni.kit.test_helpers_gfx.compare_utils import ComparisonMetric, capture_and_compare
from omni.kit.ui_test import Vec2
from omni.ui.tests.test_base import OmniUiTest
CURRENT_PATH = Path(f"{omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)}/data")
OUTPUTS_DIR = Path(omni.kit.test.get_test_output_path()).resolve().absolute()
logger = logging.getLogger(__name__)
class TestSelector(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._context = omni.usd.get_context()
self._selection = self._context.get_selection()
self._settings = carb.settings.get_settings()
self._golden_img_dir = CURRENT_PATH.absolute().resolve().joinpath("tests").joinpath("golden")
self._usd_scene_dir = CURRENT_PATH.absolute().resolve().joinpath("tests").joinpath("usd")
await self._setup()
# After running each test
async def tearDown(self):
self._golden_img_dir = None
await super().tearDown()
async def _snapshot(self, golden_img_name: str = "", threshold: float = 2e-4):
await ui_test.human_delay()
test_fn_name = ""
for frame_info in inspect.stack():
if os.path.samefile(frame_info[1], __file__):
test_fn_name = frame_info[3]
golden_img_name = f"{test_fn_name}.{golden_img_name}.png"
# Because we're testing RTX renderered pixels, use a better threshold filter for differences
diff = await capture_and_compare(
golden_img_name,
threshold=threshold,
output_img_dir=OUTPUTS_DIR,
golden_img_dir=self._golden_img_dir,
metric=ComparisonMetric.MEAN_ERROR_SQUARED,
)
self.assertLessEqual(
diff,
threshold,
f"The generated image {golden_img_name} has a difference of {diff}, but max difference is {threshold}",
)
async def _setup(
self,
scene_file: str = "test_scene.usda",
enable_toolbar: bool = False,
):
usd_path = self._usd_scene_dir.joinpath(scene_file)
success, error = await self._context.open_stage_async(str(usd_path))
self.assertTrue(success, error)
# move the mouse out of the way
await ui_test.emulate_mouse_move(Vec2(0, 0))
await ui_test.human_delay()
self._settings.set(prim_c.MANIPULATOR_PLACEMENT_SETTING, prim_c.MANIPULATOR_PLACEMENT_LAST_PRIM_PIVOT)
self._settings.set(c.TRANSFORM_MOVE_MODE_SETTING, c.TRANSFORM_MODE_GLOBAL)
self._settings.set(c.TRANSFORM_ROTATE_MODE_SETTING, c.TRANSFORM_MODE_GLOBAL)
self._settings.set(c.TRANSFORM_OP_SETTING, c.TRANSFORM_OP_MOVE)
self._settings.set("/app/viewport/snapEnabled", False)
self._settings.set("/persistent/app/viewport/snapToSurface", False)
self._settings.set("/exts/omni.kit.manipulator.prim/tools/enabled", enable_toolbar)
@unittest.skipIf(is_running_in_teamcity() and sys.platform.startswith("linux"), "OM-84020")
async def test_multi_manipulator_selector(self):
from .test_manipulator import PrimTransformManipulatorMeshTest, TransformManipulatorRegistry
# Select the /Cube, should show default manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("default_mesh")
# Select the /Xform, should show default manipulator
self._selection.set_selected_prim_paths(["/World"], True)
await ui_test.human_delay()
await self._snapshot("default_xform")
# Register the test manipulator that is specialized for Mesh
active_vp_window = omni.kit.viewport.utility.get_active_viewport_window()
if hasattr(active_vp_window, "legacy_window"):
test_manipulator = PrimTransformManipulatorMeshTest()
else:
test_manipulator = TransformManipulatorRegistry()
await ui_test.human_delay()
# Select the /Cube, should show overridden manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("overridden_mesh")
# Select the /Xform, should still show default manipulator as it's not a mesh
self._selection.set_selected_prim_paths(["/World"], True)
await ui_test.human_delay()
await self._snapshot("default_xform")
# Remove the overridden manipulator
test_manipulator.destroy()
test_manipulator = None
# Select the /Cube, should revert back to default manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("default_mesh")
| 5,734 | Python | 38.826389 | 116 | 0.679456 |
omniverse-code/kit/exts/omni.kit.manipulator.selector/docs/index.rst | omni.kit.manipulator.selector
################################
Prim Manipulator Selector Extension
.. toctree::
:maxdepth: 1
CHANGELOG
.. automodule:: omni.kit.manipulator.selector
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
:exclude-members: contextmanager
| 354 | reStructuredText | 16.749999 | 45 | 0.638418 |
omniverse-code/kit/exts/omni.usd.schema.semantics/pxr/Semantics/__init__.py | #
#====
# Copyright (c) 2018, NVIDIA CORPORATION
#======
#
#
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
import os
import sys
import platform
py38 = (3,8)
current_version = sys.version_info
if platform.system() == "Windows" and current_version >= py38:
from pathlib import Path
os.add_dll_directory(Path.joinpath(Path(os.path.dirname(__file__)), Path('..\\..\\')).__str__())
from . import _semanticAPI
from pxr import Tf
Tf.PrepareModule(_semanticAPI, locals())
del Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
try:
import __tmpDoc
__tmpDoc.Execute(locals())
del __tmpDoc
except:
pass
| 1,693 | Python | 28.719298 | 100 | 0.710573 |
omniverse-code/kit/exts/omni.usd.schema.semantics/pxr/Semantics/_semanticAPI.pyi | from __future__ import annotations
import pxr.Semantics._semanticAPI
import typing
import Boost.Python
import pxr.Usd
__all__ = [
"SemanticsAPI"
]
class SemanticsAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
@staticmethod
def Apply(*args, **kwargs) -> None: ...
@staticmethod
def CanApply(*args, **kwargs) -> None: ...
@staticmethod
def CreateSemanticDataAttr(*args, **kwargs) -> None: ...
@staticmethod
def CreateSemanticTypeAttr(*args, **kwargs) -> None: ...
@staticmethod
def Get(*args, **kwargs) -> None: ...
@staticmethod
def GetAll(*args, **kwargs) -> None: ...
@staticmethod
def GetSchemaAttributeNames(*args, **kwargs) -> None: ...
@staticmethod
def GetSemanticDataAttr(*args, **kwargs) -> None: ...
@staticmethod
def GetSemanticTypeAttr(*args, **kwargs) -> None: ...
@staticmethod
def IsSemanticsAPIPath(*args, **kwargs) -> None: ...
@staticmethod
def _GetStaticTfType(*args, **kwargs) -> None: ...
__instance_size__ = 48
pass
class _CanApplyResult(Boost.Python.instance):
@property
def whyNot(self) -> None:
"""
:type: None
"""
__instance_size__ = 56
pass
__MFB_FULL_PACKAGE_NAME = 'semanticAPI'
| 1,274 | unknown | 26.717391 | 85 | 0.626374 |
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/tests/nvindex_rtx_composite_render_test.py | #!/usr/bin/env python3
import carb
import omni.kit.commands
import omni.kit.test
import omni.usd
from omni.rtx.tests import RtxTest, testSettings, postLoadTestSettings
from omni.rtx.tests.test_common import set_transform_helper, wait_for_update
from omni.kit.test_helpers_gfx.compare_utils import ComparisonMetric
from pxr import Sdf, Gf, UsdVol
from pathlib import Path
EXTENSION_DIR = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__))
TESTS_DIR = EXTENSION_DIR.joinpath('data', 'tests')
USD_DIR = TESTS_DIR.joinpath('usd')
GOLDEN_IMAGES_DIR = TESTS_DIR.joinpath('golden')
VOLUMES_DIR = TESTS_DIR.joinpath('volumes')
OUTPUTS_DIR = Path(omni.kit.test.get_test_output_path())
# This class is auto-discoverable by omni.kit.test
class IndexRtxCompositeRenderTest(RtxTest):
WINDOW_SIZE = (512, 512)
THRESHOLD = 1e-6
async def setUp(self):
await super().setUp()
self.set_settings(testSettings)
self.ctx.new_stage()
self.add_dir_light()
await omni.kit.app.get_app().next_update_async()
self.set_settings(postLoadTestSettings)
# Overridden with custom paths
async def capture_and_compare(self, img_subdir: Path = "", golden_img_name=None, threshold=THRESHOLD,
metric: ComparisonMetric = ComparisonMetric.MEAN_ERROR_SQUARED):
golden_img_dir = GOLDEN_IMAGES_DIR.joinpath(img_subdir)
output_img_dir = OUTPUTS_DIR.joinpath(img_subdir)
if not golden_img_name:
golden_img_name = f"{self.__test_name}.png"
return await self._capture_and_compare(golden_img_name, threshold, output_img_dir, golden_img_dir, metric)
# Overridden with custom paths
def open_usd(self, usdSubpath: Path):
path = USD_DIR.joinpath(usdSubpath)
self.ctx.open_stage(str(path))
async def run_imge_test(self, usd_file: str, image_name: str, fn = None, threshold=THRESHOLD):
if usd_file:
self.open_usd(usd_file)
if fn:
fn()
await wait_for_update()
await self.capture_and_compare(golden_img_name=image_name, threshold=threshold)
#
# The tests
#
async def test_render_torus_volume_with_geometry(self):
self.open_usd('torus-volume-with-geometry.usda')
settings = carb.settings.get_settings()
for depth_mode in [0, 1, 2, 3]:
settings.set("/rtx/index/compositeDepthMode", depth_mode)
await wait_for_update()
# Non-stable depth mode is more noisy
threshold = (1e-2 if depth_mode == 2 else IndexRtxCompositeRenderTest.THRESHOLD)
await self.run_imge_test(None, f"nvindex-torus-composite-depth-mode-{depth_mode}.png", threshold=threshold)
| 2,775 | Python | 35.051948 | 119 | 0.672793 |
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/tests/__init__.py | from .nvindex_rtx_composite_render_test import *
| 49 | Python | 23.999988 | 48 | 0.795918 |
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/__init__.py | from .layer_undo import *
| 26 | Python | 12.499994 | 25 | 0.730769 |
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/layer_undo.py | from pxr import Sdf, Usd
class UsdLayerUndo:
class Key:
def __init__(self, path, info):
self.path = path
self.info = info
def __init__(self, layer: Sdf.Layer):
self._layer = layer
self.reset()
def reserve(self, path: Sdf.Path, info=None):
# Check if it's included by any added paths
path = Sdf.Path(path)
for added_key in self._paths:
if path.HasPrefix(added_key.path) and added_key.info is None:
return
# Check if it includes any added paths
if info is None:
for added_key in self._paths:
if added_key.path.HasPrefix(path):
self._paths.pop(added_key)
# If it doesn't exist, it's new spec. No need to reserve anything.
key = self.Key(path, info)
if not self._layer.GetObjectAtPath(path):
self._paths[key] = True
return
else:
self._paths[key] = False
# Reserve existing data
if info is None:
Sdf.CreatePrimInLayer(self._reserve_layer, path.GetParentPath())
Sdf.CopySpec(self._layer, path, self._reserve_layer, path)
else:
# We must know attribute type to create it in layer. So we don't handle it here.
if path.IsPropertyPath():
raise Exception("Property info is not supported.")
spec = self._layer.GetObjectAtPath(path)
Sdf.CreatePrimInLayer(self._reserve_layer, path)
reserve_spec = self._reserve_layer.GetObjectAtPath(path)
reserve_spec.SetInfo(info, spec.GetInfo(info))
def undo(self):
batch_edit = Sdf.BatchNamespaceEdit()
for key, new_spec in self._paths.items():
spec = self._layer.GetObjectAtPath(key.path)
reserve_spec = self._reserve_layer.GetObjectAtPath(key.path)
if new_spec:
# Remove new added spec
if spec:
batch_edit.Add(Sdf.NamespaceEdit.Remove(key.path))
elif key.info is None:
# Restore spec
Sdf.CopySpec(self._reserve_layer, key.path, self._layer, key.path)
else:
# Restore spec info
spec.SetInfo(key.info, reserve_spec.GetInfo(key.info))
self._layer.Apply(batch_edit)
def reset(self):
self._reserve_layer = Sdf.Layer.CreateAnonymous()
self._paths = {}
class UsdEditTargetUndo:
def __init__(self, edit_target: Usd.EditTarget):
self._edit_target = edit_target
self._layer_undo = UsdLayerUndo(self._edit_target.GetLayer())
def reserve(self, path: Sdf.Path, info=None):
self._layer_undo.reserve(path, info)
def undo(self):
self._layer_undo.undo()
def reset(self):
self._layer_undo.reset()
| 2,883 | Python | 32.149425 | 92 | 0.571627 |
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/__init__.py | from .test import *
| 20 | Python | 9.499995 | 19 | 0.7 |
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/test.py | import omni.kit.test
from ..layer_undo import *
from pxr import Sdf, Usd, UsdGeom, Kind, Gf
class TestUsdUndo(omni.kit.test.AsyncTestCase):
async def test_layer_undo(self):
stage = Usd.Stage.CreateInMemory()
usd_undo = UsdEditTargetUndo(stage.GetEditTarget())
mesh = UsdGeom.Mesh.Define(stage, "/root")
mesh.CreateNormalsAttr().Set([Gf.Vec3f(1, 0, 0)])
mesh.SetNormalsInterpolation("constant")
model = Usd.ModelAPI(mesh)
model.SetKind(Kind.Tokens.group)
org_stage_str = stage.ExportToString()
print("Original stage:")
print(org_stage_str)
usd_undo.reserve("/root.normals")
mesh.GetNormalsAttr().Set([Gf.Vec3f(0, 1, 0)])
mesh.SetNormalsInterpolation("faceVarying")
usd_undo.reserve("/root", "kind")
model.SetKind(Kind.Tokens.component)
usd_undo.reserve("/root/newPrim")
stage.DefinePrim("/root/newPrim")
modified_stage_str = stage.ExportToString()
print("Modified stage:")
print(modified_stage_str)
assert org_stage_str != modified_stage_str
usd_undo.undo()
undone_stage_str = stage.ExportToString()
print("Undone stage:")
print(undone_stage_str)
assert org_stage_str == undone_stage_str
| 1,311 | Python | 28.818181 | 59 | 0.630816 |
omniverse-code/kit/exts/omni.kit.usd_undo/docs/index.rst | omni.kit.usd_undo
###########################
Utitlity to implement undo for USD layer.
``UsdLayerUndo`` class is the utility to help you to implement USD undo. It reserves the state of a path, which could be a prim path or a property path. And when you call ``UsdLayerUndo.undo()``, those paths will be restored to their reserved state.
Example:
.. code:: python
import omni.kit.usd_undo
usd_undo = omni.kit.usd_undo.UsdLayerUndo(stage.GetEditTarget().GetLayer())
usd_undo.reserve("/root/prim")
'''Do anything to prim /root/prim here, including creating/deleting prim,
modifying/creating/deleting meta data or fields, modifying/creating/deleting
any attributes, modifying/creating/deleting any descendants, etc.'''
usd_undo.reserve("root/prim2.prop")
'''Do anything to property root/prim2.prop here, including creating, deleting,
modifying, etc.'''
usd_undo.reserve("root/prim2", Usd.Tokens.apiSchemas)
'''Do anything to apiSchemas field of prim root/prim2 here.'''
# Call UsdLayerUndo.undo() to revert all changes of those paths.
usd_undo.undo()
| 1,106 | reStructuredText | 32.545454 | 249 | 0.709765 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/__init__.py | # Expose these for easier import via from omni.kit.manipulator.selection import XXX
from .manipulator import SelectionManipulator, SelectionMode
| 145 | Python | 47.666651 | 83 | 0.848276 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/model.py | # Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from omni.ui import scene as sc
from typing import List, Sequence, Union
class SelectionShapeModel(sc.AbstractManipulatorModel):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__items = {
"ndc_start": (sc.AbstractManipulatorItem(), 2),
"ndc_current": (sc.AbstractManipulatorItem(), 2),
"ndc_rect": (sc.AbstractManipulatorItem(), 4),
"mode": (sc.AbstractManipulatorItem(), 1),
"live_update": (sc.AbstractManipulatorItem(), 1)
}
self.__ndc_ret_item = self.__items.get('ndc_rect')[0]
self.__values = {item: [] for item, _ in self.__items.values()}
def __validate_arguments(self, name: Union[str, sc.AbstractManipulatorItem], values: Sequence[Union[int, float]] = None) -> sc.AbstractManipulatorItem:
if isinstance(name, sc.AbstractManipulatorItem):
return name
item, expected_len = self.__items.get(name, (None, None))
if item is None:
raise KeyError(f"SelectionShapeModel doesn't understand values of {name}")
if values and len(values) != expected_len:
raise ValueError(f"SelectionShapeModel {name} takes {expected_len} values, got {len(values)}")
return item
def get_item(self, name: str) -> sc.AbstractManipulatorItem():
return self.__items.get(name, (None, None))[0]
def set_ints(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def set_floats(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def get_as_ints(self, name: str) -> List[int]:
item = self.__validate_arguments(name)
return self.__values[item]
def get_as_floats(self, name: str) -> List[float]:
item = self.__validate_arguments(name)
if item == self.__ndc_ret_item:
ndc_start, ndc_end = self.__values[self.get_item('ndc_start')], self.__values[self.get_item('ndc_current')]
if not ndc_start:
return []
if not ndc_end:
ndc_end = ndc_start
min_x = min(ndc_start[0], ndc_end[0])
max_x = max(ndc_start[0], ndc_end[0])
min_y = min(ndc_start[1], ndc_end[1])
max_y = max(ndc_start[1], ndc_end[1])
return [min_x, min_y, max_x, max_y]
return self.__values[item]
| 2,936 | Python | 42.83582 | 155 | 0.620232 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/manipulator.py | # Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ['SelectionManipulator', 'SelectionMode']
import carb.input
from omni.ui import scene as sc
from .model import SelectionShapeModel
from pxr import Gf
from typing import List
import weakref
class SelectionMode:
REPLACE = 0
APPEND = 1
REMOVE = 2
def _optional_bool(model: sc.AbstractManipulatorModel, item: str, default_value: bool = False):
values = model.get_as_ints(item)
return values[0] if values else default_value
class _KeyDown:
def __init__(self):
self.__input = carb.input.acquire_input_interface()
def test(self, key_a, key_b):
if self.__input.get_keyboard_button_flags(None, key_a) & carb.input.BUTTON_FLAG_DOWN:
return True
if self.__input.get_keyboard_button_flags(None, key_b) & carb.input.BUTTON_FLAG_DOWN:
return True
return False
class _SelectionPreventer(sc.GestureManager):
'''Class to explicitly block selection in favor of alt-orbit when alt-dragging'''
def can_be_prevented(self, gesture):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
if getattr(gesture, 'name', None) == "SelectionDrag":
return True
# Never prevent in the middle or at the end of drag
return (
gesture.state != sc.GestureState.CHANGED
and gesture.state != sc.GestureState.ENDED
and gesture.state != sc.GestureState.CANCELED
)
def should_prevent(self, gesture, preventer):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
name = getattr(gesture, 'name', None)
if name == "TumbleGesture":
return False
if name == "SelectionDrag":
return True
return super().should_prevent(gesture, preventer)
class _SelectionGesture:
@classmethod
def __get_selection_mode(self):
key_down = _KeyDown()
shift_down = key_down.test(carb.input.KeyboardInput.LEFT_SHIFT, carb.input.KeyboardInput.RIGHT_SHIFT)
if shift_down:
return SelectionMode.APPEND
ctrl_down = key_down.test(carb.input.KeyboardInput.LEFT_CONTROL, carb.input.KeyboardInput.RIGHT_CONTROL)
if ctrl_down:
return SelectionMode.REMOVE
# alt_down = key_down.test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
return SelectionMode.REPLACE
@classmethod
def _set_mouse(self, model: sc.AbstractManipulatorModel, ndc_mouse: List[float], is_start: bool = False):
if is_start:
model.set_floats('ndc_start', ndc_mouse)
model.set_ints('mode', [self.__get_selection_mode()])
elif _optional_bool(model, 'live_update'):
model.set_ints('mode', [self.__get_selection_mode()])
model.set_floats('ndc_current', ndc_mouse)
@classmethod
def _on_ended(self, manipulator: sc.Manipulator):
# This is needed to not fight with alt+left-mouse camera orbit when not blocking alt explicitly
# manipulator.invalidate()
model = manipulator.model
model.set_floats('ndc_start', [])
model.set_floats('ndc_current', [])
model.set_ints('mode', [])
model._item_changed(model.get_item('ndc_rect'))
class _DragGesture(sc.DragGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_began(self):
_SelectionGesture._set_mouse(self.__manipulator.model, self.sender.gesture_payload.mouse, True)
def on_changed(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse)
model._item_changed(model.get_item('ndc_rect'))
def on_ended(self):
# Track whether on_changed has been called.
# When it has: this drag is a drag.
# When it hasn't: this drag is actually a click.
if self.state != sc.GestureState.ENDED:
return
_SelectionGesture._on_ended(self.__manipulator)
class _ClickGesture(sc.ClickGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_ended(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse, True)
model._item_changed(model.get_item('ndc_rect'))
_SelectionGesture._on_ended(self.__manipulator)
class SelectionManipulator(sc.Manipulator):
def __init__(self, style: dict = None, *args, **kwargs):
applied_style = {
'as_rect': True,
'thickness': 2.0,
'color': (1.0, 1.0, 1.0, 0.2),
'inner_color': (1.0, 1.0, 1.0, 0.2)
}
if style:
applied_style.update(style)
super().__init__(*args, **kwargs)
self.__as_rect = applied_style['as_rect']
self.__outline_color = applied_style['color']
self.__inner_color = applied_style['inner_color']
self.__thickness = applied_style['thickness']
self.__polygons, self.__transform = [], None
# Provide some defaults
if not self.model:
self.model = SelectionShapeModel()
self.gestures = []
def on_build(self):
if self.__transform:
self.__transform.clear()
self.__polygons = []
sc.Screen(gestures=self.gestures or [
_DragGesture(weakref.proxy(self), manager=_SelectionPreventer(), name='SelectionDrag'),
_ClickGesture(weakref.proxy(self), name='SelectionClick'),
])
self.__transform = sc.Transform(look_at=sc.Transform.LookAt.CAMERA)
def __draw_shape(self, start, end, as_rect):
if as_rect:
avg_z = (start[2] + end[2]) * 0.5
points = ((start[0], start[1], avg_z),
(end[0], start[1], avg_z),
(end[0], end[1], avg_z),
(start[0], end[1], avg_z))
else:
if self.__polygons:
points = self.__polygons[0].positions + [end]
else:
points = start, end
# FIXME: scene.ui needs a full rebuild on this case
self.__transform.clear()
self.__polygons = []
npoints = len(points)
visible = npoints >= 3
if not self.__polygons:
with self.__transform:
faces = [x for x in range(npoints)]
# TODO: omni.ui.scene Shouldn't requires redundant color & thickness for constant color
if self.__inner_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__inner_color]*npoints, [npoints], faces, wireframe=False, visible=visible)
)
if self.__thickness and self.__outline_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__outline_color]*npoints, [npoints], faces, wireframe=True, thicknesses=[self.__thickness]*npoints, visible=visible)
)
else:
for poly in self.__polygons:
poly.positions = points
poly.visible = visible
def on_model_updated(self, item):
model = self.model
if item != model.get_item('ndc_rect'):
return
ndc_rect = model.get_as_floats('ndc_rect')
if ndc_rect:
ndc_depth = 1
start = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[0], ndc_rect[1], ndc_depth))
end = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[2], ndc_rect[3], ndc_depth))
self.__draw_shape(start, end, self.__as_rect)
else:
self.__transform.clear()
self.__polygons = []
| 8,490 | Python | 38.129032 | 169 | 0.601649 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_manipulator.py | ## Copyright (c) top_left[0]22, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
__all__ = ['TestSelectionManipulator']
import omni.kit.test
from ..manipulator import SelectionManipulator
from .test_scene_ui_base import TestOmniUiScene
from omni.ui import scene as sc
class TestSelectionManipulator(TestOmniUiScene):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__ndc_rects = []
self.__last_rect = None
def on_item_changed(self, model, item):
# ndc_rect should be part of the model, always
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Ignore other signals
if item != ndc_rect_item:
return
# Get the values
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertIsNotNone(ndc_rect)
# NDC rect cannot be none, but it can be empty (on mouse-up)
if ndc_rect != []:
# ndc_rect should be totally ordered: top-left, bottom-right
self.assertLess(ndc_rect[0], ndc_rect[2])
self.assertLess(ndc_rect[1], ndc_rect[3])
# Save the lat mouse for a test later
self.__last_rect = ndc_rect
def ndc_rects_match(self):
self.assertIsNotNone(self.__last_rect)
self.__ndc_rects.append(self.__last_rect)
self.__last_rect = None
if len(self.__ndc_rects) > 1:
self.assertEqual(self.__ndc_rects[0], self.__ndc_rects[-1])
async def test_ortho_selection(self):
window, scene_view = await self.create_ortho_scene_view('test_ortho_selection')
with scene_view.scene:
manipulator = SelectionManipulator()
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
async def test_persepctive_selection(self):
window, scene_view = await self.create_perspective_scene_view('test_persepctive_selection')
with scene_view.scene:
manipulator = SelectionManipulator({
'thickness': 5.0,
'color': (0.2, 0.2, 0.8, 0.8),
'inner_color': (0.2, 0.6, 0.8, 0.4)
})
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
| 5,588 | Python | 40.708955 | 132 | 0.635648 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/__init__.py | from .test_selection_model import TestSelectionModel
from .test_selection_manipulator import TestSelectionManipulator
| 118 | Python | 38.666654 | 64 | 0.881356 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_scene_ui_base.py | ## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from omni.ui.tests.test_base import OmniUiTest
from omni.ui.tests.compare_utils import capture_and_compare
from omni.kit.ui_test.input import emulate_mouse, emulate_mouse_slow_move, human_delay
from omni.kit.ui_test import Vec2
from omni.ui import scene as sc
import omni.ui as ui
import omni.appwindow
import omni.kit.app
import carb
from carb.input import MouseEventType
from pxr import Gf
from pathlib import Path
async def emulate_mouse_drag_and_drop(start_pos, end_pos, right_click=False, human_delay_speed: int = 4, end_with_up: bool = True):
"""Emulate Mouse Drag & Drop. Click at start position and slowly move to end position."""
await emulate_mouse(MouseEventType.MOVE, start_pos)
await emulate_mouse(MouseEventType.RIGHT_BUTTON_DOWN if right_click else MouseEventType.LEFT_BUTTON_DOWN)
await human_delay(human_delay_speed)
await emulate_mouse_slow_move(start_pos, end_pos, human_delay_speed=human_delay_speed)
if end_with_up:
await emulate_mouse(MouseEventType.RIGHT_BUTTON_UP if right_click else MouseEventType.LEFT_BUTTON_UP)
await human_delay(human_delay_speed)
def _flatten_matrix(matrix: Gf.Matrix4d):
return [matrix[0][0], matrix[0][1], matrix[0][2], matrix[0][3],
matrix[1][0], matrix[1][1], matrix[1][2], matrix[1][3],
matrix[2][0], matrix[2][1], matrix[2][2], matrix[2][3],
matrix[3][0], matrix[3][1], matrix[3][2], matrix[3][3]]
class TestOmniUiScene(OmniUiTest):
DATA_PATH = None
async def setUp(self, ext_id: str = None):
await super().setUp()
self.__width, self.__height = None, None
# If no extension-id, assume standard xxx.xxx.xxx.tests.current_test
if ext_id is None:
ext_id = '.'.join(self.__module__.split('.')[0:-2])
TestOmniUiScene.DATA_PATH = Path(carb.tokens.get_tokens_interface().resolve("${" + ext_id + "}")).absolute().resolve()
self.__golden_img_dir = TestOmniUiScene.DATA_PATH.joinpath("data", "tests")
# After running each test
async def tearDown(self):
self.__golden_img_dir = None
await super().tearDown()
async def setup_test_area_and_input(self, title: str, width: int = 256, height: int = 256):
self.__width, self.__height = width, height
await self.create_test_area(width=width, height=height)
app_window = omni.appwindow.get_default_app_window()
app_window.set_input_blocking_state(carb.input.DeviceType.MOUSE, False)
return ui.Window(title=title, width=width, height=height,
flags=ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_TITLE_BAR | ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE)
async def create_ortho_scene_view(self, title='test', width = 256, height = 256, ortho_size = 100, z_pos = -5):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.ortho_projection()
view = sc.Matrix44.get_translation_matrix(0, 0, z_pos)
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def create_perspective_scene_view(self, title='test', width = 256, height = 256, field_of_view = 25, distance = 100):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.perspective_projection(field_of_view)
eye = Gf.Vec3d(distance, distance, distance)
target = Gf.Vec3d(0, 0, 0)
forward = (target - eye).GetNormalized()
up = Gf.Vec3d(0, 0, 1).GetComplement(forward)
view = _flatten_matrix(Gf.Matrix4d().SetLookAt(eye, target, up))
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def finish_scene_ui_test(self, wait_frames = 15):
for _ in range(wait_frames):
await omni.kit.app.get_app().next_update_async()
return await self.finalize_test(golden_img_dir=self.__golden_img_dir)
def ortho_projection(self, ortho_size: float = 100, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
if aspect_ratio > 1:
ortho_half_height = ortho_size * 0.5
ortho_half_width = ortho_half_height * aspect_ratio
else:
ortho_half_width = ortho_size * 0.5
ortho_half_height = ortho_half_width * aspect_ratio
frustum = Gf.Frustum()
frustum.SetOrthographic(-ortho_half_width, ortho_half_width, -ortho_half_height, ortho_half_height, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
def perspective_projection(self, field_of_view: float = 20, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
frustum = Gf.Frustum()
frustum.SetPerspective(field_of_view / aspect_ratio, aspect_ratio, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
@property
def golden_img_dir(self):
return self.__golden_img_dir
@property
def human_delay(self):
return 4
async def wait_frames(self, frames: int = 15):
for _ in range(10):
await omni.kit.app.get_app().next_update_async()
async def end_mouse(self):
await emulate_mouse(MouseEventType.LEFT_BUTTON_UP)
await human_delay(self.human_delay)
async def mouse_dragging_test(self, test_name, start_pos, end_pos):
threshold = 10
start_pos = Vec2(start_pos[0], start_pos[1])
end_pos = Vec2(end_pos[0], end_pos[1])
# Do a drag operation
await emulate_mouse_drag_and_drop(start_pos, end_pos, human_delay_speed = self.human_delay, end_with_up=False)
# Capture while mouse is down
diff1 = await capture_and_compare(f'{test_name}_drag.png', threshold, self.golden_img_dir)
# End the drag
await self.end_mouse()
# And cature again with mouse up
diff2 = await capture_and_compare(f'{test_name}_done.png', threshold, self.golden_img_dir)
if diff1 != 0:
carb.log_warn(f"[{test_name}_drag.png] the generated image has difference {diff1}")
if diff2 != 0:
carb.log_warn(f"[{test_name}_done.png] the generated image has difference {diff2}")
self.assertTrue(
(diff1 is not None and diff1 < threshold),
msg=f"The image for test '{test_name}_drag.png' doesn't match the golden one. Difference of {diff1} is is not less than threshold of {threshold}.",
)
self.assertTrue(
(diff2 is not None and diff2 < threshold),
msg=f"The image for test '{test_name}_done.png' doesn't match the golden one. Difference of {diff2} is is not less than threshold of {threshold}.",
) | 7,634 | Python | 44.177515 | 159 | 0.653262 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_model.py | ## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
__all__ = ['TestSelectionModel']
import omni.kit.test
from ..model import SelectionShapeModel
class TestSelectionModel(omni.kit.test.AsyncTestCase):
async def test_ortho_selection(self):
model = SelectionShapeModel()
# Standard item should exist
ndc_start_item = model.get_item('ndc_start')
self.assertIsNotNone(ndc_start_item)
# Standard item should exist
ndc_current_item = model.get_item('ndc_current')
self.assertIsNotNone(ndc_current_item)
# Standard item should exist
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Test setting only a start result in no rect
model.set_floats(ndc_start_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 1, 2])
# Test setting a start and current results in a rect
model.set_floats(ndc_start_item, [1, 2])
model.set_floats(ndc_current_item, [3, 4])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
# Changing the order should result in the same sorted top-left, bottom-right rect
model.set_floats(ndc_start_item, [3, 4])
model.set_floats(ndc_current_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
| 1,847 | Python | 36.714285 | 89 | 0.674066 |
omniverse-code/kit/exts/omni.kit.manipulator.selection/docs/index.rst | omni.kit.manipulator.selection
###########################
Selection Shape/Box for omni.ui.scene
.. toctree::
:maxdepth: 1
README
CHANGELOG
.. automodule:: omni.kit.manipulator.selection
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
| 327 | reStructuredText | 15.399999 | 46 | 0.626911 |
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/__init__.py | from .tags_extension import TagsExtension
| 42 | Python | 20.49999 | 41 | 0.857143 |
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_extension.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .tags_delegate import TagsDelegate
from omni.kit.widget.filebrowser import ColumnDelegateRegistry
import omni.ext
import carb
class TagsExtension(omni.ext.IExt):
def on_startup(self, ext_id):
self._subscription = ColumnDelegateRegistry().register_column_delegate("Tags", TagsDelegate)
def on_shutdown(self):
self._subscription = None
| 799 | Python | 37.095236 | 100 | 0.783479 |
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_delegate.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from omni.kit.tagging import OmniKitTaggingDelegate, get_tagging_instance
from omni.kit.widget.filebrowser import ColumnItem
from omni.kit.widget.filebrowser import AbstractColumnDelegate
import asyncio
import carb
import functools
import omni.client
import omni.ui as ui
import traceback
def handle_exception(func):
"""
Decorator to print exception in async functions
"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except asyncio.CancelledError:
pass
except Exception as e:
carb.log_error(f"Exception when async '{func}'")
carb.log_error(f"{e}")
carb.log_error(f"{traceback.format_exc()}")
return wrapper
class TagsDelegate(AbstractColumnDelegate):
"""
The object that adds the new column "Access" to fileblowser. The columns
displays access flags.
"""
@property
def initial_width(self):
"""The width of the column"""
return ui.Pixel(40)
def build_header(self):
"""Build the header"""
ui.Label("Tags", style_type_name_override="TreeView.Header")
@handle_exception
async def build_widget(self, item: ColumnItem):
"""
Build the widget for the given item. Works inside Frame in async
mode. Once the widget is created, it will replace the content of the
frame. It allow to await something for a while and create the widget
when the result is available.
"""
tagging = get_tagging_instance()
if tagging is None:
carb.log_warn("Tagging client not found")
return
# sanitize relative item paths
path = item.path.replace("/./", "/")
results = await tagging.get_tags_async([path])
if results is None:
results = []
ordered_tags = tagging.ordered_tag_list(results)
tag_string = ", ".join(ordered_tags)
tooltip_string = "\n".join(ordered_tags)
ui.Label(tag_string, style_type_name_override="TreeView.Item", tooltip=tooltip_string)
| 2,560 | Python | 31.417721 | 94 | 0.666797 |
omniverse-code/kit/exts/omni.kit.property.layer/PACKAGE-LICENSES/omni.kit.property.layer-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. | 412 | Markdown | 57.999992 | 74 | 0.839806 |
omniverse-code/kit/exts/omni.kit.property.layer/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.1.4"
category = "Internal"
feature = true
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarly for displaying extension info in UI
title = "Layer Property Window Widgets"
description="Property Window widgets that displays Layer related information."
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["kit", "usd", "property", "Layer"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image displayed in extension manager
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
[dependencies]
"omni.kit.commands" = {}
"omni.usd" = {}
"omni.ui" = {}
"omni.client" = {}
"omni.kit.window.filepicker" = {}
"omni.kit.window.content_browser" = {}
"omni.kit.window.property" = {}
"omni.kit.widget.layers" = {}
"omni.kit.usd.layers" = {}
"omni.kit.widget.versioning" = { optional=true }
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.kit.property.layer"
[[test]]
args = ["--/app/file/ignoreUnsavedOnExit=true"]
| 1,468 | TOML | 28.979591 | 107 | 0.725477 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_models.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import asyncio
import omni.kit.commands
import omni.timeline
import omni.ui as ui
import omni.usd
import weakref
import omni.kit.widget.layers
from pxr import Usd, Sdf, UsdGeom, UsdPhysics
from omni.kit.widget.layers import LayerUtils
from .types import LayerMetaType
class LayerPathModel(ui.SimpleStringModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
if self._layer_item and self._layer_item():
self._identifier = self._layer_item().identifier
else:
self._identifier = None
def get_value_as_string(self):
return self._identifier
def set_value(self, value):
if value != self._identifier:
self._identifier = value
self._value_changed()
def begin_edit(self):
pass
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
value = self.get_value_as_string()
layer_item = self._layer_item()
if not layer_item.reserved:
sublayer_position = LayerUtils.get_sublayer_position_in_parent(
layer_item.parent.identifier, layer_item.identifier
)
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=layer_item.parent.identifier,
sublayer_position=sublayer_position,
new_layer_path=value,
)
# OM-76598: Delay frames until layer item is initialized.
async def focus_on_layer_item(path):
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layer_instance = omni.kit.widget.layers.get_instance()
layer_instance.set_current_focused_layer_item(path)
asyncio.ensure_future(focus_on_layer_item(value))
def replace_layer(self, value):
self.set_value(value)
self.end_edit()
def is_reserved_layer(self):
if not self._layer_item or not self._layer_item():
return True
return self._layer_item().reserved
def anonymous(self):
if not self._layer_item or not self._layer_item() or not self._layer_item().layer:
return True
return self._layer_item().anonymous
class LayerWorldAxisItem(ui.AbstractItem):
def __init__(self, text):
super().__init__()
self.model = ui.SimpleStringModel(text)
class LayerWorldAxisModel(ui.AbstractItemModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
self._items = [LayerWorldAxisItem(text) for text in [UsdGeom.Tokens.y, UsdGeom.Tokens.z]]
self._current_index = ui.SimpleIntModel()
self.on_value_changed()
self._current_index.add_value_changed_fn(self._current_index_changed)
def get_item_children(self, item):
return self._items
def get_item_value_model(self, item, column_id):
if item is None:
return self._current_index
return item.model
def _current_index_changed(self, model):
if not self._layer_item or not self._layer_item():
return
stage = Usd.Stage.Open(self._layer_item().layer)
index = model.as_int
if index == 0:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.y)
elif index == 1:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.z)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
self._item_changed(None)
def get_usd_token_name(self):
return UsdGeom.Tokens.upAxis
def on_value_changed(self):
if self._layer_item and self._layer_item():
layer = self._layer_item().layer
stage = Usd.Stage.Open(layer)
up_axis = UsdGeom.GetStageUpAxis(stage)
index = 0 if up_axis == UsdGeom.Tokens.y else 1
self._current_index.set_value(index)
class LayerMetaModel(ui.AbstractValueModel):
def __init__(self, layer_item: weakref, meta_type: LayerMetaType):
super().__init__()
self._layer_item = layer_item
self._meta_type = meta_type
self._value = self._get_value_as_string()
def get_value_as_string(self):
return self._value
def _get_value_as_string(self):
if not self._layer_item or not self._layer_item():
return None
layer = self._layer_item().layer
if not layer:
return None
if self._meta_type == LayerMetaType.COMMENT:
return str(layer.comment)
elif self._meta_type == LayerMetaType.DOC:
return str(layer.documentation)
elif self._meta_type == LayerMetaType.START_TIME:
return str(layer.startTimeCode)
elif self._meta_type == LayerMetaType.END_TIME:
return str(layer.endTimeCode)
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return str(layer.timeCodesPerSecond)
elif layer.HasFramesPerSecond() and self._meta_type == LayerMetaType.FPS_PER_SECOND:
return str(layer.framesPerSecond)
elif self._meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
return str(meters)
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
return str(kilograms)
elif (
self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_OFFSET
):
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.offset)
elif self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_SCALE:
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.scale)
return None
def set_value(self, value):
if value != self._value:
self._value = value
self._value_changed()
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
layer = self._layer_item().layer
if not layer:
return
if self._layer_item().parent:
parent_layer_identifier = self._layer_item().parent.identifier
else:
parent_layer_identifier = None
layer_identifier = layer.identifier
omni.kit.commands.execute(
"ModifyLayerMetadata",
layer_identifier=layer_identifier,
parent_layer_identifier=parent_layer_identifier,
meta_index=self._meta_type,
value=self._value,
)
def begin_edit(self):
pass
def get_usd_token_name(self):
if self._meta_type == LayerMetaType.COMMENT:
return Sdf.Layer.CommentKey
elif self._meta_type == LayerMetaType.DOC:
return Sdf.Layer.DocumentationKey
elif self._meta_type == LayerMetaType.START_TIME:
return Sdf.Layer.StartTimeCodeKey
elif self._meta_type == LayerMetaType.END_TIME:
return Sdf.Layer.EndTimeCodeKey
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return Sdf.Layer.TimeCodesPerSecondKey
elif self._meta_type == LayerMetaType.FPS_PER_SECOND:
return Sdf.Layer.FramesPerSecondKey
elif self._meta_type == LayerMetaType.UNITS:
return UsdGeom.Tokens.metersPerUnit
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
return UsdPhysics.Tokens.kilogramsPerUnit
elif self._meta_type == LayerMetaType.LAYER_OFFSET:
return "subLayerOffsets_offset" # USD has no python bindings for this key
elif self._meta_type == LayerMetaType.LAYER_SCALE:
return "subLayerOffsets_scale" # USD has no python bindings for this key
return ""
def on_value_changed(self):
self.set_value(self._get_value_as_string())
| 8,951 | Python | 35.390244 | 105 | 0.625517 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/widgets.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import carb
import omni.ext
import omni.kit.app
import omni.usd
import weakref
from pathlib import Path
from pxr import Sdf, UsdGeom
from typing import List
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
ICON_PATH = ""
_instance = None
def get_instance():
global _instance
return _instance
class LayerPropertyWidgets(omni.ext.IExt):
def __init__(self):
self._registered = False
self._examples = None
self._selection_notifiers = []
super().__init__()
def on_startup(self, ext_id):
global _instance
_instance = self
manager = omni.kit.app.get_app().get_extension_manager()
extension_path = manager.get_extension_path(ext_id)
global ICON_PATH
ICON_PATH = Path(extension_path).joinpath("data").joinpath("icons")
self._selection_notifiers.append(SelectionNotifier()) # default context
self._hooks = manager.subscribe_to_extension_enable(
lambda _: self._register_widget(),
lambda _: self._unregister_widget(),
ext_name="omni.kit.window.property",
hook_name="omni.kit.property.layer listener",
)
def on_shutdown(self):
global _instance
if _instance:
_instance = None
for notifier in self._selection_notifiers:
notifier.stop()
self._selection_notifiers.clear()
self._hooks = None
if self._registered:
self._unregister_widget()
def _register_widget(self):
try:
import omni.kit.window.property as p
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
w = p.get_window()
self._layer_path_widget = LayerPathWidget(ICON_PATH)
self._meta_widget = LayerMetaWiget(ICON_PATH)
if w:
w.register_widget("layers", "path", self._layer_path_widget)
w.register_widget("layers", "metadata", self._meta_widget)
for notifier in self._selection_notifiers:
notifier.start()
# notifier._notify_layer_selection_changed(None) # force a refresh
self._registered = True
except Exception as exc:
carb.log_warn(f"error {exc}")
def _unregister_widget(self):
try:
import omni.kit.window.property as p
w = p.get_window()
if w:
for notifier in self._selection_notifiers:
notifier.stop()
w.unregister_widget("layers", "metadata")
w.unregister_widget("layers", "path")
self._registered = False
if self._layer_path_widget:
self._layer_path_widget.destroy()
self._layer_path_widget = None
self._meta_widget = None
except Exception as e:
carb.log_warn(f"Unable to unregister omni.kit.property.layer.widgets: {e}")
class SelectionNotifier:
def __init__(self, property_window_context_id=""):
self._property_window_context_id = property_window_context_id
def start(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.add_layer_selection_changed_fn(self._notify_layer_selection_changed)
def get_layers_widget(self):
return omni.kit.widget.layers.get_instance()
def stop(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.remove_layer_selection_changed_fn(self._notify_layer_selection_changed)
def _notify_layer_selection_changed(self, item):
import omni.kit.window.property as p
# TODO _property_window_context_id
w = p.get_window()
if w and self.get_layers_widget():
layer_item = self.get_layers_widget().get_current_focused_layer_item()
if layer_item:
w.notify("layers", weakref.ref(layer_item))
else:
w.notify("layers", None)
| 4,491 | Python | 32.522388 | 97 | 0.616566 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/commands.py | import weakref
import carb
import omni.kit.commands
from pxr import Sdf, Usd, UsdGeom, UsdPhysics
from .types import LayerMetaType
from omni.kit.widget.layers import LayerUtils
class ModifyStageAxisCommand(omni.kit.commands.Command):
"""Modify stage up axis undoable **Command**."""
def __init__(self, stage, axis):
if stage:
self._stage = weakref.ref(stage)
else:
self._stage = None
self._new_axis = axis
self._old_axis = None
def do(self):
if self._stage and self._stage():
self._old_axis = UsdGeom.GetStageUpAxis(self._stage())
UsdGeom.SetStageUpAxis(self._stage(), self._new_axis)
def undo(self):
if self._stage and self._stage() and self._old_axis:
UsdGeom.SetStageUpAxis(self._stage(), self._old_axis)
class ModifyLayerMetadataCommand(omni.kit.commands.Command):
"""Modify layer metadata undoable **Command**."""
def __init__(self, layer_identifier, parent_layer_identifier, meta_index, value):
"""Constructor.
Keyword Arguments:
layer_identifier (str): Layer identifier to operate.
parent_identifier (str): Parent identifier that layer_identifier resides in as sublayer.
It's None if it's root layer.
meta_index (omni.kit.property.layer.types.LayerMetaType): Metadata type.
"""
super().__init__()
self._layer_identifer = layer_identifier
self._parent_layer_identifier = parent_layer_identifier
self._meta_index = meta_index
self._new_value = value
self._old_value = None
def _set_value(self, meta_type, value):
layer = Sdf.Find(self._layer_identifer)
if not layer:
return
if self._parent_layer_identifier:
parent_layer = Sdf.Find(self._parent_layer_identifier)
else:
parent_layer = None
try:
if meta_type == LayerMetaType.COMMENT:
self._old_value = layer.comment
layer.comment = str(value)
elif meta_type == LayerMetaType.DOC:
self._old_value = layer.documentation
layer.documentation = str(value)
elif meta_type == LayerMetaType.START_TIME:
self._old_value = layer.startTimeCode
layer.startTimeCode = float(value)
elif meta_type == LayerMetaType.END_TIME:
self._old_value = layer.endTimeCode
layer.endTimeCode = float(value)
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self._old_value = layer.timeCodesPerSecond
layer.timeCodesPerSecond = float(value)
elif meta_type == LayerMetaType.FPS_PER_SECOND:
self._old_value = layer.framesPerSecond
layer.framesPerSecond = float(value)
elif meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
self._old_value = meters
UsdGeom.SetStageMetersPerUnit(stage, float(value))
elif meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self._old_value = kilograms
UsdPhysics.SetStageKilogramsPerUnit(stage, float(value))
elif parent_layer and meta_type == LayerMetaType.LAYER_OFFSET:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.offset
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(float(value), offset.scale)
elif parent_layer and meta_type == LayerMetaType.LAYER_SCALE:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.scale
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(offset.offset, float(value))
except Exception as e:
pass
def do(self):
self._set_value(self._meta_index, self._new_value)
def undo(self):
self._set_value(self._meta_index, self._old_value)
| 4,624 | Python | 40.294642 | 104 | 0.60359 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_widgets.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import os
import carb
import omni.client
import omni.kit.window.content_browser as content
import omni.ui as ui
import omni.usd
from omni.kit.usd.layers import get_layers, LayerEventType, get_layer_event_payload
from omni.kit.window.property.templates import HORIZONTAL_SPACING, LABEL_HEIGHT, LABEL_WIDTH, SimplePropertyWidget
from .file_picker import FileBrowserSelectionType, FilePicker
from .layer_property_models import LayerMetaModel, LayerPathModel, LayerWorldAxisModel
from .types import LayerMetaName, LayerMetaType
class LayerPathWidget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Path", collapsed=False)
self._icon_path = icon_path
self._file_picker = None
self._layer_path_field = False
self._layer_path_model = None
def destroy(self):
if self._file_picker:
self._file_picker.destroy()
def _show_file_picker(self):
if not self._file_picker:
self._file_picker = FilePicker(
"Select File",
"Select",
FileBrowserSelectionType.FILE_ONLY,
[(omni.usd.writable_usd_re(),
omni.usd.writable_usd_files_desc())],
)
self._file_picker.set_custom_fn(self._on_file_selected, None)
if self._layer_path_field:
value = self._layer_path_field.model.get_value_as_string()
current_dir = os.path.dirname(value)
self._file_picker.set_current_directory(current_dir)
self._file_picker.show_dialog()
def _on_file_selected(self, path):
self._layer_path_field.model.replace_layer(path)
def on_new_payload(self, payload):
if not super().on_new_payload(payload, ignore_large_selection=True):
return False
return payload is not None
def build_items(self):
layer_item = self._payload
if layer_item and layer_item():
with ui.VStack(height=0, spacing=5):
with ui.HStack():
self._layer_path_model = LayerPathModel(layer_item)
if self._layer_path_model.is_reserved_layer():
read_only = True
else:
read_only = False
self._layer_path_field = ui.StringField(
name="models", model=self._layer_path_model, read_only=read_only
)
if layer_item().missing:
self._layer_path_field.set_style({"color" : 0xFF6F72FF})
style = {"image_url": str(self._icon_path.joinpath("small_folder.png"))}
if not read_only:
ui.Spacer(width=3)
open_button = ui.Button(style=style, width=20, tooltip="Open")
open_button.set_clicked_fn(self._show_file_picker)
if not self._layer_path_model.anonymous():
ui.Spacer(width=3)
style["image_url"] = str(self._icon_path.joinpath("find.png"))
find_button = ui.Button(style=style, width=20, tooltip="Find")
def find_button_fn():
path = self._layer_path_field.model.get_value_as_string()
# Remove checkpoint and branch so navigate_to works
client_url = omni.client.break_url(path)
path = omni.client.make_url(
scheme=client_url.scheme,
user=client_url.user,
host=client_url.host,
port=client_url.port,
path=client_url.path,
query=None,
fragment=client_url.fragment,
)
content.get_content_window().navigate_to(path)
find_button.set_clicked_fn(find_button_fn)
if not self._layer_path_model.anonymous():
if self._filter.matches("Checkpoint"):
self._build_checkpoint_ui(layer_item().identifier)
self._any_item_visible = True
else:
selected_info_name = "(nothing selected)"
ui.StringField(name="layer_path", height=LABEL_HEIGHT, enabled=False).model.set_value(selected_info_name)
def _build_checkpoint_ui(self, absolute_layer_path):
try:
# Use checkpoint widget in the drop down menu for more detailed information
from omni.kit.widget.versioning.checkpoint_combobox import CheckpointCombobox
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("Checkpoint")
def on_selection_changed(selection):
if selection:
self._layer_path_model.replace_layer(selection.get_full_url())
self._checkpoint_combobox = CheckpointCombobox(absolute_layer_path, on_selection_changed)
return None
except ImportError as e:
# If the widget is not available, create a simple combo box instead
carb.log_warn(f"Checkpoint widget in Layer Path widget is not availbale due to: {e}")
class LayerMetaWiget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Metadata", collapsed=False)
self._icon_path = icon_path
self._models = {}
self._meta_change_listener = None
def on_new_payload(self, payload):
if not super().on_new_payload(payload):
return False
return payload is not None
def reset(self):
super().reset()
self._meta_change_listener = None
self._models = {}
def _on_meta_changed(self, event: carb.events.IEvent):
payload = get_layer_event_payload(event)
if payload and payload.event_type == LayerEventType.INFO_CHANGED:
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
layer_item = layer_item()
if layer_item.identifier in payload.layer_info_data:
info_tokens = payload.layer_info_data.get(layer_item.identifier, [])
for token in info_tokens:
model = self._models.get(token, None)
if model:
model.on_value_changed()
def build_items(self):
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
usd_context = layer_item().usd_context
layers = get_layers(usd_context)
event_stream = layers.get_event_stream()
self._meta_change_listener = event_stream.create_subscription_to_pop(self._on_meta_changed, name="Layers Property Window")
model = LayerWorldAxisModel(layer_item)
self._models[model.get_usd_token_name()] = model
if self._filter.matches("World Axis"):
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("World Axis")
ui.ComboBox(model, name="choices")
self._any_item_visible = True
for index in range(LayerMetaType.NUM_PROPERTIES):
model = LayerMetaModel(layer_item, index)
if model.get_value_as_string() is not None:
self.add_item_with_model(LayerMetaName[index], model, True)
self._models[model.get_usd_token_name()] = model
| 8,143 | Python | 42.784946 | 134 | 0.571779 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/__init__.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .widgets import LayerPropertyWidgets, get_instance
from .commands import ModifyStageAxisCommand, ModifyLayerMetadataCommand
| 563 | Python | 45.999996 | 76 | 0.824156 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/file_picker.py | import asyncio
import os
import re
import psutil
import carb
import omni.ui
import omni.client
from typing import Callable, Iterable, Tuple, Union
from omni.kit.window.filepicker import FilePickerDialog
from omni.kit.widget.filebrowser import FileBrowserItem
class FileBrowserSelectionType:
FILE_ONLY = 0
DIRECTORY_ONLY = 1
ALL = 2
class FilePicker:
"""
Args:
title (str): Title of the window.
apply_button_name (str): Name of the confirm button.
selection_type (FileBrowserSelectionType): The file type that confirm event will respond to.
item_filter_options (Iterable[Tuple[Union[re.Pattern, str], str]]):
Array of filter options. Element of array is a tuple that first
element of this tuple is the regex for filtering (string or compiled
re.Pattern), and second element of this tuple is the descriptions,
like (".*", "All Files"). By default, it will list all files.
"""
def __init__(
self,
title: str,
apply_button_name: str,
selection_type: FileBrowserSelectionType = FileBrowserSelectionType.ALL,
item_filter_options: Iterable[Tuple[Union[re.Pattern, str], str]] = ((
re.compile(".*"), "All Files (*.*)")),
):
self._title = title
self._filepicker = None
self._selection_type = selection_type
self._custom_select_fn = None
self._custom_cancel_fn = None
self._apply_button_name = apply_button_name
self._filter_regexes = []
self._filter_descriptions = []
self._current_directory = None
for regex, desc in item_filter_options:
if not isinstance(regex, re.Pattern):
regex = re.compile(regex, re.IGNORECASE)
self._filter_regexes.append(regex)
self._filter_descriptions.append(desc)
self._build_ui()
def destroy(self):
self.set_custom_fn(None, None)
if self._filepicker:
self._filepicker.destroy()
def set_custom_fn(self, select_fn, cancel_fn):
self._custom_select_fn = select_fn
self._custom_cancel_fn = cancel_fn
def show_dialog(self):
self._filepicker.show(self._current_directory)
self._current_directory = None
def hide_dialog(self):
self._filepicker.hide()
def set_current_directory(self, dir: str):
self._current_directory = dir
def set_current_filename(self, filename: str):
self._filepicker.set_filename(filename)
def _build_ui(self):
on_click_open = lambda f, d: asyncio.ensure_future(self._on_click_open(f, d))
on_click_cancel = lambda f, d: asyncio.ensure_future(self._on_click_cancel(f, d))
# Create the dialog
self._filepicker = FilePickerDialog(
self._title,
allow_multi_selection=False,
apply_button_label=self._apply_button_name,
click_apply_handler=on_click_open,
click_cancel_handler=on_click_cancel,
item_filter_options=self._filter_descriptions,
item_filter_fn=lambda item: self._on_filter_item(item),
error_handler=lambda m: self._on_error(m),
)
# Start off hidden
self.hide_dialog()
def _on_filter_item(self, item: FileBrowserItem) -> bool:
if not item or item.is_folder:
return True
if self._filepicker.current_filter_option >= len(self._filter_regexes):
return False
regex = self._filter_regexes[self._filepicker.current_filter_option]
if regex.match(item.path):
return True
else:
return False
def _on_error(self, msg: str):
"""
Demonstrates error handling. Instead of just printing to the shell, the App can
display the error message to a console window.
"""
print(msg)
async def _on_click_open(self, filename: str, dirname: str):
"""
The meat of the App is done in this callback when the user clicks 'Accept'. This is
a potentially costly operation so we implement it as an async operation. The inputs
are the filename and directory name. Together they form the fullpath to the selected
file.
"""
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
result, entry = omni.client.stat(fullpath)
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
is_folder = False
if (is_folder and self._selection_type == FileBrowserSelectionType.FILE_ONLY) or (
not is_folder and self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY
):
return
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_select_fn:
self._custom_select_fn(fullpath)
async def _on_click_cancel(self, filename: str, dirname: str):
"""
This function is called when the user clicks 'Cancel'.
"""
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_cancel_fn:
self._custom_cancel_fn()
| 5,381 | Python | 33.72258 | 101 | 0.614012 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/types.py | class LayerMetaType:
START_TIME = 0
END_TIME = 1
TIMECODES_PER_SECOND = 2
FPS_PER_SECOND = 3
UNITS = 4
LAYER_OFFSET = 5
LAYER_SCALE = 6
KG_PER_UNIT = 7
COMMENT = 8
DOC = 9
NUM_PROPERTIES = 10
LayerMetaName = [
"Start Time Code",
"End Time Code",
"Time Codes Per Second",
"Frames Per Second",
"Meters Per Unit",
"Layer Offset",
"Layer Scale",
"Kgs Per Unit",
"Comment",
"Documentation"
]
| 473 | Python | 16.555555 | 28 | 0.566596 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/test_property_window.py | ## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import tempfile
import os
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.ui as ui
import omni.kit.widget.layers as layers_widget
import omni.kit.property.layer as layers_property
from omni.kit.property.layer.layer_property_models import LayerMetaModel, LayerWorldAxisModel
from omni.kit.property.layer.types import LayerMetaType
from omni.ui.tests.test_base import OmniUiTest
from pxr import Kind, Sdf, Gf, UsdGeom, UsdPhysics
class TestLayerPropertyUI(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._usd_context = omni.usd.get_context()
await self._usd_context.new_stage_async()
# After running each test
async def tearDown(self):
await self._usd_context.close_stage_async()
await super().tearDown()
async def wait_for_update(self, usd_context=omni.usd.get_context(), wait_frames=10):
max_loops = 0
while max_loops < wait_frames:
_, files_loaded, total_files = usd_context.get_stage_loading_status()
await omni.kit.app.get_app().next_update_async()
if files_loaded or total_files:
continue
max_loops = max_loops + 1
async def test_layer_replacement(self):
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
sublayer = Sdf.Layer.CreateAnonymous()
sublayer_replace = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
missing_identifier = "non_existed_sublayer_identifier.usd"
root_layer.subLayerPaths.append(missing_identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
omni.kit.undo.undo()
self.assertTrue(root_layer.subLayerPaths[0], sublayer.identifier)
# Focus and replace missing layer
layers_widget.get_instance().set_current_focused_layer_item(missing_identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item and focused_item.missing)
self.assertEqual(focused_item.identifier, missing_identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
async def test_commands(self):
test_comment = "test comment"
test_doc = "test document"
test_start_time = "0.0"
test_end_time = "96.0"
test_timecodes_per_second = "24.0"
test_fps_per_second = "24.0"
test_units = "10.0"
test_kg_per_units = "10.0"
test_layer_offset = "1.0"
test_layer_scale = "10.0"
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
layers_widget.get_instance().set_current_focused_layer_item(root_layer.identifier)
await self.wait_for_update()
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
old_up_index = new_up_index = None
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.COMMENT:
new_value = test_comment
elif model._meta_type == LayerMetaType.DOC:
new_value = test_doc
elif model._meta_type == LayerMetaType.START_TIME:
new_value = test_start_time
elif model._meta_type == LayerMetaType.END_TIME:
new_value = test_end_time
elif model._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
new_value = test_timecodes_per_second
elif model._meta_type == LayerMetaType.UNITS:
new_value = test_units
elif model._meta_type == LayerMetaType.KG_PER_UNIT:
new_value = test_kg_per_units
elif model._meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
new_value = test_fps_per_second
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
elif isinstance(model, LayerWorldAxisModel):
old_up_index = model._current_index.get_value_as_int()
if old_up_index == 0: # up_axis is UsdGeom.Tokens.y
new_up_index = 1
else: # up_axis is UsdGeom.Tokens.z
new_up_index = 0
model._current_index.set_value(new_up_index)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
if meta_type == LayerMetaType.COMMENT:
self.assertEqual(test_comment, str(root_layer.comment))
elif meta_type == LayerMetaType.DOC:
self.assertEqual(test_doc, str(root_layer.documentation))
elif meta_type == LayerMetaType.START_TIME:
self.assertEqual(test_start_time, str(root_layer.startTimeCode))
elif meta_type == LayerMetaType.END_TIME:
self.assertEqual(test_end_time, str(root_layer.endTimeCode))
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self.assertEqual(test_timecodes_per_second, str(root_layer.timeCodesPerSecond))
elif meta_type == LayerMetaType.UNITS:
meters = UsdGeom.GetStageMetersPerUnit(stage)
self.assertEqual(test_units, str(meters))
elif meta_type == LayerMetaType.KG_PER_UNIT:
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self.assertEqual(test_kg_per_units, str(kilograms))
elif meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
self.assertEqual(test_fps_per_second, str(root_layer.framesPerSecond))
if new_up_index is not None:
up_axis = UsdGeom.GetStageUpAxis(stage)
if new_up_index == 0:
self.assertEqual(up_axis, UsdGeom.Tokens.y)
elif new_up_index == 1:
self.assertEqual(up_axis, UsdGeom.Tokens.z)
# Testing metadata for sublayers
sublayer = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.LAYER_OFFSET and model._layer_item().parent:
new_value = test_layer_offset
elif model._meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
new_value = test_layer_scale
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
parent = model._layer_item().parent
layer = model._layer_item().layer
layer_index = layers_widget.LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
if meta_type == LayerMetaType.LAYER_OFFSET:
self.assertEqual(test_layer_offset, str(offset.offset))
elif meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
self.assertEqual(test_layer_scale, str(offset.scale))
async def test_shut_down(self):
manager = omni.kit.app.get_app().get_extension_manager()
ext_id = "omni.kit.property.layer"
self.assertTrue(ext_id)
self.assertTrue(manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, False)
await self.wait_for_update()
self.assertTrue(not manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, True)
await self.wait_for_update()
self.assertTrue(manager.is_extension_enabled(ext_id))
| 11,459 | Python | 44.296443 | 119 | 0.632516 |
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/__init__.py | from .test_property_window import * | 35 | Python | 34.999965 | 35 | 0.8 |
omniverse-code/kit/exts/omni.kit.property.layer/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.1.4] - 2023-01-17
### Changes
- Delay frames until layer item is initialized after replacing.
## [1.1.3] - 2022-03-31
### Changes
- Integrate new omni.kit.usd.layers interfaces to replace layers interfaces from omni.usd.
## [1.1.2] - 2021-06-11
### Fixes
- Fix regression to replace missing layer.
## [1.1.1] - 2021-04-23
### Changes
- Disabled large selection optimization
## [1.1.0] - 2021-03-25
### Added
- Added checkpoint dropdown to Layer Path Widget. Requires `omni.kit.widget.versioning` to be enabled.
## [1.0.1] - 2020-12-09
### Changes
- Added extension icon
- Updated preview image
## [1.0.0] - 2020-10-07
### Added
- Layer Widgets Released.
| 763 | Markdown | 21.470588 | 102 | 0.682831 |
omniverse-code/kit/exts/omni.kit.property.layer/docs/index.rst | omni.kit.property.layer
###########################
Layer Property Window Widgets
.. toctree::
:maxdepth: 1
CHANGELOG
| 131 | reStructuredText | 8.428571 | 29 | 0.541985 |
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnImportUSDPrim.rst | .. _omni_graph_ImportUSDPrim_1:
.. _omni_graph_ImportUSDPrim:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: import USD prim data
:keywords: lang-en omnigraph node graph import-u-s-d-prim
import USD prim data
====================
.. <description>
Imports data from a USD prim into attributes in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:applySkelBinding", "``bool``", "If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:applyTransform", "``bool``", "If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node.", "False"
"", "*displayGroup*", "parameters", ""
"Attributes To Import (*inputs:attrNamesToImport*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be imported or empty to import all attributes.", ""
"", "*displayGroup*", "parameters", ""
"inputs:computeBoundingBox", "``bool``", "Compute and store local bounding box of a prim and its children.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:importAttributes", "``bool``", "Import attribute data from the USD prim.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPath", "``bool``", "Record the input USD prim's path into the output bundle in an attribute named ""primPath"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPrimvarMetadata", "``bool``", "Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTime", "``bool``", "Record the usdTimecode above into the output bundle in an attribute named ""primTime"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTransform", "``bool``", "Record the transform required to take any attributes of the input USD prim into the space of this node, i.e. the world transform of the input prim times the inverse world transform of this node, into the output bundle in an attribute named ""transform"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importType", "``bool``", "Deprecated, prim type is always imported", "True"
"", "*hidden*", "true", ""
"", "*displayGroup*", "parameters", ""
"Attributes To Rename (*inputs:inputAttrNames*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be renamed", ""
"inputs:keepPrimsSeparate", "``bool``", "Prefix output attribute names with ""prim"" followed by a unique number and a colon, to keep the attributes for separate input prims separate. The prim paths will be in the ""primPaths"" token array attribute.", "True"
"", "*displayGroup*", "parameters", ""
"New Attribute Names (*inputs:outputAttrNames*)", "``token``", "Comma or space separated text, listing the new names for the attributes listed in inputAttrNames", ""
"inputs:prim", "``bundle``", "The USD prim from which to import data.", "None"
"inputs:renameAttributes", "``bool``", "If true, attributes listed in ""inputAttrNames"" will be imported to attributes with the names specified in ""outputAttrNames"".", "False"
"", "*displayGroup*", "parameters", ""
"inputs:timeVaryingAttributes", "``bool``", "Check whether the USD attributes are time-varying and if so, import their data at the time ""usdTimecode"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usdTimecode", "``double``", "The time at which to evaluate the transform of the USD prim.", "0"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the imported data.", "None"
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"state:prevApplySkelBinding", "``bool``", "Value of ""applySkelBinding"" input from previous run", "None"
"state:prevApplyTransform", "``bool``", "Value of ""applyTransform"" input from previous run", "None"
"state:prevAttrNamesToImport", "``token``", "Value of ""attrNamesToImport"" input from previous run", "None"
"state:prevComputeBoundingBox", "``bool``", "Value of ""computeBoundingBox"" input from previous run", "None"
"state:prevImportAttributes", "``bool``", "Value of ""importAttributes"" input from previous run", "None"
"state:prevImportPath", "``bool``", "Value of ""importPath"" input from previous run", "None"
"state:prevImportPrimvarMetadata", "``bool``", "Value of ""importPrimvarMetadata"" input from previous run", "None"
"state:prevImportTime", "``bool``", "Value of ""importTime"" input from previous run", "None"
"state:prevImportTransform", "``bool``", "Value of ""importTransform"" input from previous run", "None"
"state:prevImportType", "``bool``", "Value of ""importType"" input from previous run", "None"
"state:prevInputAttrNames", "``token``", "Value of ""inputAttrNames"" input from previous run", "None"
"state:prevInvNodeTransform", "``matrixd[4]``", "Inverse transform of the node prim from the previous run.", "None"
"state:prevKeepPrimsSeparate", "``bool``", "Value of ""keepPrimsSeparate"" input from previous run", "None"
"state:prevOnlyImportSpecified", "``bool``", "Value of ""onlyImportSpecified"" input from previous run", "None"
"state:prevOutputAttrNames", "``token``", "Value of ""outputAttrNames"" input from previous run", "None"
"state:prevPaths", "``token[]``", "Array of paths from the previous run.", "None"
"state:prevRenameAttributes", "``bool``", "Value of ""renameAttributes"" input from previous run", "None"
"state:prevTimeVaryingAttributes", "``bool``", "Value of ""timeVaryingAttributes"" input from previous run", "None"
"state:prevTransforms", "``matrixd[4][]``", "Array of transforms from the previous run.", "None"
"state:prevUsdTimecode", "``double``", "Value of ""usdTimecode"" input from previous run", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ImportUSDPrim"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.ImportUSDPrim.svg"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "import USD prim data"
"Generated Class Name", "OgnImportUSDPrimDatabase"
"Python Module", "omni.graph.io"
| 7,139 | reStructuredText | 55.220472 | 308 | 0.650791 |
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnTransformBundle.rst | .. _omni_graph_TransformBundle_1:
.. _omni_graph_TransformBundle:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: transform bundle
:keywords: lang-en omnigraph node graph transform-bundle
transform bundle
================
.. <description>
Applies a transform to an input bundle, storing the result in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:input", "``bundle``", "Input bundle containing the attributes to be transformed.", "None"
"inputs:transform", "``matrixd[4]``", "The transform to apply to the bundle", "[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the transformed attributes", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.TransformBundle"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.TransformBundle.svg"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "transform bundle"
"Generated Class Name", "OgnTransformBundleDatabase"
"Python Module", "omni.graph.io"
| 1,825 | reStructuredText | 25.085714 | 172 | 0.563288 |
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnBundleToUSDA.rst | .. _omni_graph_BundleToUSDA_1:
.. _omni_graph_BundleToUSDA:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Bundle to usda text
:keywords: lang-en omnigraph node threadsafe graph bundle-to-u-s-d-a
Bundle to usda text
===================
.. <description>
Outputs a represention of the content of a bundle as usda text
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:bundle", "``bundle``", "The bundle to convert to usda text.", "None"
"inputs:outputAncestors", "``bool``", "If usePath is true and this is also true, ancestor ""primPath"" entries will be output.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:outputValues", "``bool``", "If true, the values of attributes will be output, else values will be omitted.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimPath", "``bool``", "Use the attribute named ""primPath"" for the usda prim path.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimType", "``bool``", "Use the attribute named ""primType"" for the usda prim type name.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usePrimvarMetadata", "``bool``", "Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text.", "True"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:text", "``token``", "Output usda text representing the bundle contents.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.BundleToUSDA"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.BundleToUSDA.svg"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Bundle to usda text"
"Generated Class Name", "OgnBundleToUSDADatabase"
"Python Module", "omni.graph.io"
| 2,470 | reStructuredText | 30.679487 | 192 | 0.591498 |
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnExportUSDPrim.rst | .. _omni_graph_ExportUSDPrim_1:
.. _omni_graph_ExportUSDPrim:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: export USD prim data
:keywords: lang-en omnigraph node WriteOnly graph export-u-s-d-prim
export USD prim data
====================
.. <description>
Exports data from an input bundle into a USD prim
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:applyTransform", "``bool``", "If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim.", "False"
"", "*displayGroup*", "parameters", ""
"Attributes To Export (*inputs:attrNamesToExport*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be exported or empty to import all attributes.", ""
"", "*displayGroup*", "parameters", ""
"inputs:bundle", "``bundle``", "The bundle from which data should be exported.", "None"
"Attributes To Exclude (*inputs:excludedAttrNames*)", "``token``", "Attributes to be excluded from being exported", ""
"Export to Root Layer (*inputs:exportToRootLayer*)", "``bool``", "If true, prims are exported in the root layer, otherwise the layer specified by ""layerName"" is used.", "True"
"Attributes To Rename (*inputs:inputAttrNames*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be renamed", ""
"Layer Name (*inputs:layerName*)", "``token``", "Identifier of the layer to export to if ""exportToRootLayer"" is false, or leave this blank to export to the session layer", ""
"inputs:onlyExportToExisting", "``bool``", "If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.", "False"
"", "*displayGroup*", "parameters", ""
"New Attribute Names (*inputs:outputAttrNames*)", "``token``", "Comma or space separated text, listing the new names for the attributes listed in inputAttrNames", ""
"inputs:primPathFromBundle", "``bool``", "When true, if there is a ""primPath"" token attribute inside the bundle, that will be the path of the USD prim to write to, else the ""outputs:prim"" attribute below will be used for the USD prim path.", "False"
"", "*displayGroup*", "parameters", ""
"Export to Root Layer (*inputs:removeMissingAttrs*)", "``bool``", "If true, any attributes on the USD prim(s) being written to, that aren't in the input data, will be removed from the USD prim(s).", "False"
"inputs:renameAttributes", "``bool``", "If true, attributes listed in ""inputAttrNames"" will be exported to attributes with the names specified in ""outputAttrNames"". Note: to avoid potential issues with redundant attributes being created while typing, keep this off until after specifying all input and output attribute names.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:timeVaryingAttributes", "``bool``", "Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time ""usdTimecode"".", "False"
"", "*displayGroup*", "parameters", ""
"inputs:usdTimecode", "``double``", "The time at which to evaluate the transform of the USD prim for applyTransform.", "0"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:prim", "``bundle``", "The USD prim(s) to which data should be exported if primPathFromBundle is false or if the bundle doesn't have a ""primPath"" token attribute. Note: this is really an input, since the node just receives the path to the prim. The node does not contain the prim.", "None"
"", "*hidden*", "true", ""
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"state:prevApplyTransform", "``bool``", "Value of ""applyTransform"" input from previous run", "None"
"state:prevAttrNamesToExport", "``token``", "Value of ""attrNamesToExport"" input from previous run", "None"
"state:prevBundleDirtyID", "``uint64``", "Dirty ID of input bundle from previous run", "None"
"state:prevExcludedAttrNames", "``token``", "Value of ""excludedAttrNames"" input from previous run", "None"
"state:prevExportToRootLayer", "``bool``", "Value of ""exportToRootLayer"" input from previous run", "None"
"state:prevInputAttrNames", "``token``", "Value of ""inputAttrNames"" input from previous run", "None"
"state:prevLayerName", "``token``", "Value of ""layerName"" input from previous run", "None"
"state:prevOnlyExportToExisting", "``bool``", "Value of ""onlyExportToExisting"" input from previous run", "None"
"state:prevOutputAttrNames", "``token``", "Value of ""outputAttrNames"" input from previous run", "None"
"state:prevPrimDirtyIDs", "``uint64[]``", "Dirty IDs of input prims from previous run", "None"
"state:prevPrimPathFromBundle", "``bool``", "Value of ""primPathFromBundle"" input from previous run", "None"
"state:prevRemoveMissingAttrs", "``bool``", "Value of ""removeMissingAttrs"" input from previous run", "None"
"state:prevRenameAttributes", "``bool``", "Value of ""renameAttributes"" input from previous run", "None"
"state:prevTimeVaryingAttributes", "``bool``", "Value of ""timeVaryingAttributes"" input from previous run", "None"
"state:prevUsdTimecode", "``double``", "Value of ""usdTimecode"" input from previous run", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ExportUSDPrim"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.ExportUSDPrim.svg"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "export USD prim data"
"__tokens", "{""primPath"": ""primPath"", ""primType"": ""primType"", ""primTime"": ""primTime"", ""primCount"": ""primCount"", ""transform"": ""transform""}"
"Generated Class Name", "OgnExportUSDPrimDatabase"
"Python Module", "omni.graph.io"
| 6,578 | reStructuredText | 57.221238 | 345 | 0.657799 |
omniverse-code/kit/exts/omni.graph.io/PACKAGE-LICENSES/omni.graph.io-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. | 412 | Markdown | 57.999992 | 74 | 0.839806 |
omniverse-code/kit/exts/omni.graph.io/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.2.5"
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarily for displaying extension info in UI
title = "OmniGraph IO"
description="Input/output node types for OmniGraph"
# Path (relative to the root) or content of readme markdown file for UI.
readme = "docs/README.md"
# URL of the extension source repository.
repository = ""
# One of categories for UI.
category = "Graph"
# Keywords for the extension
keywords = ["graph, input, output, io"]
# Location of change log file in target (final) folder of extension, relative to the root. Can also be just a content
# of it instead of file path. More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file).
# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
# Main module for the Python interface
[[python.module]]
name = "omni.graph.io"
# Additional module used to make .ogn test files auto-discoverable
[[python.module]]
name = "omni.graph.io.ogn.tests"
# Watch the .ogn files for hot reloading (only works for Python files)
[fswatcher.patterns]
include = ["*.ogn", "*.py"]
exclude = ["Ogn*Database.py"]
# Extensions required to load before this one
[dependencies]
"omni.graph" = {}
"omni.graph.ui" = {optional = true}
"omni.usd" = {}
[[native.plugin]]
path = "bin/*.plugin"
recursive = false
[[test]]
# RTX regression OM-51983
timeout = 600
dependencies = [
"omni.graph.ui" #force load dependency to test the functionality
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
| 1,994 | TOML | 26.708333 | 118 | 0.728185 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/__init__.py | """There is no public API to this module."""
__all__ = []
| 58 | Python | 18.66666 | 44 | 0.568966 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnBundleToUSDADatabase.py | """Support for simplified access to data on nodes of type omni.graph.BundleToUSDA
Outputs a represention of the content of a bundle as usda text
"""
import carb
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnBundleToUSDADatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.BundleToUSDA
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.bundle
inputs.outputAncestors
inputs.outputValues
inputs.usePrimPath
inputs.usePrimType
inputs.usePrimvarMetadata
Outputs:
outputs.text
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:bundle', 'bundle', 0, None, 'The bundle to convert to usda text.', {}, True, None, False, ''),
('inputs:outputAncestors', 'bool', 0, None, 'If usePath is true and this is also true, ancestor "primPath" entries will be output.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:outputValues', 'bool', 0, None, 'If true, the values of attributes will be output, else values will be omitted.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimPath', 'bool', 0, None, 'Use the attribute named "primPath" for the usda prim path.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimType', 'bool', 0, None, 'Use the attribute named "primType" for the usda prim type name.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usePrimvarMetadata', 'bool', 0, None, 'Identify attributes representing metadata like the interpolation type for primvars, and include them as usda metadata in the output text.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('outputs:text', 'token', 0, None, 'Output usda text representing the bundle contents.', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
@property
def outputAncestors(self):
data_view = og.AttributeValueHelper(self._attributes.outputAncestors)
return data_view.get()
@outputAncestors.setter
def outputAncestors(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAncestors)
data_view = og.AttributeValueHelper(self._attributes.outputAncestors)
data_view.set(value)
@property
def outputValues(self):
data_view = og.AttributeValueHelper(self._attributes.outputValues)
return data_view.get()
@outputValues.setter
def outputValues(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputValues)
data_view = og.AttributeValueHelper(self._attributes.outputValues)
data_view.set(value)
@property
def usePrimPath(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimPath)
return data_view.get()
@usePrimPath.setter
def usePrimPath(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimPath)
data_view = og.AttributeValueHelper(self._attributes.usePrimPath)
data_view.set(value)
@property
def usePrimType(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimType)
return data_view.get()
@usePrimType.setter
def usePrimType(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimType)
data_view = og.AttributeValueHelper(self._attributes.usePrimType)
data_view.set(value)
@property
def usePrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.usePrimvarMetadata)
return data_view.get()
@usePrimvarMetadata.setter
def usePrimvarMetadata(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usePrimvarMetadata)
data_view = og.AttributeValueHelper(self._attributes.usePrimvarMetadata)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
@property
def text(self):
data_view = og.AttributeValueHelper(self._attributes.text)
return data_view.get()
@text.setter
def text(self, value):
data_view = og.AttributeValueHelper(self._attributes.text)
data_view.set(value)
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnBundleToUSDADatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnBundleToUSDADatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnBundleToUSDADatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 8,803 | Python | 47.373626 | 285 | 0.659889 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnTransformBundleDatabase.py | """Support for simplified access to data on nodes of type omni.graph.TransformBundle
Applies a transform to an input bundle, storing the result in an output bundle
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTransformBundleDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.TransformBundle
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.input
inputs.transform
Outputs:
outputs.output
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:input', 'bundle', 0, None, 'Input bundle containing the attributes to be transformed.', {}, True, None, False, ''),
('inputs:transform', 'matrix4d', 0, None, 'The transform to apply to the bundle', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]'}, True, [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]], False, ''),
('outputs:output', 'bundle', 0, None, 'Output bundle containing all of the transformed attributes', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.input = og.AttributeRole.BUNDLE
role_data.inputs.transform = og.AttributeRole.MATRIX
role_data.outputs.output = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def input(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.input"""
return self.__bundles.input
@property
def transform(self):
data_view = og.AttributeValueHelper(self._attributes.transform)
return data_view.get()
@transform.setter
def transform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.transform)
data_view = og.AttributeValueHelper(self._attributes.transform)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def output(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.output"""
return self.__bundles.output
@output.setter
def output(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.output with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.output.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTransformBundleDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTransformBundleDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTransformBundleDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 6,555 | Python | 48.666666 | 347 | 0.661937 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnImportUSDPrimDatabase.py | """Support for simplified access to data on nodes of type omni.graph.ImportUSDPrim
Imports data from a USD prim into attributes in an output bundle
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnImportUSDPrimDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.ImportUSDPrim
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.applySkelBinding
inputs.applyTransform
inputs.attrNamesToImport
inputs.computeBoundingBox
inputs.importAttributes
inputs.importPath
inputs.importPrimvarMetadata
inputs.importTime
inputs.importTransform
inputs.importType
inputs.inputAttrNames
inputs.keepPrimsSeparate
inputs.outputAttrNames
inputs.prim
inputs.renameAttributes
inputs.timeVaryingAttributes
inputs.usdTimecode
Outputs:
outputs.output
State:
state.prevApplySkelBinding
state.prevApplyTransform
state.prevAttrNamesToImport
state.prevComputeBoundingBox
state.prevImportAttributes
state.prevImportPath
state.prevImportPrimvarMetadata
state.prevImportTime
state.prevImportTransform
state.prevImportType
state.prevInputAttrNames
state.prevInvNodeTransform
state.prevKeepPrimsSeparate
state.prevOnlyImportSpecified
state.prevOutputAttrNames
state.prevPaths
state.prevRenameAttributes
state.prevTimeVaryingAttributes
state.prevTransforms
state.prevUsdTimecode
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:applySkelBinding', 'bool', 0, None, 'If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:applyTransform', 'bool', 0, None, 'If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:attrNamesToImport', 'token', 0, 'Attributes To Import', 'Comma or space separated text, listing the names of attributes in the input data to be imported \nor empty to import all attributes.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:computeBoundingBox', 'bool', 0, None, 'Compute and store local bounding box of a prim and its children.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:importAttributes', 'bool', 0, None, 'Import attribute data from the USD prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importPath', 'bool', 0, None, 'Record the input USD prim\'s path into the output bundle in an attribute named "primPath".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importPrimvarMetadata', 'bool', 0, None, 'Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importTime', 'bool', 0, None, 'Record the usdTimecode above into the output bundle in an attribute named "primTime".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importTransform', 'bool', 0, None, 'Record the transform required to take any attributes of the input USD prim \ninto the space of this node, i.e. the world transform of the input prim times the \ninverse world transform of this node, into the output bundle in an attribute named "transform".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:importType', 'bool', 0, None, 'Deprecated, prim type is always imported', {ogn.MetadataKeys.HIDDEN: 'true', 'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:inputAttrNames', 'token', 0, 'Attributes To Rename', 'Comma or space separated text, listing the names of attributes in the input data to be renamed', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:keepPrimsSeparate', 'bool', 0, None, 'Prefix output attribute names with "prim" followed by a unique number and a colon, \nto keep the attributes for separate input prims separate. The prim paths will \nbe in the "primPaths" token array attribute.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:outputAttrNames', 'token', 0, 'New Attribute Names', 'Comma or space separated text, listing the new names for the attributes listed in inputAttrNames', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:prim', 'bundle', 0, None, 'The USD prim from which to import data.', {}, False, None, False, ''),
('inputs:renameAttributes', 'bool', 0, None, 'If true, attributes listed in "inputAttrNames" will be imported to attributes with the names specified in "outputAttrNames".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:timeVaryingAttributes', 'bool', 0, None, 'Check whether the USD attributes are time-varying and if so, import their data at the time "usdTimecode".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:usdTimecode', 'double', 0, None, 'The time at which to evaluate the transform of the USD prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:output', 'bundle', 0, None, 'Output bundle containing all of the imported data.', {}, True, None, False, ''),
('state:prevApplySkelBinding', 'bool', 0, None, 'Value of "applySkelBinding" input from previous run', {}, True, None, False, ''),
('state:prevApplyTransform', 'bool', 0, None, 'Value of "applyTransform" input from previous run', {}, True, None, False, ''),
('state:prevAttrNamesToImport', 'token', 0, None, 'Value of "attrNamesToImport" input from previous run', {}, True, None, False, ''),
('state:prevComputeBoundingBox', 'bool', 0, None, 'Value of "computeBoundingBox" input from previous run', {}, True, None, False, ''),
('state:prevImportAttributes', 'bool', 0, None, 'Value of "importAttributes" input from previous run', {}, True, None, False, ''),
('state:prevImportPath', 'bool', 0, None, 'Value of "importPath" input from previous run', {}, True, None, False, ''),
('state:prevImportPrimvarMetadata', 'bool', 0, None, 'Value of "importPrimvarMetadata" input from previous run', {}, True, None, False, ''),
('state:prevImportTime', 'bool', 0, None, 'Value of "importTime" input from previous run', {}, True, None, False, ''),
('state:prevImportTransform', 'bool', 0, None, 'Value of "importTransform" input from previous run', {}, True, None, False, ''),
('state:prevImportType', 'bool', 0, None, 'Value of "importType" input from previous run', {}, True, None, False, ''),
('state:prevInputAttrNames', 'token', 0, None, 'Value of "inputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevInvNodeTransform', 'matrix4d', 0, None, 'Inverse transform of the node prim from the previous run.', {}, True, None, False, ''),
('state:prevKeepPrimsSeparate', 'bool', 0, None, 'Value of "keepPrimsSeparate" input from previous run', {}, True, None, False, ''),
('state:prevOnlyImportSpecified', 'bool', 0, None, 'Value of "onlyImportSpecified" input from previous run', {}, True, None, False, ''),
('state:prevOutputAttrNames', 'token', 0, None, 'Value of "outputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevPaths', 'token[]', 0, None, 'Array of paths from the previous run.', {}, True, None, False, ''),
('state:prevRenameAttributes', 'bool', 0, None, 'Value of "renameAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTimeVaryingAttributes', 'bool', 0, None, 'Value of "timeVaryingAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTransforms', 'matrix4d[]', 0, None, 'Array of transforms from the previous run.', {}, True, None, False, ''),
('state:prevUsdTimecode', 'double', 0, None, 'Value of "usdTimecode" input from previous run', {}, True, None, False, ''),
])
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.prim = og.AttributeRole.BUNDLE
role_data.outputs.output = og.AttributeRole.BUNDLE
role_data.state.prevInvNodeTransform = og.AttributeRole.MATRIX
role_data.state.prevTransforms = og.AttributeRole.MATRIX
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def applySkelBinding(self):
data_view = og.AttributeValueHelper(self._attributes.applySkelBinding)
return data_view.get()
@applySkelBinding.setter
def applySkelBinding(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applySkelBinding)
data_view = og.AttributeValueHelper(self._attributes.applySkelBinding)
data_view.set(value)
@property
def applyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
return data_view.get()
@applyTransform.setter
def applyTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applyTransform)
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
data_view.set(value)
@property
def attrNamesToImport(self):
data_view = og.AttributeValueHelper(self._attributes.attrNamesToImport)
return data_view.get()
@attrNamesToImport.setter
def attrNamesToImport(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrNamesToImport)
data_view = og.AttributeValueHelper(self._attributes.attrNamesToImport)
data_view.set(value)
@property
def computeBoundingBox(self):
data_view = og.AttributeValueHelper(self._attributes.computeBoundingBox)
return data_view.get()
@computeBoundingBox.setter
def computeBoundingBox(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.computeBoundingBox)
data_view = og.AttributeValueHelper(self._attributes.computeBoundingBox)
data_view.set(value)
@property
def importAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.importAttributes)
return data_view.get()
@importAttributes.setter
def importAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importAttributes)
data_view = og.AttributeValueHelper(self._attributes.importAttributes)
data_view.set(value)
@property
def importPath(self):
data_view = og.AttributeValueHelper(self._attributes.importPath)
return data_view.get()
@importPath.setter
def importPath(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importPath)
data_view = og.AttributeValueHelper(self._attributes.importPath)
data_view.set(value)
@property
def importPrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.importPrimvarMetadata)
return data_view.get()
@importPrimvarMetadata.setter
def importPrimvarMetadata(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importPrimvarMetadata)
data_view = og.AttributeValueHelper(self._attributes.importPrimvarMetadata)
data_view.set(value)
@property
def importTime(self):
data_view = og.AttributeValueHelper(self._attributes.importTime)
return data_view.get()
@importTime.setter
def importTime(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importTime)
data_view = og.AttributeValueHelper(self._attributes.importTime)
data_view.set(value)
@property
def importTransform(self):
data_view = og.AttributeValueHelper(self._attributes.importTransform)
return data_view.get()
@importTransform.setter
def importTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importTransform)
data_view = og.AttributeValueHelper(self._attributes.importTransform)
data_view.set(value)
@property
def importType(self):
data_view = og.AttributeValueHelper(self._attributes.importType)
return data_view.get()
@importType.setter
def importType(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.importType)
data_view = og.AttributeValueHelper(self._attributes.importType)
data_view.set(value)
@property
def inputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
return data_view.get()
@inputAttrNames.setter
def inputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.inputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
data_view.set(value)
@property
def keepPrimsSeparate(self):
data_view = og.AttributeValueHelper(self._attributes.keepPrimsSeparate)
return data_view.get()
@keepPrimsSeparate.setter
def keepPrimsSeparate(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.keepPrimsSeparate)
data_view = og.AttributeValueHelper(self._attributes.keepPrimsSeparate)
data_view.set(value)
@property
def outputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
return data_view.get()
@outputAttrNames.setter
def outputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
data_view.set(value)
@property
def prim(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.prim"""
return self.__bundles.prim
@property
def renameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
return data_view.get()
@renameAttributes.setter
def renameAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.renameAttributes)
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
data_view.set(value)
@property
def timeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
return data_view.get()
@timeVaryingAttributes.setter
def timeVaryingAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timeVaryingAttributes)
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
data_view.set(value)
@property
def usdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
return data_view.get()
@usdTimecode.setter
def usdTimecode(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usdTimecode)
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def output(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.output"""
return self.__bundles.output
@output.setter
def output(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.output with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.output.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.prevPaths_size = None
self.prevTransforms_size = None
@property
def prevApplySkelBinding(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplySkelBinding)
return data_view.get()
@prevApplySkelBinding.setter
def prevApplySkelBinding(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplySkelBinding)
data_view.set(value)
@property
def prevApplyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
return data_view.get()
@prevApplyTransform.setter
def prevApplyTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
data_view.set(value)
@property
def prevAttrNamesToImport(self):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToImport)
return data_view.get()
@prevAttrNamesToImport.setter
def prevAttrNamesToImport(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToImport)
data_view.set(value)
@property
def prevComputeBoundingBox(self):
data_view = og.AttributeValueHelper(self._attributes.prevComputeBoundingBox)
return data_view.get()
@prevComputeBoundingBox.setter
def prevComputeBoundingBox(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevComputeBoundingBox)
data_view.set(value)
@property
def prevImportAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportAttributes)
return data_view.get()
@prevImportAttributes.setter
def prevImportAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportAttributes)
data_view.set(value)
@property
def prevImportPath(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportPath)
return data_view.get()
@prevImportPath.setter
def prevImportPath(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportPath)
data_view.set(value)
@property
def prevImportPrimvarMetadata(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportPrimvarMetadata)
return data_view.get()
@prevImportPrimvarMetadata.setter
def prevImportPrimvarMetadata(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportPrimvarMetadata)
data_view.set(value)
@property
def prevImportTime(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportTime)
return data_view.get()
@prevImportTime.setter
def prevImportTime(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportTime)
data_view.set(value)
@property
def prevImportTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportTransform)
return data_view.get()
@prevImportTransform.setter
def prevImportTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportTransform)
data_view.set(value)
@property
def prevImportType(self):
data_view = og.AttributeValueHelper(self._attributes.prevImportType)
return data_view.get()
@prevImportType.setter
def prevImportType(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevImportType)
data_view.set(value)
@property
def prevInputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
return data_view.get()
@prevInputAttrNames.setter
def prevInputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
data_view.set(value)
@property
def prevInvNodeTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevInvNodeTransform)
return data_view.get()
@prevInvNodeTransform.setter
def prevInvNodeTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInvNodeTransform)
data_view.set(value)
@property
def prevKeepPrimsSeparate(self):
data_view = og.AttributeValueHelper(self._attributes.prevKeepPrimsSeparate)
return data_view.get()
@prevKeepPrimsSeparate.setter
def prevKeepPrimsSeparate(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevKeepPrimsSeparate)
data_view.set(value)
@property
def prevOnlyImportSpecified(self):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyImportSpecified)
return data_view.get()
@prevOnlyImportSpecified.setter
def prevOnlyImportSpecified(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyImportSpecified)
data_view.set(value)
@property
def prevOutputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
return data_view.get()
@prevOutputAttrNames.setter
def prevOutputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
data_view.set(value)
@property
def prevPaths(self):
data_view = og.AttributeValueHelper(self._attributes.prevPaths)
self.prevPaths_size = data_view.get_array_size()
return data_view.get()
@prevPaths.setter
def prevPaths(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPaths)
data_view.set(value)
self.prevPaths_size = data_view.get_array_size()
@property
def prevRenameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
return data_view.get()
@prevRenameAttributes.setter
def prevRenameAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
data_view.set(value)
@property
def prevTimeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
return data_view.get()
@prevTimeVaryingAttributes.setter
def prevTimeVaryingAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
data_view.set(value)
@property
def prevTransforms(self):
data_view = og.AttributeValueHelper(self._attributes.prevTransforms)
self.prevTransforms_size = data_view.get_array_size()
return data_view.get()
@prevTransforms.setter
def prevTransforms(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTransforms)
data_view.set(value)
self.prevTransforms_size = data_view.get_array_size()
@property
def prevUsdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
return data_view.get()
@prevUsdTimecode.setter
def prevUsdTimecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
data_view.set(value)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnImportUSDPrimDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnImportUSDPrimDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnImportUSDPrimDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 29,375 | Python | 48.78983 | 401 | 0.654672 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/OgnExportUSDPrimDatabase.py | """Support for simplified access to data on nodes of type omni.graph.ExportUSDPrim
Exports data from an input bundle into a USD prim
"""
import carb
import numpy
import carb
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnExportUSDPrimDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.graph.ExportUSDPrim
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.applyTransform
inputs.attrNamesToExport
inputs.bundle
inputs.excludedAttrNames
inputs.exportToRootLayer
inputs.inputAttrNames
inputs.layerName
inputs.onlyExportToExisting
inputs.outputAttrNames
inputs.primPathFromBundle
inputs.removeMissingAttrs
inputs.renameAttributes
inputs.timeVaryingAttributes
inputs.usdTimecode
Outputs:
outputs.prim
State:
state.prevApplyTransform
state.prevAttrNamesToExport
state.prevBundleDirtyID
state.prevExcludedAttrNames
state.prevExportToRootLayer
state.prevInputAttrNames
state.prevLayerName
state.prevOnlyExportToExisting
state.prevOutputAttrNames
state.prevPrimDirtyIDs
state.prevPrimPathFromBundle
state.prevRemoveMissingAttrs
state.prevRenameAttributes
state.prevTimeVaryingAttributes
state.prevUsdTimecode
Predefined Tokens:
tokens.primPath
tokens.primType
tokens.primTime
tokens.primCount
tokens.transform
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:applyTransform', 'bool', 0, None, 'If true, apply the transform necessary to transform any transforming attributes from the space of the node into the space of the specified prim.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:attrNamesToExport', 'token', 0, 'Attributes To Export', 'Comma or space separated text, listing the names of attributes in the input data to be exported \nor empty to import all attributes.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:bundle', 'bundle', 0, None, 'The bundle from which data should be exported.', {}, True, None, False, ''),
('inputs:excludedAttrNames', 'token', 0, 'Attributes To Exclude', 'Attributes to be excluded from being exported', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:exportToRootLayer', 'bool', 0, 'Export to Root Layer', 'If true, prims are exported in the root layer, otherwise the layer specified by "layerName" is used.', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:inputAttrNames', 'token', 0, 'Attributes To Rename', 'Comma or space separated text, listing the names of attributes in the input data to be renamed', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:layerName', 'token', 0, 'Layer Name', 'Identifier of the layer to export to if "exportToRootLayer" is false, or leave this blank to export to the session layer', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:onlyExportToExisting', 'bool', 0, None, 'If true, only attributes that already exist in the specified output prim will have data transferred to them from the input bundle.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:outputAttrNames', 'token', 0, 'New Attribute Names', 'Comma or space separated text, listing the new names for the attributes listed in inputAttrNames', {ogn.MetadataKeys.DEFAULT: '""'}, True, "", False, ''),
('inputs:primPathFromBundle', 'bool', 0, None, 'When true, if there is a "primPath" token attribute inside the bundle, that will be the path of the USD prim to write to, \nelse the "outputs:prim" attribute below will be used for the USD prim path.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:removeMissingAttrs', 'bool', 0, 'Export to Root Layer', "If true, any attributes on the USD prim(s) being written to, that aren't in the input data, \nwill be removed from the USD prim(s).", {ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:renameAttributes', 'bool', 0, None, 'If true, attributes listed in "inputAttrNames" will be exported to attributes with the names specified in "outputAttrNames". \nNote: to avoid potential issues with redundant attributes being created while typing, keep this off until after \nspecifying all input and output attribute names.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:timeVaryingAttributes', 'bool', 0, None, 'Check whether the USD attributes should be time-varying and if so, export their data to a time sample at the time "usdTimecode".', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: 'false'}, True, False, False, ''),
('inputs:usdTimecode', 'double', 0, None, 'The time at which to evaluate the transform of the USD prim for applyTransform.', {'displayGroup': 'parameters', ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
('outputs:prim', 'bundle', 0, None, 'The USD prim(s) to which data should be exported if primPathFromBundle is false or if the bundle doesn\'t have a "primPath" token attribute. \nNote: this is really an input, since the node just receives the path to the prim. The node does not contain the prim.', {ogn.MetadataKeys.HIDDEN: 'true'}, False, None, False, ''),
('state:prevApplyTransform', 'bool', 0, None, 'Value of "applyTransform" input from previous run', {}, True, None, False, ''),
('state:prevAttrNamesToExport', 'token', 0, None, 'Value of "attrNamesToExport" input from previous run', {}, True, None, False, ''),
('state:prevBundleDirtyID', 'uint64', 0, None, 'Dirty ID of input bundle from previous run', {}, True, None, False, ''),
('state:prevExcludedAttrNames', 'token', 0, None, 'Value of "excludedAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevExportToRootLayer', 'bool', 0, None, 'Value of "exportToRootLayer" input from previous run', {}, True, None, False, ''),
('state:prevInputAttrNames', 'token', 0, None, 'Value of "inputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevLayerName', 'token', 0, None, 'Value of "layerName" input from previous run', {}, True, None, False, ''),
('state:prevOnlyExportToExisting', 'bool', 0, None, 'Value of "onlyExportToExisting" input from previous run', {}, True, None, False, ''),
('state:prevOutputAttrNames', 'token', 0, None, 'Value of "outputAttrNames" input from previous run', {}, True, None, False, ''),
('state:prevPrimDirtyIDs', 'uint64[]', 0, None, 'Dirty IDs of input prims from previous run', {}, True, None, False, ''),
('state:prevPrimPathFromBundle', 'bool', 0, None, 'Value of "primPathFromBundle" input from previous run', {}, True, None, False, ''),
('state:prevRemoveMissingAttrs', 'bool', 0, None, 'Value of "removeMissingAttrs" input from previous run', {}, True, None, False, ''),
('state:prevRenameAttributes', 'bool', 0, None, 'Value of "renameAttributes" input from previous run', {}, True, None, False, ''),
('state:prevTimeVaryingAttributes', 'bool', 0, None, 'Value of "timeVaryingAttributes" input from previous run', {}, True, None, False, ''),
('state:prevUsdTimecode', 'double', 0, None, 'Value of "usdTimecode" input from previous run', {}, True, None, False, ''),
])
class tokens:
primPath = "primPath"
primType = "primType"
primTime = "primTime"
primCount = "primCount"
transform = "transform"
@classmethod
def _populate_role_data(cls):
"""Populate a role structure with the non-default roles on this node type"""
role_data = super()._populate_role_data()
role_data.inputs.bundle = og.AttributeRole.BUNDLE
role_data.outputs.prim = og.AttributeRole.BUNDLE
return role_data
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=True, gpu_ptr_kinds={})
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def applyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
return data_view.get()
@applyTransform.setter
def applyTransform(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.applyTransform)
data_view = og.AttributeValueHelper(self._attributes.applyTransform)
data_view.set(value)
@property
def attrNamesToExport(self):
data_view = og.AttributeValueHelper(self._attributes.attrNamesToExport)
return data_view.get()
@attrNamesToExport.setter
def attrNamesToExport(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.attrNamesToExport)
data_view = og.AttributeValueHelper(self._attributes.attrNamesToExport)
data_view.set(value)
@property
def bundle(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute inputs.bundle"""
return self.__bundles.bundle
@property
def excludedAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.excludedAttrNames)
return data_view.get()
@excludedAttrNames.setter
def excludedAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.excludedAttrNames)
data_view = og.AttributeValueHelper(self._attributes.excludedAttrNames)
data_view.set(value)
@property
def exportToRootLayer(self):
data_view = og.AttributeValueHelper(self._attributes.exportToRootLayer)
return data_view.get()
@exportToRootLayer.setter
def exportToRootLayer(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.exportToRootLayer)
data_view = og.AttributeValueHelper(self._attributes.exportToRootLayer)
data_view.set(value)
@property
def inputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
return data_view.get()
@inputAttrNames.setter
def inputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.inputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.inputAttrNames)
data_view.set(value)
@property
def layerName(self):
data_view = og.AttributeValueHelper(self._attributes.layerName)
return data_view.get()
@layerName.setter
def layerName(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.layerName)
data_view = og.AttributeValueHelper(self._attributes.layerName)
data_view.set(value)
@property
def onlyExportToExisting(self):
data_view = og.AttributeValueHelper(self._attributes.onlyExportToExisting)
return data_view.get()
@onlyExportToExisting.setter
def onlyExportToExisting(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.onlyExportToExisting)
data_view = og.AttributeValueHelper(self._attributes.onlyExportToExisting)
data_view.set(value)
@property
def outputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
return data_view.get()
@outputAttrNames.setter
def outputAttrNames(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.outputAttrNames)
data_view = og.AttributeValueHelper(self._attributes.outputAttrNames)
data_view.set(value)
@property
def primPathFromBundle(self):
data_view = og.AttributeValueHelper(self._attributes.primPathFromBundle)
return data_view.get()
@primPathFromBundle.setter
def primPathFromBundle(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.primPathFromBundle)
data_view = og.AttributeValueHelper(self._attributes.primPathFromBundle)
data_view.set(value)
@property
def removeMissingAttrs(self):
data_view = og.AttributeValueHelper(self._attributes.removeMissingAttrs)
return data_view.get()
@removeMissingAttrs.setter
def removeMissingAttrs(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.removeMissingAttrs)
data_view = og.AttributeValueHelper(self._attributes.removeMissingAttrs)
data_view.set(value)
@property
def renameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
return data_view.get()
@renameAttributes.setter
def renameAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.renameAttributes)
data_view = og.AttributeValueHelper(self._attributes.renameAttributes)
data_view.set(value)
@property
def timeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
return data_view.get()
@timeVaryingAttributes.setter
def timeVaryingAttributes(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timeVaryingAttributes)
data_view = og.AttributeValueHelper(self._attributes.timeVaryingAttributes)
data_view.set(value)
@property
def usdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
return data_view.get()
@usdTimecode.setter
def usdTimecode(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.usdTimecode)
data_view = og.AttributeValueHelper(self._attributes.usdTimecode)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.__bundles = og.BundleContainer(context, node, attributes, [], read_only=False, gpu_ptr_kinds={})
self._batchedWriteValues = { }
@property
def prim(self) -> og.BundleContents:
"""Get the bundle wrapper class for the attribute outputs.prim"""
return self.__bundles.prim
@prim.setter
def prim(self, bundle: og.BundleContents):
"""Overwrite the bundle attribute outputs.prim with a new bundle"""
if not isinstance(bundle, og.BundleContents):
carb.log_error("Only bundle attributes can be assigned to another bundle attribute")
self.__bundles.prim.bundle = bundle
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self.prevPrimDirtyIDs_size = None
@property
def prevApplyTransform(self):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
return data_view.get()
@prevApplyTransform.setter
def prevApplyTransform(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevApplyTransform)
data_view.set(value)
@property
def prevAttrNamesToExport(self):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToExport)
return data_view.get()
@prevAttrNamesToExport.setter
def prevAttrNamesToExport(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevAttrNamesToExport)
data_view.set(value)
@property
def prevBundleDirtyID(self):
data_view = og.AttributeValueHelper(self._attributes.prevBundleDirtyID)
return data_view.get()
@prevBundleDirtyID.setter
def prevBundleDirtyID(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevBundleDirtyID)
data_view.set(value)
@property
def prevExcludedAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevExcludedAttrNames)
return data_view.get()
@prevExcludedAttrNames.setter
def prevExcludedAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevExcludedAttrNames)
data_view.set(value)
@property
def prevExportToRootLayer(self):
data_view = og.AttributeValueHelper(self._attributes.prevExportToRootLayer)
return data_view.get()
@prevExportToRootLayer.setter
def prevExportToRootLayer(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevExportToRootLayer)
data_view.set(value)
@property
def prevInputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
return data_view.get()
@prevInputAttrNames.setter
def prevInputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevInputAttrNames)
data_view.set(value)
@property
def prevLayerName(self):
data_view = og.AttributeValueHelper(self._attributes.prevLayerName)
return data_view.get()
@prevLayerName.setter
def prevLayerName(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevLayerName)
data_view.set(value)
@property
def prevOnlyExportToExisting(self):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyExportToExisting)
return data_view.get()
@prevOnlyExportToExisting.setter
def prevOnlyExportToExisting(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOnlyExportToExisting)
data_view.set(value)
@property
def prevOutputAttrNames(self):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
return data_view.get()
@prevOutputAttrNames.setter
def prevOutputAttrNames(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevOutputAttrNames)
data_view.set(value)
@property
def prevPrimDirtyIDs(self):
data_view = og.AttributeValueHelper(self._attributes.prevPrimDirtyIDs)
self.prevPrimDirtyIDs_size = data_view.get_array_size()
return data_view.get()
@prevPrimDirtyIDs.setter
def prevPrimDirtyIDs(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPrimDirtyIDs)
data_view.set(value)
self.prevPrimDirtyIDs_size = data_view.get_array_size()
@property
def prevPrimPathFromBundle(self):
data_view = og.AttributeValueHelper(self._attributes.prevPrimPathFromBundle)
return data_view.get()
@prevPrimPathFromBundle.setter
def prevPrimPathFromBundle(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevPrimPathFromBundle)
data_view.set(value)
@property
def prevRemoveMissingAttrs(self):
data_view = og.AttributeValueHelper(self._attributes.prevRemoveMissingAttrs)
return data_view.get()
@prevRemoveMissingAttrs.setter
def prevRemoveMissingAttrs(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRemoveMissingAttrs)
data_view.set(value)
@property
def prevRenameAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
return data_view.get()
@prevRenameAttributes.setter
def prevRenameAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevRenameAttributes)
data_view.set(value)
@property
def prevTimeVaryingAttributes(self):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
return data_view.get()
@prevTimeVaryingAttributes.setter
def prevTimeVaryingAttributes(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevTimeVaryingAttributes)
data_view.set(value)
@property
def prevUsdTimecode(self):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
return data_view.get()
@prevUsdTimecode.setter
def prevUsdTimecode(self, value):
data_view = og.AttributeValueHelper(self._attributes.prevUsdTimecode)
data_view.set(value)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnExportUSDPrimDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnExportUSDPrimDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnExportUSDPrimDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
| 24,954 | Python | 49.211268 | 437 | 0.658852 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnImportUSDPrim.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnImportUSDPrimDatabase import OgnImportUSDPrimDatabase
test_file_name = "OgnImportUSDPrimTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_ImportUSDPrim")
database = OgnImportUSDPrimDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:applySkelBinding"))
attribute = test_node.get_attribute("inputs:applySkelBinding")
db_value = database.inputs.applySkelBinding
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:applyTransform"))
attribute = test_node.get_attribute("inputs:applyTransform")
db_value = database.inputs.applyTransform
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:attrNamesToImport"))
attribute = test_node.get_attribute("inputs:attrNamesToImport")
db_value = database.inputs.attrNamesToImport
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:computeBoundingBox"))
attribute = test_node.get_attribute("inputs:computeBoundingBox")
db_value = database.inputs.computeBoundingBox
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importAttributes"))
attribute = test_node.get_attribute("inputs:importAttributes")
db_value = database.inputs.importAttributes
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importPath"))
attribute = test_node.get_attribute("inputs:importPath")
db_value = database.inputs.importPath
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importPrimvarMetadata"))
attribute = test_node.get_attribute("inputs:importPrimvarMetadata")
db_value = database.inputs.importPrimvarMetadata
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importTime"))
attribute = test_node.get_attribute("inputs:importTime")
db_value = database.inputs.importTime
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importTransform"))
attribute = test_node.get_attribute("inputs:importTransform")
db_value = database.inputs.importTransform
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:importType"))
attribute = test_node.get_attribute("inputs:importType")
db_value = database.inputs.importType
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:inputAttrNames"))
attribute = test_node.get_attribute("inputs:inputAttrNames")
db_value = database.inputs.inputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:keepPrimsSeparate"))
attribute = test_node.get_attribute("inputs:keepPrimsSeparate")
db_value = database.inputs.keepPrimsSeparate
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputAttrNames"))
attribute = test_node.get_attribute("inputs:outputAttrNames")
db_value = database.inputs.outputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:renameAttributes"))
attribute = test_node.get_attribute("inputs:renameAttributes")
db_value = database.inputs.renameAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timeVaryingAttributes"))
attribute = test_node.get_attribute("inputs:timeVaryingAttributes")
db_value = database.inputs.timeVaryingAttributes
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usdTimecode"))
attribute = test_node.get_attribute("inputs:usdTimecode")
db_value = database.inputs.usdTimecode
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs_output"))
attribute = test_node.get_attribute("outputs_output")
db_value = database.outputs.output
self.assertTrue(test_node.get_attribute_exists("state:prevApplySkelBinding"))
attribute = test_node.get_attribute("state:prevApplySkelBinding")
db_value = database.state.prevApplySkelBinding
self.assertTrue(test_node.get_attribute_exists("state:prevApplyTransform"))
attribute = test_node.get_attribute("state:prevApplyTransform")
db_value = database.state.prevApplyTransform
self.assertTrue(test_node.get_attribute_exists("state:prevAttrNamesToImport"))
attribute = test_node.get_attribute("state:prevAttrNamesToImport")
db_value = database.state.prevAttrNamesToImport
self.assertTrue(test_node.get_attribute_exists("state:prevComputeBoundingBox"))
attribute = test_node.get_attribute("state:prevComputeBoundingBox")
db_value = database.state.prevComputeBoundingBox
self.assertTrue(test_node.get_attribute_exists("state:prevImportAttributes"))
attribute = test_node.get_attribute("state:prevImportAttributes")
db_value = database.state.prevImportAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevImportPath"))
attribute = test_node.get_attribute("state:prevImportPath")
db_value = database.state.prevImportPath
self.assertTrue(test_node.get_attribute_exists("state:prevImportPrimvarMetadata"))
attribute = test_node.get_attribute("state:prevImportPrimvarMetadata")
db_value = database.state.prevImportPrimvarMetadata
self.assertTrue(test_node.get_attribute_exists("state:prevImportTime"))
attribute = test_node.get_attribute("state:prevImportTime")
db_value = database.state.prevImportTime
self.assertTrue(test_node.get_attribute_exists("state:prevImportTransform"))
attribute = test_node.get_attribute("state:prevImportTransform")
db_value = database.state.prevImportTransform
self.assertTrue(test_node.get_attribute_exists("state:prevImportType"))
attribute = test_node.get_attribute("state:prevImportType")
db_value = database.state.prevImportType
self.assertTrue(test_node.get_attribute_exists("state:prevInputAttrNames"))
attribute = test_node.get_attribute("state:prevInputAttrNames")
db_value = database.state.prevInputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevInvNodeTransform"))
attribute = test_node.get_attribute("state:prevInvNodeTransform")
db_value = database.state.prevInvNodeTransform
self.assertTrue(test_node.get_attribute_exists("state:prevKeepPrimsSeparate"))
attribute = test_node.get_attribute("state:prevKeepPrimsSeparate")
db_value = database.state.prevKeepPrimsSeparate
self.assertTrue(test_node.get_attribute_exists("state:prevOnlyImportSpecified"))
attribute = test_node.get_attribute("state:prevOnlyImportSpecified")
db_value = database.state.prevOnlyImportSpecified
self.assertTrue(test_node.get_attribute_exists("state:prevOutputAttrNames"))
attribute = test_node.get_attribute("state:prevOutputAttrNames")
db_value = database.state.prevOutputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevPaths"))
attribute = test_node.get_attribute("state:prevPaths")
db_value = database.state.prevPaths
self.assertTrue(test_node.get_attribute_exists("state:prevRenameAttributes"))
attribute = test_node.get_attribute("state:prevRenameAttributes")
db_value = database.state.prevRenameAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTimeVaryingAttributes"))
attribute = test_node.get_attribute("state:prevTimeVaryingAttributes")
db_value = database.state.prevTimeVaryingAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTransforms"))
attribute = test_node.get_attribute("state:prevTransforms")
db_value = database.state.prevTransforms
self.assertTrue(test_node.get_attribute_exists("state:prevUsdTimecode"))
attribute = test_node.get_attribute("state:prevUsdTimecode")
db_value = database.state.prevUsdTimecode
| 13,220 | Python | 53.407407 | 92 | 0.709834 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/__init__.py | """====== GENERATED BY omni.graph.tools - DO NOT EDIT ======"""
import omni.graph.tools._internal as ogi
ogi.import_tests_in_directory(__file__, __name__)
| 155 | Python | 37.999991 | 63 | 0.645161 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnBundleToUSDA.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnBundleToUSDADatabase import OgnBundleToUSDADatabase
test_file_name = "OgnBundleToUSDATemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_BundleToUSDA")
database = OgnBundleToUSDADatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:bundle"))
attribute = test_node.get_attribute("inputs:bundle")
db_value = database.inputs.bundle
self.assertTrue(test_node.get_attribute_exists("inputs:outputAncestors"))
attribute = test_node.get_attribute("inputs:outputAncestors")
db_value = database.inputs.outputAncestors
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputValues"))
attribute = test_node.get_attribute("inputs:outputValues")
db_value = database.inputs.outputValues
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimPath"))
attribute = test_node.get_attribute("inputs:usePrimPath")
db_value = database.inputs.usePrimPath
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimType"))
attribute = test_node.get_attribute("inputs:usePrimType")
db_value = database.inputs.usePrimType
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usePrimvarMetadata"))
attribute = test_node.get_attribute("inputs:usePrimvarMetadata")
db_value = database.inputs.usePrimvarMetadata
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs:text"))
attribute = test_node.get_attribute("outputs:text")
db_value = database.outputs.text
| 4,106 | Python | 50.987341 | 92 | 0.698003 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnTransformBundle.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnTransformBundleDatabase import OgnTransformBundleDatabase
test_file_name = "OgnTransformBundleTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_TransformBundle")
database = OgnTransformBundleDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:input"))
attribute = test_node.get_attribute("inputs:input")
db_value = database.inputs.input
self.assertTrue(test_node.get_attribute_exists("inputs:transform"))
attribute = test_node.get_attribute("inputs:transform")
db_value = database.inputs.transform
expected_value = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs_output"))
attribute = test_node.get_attribute("outputs_output")
db_value = database.outputs.output
| 2,385 | Python | 49.765956 | 113 | 0.686373 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/ogn/tests/TestOgnExportUSDPrim.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.graph.io.ogn.OgnExportUSDPrimDatabase import OgnExportUSDPrimDatabase
test_file_name = "OgnExportUSDPrimTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_graph_ExportUSDPrim")
database = OgnExportUSDPrimDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:applyTransform"))
attribute = test_node.get_attribute("inputs:applyTransform")
db_value = database.inputs.applyTransform
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:attrNamesToExport"))
attribute = test_node.get_attribute("inputs:attrNamesToExport")
db_value = database.inputs.attrNamesToExport
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:bundle"))
attribute = test_node.get_attribute("inputs:bundle")
db_value = database.inputs.bundle
self.assertTrue(test_node.get_attribute_exists("inputs:excludedAttrNames"))
attribute = test_node.get_attribute("inputs:excludedAttrNames")
db_value = database.inputs.excludedAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:exportToRootLayer"))
attribute = test_node.get_attribute("inputs:exportToRootLayer")
db_value = database.inputs.exportToRootLayer
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:inputAttrNames"))
attribute = test_node.get_attribute("inputs:inputAttrNames")
db_value = database.inputs.inputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:layerName"))
attribute = test_node.get_attribute("inputs:layerName")
db_value = database.inputs.layerName
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:onlyExportToExisting"))
attribute = test_node.get_attribute("inputs:onlyExportToExisting")
db_value = database.inputs.onlyExportToExisting
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:outputAttrNames"))
attribute = test_node.get_attribute("inputs:outputAttrNames")
db_value = database.inputs.outputAttrNames
expected_value = ""
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:primPathFromBundle"))
attribute = test_node.get_attribute("inputs:primPathFromBundle")
db_value = database.inputs.primPathFromBundle
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:removeMissingAttrs"))
attribute = test_node.get_attribute("inputs:removeMissingAttrs")
db_value = database.inputs.removeMissingAttrs
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:renameAttributes"))
attribute = test_node.get_attribute("inputs:renameAttributes")
db_value = database.inputs.renameAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timeVaryingAttributes"))
attribute = test_node.get_attribute("inputs:timeVaryingAttributes")
db_value = database.inputs.timeVaryingAttributes
expected_value = False
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:usdTimecode"))
attribute = test_node.get_attribute("inputs:usdTimecode")
db_value = database.inputs.usdTimecode
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("state:prevApplyTransform"))
attribute = test_node.get_attribute("state:prevApplyTransform")
db_value = database.state.prevApplyTransform
self.assertTrue(test_node.get_attribute_exists("state:prevAttrNamesToExport"))
attribute = test_node.get_attribute("state:prevAttrNamesToExport")
db_value = database.state.prevAttrNamesToExport
self.assertTrue(test_node.get_attribute_exists("state:prevBundleDirtyID"))
attribute = test_node.get_attribute("state:prevBundleDirtyID")
db_value = database.state.prevBundleDirtyID
self.assertTrue(test_node.get_attribute_exists("state:prevExcludedAttrNames"))
attribute = test_node.get_attribute("state:prevExcludedAttrNames")
db_value = database.state.prevExcludedAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevExportToRootLayer"))
attribute = test_node.get_attribute("state:prevExportToRootLayer")
db_value = database.state.prevExportToRootLayer
self.assertTrue(test_node.get_attribute_exists("state:prevInputAttrNames"))
attribute = test_node.get_attribute("state:prevInputAttrNames")
db_value = database.state.prevInputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevLayerName"))
attribute = test_node.get_attribute("state:prevLayerName")
db_value = database.state.prevLayerName
self.assertTrue(test_node.get_attribute_exists("state:prevOnlyExportToExisting"))
attribute = test_node.get_attribute("state:prevOnlyExportToExisting")
db_value = database.state.prevOnlyExportToExisting
self.assertTrue(test_node.get_attribute_exists("state:prevOutputAttrNames"))
attribute = test_node.get_attribute("state:prevOutputAttrNames")
db_value = database.state.prevOutputAttrNames
self.assertTrue(test_node.get_attribute_exists("state:prevPrimDirtyIDs"))
attribute = test_node.get_attribute("state:prevPrimDirtyIDs")
db_value = database.state.prevPrimDirtyIDs
self.assertTrue(test_node.get_attribute_exists("state:prevPrimPathFromBundle"))
attribute = test_node.get_attribute("state:prevPrimPathFromBundle")
db_value = database.state.prevPrimPathFromBundle
self.assertTrue(test_node.get_attribute_exists("state:prevRemoveMissingAttrs"))
attribute = test_node.get_attribute("state:prevRemoveMissingAttrs")
db_value = database.state.prevRemoveMissingAttrs
self.assertTrue(test_node.get_attribute_exists("state:prevRenameAttributes"))
attribute = test_node.get_attribute("state:prevRenameAttributes")
db_value = database.state.prevRenameAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevTimeVaryingAttributes"))
attribute = test_node.get_attribute("state:prevTimeVaryingAttributes")
db_value = database.state.prevTimeVaryingAttributes
self.assertTrue(test_node.get_attribute_exists("state:prevUsdTimecode"))
attribute = test_node.get_attribute("state:prevUsdTimecode")
db_value = database.state.prevUsdTimecode
| 10,861 | Python | 53.582914 | 92 | 0.710524 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/extension.py | """Support required by the Carbonite extension loader"""
import omni.ext
from ..bindings._omni_graph_io import acquire_interface as _acquire_interface # noqa: PLE0402
from ..bindings._omni_graph_io import release_interface as _release_interface # noqa: PLE0402
class _PublicExtension(omni.ext.IExt):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__interface = None
try:
import omni.graph.ui as ogu
ogu.ComputeNodeWidget.get_instance().add_template_path(__file__)
except ImportError:
pass
def on_startup(self, ext_id):
self.__interface = _acquire_interface()
def on_shutdown(self):
if self.__interface is not None:
_release_interface(self.__interface)
self.__interface = None
| 833 | Python | 31.076922 | 94 | 0.631453 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/templates/template_omni.graph.ImportUSDPrim.py | from omni.kit.property.usd.custom_layout_helper import CustomLayoutFrame, CustomLayoutGroup, CustomLayoutProperty
class CustomLayout:
def __init__(self, compute_node_widget):
# print("\nInside template_omni.genproc.ImportUSDPrim.py, CustomLayout:__init__\n");
# Enable template
self.enable = True
self.compute_node_widget = compute_node_widget
self.compute_node_widget.get_bundles()
bundle_items_iter = iter(self.compute_node_widget.bundles.items())
_ = next(bundle_items_iter)[1][0].get_attribute_names_and_types()
def apply(self, props):
frame = CustomLayoutFrame(hide_extra=True)
with frame:
with CustomLayoutGroup("Import Parameters"):
CustomLayoutProperty("inputs:prim", "Prim(s) to Import")
CustomLayoutProperty("inputs:usdTimecode", "Timecode")
CustomLayoutProperty("inputs:keepPrimsSeparate", "Allow Multiple Prims")
CustomLayoutProperty("inputs:importTransform", "Import Transforms")
CustomLayoutProperty("inputs:computeBoundingBox", "Compute Bounding Boxes")
CustomLayoutProperty("inputs:importType", "Import Types")
CustomLayoutProperty("inputs:importPath", "Import Paths")
CustomLayoutProperty("inputs:importTime", "Import Time")
with CustomLayoutGroup("Attributes"):
CustomLayoutProperty("inputs:importAttributes", "Import Attributes")
CustomLayoutProperty("inputs:attrNamesToImport", "Attributes to Import")
CustomLayoutProperty("inputs:renameAttributes", "Rename Attributes")
CustomLayoutProperty("inputs:inputAttrNames", "Attributes to Rename")
CustomLayoutProperty("inputs:outputAttrNames", "New Attribute Names")
CustomLayoutProperty("inputs:applyTransform", "Transform Attributes")
CustomLayoutProperty("inputs:timeVaryingAttributes", "Time Varying Attributes")
CustomLayoutProperty("inputs:importPrimvarMetadata", "Import Metadata")
CustomLayoutProperty("inputs:applySkelBinding", "Apply SkelBinding")
return frame.apply(props)
# print("\nIn template_omni.graph.ImportUSDPrim.py\n")
| 2,295 | Python | 52.395348 | 113 | 0.672331 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/_impl/templates/template_omni.graph.ExportUSDPrim.py | from omni.kit.property.usd.custom_layout_helper import CustomLayoutFrame, CustomLayoutGroup, CustomLayoutProperty
class CustomLayout:
def __init__(self, compute_node_widget):
# print("\nInside template_omni.genproc.ExportUSDPrim.py, CustomLayout:__init__\n");
# Enable template
self.enable = True
self.compute_node_widget = compute_node_widget
self.compute_node_widget.get_bundles()
bundle_items_iter = iter(self.compute_node_widget.bundles.items())
_ = next(bundle_items_iter)[1][0].get_attribute_names_and_types()
def apply(self, props):
frame = CustomLayoutFrame(hide_extra=True)
with frame:
with CustomLayoutGroup("Export Parameters"):
CustomLayoutProperty("outputs:prim", "Prim(s) to Export to")
CustomLayoutProperty("inputs:bundle", "Source Data")
CustomLayoutProperty("inputs:primPathFromBundle", "Export to primPath from Source")
CustomLayoutProperty("inputs:exportToRootLayer", "Export to Root Layer")
CustomLayoutProperty("inputs:layerName", "Layer Name")
with CustomLayoutGroup("Attributes"):
CustomLayoutProperty("inputs:attrNamesToExport", "Attributes to Export")
CustomLayoutProperty("inputs:onlyExportToExisting", "Only Export Existing")
CustomLayoutProperty("inputs:removeMissingAttrs", "Remove Missing")
CustomLayoutProperty("inputs:renameAttributes", "Rename Attributes")
CustomLayoutProperty("inputs:inputAttrNames", "Attributes to Rename")
CustomLayoutProperty("inputs:outputAttrNames", "New Attribute Names")
CustomLayoutProperty("inputs:excludedAttrNames", "Attributes to Exclude")
CustomLayoutProperty("inputs:applyTransform", "Transform Attributes")
CustomLayoutProperty("inputs:timeVaryingAttributes", "Time-varying Attributes")
CustomLayoutProperty("inputs:usdTimecode", "USD Time")
return frame.apply(props)
# print("\nIn template_omni.graph.ExportUSDPrim.py\n")
| 2,150 | Python | 51.463413 | 113 | 0.672093 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core.tests as ogts
import omni.graph.io as ogio
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphIoApi(ogts.OmniGraphTestCase):
_UNPUBLISHED = ["bindings", "ogn", "tests"]
async def test_api(self):
_check_module_api_consistency(ogio, self._UNPUBLISHED) # noqa: PLW0212
_check_module_api_consistency(ogio.tests, is_test_module=True) # noqa: PLW0212
async def test_api_features(self):
"""Test that the known public API features continue to exist"""
_check_public_api_contents(ogio, [], self._UNPUBLISHED, only_expected_allowed=True) # noqa: PLW0212
_check_public_api_contents(ogio.tests, [], [], only_expected_allowed=True) # noqa: PLW0212
| 922 | Python | 47.578945 | 108 | 0.652928 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/__init__.py | """There is no public API to this module."""
__all__ = []
scan_for_test_modules = True
"""The presence of this object causes the test runner to automatically scan the directory for unit test cases"""
| 201 | Python | 32.666661 | 112 | 0.716418 |
omniverse-code/kit/exts/omni.graph.io/omni/graph/io/tests/test_prim_data_import_export.py | import omni.graph.core as ogc
import omni.kit.test
class TestPrimDataImportExport(ogc.tests.OmniGraphTestCase):
"""Run a unit test to validate data flow through bundles."""
TEST_GRAPH_PATH = "/TestGraph"
TRANSLATE = (10.0, 20.0, 30.0)
ROTATE = (90.0, 180.0, 270.0)
SCALE = (400.0, 500.0, 600.0)
async def setUp(self):
"""Set up test environment, to be torn down when done"""
await super().setUp()
self.controller = ogc.Controller()
self.graph = self.controller.create_graph(self.TEST_GRAPH_PATH)
self.context = self.graph.get_default_graph_context()
# Create ImportUSDPrim and ExportUSDPrim and connect them together.
(self.graph, (self.importNode, self.exportNode), _, _,) = self.controller.edit(
self.TEST_GRAPH_PATH,
{
ogc.Controller.Keys.CREATE_NODES: [
("import_usd_prim_data", "omni.graph.ImportUSDPrim"),
("export_usd_prim_data", "omni.graph.ExportUSDPrim"),
],
ogc.Controller.Keys.CONNECT: [
(
"import_usd_prim_data.outputs_output",
"export_usd_prim_data.inputs:bundle",
)
],
},
)
stage = omni.usd.get_context().get_stage()
# Create two Xform nodes, one as input, the other as output.
self.input_prim = ogc.Controller.create_prim("/input_prim", {}, "Xform")
self.output_prim = ogc.Controller.create_prim("/output_prim", {}, "Xform")
omni.kit.commands.execute(
"AddRelationshipTarget",
relationship=stage.GetPropertyAtPath(self.TEST_GRAPH_PATH + "/import_usd_prim_data.inputs:prim"),
target=self.input_prim.GetPath(),
)
omni.kit.commands.execute(
"AddRelationshipTarget",
relationship=stage.GetPropertyAtPath(self.TEST_GRAPH_PATH + "/export_usd_prim_data.outputs:prim"),
target=self.output_prim.GetPath(),
)
async def test_set_attributes(self):
"""Test whether attribute value changes of the input prim will be synced to the output prim."""
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Before graph evaluation, the output prim is still with its default attribute values.
self.assertFalse(self.output_prim.GetAttribute("xformOp:translate").Get() == self.TRANSLATE)
self.assertFalse(self.output_prim.GetAttribute("xformOp:rotateXYZ").Get() == self.ROTATE)
self.assertFalse(self.output_prim.GetAttribute("xformOp:scale").Get() == self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# After graph evaluation, the output prim has been fed with data from the input prim.
self.assertTrue(self.output_prim.GetAttribute("xformOp:translate").Get() == self.TRANSLATE)
self.assertTrue(self.output_prim.GetAttribute("xformOp:rotateXYZ").Get() == self.ROTATE)
self.assertTrue(self.output_prim.GetAttribute("xformOp:scale").Get() == self.SCALE)
async def test_bundle_attributes_and_metadata(self):
"""Test bundle attributes and metadata"""
# Get the bundle from the import node.
bundle = self.context.get_output_bundle(self.importNode, "outputs_output")
self.assertTrue(bundle.is_valid())
# Attribute names and types before evaluation.
attr_names, attr_types = bundle.get_attribute_names_and_types()
self.assertTrue(len(attr_names) == 0)
self.assertTrue(len(attr_types) == 0)
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# Attribute names and types after evaluation.
attr_names, attr_types = bundle.get_attribute_names_and_types()
self.assertTrue(len(attr_names) != 0)
self.assertTrue(len(attr_types) != 0)
# Internal attributes shouldn't be exposed.
metadata_names = {
"interpolation",
"source",
"bundlePrimIndexOffset",
}
self.assertTrue(metadata_names.isdisjoint(set(attr_names)))
# Convert bundle to IBundle2 for metadata access.
factory = ogc.IBundleFactory.create()
bundle = factory.get_bundle(self.context, bundle)
# Test metadata names.
self.assertEqual(
set(bundle.get_bundle_metadata_names()),
{"bundlePrimIndexOffset"},
)
async def test_bundle_dirty_id(self):
"""Test whether bundleDirtyID bumps after graph evaluation."""
factory = ogc.IBundleFactory.create()
# Get the output bundle from the importer and convert to IBundle2.
output_bundle = self.context.get_output_bundle(self.importNode, "outputs_output")
output_bundle = factory.get_bundle(self.context, output_bundle)
# Get the input bundle from the exporter and convert to IBundle2.
input_bundle = self.context.get_input_bundle(self.exportNode, "inputs:bundle")
input_bundle = factory.get_bundle(self.context, input_bundle)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
dirty_id = ogc._og_unstable.IDirtyID2.create(self.context) # noqa: PLW0212
# Get dirty id.
output_dirty_id = dirty_id.get([output_bundle])[0]
input_dirty_id = dirty_id.get([input_bundle])[0]
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# The dirty id doesn't bump because nothing gets changed.
self.assertEqual(output_dirty_id, dirty_id.get([output_bundle])[0])
self.assertEqual(input_dirty_id, dirty_id.get([input_bundle])[0])
# Assign new TRS values to the input prim.
self.input_prim.GetAttribute("xformOp:translate").Set(self.TRANSLATE)
self.input_prim.GetAttribute("xformOp:rotateXYZ").Set(self.ROTATE)
self.input_prim.GetAttribute("xformOp:scale").Set(self.SCALE)
# Trigger graph evaluation and wait for completion.
await ogc.Controller.evaluate(self.graph)
# The dirty id bumps because of TRS value changes.
self.assertNotEqual(output_dirty_id, dirty_id.get([output_bundle])[0])
self.assertNotEqual(input_dirty_id, dirty_id.get([input_bundle])[0])
async def test_child_bundle_order(self):
"""Test whether the order of child bundles extracted from the output bundle is consistent with that of target prims."""
graph_path = "/TestGraph2"
cubes = [("/cube_1", 1.0), ("/cube_2", 2.0), ("/cube_3", 3.0), ("/cube_4", 4.0)]
attr_name = "size"
controller = ogc.Controller()
keys = ogc.Controller.Keys
(graph, (_, output_node), _, _,) = controller.edit(
graph_path,
{
keys.CREATE_NODES: [
("import_usd_prim_data", "omni.graph.ImportUSDPrim"),
("bundle_to_usda_text", "omni.graph.BundleToUSDA"),
],
keys.CONNECT: [
("import_usd_prim_data.outputs_output", "bundle_to_usda_text.inputs:bundle"),
],
keys.SET_VALUES: ("import_usd_prim_data.inputs:attrNamesToImport", attr_name),
},
)
# Create target prims and assign the size attribute with different values.
for cube_path, cube_size in cubes:
prim = ogc.Controller.create_prim(cube_path, {}, "Cube")
prim.GetAttribute(attr_name).Set(cube_size)
# Assign the target prims to the import node.
stage = omni.usd.get_context().get_stage()
omni.kit.commands.execute(
"SetRelationshipTargets",
relationship=stage.GetPropertyAtPath(graph_path + "/import_usd_prim_data.inputs:prim"),
targets=[cube_path for cube_path, _ in cubes],
)
await ogc.Controller.evaluate(graph)
expected_result = (
'def Cube "cube_1"\n'
"{\n"
" double size = 1.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_1"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_2"\n'
"{\n"
" double size = 2.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_2"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_3"\n'
"{\n"
" double size = 3.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_3"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
'def Cube "cube_4"\n'
"{\n"
" double size = 4.00000000000000000e+00\n"
' token sourcePrimPath = "/cube_4"\n'
' token sourcePrimType = "Cube"\n'
"}\n"
)
# Change timecode to trigger recompute. Run 60 times to eliminate random factor.
for timecode in range(60):
self.controller.edit(
self.TEST_GRAPH_PATH,
{ogc.Controller.Keys.SET_VALUES: ("import_usd_prim_data.inputs:usdTimecode", timecode)},
)
await ogc.Controller.evaluate(self.graph)
output_attr = output_node.get_attribute("outputs:text")
self.assertTrue(output_attr is not None and output_attr.is_valid())
self.assertEqual(output_attr.get(), expected_result)
| 10,119 | Python | 41.521008 | 127 | 0.605989 |
omniverse-code/kit/exts/omni.graph.io/docs/CHANGELOG.md | # CHANGELOG
This document records all notable changes to ``omni.graph.io`` extension.
This project adheres to `Semantic Versioning <https://semver.org/>`_.
<<<<<<< HEAD
=======
## [1.2.5] - 2022-11-18
### Changed
- Allow to be used in headless mode
## [1.2.3] - 2022-08-09
### Fixed
- Applied formatting to all of the Python files
## [1.2.2] - 2022-08-09
### Fixed
- Fixed backward compatibility break for the deprecated `IDirtyID` interface.
## [1.2.1] - 2022-08-03
### Fixed
- Compilation errors related to deprecation of methods in ogn bundle.
## [1.2.0] - 2022-07-28
### Deprecated
- Deprecated `IDirtyID` interface
- Deprecated `BundleAttrib` class and `BundleAttribSource` enumeration
- Deprecated `BundlePrim`, `BundlePrims`, `BundlePrimIterator` and `BundlePrimAttrIterator`
- Deprecated `ConstBundlePrim`, `ConstBundlePrims`, `ConstBundlePrimIterator` and `ConstBundlePrimAttrIterator`
## [1.1.0] - 2022-07-07
### Added
- Test for public API consistency
- Added build handling for tests module
## [1.0.10] - 2021-11-19
- Added option on ImportUsdPrim to include local bounding box of imported prims as a common attribute.
- Fixed case where Import is not re-computed when a transform is needed and an ancestor prim's transform has changed.
## [1.0.9] - 2021-11-10
- Added option on ExportUSDPrim node type to remove, from output prims, any authored attributes that aren't being exported
## [1.0.8] - 2021-10-22
- Should be identical to 1.0.7, but incrementing the version number just in case, for logistical reasons
## [1.0.7] - 2021-10-14
- Added option to export time sampled data to specified time in ExportUSDPrim node type
## [1.0.6] - 2021-10-05
- Fixed re-importing of transforming attributes in ImportUSDPrim node type when transforms change
## [1.0.5] - 2021-09-24
- Added attribute-level change tracking to ImportUSDPrim node type
## [1.0.4] - 2021-09-16
- Added "Attributes to Import" and "Attributes to Export" to corresponding nodes to reduce confusion about how to import/export a subset of attributes
- Added support for importing/exporting "widths" interpolation from USD
## [1.0.3] - 2021-08-18
- Updated for an ABI break in Kit
## [1.0.2] - 2021-08-17
- Fixed crash related to ImportUSDPrim node type and breaking change in Kit from eTransform being deprecated in favour of eMatrix
## [1.0.1] - 2021-08-13
- Fixed crash related to ImportUSDPrim node type
## [1.0.0] - 2021-07-27
### Added
- Initial version. Added ImportUSDPrim, ExportUSDPrim, TransformBundle, and BundleToUSDA node types.
| 2,536 | Markdown | 34.236111 | 150 | 0.734227 |
omniverse-code/kit/exts/omni.graph.io/docs/index.rst | OmniGraph I/O
#############
.. tabularcolumns:: |L|R|
.. csv-table::
:width: 100%
**Extension**: omni.graph.io,**Documentation Generated**: |today|
.. toctree::
:maxdepth: 1
CHANGELOG
| 203 | reStructuredText | 10.999999 | 68 | 0.566502 |
omniverse-code/kit/exts/omni.graph.io/docs/Overview.md | # OmniGraph I/O
```{csv-table}
**Extension**: omni.graph.io,**Documentation Generated**: {sub-ref}`today`
```
| 112 | Markdown | 15.142855 | 74 | 0.642857 |
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnGetCameraTarget.rst | .. _omni_graph_ui_nodes_GetCameraTarget_2:
.. _omni_graph_ui_nodes_GetCameraTarget:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Get Camera Target
:keywords: lang-en omnigraph node sceneGraph:camera threadsafe ui_nodes get-camera-target
Get Camera Target
=================
.. <description>
Gets a viewport camera's target point.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:prim", "``target``", "The camera prim, when 'usePath' is false", "None"
"Camera Path (*inputs:primPath*)", "``token``", "Path of the camera, used when 'usePath' is true", ""
"inputs:usePath", "``bool``", "When true, the 'primPath' attribute is used as the path to the prim being read, otherwise it will read the connection at the 'prim' attribute", "True"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Target (*outputs:target*)", "``pointd[3]``", "The target point", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.GetCameraTarget"
"Version", "2"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Get Camera Target"
"Categories", "sceneGraph:camera"
"Generated Class Name", "OgnGetCameraTargetDatabase"
"Python Module", "omni.graph.ui_nodes"
| 1,887 | reStructuredText | 25.971428 | 185 | 0.579226 |
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnReadWindowSize.rst | .. _omni_graph_ui_nodes_ReadWindowSize_1:
.. _omni_graph_ui_nodes_ReadWindowSize:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Read Window Size (BETA)
:keywords: lang-en omnigraph node ui ReadOnly ui_nodes read-window-size
Read Window Size (BETA)
=======================
.. <description>
Outputs the size of a UI window.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Is Viewport? (*inputs:isViewport*)", "``bool``", "If true then only viewport windows will be considered.", "False"
"Name (*inputs:name*)", "``token``", "Name of the window. If there are multiple windows with the same name the first one found will be used.", "None"
"Widget Path (*inputs:widgetPath*)", "``token``", "Full path to a widget in the window. If specified then 'name' will be ignored and the window containing the widget will be used.", "None"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Height (*outputs:height*)", "``float``", "Height of the window in pixels.", "None"
"Width (*outputs:width*)", "``float``", "Width of the window in pixels.", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.ReadWindowSize"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "Read Window Size (BETA)"
"Categories", "ui"
"Generated Class Name", "OgnReadWindowSizeDatabase"
"Python Module", "omni.graph.ui_nodes"
| 2,058 | reStructuredText | 28 | 192 | 0.581633 |
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnNewFrame.rst | .. _omni_graph_ui_nodes_OnNewFrame_1:
.. _omni_graph_ui_nodes_OnNewFrame:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On New Frame
:keywords: lang-en omnigraph node graph:action,event compute-on-request ui_nodes on-new-frame
On New Frame
============
.. <description>
Triggers when there is a new frame available for the given viewport. Note that the graph will run asynchronously to the new frame event
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:viewport", "``token``", "Name of the viewport, or empty for the default viewport", ""
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:execOut", "``execution``", "Output Execution", "None"
"outputs:frameNumber", "``int``", "The number of the frame which is available", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnNewFrame"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "True"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On New Frame"
"Categories", "graph:action,event"
"Generated Class Name", "OgnOnNewFrameDatabase"
"Python Module", "omni.graph.ui_nodes"
| 1,797 | reStructuredText | 24.685714 | 135 | 0.578186 |
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnWidgetValueChanged.rst | .. _omni_graph_ui_nodes_OnWidgetValueChanged_1:
.. _omni_graph_ui_nodes_OnWidgetValueChanged:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Widget Value Changed (BETA)
:keywords: lang-en omnigraph node graph:action,ui compute-on-request ui_nodes on-widget-value-changed
On Widget Value Changed (BETA)
==============================
.. <description>
Event node which fires when a UI widget with the specified identifier has its value changed. This node should be used in combination with UI creation nodes such as OgnSlider.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Widget Identifier (*inputs:widgetIdentifier*)", "``token``", "A unique identifier identifying the widget. This should be specified in the UI creation node such as OgnSlider.", ""
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"New Value (*outputs:newValue*)", "``['bool', 'float', 'int', 'string']``", "The new value of the widget", "None"
"Value Changed (*outputs:valueChanged*)", "``execution``", "Executed when the value of the widget is changed", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnWidgetValueChanged"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "True"
"Implementation Language", "Python"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Widget Value Changed (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnWidgetValueChangedDatabase"
"Python Module", "omni.graph.ui_nodes"
| 2,111 | reStructuredText | 29.171428 | 183 | 0.600189 |
omniverse-code/kit/exts/omni.graph.ui_nodes/ogn/docs/OgnOnViewportDragged.rst | .. _omni_graph_ui_nodes_OnViewportDragged_1:
.. _omni_graph_ui_nodes_OnViewportDragged:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: On Viewport Dragged (BETA)
:keywords: lang-en omnigraph node graph:action,ui threadsafe compute-on-request ui_nodes on-viewport-dragged
On Viewport Dragged (BETA)
==========================
.. <description>
Event node which fires when a viewport drag event occurs in the specified viewport. Note that viewport mouse events must be enabled on the specified viewport using a SetViewportMode node.
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.ui_nodes<ext_omni_graph_ui_nodes>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Gesture (*inputs:gesture*)", "``token``", "The input gesture to trigger viewport drag events", "Left Mouse Drag"
"", "*displayGroup*", "parameters", ""
"", "*literalOnly*", "1", ""
"", "*allowedTokens*", "Left Mouse Drag,Right Mouse Drag,Middle Mouse Drag", ""
"Only Simulate On Play (*inputs:onlyPlayback*)", "``bool``", "When true, the node is only computed while Stage is being played", "True"
"", "*literalOnly*", "1", ""
"Use Normalized Coords (*inputs:useNormalizedCoords*)", "``bool``", "When true, the components of 2D position outputs are scaled to between 0 and 1, where 0 is top/left and 1 is bottom/right. When false, components are in viewport render resolution pixels.", "False"
"", "*literalOnly*", "1", ""
"Viewport (*inputs:viewport*)", "``token``", "Name of the viewport window to watch for drag events", "Viewport"
"", "*literalOnly*", "1", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Began (*outputs:began*)", "``execution``", "Enabled when the drag begins, populating 'Initial Position' with the current mouse position", "None"
"Ended (*outputs:ended*)", "``execution``", "Enabled when the drag ends, populating 'Final Position' with the current mouse position", "None"
"Final Position (*outputs:finalPosition*)", "``double[2]``", "The mouse position at which the drag ended (valid when 'Ended' is enabled)", "None"
"Initial Position (*outputs:initialPosition*)", "``double[2]``", "The mouse position at which the drag began (valid when either 'Began' or 'Ended' is enabled)", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ui_nodes.OnViewportDragged"
"Version", "1"
"Extension", "omni.graph.ui_nodes"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "tests"
"uiName", "On Viewport Dragged (BETA)"
"Categories", "graph:action,ui"
"Generated Class Name", "OgnOnViewportDraggedDatabase"
"Python Module", "omni.graph.ui_nodes"
| 3,166 | reStructuredText | 38.5875 | 270 | 0.6235 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.