i didnt get the rendering window output when I run my code

When I use this code ,i am getting output like this


i cant see renderd output window , what is the reason

#include <vtk-9.1/vtkVersion.h>
#include <vtk-9.1/vtkActor.h>
#include <vtk-9.1/vtkDiskSource.h>
#include <vtk-9.1/vtkPolyDataMapper.h>
#include <vtk-9.1/vtkRenderer.h>
#include <vtk-9.1/vtkRenderWindow.h>
#include <vtk-9.1/vtkRenderWindowInteractor.h>
#include <vtk-9.1/vtkSmartPointer.h>
#include <vtk-9.1/vtkNamedColors.h>
#include <iostream>

int main() {
    // Print the VTK version
    std::cout << "VTK Version: " << vtkVersion::GetVTKVersion() << std::endl;

// Create a disk source to generate a circle (a disk)
vtkSmartPointer<vtkDiskSource> diskSource = vtkSmartPointer<vtkDiskSource>::New();
diskSource->SetOuterRadius(5.0);
diskSource->SetRadialResolution(100);  // Resolution of the circle

// Create a mapper to map the disk data to graphics
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(diskSource->GetOutputPort());

// Create an actor to represent the circle in the window
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
actor->SetMapper(mapper);

// Create a renderer
vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();

// Create a render window
vtkSmartPointer<vtkRenderWindow> renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->AddRenderer(renderer);

// Create a render window interactor to interact with the window
vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = vtkSmartPointer<vtkRenderWindowInteractor>::New();
renderWindowInteractor->SetRenderWindow(renderWindow);

// Add the actor to the renderer
renderer->AddActor(actor);

// Set the background color to white
vtkSmartPointer<vtkNamedColors> colors = vtkSmartPointer<vtkNamedColors>::New();
renderer->SetBackground(colors->GetColor3d("White").GetData());

// Start the rendering loop
renderWindow->Render();
renderWindowInteractor->Start();

return 0;
}

here i attaching makefile, in this makfile i included deepstream and opencv for developing my application

# Set CUDA version
CUDA_VER ?= 12.2

# Application name
APP := deepstream-test3-app

# Set the DeepStream version
NVDS_VERSION := 7.0

# Directories for libraries and binaries
LIB_INSTALL_DIR ?= /opt/nvidia/deepstream/deepstream-$(NVDS_VERSION)/lib/
APP_INSTALL_DIR ?= /opt/nvidia/deepstream/deepstream-$(NVDS_VERSION)/bin/

# Source and header files
SRCS := $(wildcard *.c)
INCS := $(wildcard *.h)

# Required packages
PKGS := gstreamer-1.0

# Object files
OBJS := $(SRCS:.c=.o)

# Include directories
CXXFLAGS += -I../../../includes \
            -I /usr/local/cuda-$(CUDA_VER)/include \
            -I /usr/include/gstreamer-1.0 \
            -I /usr/include/aarch64-linux-gnu \
            -I /usr/include/glib-2.0 \
            -I /usr/lib/aarch64-linux-gnu/glib-2.0/include \
            -I /usr/include/opencv4 \
            -I/usr/include/vtk-9.1 \
            -I/usr/include/OpenGL \
            -I/usr/include/GL

# Compiler flags (pkg-config for GStreamer)
CXXFLAGS += $(shell pkg-config --cflags $(PKGS))

# Linking libraries
LIBS := $(shell pkg-config --libs $(PKGS))

LIBS += /lib/aarch64-linux-gnu/libGeographic.so.19.2.0

# Add VTK libraries
LIBS += -L/usr/lib/aarch64-linux-gnu -lvtkCommonCore-9.1 -lvtkRenderingCore-9.1 \
        -lvtkIOCore-9.1 -lvtkCommonDataModel-9.1 -lvtkIOGeometry-9.1 \
        -lvtkCommonColor-9.1 -lvtkCommonExecutionModel-9.1 -lvtkIOImage-9.1 \
        -lvtkFiltersSources-9.1 -lvtkInteractionStyle-9.1 -lvtkRenderingOpenGL2-9.1 \
        -lvtkRenderingFreeType-9.1

LIBS += -L/usr/local/cuda-$(CUDA_VER)/lib64 -lcudart -lcuda
LIBS += -L/usr/lib/aarch64-linux-gnu -lGL -lGLU

LIBS += -lvtkpng-9.4
LIBS += $(shell pkg-config --libs opencv4)
LIBS += -lgdal
LIBS += -L/usr/lib/aarch64-linux-gnu -lsqlite3
LIBS += -L/usr/lib/aarch64-linux-gnu -lproj

# All target
all: $(APP)

# Rule to compile object files from source
%.o: %.c $(INCS) Makefile
	$(CXX) -c -o $@ $(CXXFLAGS) $<

