mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-23 21:28:17 +08:00
add and update samples for CUDA 11.5
This commit is contained in:
Rutwik Choughule
18
Samples/imageDenoising/.vscode/c_cpp_properties.json
vendored
Normal file
18
Samples/imageDenoising/.vscode/c_cpp_properties.json
vendored
Normal file
@@ -0,0 +1,18 @@
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Linux",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**",
|
||||
"${workspaceFolder}/../../Common"
|
||||
],
|
||||
"defines": [],
|
||||
"compilerPath": "/usr/local/cuda/bin/nvcc",
|
||||
"cStandard": "gnu17",
|
||||
"cppStandard": "gnu++14",
|
||||
"intelliSenseMode": "linux-gcc-x64",
|
||||
"configurationProvider": "ms-vscode.makefile-tools"
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
7
Samples/imageDenoising/.vscode/extensions.json
vendored
Normal file
7
Samples/imageDenoising/.vscode/extensions.json
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"recommendations": [
|
||||
"nvidia.nsight-vscode-edition",
|
||||
"ms-vscode.cpptools",
|
||||
"ms-vscode.makefile-tools"
|
||||
]
|
||||
}
|
||||
10
Samples/imageDenoising/.vscode/launch.json
vendored
Normal file
10
Samples/imageDenoising/.vscode/launch.json
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "CUDA C++: Launch",
|
||||
"type": "cuda-gdb",
|
||||
"request": "launch",
|
||||
"program": "${workspaceFolder}/imageDenoising"
|
||||
}
|
||||
]
|
||||
}
|
||||
15
Samples/imageDenoising/.vscode/tasks.json
vendored
Normal file
15
Samples/imageDenoising/.vscode/tasks.json
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
{
|
||||
"version": "2.0.0",
|
||||
"tasks": [
|
||||
{
|
||||
"label": "sample",
|
||||
"type": "shell",
|
||||
"command": "make dbg=1",
|
||||
"problemMatcher": ["$nvcc"],
|
||||
"group": {
|
||||
"kind": "build",
|
||||
"isDefault": true
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
388
Samples/imageDenoising/Makefile
Normal file
388
Samples/imageDenoising/Makefile
Normal file
@@ -0,0 +1,388 @@
|
||||
################################################################################
|
||||
# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
# * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
# contributors may be used to endorse or promote products derived
|
||||
# from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
################################################################################
|
||||
#
|
||||
# Makefile project only supported on Mac OS X and Linux Platforms)
|
||||
#
|
||||
################################################################################
|
||||
|
||||
# Location of the CUDA Toolkit
|
||||
CUDA_PATH ?= /usr/local/cuda
|
||||
|
||||
##############################
|
||||
# start deprecated interface #
|
||||
##############################
|
||||
ifeq ($(x86_64),1)
|
||||
$(info WARNING - x86_64 variable has been deprecated)
|
||||
$(info WARNING - please use TARGET_ARCH=x86_64 instead)
|
||||
TARGET_ARCH ?= x86_64
|
||||
endif
|
||||
ifeq ($(ARMv7),1)
|
||||
$(info WARNING - ARMv7 variable has been deprecated)
|
||||
$(info WARNING - please use TARGET_ARCH=armv7l instead)
|
||||
TARGET_ARCH ?= armv7l
|
||||
endif
|
||||
ifeq ($(aarch64),1)
|
||||
$(info WARNING - aarch64 variable has been deprecated)
|
||||
$(info WARNING - please use TARGET_ARCH=aarch64 instead)
|
||||
TARGET_ARCH ?= aarch64
|
||||
endif
|
||||
ifeq ($(ppc64le),1)
|
||||
$(info WARNING - ppc64le variable has been deprecated)
|
||||
$(info WARNING - please use TARGET_ARCH=ppc64le instead)
|
||||
TARGET_ARCH ?= ppc64le
|
||||
endif
|
||||
ifneq ($(GCC),)
|
||||
$(info WARNING - GCC variable has been deprecated)
|
||||
$(info WARNING - please use HOST_COMPILER=$(GCC) instead)
|
||||
HOST_COMPILER ?= $(GCC)
|
||||
endif
|
||||
ifneq ($(abi),)
|
||||
$(error ERROR - abi variable has been removed)
|
||||
endif
|
||||
############################
|
||||
# end deprecated interface #
|
||||
############################
|
||||
|
||||
# architecture
|
||||
HOST_ARCH := $(shell uname -m)
|
||||
TARGET_ARCH ?= $(HOST_ARCH)
|
||||
ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
|
||||
ifneq ($(TARGET_ARCH),$(HOST_ARCH))
|
||||
ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
|
||||
TARGET_SIZE := 64
|
||||
else ifneq (,$(filter $(TARGET_ARCH),armv7l))
|
||||
TARGET_SIZE := 32
|
||||
endif
|
||||
else
|
||||
TARGET_SIZE := $(shell getconf LONG_BIT)
|
||||
endif
|
||||
else
|
||||
$(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
|
||||
endif
|
||||
|
||||
# sbsa and aarch64 systems look similar. Need to differentiate them at host level for now.
|
||||
ifeq ($(HOST_ARCH),aarch64)
|
||||
ifeq ($(CUDA_PATH)/targets/sbsa-linux,$(shell ls -1d $(CUDA_PATH)/targets/sbsa-linux 2>/dev/null))
|
||||
HOST_ARCH := sbsa
|
||||
TARGET_ARCH := sbsa
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq ($(TARGET_ARCH),$(HOST_ARCH))
|
||||
ifeq (,$(filter $(HOST_ARCH)-$(TARGET_ARCH),aarch64-armv7l x86_64-armv7l x86_64-aarch64 x86_64-sbsa x86_64-ppc64le))
|
||||
$(error ERROR - cross compiling from $(HOST_ARCH) to $(TARGET_ARCH) is not supported!)
|
||||
endif
|
||||
endif
|
||||
|
||||
# When on native aarch64 system with userspace of 32-bit, change TARGET_ARCH to armv7l
|
||||
ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_SIZE),aarch64-aarch64-32)
|
||||
TARGET_ARCH = armv7l
|
||||
endif
|
||||
|
||||
# operating system
|
||||
HOST_OS := $(shell uname -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
|
||||
TARGET_OS ?= $(HOST_OS)
|
||||
ifeq (,$(filter $(TARGET_OS),linux darwin qnx android))
|
||||
$(error ERROR - unsupported value $(TARGET_OS) for TARGET_OS!)
|
||||
endif
|
||||
|
||||
# host compiler
|
||||
ifeq ($(TARGET_OS),darwin)
|
||||
ifeq ($(shell expr `xcodebuild -version | grep -i xcode | awk '{print $$2}' | cut -d'.' -f1` \>= 5),1)
|
||||
HOST_COMPILER ?= clang++
|
||||
endif
|
||||
else ifneq ($(TARGET_ARCH),$(HOST_ARCH))
|
||||
ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
|
||||
ifeq ($(TARGET_OS),linux)
|
||||
HOST_COMPILER ?= arm-linux-gnueabihf-g++
|
||||
else ifeq ($(TARGET_OS),qnx)
|
||||
ifeq ($(QNX_HOST),)
|
||||
$(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
|
||||
endif
|
||||
ifeq ($(QNX_TARGET),)
|
||||
$(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
|
||||
endif
|
||||
export QNX_HOST
|
||||
export QNX_TARGET
|
||||
HOST_COMPILER ?= $(QNX_HOST)/usr/bin/arm-unknown-nto-qnx6.6.0eabi-g++
|
||||
else ifeq ($(TARGET_OS),android)
|
||||
HOST_COMPILER ?= arm-linux-androideabi-g++
|
||||
endif
|
||||
else ifeq ($(TARGET_ARCH),aarch64)
|
||||
ifeq ($(TARGET_OS), linux)
|
||||
HOST_COMPILER ?= aarch64-linux-gnu-g++
|
||||
else ifeq ($(TARGET_OS),qnx)
|
||||
ifeq ($(QNX_HOST),)
|
||||
$(error ERROR - QNX_HOST must be passed to the QNX host toolchain)
|
||||
endif
|
||||
ifeq ($(QNX_TARGET),)
|
||||
$(error ERROR - QNX_TARGET must be passed to the QNX target toolchain)
|
||||
endif
|
||||
export QNX_HOST
|
||||
export QNX_TARGET
|
||||
HOST_COMPILER ?= $(QNX_HOST)/usr/bin/q++
|
||||
else ifeq ($(TARGET_OS), android)
|
||||
HOST_COMPILER ?= aarch64-linux-android-clang++
|
||||
endif
|
||||
else ifeq ($(TARGET_ARCH),sbsa)
|
||||
HOST_COMPILER ?= aarch64-linux-gnu-g++
|
||||
else ifeq ($(TARGET_ARCH),ppc64le)
|
||||
HOST_COMPILER ?= powerpc64le-linux-gnu-g++
|
||||
endif
|
||||
endif
|
||||
HOST_COMPILER ?= g++
|
||||
NVCC := $(CUDA_PATH)/bin/nvcc -ccbin $(HOST_COMPILER)
|
||||
|
||||
# internal flags
|
||||
NVCCFLAGS := -m${TARGET_SIZE}
|
||||
CCFLAGS :=
|
||||
LDFLAGS :=
|
||||
|
||||
# build flags
|
||||
ifeq ($(TARGET_OS),darwin)
|
||||
LDFLAGS += -rpath $(CUDA_PATH)/lib
|
||||
CCFLAGS += -arch $(HOST_ARCH)
|
||||
else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
|
||||
LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
|
||||
CCFLAGS += -mfloat-abi=hard
|
||||
else ifeq ($(TARGET_OS),android)
|
||||
LDFLAGS += -pie
|
||||
CCFLAGS += -fpie -fpic -fexceptions
|
||||
endif
|
||||
|
||||
ifneq ($(TARGET_ARCH),$(HOST_ARCH))
|
||||
ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
|
||||
ifneq ($(TARGET_FS),)
|
||||
GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
|
||||
ifeq ($(GCCVERSIONLTEQ46),1)
|
||||
CCFLAGS += --sysroot=$(TARGET_FS)
|
||||
endif
|
||||
LDFLAGS += --sysroot=$(TARGET_FS)
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/lib
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
|
||||
endif
|
||||
endif
|
||||
ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
|
||||
ifneq ($(TARGET_FS),)
|
||||
GCCVERSIONLTEQ46 := $(shell expr `$(HOST_COMPILER) -dumpversion` \<= 4.6)
|
||||
ifeq ($(GCCVERSIONLTEQ46),1)
|
||||
CCFLAGS += --sysroot=$(TARGET_FS)
|
||||
endif
|
||||
LDFLAGS += --sysroot=$(TARGET_FS)
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/lib -L$(TARGET_FS)/lib
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/lib/aarch64-linux-gnu -L$(TARGET_FS)/lib/aarch64-linux-gnu
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib -L$(TARGET_FS)/usr/lib
|
||||
LDFLAGS += -rpath-link=$(TARGET_FS)/usr/lib/aarch64-linux-gnu -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
|
||||
LDFLAGS += --unresolved-symbols=ignore-in-shared-libs
|
||||
CCFLAGS += -isystem=$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include -I$(TARGET_FS)/usr/include/libdrm
|
||||
CCFLAGS += -isystem=$(TARGET_FS)/usr/include/aarch64-linux-gnu -I$(TARGET_FS)/usr/include/aarch64-linux-gnu
|
||||
endif
|
||||
endif
|
||||
ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
|
||||
NVCCFLAGS += --qpp-config 5.4.0,gcc_ntoaarch64le
|
||||
CCFLAGS += -DWIN_INTERFACE_CUSTOM -I/usr/include/aarch64-qnx-gnu
|
||||
LDFLAGS += -lsocket
|
||||
LDFLAGS += -L/usr/lib/aarch64-qnx-gnu
|
||||
CCFLAGS += "-Wl\,-rpath-link\,/usr/lib/aarch64-qnx-gnu"
|
||||
ifdef TARGET_OVERRIDE
|
||||
LDFLAGS += -lslog2
|
||||
endif
|
||||
|
||||
ifneq ($(TARGET_FS),)
|
||||
LDFLAGS += -L$(TARGET_FS)/usr/lib
|
||||
CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/lib"
|
||||
LDFLAGS += -L$(TARGET_FS)/usr/libnvidia
|
||||
CCFLAGS += "-Wl\,-rpath-link\,$(TARGET_FS)/usr/libnvidia"
|
||||
CCFLAGS += -I$(TARGET_FS)/../include
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
ifdef TARGET_OVERRIDE # cuda toolkit targets override
|
||||
NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
|
||||
endif
|
||||
|
||||
# Install directory of different arch
|
||||
CUDA_INSTALL_TARGET_DIR :=
|
||||
ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-linux)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-gnueabihf/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-linux)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),sbsa-linux)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/sbsa-linux/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-android)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/armv7-linux-androideabi/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-android)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/aarch64-linux-androideabi/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),armv7l-qnx)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/ARMv7-linux-QNX/
|
||||
else ifeq ($(TARGET_ARCH)-$(TARGET_OS),aarch64-qnx)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/aarch64-qnx/
|
||||
else ifeq ($(TARGET_ARCH),ppc64le)
|
||||
CUDA_INSTALL_TARGET_DIR = targets/ppc64le-linux/
|
||||
endif
|
||||
|
||||
# Debug build flags
|
||||
ifeq ($(dbg),1)
|
||||
NVCCFLAGS += -g -G
|
||||
BUILD_TYPE := debug
|
||||
else
|
||||
BUILD_TYPE := release
|
||||
endif
|
||||
|
||||
ALL_CCFLAGS :=
|
||||
ALL_CCFLAGS += $(NVCCFLAGS)
|
||||
ALL_CCFLAGS += $(EXTRA_NVCCFLAGS)
|
||||
ALL_CCFLAGS += $(addprefix -Xcompiler ,$(CCFLAGS))
|
||||
ALL_CCFLAGS += $(addprefix -Xcompiler ,$(EXTRA_CCFLAGS))
|
||||
|
||||
SAMPLE_ENABLED := 1
|
||||
|
||||
# This sample is not supported on QNX
|
||||
ifeq ($(TARGET_OS),qnx)
|
||||
$(info >>> WARNING - imageDenoising is not supported on QNX - waiving sample <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
|
||||
ALL_LDFLAGS :=
|
||||
ALL_LDFLAGS += $(ALL_CCFLAGS)
|
||||
ALL_LDFLAGS += $(addprefix -Xlinker ,$(LDFLAGS))
|
||||
ALL_LDFLAGS += $(addprefix -Xlinker ,$(EXTRA_LDFLAGS))
|
||||
|
||||
# Common includes and paths for CUDA
|
||||
INCLUDES := -I../../Common
|
||||
LIBRARIES :=
|
||||
|
||||
################################################################################
|
||||
|
||||
# Makefile include to help find GL Libraries
|
||||
include ./findgllib.mk
|
||||
|
||||
# OpenGL specific libraries
|
||||
ifeq ($(TARGET_OS),darwin)
|
||||
# Mac OSX specific libraries and paths to include
|
||||
LIBRARIES += -L/System/Library/Frameworks/OpenGL.framework/Libraries
|
||||
LIBRARIES += -lGL -lGLU
|
||||
ALL_LDFLAGS += -Xlinker -framework -Xlinker GLUT
|
||||
else
|
||||
LIBRARIES += $(GLLINK)
|
||||
LIBRARIES += -lGL -lGLU -lglut
|
||||
endif
|
||||
|
||||
#Detect if installed version of GCC supports required C++11
|
||||
ifeq ($(TARGET_OS),linux)
|
||||
empty :=
|
||||
space := $(empty) $(empty)
|
||||
GCCVERSIONSTRING := $(shell expr `$(HOST_COMPILER) -dumpversion`)
|
||||
#Create version number without "."
|
||||
GCCVERSION := $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f1 -d.)
|
||||
GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f2 -d.)
|
||||
GCCVERSION += $(shell expr `echo $(GCCVERSIONSTRING)` | cut -f3 -d.)
|
||||
# Make sure the version number has at least 3 decimals
|
||||
GCCVERSION += 00
|
||||
# Remove spaces from the version number
|
||||
GCCVERSION := $(subst $(space),$(empty),$(GCCVERSION))
|
||||
#$(warning $(GCCVERSION))
|
||||
|
||||
IS_MIN_VERSION := $(shell expr `echo $(GCCVERSION)` \>= 51000)
|
||||
|
||||
ifeq ($(IS_MIN_VERSION), 1)
|
||||
$(info >>> GCC Version is greater or equal to 5.1.0 <<<)
|
||||
else
|
||||
$(info >>> Waiving build. Minimum GCC version required is 5.1.0<<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
endif
|
||||
|
||||
# Gencode arguments
|
||||
ifeq ($(TARGET_ARCH),$(filter $(TARGET_ARCH),armv7l aarch64))
|
||||
SMS ?= 35 37 50 52 60 61 70 72 75 80 86
|
||||
else
|
||||
SMS ?= 35 37 50 52 60 61 70 75 80 86
|
||||
endif
|
||||
|
||||
ifeq ($(SMS),)
|
||||
$(info >>> WARNING - no SM architectures have been specified - waiving sample <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
|
||||
ifeq ($(GENCODE_FLAGS),)
|
||||
# Generate SASS code for each SM architecture listed in $(SMS)
|
||||
$(foreach sm,$(SMS),$(eval GENCODE_FLAGS += -gencode arch=compute_$(sm),code=sm_$(sm)))
|
||||
|
||||
# Generate PTX code from the highest SM architecture in $(SMS) to guarantee forward-compatibility
|
||||
HIGHEST_SM := $(lastword $(sort $(SMS)))
|
||||
ifneq ($(HIGHEST_SM),)
|
||||
GENCODE_FLAGS += -gencode arch=compute_$(HIGHEST_SM),code=compute_$(HIGHEST_SM)
|
||||
endif
|
||||
endif
|
||||
|
||||
ALL_CCFLAGS += --threads 0 --std=c++11
|
||||
|
||||
ifeq ($(SAMPLE_ENABLED),0)
|
||||
EXEC ?= @echo "[@]"
|
||||
endif
|
||||
|
||||
################################################################################
|
||||
|
||||
# Target rules
|
||||
all: build
|
||||
|
||||
build: imageDenoising
|
||||
|
||||
check.deps:
|
||||
ifeq ($(SAMPLE_ENABLED),0)
|
||||
@echo "Sample will be waived due to the above missing dependencies"
|
||||
else
|
||||
@echo "Sample is ready - all dependencies have been met"
|
||||
endif
|
||||
|
||||
bmploader.o:bmploader.cpp
|
||||
$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
|
||||
|
||||
imageDenoising.o:imageDenoising.cu
|
||||
$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
|
||||
|
||||
imageDenoisingGL.o:imageDenoisingGL.cpp
|
||||
$(EXEC) $(NVCC) $(INCLUDES) $(ALL_CCFLAGS) $(GENCODE_FLAGS) -o $@ -c $<
|
||||
|
||||
imageDenoising: bmploader.o imageDenoising.o imageDenoisingGL.o
|
||||
$(EXEC) $(NVCC) $(ALL_LDFLAGS) $(GENCODE_FLAGS) -o $@ $+ $(LIBRARIES)
|
||||
$(EXEC) mkdir -p ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
|
||||
$(EXEC) cp $@ ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)
|
||||
|
||||
run: build
|
||||
$(EXEC) ./imageDenoising
|
||||
|
||||
clean:
|
||||
rm -f imageDenoising bmploader.o imageDenoising.o imageDenoisingGL.o
|
||||
rm -rf ../../bin/$(TARGET_ARCH)/$(TARGET_OS)/$(BUILD_TYPE)/imageDenoising
|
||||
|
||||
clobber: clean
|
||||
91
Samples/imageDenoising/NsightEclipse.xml
Normal file
91
Samples/imageDenoising/NsightEclipse.xml
Normal file
@@ -0,0 +1,91 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE entry SYSTEM "SamplesInfo.dtd">
|
||||
<entry>
|
||||
<name>imageDenoising</name>
|
||||
<description><![CDATA[This sample demonstrates two adaptive image denoising techniques: KNN and NLM, based on computation of both geometric and color distance between texels. While both techniques are implemented in the DirectX SDK using shaders, massively speeded up variation of the latter technique, taking advantage of shared memory, is implemented in addition to DirectX counterparts.]]></description>
|
||||
<devicecompilation>whole</devicecompilation>
|
||||
<files>
|
||||
<file>data\portrait_noise.bmp</file>
|
||||
<file>data\ref_passthru.ppm</file>
|
||||
<file>data\ref_knn.ppm</file>
|
||||
<file>data\ref_nlm.ppm</file>
|
||||
<file>data\ref_nlm2.ppm</file>
|
||||
</files>
|
||||
<includepaths>
|
||||
<path>./</path>
|
||||
<path>../</path>
|
||||
<path>../../Common</path>
|
||||
</includepaths>
|
||||
<keyconcepts>
|
||||
<concept level="advanced">Image Processing</concept>
|
||||
</keyconcepts>
|
||||
<keywords>
|
||||
<keyword>CUDA</keyword>
|
||||
<keyword>Image Processing</keyword>
|
||||
<keyword>noise reduction</keyword>
|
||||
<keyword>openGL</keyword>
|
||||
</keywords>
|
||||
<libraries>
|
||||
<library>GLU</library>
|
||||
<library>GL</library>
|
||||
<library framework="true" os="macosx">GLUT</library>
|
||||
<library os="linux">GLEW</library>
|
||||
<library os="linux">glut</library>
|
||||
<library os="linux">X11</library>
|
||||
</libraries>
|
||||
<librarypaths>
|
||||
<path arch="x86_64" os="linux">../../common/lib/linux/x86_64</path>
|
||||
<path arch="armv7l" os="linux">../../common/lib/linux/armv7l</path>
|
||||
<path os="macosx">../../common/lib/darwin</path>
|
||||
</librarypaths>
|
||||
<nsight_eclipse>true</nsight_eclipse>
|
||||
<primary_file>imageDenoising.cu</primary_file>
|
||||
<qatests>
|
||||
<qatest>-kernel=0 -file=ref_passthru.ppm</qatest>
|
||||
<qatest>-kernel=1 -file=ref_knn.ppm</qatest>
|
||||
<qatest>-kernel=2 -file=ref_nlm.ppm</qatest>
|
||||
<qatest>-kernel=3 -file=ref_nlm2.ppm</qatest>
|
||||
</qatests>
|
||||
<required_dependencies>
|
||||
<dependency>X11</dependency>
|
||||
<dependency>GL</dependency>
|
||||
</required_dependencies>
|
||||
<scopes>
|
||||
<scope>1:CUDA Advanced Topics</scope>
|
||||
<scope>2:Image Processing</scope>
|
||||
<scope>2:Computer Vision</scope>
|
||||
</scopes>
|
||||
<sm-arch>sm35</sm-arch>
|
||||
<sm-arch>sm37</sm-arch>
|
||||
<sm-arch>sm50</sm-arch>
|
||||
<sm-arch>sm52</sm-arch>
|
||||
<sm-arch>sm60</sm-arch>
|
||||
<sm-arch>sm61</sm-arch>
|
||||
<sm-arch>sm70</sm-arch>
|
||||
<sm-arch>sm72</sm-arch>
|
||||
<sm-arch>sm75</sm-arch>
|
||||
<sm-arch>sm80</sm-arch>
|
||||
<sm-arch>sm86</sm-arch>
|
||||
<supported_envs>
|
||||
<env>
|
||||
<arch>x86_64</arch>
|
||||
<platform>linux</platform>
|
||||
</env>
|
||||
<env>
|
||||
<platform>windows7</platform>
|
||||
</env>
|
||||
<env>
|
||||
<arch>x86_64</arch>
|
||||
<platform>macosx</platform>
|
||||
</env>
|
||||
<env>
|
||||
<arch>arm</arch>
|
||||
</env>
|
||||
</supported_envs>
|
||||
<supported_sm_architectures>
|
||||
<include>all</include>
|
||||
</supported_sm_architectures>
|
||||
<title>Image denoising</title>
|
||||
<type>exe</type>
|
||||
<whitepaper>doc\imageDenoising.pdf</whitepaper>
|
||||
</entry>
|
||||
71
Samples/imageDenoising/README.md
Normal file
71
Samples/imageDenoising/README.md
Normal file
@@ -0,0 +1,71 @@
|
||||
# imageDenoising - Image denoising
|
||||
|
||||
## Description
|
||||
|
||||
This sample demonstrates two adaptive image denoising techniques: KNN and NLM, based on computation of both geometric and color distance between texels. While both techniques are implemented in the DirectX SDK using shaders, massively speeded up variation of the latter technique, taking advantage of shared memory, is implemented in addition to DirectX counterparts.
|
||||
|
||||
## Key Concepts
|
||||
|
||||
Image Processing
|
||||
|
||||
## Supported SM Architectures
|
||||
|
||||
[SM 3.5 ](https://developer.nvidia.com/cuda-gpus) [SM 3.7 ](https://developer.nvidia.com/cuda-gpus) [SM 5.0 ](https://developer.nvidia.com/cuda-gpus) [SM 5.2 ](https://developer.nvidia.com/cuda-gpus) [SM 6.0 ](https://developer.nvidia.com/cuda-gpus) [SM 6.1 ](https://developer.nvidia.com/cuda-gpus) [SM 7.0 ](https://developer.nvidia.com/cuda-gpus) [SM 7.2 ](https://developer.nvidia.com/cuda-gpus) [SM 7.5 ](https://developer.nvidia.com/cuda-gpus) [SM 8.0 ](https://developer.nvidia.com/cuda-gpus) [SM 8.6 ](https://developer.nvidia.com/cuda-gpus)
|
||||
|
||||
## Supported OSes
|
||||
|
||||
Linux, Windows
|
||||
|
||||
## Supported CPU Architecture
|
||||
|
||||
x86_64, armv7l
|
||||
|
||||
## CUDA APIs involved
|
||||
|
||||
## Dependencies needed to build/run
|
||||
[X11](../../README.md#x11), [GL](../../README.md#gl)
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Download and install the [CUDA Toolkit 11.5](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
|
||||
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
|
||||
|
||||
## Build and Run
|
||||
|
||||
### Windows
|
||||
The Windows samples are built using the Visual Studio IDE. Solution files (.sln) are provided for each supported version of Visual Studio, using the format:
|
||||
```
|
||||
*_vs<version>.sln - for Visual Studio <version>
|
||||
```
|
||||
Each individual sample has its own set of solution files in its directory:
|
||||
|
||||
To build/examine all the samples at once, the complete solution files should be used. To build/examine a single sample, the individual sample solution files should be used.
|
||||
> **Note:** Some samples require that the Microsoft DirectX SDK (June 2010 or newer) be installed and that the VC++ directory paths are properly set up (**Tools > Options...**). Check DirectX Dependencies section for details."
|
||||
|
||||
### Linux
|
||||
The Linux samples are built using makefiles. To use the makefiles, change the current directory to the sample directory you wish to build, and run make:
|
||||
```
|
||||
$ cd <sample_dir>
|
||||
$ make
|
||||
```
|
||||
The samples makefiles can take advantage of certain options:
|
||||
* **TARGET_ARCH=<arch>** - cross-compile targeting a specific architecture. Allowed architectures are x86_64, armv7l.
|
||||
By default, TARGET_ARCH is set to HOST_ARCH. On a x86_64 machine, not setting TARGET_ARCH is the equivalent of setting TARGET_ARCH=x86_64.<br/>
|
||||
`$ make TARGET_ARCH=x86_64` <br/> `$ make TARGET_ARCH=armv7l` <br/>
|
||||
See [here](http://docs.nvidia.com/cuda/cuda-samples/index.html#cross-samples) for more details.
|
||||
* **dbg=1** - build with debug symbols
|
||||
```
|
||||
$ make dbg=1
|
||||
```
|
||||
* **SMS="A B ..."** - override the SM architectures for which the sample will be built, where `"A B ..."` is a space-delimited list of SM architectures. For example, to generate SASS for SM 50 and SM 60, use `SMS="50 60"`.
|
||||
```
|
||||
$ make SMS="50 60"
|
||||
```
|
||||
|
||||
* **HOST_COMPILER=<host_compiler>** - override the default g++ host compiler. See the [Linux Installation Guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#system-requirements) for a list of supported host compilers.
|
||||
```
|
||||
$ make HOST_COMPILER=g++
|
||||
```
|
||||
|
||||
## References (for more details)
|
||||
|
||||
128
Samples/imageDenoising/bmploader.cpp
Normal file
128
Samples/imageDenoising/bmploader.cpp
Normal file
@@ -0,0 +1,128 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
|
||||
#pragma warning(disable : 4996) // disable deprecated warning
|
||||
#endif
|
||||
|
||||
#pragma pack(1)
|
||||
|
||||
typedef struct {
|
||||
short type;
|
||||
int size;
|
||||
short reserved1;
|
||||
short reserved2;
|
||||
int offset;
|
||||
} BMPHeader;
|
||||
|
||||
typedef struct {
|
||||
int size;
|
||||
int width;
|
||||
int height;
|
||||
short planes;
|
||||
short bitsPerPixel;
|
||||
unsigned compression;
|
||||
unsigned imageSize;
|
||||
int xPelsPerMeter;
|
||||
int yPelsPerMeter;
|
||||
int clrUsed;
|
||||
int clrImportant;
|
||||
} BMPInfoHeader;
|
||||
|
||||
// Isolated definition
|
||||
typedef struct { unsigned char x, y, z, w; } uchar4;
|
||||
|
||||
extern "C" void LoadBMPFile(uchar4 **dst, int *width, int *height,
|
||||
const char *name) {
|
||||
BMPHeader hdr;
|
||||
BMPInfoHeader infoHdr;
|
||||
int x, y;
|
||||
|
||||
FILE *fd;
|
||||
|
||||
printf("Loading %s...\n", name);
|
||||
|
||||
if (sizeof(uchar4) != 4) {
|
||||
printf("***Bad uchar4 size***\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
if (!(fd = fopen(name, "rb"))) {
|
||||
printf("***BMP load error: file access denied***\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
fread(&hdr, sizeof(hdr), 1, fd);
|
||||
|
||||
if (hdr.type != 0x4D42) {
|
||||
printf("***BMP load error: bad file format***\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
fread(&infoHdr, sizeof(infoHdr), 1, fd);
|
||||
|
||||
if (infoHdr.bitsPerPixel != 24) {
|
||||
printf("***BMP load error: invalid color depth***\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
if (infoHdr.compression) {
|
||||
printf("***BMP load error: compressed image***\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
*width = infoHdr.width;
|
||||
*height = infoHdr.height;
|
||||
*dst = (uchar4 *)malloc(*width * *height * 4);
|
||||
|
||||
printf("BMP width: %u\n", infoHdr.width);
|
||||
printf("BMP height: %u\n", infoHdr.height);
|
||||
|
||||
fseek(fd, hdr.offset - sizeof(hdr) - sizeof(infoHdr), SEEK_CUR);
|
||||
|
||||
for (y = 0; y < infoHdr.height; y++) {
|
||||
for (x = 0; x < infoHdr.width; x++) {
|
||||
(*dst)[(y * infoHdr.width + x)].z = fgetc(fd);
|
||||
(*dst)[(y * infoHdr.width + x)].y = fgetc(fd);
|
||||
(*dst)[(y * infoHdr.width + x)].x = fgetc(fd);
|
||||
}
|
||||
|
||||
for (x = 0; x < (4 - (3 * infoHdr.width) % 4) % 4; x++) fgetc(fd);
|
||||
}
|
||||
|
||||
if (ferror(fd)) {
|
||||
printf("***Unknown BMP load error.***\n");
|
||||
free(*dst);
|
||||
exit(EXIT_SUCCESS);
|
||||
} else
|
||||
printf("BMP file loaded successfully!\n");
|
||||
|
||||
fclose(fd);
|
||||
}
|
||||
BIN
Samples/imageDenoising/data/portrait_noise.bmp
Normal file
BIN
Samples/imageDenoising/data/portrait_noise.bmp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 383 KiB |
1465
Samples/imageDenoising/data/ref_knn.ppm
Normal file
1465
Samples/imageDenoising/data/ref_knn.ppm
Normal file
File diff suppressed because one or more lines are too long
1067
Samples/imageDenoising/data/ref_nlm.ppm
Normal file
1067
Samples/imageDenoising/data/ref_nlm.ppm
Normal file
File diff suppressed because one or more lines are too long
881
Samples/imageDenoising/data/ref_nlm2.ppm
Normal file
881
Samples/imageDenoising/data/ref_nlm2.ppm
Normal file
File diff suppressed because one or more lines are too long
BIN
Samples/imageDenoising/data/ref_passthru.ppm
Normal file
BIN
Samples/imageDenoising/data/ref_passthru.ppm
Normal file
Binary file not shown.
BIN
Samples/imageDenoising/doc/NLM_lg.png
Normal file
BIN
Samples/imageDenoising/doc/NLM_lg.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 450 KiB |
BIN
Samples/imageDenoising/doc/NLM_md.png
Normal file
BIN
Samples/imageDenoising/doc/NLM_md.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 147 KiB |
BIN
Samples/imageDenoising/doc/NLM_sm.png
Normal file
BIN
Samples/imageDenoising/doc/NLM_sm.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
BIN
Samples/imageDenoising/doc/imageDenoising.doc
Normal file
BIN
Samples/imageDenoising/doc/imageDenoising.doc
Normal file
Binary file not shown.
BIN
Samples/imageDenoising/doc/imageDenoising.pdf
Normal file
BIN
Samples/imageDenoising/doc/imageDenoising.pdf
Normal file
Binary file not shown.
145
Samples/imageDenoising/findgllib.mk
Normal file
145
Samples/imageDenoising/findgllib.mk
Normal file
@@ -0,0 +1,145 @@
|
||||
################################################################################
|
||||
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
# * Redistributions of source code must retain the above copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# * Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
# * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
# contributors may be used to endorse or promote products derived
|
||||
# from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
################################################################################
|
||||
#
|
||||
# findgllib.mk is used to find the necessary GL Libraries for specific distributions
|
||||
# this is supported on Mac OSX and Linux Platforms
|
||||
#
|
||||
################################################################################
|
||||
|
||||
# Determine OS platform and unix distribution
|
||||
ifeq ("$(TARGET_OS)","linux")
|
||||
# first search lsb_release
|
||||
DISTRO := $(shell lsb_release -i -s 2>/dev/null | tr "[:upper:]" "[:lower:]")
|
||||
ifeq ("$(DISTRO)","")
|
||||
# second search and parse /etc/issue
|
||||
DISTRO := $(shell awk '{print $$1}' /etc/issue | tr -d "[:space:]" | sed -e "/^$$/d" | tr "[:upper:]" "[:lower:]")
|
||||
# ensure data from /etc/issue is valid
|
||||
ifeq (,$(filter $(DISTRO),ubuntu fedora red rhel centos suse))
|
||||
DISTRO :=
|
||||
endif
|
||||
ifeq ("$(DISTRO)","")
|
||||
# third, we can search in /etc/os-release or /etc/{distro}-release
|
||||
DISTRO := $(shell awk '/ID/' /etc/*-release | sed 's/ID=//' | grep -v "VERSION" | grep -v "ID" | grep -v "DISTRIB")
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
ifeq ("$(TARGET_OS)","linux")
|
||||
# $(info) >> findgllib.mk -> LINUX path <<<)
|
||||
# Each set of Linux Distros have different paths for where to find their OpenGL libraries reside
|
||||
UBUNTU = $(shell echo $(DISTRO) | grep -i ubuntu >/dev/null 2>&1; echo $$?)
|
||||
FEDORA = $(shell echo $(DISTRO) | grep -i fedora >/dev/null 2>&1; echo $$?)
|
||||
RHEL = $(shell echo $(DISTRO) | grep -i 'red\|rhel' >/dev/null 2>&1; echo $$?)
|
||||
CENTOS = $(shell echo $(DISTRO) | grep -i centos >/dev/null 2>&1; echo $$?)
|
||||
SUSE = $(shell echo $(DISTRO) | grep -i 'suse\|sles' >/dev/null 2>&1; echo $$?)
|
||||
ifeq ("$(UBUNTU)","0")
|
||||
ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-armv7l)
|
||||
GLPATH := /usr/arm-linux-gnueabihf/lib
|
||||
GLLINK := -L/usr/arm-linux-gnueabihf/lib
|
||||
ifneq ($(TARGET_FS),)
|
||||
GLPATH += $(TARGET_FS)/usr/lib/arm-linux-gnueabihf
|
||||
GLLINK += -L$(TARGET_FS)/usr/lib/arm-linux-gnueabihf
|
||||
endif
|
||||
else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-aarch64)
|
||||
GLPATH := /usr/aarch64-linux-gnu/lib
|
||||
GLLINK := -L/usr/aarch64-linux-gnu/lib
|
||||
ifneq ($(TARGET_FS),)
|
||||
GLPATH += $(TARGET_FS)/usr/lib
|
||||
GLPATH += $(TARGET_FS)/usr/lib/aarch64-linux-gnu
|
||||
GLLINK += -L$(TARGET_FS)/usr/lib/aarch64-linux-gnu
|
||||
endif
|
||||
else ifeq ($(HOST_ARCH)-$(TARGET_ARCH),x86_64-ppc64le)
|
||||
GLPATH := /usr/powerpc64le-linux-gnu/lib
|
||||
GLLINK := -L/usr/powerpc64le-linux-gnu/lib
|
||||
else
|
||||
UBUNTU_PKG_NAME = $(shell which dpkg >/dev/null 2>&1 && dpkg -l 'nvidia-*' | grep '^ii' | awk '{print $$2}' | head -1)
|
||||
ifneq ("$(UBUNTU_PKG_NAME)","")
|
||||
GLPATH ?= /usr/lib/$(UBUNTU_PKG_NAME)
|
||||
GLLINK ?= -L/usr/lib/$(UBUNTU_PKG_NAME)
|
||||
endif
|
||||
|
||||
DFLT_PATH ?= /usr/lib
|
||||
endif
|
||||
endif
|
||||
ifeq ("$(SUSE)","0")
|
||||
GLPATH ?= /usr/X11R6/lib64
|
||||
GLLINK ?= -L/usr/X11R6/lib64
|
||||
DFLT_PATH ?= /usr/lib64
|
||||
endif
|
||||
ifeq ("$(FEDORA)","0")
|
||||
GLPATH ?= /usr/lib64/nvidia
|
||||
GLLINK ?= -L/usr/lib64/nvidia
|
||||
DFLT_PATH ?= /usr/lib64
|
||||
endif
|
||||
ifeq ("$(RHEL)","0")
|
||||
GLPATH ?= /usr/lib64/nvidia
|
||||
GLLINK ?= -L/usr/lib64/nvidia
|
||||
DFLT_PATH ?= /usr/lib64
|
||||
endif
|
||||
ifeq ("$(CENTOS)","0")
|
||||
GLPATH ?= /usr/lib64/nvidia
|
||||
GLLINK ?= -L/usr/lib64/nvidia
|
||||
DFLT_PATH ?= /usr/lib64
|
||||
endif
|
||||
|
||||
# find libGL, libGLU
|
||||
GLLIB := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGL.so -print 2>/dev/null)
|
||||
GLULIB := $(shell find -L $(GLPATH) $(DFLT_PATH) -name libGLU.so -print 2>/dev/null)
|
||||
|
||||
ifeq ("$(GLLIB)","")
|
||||
$(info >>> WARNING - libGL.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
ifeq ("$(GLULIB)","")
|
||||
$(info >>> WARNING - libGLU.so not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
|
||||
HEADER_SEARCH_PATH ?= $(TARGET_FS)/usr/include
|
||||
ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
|
||||
HEADER_SEARCH_PATH += /usr/arm-linux-gnueabihf/include
|
||||
else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-aarch64-linux)
|
||||
HEADER_SEARCH_PATH += /usr/aarch64-linux-gnu/include
|
||||
endif
|
||||
|
||||
GLHEADER := $(shell find -L $(HEADER_SEARCH_PATH) -name gl.h -print 2>/dev/null)
|
||||
GLUHEADER := $(shell find -L $(HEADER_SEARCH_PATH) -name glu.h -print 2>/dev/null)
|
||||
|
||||
ifeq ("$(GLHEADER)","")
|
||||
$(info >>> WARNING - gl.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
ifeq ("$(GLUHEADER)","")
|
||||
$(info >>> WARNING - glu.h not found, refer to CUDA Getting Started Guide for how to find and install them. <<<)
|
||||
SAMPLE_ENABLED := 0
|
||||
endif
|
||||
else
|
||||
# This would be the Mac OS X path if we had to do anything special
|
||||
endif
|
||||
|
||||
112
Samples/imageDenoising/imageDenoising.cu
Normal file
112
Samples/imageDenoising/imageDenoising.cu
Normal file
@@ -0,0 +1,112 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This sample demonstrates two adaptive image denoising techniques:
|
||||
* KNN and NLM, based on computation of both geometric and color distance
|
||||
* between texels. While both techniques are already implemented in the
|
||||
* DirectX SDK using shaders, massively speeded up variation
|
||||
* of the latter technique, taking advantage of shared memory, is implemented
|
||||
* in addition to DirectX counterparts.
|
||||
* See supplied whitepaper for more explanations.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <helper_cuda.h>
|
||||
#include "imageDenoising.h"
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Helper functions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
float Max(float x, float y) { return (x > y) ? x : y; }
|
||||
|
||||
float Min(float x, float y) { return (x < y) ? x : y; }
|
||||
|
||||
int iDivUp(int a, int b) { return ((a % b) != 0) ? (a / b + 1) : (a / b); }
|
||||
|
||||
__device__ float lerpf(float a, float b, float c) { return a + (b - a) * c; }
|
||||
|
||||
__device__ float vecLen(float4 a, float4 b) {
|
||||
return ((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y) +
|
||||
(b.z - a.z) * (b.z - a.z));
|
||||
}
|
||||
|
||||
__device__ TColor make_color(float r, float g, float b, float a) {
|
||||
return ((int)(a * 255.0f) << 24) | ((int)(b * 255.0f) << 16) |
|
||||
((int)(g * 255.0f) << 8) | ((int)(r * 255.0f) << 0);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Global data handlers and parameters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Texture object and channel descriptor for image texture
|
||||
cudaTextureObject_t texImage;
|
||||
cudaChannelFormatDesc uchar4tex = cudaCreateChannelDesc<uchar4>();
|
||||
|
||||
// CUDA array descriptor
|
||||
cudaArray *a_Src;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Filtering kernels
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#include "imageDenoising_copy_kernel.cuh"
|
||||
#include "imageDenoising_knn_kernel.cuh"
|
||||
#include "imageDenoising_nlm_kernel.cuh"
|
||||
#include "imageDenoising_nlm2_kernel.cuh"
|
||||
|
||||
extern "C" cudaError_t CUDA_MallocArray(uchar4 **h_Src, int imageW,
|
||||
int imageH) {
|
||||
cudaError_t error;
|
||||
|
||||
error = cudaMallocArray(&a_Src, &uchar4tex, imageW, imageH);
|
||||
error = cudaMemcpy2DToArray(a_Src, 0, 0, *h_Src, sizeof(uchar4) * imageW,
|
||||
sizeof(uchar4) * imageW, imageH,
|
||||
cudaMemcpyHostToDevice);
|
||||
|
||||
cudaResourceDesc texRes;
|
||||
memset(&texRes, 0, sizeof(cudaResourceDesc));
|
||||
|
||||
texRes.resType = cudaResourceTypeArray;
|
||||
texRes.res.array.array = a_Src;
|
||||
|
||||
cudaTextureDesc texDescr;
|
||||
memset(&texDescr, 0, sizeof(cudaTextureDesc));
|
||||
|
||||
texDescr.normalizedCoords = false;
|
||||
texDescr.filterMode = cudaFilterModeLinear;
|
||||
texDescr.addressMode[0] = cudaAddressModeWrap;
|
||||
texDescr.addressMode[1] = cudaAddressModeWrap;
|
||||
texDescr.readMode = cudaReadModeNormalizedFloat;
|
||||
|
||||
checkCudaErrors(cudaCreateTextureObject(&texImage, &texRes, &texDescr, NULL));
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
extern "C" cudaError_t CUDA_FreeArray() { return cudaFreeArray(a_Src); }
|
||||
89
Samples/imageDenoising/imageDenoising.h
Normal file
89
Samples/imageDenoising/imageDenoising.h
Normal file
@@ -0,0 +1,89 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef IMAGE_DENOISING_H
|
||||
#define IMAGE_DENOISING_H
|
||||
|
||||
typedef unsigned int TColor;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Filter configuration
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#define KNN_WINDOW_RADIUS 3
|
||||
#define NLM_WINDOW_RADIUS 3
|
||||
#define NLM_BLOCK_RADIUS 3
|
||||
#define KNN_WINDOW_AREA \
|
||||
((2 * KNN_WINDOW_RADIUS + 1) * (2 * KNN_WINDOW_RADIUS + 1))
|
||||
#define NLM_WINDOW_AREA \
|
||||
((2 * NLM_WINDOW_RADIUS + 1) * (2 * NLM_WINDOW_RADIUS + 1))
|
||||
#define INV_KNN_WINDOW_AREA (1.0f / (float)KNN_WINDOW_AREA)
|
||||
#define INV_NLM_WINDOW_AREA (1.0f / (float)NLM_WINDOW_AREA)
|
||||
|
||||
#define KNN_WEIGHT_THRESHOLD 0.02f
|
||||
#define KNN_LERP_THRESHOLD 0.79f
|
||||
#define NLM_WEIGHT_THRESHOLD 0.10f
|
||||
#define NLM_LERP_THRESHOLD 0.10f
|
||||
|
||||
#define BLOCKDIM_X 8
|
||||
#define BLOCKDIM_Y 8
|
||||
|
||||
#ifndef MAX
|
||||
#define MAX(a, b) ((a < b) ? b : a)
|
||||
#endif
|
||||
#ifndef MIN
|
||||
#define MIN(a, b) ((a < b) ? a : b)
|
||||
#endif
|
||||
|
||||
// functions to load images
|
||||
extern "C" void LoadBMPFile(uchar4 **dst, int *width, int *height,
|
||||
const char *name);
|
||||
|
||||
// CUDA wrapper functions for allocation/freeing texture arrays
|
||||
extern "C" cudaTextureObject_t texImage;
|
||||
|
||||
extern "C" cudaError_t CUDA_MallocArray(uchar4 **h_Src, int imageW, int imageH);
|
||||
extern "C" cudaError_t CUDA_FreeArray();
|
||||
|
||||
// CUDA kernel functions
|
||||
extern "C" void cuda_Copy(TColor *d_dst, int imageW, int imageH,
|
||||
cudaTextureObject_t texImage);
|
||||
extern "C" void cuda_KNN(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage);
|
||||
extern "C" void cuda_KNNdiag(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage);
|
||||
extern "C" void cuda_NLM(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage);
|
||||
extern "C" void cuda_NLMdiag(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage);
|
||||
|
||||
extern "C" void cuda_NLM2(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float LerpC, cudaTextureObject_t texImage);
|
||||
extern "C" void cuda_NLM2diag(TColor *d_dst, int imageW, int imageH,
|
||||
float Noise, float LerpC,
|
||||
cudaTextureObject_t texImage);
|
||||
|
||||
#endif
|
||||
560
Samples/imageDenoising/imageDenoisingGL.cpp
Normal file
560
Samples/imageDenoising/imageDenoisingGL.cpp
Normal file
@@ -0,0 +1,560 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This sample demonstrates two adaptive image denoising techniques:
|
||||
* KNN and NLM, based on computation of both geometric and color distance
|
||||
* between texels. While both techniques are already implemented in the
|
||||
* DirectX SDK using shaders, massively speeded up variation
|
||||
* of the latter technique, taking advantage of shared memory, is implemented
|
||||
* in addition to DirectX counterparts.
|
||||
* See supplied whitepaper for more explanations.
|
||||
*/
|
||||
|
||||
// OpenGL Graphics includes
|
||||
#include <helper_gl.h>
|
||||
#if defined(__APPLE__) || defined(MACOSX)
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||||
#include <GLUT/glut.h>
|
||||
#else
|
||||
#include <GL/freeglut.h>
|
||||
#endif
|
||||
|
||||
// CUDA utilities and system includes
|
||||
#include <cuda_runtime.h>
|
||||
#include <cuda_gl_interop.h>
|
||||
|
||||
// Includes
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "imageDenoising.h"
|
||||
|
||||
// includes, project
|
||||
#include <helper_functions.h> // includes for helper utility functions
|
||||
#include <helper_cuda.h> // includes for cuda error checking and initialization
|
||||
|
||||
const char *sSDKsample = "CUDA ImageDenoising";
|
||||
|
||||
const char *filterMode[] = {"Passthrough", "KNN method", "NLM method",
|
||||
"Quick NLM(NLM2) method", NULL};
|
||||
|
||||
// Define the files that are to be save and the reference images for validation
|
||||
const char *sOriginal[] = {"image_passthru.ppm", "image_knn.ppm",
|
||||
"image_nlm.ppm", "image_nlm2.ppm", NULL};
|
||||
|
||||
const char *sReference[] = {"ref_passthru.ppm", "ref_knn.ppm", "ref_nlm.ppm",
|
||||
"ref_nlm2.ppm", NULL};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Global data handlers and parameters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL PBO and texture "names"
|
||||
GLuint gl_PBO, gl_Tex;
|
||||
struct cudaGraphicsResource *cuda_pbo_resource; // handles OpenGL-CUDA exchange
|
||||
// Source image on the host side
|
||||
uchar4 *h_Src;
|
||||
int imageW, imageH;
|
||||
GLuint shader;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Main program
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
int g_Kernel = 0;
|
||||
bool g_FPS = false;
|
||||
bool g_Diag = false;
|
||||
StopWatchInterface *timer = NULL;
|
||||
|
||||
// Algorithms global parameters
|
||||
const float noiseStep = 0.025f;
|
||||
const float lerpStep = 0.025f;
|
||||
static float knnNoise = 0.32f;
|
||||
static float nlmNoise = 1.45f;
|
||||
static float lerpC = 0.2f;
|
||||
|
||||
const int frameN = 24;
|
||||
int frameCounter = 0;
|
||||
|
||||
#define BUFFER_DATA(i) ((char *)0 + i)
|
||||
|
||||
// Auto-Verification Code
|
||||
const int frameCheckNumber = 4;
|
||||
int fpsCount = 0; // FPS count for averaging
|
||||
int fpsLimit = 1; // FPS limit for sampling
|
||||
unsigned int frameCount = 0;
|
||||
unsigned int g_TotalErrors = 0;
|
||||
|
||||
int *pArgc = NULL;
|
||||
char **pArgv = NULL;
|
||||
|
||||
#define MAX_EPSILON_ERROR 5
|
||||
#define REFRESH_DELAY 10 // ms
|
||||
|
||||
void cleanup();
|
||||
|
||||
void computeFPS() {
|
||||
frameCount++;
|
||||
fpsCount++;
|
||||
|
||||
if (fpsCount == fpsLimit) {
|
||||
char fps[256];
|
||||
float ifps = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
|
||||
sprintf(fps, "<%s>: %3.1f fps", filterMode[g_Kernel], ifps);
|
||||
|
||||
glutSetWindowTitle(fps);
|
||||
fpsCount = 0;
|
||||
|
||||
// fpsLimit = (int)MAX(ifps, 1.f);
|
||||
sdkResetTimer(&timer);
|
||||
}
|
||||
}
|
||||
|
||||
void runImageFilters(TColor *d_dst) {
|
||||
switch (g_Kernel) {
|
||||
case 0:
|
||||
cuda_Copy(d_dst, imageW, imageH, texImage);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if (!g_Diag) {
|
||||
cuda_KNN(d_dst, imageW, imageH, 1.0f / (knnNoise * knnNoise), lerpC,
|
||||
texImage);
|
||||
} else {
|
||||
cuda_KNNdiag(d_dst, imageW, imageH, 1.0f / (knnNoise * knnNoise), lerpC,
|
||||
texImage);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 2:
|
||||
if (!g_Diag) {
|
||||
cuda_NLM(d_dst, imageW, imageH, 1.0f / (nlmNoise * nlmNoise), lerpC,
|
||||
texImage);
|
||||
} else {
|
||||
cuda_NLMdiag(d_dst, imageW, imageH, 1.0f / (nlmNoise * nlmNoise), lerpC,
|
||||
texImage);
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 3:
|
||||
if (!g_Diag) {
|
||||
cuda_NLM2(d_dst, imageW, imageH, 1.0f / (nlmNoise * nlmNoise), lerpC,
|
||||
texImage);
|
||||
} else {
|
||||
cuda_NLM2diag(d_dst, imageW, imageH, 1.0f / (nlmNoise * nlmNoise),
|
||||
lerpC, texImage);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
getLastCudaError("Filtering kernel execution failed.\n");
|
||||
}
|
||||
|
||||
void displayFunc(void) {
|
||||
sdkStartTimer(&timer);
|
||||
TColor *d_dst = NULL;
|
||||
size_t num_bytes;
|
||||
|
||||
if (frameCounter++ == 0) {
|
||||
sdkResetTimer(&timer);
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
|
||||
getLastCudaError("cudaGraphicsMapResources failed");
|
||||
checkCudaErrors(cudaGraphicsResourceGetMappedPointer(
|
||||
(void **)&d_dst, &num_bytes, cuda_pbo_resource));
|
||||
getLastCudaError("cudaGraphicsResourceGetMappedPointer failed");
|
||||
|
||||
runImageFilters(d_dst);
|
||||
|
||||
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
|
||||
|
||||
// Common display code path
|
||||
{
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA,
|
||||
GL_UNSIGNED_BYTE, BUFFER_DATA(0));
|
||||
glBegin(GL_TRIANGLES);
|
||||
glTexCoord2f(0, 0);
|
||||
glVertex2f(-1, -1);
|
||||
glTexCoord2f(2, 0);
|
||||
glVertex2f(+3, -1);
|
||||
glTexCoord2f(0, 2);
|
||||
glVertex2f(-1, +3);
|
||||
glEnd();
|
||||
glFinish();
|
||||
}
|
||||
|
||||
if (frameCounter == frameN) {
|
||||
frameCounter = 0;
|
||||
|
||||
if (g_FPS) {
|
||||
printf("FPS: %3.1f\n", frameN / (sdkGetTimerValue(&timer) * 0.001));
|
||||
g_FPS = false;
|
||||
}
|
||||
}
|
||||
|
||||
glutSwapBuffers();
|
||||
glutReportErrors();
|
||||
|
||||
sdkStopTimer(&timer);
|
||||
|
||||
computeFPS();
|
||||
}
|
||||
|
||||
void timerEvent(int value) {
|
||||
if (glutGetWindow()) {
|
||||
glutPostRedisplay();
|
||||
glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void keyboard(unsigned char k, int /*x*/, int /*y*/) {
|
||||
switch (k) {
|
||||
case 27:
|
||||
case 'q':
|
||||
case 'Q':
|
||||
#if defined(__APPLE__) || defined(MACOSX)
|
||||
exit(EXIT_SUCCESS);
|
||||
#else
|
||||
glutDestroyWindow(glutGetWindow());
|
||||
return;
|
||||
#endif
|
||||
|
||||
case '1':
|
||||
printf("Passthrough.\n");
|
||||
g_Kernel = 0;
|
||||
break;
|
||||
|
||||
case '2':
|
||||
printf("KNN method \n");
|
||||
g_Kernel = 1;
|
||||
break;
|
||||
|
||||
case '3':
|
||||
printf("NLM method\n");
|
||||
g_Kernel = 2;
|
||||
break;
|
||||
|
||||
case '4':
|
||||
printf("Quick NLM(NLM2) method\n");
|
||||
g_Kernel = 3;
|
||||
break;
|
||||
|
||||
case '*':
|
||||
printf(g_Diag ? "LERP highlighting mode.\n" : "Normal mode.\n");
|
||||
g_Diag = !g_Diag;
|
||||
break;
|
||||
|
||||
case 'n':
|
||||
printf("Decrease noise level.\n");
|
||||
knnNoise -= noiseStep;
|
||||
nlmNoise -= noiseStep;
|
||||
break;
|
||||
|
||||
case 'N':
|
||||
printf("Increase noise level.\n");
|
||||
knnNoise += noiseStep;
|
||||
nlmNoise += noiseStep;
|
||||
break;
|
||||
|
||||
case 'l':
|
||||
printf("Decrease LERP quotient.\n");
|
||||
lerpC = MAX(lerpC - lerpStep, 0.0f);
|
||||
break;
|
||||
|
||||
case 'L':
|
||||
printf("Increase LERP quotient.\n");
|
||||
lerpC = MIN(lerpC + lerpStep, 1.0f);
|
||||
break;
|
||||
|
||||
case 'f':
|
||||
case 'F':
|
||||
g_FPS = true;
|
||||
break;
|
||||
|
||||
case '?':
|
||||
printf("lerpC = %5.5f\n", lerpC);
|
||||
printf("knnNoise = %5.5f\n", knnNoise);
|
||||
printf("nlmNoise = %5.5f\n", nlmNoise);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int initGL(int *argc, char **argv) {
|
||||
printf("Initializing GLUT...\n");
|
||||
glutInit(argc, argv);
|
||||
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
|
||||
glutInitWindowSize(imageW, imageH);
|
||||
glutInitWindowPosition(512 - imageW / 2, 384 - imageH / 2);
|
||||
glutCreateWindow(argv[0]);
|
||||
glutDisplayFunc(displayFunc);
|
||||
glutKeyboardFunc(keyboard);
|
||||
glutTimerFunc(REFRESH_DELAY, timerEvent, 0);
|
||||
printf("OpenGL window created.\n");
|
||||
|
||||
#if defined(__APPLE__) || defined(MACOSX)
|
||||
atexit(cleanup);
|
||||
#else
|
||||
glutCloseFunc(cleanup);
|
||||
#endif
|
||||
|
||||
if (!isGLVersionSupported(1, 5) ||
|
||||
!areGLExtensionsSupported(
|
||||
"GL_ARB_vertex_buffer_object GL_ARB_pixel_buffer_object")) {
|
||||
fprintf(stderr, "Error: failed to get minimal extensions for demo\n");
|
||||
fprintf(stderr, "This sample requires:\n");
|
||||
fprintf(stderr, " OpenGL version 1.5\n");
|
||||
fprintf(stderr, " GL_ARB_vertex_buffer_object\n");
|
||||
fprintf(stderr, " GL_ARB_pixel_buffer_object\n");
|
||||
fflush(stderr);
|
||||
return false;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// shader for displaying floating-point texture
|
||||
static const char *shader_code =
|
||||
"!!ARBfp1.0\n"
|
||||
"TEX result.color, fragment.texcoord, texture[0], 2D; \n"
|
||||
"END";
|
||||
|
||||
GLuint compileASMShader(GLenum program_type, const char *code) {
|
||||
GLuint program_id;
|
||||
glGenProgramsARB(1, &program_id);
|
||||
glBindProgramARB(program_type, program_id);
|
||||
glProgramStringARB(program_type, GL_PROGRAM_FORMAT_ASCII_ARB,
|
||||
(GLsizei)strlen(code), (GLubyte *)code);
|
||||
|
||||
GLint error_pos;
|
||||
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
|
||||
|
||||
if (error_pos != -1) {
|
||||
const GLubyte *error_string;
|
||||
error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
|
||||
fprintf(stderr, "Program error at position: %d\n%s\n", (int)error_pos,
|
||||
error_string);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return program_id;
|
||||
}
|
||||
|
||||
void initOpenGLBuffers() {
|
||||
printf("Creating GL texture...\n");
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glGenTextures(1, &gl_Tex);
|
||||
glBindTexture(GL_TEXTURE_2D, gl_Tex);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, imageW, imageH, 0, GL_RGBA,
|
||||
GL_UNSIGNED_BYTE, h_Src);
|
||||
printf("Texture created.\n");
|
||||
|
||||
printf("Creating PBO...\n");
|
||||
glGenBuffers(1, &gl_PBO);
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, gl_PBO);
|
||||
glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, imageW * imageH * 4, h_Src,
|
||||
GL_STREAM_COPY);
|
||||
// While a PBO is registered to CUDA, it can't be used
|
||||
// as the destination for OpenGL drawing calls.
|
||||
// But in our particular case OpenGL is only used
|
||||
// to display the content of the PBO, specified by CUDA kernels,
|
||||
// so we need to register/unregister it only once.
|
||||
// DEPRECATED: checkCudaErrors(cudaGLRegisterBufferObject(gl_PBO) );
|
||||
checkCudaErrors(cudaGraphicsGLRegisterBuffer(
|
||||
&cuda_pbo_resource, gl_PBO, cudaGraphicsMapFlagsWriteDiscard));
|
||||
GLenum gl_error = glGetError();
|
||||
|
||||
if (gl_error != GL_NO_ERROR) {
|
||||
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
|
||||
char tmpStr[512];
|
||||
// NOTE: "%s(%i) : " allows Visual Studio to directly jump to the file at
|
||||
// the right line when the user double clicks on the error line in the
|
||||
// Output pane. Like any compile error.
|
||||
sprintf_s(tmpStr, 255, "\n%s(%i) : GL Error : %s\n\n", __FILE__, __LINE__,
|
||||
gluErrorString(gl_error));
|
||||
OutputDebugString(tmpStr);
|
||||
#endif
|
||||
fprintf(stderr, "GL Error in file '%s' in line %d :\n", __FILE__, __LINE__);
|
||||
fprintf(stderr, "%s\n", gluErrorString(gl_error));
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
printf("PBO created.\n");
|
||||
|
||||
// load shader program
|
||||
shader = compileASMShader(GL_FRAGMENT_PROGRAM_ARB, shader_code);
|
||||
}
|
||||
|
||||
void cleanup() {
|
||||
free(h_Src);
|
||||
checkCudaErrors(CUDA_FreeArray());
|
||||
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
|
||||
|
||||
glDeleteProgramsARB(1, &shader);
|
||||
|
||||
sdkDeleteTimer(&timer);
|
||||
}
|
||||
|
||||
void runAutoTest(int argc, char **argv, const char *filename,
|
||||
int kernel_param) {
|
||||
printf("[%s] - (automated testing w/ readback)\n", sSDKsample);
|
||||
|
||||
int devID = findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
// First load the image, so we know what the size of the image (imageW and
|
||||
// imageH)
|
||||
printf("Allocating host and CUDA memory and loading image file...\n");
|
||||
const char *image_path = sdkFindFilePath("portrait_noise.bmp", argv[0]);
|
||||
|
||||
if (image_path == NULL) {
|
||||
printf(
|
||||
"imageDenoisingGL was unable to find and load image file "
|
||||
"<portrait_noise.bmp>.\nExiting...\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
|
||||
printf("Data init done.\n");
|
||||
|
||||
checkCudaErrors(CUDA_MallocArray(&h_Src, imageW, imageH));
|
||||
|
||||
TColor *d_dst = NULL;
|
||||
unsigned char *h_dst = NULL;
|
||||
checkCudaErrors(
|
||||
cudaMalloc((void **)&d_dst, imageW * imageH * sizeof(TColor)));
|
||||
h_dst = (unsigned char *)malloc(imageH * imageW * 4);
|
||||
|
||||
{
|
||||
g_Kernel = kernel_param;
|
||||
printf("[AutoTest]: %s <%s>\n", sSDKsample, filterMode[g_Kernel]);
|
||||
|
||||
runImageFilters(d_dst);
|
||||
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
checkCudaErrors(cudaMemcpy(h_dst, d_dst, imageW * imageH * sizeof(TColor),
|
||||
cudaMemcpyDeviceToHost));
|
||||
sdkSavePPM4ub(filename, h_dst, imageW, imageH);
|
||||
}
|
||||
|
||||
checkCudaErrors(CUDA_FreeArray());
|
||||
free(h_Src);
|
||||
|
||||
checkCudaErrors(cudaFree(d_dst));
|
||||
free(h_dst);
|
||||
|
||||
printf("\n[%s] -> Kernel %d, Saved: %s\n", sSDKsample, kernel_param,
|
||||
filename);
|
||||
|
||||
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char *dump_file = NULL;
|
||||
|
||||
#if defined(__linux__)
|
||||
setenv("DISPLAY", ":0", 0);
|
||||
#endif
|
||||
|
||||
pArgc = &argc;
|
||||
pArgv = argv;
|
||||
|
||||
printf("%s Starting...\n\n", sSDKsample);
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "file",
|
||||
(char **)&dump_file);
|
||||
|
||||
int kernel = 1;
|
||||
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "kernel")) {
|
||||
kernel = getCmdLineArgumentInt(argc, (const char **)argv, "kernel");
|
||||
}
|
||||
|
||||
runAutoTest(argc, argv, dump_file, kernel);
|
||||
} else {
|
||||
printf("[%s]\n", sSDKsample);
|
||||
|
||||
// use command-line specified CUDA device, otherwise use device with highest
|
||||
// Gflops/s
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "device")) {
|
||||
printf("[%s]\n", argv[0]);
|
||||
printf(" Does not explicitly support -device=n in OpenGL mode\n");
|
||||
printf(" To use -device=n, the sample must be running w/o OpenGL\n\n");
|
||||
printf(" > %s -device=n -qatest\n", argv[0]);
|
||||
printf("exiting...\n");
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
|
||||
// First load the image, so we know what the size of the image (imageW and
|
||||
// imageH)
|
||||
printf("Allocating host and CUDA memory and loading image file...\n");
|
||||
const char *image_path = sdkFindFilePath("portrait_noise.bmp", argv[0]);
|
||||
|
||||
if (image_path == NULL) {
|
||||
printf(
|
||||
"imageDenoisingGL was unable to find and load image file "
|
||||
"<portrait_noise.bmp>.\nExiting...\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
LoadBMPFile(&h_Src, &imageW, &imageH, image_path);
|
||||
printf("Data init done.\n");
|
||||
|
||||
initGL(&argc, argv);
|
||||
findCudaDevice(argc, (const char **)argv);
|
||||
|
||||
checkCudaErrors(CUDA_MallocArray(&h_Src, imageW, imageH));
|
||||
|
||||
initOpenGLBuffers();
|
||||
}
|
||||
|
||||
printf("Starting GLUT main loop...\n");
|
||||
printf("Press [1] to view noisy image\n");
|
||||
printf("Press [2] to view image restored with knn filter\n");
|
||||
printf("Press [3] to view image restored with nlm filter\n");
|
||||
printf("Press [4] to view image restored with modified nlm filter\n");
|
||||
printf(
|
||||
"Press [*] to view smooth/edgy areas [RED/BLUE] Ct's when a filter is "
|
||||
"active\n");
|
||||
printf("Press [f] to print frame rate\n");
|
||||
printf("Press [?] to print Noise and Lerp Ct's\n");
|
||||
printf("Press [q] to exit\n");
|
||||
|
||||
sdkCreateTimer(&timer);
|
||||
sdkStartTimer(&timer);
|
||||
|
||||
glutMainLoop();
|
||||
}
|
||||
48
Samples/imageDenoising/imageDenoising_copy_kernel.cuh
Normal file
48
Samples/imageDenoising/imageDenoising_copy_kernel.cuh
Normal file
@@ -0,0 +1,48 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
__global__ void Copy(TColor *dst, int imageW, int imageH,
|
||||
cudaTextureObject_t texImage) {
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
float4 fresult = tex2D<float4>(texImage, x, y);
|
||||
dst[imageW * iy + ix] = make_color(fresult.x, fresult.y, fresult.z, 0);
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void cuda_Copy(TColor *d_dst, int imageW, int imageH,
|
||||
cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
Copy<<<grid, threads>>>(d_dst, imageW, imageH, texImage);
|
||||
}
|
||||
146
Samples/imageDenoising/imageDenoising_knn_kernel.cuh
Normal file
146
Samples/imageDenoising/imageDenoising_knn_kernel.cuh
Normal file
@@ -0,0 +1,146 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// KNN kernel
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void KNN(TColor *dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Normalized counter for the weight threshold
|
||||
float fCount = 0;
|
||||
// Total sum of pixel weights
|
||||
float sumWeights = 0;
|
||||
// Result accumulator
|
||||
float3 clr = {0, 0, 0};
|
||||
// Center of the KNN window
|
||||
float4 clr00 = tex2D<float4>(texImage, x, y);
|
||||
|
||||
// Cycle through KNN window, surrounding (x, y) texel
|
||||
for (float i = -KNN_WINDOW_RADIUS; i <= KNN_WINDOW_RADIUS; i++)
|
||||
for (float j = -KNN_WINDOW_RADIUS; j <= KNN_WINDOW_RADIUS; j++) {
|
||||
float4 clrIJ = tex2D<float4>(texImage, x + j, y + i);
|
||||
float distanceIJ = vecLen(clr00, clrIJ);
|
||||
|
||||
// Derive final weight from color distance
|
||||
float weightIJ = __expf(
|
||||
-(distanceIJ * Noise + (i * i + j * j) * INV_KNN_WINDOW_AREA));
|
||||
|
||||
// Accumulate (x + j, y + i) texel color with computed weight
|
||||
clr.x += clrIJ.x * weightIJ;
|
||||
clr.y += clrIJ.y * weightIJ;
|
||||
clr.z += clrIJ.z * weightIJ;
|
||||
|
||||
// Sum of weights for color normalization to [0..1] range
|
||||
sumWeights += weightIJ;
|
||||
|
||||
// Update weight counter, if KNN weight for current window texel
|
||||
// exceeds the weight threshold
|
||||
fCount += (weightIJ > KNN_WEIGHT_THRESHOLD) ? INV_KNN_WINDOW_AREA : 0;
|
||||
}
|
||||
|
||||
// Normalize result color by sum of weights
|
||||
sumWeights = 1.0f / sumWeights;
|
||||
clr.x *= sumWeights;
|
||||
clr.y *= sumWeights;
|
||||
clr.z *= sumWeights;
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the KNN window exceeded the weight threshold
|
||||
float lerpQ = (fCount > KNN_LERP_THRESHOLD) ? lerpC : 1.0f - lerpC;
|
||||
|
||||
// Write final result to global memory
|
||||
clr.x = lerpf(clr.x, clr00.x, lerpQ);
|
||||
clr.y = lerpf(clr.y, clr00.y, lerpQ);
|
||||
clr.z = lerpf(clr.z, clr00.z, lerpQ);
|
||||
dst[imageW * iy + ix] = make_color(clr.x, clr.y, clr.z, 0);
|
||||
};
|
||||
}
|
||||
|
||||
extern "C" void cuda_KNN(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
KNN<<<grid, threads>>>(d_dst, imageW, imageH, Noise, lerpC, texImage);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Stripped KNN kernel, only highlighting areas with different LERP directions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void KNNdiag(TColor *dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Normalized counter for the weight threshold
|
||||
float fCount = 0;
|
||||
// Center of the KNN window
|
||||
float4 clr00 = tex2D<float4>(texImage, x, y);
|
||||
|
||||
// Cycle through KNN window, surrounding (x, y) texel
|
||||
for (float i = -KNN_WINDOW_RADIUS; i <= KNN_WINDOW_RADIUS; i++)
|
||||
for (float j = -KNN_WINDOW_RADIUS; j <= KNN_WINDOW_RADIUS; j++) {
|
||||
float4 clrIJ = tex2D<float4>(texImage, x + j, y + i);
|
||||
float distanceIJ = vecLen(clr00, clrIJ);
|
||||
|
||||
// Derive final weight from color and geometric distance
|
||||
float weightIJ = __expf(
|
||||
-(distanceIJ * Noise + (i * i + j * j) * INV_KNN_WINDOW_AREA));
|
||||
|
||||
// Update weight counter, if KNN weight for current window texel
|
||||
// exceeds the weight threshold
|
||||
fCount +=
|
||||
(weightIJ > KNN_WEIGHT_THRESHOLD) ? INV_KNN_WINDOW_AREA : 0.0f;
|
||||
}
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the KNN window exceeded the weight threshold
|
||||
float lerpQ = (fCount > KNN_LERP_THRESHOLD) ? 1.0f : 0;
|
||||
|
||||
// Write final result to global memory
|
||||
dst[imageW * iy + ix] = make_color(lerpQ, 0, (1.0f - lerpQ), 0);
|
||||
};
|
||||
}
|
||||
|
||||
extern "C" void cuda_KNNdiag(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
KNNdiag<<<grid, threads>>>(d_dst, imageW, imageH, Noise, lerpC, texImage);
|
||||
}
|
||||
217
Samples/imageDenoising/imageDenoising_nlm2_kernel.cuh
Normal file
217
Samples/imageDenoising/imageDenoising_nlm2_kernel.cuh
Normal file
@@ -0,0 +1,217 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// 0 1 2 3 4 5 6 7
|
||||
// 0 + . . . . . . .
|
||||
// 1 . . . . . . . .
|
||||
// 2 . . . . . . . .
|
||||
// 3 . . . * . . . .
|
||||
// 4 . . . . . . . .
|
||||
// 5 . . . . . . . .
|
||||
// 6 . . . . . . . .
|
||||
// 7 . . . . . . . .
|
||||
//
|
||||
// * - Base point for every thread, + - pixel around which ColorDistance is
|
||||
// computed
|
||||
// The idea behind this method:
|
||||
// - Every thread in a 8x8 block computes just one ColorDistance
|
||||
// - It is saved in the weights array that is shared across the threads
|
||||
// - Threads are synced
|
||||
// - For every pixel inside the block weights are considered to be constants
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#include <cooperative_groups.h>
|
||||
|
||||
namespace cg = cooperative_groups;
|
||||
|
||||
__global__ void NLM2(TColor *dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
// Handle to thread block group
|
||||
cg::thread_block cta = cg::this_thread_block();
|
||||
|
||||
// Weights cache
|
||||
__shared__ float fWeights[BLOCKDIM_X * BLOCKDIM_Y];
|
||||
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
const float cx = blockDim.x * blockIdx.x + NLM_WINDOW_RADIUS + 0.5f;
|
||||
const float cy = blockDim.x * blockIdx.y + NLM_WINDOW_RADIUS + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Find color distance from current texel to the center of NLM window
|
||||
float weight = 0;
|
||||
|
||||
for (float n = -NLM_BLOCK_RADIUS; n <= NLM_BLOCK_RADIUS; n++)
|
||||
for (float m = -NLM_BLOCK_RADIUS; m <= NLM_BLOCK_RADIUS; m++)
|
||||
weight += vecLen(tex2D<float4>(texImage, cx + m, cy + n),
|
||||
tex2D<float4>(texImage, x + m, y + n));
|
||||
|
||||
// Geometric distance from current texel to the center of NLM window
|
||||
float dist =
|
||||
(threadIdx.x - NLM_WINDOW_RADIUS) * (threadIdx.x - NLM_WINDOW_RADIUS) +
|
||||
(threadIdx.y - NLM_WINDOW_RADIUS) * (threadIdx.y - NLM_WINDOW_RADIUS);
|
||||
|
||||
// Derive final weight from color and geometric distance
|
||||
weight = __expf(-(weight * Noise + dist * INV_NLM_WINDOW_AREA));
|
||||
|
||||
// Write the result to shared memory
|
||||
fWeights[threadIdx.y * BLOCKDIM_X + threadIdx.x] = weight;
|
||||
// Wait until all the weights are ready
|
||||
cg::sync(cta);
|
||||
|
||||
// Normalized counter for the NLM weight threshold
|
||||
float fCount = 0;
|
||||
// Total sum of pixel weights
|
||||
float sumWeights = 0;
|
||||
// Result accumulator
|
||||
float3 clr = {0, 0, 0};
|
||||
|
||||
int idx = 0;
|
||||
|
||||
// Cycle through NLM window, surrounding (x, y) texel
|
||||
for (float i = -NLM_WINDOW_RADIUS; i <= NLM_WINDOW_RADIUS + 1; i++)
|
||||
for (float j = -NLM_WINDOW_RADIUS; j <= NLM_WINDOW_RADIUS + 1; j++) {
|
||||
// Load precomputed weight
|
||||
float weightIJ = fWeights[idx++];
|
||||
|
||||
// Accumulate (x + j, y + i) texel color with computed weight
|
||||
float4 clrIJ = tex2D<float4>(texImage, x + j, y + i);
|
||||
clr.x += clrIJ.x * weightIJ;
|
||||
clr.y += clrIJ.y * weightIJ;
|
||||
clr.z += clrIJ.z * weightIJ;
|
||||
|
||||
// Sum of weights for color normalization to [0..1] range
|
||||
sumWeights += weightIJ;
|
||||
|
||||
// Update weight counter, if NLM weight for current window texel
|
||||
// exceeds the weight threshold
|
||||
fCount += (weightIJ > NLM_WEIGHT_THRESHOLD) ? INV_NLM_WINDOW_AREA : 0;
|
||||
}
|
||||
|
||||
// Normalize result color by sum of weights
|
||||
sumWeights = 1.0f / sumWeights;
|
||||
clr.x *= sumWeights;
|
||||
clr.y *= sumWeights;
|
||||
clr.z *= sumWeights;
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the NLM window exceeded the weight threshold
|
||||
float lerpQ = (fCount > NLM_LERP_THRESHOLD) ? lerpC : 1.0f - lerpC;
|
||||
|
||||
// Write final result to global memory
|
||||
float4 clr00 = tex2D<float4>(texImage, x, y);
|
||||
clr.x = lerpf(clr.x, clr00.x, lerpQ);
|
||||
clr.y = lerpf(clr.y, clr00.y, lerpQ);
|
||||
clr.z = lerpf(clr.z, clr00.z, lerpQ);
|
||||
dst[imageW * iy + ix] = make_color(clr.x, clr.y, clr.z, 0);
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void cuda_NLM2(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float LerpC, cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
NLM2<<<grid, threads>>>(d_dst, imageW, imageH, Noise, LerpC, texImage);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Stripped NLM2 kernel, only highlighting areas with different LERP directions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void NLM2diag(TColor *dst, int imageW, int imageH, float Noise,
|
||||
float LerpC, cudaTextureObject_t texImage) {
|
||||
// Handle to thread block group
|
||||
cg::thread_block cta = cg::this_thread_block();
|
||||
|
||||
// Weights cache
|
||||
__shared__ float fWeights[BLOCKDIM_X * BLOCKDIM_Y];
|
||||
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
const float cx = blockDim.x * blockIdx.x + NLM_WINDOW_RADIUS + 0.5f;
|
||||
const float cy = blockDim.x * blockIdx.y + NLM_WINDOW_RADIUS + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Find color distance from current texel to the center of NLM window
|
||||
float weight = 0;
|
||||
|
||||
for (float n = -NLM_BLOCK_RADIUS; n <= NLM_BLOCK_RADIUS + 1; n++)
|
||||
for (float m = -NLM_BLOCK_RADIUS; m <= NLM_BLOCK_RADIUS + 1; m++)
|
||||
weight += vecLen(tex2D<float4>(texImage, cx + m, cy + n),
|
||||
tex2D<float4>(texImage, x + m, y + n));
|
||||
|
||||
// Geometric distance from current texel to the center of NLM window
|
||||
float dist =
|
||||
(threadIdx.x - NLM_WINDOW_RADIUS) * (threadIdx.x - NLM_WINDOW_RADIUS) +
|
||||
(threadIdx.y - NLM_WINDOW_RADIUS) * (threadIdx.y - NLM_WINDOW_RADIUS);
|
||||
|
||||
// Derive final weight from color and geometric distance
|
||||
weight = __expf(-(weight * Noise + dist * INV_NLM_WINDOW_AREA));
|
||||
|
||||
// Write the result to shared memory
|
||||
fWeights[threadIdx.y * BLOCKDIM_X + threadIdx.x] = weight;
|
||||
// Wait until all the weights are ready
|
||||
cg::sync(cta);
|
||||
|
||||
// Normalized counter for the NLM weight threshold
|
||||
float fCount = 0;
|
||||
int idx = 0;
|
||||
|
||||
// Cycle through NLM window, surrounding (x, y) texel
|
||||
for (float n = -NLM_WINDOW_RADIUS; n <= NLM_WINDOW_RADIUS + 1; n++)
|
||||
for (float m = -NLM_WINDOW_RADIUS; m <= NLM_WINDOW_RADIUS + 1; m++) {
|
||||
// Load precomputed weight
|
||||
float weightIJ = fWeights[idx++];
|
||||
|
||||
// Update weight counter, if NLM weight for current window texel
|
||||
// exceeds the weight threshold
|
||||
fCount += (weightIJ > NLM_WEIGHT_THRESHOLD) ? INV_NLM_WINDOW_AREA : 0;
|
||||
}
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the NLM window exceeded the weight threshold
|
||||
float lerpQ = (fCount > NLM_LERP_THRESHOLD) ? 1.0f : 0.0f;
|
||||
|
||||
// Write final result to global memory
|
||||
dst[imageW * iy + ix] = make_color(lerpQ, 0, (1.0f - lerpQ), 0);
|
||||
};
|
||||
}
|
||||
|
||||
extern "C" void cuda_NLM2diag(TColor *d_dst, int imageW, int imageH,
|
||||
float Noise, float LerpC,
|
||||
cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
NLM2diag<<<grid, threads>>>(d_dst, imageW, imageH, Noise, LerpC, texImage);
|
||||
}
|
||||
153
Samples/imageDenoising/imageDenoising_nlm_kernel.cuh
Normal file
153
Samples/imageDenoising/imageDenoising_nlm_kernel.cuh
Normal file
@@ -0,0 +1,153 @@
|
||||
/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// NLM kernel
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void NLM(TColor *dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Normalized counter for the NLM weight threshold
|
||||
float fCount = 0;
|
||||
// Total sum of pixel weights
|
||||
float sumWeights = 0;
|
||||
// Result accumulator
|
||||
float3 clr = {0, 0, 0};
|
||||
|
||||
// Cycle through NLM window, surrounding (x, y) texel
|
||||
for (float i = -NLM_WINDOW_RADIUS; i <= NLM_WINDOW_RADIUS; i++)
|
||||
for (float j = -NLM_WINDOW_RADIUS; j <= NLM_WINDOW_RADIUS; j++) {
|
||||
// Find color distance from (x, y) to (x + j, y + i)
|
||||
float weightIJ = 0;
|
||||
|
||||
for (float n = -NLM_BLOCK_RADIUS; n <= NLM_BLOCK_RADIUS; n++)
|
||||
for (float m = -NLM_BLOCK_RADIUS; m <= NLM_BLOCK_RADIUS; m++)
|
||||
weightIJ += vecLen(tex2D<float4>(texImage, x + j + m, y + i + n),
|
||||
tex2D<float4>(texImage, x + m, y + n));
|
||||
|
||||
// Derive final weight from color and geometric distance
|
||||
weightIJ =
|
||||
__expf(-(weightIJ * Noise + (i * i + j * j) * INV_NLM_WINDOW_AREA));
|
||||
|
||||
// Accumulate (x + j, y + i) texel color with computed weight
|
||||
float4 clrIJ = tex2D<float4>(texImage, x + j, y + i);
|
||||
clr.x += clrIJ.x * weightIJ;
|
||||
clr.y += clrIJ.y * weightIJ;
|
||||
clr.z += clrIJ.z * weightIJ;
|
||||
|
||||
// Sum of weights for color normalization to [0..1] range
|
||||
sumWeights += weightIJ;
|
||||
|
||||
// Update weight counter, if NLM weight for current window texel
|
||||
// exceeds the weight threshold
|
||||
fCount += (weightIJ > NLM_WEIGHT_THRESHOLD) ? INV_NLM_WINDOW_AREA : 0;
|
||||
}
|
||||
|
||||
// Normalize result color by sum of weights
|
||||
sumWeights = 1.0f / sumWeights;
|
||||
clr.x *= sumWeights;
|
||||
clr.y *= sumWeights;
|
||||
clr.z *= sumWeights;
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the NLM window exceeded the weight threshold
|
||||
float lerpQ = (fCount > NLM_LERP_THRESHOLD) ? lerpC : 1.0f - lerpC;
|
||||
|
||||
// Write final result to global memory
|
||||
float4 clr00 = tex2D<float4>(texImage, x, y);
|
||||
clr.x = lerpf(clr.x, clr00.x, lerpQ);
|
||||
clr.y = lerpf(clr.y, clr00.y, lerpQ);
|
||||
clr.z = lerpf(clr.z, clr00.z, lerpQ);
|
||||
dst[imageW * iy + ix] = make_color(clr.x, clr.y, clr.z, 0);
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" void cuda_NLM(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
NLM<<<grid, threads>>>(d_dst, imageW, imageH, Noise, lerpC, texImage);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Stripped NLM kernel, only highlighting areas with different LERP directions
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void NLMdiag(TColor *dst, unsigned int imageW, unsigned int imageH,
|
||||
float Noise, float lerpC,
|
||||
cudaTextureObject_t texImage) {
|
||||
const int ix = blockDim.x * blockIdx.x + threadIdx.x;
|
||||
const int iy = blockDim.y * blockIdx.y + threadIdx.y;
|
||||
// Add half of a texel to always address exact texel centers
|
||||
const float x = (float)ix + 0.5f;
|
||||
const float y = (float)iy + 0.5f;
|
||||
|
||||
if (ix < imageW && iy < imageH) {
|
||||
// Normalized counter for the weight threshold
|
||||
float fCount = 0;
|
||||
|
||||
// Cycle through NLM window, surrounding (x, y) texel
|
||||
for (float i = -NLM_WINDOW_RADIUS; i <= NLM_WINDOW_RADIUS; i++)
|
||||
for (float j = -NLM_WINDOW_RADIUS; j <= NLM_WINDOW_RADIUS; j++) {
|
||||
// Find color distance between (x, y) and (x + j, y + i)
|
||||
float weightIJ = 0;
|
||||
|
||||
for (float n = -NLM_BLOCK_RADIUS; n <= NLM_BLOCK_RADIUS; n++)
|
||||
for (float m = -NLM_BLOCK_RADIUS; m <= NLM_BLOCK_RADIUS; m++)
|
||||
weightIJ += vecLen(tex2D<float4>(texImage, x + j + m, y + i + n),
|
||||
tex2D<float4>(texImage, x + m, y + n));
|
||||
|
||||
// Derive final weight from color and geometric distance
|
||||
weightIJ =
|
||||
__expf(-(weightIJ * Noise + (i * i + j * j) * INV_NLM_WINDOW_AREA));
|
||||
|
||||
// Increase the weight threshold counter
|
||||
fCount += (weightIJ > NLM_WEIGHT_THRESHOLD) ? INV_NLM_WINDOW_AREA : 0;
|
||||
}
|
||||
|
||||
// Choose LERP quotient basing on how many texels
|
||||
// within the NLM window exceeded the LERP threshold
|
||||
float lerpQ = (fCount > NLM_LERP_THRESHOLD) ? 1.0f : 0;
|
||||
|
||||
// Write final result to global memory
|
||||
dst[imageW * iy + ix] = make_color(lerpQ, 0, (1.0f - lerpQ), 0);
|
||||
};
|
||||
}
|
||||
|
||||
extern "C" void cuda_NLMdiag(TColor *d_dst, int imageW, int imageH, float Noise,
|
||||
float lerpC, cudaTextureObject_t texImage) {
|
||||
dim3 threads(BLOCKDIM_X, BLOCKDIM_Y);
|
||||
dim3 grid(iDivUp(imageW, BLOCKDIM_X), iDivUp(imageH, BLOCKDIM_Y));
|
||||
|
||||
NLMdiag<<<grid, threads>>>(d_dst, imageW, imageH, Noise, lerpC, texImage);
|
||||
}
|
||||
20
Samples/imageDenoising/imageDenoising_vs2017.sln
Normal file
20
Samples/imageDenoising/imageDenoising_vs2017.sln
Normal file
@@ -0,0 +1,20 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio 2017
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "imageDenoising", "imageDenoising_vs2017.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|x64 = Debug|x64
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
129
Samples/imageDenoising/imageDenoising_vs2017.vcxproj
Normal file
129
Samples/imageDenoising/imageDenoising_vs2017.vcxproj
Normal file
@@ -0,0 +1,129 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
|
||||
</PropertyGroup>
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
|
||||
<RootNamespace>imageDenoising_vs2017</RootNamespace>
|
||||
<ProjectName>imageDenoising</ProjectName>
|
||||
<CudaToolkitCustomDir />
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(WindowsTargetPlatformVersion)'==''">
|
||||
<LatestTargetPlatformVersion>$([Microsoft.Build.Utilities.ToolLocationHelper]::GetLatestSDKTargetPlatformVersion('Windows', '10.0'))</LatestTargetPlatformVersion>
|
||||
<WindowsTargetPlatformVersion Condition="'$(WindowsTargetPlatformVersion)' == ''">$(LatestTargetPlatformVersion)</WindowsTargetPlatformVersion>
|
||||
<TargetPlatformVersion>$(WindowsTargetPlatformVersion)</TargetPlatformVersion>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup>
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v141</PlatformToolset>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Debug'">
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Release'">
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
<Import Project="$(CUDAPropsPath)\CUDA 11.5.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets">
|
||||
<Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup>
|
||||
<IntDir>$(Platform)/$(Configuration)/</IntDir>
|
||||
<IncludePath>$(IncludePath)</IncludePath>
|
||||
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
|
||||
<CodeAnalysisRules />
|
||||
<CodeAnalysisRuleAssemblies />
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Platform)'=='x64'">
|
||||
<OutDir>../../bin/win64/$(Configuration)/</OutDir>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup>
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
|
||||
<OutputFile>$(OutDir)/imageDenoising.exe</OutputFile>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
|
||||
<AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
|
||||
<Include>./;../../Common</Include>
|
||||
<Defines>WIN32</Defines>
|
||||
<AdditionalOptions>--threads 0</AdditionalOptions>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
|
||||
<ClCompile>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<Runtime>MTd</Runtime>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
|
||||
<ClCompile>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>false</GenerateDebugInformation>
|
||||
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<Runtime>MT</Runtime>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
|
||||
<Link>
|
||||
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
|
||||
<Link>
|
||||
<AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="bmploader.cpp" />
|
||||
<CudaCompile Include="imageDenoising.cu" />
|
||||
<ClCompile Include="imageDenoisingGL.cpp" />
|
||||
<ClInclude Include="imageDenoising.h" />
|
||||
<None Include="imageDenoising_copy_kernel.cuh" />
|
||||
<None Include="imageDenoising_knn_kernel.cuh" />
|
||||
<None Include="imageDenoising_nlm2_kernel.cuh" />
|
||||
<None Include="imageDenoising_nlm_kernel.cuh" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
<Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
20
Samples/imageDenoising/imageDenoising_vs2019.sln
Normal file
20
Samples/imageDenoising/imageDenoising_vs2019.sln
Normal file
@@ -0,0 +1,20 @@
|
||||
|
||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio 2019
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "imageDenoising", "imageDenoising_vs2019.vcxproj", "{997E0757-EA74-4A4E-A0FC-47D8C8831A15}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|x64 = Debug|x64
|
||||
Release|x64 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.ActiveCfg = Debug|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Debug|x64.Build.0 = Debug|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.ActiveCfg = Release|x64
|
||||
{997E0757-EA74-4A4E-A0FC-47D8C8831A15}.Release|x64.Build.0 = Release|x64
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
125
Samples/imageDenoising/imageDenoising_vs2019.vcxproj
Normal file
125
Samples/imageDenoising/imageDenoising_vs2019.vcxproj
Normal file
@@ -0,0 +1,125 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
||||
<PropertyGroup>
|
||||
<CUDAPropsPath Condition="'$(CUDAPropsPath)'==''">$(VCTargetsPath)\BuildCustomizations</CUDAPropsPath>
|
||||
</PropertyGroup>
|
||||
<ItemGroup Label="ProjectConfigurations">
|
||||
<ProjectConfiguration Include="Debug|x64">
|
||||
<Configuration>Debug</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
<ProjectConfiguration Include="Release|x64">
|
||||
<Configuration>Release</Configuration>
|
||||
<Platform>x64</Platform>
|
||||
</ProjectConfiguration>
|
||||
</ItemGroup>
|
||||
<PropertyGroup Label="Globals">
|
||||
<ProjectGuid>{997E0757-EA74-4A4E-A0FC-47D8C8831A15}</ProjectGuid>
|
||||
<RootNamespace>imageDenoising_vs2019</RootNamespace>
|
||||
<ProjectName>imageDenoising</ProjectName>
|
||||
<CudaToolkitCustomDir />
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
<PropertyGroup>
|
||||
<ConfigurationType>Application</ConfigurationType>
|
||||
<CharacterSet>MultiByte</CharacterSet>
|
||||
<PlatformToolset>v142</PlatformToolset>
|
||||
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Debug'">
|
||||
<UseDebugLibraries>true</UseDebugLibraries>
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Configuration)'=='Release'">
|
||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
||||
<ImportGroup Label="ExtensionSettings">
|
||||
<Import Project="$(CUDAPropsPath)\CUDA 11.5.props" />
|
||||
</ImportGroup>
|
||||
<ImportGroup Label="PropertySheets">
|
||||
<Import Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" />
|
||||
</ImportGroup>
|
||||
<PropertyGroup Label="UserMacros" />
|
||||
<PropertyGroup>
|
||||
<IntDir>$(Platform)/$(Configuration)/</IntDir>
|
||||
<IncludePath>$(IncludePath)</IncludePath>
|
||||
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
|
||||
<CodeAnalysisRules />
|
||||
<CodeAnalysisRuleAssemblies />
|
||||
</PropertyGroup>
|
||||
<PropertyGroup Condition="'$(Platform)'=='x64'">
|
||||
<OutDir>../../bin/win64/$(Configuration)/</OutDir>
|
||||
</PropertyGroup>
|
||||
<ItemDefinitionGroup>
|
||||
<ClCompile>
|
||||
<WarningLevel>Level3</WarningLevel>
|
||||
<PreprocessorDefinitions>WIN32;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<AdditionalIncludeDirectories>./;$(CudaToolkitDir)/include;../../Common;</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
<AdditionalDependencies>cudart_static.lib;freeglut.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
<AdditionalLibraryDirectories>$(CudaToolkitLibDir);../../Common/lib/$(PlatformName);</AdditionalLibraryDirectories>
|
||||
<OutputFile>$(OutDir)/imageDenoising.exe</OutputFile>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<CodeGeneration>compute_35,sm_35;compute_37,sm_37;compute_50,sm_50;compute_52,sm_52;compute_60,sm_60;compute_61,sm_61;compute_70,sm_70;compute_75,sm_75;compute_80,sm_80;compute_86,sm_86;</CodeGeneration>
|
||||
<AdditionalOptions>-Xcompiler "/wd 4819" %(AdditionalOptions)</AdditionalOptions>
|
||||
<Include>./;../../Common</Include>
|
||||
<Defines>WIN32</Defines>
|
||||
<AdditionalOptions>--threads 0</AdditionalOptions>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
|
||||
<ClCompile>
|
||||
<Optimization>Disabled</Optimization>
|
||||
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
||||
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<Runtime>MTd</Runtime>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
|
||||
<ClCompile>
|
||||
<Optimization>MaxSpeed</Optimization>
|
||||
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<GenerateDebugInformation>false</GenerateDebugInformation>
|
||||
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
|
||||
</Link>
|
||||
<CudaCompile>
|
||||
<Runtime>MT</Runtime>
|
||||
<TargetMachinePlatform>64</TargetMachinePlatform>
|
||||
</CudaCompile>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Platform)'=='Win32'">
|
||||
<Link>
|
||||
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemDefinitionGroup Condition="'$(Platform)'=='x64'">
|
||||
<Link>
|
||||
<AdditionalDependencies>glew64.lib;%(AdditionalDependencies)</AdditionalDependencies>
|
||||
</Link>
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="bmploader.cpp" />
|
||||
<CudaCompile Include="imageDenoising.cu" />
|
||||
<ClCompile Include="imageDenoisingGL.cpp" />
|
||||
<ClInclude Include="imageDenoising.h" />
|
||||
<None Include="imageDenoising_copy_kernel.cuh" />
|
||||
<None Include="imageDenoising_knn_kernel.cuh" />
|
||||
<None Include="imageDenoising_nlm2_kernel.cuh" />
|
||||
<None Include="imageDenoising_nlm_kernel.cuh" />
|
||||
</ItemGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
||||
<ImportGroup Label="ExtensionTargets">
|
||||
<Import Project="$(CUDAPropsPath)\CUDA 11.5.targets" />
|
||||
</ImportGroup>
|
||||
</Project>
|
||||
Reference in New Issue
Block a user