C++ write_ppm函数代码示例

int main()
{
    //--------------------
    // Allocate the buffer.
    // Clear the buffer, for now "manually"
    // Create the rendering buffer object
    // Create the Pixel Format renderer
    // Do something simple, draw a diagonal line
    // Write the buffer to agg_test.ppm
    // Free memory

    unsigned char* buffer = new unsigned char[frame_width * frame_height * 3];

    memset(buffer, 255, frame_width * frame_height * 3);

    agg::rendering_buffer rbuf(buffer, 
                               frame_width, 
                               frame_height, 
                               frame_width * 3);

    agg::pixfmt_rgb24 pixf(rbuf);

    unsigned i;
    for(i = 0; i < pixf.height()/2; ++i)
    {
        pixf.copy_pixel(i, i, agg::rgba8(127, 200, 98));
    }

    draw_black_frame(pixf);
    write_ppm(buffer, frame_width, frame_height, "agg_test.ppm");

    delete [] buffer;
    return 0;
}

int main(int argc, char** argv) {
    if (argc != 2) {
        std::cerr << "Error: wrong number of argument:" << std::endl
            << "usage: ./shiny-tracer scene.sce" << std::endl;
        return 1;
    }

    Scene scene;
    parser(argv[1], scene);

    // DEBUG
    std::cout << scene.nbObjects() << " objects and " << scene.nbLights() << " lights" << std::endl;

    int width = scene.getCam().getWidth();
    int height = scene.getCam().getHeight();

    std::vector<Color> screen;
    scene.computeImage(screen);

    std::string filename(argv[1]);
    size_t pos = filename.find(".sce");
    filename = filename.substr(0, pos);
    filename.append(".ppm");
    write_ppm(filename.c_str(), screen, width, height);

    return 0;
}

int main (int argc, char * argv[]){
    char * path = "/Users/neo_cupid/Desktop/18645/final_proj/data-2/1/input0.ppm";
    char * path_csv = "/Users/neo_cupid/Desktop/18645/final_proj/data-2/1/input1.csv";
    char * path_out = "/Users/neo_cupid/Desktop/18645/final_proj/data-2/1/outTest.ppm";
    clock_t begin, end;
    double time_spent;
    
    begin = clock();
    
    PPM_IMG img = read_ppm (path);
    PPM_IMG output;
    output.h = img.h;
    output.w = img.w;
    output.data = (unsigned char *)malloc(3 * img.w * img.h * sizeof(unsigned char));
    float mask[25];
    read_csv(path_csv, mask);
    convolution(CHANNELS, img.w, img.h, mask, img, &output);
    write_ppm(output, path_out);
    free (output.data);
    free(img.data);
    end = clock();
    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    printf("execution time: %lf.\n",time_spent);
    return 0;
    
}

static int
files_video(void *handle, struct ng_video_buf *buf)
{
    struct files_handle *h = handle;
    int rc = -1;
    FILE *fp;

    if (h->gotcha) {
	fprintf(stderr,"Oops: can't count up file names any more\n");
	return -1;
    }
    
    switch (h->video.fmtid) {
    case VIDEO_RGB24:
	rc = write_ppm(h->file, buf);
	break;
    case VIDEO_GRAY:
	rc = write_pgm(h->file, buf);
	break;
    case VIDEO_JPEG:
	if (NULL == (fp = fopen(h->file,"w"))) {
	    fprintf(stderr,"grab: can't open %s: %s\n",h->file,strerror(errno));
	    rc = -1;
	} else {
	    fwrite(buf->data,buf->size,1,fp);
	    fclose(fp);
	    rc = 0;
	}
    }
    if (1 != patch_up(h->file))
	h->gotcha = 1;
    return rc;
}

void write_image(char *file_name, int render_fmt, VInfo *ji, uint8_t *buf) {
  FILE *x;
  if ((x = open_outfile(file_name))) {
    switch (render_fmt) {
      case FMT_JPG:
	if (write_jpeg(ji, buf, JPEG_QUALITY, x))
	  dlog(LOG_ERR, "IMF: Could not write jpeg: %s\n", file_name);
	break;
      case FMT_PNG:
	if (write_png(ji, buf, x))
	  dlog(LOG_ERR, "IMF: Could not write png: %s\n", file_name);
	break;
      case FMT_PPM:
	if (write_ppm(ji, buf, x))
	  dlog(LOG_ERR, "IMF: Could not write ppm: %s\n", file_name);
	break;
      default:
	dlog(LOG_ERR, "IMF: Unknown outformat %d\n", render_fmt);
	break;
    }
    if (strcmp(file_name, "-")) fclose(x);
    dlog(LOG_INFO, "IMF: Outputfile %s closed\n", file_name);
  }
  else
    dlog(LOG_ERR, "IMF: Could not open outfile: %s\n", file_name);
  return;
}

