Accessing GpuMat on another GPU

See also questions close to this topic

• how to define a class so that it can only be created on stack, not on heap?

  Class with private destructor can only be stored in heap, i.e. has to stay out-of-stack. Because if it stays on stack, when it goes out of scope, stack unwind, destructor will always be called. If it stays on heap, then destructor is called only when delete is explicitly called. Then we can call some other equivalent function, in stead of the destructor itself.

  I learned about the above notes. And start to wonder how to make a class so that it can only be stored on stack, not on heap? Can anyone share some thoughts?
• Mouse-magnet jittering

  So what I'm trying to achieve is a smooth "magnet" to a single point on your screen that slightly moves the cursor towards it. The problem is that the trail is really "jittery" as shown here (I'm drawing a circle here):

  

  I've tried a few methods, here's my first one (simpler):

  void moveMouseRelative(Vector2 wantedCoords, Vector2 currentCoords, Vector2 lastCoords, float fMagnetPowerReducerValue)
  {
      // Dividing by under 1 isn't a good idea in this scenario
      if (fMagnetPowerReducerValue < 1.f)
          fMagnetPowerReducerValue = 1.f;
  
      // Calculate where we should slightly move the mouse
      LONG x = (LONG)ceil((wantedCoords.x - currentCoords.x) / fMagnetPowerReducerValue);
      LONG y = (LONG)ceil((wantedCoords.y - currentCoords.y) / fMagnetPowerReducerValue);
  
      // Setup our input
      INPUT input;
      input.type = INPUT_MOUSE;
      input.mi.dx = x;
      input.mi.dy = y;
      input.mi.mouseData = NULL;
      input.mi.dwFlags = MOUSEEVENTF_MOVE;
      input.mi.time = NULL;
      input.mi.dwExtraInfo = NULL;
  
      // Move the mouse
      SendInput(1, &input, sizeof(INPUT));
  }
  

  And here's my second method (lerp / linear interpolation):

  void moveMouseRelative(Vector2 wantedCoords, Vector2 currentCoords, Vector2 lastCoords, float fMagnetPowerReducerValue)
  {
      // The value should be always between 0 and 1
      if (fMagnetPowerReducerValue < 0.f)
          fMagnetPowerReducerValue = 0.0;
      else if (fMagnetPowerReducerValue > 1.f)
          fMagnetPowerReducerValue = 1.f;
  
      // Calculate where we should slightly move the mouse
      float fX = lerp(fMagnetPowerReducerValue, wantedCoords.x, currentCoords.x);
      float fY = lerp(fMagnetPowerReducerValue, wantedCoords.y, currentCoords.y);
  
      // Translate the position
      LONG x = (LONG)ceil(fX * (65536.f / GetSystemMetrics(SM_CXSCREEN)));
      LONG y = (LONG)ceil(fY * (65536.f / GetSystemMetrics(SM_CYSCREEN)));
  
      // Setup our input
      INPUT input;
      input.type = INPUT_MOUSE;
      input.mi.dx = x;
      input.mi.dy = y;
      input.mi.mouseData = NULL;
      input.mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE_NOCOALESCE;
      input.mi.time = NULL;
      input.mi.dwExtraInfo = NULL;
  
      // Move the mouse
      SendInput(1, &input, sizeof(INPUT));
  }
  

  But both basically give out the same result.

  Also, here's my main and Vector2 struct:

  struct Vector2
  {
      float x;
      float y;
  
      Vector2(POINT p) : x((float)p.x), y((float)p.y) {}
      Vector2(float x, float y) : x(x), y(y) {}
      Vector2() {}
  };
  
  void main()
  {
      // More = smoother (at least should be) and less "powerful"
      // This should be between 0 and 1 if we use the "linear interpolation"
      // method and this can be a lot more if we use the "simpler" method
      float fMagnetPowerReducerValue = 0.5f;
  
      Vector2 lastCoords;
      Vector2 wantedCoords(960.f, 540.f); // Middle of my screen
  
      for (;;)
      {
          if (GetAsyncKeyState(VK_SPACE))
              break;
  
          // Store our position
          POINT p;
          GetCursorPos(&p);
          Vector2 currentCoords(p);
  
          // Changing the sleep time doesn't really change
          // anything, it's still going to be really jittery
          std::this_thread::sleep_for(std::chrono::milliseconds(5));
  
          moveMouseRelative(wantedCoords, currentCoords, lastCoords, fMagnetPowerReducerValue);
  
          // Store out last position
          GetCursorPos(&p);
          lastCoords.x = (float)p.x;
          lastCoords.y = (float)p.y;
      }
  }
  

  Can anyone explain why this is happening? And how can I prevent the jittering or is there a better way to do it?
