void test_backremoval(){ float max_value; float min_value; IplImage * rimage = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); IplImage * min_image = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); int values [] = {0,0,0,0,0,0,0,0,0}; IplConvKernel * kernel = cvCreateStructuringElementEx(3,3,1,1,CV_SHAPE_RECT,values); cvDilate(image,rimage,kernel); display_image("dilate",rimage); cvErode(rimage,rimage,kernel); display_image("erode",rimage); //cvDilate(max_image,max_image,kernel); //cvDilate(max_image,max_image,kernel); display_image("original",image); display_image("rimage",rimage); //rimage = test_background_subtraction(image,max_image); //display_image("back removed",rimage); //IplImage * otsu_image = otsu_algorithm(rimage); //otsu_image = invert_image(otsu_image); //display_image("otsu image",otsu_image); }
static void display_image_charging(uint16_t soc, enum charge_level_t level) { if (level == CHARGE_DISABLE) { display_image(IMAGE_CHARGE_NEEDED, soc); } else { display_image(IMAGE_CHARGING, soc); } }
int main(void) { SDL_Surface *img = load_image("visage"); display_image(img); unsigned long **array = img_to_tab(img); parcours(array, img->w, img->h); img = tab_to_img(array, img->w, img->h); display_image(img); return 0; }
void test_time_opencv_erode(){ //image = cvLoadImage("C:\\Users\\ninao\\Documents\\images\\dibco_test_images\\H04.bmp",0); display_image("image",image); IplImage * rimage = cvCloneImage(image); int values [] = {0,0,0,0,0,0,0,0,0}; IplConvKernel * kernel = cvCreateStructuringElementEx(3,3,1,1,CV_SHAPE_RECT,values); tester->start_timer(); cvErode(image,rimage,kernel); tester->stop_timer(); display_image("erode",rimage); }
int board_charging(void) { enum charge_level_t charger; uint16_t batt_soc = 0; int ret; charger = charger_detect(); ret = init_batt(); if (ret && charger == CHARGE_DISABLE) { printf("failed to init battery: %d\n", ret); return ret; } ret = max17042_soc(&batt_soc); if (ret && charger == CHARGE_DISABLE) { printf("failed to read initial SOC: %d\n", ret); return ret; } if (batt_soc < SOC_THRESH_MIN) { display_image(IMAGE_CHARGE_NEEDED, batt_soc); if (ret) { printf("No battery detected, emergency charging!\n"); } charge_loop(&batt_soc, ret ? 1 : 0); if (batt_soc < SOC_THRESH_MIN) { // Uh-oh, we exited the charge loop // before we passed the minimum // In this case we should power down if (batt_soc >= SOC_THRESH_DISPLAY_MIN) { display_image(IMAGE_CHARGE_NEEDED, batt_soc); udelay(1000 * 1000 * 2); } twl6030_power_off(); } } /* Reconfigure MPU DPLL clock as it might have been set */ /* to conservative values in x-loader, only do this in the case where we are actually going to boot */ set_mpu_dpll_max_opp(); display_image(IMAGE_BOOT, batt_soc); printf("SOC %hu%%, booting.\n", batt_soc); return ret; }
void test_normalization_min_max(){ float max_value; float min_value; IplImage * max_image = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); IplImage * min_image = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); IplConvKernel * kernel = cvCreateStructuringElementEx(3,3,1,1,CV_SHAPE_RECT); cvErode(image,min_image,kernel); cvDilate(image,max_image,kernel); display_image("dilate",min_image); display_image("erode",max_image); int kernel_radius = 1; test_get_normalization_parameters(image,min_image,max_image,kernel_radius,max_value,min_value); printf("max: %f, min: %f",max_value,min_value); }
void test_su_algorithm_parts(){ IplImage* edges_image = min_max_edge_detection(image); display_image("edges image",edges_image); IplImage * contrast_image = otsu_algorithm(edges_image); contrast_image = invert_image(contrast_image); display_image("otsu image",contrast_image); IplImage* peak_pixels_image = get_peak_pixels(contrast_image); display_image("peak_pixels_image",peak_pixels_image); int text_width = text_width_approximation(peak_pixels_image); printf("text width: %d",text_width); display_image("image before local thresholding",image); IplImage* rimage = perform_local_thresholding(image,contrast_image,text_width); display_image("resutl",rimage); }
void test_performance_parts(){ tester->start_timer(); printf("edge detection\n"); IplImage* edges_image = min_max_edge_detection(image); tester->stop_timer(); tester->start_timer(); printf("otsu\n"); IplImage * contrast_image = otsu_algorithm(edges_image); tester->stop_timer(); tester->start_timer(); printf("invert image\n"); contrast_image = invert_image(contrast_image); tester->stop_timer(); tester->start_timer(); printf("get peak pixels\n"); IplImage* peak_pixels_image = get_peak_pixels(contrast_image); tester->stop_timer(); tester->start_timer(); printf("text width\n"); int text_width = 3;//text_width_approximation(peak_pixels_image); printf("text width: %d \n",text_width); tester->stop_timer(); tester->start_timer(); printf("local thresholding\n"); IplImage* rimage = perform_local_thresholding(image,contrast_image,text_width); tester->stop_timer(); tester->get_total_testing_time(); display_image("rimage",rimage); }
int event_mouse(int button, int x, int y, t_global *global) { t_object *tmp; double vector[NB_DIMENSION]; t_detail detail; if (init_detail(&detail) || global == NULL || global->scene == NULL) return (EXIT_FAILURE); tmp = global->scene->object; if (button == CLICK_LEFT && !calc_direction_vector(global, vector, x, y)) { while (tmp) { if (inter_ray_box(global->scene->camera, vector, tmp)) tmp->inter(global->scene->camera, tmp, &detail, vector); tmp = tmp->next; } global->object = detail.object; } if ((button == SCROLL_UP || button == SCROLL_DOWN)) { if (global->scene->camera) global->scene->camera->fov += ((button == SCROLL_UP ? 1 : -1) * 10); display_image(global); } return (EXIT_SUCCESS); }
int receive_mouse(char* ip, int port){ //TODO: Change buffer size such that it's dynamic depending on the //other person's screen size. #define BUFFER_SIZE 256 #define NO_SPECIAL_PROTOCOL 0 #define NO_FLAGS 0 struct sockaddr_in server_address; char* server_name; char buffer[BUFFER_SIZE]; socklen_t address_size; int socket_file_descriptor; //AF_INET is to specify that one wants //IPv4 as the domain. socket_file_descriptor = socket(AF_INET, SOCK_STREAM, NO_SPECIAL_PROTOCOL); memset(&server_address, 0, sizeof(server_address)); server_address.sin_family = AF_INET; server_address.sin_port = htonl(port); server_name = (char*) gethostbyname("localhost"); inet_pton(AF_INET, server_name, &server_address.sin_addr); address_size = sizeof(server_address); if(connect(socket_file_descriptor, (struct sockaddr *)&server_address, address_size) == -1){ exit(21); } while(recv(socket_file_descriptor, buffer, sizeof(buffer), NO_FLAGS) != -1){ display_image(buffer,500,500); } return 1; }
void test_min_max_edge_detection(){ tester->start_timer(); float max_value; float min_value; IplImage * max_image = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); IplImage * min_image = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); int values [] = {0,0,0,0,0,0,0,0,0}; IplConvKernel * kernel = cvCreateStructuringElementEx(3,3,1,1,CV_SHAPE_RECT,values); cvErode(image,min_image,kernel); cvDilate(image,max_image,kernel); //display_image("erode",min_image); //display_image("dilate",max_image); int kernel_radius = 1; //test_get_normalization_parameters(image,min_image,max_image,kernel_radius,max_value,min_value); IplImage * rimage = cvCloneImage(image); for(int y=0;y<image->height;y++){ for(int x=0;x<image->width;x++){ //int value = get_pixel(image,y,x); //printf("%d \n",value); float enhanced_value = test_min_max_enhancement(y,x,kernel_radius,image,min_image,max_image); //int new_value = 255 * enhanced_value/max_value; int new_value = enhanced_value; set_pixel(rimage,y,x,new_value); } } tester->stop_timer(); display_image("result",rimage); cvSaveImage("images/edges.png",rimage); }
/** * Display invalid PIN message */ static void display_invalid_pin() { uint32_t x = CENTER_IMAGE_ON_X_AXIS(MDTP_MAIN_TEXT_WIDTH,fb_config->width); uint32_t y = (fb_config->height)*MAIN_TEXT_RELATIVE_Y_LOCATION; display_image(MDTP_INVALID_PIN_OFFSET, MDTP_MAIN_TEXT_WIDTH, MDTP_MAIN_TEXT_HEIGHT, x, y); }
/* save file */ void save_file(const int fd, const char *filename, const int total) { int w_bytes, chk; FILE *fp = NULL; static char buf[1500]; assert(filename != NULL && total >= 0); fp = fopen(filename, "a+"); if (NULL == fp) { printf("open file error!\r\n"); return; } w_bytes = 0; while (w_bytes != total) { chk = recv(fd, buf, sizeof(buf), 0); fwrite(buf, chk, 1, fp); w_bytes += chk; fflush(fp); /* update progress bar */ update_progress(&bar, chk); display_image(&bar); } putchar('\n'); fflush(fp); fclose(fp); printf("%s: save!", filename); }
void montage_channels(const Blob<Dtype> *image, const std::string &prefix, bool show_diff) { cv::Mat *result = NULL; get_montage_channels_mat(image, show_diff, result); display_image(prefix, result); }
void imshow(const Blob<Dtype> *image, int show_num, const std::string &prefix, bool show_diff) { const int channels = image->channels(); const int height = image->height(); const int width = image->width(); const Dtype *data_ptr = show_diff ? image->cpu_diff() : image->cpu_data(); int show_channels = channels == 3 ? channels : 1; int imsize = channels == 3 ? height * width * 3 : height * width; int type = channels == 3 ? CV_32FC3 : CV_32FC1; Dtype buffer[imsize]; char name_buff[100]; std::string window_name; for (int i = 0; i < show_num; ++i) { // std::copy(data_ptr + image->offset(i, 0, 0, 0), // data_ptr + image->offset(i, 0, 0, 0) + imsize, buffer); // open cv does channels for each row int counter = 0; for (int h = 0; h < height; ++h) { for (int w = 0; w < width; ++w) { for (int c = 0; c < show_channels; ++c) { buffer[counter++] = data_ptr[image->offset(i, c, h, w)]; } } } // between [0, 1] normalize(buffer, imsize); cv::Mat im(height, width, type, buffer, 0); snprintf(name_buff, 100, " %d", i); display_image(prefix + name_buff, &im); } }
/** * Display the instructions for the OK button. */ static void display_pin_instructions() { uint32_t x = CENTER_IMAGE_ON_X_AXIS(MDTP_PIN_INSTRUCTIONS_WIDTH,fb_config->width); uint32_t y = (fb_config->height)*OK_TEXT_RELATIVE_Y_LOCATION; display_image(MDTP_PIN_INSTRUCTIONS_OFFSET, MDTP_PIN_INSTRUCTIONS_WIDTH, MDTP_PIN_INSTRUCTIONS_HEIGHT, x, y); }
void display_page(book * b, page * p) { char ** l; int i; char str[20]; if(!p) return; set_font(2); if(p->image) { display_image(p->image); } for(i=0, l=p->lines; *l; i++,l++){ glColor3f(0.34f,0.25f, 0.16f); draw_string_zoomed(10,i*18*0.9f,(unsigned char*)*l,0,1.0f); } glColor3f(0.385f,0.285f, 0.19f); safe_snprintf(str,sizeof(str),"%d",p->page_no); if(b->type==1) draw_string_zoomed(140,b->max_lines*18*0.9f+2,(unsigned char*)str,0,1.0); else if(b->type==2) draw_string_zoomed(110,b->max_lines*18*0.9f+2,(unsigned char*)str,0,1.0); set_font(0); }
int main() { /* Provides a user interface for the fill algorithm. */ char filename[BUFSIZ] ; int x, y, old_color, new_color ; printf( "Enter image file name. " ) ; scanf( "%s", filename ) ; if( init_image( filename ) == - 1 ) { printf( "Error initializing the image.\n" ) ; exit( 1 ) ; } while( TRUE ) { display_image() ; printf( "Enter the point at which the fill should start ( x, y ) : " ) ; scanf( "%d, %d", &x, &y ) ; if( ( x == -1 ) && ( y == -1 ) ) break ; old_color = read_pixel( x, y ) ; do { printf( "Pixel color is %d. Enter the new color: ", old_color ) ; scanf( "%d", &new_color ) ; } while( old_color == new_color || new_color < 0 || new_color > 9 ) ; fill( x, y, old_color, new_color ) ; } printf( "All done.\n" ) ; return 0 ; }
/** * Display initial delay message */ static void display_initial_delay() { uint32_t x = CENTER_IMAGE_ON_X_AXIS(MDTP_MAIN_TEXT_WIDTH,fb_config->width); uint32_t y = (fb_config->height)*MAIN_TEXT_RELATIVE_Y_LOCATION; display_image(MDTP_INITIAL_DELAY_OFFSET, MDTP_MAIN_TEXT_WIDTH, MDTP_MAIN_TEXT_HEIGHT, x, y); }
/* This function is called repetitively from the main program */ void labwork( void ) { delay( 1000 ); time2string( textstring, mytime ); display_string( 3, textstring ); display_update(); getbtns(); if (getbtns() == 1) mytime += (getsw() << 4); if (getbtns() == 2) mytime += (getsw() << 8); if (getbtns() == 4) mytime += (getsw() << 12); volatile int* porte = (volatile int*) 0xbf886110; tick( &mytime ); *porte += 1; display_image(96, icon); }
/** * Display OK button as selected. */ static void display_selected_ok_button() { uint32_t ok_x = CENTER_IMAGE_ON_X_AXIS(MDTP_OK_BUTTON_WIDTH,fb_config->width); uint32_t ok_y = (fb_config->height)*OK_BUTTON_RELATIVE_Y_LOCATION; display_image(MDTP_SELECTED_OK_BUTTON_OFFSET, MDTP_OK_BUTTON_WIDTH, MDTP_OK_BUTTON_HEIGHT, ok_x, ok_y); }
void test_otsu_step(){ //IplImage * edge_image = min_max_edge_detection(image); //display_image("edge_image",edge_image); IplImage * edge_image = cvLoadImage("images/edges.png",0); display_image("edges image",edge_image); IplImage * otsu_image = otsu_algorithm(edge_image); otsu_image = invert_image(otsu_image); display_image("otsu image",otsu_image); IplImage * segmented_pixels = get_pixels_on_template(image,otsu_image); display_image("segmented pixs",segmented_pixels); int threshold = otsu_thresholding_no_white(segmented_pixels); IplImage* fimage = apply_threshold(segmented_pixels,threshold); display_image("fimage", fimage); cvSaveImage("images/otsu_edges.png",otsu_image); }
void test_su_algorithm(){ tester->start_timer(); IplImage* rimage = su_algorithm(image); tester->stop_timer(); display_image("result",rimage); cvSaveImage("image2-T.png",rimage); }
void test_peak_image_values_from_otsu(){ IplImage * edge_image = cvLoadImage("images/otsu_edges.png",0); display_image("edge_images",edge_image); //int peak_value = get_max_value(edge_image); //printf("peak_val: %d",peak_value); //IplImage* rimage = cvCreateImage(cvGetSize(edge_image),edge_image->depth,edge_image->nChannels); //cvZero(rimage); IplImage * rimage = create_white_image(image->width,image->height,1); int kernel_radius = 1; for(int x=0;x<rimage->width;x=x+1){ for(int y=0;y<rimage->height;y++){ int center_value = get_pixel(edge_image,y,x); bool center_is_peak = false; /*for(int i=x-kernel_radius;i<=x+kernel_radius;i++){ if(is_coordinate_inside_boundaries(y,i,image)){ int pixel = get_pixel(edge_image,y,i); if(pixel>center_value){ center_is_peak = false; } } }*/ if(center_value ==0) if(is_coordinate_inside_boundaries(y,x-kernel_radius,image)&&is_coordinate_inside_boundaries(y,x+kernel_radius,image)) { int left_pixel = get_pixel(edge_image,y,x-kernel_radius); int right_pixel = get_pixel(edge_image,y,x+kernel_radius); int threshold = 20; if(left_pixel == 255 || right_pixel== 255) center_is_peak= true; } if(center_is_peak){ //set_pixel(rimage,y,x,center_value); set_pixel(rimage,y,x,0); //if(pixel==255){ //set_pixel(rimage,y,x,255); //} } } } //rimage = invert_image(rimage); display_image("peak values ",rimage); cvSaveImage("images/peakvalues.png",rimage); }
void test_local_thresholding(){ int text_width = 3; IplImage* edges_image = cvLoadImage("images/otsu_edges.png",0); display_image("edges image",edges_image); IplImage* original_image = image; //IplImage* local_thresholding(IplImage * compensate_img, IplImage * edges_img,int text_width){ int window_size = text_width * 2; if(window_size%2==0) // to make it odd window_size++; int radius = floor((float)window_size /2); int Nmin = window_size; IplImage * rimage = cvCloneImage(image); int height_limit = image->height-radius; int width_limit = image->width-radius; for(int j=0; j< image->height ;j++){ //change radius to 130 ie to debug windows size for(int i=0 ; i < image->width;i++){ if(j <radius || i < radius || j>= height_limit ||i >= width_limit){ //This is to make whie the borders, we assume there is no text in the borders set_pixel(rimage,j,i,255); continue; } int Ne = get_number_edge_pixels(edges_image,i,j,radius); float Emean = get_edges_mean(edges_image,image,i,j,radius); float Estd = get_edges_std(edges_image,image,Emean,i,j,radius); int pixel = get_pixel(image,j,i); if( Ne >= Nmin && pixel <= (Emean+Estd/2)){ set_pixel(rimage,j,i,0); } else{ set_pixel(rimage,j,i,255); } } } //return rimage; display_image("local thresholding",rimage); cvSaveImage("images/localt.png",rimage); }
void test_stable(){ //image = cvLoadImage("C:\\Users\\ninao\\Documents\\images\\testimages\\bigimage.bmp",0); tester->start_timer(); test_min_max_edge_detection(); IplImage * edges_image = cvLoadImage("images/edges.png",0); display_image("edges",edges_image); IplImage * rimage = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); int values [] = {0,0,0,0,0,0,0,0,0}; IplConvKernel * kernel = cvCreateStructuringElementEx(3,3,1,1,CV_SHAPE_RECT,values); //cvDilate(edges_image,rimage,kernel); //display_image("dilate",rimage); IplImage * otsu_image = otsu_algorithm(edges_image); otsu_image = invert_image(otsu_image); tester->stop_timer(); cvSaveImage("images/fasterver.png",otsu_image); display_image("otsu image",otsu_image); }
virtual int on_image(const cv::Mat& image) { cv::Mat display_image(image); cv::putText( display_image, opts()[0], {10,70}, cv::FONT_HERSHEY_SIMPLEX, 2, {0,0,255}); add_display_image("image", display_image); return 0; }
void display_frame(ClFrame &frame) { if(m_crop) { PERF_START("display_image_crop"); display_image_ocl_crop(frame); PERF_END("display_image_crop"); } else { PERF_START("display_image"); display_image(frame); PERF_END("display_image"); } }
void test_performance(){ //image = cvLoadImage("C:\\Users\\ninao\\Documents\\images\\testimages\\bigimage.bmp",0); tester->start_timer(); IplImage* rimage = su_algorithm(image); tester->stop_timer(); display_image("result",rimage); cvSaveImage("images/bigimage-su.png",rimage); }
void display_a_card_by_animation(SDL_Renderer *pRenderer, SDL_Texture *card_back_face_texture, Vector animation_coords) { /** Distribute or gathering cards animation card display function. **/ if ( (int16_t) round(animation_coords.x) == 0 || (int16_t) round(animation_coords.x) == 0) { return ; } display_image(pRenderer,card_back_face_texture, (int16_t) round(animation_coords.x), (int16_t) round(animation_coords.y), CARD_WIDTH, CARD_HEIGHT ) ; return ; }