img_rcc 0.1.0

A Rust library for image processing with CUDA, C++.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use img_rcc::{
    kernel::{get_kernel, KernelType},
    Device, Image,
};
// use std::time::Instant;

fn main() {
    // Load a predefined 3x3 Gaussian Blur kernel
    let gaussian_kernel_3x3 = get_kernel(KernelType::GaussianBlur3x3);
    let mut image = Image::load("jenna.png");
    // image.to(Device::GPU);
    image.convolve(&gaussian_kernel_3x3); // Apply the 5x5 Gaussian blur
    image.save("jenna_gaussian_3x3.png");

    // Load a dynamically generated 5x5 Gaussian Blur kernel
    let gaussian_kernel_5x5 = get_kernel(KernelType::GaussianBlurNxN(15));
    let mut image = Image::load("jenna.png");
    image.to(Device::GPU);
    image.convolve(&gaussian_kernel_5x5); // Apply the 5x5 Gaussian blur
    image.save("jenna_gaussian_13x13.png");
}

// fn main() {
//     let image_path = "input.png";

//     println!("\x1b[32mRunning the benchmark for load to device:\x1b[0m");
//     let start_load_to_device = Instant::now();
//     let _image = Image::load_to_device(image_path, Device::GPU);
//     let duration_load_to_device = start_load_to_device.elapsed();
//     println!(
//         "Time taken for load to device: {:?}",
//         duration_load_to_device
//     );

//     // free_image(image);

//     println!("\x1b[32mRunning the benchmark for GPU:\x1b[0m");
//     let start_load_gpu = Instant::now();
//     let mut image = Image::load(image_path);
//     let duration_load_gpu = start_load_gpu.elapsed();
//     println!("Time taken for GPU load: {:?}", duration_load_gpu);

//     let start_transfer = Instant::now();
//     image.to(Device::GPU);
//     let duration_transfer = start_transfer.elapsed();
//     println!("Time taken for GPU transfer: {:?}", duration_transfer);

//     let start_grayscale_gpu = Instant::now();
//     image.grayscale();
//     let duration_grayscale_gpu = start_grayscale_gpu.elapsed();
//     println!("Time taken for GPU grayscale: {:?}", duration_grayscale_gpu);

//     let start_save_gpu = Instant::now();
//     image.save("output_gpu.png");
//     let duration_save_gpu = start_save_gpu.elapsed();
//     println!("Time taken for GPU save: {:?}", duration_save_gpu);

//     let start_free_gpu = Instant::now();
//     // free_image(image);
//     let duration_free_gpu = start_free_gpu.elapsed();
//     println!("Time taken for GPU free: {:?}", duration_free_gpu);

//     println!("\x1b[32mRunning the benchmark for CPU:\x1b[0m");
//     let start_load_cpu = Instant::now();
//     let mut image = Image::load(image_path);
//     let duration_load_cpu = start_load_cpu.elapsed();
//     println!("Time taken for CPU load: {:?}", duration_load_cpu);

//     let start_transfer = Instant::now();
//     image.to(Device::CPU);
//     let duration_transfer = start_transfer.elapsed();
//     // println!("Channels: {}", image.channels);
//     println!("Time taken for CPU transfer: {:?}", duration_transfer);

//     let start_grayscale_cpu = Instant::now();
//     image.grayscale();
//     let duration_grayscale_cpu = start_grayscale_cpu.elapsed();
//     println!("Time taken for CPU grayscale: {:?}", duration_grayscale_cpu);

//     let start_save_cpu = Instant::now();
//     image.save("output_cpu.png");
//     let duration_save_cpu = start_save_cpu.elapsed();
//     println!("Time taken for CPU save: {:?}", duration_save_cpu);

//     let start_free_cpu = Instant::now();
//     // free_image(image);
//     let duration_free_cpu = start_free_cpu.elapsed();
//     println!("Time taken for CPU free: {:?}", duration_free_cpu);
// }