nareshmlx/opencv-pr huggingface dataset:
**File:** modules/dnn/src/layers/padding_layer.cpp
**Change Type:** modified
**Context:** PR #25241: Added int support to padding layer

**Code Changes:**
```diff
@@ -34,7 +34,7 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
     PaddingLayerImpl(const LayerParams &params)
     {
         setParamsFrom(params);
-        paddingValue = params.get<float>("value", 0);
+        paddingValue = params.get<double>("value", 0);
         inputDims = params.get<int>("input_dims", -1);
         paddingType = params.get<String>("type", "constant");
 
@@ -70,6 +70,23 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
```

Review comment:
Is that really affect accuracy? `constant_values_mat` has `CV_32F` and should cast Scalar appropriately
**File:** modules/dnn/src/layers/padding_layer.cpp
**Change Type:** modified
**Context:** PR #25241: Added int support to padding layer
**Review Line:** 282

**Code Changes:**
```diff
@@ -261,7 +279,7 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
     std::vector<std::pair<int, int> > paddings;  // Pairs pad before, pad after.
     std::vector<Range> dstRanges;
     int inputDims;
-    float paddingValue;
+    double paddingValue;
     std::string paddingType;
 };
 
```

Review comment:
Can you please highlight why double precision is required?
**File:** modules/dnn/src/layers/padding_layer.cpp
**Change Type:** modified
**Context:** PR #25241: Added int support to padding layer

**Code Changes:**
```diff
@@ -34,7 +34,7 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
     PaddingLayerImpl(const LayerParams &params)
     {
         setParamsFrom(params);
-        paddingValue = params.get<float>("value", 0);
+        paddingValue = params.get<double>("value", 0);
         inputDims = params.get<int>("input_dims", -1);
         paddingType = params.get<String>("type", "constant");
 
@@ -70,6 +70,23 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
```

Review comment:
paddingValueFloat veriable is required only for Ngraph, because it requires a pointer to float value on initialization and probably doesn't copy the value. Here we can use paddingValue or (float)paddingValue, the result should be the same
**File:** modules/dnn/src/layers/padding_layer.cpp
**Change Type:** modified
**Context:** PR #25241: Added int support to padding layer
**Review Line:** 282

**Code Changes:**
```diff
@@ -261,7 +279,7 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
     std::vector<std::pair<int, int> > paddings;  // Pairs pad before, pad after.
     std::vector<Range> dstRanges;
     int inputDims;
-    float paddingValue;
+    double paddingValue;
     std::string paddingType;
 };
 
```

Review comment:
in ONNX parser paddingValue has the same depth as the input layer, so it can have int type. So we need to store paddingValue using some variable with dynamic type. To make things simpler I just use double type, it should be enough.
**File:** modules/dnn/src/layers/padding_layer.cpp
**Change Type:** modified
**Context:** PR #25241: Added int support to padding layer

**Code Changes:**
```diff
@@ -34,7 +34,7 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
     PaddingLayerImpl(const LayerParams &params)
     {
         setParamsFrom(params);
-        paddingValue = params.get<float>("value", 0);
+        paddingValue = params.get<double>("value", 0);
         inputDims = params.get<int>("input_dims", -1);
         paddingType = params.get<String>("type", "constant");
 
@@ -70,6 +70,23 @@ class PaddingLayerImpl CV_FINAL : public PaddingLayer
```

Review comment:
It copies so you can make it local.
**File:** modules/core/include/opencv2/core.hpp
**Change Type:** modified
**Context:** PR #25356: core: doc: add note for countNonZero, hasNonZero and findNonZero

**Code Changes:**
```diff
@@ -248,7 +248,7 @@ CV_EXPORTS void swap( UMat& a, UMat& b );
 The function computes and returns the coordinate of a donor pixel corresponding to the specified
 extrapolated pixel when using the specified extrapolation border mode. For example, if you use
 cv::BORDER_WRAP mode in the horizontal direction, cv::BORDER_REFLECT_101 in the vertical direction and
-want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img , it
+want to compute value of the "virtual" pixel Point(-5, 100) in a floating-point image img, it
 looks like:
 @code{.cpp}
     float val = img.at<float>(borderInterpolate(100, img.rows, cv::BORDER_REFLECT_101),
@@ -259,7 +259,7 @@ copyMakeBorder.
```

Review comment:
No need in space before , and . Here and bellow.
**File:** modules/photo/src/inpaint.cpp
**Change Type:** modified
**Context:** PR #25122: Use std::priority_queue in inpaint function for performance improvement
**Review Line:** 87

