Hello World

For our first example, we look at how to create a Hello World example using the Holoscan SDK.

In this example we’ll cover:

• how to define your application class

• how to define a custom operator class

• how to define a one-operator workflow

• how to use a CountCondition to limit the number of times an operator is executed

Every Holoscan application requires defining an Application class. Creating a new Application starts with inheriting from the Application base class which in turn inherits from the Fragment class to provide the functionalities of a Fragment (i.e., creating a workflow and running it). When defining your application class, the primary task is to override the Application’s compose() method to define the operators used in your application and the interconnectivity between the operators to define the application workflow. For more details, see the section on Creating an Application.

The following code snippet shows an example Application code skeleton:

            

            
#include 
  
 
class App : public holoscan::Application {  public:
 void compose() override {     using namespace holoscan;

    // Define Operators
    // ...

    // Define the workflow
    // ...

  }
};

int main() {
 auto app = holoscan::make_application<App>();  app->run(); 
  return 0;
}
        

            

            
from holoscan.conditions import CountCondition from holoscan.core import Application, Operator, OperatorSpec 
class App(Application): 
 def compose(self):         # Define Operators
        # ...

        # Define the workflow
        # ...

if __name__ == "__main__":
 app = App()  app.run() 
        

Operators are the unit of work in the Holoscan SDK Framework. An operator receives streaming data at an input port, processes it, and publishes it to one of its output ports. There are several categories of operators in the framework, but in this tutorial we will be referring to Native C++/Python operators unless mentioned otherwise. For more details on how operators work and the different categories of operators, see C++ Operators and Python Operators.

The Hello World example uses the simplest form of a workflow which consists of a single operator.

Fig. 5 A one-operator workflow

The HelloWorldOp has neither input nor output ports. Whenever this operator’s compute() method is invoked by the Scheduler, it simply prints a Hello World message to standard output. We can add an operator to the workflow by calling add_operator() in the application’s compose() method.

The following code snippet shows how to define the custom HelloWordOp operator class.

            

            
#include <iostream>
#include <holoscan/holoscan.hpp>

namespace holoscan::ops {

class HelloWorldOp : public Operator {  public:
  HOLOSCAN_OPERATOR_FORWARD_ARGS(HelloWorldOp)

  HelloWorldOp() = default;

  void setup(OperatorSpec& spec) override {
  }

 void compute(InputContext& op_input, OutputContext& op_output,                ExecutionContext& context) override {
    std::cout << std::endl;
    std::cout << "Hello World!\n";
    std::cout << std::endl;
  }
};

}  // namespace holoscan::ops
        

            

            
from holoscan.conditions import CountCondition
from holoscan.core import Application, Operator, OperatorSpec

class HelloWorldOp(Operator):     """Simple hello world operator.

This operator has no ports.

On each tick, this operator prints out hello world.
"""

    def setup(self, spec: OperatorSpec):
        pass

 def compute(self, op_input, op_output, context):         print("")
        print("Hello World!")
        print("")
        

Holoscan applications deal with streaming data, so an operator’s compute() method will be called continuously until some situation arises that causes the operator to stop. For our Hello World example, we want the operator’s compute() method to be called once, and we can impose such a condition by passing a CountConditionobject as an argument the the operator’s constructor.

            

            
class HelloWorldApp : public holoscan::Application {  public:
  void compose() override {
    using namespace holoscan;

    // Define the operators, allowing the hello operator to execute once
 auto hello = make_operator<ops::HelloWorldOp>("hello", make_condition<CountCondition>(1)); 
    // Define the workflow by adding operator into the graph
 add_operator(hello);   }
};

int main(int argc, char** argv) {
  auto app = holoscan::make_application<HelloWorldApp>();
  app->run();

  return 0;
}
        

            

            
class HelloWorldApp(Application):     def compose(self):
        # Define the operators
 hello = HelloWorldOp(self, CountCondition(self, 1), name="hello") 
        # Define the one-operator workflow
 self.add_operator(hello) 

if __name__ == "__main__":
    app = HelloWorldApp()
    app.run()
        

To run the application, please refer to the run instructions for your type of installation found on GitHub under the examples directory.

Running the application should give you the following output in your terminal:

            

            
Hello World!
        

Congratulations! You have successfully run your first Holoscan SDK application!