void label_classifier(char *datacfg, char *filename, char *weightfile)
{
int i;
network *net = load_network(filename, weightfile, 0);
set_batch_network(net, 1);
srand(time(0));
list *options = read_data_cfg(datacfg);
char *label_list = option_find_str(options, "names", "data/labels.list");
char *test_list = option_find_str(options, "test", "data/train.list");
int classes = option_find_int(options, "classes", 2);
char **labels = get_labels(label_list);
list *plist = get_paths(test_list);
char **paths = (char **)list_to_array(plist);
int m = plist->size;
free_list(plist);
for(i = 0; i < m; ++i){
image im = load_image_color(paths[i], 0, 0);
image resized = resize_min(im, net->w);
image crop = crop_image(resized, (resized.w - net->w)/2, (resized.h - net->h)/2, net->w, net->h);
float *pred = network_predict(net, crop.data);
if(resized.data != im.data) free_image(resized);
free_image(im);
free_image(crop);
int ind = max_index(pred, classes);
printf("%s\n", labels[ind]);
}
}
void draw_label(image a, int r, int c, image label, image prob_label, const float *rgb)
{
float ratio = (float) label.w / label.h;
int h = label.h;
int w = ratio * h;
image rl = resize_image(label, w, h);
if (r - h >= 0) r = r - h;
float ratiop = (float) prob_label.w / prob_label.h;
int hp = prob_label.h;
int wp = ratiop * hp;
image rpl = resize_image(prob_label, wp, hp);
int i, j, k;
for(j = 0; j < h && j + r < a.h; ++j){
for(i = 0; i < w && i + c < a.w; ++i){
for(k = 0; k < label.c; ++k){
float val = get_pixel(rl, i, j, k);
set_pixel(a, i+c+50, j+r, k, rgb[k] * val);
}
}
}
for(j = 0; j < hp && j + r < a.h; ++j){
for(i = 0; i < wp && i + c < a.w; ++i){
for(k = 0; k < prob_label.c; ++k){
float val = get_pixel(rpl, i, j, k);
set_pixel(a, i+c, j+r, k, rgb[k] * val);
}
}
}
free_image(rl);
free_image(rpl);
}
/*
* do prediction
*@param[in]: yoloctx, context
*@param[in]: filename, input picture
*@param[in]: thresh, threshold for probability x confidence level
*@param[out]: predictions, store detected objects
*/
void yoloPredict(context_param_yolo_t *yoloctx, char *filename, float thresh, yoloPredictions *predictions)
{
printf("YOLO predict\n");
int nwidth = yoloctx->_nwidth;
int nheight = yoloctx->_nheight;
int side = yoloctx->_grid.grids;
int classes = yoloctx->_grid.classes;
int bbs = yoloctx->_grid.bbs;
int sqrt = yoloctx->_sqrt;
float nms = yoloctx->_nms;
image im = load_image_color(filename, 0, 0);
image sized = resize_image(im, nwidth, nheight);
resetData(yoloctx);
float *x = sized.data;
float *fpredictions = network_predict(yoloctx->_net, x);
float **probs = yoloctx->_grid.probs;
box *boxes = yoloctx->_grid.boxes;
convertDetections(fpredictions, classes, bbs, sqrt, side, 1, 1, thresh, probs, boxes, 0);
if (nms) do_nms_sort(boxes, probs, side*side*bbs, classes, nms);
convertResults(im.w, im.h, side*side*bbs, thresh, boxes, probs, class_names, 20, predictions);
//free(predictions);
free_image(sized);
free_image(im);
}
void predict_regressor(char *cfgfile, char *weightfile, char *filename)
{
network *net = load_network(cfgfile, weightfile, 0);
set_batch_network(net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, 0, 0);
image sized = letterbox_image(im, net->w, net->h);
float *X = sized.data;
time=clock();
float *predictions = network_predict(net, X);
printf("Predicted: %f\n", predictions[0]);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
free_image(im);
free_image(sized);
if (filename) break;
}
free_network(net);
}
image collapse_images_horz(image *ims, int n)
{
int color = 1;
int border = 1;
int h,w,c;
int size = ims[0].h;
h = size;
w = (ims[0].w + border) * n - border;
c = ims[0].c;
if(c != 3 || !color){
h = (h+border)*c - border;
c = 1;
}
image filters = make_image(w, h, c);
int i,j;
for(i = 0; i < n; ++i){
int w_offset = i*(size+border);
image copy = copy_image(ims[i]);
//normalize_image(copy);
if(c == 3 && color){
embed_image(copy, filters, w_offset, 0);
}
else{
for(j = 0; j < copy.c; ++j){
int h_offset = j*(size+border);
image layer = get_image_layer(copy, j);
embed_image(layer, filters, w_offset, h_offset);
free_image(layer);
}
}
free_image(copy);
}
return filters;
}
void
free_video (video_t *video)
/*
* Video struct destructor:
* Free memory of given 'video' struct.
*
* No return value.
*
* Side effects:
* 'video' struct is discarded.
*/
{
if (video->past)
free_image (video->past);
if (video->future)
free_image (video->future);
if (video->sfuture)
free_image (video->sfuture);
if (video->frame)
free_image (video->frame);
if (video->sframe)
free_image (video->sframe);
if (video->wfa)
free_wfa (video->wfa);
if (video->wfa_past)
free_wfa (video->wfa_past);
if (video->wfa_future)
free_wfa (video->wfa_future);
Free (video);
}
void mkimg(char *cfgfile, char *weightfile, int h, int w, int num, char *prefix)
{
network *net = load_network(cfgfile, weightfile, 0);
image *ims = get_weights(net->layers[0]);
int n = net->layers[0].n;
int z;
for(z = 0; z < num; ++z){
image im = make_image(h, w, 3);
fill_image(im, .5);
int i;
for(i = 0; i < 100; ++i){
image r = copy_image(ims[rand()%n]);
rotate_image_cw(r, rand()%4);
random_distort_image(r, 1, 1.5, 1.5);
int dx = rand()%(w-r.w);
int dy = rand()%(h-r.h);
ghost_image(r, im, dx, dy);
free_image(r);
}
char buff[256];
sprintf(buff, "%s/gen_%d", prefix, z);
save_image(im, buff);
free_image(im);
}
free_network(net);
}
void
free_ship (RACE_DESC *raceDescPtr, BOOLEAN FreeIconData,
BOOLEAN FreeBattleData)
{
if (raceDescPtr->uninit_func != NULL)
(*raceDescPtr->uninit_func) (raceDescPtr);
if (FreeBattleData)
{
DATA_STUFF *shipData = &raceDescPtr->ship_data;
free_image (shipData->special);
free_image (shipData->weapon);
free_image (shipData->ship);
DestroyDrawable (
ReleaseDrawable (shipData->captain_control.background));
DestroyMusic (shipData->victory_ditty);
DestroySound (ReleaseSound (shipData->ship_sounds));
}
if (FreeIconData)
{
SHIP_INFO *shipInfo = &raceDescPtr->ship_info;
DestroyDrawable (ReleaseDrawable (shipInfo->melee_icon));
DestroyDrawable (ReleaseDrawable (shipInfo->icons));
DestroyStringTable (ReleaseStringTable (shipInfo->race_strings));
}
DestroyCodeRes (ReleaseCodeRes (raceDescPtr->CodeRef));
}
void test_detector(char *datacfg, char *cfgfile, char *weightfile, char *filename, float thresh, float hier_thresh)
{
int show_flag = 1;
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", "data/names.list");
char **names = get_labels(name_list);
image **alphabet = load_alphabet();
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
int j;
float nms=.4;
while(1){
if(filename){
strncpy(input, filename, 256);
} else {
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input,0,0);
image sized = resize_image(im, net.w, net.h);
layer l = net.layers[net.n-1];
box *boxes = calloc(l.w*l.h*l.n, sizeof(box));
float **probs = calloc(l.w*l.h*l.n, sizeof(float *));
for(j = 0; j < l.w*l.h*l.n; ++j) probs[j] = calloc(l.classes + 1, sizeof(float *));
float *X = sized.data;
time=clock();
network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
get_region_boxes(l, 1, 1, thresh, probs, boxes, 0, 0, hier_thresh);
if (l.softmax_tree && nms) do_nms_obj(boxes, probs, l.w*l.h*l.n, l.classes, nms);
else if (nms) do_nms_sort(boxes, probs, l.w*l.h*l.n, l.classes, nms);
draw_detections(im, l.w*l.h*l.n, thresh, boxes, probs, names, alphabet, l.classes, show_flag);
save_image(im, "predictions");
show_image(im, "predictions");
free_image(im);
free_image(sized);
free(boxes);
free_ptrs((void **)probs, l.w*l.h*l.n);
#ifdef OPENCV
cvWaitKey(0);
cvDestroyAllWindows();
#endif
if (filename) break;
}
}
void validate_classifier_full(char *datacfg, char *filename, char *weightfile)
{
int i, j;
network net = parse_network_cfg(filename);
set_batch_network(&net, 1);
if(weightfile){
load_weights(&net, weightfile);
}
srand(time(0));
list *options = read_data_cfg(datacfg);
char *label_list = option_find_str(options, "labels", "data/labels.list");
char *valid_list = option_find_str(options, "valid", "data/train.list");
int classes = option_find_int(options, "classes", 2);
int topk = option_find_int(options, "top", 1);
char **labels = get_labels(label_list);
list *plist = get_paths(valid_list);
char **paths = (char **)list_to_array(plist);
int m = plist->size;
free_list(plist);
float avg_acc = 0;
float avg_topk = 0;
int *indexes = calloc(topk, sizeof(int));
int size = net.w;
for(i = 0; i < m; ++i){
int class = -1;
char *path = paths[i];
for(j = 0; j < classes; ++j){
if(strstr(path, labels[j])){
class = j;
break;
}
}
image im = load_image_color(paths[i], 0, 0);
image resized = resize_min(im, size);
resize_network(&net, resized.w, resized.h);
//show_image(im, "orig");
//show_image(crop, "cropped");
//cvWaitKey(0);
float *pred = network_predict(net, resized.data);
if(net.hierarchy) hierarchy_predictions(pred, net.outputs, net.hierarchy, 1, 1);
free_image(im);
free_image(resized);
top_k(pred, classes, topk, indexes);
if(indexes[0] == class) avg_acc += 1;
for(j = 0; j < topk; ++j){
if(indexes[j] == class) avg_topk += 1;
}
printf("%d: top 1: %f, top %d: %f\n", i, avg_acc/(i+1), topk, avg_topk/(i+1));
}
}
void test_lsd(char *cfgfile, char *weightfile, char *filename)
{
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
int i, imlayer = 0;
for (i = 0; i < net.n; ++i) {
if (net.layers[i].out_c == 3) {
imlayer = i;
printf("%d\n", i);
break;
}
}
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, 0, 0);
image resized = resize_min(im, net.w);
image crop = crop_image(resized, (resized.w - net.w)/2, (resized.h - net.h)/2, net.w, net.h);
//grayscale_image_3c(crop);
float *X = crop.data;
time=clock();
network_predict(net, X);
image out = get_network_image_layer(net, imlayer);
//yuv_to_rgb(out);
constrain_image(out);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
show_image(out, "out");
show_image(crop, "crop");
save_image(out, "out");
#ifdef OPENCV
cvWaitKey(0);
#endif
free_image(im);
free_image(resized);
free_image(crop);
if (filename) break;
}
}
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename, int top)
{
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", 0);
if(!name_list) name_list = option_find_str(options, "labels", "data/labels.list");
if(top == 0) top = option_find_int(options, "top", 1);
int i = 0;
char **names = get_labels(name_list);
clock_t time;
int *indexes = calloc(top, sizeof(int));
char buff[256];
char *input = buff;
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, 0, 0);
image r = letterbox_image(im, net.w, net.h);
//resize_network(&net, r.w, r.h);
//printf("%d %d\n", r.w, r.h);
float *X = r.data;
time=clock();
float *predictions = network_predict(net, X);
if(net.hierarchy) hierarchy_predictions(predictions, net.outputs, net.hierarchy, 1, 1);
top_k(predictions, net.outputs, top, indexes);
fprintf(stderr, "%s: Predicted in %f seconds.\n", input, sec(clock()-time));
for(i = 0; i < top; ++i){
int index = indexes[i];
//if(net.hierarchy) printf("%d, %s: %f, parent: %s \n",index, names[index], predictions[index], (net.hierarchy->parent[index] >= 0) ? names[net.hierarchy->parent[index]] : "Root");
//else printf("%s: %f\n",names[index], predictions[index]);
printf("%5.2f%%: %s\n", predictions[index]*100, names[index]);
}
if(r.data != im.data) free_image(r);
free_image(im);
if (filename) break;
}
}
int main (int argc, char ** argv) {
s_rand (42);
image * from = init_to_value (make_image (HORZ, VERT), 0.0f);
image * to = init_to_value (make_image (HORZ, VERT), 0.0f);
TicTocTimer clock = tic();
for (size_t i = 0; i < PERF_REPS; ++i)
add (to, from, 42.0);
printf("Elapsed time %f seconds.\n",toc(&clock));
free_image (from);
free_image (to);
return 0;
}
void demo_regressor(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename)
{
#ifdef OPENCV
printf("Regressor Demo\n");
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
CvCapture * cap;
if(filename){
cap = cvCaptureFromFile(filename);
}else{
cap = cvCaptureFromCAM(cam_index);
}
if(!cap) error("Couldn't connect to webcam.\n");
cvNamedWindow("Regressor", CV_WINDOW_NORMAL);
cvResizeWindow("Regressor", 512, 512);
float fps = 0;
while(1){
struct timeval tval_before, tval_after, tval_result;
gettimeofday(&tval_before, NULL);
image in = get_image_from_stream(cap);
image in_s = letterbox_image(in, net.w, net.h);
show_image(in, "Regressor");
float *predictions = network_predict(net, in_s.data);
printf("\033[2J");
printf("\033[1;1H");
printf("\nFPS:%.0f\n",fps);
printf("People: %f\n", predictions[0]);
free_image(in_s);
free_image(in);
cvWaitKey(10);
gettimeofday(&tval_after, NULL);
timersub(&tval_after, &tval_before, &tval_result);
float curr = 1000000.f/((long int)tval_result.tv_usec);
fps = .9*fps + .1*curr;
}
#endif
}
void
UninitSpace (void)
{
if (space_ini_cnt && --space_ini_cnt == 0)
{
free_image (blast);
free_image (explosion);
free_image (asteroid);
DestroyDrawable (ReleaseDrawable (stars_in_space));
stars_in_space = 0;
}
}
void predict_classifier(char *datacfg, char *cfgfile, char *weightfile, char *filename)
{
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(2222222);
list *options = read_data_cfg(datacfg);
char *name_list = option_find_str(options, "names", 0);
if(!name_list) name_list = option_find_str(options, "labels", "data/labels.list");
int top = option_find_int(options, "top", 1);
int i = 0;
char **names = get_labels(name_list);
clock_t time;
int *indexes = calloc(top, sizeof(int));
char buff[256];
char *input = buff;
int size = net.w;
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, 0, 0);
image r = resize_min(im, size);
resize_network(&net, r.w, r.h);
printf("%d %d\n", r.w, r.h);
float *X = r.data;
time=clock();
float *predictions = network_predict(net, X);
top_predictions(net, top, indexes);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
for(i = 0; i < top; ++i){
int index = indexes[i];
printf("%s: %f\n", names[index], predictions[index]);
}
if(r.data != im.data) free_image(r);
free_image(im);
if (filename) break;
}
}
void test_yolo(char *cfgfile, char *weightfile, char *filename, float thresh)
{
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
}
detection_layer l = net.layers[net.n-1];
set_batch_network(&net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
int j;
float nms=.5;
box *boxes = calloc(l.side*l.side*l.n, sizeof(box));
float **probs = calloc(l.side*l.side*l.n, sizeof(float *));
for(j = 0; j < l.side*l.side*l.n; ++j) probs[j] = calloc(l.classes, sizeof(float *));
while(1){
if(filename){
strncpy(input, filename, 256);
} else {
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input,0,0);
image sized = resize_image(im, net.w, net.h);
float *X = sized.data;
time=clock();
float *predictions = network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, probs, boxes, 0);
if (nms) do_nms_sort(boxes, probs, l.side*l.side*l.n, l.classes, nms);
//draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, voc_labels, 20);
draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, 0, 20);
show_image(im, "predictions");
save_image(im, "predictions");
show_image(sized, "resized");
free_image(im);
free_image(sized);
#ifdef OPENCV
cvWaitKey(0);
cvDestroyAllWindows();
#endif
if (filename) break;
}
}
int ClassifyOcrSamples_Example()
{
char *input = Examples::getPath_alloc(ocrSamples);
char *output = Examples::getPath_alloc(ocrSamplesOutput);
Image *img = ReadImage_STB(input);
if (img == NULL) {
NConsolePrint("\nClassify OCR Samples failed! input image not found!");
return -1;
}
Image *subimage = 0;
Image *subImageEdges = NULL;
ImageClassificationData *icdTemp = 0;
List *classes = list_create();
int si = 0;
for (int x = 0; x < 2000 - 20; x += 20)
{
for (int y = 700; y < 800; y += 20)
{
subimage = image_get_area(img, x, y, ocrSubimageSize, ocrSubimageSize);
icdTemp = image_classify(subimage, 12);
free_image(subimage);
if (icdTemp == NULL)
continue;
list_put(classes, icdTemp);
//free_image_classification_data(icdTemp);
si++;
}
}
char *csvContent = datas_get_format_csv(classes);
file_write(output, csvContent);
freeN(csvContent);
//list_free_default(classes, free_l);
list_free_custom(classes, free_l);
freeN(input);
freeN(output);
free_image(img);
return 0;
}
void demo_regressor(char *datacfg, char *cfgfile, char *weightfile, int cam_index, const char *filename)
{
#ifdef OPENCV
printf("Regressor Demo\n");
network *net = load_network(cfgfile, weightfile, 0);
set_batch_network(net, 1);
srand(2222222);
list *options = read_data_cfg(datacfg);
int classes = option_find_int(options, "classes", 1);
char *name_list = option_find_str(options, "names", 0);
char **names = get_labels(name_list);
void * cap = open_video_stream(filename, cam_index, 0,0,0);
if(!cap) error("Couldn't connect to webcam.\n");
float fps = 0;
while(1){
struct timeval tval_before, tval_after, tval_result;
gettimeofday(&tval_before, NULL);
image in = get_image_from_stream(cap);
image crop = center_crop_image(in, net->w, net->h);
grayscale_image_3c(crop);
float *predictions = network_predict(net, crop.data);
printf("\033[2J");
printf("\033[1;1H");
printf("\nFPS:%.0f\n",fps);
int i;
for(i = 0; i < classes; ++i){
printf("%s: %f\n", names[i], predictions[i]);
}
show_image(crop, "Regressor", 10);
free_image(in);
free_image(crop);
gettimeofday(&tval_after, NULL);
timersub(&tval_after, &tval_before, &tval_result);
float curr = 1000000.f/((long int)tval_result.tv_usec);
fps = .9*fps + .1*curr;
}
free_network(net);
#endif
}
void test_writing(char *cfgfile, char *weightfile, char *filename)
{
network * net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(net, weightfile);
}
set_batch_network(net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, 0, 0);
resize_network(net, im.w, im.h);
printf("%d %d %d\n", im.h, im.w, im.c);
float *X = im.data;
time=clock();
network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
image pred = get_network_image(net);
image upsampled = resize_image(pred, im.w, im.h);
image thresh = threshold_image(upsampled, .5);
pred = thresh;
show_image(pred, "prediction");
show_image(im, "orig");
#ifdef OPENCV
cvWaitKey(0);
cvDestroyAllWindows();
#endif
free_image(upsampled);
free_image(thresh);
free_image(im);
if (filename) break;
}
}
image_t *make_image(int width, int height, int rowbytes) {
int y;
image_t *image = malloc(sizeof(struct image));
if (image == NULL)
goto err;
image->width = width;
image->height = height;
image->rows = NULL;
image->rows = (png_bytep*) malloc(sizeof(png_bytep) * height);
if (image->rows == NULL)
goto err;
for (y = 0; y < height; y++) {
image->rows[y] = (png_byte*) malloc(rowbytes);
if (image->rows[y] == NULL)
goto err;
}
done: return image;
err: free_image(image);
image = NULL;
goto done;
}
void Darknet::yoloImage(const QString &filename, float thresh)
{
const Mat ori = OpenCV::loadImage(getAbs(filename), -1);
Mat img;
cv::resize(ori, img, cv::Size(priv->net.w, priv->net.h));
image im = toDarkImage(img);
//image im = load_image_color((char *)qPrintable(getAbs(filename)), 0, 0);
//image sized = resize_image(im, priv->net.w, priv->net.h);
//float *X = sized.data;
float *X = im.data;
float *predictions = network_predict(priv->net, X);
float nms=.5;
const detection_layer l = priv->l;
convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, priv->probs, priv->boxes, 0);
if (nms) do_nms_sort(priv->boxes, priv->probs, l.side*l.side*l.n, l.classes, nms);
draw_detections(im, l.side*l.side*l.n, thresh, priv->boxes, priv->probs, voc_names, 0, 20);
show_image(im, "predictions");
save_image(im, "predictions");
//show_image(sized, "resized");
free_image(im);
//free_image(sized);
}
void test_dice(char *cfgfile, char *weightfile, char *filename)
{
network * net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(net, weightfile);
}
set_batch_network(net, 1);
srand(2222222);
int i = 0;
char **names = dice_labels;
char buff[256];
char *input = buff;
int indexes[6];
while(1){
if(filename){
strncpy(input, filename, 256);
}else{
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
}
image im = load_image_color(input, net->w, net->h);
float *X = im.data;
float *predictions = network_predict(net, X);
top_predictions(net, 6, indexes);
for(i = 0; i < 6; ++i){
int index = indexes[i];
printf("%s: %f\n", names[index], predictions[index]);
}
free_image(im);
if (filename) break;
}
}
void keyboardDown(unsigned char key, int x, int y) {
switch(key) {
case 'q':
for(int i = 0; i < population_size; i++)
free_image(population[i]);
free(population);
free_image(best_image);
exit(0);
break;
case 'p':
paused = !paused;
break;
default:
break;
}
}
void *detect_in_thread(void *ptr)
{
float nms = .4;
detection_layer l = net.layers[net.n-1];
float *X = det_s.data;
float *prediction = network_predict(net, X);
memcpy(predictions[demo_index], prediction, l.outputs*sizeof(float));
mean_arrays(predictions, FRAMES, l.outputs, avg);
free_image(det_s);
convert_detections(avg, l.classes, l.n, l.sqrt, l.side, 1, 1, demo_thresh, probs, boxes, 0);
if (nms > 0) do_nms(boxes, probs, l.side*l.side*l.n, l.classes, nms);
printf("\033[2J");
printf("\033[1;1H");
printf("\nFPS:%.1f\n",fps);
printf("Objects:\n\n");
images[demo_index] = det;
det = images[(demo_index + FRAMES/2 + 1)%FRAMES];
demo_index = (demo_index + 1)%FRAMES;
draw_detections(det, l.side*l.side*l.n, demo_thresh, boxes, probs, demo_names, demo_labels, demo_classes);
return 0;
}
void *detect_in_thread(void *ptr)
{
float nms = .4;
layer l = net.layers[net.n-1];
float *X = det_s.data;
float *prediction = network_predict(net, X);
memcpy(predictions[demo_index], prediction, l.outputs*sizeof(float));
mean_arrays(predictions, FRAMES, l.outputs, avg);
l.output = avg;
free_image(det_s);
if(l.type == DETECTION){
get_detection_boxes(l, 1, 1, demo_thresh, probs, boxes, 0);
} else if (l.type == REGION){
get_region_boxes(l, 1, 1, demo_thresh, probs, boxes, 0, 0, demo_hier_thresh);
} else {
error("Last layer must produce detections\n");
}
if (nms > 0) do_nms(boxes, probs, l.w*l.h*l.n, l.classes, nms);
printf("\033[2J");
printf("\033[1;1H");
printf("\nFPS:%.1f\n",fps);
printf("Objects:\n\n");
images[demo_index] = det;
det = images[(demo_index + FRAMES/2 + 1)%FRAMES];
demo_index = (demo_index + 1)%FRAMES;
draw_detections(det, l.w*l.h*l.n, demo_thresh, boxes, probs, demo_names, demo_alphabet, demo_classes);
return 0;
}
/**
* @brief image_t型構造体のメモリを確保し初期化する。
*
* @param[in] width 画像の幅
* @param[in] height 画像の高さ
* @param[in] type 色表現の種別
* @return 初期化済みimage_t型構造体
*/
image_t *allocate_image(uint32_t width, uint32_t height, uint8_t type) {
uint32_t i;
image_t *img;
if ((img = calloc(1, sizeof(image_t))) == NULL) {
return NULL;
}
img->width = width;
img->height = height;
img->color_type = type;
if (type == COLOR_TYPE_INDEX) {
if ((img->palette = calloc(256, sizeof(color_t))) == NULL) {
goto error;
}
} else {
img->palette = NULL;
}
img->palette_num = 0;
if ((img->map = calloc(height, sizeof(pixcel_t*))) == NULL) {
goto error;
}
for (i = 0; i < height; i++) {
if ((img->map[i] = calloc(width, sizeof(pixcel_t))) == NULL) {
goto error;
}
}
return img;
error:
free_image(img);
return NULL;
}
std::vector< classification > ofxDarknet::classify( ofPixels & pix, int count )
{
int *indexes = ( int* ) calloc( count, sizeof( int ) );
ofPixels pix2( pix );
if (pix2.getImageType() != OF_IMAGE_COLOR) {
pix2.setImageType(OF_IMAGE_COLOR);
}
if( pix2.getWidth() != net.w && pix2.getHeight() != net.h ) {
pix2.resize( net.w, net.h );
}
image im = convert( pix2 );
float *predictions = network_predict( net, im.data1 );
top_k( predictions, net.outputs, count, indexes );
std::vector< classification > classifications;
for( int i = 0; i < count; ++i ) {
int index = indexes[ i ];
classification c;
c.label = labelsAvailable ? names[ index ] : ofToString(index);
c.probability = predictions[ index ];
classifications.push_back( c );
}
free_image( im );
free(indexes);
return classifications;
}
void test_cifar_multi(char *filename, char *weightfile)
{
network net = parse_network_cfg(filename);
if(weightfile){
load_weights(&net, weightfile);
}
set_batch_network(&net, 1);
srand(time(0));
float avg_acc = 0;
data test = load_cifar10_data("data/cifar/cifar-10-batches-bin/test_batch.bin");
int i;
for(i = 0; i < test.X.rows; ++i){
image im = float_to_image(32, 32, 3, test.X.vals[i]);
float pred[10] = {0};
float *p = network_predict(net, im.data);
axpy_cpu(10, 1, p, 1, pred, 1);
flip_image(im);
p = network_predict(net, im.data);
axpy_cpu(10, 1, p, 1, pred, 1);
int index = max_index(pred, 10);
int class = max_index(test.y.vals[i], 10);
if(index == class) avg_acc += 1;
free_image(im);
printf("%4d: %.2f%%\n", i, 100.*avg_acc/(i+1));
}
}
void malloc_image(Image* i) {
i->pixel = i->red = i->green = i->blue = NULL;
i->yadds = NULL;
i->lookup_resx = NULL;
i->width = width;
i->height = height;
i->yadds = (int*) malloc(height * sizeof(int));
i->pixel = (float*) malloc(width*height*sizeof(float));
if ( usecolors ) {
i->red = (float*) malloc(width*height*sizeof(float));
i->green = (float*) malloc(width*height*sizeof(float));
i->blue = (float*) malloc(width*height*sizeof(float));
}
// we allocate one extra pixel for resx because of the src .. src_end stuff in process_scanline
i->lookup_resx = (int*) malloc( (1 + width) * sizeof(int));
if ( !(i->pixel && i->yadds && i->lookup_resx) ||
(usecolors && !(i->red && i->green && i->blue)) )
{
fprintf(stderr, "Not enough memory for given output dimension\n");
free_image(i);
exit(1);
}
}