::New();
clock->StartTimer();
for (int i = 0; i < endCount; i++)
{
double max[3]={bounds[1]+vtkMath::Random(0,10),bounds[3]+vtkMath::Random(0,10),bounds[5]+vtkMath::Random(0,10)};
double min[3]={bounds[0]+vtkMath::Random(0,10),bounds[2]+vtkMath::Random(0,10),bounds[4]+vtkMath::Random(0,10)};
renderer->ResetCamera(min[0],max[0],min[1],max[1],min[2],max[2]);
renderWindow->Render();
}
clock->StopTimer();
double frameRate = (double)endCount / clock->GetElapsedTime();
std::cout << "AVERAGE FRAME RATE: " << frameRate << " fps" << std::endl;
```
That gives:
AVERAGE FRAME RATE: 93902.3 fps
The updated codes are attached
[main.cpp](https://discourse.vtk.org/uploads/short-url/kxjvbu7lLwkFrTeR3uuJLnMlwY8.cpp) (4.4 KB) [test.py](https://discourse.vtk.org/uploads/short-url/deJqL8HMslTu8OCH18b52hNFtcD.py) (2.7 KB)
Thank you very much in advance,
Best regards,
Evgeniya
---
### Author:  [@dgobbi](https://discourse.vtk.org/u/dgobbi)
#### Post date: [March 18, 2021, 8:29pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/5 "2021-03-18T20:29:08Z")
You gotta clean up your code. Fix the indentation. Rename variables so that you don’t have nonsense statements like `time+=double(1.0)/(sec)`. Remove superfluous whitespace like the three blank lines before the “ResetCamera” line.
Well-formatted code is much easier to review.
---
### Author:  [@EMalikova](https://discourse.vtk.org/u/EMalikova)
#### Post date: [March 18, 2021, 10:29pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/6 "2021-03-18T22:29:40Z")
[main.cpp](https://discourse.vtk.org/uploads/short-url/EqcoWHichetXecihrX6knqAVfn.cpp) (4.4 KB)
---
### Author:  [@EMalikova](https://discourse.vtk.org/u/EMalikova)
#### Post date: [March 18, 2021, 11:11pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/7 "2021-03-18T23:11:04Z")
A small update. I have just tested this c++ code (VTK\_MODULE\_INIT(vtkRendererOpenGL2); was only added on top) with vtk 8.2 and it gave me the output that seems correct:
## C++ output
seconds 0.000812054
seconds 0.000779867
seconds 0.000838995
seconds 0.000784159
seconds 0.000291109
seconds 0.000329971
seconds 0.000452042
seconds 0.000813961
seconds 0.000782967
seconds 0.000813007
seconds 0.0007689
Total FPS: 130.022
AVERAGE FRAME RATE: 59.9952 fps
Trying the same fix for version compiled with vtk 9.0.1 made no effect.
Also, a version 9.0.1 was compiled and tested as offscreen, 8.2 with x11 (linux system).
---
### Author:  [@dgobbi](https://discourse.vtk.org/u/dgobbi)
#### Post date: [March 19, 2021, 2:43am UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/8 "2021-03-19T02:43:04Z")
In the code, you can check to make sure that vtkRenderer::New() is giving you vtkRendererOpenGL2:
```auto
std::cout << renderer->GetClassName() << std::endl;
```
For rendering benchmarks, you can also check driver information. Especially if you are benchmarking in different environments or between different builds of VTK. This must be called after you have called Render(), not before:
```auto
std::cout << renderWindow->ReportCapabilities() << std::endl;
```
The 60 fps that you are getting is just the frame rate of your monitor. The GPU is capable of rendering much faster than that, but the OpenGL driver is synchronizing to the monitor.
---
### Author:  [@EMalikova](https://discourse.vtk.org/u/EMalikova)
#### Post date: [March 19, 2021, 8:06am UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/9 "2021-03-19T08:06:44Z")
Ok, seems that I has not reloaded the code before compilation.
1. VTK\_MODULE\_INIT(vtkRendereringOpenGL2)
2. renderer-\>GetClassName() - gives vtkRendererOpenGL
The above adjustments DID FIX the frame rate issue in VTK 9.01.
What was happening before these adjustments? The vtk 8.2 codes just did not wanted to run unless I have added them and vtk 9.0 was running without a problem silently (no warnings or something else) but gave me these strange framing rates.
Oh, and what about Python codes? A final result deals with remote rendering, so rendering happens from Python. Is it more appropriate to make FPS measurements from Python or C++?
(it seems that Python code was calling vtkOpenGLRenderer from the beginning).
Best regards,
Evgeniya
---
### Author:  [@dgobbi](https://discourse.vtk.org/u/dgobbi)
#### Post date: [March 19, 2021, 12:53pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/10 "2021-03-19T12:53:12Z")
In VTK 8.2, vtkRenderer::DeviceRender is declared as a pure virtual method, so it will crash unless vtkRenderer is replaced by vtkRenderingOpenGL2:
```auto
/**
* Create an image. Subclasses of vtkRenderer must implement this method.
*/
virtual void DeviceRender() =0;
```
In VTK 9, this method will “do nothing” instead of crashing:
```auto
/**
* Create an image. Subclasses of vtkRenderer must implement this method.
*/
virtual void DeviceRender(){};
```
In Python, when you do “`import vtk`”, everything is imported – so you get vtkRenderingOpenGL2 automatically. It is possible in Python to load only vtkRenderingCore:
```python
from vtkmodules.vtkRenderingCore import *
# without the following line, rendering will not work:
#from vtkmodules.vtkRenderingOpenGL2 import *
# with the following line, vtkRenderingOpenGL2 is imported automatically:
#from vtk import *
```
It is equally valid to measure the FPS from C++ or Python, and the results should be very similar (as long as the rendering is working).
---
### Author:  [@EMalikova](https://discourse.vtk.org/u/EMalikova)
#### Post date: [March 19, 2021, 7:44pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/11 "2021-03-19T19:44:04Z")
Dear David Gobbi,
thank you very much. Do I understand correctly that alternative (less flexible) to VTK\_MODULE\_INIT macro for initialisation of a platform specific vtkRenderingOpenGL2 module during runtime, can be, for example, directly use vtkOpenGLRenderer instead of vtkRenderer?
Best regards,
Evgeniya
---
### Author:  [@dgobbi](https://discourse.vtk.org/u/dgobbi)
#### Post date: [March 19, 2021, 8:15pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/12 "2021-03-19T20:15:21Z")
Hi Evgeniya,
It is not recommended to call vtkOpenGLRenderer::New() yourself, because vtkRenderingOpenGL2 contains necessary OpenGL versions of many classes. For example: vtkOpenGLPolyDataMapper, vtkOpenGLActor, vtkOpenGLCamera, vtkOpenGLLight, vtkOpenGLFramebufferObject.
Many of these classes (like Camera and Light) are created by other classes, and without `VTK_MODULE_INIT(vtkRendereringOpenGL2)` the wrong class will be instantiated.
David
---
### Author:  [@EMalikova](https://discourse.vtk.org/u/EMalikova)
#### Post date: [March 19, 2021, 8:21pm UTC](https://discourse.vtk.org/t/measuring-of-rendering-performance-for-remote-python-based-visualisation/5404/13 "2021-03-19T20:21:00Z")
Ah, I see. Thank you.
Best regards,
Evgeniya