Попытка просмотреть запись на моем Jetson и определить скорость движущихся транспортных средств. Иметь код работать с ви ⇐ C++

[Anonymous]

Ниже приведен код CUDA, работающий в VSCODE на моем Jetson Orin Nano. Код ошибки содержится в многострочном комментарии в самом нижней части тела. Попытка использовать живые видеозаписи для определения скорости движущихся транспортных средств. Чтобы имитировать это, я хочу сыграть видео о дороге на моем экране и снимке экрана оттуда. У меня есть код, работающий для предварительно записанных видео, и я могу получить довольно точные измерения скорости, но по какой -то причине я не могу получить работу по записи экрана < /p>
#include
#include
#include
#include
#include
#include
#include

// Constants for speed detection and transformation
const float MIN_SPEED_THRESHOLD = 0.0; // km/h
const float MAX_SPEED_THRESHOLD = 1000.0; // km/h
const int TRACE_LENGTH = 30; // Equivalent to 1 second at 30 FPS

// Original constants
const float INPUT_WIDTH = 640.0;
const float INPUT_HEIGHT = 640.0;
const float SCORE_THRESHOLD = 0.2;
const float NMS_THRESHOLD = 0.4;
const float CONFIDENCE_THRESHOLD = 0.2;

// Capture mode enum
enum CaptureMode {
VIDEO_FILE,
SCREEN_CAPTURE,
CSI_CAMERA
};

// Color definitions
const std::vector colors = {
cv::Scalar(255, 255, 0),
};

// NVIDIA Screen Capture Method for Jetson
cv::VideoCapture setupNVIDIAScreenCapture() {
std::string pipeline =
"ximagesrc display-name=:0.0 use-damage=0 ! "
"videoconvert ! "
"nvvidconv ! "
"video/x-raw(memory:NVMM), width=1920, height=1080 ! "
"nvvidconv ! "
"videoconvert ! "
"appsink";

return cv::VideoCapture(pipeline, cv::CAP_GSTREAMER);
}

// Additional CUDA-accelerated preprocessing function
cv::Mat processCUDAFrame(const cv::Mat& inputFrame) {
cv::cuda::GpuMat gpuFrame;
gpuFrame.upload(inputFrame);

cv::Mat processedFrame;
gpuFrame.download(processedFrame);

return processedFrame;
}

// Helper functions for measurement region points
void saveMeasurementPoints(const std::vector& points, const std::string& filename) {
std::ofstream file(filename);
for (const auto& point : points) {
file y) {
points.emplace_back(x, y);
}
return points;
}

bool isInMeasurementRegion(const cv::Point2f& point, const std::vector& region) {
return cv::pointPolygonTest(region, point, false) >= 0;
}

std::vector getMeasurementRegionPoints(const cv::Mat& first_frame) {
std::vector points;
cv::Mat frame_copy = first_frame.clone();

std::cout size() > 1) {
cv::line(*img, points->at(points->size()-2), points->at(points->size()-1),
cv::Scalar(0, 255, 0), 2);
}
if (points->size() == 4) {
cv::line(*img, points->at(3), points->at(0),
cv::Scalar(0, 255, 0), 2);
}
}
};

auto callback_data = std::make_pair(&points, &frame_copy);
cv::namedWindow("Select Region");
cv::setMouseCallback("Select Region", mouseCallback, &callback_data);

while (true) {
cv::imshow("Select Region", frame_copy);
char key = cv::waitKey(1);
if (key == 'q' || points.size() >= 4) {
break;
}
}

cv::destroyWindow("Select Region");
return points;
}
struct Detection {
int class_id;
float confidence;
cv::Rect box;
};

class WorldMapper {
public:
WorldMapper() : M(cv::Mat()) {}

void find_perspective_transform(const std::vector& image_pts, const std::vector& world_pts) {
// Convert points to the format needed for perspective transform
cv::Mat image_pts_mat = cv::Mat(image_pts).reshape(1);
cv::Mat world_pts_mat = cv::Mat(world_pts).reshape(1);

// Calculate the perspective transform matrix
M = cv::getPerspectiveTransform(image_pts_mat, world_pts_mat);
}

std::vector transformPoints(const std::vector& points) const {
if (M.empty()) {
throw std::runtime_error("Perspective transform not estimated");
}

std::vector transformed_points;
cv::perspectiveTransform(points, transformed_points, M);
return transformed_points;
}

const cv::Mat& getTransformMatrix() const { return M; }

private:
cv::Mat M;
};