**Code Changes:**
```diff
+            return false;
+        }
+        return order > rhs.order;
+    }
 }
 CvHeapElem;
 
@@ -84,42 +94,10 @@ class CvPriorityQueueFloat
     CvPriorityQueueFloat& operator=(const CvPriorityQueueFloat &); // assign disabled
 
 protected:
```

Review comment:
I propose to remove `CvPriorityQueueFloat` as it is not public API and replace its usage with std object calls. cv::Ptr is not needed any more and you can use `std::priority_queue&` as parameter.
**File:** modules/photo/src/inpaint.cpp
**Change Type:** modified
**Context:** PR #25122: Use std::priority_queue in inpaint function for performance improvement
**Review Line:** 87

**Code Changes:**
```diff
+            return false;
+        }
+        return order > rhs.order;
+    }
 }
 CvHeapElem;
 
@@ -84,42 +94,10 @@ class CvPriorityQueueFloat
     CvPriorityQueueFloat& operator=(const CvPriorityQueueFloat &); // assign disabled
 
 protected:
```

Review comment:
I see. That is a good idea. I'll fix it.
**File:** modules/photo/src/inpaint.cpp
**Change Type:** modified
**Context:** PR #25122: Use std::priority_queue in inpaint function for performance improvement
**Review Line:** 87

**Code Changes:**
```diff
+            return false;
+        }
+        return order > rhs.order;
+    }
 }
 CvHeapElem;
 
@@ -84,42 +94,10 @@ class CvPriorityQueueFloat
     CvPriorityQueueFloat& operator=(const CvPriorityQueueFloat &); // assign disabled
 
 protected:
```

Review comment:
Actually I need to add `next_order` variable in the priority queue class to keep insertion order for complete compatibility. It is because `std::priority_queue` cannot keep insertion order when two elements have the same score. So I think it is simpler to keep this class. If it is OK to break compatibility, i can remove this variable. Even in that case, the result is almost same. How do you think?
**File:** modules/dnn/src/int8layers/layers_common.simd.hpp
**Change Type:** modified
**Context:** PR #25230: Optimize int8 layers in DNN modules by using RISC-V Vector intrinsic.

**Code Changes:**
```diff
@@ -1257,5 +1257,440 @@ void fastGEMM1T( const int8_t* vec, const int8_t* weights,
 }
 #endif // CV_LASX
 
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_RVV && defined(__riscv_v_intrinsic) && __riscv_v_intrinsic>=11000
+
+static const size_t __cv_rvv_e8m1_max = __riscv_vsetvlmax_e8m1();
+static const size_t __cv_rvv_e16m1_max = __riscv_vsetvlmax_e16m1();
+static const size_t __cv_rvv_e32m2_max = __riscv_vsetvlmax_e32m2();
+
```

Review comment:
I have a problem here when compiling with GCC 13.2+ (13.x release branch somewhere after 13.2.0): ``` /work/opencv/modules/dnn/src/int8layers/layers_common.simd.hpp:1370:26: error: no matching function for call to '__riscv_vse32(int [16], vint32m2_t&, const size_t&)' 1370 | __riscv_vse32(vs, vs00, e8m1); | ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~ ``` GCC version: ``` ./riscv64-unknown-linux-gnu-g++ --version riscv64-unknown-linux-gnu-g++ (g128d9cc0599) 13.2.1 20240220 ``` I'm using this GCC because 13.2.0 can not build OpenCV due to an error which has been fixed after this release on branch [releases/gcc-13](https://gcc.gnu.org/git?p=gcc.git;a=shortlog;h=refs/heads/releases/gcc-13) and on trunk branch [trunk](https://gcc.gnu.org/git?p=gcc.git;a=shortlog;h=refs/heads/trunk) This overloaded intrinsic can be replaced with `__riscv_vse32_v_i32m2`.
**File:** modules/dnn/src/int8layers/layers_common.simd.hpp
**Change Type:** modified
**Context:** PR #25230: Optimize int8 layers in DNN modules by using RISC-V Vector intrinsic.

**Code Changes:**
```diff
@@ -1257,5 +1257,440 @@ void fastGEMM1T( const int8_t* vec, const int8_t* weights,
 }
 #endif // CV_LASX
 
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_RVV && defined(__riscv_v_intrinsic) && __riscv_v_intrinsic>=11000
+
+static const size_t __cv_rvv_e8m1_max = __riscv_vsetvlmax_e8m1();
+static const size_t __cv_rvv_e16m1_max = __riscv_vsetvlmax_e16m1();
+static const size_t __cv_rvv_e32m2_max = __riscv_vsetvlmax_e32m2();
+
```

