Merge pull request #24411 from alexlyulkov:al/dnn-type-inference

Added int32, int64 support and type inference to dnn #24411

**Added a type inference to dnn similar to the shape inference, added int32 and int64 support.**

- Added getTypes method for layers that calculates layer outputs types and internals types from inputs types (Similar to getMemoryShapes). By default outputs and internals types = input[0] type
- Added type inference pipeline similar to shape inference pipeline. LayersShapes struct (that is used in shape inference pipeline) now contains both shapes and types
- All layers output blobs are now allocated using the calculated types from the type inference.
- Inputs and constants with int32 and int64 types are not automatically converted into float32 now.
- Added int32 and int64 support for all the layers with indexing and for all the layers required in tests.

Added  int32 and int64 support for CUDA:
- Added host<->device data moving for int32 and int64
- Added int32 and int64 support for several layers (just slightly modified CUDA C++ templates)

Passed all the accuracy tests on CPU, OCL, OCL_FP16, CUDA, CUDA_FP16. (except RAFT model)

**CURRENT PROBLEMS**:
-  ONNX parser always converts int64 constants and layers attributes to int32, so some models with int64 constants doesn't work (e.g. RAFT). The solution is to disable int64->int32 conversion and fix attributes reading in a lot of ONNX layers parsers (https://github.com/opencv/opencv/issues/25102)
- I didn't add type inference and int support to VULCAN, so it doesn't work at all now.
- Some layers don't support int yet, so some unknown models may not work.

**CURRENT WORKAROUNDS**:
- CPU arg_layer indides are implemented in int32 followed by a int32->int64 conversion (the master branch has the same workaround with int32->float conversion)
- CPU and OCL pooling_layer indices are implemented in float followed by a float->int64 conversion
- CPU gather_layer indices are implemented in int32, so int64 indices are converted to int32 (the master branch has the same workaround with float->int32 conversion)

**DISABLED TESTS**:
- RAFT model

**REMOVED TESTS**:
- Greater_input_dtype_int64 (because it doesn't fit ONNX rules, the whole test is just comparing float tensor with int constant)

**TODO IN NEXT PULL REQUESTS**:
- Add int64 support for ONNX parser
- Add int support for more layers
- Add int support for OCL (currently int layers just run on CPU)
- Add int tests
- Add int support for other backends

modules/dnn/perf/perf_layer.cpp

@@ -267,15 +267,13 @@ PERF_TEST_P_(Layer_Scatter, scatter) {
     int target_id = get<1>(get<3>(GetParam()));
 
     Mat data(shape, CV_32FC1);
-    Mat indices(shape, CV_32FC1);
+    Mat indices(shape, CV_64SC1);
     Mat updates(shape, CV_32FC1);
 
     randn(data, 0.f, 1.f);
     randu(indices, 0, shape[axis]);
     randn(updates, 0.f, 1.f);
 
-    indices.convertTo(indices, CV_32SC1, 1, -1);
-
     Net net;
     LayerParams lp;
     lp.type = "Scatter";
@@ -334,7 +332,7 @@ PERF_TEST_P_(Layer_ScatterND, scatterND) {
     std::vector<int> indices_shape(shape);
     indices_shape.push_back(int(shape.size()));
     Mat data(shape, CV_32FC1);
-    Mat indices(indices_shape, CV_32FC1);
+    Mat indices(indices_shape, CV_32SC1);
     Mat updates(shape, CV_32FC1);
 
     randn(data, 0.f, 1.f);
@@ -346,11 +344,11 @@ PERF_TEST_P_(Layer_ScatterND, scatterND) {
     std::vector<int> indices_step;
     for (int i = 0; i < indices.dims; i++)
     {
-        int step = indices.step.p[i] / sizeof(float);
+        int step = indices.step.p[i] / sizeof(int32_t);
         indices_step.push_back(step);
     }
     int t, j, idx, offset_at_idx, offset;
-    auto *indices_ptr = indices.ptr<float>();
+    auto *indices_ptr = indices.ptr<int32_t>();
     for (int i = 0; i < total; i++)
     {
         t = i;
@@ -629,7 +627,7 @@ struct Layer_GatherElements : public TestBaseWithParam<tuple<Backend, Target> >
         int targetId = get<1>(GetParam());
 
         Mat data(data_shape, CV_32FC1);
-        Mat indices(indices_shape, CV_32FC1);
+        Mat indices(indices_shape, CV_64SC1);
 
         randu(data, 0.f, 1.f);
         randu(indices, 0, data_shape[axis]);