build.sh

#!/bin/bash

set -e

# Deepdetect architecture and build profiles
deepdetect_arch=(cpu gpu jetson)
deepdetect_cpu_build_profiles=(default armv7)
deepdetect_gpu_build_profiles=(default tensorrt)
deepdetect_gpu_variants=(default legacy61)

DEEPDETECT_GPU_VARIANT=${DEEPDETECT_GPU_VARIANT:-default}
DEEPDETECT_JETSON_ARCH="8.7" # Orin only
USE_PREBUILT_TORCH=${USE_PREBUILT_TORCH:-ON}

DEEPDETECT_RELEASE=${DEEPDETECT_RELEASE:-OFF}
BUILD_TESTS=${BUILD_TESTS:-OFF}

configure_prebuilt_torch() {
    if [ "${USE_PREBUILT_TORCH}" != "ON" ]; then
        return
    fi

    if [ -z "${CMAKE_PREFIX_PATH}" ]; then
        if ! command -v python3 >/dev/null 2>&1; then
            return
        fi
        local torch_cmake_prefix
        torch_cmake_prefix=$(python3 - <<'PY'
try:
    import torch
    print(torch.utils.cmake_prefix_path)
except Exception:
    pass
PY
)
        if [ "${torch_cmake_prefix}" ]; then
            export CMAKE_PREFIX_PATH="${torch_cmake_prefix}"
        fi
    fi
}

prebuilt_torch_flags() {
    if [ "${USE_PREBUILT_TORCH}" = "ON" ]; then
        echo "-DUSE_PREBUILT_TORCH=ON"
    else
        echo "-DUSE_PREBUILT_TORCH=OFF"
    fi
}

build_cuda_arch_flags() {
    local flags=
    local card=

    for card in "$@"; do
        flags="${flags} -gencode arch=compute_${card},code=sm_${card}"
    done

    echo "${flags}" | xargs
}

configure_gpu_variant() {
    local default_cuda_arch=
    local default_cuda_arch_cards=

    case "${DEEPDETECT_GPU_VARIANT}" in
    "default")
        default_cuda_arch="7.5;8.0;8.6;8.9;9.0;10.0;12.0"
        default_cuda_arch_cards="75 80 86 89 90 100 120"
        ;;
    "legacy61")
        default_cuda_arch="6.1;6.2;7.0;7.2;7.5;8.0;8.6;8.9;9.0"
        default_cuda_arch_cards="61 62 70 72 75 80 86 89 90"
        ;;
    *)
        echo "Unknown DEEPDETECT_GPU_VARIANT value: ${DEEPDETECT_GPU_VARIANT}"
        echo "Supported GPU variants: ${deepdetect_gpu_variants[*]}"
        exit 1
        ;;
    esac

    DEEPDETECT_CUDA_ARCH=${DEEPDETECT_CUDA_ARCH:-${default_cuda_arch}}
    DEEPDETECT_CUDA_ARCH_FLAGS=${DEEPDETECT_CUDA_ARCH_FLAGS:-$(build_cuda_arch_flags ${default_cuda_arch_cards})}
    DEEPDETECT_OPENCV_CUDA_ARCH_BIN=${DEEPDETECT_OPENCV_CUDA_ARCH_BIN:-${DEEPDETECT_CUDA_ARCH//;/ }}
}

validate_gpu_variant() {
    local cuda_major=

    if [ "${DD_CUDA_VERSION}" ]; then
        cuda_major=${DD_CUDA_VERSION%%.*}
    fi

    if [ "${cuda_major}" ]; then
        if [ "${DEEPDETECT_GPU_VARIANT}" = "default" ] && [ "${cuda_major}" -lt 13 ] 2>/dev/null; then
            echo "DEEPDETECT_GPU_VARIANT=default requires DD_CUDA_VERSION >= 13, got ${DD_CUDA_VERSION}"
            exit 1
        fi
        if [ "${DEEPDETECT_GPU_VARIANT}" = "legacy61" ] && [ "${cuda_major}" -ge 13 ] 2>/dev/null; then
            echo "DEEPDETECT_GPU_VARIANT=legacy61 requires a CUDA 12.x image, got ${DD_CUDA_VERSION}"
            exit 1
        fi
    fi
}

# Help menu with arguments descriptions
help_menu() {
    IFS=,
    echo "Deepdetect build script"
    echo ""
    echo "Env variables usage: DEEPDETECT_ARCH=${deepdetect_arch[*]} DEEPDETECT_BUILD=${deepdetect_cpu_build_profiles[*]},[...] $0 "
    echo "GPU only: DEEPDETECT_GPU_VARIANT=${deepdetect_gpu_variants[*]}"
    echo "Torch only: USE_PREBUILT_TORCH=ON/OFF (default: ON)"
    echo ""
    echo "or"
    echo ""
    echo "Params usage: $0 [options...]" >&2
    echo
    echo "   -a, --deepdetect-arch          Choose Deepdetect architecture : ${deepdetect_arch[*]}"
    echo "   -b, --deepdetect-build         Choose Deepdetect build profile : CPU (${deepdetect_cpu_build_profiles[*]}) / GPU (${deepdetect_gpu_build_profiles[*]})"
    echo "   -c, --deepdetect-cuda-arch     Choose Deepdetect cuda arch (default: ${DEEPDETECT_CUDA_ARCH})"
    echo "   -g, --deepdetect-gpu-variant   Choose Deepdetect GPU variant : ${deepdetect_gpu_variants[*]}"
    echo "   -t, --build-tests              Build unit tests (ON/OFF)"
    echo
    exit 1
}

# Parse arguments
while (("$#")); do
    case "$1" in
    -a | --deepdetect-arch)
        DEEPDETECT_ARCH=$2
        shift 2
        ;;
    -b | --deepdetect-build)
        DEEPDETECT_BUILD=$2
        shift 2
        ;;
    -c | --deepdetect-cuda-arch)
        DEEPDETECT_CUDA_ARCH=$2
        shift 2
        ;;
    -g | --deepdetect-gpu-variant)
        DEEPDETECT_GPU_VARIANT=$2
        shift 2
        ;;
    -t | --build-tests)
        BUILD_TESTS=$2
        shift 2
        ;;
    -h | --help)
        help_menu
        break
        ;;
    esac
