void save_files() { char fn1[255], fn2[255]; FILE *f1, *f2; gray **image1, **image2; image1 = pgm_allocarray(wid, hgt); image2 = pgm_allocarray(wid, hgt); for (int i=0; i<wid*hgt; i++) { image1[i/wid][i%wid] = (gray) data1[i]; image2[i/wid][i%wid] = (gray) data2[i]; } snprintf(fn1, 256, "%s_%+.1f_.pgm", fname1, angle_value->value()); snprintf(fn2, 256, "%s_%+.1f_.pgm", fname2, angle_value->value()); f1 = fopen(fn1, "w"); f2 = fopen(fn2, "w"); pgm_writepgm(f1, image1, wid, hgt, 65535, false); pgm_writepgm(f2, image2, wid, hgt, 65535, false); fclose(f1); fclose(f2); pgm_freearray(image1, hgt); pgm_freearray(image2, hgt); fl_beep(FL_BEEP_MESSAGE); }
/** frees the data */ void GeoImage::freeData() { if (data_) { switch (type_) { case PBM: pbm_freearray(data_, rows_); break; case PGM: pgm_freearray(data_, rows_); break; case PPM: ppm_freearray(data_, rows_); break; case PFM_3BYTE:{ PFM3Byte *ppmbuf = (PFM3Byte *) data_; free(ppmbuf->r); free(ppmbuf->g); free(ppmbuf->b); free(data_); } break; default: free(data_); break; } data_ = 0; dataSize_=0; } }
void pnm_pgm_free(pgm_t *pgm) { if (!pgm) return; if (pgm->pixels) pgm_freearray(pgm->pixels, pgm->rows); pnm_pgm_init(pgm); }
void pgm_erode( gray **pgm, int cols, int rows, int num ) { int n, i, j; gray **tmp_pgm; /* allocate space */ tmp_pgm = pgm_allocarray(cols, rows); if (tmp_pgm == NULL) pm_error("no more memory."); for (n=0; n < num; n++) { /* copy pgm -> tmp_pgm */ for (i=0; i < rows; i++) for (j=0; j < cols; j++) tmp_pgm[i][j] = pgm[i][j]; /* dilate 1 pixel */ for (i=1; i < rows-1; i++) for (j=1; j < cols-1; j++) if (tmp_pgm[i][j] == OBJECT && (tmp_pgm[i-1][j-1] == BACKGROUND || tmp_pgm[i-1][j ] == BACKGROUND || tmp_pgm[i-1][j+1] == BACKGROUND || tmp_pgm[i ][j-1] == BACKGROUND || tmp_pgm[i ][j+1] == BACKGROUND || tmp_pgm[i+1][j-1] == BACKGROUND || tmp_pgm[i+1][j ] == BACKGROUND || tmp_pgm[i+1][j+1] == BACKGROUND)) pgm[i][j] = BACKGROUND; } /* end for */ pgm_freearray(tmp_pgm, rows); } /* end pgm_erode() */
int main(int argc, char *argv[]) { int saca_pgm(); FILE *fd; FILE *fd1; int cols, rows, i, j, bucle, carpeta, nresultados; float carac[11]; gray maxval; gray **imagen; gray **imagen1; struct dirent **resultados=NULL; // inicializamos todas las variables pgm_init(&argc, argv); nresultados=0; printf("Haciendo magia...\n"); fd = fopen(filepatron, "r"); if (fd == NULL ) { pm_error("error: no puedo abrir los ficheros"); exit(-1); } imagen = pgm_readpgm(fd, &cols, &rows, &maxval); if (imgpatron == NULL ) { pm_error("error: no puedo leer las imagenes"); exit(-1); } // abrimos el fichero de imagen en modo lectura fd1 = fopen(argv[1], "r"); if (fd1 == NULL ) { pm_error("error: no puedo abrir los ficheros"); exit(-1); } // leemos la imagen imagen1 = pgm_readpgm(fd1, &cols, &rows, &maxval); if (imagen == NULL ) { pm_error("error: no puedo leer las imagenes"); exit(-1); } //*******************************************************************// //en 'imagen' tenemos la foto a analizar para el fichero clasificador// //*******************************************************************// for(i=0; i<rows;i++){ for(j=0; j<cols; j++){ //Retiramos fondo por division imagen[i][j] = MIN(255, 255*((float)imagen[i][j]/(float)imgpatron[i][j]) ); //Aplicamos umbral if(imagen[i][j] <= 210) imagen[i][j] = 0; else imagen[i][j] = 255; } } // <----- falta erosionar y dilatar!!! /* dilate */ pgm_dilate(imagen, cols, rows, 2); /* erode */ pgm_erode(imagen, cols, rows, 2); pgm_writepgm(stdout, imagen, cols, rows, 255, 0); fclose(fd); //Liberamos la memoria de la imagen, para cargar otra pgm_freearray(imagen, rows); printf("Fin de la magia...\n"); fclose(patron); exit(0); }
int main( int argc, char *argv[] ){ int fd, err, n, r, w, k; struct v4l2_fmtdesc fmts; struct v4l2_streamparm parm; struct v4l2_format fmt; struct v4l2_requestbuffers req; struct v4l2_buffer buf; enum v4l2_buf_type type; void *vbuffers[VIDEO_BUFFERS]; size_t vbuffers_lenght[VIDEO_BUFFERS]; //char filename[512]; //FILE *fi; gray **image_pgm; //pixel **image_ppm; int cols, rows; fd_set fds; struct timeval tout; // open camera fd = open(VIDEO_DEVICE, O_RDWR | O_NONBLOCK); if (fd == -1) { perror ("Open"); exit(-1); } // end if fprintf(stderr, "Dispositivo %s abierto:\n", VIDEO_DEVICE); // formatos de video fprintf(stderr, " |-> Formatos de video disponibles:\n"); // formatos aceptados por la camara bzero(&fmts, sizeof(fmts)); // poner a ceros fmts.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; fmts.index = 0; err = ioctl(fd, VIDIOC_ENUM_FMT, &fmts); while (err != -1) { fprintf(stderr, " | |-> #%d: %s (0x%x %s)\n", fmts.index, fmts.description, fmts.pixelformat, (fmts.flags & V4L2_FMT_FLAG_COMPRESSED) ? "comprimido" : ""); fmts.index++; err = ioctl(fd, VIDIOC_ENUM_FMT, &fmts); } // end while // set framerate bzero(&parm, sizeof(parm)); // poner a ceros parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; parm.parm.capture.timeperframe.numerator = 1; parm.parm.capture.timeperframe.denominator = 30; // FPS if ((err = ioctl(fd, VIDIOC_S_PARM, &parm))<0) { perror("VIDIOC_S_PARAM"); exit(-1); } // end if fprintf(stderr, " |-> FPS: %d\n", parm.parm.capture.timeperframe.denominator); // set resolution & video format bzero(&fmt, sizeof(fmt)); // poner a ceros fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; fmt.fmt.pix.width = VIDEO_ANCHO; // columnas fmt.fmt.pix.height = VIDEO_ALTO; // filas fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG; // modo de video if ((err = ioctl(fd, VIDIOC_S_FMT, &fmt))<0) { perror("VIDIOC_S_FMT"); exit(-1); } // end if fprintf(stderr, " |-> Tama�o: %dx%d\n", fmt.fmt.pix.width, fmt.fmt.pix.height); fprintf(stderr, " |-> Formato: MJPEG\n"); // solicita buffers para el video bzero(&req, sizeof(req)); req.count = VIDEO_BUFFERS; // numero de buffer que se solicitaran req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; req.memory = V4L2_MEMORY_MMAP; if ((err = ioctl(fd, VIDIOC_REQBUFS, &req))<0) { perror("VIDIOC_REQBUFS"); exit(-1); } // end if // mapeo los buffers en memoria for (n = 0; n < req.count; n++) { bzero(&buf, sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = n; if ((err = ioctl(fd, VIDIOC_QUERYBUF, &buf))<0) { perror("VIDIOC_QUERYBUF"); exit(-1); } // end if FORMATO DE LOS BUFFERS vbuffers_lenght[n] = buf.length; vbuffers[n] = mmap(NULL, buf.length, PROT_READ | PROT_WRITE /* required */, MAP_SHARED /* recommended */, fd, buf.m.offset); if (vbuffers[n] == MAP_FAILED) { perror("mmap"); exit(-1); } // end if } // end for fprintf(stderr, " |-> Buffers mapeados: %d\n", req.count); // encola los buffers en el driver de la camara BUFFERS VACIOS for (n=0; n< VIDEO_BUFFERS; n++) { bzero(&buf, sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = n; if ((err = ioctl(fd, VIDIOC_QBUF, &buf))<0) { perror("VIDIOC_QBUF"); exit(-1); } // end if } // end for //activa captura de video type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if ((err = ioctl (fd, VIDIOC_STREAMON, &type))<0) { perror("VIDIOC_STREAMON"); exit(-1); } // end if fprintf(stderr, "Video activo.\n"); eaw_init(); w = eaw_new_window("Prac2", 800, 600); n=0; // captura imagenes do{ // leer imagen do { // espera a que llegue una imagen con timeout FD_ZERO (&fds); // conjunto vacio FD_SET (fd, &fds); // annade fd tout.tv_sec = 3; // Timeout de 3 segundos tout.tv_usec = 0; r = select (fd + 1, &fds, NULL, NULL, &tout); // espera // control de errores if (r == -1) { if (errno == EINTR) continue; perror("select"); exit(-1); } // end if if (r == 0) { fprintf (stderr, "Imagen timeout.\n"); exit(-1); } // end if // desencola el buffer bzero(&buf, sizeof(buf)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; if ((err = ioctl(fd, VIDIOC_DQBUF, &buf))<0) { switch (errno) { case EAGAIN: // nothing yet continue; case EIO: // se puede ignorar EIO default: perror("VIDIOC_DQBUF"); exit(-1); } // end switch } // end if break; } while (1); //fprintf(stderr, "Captura %02d Ok.", n); // convert to pgm and save image_pgm = sdv_jpeg_to_pgm(vbuffers[buf.index], &cols, &rows); if (!image_pgm) { fprintf(stderr, "Bad JPG image.\n"); } else { if(n>0) eaw_draw_image(w, image_pgm, cols, rows); pgm_freearray(image_pgm, rows); } // end if/else // devolver el buffer al driverec if ((err = ioctl(fd, VIDIOC_QBUF, &buf))<0) { perror("VIDIOC_QBUF"); exit(-1); } // end if k = eaw_wait_a_key(5) & 0xFF; n++; }while( k!= 'q'); // end do // Cerrando ventana y video eaw_close_window(w); // detener el video type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if ((err = ioctl (fd, VIDIOC_STREAMOFF, &type))<0) { perror("VIDIOC_STREAMOFF"); exit(-1); } // end if // unmap buffers for (n=0; n<VIDEO_BUFFERS; ++n) { if (munmap (vbuffers[n], vbuffers_lenght[n])<0) { perror("munmap"); exit(-1); } // end if } // end for // close camera close(fd); fprintf(stderr, "Dispositivo %s cerrado.\n", VIDEO_DEVICE); exit(0); } // end main()
static GtsSurface * happrox (gray ** g, gint width, gint height, CostFunc cost_func, gpointer cost_data, GtsStopFunc stop_func, gpointer stop_data) { GtsSurface * s = gts_surface_new (gts_surface_class (), GTS_FACE_CLASS (list_face_class ()), gts_edge_class (), gts_vertex_class ()); GtsVertex * v1 = gts_vertex_new (s->vertex_class, 0., 0., g[0][0]); GtsVertex * v2 = gts_vertex_new (s->vertex_class, 0., height - 1, g[height - 1][0]); GtsVertex * v3 = gts_vertex_new (s->vertex_class, width - 1, 0., g[0][width - 1]); GtsVertex * v4 = gts_vertex_new (s->vertex_class, width - 1, height - 1, g[height - 1][width - 1]); guint i, j; GSList * corners = NULL; GtsTriangle * t; GtsVertex * w1, * w2, * w3; GtsListFace * f; /* creates enclosing triangle */ corners = g_slist_prepend (corners, v1); corners = g_slist_prepend (corners, v2); corners = g_slist_prepend (corners, v3); corners = g_slist_prepend (corners, v4); t = gts_triangle_enclosing (gts_triangle_class (), corners, 100.); g_slist_free (corners); gts_triangle_vertices (t, &w1, &w2, &w3); f = GTS_LIST_FACE (gts_face_new (s->face_class, t->e1, t->e2, t->e3)); gts_surface_add_face (s, GTS_FACE (f)); /* add PGM vertices (corners excepted) to point list of f */ for (i = 1; i < width - 1; i++) { for (j = 1; j < height - 1; j++) prepend (f, g, i, j); prepend (f, g, i, 0); prepend (f, g, i, height - 1); } for (j = 1; j < height - 1; j++) { prepend (f, g, 0, j); prepend (f, g, width - 1, j); } pgm_freearray (g, height); /* add four corners to initial triangulation */ g_assert (gts_delaunay_add_vertex_to_face (s, v1, GTS_FACE (f)) == NULL); f = GTS_LIST_FACE (gts_point_locate (GTS_POINT (v2), s, NULL)); g_assert (gts_delaunay_add_vertex_to_face (s, v2, GTS_FACE (f)) == NULL); f = GTS_LIST_FACE (gts_point_locate (GTS_POINT (v3), s, NULL)); g_assert (gts_delaunay_add_vertex_to_face (s, v3, GTS_FACE (f)) == NULL); f = GTS_LIST_FACE (gts_point_locate (GTS_POINT (v4), s, NULL)); g_assert (gts_delaunay_add_vertex_to_face (s, v4, GTS_FACE (f)) == NULL); /* refine surface */ surface_hf_refine (s, cost_func, cost_data, stop_func, stop_data); /* destroy unused vertices */ gts_surface_foreach_face (s, (GtsFunc) destroy_unused, NULL); /* destroy enclosing triangle */ gts_allow_floating_vertices = TRUE; gts_object_destroy (GTS_OBJECT (w1)); gts_object_destroy (GTS_OBJECT (w2)); gts_object_destroy (GTS_OBJECT (w3)); gts_allow_floating_vertices = FALSE; return s; }
int main(int argc, char *argv[]) { FILE *in = stdin; FILE *out = stdout; FILE *sig = NULL; char output_name[MAXPATHLEN] = "(stdout)"; char input_name[MAXPATHLEN] = "(stdin)"; char signature_name[MAXPATHLEN]; int i, c, w; int row; int n; double alpha = 0.0; double beta = 0.0; int filter = 0; int method = -1; int level = 0; char filter_name[MAXPATHLEN] = ""; int verbose = 0; gray **image; Image_tree dwts; gray maxval; int rows, cols, format; double *watermark; progname = argv[0]; pgm_init(&argc, argv); wm_init(); while ((c = getopt(argc, argv, "a:b:e:f:F:h?o:s:v:")) != EOF) { switch (c) { case 'a': alpha = atof(optarg); if (alpha <= 0.0) { fprintf(stderr, "%s: alpha factor %f out of range\n", progname, alpha); exit(1); } break; case 'b': beta = atof(optarg); if (beta <= 0.0) { fprintf(stderr, "%s: beta factor %f out of range\n", progname, beta); exit(1); } break; case 'e': method = atoi(optarg); if (method < 0) { fprintf(stderr, "%s: wavelet filtering method %d out of range\n", progname, method); exit(1); } break; case 'f': filter = atoi(optarg); if (filter <= 0) { fprintf(stderr, "%s: filter number %d out of range\n", progname, filter); exit(1); } break; case 'F': strcpy(filter_name, optarg); break; case 'h': case '?': usage(); break; case 'o': if ((out = fopen(optarg, "wb")) == NULL) { fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg); exit(1); } strcpy(output_name, optarg); break; case 's': if ((sig = fopen(optarg, "r")) == NULL) { fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg); exit(1); } strcpy(signature_name, optarg); break; case 'v': verbose = atoi(optarg); if (verbose < 0) { fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose); exit(1); } break; } } argc -= optind; argv += optind; if (argc > 1) { usage(); exit(1); } if (argc == 1 && *argv[0] != '-') { if ((in = fopen(argv[0], "rb")) == NULL) { fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]); exit(1); } else strcpy(input_name, argv[0]); } if (sig) { char line[32]; fgets(line, sizeof(line), sig); if (strspn(line, "WGSG") >= 4) { fscanf(sig, "%d\n", &n); if (alpha == 0.0) fscanf(sig, "%lf\n", &alpha); else fscanf(sig, "%*f\n"); if (beta == 0.0) fscanf(sig, "%lf\n", &beta); else fscanf(sig, "%*f\n"); if (method < 0) fscanf(sig, "%d\n", &method); else fscanf(sig, "%*d\n"); if (filter == 0) fscanf(sig, "%d\n", &filter); else fscanf(sig, "%*d\n"); if (!strcmp(filter_name, "")) fscanf(sig, "%[^\n\r]\n", filter_name); else fscanf(sig, "%*[^\n\r]\n"); } else { fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name); exit(1); } } else { fprintf(stderr, "%s: signature file not specified, use -s file option\n", progname); exit(1); } watermark = malloc(n * sizeof(double)); for (i = 0; i < n; i++) fscanf(sig, "%lf\n", &watermark[i]); fclose(sig); pgm_readpgminit(in, &cols, &rows, &maxval, &format); image = pgm_allocarray(cols, rows); for (row = 0; row < rows; row++) pgm_readpgmrow(in, image[row], cols, maxval, format); fclose(in); // complete decomposition level = find_deepest_level(cols, rows) - 1; // wavelet transform init_dwt(cols, rows, filter_name, filter, level, method); #ifdef POLLEN_STUFF #include "pollen_stuff.c" #endif #ifdef PARAM_STUFF #include "param_stuff.c" #endif dwts = fdwt(image); // build tree for subband selection, calculate subband thresholds init_subbands(dwts); set_subbands_type_beta(HORIZONTAL, beta); set_subbands_type_beta(VERTICAL, beta); calc_subbands_threshold(); w = 0; while (w < n) { Subband_data s; // select subband with max. threshold s = select_subband(); if (verbose > 1) fprintf(stderr, "%s: selected subband %s%d, T=%lf, beta=%lf\n", progname, subband_name(s->type), s->level, s->T, s->beta); // watermark significant coefficients and set them selected // check is entire signature has been embedded c = select_subband_coeff(s); do { double p; if (c < 0) // no more significant coefficients in subband break; p = get_subband_coeff(s, c); if (p < s->Cmax) { if (verbose > 2) fprintf(stderr, "%s: embedding sig. coeff. #%d (= %lf)\n into %s%d coeff. #%d\n", progname, w, watermark[w], subband_name(s->type), s->level, c); p = p + alpha * s->beta * s->T * watermark[w]; set_subband_coeff(s, c, p); w++; } mark_subband_coeff(s, c); // select next significant coefficient c = select_subband_coeff_from(s, c); } while (w < n); // update subband threshold s->T /= 2.0; } free_subbands(); free(watermark); idwt(dwts, image); pgm_writepgminit(out, cols, rows, maxval, 0); for (row = 0; row < rows; row++) pgm_writepgmrow(out, image[row], cols, maxval, 0); fclose(out); pgm_freearray(image, rows); exit(0); }
int main(int argc, char *argv[]) { FILE *in = stdin; FILE *out = stdout; FILE *sig = NULL; char output_name[MAXPATHLEN] = "(stdout)"; char input_name[MAXPATHLEN] = "(stdin)"; char signature_name[MAXPATHLEN]; int c; int row, col; int n; double quality = 0.0; int filter = 0; int method = -1; int level = 0; char filter_name[MAXPATHLEN] = ""; int seed; int verbose = 0; gray **image; Image_tree dwts; gray maxval; int rows, cols, colors, format; progname = argv[0]; pgm_init(&argc, argv); #ifdef __EMX__ _fsetmode(in, "b"); _fsetmode(out, "b"); #endif while ((c = getopt(argc, argv, "e:f:F:h?l:o:q:s:v:")) != EOF) { switch (c) { case 'e': method = atoi(optarg); if (method < 0) { fprintf(stderr, "%s: wavelet filtering method %d out of range\n", progname, method); exit(1); } break; case 'f': filter = atoi(optarg); if (filter <= 0) { fprintf(stderr, "%s: filter number %d out of range\n", progname, filter); exit(1); } break; case 'F': strcpy(filter_name, optarg); break; case 'h': case '?': usage(); break; case 'l': level = atoi(optarg); if (level < 1) { fprintf(stderr, "%s: embedding level out of range\n", progname); exit(1); } break; case 'o': if ((out = fopen(optarg, "wb")) == NULL) { fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg); exit(1); } strcpy(output_name, optarg); break; case 'q': quality = atoi(optarg); if (quality <= 0) { fprintf(stderr, "%s: quality factor %d out of range\n", progname, quality); exit(1); } break; case 's': if ((sig = fopen(optarg, "r")) == NULL) { fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg); exit(1); } strcpy(signature_name, optarg); break; case 'v': verbose = atoi(optarg); if (verbose < 0) { fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose); exit(1); } break; } } argc -= optind; argv += optind; if (argc > 1) { usage(); exit(1); } if (argc == 1 && *argv[0] != '-') if ((in = fopen(argv[0], "rb")) == NULL) { fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]); exit(1); } else strcpy(input_name, argv[0]); if (sig) { char line[32]; fgets(line, sizeof(line), sig); if (strspn(line, "KDSG") >= 4) { fscanf(sig, "%d\n", &n); if (quality == 0.0) fscanf(sig, "%lf\n", &quality); else fscanf(sig, "%*f\n"); if (method < 0) fscanf(sig, "%d\n", &method); else fscanf(sig, "%*d\n"); if (filter == 0) fscanf(sig, "%d\n", &filter); else fscanf(sig, "%*d\n"); if (!strcmp(filter_name, "")) fscanf(sig, "%[^\n\r]\n", filter_name); else fscanf(sig, "%*[^\n\r]\n"); if (level == 0) fscanf(sig, "%d\n", &level); else fscanf(sig, "%*d\n"); fscanf(sig, "%d\n", &seed); srandom(seed); n_signature = NBITSTOBYTES(nbit_signature); fread(signature, sizeof(char), n_signature, sig); fscanf(sig, "\n"); } else { fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name); exit(1); } fclose(sig); } else { fprintf(stderr, "%s: signature file not specified, use -s file option\n", progname); exit(1); } pgm_readpgminit(in, &cols, &rows, &maxval, &format); image = pgm_allocarray(cols, rows); for (row = 0; row < rows; row++) pgm_readpgmrow(in, image[row], cols, maxval, format); fclose(in); // check watermark dimensions and decomposition level // decomposition of image init_dwt(cols, rows, filter_name, filter, level, method); #ifdef POLLEN_STUFF { double alpha, beta; char *alpha_str = getenv("POLLEN_ALPHA"), *beta_str = getenv("POLLEN_BETA"); if (alpha_str && beta_str) { alpha = atof(alpha_str); beta = atof(beta_str); if (alpha < -M_PI || alpha >= M_PI) { fprintf(stderr, "%s: pollen - alpha %f out of range\n", progname, alpha); exit(1); } if (beta < -M_PI || beta >= M_PI) { fprintf(stderr, "%s: pollen - beta %f out of range\n", progname, beta); exit(1); } if (verbose > 7) fprintf(stderr, "%s: pollen - alpha %f, beta %f\n", progname, alpha, beta); dwt_pollen_filter(alpha, beta); } } #endif dwts = fdwt(image); // create 'image' from binary watermark // decomposition of watermark init_dwt(cols, rows, filter_name, filter, 1, method); // dwts = fdwt(watermark); // calculate mean value of image and set alpha // setup of contrast sensitivity matrix // segment detail images at each level // calculate DFT of each segment // compute salience for each segment // calculate gamma or each detail image // embed watermark // reconstruction of watermarked image idwt(dwts, image); pgm_writepgminit(out, cols, rows, maxval, 0); for (row = 0; row < rows; row++) pgm_writepgmrow(out, image[row], cols, maxval, 0); fclose(out); pgm_freearray(image, rows); exit(0); }
int main(int argc, char * argv[]) { struct cmdlineInfo cmdline; FILE * ifP; int cols, rows; int median; enum medianMethod medianMethod; pgm_init(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifP = pm_openr(cmdline.inputFileName); ccolso2 = cmdline.width / 2; crowso2 = cmdline.height / 2; pgm_readpgminit(ifP, &cols, &rows, &maxval, &format); pgm_writepgminit(stdout, cols, rows, maxval, forceplain); /* Allocate space for number of rows in mask size. */ grays = pgm_allocarray(cols, cmdline.height); grayrow = pgm_allocrow(cols); /* Read in and write out initial rows that won't get changed. */ for (row = 0; row < cmdline.height - 1; ++row) { pgm_readpgmrow(ifP, grays[row], cols, maxval, format); /* Write out the unchanged row. */ if (row < crowso2) pgm_writepgmrow(stdout, grays[row], cols, maxval, forceplain); } median = (cmdline.height * cmdline.width) / 2; /* Choose which sort to run. */ if (cmdline.type == MEDIAN_UNSPECIFIED) { if ((maxval / ((cmdline.width * cmdline.height) - 1)) < cmdline.cutoff) medianMethod = HISTOGRAM_SORT_MEDIAN; else medianMethod = SELECT_MEDIAN; } else medianMethod = cmdline.type; switch (medianMethod) { case SELECT_MEDIAN: selectMedian(ifP, cmdline.width, cmdline.height, cols, rows, median); break; case HISTOGRAM_SORT_MEDIAN: histogramSortMedian(ifP, cmdline.width, cmdline.height, cols, rows, median); break; case MEDIAN_UNSPECIFIED: pm_error("INTERNAL ERROR: median unspecified"); } pm_close(ifP); pm_close(stdout); pgm_freearray(grays, cmdline.height); pgm_freerow(grayrow); return 0; }
int main(int argc, const char ** argv) { FILE * ifP; gray ** grays; int argn; unsigned int rows, cols; unsigned int divisor; unsigned int * obuf; /* malloced */ const char * const usage = "[-d <val>] height width [asciifile]"; pm_proginit(&argc, argv); rows = 0; /* initial value */ cols = 0; /* initial value */ divisor = 1; /* initial value */ argn = 1; if ( argc < 3 || argc > 6 ) pm_usage( usage ); if ( argv[argn][0] == '-' ) { if ( streq( argv[argn], "-d" ) ) { if ( argc == argn + 1 ) pm_usage( usage ); if ( sscanf( argv[argn+1], "%u", &divisor ) != 1 ) pm_usage( usage ); argn += 2; } else pm_usage( usage ); } if ( sscanf( argv[argn++], "%u", &rows ) != 1 ) pm_usage( usage ); if ( sscanf( argv[argn++], "%u", &cols ) != 1 ) pm_usage( usage ); if ( rows < 1 ) pm_error( "height is less than 1" ); if ( cols < 1 ) pm_error( "width is less than 1" ); if ( argc > argn + 1 ) pm_usage( usage ); if ( argc == argn + 1 ) ifP = pm_openr(argv[argn]); else ifP = stdin; MALLOCARRAY(obuf, cols); if (obuf == NULL) pm_error("Unable to allocate memory for %u columns", cols); grays = pgm_allocarray(cols, rows); convertAsciiToPgm(ifP, cols, rows, divisor, maxval, grays, obuf); pm_close(ifP); pgm_writepgm(stdout, grays, cols, rows, maxval, 0); free(obuf); pgm_freearray(grays, rows); return 0; }
/** write a scrap of the data, * return the filename, * if the file exist do nothing * argument fname is optional * the coordinates of the image part are geodata e.g. Gauss Krueger **/ QString GeoImage::part(float west, float north, float east, float south, QString fname) { if (fname.isEmpty()) { //create output filname Q_ASSERT(contains("key")); QString dir = CleanUp::getTmpDir(); fname.sprintf("%s/%s_%f_%f_%f_%f", dir.toLatin1().constData(), value("key").toLatin1().constData(), west, north, east, south); } qDebug("# GeoImage::part %s (%f, %f, %f, %f)", fname.toLatin1().constData(), west, north, east, south); QFile f(fname); if (f.exists()) return fname; const void *data_p = data(); //get pointer to data Q_ASSERT(data_p); if (type_ == UNKNOWN) return 0; int dx, dy, i, j, rx1, ry1, rx2, ry2; picBBox(west, north, east, south, rx1, ry2, rx2, ry1); dx = rx2 - rx1 + 1; dy = ry2 - ry1 + 1; if (dx <= 0 || dy <= 0) { qDebug("# (ERROR) GeoImage::part: (dx=%d=%d-%d || dy=%d=%d-%d)", dx, rx2, rx1, dy, ry2, ry1); throw ImageException(rx1,rx2,dx,ry1,ry2,dy); } FILE *of = fopen(fname.toLatin1().constData(), "w"); if (!of) { throw FileIOException(FileIOException::OPEN_FAILED,fname); } switch (type_) { case PBM:{ bit *bpi, *bpo, **dat_b_out = pbm_allocarray(dx, dy); bit **dat_b = (bit **) data_p; for (i = 0; i < dy; i++) { bpi = dat_b[i + ry1] + rx1; bpo = dat_b_out[i]; for (j = 0; j < dx; j++) { *bpo = *bpi; bpo++; bpi++; } } pbm_writepbm(of, (bit **) dat_b_out, dx, dy, 0); pbm_freearray(dat_b_out, dy); } break; case PGM:{ gray *gpi, *gpo, **dat_g_out = pgm_allocarray(dx, dy); gray **dat_g = (gray **) data_p; gray maxval = 0; for (i = 0; i < dy; i++) { gpi = dat_g[i + ry1] + rx1; gpo = dat_g_out[i]; for (j = 0; j < dx; j++) { *gpo = *gpi; if (*gpi > maxval) maxval = *gpi; gpo++; gpi++; } } pgm_writepgm(of, (gray **) dat_g_out, dx, dy, maxval, 0); pgm_freearray(dat_g_out, dy); } break; case PPM:{ pixel *ppi, *ppo, **dat_p_out = ppm_allocarray(dx, dy); pixel **dat_p = (pixel **) data_p; pixval maxval = 255; //! should be calculated for (i = 0; i < dy; i++) { ppi = dat_p[i + ry1] + rx1; ppo = dat_p_out[i]; for (j = 0; j < dx; j++) { *ppo = *ppi; ppo++; ppi++; } } ppm_writeppm(of, (pixel **) dat_p_out, dx, dy, maxval, 0); ppm_freearray(dat_p_out, dy); } break; default: pfm_geo_set(geoWest(),geoNorth(),geoEast(),geoSouth()); pfm_writepfm_region_type(of, data_, cols_, rows_, minval_, maxval_, rx1, ry1, rx2, ry2, type_); break; } fclose(of); return fname; }
int main(int argc, char *argv[]) { FILE *in = stdin; FILE *out = stdout; FILE *orig = NULL; FILE *sig = NULL; gray **input_image; gray **orig_image; char signature_name[MAXPATHLEN]; char output_name[MAXPATHLEN] = "(stdout)"; char input_name[MAXPATHLEN] = "(stdin)"; char orig_name[MAXPATHLEN]; int c; int n = 0; int method = -1; int filter = 0; char filter_name[MAXPATHLEN] = ""; int level = 0; double alpha = 0.0; int in_rows, in_cols, in_format; gray in_maxval; int orig_rows, orig_cols, orig_format; gray orig_maxval; int rows, cols; int row, col; Image_tree input_dwts; Image_tree orig_dwts; int verbose = 0; progname = argv[0]; pgm_init(&argc, argv); wm_init2(); while ((c = getopt(argc, argv, "a:e:f:F:h?i:n:o:s:v:")) != EOF) { switch (c) { case 'a': alpha = atof(optarg); if (alpha <= 0.0) { fprintf(stderr, "%s: alpha factor %f out of range\n", progname, alpha); exit(1); } break; case 'e': method = atoi(optarg); if (method < 0) { fprintf(stderr, "%s: wavelet filtering method %d out of range\n", progname, method); exit(1); } break; case 'f': filter = atoi(optarg); if (filter <= 0) { fprintf(stderr, "%s: filter number %d out of range\n", progname, filter); exit(1); } break; case 'F': strcpy(filter_name, optarg); break; case 'h': case '?': usage(); break; case 'i': if ((orig = fopen(optarg, "rb")) == NULL) { fprintf(stderr, "%s: unable to open original image file %s\n", progname, optarg); exit(1); } strcpy(orig_name, optarg); break; case 'n': n = atoi(optarg); if (n < 1 || n > 1000) { fprintf(stderr, "%s: watermark length %d out of range\n", progname, n); exit(1); } break; case 'o': if ((out = fopen(optarg, "w")) == NULL) { fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg); exit(1); } strcpy(output_name, optarg); break; case 's': if ((sig = fopen(optarg, "r")) == NULL) { fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg); exit(1); } strcpy(signature_name, optarg); break; case 'v': verbose = atoi(optarg); if (verbose < 0) { fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose); exit(1); } break; } } argc -= optind; argv += optind; if (argc > 1) { usage(); exit(1); } if (argc == 1 && *argv[0] != '-') { if ((in = fopen(argv[0], "rb")) == NULL) { fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]); exit(1); } else strcpy(input_name, argv[0]); } if (!orig) { fprintf(stderr, "%s: original image file not specified, use -i file option\n", progname); exit(1); } if (sig) { char line[32]; fgets(line, sizeof(line), sig); if (strspn(line, "CVSG") >= 4) { fscanf(sig, "%d\n", &n); if (alpha == 0.0) fscanf(sig, "%lf\n", &alpha); else fscanf(sig, "%*f\n"); if (method < 0) fscanf(sig, "%d\n", &method); else fscanf(sig, "%*d\n"); if (filter == 0) fscanf(sig, "%d\n", &filter); else fscanf(sig, "%*d\n"); if (!strcmp(filter_name, "")) fscanf(sig, "%[^\n\r]\n", filter_name); else fscanf(sig, "%*[^\n\r]\n"); } else { fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name); exit(1); } fclose(sig); } else { fprintf(stderr, "%s: signature file not specified, use -s file option\n", progname); exit(1); } pgm_readpgminit(in, &in_cols, &in_rows, &in_maxval, &in_format); pgm_readpgminit(orig, &orig_cols, &orig_rows, &orig_maxval, &orig_format); if (in_cols != orig_cols || in_rows != orig_rows) { fprintf(stderr, "%s: input image %s does not match dimensions of original image %s\n", progname, input_name, orig_name); exit(1); } cols = in_cols; rows = in_rows; input_image = pgm_allocarray(in_cols, in_rows); orig_image = pgm_allocarray(orig_cols, orig_rows); for (row = 0; row < in_rows; row++) pgm_readpgmrow(in, input_image[row], in_cols, in_maxval, in_format); fclose(in); for (row = 0; row < orig_rows; row++) pgm_readpgmrow(orig, orig_image[row], orig_cols, orig_maxval, orig_format); fclose(orig); level = 0; row = rows; col = cols; while (n < row * col / 4.0 && row >= 2 && col >= 2) { row /= 2; col /= 2; level++; } if (verbose >= 2) { fprintf(stderr, "%s: extracting from coarse image (x %d/y %d) at level %d\n", progname, col, row, level); } init_dwt(cols, rows, filter_name, filter, level, method); #ifdef POLLEN_STUFF #include "pollen_stuff.c" #endif #ifdef PARAM_STUFF #include "param_stuff.c" #endif input_dwts = fdwt(input_image); orig_dwts = fdwt(orig_image); fprintf(out, "CVWM\n"); fprintf(out, "%d\n", n); { Image_tree p = input_dwts; Image_tree q = orig_dwts; Image input_img; Image orig_img; double input_med; double orig_med; double input_var; double orig_var; while (!p->image) p = p->coarse; while (!q->image) q = q->coarse; input_img = p->image; orig_img = q->image; input_med = 0.0; for (row = 0; row < input_img->height; row++) for (col = 0; col < input_img->width; col++) input_med += get_pixel(input_img, col, row); input_med /= (double) (input_img->height * input_img->width); orig_med = 0.0; for (row = 0; row < orig_img->height; row++) for (col = 0; col < orig_img->width; col++) orig_med += get_pixel(orig_img, col, row); orig_med /= (double) (orig_img->height * orig_img->width); orig_var = 0.0; for (row = 0; row < orig_img->height; row++) for (col = 0; col < orig_img->width; col++) orig_var += sqr(get_pixel(orig_img, col, row) - orig_med); orig_var /= (double) (orig_img->height * orig_img->width); input_var = 0.0; for (row = 0; row < input_img->height; row++) for (col = 0; col < input_img->width; col++) input_var += sqr(get_pixel(input_img, col, row) - input_med); input_var /= (double) (input_img->height * input_img->width); orig_var = sqrt(orig_var); input_var = sqrt(input_var); if (verbose > 3) fprintf(stderr, "%s: mean (input, orig): %f, %f,\n variance (input, orig): %f, %f\n", progname, input_med, orig_med, input_var, orig_var); row = 0; col = 0; while (n > 0) { double input_pix; double orig_pix; double x; input_pix = get_pixel(input_img, col, row); orig_pix = get_pixel(orig_img, col, row); x = (((input_pix - input_med) * (orig_var / input_var) - (orig_pix / orig_med)) / (orig_pix - orig_med) - 1.0) / alpha; fprintf(out, "%f\n", x); if (++col == orig_img->width) { col = 0; row++; } n--; } } fclose(out); pgm_freearray(input_image, rows); pgm_freearray(orig_image, rows); exit(0); }
int main(int argc, char *argv[]) { FILE *ifp; int rows, cols; unsigned int ncolors; bool transparentSomewhere; pixval maxval, alphaMaxval; colorhash_table cht; colorhist_vector chv; colorhash_table colornameHash; /* Hash table to map colors to their names */ const char ** colornames; /* Table of color names; 'colornameHash' yields an index into this array. */ pixel **pixels; gray **alpha; /* Used for rgb value -> character-pixel string mapping */ cixel_map *cmap; /* malloc'ed */ /* The XPM colormap */ unsigned int cmapSize; /* Number of entries in 'cmap' */ unsigned int transIndex; /* Index into 'cmap' of the transparent color, if there is one */ unsigned int charsPerPixel; struct cmdlineInfo cmdline; ppm_init(&argc, argv); parseCommandLine(argc, argv, &cmdline); ifp = pm_openr(cmdline.inputFilename); pixels = ppm_readppm(ifp, &cols, &rows, &maxval); pm_close(ifp); if (cmdline.alpha_filename) readAlpha(cmdline.alpha_filename, &alpha, cols, rows, &alphaMaxval); else alpha = NULL; computeColormap(pixels, alpha, cols, rows, alphaMaxval, &chv, &cht, &ncolors, &transparentSomewhere); if (cmdline.hexonly) colornameHash = NULL; else if (cmdline.rgb) ppm_readcolornamefile(cmdline.rgb, TRUE, &colornameHash, &colornames); else ppm_readcolornamefile(NULL, FALSE, &colornameHash, &colornames); /* Now generate the character-pixel colormap table. */ genCmap(chv, ncolors, maxval, colornameHash, colornames, transparentSomewhere, &cmap, &transIndex, &cmapSize, &charsPerPixel); writeXpmFile(stdout, pixels, alpha, alphaMaxval, cmdline.name, cols, rows, cmapSize, charsPerPixel, cmap, cht, transIndex); if (colornameHash) { ppm_freecolorhash(colornameHash); ppm_freecolornames(colornames); } destroyCmap(cmap, cmapSize); ppm_freearray(pixels, rows); if (alpha) pgm_freearray(alpha, rows); return 0; }