OGN Code Samples - Python 

This files contains a collection of examples for using the .ogn generated code from Python. There is no particular flow to these examples, they are used as reference data for the OGN User Guide.

For examples specific to Action Graph see Action Graph Code Samples - Python.

In the examples below this import will be assumed when describing names from the OmniGraph API, in the spirit of common usage for packages such as numpy or pandas:

import omni.graph.core as og

Contents

OGN Code Samples - Python

Python Generated Database 

When the .ogn files are processed and the implementation language is set to python it generates a database file through which all of the attribute data can be accessed. It also generates some utility functions that are useful in the context of a compute function. For the file OgnMyNode.ogn the database class will be named OgnMyNodeDatabase and can be imported directly from the generated ogn module inside your Python module.

from omni.examples.ogn.OgnMyNodeDatabase import OgnMyNodeDatabase as database

Usually you will not need to import the file though as the compute method is passed an instance to it. The contents of that database file will include these functions:

db.log_error("Explanation of error") # Log an error in the compute
db.log_warning("Explanation of warning") # Log a warning in the compute
db.log_warn("Explanation of warning") # An alias for log_warning
db.inputs # Object containing accessors for all input attribute data
db.outputs # Object containing accessors for all output attribute data
db.state # Object containing accessors for all state attribute data
# Class method to get the internal state data shared by all instances of an authored node
database.shared_internal_state(node)
# Class method to get the internal state data attached to a specific instance of an authored node
database.per_instance_internal_state(node)

The attribute members of db.inputs, db.outputs, and db.state are all properties. The input setter can only be used during node initialization.

Minimal Python Node Implementation 

Every Python node must contain a node class definition with an implementation of the compute method that takes the database as a parameter and returns a boolean indicating if the compute succeeded. To enforce more stringent type checking on compute calls, import the database definition for the declaration.

# This line isn't strictly necessary. It's only useful for more stringent type information of the compute parameter.
# Note how the extra submodule "ogn" is appended to the extension's module to find the database file.
from ogn.examples.ogn.OgnNoOpDatabase import OgnNoOpDatabase


class OgnNoOp:
    @staticmethod
    def compute(db: OgnNoOpDatabase) -> bool:
        """This comment should describe the compute algorithm.
        Running help() on the database class will provide the information from the node type description field in the
        .ogn file. The information here should be a supplement to that, consisting of implementation notes.
        """
        # This logs a warning to the console, once
        db.log_warning("This node does nothing")

        # The node is accessible through the database. Normally you don't have to check its validity as it
        # will already be checked, it's just done here to illustrate access and error logging.
        if db.node is None or not db.node.isValid():
            # This logs an error to the console and should only be used for compute failure
            db.log_error("The node being computed is not valid")
            return False

        return True

Note

For simplicity, the import will be omitted from subsequent examples.