diff options
| author | CoprDistGit <infra@openeuler.org> | 2023-05-29 11:01:13 +0000 |
|---|---|---|
| committer | CoprDistGit <infra@openeuler.org> | 2023-05-29 11:01:13 +0000 |
| commit | 5f689d092c270636263b0e11766b50e122030b13 (patch) | |
| tree | 447c65ea8d27717f416596a2e343e76845ab823b | |
| parent | dd4ebcdcdb9020a45b4c65ee42726cb0e9e54a06 (diff) | |
automatic import of python-konigcell
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | python-konigcell.spec | 742 | ||||
| -rw-r--r-- | sources | 1 |
3 files changed, 744 insertions, 0 deletions
@@ -0,0 +1 @@ +/konigcell-0.2.1.tar.gz diff --git a/python-konigcell.spec b/python-konigcell.spec new file mode 100644 index 0000000..20a1300 --- /dev/null +++ b/python-konigcell.spec @@ -0,0 +1,742 @@ +%global _empty_manifest_terminate_build 0 +Name: python-konigcell +Version: 0.2.1 +Release: 1 +Summary: Quantitative, Fast Grid-Based Fields Calculations in 2D and 3D - Residence Time Distributions, Velocity Grids, Eulerian Cell Projections etc. +License: MIT +URL: https://github.com/anicusan/KonigCell +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/8c/fa/a73f7b471a6683673b1cc365686ef2a6645453978d8e2e268529672ee849/konigcell-0.2.1.tar.gz + +Requires: python3-numpy +Requires: python3-Cython +Requires: python3-tqdm +Requires: python3-plotly +Requires: python3-matplotlib +Requires: python3-pyvista +Requires: python3-Sphinx +Requires: python3-numpydoc +Requires: python3-ipython +Requires: python3-pydata-sphinx-theme +Requires: python3-pytest + +%description + + +[](https://konigcell.readthedocs.io/en/latest/) + +[](https://pypi.python.org/pypi/konigcell/) +[](https://konigcell.readthedocs.io/en/latest/?badge=latest) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:python) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:cpp) +[](https://github.com/anicusan/konigcell) +[](https://pypi.python.org/pypi/konigcell/) + +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) + +#### **Quantitative, Fast Grid-Based Fields Calculations in 2D and 3D** - Residence Time Distributions, Velocity Grids, Eulerian Cell Projections etc. + +That sounds dry as heck. + +#### **Project moving particles' trajectories (experimental or simulated) onto 2D or 3D grids with infinite resolution.** + +Better? No? Here are some figures produced by KonigCell: + + + + +*Left panel: 2D residence time distribution in a GranuTools GranuDrum imaged using Positron Emission Particle Tracking (PEPT). Two middle panels: 3D velocity distribution in the same system; voxels are rendered as a scatter plot (left) and tomogram-like 3-slice (right). Right panel: velocity vectorfield in a constricted pipe simulating a aneurysm, imaged using PEPT.* + + +This is, to my knowledge, the only library that accurately projects particle +trajectories onto grids - that is, taking their full projected area / volume into +account (and not approximating them as points / lines). It's also the only one creating +quantitative 3D projections. + +And it is *fast* - 1,000,000 particle positions can be rasterized onto a 512x512 +grid in 7 seconds on my 16-thread i9 CPU. The code is fully parallelised on +threads, processes or distributed MPI nodes. + + + +## But Why? + +Rasterizing moving tracers onto uniform grids is a powerful way of computing statistics about a +system - occupancies, velocity vector fields, modelling particle clump imaging etc. - be it +experimental or simulated. However, the classical approach of approximating particle trajectories +as lines discards a lot of (most) information. + +Here is an example of a particle moving randomly inside a box - on a high resolution (512x512) +pixel grid, the classical approach (top row) does not yield much better statistics with increasing +numbers of particle positions imaged. Projecting complete trajectory **areas** onto the grid +(KonigCell, bottom row) preserves more information about the system explored: + + + + +A typical strategy for dealing with information loss is to coarsen the pixel grid, resulting in +a trade-off between accuracy and statistical soundness. However, even very low resolutions +still yield less information using line approximations (top row). With area projections, +**you can increase the resolution arbitrarily** and improve precision (KonigCell, bottom row): + + + + + + +## The KonigCell Libraries + +This repository effectively hosts three libraries: + +- `konigcell2d`: a portable C library for 2D grid projections. +- `konigcell3d`: a portable C library for 3D grid projections. +- `konigcell`: a user-friendly Python interface to the two libraries above. + + + +### Installing the Python Package + +This package supports Python 3.6 and above (though it might work with even older +versions). + +Install this package from PyPI: + +```pip install konigcell``` + + +Or conda-forge: + +```conda install konigcell``` + + +If you have a relatively standard system, the above should just download pre-compiled wheels - +so no prior configuration should be needed. + + +To *build* this package on your specific machine, you will need a C compiler - +the low-level C code does not use any tomfoolery, so any compiler since the +2000s should do. + + +To build the latest development version from GitHub: + +```pip install git+https://github.com/anicusan/KonigCell``` + + + +### Integrating the C Libraries with your Code + +The C libraries in the `konigcell2d` and `konigcell3d` directories in this repository; they +contain instructions for compiling and using the low-level subroutines. All code is fully +commented and follows a portable subset of the C99 standard - so no VLAs, weird macros or +compiler-specific extensions. Even MSVC compiles it! + +You can run `make` in the `konigcell2d` or `konigcell3d` directories to build shared +libraries and the example executables under `-Wall -Werror -Wextra` like a stickler. Running +`make` in the repository root builds both libraries. + +Both libraries are effectively single-source - they should be as straightforward as possible +to integrate in other C / C++ codebases, or interface with from higher-level programming +languages. + + + +## Examples and Documentation + +The `examples` directory contains some Python scripts using the high-level Python routines +and the low-level Cython interfaces. The `konigcell2d` and `konigcell3d` directories contain +C examples. + +Full documentation is available [here](https://konigcell.readthedocs.io/). + +```python +import numpy as np +import konigcell as kc + +# Generate a short trajectory of XY positions to pixellise +positions = np.array([ + [0.3, 0.2], + [0.2, 0.8], + [0.3, 0.55], + [0.6, 0.8], + [0.3, 0.45], + [0.6, 0.2], +]) + +# The particle radius may change +radii = np.array([0.05, 0.03, 0.01, 0.02, 0.02, 0.03]) + +# Values to rasterize - velocity, duration, etc. +values = np.array([1, 2, 1, 1, 2, 1]) + +# Pixellise the particle trajectories +pixels1 = kc.dynamic2d( + positions, + mode = kc.ONE, + radii = radii, + values = values[:-1], + resolution = (512, 512), +) + +pixels2 = kc.static2d( + positions, + mode = kc.ONE, + radii = radii, + values = values, + resolution = (512, 512), +) + +# Create Plotly 1x2 subplot grid and add Plotly heatmaps of pixels +fig = kc.create_fig( + nrows = 1, ncols = 2, + subplot_titles = ["Dynamic 2D", "Static 2D"], +) + +fig.add_trace(pixels1.heatmap_trace(), row = 1, col = 1) +fig.add_trace(pixels2.heatmap_trace(), row = 1, col = 2) + +fig.show() +``` + + + + + +## Contributing +You are more than welcome to contribute to this library in the form of library +improvements, documentation or helpful examples; please submit them either as: + +- GitHub issues. +- Pull requests (superheroes only). +- Email me at <a.l.nicusan@bham.ac.uk>. + + + +## Acknowledgements +I would like to thank the Formulation Engineering CDT @School of Chemical +Engineering and the Positron Imaging Centre @School of Physics and +Astronomy, University of Birmingham for supporting my work. + +And thanks to Dr. Kit Windows-Yule for putting up with my bonkers ideas. + + + +## Citing +If you use this library in your research, you are kindly asked to cite: + +> [Paper after publication] + + +This library would not have been possible without the excellent `r3d` library +(https://github.com/devonmpowell/r3d) which forms the very core of the C +subroutines; if you use KonigCell in your work, please also cite: + +> Powell D, Abel T. An exact general remeshing scheme applied to physically conservative voxelization. Journal of Computational Physics. 2015 Sep 15;297:340-56. + + + +## Licensing +KonigCell is MIT licensed. Enjoy. + + +%package -n python3-konigcell +Summary: Quantitative, Fast Grid-Based Fields Calculations in 2D and 3D - Residence Time Distributions, Velocity Grids, Eulerian Cell Projections etc. +Provides: python-konigcell +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +BuildRequires: python3-cffi +BuildRequires: gcc +BuildRequires: gdb +%description -n python3-konigcell + + +[](https://konigcell.readthedocs.io/en/latest/) + +[](https://pypi.python.org/pypi/konigcell/) +[](https://konigcell.readthedocs.io/en/latest/?badge=latest) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:python) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:cpp) +[](https://github.com/anicusan/konigcell) +[](https://pypi.python.org/pypi/konigcell/) + +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) + +#### **Quantitative, Fast Grid-Based Fields Calculations in 2D and 3D** - Residence Time Distributions, Velocity Grids, Eulerian Cell Projections etc. + +That sounds dry as heck. + +#### **Project moving particles' trajectories (experimental or simulated) onto 2D or 3D grids with infinite resolution.** + +Better? No? Here are some figures produced by KonigCell: + + + + +*Left panel: 2D residence time distribution in a GranuTools GranuDrum imaged using Positron Emission Particle Tracking (PEPT). Two middle panels: 3D velocity distribution in the same system; voxels are rendered as a scatter plot (left) and tomogram-like 3-slice (right). Right panel: velocity vectorfield in a constricted pipe simulating a aneurysm, imaged using PEPT.* + + +This is, to my knowledge, the only library that accurately projects particle +trajectories onto grids - that is, taking their full projected area / volume into +account (and not approximating them as points / lines). It's also the only one creating +quantitative 3D projections. + +And it is *fast* - 1,000,000 particle positions can be rasterized onto a 512x512 +grid in 7 seconds on my 16-thread i9 CPU. The code is fully parallelised on +threads, processes or distributed MPI nodes. + + + +## But Why? + +Rasterizing moving tracers onto uniform grids is a powerful way of computing statistics about a +system - occupancies, velocity vector fields, modelling particle clump imaging etc. - be it +experimental or simulated. However, the classical approach of approximating particle trajectories +as lines discards a lot of (most) information. + +Here is an example of a particle moving randomly inside a box - on a high resolution (512x512) +pixel grid, the classical approach (top row) does not yield much better statistics with increasing +numbers of particle positions imaged. Projecting complete trajectory **areas** onto the grid +(KonigCell, bottom row) preserves more information about the system explored: + + + + +A typical strategy for dealing with information loss is to coarsen the pixel grid, resulting in +a trade-off between accuracy and statistical soundness. However, even very low resolutions +still yield less information using line approximations (top row). With area projections, +**you can increase the resolution arbitrarily** and improve precision (KonigCell, bottom row): + + + + + + +## The KonigCell Libraries + +This repository effectively hosts three libraries: + +- `konigcell2d`: a portable C library for 2D grid projections. +- `konigcell3d`: a portable C library for 3D grid projections. +- `konigcell`: a user-friendly Python interface to the two libraries above. + + + +### Installing the Python Package + +This package supports Python 3.6 and above (though it might work with even older +versions). + +Install this package from PyPI: + +```pip install konigcell``` + + +Or conda-forge: + +```conda install konigcell``` + + +If you have a relatively standard system, the above should just download pre-compiled wheels - +so no prior configuration should be needed. + + +To *build* this package on your specific machine, you will need a C compiler - +the low-level C code does not use any tomfoolery, so any compiler since the +2000s should do. + + +To build the latest development version from GitHub: + +```pip install git+https://github.com/anicusan/KonigCell``` + + + +### Integrating the C Libraries with your Code + +The C libraries in the `konigcell2d` and `konigcell3d` directories in this repository; they +contain instructions for compiling and using the low-level subroutines. All code is fully +commented and follows a portable subset of the C99 standard - so no VLAs, weird macros or +compiler-specific extensions. Even MSVC compiles it! + +You can run `make` in the `konigcell2d` or `konigcell3d` directories to build shared +libraries and the example executables under `-Wall -Werror -Wextra` like a stickler. Running +`make` in the repository root builds both libraries. + +Both libraries are effectively single-source - they should be as straightforward as possible +to integrate in other C / C++ codebases, or interface with from higher-level programming +languages. + + + +## Examples and Documentation + +The `examples` directory contains some Python scripts using the high-level Python routines +and the low-level Cython interfaces. The `konigcell2d` and `konigcell3d` directories contain +C examples. + +Full documentation is available [here](https://konigcell.readthedocs.io/). + +```python +import numpy as np +import konigcell as kc + +# Generate a short trajectory of XY positions to pixellise +positions = np.array([ + [0.3, 0.2], + [0.2, 0.8], + [0.3, 0.55], + [0.6, 0.8], + [0.3, 0.45], + [0.6, 0.2], +]) + +# The particle radius may change +radii = np.array([0.05, 0.03, 0.01, 0.02, 0.02, 0.03]) + +# Values to rasterize - velocity, duration, etc. +values = np.array([1, 2, 1, 1, 2, 1]) + +# Pixellise the particle trajectories +pixels1 = kc.dynamic2d( + positions, + mode = kc.ONE, + radii = radii, + values = values[:-1], + resolution = (512, 512), +) + +pixels2 = kc.static2d( + positions, + mode = kc.ONE, + radii = radii, + values = values, + resolution = (512, 512), +) + +# Create Plotly 1x2 subplot grid and add Plotly heatmaps of pixels +fig = kc.create_fig( + nrows = 1, ncols = 2, + subplot_titles = ["Dynamic 2D", "Static 2D"], +) + +fig.add_trace(pixels1.heatmap_trace(), row = 1, col = 1) +fig.add_trace(pixels2.heatmap_trace(), row = 1, col = 2) + +fig.show() +``` + + + + + +## Contributing +You are more than welcome to contribute to this library in the form of library +improvements, documentation or helpful examples; please submit them either as: + +- GitHub issues. +- Pull requests (superheroes only). +- Email me at <a.l.nicusan@bham.ac.uk>. + + + +## Acknowledgements +I would like to thank the Formulation Engineering CDT @School of Chemical +Engineering and the Positron Imaging Centre @School of Physics and +Astronomy, University of Birmingham for supporting my work. + +And thanks to Dr. Kit Windows-Yule for putting up with my bonkers ideas. + + + +## Citing +If you use this library in your research, you are kindly asked to cite: + +> [Paper after publication] + + +This library would not have been possible without the excellent `r3d` library +(https://github.com/devonmpowell/r3d) which forms the very core of the C +subroutines; if you use KonigCell in your work, please also cite: + +> Powell D, Abel T. An exact general remeshing scheme applied to physically conservative voxelization. Journal of Computational Physics. 2015 Sep 15;297:340-56. + + + +## Licensing +KonigCell is MIT licensed. Enjoy. + + +%package help +Summary: Development documents and examples for konigcell +Provides: python3-konigcell-doc +%description help + + +[](https://konigcell.readthedocs.io/en/latest/) + +[](https://pypi.python.org/pypi/konigcell/) +[](https://konigcell.readthedocs.io/en/latest/?badge=latest) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:python) +[](https://lgtm.com/projects/g/anicusan/KonigCell/context:cpp) +[](https://github.com/anicusan/konigcell) +[](https://pypi.python.org/pypi/konigcell/) + +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) +[](https://pypi.org/project/konigcell/#files) + +#### **Quantitative, Fast Grid-Based Fields Calculations in 2D and 3D** - Residence Time Distributions, Velocity Grids, Eulerian Cell Projections etc. + +That sounds dry as heck. + +#### **Project moving particles' trajectories (experimental or simulated) onto 2D or 3D grids with infinite resolution.** + +Better? No? Here are some figures produced by KonigCell: + + + + +*Left panel: 2D residence time distribution in a GranuTools GranuDrum imaged using Positron Emission Particle Tracking (PEPT). Two middle panels: 3D velocity distribution in the same system; voxels are rendered as a scatter plot (left) and tomogram-like 3-slice (right). Right panel: velocity vectorfield in a constricted pipe simulating a aneurysm, imaged using PEPT.* + + +This is, to my knowledge, the only library that accurately projects particle +trajectories onto grids - that is, taking their full projected area / volume into +account (and not approximating them as points / lines). It's also the only one creating +quantitative 3D projections. + +And it is *fast* - 1,000,000 particle positions can be rasterized onto a 512x512 +grid in 7 seconds on my 16-thread i9 CPU. The code is fully parallelised on +threads, processes or distributed MPI nodes. + + + +## But Why? + +Rasterizing moving tracers onto uniform grids is a powerful way of computing statistics about a +system - occupancies, velocity vector fields, modelling particle clump imaging etc. - be it +experimental or simulated. However, the classical approach of approximating particle trajectories +as lines discards a lot of (most) information. + +Here is an example of a particle moving randomly inside a box - on a high resolution (512x512) +pixel grid, the classical approach (top row) does not yield much better statistics with increasing +numbers of particle positions imaged. Projecting complete trajectory **areas** onto the grid +(KonigCell, bottom row) preserves more information about the system explored: + + + + +A typical strategy for dealing with information loss is to coarsen the pixel grid, resulting in +a trade-off between accuracy and statistical soundness. However, even very low resolutions +still yield less information using line approximations (top row). With area projections, +**you can increase the resolution arbitrarily** and improve precision (KonigCell, bottom row): + + + + + + +## The KonigCell Libraries + +This repository effectively hosts three libraries: + +- `konigcell2d`: a portable C library for 2D grid projections. +- `konigcell3d`: a portable C library for 3D grid projections. +- `konigcell`: a user-friendly Python interface to the two libraries above. + + + +### Installing the Python Package + +This package supports Python 3.6 and above (though it might work with even older +versions). + +Install this package from PyPI: + +```pip install konigcell``` + + +Or conda-forge: + +```conda install konigcell``` + + +If you have a relatively standard system, the above should just download pre-compiled wheels - +so no prior configuration should be needed. + + +To *build* this package on your specific machine, you will need a C compiler - +the low-level C code does not use any tomfoolery, so any compiler since the +2000s should do. + + +To build the latest development version from GitHub: + +```pip install git+https://github.com/anicusan/KonigCell``` + + + +### Integrating the C Libraries with your Code + +The C libraries in the `konigcell2d` and `konigcell3d` directories in this repository; they +contain instructions for compiling and using the low-level subroutines. All code is fully +commented and follows a portable subset of the C99 standard - so no VLAs, weird macros or +compiler-specific extensions. Even MSVC compiles it! + +You can run `make` in the `konigcell2d` or `konigcell3d` directories to build shared +libraries and the example executables under `-Wall -Werror -Wextra` like a stickler. Running +`make` in the repository root builds both libraries. + +Both libraries are effectively single-source - they should be as straightforward as possible +to integrate in other C / C++ codebases, or interface with from higher-level programming +languages. + + + +## Examples and Documentation + +The `examples` directory contains some Python scripts using the high-level Python routines +and the low-level Cython interfaces. The `konigcell2d` and `konigcell3d` directories contain +C examples. + +Full documentation is available [here](https://konigcell.readthedocs.io/). + +```python +import numpy as np +import konigcell as kc + +# Generate a short trajectory of XY positions to pixellise +positions = np.array([ + [0.3, 0.2], + [0.2, 0.8], + [0.3, 0.55], + [0.6, 0.8], + [0.3, 0.45], + [0.6, 0.2], +]) + +# The particle radius may change +radii = np.array([0.05, 0.03, 0.01, 0.02, 0.02, 0.03]) + +# Values to rasterize - velocity, duration, etc. +values = np.array([1, 2, 1, 1, 2, 1]) + +# Pixellise the particle trajectories +pixels1 = kc.dynamic2d( + positions, + mode = kc.ONE, + radii = radii, + values = values[:-1], + resolution = (512, 512), +) + +pixels2 = kc.static2d( + positions, + mode = kc.ONE, + radii = radii, + values = values, + resolution = (512, 512), +) + +# Create Plotly 1x2 subplot grid and add Plotly heatmaps of pixels +fig = kc.create_fig( + nrows = 1, ncols = 2, + subplot_titles = ["Dynamic 2D", "Static 2D"], +) + +fig.add_trace(pixels1.heatmap_trace(), row = 1, col = 1) +fig.add_trace(pixels2.heatmap_trace(), row = 1, col = 2) + +fig.show() +``` + + + + + +## Contributing +You are more than welcome to contribute to this library in the form of library +improvements, documentation or helpful examples; please submit them either as: + +- GitHub issues. +- Pull requests (superheroes only). +- Email me at <a.l.nicusan@bham.ac.uk>. + + + +## Acknowledgements +I would like to thank the Formulation Engineering CDT @School of Chemical +Engineering and the Positron Imaging Centre @School of Physics and +Astronomy, University of Birmingham for supporting my work. + +And thanks to Dr. Kit Windows-Yule for putting up with my bonkers ideas. + + + +## Citing +If you use this library in your research, you are kindly asked to cite: + +> [Paper after publication] + + +This library would not have been possible without the excellent `r3d` library +(https://github.com/devonmpowell/r3d) which forms the very core of the C +subroutines; if you use KonigCell in your work, please also cite: + +> Powell D, Abel T. An exact general remeshing scheme applied to physically conservative voxelization. Journal of Computational Physics. 2015 Sep 15;297:340-56. + + + +## Licensing +KonigCell is MIT licensed. Enjoy. + + +%prep +%autosetup -n konigcell-0.2.1 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-konigcell -f filelist.lst +%dir %{python3_sitearch}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Mon May 29 2023 Python_Bot <Python_Bot@openeuler.org> - 0.2.1-1 +- Package Spec generated @@ -0,0 +1 @@ +5eda3504a194563552b91ce27420b6e5 konigcell-0.2.1.tar.gz |