Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/Enet4/dicom-rs
Rust implementation of the DICOM standard
https://github.com/Enet4/dicom-rs
dicom dicom-standard hacktoberfest medical-imaging rust
Last synced: 23 days ago
JSON representation
Rust implementation of the DICOM standard
- Host: GitHub
- URL: https://github.com/Enet4/dicom-rs
- Owner: Enet4
- License: apache-2.0
- Created: 2016-10-23T23:11:59.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2024-10-29T19:30:05.000Z (about 1 month ago)
- Last Synced: 2024-10-29T21:37:59.988Z (about 1 month ago)
- Topics: dicom, dicom-standard, hacktoberfest, medical-imaging, rust
- Language: Rust
- Homepage: https://dicom-rs.github.io
- Size: 5.01 MB
- Stars: 420
- Watchers: 11
- Forks: 82
- Open Issues: 56
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE-APACHE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
- awesome-dicom - DICOM-rs - A pure Rust implementation of the DICOM standard, allowing users to work with DICOM objects and interact with DICOM applications, while aiming to be fast, safe, and intuitive to use. (Libraries / Rust)
README
# DICOM-rs
[](https://crates.io/crates/dicom)
[](https://github.com/Enet4/dicom-rs/actions/workflows/rust.yml)
[](https://deps.rs/repo/github/Enet4/dicom-rs)
[](https://dicom-rs.zulipchat.com/)
[](https://docs.rs/dicom)
An ecosystem of library and tools for [DICOM](https://dicomstandard.org) compliant systems.
This collection provides a pure Rust implementation of the DICOM standard,
allowing users to work with DICOM objects
and interact with DICOM applications,
while aiming to be fast, safe, and intuitive to use.
## Components
### Library
The following library packages are designed to be used in
other Rust libraries and applications.
- [`object`](object) provides a high-level abstraction of DICOM objects
and functions for reading and writing DICOM files.
- [`pixeldata`](pixeldata) enables the decoding and conversion of DICOM objects
into usable imaging data structures,
such as images and multidimensional arrays.
- [`dump`](dump) provides helpful routines for
dumping the contents of DICOM objects.
- [`json`](json) provides serialization and deserialization to DICOM JSON.
- [`ul`](ul) implements the DICOM upper layer protocol.
- [`dictionary-std`](dictionary-std) contains a Rust definition of
the standard data dictionary.
- [`transfer-syntax-registry`](transfer-syntax-registry) contains a registry of
transfer syntax specifications.
- [`parser`](parser) provides a middle-level abstraction
for the parsing and printing of DICOM data sets.
- [`encoding`](encoding) contains DICOM data encoding and decoding primitives.
- [`core`](core) represents all of the base traits,
data structures and functions related to DICOM content.
#### Using as a library
The parent crate [`dicom`](parent) aggregates the key components of the full library,
so it can be added to a project as an alternative to
selectively grabbing the components that you need.
Generally, most projects would add [`dicom_object`](object),
which is the most usable crate for reading DICOM objects from a file or a similar source.
This crate is available in `dicom::object`.
For working with the imaging data of a DICOM object,
add [`pixeldata`](pixeldata).
Network capabilities may be constructed on top of [`ul`](ul).
A simple example of use follows.
For more details,
please visit the [`dicom` documentation](https://docs.rs/dicom).
```rust
use dicom::object::open_file;
use dicom::dictionary_std::tags;
let obj = open_file("0001.dcm")?;
let patient_name = obj.element(tags::PATIENT_NAME)?.to_str()?;
let modality = obj.element(tags::MODALITY)?.to_str()?;
```
### Tools
The project also comprises an assortment of command line tools.
- [`dump`](dump), aside from being a library,
is also a command-line application for inspecting DICOM files.
- [`scpproxy`](scpproxy) implements a Proxy service class provider.
- [`echoscu`](echoscu) implements a Verification service class user.
- [`findscu`](findscu) implements a Find service class user.
- [`storescu`](storescu) implements a Storage service class user.
- [`storescp`](storescp) implements a Storage service class provider.
- [`toimage`](toimage) lets you convert a DICOM file into an image file.
- [`fromimage`](fromimage) lets you replace the imaging data of a DICOM file
with one from an image file.
- [`pixeldata`](pixeldata) also includes `dicom-transcode`,
which lets you transcode DICOM files to other transfer syntaxes.
### Development tools
- [`dictionary-builder`](dictionary-builder) is an independent application that
generates code and other data structures for a DICOM standard dictionary.
## Building
You can use Cargo to build all crates in the repository.
```sh
cargo build
```
Other than the parts needed to build a pure Rust project,
no other development dependencies are necessary
unless certain extensions are included via Cargo features.
Consult each crate for guidelines on selecting features to suit your needs.
Minimum supported Rust version is 1.72.0 and only applies to the library crates with default features.
Binary crates and extra features may require a newer version of Rust.
## Roadmap & Contributing
This project is under active development.
Your feedback during the development of these solutions is welcome. Please see the [wiki](https://github.com/Enet4/dicom-rs/wiki)
for additional guidelines related to the project's roadmap.
See also the [contributor guidelines](CONTRIBUTING.md) and the project's [Code of Conduct](CODE_OF_CONDUCT.md).
## License
Licensed under either of
- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or )
- MIT license ([LICENSE-MIT](LICENSE-MIT) or )
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
additional terms or conditions.