|
|
// // // Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
|
|
|
// // //
|
|
|
// // // Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
// // // you may not use this file except in compliance with the License.
|
|
|
// // // You may obtain a copy of the License at
|
|
|
// // //
|
|
|
// // // http://www.apache.org/licenses/LICENSE-2.0
|
|
|
// // //
|
|
|
// // // Unless required by applicable law or agreed to in writing, software
|
|
|
// // // distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
// // // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
// // // See the License for the specific language governing permissions and
|
|
|
// // // limitations under the License.
|
|
|
|
|
|
// // #include <thread>
|
|
|
// // #include "fastdeploy/vision.h"
|
|
|
// // #include <opencv2/opencv.hpp>
|
|
|
// // #include <chrono>
|
|
|
// // #ifdef WIN32
|
|
|
// // const char sep = '\\';
|
|
|
// // #else
|
|
|
// // const char sep = '/';
|
|
|
// // #endif
|
|
|
|
|
|
// // // void Predict(fastdeploy::vision::classification::PaddleClasModel *model, int thread_id, const std::vector<std::string>& images) {
|
|
|
// // // for (auto const &image_file : images) {
|
|
|
// // // std::cout << image_file << std::endl;
|
|
|
// // // auto im = cv::imread(image_file);
|
|
|
|
|
|
// // // fastdeploy::vision::ClassifyResult res;
|
|
|
// // // if (!model->Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
|
|
|
// // // // print res
|
|
|
// // // std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
// // // }
|
|
|
// // // }
|
|
|
|
|
|
|
|
|
// // void GetImageList(std::vector<std::vector<std::string>>* image_list, const std::string& image_file_path, int thread_num){
|
|
|
// // std::vector<cv::String> images;
|
|
|
// // cv::glob(image_file_path, images, false);
|
|
|
// // // number of image files in images folder
|
|
|
// // size_t count = images.size();
|
|
|
// // size_t num = count / thread_num;
|
|
|
// // for (int i = 0; i < thread_num; i++) {
|
|
|
// // std::vector<std::string> temp_list;
|
|
|
// // if (i == thread_num - 1) {
|
|
|
// // for (size_t j = i*num; j < count; j++){
|
|
|
// // temp_list.push_back(images[j]);
|
|
|
// // }
|
|
|
// // } else {
|
|
|
// // for (size_t j = 0; j < num; j++){
|
|
|
// // temp_list.push_back(images[i * num + j]);
|
|
|
// // }
|
|
|
// // }
|
|
|
// // (*image_list)[i] = temp_list;
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
|
|
|
// // // SCRFD
|
|
|
// // void Predict(fastdeploy::vision::facedet::SCRFD *model, int thread_id, const std::vector<std::string>& images, cv::Mat im) {
|
|
|
// // // auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // if (!model->Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// // // 获取时间戳
|
|
|
// // auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
|
|
|
|
|
|
// // // 打印时间戳
|
|
|
// // std::cout << "程序开始时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
// // for (auto const &image_file : images) {
|
|
|
// // std::cout << image_file << std::endl;
|
|
|
|
|
|
// // fastdeploy::vision::FaceDetectionResult res;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
// // if (!model->Predict(&im, &res)) {
|
|
|
// // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
// // auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// // auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
// // std::cout << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // // print res
|
|
|
// // std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// // std::cout << res.Str() << std::endl;
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
|
|
|
|
|
|
// // //SCRFD
|
|
|
// // void GpuInfer(const std::string& model_dir, const std::string& image_file_path, int thread_num) {
|
|
|
// // auto option1 = fastdeploy::RuntimeOption();
|
|
|
// // option1.UseGpu();
|
|
|
// // option1.UseTrtBackend();
|
|
|
// // option1.SetTrtInputShape("images", {1, 3, 640, 640});
|
|
|
// // option1.trt_option.serialize_file = "./tmp3.trt";
|
|
|
// // option1.trt_option.enable_fp16 = true;
|
|
|
// // auto model1 = fastdeploy::vision::facedet::SCRFD("scrfd_500m_bnkps_shape640x640.onnx", "", option1);
|
|
|
// // if (!model1.Initialized()) {
|
|
|
// // std::cerr << "Failed to initialize." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
|
|
|
// // auto im = cv::imread("test_face.jpg");
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // if (!model1.Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
|
|
|
// // std::vector<decltype(model1.Clone())> models;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // models.emplace_back(std::move(model1.Clone()));
|
|
|
// // }
|
|
|
|
|
|
// // std::vector<std::vector<std::string>> image_list(thread_num);
|
|
|
// // GetImageList(&image_list, image_file_path, thread_num);
|
|
|
|
|
|
// // std::vector<std::thread> threads;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads.emplace_back(Predict, models[i].get(), i, image_list[i], im);
|
|
|
// // }
|
|
|
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads[i].join();
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
// // // yolov8
|
|
|
// // void PredictYolo(fastdeploy::vision::detection::YOLOv8 *model, int thread_id, const std::vector<std::string>& images, cv::Mat im) {
|
|
|
// // // auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // if (!model->Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// // // 获取时间戳
|
|
|
// // auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
|
|
|
|
|
|
// // // 打印时间戳
|
|
|
// // std::cout << "程序开始时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
// // for (auto const &image_file : images) {
|
|
|
// // std::cout << image_file << std::endl;
|
|
|
// // // auto im = cv::imread(image_file);
|
|
|
|
|
|
// // fastdeploy::vision::DetectionResult res;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
// // if (!model->Predict(im, &res)) {
|
|
|
// // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
// // auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// // auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
// // std::cout << "&&&&& " << res.label_ids[0] << std::endl;
|
|
|
// // std::cout << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // // print res
|
|
|
// // std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// // std::cout << res.Str() << std::endl;
|
|
|
// // auto vis_im = fastdeploy::vision::VisDetection(im, res);
|
|
|
// // cv::imwrite("vis_result.jpg", vis_im);
|
|
|
// // std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
|
|
|
// // // void PredictYolo1(fastdeploy::vision::detection::YOLOv8 *model, int thread_id, const std::vector<std::string>& images, cv::Mat im) {
|
|
|
// // // // auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// // // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // // if (!model->Predict(im, &res)) {
|
|
|
// // // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // // return;
|
|
|
// // // // }
|
|
|
// // // // std::cout << res.Str() << std::endl;
|
|
|
// // // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// // // // 获取时间戳
|
|
|
// // // auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
|
|
|
|
|
|
// // // // 打印时间戳
|
|
|
// // // std::cout << "程序开始时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
// // // if (!model->Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// // // auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
// // // std::cout << "&&&&& " << res.label_ids[0] << std::endl;
|
|
|
// // // std::cout << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // // // print res
|
|
|
// // // std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
// // // auto vis_im = fastdeploy::vision::VisDetection(im, res);
|
|
|
// // // cv::imwrite("vis_result.jpg", vis_im);
|
|
|
// // // std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
|
|
|
// // // }
|
|
|
|
|
|
|
|
|
|
|
|
// // //yolov8
|
|
|
// // void GpuInferYolo(const std::string& model_dir, const std::string& image_file_path, int thread_num) {
|
|
|
// // auto option1 = fastdeploy::RuntimeOption();
|
|
|
// // option1.UseGpu();
|
|
|
// // option1.UseTrtBackend();
|
|
|
// // option1.SetTrtInputShape("images", {1, 3, 640, 640});
|
|
|
// // option1.trt_option.serialize_file = "./tmp2.trt";
|
|
|
// // option1.trt_option.enable_fp16 = true;
|
|
|
// // auto model1 = fastdeploy::vision::detection::YOLOv8("yolov8s.onnx", "", option1);
|
|
|
// // if (!model1.Initialized()) {
|
|
|
// // std::cerr << "Failed to initialize." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
|
|
|
// // auto im = cv::imread("frame_6.png");
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // if (!model1.Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
|
|
|
// // std::vector<decltype(model1.Clone())> models;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // models.emplace_back(std::move(model1.Clone()));
|
|
|
// // }
|
|
|
|
|
|
// // std::vector<std::vector<std::string>> image_list(thread_num);
|
|
|
// // GetImageList(&image_list, image_file_path, thread_num);
|
|
|
|
|
|
// // std::vector<std::thread> threads;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads.emplace_back(PredictYolo, models[i].get(), i, image_list[i], im);
|
|
|
// // }
|
|
|
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads[i].join();
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
// // // faceid
|
|
|
// // void PredictFaceId(fastdeploy::vision::faceid::PartialFC *model, int thread_id, const std::vector<std::string>& images, cv::Mat im) {
|
|
|
// // // auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// // // fastdeploy::vision::DetectionResult res;
|
|
|
// // // if (!model->Predict(im, &res)) {
|
|
|
// // // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
// // // std::cout << res.Str() << std::endl;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// // // 获取时间戳
|
|
|
// // auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
|
|
|
|
|
|
// // // 打印时间戳
|
|
|
// // std::cout << "程序开始时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
// // for (auto const &image_file : images) {
|
|
|
// // std::cout << image_file << std::endl;
|
|
|
// // auto im = cv::imread(image_file);
|
|
|
|
|
|
// // // auto face0 = cv::imread("face_0.jpg");
|
|
|
// // // auto face1 = cv::imread("face_1.jpg");
|
|
|
// // // auto face2 = cv::imread("face_2.jpg");
|
|
|
|
|
|
// // // fastdeploy::vision::FaceRecognitionResult res0;
|
|
|
// // // fastdeploy::vision::FaceRecognitionResult res1;
|
|
|
// // // fastdeploy::vision::FaceRecognitionResult res2;
|
|
|
|
|
|
|
|
|
// // // if ((!model->Predict(face0, &res0)) || (!model->Predict(face1, &res1)) ||
|
|
|
// // // (!model->Predict(face2, &res2))) {
|
|
|
// // // std::cerr << "Prediction Failed." << std::endl;
|
|
|
// // // }
|
|
|
// // // std::cout << "Prediction Done!" << std::endl;
|
|
|
|
|
|
// // // std::cout << "--- [Face 0]:" << res0.Str();
|
|
|
// // // std::cout << "--- [Face 1]:" << res1.Str();
|
|
|
// // // std::cout << "--- [Face 2]:" << res2.Str();
|
|
|
// // // float cosine01 = fastdeploy::vision::utils::CosineSimilarity(
|
|
|
// // // res0.embedding, res1.embedding,
|
|
|
// // // model->GetPostprocessor().GetL2Normalize());
|
|
|
// // // float cosine02 = fastdeploy::vision::utils::CosineSimilarity(
|
|
|
// // // res0.embedding, res2.embedding,
|
|
|
// // // model->GetPostprocessor().GetL2Normalize());
|
|
|
// // // std::cout << "Detect Done! Cosine 01: " << cosine01
|
|
|
// // // << ", Cosine 02:" << cosine02 << std::endl;
|
|
|
|
|
|
|
|
|
// // fastdeploy::vision::FaceRecognitionResult res;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
// // if (!model->Predict(im, &res)) {
|
|
|
// // std::cerr << "Failed to predict." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
// // auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// // auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
// // std::cout << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // // print res
|
|
|
// // std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// // std::cout << res.Str() << std::endl;
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
// // // faceid
|
|
|
// // void GpuInferPredictFaceId(const std::string& model_dir, const std::string& image_file_path, int thread_num) {
|
|
|
// // auto option1 = fastdeploy::RuntimeOption();
|
|
|
// // option1.UseGpu();
|
|
|
// // option1.UseTrtBackend();
|
|
|
// // option1.SetTrtInputShape("data", {1, 3, 112, 112});
|
|
|
// // option1.trt_option.serialize_file = "./tmp_faceid.trt";
|
|
|
// // option1.trt_option.enable_fp16 = true;
|
|
|
// // auto model1 = fastdeploy::vision::faceid::PartialFC("partial_fc_glint360k_r100.onnx", "", option1);
|
|
|
// // if (!model1.Initialized()) {
|
|
|
// // std::cerr << "Failed to initialize." << std::endl;
|
|
|
// // return;
|
|
|
// // }
|
|
|
|
|
|
// // auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// // std::vector<decltype(model1.Clone())> models;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // models.emplace_back(std::move(model1.Clone()));
|
|
|
// // }
|
|
|
|
|
|
// // std::vector<std::vector<std::string>> image_list(thread_num);
|
|
|
// // GetImageList(&image_list, image_file_path, thread_num);
|
|
|
|
|
|
// // std::vector<std::thread> threads;
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads.emplace_back(PredictFaceId, models[i].get(), i, image_list[i], im);
|
|
|
// // }
|
|
|
|
|
|
// // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // threads[i].join();
|
|
|
// // }
|
|
|
// // }
|
|
|
|
|
|
|
|
|
// // // void GpuInfer(const std::string& model_dir, const std::string& image_file_path, int thread_num) {
|
|
|
// // // auto model_file = model_dir + sep + "inference.pdmodel";
|
|
|
// // // auto params_file = model_dir + sep + "inference.pdiparams";
|
|
|
// // // auto config_file = model_dir + sep + "inference_cls.yaml";
|
|
|
// // // auto option = fastdeploy::RuntimeOption();
|
|
|
// // // option.UseGpu();
|
|
|
// // // option.UsePaddleBackend();
|
|
|
// // // auto model = fastdeploy::vision::classification::PaddleClasModel(
|
|
|
// // // model_file, params_file, config_file, option);
|
|
|
// // // if (!model.Initialized()) {
|
|
|
// // // std::cerr << "Failed to initialize." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
|
|
|
// // // std::vector<decltype(model.Clone())> models;
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // models.emplace_back(std::move(model.Clone()));
|
|
|
// // // }
|
|
|
|
|
|
// // // std::vector<std::vector<std::string>> image_list(thread_num);
|
|
|
// // // GetImageList(&image_list, image_file_path, thread_num);
|
|
|
|
|
|
// // // std::vector<std::thread> threads;
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // threads.emplace_back(Predict, models[i].get(), i, image_list[i]);
|
|
|
// // // }
|
|
|
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // threads[i].join();
|
|
|
// // // }
|
|
|
// // // }
|
|
|
|
|
|
|
|
|
// // // void TrtInfer(const std::string& model_dir, const std::string& image_file_path, int thread_num) {
|
|
|
// // // auto model_file = model_dir + sep + "inference.pdmodel";
|
|
|
// // // auto params_file = model_dir + sep + "inference.pdiparams";
|
|
|
// // // auto config_file = model_dir + sep + "inference_cls.yaml";
|
|
|
// // // auto option = fastdeploy::RuntimeOption();
|
|
|
// // // option.UseGpu();
|
|
|
// // // option.UseTrtBackend();
|
|
|
// // // option.SetTrtInputShape("inputs", {1, 3, 224, 224});
|
|
|
// // // option.trt_option.serialize_file = "./tmp3.trt";
|
|
|
// // // option.trt_option.enable_fp16 = true;
|
|
|
|
|
|
// // // // for model.Clone() must SetTrtInputShape first
|
|
|
// // // option.SetTrtInputShape("inputs", {1, 3, 224, 224});
|
|
|
// // // auto model = fastdeploy::vision::classification::PaddleClasModel(
|
|
|
// // // model_file, params_file, config_file, option);
|
|
|
// // // if (!model.Initialized()) {
|
|
|
// // // std::cerr << "Failed to initialize." << std::endl;
|
|
|
// // // return;
|
|
|
// // // }
|
|
|
|
|
|
// // // std::vector<decltype(model.Clone())> models;
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // models.emplace_back(std::move(model.Clone()));
|
|
|
// // // }
|
|
|
|
|
|
// // // std::vector<std::vector<std::string>> image_list(thread_num);
|
|
|
// // // GetImageList(&image_list, image_file_path, thread_num);
|
|
|
|
|
|
// // // std::vector<std::thread> threads;
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // threads.emplace_back(Predict, models[i].get(), i, image_list[i]);
|
|
|
// // // }
|
|
|
|
|
|
// // // for (int i = 0; i < thread_num; ++i) {
|
|
|
// // // threads[i].join();
|
|
|
// // // }
|
|
|
// // // }
|
|
|
|
|
|
|
|
|
|
|
|
// // int main(int argc, char **argv) {
|
|
|
// // std::vector<std::vector<uchar>> videoFrames;
|
|
|
// // auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
|
|
|
// // cv::VideoCapture cap("test.mp4");
|
|
|
|
|
|
// // // 检查视频是否成功打开
|
|
|
// // if (!cap.isOpened()) {
|
|
|
// // std::cerr << "Error opening video file!" << std::endl;
|
|
|
// // return -1;
|
|
|
// // }
|
|
|
|
|
|
// // // 获取视频的帧数和帧率
|
|
|
// // int frameCount = cap.get(cv::CAP_PROP_FRAME_COUNT);
|
|
|
// // double fps = cap.get(cv::CAP_PROP_FPS);
|
|
|
|
|
|
// // std::cout << "Number of frames: " << frameCount << std::endl;
|
|
|
// // std::cout << "Frames per second: " << fps << std::endl;
|
|
|
|
|
|
|
|
|
// // for (int i = 0; i < frameCount; ++i) {
|
|
|
// // cv::Mat frame;
|
|
|
// // cap >> frame; // 读取一帧
|
|
|
// // std::cout << i << std::endl;
|
|
|
// // // 检查是否成功读取帧
|
|
|
// // if (frame.empty()) {
|
|
|
// // std::cerr << "Error reading frame " << i << " from video!" << std::endl;
|
|
|
// // break;
|
|
|
// // }
|
|
|
// // std::vector<uchar> compressedData;
|
|
|
// // cv::imencode(".jpg", frame, compressedData, {cv::IMWRITE_JPEG_QUALITY, 90});
|
|
|
// // videoFrames.push_back(compressedData);
|
|
|
|
|
|
// // }
|
|
|
// // std::cout << "size: " << videoFrames.size() << std::endl;
|
|
|
// // // int flag = std::atoi(argv[3]);
|
|
|
// // // if (flag == 0) {
|
|
|
// // // GpuInfer(argv[1], argv[2], std::atoi(argv[4]));
|
|
|
// // // } else if (flag == 1){
|
|
|
// // // GpuInferYolo(argv[1], argv[2], std::atoi(argv[4]));
|
|
|
// // // } else if (flag == 2) {
|
|
|
// // // GpuInferPredictFaceId(argv[1], argv[2], std::atoi(argv[4]));
|
|
|
// // // } else {
|
|
|
|
|
|
// // // }
|
|
|
|
|
|
|
|
|
|
|
|
// // // auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// // // auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(end_time.time_since_epoch()).count();
|
|
|
|
|
|
// // // // 打印时间戳
|
|
|
// // // std::cout << "程序结束时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
// // // // 计算程序运行时间
|
|
|
// // // auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
|
|
|
// // // // 打印程序运行时间
|
|
|
// // // std::cout << "程序运行时间: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // return 0;
|
|
|
// // }
|
|
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
#include <vector>
|
|
|
#include <string>
|
|
|
#include <chrono>
|
|
|
#include <thread>
|
|
|
#include <opencv2/opencv.hpp>
|
|
|
#include "fastdeploy/vision.h"
|
|
|
#include <atomic>
|
|
|
#include <condition_variable>
|
|
|
#include <dirent.h>
|
|
|
|
|
|
// #include <pybind11/pybind11.h>
|
|
|
|
|
|
// namespace py = pybind11;
|
|
|
|
|
|
// #include <filesystem>
|
|
|
|
|
|
// namespace fs = std::filesystem;
|
|
|
|
|
|
|
|
|
std::atomic<bool> hasCarOrPerson(false);
|
|
|
std::mutex resultMutex;
|
|
|
std::condition_variable resultCondition;
|
|
|
|
|
|
class VideoSegmenter {
|
|
|
public:
|
|
|
static const std::string FFMPEG_PATH;
|
|
|
static const std::string SEGMENT_TIME;
|
|
|
static const std::string TMP_OUTPUT_PATH;
|
|
|
|
|
|
static std::string segmentVideo(const std::string& videoPath) {
|
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// fs::path outputPath = fs::path(TMP_OUTPUT_PATH) / "%04d.mp4";
|
|
|
// fs::remove_all(outputPath.parent_path());
|
|
|
// fs::create_directories(outputPath.parent_path());
|
|
|
std::string outputPath = TMP_OUTPUT_PATH + "/%04d.mp4";
|
|
|
|
|
|
// 删除目录
|
|
|
std::string parentPath = outputPath.substr(0, outputPath.find_last_of("/"));
|
|
|
std::string removeCommand = "rm -rf " + parentPath;
|
|
|
std::system(removeCommand.c_str());
|
|
|
|
|
|
// 创建目录
|
|
|
std::string createDirectoriesCommand = "mkdir -p " + parentPath;
|
|
|
std::system(createDirectoriesCommand.c_str());
|
|
|
|
|
|
// std::vector<std::string> command = {
|
|
|
// FFMPEG_PATH,
|
|
|
// "-i",
|
|
|
// videoPath,
|
|
|
// "-c",
|
|
|
// "copy",
|
|
|
// "-reset_timestamps",
|
|
|
// "1",
|
|
|
// "-segment_time",
|
|
|
// SEGMENT_TIME,
|
|
|
// "-f",
|
|
|
// "segment",
|
|
|
// outputPath.string()
|
|
|
// };
|
|
|
|
|
|
try {
|
|
|
std::string command = "ffmpeg -i " + videoPath + " -c copy -reset_timestamps 1 -segment_time 00:10 -f segment ../SegmentationFiles/%04d.mp4";
|
|
|
int result = std::system(command.c_str());
|
|
|
if (result != 0) {
|
|
|
throw std::runtime_error("Failed to segment video");
|
|
|
}
|
|
|
} catch (const std::exception& e) {
|
|
|
throw std::runtime_error("Failed to segment video");
|
|
|
}
|
|
|
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
|
std::cout << "Segmentation completed in " << std::chrono::duration_cast<std::chrono::seconds>(end - start).count() << "s" << std::endl;
|
|
|
|
|
|
return parentPath;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
const std::string VideoSegmenter::FFMPEG_PATH = "/usr/local/ffmpeg-6.0.1-amd64-static/ffmpeg";
|
|
|
const std::string VideoSegmenter::SEGMENT_TIME = "00:10";
|
|
|
const std::string VideoSegmenter::TMP_OUTPUT_PATH = "../SegmentationFiles";
|
|
|
|
|
|
class FastReader {
|
|
|
public:
|
|
|
static std::vector<std::vector<uchar>> readVideoFrames(const std::string& videoPath, int skipFrame=0) {
|
|
|
cv::VideoCapture cap(videoPath);
|
|
|
std::vector<std::vector<uchar>> frames;
|
|
|
int count = 0;
|
|
|
while (true) {
|
|
|
++count;
|
|
|
cv::Mat frame;
|
|
|
cap >> frame;
|
|
|
if (frame.empty()) {
|
|
|
break;
|
|
|
}
|
|
|
std::cout << skipFrame << "####" << count << "###" <<(count % skipFrame) << std::endl;
|
|
|
if ((skipFrame > 0) && ((count % (skipFrame+1)) != 0)) {
|
|
|
continue;
|
|
|
}
|
|
|
std::vector<uchar> encodedFrame;
|
|
|
cv::imencode(".jpg", frame, encodedFrame);
|
|
|
frames.push_back(encodedFrame);
|
|
|
// 这里可以添加额外的图像处理操作，例如缩放、灰度转换等
|
|
|
}
|
|
|
|
|
|
return frames;
|
|
|
}
|
|
|
|
|
|
static std::vector<std::vector<uchar>> read(const std::string& videoPath, int skipFrame=0) {
|
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
std::string folderPath = VideoSegmenter::segmentVideo(videoPath);
|
|
|
|
|
|
std::vector<std::string> videoFiles;
|
|
|
// for (const auto& entry : fs::directory_iterator(folderPath)) {
|
|
|
// if (entry.path().extension() == ".mp4") {
|
|
|
// videoFiles.push_back(entry.path().string());
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
DIR *dir;
|
|
|
struct dirent *ent;
|
|
|
|
|
|
if ((dir = opendir(folderPath.c_str())) != nullptr) {
|
|
|
while ((ent = readdir(dir)) != nullptr) {
|
|
|
std::string filePath = folderPath + "/" + ent->d_name;
|
|
|
size_t pos = filePath.find_last_of('.');
|
|
|
|
|
|
if (pos != std::string::npos && filePath.substr(pos) == ".mp4") {
|
|
|
videoFiles.push_back(filePath);
|
|
|
}
|
|
|
}
|
|
|
closedir(dir);
|
|
|
} else {
|
|
|
std::cerr << "Error opening directory" << std::endl;
|
|
|
}
|
|
|
|
|
|
|
|
|
std::sort(videoFiles.begin(), videoFiles.end());
|
|
|
|
|
|
std::vector<std::vector<std::vector<uchar>>> caches(videoFiles.size());
|
|
|
|
|
|
std::vector<std::thread> threads;
|
|
|
|
|
|
for (size_t idx = 0; idx < videoFiles.size(); ++idx) {
|
|
|
threads.emplace_back([&, idx]() {
|
|
|
caches[idx] = readVideoFrames(videoFiles[idx], skipFrame);
|
|
|
});
|
|
|
}
|
|
|
|
|
|
for (auto& thread : threads) {
|
|
|
thread.join();
|
|
|
}
|
|
|
|
|
|
// 将缓存中的帧按照文件顺序拼接成一个完整的vector
|
|
|
std::vector<std::vector<uchar>> framesList;
|
|
|
for (const auto& cache : caches) {
|
|
|
std::cout << cache.size() << std::endl;
|
|
|
for (const auto& frame : cache) {
|
|
|
framesList.push_back(frame);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
std::cout << framesList.size() << std::endl;
|
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
|
std::cout << "Reading " << videoFiles.size() << " video files took " << std::chrono::duration_cast<std::chrono::seconds>(end - start).count() << " seconds." << std::endl;
|
|
|
|
|
|
return framesList;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
// yolov8
|
|
|
void PredictYolo(int thread_id, fastdeploy::vision::detection::YOLOv8* model, std::vector<uchar>* videos, size_t start, size_t end) {
|
|
|
for (size_t i = start; i < end; ++i) {
|
|
|
auto im = cv::imdecode((videos[i]), cv::IMREAD_UNCHANGED);
|
|
|
fastdeploy::vision::DetectionResult res;
|
|
|
auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
if (!model->Predict(im, &res)) {
|
|
|
std::cerr << "Failed to predict." << std::endl;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
bool found = false;
|
|
|
for (size_t i = 0; i < res.label_ids.size(); ++i) {
|
|
|
if (res.label_ids[i] == 0 || res.label_ids[i] == 1) {
|
|
|
found = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (found) {
|
|
|
{
|
|
|
std::lock_guard<std::mutex> lock(resultMutex);
|
|
|
hasCarOrPerson = true;
|
|
|
}
|
|
|
resultCondition.notify_all(); // 通知其他线程结束
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
std::cout << i << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
}
|
|
|
// auto im = cv::imread("ILSVRC2012_val_00000010.jpeg");
|
|
|
|
|
|
// fastdeploy::vision::DetectionResult res;
|
|
|
// if (!model->Predict(im, &res)) {
|
|
|
// std::cerr << "Failed to predict." << std::endl;
|
|
|
// return;
|
|
|
// }
|
|
|
// std::cout << res.Str() << std::endl;
|
|
|
// auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
|
|
|
// // 获取时间戳
|
|
|
// auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_time.time_since_epoch()).count();
|
|
|
|
|
|
// // 打印时间戳
|
|
|
// std::cout << "程序开始时间戳: " << timestamp << " 毫秒" << std::endl;
|
|
|
// for (auto const &image_file : images) {
|
|
|
// std::cout << image_file << std::endl;
|
|
|
// // auto im = cv::imread(image_file);
|
|
|
|
|
|
// fastdeploy::vision::DetectionResult res;
|
|
|
// auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
// if (!model->Predict(im, &res)) {
|
|
|
// std::cerr << "Failed to predict." << std::endl;
|
|
|
// return;
|
|
|
// }
|
|
|
// auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
// auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
// std::cout << "&&&&& " << res.label_ids[0] << std::endl;
|
|
|
// std::cout << "花费: " << duration.count() << " 毫秒" << std::endl;
|
|
|
// // print res
|
|
|
// std::cout << "Thread Id: " << thread_id << std::endl;
|
|
|
// std::cout << res.Str() << std::endl;
|
|
|
// auto vis_im = fastdeploy::vision::VisDetection(im, res);
|
|
|
// cv::imwrite("vis_result.jpg", vis_im);
|
|
|
// std::cout << "Visualized result saved in ./vis_result.jpg" << std::endl;
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
|
|
|
class FrameChangeDetectorV1 {
|
|
|
public:
|
|
|
FrameChangeDetectorV1(int threshold = 10) {
|
|
|
detector = cv::FastFeatureDetector::create();
|
|
|
detector->setThreshold(threshold);
|
|
|
}
|
|
|
|
|
|
std::tuple<double, double> detectDiff(const cv::Mat& currGray, const cv::Mat& prevGray) {
|
|
|
std::vector<cv::KeyPoint> kpPrevPoints;
|
|
|
detector->detect(prevGray, kpPrevPoints);
|
|
|
|
|
|
std::vector<cv::Point2f> prevPoints;
|
|
|
for (const auto& kp : kpPrevPoints) {
|
|
|
prevPoints.emplace_back(kp.pt);
|
|
|
}
|
|
|
|
|
|
if (prevPoints.empty()) {
|
|
|
return std::make_tuple(0.0, 0.0);
|
|
|
}
|
|
|
|
|
|
std::vector<cv::Point2f> currPoints;
|
|
|
std::vector<uchar> status;
|
|
|
std::vector<float> err;
|
|
|
cv::calcOpticalFlowPyrLK(
|
|
|
prevGray, currGray, prevPoints, currPoints, status, err,
|
|
|
cv::Size(15, 15), 2,
|
|
|
cv::TermCriteria(cv::TermCriteria::EPS | cv::TermCriteria::COUNT, 3, 0.01)
|
|
|
);
|
|
|
|
|
|
int count = 0;
|
|
|
double avgFlowX = 0.0;
|
|
|
double avgFlowY = 0.0;
|
|
|
|
|
|
for (size_t i = 0; i < currPoints.size(); ++i) {
|
|
|
if (status[i] == 1) {
|
|
|
double dx = currPoints[i].x - prevPoints[i].x;
|
|
|
double dy = currPoints[i].y - prevPoints[i].y;
|
|
|
avgFlowX += dx;
|
|
|
avgFlowY += dy;
|
|
|
count++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
avgFlowX /= count;
|
|
|
avgFlowY /= count;
|
|
|
|
|
|
return std::make_tuple(avgFlowX, avgFlowY);
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
cv::Ptr<cv::FastFeatureDetector> detector;
|
|
|
};
|
|
|
|
|
|
void processStill(int thread_id, FrameChangeDetectorV1* frameChangeDetector, std::vector<uchar>* videos, size_t start, size_t end, int& belowThresholdCount, double diffThreshold) {
|
|
|
for (size_t i = start; i < end; ++i) {
|
|
|
if (i == 0) {
|
|
|
continue;
|
|
|
}
|
|
|
auto preIm = cv::imdecode((videos[i]), cv::IMREAD_UNCHANGED);
|
|
|
auto currIm = cv::imdecode((videos[i-1]), cv::IMREAD_UNCHANGED);
|
|
|
auto result = frameChangeDetector->detectDiff(currIm, preIm);
|
|
|
double avgFlowX = std::get<0>(result);
|
|
|
double avgFlowY = std::get<1>(result);
|
|
|
double avgFlow = std::abs((avgFlowX + avgFlowY) / 2.0);
|
|
|
if (avgFlow < diffThreshold) {
|
|
|
belowThresholdCount++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// int add(int i, int j)
|
|
|
// {
|
|
|
// return i + j;
|
|
|
// }
|
|
|
|
|
|
// PYBIND11_MODULE(example, m)
|
|
|
// {
|
|
|
// // 可选，说明这个模块是做什么的
|
|
|
// m.doc() = "pybind11 example plugin";
|
|
|
// //def("给python调用方法名"， &实际操作的函数， "函数功能说明"，默认参数). 其中函数功能说明为可选
|
|
|
// m.def("add", &add, "A function which adds two numbers", py::arg("i")=1, py::arg("j")=2);
|
|
|
// }
|
|
|
|
|
|
int main(int argc, char **argv) {
|
|
|
double value_3 = std::stod(argv[3]);
|
|
|
double value_4 = std::stod(argv[4]);
|
|
|
auto start_time = std::chrono::high_resolution_clock::now();
|
|
|
int skipFrame = 10;
|
|
|
auto videos = FastReader::read(argv[1], skipFrame);
|
|
|
bool isStill = true;
|
|
|
|
|
|
int belowThresholdCount = 1;
|
|
|
std::vector<std::thread> stillThreads;
|
|
|
int stillThreadNum = 10;
|
|
|
// double diffThreshold=0.01;
|
|
|
// double countThreshold=0.9;
|
|
|
double diffThreshold=value_3;
|
|
|
double countThreshold=value_4;
|
|
|
FrameChangeDetectorV1 frameChangeDetector;
|
|
|
const size_t stillElementsPerThread = videos.size() / stillThreadNum;
|
|
|
for (size_t i = 0; i < stillThreadNum; ++i) {
|
|
|
size_t start = i * stillElementsPerThread;
|
|
|
size_t end = (i == stillThreadNum - 1) ? videos.size() : (i + 1) * stillElementsPerThread;
|
|
|
stillThreads.emplace_back(processStill, i, &frameChangeDetector, videos.data(), start, end, std::ref(belowThresholdCount), diffThreshold);
|
|
|
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < stillThreadNum; ++i) {
|
|
|
stillThreads[i].join();
|
|
|
}
|
|
|
|
|
|
double stillRatio = static_cast<double>(belowThresholdCount) / static_cast<double>(videos.size());
|
|
|
std::cout << "结果: " << stillRatio << std::endl;
|
|
|
if (stillRatio < countThreshold) {
|
|
|
isStill = false;
|
|
|
std::vector<std::thread> threads;
|
|
|
int numThreads = 4;
|
|
|
auto option1 = fastdeploy::RuntimeOption();
|
|
|
option1.UseGpu();
|
|
|
option1.UseTrtBackend();
|
|
|
option1.SetTrtInputShape("images", {1, 3, 640, 640});
|
|
|
option1.trt_option.serialize_file = std::string(argv[2])+"tmp2.trt";
|
|
|
option1.trt_option.enable_fp16 = true;
|
|
|
auto model1 = fastdeploy::vision::detection::YOLOv8(std::string(argv[2])+"yolov8s.onnx", "", option1);
|
|
|
if (!model1.Initialized()) {
|
|
|
std::cerr << "Failed to initialize." << std::endl;
|
|
|
return -1;
|
|
|
}
|
|
|
std::vector<decltype(model1.Clone())> models;
|
|
|
for (int i = 0; i < numThreads; ++i) {
|
|
|
models.emplace_back(std::move(model1.Clone()));
|
|
|
}
|
|
|
|
|
|
const size_t elementsPerThread = videos.size() / numThreads;
|
|
|
for (size_t i = 0; i < numThreads; ++i) {
|
|
|
size_t start = i * elementsPerThread;
|
|
|
size_t end = (i == numThreads - 1) ? videos.size() : (i + 1) * elementsPerThread;
|
|
|
|
|
|
std::cerr << start << end << std::endl;
|
|
|
threads.emplace_back(PredictYolo, i, models[i].get(), videos.data(), start, end);
|
|
|
|
|
|
}
|
|
|
for (int i = 0; i < numThreads; ++i) {
|
|
|
threads[i].join();
|
|
|
}
|
|
|
}
|
|
|
auto end_time = std::chrono::high_resolution_clock::now();
|
|
|
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
|
|
|
std::cout << "花费: " << duration.count() << " 毫秒" << hasCarOrPerson << std::endl;
|
|
|
|
|
|
if (isStill) {
|
|
|
std::cout << "code108" << std::endl;
|
|
|
} else{
|
|
|
if (hasCarOrPerson) {
|
|
|
std::cout << "code200" << std::endl;
|
|
|
} else{
|
|
|
std::cout << "code107" << std::endl;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
} |