done

# Check arguments for incompatibility
if [[ -v DEEPDETECT_OPENCV4_BUILD_PATH ]] && [[ -v BUILD_OPENCV ]]; then
	echo "Please choose between setting DEEPDETECT_OPENCV4_BUILD_PATH or BUILD_OPENCV"
	echo "Use DEEPDETECT_OPENCV4_BUILD_PATH if you wish to use a custom opencv build"
	echo "Use BUILD_OPENCV if you wish for opencv to be built for you"
	exit
fi

configure_gpu_variant
validate_gpu_variant

# Deepdetect platform selector
select_platform() {
    clear
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    echo " Select Deepdetect build platform"
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    for index in ${!deepdetect_arch[*]}; do
        echo "  $index. ${deepdetect_arch[$index]^^}"
    done
    echo ""

    local choice
    read -p "Enter choice : " choice
    DEEPDETECT_ARCH=${deepdetect_arch[$choice]}
}

# Deepdetect select CPU build profile
select_cpu_build_profile() {
    clear
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    echo " Select Deepdetect build profile"
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    for index in ${!deepdetect_cpu_build_profiles[*]}; do
        echo "  $index. ${deepdetect_cpu_build_profiles[$index]}"
    done
    echo ""

    local choice
    read -p "Enter choice : " choice
    DEEPDETECT_BUILD=${deepdetect_cpu_build_profiles[$choice]}
}
# Deepdetect select GPU build profile
select_gpu_build_profile() {
    clear
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    echo " Select Deepdetect build profile"
    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    for index in ${!deepdetect_gpu_build_profiles[*]}; do
        echo "  $index. ${deepdetect_gpu_build_profiles[$index]}"
    done
    echo ""

    local choice
    read -p "Enter choice : " choice
    DEEPDETECT_BUILD=${deepdetect_gpu_build_profiles[$choice]}
}

# Use menu...
show_interactive_platform_selector() {
    # Main menu handler loop
    select_platform
    if [ ${DEEPDETECT_ARCH} == "cpu" ]; then
        select_cpu_build_profile
    fi
    if [ ${DEEPDETECT_ARCH} == "gpu" ] || ${DEEPDETECT_ARCH} == "jetson" ]; then
        select_gpu_build_profile
    fi
}