int
vips__ppm_save( VipsImage *in, const char *filename, gboolean ascii )
{
	Write *write;

	if( vips_check_uintorf( "vips2ppm", in ) || 
		vips_check_bands_1or3( "vips2ppm", in ) || 
		vips_check_uncoded( "vips2ppm", in ) || 
		vips_image_pio_input( in ) )
		return( -1 );

	/* We can only write >8 bit binary images in float.
	 */
	if( vips_format_sizeof( in->BandFmt ) > 1 && 
		!ascii && 
		in->BandFmt != VIPS_FORMAT_FLOAT ) {
		vips_error( "vips2ppm", 
			"%s", _( "binary >8 bit images must be float" ) );
		return( -1 );
	}

	if( !(write = write_new( in, filename )) )
		return( -1 );

	if( write_ppm( write, ascii ) ) {
		write_destroy( write );
		return( -1 );
	}
	write_destroy( write );

	return( 0 );
}

void free_context()
{
   write_ppm("a.ppm", buffer, Width, Height);

   printf("all done\n");

   free( buffer );

   OSMesaDestroyContext( ctx );
}

int main()
{
  image_t *img = read_ppm("example.ppm");
  if (!img)
    return EXIT_FAILURE;
  for (size_t i = 0; i<img->width*img->height; ++i)
  {
    img->red_buffer[i] = 255-img->green_buffer[i];
  }
  write_ppm("example-out.ppm", img);
  return EXIT_SUCCESS;
}

static const char *
ps_convert (char **argv, int fd)
{
    const char *err;
    cairo_surface_t *surface = NULL; /* silence compiler warning */

    err = _spectre_render_page (argv[0], argv[1], &surface);
    if (err != NULL)
	return err;

    err = write_ppm (surface, fd);
    cairo_surface_destroy (surface);

    return err;
}

int main() {
  unsigned char buf[WIDTH*HEIGHT*3];
  char *filename_in;
  char *filename_out;
  filename_in = "testdata/pixbuff_7.ppm";
  filename_out = "testdata/blurtest.ppm";
  read_ppm(buf, filename_in);
  printf("These two sequences of numbers should be different.\n");
  printf("%d %d %d\n", buf[12], buf[13], buf[14]);
  gauss_blur(buf);
  printf("%d %d %d\n", buf[12], buf[13], buf[14]);
  write_ppm(buf, filename_out);
  printf("Confirm that the image testdata/blurtest.ppm is a blurred copy of image testdata/pixbuff_7.ppm\n");
  return 0;
}

int main(int argc, char** argv)
{

    int grid_size_x;
    int grid_size_y;
    int max_iter;
    float xmin;
    float xmax;
    float ymin;
    float ymax;
    int **image;
    int rank;
//initialise a fn pointer
    in_set_fn_t fp; 
    MPI_Comm comm;
    comm = MPI_COMM_WORLD;

    MPI_Init(&argc, & argv);

    MPI_Comm_rank(comm, &rank); 

    read_options(argc, argv, &grid_size_x, &grid_size_y, &max_iter,
                 &xmin, &xmax, &ymin, &ymax);

    if(0 == rank)
    {
      initialise_image(&image, grid_size_x, grid_size_y);
    }


//set it to either julia or mandelbrot calculation
    fp = &point_in_julia;  

    compute_set(fp, image, xmin, xmax, ymin, ymax, grid_size_x, grid_size_y, max_iter, comm);

    if(0 == rank)
    {
      write_ppm("output.ppm", image, grid_size_x, grid_size_y, max_iter);
      free(image);
    }

    MPI_Finalize();
    return 0;
}

