Пример #1
0
void test_resize(char *filename)
{
    image im = load_image(filename, 0,0, 3);
    image gray = grayscale_image(im);

    image sat2 = copy_image(im);
    saturate_image(sat2, 2);

    image sat5 = copy_image(im);
    saturate_image(sat5, .5);

    image exp2 = copy_image(im);
    exposure_image(exp2, 2);

    image exp5 = copy_image(im);
    exposure_image(exp5, .5);

    show_image(im, "Original");
    show_image(gray, "Gray");
    show_image(sat2, "Saturation-2");
    show_image(sat5, "Saturation-.5");
    show_image(exp2, "Exposure-2");
    show_image(exp5, "Exposure-.5");
#ifdef OPENCV
    cvWaitKey(0);
#endif
}
Пример #2
0
cv::Mat applyThreshold(cv::Mat &img, int debug) {
    int bin_threshold = 180;

    cv::Mat grayscale_image(img.rows, img.cols, CV_8UC1, cvScalarAll(0));
    cv::Mat threshold_image(img.rows, img.cols, CV_8UC1, cvScalarAll(0));

    if (debug == 4) {
        cv::namedWindow("threshold_control_box", 1);
        cv::createTrackbar("bin_threshold", "threshold_control_box", &bin_threshold, 255);
    }

    cv::inRange(img, cv::Scalar(bin_threshold, bin_threshold, bin_threshold), cv::Scalar(256, 256, 256), threshold_image);

    return threshold_image;
} //  converting a given image into binary using a threshold_image
Пример #3
0
void test_resize(char *filename)
{
    image im = load_image(filename, 0,0, 3);
    float mag = mag_array(im.data, im.w*im.h*im.c);
    printf("L2 Norm: %f\n", mag);
    image gray = grayscale_image(im);

    image sat2 = copy_image(im);
    saturate_image(sat2, 2);

    image sat5 = copy_image(im);
    saturate_image(sat5, .5);

    image exp2 = copy_image(im);
    exposure_image(exp2, 2);

    image exp5 = copy_image(im);
    exposure_image(exp5, .5);

    #ifdef GPU
    image r = resize_image(im, im.w, im.h);
    image black = make_image(im.w*2 + 3, im.h*2 + 3, 9);
    image black2 = make_image(im.w, im.h, 3);

    float *r_gpu = cuda_make_array(r.data, r.w*r.h*r.c);
    float *black_gpu = cuda_make_array(black.data, black.w*black.h*black.c);
    float *black2_gpu = cuda_make_array(black2.data, black2.w*black2.h*black2.c);
    shortcut_gpu(3, r.w, r.h, 1, r_gpu, black.w, black.h, 3, black_gpu);
    //flip_image(r);
    //shortcut_gpu(3, r.w, r.h, 1, r.data, black.w, black.h, 3, black.data);

    shortcut_gpu(3, black.w, black.h, 3, black_gpu, black2.w, black2.h, 1, black2_gpu);
    cuda_pull_array(black_gpu, black.data, black.w*black.h*black.c);
    cuda_pull_array(black2_gpu, black2.data, black2.w*black2.h*black2.c);
    show_image_layers(black, "Black");
    show_image(black2, "Recreate");
    #endif

    show_image(im, "Original");
    show_image(gray, "Gray");
    show_image(sat2, "Saturation-2");
    show_image(sat5, "Saturation-.5");
    show_image(exp2, "Exposure-2");
    show_image(exp5, "Exposure-.5");
#ifdef OPENCV
    cvWaitKey(0);
#endif
}
Пример #4
0
cv::Mat applyCanny(cv::Mat &img, int debug) {
    cv::Mat grayscale_image(img.rows, img.cols, CV_8UC1, cvScalarAll(0));
    cv::Mat canny_image(img.rows, img.cols, CV_8UC1, cvScalarAll(0));
    cv::cvtColor(img, grayscale_image, CV_BGR2GRAY);
    int minthreshold = 180, maxthreshold = 255;
    if (debug == 3) {
        cv::namedWindow("canny_control_box", 1);
        cv::createTrackbar("minthreshold", "canny_control_box", &minthreshold, 255);
        cv::createTrackbar("maxthreshold", "canny_control_box", &maxthreshold, 255);
    }
    do {
        cv::Canny(grayscale_image, canny_image, minthreshold, maxthreshold, 3);
        if (debug == 3) {
            cv::imshow("canny_control_box", canny_image);
        }
        if (cv::waitKey(33) == 27)
            break;

    } while (debug == 3);
    return canny_image;
} // converts the given image into a binary one using canny
Пример #5
0
void run_nightmare(int argc, char **argv)
{
    srand(0);
    if(argc < 4){
        fprintf(stderr, "usage: %s %s [cfg] [weights] [image] [layer] [options! (optional)]\n", argv[0], argv[1]);
        return;
    }

    char *cfg = argv[2];
    char *weights = argv[3];
    char *input = argv[4];
    int max_layer = atoi(argv[5]);

    int range = find_int_arg(argc, argv, "-range", 1);
    int norm = find_int_arg(argc, argv, "-norm", 1);
    int rounds = find_int_arg(argc, argv, "-rounds", 1);
    int iters = find_int_arg(argc, argv, "-iters", 10);
    int octaves = find_int_arg(argc, argv, "-octaves", 4);
    float zoom = find_float_arg(argc, argv, "-zoom", 1.);
    float rate = find_float_arg(argc, argv, "-rate", .04);
    float thresh = find_float_arg(argc, argv, "-thresh", 1.);
    float rotate = find_float_arg(argc, argv, "-rotate", 0);
    float momentum = find_float_arg(argc, argv, "-momentum", .9);
    float lambda = find_float_arg(argc, argv, "-lambda", .01);
    char *prefix = find_char_arg(argc, argv, "-prefix", 0);
    int reconstruct = find_arg(argc, argv, "-reconstruct");
    int smooth_size = find_int_arg(argc, argv, "-smooth", 1);

    network net = parse_network_cfg(cfg);
    load_weights(&net, weights);
    char *cfgbase = basecfg(cfg);
    char *imbase = basecfg(input);

    set_batch_network(&net, 1);
    image im = load_image_color(input, 0, 0);
    if(0){
        float scale = 1;
        if(im.w > 512 || im.h > 512){
            if(im.w > im.h) scale = 512.0/im.w;
            else scale = 512.0/im.h;
        }
        image resized = resize_image(im, scale*im.w, scale*im.h);
        free_image(im);
        im = resized;
    }

    float *features = 0;
    image update;
    if (reconstruct){
        resize_network(&net, im.w, im.h);

        int zz = 0;
        network_predict(net, im.data);
        image out_im = get_network_image(net);
        image crop = crop_image(out_im, zz, zz, out_im.w-2*zz, out_im.h-2*zz);
        //flip_image(crop);
        image f_im = resize_image(crop, out_im.w, out_im.h);
        free_image(crop);
        printf("%d features\n", out_im.w*out_im.h*out_im.c);


        im = resize_image(im, im.w, im.h);
        f_im = resize_image(f_im, f_im.w, f_im.h);
        features = f_im.data;

        int i;
        for(i = 0; i < 14*14*512; ++i){
            features[i] += rand_uniform(-.19, .19);
        }

        free_image(im);
        im = make_random_image(im.w, im.h, im.c);
        update = make_image(im.w, im.h, im.c);

    }

    int e;
    int n;
    for(e = 0; e < rounds; ++e){
        fprintf(stderr, "Iteration: ");
        fflush(stderr);
        for(n = 0; n < iters; ++n){  
            fprintf(stderr, "%d, ", n);
            fflush(stderr);
            if(reconstruct){
                reconstruct_picture(net, features, im, update, rate, momentum, lambda, smooth_size, 1);
                //if ((n+1)%30 == 0) rate *= .5;
                show_image(im, "reconstruction");
#ifdef OPENCV
                cvWaitKey(10);
#endif
            }else{
                int layer = max_layer + rand()%range - range/2;
                int octave = rand()%octaves;
                optimize_picture(&net, im, layer, 1/pow(1.33333333, octave), rate, thresh, norm);
            }
        }
        fprintf(stderr, "done\n");
        if(0){
            image g = grayscale_image(im);
            free_image(im);
            im = g;
        }
        char buff[256];
        if (prefix){
            sprintf(buff, "%s/%s_%s_%d_%06d",prefix, imbase, cfgbase, max_layer, e);
        }else{
            sprintf(buff, "%s_%s_%d_%06d",imbase, cfgbase, max_layer, e);
        }
        printf("%d %s\n", e, buff);
        save_image(im, buff);
        //show_image(im, buff);
        //cvWaitKey(0);

        if(rotate){
            image rot = rotate_image(im, rotate);
            free_image(im);
            im = rot;
        }
        image crop = crop_image(im, im.w * (1. - zoom)/2., im.h * (1.-zoom)/2., im.w*zoom, im.h*zoom);
        image resized = resize_image(crop, im.w, im.h);
        free_image(im);
        free_image(crop);
        im = resized;
    }
}
Пример #6
0
void run_nightmare(int argc, char **argv)
{
    srand(0);
    if(argc < 4){
        fprintf(stderr, "usage: %s %s [cfg] [weights] [image] [layer] [options! (optional)]\n", argv[0], argv[1]);
        return;
    }

    char *cfg = argv[2];
    char *weights = argv[3];
    char *input = argv[4];
    int max_layer = atoi(argv[5]);

    int range = find_int_arg(argc, argv, "-range", 1);
    int rounds = find_int_arg(argc, argv, "-rounds", 1);
    int iters = find_int_arg(argc, argv, "-iters", 10);
    int octaves = find_int_arg(argc, argv, "-octaves", 4);
    float zoom = find_float_arg(argc, argv, "-zoom", 1.);
    float rate = find_float_arg(argc, argv, "-rate", .04);
    float thresh = find_float_arg(argc, argv, "-thresh", 1.);
    float rotate = find_float_arg(argc, argv, "-rotate", 0);
    char *prefix = find_char_arg(argc, argv, "-prefix", 0);

    network net = parse_network_cfg(cfg);
    load_weights(&net, weights);
    char *cfgbase = basecfg(cfg);
    char *imbase = basecfg(input);

    set_batch_network(&net, 1);
    image im = load_image_color(input, 0, 0);
    if(0){
        float scale = 1;
        if(im.w > 512 || im.h > 512){
            if(im.w > im.h) scale = 512.0/im.w;
            else scale = 512.0/im.h;
        }
        image resized = resize_image(im, scale*im.w, scale*im.h);
        free_image(im);
        im = resized;
    }

    int e;
    int n;
    for(e = 0; e < rounds; ++e){
            fprintf(stderr, "Iteration: ");
            fflush(stderr);
        for(n = 0; n < iters; ++n){  
            fprintf(stderr, "%d, ", n);
            fflush(stderr);
            int layer = max_layer + rand()%range - range/2;
            int octave = rand()%octaves;
            optimize_picture(&net, im, layer, 1/pow(1.33333333, octave), rate, thresh);
        }
        fprintf(stderr, "done\n");
        if(0){
            image g = grayscale_image(im);
            free_image(im);
            im = g;
        }
        char buff[256];
        if (prefix){
            sprintf(buff, "%s/%s_%s_%d_%06d",prefix, imbase, cfgbase, max_layer, e);
        }else{
            sprintf(buff, "%s_%s_%d_%06d",imbase, cfgbase, max_layer, e);
        }
        printf("%d %s\n", e, buff);
        save_image(im, buff);
        //show_image(im, buff);
        //cvWaitKey(0);

        if(rotate){
            image rot = rotate_image(im, rotate);
            free_image(im);
            im = rot;
        }
        image crop = crop_image(im, im.w * (1. - zoom)/2., im.h * (1.-zoom)/2., im.w*zoom, im.h*zoom);
        image resized = resize_image(crop, im.w, im.h);
        free_image(im);
        free_image(crop);
        im = resized;
    }
}
Пример #7
0
/*----------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
	int loop, test = 0, error = 0, command = COMMAND_NONE;
	int gray = 0, view = 1, help = 0;
	char *psave = 0x0, *pname = 0x0, *pdata = 0x0;
	my1Image currimage, tempimage, *pimage;
	my1IFrame currframe, tempframe;

	/* print tool info */
	printf("\n%s - %s (%s)\n",MY1APP_PROGNAME,MY1APP_PROGINFO,MY1APP_PROGVERS);
	printf("  => by [email protected]\n\n");

	/* check program arguments */
	if(argc>1)
	{
		for(loop=1;loop<argc;loop++)
		{
			if(argv[loop][0]=='-') /* options! */
			{
				if(!strcmp(argv[loop],"--save"))
				{
					loop++;
					if(loop<argc)
						psave = argv[loop];
					else
						printf("Cannot get save file name - NOT saving!\n");
				}
				else if(!strcmp(argv[loop],"--cdata"))
				{
					loop++;
					if(loop<argc)
						pdata = argv[loop];
					else
						printf("Cannot get C data file name - NOT writing!\n");
				}
				else if(!strcmp(argv[loop],"--gray"))
				{
					gray = 1;
				}
				else if(!strcmp(argv[loop],"--hide"))
				{
					view = 0;
				}
				else if(!strcmp(argv[loop],"--help"))
				{
					help = 1;
				}
				else
				{
					printf("Unknown option '%s'!\n",argv[loop]);
				}
			}
			else /* not an option? */
			{
				/* first non-option must be file name! */
				if(!pname)
				{
					pname = argv[loop];
					continue;
				}
				/* then check for command! */
				if(!strcmp(argv[loop],"laplace1"))
				{
					command = COMMAND_LAPLACE1;
					gray = 1;
				}
				else if(!strcmp(argv[loop],"sobelx"))
				{
					command = COMMAND_SOBELX;
					gray = 1;
				}
				else if(!strcmp(argv[loop],"sobely"))
				{
					command = COMMAND_SOBELY;
					gray = 1;
				}
				else if(!strcmp(argv[loop],"sobelall"))
				{
					command = COMMAND_SOBELALL;
					gray = 1;
				}
				else if(!strcmp(argv[loop],"laplace2"))
				{
					command = COMMAND_LAPLACE2;
					gray = 1;
				}
				else if(!strcmp(argv[loop],"gauss"))
				{
					command = COMMAND_GAUSS;
					gray = 1;
				}
				else
				{
					printf("Unknown parameter %s!\n",argv[loop]);
					continue;
				}
				/* warn if overriding previous command! */
				if(command)
				{
					printf("Warning! Command '%s' overrides '%s'!\n",
						argv[loop],argv[test]);
				}
				test = loop;
			}
		}
	}

	/* check if user requested help */
	if(help)
	{
		about();
		return 0;
	}

	/** check input filename */
	if(!pname)
	{
		printf("No filename given! Aborting!\n");
		return ERROR_GENERAL;
	}

	/* initialize image & frame*/
	initimage(&currimage);
	initimage(&tempimage);
	initframe(&currframe);
	initframe(&tempframe);

	/* try to open file */
	if((error=load_image(&currimage,pname))<0)
	{
		return error;
	}

	/* display basic info */
	printf("Input image: %s\n",pname);
	print_image_info(&currimage);

	/* convert grayscale if requested/required */
	if(gray) grayscale_image(&currimage);

	/* process command */
	switch(command)
	{
		case COMMAND_LAPLACE1:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			laplace_image(&currimage,&tempimage);
			break;
		}
		case COMMAND_SOBELX:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			sobel_x_image(&currimage,&tempimage);
			break;
		}
		case COMMAND_SOBELY:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			sobel_y_image(&currimage,&tempimage);
			break;
		}
		case COMMAND_SOBELALL:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			sobel_image(&currimage,&tempimage,0x0);
			break;
		}
		case COMMAND_LAPLACE2:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			createframe(&currframe,currimage.height,currimage.width);
			createframe(&tempframe,currimage.height,currimage.width);
			image2frame(&currimage,&currframe,0);
			laplace_frame(&currframe,&tempframe);
			frame2image(&tempframe,&tempimage,1);
			break;
		}
		case COMMAND_GAUSS:
		{
			createimage(&tempimage,currimage.height,currimage.width);
			createframe(&currframe,currimage.height,currimage.width);
			createframe(&tempframe,currimage.height,currimage.width);
			image2frame(&currimage,&currframe,0);
			gauss_frame(&currframe,&tempframe,1.0,0x0);
			frame2image(&tempframe,&tempimage,1);
			break;
		}
	}

	if(!tempimage.length)
		pimage = &currimage;
	else
		pimage = &tempimage;
	printf("Check image:\n");
	print_image_info(pimage);

	/** save results if requested */
	if(psave)
	{
		printf("Saving image data to %s...\n",psave);
		error=save_image(pimage,psave);
		view = 0;
	}

	if(pdata)
	{
		printf("Saving C data to %s...\n",pdata);
		error=cdata_image(pimage,pdata);
	}

	/* view image if no request to hide! .. and NOT saving! */
	if(view) view_image(pimage);

	/* cleanup */
	freeframe(&currframe);
	freeframe(&tempframe);
	freeimage(&currimage);
	freeimage(&tempimage);

	return error;
}