Review comment:
BTW, is `int vs[16]` array actually used anywhere?
**File:** modules/dnn/src/int8layers/layers_common.simd.hpp
**Change Type:** modified
**Context:** PR #25230: Optimize int8 layers in DNN modules by using RISC-V Vector intrinsic.

**Code Changes:**
```diff
@@ -1257,5 +1257,440 @@ void fastGEMM1T( const int8_t* vec, const int8_t* weights,
 }
 #endif // CV_LASX
 
+#if !defined(CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY) && CV_RVV && defined(__riscv_v_intrinsic) && __riscv_v_intrinsic>=11000
+
+static const size_t __cv_rvv_e8m1_max = __riscv_vsetvlmax_e8m1();
+static const size_t __cv_rvv_e16m1_max = __riscv_vsetvlmax_e16m1();
+static const size_t __cv_rvv_e32m2_max = __riscv_vsetvlmax_e32m2();
+
```

Review comment:
Sorry, it looks like the code I used for debugging was not removed. I have deleted it now.
**File:** modules/3d/include/opencv2/3d.hpp
**Change Type:** modified
**Context:** PR #25041: (5.x) Merge 4.x - OpenCV Contrib: https://github.com/opencv/opencv_contrib/pull/3637 OpenCV Extra: https://github.com/opencv/opencv_extra/p...

**Code Changes:**
```diff
@@ -2603,6 +2603,45 @@ of image, we can notice that on image a) these points are distorted.
 CV_EXPORTS_W void undistortImage(InputArray distorted, OutputArray undistorted,
     InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());
 
+/**
+@brief Finds an object pose from 3D-2D point correspondences for fisheye camera moodel.
+
+@param objectPoints Array of object points in the object coordinate space, Nx3 1-channel or
+1xN/Nx1 3-channel, where N is the number of points. vector\<Point3d\> can be also passed here.
+@param imagePoints Array of corresponding image points, Nx2 1-channel or 1xN/Nx1 2-channel,
```

Review comment:
Parenthesis are aligned on 4.x branch. Unnecessary change during this merge.
**File:** modules/3d/test/test_fisheye.cpp
**Change Type:** modified
**Context:** PR #25041: (5.x) Merge 4.x - OpenCV Contrib: https://github.com/opencv/opencv_contrib/pull/3637 OpenCV Extra: https://github.com/opencv/opencv_extra/p...

**Code Changes:**
```diff
@@ -129,6 +129,34 @@ TEST_F(fisheyeTest, distortUndistortPoints)
     }
 }
 
+TEST_F(fisheyeTest, solvePnP)
+{
+    const int n = 16;
+
+    const cv::Matx33d R_mat ( 9.9756700084424932e-01, 6.9698277640183867e-02, 1.4929569991321144e-03,
+                            -6.9711825162322980e-02, 9.9748249845531767e-01, 1.2997180766418455e-02,
```

Review comment:
Don't mess tests order between branches to avoid further merge conflicts. This test comes right before `TEST_F(fisheyeTest, undistortImage)` on 4.x branch: https://github.com/opencv/opencv/blob/12aa0fe89819c02db53677c5749771a1007f623e/modules/calib3d/test/test_fisheye.cpp#L153-L175 This corresponds to the line 132 on 5.x branch. --- If you want to fix order, then do that on 4.x branch first (or better perform reviews of origin PRs)
**File:** modules/dnn/test/test_int.cpp
**Change Type:** modified
**Context:** PR #25330: Added int tests for Const, Concat, ScatterND, NaryEltwise, Arg, Blank layers
**Review Line:** 315

**Code Changes:**
```diff
+    EXPECT_EQ(re.size[2], input1.size[2]);
+    EXPECT_EQ(re.size[3], input1.size[3]);
+
+    std::vector<int> inIndices(4);
+    std::vector<int> reIndices(4);
+    for (int i0 = 0; i0 < re.size[0]; ++i0)
+    {
+        reIndices[0] = i0;
+        inIndices[0] = i0;
+        for (int i1 = 0; i1 < re.size[1]; ++i1)
+        {
```