# Linking object files to create the final executable
$(APP): $(OBJS) Makefile
	$(CXX) -o $(APP) $(OBJS) $(LIBS)

# Install rule
install: $(APP)
	cp -rv $(APP) $(APP_INSTALL_DIR)

# Clean up generated files
clean:
	rm -rf $(OBJS) $(APP)

These are the Installed packages related to VTK

paar-orin1@ubuntu:~/DiffuseSpheres/test$ dpkg-query -l | grep vtk
ii  libvtk9-dev                                  9.1.0+really9.1.0+dfsg2-3build1             arm64        VTK header files
ii  libvtk9-java                                 9.1.0+really9.1.0+dfsg2-3build1             arm64        VTK - Java language support
ii  libvtk9.1:arm64                              9.1.0+really9.1.0+dfsg2-3build1             arm64        VTK libraries
ii  libvtk9.1-qt:arm64                           9.1.0+really9.1.0+dfsg2-3build1             arm64        VTK libraries, Qt files
ii  python3-vtk9                                 9.1.0+really9.1.0+dfsg2-3build1             arm64        Python bindings for VTK
ii  vtk9                                         9.1.0+really9.1.0+dfsg2-3build1             arm64        Binaries for VTK9

ere i attaching makefile, in this makfile i included deepstream and opencv for developing my application

Use CMake instead of writing your own Makefile.

So try to write a CMakeLists.txt

can you help me what I want to do like this , what are the changes i want to make

Start from the CylinderExample CMakeLists.txt and evolve it to your needs.

Hi When I integrate Deepstream and OpenCV at CMakeLists.txt, My code is working It didnt show any error but i cant see rendering output, here I attaching my code and CMakeLists.txt

#include <gst/gst.h>
#include <glib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <sys/time.h>
#include <cuda_runtime_api.h>
#include <tuple>
#include <GeographicLib/UTMUPS.hpp> // Example: Include a UTM conversion library like GeographicLib or proj

#include "gstnvdsmeta.h"
#include "nvds_yml_parser.h"
#include "gst-nvmessage.h"
#include <opencv2/opencv.hpp>
#include <iostream>
#include <cmath>
#include <vector>
#include <random>
#include <string>
#include <gdal.h>
#include <gdal_priv.h>
#include <ogrsf_frmts.h>
#include "ogr_spatialref.h"
#include <gdal_priv.h>  // For GDAL, used to read shapefiles and handle projections
#include <ogr_api.h>
#include <ogr_geometry.h>
#include <ogr_feature.h>
#include <utility>
#include <vtkActor.h>
#include <vtkCamera.h>
#include <vtkCylinderSource.h>
#include <vtkNamedColors.h>
#include <vtkNew.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>

#include <array>

#define MAX_DISPLAY_LEN 64

#define PGIE_CLASS_ID_VEHICLE 0
#define PGIE_CLASS_ID_PERSON 2

/* By default, OSD process-mode is set to GPU_MODE. To change mode, set as:
 * 0: CPU mode
 * 1: GPU mode
 */
#define OSD_PROCESS_MODE 1

/* By default, OSD will not display text. To display text, change this to 1 */
#define OSD_DISPLAY_TEXT 0

/* The muxer output resolution must be set if the input streams will be of
 * different resolution. The muxer will scale all the input frames to this
 * resolution. */
#define MUXER_OUTPUT_WIDTH 854
#define MUXER_OUTPUT_HEIGHT 480

/* Muxer batch formation timeout, for e.g. 40 millisec. Should ideally be set
 * based on the fastest source's framerate. */
#define MUXER_BATCH_TIMEOUT_USEC 40000

#define TILED_OUTPUT_WIDTH 1280
#define TILED_OUTPUT_HEIGHT 720

/* NVIDIA Decoder source pad memory feature. This feature signifies that source
 * pads having this capability will push GstBuffers containing cuda buffers. */
#define GST_CAPS_FEATURES_NVMM "memory:NVMM"

/* Check for parsing error. */
#define RETURN_ON_PARSER_ERROR(parse_expr) \
  if (NVDS_YAML_PARSER_SUCCESS != parse_expr) { \
    g_printerr("Error in parsing configuration file.\n"); \
    return -1; \
  }




