opencv
diff --git a/‎modules/dnn/src/caffe/caffe_importer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/dnn/src/caffe/caffe_importer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎modules/dnn/src/caffe/caffe_shrinker.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/dnn/src/caffe/caffe_shrinker.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎modules/dnn/src/ie_ngraph.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/dnn/src/ie_ngraph.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎modules/dnn/src/int8layers/quantization_utils.cpp
Copy file name to clipboard
+3-6Lines changed: 3 additions & 6 deletions b/‎modules/dnn/src/int8layers/quantization_utils.cpp
Copy file name to clipboard
+3-6Lines changed: 3 additions & 6 deletions
diff --git a/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎modules/dnn/src/layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎modules/dnn/src/layer_internals.hpp
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎modules/dnn/src/layer_internals.hpp
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎modules/dnn/src/layers/attention_layer.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/dnn/src/layers/attention_layer.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/dnn/src/layers/batch_norm_layer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎modules/dnn/src/layers/concat_layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎modules/dnn/src/layers/concat_layer.cpp
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎modules/dnn/src/layers/const_layer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎modules/dnn/src/layers/const_layer.cpp
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -279,8 +279,8 @@ class CaffeImporter
                 // Half precision floats.
                 CV_Assert(raw_data.size() / 2 == (int)dstBlob.total());
 