• invalid conversion from ‘const void*’ to ‘PVOID {aka void*}’[-fpermissive]

  I am trying to compile the following code, and I keep getting this error:

  invalid conversion from ‘const void*’ to ‘PVOID {aka void*}’[-fpermissive]

  I am basically looking to do a simple read-write on external EEPROM using a UMFT201-xb breakout board with the FT201x USB to I2C interface.

  I downloaded the example code from the D2XX EEPROM Programming examples and the specific file I am trying to compile that gives me the above error is at AN_428_D2XX_EEPROM_Programming_Examples/FT-X/FT-X EEPROM Modify/FT-X EEPROM Modify.cpp.

  FYI, I am working on Linux.

  This is the specific bit of code it complains about:

  enter co/Open the port
  //********************************************************
  
  for (i = 0; i < numDevs; i++)
  {
      if ((Dev_Found == FALSE) && (devInfo[i].Type == FT_DEVICE_X_SERIES))
      {
          Dev_Found = TRUE;
  
          status = FT_OpenEx("Chipi-X", FT_OPEN_BY_DESCRIPTION, &fthandle);
  
          if (status != FT_OK)
          {
              printf("Open status not ok %d\n", status);
              printf("Trying to open default EEPROM device...\n");
              status = FT_OpenEx("FT231X USB UART", FT_OPEN_BY_DESCRIPTION, &fthandle);
              if (status != FT_OK)
              {
                  printf("Open status not ok %d\n", status);
                  printf("\n");
                  return 0;
              }
              else
              {
                  printf("Open status OK %d\n", status);
                  printf("\n");
              }
  
              printf("\n");
          }
          else
          {
              printf("Open status OK %d\n", status);
              printf("\n");
          }
  

  The issue arises at the line:

  status = FT_OpenEx("Chipi-X", FT_OPEN_BY_DESCRIPTION, &fthandle);
  
• How to find area of different objects in same image using python

  I need to find the area of the each grain using python and opencv

  This image contain rice grains
• Can I use OpenCV to analyze a video for how long a face is in the centre of the screen?

  This is a frame from a video taken using the HTC Vive (it's from the user's perspective of a game I developed in Unity) I've overlaid those boxes in paint.

  I'm trying to determine which character the person is looking at (assuming the white box is where they user is focusing)

  I know this can be done in Unity without the need for a video, but I want to know if the video can be analyzed using something like OpenCV to detect how long each character faces is in the white box. I just made this in paint to get the idea across, the parameters aren't to scale or anything, I just have no idea where to start with a concept like this apart from OpenCV.

  But to summarize, can I use OpenCV to detect how long each face is in the centre of the screen? i.e. How long the user looked at each character.

  
• Can't view opencv processed videos in Django

  I have a Django app that lets you upload a video or image, it sends it to an OpenCV function that returns a new image/video with some annotations on it and then shows it in the template.

  For images it works just fine, but for video it doesn't.

  The video is shown as unavailable both in the view (as HTML5 video) and when following the /media/[path_to_file], but when I'm opening it with VLC (or some other desktop player, locally), the video exists and is working as expected.

  Moreover, I tried removing the OpenCV function and left only the upload functionality. When I uploaded a normal video, everything was fine, but when I tried to upload a video that was previously processed with OpenCV, it appears as unavailable again.

  My question is: is opencv changing the video properties in any way comparing to the original so that Django doesn't recognise it anymore? What might be the problem? And how can I make it that opencv processed videos are visible in my view?

  Also, the processed video has the same name and extension (and type) as the original.

  If you have any idea it's more than helpful. Thanks a lot!
• How to program structs in pycuda for kernel code?

  A couple of days ago a discoverd pycuda as a python version of programming cuda. In c cuda I've programmed a small kernel which uses a struct "Matrix", which I would like to use in pycuda, as well.

  typedef struct {
      int col;
      int row;
      float *ptr;
  } Matrix;
  
   __global__
  void mul(Matrix A, Matrix B, Matrix C){
      //multiplication
  }
  

  Can anybody help me, with what to do on python side, so I can use the Matrix struct as seen in the above example?

  In pycuda documentation I only found one example, working with structs demo_struct.py , but I have trouble understanding it so far, that I can write my own Matrix class.
• Compiling Tensor flow example custom op for GPU

  Following the online example provided by Tensorflow I am having trouble using the custom op they define under GPU kernels. The instructions to build the example list three required files:

  header file

  // kernel_example.h
  #ifndef KERNEL_EXAMPLE_H_
  #define KERNEL_EXAMPLE_H_
  
  template <typename Device, typename T>
  struct ExampleFunctor {
    void operator()(const Device& d, int size, const T* in, T* out);
  };
  
  #if GOOGLE_CUDA
  // Partially specialize functor for GpuDevice.
  template <typename Eigen::GpuDevice, typename T>
  struct ExampleFunctor {
    void operator()(const Eigen::GpuDevice& d, int size, const T* in, T* out);
  };
  #endif
  
  #endif //KERNEL_EXAMPLE_H_ [1] commented out 
  

  ((1) Here I have commented out KERNEL_EXAMPLE_H_ on the last line, as it causes a compile error.)

  .cc file

  // kernel_example.cc
  #include "kernel_example.h"    <--------[2] replaced example.h
  #include "tensorflow/core/framework/op_kernel.h"
  
  using namespace tensorflow;
  
  using CPUDevice = Eigen::ThreadPoolDevice;
  using GPUDevice = Eigen::GpuDevice;
  
  // CPU specialization of actual computation.
  template <typename T>
  struct ExampleFunctor<CPUDevice, T> {
    void operator()(const CPUDevice& d, int size, const T* in, T* out) {
      for (int i = 0; i < size; ++i) {
        out[i] = 2 * in[i];
      }
    }
  };
  
  // OpKernel definition.
  // template parameter <T> is the datatype of the tensors.
  template <typename Device, typename T>
  class ExampleOp : public OpKernel {
   public:
    explicit ExampleOp(OpKernelConstruction* context) : OpKernel(context) {}
  
    void Compute(OpKernelContext* context) override {
      // Grab the input tensor
      const Tensor& input_tensor = context->input(0);
  
      // Create an output tensor
      Tensor* output_tensor = NULL;
      OP_REQUIRES_OK(context, context->allocate_output(0, input_tensor.shape(),
                                                       &output_tensor));
  
      // Do the computation.
      OP_REQUIRES(context, input_tensor.NumElements() <= tensorflow::kint32max,
                  errors::InvalidArgument("Too many elements in tensor"));
      ExampleFunctor<Device, T>()(
          context->eigen_device<Device>(),
          static_cast<int>(input_tensor.NumElements()),
          input_tensor.flat<T>().data(),
          output_tensor->flat<T>().data());
    }
  };
  
  // Register the CPU kernels.
  #define REGISTER_CPU(T)                                          \
    REGISTER_KERNEL_BUILDER(                                       \
        Name("Example").Device(DEVICE_CPU).TypeConstraint<T>("T"), \
        ExampleOp<CPUDevice, T>);
  REGISTER_CPU(float);
  REGISTER_CPU(int32);
  
  // Register the GPU kernels.
  #ifdef GOOGLE_CUDA
  #define REGISTER_GPU(T)                                          \
    /* Declare explicit instantiations in kernel_example.cu.cc. */ \
    extern template ExampleFunctor<GPUDevice, T>;                  \
    REGISTER_KERNEL_BUILDER(                                       \
        Name("Example").Device(DEVICE_GPU).TypeConstraint<T>("T"), \
        ExampleOp<GPUDevice, T>);
  REGISTER_GPU(float);
  REGISTER_GPU(int32);
  #endif  // GOOGLE_CUDA
  

  ([2] Here I have changed the name of the header file to match the filename.) and

  .cu.cc file

  // kernel_example.cu.cc
  #ifdef GOOGLE_CUDA
  #define EIGEN_USE_GPU
  #include "kernel_example.h"    //[3] replaced example.h
  #include "tensorflow/core/util/cuda_kernel_helper.h"
  
  using namespace tensorflow;
  
  using GPUDevice = Eigen::GpuDevice;
  
  // Define the CUDA kernel.
  template <typename T>
  __global__ void ExampleCudaKernel(const int size, const T* in, T* out) {
    for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < size;
         i += blockDim.x * gridDim.x) {
      out[i] = 2 * ldg(in + i);
    }
  }
  
  // Define the GPU implementation that launches the CUDA kernel.
  template <typename T>
  void ExampleFunctor<GPUDevice, T>::operator()(
      const GPUDevice& d, int size, const T* in, T* out) {
    // Launch the cuda kernel.
    //
    // See core/util/cuda_kernel_helper.h for example of computing
    // block count and thread_per_block count.
    int block_count = 1024;
    int thread_per_block = 20;
    ExampleCudaKernel<T>
        <<<block_count, thread_per_block, 0, d.stream()>>>(size, in, out);
  }
  
  // Explicitly instantiate functors for the types of OpKernels registered.
  template struct ExampleFunctor<GPUDevice, float>;
  template struct ExampleFunctor<GPUDevice, int32>;
  
  #endif  // GOOGLE_CUDA
  

  [3] Here I have changed the name of the header file to match the filename.

  The only 3 minor changes I have made are listed below each script.

  Building the op library using the suggested method:

  TF_CFLAGS=( $(python -c 'import tensorflow as tf; print(" ".join(tf.sysconfig.get_compile_flags()))') )
  TF_LFLAGS=( $(python -c 'import tensorflow as tf; print(" ".join(tf.sysconfig.get_link_flags()))') )
  g++ -std=c++11 -shared kernel_example.cc kernel_example.cu.cc -o gpu_op.so -fPIC ${TF_CFLAGS[@]} ${TF_LFLAGS[@]} -O2
  

  appears successful. And gpu_op.so is generated. But importing this op library and trying to use it:

  # run_op.py
  import tensorflow as tf
  import numpy as np
  my_module = tf.load_op_library('./gpu_op.so')
  
  a = np.ones((20,5,5))
  in1 = tf.convert_to_tensor(a, dtype = float)
  
  print("input1: ", in1)
  
  with tf.Session() as sess:
      ans = sess.run(my_module.example(in1))
  print("output:", ans)
  

  results in the operation not being found:

    File "run_op.py", line 11, in <module>
      ans = sess.run(my_module.example(in1))
  AttributeError: module '33c9073b4d33739023b5757fe9acdd79' has no attribute 'example'
  

  I am relatively new to C++ and may not be compiling this correctly. So what should I be doing to make this module importable? And was I correct to make the 3 alterations to the code mentioned above?
• Link CUDA function library in CMake but get error

  I am trying to link a CUDA library to C++ so that I can call CUDA function to finish my work.but when after I include the SGM.h which contains API of CUDA function,I got errors like this:

  error: there are no arguments to ‘__byte_perm’ that depend on a template parameter, so a declaration of ‘__byte_perm’ must be available [-fpermissive] next_dis = __byte_perm(*old_values, next_dis4, 0x4321); ^ cost_aggregation.h:128:18: error: there are no arguments to ‘__syncthreads’ that depend on a template parameter, so a declaration of ‘__syncthreads’ must be available [-fpermissive] __syncthreads(); ^ cost_aggregation.h:161:55: error: there are no arguments to ‘__vminu4’ that depend on a template parameter, so a declaration of ‘__vminu4’ must be available [-fpermissive] const uint32_t min1 = __vminu4(*old_values, prev_dis);

  this is what the top level CMakeLists looks like:

  PROJECT(ChenLab_StereoCamera)
  CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
  set(CMAKE_CXX_STANDARD  11)
  
  find_package(OpenCV REQUIRED)
  find_package( CUDA REQUIRED )
  
  add_subdirectory(Driver)
  add_subdirectory(Rectification)
  add_subdirectory(SGM)
  #add_subdirectory(Utils)
  
  set(
      CUDA_NVCC_FLAGS
      ${CUDA_NVCC_FLAGS};
      -O3 -lineinfo
      -gencode=arch=compute_61,code=sm_61
  )
  
  cuda_add_executable(ChenLab_StereoCamera main.cpp)
  
  target_link_libraries(ChenLab_StereoCamera Driver Rectification SGM - 
  pthread ${OpenCV_LIBS} ${CUDA_LIBRARIES
  

  and this is cuda library CMakeLists looks like:

  cmake_minimum_required(VERSION 2.4)
  
  project(SGM)
  set(CMAKE_CXX_STANDARD 11)
  find_package( OpenCV REQUIRED )
  find_package( CUDA REQUIRED )
  
  set(
  CUDA_NVCC_FLAGS
  ${CUDA_NVCC_FLAGS};
  -O3 -lineinfo
  -gencode=arch=compute_61,code=sm_61
  )
  cuda_add_library(SGM  SGM.cu median_filter.cu hamming_cost.cu 
  disparity_method.cu debug.cu costs.cu util.h)