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 one-operator workflow.
• How to use a CountCondition to limit the number of times an operator is executed.

Defining the HelloWorldApp class

For more details, see the Defining an Application Class section.

We define the HelloWorldApp class that inherits from holoscan’s Application base class. An instance of the application is created in main. The run() method will then start the application.

1
  class HelloWorldApp : public holoscan::Application {
2
   public:
3
    void compose() override {
4
      using namespace holoscan;
5
   
6
      // Define the operators, allowing the hello operator to execute once
7
      auto hello = make_operator&lt;ops::HelloWorldOp&gt;("hello", make_condition<CountCondition>(1));
8
   
9
      // Define the workflow by adding operator into the graph
10
      add_operator(hello);
11
    }
12
  };
13
   
14
  int main(int argc, char** argv) {
15
    auto app = holoscan::make_application<HelloWorldApp>();
16
    app->run();
17
   
18
    return 0;
19
  }

Defining the HelloWorldApp workflow

For more details, see the Application Workflows section.

When defining your application class, the primary task is to define the operators used in your application, and the interconnectivity between them to define the application workflow. The HelloWorldApp uses the simplest form of a workflow which consists of a single operator: HelloWorldOp.

For the sake of this first example, we will ignore the details of defining a custom operator to focus on the highlighted information below: when this operator runs (compute), it will print out Hello World! to the standard output:

1
  class HelloWorldOp : public Operator {
2
   public:
3
    HOLOSCAN_OPERATOR_FORWARD_ARGS(HelloWorldOp)
4
   
5
    HelloWorldOp() = default;
6
   
7
    void setup(OperatorSpec& spec) override {
8
    }
9
   
10
    void compute(InputContext& op_input, OutputContext& op_output,
11
                 ExecutionContext& context) override {
12
      std::cout << std::endl;
13
      std::cout << "Hello World!" << std::endl;
14
      std::cout << std::endl;
15
    }
16
  };

Defining the application workflow occurs within the application’s compose() method. In there, we first create an instance of the HelloWorldOp operator defined above, then add it to our simple workflow using add_operator().

1
  class HelloWorldApp : public holoscan::Application {
2
   public:
3
    void compose() override {
4
      using namespace holoscan;
5
   
6
      // Define the operators, allowing the hello operator to execute once
7
      auto hello = make_operator&lt;ops::HelloWorldOp&gt;("hello", make_condition<CountCondition>(1));
8
   
9
      // Define the workflow by adding operator into the graph
10
      add_operator(hello);
11
    }
12
  };

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 to execute the operator only once. We can impose such a condition by passing a CountCondition object as an argument to the operator’s constructor.

For more details, see the Configuring App Operator Conditions section.

Running the Application

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

Hello World!

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