Review comment:
Is that possible to fill an expected Mat and compare two matrices?
**File:** modules/dnn/test/test_int.cpp
**Change Type:** modified
**Context:** PR #25330: Added int tests for Const, Concat, ScatterND, NaryEltwise, Arg, Blank layers
**Review Line:** 315

**Code Changes:**
```diff
+    EXPECT_EQ(re.size[2], input1.size[2]);
+    EXPECT_EQ(re.size[3], input1.size[3]);
+
+    std::vector<int> inIndices(4);
+    std::vector<int> reIndices(4);
+    for (int i0 = 0; i0 < re.size[0]; ++i0)
+    {
+        reIndices[0] = i0;
+        inIndices[0] = i0;
+        for (int i1 = 0; i1 < re.size[1]; ++i1)
+        {
```

Review comment:
Yes, but what is the difference?
**File:** modules/dnn/src/layers/gather_layer.cpp
**Change Type:** modified
**Context:** PR #25211: Added native int64 indices support to gather layer
**Review Line:** 105

**Code Changes:**
```diff
@@ -115,7 +102,7 @@ class GatherLayerImpl CV_FINAL : public GatherLayer
             const size_t src_offset = i * outer_size;
             for (size_t j = 0 ; j < indices_total; ++j)
             {
-                const int index = idx[j];
+                const int index = normalize_axis(idx[j], axis_size);
                 CV_DbgCheck(index, index >= 0 && index < axis_size, "");
                 const size_t new_offset = src_offset + index * inner_size;
                 std::memcpy(dst, src + new_offset * es, inner_bytes);
```

Review comment:
I cannot understand the motivation of removing `convertTo` while there is explicit conversion to `int` at this line from `int64_t`
**File:** modules/dnn/src/layers/gather_layer.cpp
**Change Type:** modified
**Context:** PR #25211: Added native int64 indices support to gather layer
**Review Line:** 105

**Code Changes:**
```diff
@@ -115,7 +102,7 @@ class GatherLayerImpl CV_FINAL : public GatherLayer
             const size_t src_offset = i * outer_size;
             for (size_t j = 0 ; j < indices_total; ++j)
             {
-                const int index = idx[j];
+                const int index = normalize_axis(idx[j], axis_size);
                 CV_DbgCheck(index, index >= 0 && index < axis_size, "");
                 const size_t new_offset = src_offset + index * inner_size;
                 std::memcpy(dst, src + new_offset * es, inner_bytes);
```

Review comment:
As I understand, OpenCV supports only int32 Mat sizes, so there is no point to keep int64 index value. ConvertTo creates a copy of Mat, so it uses some memory and CPU resources. Casting of a local variable doesn't uses additional memory and most likely doesn't affect performance.
**File:** modules/videoio/test/test_v4l2.cpp
**Change Type:** modified
**Context:** PR #25333: Added option to dump v4l2 test frame from virtual camera

**Code Changes:**
```diff
@@ -17,6 +17,8 @@
 
 #ifdef HAVE_CAMV4L2
 
+// #define DUMP_CAMERA_FRAME
+
 #include "test_precomp.hpp"
 #include <opencv2/core/utils/configuration.private.hpp>
 #include <linux/videodev2.h>
@@ -113,6 +115,13 @@ TEST_P(videoio_v4l2, formats)
```

Review comment:
There are two functions: `fourccToStringSafe` and `fourccToString` declared in test_precomp.hpp, maybe they can be reused?
**File:** modules/dnn/src/layers/cumsum_layer.cpp
**Change Type:** modified
**Context:** PR #25214: Added int support to CumSum layer
**Review Line:** 76

**Code Changes:**
```diff
+                forwardImpl<int64_t>(inputs, outputs);
+                break;
+            default:
+                CV_Error(Error::BadDepth, "");
+        }
+    }
+
+    template <typename T>
+    void forwardImpl(const std::vector<Mat>& inputs, std::vector<Mat>& outputs)
+    {
         // Get input tensor.
```

Review comment:
Do we have tests for int32 and int64 data types?
**File:** modules/dnn/src/layers/cumsum_layer.cpp
**Change Type:** modified
**Context:** PR #25214: Added int support to CumSum layer
**Review Line:** 76

**Code Changes:**
```diff
+                forwardImpl<int64_t>(inputs, outputs);
+                break;
+            default:
+                CV_Error(Error::BadDepth, "");
+        }
+    }
+
+    template <typename T>
+    void forwardImpl(const std::vector<Mat>& inputs, std::vector<Mat>& outputs)
+    {
         // Get input tensor.
```