class SpeedEstimator {
public:
SpeedEstimator(const WorldMapper& mapper, float fps)
: mapper(mapper), fps(fps), mps_to_kph(3.6f) {}

float calculateSpeed(const std::vector& image_trace,
const cv::Mat& frame,
const std::vector& measurement_region) {
// Only use points within measurement region
std::vector filtered_trace;
for (const auto& point : image_trace) {
if (isInMeasurementRegion(point, measurement_region)) {
filtered_trace.push_back(point);
}
}

if (filtered_trace.size() < 2) return 0.0f;

// Transform to world coordinates
std::vector world_trace = mapper.transformPoints(filtered_trace);

// Calculate speeds between consecutive points
std::vector speeds;
for (size_t i = 1; i < world_trace.size(); ++i) {
float dx = world_trace.x - world_trace[i-1].x;
float dy = world_trace.y - world_trace[i-1].y;

float displacement = std::sqrt(dx*dx + dy*dy);
float speed = displacement * fps * mps_to_kph;
speeds.push_back(speed);
}

if (speeds.empty()) return 0.0f;

// Use median speed
std::sort(speeds.begin(), speeds.end());
float median_speed = speeds[speeds.size() / 2];

return std::max(MIN_SPEED_THRESHOLD,
std::min(median_speed, MAX_SPEED_THRESHOLD));
}

private:
const WorldMapper& mapper;
float fps;
float mps_to_kph;
};

struct VehicleTrack {
int id;
cv::Rect box;
std::chrono::time_point last_seen;
float speed;
int class_id;
std::vector trace;

VehicleTrack(int id, const cv::Rect& box, int class_id)
: id(id), box(box), speed(0.0f), class_id(class_id) {
last_seen = std::chrono::high_resolution_clock::now();
trace.reserve(TRACE_LENGTH);
}

void updatePosition(const cv::Rect& new_box) {
box = new_box;
last_seen = std::chrono::high_resolution_clock::now();

// Add center bottom point to trace
cv::Point2f pos(box.x + box.width/2.0f, box.y + box.height);
trace.push_back(pos);

if (trace.size() > TRACE_LENGTH) {
trace.erase(trace.begin());
}
}
};

// Global variables
std::vector active_tracks;
int next_vehicle_id = 0;

std::vector load_class_list() {
std::vector class_list;
std::ifstream ifs("classes.txt");
std::string line;
while (getline(ifs, line)) {
class_list.push_back(line);
}
return class_list;
}
void load_net(cv::dnn::Net &net, bool is_cuda) {
auto result = cv::dnn::readNet("yolov5s.onnx");
if (is_cuda) {
std::cout SCORE_THRESHOLD) {
// Only process vehicles (car, truck, bus)
if (className[class_id.x] == "car" ||
className[class_id.x] == "truck" ||
className[class_id.x] == "bus") {

float x = data[0];
float y = data[1];
float w = data[2];
float h = data[3];
int left = int((x - 0.5 * w) * x_factor);
int top = int((y - 0.5 * h) * y_factor);
int width = int(w * x_factor);
int height = int(h * y_factor);

// Check if center bottom point is in measurement region
cv::Point2f center(left + width/2.0f, top + height);
if (isInMeasurementRegion(center, measurement_region)) {
confidences.push_back(confidence);
class_ids.push_back(class_id.x);
boxes.push_back(cv::Rect(left, top, width, height));
}
}
}
}
data += 85;
}

std::vector nms_result;
cv::dnn::NMSBoxes(boxes, confidences, SCORE_THRESHOLD, NMS_THRESHOLD, nms_result);
for (int i = 0; i < nms_result.size(); i++) {
int idx = nms_result;
Detection result;
result.class_id = class_ids[idx];
result.confidence = confidences[idx];
result.box = boxes[idx];
output.push_back(result);
}
}
int main(int argc, char **argv) {
// Select capture mode
CaptureMode capture_mode = SCREEN_CAPTURE;

std::vector class_list = load_class_list();

cv::Mat frame;
cv::VideoCapture capture;

// Verbose mode selection output
switch(capture_mode) {
case VIDEO_FILE:
std::cout

Подробнее здесь: https://stackoverflow.com/questions/796 ... g-vehicles