void gli_draw_pixel_lcd(int x, int y, unsigned char *alpha, unsigned char *rgb) { unsigned char *p = gli_image_rgb + y * gli_image_s + x * gli_bpp; unsigned char invalf[3]; invalf[0] = 255 - alpha[0]; invalf[1] = 255 - alpha[1]; invalf[2] = 255 - alpha[2]; if (x < 0 || x >= gli_image_w) return; if (y < 0 || y >= gli_image_h) return; #ifdef WIN32 p[0] = rgb[2] + mul255((short)p[0] - rgb[2], invalf[2]); p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]); p[2] = rgb[0] + mul255((short)p[2] - rgb[0], invalf[0]); #elif defined __APPLE__ || defined EFL_4BPP p[0] = rgb[2] + mul255((short)p[0] - rgb[2], invalf[2]); p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]); p[2] = rgb[0] + mul255((short)p[2] - rgb[0], invalf[0]); p[3] = 0xFF; #elif defined EFL_1BPP int gray = grayscale( rgb[0], rgb[1], rgb[2] ); int invalfgray = grayscale( invalf[0], invalf[1], invalf[2] ); p[0] = gray + mul255((short)p[0] - gray, invalfgray); #else p[0] = rgb[0] + mul255((short)p[0] - rgb[0], invalf[0]); p[1] = rgb[1] + mul255((short)p[1] - rgb[1], invalf[1]); p[2] = rgb[2] + mul255((short)p[2] - rgb[2], invalf[2]); #endif }
virtual void onDraw(SkCanvas* canvas) { SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT); SkPaint paint; paint.setColor(SK_ColorRED); canvas->save(); for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.2f) { SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness)); SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, dim)); paint.setImageFilter(bright); drawClippedRect(canvas, r, paint); canvas->translate(FILTER_WIDTH + MARGIN, 0); } canvas->restore(); canvas->translate(0, FILTER_HEIGHT + MARGIN); { SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f)); SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness)); paint.setImageFilter(grayscale); drawClippedRect(canvas, r, paint); canvas->translate(FILTER_WIDTH + MARGIN, 0); } { SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, grayscale)); paint.setImageFilter(brightness); drawClippedRect(canvas, r, paint); canvas->translate(FILTER_WIDTH + MARGIN, 0); } { SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue)); paint.setImageFilter(brightness); drawClippedRect(canvas, r, paint); canvas->translate(FILTER_WIDTH + MARGIN, 0); } { SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness)); paint.setImageFilter(blue); drawClippedRect(canvas, r, paint); canvas->translate(FILTER_WIDTH + MARGIN, 0); } { SkAutoTUnref<SkImageFilter> blur(make_blur(3.0f)); SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.5f, blur)); paint.setImageFilter(brightness); drawClippedRect(canvas, r, paint, 3); canvas->translate(FILTER_WIDTH + MARGIN, 0); } { SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); paint.setImageFilter(blue.get()); drawClippedRect(canvas, r, paint, 5); canvas->translate(FILTER_WIDTH + MARGIN, 0); } }
void FluxTensorMethod :: convert2grayscale(const Mat & input, Mat & output) { Mat grayscale(input.size(), CV_8U); output = grayscale.clone(); double rgb[3]; const uchar * input_pixel_ptr; uchar * result_pixel_ptr; uchar gray_value; int height = input.rows; int width = input.cols; for(int row = 0; row < height; ++row) { input_pixel_ptr = input.ptr(row); result_pixel_ptr = output.ptr(row); for(int col = 0; col < width; ++col) { //RGB reverted order rgb[2] = (double) *input_pixel_ptr++; rgb[1] = (double) *input_pixel_ptr++; rgb[0] = (double) *input_pixel_ptr++; //gray_value = (rgb[0]+rgb[1]+rgb[2])/3; gray_value = 0.2126*rgb[0]+0.7152*rgb[1]+0.0722*rgb[2]; //for(int i = 0; i < 3; ++i) *result_pixel_ptr++ = gray_value; } } }
void gli_draw_clear(unsigned char *rgb) { unsigned char *p; int x, y; #ifdef EFL_1BPP int gray = grayscale( rgb[0], rgb[1], rgb[2] ); #endif for (y = 0; y < gli_image_h; y++) { p = gli_image_rgb + y * gli_image_s; for (x = 0; x < gli_image_w; x++) { #ifdef WIN32 *p++ = rgb[2]; *p++ = rgb[1]; *p++ = rgb[0]; #elif defined __APPLE__ || defined EFL_4BPP *p++ = rgb[2]; *p++ = rgb[1]; *p++ = rgb[0]; *p++ = 0xFF; #elif defined EFL_1BPP *p++ = gray; #else *p++ = rgb[0]; *p++ = rgb[1]; *p++ = rgb[2]; #endif } } }
void onDraw(const int loops, SkCanvas* canvas) override { SkRect r = getFilterRect(); SkPaint paint; paint.setColor(SK_ColorRED); for (int i = 0; i < loops; i++) { SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); paint.setImageFilter(grayscale); canvas->drawRect(r, paint); } }
void GUI::apply_grayscale(Controller &controller) { if ( ! controller.image_file_loaded ) { return ; } // Transform image into a grayscale image according choosen settings: switch (combo_current_grayscaling) { case 0 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "average") ; break ; case 1 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "max") ; break ; case 2 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "min") ; break ; case 3 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "red") ; break ; case 4 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "green") ; break ; case 5 : grayscale(controller.current_image_to_process, controller.current_image_to_process, "blue") ; break ; #ifdef DEBUG default : // Cannot append due of the GUI interfacing. fprintf(stdout,"Error applying grayscale filter !!!\n") ; return ; #endif } // We register current frame in vector<cv::Mat> for undo-redo. controller.process_after_applying() ; // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display. set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ; // It auto process conversion to RGB(A). // Reset some variables. after_applying_reset_settings(controller) ; }
void gli_draw_rect(int x0, int y0, int w, int h, unsigned char *rgb) { unsigned char *p0; int x1 = x0 + w; int y1 = y0 + h; int x, y; if (x0 < 0) x0 = 0; if (y0 < 0) y0 = 0; if (x1 < 0) x1 = 0; if (y1 < 0) y1 = 0; if (x0 > gli_image_w) x0 = gli_image_w; if (y0 > gli_image_h) y0 = gli_image_h; if (x1 > gli_image_w) x1 = gli_image_w; if (y1 > gli_image_h) y1 = gli_image_h; p0 = gli_image_rgb + y0 * gli_image_s + x0 * gli_bpp; #ifdef EFL_1BPP int gray = grayscale( rgb[0], rgb[1], rgb[2] ); #endif for (y = y0; y < y1; y++) { unsigned char *p = p0; for (x = x0; x < x1; x++) { #ifdef WIN32 *p++ = rgb[2]; *p++ = rgb[1]; *p++ = rgb[0]; #elif defined __APPLE__ || defined EFL_4BPP *p++ = rgb[2]; *p++ = rgb[1]; *p++ = rgb[0]; *p++ = 0xFF; #elif defined EFL_1BPP *p++ = gray; #else *p++ = rgb[0]; *p++ = rgb[1]; *p++ = rgb[2]; #endif } p0 += gli_image_s; } }
void P6::Monochrome(const char* filename) { if (isGrayMonochrome() == true) { cout << "The image is already monochrome \n"; return; } else { char* newName = ChangeFileName(filename, "_monochrome.ppm"); ofstream outFile(newName, ios::out); if (!outFile) { cerr << "Cannot write P6 file \n"; return; } char magic_pbm[3] = "P6"; outFile << magic_pbm << endl << getWidth() << " " << getHeight() << endl << getMaxNum() << endl; int r = 0, g = 0, b = 0; for (int i = 0; i < getHeight(); i++) { for (int j = 0; j < getWidth(); j++) { r = getPixels()[i][j].getRed(); g = getPixels()[i][j].getGreen(); b = getPixels()[i][j].getBlue(); int gray = grayscale(r, g, b); int m = monochrome(gray); outFile.write((const char*)&m, sizeof(char)); outFile.write((const char*)&m, sizeof(char)); outFile.write((const char*)&m, sizeof(char)); } } outFile.flush(); outFile.close(); delete[] newName; } }
void ImggFormatsConvertViewQtWidget::writeImg( MatrixWorkspace_sptr inWks, const std::string &outputName, const std::string &outFormat) const { if (!inWks) return; auto width = inWks->getNumberHistograms(); if (0 == width) return; auto height = inWks->blocksize(); QImage img(QSize(static_cast<int>(width), static_cast<int>(height)), QImage::Format_Indexed8); int tableSize = 256; QVector<QRgb> grayscale(tableSize); for (int i = 0; i < grayscale.size(); i++) { int level = i; // would be equivalent: qGray(i, i, i); grayscale[i] = qRgb(level, level, level); } img.setColorTable(grayscale); // only 16 to 8 bits color map supported with current libraries const double scaleFactor = std::numeric_limits<unsigned short int>::max() / std::numeric_limits<unsigned char>::max(); for (int yi = 0; yi < static_cast<int>(width); ++yi) { const auto &row = inWks->readY(yi); for (int xi = 0; xi < static_cast<int>(width); ++xi) { int scaled = static_cast<int>(row[xi] / scaleFactor); // Images not from IMAT, just crop. This needs much improvement when // we have proper Load/SaveImage algorithms if (scaled > 255) scaled = 255; if (scaled < 0) scaled = 0; img.setPixel(xi, yi, scaled); } } writeImgFile(img, outputName, outFormat); }
int main(int argc, char **argv) { ros::init(argc, argv, "sca_image_d_viewer"); ros::NodeHandle n; ros::Subscriber scan_image_sub = n.subscribe("/scan_image", 1, scan_image_callback); ros::Subscriber image_sub = n.subscribe("/image_raw", 1, image_callback); ros::Subscriber car_fusion_sub = n.subscribe("/obj_car/image_obj_ranged", 1, car_fusion_callback); ros::Subscriber pedestrian_fusion_sub = n.subscribe("/obj_person/image_obj_ranged", 1, ped_fusion_callback); cv::Mat grayscale(256,1,CV_8UC1); for(int i = 0; i < 256; i++) { grayscale.at<uchar>(i)=i; } cv::applyColorMap(grayscale, colormap, cv::COLORMAP_JET); cvNamedWindow(window_name, 2); ros::spin(); cvDestroyWindow(window_name); return 0; }
Canvas * grayscale_canvas(Canvas * base, int num_threads) { const int w = base->w; const int h = base->h; Canvas * ret = new_canvas(w, h); omp_set_num_threads((num_threads < 2) ? 1 : num_threads); int x; int y; #pragma omp parallel private(x, y) #pragma omp for collapse(2) schedule(dynamic, IMG_CHUNK) for(x = 0; x < w; ++x) { for(y = 0; y < h; ++y) { const Color c = get_pixel(x, y, base); const Color gray = grayscale(c); set_pixel(x, y, gray, ret); } } return ret; }
void P6::Grayscale(const char* filename) { if (isGrayMonochrome() == true) { cout << "The image is already grayscale \n"; return; } else { char* newName = ChangeFileName(filename, "_grayscale.ppm"); ofstream outFile(newName, ios::out | ios::binary); if (!outFile) { cerr << "Cannot write P6 file \n"; return; } char magic_pgm[3] = "P6"; outFile << magic_pgm << endl << width << " " << height << endl << max_num << endl; for (int i = 0; i < getHeight(); i++) { for (int j = 0; j < getWidth(); j++) { r = getPixels()[i][j].getRed(); g = getPixels()[i][j].getGreen(); b = getPixels()[i][j].getBlue(); int gray = grayscale(r, g, b); outFile.write((const char*)&gray, sizeof(Color) / 3); outFile.write((const char*)&gray, sizeof(Color) / 3); outFile.write((const char*)&gray, sizeof(Color) / 3); } } outFile.flush(); outFile.close(); delete[] newName; } }
int main(int argc, char **argv) { /* create resizable window */ cvNamedWindow(window_name, CV_WINDOW_NORMAL); cvStartWindowThread(); ros::init(argc, argv, "vscan_image_viewer"); ros::NodeHandle n; ros::Subscriber sub_image = n.subscribe("image_raw", 1, image_cb); ros::Subscriber sub_points = n.subscribe("vscan_image", 1, points_cb); cv::Mat grayscale(256,1,CV_8UC1); for(int i=0;i<256;i++) { grayscale.at<uchar>(i)=i; } cv::applyColorMap(grayscale,colormap,cv::COLORMAP_JET); ros::spin(); cvDestroyWindow(window_name); return 0; }
int main (int argc, char **argv) { unsigned char *buf; long bufSize = 0; unsigned char *original; long originalSize = 0; unsigned char *originalGray = NULL; long originalGraySize = 0; unsigned char *compressed = NULL; unsigned long compressedSize = 0; unsigned char *compressedGray; long compressedGraySize = 0; unsigned char *tmpImage; int width, height; unsigned char *metaBuf; unsigned int metaSize = 0; FILE *file; // Parse commandline options command_t cmd; command_init(&cmd, argv[0], VERSION); cmd.usage = "[options] input.jpg compressed-output.jpg"; command_option(&cmd, "-t", "--target [arg]", "Set target quality [0.9999]", setTarget); command_option(&cmd, "-q", "--quality [arg]", "Set a quality preset: low, medium, high, veryhigh [medium]", setQuality); command_option(&cmd, "-n", "--min [arg]", "Minimum JPEG quality [40]", setMinimum); command_option(&cmd, "-x", "--max [arg]", "Maximum JPEG quality [95]", setMaximum); command_option(&cmd, "-l", "--loops [arg]", "Set the number of runs to attempt [6]", setAttempts); command_option(&cmd, "-a", "--accurate", "Favor accuracy over speed", setAccurate); command_option(&cmd, "-m", "--method [arg]", "Set comparison method to one of 'mpe', 'ssim', 'ms-ssim', 'smallfry' [ssim]", setMethod); command_option(&cmd, "-s", "--strip", "Strip metadata", setStrip); command_option(&cmd, "-d", "--defish [arg]", "Set defish strength [0.0]", setDefish); command_option(&cmd, "-z", "--zoom [arg]", "Set defish zoom [1.0]", setZoom); command_option(&cmd, "-r", "--ppm", "Parse input as PPM instead of JPEG", setPpm); command_option(&cmd, "-c", "--no-copy", "Disable copying files that will not be compressed", setCopyFiles); command_option(&cmd, "-p", "--no-progressive", "Disable progressive encoding", setNoProgressive); command_parse(&cmd, argc, argv); if (cmd.argc < 2) { command_help(&cmd); return 255; } if (method == UNKNOWN) { fprintf(stderr, "Invalid method!"); command_help(&cmd); return 255; } // No target passed, use preset! if (!target) { setTargetFromPreset(); } // Read original bufSize = readFile((char *) cmd.argv[0], (void **) &buf); if (!bufSize) { return 1; } if (!ppm) { // Decode the JPEG originalSize = decodeJpeg(buf, bufSize, &original, &width, &height, JCS_RGB); } else { // Decode the PPM originalSize = decodePpm(buf, bufSize, &original, &width, &height); } if (defishStrength) { fprintf(stderr, "Defishing...\n"); tmpImage = malloc(width * height * 3); defish(original, tmpImage, width, height, 3, defishStrength, defishZoom); free(original); original = tmpImage; } // Convert RGB input into Y originalGraySize = grayscale(original, &originalGray, width, height); if (!ppm) { // Read metadata (EXIF / IPTC / XMP tags) if (getMetadata(buf, bufSize, &metaBuf, &metaSize, COMMENT)) { fprintf(stderr, "File already processed by jpeg-recompress!\n"); if (copyFiles) { file = openOutput(cmd.argv[1]); fwrite(buf, bufSize, 1, file); fclose(file); free(buf); return 0; } else { free(buf); return 2; } } } if (strip) { // Pretend we have no metadata metaSize = 0; } else { fprintf(stderr, "Metadata size is %ukb\n", metaSize / 1024); } if (!originalSize || !originalGraySize) { return 1; } // Do a binary search to find the optimal encoding quality for the // given target SSIM value. int min = jpegMin, max = jpegMax; for (int attempt = attempts - 1; attempt >= 0; --attempt) { float metric; int quality = min + (max - min) / 2; int progressive = attempt ? 0 : !noProgressive; int optimize = accurate ? 1 : (attempt ? 0 : 1); // Recompress to a new quality level, without optimizations (for speed) compressedSize = encodeJpeg(&compressed, original, width, height, JCS_RGB, quality, progressive, optimize); // Load compressed luma for quality comparison compressedGraySize = decodeJpeg(compressed, compressedSize, &compressedGray, &width, &height, JCS_GRAYSCALE); if (!compressedGraySize) { fprintf(stderr, "Unable to decode file that was just encoded!\n"); return 1; } if (!attempt) { fprintf(stderr, "Final optimized "); } // Measure quality difference switch (method) { case MS_SSIM: metric = iqa_ms_ssim(originalGray, compressedGray, width, height, width, 0); fprintf(stderr, "ms-ssim"); break; case SMALLFRY: metric = smallfry_metric(originalGray, compressedGray, width, height); fprintf(stderr, "smallfry"); break; case MPE: metric = meanPixelError(originalGray, compressedGray, width, height, 1); fprintf(stderr, "mpe"); break; case SSIM: default: metric = iqa_ssim(originalGray, compressedGray, width, height, width, 0, 0); fprintf(stderr, "ssim"); break; } if (attempt) { fprintf(stderr, " at q=%i (%i - %i): %f\n", quality, min, max, metric); } else { fprintf(stderr, " at q=%i: %f\n", quality, metric); } if (metric < target) { if (compressedSize >= bufSize) { fprintf(stderr, "Output file would be larger than input!\n"); free(compressed); free(compressedGray); if (copyFiles) { file = openOutput(cmd.argv[1]); fwrite(buf, bufSize, 1, file); fclose(file); free(buf); return 0; } else { free(buf); return 1; } } switch (method) { case SSIM: case MS_SSIM: case SMALLFRY: // Too distorted, increase quality min = quality + 1; break; case MPE: // Higher than required, decrease quality max = quality - 1; break; } } else { switch (method) { case SSIM: case MS_SSIM: case SMALLFRY: // Higher than required, decrease quality max = quality - 1; break; case MPE: // Too distorted, increase quality min = quality + 1; break; } } // If we aren't done yet, then free the image data if (attempt) { free(compressed); free(compressedGray); } } free(buf); // Calculate and show savings, if any int percent = (compressedSize + metaSize) * 100 / bufSize; unsigned long saved = (bufSize > compressedSize) ? bufSize - compressedSize - metaSize : 0; fprintf(stderr, "New size is %i%% of original (saved %lu kb)\n", percent, saved / 1024); if (compressedSize >= bufSize) { fprintf(stderr, "Output file is larger than input, aborting!\n"); return 1; } // Open output file for writing file = openOutput(cmd.argv[1]); // Write output fwrite(compressed, 20, 1, file); /* 0xffd8 and JFIF marker */ // Write comment so we know not to reprocess this file // in the future if it gets passed in again. // 0xfffe (COM marker), two-byte big-endian length, string fputc(0xff, file); fputc(0xfe, file); fputc(0x00, file); fputc(32, file); fwrite(COMMENT, 30, 1, file); // Write metadata markers if (!strip && !ppm) { fwrite(metaBuf, metaSize, 1, file); } // Write image data fwrite(compressed + 20, compressedSize - 20, 1, file); fclose(file); // Cleanup command_free(&cmd); if (!strip && !ppm) { free(metaBuf); } free(compressed); free(original); free(originalGray); return 0; }
/***************************************************************************//** * Menu_PointProcesses_ModifiedContrastStretch * Author - Derek Stotz * * Uses the QtImageLib to convert the image to a grayscale image. * * Parameters - image - the image object to manipulate. * * Returns * true if successful, false if not ******************************************************************************/ bool PointProcessor::Menu_PointProcesses_ConvertToGreyscale(Image& image) { return grayscale(image); }
int main(int argc, const char * argv[]) { int width,height,numPixels,i,rgb_color=255; char c,choice; FILE * inFile; inFile = fopen("Android_robot.png","r"); c=getc(inFile); while(c=='#') { do { c=getc(inFile); }while (c!='\n'); c=getc(inFile); } ungetc(c, inFile); // gusoma width na height birimuri iyo file if(fscanf(inFile,"P6 %d %d",&width,&height)!=2) { fprintf(stderr, "invalid image size. \n"); exit(1); } // gusoma RGB color components if(fscanf(inFile, "%d\n",&rgb_color)!=1) { fprintf(stderr, "invalid RGB color component. \n"); exit(1); } //gucheckinga RGB deth niba ingana na yayindi twa defininze hejuru if(rgb_color!=RGB_COLOR) { fprintf(stderr, "Invalid RBG value.\n"); exit(1); } //gushaka number of pixels zirimo numPixels = width*height; //kw allocatinga space ingana na number of pixels image = malloc(numPixels * sizeof(pixel_t)); // ku readinga data ziri muri pixel for(i=0;i<numPixels;i++) { fscanf(inFile, "%c%c%c",&image[i].r,&image[i].g,&image[i].b); } // new header printf("P6\n"); printf("%d %d 255\n",width,height); printf(" choose 1.filp image 2.grascale 3.rotate image .\n"); scanf("%c",&choice); switch (choice) { case '1': flipImage(image,width, height); break; case '2': grayscale(image, width, height); break; case '3': //rotate(image, width, height); break; default: printf("invalid command"); break; } return 0; }
int main(int argc, char** argv) { /**Abertura do arquivo da imagem*/ printf("%s\n","Informe o nome do arquivo de imagem a ser aberto:"); scanf("%s",Nome_arquivo); /**Função limpa tela*/ reset(); FILE *arquivo; /**Ler o arquivo*/ arquivo = fopen(Nome_arquivo, "r"); /**Faz o teste de erro na abertura do arquivo*/ if(arquivo == NULL){ printf("%s\n","Erro ao abrir o arquivo de imagem."); }else{ printf("%s\n","Arquivo de imagem aberto com sucesso."); } /**Ler os dados do cabeçalho*/ fscanf(arquivo, "P3 %i %i 255",&largura, &altura); /**Comparação para ver o maior valor da matriz*/ if (largura > altura) { max = largura; }else{ max = altura; } /**Cria uma variável do tipo struct*/ Pixel imagem[max][max]; /**Ler cada Pixel alocando na variável referente ao struct*/ for (i = 0; i < altura; i++){ for(j = 0; j < largura; j++){ fscanf(arquivo, "%i %i %i", &imagem[i][j].r, &imagem[i][j].g, &imagem[i][j].b); } } /**fecha o arquivo*/ fclose(arquivo); do{ /**Menu do programa sendo chamado*/ menu(); printf("\nDigite o comando:>"); /**Comando para leitura do menu*/ scanf("%s",comando); reset(); /**converte as letras para minusculo afim de facilitar a comparação*/ for(i=0;comando[i];i++) comando[i]=tolower(comando[i]); if(strcmp(comando,"lap")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o Filtro de laplace*/ laplace(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"gau")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro de gaus*/ gaussiano(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"blu")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro Blurring*/ passa_baixa(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"sha")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro sharpening*/ passa_alta(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"amp")==0){ printf("\nExecutando o comando: %s\n", comando); printf("\nInforme o zoom desejado:\n"); /**Ler o zoom para ampliar a imagem*/ scanf("%i",&zoom); printf("%s\n", "Informe o nome desejado para saída:"); scanf("%s",arq); /**Chama a função para ampliar da imagem*/ ampliar_img(strcat(arq,".ppm"),zoom,imagem); printf("%s\n", "Imagem ampliada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"red")==0){ printf("\nExecutando o comando: %s\n", comando); printf("\nInforme o zoom desejado:\n"); /**Ler o zoom para reduzir a imagem*/ scanf("%i",&zoom); printf("%s\n", "Informe o nome desejado para saída:"); scanf("%s",arq); /**Chama a função para redução da imagem*/ reduzir_img(strcat(arq,".ppm"),zoom,imagem); printf("%s\n", "Imagem reduzida com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"rel")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro para aplicar o relevo na imagem*/ relevo(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"thr")==0){ printf("\nExecutando o comando: %s\n", comando); printf("\nInforme o valor do thresholding:\n"); scanf("%i",&thr); /**Chama o filtro da binarização*/ binarization(imagem, thr); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem binarizada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"gra")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro para grayscale*/ grayscale(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"inv")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama o filtro para inverter as cores*/ inverter(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem tratada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"esp")==0){ printf("\nExecutando o comando: %s\n", comando); /**Chama a função para espelhar a imagem*/ espelhar(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem espelhada com sucesso."); return (EXIT_SUCCESS); }else if(strcmp(comando,"rot")==0){ printf("%s\n", "Informe o ângulo desejado desejado (90, 180, 270):"); /**Detalha o ângulo de rotação*/ scanf("%i",&angulo); if(angulo == 90){ printf("\nExecutando o comando: %s\n", comando); /**Chama a função para rotacionar a imagem*/ rotacionar_esq(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem rotacionada com sucesso."); return (EXIT_SUCCESS); }else if(angulo == 180){ printf("\nExecutando o comando: %s\n", comando); rotacionar_180(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem rotacionada com sucesso."); return (EXIT_SUCCESS); }else if(angulo == 270){ printf("\nExecutando o comando: %s\n", comando); rotacionar_270(imagem); printf("%s\n", "Informe o nome desejado para saída:"); /**Ler o novo nome para a imagem*/ scanf("%s",arq); gerar_img(imagem, arq); printf("%s\n", "Imagem rotacionada com sucesso."); return (EXIT_SUCCESS); } }else{ /** chama a funcao limpa tela*/ reset(); printf("\nComando desconhecido: %s\n",comando); } }while(strcmp(comando,"exit")!=0); printf("%s\n", "Programa finalizado"); /**Finaliza o programa*/ return (EXIT_SUCCESS); }
int main(int argc, char **argv) { /* create resizable window */ cvNamedWindow(window_name, CV_WINDOW_NORMAL); cvStartWindowThread(); ros::init(argc, argv, "points_image_d_viewer"); ros::NodeHandle n; ros::NodeHandle private_nh("~"); std::string image_topic_name; std::string car_node; std::string pedestrian_node; std::string points_node; if (private_nh.getParam("image_raw_topic", image_topic_name)) { ROS_INFO("Setting image topic to %s", image_topic_name.c_str()); } else { ROS_INFO("No image topic received, defaulting to image_raw, you can use _image_raw_topic:=YOUR_NODE"); image_topic_name = "/image_raw"; } if (private_nh.getParam("car_node", car_node)) { ROS_INFO("Setting car positions node to %s", car_node.c_str()); } else { ROS_INFO("No car positions node received, defaulting to car_pixel_xyz, you can use _car_node:=YOUR_TOPIC"); car_node = "/obj_car/image_obj_ranged"; } if (private_nh.getParam("pedestrian_node", pedestrian_node)) { ROS_INFO("Setting pedestrian positions node to %s", pedestrian_node.c_str()); } else { ROS_INFO("No pedestrian positions node received, defaulting to pedestrian_pixel_xyz, you can use _pedestrian_node:=YOUR_TOPIC"); pedestrian_node = "/obj_person/image_obj_ranged"; } if (private_nh.getParam("points_node", points_node)) { ROS_INFO("Setting pedestrian positions node to %s", points_node.c_str()); } else { ROS_INFO("No points node received, defaulting to points_image, you can use _points_node:=YOUR_TOPIC"); points_node = "/points_image"; } #if (CV_MAJOR_VERSION == 3) generateColors(_colors, 25); #else cv::generateColors(_colors, 25); #endif ros::Subscriber scriber = n.subscribe(image_topic_name, 1, image_cb); ros::Subscriber scriber_car = n.subscribe(car_node, 1, car_updater_callback); ros::Subscriber scriber_ped = n.subscribe(pedestrian_node, 1, ped_updater_callback); ros::Subscriber scriber_points = n.subscribe(points_node, 1, points_cb); cv::Mat grayscale(256,1,CV_8UC1); for(int i=0;i<256;i++) { grayscale.at<uchar>(i)=i; } cv::applyColorMap(grayscale,colormap,cv::COLORMAP_JET); ros::spin(); cvDestroyWindow(window_name); return 0; }
int main(int argc, char *argv[]) { if (argc != 4) { cout << "Usage: " << argv[0] << " cpu|gpu out_func out_prefix" << endl; return 1; } ImageParam input(UInt(8), 3, "input"); Func clamped("clamped"), grayscale("grayscale"); Func g_x("g_x"), g_y("g_y"), g_mag("g_mag"); Func sobel("sobel"); Var c("c"), x("x"), y("y"); // Algorithm clamped(x, y, c) = input( clamp(x, 0, input.width()-1), clamp(y, 0, input.height()-1), c) / 255.f; grayscale(x, y) = clamped(x, y, 0)*0.299f + clamped(x, y, 1)*0.587f + clamped(x, y, 2)*0.114f; Image<int16_t> kernel(3, 3); kernel(0, 0) = -1; kernel(0, 1) = -2; kernel(0, 2) = -1; kernel(1, 0) = 0; kernel(1, 1) = 0; kernel(1, 2) = 0; kernel(2, 0) = 1; kernel(2, 1) = 2; kernel(2, 2) = 1; RDom r(kernel); g_x(x, y) += kernel(r.x, r.y) * grayscale(x + r.x - 1, y + r.y - 1); g_y(x, y) += kernel(r.y, r.x) * grayscale(x + r.x - 1, y + r.y - 1); g_mag(x, y) = sqrt(g_x(x, y)*g_x(x, y) + g_y(x, y)*g_y(x, y)); sobel(x, y, c) = select(c==3, 255, u8(clamp(g_mag(x, y), 0, 1)*255)); // Channel order input.set_stride(0, 4); input.set_extent(2, 4); sobel.reorder_storage(c, x, y); sobel.output_buffer().set_stride(0, 4); sobel.output_buffer().set_extent(2, 4); // Schedules if (!strcmp(argv[1], "cpu")) { sobel.parallel(y).vectorize(c, 4); } else if (!strcmp(argv[1], "gpu")) { sobel.cuda_tile(x, y, 16, 4); } else { cout << "Invalid schedule type '" << argv[1] << "'" << endl; return 1; } compile(sobel, input, argv[2], argv[3]); return 0; }
void gli_draw_picture(picture_t *src, int x0, int y0, int dx0, int dy0, int dx1, int dy1) { unsigned char *sp, *dp; int x1, y1, sx0, sy0, sx1, sy1; int x, y, w, h; sx0 = 0; sy0 = 0; sx1 = src->w; sy1 = src->h; x1 = x0 + src->w; y1 = y0 + src->h; if (x1 <= dx0 || x0 >= dx1) return; if (y1 <= dy0 || y0 >= dy1) return; if (x0 < dx0) { sx0 += dx0 - x0; x0 = dx0; } if (y0 < dy0) { sy0 += dy0 - y0; y0 = dy0; } if (x1 > dx1) { sx1 += dx1 - x1; x1 = dx1; } if (y1 > dy1) { sy1 += dy1 - y1; y1 = dy1; } sp = src->rgba + (sy0 * src->w + sx0) * 4; dp = gli_image_rgb + y0 * gli_image_s + x0 * gli_bpp; w = sx1 - sx0; h = sy1 - sy0; for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { unsigned char sa = sp[x*4+3]; unsigned char na = 255 - sa; unsigned char sr = mul255(sp[x*4+0], sa); unsigned char sg = mul255(sp[x*4+1], sa); unsigned char sb = mul255(sp[x*4+2], sa); #ifdef EFL_1BPP unsigned char sgray = grayscale(sr, sg, sb); #endif #ifdef WIN32 dp[x*3+0] = sb + mul255(dp[x*3+0], na); dp[x*3+1] = sg + mul255(dp[x*3+1], na); dp[x*3+2] = sr + mul255(dp[x*3+2], na); #elif defined __APPLE__ || defined EFL_4BPP dp[x*4+0] = sb + mul255(dp[x*4+0], na); dp[x*4+1] = sg + mul255(dp[x*4+1], na); dp[x*4+2] = sr + mul255(dp[x*4+2], na); dp[x*4+3] = 0xFF; #elif defined EFL_1BPP dp[x] = sgray + mul255(dp[x], na); #else dp[x*3+0] = sr + mul255(dp[x*3+0], na); dp[x*3+1] = sg + mul255(dp[x*3+1], na); dp[x*3+2] = sb + mul255(dp[x*3+2], na); #endif } sp += src->w * 4; dp += gli_image_s; } }
void Tracker::run() { camera = cv::VideoCapture(camera_index); if (force_width) camera.set(CV_CAP_PROP_FRAME_WIDTH, force_width); if (force_height) camera.set(CV_CAP_PROP_FRAME_HEIGHT, force_height); if (force_fps) camera.set(CV_CAP_PROP_FPS, force_fps); aruco::MarkerDetector detector; detector.setDesiredSpeed(3); detector.setThresholdParams(11, 6); cv::Rect last_roi(65535, 65535, 0, 0); cv::Mat color, color_, grayscale, rvec, tvec; const double stateful_coeff = 0.81; if (!camera.isOpened()) { fprintf(stderr, "aruco tracker: can't open camera\n"); return; } while (!stop) if(camera.read(color_)) break; auto freq = cv::getTickFrequency(); auto last_time = cv::getTickCount(); int fps = 0; int last_fps = 0; cv::Point2f last_centroid; while (!stop) { if (!camera.read(color_)) continue; auto tm = cv::getTickCount(); color_.copyTo(color); cv::cvtColor(color, grayscale, cv::COLOR_BGR2GRAY); const int scale = frame.cols > 480 ? 2 : 1; const float focal_length_w = 0.5 * grayscale.cols / tan(0.5 * fov * HT_PI / 180); const float focal_length_h = 0.5 * grayscale.rows / tan(0.5 * fov * grayscale.rows / grayscale.cols * HT_PI / 180.0); cv::Mat intrinsics = cv::Mat::eye(3, 3, CV_32FC1); intrinsics.at<float> (0, 0) = focal_length_w; intrinsics.at<float> (1, 1) = focal_length_h; intrinsics.at<float> (0, 2) = grayscale.cols/2; intrinsics.at<float> (1, 2) = grayscale.rows/2; cv::Mat dist_coeffs = cv::Mat::zeros(5, 1, CV_32FC1); for (int i = 0; i < 5; i++) dist_coeffs.at<float>(i) = 0; std::vector< aruco::Marker > markers; if (last_roi.width > 0 && (detector.detect(grayscale(last_roi), markers, cv::Mat(), cv::Mat(), -1, false), markers.size() == 1 && markers[0].size() == 4)) { detector.setMinMaxSize(std::max(0.2, 0.08 * grayscale.cols / last_roi.width), std::min(1.0, 0.39 * grayscale.cols / last_roi.width)); auto& m = markers.at(0); for (int i = 0; i < 4; i++) { auto& p = m.at(i); p.x += last_roi.x; p.y += last_roi.y; } } else { detector.setMinMaxSize(0.09, 0.4); detector.detect(grayscale, markers, cv::Mat(), cv::Mat(), -1, false); } if (markers.size() == 1 && markers[0].size() == 4) { const aruco::Marker& m = markers.at(0); for (int i = 0; i < 4; i++) cv::line(color, m[i], m[(i+1)%4], cv::Scalar(0, 0, 255), scale, 8); } auto time = cv::getTickCount(); if ((long) (time / freq) != (long) (last_time / freq)) { last_fps = fps; fps = 0; last_time = time; } fps++; char buf[128]; frame = color.clone(); ::sprintf(buf, "Hz: %d", last_fps); cv::putText(frame, buf, cv::Point(10, 32), cv::FONT_HERSHEY_PLAIN, scale, cv::Scalar(0, 255, 0), scale); ::sprintf(buf, "Jiffies: %ld", (long) (10000 * (time - tm) / freq)); cv::putText(frame, buf, cv::Point(10, 54), cv::FONT_HERSHEY_PLAIN, scale, cv::Scalar(80, 255, 0), scale); if (markers.size() == 1 && markers[0].size() == 4) { const aruco::Marker& m = markers.at(0); const float size = 7; cv::Mat obj_points(4,3,CV_32FC1); obj_points.at<float>(1,0)=-size + headpos[0]; obj_points.at<float>(1,1)=-size + headpos[1]; obj_points.at<float>(1,2)=0 + headpos[2]; obj_points.at<float>(2,0)=size + headpos[0]; obj_points.at<float>(2,1)=-size + headpos[1]; obj_points.at<float>(2,2)=0 + headpos[2]; obj_points.at<float>(3,0)=size + headpos[0]; obj_points.at<float>(3,1)=size + headpos[1]; obj_points.at<float>(3,2)=0 + headpos[2]; obj_points.at<float>(0,0)=-size + headpos[0]; obj_points.at<float>(0,1)=size + headpos[1]; obj_points.at<float>(0,2)=0 + headpos[2]; last_roi = cv::Rect(65535, 65535, 0, 0); for (int i = 0; i < 4; i++) { auto foo = m.at(i); last_roi.x = std::min<int>(foo.x, last_roi.x); last_roi.y = std::min<int>(foo.y, last_roi.y); last_roi.width = std::max<int>(foo.x, last_roi.width); last_roi.height = std::max<int>(foo.y, last_roi.height); } { last_roi.width -= last_roi.x; last_roi.height -= last_roi.y; last_roi.x -= last_roi.width * stateful_coeff; last_roi.y -= last_roi.height * stateful_coeff; last_roi.width *= stateful_coeff * 3; last_roi.height *= stateful_coeff * 3; last_roi.x = std::max<int>(0, last_roi.x); last_roi.y = std::max<int>(0, last_roi.y); last_roi.width = std::min<int>(grayscale.cols - last_roi.x, last_roi.width); last_roi.height = std::min<int>(grayscale.rows - last_roi.y, last_roi.height); } cv::solvePnP(obj_points, m, intrinsics, dist_coeffs, rvec, tvec, false, cv::ITERATIVE); cv::Mat rotation_matrix = cv::Mat::zeros(3, 3, CV_64FC1); cv::Mat junk1(3, 3, CV_64FC1), junk2(3, 3, CV_64FC1); cv::Rodrigues(rvec, rotation_matrix); { const double beta = headpitch * HT_PI / 180; double pitch[] = { 1, 0, 0, 0, cos(beta), -sin(beta), 0, sin(beta), cos(beta) }; cv::Mat rot(3, 3, CV_64F, pitch); cv::Mat tvec2 = rot * tvec; rotation_matrix = rot * rotation_matrix; cv::Vec3d euler = cv::RQDecomp3x3(rotation_matrix, junk1, junk2); QMutexLocker lck(&mtx); for (int i = 0; i < 3; i++) pose[i] = tvec2.at<double>(i); pose[Yaw] = euler[1]; pose[Pitch] = -euler[0]; pose[Roll] = euler[2]; } std::vector<cv::Point2f> repr2; std::vector<cv::Point3f> centroid; centroid.push_back(cv::Point3f(0, 0, 0)); cv::projectPoints(centroid, rvec, tvec, intrinsics, dist_coeffs, repr2); { auto s = cv::Scalar(255, 0, 255); cv::circle(frame, repr2.at(0), 4, s, -1); } last_centroid = repr2[0]; } else { last_roi = cv::Rect(65535, 65535, 0, 0); } if (frame.rows > 0) videoWidget->update_image(frame); } }
int main(int argc, char **argv) { unsigned short grafboard; extern int disk_error_handler(int errval, int ax, int bp, int si); char *p; allocatebuffers(); if (init_mem_err) { cprintf("\r\n\r\nSorry, not enough memory to run Toy Universes.\r\n"); return -1; } harderr(disk_error_handler); /* Find out if we have a VGA or EGA at all. */ grafboard = QueryGrafix(); if ((grafboard & 0x200) != 0x200) { printf("This programs requires EGA capability.\n"); exit(-1); } if (grafboard == 0xffff || InitGrafix(-EGA640x350) < 0) { printf("Metagraphics not installed. Execute the command:\n"); printf("metashel /i\n"); printf("and then try again.\n"); exit(-1); } vgaflag = -1; while (argc > 1) { if (argv[1][0] == '-') { switch (argv[1][1]) { case 'e': vgaflag = 0; break; case 'v': vgaflag = 1; break; } } argc--; argv++; } if (vgaflag == -1) { if ((grafboard & 0x300) == 0x300) vgaflag = 1; else vgaflag = 0; } Comm = QueryComm(); if (Comm == MsDriver) InitMouse(MsDriver); else if (Comm == MsCOM1) InitMouse(MsCOM1); else if (Comm == MsCOM2) InitMouse(MsCOM2); else if (Comm & 3) InitMouse(COM1); /* * Probably wrong. Need to check for MS mouse address in some special * way. */ randomize(); p = searchpath("system16.fnt"); if (p) LoadFont(p); installmode(); load_preset_palettes(); usepalette(); current_main_item = 0; usepalette(); TWICE(initialize_buttons()); ShowCursor(); if (allocatefailflag) ErrorBox("Not enough memory for hi-res."); /* Lets see if there is enough for a later gif */ if (!memok(20712L)) /* Added up mallocs in comprs.c */ ErrorBox("There may not be enough memory to save or view a Gif."); prog_init = 1; if (!setjmp(beatit)) { while (!exitflag) { rebuildflag = 0; if (newcaflag && !donescreenflag) { loadlookuptable(increment, maxstate); newcaflag = 0; } if (newcaoflag) { unsigned char *p1,*p2; static int firsttime = true; switch(caotype) { case CA_HODGE: p1 = (char *)HODGE_colortable; p2 = HODGE_ct; break; case CA_EAT: p1 = (char *)EAT_colortable; p2 = EAT_ct; break; case CA_TUBE: p1 = (char *)TUBE_colortable; p2 = TUBE_ct; break; case CA_NLUKY: p1 = (char *)NLUKY_colortable; p2 = NLUKY_ct; break; } memcpy(vgacolortable,p1,16*3); if (!hasVGA) memcpy(egacolortable,p2,16); if (!firsttime) { TWICE(initialize_numbers()); } else firsttime = false; usepalette(); newcaoflag = 0; current_main_item = -1; } if (blankflag) { blankbuffers(); blankflag = 0; } if (randomizeflag) { carandomize(); randomizeflag = 0; } while (!exitflag && !rebuildflag) { if (onestep || !stopped) { if (display_mode == HI) hiresupdate(); else loresupdate(); if (onestep) onestep--; } if (spinflag && (!stopped || (iteration++ > spinspeed))) { if (spinflag == 1) spinpalette(); else revspinpalette(); iteration = 0; } checkkeyboard(); if (newcaflag) rebuildflag = 1; } } } StopMouse(); StopEvent(); grayflag = 0; grayscale(); SetDisplay(TextPg0); return exitflag; }
int main( int argc , const char **argv ) { cv::Mat src, dst; src = cv::imread( "person.jpg" , CV_LOAD_IMAGE_COLOR ); if( src.empty() ) { std::cerr << "Could not open or find the image!" << std::endl; return -1; } cv::namedWindow( "Source Image" , CV_WINDOW_AUTOSIZE ); cv::Mat grayscale; cv::cvtColor( src , grayscale , CV_BGR2GRAY ); cv::equalizeHist( grayscale , grayscale ); cv::CascadeClassifier faceCascade, leftEyeCascade, rightEyeCascade, noseCascade, mouthCascade; faceCascade.load( "frontalface.xml" ); leftEyeCascade.load( "lefteye.xml" ); rightEyeCascade.load( "righteye.xml" ); noseCascade.load( "nose.xml" ); mouthCascade.load( "mouse.xml" ); std::vector< cv::Rect > faces; faceCascade.detectMultiScale( grayscale , faces , 1.2 , 2 , CV_HAAR_DO_CANNY_PRUNING , cv::Size( 50 , 50 ) ); dst.create( src.size() , src.type() ); src.copyTo( dst ); for( std::vector< cv::Rect >::iterator i = faces.begin() ; i != faces.end() ; ++i ) { cv::rectangle( dst , cv::Rect( int( ( *i ).x ) , int( ( *i ).y ) , int( ( *i ).width ) , int( ( *i ).height ) ) , CV_RGB( 0 , 255 , 0 ) , 3 ); cv::Mat face = grayscale( *i ); std::vector< cv::Rect > leftEyes; leftEyeCascade.detectMultiScale( grayscale , leftEyes , 1.2 , 2 , CV_HAAR_DO_CANNY_PRUNING , cv::Size( 30 , 30 ) ); cv::Point center( leftEyes[ 1 ].x + leftEyes[ 1 ].width * 0.5 , leftEyes[ 1 ].y + leftEyes[ 1 ].height * 0.5 ); int radius = cvRound( ( leftEyes[ 1 ].width + leftEyes[ 1 ].height ) * 0.25 ); cv::circle( dst , center , radius , CV_RGB( 255 , 0 , 0 ) , 2 ); std::vector< cv::Rect > rightEyes; rightEyeCascade.detectMultiScale( grayscale , rightEyes , 1.2 , 2 , CV_HAAR_DO_CANNY_PRUNING , cv::Size( 30 , 30 ) ); center = cv::Point( rightEyes[ 1 ].x + rightEyes[ 1 ].width * 0.5 , rightEyes[ 1 ].y + rightEyes[ 1 ].height * 0.5 ); radius = cvRound( ( rightEyes[ 1 ].width + rightEyes[ 1 ].height ) * 0.25 ); cv::circle( dst , center , radius , CV_RGB( 0 , 0 , 255 ) , 2 ); std::vector< cv::Rect > noses; noseCascade.detectMultiScale( grayscale , noses , 1.2 , 2 , CV_HAAR_DO_CANNY_PRUNING , cv::Size( 30 , 30 ) ); if( !noses.empty() ) cv::rectangle( dst , cv::Rect( int( noses[ 0 ].x ) , int( noses[ 0 ].y ) , int( noses[ 0 ].width ) , int( noses[ 0 ].height ) ) , CV_RGB( 0 , 255 , 255 ) , 2 ); std::vector< cv::Rect > mouthes; mouthCascade.detectMultiScale( grayscale , mouthes , 1.2 , 2 , CV_HAAR_DO_CANNY_PRUNING , cv::Size( 30 , 30 ) ); if( !mouthes.empty() ) cv::rectangle( dst , cv::Rect( int( mouthes[ 0 ].x ) , int( mouthes[ 0 ].y ) , int( mouthes[ 0 ].width ) , int( mouthes[ 0 ].height ) ) , CV_RGB( 255 , 255 , 0 ) , 2 ); } imshow( "Source Image" , src ); imshow( "Grayscale Image" , grayscale ); imshow( "Face Detector" , dst ); cv::waitKey( 0 ); cv::destroyAllWindows(); return 0; }
void FaceDetector::imageCallback(const sensor_msgs::Image::ConstPtr& image_ptr) { #ifdef marco_debug ROS_INFO("imagecallback called"); #endif cv_bridge::CvImagePtr cv_ptr; try { cv_ptr = cv_bridge::toCvCopy(image_ptr, sensor_msgs::image_encodings::RGB8); } catch (cv_bridge::Exception& e) { ROS_ERROR("cv_bridge exception: %s", e.what()); return; } cv::Mat image_received = (cv_ptr->image).clone(); image_size_ = cv_ptr->image.size(); vector<cv::Rect> faces_roi; cv::Mat grayscale; cv::cvtColor(image_received,grayscale,CV_RGB2GRAY); // marco: converting to grayscale before haar detection detectFacesHaar(image_received, faces_roi,face_classifier_); if(faces_roi.size() > 0) //If Haar cascade classifier found a face { #ifdef marco_debug ROS_INFO("haar cascade found a face"); #endif vector<cv::Rect> eyes_roi; detectFacesHaar(grayscale(faces_roi[0]), eyes_roi,alternative_face_classifier_); if (eyes_roi.size()>0) { //ROS_INFO("HAAR CLASSIFIER FOUND A FACE"); face_detected_bool_ = true; track_object_ = false; //Changed detected_face_roi_ = faces_roi[0]; detected_face_ = cv_ptr->image(detected_face_roi_); } else face_detected_bool_=false; } else { face_detected_bool_=false; } // >>>>>>>> KALMAN double precTick = ticks_; ticks_ = (double) cv::getTickCount(); double dT = (ticks_ - precTick) / cv::getTickFrequency(); //seconds if (found_) { // >>>> Matrix A kalman_filter_.transitionMatrix.at<float>(2) = dT; kalman_filter_.transitionMatrix.at<float>(9) = dT; // <<<< Matrix A state_ = kalman_filter_.predict(); //cout << "State post:" << endl << state_ << endl; cv::Rect predRect; predRect.width = state_.at<float>(4); predRect.height = state_.at<float>(5); predRect.x = state_.at<float>(0) - predRect.width / 2; predRect.y = state_.at<float>(1) - predRect.height / 2; cv::Point center; center.x = state_.at<float>(0); center.y = state_.at<float>(1); cv::circle(image_received, center, 2, CV_RGB(255,0,0), -1); cv::rectangle(image_received, predRect, CV_RGB(255,0,0), 2); } if (!face_detected_bool_) { notFoundCount_++; //cout << "notFoundCount:" << notFoundCount_ << endl; if( notFoundCount_ >= 10 ) { found_ = false; } else { kalman_filter_.statePost = state_; } } else { notFoundCount_ = 0; meas_.at<float>(0) = (float)(detected_face_roi_.x + detected_face_roi_.width/2); meas_.at<float>(1) = (float)(detected_face_roi_.y + detected_face_roi_.height/2); meas_.at<float>(2) = (float)detected_face_roi_.width; meas_.at<float>(3) = (float)detected_face_roi_.height; if (!found_) // First detection! { // >>>> Initialization kalman_filter_.errorCovPre.at<float>(0) = 1; // px kalman_filter_.errorCovPre.at<float>(7) = 1; // px kalman_filter_.errorCovPre.at<float>(14) = 1; kalman_filter_.errorCovPre.at<float>(21) = 1; kalman_filter_.errorCovPre.at<float>(28) = 1; // px kalman_filter_.errorCovPre.at<float>(35) = 1; // px state_.at<float>(0) = meas_.at<float>(0); state_.at<float>(1) = meas_.at<float>(1); state_.at<float>(2) = 0; state_.at<float>(3) = 0; state_.at<float>(4) = meas_.at<float>(2); state_.at<float>(5) = meas_.at<float>(3); // <<<< Initialization found_ = true; } else kalman_filter_.correct(meas_); // Kalman Correction // cout << "Measure matrix:" << endl << meas_ << endl; } float head_distance; // ROS_INFO("Computing head distance"); if(!face_detected_bool_) { if(head_distances_.size()!=0) { head_distance=head_distances_[0];//100; } else head_distance = 3.0; } else { head_distance=calcDistanceToHead(detected_face_, kalman_filter_); #ifdef marco_debug ROS_ERROR ("COMPUTED HEAD DISTANCE: %f",head_distance); #endif } if(head_distances_.size()==0) { for(int i=0;i<10;i++) head_distances_.push_back(head_distance); } else { head_distances_.pop_back(); head_distances_.insert(head_distances_.begin(),head_distance); } #ifdef marco_debug ROS_INFO("head distance computed"); #endif head_distance=0; //Reuse variable to compute mean head distance //Use mean distance of last measured head distances for(unsigned int i=0;i<head_distances_.size();i++) head_distance+=head_distances_[i]; head_distance=head_distance/head_distances_.size(); //ROS_ERROR ("HEAD DISTANCE AFTER MEAN COMPUTING: %f",head_distance); #ifdef marco_debug ROS_INFO("updated undetected count"); #endif if(head_distance != head_distance) //not a number head_distance=3.0; //Create HeadDistance message std_msgs::Float32 head_distance_msgs; head_distance_msgs.data=head_distance; face_distance_pub_.publish(head_distance_msgs); //Create Face Pos and Size message sensor_msgs::JointState message; int servos_count=2; message.name.resize(servos_count); message.position.resize(servos_count); message.velocity.resize(servos_count); message.name[0]="head_pan_joint"; //izquierda-derecha message.name[1]="head_tilt_joint"; //arriba-abajo message.header.stamp = ros::Time::now(); #ifdef marco_debug ROS_INFO("message created"); #endif if( notFoundCount_ >= 10 ) { float rand_tilt = search_min_tilt_+((search_max_tilt_-search_min_tilt_) * double(rand()%20)/20.); float rand_pan = search_min_pan_+((search_max_pan_-search_min_pan_) * double(rand()%20)/20.); message.position[0]=rand_pan; message.position[1]=rand_tilt; message.velocity[0]=search_pan_vel_; message.velocity[1]=search_tilt_vel_; //ROS_ERROR("RANDOM MOVE: tilt: %f pan: %f",rand_tilt,rand_pan); random_=true; } else { if(face_detected_bool_) { float pan_pos=meas_.at<float>(0); // it was meas_ float tilt_pos=meas_.at<float>(1); pan_pos=scalePan(pan_pos); tilt_pos=scaleTilt(tilt_pos); message.position[0]=yaw_from_joint_ + pan_pos; message.position[1]=pitch_from_joint_ + tilt_pos; message.velocity[0]=abs(pan_pos*1.3) ; message.velocity[1]=abs(tilt_pos*1.5); } else { float pan_pos=state_.at<float>(0); // it was meas_ float tilt_pos=state_.at<float>(1); pan_pos=scalePan(pan_pos); tilt_pos=scaleTilt(tilt_pos); message.position[0]=yaw_from_joint_ + pan_pos; message.position[1]=pitch_from_joint_ + tilt_pos; message.velocity[0]=abs(pan_pos*1.3); message.velocity[1]=abs(tilt_pos*1.5); } //ROS_ERROR("KALMAN MOVE: pan: %f --- tilt: %f",message.position[0], message.position[1]); random_=false; } cv::imshow("Kalman predictor", image_received); cvWaitKey(1); /* * Publish joint state */ #ifdef marco_debug ROS_INFO("publishing: pan_pos: %lg --- tilt_pos: %lg",message.position[0],message.position[1]); #endif joint_pub_.publish(message); //ROS_ERROR("JOint state yaw_from_joint_: %f",yaw_from_joint_); sendBaseVelocity(head_distance); }
int main( int agrc, char** argv ) { uint8_t *raw; char *filename = argv[1]; image_width = atoi( argv[2] ); image_height = atoi( argv[3] ); printf( "%s %d %d\n", filename, image_width, image_height ); stride = image_width+2; raw = read_raw( filename ); write_padded( "padded.raw", raw ); uint8_t *blurred = malloc( stride*(image_height+2)*4 ); clock_t start = clock(); /* Box Blur applied 3 times is extremely similar to Gaussian blur */ for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( raw, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( blurred, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { average_neighbors( blurred, blurred, x, y ); } } clock_t end = clock(); float seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "Regular box blur took %f seconds\n", seconds ); write_raw( "blurred.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); /* Box Blur applied 3 times is extremely similar to Gaussian blur */ for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( raw, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( blurred, blurred, x, y ); } } for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=2 ) { average_neighbors_simd( blurred, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "SIMD blur took %f seconds\n", seconds ); write_raw( "blurred_simd.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { grayscale( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "grayscale took %f seconds\n", seconds ); write_raw( "grayscale.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x+=8 ) { grayscale_simd( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "grayscale SIMD took %f seconds\n", seconds ); write_raw( "grayscale_simd.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { sharpen( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "sharpen took %f seconds\n", seconds ); write_raw( "sharpen.raw", blurred ); start = clock(); memset( blurred, 0, stride*(image_height+2)*4 ); for ( int y = 0; y < image_height+2; y++ ) { for ( int x = 0; x < stride; x++ ) { sharpen_simd( raw, blurred, x, y ); } } end = clock(); seconds = (float)(end - start) / CLOCKS_PER_SEC; printf( "sharpen SIMD took %f seconds\n", seconds ); write_raw( "sharpen_simd.raw", blurred ); free( raw ); free( blurred ); return 0; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); // canvas imageLabel = new QLabel("Загрузите изображение"); imageLabel->setBackgroundRole(QPalette::Dark); ui->scrollArea->setWidget(imageLabel); imageLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter); imageLabel->setBackgroundRole(QPalette::Base); // layouts ui->centralWidget->setLayout(ui->mainLayout); ui->scrollArea->setBackgroundRole(QPalette::Dark); ui->toolsDock->setWidget(ui->toolsScrollArea); ui->toolsLayout->setMargin(10); ui->toolsScrollAreaContent->setLayout(ui->toolsLayout); ui->brightnessDock->setWidget(ui->brightnessScrollArea); ui->brightnessLayout->setMargin(10); ui->brightnessScrollAreaContents->setLayout(ui->brightnessLayout); ui->filtersDock->setWidget(ui->filtersScrollArea); ui->filtersLayout->setMargin(5); ui->filtersScrollArea->setLayout(ui->filtersLayout); ui->multiTab->setLayout(ui->multiLayout); ui->multiLayout->setMargin(10); ui->additTab->setLayout(ui->additLayout); ui->additLayout->setMargin(10); ui->impulseTab->setLayout(ui->impulseLayout); ui->impulseLayout->setMargin(10); ui->analysisTab->setLayout(ui->analysisLayout); ui->analysisLayout->setMargin(10); ui->autolevelsGroupBox->setLayout(ui->autolevelsLayout); ui->linContrastGroupBox->setLayout(ui->linContrastLayout); //ui->autolevelsLayout->setMargin(5); ui->brightnessDock->hide(); // signals & slots connect(ui->loadButton, SIGNAL(clicked()), this, SLOT(loadImage())); connect(ui->showToolsAction, SIGNAL(toggled(bool)), ui->toolsDock, SLOT(setShown(bool))); connect(ui->showBrightnessAction, SIGNAL(toggled(bool)), ui->brightnessDock, SLOT(setShown(bool))); connect(ui->showProcessedButton, SIGNAL(clicked()), this, SIGNAL(restoreImage())); connect(ui->noiseDial, SIGNAL(valueChanged(int)), this, SIGNAL(rateChanged(int))); connect(ui->filterOffsetBox, SIGNAL(valueChanged(int)), this, SIGNAL(offsetChanged(int))); connect(ui->actionGrayscale, SIGNAL(triggered()), this, SIGNAL(grayscale())); connect(ui->histAction, SIGNAL(triggered()), this, SIGNAL(showHist())); connect(ui->invertseAction, SIGNAL(triggered()), this, SIGNAL(inverse())); connect(ui->equalizeAction, SIGNAL(triggered()), this, SIGNAL(equalize())); // test connect(ui->showConvolutionAction, SIGNAL(toggled(bool)), ui->filtersDock, SLOT(setShown(bool))); ui->collectionsTab->setLayout(ui->collectionsLayout); ui->collectionsLayout->setMargin(5); this->resize(1000, 600); this->move(50, 50); this->raise(); }
ImageRAII canny( IplImage * image, std::pair< int, int > thresh, double sigma ) { const char * WINDOW_NAME = "Basic Canny Edge Detector"; ImageRAII grayscale( cvCreateImage( cvGetSize( image ), image->depth, 1 ) ); ImageRAII destination( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); ImageRAII gaussian( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); ImageRAII gradient_x( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); ImageRAII gradient_y( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); ImageRAII gradient( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); ImageRAII orientation( cvCreateImage( cvGetSize( image ), image->depth, grayscale.image->nChannels ) ); // convert image to grayscale cvCvtColor( image, grayscale.image, CV_BGR2GRAY ); // gaussian smoothing cvSmooth( grayscale.image, gaussian.image, CV_GAUSSIAN, GAUSSIAN_X, GAUSSIAN_Y, sigma ); // find edge strength cvSobel( gaussian.image, gradient_x.image, 1, 0, 3 ); cvSobel( gaussian.image, gradient_y.image, 0, 1, 3 ); // find edge orientation CvSize image_size = cvGetSize( gaussian.image ); for( int i = 0; i < image_size.width; i++ ) { for( int j = 0; j < image_size.height; j++ ) { double x = cvGet2D( gradient_x.image, j, i ).val[0]; double y = cvGet2D( gradient_y.image, j, i ).val[0]; float angle; if( x == 0 ) { if( y == 0 ) angle = 0; else angle = 90; } else angle = cvFastArctan( y, x ); CvScalar g; CvScalar a; g.val[0] = cvSqrt( pow( x, 2 ) + pow( y, 2 ) ); a.val[0] = find_angle( angle ); cvSet2D( destination.image, j, i, g ); cvSet2D( orientation.image, j, i, a ); } } ImageRAII suppressed_image = nonMaxSup( destination.image, orientation.image ); ImageRAII hysteresis_image = hysteresis( suppressed_image.image, orientation.image, thresh ); cvNamedWindow( WINDOW_NAME ); cvShowImage( WINDOW_NAME, destination.image ); cvMoveWindow( WINDOW_NAME, image_size.width, 0 ); return hysteresis_image; }