if [[ ${BUILD_OPENCV} == "ON" ]]; then
echo "Opencv will be built from source"
# Build OpenCV 4 with CUDA
DEEPDETECT_ROOT="$(git rev-parse --show-toplevel)"
DEEPDETECT_OPENCV4_BUILD_PATH="${DEEPDETECT_ROOT}/build/opencv/opencv-4.13.0/build"
mkdir -p opencv
cd opencv
if [ ! -d opencv-4.13.0 ]; then
echo "Downloading opencv"
wget -O opencv-4.13.0.zip https://github.com/opencv/opencv/archive/refs/tags/4.13.0.zip
wget -O opencv_contrib-4.13.0.zip https://github.com/opencv/opencv_contrib/archive/refs/tags/4.13.0.zip
unzip opencv-4.13.0.zip
unzip opencv_contrib-4.13.0.zip
fi
mkdir -p opencv-4.13.0/build
cd opencv-4.13.0/build
if grep -q "_LIBCUDACXX_BEGIN_NAMESPACE_STD" ../../opencv_contrib-4.13.0/modules/cudev/include/opencv2/cudev/ptr2d/zip.hpp; then
patch -d ../../opencv_contrib-4.13.0 -p1 < "${DEEPDETECT_ROOT}/patches/opencv/opencv_contrib_413_cuda13_cccl.patch"
fi
if ! grep -q "#include <thrust/tuple.h>" ../../opencv_contrib-4.13.0/modules/videostab/src/cuda/global_motion.cu; then
patch -d ../../opencv_contrib-4.13.0 -p1 < "${DEEPDETECT_ROOT}/patches/opencv/opencv_contrib_413_videostab_cuda13_thrust_tuple.patch"
fi
cmake -D CMAKE_BUILD_TYPE=DEBUG \
-D CMAKE_CXX_STANDARD=17 \
-D CMAKE_CXX_STANDARD_REQUIRED=ON \
-D CMAKE_CUDA_STANDARD=17 \
-D CMAKE_CUDA_STANDARD_REQUIRED=ON \
-D CMAKE_CUDA_FLAGS="--std=c++17" \
-D CUDA_NVCC_FLAGS="--std=c++17" \
-D CMAKE_INSTALL_PREFIX=/tmp/ \
-D CMAKE_LIBRARY_PATH=/usr/local/cuda/lib64/stubs \
-D CMAKE_CXX_FLAGS="-Wl,--allow-shlib-undefined" \
-D WITH_TBB=ON \
-D ENABLE_FAST_MATH=1 \
-D CUDA_FAST_MATH=1 \
-D WITH_CUBLAS=1 \
-D WITH_CUDA=ON \
-D BUILD_opencv_cudacodec=ON \
-D WITH_CUDNN=ON \
-D OPENCV_DNN_CUDA=OFF \
-D CUDA_ARCH_BIN="${DEEPDETECT_OPENCV_CUDA_ARCH_BIN}" \
-D WITH_V4L=ON \
-D WITH_QT=OFF \
-D WITH_OPENGL=OFF \
-D WITH_GSTREAMER=ON \
-D WITH_NVCUVID=ON \
-D OPENCV_GENERATE_PKGCONFIG=ON \
-D OPENCV_PC_FILE_NAME=opencv.pc \
-D OPENCV_ENABLE_NONFREE=ON \
-D BUILD_opencv_python2=OFF \
-D BUILD_opencv_python3=OFF \
-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-4.13.0/modules \
-D INSTALL_PYTHON_EXAMPLES=OFF \
-D INSTALL_C_EXAMPLES=OFF \
-D BUILD_EXAMPLES=OFF \
-D BUILD_opencv_cudev=ON \
-D BUILD_opencv_core=ON \
-D BUILD_opencv_imgproc=ON \
-D BUILD_opencv_imgcodecs=ON \
-D BUILD_opencv_videoio=ON \
-D BUILD_opencv_highgui=ON ..

make -j8
make install
cd ../../..
else
echo "Using custom opencv"
fi

# Build functions
cpu_build() {
    local torch_flags
    torch_flags=$(prebuilt_torch_flags)

    case ${DEEPDETECT_BUILD} in

    "armv7")
        cmake .. -DUSE_NCNN=ON -DRPI3=ON -DUSE_HDF5=OFF -DUSE_TORCH=OFF -DRELEASE=${DEEPDETECT_RELEASE} -DBUILD_TESTS=${BUILD_TESTS} -DOpenCV_DIR=${DEEPDETECT_OPENCV4_BUILD_PATH}
        make -j6
        ;; 

    *)
        configure_prebuilt_torch
        cmake .. ${torch_flags} -DUSE_XGBOOST=OFF -DUSE_CPU_ONLY=ON -DUSE_SIMSEARCH=OFF -DUSE_TSNE=OFF -DUSE_NCNN=OFF -DRELEASE=${DEEPDETECT_RELEASE} -DBUILD_TESTS=${BUILD_TESTS} -DOpenCV_DIR=${DEEPDETECT_OPENCV4_BUILD_PATH}
        make -j6
        ;; 
    esac

}

