bluebrain / brayns Goto Github PK

In file included from ../uvw/src/uvw/async.hpp:7:0,
from ../uvw/src/uvw.hpp:1,
from ../apps/BraynsService/main.cpp:28:
../uvw/src/uvw/event.hpp: In constructor ‘uvw::ErrorEvent::ErrorEvent(U)’:
../uvw/src/uvw/event.hpp:55:56: error: could not convert ‘((uvw::ErrorEvent*)this)->uvw::ErrorEvent::ec’ from ‘const int’ to ‘uv_err_t {aka uv_err_s}’
: ec{static_cast(val)}, str{uv_strerror(ec)}
^
In file included from ../uvw/src/uvw/resource.hpp:8:0,
from ../uvw/src/uvw/handle.hpp:8,
from ../uvw/src/uvw/async.hpp:8,
from ../uvw/src/uvw.hpp:1,
from ../apps/BraynsService/main.cpp:28:
../uvw/src/uvw/loop.hpp: In static member function ‘static std::shared_ptruvw::Loop uvw::Loop::create()’:
../uvw/src/uvw/loop.hpp:139:41: error: ‘uv_loop_init’ was not declared in this scope
if(uv_loop_init(loop->loop.get())) {
^
In file included from ../uvw/src/uvw/resource.hpp:8:0,
from ../uvw/src/uvw/handle.hpp:8,
from ../uvw/src/uvw/async.hpp:8,
from ../uvw/src/uvw.hpp:1,
from ../apps/BraynsService/main.cpp:28:
../uvw/src/uvw/loop.hpp: In member function ‘void uvw::Loop::close()’:
../uvw/src/uvw/loop.hpp:254:44: error: ‘uv_loop_close’ was not declared in this scope
auto err = uv_loop_close(loop.get());
^
../uvw/src/uvw/loop.hpp:255:41: error: no matching function for call to ‘uvw::ErrorEvent::ErrorEvent()’
if(err) { publish(ErrorEvent{err}); }
^
In file included from ../uvw/src/uvw/async.hpp:7:0,
from ../uvw/src/uvw.hpp:1,
from ../apps/BraynsService/main.cpp:28:
../uvw/src/uvw/event.hpp:54:14: note: candidate: template<class U, class> uvw::ErrorEvent::ErrorEvent(U)
explicit ErrorEvent(U val) noexcept
^
../uvw/src/uvw/event.hpp:54:14: note: template argument deduction/substitution failed:
../uvw/src/uvw/event.hpp:52:8: note: candidate: constexpr uvw::ErrorEvent::ErrorEvent(const uvw::ErrorEvent&)
struct ErrorEvent: Event {
^
../uvw/src/uvw/event.hpp:52:8: note: conversion of argument 1 would be ill-formed:
../uvw/src/uvw/event.hpp:52:8: note: candidate: constexpr uvw::ErrorEvent::ErrorEvent(uvw::ErrorEvent&&)
../uvw/src/uvw/event.hpp:52:8: note: conversion of argument 1 would be ill-formed:
In file included from ../uvw/src/uvw/resource.hpp:8:0,
from ../uvw/src/uvw/handle.hpp:8,
from ../uvw/src/uvw/async.hpp:8,
from ../uvw/src/uvw.hpp:1,
from ../apps/BraynsService/main.cpp:28:
../uvw/src/uvw/loop.hpp: In member function ‘bool uvw::Loop::alive() const’:
../uvw/src/uvw/loop.hpp:288:42: error: ‘uv_loop_alive’ was not declared in this scope
return !(uv_loop_alive(loop.get()) == 0);
^
compilation terminated due to -fmax-errors=5.

Expected: build succeeds, libuv support disabled by CMakeLists if neccessary.

Today, only modifications on camera, settings, etc. by braynsViewer are broadcasted in RocketsPlugin. We don't want to that for braynsService as in between the async render, new changes might be received and then they will be send back to the sender.

To cleanly fix this, we probably would need to double-buffer all objects to separate changes for the current and the next frame. As long as braynsViewer does not become asynchronous this is not needed.

As a result, events sent by Deflect are not broadcasted in RocketsPlugin in the braynsService case.

• explicit light sampling or "next event estimation" direct lighting, where a ray is traced to the light at each bounce for much faster convergence (see http://robbinmarcus.blogspot.ch/2015/12/real-time-raytracing-part-4.html)

Useful for path tracing scenes with area/spot/directional lights. Less useful with environment lighting.

Let's move/remove the growing neuron shader into a module/plugin.

Embree has a new type of superfast BVH builder using Morton codes since Embree 2.1. It builds lower quality BVHs (slower rendering performance) but they are much faster to build than the SAH BVH: https://embree.github.io

Is there a way Ospray can make use of that?

If the user needs super quick real-time dynamic scenes, we should use this BVH. Once the scene remains static (the user may still interact with the scene such as rotating, zooming, changing materials, render modes and DOF etc, but the scene geometry itself doesn't change), we can replace the BVH with a higher quality version (SAH BVH + spatial splits), hopefully without having to throw away the already accumulated samples.

Input: resolution and quality (samples per pixel, etc.. maybe provide presets?)
processing: blocking for the time being, unless #286 allows queueing and async processing (does OSPRay allow that? temporary framebuffer etc. is needed for that)
Output: Image (jpg/png/tiff/raw?)

Request from Christian

"Ability to loop through morphologies of a scene, get their meshing points, apply them a different color, etc."

..only if a new simulation frame has been selected.

Scenario:

• change materialLUT from HTTP (viztools, Sauron)
• watch no difference in rendered image
• select another simulation frame
• watch your new colormap

Make it possible to add, remove and modify "objects" in the scene. By objects, we understands things like circuits, volumes, meshes, point clouds, etc.

• Define a C++ API
• Define the pending REST/WS API
• Make it possible to have several instances of the same object, with different transformations.

Requested by Christian:

"- Ability to add morphologies to an existing scene (ideally, by specifying the path to a file; ability to read .asc would be nice... but not essential)

• Ability to add meshes to an existing scene (ideally, by specifying the path to a file)"

Request from Christian:

"Ability to apply a transformation to scene morphologies and meshes (rotation, translation, scaling)"

This would require:

• object picking
• highlight the active object (e.g. by showing a bounding box in WebGL or highlighting the name in a list of scene objects)
• a WebGL 3d transform manipulator widget (like https://threejs.org/examples/#misc_controls_transform)

I hope I am not requesting features that are actually already there. Here are some relatively low-level features (e.g., as compared to calls that manage the visualization of whole circuits from CircuitConfig files) that would really empower the users to use Brayns in daily debugging, investigation, and visualization:

• Ability to add morphologies to an existing scene (ideally, by specifying the path to a file; ability to read .asc would be nice... but not essential)
• Ability to add meshes to an existing scene (ideally, by specifying the path to a file)
• Ability to apply a transformation to scene morphologies and meshes (rotation, translation, scaling)
• Ability to loop through morphologies of a scene, get their meshing points, apply them a different color, etc.

As a user involved in circuit building, these low level features are in the end more useful to me than more high-level (e.g., single-call visualization of circuits) because I can build high-level features from low-level ones, but I cannot do it the other way around.

Enables RPCs in Brayns, next to object/state modifications. Picking, reset-camera and quit application are the first candidates. All websocket messages are using JSON RPC.

Requires JSON RPC from Rockets

Use case: drag&drop file(s) from the client, send the blob to Brayns and load the blob (mesh, xyz, ...) accordingly

Currently, when there is no simulation we set the {end, current} params to int_max. They should be set to 0 or never broadcast the frame if there is no simulation.

The output from Embree's path tracer example code differs significantly from Ospray's (which looks strange).

• Check whether Ospray's path tracer implementation is correct
• Compare to Embree, Blender Cycles or Mitsuba.

brayns mesh loader requires assimp, but doesn't check for it in cmakefile - simply creates link error after compiling.

braynsViewer --help and braynsService --help does not work, the application starts and ignores the --help parameter.

Sauron/Brayns-UI displays the "Cannot connect to the renderer" a lot when running Brayns on my MacBook (connected via Wifi). Sometimes I see a brief glimpse of the default Cornell box before the error occurs, other times it appears straight away.

Restarted Docker a couple of times, but to no avail.

Used: http://brayns.ocp.bbp.epfl.ch/?host=localhost:8200 to run Brayns. Can this address handle multiple users at once?

• slider for ao distance
• compare ao shader to other renderers e.g. Mitsuba (which has a very nice ao solution) for correctness

If a lot of morphologies are loaded, it generates a huge load of messages. Maybe in general all message sends should be throttled. Reuse the image stream fps?

TBB provides concurrent vector with stl API and avoids mixing TBB and OPENMP
https://software.intel.com/en-us/node/506203

Instead of having /simulation-histogram and /volume-histogram we should have a single /histogram endpoint.

If it's necessary to differentiate between the two, we can use the request body/params to do so.

(including focal distance and aperture size)

More costly than the current DOF solution, as it requires more random number generation, but looks much better while interacting.

(for an example, see lines 700-718 in https://github.com/straaljager/GPU-path-tracing-tutorial-3/blob/master/cuda_pathtracer.cu)

When subproject_zerobuf is disabled, some code still thinks it's enabled, then fails

[ 64%] Building CXX object brayns/common/CMakeFiles/braynsCommon.dir/camera/Camera.cpp.o
/home/wald/Projects/Brayns/brayns/common/camera/Camera.cpp:25:37: fatal error: zerobuf/render/camera.h: No such file or directory
compilation terminated.

Mainly for (external) use-cases. Needs a stable (plugin) API and version checking.

To ensure smooth interaction when in path tracing mode, switch to simple direct lighting when moving the camera, similar to https://www.shadertoy.com/view/4lVGRW

• requires groups in the use case plugin

• naive path tracing
• fixed max path length

Rotating the camera seems to make the model tilt around the center of rotation. I'm not sure if this is the expected behaviour, but it's a bit odd.

• Move all the common_find_package() calls to the top-level CMakeLists. This is needed so that the return() from the common_find_package macro works correctly if a REQUIRED dependency is not found when Brayns is a subproject.
• Replace all

option(BRAYNS_ENABLE_FOO "Enable Foo support" OFF)
if(BRAYNS_ENABLE_FOO)
  common_find_package(foo)
endif()

with:

common_find_package(foo)
if(FOO_FOUND)
  option(BRAYNS_ENABLE_FOO "Enable Foo support" ON)
endif()

This logic has the advantage of enabling all the options that are found by default and still lets users disable them if need be.

cmake ../ -DBRAYNS_BRION_ENABLED=OFF -DBRAYNS_DEFLECT_ENABLED=OFF -DBRAYNS_IMAGEMAGICK_ENABLED=OFF -DBRAYNS_REST_ENABLED=OFF -DSUBPROJECT_Brion=OFF -DSUBPROJECT_Deflect=OFF -DSUBPROJECT_Keyv=OFF -DSUBPROJECT_Lexis=OFF -DSUBPROJECT_Lunchbox=OFF -DSUBPROJECT_MVDTool=OFF -DSUBPROJECT_ZeroBuf=OFF -DSUBPROJECT_ZeroEQ=OFF -DSUBPROJECT_cppnetlib=OFF

gives

[ 51%] Building CXX object brayns/io/CMakeFiles/braynsIO.dir/NESTLoader.cpp.o
/home/wald/Projects/Brayns/brayns/io/NESTLoader.cpp:28:19: fatal error: H5Cpp.h: No such file or directory

(note libhdf5-dev is installed:
wald@luchser:~/Projects/Brayns/bin$ ll /usr/include/hdf5/serial/H5Cpp.h
-rw-r--r-- 1 root root 2.2k Apr 5 2016 /usr/include/hdf5/serial/H5Cpp.h
)

Path tracing feature: Rays that "miss" the scene, but hit the background (an HDRI environment light) illuminate the scene

AFAIK, the server currently sends an image to the client with each sample. This interval could be progressively decreased (less frequent updates) when the camera is stationary (no user interaction) and samples are accumulated (e.g. once every sample during the first 10 samples, then only once every 10 samples) to save bandwidth.
JPEGs could also be replaced by PNGs after a while.

We should have two API endpoints (rpc events):

• search - returns various data specific info, etc.
• action - reacts to rpc request with id from search object

Save state of materials, lights, camera positions and parameters (not scene geometry itself)

As a user, I should be able to pick a time interval for generating a movie for a simulation.

We should rename /frame to /animation-parameters and follow the same pattern as with the other params endpoints.

Brayns automatically pulled some packages, but ZeroEQ remains as a dependency I have to install manually . Is this intended?

When interacting with the scene (camera rotation, changing lights, materials, DOF, ...), enable subsampling (blocks of 2x2 or 3x3 pixels) when the framerate drops below 15 fps. Revert back to full res rendering and start accumulating samples when there are no more changes.

It's not clear if AA is being applied in Brayns/Ospray as some aliasing is noticeable (most noticeable on very thin branches such as in the image below), which does not disappear over time.

If the entire area of each pixel is explored randomly, I would expect that even very fine subpixel geometry like distant branches would become clearly visible after enough samples are accumulated. It's also possible that the only way to get rid of the aliasing artefacts is to render at higher resolution and then downsample.