int main(int, char*[])
{
  vtkNew<vtkNamedColors> colors;

  // Set the background color.
  std::array<unsigned char, 4> bkg{{26, 51, 102, 255}};
  colors->SetColor("BkgColor", bkg.data());

  // This creates a polygonal cylinder model with eight circumferential facets
  // (i.e, in practice an octagonal prism).
  vtkNew<vtkCylinderSource> cylinder;
  cylinder->SetResolution(8);

  // The mapper is responsible for pushing the geometry into the graphics
  // library. It may also do color mapping, if scalars or other attributes are
  // defined.
  vtkNew<vtkPolyDataMapper> cylinderMapper;
  cylinderMapper->SetInputConnection(cylinder->GetOutputPort());

  // The actor is a grouping mechanism: besides the geometry (mapper), it
  // also has a property, transformation matrix, and/or texture map.
  // Here we set its color and rotate it around the X and Y axes.
  vtkNew<vtkActor> cylinderActor;
  cylinderActor->SetMapper(cylinderMapper);
  cylinderActor->GetProperty()->SetColor(
      colors->GetColor4d("Tomato").GetData());
  cylinderActor->RotateX(30.0);
  cylinderActor->RotateY(-45.0);

  // The renderer generates the image
  // which is then displayed on the render window.
  // It can be thought of as a scene to which the actor is added
  vtkNew<vtkRenderer> renderer;
  renderer->AddActor(cylinderActor);
  renderer->SetBackground(colors->GetColor3d("BkgColor").GetData());
  // Zoom in a little by accessing the camera and invoking its "Zoom" method.
  renderer->ResetCamera();
  renderer->GetActiveCamera()->Zoom(1.5);

  // The render window is the actual GUI window
  // that appears on the computer screen
  vtkNew<vtkRenderWindow> renderWindow;
  renderWindow->SetSize(300, 300);
  renderWindow->AddRenderer(renderer);
  renderWindow->SetWindowName("Cylinder");

  // The render window interactor captures mouse events
  // and will perform appropriate camera or actor manipulation
  // depending on the nature of the events.
  vtkNew<vtkRenderWindowInteractor> renderWindowInteractor;
  renderWindowInteractor->SetRenderWindow(renderWindow);

  // This starts the event loop and as a side effect causes an initial render.
  renderWindow->Render();
  renderWindowInteractor->Start();

  return EXIT_SUCCESS;
  }

This is CMakeLists.txt

# Set minimum required CMake version
cmake_minimum_required(VERSION 3.12)

# Define the project name
project(DeepstreamTest3App)

# Set CUDA version and paths
set(CUDA_VER "12.2")

# Set the DeepStream version
set(NVDS_VERSION "7.0")

# Find VTK and OpenCV packages
find_package(VTK REQUIRED
  COMPONENTS 
  CommonColor
  CommonCore
  FiltersSources
  InteractionStyle
  RenderingCore
  RenderingFreeType
  RenderingOpenGL2
  IOCore
  IOImage
  CommonDataModel
)

find_package(OpenCV REQUIRED)

# Find GStreamer (for DeepStream)
find_package(PkgConfig REQUIRED)
pkg_check_modules(GSTREAMER REQUIRED gstreamer-1.0)

# Add include directories
include_directories(
  /usr/local/cuda-${CUDA_VER}/include
  /usr/include/gstreamer-1.0
  /usr/include/aarch64-linux-gnu
  /usr/include/glib-2.0
  /usr/lib/aarch64-linux-gnu/glib-2.0/include
  /usr/include/opencv4
  /opt/nvidia/deepstream/deepstream-${NVDS_VERSION}/sources/includes
  ${VTK_INCLUDE_DIRS}
  ${OpenCV_INCLUDE_DIRS}
)

# Define the source files
set(SRCS
  main.cxx
)

# Define the executable
add_executable(${PROJECT_NAME} ${SRCS})

# Set compiler flags
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

# Link directories for DeepStream libraries
link_directories(
  /opt/nvidia/deepstream/deepstream-${NVDS_VERSION}/lib
  /opt/nvidia/deepstream/deepstream-${NVDS_VERSION}/sources/libs
)

# Link libraries
target_link_libraries(${PROJECT_NAME}
  ${GSTREAMER_LIBRARIES}
  ${VTK_LIBRARIES}
  ${OpenCV_LIBS}
  /lib/aarch64-linux-gnu/libGeographic.so.19.2.0
  /usr/local/cuda-${CUDA_VER}/lib64/libcudart.so
  /usr/lib/aarch64-linux-gnu/libcuda.so
  /usr/lib/aarch64-linux-gnu/libproj.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvdsgst_meta.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvds_meta.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvdsgst_helper.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvds_utils.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvds_msgbroker.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvbufsurface.so
  /opt/nvidia/deepstream/deepstream-7.0/lib/libnvbufsurftransform.so
  -lGL
  -lGLU
  -lgdal
  -lsqlite3
)

# Set RPATH for DeepStream libraries
set_target_properties(${PROJECT_NAME} PROPERTIES
  INSTALL_RPATH "/opt/nvidia/deepstream/deepstream-${NVDS_VERSION}/lib"
)

# Install the executable to the DeepStream bin directory
install(TARGETS ${PROJECT_NAME} DESTINATION /opt/nvidia/deepstream/deepstream-${NVDS_VERSION}/bin)

# Enable debugging symbols
set(CMAKE_BUILD_TYPE Debug)

Please help me how to correct my issue