Review comment:
Not yet. I will add .onnx tests in opencv_extra for all the new int layers later in a separate PR
**File:** modules/core/src/rand.cpp
**Change Type:** modified
**Context:** PR #25328: Resolve out of bound write in RNG::fill

**Code Changes:**
```diff
@@ -544,7 +544,7 @@ void RNG::fill( InputOutputArray _mat, int disttype,
 
     if( disttype == UNIFORM )
     {
-        _parambuf.allocate((sizeof(DivStruct)+sizeof(double)-1)/sizeof(double) + cn*2 + n1 + n2);
+        _parambuf.allocate(cn*(sizeof(DivStruct)+sizeof(double)-1)/sizeof(double) + cn*4);
         double* parambuf = _parambuf.data();
         double* p1 = _param1.ptr<double>();
         double* p2 = _param2.ptr<double>();
@@ -570,6 +570,7 @@ void RNG::fill( InputOutputArray _mat, int disttype,
```

Review comment:
Need to move this check out of the cycle.
**File:** modules/dnn/test/test_layers_1d.cpp
**Change Type:** modified
**Context:** PR #25074: 1D Input Softmax test

**Code Changes:**
```diff
@@ -381,4 +381,53 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Concat_Test,
     std::vector<int>({}),
     std::vector<int>({1})
 ));
+
+typedef testing::TestWithParam<tuple<std::vector<int>, int>> Layer_Softmax_Test;
+TEST_P(Layer_Softmax_Test, Accuracy_01D) {
+
+    int axis = get<1>(GetParam());
+    std::vector<int> input_shape = get<0>(GetParam());
```

Review comment:
For `dims=1` I recommend make a vector (more than single element)
**File:** modules/dnn/test/test_layers_1d.cpp
**Change Type:** modified
**Context:** PR #25074: 1D Input Softmax test

**Code Changes:**
```diff
@@ -381,4 +381,53 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Concat_Test,
     std::vector<int>({}),
     std::vector<int>({1})
 ));
+
+typedef testing::TestWithParam<tuple<std::vector<int>, int>> Layer_Softmax_Test;
+TEST_P(Layer_Softmax_Test, Accuracy_01D) {
+
+    int axis = get<1>(GetParam());
+    std::vector<int> input_shape = get<0>(GetParam());
```

Review comment:
I even wanted to see more intuitive parametrization by `input_shape`: ```cpp typedef testing::TestWithParam<std::vector<int>> Layer_Softmax_Test; TEST_P(Layer_Softmax_Test, Accuracy) { std::vector<int> input_shape = GetParam(); LayerParams lp; lp.type = "Softmax"; lp.name = "softmaxLayer"; lp.set("axis", 0); Ptr<SoftmaxLayer> layer = SoftmaxLayer::create(lp); cv::Mat input = cv::Mat(input_shape.size(), input_shape.data(), CV_32F, 1.0); cv::randn(input, 0.0, 1.0); std::vector<Mat> inputs{input}; std::vector<Mat> outputs; runLayer(layer, inputs, outputs); cv::Mat output_ref; cv::exp(input, output_ref); cv::divide(output_ref, cv::sum(output_ref), output_ref); ASSERT_EQ(shape(output_ref), shape(outputs[0])); normAssert(output_ref, outputs[0]); } INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Softmax_Test, /*input blob shape*/ ValuesIn(std::vector<std::vector<int>>{{}, {1}, {10}})); ```
**File:** modules/dnn/test/test_layers_1d.cpp
**Change Type:** modified
**Context:** PR #25074: 1D Input Softmax test

**Code Changes:**
```diff
@@ -381,4 +381,53 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Concat_Test,
     std::vector<int>({}),
     std::vector<int>({1})
 ));
+
+typedef testing::TestWithParam<tuple<std::vector<int>, int>> Layer_Softmax_Test;
+TEST_P(Layer_Softmax_Test, Accuracy_01D) {
+
+    int axis = get<1>(GetParam());
+    std::vector<int> input_shape = get<0>(GetParam());
```

Review comment:
What about dims == 1 and axis == 1? Generally speaking, `axis >= dims`
**File:** modules/dnn/test/test_layers_1d.cpp
**Change Type:** modified
**Context:** PR #25074: 1D Input Softmax test

