Skip to content

Commit 2381e92

Browse files
wilsonCernWqwilsonCernWq
committed
cleanup codes, updare readme, add dockerfile
1 parent d6567a5 commit 2381e92

File tree

6 files changed

+209
-132
lines changed

6 files changed

+209
-132
lines changed

‎.gitmodules

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
11
[submodule "tcnn"]
22
path = tcnn
3-
url = git@github.com:wilsonCernWq/tiny-cuda-nn.git
3+
url = https://github.com/wilsonCernWq/tiny-cuda-nn.git

‎Dockerfile

+49
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
# Example Command to Run
2+
# docker build -t instantvnr .
3+
# xhost +si:localuser:root
4+
# docker run --runtime=nvidia -ti --rm -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix instantvnr
5+
# docker run --runtime=nvidia -ti --rm -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix -v ${PWD}:/instantvnr/source -w /instantvnr/build instantvnr
6+
7+
FROM nvidia/cuda:11.6.2-devel-ubuntu20.04
8+
9+
ARG DEBIAN_FRONTEND=noninteractive
10+
11+
RUN apt-get update
12+
RUN apt-get install -y --no-install-recommends \
13+
build-essential mesa-utils pkg-config \
14+
libglx0 libglvnd0 libglvnd-dev \
15+
libgl1 libgl1-mesa-dev \
16+
libegl1 libegl1-mesa-dev \
17+
libgles2 libgles2-mesa-dev \
18+
libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libssl-dev \
19+
libaio-dev \
20+
wget git ninja-build imagemagick
21+
# RUN rm -rf /var/lib/apt/lists/*
22+
23+
ENV NVIDIA_VISIBLE_DEVICES all
24+
ENV NVIDIA_DRIVER_CAPABILITIES compute,utility,graphics
25+
ADD https://raw.githubusercontent.com/NVlabs/nvdiffrec/main/docker/10_nvidia.json \
26+
/usr/share/glvnd/egl_vendor.d/10_nvidia.json
27+
28+
# Install cmake
29+
RUN wget -qO- "https://cmake.org/files/v3.23/cmake-3.23.2-linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local
30+
31+
# Install tbb
32+
RUN wget -qO- "https://github.com/oneapi-src/oneTBB/releases/download/v2021.9.0/oneapi-tbb-2021.9.0-lin.tgz" | tar --strip-components=1 -xz -C /usr/local
33+
34+
# Create a superbuild
35+
RUN git clone --recursive https://github.com/VIDILabs/open-volume-renderer.git /instantvnr/ovr
36+
RUN git clone --recursive https://github.com/VIDILabs/instantvnr.git /instantvnr/source
37+
RUN ln -s /instantvnr/source /instantvnr/ovr/projects/instantvnr
38+
39+
# Config and build
40+
RUN mkdir -p /instantvnr/build
41+
RUN cmake -S /instantvnr/ovr -B/instantvnr/build -GNinja \
42+
-DOptiX_INSTALL_DIR=/instantvnr/ovr/github-actions/optix-cmake-github-actions/NVIDIA-OptiX-SDK-7.3.0-linux64-x86_64 \
43+
-DGDT_CUDA_ARCHITECTURES=75 -DOVR_BUILD_MODULE_NNVOLUME=ON -DOVR_BUILD_DEVICE_OSPRAY=OFF -DOVR_BUILD_DEVICE_OPTIX7=ON
44+
RUN cmake --build /instantvnr/build --config Release --parallel 16
45+
46+
RUN ln -s /instantvnr/ovr/data /instantvnr/build/data
47+
RUN cp /instantvnr/source/example-model.json /instantvnr/build/example-model.json
48+
49+
WORKDIR [ '/instantvnr/build' ]

‎README.md

