int display(Mat im, CMT & cmt)
{
//Visualize the output
//It is ok to draw on im itself, as CMT only uses the grayscale image
for(size_t i = 0; i < cmt.points_active.size(); i++)
{
circle(im, cmt.points_active[i], 2, Scalar(0, 255, 0));
}
Scalar color;
if (cmt.confidence < 0.3) {
color = Scalar(0, 0, 255);
} else if (cmt.confidence < 0.4) {
color = Scalar(0, 255, 255);
} else {
color = Scalar(255, 0, 0);
}
Point2f vertices[4];
cmt.bb_rot.points(vertices);
for (int i = 0; i < 4; i++)
{
line(im, vertices[i], vertices[(i+1)%4], color);
}
imshow(WIN_NAME, im);
return waitKey(5);
}
int display(Mat im, CMT & cmt)
{
//Visualize the output
//It is ok to draw on im itself, as CMT only uses the grayscale image
for(size_t i = 0; i < cmt.points_active.size(); i++)
{
circle(im, cmt.points_active[i], 2, Scalar(255,0,0));
}
Point2f vertices[4];
cmt.bb_rot.points(vertices);
for (int i = 0; i < 4; i++)
{
line(im, vertices[i], vertices[(i+1)%4], Scalar(255,0,0));
}
imshow(WIN_NAME, im);
return waitKey(CV_UPDATE_TIME);
}
int main(int argc, char **argv)
{
//Create a CMT object
Config config("FAST", "BRISK","RANSAC",0.5);
CMT cmt(config);
//Initialization bounding box
Rect rect;
//Parse args
int challenge_flag = 0;
int loop_flag = 0;
int verbose_flag = 0;
int bbox_flag = 0;
int skip_frames = 0;
int skip_msecs = 0;
int output_flag = 0;
string input_path;
string output_path;
const int detector_cmd = 1000;
const int descriptor_cmd = 1001;
const int bbox_cmd = 1002;
const int no_scale_cmd = 1003;
const int with_rotation_cmd = 1004;
const int skip_cmd = 1005;
const int skip_msecs_cmd = 1006;
const int output_file_cmd = 1007;
struct option longopts[] =
{
//No-argument options
{"challenge", no_argument, &challenge_flag, 1},
{"loop", no_argument, &loop_flag, 1},
{"verbose", no_argument, &verbose_flag, 1},
{"no-scale", no_argument, 0, no_scale_cmd},
{"with-rotation", no_argument, 0, with_rotation_cmd},
//Argument options
{"bbox", required_argument, 0, bbox_cmd},
{"detector", required_argument, 0, detector_cmd},
{"descriptor", required_argument, 0, descriptor_cmd},
{"output-file", required_argument, 0, output_file_cmd},
{"skip", required_argument, 0, skip_cmd},
{"skip-msecs", required_argument, 0, skip_msecs_cmd},
{0, 0, 0, 0}
};
int index = 0;
int c;
while((c = getopt_long(argc, argv, "v", longopts, &index)) != -1)
{
switch (c)
{
case 'v':
verbose_flag = true;
break;
case bbox_cmd:
{
//TODO: The following also accepts strings of the form %f,%f,%f,%fxyz...
string bbox_format = "%f,%f,%f,%f";
float x,y,w,h;
int ret = sscanf(optarg, bbox_format.c_str(), &x, &y, &w, &h);
if (ret != 4)
{
cerr << "bounding box must be given in format " << bbox_format << endl;
return 1;
}
bbox_flag = 1;
rect = Rect(x,y,w,h);
}
break;
case detector_cmd:
cmt.str_detector = optarg;
break;
case descriptor_cmd:
cmt.str_descriptor = optarg;
break;
case output_file_cmd:
output_path = optarg;
output_flag = 1;
break;
case skip_cmd:
{
int ret = sscanf(optarg, "%d", &skip_frames);
if (ret != 1)
{
skip_frames = 0;
}
}
break;
case skip_msecs_cmd:
{
int ret = sscanf(optarg, "%d", &skip_msecs);
if (ret != 1)
{
skip_msecs = 0;
}
}
break;
case no_scale_cmd:
cmt.consensus.estimate_scale = false;
break;
case with_rotation_cmd:
cmt.consensus.estimate_rotation = true;
break;
case '?':
return 1;
}
}
// Can only skip frames or milliseconds, not both.
if (skip_frames > 0 && skip_msecs > 0)
{
cerr << "You can only skip frames, or milliseconds, not both." << endl;
return 1;
}
//One argument remains
if (optind == argc - 1)
{
input_path = argv[optind];
}
else if (optind < argc - 1)
{
cerr << "Only one argument is allowed." << endl;
return 1;
}
//Set up logging
FILELog::ReportingLevel() = verbose_flag ? logDEBUG : logINFO;
Output2FILE::Stream() = stdout; //Log to stdout
//Challenge mode
if (challenge_flag)
{
//Read list of images
ifstream im_file("images.txt");
vector<string> files;
string line;
while(getline(im_file, line ))
{
files.push_back(line);
}
//Read region
ifstream region_file("region.txt");
vector<float> coords = getNextLineAndSplitIntoFloats(region_file);
if (coords.size() == 4) {
rect = Rect(coords[0], coords[1], coords[2], coords[3]);
}
else if (coords.size() == 8)
{
//Split into x and y coordinates
vector<float> xcoords;
vector<float> ycoords;
for (size_t i = 0; i < coords.size(); i++)
{
if (i % 2 == 0) xcoords.push_back(coords[i]);
else ycoords.push_back(coords[i]);
}
float xmin = *min_element(xcoords.begin(), xcoords.end());
float xmax = *max_element(xcoords.begin(), xcoords.end());
float ymin = *min_element(ycoords.begin(), ycoords.end());
float ymax = *max_element(ycoords.begin(), ycoords.end());
rect = Rect(xmin, ymin, xmax-xmin, ymax-ymin);
cout << "Found bounding box" << xmin << " " << ymin << " " << xmax-xmin << " " << ymax-ymin << endl;
}
else {
cerr << "Invalid Bounding box format" << endl;
return 0;
}
//Read first image
Mat im0 = imread(files[0]);
Mat im0_gray;
cvtColor(im0, im0_gray, CV_BGR2GRAY);
//Initialize cmt
cmt.initialize(im0_gray, rect);
//Write init region to output file
ofstream output_file("output.txt");
output_file << rect.x << ',' << rect.y << ',' << rect.width << ',' << rect.height << std::endl;
//Process images, write output to file
for (size_t i = 1; i < files.size(); i++)
{
FILE_LOG(logINFO) << "Processing frame " << i << "/" << files.size();
Mat im = imread(files[i]);
Mat im_gray;
cvtColor(im, im_gray, CV_BGR2GRAY);
cmt.processFrame(im_gray);
if (verbose_flag)
{
display(im, cmt);
}
rect = cmt.bb_rot.boundingRect();
output_file << rect.x << ',' << rect.y << ',' << rect.width << ',' << rect.height << std::endl;
}
output_file.close();
return 0;
}
//Normal mode
//Create window
namedWindow(WIN_NAME);
VideoCapture cap;
bool show_preview = true;
//If no input was specified
if (input_path.length() == 0)
{
cap.open(0); //Open default camera device
}
//Else open the video specified by input_path
else
{
cap.open(input_path);
if (skip_frames > 0)
{
cap.set(CV_CAP_PROP_POS_FRAMES, skip_frames);
}
if (skip_msecs > 0)
{
cap.set(CV_CAP_PROP_POS_MSEC, skip_msecs);
// Now which frame are we on?
skip_frames = (int) cap.get(CV_CAP_PROP_POS_FRAMES);
}
show_preview = false;
}
//If it doesn't work, stop
if(!cap.isOpened())
{
cerr << "Unable to open video capture." << endl;
return -1;
}
//Show preview until key is pressed
while (show_preview)
{
Mat preview;
cap >> preview;
screenLog(preview, "Press a key to start selecting an object.");
imshow(WIN_NAME, preview);
char k = waitKey(10);
if (k != -1) {
show_preview = false;
}
}
//Get initial image
Mat im0;
cap >> im0;
//If no bounding was specified, get it from user
if (!bbox_flag)
{
rect = getRect(im0, WIN_NAME);
}
FILE_LOG(logINFO) << "Using " << rect.x << "," << rect.y << "," << rect.width << "," << rect.height
<< " as initial bounding box.";
//Convert im0 to grayscale
Mat im0_gray;
if (im0.channels() > 1) {
cvtColor(im0, im0_gray, CV_BGR2GRAY);
} else {
im0_gray = im0;
}
//Initialize CMT
cmt.initialize(im0_gray, rect);
int frame = skip_frames;
//Open output file.
ofstream output_file;
if (output_flag)
{
int msecs = (int) cap.get(CV_CAP_PROP_POS_MSEC);
output_file.open(output_path.c_str());
output_file << OUT_FILE_COL_HEADERS << endl;
output_file << frame << "," << msecs << ",";
output_file << cmt.points_active.size() << ",";
output_file << write_rotated_rect(cmt.bb_rot) << endl;
}
//Main loop
while (true)
{
frame++;
Mat im;
//If loop flag is set, reuse initial image (for debugging purposes)
if (loop_flag) im0.copyTo(im);
else cap >> im; //Else use next image in stream
if (im.empty()) break; //Exit at end of video stream
Mat im_gray;
if (im.channels() > 1) {
cvtColor(im, im_gray, CV_BGR2GRAY);
} else {
im_gray = im;
}
//Let CMT process the frame
cmt.processFrame(im_gray);
//Output.
if (output_flag)
{
int msecs = (int) cap.get(CV_CAP_PROP_POS_MSEC);
output_file << frame << "," << msecs << ",";
output_file << cmt.points_active.size() << ",";
output_file << write_rotated_rect(cmt.bb_rot) << endl;
}
else
{
//TODO: Provide meaningful output
FILE_LOG(logINFO) << "#" << frame << " active: " << cmt.points_active.size();
}
//Display image and then quit if requested.
char key = display(im, cmt);
if(key == 'q') break;
}
//Close output file.
if (output_flag) output_file.close();
return 0;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
cout << "Usage: " << argv[0] << " <raw_file> [frame_id]" << endl;
return 1;
}
ifstream in{argv[1]};
struct stat st;
char *buf{nullptr};
size_t file_size;
size_t i{0};
array<char, 160 * 120 * 2> raw;
vector<Packet> pkts;
vector<uint8_t> ids;
if (stat(argv[1], &st) != 0)
{
cout << "Could not stat " << argv[1] << endl;
return 1;
}
file_size = static_cast<size_t>(st.st_size);
buf = new char[file_size];
in.read(buf, file_size);
if (static_cast<size_t>(in.tellg()) != file_size)
{
cout << "Did not reach EOF" << endl;
cout << "read " << in.tellg() << "/" << file_size << endl;
cout << "file is good: " << static_cast<int>(in.good()) << endl;
return 1;
}
uint8_t id = 0;
while (i < file_size)
{
Packet tmp;
try
{
tmp.parse(reinterpret_cast<uint8_t*>(buf + i), file_size - i);
}
catch (const ParseError &e)
{
cout << "Caught a parsing error - \"" << e.getMessage() << "\"" <<
endl;
break;
}
if (id != tmp.getID())
{
id = tmp.getID();
cout << "id: " << static_cast<int>(tmp.getID()) << " ";
cout << "len: " << static_cast<int>(tmp.getLength()) << endl;
}
pkts.push_back(tmp);
i += tmp.getRawLength();
}
cout << "Parsed " << pkts.size() << " packets" << endl;
for (int k = 2; k < argc; k++)
{
ids.push_back(static_cast<uint8_t>(std::stoi(string{argv[k]})));
}
if (ids.size() == 0)
{
return 0;
}
cout << "examining IDs ";
for (const auto &id : ids)
{
cout << static_cast<int>(id) << " ";
}
cout << endl;
for (const auto &id : ids)
{
vector<uint8_t> raw;
PacketType type;
cout << "examining " << static_cast<int>(id) << endl;
for (const auto &pkt : pkts)
{
if (pkt.getID() == id)
{
size_t new_length = pkt.getOffset() +
static_cast<size_t>(pkt.getLength());
type = pkt.getType();
if (new_length > raw.size())
{
raw.resize(new_length, 0);
}
for (size_t k = 0; k < pkt.getLength(); k++)
{
raw[pkt.getOffset() + k] = pkt.getData()[k];
}
}
}
cout << "type: " << type << endl;
cout << hex;
for (size_t j = 0; j < 512; j++)
{
if (j > 0 && (j % 32) == 0)
{
cout << endl;
}
cout << (static_cast<unsigned int>(raw[j]) & 0xFF) << " ";
}
cout << endl;
Mat img{Size(160, 120), CV_8UC3, raw.data()};
Mat dst;
//cvtColor(img, dst, CV_YUV2GRAY_UYVY);
//cvtColor(img, dst, CV_YUV2GRAY_YUY2);
//cvtColor(img, dst, CV_YUV2BGR_UYVY);
//cvtColor(img, dst, CV_YUV2BGRA_UYVY);
//cvtColor(img, dst, CV_YUV2BGR_YUY2);
//cvtColor(img, dst, CV_YUV2BGR_YVYU);
//cvtColor(img, dst, CV_YUV2BGRA_YUY2);
//cvtColor(img, dst, CV_YUV2BGRA_YVYU);
//cvtColor(img, dst, CV_YUV2GRAY_NV12);
//cvtColor(img, dst, CV_YUV2BGR_NV12);
cvtColor(img, dst, CV_YCrCb2BGR);
imshow("Police Video", dst);
waitKey(0);
ofstream out_jpeg{"out.jpg", ofstream::binary};
for (size_t j = 0; j < raw.size(); j++)
{
if (raw[j] == 0xFF && raw[j + 1] == 0xD8)
{
cout << "hit the start" << endl;
out_jpeg.write(reinterpret_cast<char *>(raw.data() + j), 2);
j++;
}
else if (raw[j] == 0xFF && raw[j + 1] == 0xDB)
{
cout << "hit the start 2" << endl;
out_jpeg.write(reinterpret_cast<char *>(raw.data() + j), 2);
j++;
}
else if (raw[j] == 0xFF && raw[j + 1] == 0xC0)
{
cout << "hit the start 3" << endl;
out_jpeg.write(reinterpret_cast<char *>(raw.data() + j), 2);
j++;
}
else if (raw[j] == 0xFF && raw[j + 1] == 0xD9)
{
cout << "hit the end" << endl;
out_jpeg.write(reinterpret_cast<char *>(raw.data() + j), 2);
return 0;
}
else
{
out_jpeg.write(reinterpret_cast<char *>(raw.data() + j), 1);
}
}
}
return 0;
}
