mirror/darknet
1
0
Fork 0
mirror of https://github.com/pjreddie/darknet.git synced 2023-08-10 21:13:14 +03:00
Code Issues Projects Releases Wiki Activity

Another part of OpenCV C-functions replaced by CPP-functions

Browse Source
This commit is contained in:
AlexeyAB
2019-04-05 21:21:13 +03:00
parent 33b854a631
commit 4e47429d82
4 changed files with 91 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/detector.c
View File

@ -209,7 +209,8 @@ void train_detector(char *datacfg, char *cfgfile, char *weightfile, int *gpus, i
float loss = 0;
#ifdef GPU
if (ngpus == 1) {
loss = train_network_waitkey(net, train, 1);
int wait_key = (dont_show) ? 0 : 1;
loss = train_network_waitkey(net, train, wait_key);
}
else {
loss = train_networks(nets, ngpus, train, 4);

164
src/image_opencv.cpp
View File

@ -214,6 +214,13 @@ cv::Mat ipl_to_mat(IplImage *ipl)
return m;
}
IplImage *mat_to_ipl(cv::Mat mat)
{
IplImage *ipl = new IplImage;
*ipl = mat;
return ipl;
}
Mat image_to_mat(image im)
{
image copy = copy_image(im);
@ -335,13 +342,9 @@ void show_image_cv_ipl(mat_cv *disp, const char *name)
{
if (disp == NULL) return;
char buff[256];
//sprintf(buff, "%s (%d)", name, windows);
sprintf(buff, "%s", name);
cv::namedWindow(buff, WINDOW_NORMAL);
//cvMoveWindow(buff, 100*(windows%10) + 200*(windows/10), 100*(windows%10));
//++windows;
cvShowImage(buff, disp);
//cvReleaseImage(&disp);
}
@ -688,6 +691,23 @@ image get_image_from_stream_letterbox(cap_cv *cap, int w, int h, int c, mat_cv**
extern int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes);
extern int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);
void save_mat_png(cv::Mat img_src, const char *name)
{
cv::Mat img_rgb;
cv::cvtColor(img_src, img_rgb, CV_RGB2BGR);
stbi_write_png(name, img_rgb.cols, img_rgb.rows, 3, (char *)img_rgb.data, 0);
}
// ----------------------------------------
void save_mat_jpg(cv::Mat img_src, const char *name)
{
cv::Mat img_rgb;
cv::cvtColor(img_src, img_rgb, CV_RGB2BGR);
stbi_write_jpg(name, img_rgb.cols, img_rgb.rows, 3, (char *)img_rgb.data, 80);
}
// ----------------------------------------
void save_cv_png(mat_cv *img_src, const char *name)
{
IplImage* img = (IplImage* )img_src;
@ -841,79 +861,78 @@ mat_cv* draw_train_chart(float max_img_loss, int max_batches, int number_of_line
{
int img_offset = 50;
int draw_size = img_size - img_offset;
IplImage* img = cvCreateImage(cvSize(img_size, img_size), 8, 3);
cvSet(img, CV_RGB(255, 255, 255), 0);
CvPoint pt1, pt2, pt_text;
CvFont font;
cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 1, CV_AA);
cv::Mat *img_ptr = new cv::Mat(img_size, img_size, CV_8UC3, CV_RGB(255, 255, 255));
cv::Mat &img = *img_ptr;
cv::Point pt1, pt2, pt_text;
char char_buff[100];
int i;
// vertical lines
pt1.x = img_offset; pt2.x = img_size, pt_text.x = 10;
for (i = 1; i <= number_of_lines; ++i) {
pt1.y = pt2.y = (float)i * draw_size / number_of_lines;
cvLine(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
cv::line(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
if (i % 10 == 0) {
sprintf(char_buff, "%2.1f", max_img_loss*(number_of_lines - i) / number_of_lines);
pt_text.y = pt1.y + 5;
cvPutText(img, char_buff, pt_text, &font, CV_RGB(0, 0, 0));
cvLine(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
cv::putText(img, char_buff, pt_text, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
cv::line(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
}
}
// horizontal lines
pt1.y = draw_size; pt2.y = 0, pt_text.y = draw_size + 15;
for (i = 0; i <= number_of_lines; ++i) {
pt1.x = pt2.x = img_offset + (float)i * draw_size / number_of_lines;
cvLine(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
cv::line(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
if (i % 10 == 0) {
sprintf(char_buff, "%d", max_batches * i / number_of_lines);
pt_text.x = pt1.x - 20;
cvPutText(img, char_buff, pt_text, &font, CV_RGB(0, 0, 0));
cvLine(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
cv::putText(img, char_buff, pt_text, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
cv::line(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
}
}
cvPutText(img, "Loss", cvPoint(0, 35), &font, CV_RGB(0, 0, 255));
cvPutText(img, "Iteration number", cvPoint(draw_size / 2, img_size - 10), &font, CV_RGB(0, 0, 0));
cv::putText(img, "Loss", cvPoint(0, 35), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
cv::putText(img, "Iteration number", cvPoint(draw_size / 2, img_size - 10), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
char max_batches_buff[100];
sprintf(max_batches_buff, "in cfg max_batches=%d", max_batches);
cvPutText(img, max_batches_buff, cvPoint(draw_size - 195, img_size - 10), &font, CV_RGB(0, 0, 0));
cvPutText(img, "Press 's' to save: chart.png", cvPoint(5, img_size - 10), &font, CV_RGB(0, 0, 0));
cv::putText(img, max_batches_buff, cvPoint(draw_size - 195, img_size - 10), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
cv::putText(img, "Press 's' to save : chart.png", cvPoint(5, img_size - 10), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
if (!dont_show) {
printf(" If error occurs - run training with flag: -dont_show \n");
cvNamedWindow("average loss", CV_WINDOW_NORMAL);
cvMoveWindow("average loss", 0, 0);
cvResizeWindow("average loss", img_size, img_size);
cvShowImage("average loss", img);
cvWaitKey(20);
cv::namedWindow("average loss", CV_WINDOW_NORMAL);
cv::moveWindow("average loss", 0, 0);
cv::resizeWindow("average loss", img_size, img_size);
cv::imshow("average loss", img);
cv::waitKey(20);
}
return (mat_cv*)img;
return (mat_cv*)img_ptr;
}
// ----------------------------------------
void draw_train_loss(mat_cv* img_src, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches,
float precision, int draw_precision, char *accuracy_name, int dont_show, int mjpeg_port)
{
IplImage* img = (IplImage*)img_src;
cv::Mat &img = *(cv::Mat*)img_src;
int img_offset = 50;
int draw_size = img_size - img_offset;
CvFont font;
cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 1, CV_AA);
char char_buff[100];
CvPoint pt1, pt2;
pt1.x = img_offset + draw_size * (float)current_batch / max_batches;
pt1.y = draw_size * (1 - avg_loss / max_img_loss);
if (pt1.y < 0) pt1.y = 1;
cvCircle(img, pt1, 1, CV_RGB(0, 0, 255), CV_FILLED, 8, 0);
cv::circle(img, pt1, 1, CV_RGB(0, 0, 255), CV_FILLED, 8, 0);
// precision
if (draw_precision) {
static float old_precision = 0;
static int iteration_old = 0;
static int text_iteration_old = 0;
if (iteration_old == 0) cvPutText(img, accuracy_name, cvPoint(0, 12), &font, CV_RGB(255, 0, 0));
if (iteration_old == 0)
cv::putText(img, accuracy_name, cvPoint(0, 12), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(255, 0, 0), 1, CV_AA);
cvLine(img,
cv::line(img,
cvPoint(img_offset + draw_size * (float)iteration_old / max_batches, draw_size * (1 - old_precision)),
cvPoint(img_offset + draw_size * (float)current_batch / max_batches, draw_size * (1 - precision)),
CV_RGB(255, 0, 0), 1, 8, 0);
@ -921,13 +940,9 @@ void draw_train_loss(mat_cv* img_src, int img_size, float avg_loss, float max_im
if (((int)(old_precision * 10) != (int)(precision * 10)) || (current_batch - text_iteration_old) >= max_batches / 10) {
text_iteration_old = current_batch;
sprintf(char_buff, "%2.0f%% ", precision * 100);
CvFont font3;
cvInitFont(&font3, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 5, CV_AA);
cvPutText(img, char_buff, cvPoint(pt1.x - 30, draw_size * (1 - precision) + 15), &font3, CV_RGB(255, 255, 255));
cv::putText(img, char_buff, cvPoint(pt1.x - 30, draw_size * (1 - precision) + 15), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(255, 255, 255), 5, CV_AA);
CvFont font2;
cvInitFont(&font2, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 1, CV_AA);
cvPutText(img, char_buff, cvPoint(pt1.x - 30, draw_size * (1 - precision) + 15), &font2, CV_RGB(200, 0, 0));
cv::putText(img, char_buff, cvPoint(pt1.x - 30, draw_size * (1 - precision) + 15), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(200, 0, 0), 1, CV_AA);
}
old_precision = precision;
iteration_old = current_batch;
@ -936,23 +951,23 @@ void draw_train_loss(mat_cv* img_src, int img_size, float avg_loss, float max_im
sprintf(char_buff, "current avg loss = %2.4f iteration = %d", avg_loss, current_batch);
pt1.x = 55, pt1.y = 10;
pt2.x = pt1.x + 460, pt2.y = pt1.y + 20;
cvRectangle(img, pt1, pt2, CV_RGB(255, 255, 255), CV_FILLED, 8, 0);
cv::rectangle(img, pt1, pt2, CV_RGB(255, 255, 255), CV_FILLED, 8, 0);
pt1.y += 15;
cvPutText(img, char_buff, pt1, &font, CV_RGB(0, 0, 0));
cv::putText(img, char_buff, pt1, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(0, 0, 0), 1, CV_AA);
int k = 0;
if (!dont_show) {
cvShowImage("average loss", img);
k = cvWaitKey(20);
cv::imshow("average loss", img);
k = cv::waitKey(20);
}
if (k == 's' || current_batch == (max_batches - 1) || current_batch % 100 == 0) {
save_cv_png((mat_cv *)img, "chart.png");
cvPutText(img, "- Saved", cvPoint(250, img_size - 10), &font, CV_RGB(255, 0, 0));
save_mat_png(img, "chart.png");
cv::putText(img, "- Saved", cvPoint(260, img_size - 10), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(255, 0, 0), 1, CV_AA);
}
else
cvPutText(img, "- Saved", cvPoint(250, img_size - 10), &font, CV_RGB(255, 255, 255));
cv::putText(img, "- Saved", cvPoint(260, img_size - 10), CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, CV_RGB(255, 255, 255), 1, CV_AA);
if (mjpeg_port > 0) send_mjpeg((mat_cv *)img, mjpeg_port, 500000, 100);
if (mjpeg_port > 0) send_mjpeg((mat_cv *)mat_to_ipl(img), mjpeg_port, 500000, 100);
}
// ----------------------------------------
@ -1034,57 +1049,50 @@ image image_data_augmentation(mat_cv* ipl, int w, int h,
// ====================================================================
void show_acnhors(int number_of_boxes, int num_of_clusters, float *rel_width_height_array, model anchors_data, int width, int height)
{
CvMat* labels = cvCreateMat(number_of_boxes, 1, CV_32SC1);
CvMat* points = cvCreateMat(number_of_boxes, 2, CV_32FC1);
CvMat* centers = cvCreateMat(num_of_clusters, 2, CV_32FC1);
cv::Mat labels = cv::Mat(number_of_boxes, 1, CV_32SC1);
cv::Mat points = cv::Mat(number_of_boxes, 2, CV_32FC1);
cv::Mat centers = cv::Mat(num_of_clusters, 2, CV_32FC1);
int i, j;
for (i = 0; i < number_of_boxes; ++i) {
points->data.fl[i * 2] = rel_width_height_array[i * 2];
points->data.fl[i * 2 + 1] = rel_width_height_array[i * 2 + 1];
//cvSet1D(points, i * 2, cvScalar(rel_width_height_array[i * 2], 0, 0, 0));
//cvSet1D(points, i * 2 + 1, cvScalar(rel_width_height_array[i * 2 + 1], 0, 0, 0));
for (int i = 0; i < number_of_boxes; ++i) {
points.at<float>(i, 0) = rel_width_height_array[i * 2];
points.at<float>(i, 1) = rel_width_height_array[i * 2 + 1];
}
for (i = 0; i < num_of_clusters; ++i) {
centers->data.fl[i * 2] = anchors_data.centers.vals[i][0];
centers->data.fl[i * 2 + 1] = anchors_data.centers.vals[i][1];
for (int i = 0; i < num_of_clusters; ++i) {
centers.at<float>(i, 0) = anchors_data.centers.vals[i][0];
centers.at<float>(i, 1) = anchors_data.centers.vals[i][1];
}
for (i = 0; i < number_of_boxes; ++i) {
labels->data.i[i] = anchors_data.assignments[i];
for (int i = 0; i < number_of_boxes; ++i) {
labels.at<int>(i, 0) = anchors_data.assignments[i];
}
size_t img_size = 700;
IplImage* img = cvCreateImage(cvSize(img_size, img_size), 8, 3);
cvZero(img);
for (i = 0; i < number_of_boxes; ++i) {
cv::Mat img = cv::Mat(img_size, img_size, CV_8UC3);
for (int i = 0; i < number_of_boxes; ++i) {
CvPoint pt;
pt.x = points->data.fl[i * 2] * img_size / width;
pt.y = points->data.fl[i * 2 + 1] * img_size / height;
int cluster_idx = labels->data.i[i];
pt.x = points.at<float>(i, 0) * img_size / width;
pt.y = points.at<float>(i, 1) * img_size / height;
int cluster_idx = labels.at<int>(i, 0);
int red_id = (cluster_idx * (uint64_t)123 + 55) % 255;
int green_id = (cluster_idx * (uint64_t)321 + 33) % 255;
int blue_id = (cluster_idx * (uint64_t)11 + 99) % 255;
cvCircle(img, pt, 1, CV_RGB(red_id, green_id, blue_id), CV_FILLED, 8, 0);
cv::circle(img, pt, 1, CV_RGB(red_id, green_id, blue_id), CV_FILLED, 8, 0);
//if(pt.x > img_size || pt.y > img_size) printf("\n pt.x = %d, pt.y = %d \n", pt.x, pt.y);
}
for (j = 0; j < num_of_clusters; ++j) {
for (int j = 0; j < num_of_clusters; ++j) {
CvPoint pt1, pt2;
pt1.x = pt1.y = 0;
pt2.x = centers->data.fl[j * 2] * img_size / width;
pt2.y = centers->data.fl[j * 2 + 1] * img_size / height;
cvRectangle(img, pt1, pt2, CV_RGB(255, 255, 255), 1, 8, 0);
pt2.x = centers.at<float>(j, 0) * img_size / width;
pt2.y = centers.at<float>(j, 1) * img_size / height;
cv::rectangle(img, pt1, pt2, CV_RGB(255, 255, 255), 1, 8, 0);
}
save_cv_png((mat_cv *)img, "cloud.png");
cvShowImage("clusters", img);
cvWaitKey(0);
cvReleaseImage(&img);
cvDestroyAllWindows();
cvReleaseMat(&labels);
cvReleaseMat(&points);
cvReleaseMat(&centers);
save_mat_png(img, "cloud.png");
cv::imshow("clusters", img);
cv::waitKey(0);
cv::destroyAllWindows();
}
} // extern "C"

4
src/network.c
View File

@ -326,7 +326,7 @@ float train_network(network net, data d)
return train_network_waitkey(net, d, 0);
}
float train_network_waitkey(network net, data d, int is_main_thread)
float train_network_waitkey(network net, data d, int wait_key)
{
assert(d.X.rows % net.batch == 0);
int batch = net.batch;
@ -340,7 +340,7 @@ float train_network_waitkey(network net, data d, int is_main_thread)
get_next_batch(d, batch, i*batch, X, y);
float err = train_network_datum(net, X, y);
sum += err;
wait_key_cv(5);
if(wait_key) wait_key_cv(5);
}
free(X);
free(y);

2
src/network.h
View File

@ -116,7 +116,7 @@ void backward_network(network net, network_state state);
void update_network(network net);
float train_network(network net, data d);
float train_network_waitkey(network net, data d, int is_main_thread);
float train_network_waitkey(network net, data d, int wait_key);
float train_network_batch(network net, data d, int n);
float train_network_sgd(network net, data d, int n);
float train_network_datum(network net, float *x, float *y);