-                Mat halfs((int)shape.size(), &shape[0], CV_16SC1, (void*)raw_data.c_str());
-                convertFp16(halfs, dstBlob);
+                Mat halfs((int)shape.size(), &shape[0], CV_16FC1, (void*)raw_data.c_str());
+                halfs.convertTo(dstBlob, CV_32F);
             }
             else if (pbBlob.raw_data_type() == caffe::FLOAT)
             {
 
@@ -44,8 +44,8 @@ void shrinkCaffeModel(const String& src, const String& dst, const std::vector<St
             CV_Assert(blob->data_size() != 0);  // float32 array.
 
             Mat floats(1, blob->data_size(), CV_32FC1, (void*)blob->data().data());
-            Mat halfs(1, blob->data_size(), CV_16SC1);
-            convertFp16(floats, halfs);  // Convert to float16.
+            Mat halfs(1, blob->data_size(), CV_16FC1);
+            floats.convertTo(halfs, CV_16F);  // Convert to float16.
 
             blob->clear_data();  // Clear float32 data.
 
 
@@ -502,7 +502,7 @@ void InfEngineNgraphNet::init(Target targetId)
                     size_t total = ngraph::shape_size(constant->get_shape());
                     Mat floats(1, total, CV_32F, (void*)floatsData);
                     Mat halfs;
-                    cv::convertFp16(floats, halfs);
+                    floats.convertTo(halfs, CV_16F);
 
                     auto new_const = std::make_shared<ngraph::op::Constant>(ngraph::element::f16, constant->get_shape(), halfs.data);
                     new_const->set_friendly_name(constant->get_friendly_name());
 
@@ -135,10 +135,10 @@ class QuantizeLayerImpl CV_FINAL : public QuantizeLayer
         inputs_.getUMatVector(inputs);
         outputs_.getUMatVector(outputs);
 
-        if (inputs_.depth() == CV_16S)
+        if (inputs_.depth() == CV_16F)
         {
             UMat inputFp32;
-            convertFp16(inputs[0], inputFp32);
+            inputs[0].convertTo(inputFp32, CV_32F);
             inputs[0] = inputFp32;  // replace
         }
 
@@ -264,10 +264,7 @@ class DequantizeLayerImpl CV_FINAL : public DequantizeLayer
         UMat outputFp32;
         inputs[0].convertTo(outputFp32, CV_32F, scales[0], -(scales[0]*zeropoints[0]));
 
-        if (outputs_.depth() == CV_16S)
-            convertFp16(outputFp32, outputs[0]);
-        else
-            outputFp32.copyTo(outputs[0]);
+        outputFp32.convertTo(outputs[0], outputs_.depth());
         return true;
     }
 #endif
 
@@ -176,7 +176,7 @@ void Layer::forward_fallback(InputArrayOfArrays inputs_arr, OutputArrayOfArrays
     CV_TRACE_FUNCTION();
     CV_TRACE_ARG_VALUE(name, "name", name.c_str());
 
-    if (preferableTarget == DNN_TARGET_OPENCL_FP16 && inputs_arr.depth() == CV_16S)
+    if (preferableTarget == DNN_TARGET_OPENCL_FP16 && inputs_arr.depth() == CV_16F)
     {
         std::vector<UMat> inputs;
         std::vector<UMat> outputs;
@@ -192,7 +192,7 @@ void Layer::forward_fallback(InputArrayOfArrays inputs_arr, OutputArrayOfArrays
 
         inputs.resize(orig_inputs.size());
         for (size_t i = 0; i < orig_inputs.size(); i++)
-            convertFp16(orig_inputs[i], inputs[i]);
+            orig_inputs[i].convertTo(inputs[i], CV_32F);
 
         outputs.resize(orig_outputs.size());
         for (size_t i = 0; i < orig_outputs.size(); i++)
@@ -205,7 +205,7 @@ void Layer::forward_fallback(InputArrayOfArrays inputs_arr, OutputArrayOfArrays
         forward(inputs, outputs, internals);
 
         for (size_t i = 0; i < outputs.size(); i++)
-            convertFp16(outputs[i], orig_outputs[i]);
+            outputs[i].convertTo(orig_outputs[i], CV_16F);
 
         // sync results back
         outputs_arr.assign(orig_outputs);
 
@@ -146,7 +146,7 @@ struct DataLayer : public Layer
         CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),
                 forward_ocl(inputs_arr, outputs_arr, internals_arr))
 
-        bool isFP16 = outputs_arr.depth() == CV_16S;
+        bool isFP16 = outputs_arr.depth() == CV_16F;
 
         std::vector<Mat> outputs, internals;
         outputs_arr.getMatVector(outputs);
@@ -159,7 +159,7 @@ struct DataLayer : public Layer
 
             CV_Assert(mean == Scalar() || inputsData[i].size[1] <= 4);
             if (isFP16)
-                CV_CheckTypeEQ(outputs[i].type(), CV_16SC1, "");
+                CV_CheckTypeEQ(outputs[i].type(), CV_16FC1, "");
             else
                 CV_CheckTypeEQ(outputs[i].type(), CV_32FC1, "");
 
@@ -175,7 +175,7 @@ struct DataLayer : public Layer
                 {
                     Mat input_f32;
                     inputsData[i].convertTo(input_f32, CV_32F, scale, -mean[0] * scale);
-                    convertFp16(input_f32, outputs[i]);
+                    input_f32.convertTo(outputs[i], CV_16F);
                 }
                 else
                 {
@@ -194,7 +194,7 @@ struct DataLayer : public Layer
                         {
                             Mat input_f32;
                             inp.convertTo(input_f32, CV_32F, scale, -mean[c] * scale);
-                            convertFp16(input_f32, out);
+                            input_f32.convertTo(out, CV_16F);
                         }
                         else
                         {
@@ -209,7 +209,7 @@ struct DataLayer : public Layer
 #ifdef HAVE_OPENCL
     bool forward_ocl(InputArrayOfArrays, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)
     {
-        bool isFP16 = outputs_.depth() == CV_16S;
+        bool isFP16 = outputs_.depth() == CV_16F;
 
         std::vector<UMat> outputs;
         outputs_.getUMatVector(outputs);
@@ -223,7 +223,7 @@ struct DataLayer : public Layer
 
             CV_Assert(mean == Scalar() || inputData.size[1] <= 4);
             if (isFP16)
-                CV_CheckTypeEQ(outputs[i].type(), CV_16SC1, "");
+                CV_CheckTypeEQ(outputs[i].type(), CV_16FC1, "");
             else
                 CV_CheckTypeEQ(outputs[i].type(), CV_32FC1, "");
 
@@ -239,7 +239,7 @@ struct DataLayer : public Layer
                 {
                     UMat input_i;
                     inputData.convertTo(input_i, CV_32F, scale, -mean[0] * scale);
-                    convertFp16(input_i, outputs[i]);
+                    input_i.convertTo(outputs[i], CV_16F);
                 }
                 else
                 {
@@ -263,7 +263,7 @@ struct DataLayer : public Layer
                         {
                             UMat input_i;
                             inp.convertTo(input_i, CV_32F, scale, -mean[c] * scale);
-                            convertFp16(input_i, out);
+                            input_i.convertTo(out, CV_16F);
                         }
                         else
                         {
 
@@ -106,7 +106,7 @@ class AttentionLayerImpl CV_FINAL : public AttentionLayer {
         CV_TRACE_FUNCTION();
         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
 
-        if (inputs_arr.depth() == CV_16S)
+        if (inputs_arr.depth() == CV_16F)
         {
             forward_fallback(inputs_arr, outputs_arr, internals_arr);
             return;
 
@@ -192,7 +192,7 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
         std::vector<UMat> inputs;
         std::vector<UMat> outputs;
 
-        bool use_half = (inputs_.depth() == CV_16S);
+        bool use_half = (inputs_.depth() == CV_16F);
         inputs_.getUMatVector(inputs);
         outputs_.getUMatVector(outputs);
 
@@ -266,7 +266,7 @@ class BatchNormLayerImpl CV_FINAL : public BatchNormLayer
         CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),
                    forward_ocl(inputs_arr, outputs_arr, internals_arr))
 
-        if (inputs_arr.depth() == CV_16S)
+        if (inputs_arr.depth() == CV_16F)
         {
             forward_fallback(inputs_arr, outputs_arr, internals_arr);
             return;
 
@@ -165,14 +165,14 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
             for( i = 0; i < ninputs; i++ )
             {
                 Mat& inp = inputs[i];
-                CV_Assert( inp.isContinuous() && (inp.type() == CV_32F || inp.type() == CV_16S || inp.type() == CV_8S) &&
+                CV_Assert( inp.isContinuous() && (inp.type() == CV_32F || inp.type() == CV_16F || inp.type() == CV_8S) &&
                            inp.dims == 4 && inp.size[0] == output.size[0] &&
                            inp.size[2] == output.size[2] &&
                            inp.size[3] == output.size[3] );
                 nchannels += inp.size[1];
             }
             CV_Assert( nchannels == output.size[1] );
-            CV_Assert( output.isContinuous() && (output.type() == CV_32F || output.type() == CV_16S || output.type() == CV_8S) );
+            CV_Assert( output.isContinuous() && (output.type() == CV_32F || output.type() == CV_16F || output.type() == CV_8S) );
 
             cc.chptrs.resize(nchannels*batchsz);
 
@@ -223,7 +223,7 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
         std::vector<UMat> inputs;
         std::vector<UMat> outputs;
 
-        bool use_half = (inps.depth() == CV_16S);
+        bool use_half = (inps.depth() == CV_16F);
         inps.getUMatVector(inputs);
         outs.getUMatVector(outputs);
 
 
@@ -62,12 +62,12 @@ class ConstLayerImpl CV_FINAL : public ConstLayer
     {
         std::vector<UMat> outputs;
         outs.getUMatVector(outputs);
-        if (outs.depth() == CV_16S) {
+        if (outs.depth() == CV_16F) {
             auto blob = blobs[0];
             if (blob.type() != CV_32F) {
                 blob.convertTo(blob, CV_32F);
             }
-            convertFp16(blob, outputs[0]);
+            blob.convertTo(outputs[0], CV_16F);
         }
         else
             blobs[0].convertTo(outputs[0], outputs[0].type());
Original file line number	Diff line number	Diff line change
`@@ -279,8 +279,8 @@ class CaffeImporter`
`279`	`279`	`// Half precision floats.`
`280`	`280`	`CV_Assert(raw_data.size() / 2 == (int)dstBlob.total());`
`281`	`281`
`282`		`- Mat halfs((int)shape.size(), &shape[0], CV_16SC1, (void*)raw_data.c_str());`
`283`		`- convertFp16(halfs, dstBlob);`
	`282`	`+ Mat halfs((int)shape.size(), &shape[0], CV_16FC1, (void*)raw_data.c_str());`
	`283`	`+ halfs.convertTo(dstBlob, CV_32F);`
`284`	`284`	`}`
`285`	`285`	`else if (pbBlob.raw_data_type() == caffe::FLOAT)`
`286`	`286`	`{`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ struct DataLayer : public Layer`
`146`	`146`	`CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),`
`147`	`147`	`forward_ocl(inputs_arr, outputs_arr, internals_arr))`
`148`	`148`
`149`		`- bool isFP16 = outputs_arr.depth() == CV_16S;`
	`149`	`+ bool isFP16 = outputs_arr.depth() == CV_16F;`
`150`	`150`
`151`	`151`	`std::vector<Mat> outputs, internals;`
`152`	`152`	`outputs_arr.getMatVector(outputs);`
`@@ -159,7 +159,7 @@ struct DataLayer : public Layer`
`159`	`159`
`160`	`160`	`CV_Assert(mean == Scalar() \|\| inputsData[i].size[1] <= 4);`
`161`	`161`	`if (isFP16)`
`162`		`- CV_CheckTypeEQ(outputs[i].type(), CV_16SC1, "");`
	`162`	`+ CV_CheckTypeEQ(outputs[i].type(), CV_16FC1, "");`
`163`	`163`	`else`
`164`	`164`	`CV_CheckTypeEQ(outputs[i].type(), CV_32FC1, "");`
`165`	`165`
`@@ -175,7 +175,7 @@ struct DataLayer : public Layer`
`175`	`175`	`{`
`176`	`176`	`Mat input_f32;`
`177`	`177`	`inputsData[i].convertTo(input_f32, CV_32F, scale, -mean[0] * scale);`
`178`		`- convertFp16(input_f32, outputs[i]);`
	`178`	`+ input_f32.convertTo(outputs[i], CV_16F);`
`179`	`179`	`}`
`180`	`180`	`else`
`181`	`181`	`{`
`@@ -194,7 +194,7 @@ struct DataLayer : public Layer`
`194`	`194`	`{`
`195`	`195`	`Mat input_f32;`
`196`	`196`	`inp.convertTo(input_f32, CV_32F, scale, -mean[c] * scale);`
`197`		`- convertFp16(input_f32, out);`
	`197`	`+ input_f32.convertTo(out, CV_16F);`
`198`	`198`	`}`
`199`	`199`	`else`
`200`	`200`	`{`
`@@ -209,7 +209,7 @@ struct DataLayer : public Layer`
`209`	`209`	`#ifdef HAVE_OPENCL`
`210`	`210`	`bool forward_ocl(InputArrayOfArrays, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)`
`211`	`211`	`{`
`212`		`- bool isFP16 = outputs_.depth() == CV_16S;`
	`212`	`+ bool isFP16 = outputs_.depth() == CV_16F;`
`213`	`213`
`214`	`214`	`std::vector<UMat> outputs;`
`215`	`215`	`outputs_.getUMatVector(outputs);`
`@@ -223,7 +223,7 @@ struct DataLayer : public Layer`
`223`	`223`
`224`	`224`	`CV_Assert(mean == Scalar() \|\| inputData.size[1] <= 4);`
`225`	`225`	`if (isFP16)`
`226`		`- CV_CheckTypeEQ(outputs[i].type(), CV_16SC1, "");`
	`226`	`+ CV_CheckTypeEQ(outputs[i].type(), CV_16FC1, "");`
`227`	`227`	`else`
`228`	`228`	`CV_CheckTypeEQ(outputs[i].type(), CV_32FC1, "");`
`229`	`229`
`@@ -239,7 +239,7 @@ struct DataLayer : public Layer`
`239`	`239`	`{`
`240`	`240`	`UMat input_i;`
`241`	`241`	`inputData.convertTo(input_i, CV_32F, scale, -mean[0] * scale);`
`242`		`- convertFp16(input_i, outputs[i]);`
	`242`	`+ input_i.convertTo(outputs[i], CV_16F);`
`243`	`243`	`}`
`244`	`244`	`else`
`245`	`245`	`{`
`@@ -263,7 +263,7 @@ struct DataLayer : public Layer`
`263`	`263`	`{`
`264`	`264`	`UMat input_i;`
`265`	`265`	`inp.convertTo(input_i, CV_32F, scale, -mean[c] * scale);`
`266`		`- convertFp16(input_i, out);`
	`266`	`+ input_i.convertTo(out, CV_16F);`
`267`	`267`	`}`
`268`	`268`	`else`
`269`	`269`	`{`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ class AttentionLayerImpl CV_FINAL : public AttentionLayer {`
`106`	`106`	`CV_TRACE_FUNCTION();`
`107`	`107`	`CV_TRACE_ARG_VALUE(name, "name", name.c_str());`
`108`	`108`
`109`		`- if (inputs_arr.depth() == CV_16S)`
	`109`	`+ if (inputs_arr.depth() == CV_16F)`
`110`	`110`	`{`
`111`	`111`	`forward_fallback(inputs_arr, outputs_arr, internals_arr);`
`112`	`112`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,12 @@ class ConstLayerImpl CV_FINAL : public ConstLayer`
`62`	`62`	`{`
`63`	`63`	`std::vector<UMat> outputs;`
`64`	`64`	`outs.getUMatVector(outputs);`
`65`		`- if (outs.depth() == CV_16S) {`
	`65`	`+ if (outs.depth() == CV_16F) {`
`66`	`66`	`auto blob = blobs[0];`
`67`	`67`	`if (blob.type() != CV_32F) {`
`68`	`68`	`blob.convertTo(blob, CV_32F);`
`69`	`69`	`}`
`70`		`- convertFp16(blob, outputs[0]);`
	`70`	`+ blob.convertTo(outputs[0], CV_16F);`
`71`	`71`	`}`
`72`	`72`	`else`
`73`	`73`	`blobs[0].convertTo(outputs[0], outputs[0].type());`