NASP/cuda-samples
84
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-13 00:08:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

CUDA 13.2 samples update (#432)

Browse Source 
- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.
This commit is contained in:
Dheemanth
2026-05-13 15:13:18 -07:00
committed by GitHub
parent a4526d5229
commit aeab82ff30
2072 changed files with 15077 additions and 1970 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
cpp/5_Domain_Specific/stereoDisparity/.vscode/c_cpp_properties.json vendored Normal file
View 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
cpp/5_Domain_Specific/stereoDisparity/.vscode/extensions.json vendored Normal file
View File

@@ -0,0 +1,7 @@
{
"recommendations": [
"nvidia.nsight-vscode-edition",
"ms-vscode.cpptools",
"ms-vscode.makefile-tools"
]
}

40
cpp/5_Domain_Specific/stereoDisparity/CMakeLists.txt Normal file
View File

@@ -0,0 +1,40 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/Modules")
project(stereoDisparity LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_CUDA_ARCHITECTURES 75 80 86 87 89 90 100 110 120)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
if(ENABLE_CUDA_DEBUG)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (may significantly affect performance on some targets)
else()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
endif()
# Include directories and libraries
include_directories(../../../Common)
# Source file
# Add target for stereoDisparity
add_executable(stereoDisparity stereoDisparity.cu)
target_compile_options(stereoDisparity PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(stereoDisparity PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(stereoDisparity PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
add_custom_command(TARGET stereoDisparity POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory
${CMAKE_CURRENT_SOURCE_DIR}/data
${CMAKE_CURRENT_BINARY_DIR}/data
)
# Include installation configuration
include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/InstallSamples.cmake)
setup_samples_install()

32
cpp/5_Domain_Specific/stereoDisparity/README.md Normal file
View File

@@ -0,0 +1,32 @@
# stereoDisparity - Stereo Disparity Computation (SAD SIMD Intrinsics)
## Description
A CUDA program that demonstrates how to compute a stereo disparity map using SIMD SAD (Sum of Absolute Difference) intrinsics. Requires Compute Capability 2.0 or higher.
## Key Concepts
Image Processing, Video Intrinsics
## Supported SM Architectures
[SM 5.0 ](https://developer.nvidia.com/cuda-gpus) [SM 5.2 ](https://developer.nvidia.com/cuda-gpus) [SM 5.3 ](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) [SM 8.7 ](https://developer.nvidia.com/cuda-gpus) [SM 8.9 ](https://developer.nvidia.com/cuda-gpus) [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
## Supported OSes
Linux, Windows
## Supported CPU Architecture
x86_64, armv7l
## CUDA APIs involved
### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
cudaMemcpy, cudaFree, cudaEventSynchronize, cudaDeviceSynchronize, cudaCreateTextureObject, cudaEventRecord, cudaMalloc, cudaEventElapsedTime, cudaGetDeviceProperties, cudaEventCreate
## Prerequisites
Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
## References (for more details)

BIN
cpp/5_Domain_Specific/stereoDisparity/data/stereo.im0.640x533.ppm Normal file
View File

Binary file not shown.

BIN
cpp/5_Domain_Specific/stereoDisparity/data/stereo.im1.640x533.ppm Normal file
View File

Binary file not shown.

285
cpp/5_Domain_Specific/stereoDisparity/stereoDisparity.cu Normal file
View File

@@ -0,0 +1,285 @@
/* Copyright (c) 2022, 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.
*/
/* A CUDA program that demonstrates how to compute a stereo disparity map using
* SIMD SAD (Sum of Absolute Difference) intrinsics
*/
// includes, system
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// includes, kernels
#include <cuda_runtime.h>
#include "stereoDisparity_kernel.cuh"
// includes, project
#include <helper_cuda.h> // helper for checking cuda initialization and error checking
#include <helper_functions.h> // helper for shared that are common to CUDA Samples
#include <helper_string.h> // helper functions for string parsing
static const char *sSDKsample = "[stereoDisparity]\0";
int iDivUp(int a, int b) { return ((a % b) != 0) ? (a / b + 1) : (a / b); }
////////////////////////////////////////////////////////////////////////////////
// declaration, forward
void runTest(int argc, char **argv);
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
printf("%s Starting...\n\n", sSDKsample);
runTest(argc, argv);
}
////////////////////////////////////////////////////////////////////////////////
//! CUDA Sample for calculating depth maps
////////////////////////////////////////////////////////////////////////////////
void runTest(int argc, char **argv)
{
cudaDeviceProp deviceProp;
deviceProp.major = 0;
deviceProp.minor = 0;
int dev = 0;
// This will pick the best possible CUDA capable device
dev = findCudaDevice(argc, (const char **)argv);
checkCudaErrors(cudaGetDeviceProperties(&deviceProp, dev));
// Statistics about the GPU device
printf("> GPU device has %d Multi-Processors, SM %d.%d compute capabilities\n\n",
deviceProp.multiProcessorCount,
deviceProp.major,
deviceProp.minor);
StopWatchInterface *timer;
sdkCreateTimer(&timer);
// Search parameters
int minDisp = -16;
int maxDisp = 0;
// Load image data
// allocate mem for the images on host side
// initialize pointers to NULL to request lib call to allocate as needed
// PPM images are loaded into 4 byte/pixel memory (RGBX)
unsigned char *h_img0 = NULL;
unsigned char *h_img1 = NULL;
unsigned int w, h;
char *fname0 = sdkFindFilePath("stereo.im0.640x533.ppm", argv[0]);
char *fname1 = sdkFindFilePath("stereo.im1.640x533.ppm", argv[0]);
printf("Loaded <%s> as image 0\n", fname0);
if (!sdkLoadPPM4ub(fname0, &h_img0, &w, &h)) {
fprintf(stderr, "Failed to load <%s>\n", fname0);
}
printf("Loaded <%s> as image 1\n", fname1);
if (!sdkLoadPPM4ub(fname1, &h_img1, &w, &h)) {
fprintf(stderr, "Failed to load <%s>\n", fname1);
}
dim3 numThreads = dim3(blockSize_x, blockSize_y, 1);
dim3 numBlocks = dim3(iDivUp(w, numThreads.x), iDivUp(h, numThreads.y));
unsigned int numData = w * h;
unsigned int memSize = sizeof(int) * numData;
// allocate mem for the result on host side
unsigned int *h_odata = (unsigned int *)malloc(memSize);
// initialize the memory
for (unsigned int i = 0; i < numData; i++)
h_odata[i] = 0;
// allocate device memory for result
unsigned int *d_odata, *d_img0, *d_img1;
checkCudaErrors(cudaMalloc((void **)&d_odata, memSize));
checkCudaErrors(cudaMalloc((void **)&d_img0, memSize));
checkCudaErrors(cudaMalloc((void **)&d_img1, memSize));
// copy host memory to device to initialize to zeros
checkCudaErrors(cudaMemcpy(d_img0, h_img0, memSize, cudaMemcpyHostToDevice));
checkCudaErrors(cudaMemcpy(d_img1, h_img1, memSize, cudaMemcpyHostToDevice));
checkCudaErrors(cudaMemcpy(d_odata, h_odata, memSize, cudaMemcpyHostToDevice));
cudaChannelFormatDesc ca_desc0 = cudaCreateChannelDesc<unsigned int>();
cudaChannelFormatDesc ca_desc1 = cudaCreateChannelDesc<unsigned int>();
cudaTextureObject_t tex2Dleft, tex2Dright;
cudaResourceDesc texRes;
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypePitch2D;
texRes.res.pitch2D.devPtr = d_img0;
texRes.res.pitch2D.desc = ca_desc0;
texRes.res.pitch2D.width = w;
texRes.res.pitch2D.height = h;
texRes.res.pitch2D.pitchInBytes = w * 4;
cudaTextureDesc texDescr;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = false;
texDescr.filterMode = cudaFilterModePoint;
texDescr.addressMode[0] = cudaAddressModeClamp;
texDescr.addressMode[1] = cudaAddressModeClamp;
texDescr.readMode = cudaReadModeElementType;
checkCudaErrors(cudaCreateTextureObject(&tex2Dleft, &texRes, &texDescr, NULL));
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypePitch2D;
texRes.res.pitch2D.devPtr = d_img1;
texRes.res.pitch2D.desc = ca_desc1;
texRes.res.pitch2D.width = w;
texRes.res.pitch2D.height = h;
texRes.res.pitch2D.pitchInBytes = w * 4;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = false;
texDescr.filterMode = cudaFilterModePoint;
texDescr.addressMode[0] = cudaAddressModeClamp;
texDescr.addressMode[1] = cudaAddressModeClamp;
texDescr.readMode = cudaReadModeElementType;
checkCudaErrors(cudaCreateTextureObject(&tex2Dright, &texRes, &texDescr, NULL));
// First run the warmup kernel (which we'll use to get the GPU in the correct
// max power state
stereoDisparityKernel<<<numBlocks, numThreads>>>(
d_img0, d_img1, d_odata, w, h, minDisp, maxDisp, tex2Dleft, tex2Dright);
cudaDeviceSynchronize();
// Allocate CUDA events that we'll use for timing
cudaEvent_t start, stop;
checkCudaErrors(cudaEventCreate(&start));
checkCudaErrors(cudaEventCreate(&stop));
printf("Launching CUDA stereoDisparityKernel()\n");
// Record the start event
checkCudaErrors(cudaEventRecord(start, NULL));
// launch the stereoDisparity kernel
stereoDisparityKernel<<<numBlocks, numThreads>>>(
d_img0, d_img1, d_odata, w, h, minDisp, maxDisp, tex2Dleft, tex2Dright);
// Record the stop event
checkCudaErrors(cudaEventRecord(stop, NULL));
// Wait for the stop event to complete
checkCudaErrors(cudaEventSynchronize(stop));
// Check to make sure the kernel didn't fail
getLastCudaError("Kernel execution failed");
float msecTotal = 0.0f;
checkCudaErrors(cudaEventElapsedTime(&msecTotal, start, stop));
// Copy result from device to host for verification
checkCudaErrors(cudaMemcpy(h_odata, d_odata, memSize, cudaMemcpyDeviceToHost));
printf("Input Size [%dx%d], ", w, h);
printf("Kernel size [%dx%d], ", (2 * RAD + 1), (2 * RAD + 1));
printf("Disparities [%d:%d]\n", minDisp, maxDisp);
printf("GPU processing time : %.4f (ms)\n", msecTotal);
printf("Pixel throughput : %.3f Mpixels/sec\n", ((float)(w * h * 1000.f) / msecTotal) / 1000000);
// calculate sum of resultant GPU image
unsigned int checkSum = 0;
for (unsigned int i = 0; i < w * h; i++) {
checkSum += h_odata[i];
}
printf("GPU Checksum = %u, ", checkSum);
// write out the resulting disparity image.
unsigned char *dispOut = (unsigned char *)malloc(numData);
int mult = 20;
const char *fnameOut = "output_GPU.pgm";
for (unsigned int i = 0; i < numData; i++) {
dispOut[i] = (int)h_odata[i] * mult;
}
printf("GPU image: <%s>\n", fnameOut);
sdkSavePGM(fnameOut, dispOut, w, h);
// compute reference solution
printf("Computing CPU reference...\n");
cpu_gold_stereo((unsigned int *)h_img0, (unsigned int *)h_img1, (unsigned int *)h_odata, w, h, minDisp, maxDisp);
unsigned int cpuCheckSum = 0;
for (unsigned int i = 0; i < w * h; i++) {
cpuCheckSum += h_odata[i];
}
printf("CPU Checksum = %u, ", cpuCheckSum);
const char *cpuFnameOut = "output_CPU.pgm";
for (unsigned int i = 0; i < numData; i++) {
dispOut[i] = (int)h_odata[i] * mult;
}
printf("CPU image: <%s>\n", cpuFnameOut);
sdkSavePGM(cpuFnameOut, dispOut, w, h);
// cleanup memory
checkCudaErrors(cudaFree(d_odata));
checkCudaErrors(cudaFree(d_img0));
checkCudaErrors(cudaFree(d_img1));
if (h_odata != NULL)
free(h_odata);
if (h_img0 != NULL)
free(h_img0);
if (h_img1 != NULL)
free(h_img1);
if (dispOut != NULL)
free(dispOut);
sdkDeleteTimer(&timer);
exit((checkSum == cpuCheckSum) ? EXIT_SUCCESS : EXIT_FAILURE);
}

264
cpp/5_Domain_Specific/stereoDisparity/stereoDisparity_kernel.cuh Normal file
View File

@@ -0,0 +1,264 @@
/* Copyright (c) 2022, 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.
*/
/* Simple kernel computes a Stereo Disparity using CUDA SIMD SAD intrinsics. */
#ifndef _STEREODISPARITY_KERNEL_H_
#define _STEREODISPARITY_KERNEL_H_
#define blockSize_x 32
#define blockSize_y 8
// RAD is the radius of the region of support for the search
#define RAD 8
// STEPS is the number of loads we must perform to initialize the shared memory
// area (see convolution CUDA Sample for example)
#define STEPS 3
#include <cooperative_groups.h>
namespace cg = cooperative_groups;
////////////////////////////////////////////////////////////////////////////////
// This function applies the video intrinsic operations to compute a
// sum of absolute differences. The absolute differences are computed
// and the optional .add instruction is used to sum the lanes.
//
// For more information, see also the documents:
// "Using_Inline_PTX_Assembly_In_CUDA.pdf"
// and also the PTX ISA documentation for the architecture in question, e.g.:
// "ptx_isa_3.0K.pdf"
// included in the NVIDIA GPU Computing Toolkit
////////////////////////////////////////////////////////////////////////////////
__device__ unsigned int __usad4(unsigned int A, unsigned int B, unsigned int C = 0)
{
unsigned int result;
// Kepler (SM 3.x) and higher supports a 4 vector SAD SIMD
asm("vabsdiff4.u32.u32.u32.add"
" %0, %1, %2, %3;"
: "=r"(result)
: "r"(A), "r"(B), "r"(C));
return result;
}
////////////////////////////////////////////////////////////////////////////////
//! Simple stereo disparity kernel to test atomic instructions
//! Algorithm Explanation:
//! For stereo disparity this performs a basic block matching scheme.
//! The sum of abs. diffs between and area of the candidate pixel in the left
//! images
//! is computed against different horizontal shifts of areas from the right.
//! The shift at which the difference is minimum is taken as how far that pixel
//! moved between left/right image pairs. The recovered motion is the
//! disparity map
//! More motion indicates more parallax indicates a closer object.
//! @param g_img1 image 1 in global memory, RGBA, 4 bytes/pixel
//! @param g_img2 image 2 in global memory
//! @param g_odata disparity map output in global memory, unsigned int
//! output/pixel
//! @param w image width in pixels
//! @param h image height in pixels
//! @param minDisparity leftmost search range
//! @param maxDisparity rightmost search range
////////////////////////////////////////////////////////////////////////////////
__global__ void stereoDisparityKernel(unsigned int *g_img0,
unsigned int *g_img1,
unsigned int *g_odata,
int w,
int h,
int minDisparity,
int maxDisparity,
cudaTextureObject_t tex2Dleft,
cudaTextureObject_t tex2Dright)
{
// Handle to thread block group
cg::thread_block cta = cg::this_thread_block();
// access thread id
const int tidx = blockDim.x * blockIdx.x + threadIdx.x;
const int tidy = blockDim.y * blockIdx.y + threadIdx.y;
const unsigned int sidx = threadIdx.x + RAD;
const unsigned int sidy = threadIdx.y + RAD;
unsigned int imLeft;
unsigned int imRight;
unsigned int cost;
unsigned int bestCost = 9999999;
unsigned int bestDisparity = 0;
__shared__ unsigned int diff[blockSize_y + 2 * RAD][blockSize_x + 2 * RAD];
// store needed values for left image into registers (constant indexed local
// vars)
unsigned int imLeftA[STEPS];
unsigned int imLeftB[STEPS];
for (int i = 0; i < STEPS; i++) {
int offset = -RAD + i * RAD;
imLeftA[i] = tex2D<unsigned int>(tex2Dleft, tidx - RAD, tidy + offset);
imLeftB[i] = tex2D<unsigned int>(tex2Dleft, tidx - RAD + blockSize_x, tidy + offset);
}
// for a fixed camera system this could be hardcoded and loop unrolled
for (int d = minDisparity; d <= maxDisparity; d++) {
// LEFT
#pragma unroll
for (int i = 0; i < STEPS; i++) {
int offset = -RAD + i * RAD;
// imLeft = tex2D( tex2Dleft, tidx-RAD, tidy+offset );
imLeft = imLeftA[i];
imRight = tex2D<unsigned int>(tex2Dright, tidx - RAD + d, tidy + offset);
cost = __usad4(imLeft, imRight);
diff[sidy + offset][sidx - RAD] = cost;
}
// RIGHT
#pragma unroll
for (int i = 0; i < STEPS; i++) {
int offset = -RAD + i * RAD;
if (threadIdx.x < 2 * RAD) {
// imLeft = tex2D( tex2Dleft, tidx-RAD+blockSize_x, tidy+offset );
imLeft = imLeftB[i];
imRight = tex2D<unsigned int>(tex2Dright, tidx - RAD + blockSize_x + d, tidy + offset);
cost = __usad4(imLeft, imRight);
diff[sidy + offset][sidx - RAD + blockSize_x] = cost;
}
}
cg::sync(cta);
// sum cost horizontally
#pragma unroll
for (int j = 0; j < STEPS; j++) {
int offset = -RAD + j * RAD;
cost = 0;
#pragma unroll
for (int i = -RAD; i <= RAD; i++) {
cost += diff[sidy + offset][sidx + i];
}
cg::sync(cta);
diff[sidy + offset][sidx] = cost;
cg::sync(cta);
}
// sum cost vertically
cost = 0;
#pragma unroll
for (int i = -RAD; i <= RAD; i++) {
cost += diff[sidy + i][sidx];
}
// see if it is better or not
if (cost < bestCost) {
bestCost = cost;
bestDisparity = d + 8;
}
cg::sync(cta);
}
if (tidy < h && tidx < w) {
g_odata[tidy * w + tidx] = bestDisparity;
}
}
void cpu_gold_stereo(unsigned int *img0,
unsigned int *img1,
unsigned int *odata,
int w,
int h,
int minDisparity,
int maxDisparity)
{
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
unsigned int bestCost = 9999999;
unsigned int bestDisparity = 0;
for (int d = minDisparity; d <= maxDisparity; d++) {
unsigned int cost = 0;
for (int i = -RAD; i <= RAD; i++) {
for (int j = -RAD; j <= RAD; j++) {
// border clamping
int yy, xx, xxd;
yy = y + i;
if (yy < 0)
yy = 0;
if (yy >= h)
yy = h - 1;
xx = x + j;
if (xx < 0)
xx = 0;
if (xx >= w)
xx = w - 1;
xxd = x + j + d;
if (xxd < 0)
xxd = 0;
if (xxd >= w)
xxd = w - 1;
// sum abs diff across components
unsigned char *A = (unsigned char *)&img0[yy * w + xx];
unsigned char *B = (unsigned char *)&img1[yy * w + xxd];
unsigned int absdiff = 0;
for (int k = 0; k < 4; k++) {
absdiff += abs((int)(A[k] - B[k]));
}
cost += absdiff;
}
}
if (cost < bestCost) {
bestCost = cost;
bestDisparity = d + 8;
}
} // end for disparities
// store to best disparity
odata[y * w + x] = bestDisparity;
}
}
}
#endif // #ifndef _STEREODISPARITY_KERNEL_H_