make gpr update
This commit is contained in:
@@ -0,0 +1,78 @@
|
||||
# 3.22 = apt cmake на Ubuntu 22.04 (Jetson/JetPack); фич новее здесь нет.
|
||||
cmake_minimum_required(VERSION 3.22)
|
||||
project(gpr_cpp LANGUAGES CXX) # CXX-only: CUDA компилируется в рантайме через NVRTC
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
if(NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE Release)
|
||||
endif()
|
||||
set(CMAKE_CXX_FLAGS_RELEASE "-O3")
|
||||
|
||||
# bindings/pymodule.cpp не вендорен в radar_system — включение потребует вернуть его из VNA_AlGo
|
||||
option(GPR_BUILD_PYTHON "Build pybind11 module" OFF)
|
||||
option(GPR_BUILD_TESTS "Build C++ parity tests" OFF)
|
||||
option(GPR_BUILD_EXAMPLES "Build standalone C++ example" ON)
|
||||
|
||||
# Python окружение (venv) — источник pybind11 и pip CUDA-библиотек (nvrtc, cudart).
|
||||
if(NOT DEFINED PYTHON_EXECUTABLE)
|
||||
set(PYTHON_EXECUTABLE python3)
|
||||
endif()
|
||||
|
||||
# CUDA include/lib из pip-пакетов nvidia-*; задаются -DGPR_CUDA_INC / -DGPR_CUDA_LIB
|
||||
# (детект делает build_cmake.sh). Заголовки: nvrtc.h, cuda.h (Driver API).
|
||||
# GPR_CUDA_INC может быть СПИСКОМ каталогов (через ';'): в раздельных pip-пакетах
|
||||
# (Jetson: cuda_nvrtc + cuda_runtime) nvrtc.h и cuda.h лежат в разных include/.
|
||||
if(NOT DEFINED GPR_CUDA_INC OR NOT DEFINED GPR_CUDA_LIB)
|
||||
message(FATAL_ERROR "Задайте -DGPR_CUDA_INC=<dir(ы) с nvrtc.h,cuda.h; ';'-список> и -DGPR_CUDA_LIB=<dir с libnvrtc.so*>")
|
||||
endif()
|
||||
|
||||
# libcuda (драйвер) — системный
|
||||
find_library(CUDA_DRIVER_LIB cuda PATHS /usr/lib/x86_64-linux-gnu /usr/lib/aarch64-linux-gnu
|
||||
/usr/lib REQUIRED)
|
||||
# libnvrtc из pip
|
||||
find_library(NVRTC_LIB NAMES nvrtc libnvrtc.so.13 libnvrtc.so.12 nvrtc.so
|
||||
PATHS ${GPR_CUDA_LIB} REQUIRED NO_DEFAULT_PATH)
|
||||
|
||||
# PocketFFT (header-only, vendored)
|
||||
add_library(pocketfft INTERFACE)
|
||||
target_include_directories(pocketfft INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/third_party/pocketfft)
|
||||
|
||||
# --- ядро библиотеки (usable без Python) ---
|
||||
add_library(gpr_core_cpp STATIC
|
||||
src/geometry.cpp
|
||||
src/ascan.cpp
|
||||
src/device.cpp
|
||||
src/nvrtc_kernel.cpp
|
||||
src/sar3d.cpp)
|
||||
target_include_directories(gpr_core_cpp PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/include
|
||||
${GPR_CUDA_INC})
|
||||
target_link_libraries(gpr_core_cpp PUBLIC pocketfft ${NVRTC_LIB} ${CUDA_DRIVER_LIB})
|
||||
# rpath на каталог pip libnvrtc — чтобы бинарник/модуль грузились без LD_LIBRARY_PATH
|
||||
set_target_properties(gpr_core_cpp PROPERTIES POSITION_INDEPENDENT_CODE ON
|
||||
BUILD_RPATH "${GPR_CUDA_LIB}" INSTALL_RPATH "${GPR_CUDA_LIB}")
|
||||
|
||||
if(GPR_BUILD_PYTHON)
|
||||
execute_process(COMMAND ${PYTHON_EXECUTABLE} -m pybind11 --cmakedir
|
||||
OUTPUT_VARIABLE PB11_DIR OUTPUT_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE PB11_RC)
|
||||
if(PB11_RC EQUAL 0)
|
||||
find_package(pybind11 CONFIG REQUIRED HINTS ${PB11_DIR})
|
||||
else()
|
||||
find_package(pybind11 CONFIG REQUIRED)
|
||||
endif()
|
||||
pybind11_add_module(_gpr_cpp bindings/pymodule.cpp)
|
||||
target_link_libraries(_gpr_cpp PRIVATE gpr_core_cpp)
|
||||
set_target_properties(_gpr_cpp PROPERTIES BUILD_RPATH "${GPR_CUDA_LIB}" INSTALL_RPATH "${GPR_CUDA_LIB}")
|
||||
endif()
|
||||
|
||||
if(GPR_BUILD_TESTS)
|
||||
add_executable(gpr_test_parity tests/cpp/test_parity.cpp)
|
||||
target_link_libraries(gpr_test_parity PRIVATE gpr_core_cpp)
|
||||
endif()
|
||||
|
||||
if(GPR_BUILD_EXAMPLES)
|
||||
add_executable(standalone_bp examples/standalone_bp.cpp)
|
||||
target_link_libraries(standalone_bp PRIVATE gpr_core_cpp)
|
||||
set_target_properties(standalone_bp PROPERTIES BUILD_RPATH "${GPR_CUDA_LIB}" INSTALL_RPATH "${GPR_CUDA_LIB}")
|
||||
endif()
|
||||
@@ -0,0 +1,87 @@
|
||||
# gpr_cpp — C++/CUDA счёт-ядро MIMO GPR 3D SAR
|
||||
|
||||
> Вендорено из репозитория VNA_AlGo (`gpr_cpp/`, коммит `544dc59`); python-биндинги
|
||||
> (`bindings/`, pybind11) при переносе не взяты — сборка здесь только C++
|
||||
> (`GPR_BUILD_PYTHON=OFF`). Собирается из корневого Makefile radar_system
|
||||
> (цель `$(GPR_CPP_LIB)` вызывает `build_cmake.sh`).
|
||||
|
||||
Порт вычислительного ядра из Python/CuPy (`gpr_core`) в самостоятельную
|
||||
C++/CUDA библиотеку для интеграции в C++ проект.
|
||||
Алгоритм — см. `ALGORITHM.md` в репозитории VNA_AlGo.
|
||||
|
||||
## Что внутри (граница C++ ↔ Python)
|
||||
|
||||
**В C++ (`libgpr_core_cpp`):** геометрия, препроцессинг A-сканов (bg-subtract,
|
||||
фазовая коррекция движения, k0-вставка + Ханн + IFFT через PocketFFT, нормировка),
|
||||
3D SAR апертурный объём (одно CUDA-ядро на всю апертуру). Возвращает **сырые**
|
||||
`acc`(complex64)/`cnt`(float32).
|
||||
|
||||
**Остаётся в Python:** загрузка `.npy`, финализация объёма (abs+gate+gaussian+
|
||||
нормировка), CLEAN-детекция, трек, оценка скорости, plotly.
|
||||
|
||||
## Ключевое решение: CUDA без nvcc (NVRTC + Driver API)
|
||||
|
||||
На целевых машинах (x86+T600, Jetson) нет полного CUDA toolkit — только runtime +
|
||||
**NVRTC** (как у cupy). Поэтому ядро **не компилируется nvcc'ом**: его исходник
|
||||
встроен строкой ([src/kernel_src.hpp](src/kernel_src.hpp)), компилируется в рантайме
|
||||
через NVRTC в **cubin под точную арх устройства** (запрос compute capability →
|
||||
`sm_XY`, без JIT PTX), грузится и запускается через **CUDA Driver API**. Хост-часть
|
||||
собирается обычным g++. Плюс: без toolkit и без привязки к SM — один код для
|
||||
x86 (sm_75) и Jetson (sm_87).
|
||||
|
||||
## Сборка
|
||||
|
||||
```bash
|
||||
bash build_cmake.sh # авто-детект pip CUDA-путей; собирает всё
|
||||
# артефакты в build/: libgpr_core_cpp.a, _gpr_cpp*.so, standalone_bp
|
||||
```
|
||||
Требуется: g++ ≥13, cmake ≥3.24, pybind11 (`pip install pybind11`), pip-пакеты
|
||||
`nvidia-*` (nvrtc+cudart, идут с cupy), системный `libcuda`. rpath на каталог
|
||||
libnvrtc прописан — бинарники/модуль грузятся без `LD_LIBRARY_PATH`.
|
||||
|
||||
## Публичный C++ API ([include/gpr/](include/gpr/))
|
||||
|
||||
```cpp
|
||||
#include "gpr/config.hpp" // GeometryConfig/BPConfig/MotionConfig/SARConfig (дефолты = config.py)
|
||||
#include "gpr/ascan.hpp" // preprocess_snapshot(...) -> AScanSet
|
||||
#include "gpr/sar3d.hpp" // SarEngine::aperture_volume(frames, grid) -> VolumeRaw{acc,cnt}
|
||||
#include "gpr/geometry.hpp" // frame_offsets, frame_weights, build_grid_scene, point_to_scene
|
||||
|
||||
gpr::SarEngine engine(geom, bp, mot, sar); // компилит ядро под устройство
|
||||
auto vol = engine.aperture_volume(frames, grid); // один запуск ядра на апертуру
|
||||
// vol.acc / vol.cnt — сырые; финализацию (gaussian/normalize) делает вызывающий
|
||||
```
|
||||
Пример без Python: [examples/standalone_bp.cpp](examples/standalone_bp.cpp) — грузит
|
||||
S21 из `.npy`, строит объём, печатает максимум.
|
||||
```bash
|
||||
./build/standalone_bp <preprocessed_dir> 0038_id39_ns11361438137486
|
||||
```
|
||||
|
||||
## Python-модуль
|
||||
|
||||
```python
|
||||
import _gpr_cpp # из gpr_cpp/build
|
||||
eng = _gpr_cpp.SarEngine(_gpr_cpp.GeometryConfig(), _gpr_cpp.BPConfig(),
|
||||
_gpr_cpp.MotionConfig(), _gpr_cpp.SARConfig())
|
||||
a = _gpr_cpp.preprocess_snapshot(s21, freq, background, mot, geom, bp, True) # -> AScanSet
|
||||
acc, cnt = eng.aperture_volume([(a, dx, dy, dz, w), ...], gx, gy, gz) # numpy
|
||||
```
|
||||
|
||||
## Паритет (проверено на x86 T600)
|
||||
|
||||
| Этап | Порог | Факт |
|
||||
|---|---|---|
|
||||
| config дефолты vs dataclass | точно | OK |
|
||||
| A-сканы raw H vs numpy (float64) | <1e-9 | 1.7e-12 |
|
||||
| A-сканы норм. H (FFT-ULP через медиану) | <1e-4 | 2.5e-6 |
|
||||
| **3D объём C++ ядро vs cupy** (float32) | <5e-3 | **3e-7, argmax идентичен** |
|
||||
|
||||
Тесты: [../tests/test_parity_cpp.py](../tests/test_parity_cpp.py) (C++ vs cupy).
|
||||
|
||||
## Статус
|
||||
|
||||
- [x] x86 (T600, sm_75, CUDA 13): собрано, паритет, standalone работает.
|
||||
- [ ] Jetson (Orin NX, sm_87, CUDA 12.6): порт тривиален (NVRTC сам берёт sm_87);
|
||||
собрать `build_cmake.sh` на Jetson с его venv.
|
||||
- Опц.: ветка `impl='cpp'` в `gpr_core/sar3d.py` (адаптер `gpr_cpp_backend.py`),
|
||||
кэш device-A-сканов (сейчас каждый вызов грузит стек на GPU).
|
||||
@@ -0,0 +1,87 @@
|
||||
#!/usr/bin/env bash
|
||||
# CMake-сборка libgpr_core_cpp + standalone (без nvcc; NVRTC/driver).
|
||||
#
|
||||
# Источник CUDA (nvrtc.h / libnvrtc), по убыванию приоритета:
|
||||
# 1. env CUDA_INC / CUDA_LIB — заданы явно;
|
||||
# 2. pip-пакеты nvidia-* в venv ($VENV, по умолчанию ../../.venv — venv
|
||||
# radar_system) — дев-машина;
|
||||
# 3. системный toolkit /usr/local/cuda — Jetson/JetPack, apt cuda-toolkit.
|
||||
#
|
||||
# GPR_BUILD_PYTHON=ON вернул бы pybind-модуль, но bindings/ не вендорен в
|
||||
# radar_system (см. README) — по умолчанию OFF.
|
||||
set -eu
|
||||
HERE="$(cd "$(dirname "$0")" && pwd)"
|
||||
VENV="${VENV:-$HERE/../../.venv}"
|
||||
PY="$VENV/bin/python"
|
||||
GPR_BUILD_PYTHON="${GPR_BUILD_PYTHON:-OFF}"
|
||||
|
||||
CUDA_INC="${CUDA_INC:-}"
|
||||
CUDA_LIB="${CUDA_LIB:-}"
|
||||
|
||||
if [ -z "$CUDA_INC" ] || [ -z "$CUDA_LIB" ]; then
|
||||
if [ -x "$PY" ]; then
|
||||
# Печатается только когда найдены nvrtc.h, cuda.h И библиотека — частичная
|
||||
# детекция не может подсунуть мусорный путь. nvrtc.h и cuda.h могут лежать
|
||||
# в РАЗНЫХ каталогах (раздельные pip-пакеты cuda_nvrtc/cuda_runtime на
|
||||
# Jetson) — тогда CUDA_INC становится ';'-списком для CMake.
|
||||
PIP_CUDA=$("$PY" - <<'P' 2>/dev/null || true
|
||||
import glob, os, site
|
||||
sp = site.getsitepackages()[0]
|
||||
nvrtc_hdr = glob.glob(os.path.join(sp, 'nvidia', '**', 'include', 'nvrtc.h'), recursive=True)
|
||||
cuda_hdr = glob.glob(os.path.join(sp, 'nvidia', '**', 'include', 'cuda.h'), recursive=True)
|
||||
lib = sorted(glob.glob(os.path.join(sp, 'nvidia', '**', 'lib', 'libnvrtc.so*'), recursive=True))
|
||||
if nvrtc_hdr and cuda_hdr and lib:
|
||||
inc_dirs = []
|
||||
for hdr in (nvrtc_hdr[0], cuda_hdr[0]):
|
||||
d = os.path.dirname(hdr)
|
||||
if d not in inc_dirs:
|
||||
inc_dirs.append(d)
|
||||
print(';'.join(inc_dirs))
|
||||
print(os.path.dirname(lib[0]))
|
||||
P
|
||||
)
|
||||
if [ -n "$PIP_CUDA" ]; then
|
||||
CUDA_INC=$(printf '%s\n' "$PIP_CUDA" | sed -n 1p)
|
||||
CUDA_LIB=$(printf '%s\n' "$PIP_CUDA" | sed -n 2p)
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ -z "$CUDA_INC" ] || [ -z "$CUDA_LIB" ]; then
|
||||
if [ -e /usr/local/cuda/include/nvrtc.h ]; then
|
||||
CUDA_INC=/usr/local/cuda/include
|
||||
CUDA_LIB=/usr/local/cuda/lib64
|
||||
echo "[build_cmake] pip nvidia-* не найдены; использую системный CUDA: $CUDA_INC"
|
||||
else
|
||||
echo "[build_cmake] CUDA не найден: нет ни pip nvidia-* в $VENV, ни /usr/local/cuda." >&2
|
||||
echo "[build_cmake] Задайте CUDA_INC=<dir с nvrtc.h,cuda.h> и CUDA_LIB=<dir с libnvrtc.so*>." >&2
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
PYTHON_ARG=()
|
||||
if [ "$GPR_BUILD_PYTHON" = "ON" ] && [ -x "$PY" ]; then
|
||||
PYTHON_ARG=(-DPYTHON_EXECUTABLE="$PY")
|
||||
fi
|
||||
|
||||
# cmake: сначала из venv (pip install cmake — свежий без sudo), потом системный.
|
||||
CMAKE="$VENV/bin/cmake"
|
||||
if [ ! -x "$CMAKE" ]; then
|
||||
CMAKE=$(command -v cmake || true)
|
||||
fi
|
||||
if [ -z "$CMAKE" ]; then
|
||||
echo "[build_cmake] cmake не найден. Поставьте его в venv: \"$VENV/bin/pip\" install cmake" >&2
|
||||
echo "[build_cmake] (или системно: sudo apt install cmake)" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
"$CMAKE" -S "$HERE" -B "$HERE/build" \
|
||||
${PYTHON_ARG[@]+"${PYTHON_ARG[@]}"} \
|
||||
-DGPR_BUILD_PYTHON="$GPR_BUILD_PYTHON" \
|
||||
-DGPR_CUDA_INC="$CUDA_INC" \
|
||||
-DGPR_CUDA_LIB="$CUDA_LIB" \
|
||||
-DCMAKE_BUILD_TYPE=Release "$@" 2>&1 | tail -8
|
||||
"$CMAKE" --build "$HERE/build" -j4 2>&1 | tail -15
|
||||
echo "--- артефакты ---"
|
||||
ls -la "$HERE/build/libgpr_core_cpp.a" "$HERE/build/standalone_bp" "$HERE"/build/_gpr_cpp*.so 2>/dev/null | awk '{print $5,$9}'
|
||||
echo "CUDA_LIB=$CUDA_LIB (для LD_LIBRARY_PATH при запуске)"
|
||||
@@ -0,0 +1,145 @@
|
||||
// Автономный пример: C++ без Python. Грузит S21 снапшота из .npy,
|
||||
// строит A-сканы и 3D SAR-объём апертуры, печатает максимум |acc/cnt|.
|
||||
//
|
||||
// Использование:
|
||||
// standalone_bp <preprocessed_dir> <center_snapshot_name>
|
||||
// где preprocessed_dir содержит папки снапшотов с i{rx}_o{tx}_s21.npy и _freq.npy.
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <complex>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <dirent.h>
|
||||
#include <fstream>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "gpr/ascan.hpp"
|
||||
#include "gpr/config.hpp"
|
||||
#include "gpr/geometry.hpp"
|
||||
#include "gpr/sar3d.hpp"
|
||||
|
||||
using namespace gpr;
|
||||
|
||||
// --- минимальный загрузчик numpy .npy (v1.0, 1-D complex128 или float64) ---
|
||||
struct NpyArray { std::vector<double> f64; std::vector<c128> c128v; bool is_complex = false; };
|
||||
|
||||
static NpyArray load_npy(const std::string& path) {
|
||||
std::ifstream in(path, std::ios::binary);
|
||||
if (!in) throw std::runtime_error("не открыть " + path);
|
||||
char magic[6]; in.read(magic, 6);
|
||||
uint8_t ver[2]; in.read((char*)ver, 2);
|
||||
uint16_t hlen; in.read((char*)&hlen, 2);
|
||||
std::string hdr(hlen, '\0'); in.read(&hdr[0], hlen);
|
||||
auto sp = hdr.find("'shape':");
|
||||
auto lp = hdr.find('(', sp), rp = hdr.find(')', sp);
|
||||
long n = std::stol(hdr.substr(lp + 1, rp - lp - 1));
|
||||
NpyArray a;
|
||||
auto has = [&](const char* s) { return hdr.find(s) != std::string::npos; };
|
||||
if (has("c8")) { // complex64 → c128
|
||||
a.is_complex = true; a.c128v.resize(n);
|
||||
std::vector<std::complex<float>> tmp(n);
|
||||
in.read((char*)tmp.data(), n * sizeof(std::complex<float>));
|
||||
for (long i = 0; i < n; ++i) a.c128v[i] = c128(tmp[i].real(), tmp[i].imag());
|
||||
} else if (has("c16")) { // complex128
|
||||
a.is_complex = true; a.c128v.resize(n);
|
||||
in.read((char*)a.c128v.data(), n * sizeof(c128));
|
||||
} else if (has("f4")) { // float32 → double
|
||||
a.f64.resize(n);
|
||||
std::vector<float> tmp(n); in.read((char*)tmp.data(), n * sizeof(float));
|
||||
for (long i = 0; i < n; ++i) a.f64[i] = tmp[i];
|
||||
} else { // float64
|
||||
a.f64.resize(n); in.read((char*)a.f64.data(), n * sizeof(double));
|
||||
}
|
||||
return a;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
if (argc < 3) { printf("usage: %s <preprocessed_dir> <center_snapshot>\n", argv[0]); return 1; }
|
||||
std::string root = argv[1], center = argv[2];
|
||||
|
||||
GeometryConfig geom; geom.finalize();
|
||||
BPConfig bp; MotionConfig mot; SARConfig sar;
|
||||
auto pairs = geom.pair_keys();
|
||||
auto tx = geom.output_idx, rx = geom.input_idx;
|
||||
std::sort(tx.begin(), tx.end()); std::sort(rx.begin(), rx.end());
|
||||
|
||||
// список снапшотов, выбор апертуры вокруг center
|
||||
std::vector<std::string> snaps;
|
||||
if (DIR* d = opendir(root.c_str())) {
|
||||
for (dirent* e; (e = readdir(d));) {
|
||||
std::string n = e->d_name;
|
||||
if (!n.empty() && isdigit(n[0])) snaps.push_back(n);
|
||||
}
|
||||
closedir(d);
|
||||
}
|
||||
std::sort(snaps.begin(), snaps.end());
|
||||
int ci = -1; for (int i = 0; i < (int)snaps.size(); ++i) if (snaps[i] == center) ci = i;
|
||||
if (ci < 0) { printf("центр %s не найден\n", center.c_str()); return 1; }
|
||||
int lo = std::max(0, ci - sar.frame_radius), hi = std::min((int)snaps.size(), ci + sar.frame_radius + 1);
|
||||
std::vector<std::string> aperture(snaps.begin() + lo, snaps.begin() + hi);
|
||||
printf("апертура: %d кадров вокруг %s\n", (int)aperture.size(), center.c_str());
|
||||
|
||||
auto load_snapshot = [&](const std::string& snap,
|
||||
std::map<PairKey, std::vector<c128>>& s21,
|
||||
std::map<PairKey, std::vector<double>>& freq) {
|
||||
for (int p = 0; p < (int)pairs.size(); ++p) {
|
||||
int i_tx = pairs[p].first, i_rx = pairs[p].second;
|
||||
int phys_tx = tx[i_tx], phys_rx = rx[i_rx];
|
||||
char fn[512];
|
||||
snprintf(fn, sizeof(fn), "%s/%s/i%d_o%d_s21.npy", root.c_str(), snap.c_str(), phys_rx, phys_tx);
|
||||
s21[{i_tx, i_rx}] = load_npy(fn).c128v;
|
||||
snprintf(fn, sizeof(fn), "%s/%s/i%d_o%d_freq.npy", root.c_str(), snap.c_str(), phys_rx, phys_tx);
|
||||
freq[{i_tx, i_rx}] = load_npy(fn).f64;
|
||||
}
|
||||
};
|
||||
|
||||
auto ts = compute_pair_timestamps(mot, geom);
|
||||
SarEngine engine(geom, bp, mot, sar);
|
||||
|
||||
// держим AScanSet живыми
|
||||
std::vector<std::shared_ptr<AScanSet>> keep;
|
||||
std::vector<ApertureFrame> frames;
|
||||
std::vector<double> frame_times;
|
||||
for (auto& snap : aperture) {
|
||||
// время из суффикса _nsNNNN
|
||||
auto pos = snap.rfind("_ns");
|
||||
double t = (pos != std::string::npos) ? std::stod(snap.substr(pos + 3)) * 1e-9 : 0.0;
|
||||
frame_times.push_back(t);
|
||||
}
|
||||
double t_ref = frame_times[ci - lo];
|
||||
auto offs = frame_offsets(frame_times, t_ref, mot);
|
||||
auto wts = frame_weights(offs, sar.edge_frame_weight);
|
||||
|
||||
for (int f = 0; f < (int)aperture.size(); ++f) {
|
||||
std::map<PairKey, std::vector<c128>> s21;
|
||||
std::map<PairKey, std::vector<double>> freq;
|
||||
load_snapshot(aperture[f], s21, freq);
|
||||
auto a = std::make_shared<AScanSet>(
|
||||
preprocess_snapshot(s21, freq, nullptr, mot, geom, bp, ts, true));
|
||||
keep.push_back(a);
|
||||
frames.push_back(ApertureFrame{a.get(), offs[f], wts[f]});
|
||||
}
|
||||
|
||||
// центр сетки: под центральным снапшотом на глубине 5.6 м (сцена)
|
||||
auto center_scene = point_to_scene(0.0, 0.0, 5.6, mot, sar);
|
||||
Grid grid = build_grid_scene(center_scene, sar);
|
||||
printf("сетка %dx%dx%d, счёт объёма...\n", grid.NX(), grid.NY(), grid.NZ());
|
||||
|
||||
VolumeRaw vol = engine.aperture_volume(frames, grid);
|
||||
|
||||
// финализация: |acc/cnt|, максимум
|
||||
double vmax = 0; size_t amax = 0;
|
||||
for (size_t i = 0; i < vol.acc.size(); ++i) {
|
||||
double v = std::abs(vol.acc[i]) / (vol.cnt[i] + 1e-12);
|
||||
if (v > vmax) { vmax = v; amax = i; }
|
||||
}
|
||||
int NX = vol.NX, NZ = vol.NZ;
|
||||
int ix = amax % NX, iz = (amax / NX) % NZ, iy = amax / ((size_t)NX * NZ);
|
||||
printf("МАКСИМУМ объёма: |acc/cnt|=%.4e в вокселе (ix=%d,iy=%d,iz=%d)\n", vmax, ix, iy, iz);
|
||||
printf(" X=%.1f см, Y=%.1f см, Z=%.1f см\n",
|
||||
grid.x[ix] * 100, grid.y[iy] * 100, grid.z[iz] * 100);
|
||||
printf("OK: автономный C++ путь отработал без Python.\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
// Препроцессинг S21 → комплексные A-сканы (host, float64). Порт preprocess.py.
|
||||
#pragma once
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "gpr/config.hpp"
|
||||
#include "gpr/types.hpp"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
using PairKey = std::pair<int, int>;
|
||||
|
||||
// Тайминги пары (нужны slot/n_slots/t_center для фазовой коррекции).
|
||||
struct PairTiming {
|
||||
int tx_interleave_slot = 0;
|
||||
int tx_interleave_slots = 1;
|
||||
double t_center_s = 0.0;
|
||||
};
|
||||
using PairTimestamps = std::map<PairKey, PairTiming>;
|
||||
|
||||
PairTimestamps compute_pair_timestamps(const MotionConfig&, const GeometryConfig&);
|
||||
|
||||
// A-сканы одного снапшота, общая ось времени у всех пар (assert).
|
||||
struct AScanSet {
|
||||
int n_pairs = 0;
|
||||
int n_fft = 0;
|
||||
double t0 = 0.0, dt = 0.0; // общая ось: t_k = t0 + k*dt
|
||||
std::vector<PairKey> pairs; // порядок как в geom.pair_keys()
|
||||
std::vector<c128> H; // [n_pairs * n_fft] float64
|
||||
const c128* pair_ptr(int p) const { return H.data() + (size_t)p * n_fft; }
|
||||
};
|
||||
|
||||
// Порт compute_pair_ascans: bg-subtract → phase correction → k0-IFFT → норма.
|
||||
// s21/freq/background — по ключам (i_tx,i_rx); background может быть nullptr.
|
||||
AScanSet preprocess_snapshot(
|
||||
const std::map<PairKey, std::vector<c128>>& s21,
|
||||
const std::map<PairKey, std::vector<double>>& freq,
|
||||
const std::map<PairKey, std::vector<c128>>* background,
|
||||
const MotionConfig&, const GeometryConfig&, const BPConfig&,
|
||||
const PairTimestamps&, bool normalize = true);
|
||||
|
||||
// Отдельные шаги (для тестов/переиспользования):
|
||||
std::vector<c128> apply_intra_sweep_phase_correction(
|
||||
const std::vector<c128>& s21, const std::vector<double>& freq_full,
|
||||
const PairTiming&, const MotionConfig&, double wave_speed,
|
||||
double f_start, double f_stop, int n_slots_default);
|
||||
|
||||
// Возвращает t (ось), h (комплексный A-скан). n_fft через out-параметр.
|
||||
void compute_ascan_bp(const std::vector<c128>& s21, const std::vector<double>& freq,
|
||||
double f_start, double f_stop, bool window, int oversample,
|
||||
std::vector<double>& t_out, std::vector<c128>& h_out);
|
||||
|
||||
double pair_norm_scale(const std::vector<c128>& h, const std::vector<double>& t,
|
||||
double wave_speed, const BPConfig&);
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,102 @@
|
||||
// Конфигурация счёт-ядра. Дефолты 1:1 повторяют gpr_core/config.py.
|
||||
#pragma once
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
struct GeometryConfig {
|
||||
std::vector<int> input_idx{0, 1, 2, 3};
|
||||
std::vector<int> output_idx{0, 1};
|
||||
// (x,y,z) метры; порядок по физическим индексам как в config.py
|
||||
std::vector<std::array<double, 3>> tx_positions{{0.785, 0.0, 0.0}, {-0.785, 0.0, 0.0}};
|
||||
std::vector<std::array<double, 3>> rx_positions{
|
||||
{-0.42, 0.0, 0.0}, {0.48, 0.0, 0.0}, {0.18, 0.0, 0.0}, {-0.12, 0.0, 0.0}};
|
||||
double eps_r = 1.0;
|
||||
double bp_plane_y = 0.0;
|
||||
|
||||
// --- производные (заполняются finalize) ---
|
||||
std::vector<double> x_tx, y_tx, z_tx; // отсортированы по phys-индексу
|
||||
std::vector<double> x_rx, y_rx, z_rx;
|
||||
int n_tx = 0, n_rx = 0;
|
||||
double v = 0.0;
|
||||
|
||||
void finalize() {
|
||||
auto sort_xyz = [](std::vector<int> idx, const std::vector<std::array<double, 3>>& pos,
|
||||
std::vector<double>& X, std::vector<double>& Y, std::vector<double>& Z) {
|
||||
std::vector<int> order(idx.size());
|
||||
for (size_t i = 0; i < idx.size(); ++i) order[i] = (int)i;
|
||||
std::sort(order.begin(), order.end(), [&](int a, int b) { return idx[a] < idx[b]; });
|
||||
X.clear(); Y.clear(); Z.clear();
|
||||
for (int o : order) { X.push_back(pos[o][0]); Y.push_back(pos[o][1]); Z.push_back(pos[o][2]); }
|
||||
};
|
||||
sort_xyz(output_idx, tx_positions, x_tx, y_tx, z_tx);
|
||||
sort_xyz(input_idx, rx_positions, x_rx, y_rx, z_rx);
|
||||
n_tx = (int)output_idx.size();
|
||||
n_rx = (int)input_idx.size();
|
||||
v = 3e8 / std::sqrt(eps_r);
|
||||
}
|
||||
|
||||
std::vector<std::pair<int, int>> pair_keys() const {
|
||||
std::vector<std::pair<int, int>> p;
|
||||
for (int i = 0; i < n_tx; ++i)
|
||||
for (int j = 0; j < n_rx; ++j) p.emplace_back(i, j);
|
||||
return p;
|
||||
}
|
||||
};
|
||||
|
||||
struct BPConfig {
|
||||
double f_start = 20 * 1e8; // 2 ГГц
|
||||
double f_stop = 6.0e9;
|
||||
double min_depth = 3.2;
|
||||
double max_depth = 10.0;
|
||||
double grid_x_pad = 2.0;
|
||||
double z_min = 0.1;
|
||||
int nx = 300;
|
||||
int nz = 300;
|
||||
int oversample = 8;
|
||||
bool window = true;
|
||||
bool pair_normalize = true;
|
||||
double pair_norm_percentile = 50.0;
|
||||
double pair_norm_depth_min = 3.2;
|
||||
double pair_norm_depth_max = 10.0;
|
||||
double pair_norm_eps = 1e-15;
|
||||
double comp_range_power = 0.25;
|
||||
double comp_weight_max = 5.0;
|
||||
double comp_ref_depth = 5.0;
|
||||
double smooth_sigma = 1.5;
|
||||
bool bg_subtract = true;
|
||||
double cf_eps = 1e-12;
|
||||
};
|
||||
|
||||
struct MotionConfig {
|
||||
double speed_m_s = 0.854;
|
||||
double look_angle_deg = 6.0;
|
||||
double pitch_deg = 6.0;
|
||||
double tx_sweep_time_s = 0.079;
|
||||
double tx_switch_time_s = 1e-5;
|
||||
// frequency_timing_mode всегда interleaved_tx_by_frequency
|
||||
double direction_sign = +1.0;
|
||||
bool apply_freq_phase_correction = true;
|
||||
double motion_phase_sign = -1.0;
|
||||
|
||||
double frame_time_s(int n_tx) const {
|
||||
return n_tx * tx_sweep_time_s + std::max(0, n_tx - 1) * tx_switch_time_s;
|
||||
}
|
||||
};
|
||||
|
||||
struct SARConfig {
|
||||
int frame_radius = 6;
|
||||
double edge_frame_weight = 0.75;
|
||||
std::array<double, 3> half_width_m{1.8, 1.0, 1.8};
|
||||
std::array<int, 3> grid{150, 120, 160}; // NX, NY, NZ
|
||||
bool coord_mode_ground = true; // 'ground' vs 'radar_local'
|
||||
bool use_compensation = true;
|
||||
bool normalize_each_frame = true;
|
||||
};
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,52 @@
|
||||
// CUDA Driver API RAII: контекст, поток, буфер устройства.
|
||||
#pragma once
|
||||
#include <cuda.h>
|
||||
|
||||
#include <cstddef>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
void cu_check(CUresult r, const char* what);
|
||||
|
||||
// Инициализация драйвера + primary context на device 0. Возвращает (major,minor) CC.
|
||||
struct CudaContext {
|
||||
CUdevice dev = 0;
|
||||
CUcontext ctx = nullptr;
|
||||
int cc_major = 0, cc_minor = 0;
|
||||
CudaContext();
|
||||
~CudaContext();
|
||||
std::string arch_flag() const; // "--gpu-architecture=sm_XY"
|
||||
};
|
||||
|
||||
template <class T>
|
||||
class DeviceBuffer {
|
||||
CUdeviceptr ptr_ = 0;
|
||||
size_t n_ = 0;
|
||||
|
||||
public:
|
||||
DeviceBuffer() = default;
|
||||
explicit DeviceBuffer(size_t n) { alloc(n); }
|
||||
~DeviceBuffer() { free(); }
|
||||
DeviceBuffer(const DeviceBuffer&) = delete;
|
||||
DeviceBuffer& operator=(const DeviceBuffer&) = delete;
|
||||
DeviceBuffer(DeviceBuffer&& o) noexcept : ptr_(o.ptr_), n_(o.n_) { o.ptr_ = 0; o.n_ = 0; }
|
||||
|
||||
void alloc(size_t n) {
|
||||
free();
|
||||
if (n) cu_check(cuMemAlloc(&ptr_, n * sizeof(T)), "cuMemAlloc");
|
||||
n_ = n;
|
||||
}
|
||||
void free() {
|
||||
if (ptr_) cuMemFree(ptr_);
|
||||
ptr_ = 0; n_ = 0;
|
||||
}
|
||||
void upload(const T* host, size_t n) { cu_check(cuMemcpyHtoD(ptr_, host, n * sizeof(T)), "HtoD"); }
|
||||
void download(T* host, size_t n) const { cu_check(cuMemcpyDtoH(host, ptr_, n * sizeof(T)), "DtoH"); }
|
||||
CUdeviceptr ptr() const { return ptr_; }
|
||||
CUdeviceptr* addr() { return &ptr_; }
|
||||
size_t size() const { return n_; }
|
||||
};
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,28 @@
|
||||
// Геометрия: опорное расхождение пары, смещения/веса кадров, построение сетки.
|
||||
#pragma once
|
||||
#include <vector>
|
||||
|
||||
#include "gpr/config.hpp"
|
||||
#include "gpr/types.hpp"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
// 1/geo_ref пары (порт pair_geo_ref, скаляр float64).
|
||||
double pair_geo_ref(const GeometryConfig&, const BPConfig&, int i_tx, int i_rx, double yy);
|
||||
|
||||
// Смещения кадров относительно опорного (порт sar_frame_offsets).
|
||||
// frame_times[k] — время кадра (сек, от ns-таймстемпа); t_ref — время опорного.
|
||||
std::vector<FrameOffset> frame_offsets(const std::vector<double>& frame_times, double t_ref,
|
||||
const MotionConfig&);
|
||||
|
||||
// Косинусные веса апертуры (порт sar_frame_weights); dt берётся относительно центра.
|
||||
std::vector<double> frame_weights(const std::vector<FrameOffset>& offsets, double edge_weight);
|
||||
|
||||
// Сетка вокруг точки сцены (порт sar_build_grid_scene).
|
||||
Grid build_grid_scene(const std::array<double, 3>& center_scene, const SARConfig&);
|
||||
|
||||
// point_to_scene: оси радара → сцена (поворот на pitch, если ground).
|
||||
std::array<double, 3> point_to_scene(double x, double y, double z, const MotionConfig&,
|
||||
const SARConfig&);
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,25 @@
|
||||
// Компиляция строки CUDA-ядра через NVRTC → cubin под арх устройства → CUfunction.
|
||||
#pragma once
|
||||
#include <cuda.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
class NvrtcKernel {
|
||||
CUmodule module_ = nullptr;
|
||||
CUfunction func_ = nullptr;
|
||||
|
||||
public:
|
||||
NvrtcKernel() = default;
|
||||
~NvrtcKernel();
|
||||
NvrtcKernel(const NvrtcKernel&) = delete;
|
||||
NvrtcKernel& operator=(const NvrtcKernel&) = delete;
|
||||
|
||||
// Компилирует src в cubin под arch_flag ("--gpu-architecture=sm_XY"),
|
||||
// загружает модуль и берёт функцию func_name.
|
||||
void compile(const char* src, const std::string& arch_flag, const char* func_name);
|
||||
CUfunction func() const { return func_; }
|
||||
};
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,44 @@
|
||||
// 3D SAR: сборка взвешенного объёма апертуры за один запуск ядра.
|
||||
#pragma once
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "gpr/ascan.hpp"
|
||||
#include "gpr/config.hpp"
|
||||
#include "gpr/device.hpp"
|
||||
#include "gpr/geometry.hpp"
|
||||
#include "gpr/nvrtc_kernel.hpp"
|
||||
#include "gpr/types.hpp"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
// Один кадр апертуры: A-сканы + смещение + вес.
|
||||
struct ApertureFrame {
|
||||
const AScanSet* ascans;
|
||||
FrameOffset offset;
|
||||
double weight;
|
||||
};
|
||||
|
||||
// Сырой результат объёма (Python делает finish: abs+gate+gaussian+normalize).
|
||||
struct VolumeRaw {
|
||||
std::vector<c64> acc; // [NY*NZ*NX]
|
||||
std::vector<float> cnt; // [NY*NZ*NX]
|
||||
int NX = 0, NY = 0, NZ = 0;
|
||||
};
|
||||
|
||||
class SarEngine {
|
||||
public:
|
||||
SarEngine(const GeometryConfig&, const BPConfig&, const MotionConfig&, const SARConfig&);
|
||||
// Весь объём апертуры за один запуск ядра; возвращает сырые acc/cnt (host).
|
||||
VolumeRaw aperture_volume(const std::vector<ApertureFrame>& frames, const Grid&);
|
||||
|
||||
private:
|
||||
GeometryConfig geom_;
|
||||
BPConfig bp_;
|
||||
MotionConfig mot_;
|
||||
SARConfig sar_;
|
||||
std::unique_ptr<CudaContext> ctx_;
|
||||
std::unique_ptr<NvrtcKernel> kernel_;
|
||||
};
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,25 @@
|
||||
// Базовые типы счёт-ядра.
|
||||
#pragma once
|
||||
#include <complex>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
using c64 = std::complex<float>; // complex64, layout == cuComplex (2×float)
|
||||
using c128 = std::complex<double>; // float64 для препроцессинга/IFFT
|
||||
|
||||
// Ground-scene сетка (порт dict из geometry.py: x,y,z оси в метрах).
|
||||
struct Grid {
|
||||
std::vector<double> x, y, z;
|
||||
int NX() const { return (int)x.size(); }
|
||||
int NY() const { return (int)y.size(); }
|
||||
int NZ() const { return (int)z.size(); }
|
||||
};
|
||||
|
||||
// Смещение антенн кадра апертуры (порт sar_frame_offsets).
|
||||
struct FrameOffset {
|
||||
double dx_m = 0.0, dy_m = 0.0, dz_m = 0.0, dt_s = 0.0, horizontal_m = 0.0;
|
||||
};
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,198 @@
|
||||
#include "gpr/ascan.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <numeric>
|
||||
#include <stdexcept>
|
||||
|
||||
#include "pocketfft_hdronly.h"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
PairTimestamps compute_pair_timestamps(const MotionConfig& mot, const GeometryConfig& geom) {
|
||||
// interleaved_tx_by_frequency: слот Tx = порядок в отсортированном output_idx.
|
||||
std::vector<int> tx = geom.output_idx, rx = geom.input_idx;
|
||||
std::sort(tx.begin(), tx.end());
|
||||
std::sort(rx.begin(), rx.end());
|
||||
int n_slots = (int)tx.size();
|
||||
double frame_center = 0.5 * n_slots * mot.tx_sweep_time_s;
|
||||
PairTimestamps ts;
|
||||
for (int slot = 0; slot < (int)tx.size(); ++slot) {
|
||||
int i_tx = slot; // индекс в отсортированном == логический
|
||||
for (int j = 0; j < (int)rx.size(); ++j) {
|
||||
ts[{i_tx, j}] = PairTiming{slot, n_slots, frame_center};
|
||||
}
|
||||
}
|
||||
return ts;
|
||||
}
|
||||
|
||||
static double median_of_diff(const std::vector<double>& f) {
|
||||
std::vector<double> d(f.size() - 1);
|
||||
for (size_t i = 0; i + 1 < f.size(); ++i) d[i] = f[i + 1] - f[i];
|
||||
std::sort(d.begin(), d.end());
|
||||
size_t n = d.size();
|
||||
return (n % 2) ? d[n / 2] : 0.5 * (d[n / 2 - 1] + d[n / 2]);
|
||||
}
|
||||
|
||||
std::vector<c128> apply_intra_sweep_phase_correction(
|
||||
const std::vector<c128>& s21, const std::vector<double>& freq_full,
|
||||
const PairTiming& info, const MotionConfig& cfg, double wave_speed,
|
||||
double f_start, double f_stop, int n_slots_default) {
|
||||
std::vector<c128> out = s21;
|
||||
int n_full = (int)freq_full.size();
|
||||
// индексы в полосе
|
||||
std::vector<int> idx;
|
||||
for (int i = 0; i < n_full; ++i)
|
||||
if (freq_full[i] >= f_start && freq_full[i] <= f_stop) idx.push_back(i);
|
||||
if (idx.empty()) throw std::runtime_error("phase corr: пустая полоса");
|
||||
if (n_full < 2) return out;
|
||||
|
||||
int n_slots = info.tx_interleave_slots ? info.tx_interleave_slots : n_slots_default;
|
||||
int slot = info.tx_interleave_slot;
|
||||
double dt_base = cfg.tx_sweep_time_s / (n_full - 1);
|
||||
// t_all по всему свипу; t_center — середина ПОЛНОГО свипа (как в preprocess.py)
|
||||
double t_first = (double)(n_slots * 0 + slot) * dt_base;
|
||||
double t_last = (double)(n_slots * (n_full - 1) + slot) * dt_base;
|
||||
double t_center = 0.5 * (t_first + t_last);
|
||||
double theta = cfg.look_angle_deg * M_PI / 180.0;
|
||||
if (!cfg.apply_freq_phase_correction) return out;
|
||||
for (int i : idx) {
|
||||
double t_abs = (double)(n_slots * i + slot) * dt_base;
|
||||
double dt_intra = t_abs - t_center;
|
||||
double delta_range = cfg.direction_sign * cfg.speed_m_s * std::cos(theta) * dt_intra;
|
||||
double dtau = 2.0 * delta_range / wave_speed;
|
||||
double phi = 2.0 * M_PI * freq_full[i] * dtau;
|
||||
double ang = cfg.motion_phase_sign * phi;
|
||||
out[i] *= c128(std::cos(ang), std::sin(ang));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
static int next_pow2(int x) {
|
||||
int p = 1;
|
||||
while (p < x) p <<= 1;
|
||||
return p;
|
||||
}
|
||||
|
||||
void compute_ascan_bp(const std::vector<c128>& s21, const std::vector<double>& freq,
|
||||
double f_start, double f_stop, bool window, int oversample,
|
||||
std::vector<double>& t_out, std::vector<c128>& h_out) {
|
||||
std::vector<double> freq_cut;
|
||||
std::vector<c128> s_cut;
|
||||
for (size_t i = 0; i < freq.size(); ++i)
|
||||
if (freq[i] >= f_start && freq[i] <= f_stop) {
|
||||
freq_cut.push_back(freq[i]);
|
||||
s_cut.push_back(s21[i]);
|
||||
}
|
||||
if (freq_cut.size() < 2) throw std::runtime_error("ascan: <2 точек в полосе");
|
||||
|
||||
double df = median_of_diff(freq_cut);
|
||||
int n = (int)freq_cut.size();
|
||||
int k0 = (int)std::nearbyint(freq_cut[0] / df); // round-half-to-even как python round
|
||||
int min_len = 2 * (k0 + n - 1);
|
||||
int n_fft_base = next_pow2(min_len);
|
||||
int n_fft = n_fft_base * oversample;
|
||||
double dt = 1.0 / ((double)n_fft * df);
|
||||
|
||||
// окно Ханна (numpy np.hanning: 0.5 - 0.5*cos(2*pi*i/(N-1)))
|
||||
std::vector<c128> H(n_fft, c128(0.0, 0.0));
|
||||
for (int i = 0; i < n; ++i) {
|
||||
c128 v = s_cut[i];
|
||||
if (window) {
|
||||
double w = 0.5 - 0.5 * std::cos(2.0 * M_PI * i / (n - 1));
|
||||
v *= w;
|
||||
}
|
||||
H[k0 + i] = v;
|
||||
}
|
||||
|
||||
// IFFT через pocketfft (backward + 1/n_fft == numpy ifft)
|
||||
h_out.assign(n_fft, c128(0.0, 0.0));
|
||||
pocketfft::shape_t shape{(size_t)n_fft};
|
||||
pocketfft::stride_t stride{(ptrdiff_t)sizeof(c128)};
|
||||
pocketfft::c2c(shape, stride, stride, {0}, pocketfft::BACKWARD,
|
||||
H.data(), h_out.data(), (double)(1.0 / n_fft));
|
||||
|
||||
t_out.resize(n_fft);
|
||||
for (int i = 0; i < n_fft; ++i) t_out[i] = i * dt;
|
||||
}
|
||||
|
||||
double pair_norm_scale(const std::vector<c128>& h, const std::vector<double>& t,
|
||||
double wave_speed, const BPConfig& bp) {
|
||||
std::vector<double> vals;
|
||||
vals.reserve(h.size());
|
||||
for (size_t i = 0; i < h.size(); ++i) {
|
||||
double z = t[i] * wave_speed / 2.0;
|
||||
if (z >= bp.pair_norm_depth_min && z <= bp.pair_norm_depth_max)
|
||||
vals.push_back(std::abs(h[i]));
|
||||
}
|
||||
if (vals.empty())
|
||||
for (auto& c : h) vals.push_back(std::abs(c));
|
||||
std::sort(vals.begin(), vals.end());
|
||||
// numpy.percentile linear interpolation
|
||||
double q = bp.pair_norm_percentile / 100.0;
|
||||
double pos = q * (vals.size() - 1);
|
||||
int lo = (int)std::floor(pos);
|
||||
int hi = std::min(lo + 1, (int)vals.size() - 1);
|
||||
double scale = vals[lo] + (pos - lo) * (vals[hi] - vals[lo]);
|
||||
if (!std::isfinite(scale) || scale <= bp.pair_norm_eps) scale = 1.0;
|
||||
return scale;
|
||||
}
|
||||
|
||||
AScanSet preprocess_snapshot(
|
||||
const std::map<PairKey, std::vector<c128>>& s21,
|
||||
const std::map<PairKey, std::vector<double>>& freq,
|
||||
const std::map<PairKey, std::vector<c128>>* background,
|
||||
const MotionConfig& mot, const GeometryConfig& geom, const BPConfig& bp,
|
||||
const PairTimestamps& ts, bool normalize) {
|
||||
AScanSet out;
|
||||
out.pairs = geom.pair_keys();
|
||||
out.n_pairs = (int)out.pairs.size();
|
||||
|
||||
std::vector<std::vector<c128>> Hs;
|
||||
std::vector<std::vector<double>> Ts;
|
||||
for (auto& key : out.pairs) {
|
||||
auto its = s21.find(key);
|
||||
if (its == s21.end()) throw std::runtime_error("preprocess: нет пары в s21");
|
||||
std::vector<c128> s = its->second; // копия
|
||||
if (background) {
|
||||
auto ib = background->find(key);
|
||||
if (ib != background->end())
|
||||
for (size_t i = 0; i < s.size(); ++i) s[i] -= ib->second[i];
|
||||
}
|
||||
const std::vector<double>& fr = freq.at(key);
|
||||
auto itt = ts.find(key);
|
||||
if (itt != ts.end())
|
||||
s = apply_intra_sweep_phase_correction(s, fr, itt->second, mot, geom.v,
|
||||
bp.f_start, bp.f_stop, geom.n_tx);
|
||||
std::vector<double> t;
|
||||
std::vector<c128> h;
|
||||
compute_ascan_bp(s, fr, bp.f_start, bp.f_stop, bp.window, bp.oversample, t, h);
|
||||
Hs.push_back(std::move(h));
|
||||
Ts.push_back(std::move(t));
|
||||
}
|
||||
|
||||
// общая ось времени — проверка
|
||||
int n_fft = (int)Ts[0].size();
|
||||
double t0 = Ts[0][0];
|
||||
double dt = (Ts[0].back() - t0) / (n_fft - 1);
|
||||
for (auto& t : Ts)
|
||||
if ((int)t.size() != n_fft || std::abs(t[0] - t0) > 1e-18)
|
||||
throw std::runtime_error("A-сканы: разная ось времени у пар");
|
||||
|
||||
if (normalize) {
|
||||
for (int p = 0; p < out.n_pairs; ++p) {
|
||||
double scale = pair_norm_scale(Hs[p], Ts[p], geom.v, bp);
|
||||
for (auto& c : Hs[p]) c /= (scale + bp.pair_norm_eps);
|
||||
}
|
||||
}
|
||||
|
||||
out.n_fft = n_fft;
|
||||
out.t0 = t0;
|
||||
out.dt = dt;
|
||||
out.H.resize((size_t)out.n_pairs * n_fft);
|
||||
for (int p = 0; p < out.n_pairs; ++p)
|
||||
std::copy(Hs[p].begin(), Hs[p].end(), out.H.begin() + (size_t)p * n_fft);
|
||||
return out;
|
||||
}
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,34 @@
|
||||
#include "gpr/device.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
void cu_check(CUresult r, const char* what) {
|
||||
if (r != CUDA_SUCCESS) {
|
||||
const char* s = nullptr;
|
||||
cuGetErrorString(r, &s);
|
||||
throw std::runtime_error(std::string("CUDA error in ") + what + ": " + (s ? s : "?"));
|
||||
}
|
||||
}
|
||||
|
||||
CudaContext::CudaContext() {
|
||||
cu_check(cuInit(0), "cuInit");
|
||||
cu_check(cuDeviceGet(&dev, 0), "cuDeviceGet");
|
||||
cu_check(cuDeviceGetAttribute(&cc_major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev),
|
||||
"cc_major");
|
||||
cu_check(cuDeviceGetAttribute(&cc_minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev),
|
||||
"cc_minor");
|
||||
cu_check(cuDevicePrimaryCtxRetain(&ctx, dev), "primaryCtxRetain");
|
||||
cu_check(cuCtxSetCurrent(ctx), "ctxSetCurrent");
|
||||
}
|
||||
|
||||
CudaContext::~CudaContext() {
|
||||
if (ctx) cuDevicePrimaryCtxRelease(dev);
|
||||
}
|
||||
|
||||
std::string CudaContext::arch_flag() const {
|
||||
return "--gpu-architecture=sm_" + std::to_string(cc_major) + std::to_string(cc_minor);
|
||||
}
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,68 @@
|
||||
#include "gpr/geometry.hpp"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
namespace gpr {
|
||||
|
||||
double pair_geo_ref(const GeometryConfig& g, const BPConfig& bp, int i_tx, int i_rx, double yy) {
|
||||
double xc = (g.x_tx[i_tx] + g.x_rx[i_rx]) / 2.0;
|
||||
double Rtx = std::sqrt(std::pow(xc - g.x_tx[i_tx], 2) + std::pow(yy - g.y_tx[i_tx], 2) +
|
||||
std::pow(bp.comp_ref_depth - g.z_tx[i_tx], 2));
|
||||
double Rrx = std::sqrt(std::pow(xc - g.x_rx[i_rx], 2) + std::pow(yy - g.y_rx[i_rx], 2) +
|
||||
std::pow(bp.comp_ref_depth - g.z_rx[i_rx], 2));
|
||||
return 1.0 / (Rtx * Rrx + 1e-12) + 1e-30;
|
||||
}
|
||||
|
||||
std::vector<FrameOffset> frame_offsets(const std::vector<double>& frame_times, double t_ref,
|
||||
const MotionConfig& cfg) {
|
||||
std::vector<FrameOffset> out(frame_times.size());
|
||||
double pitch = cfg.pitch_deg * M_PI / 180.0;
|
||||
for (size_t k = 0; k < frame_times.size(); ++k) {
|
||||
double t = frame_times[k] - t_ref;
|
||||
double h = cfg.direction_sign * cfg.speed_m_s * t;
|
||||
out[k].dx_m = 0.0;
|
||||
out[k].dy_m = h * std::sin(pitch);
|
||||
out[k].dz_m = h * std::cos(pitch);
|
||||
out[k].dt_s = t;
|
||||
out[k].horizontal_m = h;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
std::vector<double> frame_weights(const std::vector<FrameOffset>& offs, double edge_weight) {
|
||||
size_t n = offs.size();
|
||||
std::vector<double> w(n, 1.0);
|
||||
double edge = std::min(std::max(edge_weight, 0.0), 1.0);
|
||||
if (n == 0 || edge >= 1.0) return w;
|
||||
double dmax = 0.0;
|
||||
for (auto& o : offs) dmax = std::max(dmax, std::abs(o.dt_s));
|
||||
if (dmax <= 1e-12) return w;
|
||||
for (size_t i = 0; i < n; ++i) {
|
||||
double r = std::min(std::abs(offs[i].dt_s) / dmax, 1.0);
|
||||
w[i] = edge + (1.0 - edge) * 0.5 * (1.0 + std::cos(M_PI * r));
|
||||
}
|
||||
return w;
|
||||
}
|
||||
|
||||
std::array<double, 3> point_to_scene(double x, double y, double z, const MotionConfig& mot,
|
||||
const SARConfig& sar) {
|
||||
if (!sar.coord_mode_ground) return {x, y, z};
|
||||
double p = mot.pitch_deg * M_PI / 180.0;
|
||||
double ys = y * std::cos(p) - z * std::sin(p);
|
||||
double zs = y * std::sin(p) + z * std::cos(p);
|
||||
return {x, ys, zs};
|
||||
}
|
||||
|
||||
Grid build_grid_scene(const std::array<double, 3>& c, const SARConfig& sar) {
|
||||
Grid g;
|
||||
auto lin = [](double a, double b, int n, std::vector<double>& out) {
|
||||
out.resize(n);
|
||||
for (int i = 0; i < n; ++i) out[i] = a + (b - a) * i / (double)(n - 1);
|
||||
};
|
||||
lin(c[0] - sar.half_width_m[0], c[0] + sar.half_width_m[0], sar.grid[0], g.x);
|
||||
lin(c[1] - sar.half_width_m[1], c[1] + sar.half_width_m[1], sar.grid[1], g.y);
|
||||
lin(c[2] - sar.half_width_m[2], c[2] + sar.half_width_m[2], sar.grid[2], g.z);
|
||||
return g;
|
||||
}
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,72 @@
|
||||
// Исходник CUDA-ядра для NVRTC (порт bp_aperture_contribution из gpr_core/kernels.py).
|
||||
// Self-contained complex<float> (без cupy-заголовков).
|
||||
#pragma once
|
||||
|
||||
namespace gpr {
|
||||
|
||||
inline const char* APERTURE_KERNEL_SRC = R"CUDA(
|
||||
struct cf { float x, y; };
|
||||
__device__ __forceinline__ cf operator+(cf a, cf b){ return {a.x+b.x, a.y+b.y}; }
|
||||
__device__ __forceinline__ cf operator-(cf a, cf b){ return {a.x-b.x, a.y-b.y}; }
|
||||
__device__ __forceinline__ cf operator*(float s, cf a){ return {s*a.x, s*a.y}; }
|
||||
|
||||
// Весь взвешенный объём апертуры за один запуск: один поток на воксель,
|
||||
// внутренний цикл по n_contrib = n_frames*n_pairs. acc/cnt пишутся один раз.
|
||||
extern "C" __global__ void bp_aperture_contribution(
|
||||
const cf* __restrict__ H,
|
||||
const float t0, const float inv_dt, const int n_fft, const float inv_v,
|
||||
const float* __restrict__ xt, const float* __restrict__ yt, const float* __restrict__ zt,
|
||||
const float* __restrict__ xr, const float* __restrict__ yr, const float* __restrict__ zr,
|
||||
const float* __restrict__ inv_geo_ref, const float* __restrict__ wgt,
|
||||
const float* __restrict__ gx, const float* __restrict__ gy, const float* __restrict__ gz,
|
||||
const int NX, const int NY, const int NZ, const int n_contrib,
|
||||
const float cos_p, const float sin_p,
|
||||
const float min_depth, const float max_depth,
|
||||
const float comp_pow, const float w_max, const int use_comp,
|
||||
cf* __restrict__ acc, float* __restrict__ cnt)
|
||||
{
|
||||
const long total = (long)NX * NY * NZ;
|
||||
for (long gid = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
gid < total; gid += (long)gridDim.x * blockDim.x) {
|
||||
int ix = gid % NX;
|
||||
int iz = (gid / NX) % NZ;
|
||||
int iy = gid / ((long)NX * NZ);
|
||||
float x = gx[ix];
|
||||
float ys = gy[iy], zs = gz[iz];
|
||||
float y_rad = ys * cos_p + zs * sin_p;
|
||||
float z_rad = -ys * sin_p + zs * cos_p;
|
||||
bool depth_ok = (z_rad >= min_depth) && (z_rad <= max_depth);
|
||||
|
||||
cf a = {0.f, 0.f};
|
||||
float c = 0.f;
|
||||
for (int i = 0; i < n_contrib; ++i) {
|
||||
float w = wgt[i];
|
||||
float dxt = x - xt[i], dyt = y_rad - yt[i], dzt = z_rad - zt[i];
|
||||
float dxr = x - xr[i], dyr = y_rad - yr[i], dzr = z_rad - zr[i];
|
||||
float Rt = sqrtf(dxt*dxt + dyt*dyt + dzt*dzt);
|
||||
float Rr = sqrtf(dxr*dxr + dyr*dyr + dzr*dzr);
|
||||
float pos = ((Rt + Rr) * inv_v - t0) * inv_dt;
|
||||
bool inside = (pos >= 0.f) && (pos <= (float)(n_fft - 1));
|
||||
if (!inside) continue;
|
||||
int k = (int)floorf(pos);
|
||||
if (k < 0) k = 0;
|
||||
if (k > n_fft - 2) k = n_fft - 2;
|
||||
float f = pos - (float)k;
|
||||
const cf* h = H + (long)i * n_fft;
|
||||
cf hv = h[k] + f * (h[k+1] - h[k]);
|
||||
if (use_comp) {
|
||||
float ratio = (1.f/(Rt*Rr + 1e-12f) + 1e-30f) * inv_geo_ref[i];
|
||||
float denom = (comp_pow == 0.25f) ? sqrtf(sqrtf(ratio)) : powf(ratio, comp_pow);
|
||||
float ww = 1.f/(denom + 1e-12f);
|
||||
ww = fminf(fmaxf(ww, 0.f), w_max);
|
||||
hv = ww * hv;
|
||||
}
|
||||
if (depth_ok) { a = a + (w * hv); c += w; }
|
||||
}
|
||||
acc[gid] = a;
|
||||
cnt[gid] = c;
|
||||
}
|
||||
}
|
||||
)CUDA";
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,48 @@
|
||||
#include "gpr/nvrtc_kernel.hpp"
|
||||
|
||||
#include <nvrtc.h>
|
||||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "gpr/device.hpp"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
static void nvrtc_check(nvrtcResult r, const char* what) {
|
||||
if (r != NVRTC_SUCCESS)
|
||||
throw std::runtime_error(std::string("NVRTC error in ") + what + ": " +
|
||||
nvrtcGetErrorString(r));
|
||||
}
|
||||
|
||||
NvrtcKernel::~NvrtcKernel() {
|
||||
if (module_) cuModuleUnload(module_);
|
||||
}
|
||||
|
||||
void NvrtcKernel::compile(const char* src, const std::string& arch_flag, const char* func_name) {
|
||||
nvrtcProgram prog;
|
||||
nvrtc_check(nvrtcCreateProgram(&prog, src, "gpr_kernel.cu", 0, nullptr, nullptr),
|
||||
"createProgram");
|
||||
std::vector<const char*> opts{arch_flag.c_str()};
|
||||
nvrtcResult cr = nvrtcCompileProgram(prog, (int)opts.size(), opts.data());
|
||||
if (cr != NVRTC_SUCCESS) {
|
||||
size_t logsz = 0;
|
||||
nvrtcGetProgramLogSize(prog, &logsz);
|
||||
std::string log(logsz, '\0');
|
||||
if (logsz) nvrtcGetProgramLog(prog, &log[0]);
|
||||
nvrtcDestroyProgram(&prog);
|
||||
throw std::runtime_error("NVRTC compile failed:\n" + log);
|
||||
}
|
||||
// cubin под точную арх (без JIT PTX — драйвер грузит SASS напрямую)
|
||||
size_t cubsz = 0;
|
||||
nvrtc_check(nvrtcGetCUBINSize(prog, &cubsz), "getCUBINSize");
|
||||
std::string cubin(cubsz, '\0');
|
||||
nvrtc_check(nvrtcGetCUBIN(prog, &cubin[0]), "getCUBIN");
|
||||
nvrtcDestroyProgram(&prog);
|
||||
|
||||
cu_check(cuModuleLoadDataEx(&module_, cubin.data(), 0, nullptr, nullptr), "moduleLoad");
|
||||
cu_check(cuModuleGetFunction(&func_, module_, func_name), "getFunction");
|
||||
}
|
||||
|
||||
} // namespace gpr
|
||||
@@ -0,0 +1,111 @@
|
||||
#include "gpr/sar3d.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <stdexcept>
|
||||
|
||||
#include "kernel_src.hpp"
|
||||
|
||||
namespace gpr {
|
||||
|
||||
SarEngine::SarEngine(const GeometryConfig& g, const BPConfig& bp, const MotionConfig& mot,
|
||||
const SARConfig& sar)
|
||||
: geom_(g), bp_(bp), mot_(mot), sar_(sar) {
|
||||
geom_.finalize();
|
||||
ctx_ = std::make_unique<CudaContext>();
|
||||
kernel_ = std::make_unique<NvrtcKernel>();
|
||||
kernel_->compile(APERTURE_KERNEL_SRC, ctx_->arch_flag(), "bp_aperture_contribution");
|
||||
}
|
||||
|
||||
VolumeRaw SarEngine::aperture_volume(const std::vector<ApertureFrame>& frames, const Grid& grid) {
|
||||
if (frames.empty()) throw std::runtime_error("aperture_volume: нет кадров");
|
||||
auto pairs = geom_.pair_keys();
|
||||
int n_pairs = (int)pairs.size();
|
||||
int n_frames = (int)frames.size();
|
||||
int n_contrib = n_frames * n_pairs;
|
||||
|
||||
const AScanSet& a0 = *frames[0].ascans;
|
||||
int n_fft = a0.n_fft;
|
||||
double t0 = a0.t0, dt = a0.dt;
|
||||
|
||||
int NX = grid.NX(), NY = grid.NY(), NZ = grid.NZ();
|
||||
size_t nvox = (size_t)NX * NY * NZ;
|
||||
|
||||
// Плоские массивы по (кадр, пара)
|
||||
std::vector<c64> H_stack((size_t)n_contrib * n_fft);
|
||||
std::vector<float> xt(n_contrib), yt(n_contrib), zt(n_contrib);
|
||||
std::vector<float> xr(n_contrib), yr(n_contrib), zr(n_contrib);
|
||||
std::vector<float> igr(n_contrib), wgt(n_contrib);
|
||||
int idx = 0;
|
||||
for (int f = 0; f < n_frames; ++f) {
|
||||
const AScanSet& a = *frames[f].ascans;
|
||||
if (a.n_fft != n_fft || std::abs(a.t0 - t0) > 1e-18)
|
||||
throw std::runtime_error("кадры апертуры: разная ось времени");
|
||||
double dx = frames[f].offset.dx_m, dy = frames[f].offset.dy_m, dz = frames[f].offset.dz_m;
|
||||
float w = (float)frames[f].weight;
|
||||
for (int p = 0; p < n_pairs; ++p) {
|
||||
int i = pairs[p].first, j = pairs[p].second;
|
||||
// A-скан пары p → в стек (каст c128→c64)
|
||||
const c128* src = a.pair_ptr(p);
|
||||
c64* dst = H_stack.data() + (size_t)idx * n_fft;
|
||||
for (int k = 0; k < n_fft; ++k) dst[k] = c64((float)src[k].real(), (float)src[k].imag());
|
||||
xt[idx] = (float)(geom_.x_tx[i] + dx); yt[idx] = (float)(geom_.y_tx[i] + dy);
|
||||
zt[idx] = (float)(geom_.z_tx[i] + dz);
|
||||
xr[idx] = (float)(geom_.x_rx[j] + dx); yr[idx] = (float)(geom_.y_rx[j] + dy);
|
||||
zr[idx] = (float)(geom_.z_rx[j] + dz);
|
||||
igr[idx] = (float)(1.0 / pair_geo_ref(geom_, bp_, i, j, geom_.bp_plane_y));
|
||||
wgt[idx] = w;
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<float> gx(grid.x.begin(), grid.x.end());
|
||||
std::vector<float> gy(grid.y.begin(), grid.y.end());
|
||||
std::vector<float> gz(grid.z.begin(), grid.z.end());
|
||||
|
||||
float cos_p = 1.f, sin_p = 0.f;
|
||||
if (sar_.coord_mode_ground) {
|
||||
double p = mot_.pitch_deg * M_PI / 180.0;
|
||||
cos_p = (float)std::cos(p); sin_p = (float)std::sin(p);
|
||||
}
|
||||
|
||||
// Заливка на устройство
|
||||
DeviceBuffer<c64> dH(H_stack.size()); dH.upload(H_stack.data(), H_stack.size());
|
||||
DeviceBuffer<float> dxt(n_contrib), dyt(n_contrib), dzt(n_contrib);
|
||||
DeviceBuffer<float> dxr(n_contrib), dyr(n_contrib), dzr(n_contrib);
|
||||
DeviceBuffer<float> digr(n_contrib), dwgt(n_contrib);
|
||||
dxt.upload(xt.data(), n_contrib); dyt.upload(yt.data(), n_contrib); dzt.upload(zt.data(), n_contrib);
|
||||
dxr.upload(xr.data(), n_contrib); dyr.upload(yr.data(), n_contrib); dzr.upload(zr.data(), n_contrib);
|
||||
digr.upload(igr.data(), n_contrib); dwgt.upload(wgt.data(), n_contrib);
|
||||
DeviceBuffer<float> dgx(NX), dgy(NY), dgz(NZ);
|
||||
dgx.upload(gx.data(), NX); dgy.upload(gy.data(), NY); dgz.upload(gz.data(), NZ);
|
||||
DeviceBuffer<c64> dacc(nvox);
|
||||
DeviceBuffer<float> dcnt(nvox);
|
||||
|
||||
float f_t0 = (float)t0, f_inv_dt = (float)(1.0 / dt), f_inv_v = (float)(1.0 / geom_.v);
|
||||
float min_d = (float)bp_.min_depth, max_d = (float)bp_.max_depth;
|
||||
float comp_pow = (float)bp_.comp_range_power, w_max = (float)bp_.comp_weight_max;
|
||||
int use_comp = sar_.use_compensation ? 1 : 0;
|
||||
|
||||
void* args[] = {
|
||||
dH.addr(), &f_t0, &f_inv_dt, &n_fft, &f_inv_v,
|
||||
dxt.addr(), dyt.addr(), dzt.addr(), dxr.addr(), dyr.addr(), dzr.addr(),
|
||||
digr.addr(), dwgt.addr(), dgx.addr(), dgy.addr(), dgz.addr(),
|
||||
&NX, &NY, &NZ, &n_contrib, &cos_p, &sin_p, &min_d, &max_d,
|
||||
&comp_pow, &w_max, &use_comp, dacc.addr(), dcnt.addr()};
|
||||
|
||||
int block = 256;
|
||||
int gridDim = (int)std::min<long>(65535, ((long)nvox + block - 1) / block);
|
||||
cu_check(cuLaunchKernel(kernel_->func(), gridDim, 1, 1, block, 1, 1, 0, 0, args, nullptr),
|
||||
"launch aperture");
|
||||
cu_check(cuCtxSynchronize(), "sync");
|
||||
|
||||
VolumeRaw out;
|
||||
out.NX = NX; out.NY = NY; out.NZ = NZ;
|
||||
out.acc.resize(nvox); out.cnt.resize(nvox);
|
||||
dacc.download(out.acc.data(), nvox);
|
||||
dcnt.download(out.cnt.data(), nvox);
|
||||
return out;
|
||||
}
|
||||
|
||||
} // namespace gpr
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user