static void DisplayNoDrawDoTest(void)
{

    for (global_iteration = 0; global_iteration < global_num_proc;
         global_iteration++) {
        IceTImage image;
        IceTUByte *color_buffer;

        printf("Blank image is rank %d\n", global_iteration);

        image = icetGLDrawFrame();
        swap_buffers();

        if (   (global_rank == 0)
            && (global_num_proc > 1)
          /* This last case covers when there is only 2 processes,
           * the root, as always, is not drawing anything and the
           * other process is drawing the clear screen. */
            && ((global_num_proc > 2) || (global_iteration != 1)) ) {
            int p;
            int bad_count = 0;
            printf("Checking pixels.\n");
            color_buffer = icetImageGetColorub(image);
            for (p = 0;
                 (p < SCREEN_WIDTH*SCREEN_HEIGHT*4) && (bad_count < 10); p++) {
                if (color_buffer[p] != 255) {
                    printf("BAD PIXEL %d.%d\n", p/4, p%4);
                    printf("    Expected 255, got %d\n", color_buffer[p]);
                    bad_count++;
                }
            }
            if (bad_count >= 10) {
                char filename[256];
                global_result = TEST_FAILED;
                sprintf(filename, "DisplayNoDraw_%s_%s_%d.ppm",
                        icetGetStrategyName(), icetGetSingleImageStrategyName(),
                        global_iteration);
                write_ppm(filename, color_buffer,
                          (int)SCREEN_WIDTH, (int)SCREEN_HEIGHT);
                break;
            }
        }
    }
}

int main()
{
    //--------------------
    // Allocate the buffer.
    // Clear the buffer, for now "manually"
    // Create the rendering buffer object
    // Create the Pixel Format renderer
    // Create one line (span) of type rgba8.
    // Fill the buffer using blend_color_span
    // Write the buffer to agg_test.ppm
    // Free memory

    unsigned char* buffer = new unsigned char[frame_width * frame_height * 3];

    memset(buffer, 255, frame_width * frame_height * 3);

    agg::rendering_buffer rbuf(buffer, 
                               frame_width, 
                               frame_height, 
                               frame_width * 3);

    agg::pixfmt_rgb24 pixf(rbuf);

    agg::rgba8 span[frame_width];

    unsigned i;
    for(i = 0; i < frame_width; ++i)
    {
        agg::rgba c(380.0 + 400.0 * i / frame_width, 0.8);
        span[i] = agg::rgba8(c);
    }

    for(i = 0; i < frame_height; ++i)
    {
        pixf.blend_color_hspan(0, i, frame_width, span, 0, 255);
    }


    write_ppm(buffer, frame_width, frame_height, "agg_test.ppm");

    delete [] buffer;
    return 0;
}

void write_thumb(libraw_processed_image_t *img, const char *basename)
{
    if(!img) return;

    if(img->type == LIBRAW_IMAGE_BITMAP)
        {
            char fnt[1024];
            snprintf(fnt,1024,"%s.thumb",basename);
            write_ppm(img,fnt);
        }
    else if (img->type == LIBRAW_IMAGE_JPEG)
        {
            char fn[1024];
            snprintf(fn,1024,"%s.thumb.jpg",basename);
            FILE *f = fopen(fn,"wb");
            if(!f) return;
            fwrite(img->data,img->data_size,1,f);
            fclose(f);
        }
}

void run_cpu_color_test(PPM_IMG img_in)
{
    StopWatchInterface *timer=NULL;
    printf("Starting CPU processing...\n");

    sdkCreateTimer(&timer);
    sdkStartTimer(&timer);
    img_obuf_yuv_cpu = rgb2yuv(img_in); //Start RGB 2 YUV
    sdkStopTimer(&timer);
    printf("RGB to YUV conversion time: %f (ms)\n", sdkGetTimerValue(&timer));
    sdkDeleteTimer(&timer);

    sdkCreateTimer(&timer);
    sdkStartTimer(&timer);
    img_obuf_rgb_cpu = yuv2rgb(img_obuf_yuv_cpu); //Start YUV 2 RGB
    sdkStopTimer(&timer);
    printf("YUV to RGB conversion time: %f (ms)\n", sdkGetTimerValue(&timer));
    sdkDeleteTimer(&timer);    

    write_yuv(img_obuf_yuv_cpu, "out_yuv.yuv");
    write_ppm(img_obuf_rgb_cpu, "out_rgb.ppm");
}