bayer 0.1.5

Algorithms for demosaicing Bayer images.
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119


LibBayer [![Version][version-img]][version-url] [![Status][travis-ci-img]][travis-ci-url]
========


About
-----

LibBayer provides routines for demosaicing Bayer (raw) images.

The library supports 8-bit and 16-bit images.

Several demosaicing algorithms are available.  See the src/demosaic
directory for a list and their individual descriptions.  Pixels on the
border of the image are retained by replicating or mirroring the data
in the neighbourhood.

LibBayer is written entirely in Rust.  C bindings to the underlying
algorithms are provided.


Examples
--------

An example program is provided in the `examples/` directory:

* _showbayer_ - a simple Bayer file viewer.
* _writebayer_ - converts an image to a raw Bayer image file.

To clone this repository, run:

```sh
git clone https://github.com/wangds/libbayer.git
```

Then build the library and run the example programs using Cargo.

```sh
cargo build --release --example showbayer
```

To display a Bayer file, run:

```sh
cargo run --release --example showbayer <width> <height> <depth> <example.raw>
```

Change the colour filter array (CFA) pattern and the demosaicing
algorithm from inside the example program.



Basic Usage
-----------

Add LibBayer as a dependency to your project's Cargo.toml:

```toml
[dependencies]
bayer = "0.1"
```

Import the library in your project, e.g.:

```rust
extern crate bayer;
```

Open a Bayer file from disk.

```rust
let mut file = File::open(Path::new("example.raw")).unwrap();
```

This raw data contains the red, green, or blue values at each pixel
only.  There is no additional header data, so the image width and
height, pixel depth, and CFA pattern must be provided from elsewhere.

Allocate the buffer to which we will decode the image.

```rust
let img_w = 320;
let img_h = 200;
let depth = bayer::RasterDepth::Depth8;
let bytes_per_pixel = 3;
let mut buf = vec![0; bytes_per_pixel * img_w * img_h];
let mut dst = bayer::RasterMut::new(img_w, img_h, depth, &mut buf);
```

Then run the demosaicing process:

```rust
let cfa = bayer::CFA::RGGB;
let alg = bayer::Demosaic::Linear;
bayer::run_demosaic(&mut file, bayer::BayerDepth:Depth8, cfa, alg, &mut dst);
```

Note that many cameras will capture 12-bits per pixel (channel), but
store the data as 16-bits per pixel.  These should be treated as
16-bits per pixel for the purposes of this library.


Documentation
-------------

* [Documentation][documentation].


Author
------

David Wang


[documentation]: https://docs.rs/bayer/
[travis-ci-img]: https://travis-ci.org/wangds/libbayer.svg?branch=master
[travis-ci-url]: https://travis-ci.org/wangds/libbayer
[version-img]: https://img.shields.io/crates/v/bayer.svg
[version-url]: https://crates.io/crates/bayer