Fixed cosine distance between embeddings

Author: Nuzhny007

example/examples.h

@@ -680,7 +680,6 @@ class YoloDarknetExample final : public VideoExample
 		if (!m_trackerSettingsLoaded)
 		{
 			bool useDeepSORT = false;
-
 			if (useDeepSORT)
 			{
 #ifdef _WIN32
@@ -689,16 +688,18 @@ class YoloDarknetExample final : public VideoExample
 				std::string pathToModel = "../data/";
 #endif
 
+#if 1
 				m_trackerSettings.m_embeddings.emplace_back(pathToModel + "open_model_zoo/person-reidentification-retail-0286/FP16-INT8/person-reidentification-retail-0286.xml",
                                                             pathToModel + "open_model_zoo/person-reidentification-retail-0286/FP16-INT8/person-reidentification-retail-0286.bin",
                                                             cv::Size(128, 256),
 					                                        std::vector<ObjectTypes>{ ObjectTypes::obj_person });
+#endif
 
-#if 1
+#if 0
 				m_trackerSettings.m_embeddings.emplace_back(pathToModel + "open_model_zoo/vehicle-reid-0001/osnet_ain_x1_0_vehicle_reid.xml",
                                                             pathToModel + "open_model_zoo/vehicle-reid-0001/osnet_ain_x1_0_vehicle_reid.bin",
                                                             cv::Size(208, 208),
-                                                            std::vector<ObjectTypes>{ ObjectTypes::obj_car, ObjectTypes::obj_bus, ObjectTypes::obj_truck });
+                                                            std::vector<ObjectTypes>{ ObjectTypes::obj_car, ObjectTypes::obj_bus, ObjectTypes::obj_truck, ObjectTypes::obj_vehicle });
 #endif
 
 				std::array<track_t, tracking::DistsCount> distType{
@@ -719,11 +720,11 @@ class YoloDarknetExample final : public VideoExample
 			m_trackerSettings.m_kalmanType = tracking::KalmanLinear;
 			m_trackerSettings.m_filterGoal = tracking::FilterRect;
 			m_trackerSettings.m_lostTrackType = useDeepSORT ? tracking::TrackNone : tracking::TrackCSRT; // Use visual objects tracker for collisions resolving. Used if m_filterGoal == tracking::FilterRect
-			m_trackerSettings.m_matchType = tracking::MatchBipart;
+			m_trackerSettings.m_matchType = tracking::MatchHungrian;
 			m_trackerSettings.m_useAcceleration = false;                   // Use constant acceleration motion model
 			m_trackerSettings.m_dt = m_trackerSettings.m_useAcceleration ? 0.05f : 0.4f; // Delta time for Kalman filter
 			m_trackerSettings.m_accelNoiseMag = 0.2f;                     // Accel noise magnitude for Kalman filter
-			m_trackerSettings.m_distThres = 0.8f;                         // Distance threshold between region and object on two frames
+			m_trackerSettings.m_distThres = useDeepSORT ? 0.7f : 0.8f;    // Distance threshold between region and object on two frames
 #if 0
 			m_trackerSettings.m_minAreaRadiusPix = frame.rows / 20.f;
 #else

src/Tracker/Ctracker.cpp

@@ -344,7 +344,7 @@ void CTracker::UpdateTrackingState(const regions_t& regions,
 
     // Update Kalman Filters state
     const ptrdiff_t stop_i = static_cast<ptrdiff_t>(assignment.size());
-#pragma omp parallel for
+//#pragma omp parallel for
     for (ptrdiff_t i = 0; i < stop_i; ++i)
     {
         // If track updated less than one time, than filter state is not correct.
@@ -474,8 +474,17 @@ void CTracker::CreateDistaceMatrix(const regions_t& regions,
                 {
                     if (reg.m_type == track->LastRegion().m_type)
                     {
-                        std::cout << "CalcCosine: " << TypeConverter::Type2Str(track->LastRegion().m_type) << ", reg = " << reg.m_brect << ", track = " << track->LastRegion().m_brect << std::endl;
-                        dist += m_settings.m_distType[ind] * track->CalcCosine(regionEmbeddings[j]);
+                        auto resCos = track->CalcCosine(regionEmbeddings[j]);
+                        if (resCos)
+                        {
+                            dist += m_settings.m_distType[ind] * resCos.value();
+                            //std::cout << "CalcCosine: " << TypeConverter::Type2Str(track->LastRegion().m_type) << ", reg = " << reg.m_brect << ", track = " << track->LastRegion().m_brect << ": res = " << resCos.value() << ", dist = " << dist << std::endl;
+                        }
+                        else
+                        {
+                            dist /= m_settings.m_distType[ind];
+                            //std::cout << "CalcCosine: " << TypeConverter::Type2Str(track->LastRegion().m_type) << ", reg = " << reg.m_brect << ", track = " << track->LastRegion().m_brect << ": res = 1, weight = " << m_settings.m_distType[ind] << ", dist = " << dist << std::endl;
+                        }
                     }
                 }
 				++ind;
@@ -531,18 +540,18 @@ void CTracker::CalcEmbeddins(std::vector<RegionEmbedding>& regionEmbeddings, con
             {
                 if (regionEmbeddings[j].m_embedding.empty())
                 {
-                    std::cout << "Search embCalc for " << TypeConverter::Type2Str(regions[j].m_type) << ": ";
+                    //std::cout << "Search embCalc for " << TypeConverter::Type2Str(regions[j].m_type) << ": ";
                     auto embCalc = m_embCalculators.find(regions[j].m_type);
                     if (embCalc != std::end(m_embCalculators))
                     {
                         embCalc->second->Calc(currFrame, regions[j].m_brect, regionEmbeddings[j].m_embedding);
                         regionEmbeddings[j].m_embDot = regionEmbeddings[j].m_embedding.dot(regionEmbeddings[j].m_embedding);
 
-                        std::cout << "Founded! m_embedding = " << regionEmbeddings[j].m_embedding.size() << ", m_embDot = " << regionEmbeddings[j].m_embDot << std::endl;
+                        //std::cout << "Founded! m_embedding = " << regionEmbeddings[j].m_embedding.size() << ", m_embDot = " << regionEmbeddings[j].m_embDot << std::endl;
                     }
                     else
                     {
-                        std::cout << "Not found" << std::endl;
+                        //std::cout << "Not found" << std::endl;
                     }
                 }
             }

src/Tracker/EmbeddingsCalculator.hpp

@@ -73,7 +73,7 @@ class EmbeddingsCalculator
 		Clamp(rect.y, rect.height, img.rows);
 
 		cv::UMat obj;
-		cv::resize(img(rect), obj, m_inputLayer, 0., 0., cv::INTER_LINEAR);
+		cv::resize(img(rect), obj, m_inputLayer, 0., 0., cv::INTER_LANCZOS4);
 		cv::Mat blob = cv::dnn::blobFromImage(obj, 1.0, cv::Size(), cv::Scalar(), false, false);
 
 		m_net.setInput(blob);

src/Tracker/track.cpp

@@ -163,27 +163,31 @@ track_t CTrack::CalcDistHist(const RegionEmbedding& embedding) const
 /// \param embedding
 /// \return
 ///
-track_t CTrack::CalcCosine(const RegionEmbedding& embedding) const
+std::optional<track_t> CTrack::CalcCosine(const RegionEmbedding& embedding) const
 {
 	track_t res = 1;
 	if (!embedding.m_embedding.empty() && !m_regionEmbedding.m_embedding.empty())
 	{
 		double xy = embedding.m_embedding.dot(m_regionEmbedding.m_embedding);
 		double norm = sqrt(embedding.m_embDot * m_regionEmbedding.m_embDot) + 1e-6;
-		//res = 1.f - 0.5f * fabs(static_cast<float>(xy / norm));
+#if 1
+        res = 1.f - 0.5f * fabs(static_cast<float>(xy / norm));
+#else
         res = 0.5f * static_cast<float>(1.0 - xy / norm);
         if (res < 0)
             res += 1;
         //res = static_cast<float>(-xy / norm);
+#endif
+        //std::cout << "CTrack::CalcCosine: " << embedding.m_embedding.size() << " - " << m_regionEmbedding.m_embedding.size() << " = " << res << std::endl;
+        return res;
 	}
     else
     {
-        assert(0);
-        CV_Assert(!embedding.m_embedding.empty());
-        CV_Assert(!m_regionEmbedding.m_embedding.empty());
+        //assert(0);
+        //CV_Assert(!embedding.m_embedding.empty());
+        //CV_Assert(!m_regionEmbedding.m_embedding.empty());
+        return {};
     }
-    std::cout << "CalcCosine: " << embedding.m_embedding.size() << " - " << m_regionEmbedding.m_embedding.size() << " = " << res << std::endl;
-	return res;
 }
 
 ///

src/Tracker/track.h

@@ -4,6 +4,7 @@
 #include <deque>
 #include <memory>
 #include <array>
+#include <optional>
 
 #ifdef USE_OCV_KCF
 #include <opencv2/tracking.hpp>
@@ -84,7 +85,7 @@ class CTrack
 	/// \param embedding
 	/// \return
 	///
-	track_t CalcCosine(const RegionEmbedding& embedding) const;
+	std::optional<track_t> CalcCosine(const RegionEmbedding& embedding) const;
 
 	cv::RotatedRect CalcPredictionEllipse(cv::Size_<track_t> minRadius) const;
 	///