**Code Changes:**
```diff
@@ -381,4 +381,53 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Concat_Test,
     std::vector<int>({}),
     std::vector<int>({1})
 ));
+
+typedef testing::TestWithParam<tuple<std::vector<int>, int>> Layer_Softmax_Test;
+TEST_P(Layer_Softmax_Test, Accuracy_01D) {
+
+    int axis = get<1>(GetParam());
+    std::vector<int> input_shape = get<0>(GetParam());
```

Review comment:
How 0d softmax works? How 1d tensor works with axis=1 in softmax? --- Also I would suggest using shape vector is enough and dim can be retrieve from the vector shape.
**File:** modules/3d/src/pointcloud/io_obj.cpp
**Change Type:** modified
**Context:** PR #25221: OBJ and PLY loaders extention to support texture coordinates and difused colors

**Code Changes:**
```diff
@@ -12,12 +12,24 @@ namespace cv {
 
 std::unordered_set<std::string> ObjDecoder::m_unsupportedKeys;
 
-void ObjDecoder::readData(std::vector<Point3f> &points, std::vector<Point3f> &normals, std::vector<Point3_<uchar>> &rgb, std::vector<std::vector<int32_t>> &indices)
+void ObjDecoder::readData(std::vector<Point3f>& points, std::vector<Point3f>& normals, std::vector<Point3f>& rgb)
 {
-    points.clear();
-    normals.clear();
-    rgb.clear();
```

Review comment:
Please do not ignore exceptions. It should be `CV_LOG_ERROR` at least.
**File:** modules/3d/test/test_pointcloud.cpp
**Change Type:** modified
**Context:** PR #25221: OBJ and PLY loaders extention to support texture coordinates and difused colors

**Code Changes:**
```diff
@@ -11,39 +11,40 @@
 
 namespace opencv_test { namespace {
 
-TEST(PointCloud, LoadObj)
+TEST(PointCloud, LoadPointCloudObj)
 {
     std::vector<cv::Point3f> points_gold = {
-        {-5.93915f, -0.13257f, 2.55837f},
-        {-5.93915f, 1.86743f, 2.55837f},
```

Review comment:
Please add check that loaded arrays are not empty.
**File:** modules/3d/test/test_pointcloud.cpp
**Change Type:** modified
**Context:** PR #25221: OBJ and PLY loaders extention to support texture coordinates and difused colors
**Review Line:** 139

**Code Changes:**
```diff
+    std::vector<cv::Point3f> points_gold, normals_gold, colors_gold;
+    std::vector<cv::Point2f> texCoords_gold;
     std::vector<std::vector<int32_t>> indices_gold;
 
-    cv::loadMesh(new_path, points_gold, indices_gold, normals_gold);
+    cv::loadMesh(new_path, points_gold, indices_gold, normals_gold, colors_gold, texCoords_gold);
+    EXPECT_FALSE(points_gold.empty());
+    EXPECT_FALSE(indices_gold.empty());
+    EXPECT_FALSE(normals_gold.empty());
+    EXPECT_FALSE(colors_gold.empty());
+    EXPECT_FALSE(texCoords_gold.empty());
```

Review comment:
The same or check gold values at least.
**File:** modules/3d/src/pointcloud/io_base.hpp
**Change Type:** modified
**Context:** PR #25221: OBJ and PLY loaders extention to support texture coordinates and difused colors
**Review Line:** 54

**Code Changes:**
```diff
+                           const std::vector<Point3f>& texCoords, int nTexCoords,
+                           const std::vector<std::vector<int32_t>>& indices) = 0;
 
 protected:
-    String m_filename;
+    std::string m_filename;
 };
 
 } /* namespace cv */
```

Review comment:
they are synonyms. The change does not make a lot of sense.
**File:** modules/3d/src/pointcloud/io_ply.cpp
**Change Type:** modified
**Context:** PR #25221: OBJ and PLY loaders extention to support texture coordinates and difused colors
**Review Line:** 471

**Code Changes:**
```diff
             offset = offsetof(VertexFields, r);
-        if (p.name == "green")
+        if (p.name == "green" || p.name == "diffuse_green")
             offset = offsetof(VertexFields, g);
-        if (p.name == "blue")
+        if (p.name == "blue"  || p.name == "diffuse_blue")
             offset = offsetof(VertexFields, b);
         vertexOffsets[j] = offset;
     }
@@ -426,18 +504,12 @@ void PlyDecoder::parseBody(std::ifstream &file, std::vector<Point3f> &points, st
             size_t offset = vertexOffsets[j];
```

Review comment:
Are regular colors and diffuse colors possible together? If true, then parser should not mix red, diffuse_green and blue together, but prefer on of color spaces.