Download modules/core/src/cuda_gpu_mat_nd.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 3.9 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/cuda_gpu_mat_nd.cpp
- Command line
-
hf download hf://tgollogly/test/modules/core/src/cuda_gpu_mat_nd.cpp
-
curl -L -o cuda_gpu_mat_nd.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/core/src/cuda_gpu_mat_nd.cpp
3.9 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html. | |
| using namespace cv; | |
| using namespace cv::cuda; | |
| GpuMatND::~GpuMatND() = default; | |
| GpuMatND::GpuMatND(SizeArray _size, int _type, void* _data, StepArray _step) : | |
| flags(0), dims(0), data(static_cast<uchar*>(_data)), offset(0) | |
| { | |
| CV_Assert(_step.empty() || _size.size() == _step.size() + 1); | |
| setFields(std::move(_size), _type, std::move(_step)); | |
| } | |
| GpuMatND GpuMatND::operator()(const std::vector<Range>& ranges) const | |
| { | |
| CV_Assert(dims == (int)ranges.size()); | |
| for (int i = 0; i < dims; ++i) | |
| { | |
| Range r = ranges[i]; | |
| CV_Assert(r == Range::all() || (0 <= r.start && r.start < r.end && r.end <= size[i])); | |
| } | |
| GpuMatND ret = *this; | |
| for (int i = 0; i < dims; ++i) | |
| { | |
| Range r = ranges[i]; | |
| if (r != Range::all() && r != Range(0, ret.size[i])) | |
| { | |
| ret.offset += r.start * ret.step[i]; | |
| ret.size[i] = r.size(); | |
| ret.flags |= Mat::SUBMATRIX_FLAG; | |
| } | |
| } | |
| ret.flags = cv::updateContinuityFlag(ret.flags, dims, ret.size.data(), ret.step.data()); | |
| return ret; | |
| } | |
| GpuMat GpuMatND::createGpuMatHeader(IndexArray idx, Range rowRange, Range colRange) const | |
| { | |
| CV_Assert((int)idx.size() == dims - 2); | |
| std::vector<Range> ranges; | |
| for (int i : idx) | |
| ranges.emplace_back(i, i+1); | |
| ranges.push_back(rowRange); | |
| ranges.push_back(colRange); | |
| return (*this)(ranges).createGpuMatHeader(); | |
| } | |
| GpuMat GpuMatND::createGpuMatHeader() const | |
| { | |
| auto Effectively2D = [](GpuMatND m) | |
| { | |
| for (int i = 0; i < m.dims - 2; ++i) | |
| if (m.size[i] > 1) | |
| return false; | |
| return true; | |
| }; | |
| CV_Assert(Effectively2D(*this)); | |
| return GpuMat(size[dims-2], size[dims-1], type(), getDevicePtr(), step[dims-2]); | |
| } | |
| GpuMat GpuMatND::operator()(IndexArray idx, Range rowRange, Range colRange) const | |
| { | |
| return createGpuMatHeader(idx, rowRange, colRange).clone(); | |
| } | |
| GpuMatND::operator GpuMat() const | |
| { | |
| return createGpuMatHeader().clone(); | |
| } | |
| void GpuMatND::setFields(SizeArray _size, int _type, StepArray _step) | |
| { | |
| _type &= Mat::TYPE_MASK; | |
| flags = Mat::MAGIC_VAL + _type; | |
| dims = static_cast<int>(_size.size()); | |
| size = std::move(_size); | |
| if (_step.empty()) | |
| { | |
| step = StepArray(dims); | |
| step.back() = elemSize(); | |
| for (int _i = dims - 2; _i >= 0; --_i) | |
| { | |
| const size_t i = _i; | |
| step[i] = step[i+1] * size[i+1]; | |
| } | |
| flags |= Mat::CONTINUOUS_FLAG; | |
| } | |
| else | |
| { | |
| step = std::move(_step); | |
| step.push_back(elemSize()); | |
| flags = cv::updateContinuityFlag(flags, dims, size.data(), step.data()); | |
| } | |
| CV_Assert(size.size() == step.size()); | |
| CV_Assert(step.back() == elemSize()); | |
| } | |
| GpuData::GpuData(const size_t _size) | |
| : data(nullptr), size(0) | |
| { | |
| CV_UNUSED(_size); | |
| throw_no_cuda(); | |
| } | |
| GpuData::~GpuData() | |
| { | |
| } | |
| void GpuMatND::create(SizeArray _size, int _type) | |
| { | |
| CV_UNUSED(_size); | |
| CV_UNUSED(_type); | |
| throw_no_cuda(); | |
| } | |
| void GpuMatND::release() | |
| { | |
| throw_no_cuda(); | |
| } | |
| GpuMatND GpuMatND::clone() const | |
| { | |
| throw_no_cuda(); | |
| } | |
| GpuMatND GpuMatND::clone(Stream& stream) const | |
| { | |
| CV_UNUSED(stream); | |
| throw_no_cuda(); | |
| } | |
| void GpuMatND::upload(InputArray src) | |
| { | |
| CV_UNUSED(src); | |
| throw_no_cuda(); | |
| } | |
| void GpuMatND::upload(InputArray src, Stream& stream) | |
| { | |
| CV_UNUSED(src); | |
| CV_UNUSED(stream); | |
| throw_no_cuda(); | |
| } | |
| void GpuMatND::download(OutputArray dst) const | |
| { | |
| CV_UNUSED(dst); | |
| throw_no_cuda(); | |
| } | |
| void GpuMatND::download(OutputArray dst, Stream& stream) const | |
| { | |
| CV_UNUSED(dst); | |
| CV_UNUSED(stream); | |
| throw_no_cuda(); | |
| } | |