+15-1
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,23 @@ cmake .. -DGDT_CUDA_ARCHITECTURES=86 -DOVR_BUILD_MODULE_NNVOLUME=ON -DOVR_BUILD_
4040
cmake --build . --config Release --parallel 16
4141
```
4242

43+
We also provide a docker container to build the project entirely
44+
```
45+
```
46+
4347
### Execution
4448
```
45-
TODO ...
49+
# # In the binary output directory, setup symbolic links to the data folder
50+
# ln -s ../../data .
51+
# cp ../../projects/instantvnr/example-model.json .
52+
53+
./vnr_int_dual --rendering-mode 14 --volume ./data/configs/scene_vorts1.json --network ./example-model.json
54+
55+
./vnr_int_single --neural-volume ./params.json --tfn ./data/configs/scene_vorts1.json --rendering-mode 5
56+
57+
./vnr_cmd_train --volume ./data/configs/scene_vorts1.json --network ./example-model.json
58+
59+
./vnr_cmd_render --neural-volume ./params.json --tfn ./data/configs/scene_vorts1.json --rendering-mode 5 --num-frames 16
4660
```
4761

4862
### Citation

‎apps/int_dual_volume.cpp

+2
Original file line numberDiff line numberDiff line change
@@ -366,6 +366,8 @@ struct MainWindow : public glfwapp::GLFCameraWindow {
366366
, background_task(std::bind(&MainWindow::background_work, this))
367367
, args(commandline)
368368
{
369+
ImPlot::CreateContext();
370+
369371
glEnable(GL_TEXTURE_2D);
370372
glEnable(GL_BLEND);
371373
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

‎core/samplers/neural_sampler.cpp

+142
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,21 @@
11
#include "neural_sampler.h"
22

3+
namespace vidi {
4+
enum VoxelType {
5+
VOXEL_UINT8 = vnr::VALUE_TYPE_UINT8,
6+
VOXEL_INT8 = vnr::VALUE_TYPE_INT8,
7+
VOXEL_UINT16 = vnr::VALUE_TYPE_UINT16,
8+
VOXEL_INT16 = vnr::VALUE_TYPE_INT16,
9+
VOXEL_UINT32 = vnr::VALUE_TYPE_UINT32,
10+
VOXEL_INT32 = vnr::VALUE_TYPE_INT32,
11+
VOXEL_FLOAT = vnr::VALUE_TYPE_FLOAT,
12+
VOXEL_DOUBLE = vnr::VALUE_TYPE_DOUBLE,
13+
};
14+
} // namespace vidi
15+
#define VIDI_VOLUME_EXTERNAL_TYPE_ENUM
16+
#include <vidi_parallel_algorithm.h>
17+
#include <vidi_volume_reader.h>
18+
319

420
#ifdef ENABLE_OUT_OF_CORE
521

@@ -149,6 +165,132 @@ isclose(float a, float b, float rel_tol = 10*float_epsilon, float abs_tol = 0.0)
149165
//
150166
// ------------------------------------------------------------------
151167

168+
namespace {
169+
170+
// template<class T>
171+
// constexpr const T& clamp(const T& v, const T& lo, const T& hi)
172+
// {
173+
// return (v < lo) ? lo : (hi < v) ? hi : v;
174+
// }
175+
176+
template<typename IType>
177+
std::shared_ptr<char[]>
178+
convert_volume(std::shared_ptr<char[]> idata, size_t size, float vmin, float vmax)
179+
{
180+
std::shared_ptr<char[]> odata;
181+
odata.reset(new char[size * sizeof(float)]);
182+
183+
tbb::parallel_for(size_t(0), size, [&](size_t idx) {
184+
auto* i = (IType*)&idata[idx * sizeof(IType)];
185+
auto* o = (float*)&odata[idx * sizeof(float)];
186+
#ifdef TEST_SIREN
187+
*o = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f) * 2.f - 1.f;
188+
#else
189+
*o = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f);
190+
#endif
191+
});
192+
193+
return odata;
194+
}
195+
196+
template<>
197+
std::shared_ptr<char[]>
198+
convert_volume<float>(std::shared_ptr<char[]> idata, size_t size, float vmin, float vmax)
199+
{
200+
tbb::parallel_for(size_t(0), size, [&](size_t idx) {
201+
auto* i = (float*)&idata[idx * sizeof(float)];
202+
#ifdef TEST_SIREN
203+
*i = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f) * 2.f - 1.f;
204+
#else
205+
*i = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f);
206+
#endif
207+
});
208+
209+
return idata;
210+
}
211+
212+
template<typename T>
213+
static range1f
214+
compute_scalar_fminmax(const void* _array, size_t count)
215+
{
216+
using vidi::parallel::compute_scalar_minmax;
217+
auto r = compute_scalar_minmax<T>(_array, count, 0);
218+
return range1f((float)r.first, (float)r.second);
219+
}
220+
221+
} // namespace
222+
223+
void
224+
StaticSampler::load(const MultiVolume::File& desc,
225+
vec3i dims, dtype type, range1f minmax,
226+
std::shared_ptr<char[]>& buffer,
227+
range1f& value_range_unnormalized,
228+
range1f& value_range_normalized)
229+
{
230+
const auto& offset = desc.offset;
231+
const auto& filename = desc.filename;
232+
const auto& is_big_endian = desc.bigendian;
233+
234+
/* load data from file */
235+
{
236+
vidi::StructuredRegularVolumeDesc desc;
237+
desc.dims.x = dims.x;
238+
desc.dims.y = dims.y;
239+
desc.dims.z = dims.z;
240+
desc.type = (vidi::VoxelType)type;
241+
desc.offset = offset;
242+
desc.is_big_endian = is_big_endian;
243+
buffer = vidi::read_volume_structured_regular(filename, desc);
244+
}
245+
246+
/* copy data to GPU */
247+
const size_t count = (size_t)dims.x * dims.y * dims.z;
248+
249+
/* convert volume into floats */
250+
range1f range;
251+
{
252+
if (minmax.is_empty()) {
253+
switch (type) {
254+
case VALUE_TYPE_UINT8: range = compute_scalar_fminmax<uint8_t>(buffer.get(), count); break;
255+
case VALUE_TYPE_INT8: range = compute_scalar_fminmax<int8_t>(buffer.get(), count); break;
256+
case VALUE_TYPE_UINT16: range = compute_scalar_fminmax<uint16_t>(buffer.get(), count); break;
257+
case VALUE_TYPE_INT16: range = compute_scalar_fminmax<int16_t>(buffer.get(), count); break;
258+
case VALUE_TYPE_UINT32: range = compute_scalar_fminmax<uint32_t>(buffer.get(), count); break;
259+
case VALUE_TYPE_INT32: range = compute_scalar_fminmax<int32_t>(buffer.get(), count); break;
260+
case VALUE_TYPE_FLOAT: range = compute_scalar_fminmax<float>(buffer.get(), count); break;
261+
case VALUE_TYPE_DOUBLE: range = compute_scalar_fminmax<double>(buffer.get(), count); break;
262+
default: throw std::runtime_error("unknown data type");
263+
}
264+
}
265+
else {
266+
range = minmax;
267+
}
268+
269+
switch (type) {
270+
case VALUE_TYPE_UINT8: buffer = convert_volume<uint8_t> (buffer, count, range.lower, range.upper); break;
271+
case VALUE_TYPE_INT8: buffer = convert_volume<int8_t> (buffer, count, range.lower, range.upper); break;
272+
case VALUE_TYPE_UINT16: buffer = convert_volume<uint16_t>(buffer, count, range.lower, range.upper); break;
273+
case VALUE_TYPE_INT16: buffer = convert_volume<int16_t> (buffer, count, range.lower, range.upper); break;
274+
case VALUE_TYPE_UINT32: buffer = convert_volume<uint32_t>(buffer, count, range.lower, range.upper); break;
275+
case VALUE_TYPE_INT32: buffer = convert_volume<int32_t> (buffer, count, range.lower, range.upper); break;
276+
case VALUE_TYPE_FLOAT: buffer = convert_volume<float> (buffer, count, range.lower, range.upper); break;
277+
case VALUE_TYPE_DOUBLE: buffer = convert_volume<double> (buffer, count, range.lower, range.upper); break;
278+
default: throw std::runtime_error("unknown data type");
279+
}
280+
}
281+
value_range_unnormalized = range;
282+
value_range_normalized.lower = 0.f;
283+
value_range_normalized.upper = 1.f;
284+
// std::tie(value_range_normalized.lower, value_range_normalized.upper) = vidi::parallel::compute_scalar_minmax<float>(buffer.get(), count, 0);
285+
286+
log() << "[vnr] unnormalized range " << value_range_unnormalized.lower << " " << value_range_unnormalized.upper << std::endl;
287+
log() << "[vnr] normalized range " << value_range_normalized.lower << " " << value_range_normalized.upper << std::endl;
288+
}
289+
290+
// ------------------------------------------------------------------
291+
//
292+
// ------------------------------------------------------------------
293+
152294
template<typename F>
153295
static float
154296
nearest_vkl(const vec3f& p_cell_centered, const vec3i& m_dims, const F& accessor)

‎core/samplers/neural_sampler.cu

-130
Original file line numberDiff line numberDiff line change
@@ -4,24 +4,6 @@
44
using TCNN_NAMESPACE :: generate_random_uniform;
55
using default_rng_t = TCNN_NAMESPACE :: default_rng_t;
66

7-
namespace vidi {
8-
enum VoxelType {
9-
VOXEL_UINT8 = vnr::VALUE_TYPE_UINT8,
10-
VOXEL_INT8 = vnr::VALUE_TYPE_INT8,
11-
VOXEL_UINT16 = vnr::VALUE_TYPE_UINT16,
12-
VOXEL_INT16 = vnr::VALUE_TYPE_INT16,
13-
VOXEL_UINT32 = vnr::VALUE_TYPE_UINT32,
14-
VOXEL_INT32 = vnr::VALUE_TYPE_INT32,
15-
VOXEL_FLOAT = vnr::VALUE_TYPE_FLOAT,
16-
VOXEL_DOUBLE = vnr::VALUE_TYPE_DOUBLE,
17-
};
18-
} // namespace vidi
19-
#define VIDI_VOLUME_EXTERNAL_TYPE_ENUM
20-
#include <vidi_parallel_algorithm.h>
21-
#include <vidi_volume_reader.h>
22-
23-
#include <tbb/parallel_for.h>
24-
257
// #define TEST_SIREN
268

279
#ifdef ENABLE_LOGGING
@@ -45,51 +27,6 @@ constexpr const T& clamp(const T& v, const T& lo, const T& hi)
4527
return (v < lo) ? lo : (hi < v) ? hi : v;
4628
}
4729

48-
template<typename IType>
49-
std::shared_ptr<char[]>
50-
convert_volume(std::shared_ptr<char[]> idata, size_t size, float vmin, float vmax)
51-
{
52-
std::shared_ptr<char[]> odata;
53-
odata.reset(new char[size * sizeof(float)]);
54-
55-
tbb::parallel_for(size_t(0), size, [&](size_t idx) {
56-
auto* i = (IType*)&idata[idx * sizeof(IType)];
57-
auto* o = (float*)&odata[idx * sizeof(float)];
58-
#ifdef TEST_SIREN
59-
*o = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f) * 2.f - 1.f;
60-
#else
61-
*o = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f);
62-
#endif
63-
});
64-
65-
return odata;
66-
}
67-
68-
template<>
69-
std::shared_ptr<char[]>
70-
convert_volume<float>(std::shared_ptr<char[]> idata, size_t size, float vmin, float vmax)
71-
{
72-
tbb::parallel_for(size_t(0), size, [&](size_t idx) {
73-
auto* i = (float*)&idata[idx * sizeof(float)];
74-
#ifdef TEST_SIREN
75-
*i = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f) * 2.f - 1.f;
76-
#else
77-
*i = clamp((static_cast<float>(*i) - (float)vmin) / ((float)vmax - (float)vmin), 0.f, 1.f);
78-
#endif
79-
});
80-
81-
return idata;
82-
}
83-
84-
template<typename T>
85-
static range1f
86-
compute_scalar_fminmax(const void* _array, size_t count)
87-
{
88-
using vidi::parallel::compute_scalar_minmax;
89-
auto r = compute_scalar_minmax<T>(_array, count, 0);
90-
return range1f((float)r.first, (float)r.second);
91-
}
92-
9330
} // namespace
9431

9532
// ------------------------------------------------------------------
@@ -183,73 +120,6 @@ StaticSampler::StaticSampler(const MultiVolume& desc, bool save_volume, bool ski
183120
}
184121
}
185122

186-
void
187-
StaticSampler::load(const MultiVolume::File& desc,
188-
vec3i dims, dtype type, range1f minmax,
189-
std::shared_ptr<char[]>& buffer,
190-
range1f& value_range_unnormalized,
191-
range1f& value_range_normalized)
192-
{
193-
const auto& offset = desc.offset;
194-
const auto& filename = desc.filename;
195-
const auto& is_big_endian = desc.bigendian;
196-
197-
/* load data from file */
198-
{
199-
vidi::StructuredRegularVolumeDesc desc;
200-
desc.dims.x = dims.x;
201-
desc.dims.y = dims.y;
202-
desc.dims.z = dims.z;
203-
desc.type = (vidi::VoxelType)type;
204-
desc.offset = offset;
205-
desc.is_big_endian = is_big_endian;
206-
buffer = vidi::read_volume_structured_regular(filename, desc);
207-
}
208-
209-
/* copy data to GPU */
210-
const size_t count = (size_t)dims.x * dims.y * dims.z;
211-
212-
/* convert volume into floats */
213-
range1f range;
214-
{
215-
if (minmax.is_empty()) {
216-
switch (type) {
217-
case VALUE_TYPE_UINT8: range = compute_scalar_fminmax<uint8_t>(buffer.get(), count); break;
218-
case VALUE_TYPE_INT8: range = compute_scalar_fminmax<int8_t>(buffer.get(), count); break;
219-
case VALUE_TYPE_UINT16: range = compute_scalar_fminmax<uint16_t>(buffer.get(), count); break;
220-
case VALUE_TYPE_INT16: range = compute_scalar_fminmax<int16_t>(buffer.get(), count); break;
221-
case VALUE_TYPE_UINT32: range = compute_scalar_fminmax<uint32_t>(buffer.get(), count); break;
222-
case VALUE_TYPE_INT32: range = compute_scalar_fminmax<int32_t>(buffer.get(), count); break;
223-
case VALUE_TYPE_FLOAT: range = compute_scalar_fminmax<float>(buffer.get(), count); break;
224-
case VALUE_TYPE_DOUBLE: range = compute_scalar_fminmax<double>(buffer.get(), count); break;
225-
default: throw std::runtime_error("unknown data type");
226-
}
227-
}
228-
else {
229-
range = minmax;
230-
}
231-
232-
switch (type) {
233-
case VALUE_TYPE_UINT8: buffer = convert_volume<uint8_t> (buffer, count, range.lower, range.upper); break;
234-
case VALUE_TYPE_INT8: buffer = convert_volume<int8_t> (buffer, count, range.lower, range.upper); break;
235-
case VALUE_TYPE_UINT16: buffer = convert_volume<uint16_t>(buffer, count, range.lower, range.upper); break;
236-
case VALUE_TYPE_INT16: buffer = convert_volume<int16_t> (buffer, count, range.lower, range.upper); break;
237-
case VALUE_TYPE_UINT32: buffer = convert_volume<uint32_t>(buffer, count, range.lower, range.upper); break;
238-
case VALUE_TYPE_INT32: buffer = convert_volume<int32_t> (buffer, count, range.lower, range.upper); break;
239-
case VALUE_TYPE_FLOAT: buffer = convert_volume<float> (buffer, count, range.lower, range.upper); break;
240-
case VALUE_TYPE_DOUBLE: buffer = convert_volume<double> (buffer, count, range.lower, range.upper); break;
241-
default: throw std::runtime_error("unknown data type");
242-
}
243-
}
244-
value_range_unnormalized = range;
245-
value_range_normalized.lower = 0.f;
246-
value_range_normalized.upper = 1.f;
247-
// std::tie(value_range_normalized.lower, value_range_normalized.upper) = vidi::parallel::compute_scalar_minmax<float>(buffer.get(), count, 0);
248-
249-
log() << "[vnr] unnormalized range " << value_range_unnormalized.lower << " " << value_range_unnormalized.upper << std::endl;
250-
log() << "[vnr] normalized range " << value_range_normalized.lower << " " << value_range_normalized.upper << std::endl;
251-
}
252-
253123
void
254124
StaticSampler::set_current_volume_timestamp(int index)
255125
{

0 commit comments

Comments
 (0)