gpu_build() {
    local extra_flags=
    local torch_flags
    torch_flags=$(prebuilt_torch_flags)
    local default_flags="${torch_flags} -DUSE_FAISS=OFF -DUSE_CUDNN=ON -DUSE_XGBOOST=OFF -DUSE_SIMSEARCH=OFF -DUSE_TSNE=OFF -DUSE_TORCH=ON -DUSE_OPENCV_VERSION=4 -DOpenCV_DIR=${DEEPDETECT_OPENCV4_BUILD_PATH}"

    case ${DEEPDETECT_BUILD} in
        "tensorrt")
            extra_flags="-DUSE_TENSORRT=ON -DUSE_TORCH=OFF -DUSE_CUDA_CV=ON -DUSE_OPENCV_VERSION=4 -DOpenCV_DIR=${DEEPDETECT_OPENCV4_BUILD_PATH}"
            if [ "${DEEPDETECT_TENSORRT_VERSION}" ] && [ "${DEEPDETECT_TENSORRT_VERSION}" != "null" ]; then
                extra_flags="${extra_flags} -DTENSORRT_VERSION=${DEEPDETECT_TENSORRT_VERSION}"
            fi
            ;;
        *)
            configure_prebuilt_torch
            extra_flags="$default_flags"
            ;;
    esac
    echo $extra_flags

    cmake .. $extra_flags -DCUDA_ARCH_FLAGS="${DEEPDETECT_CUDA_ARCH_FLAGS}" -DCUDA_ARCH="${DEEPDETECT_CUDA_ARCH}" -DRELEASE="${DEEPDETECT_RELEASE}" -DBUILD_TESTS=${BUILD_TESTS} -DOpenCV_DIR="${DEEPDETECT_OPENCV4_BUILD_PATH}"
    make -j6
}

jetson_build() {
    local default_flags="-DUSE_FAISS=OFF -DUSE_XGBOOST=OFF -DUSE_SIMSEARCH=OFF -DUSE_TSNE=OFF -DUSE_TORCH=OFF -DJETSON=ON -DUSE_TENSORRT=ON -DUSE_CUDA_CV=ON -DUSE_OPENCV_VERSION=4 -DOpenCV_DIR=${DEEPDETECT_OPENCV4_BUILD_PATH} -DBUILD_TESTS=${BUILD_TESTS}"

    cmake .. $default_flags -DCUDA_ARCH="${DEEPDETECT_JETSON_ARCH}" -DRELEASE="${DEEPDETECT_RELEASE}"
    make -j6
}


# If no arguments provided, display usage information
if [ -z "$DEEPDETECT_ARCH" ] && [ $# -eq 0 ]; then
    show_interactive_platform_selector
fi

# Select build profile
if [[ ${DEEPDETECT_ARCH} == "cpu" ]]; then
    echo ""
    echo "Deepdetect build params :"
    echo "  DEEPDETECT_ARCH      : ${DEEPDETECT_ARCH}"
    echo "  DEEPDETECT_BUILD     : ${DEEPDETECT_BUILD}"
    echo "  USE_PREBUILT_TORCH   : ${USE_PREBUILT_TORCH}"
    echo ""
    cpu_build
elif [[ ${DEEPDETECT_ARCH} == "gpu" ]]; then
    echo ""
    echo "Deepdetect build params :"
    echo "  DEEPDETECT_ARCH      : ${DEEPDETECT_ARCH}"
    echo "  DEEPDETECT_BUILD     : ${DEEPDETECT_BUILD}"
    echo "  DEEPDETECT_GPU_VARIANT : ${DEEPDETECT_GPU_VARIANT}"
    echo "  DEEPDETECT_CUDA_ARCH : ${DEEPDETECT_CUDA_ARCH}"
    echo "  DEEPDETECT_CUDA_ARCH_FLAGS : ${DEEPDETECT_CUDA_ARCH_FLAGS}"
    echo "  DEEPDETECT_OPENCV4_BUILD_PATH : ${DEEPDETECT_OPENCV4_BUILD_PATH}"
    echo "  USE_PREBUILT_TORCH   : ${USE_PREBUILT_TORCH}"
    echo ""
    gpu_build
elif [[ ${DEEPDETECT_ARCH} == "jetson" ]]; then
    echo ""
    echo "Deepdetect build params :"
    echo "  DEEPDETECT_ARCH      : ${DEEPDETECT_ARCH}"
    echo "  DEEPDETECT_BUILD     : ${DEEPDETECT_BUILD}"
    echo "  DEEPDETECT_CUDA_ARCH : ${DEEPDETECT_JETSON_ARCH}"
    echo "  DEEPDETECT_OPENCV4_BUILD_PATH : ${DEEPDETECT_OPENCV4_BUILD_PATH}"
    echo ""
    jetson_build
else
    echo "Missing DEEPDETECT_ARCH variable to select build profile: cpu or gpu"
fi