morphogen 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- morphogen/__init__.py +60 -0
- morphogen/__main__.py +7 -0
- morphogen/_platform.py +55 -0
- morphogen/_public.py +153 -0
- morphogen/_utils.py +80 -0
- morphogen/_version.py +1 -0
- morphogen/analysis/__init__.py +174 -0
- morphogen/analysis/anisotropy.py +135 -0
- morphogen/analysis/basic.py +38 -0
- morphogen/analysis/cells.py +54 -0
- morphogen/analysis/connectivity.py +156 -0
- morphogen/analysis/correlation.py +195 -0
- morphogen/analysis/covariance.py +80 -0
- morphogen/analysis/fractal.py +54 -0
- morphogen/analysis/measures.py +188 -0
- morphogen/analysis/morphology.py +265 -0
- morphogen/analysis/particles.py +160 -0
- morphogen/analysis/percolation.py +2034 -0
- morphogen/analysis/power_laws.py +143 -0
- morphogen/analysis/random_sets.py +351 -0
- morphogen/analysis/stereology.py +289 -0
- morphogen/analysis/surface.py +107 -0
- morphogen/analysis/topology.py +92 -0
- morphogen/automata/__init__.py +74 -0
- morphogen/automata/engine.py +211 -0
- morphogen/automata/growth.py +686 -0
- morphogen/automata/lattice.py +143 -0
- morphogen/automata/reaction.py +255 -0
- morphogen/automata/rules.py +353 -0
- morphogen/automata/tilings.py +1715 -0
- morphogen/cli.py +3526 -0
- morphogen/config.py +2167 -0
- morphogen/contact/__init__.py +113 -0
- morphogen/contact/experiments.py +368 -0
- morphogen/contact/hertz.py +104 -0
- morphogen/contact/kernels.py +827 -0
- morphogen/contact/periodic.py +278 -0
- morphogen/contact/problem.py +578 -0
- morphogen/contact/surfaces.py +310 -0
- morphogen/coupling/__init__.py +43 -0
- morphogen/coupling/ageing.py +143 -0
- morphogen/coupling/diffusion.py +226 -0
- morphogen/coupling/fenicsx.py +484 -0
- morphogen/coupling/oxidation.py +447 -0
- morphogen/coupling/plates.py +247 -0
- morphogen/design/__init__.py +51 -0
- morphogen/design/csp.py +616 -0
- morphogen/design/frames.py +277 -0
- morphogen/design/search.py +287 -0
- morphogen/design/tiles.py +336 -0
- morphogen/distributions.py +312 -0
- morphogen/domain.py +203 -0
- morphogen/dynamics/__init__.py +179 -0
- morphogen/dynamics/model.py +638 -0
- morphogen/dynamics/openradioss.py +643 -0
- morphogen/dynamics/results.py +515 -0
- morphogen/fracture/__init__.py +170 -0
- morphogen/fracture/bulk.py +349 -0
- morphogen/fracture/cohesive.py +1614 -0
- morphogen/fracture/ductile.py +557 -0
- morphogen/fracture/lefm.py +1168 -0
- morphogen/fracture/mixed.py +1178 -0
- morphogen/fracture/periodic.py +733 -0
- morphogen/fracture/phasefield.py +714 -0
- morphogen/fracture/phasefield_finite.py +368 -0
- morphogen/fracture/surface.py +572 -0
- morphogen/fracture/toughness.py +566 -0
- morphogen/gpu.py +108 -0
- morphogen/gui/__init__.py +8 -0
- morphogen/gui/api.py +1927 -0
- morphogen/gui/desktop.py +387 -0
- morphogen/gui/icon.png +0 -0
- morphogen/gui/index.html +1909 -0
- morphogen/gui/server.py +229 -0
- morphogen/gui/tools/__init__.py +629 -0
- morphogen/gui/tools/compare.py +149 -0
- morphogen/gui/tools/contact.py +391 -0
- morphogen/gui/tools/couplings.py +1085 -0
- morphogen/gui/tools/crackfront.py +245 -0
- morphogen/gui/tools/design.py +224 -0
- morphogen/gui/tools/dynamics.py +824 -0
- morphogen/gui/tools/fracture.py +2586 -0
- morphogen/gui/tools/interop.py +1654 -0
- morphogen/gui/tools/learning.py +595 -0
- morphogen/gui/tools/mechanics.py +3881 -0
- morphogen/gui/tools/nonlocal_damage.py +1321 -0
- morphogen/gui/tools/phasefield.py +215 -0
- morphogen/gui/tools/physics.py +597 -0
- morphogen/gui/tools/stability.py +1756 -0
- morphogen/gui/tools/statistics.py +1408 -0
- morphogen/gui/viewer.js +1100 -0
- morphogen/homogenization/__init__.py +210 -0
- morphogen/homogenization/acoustics.py +566 -0
- morphogen/homogenization/amg.py +1005 -0
- morphogen/homogenization/apparent.py +1046 -0
- morphogen/homogenization/behaviours.cu +2285 -0
- morphogen/homogenization/behaviours.py +944 -0
- morphogen/homogenization/beremin.py +263 -0
- morphogen/homogenization/bifurcation.py +1085 -0
- morphogen/homogenization/bloch.py +507 -0
- morphogen/homogenization/bounds.py +226 -0
- morphogen/homogenization/core.py +458 -0
- morphogen/homogenization/coupled.py +1135 -0
- morphogen/homogenization/crystal.py +2967 -0
- morphogen/homogenization/dilatation.py +454 -0
- morphogen/homogenization/elements.py +157 -0
- morphogen/homogenization/fatigue.py +768 -0
- morphogen/homogenization/fe.py +1739 -0
- morphogen/homogenization/fenicsx.py +307 -0
- morphogen/homogenization/fft.py +499 -0
- morphogen/homogenization/fft_nonlinear.py +391 -0
- morphogen/homogenization/finite.py +613 -0
- morphogen/homogenization/flow.py +361 -0
- morphogen/homogenization/frames.py +1125 -0
- morphogen/homogenization/gpu.py +1241 -0
- morphogen/homogenization/harmonic.py +427 -0
- morphogen/homogenization/identification.py +579 -0
- morphogen/homogenization/kernels.py +760 -0
- morphogen/homogenization/laws.py +2061 -0
- morphogen/homogenization/materials.py +1080 -0
- morphogen/homogenization/mfront.py +589 -0
- morphogen/homogenization/networks.py +880 -0
- morphogen/homogenization/nonlinear.py +2612 -0
- morphogen/homogenization/ntfa.py +577 -0
- morphogen/homogenization/paths.py +476 -0
- morphogen/homogenization/photonic.py +467 -0
- morphogen/homogenization/poroelastic.py +212 -0
- morphogen/homogenization/porous.py +1120 -0
- morphogen/homogenization/postprocess.py +290 -0
- morphogen/homogenization/solvers.py +1140 -0
- morphogen/homogenization/tensors.py +240 -0
- morphogen/homogenization/voxel_fe.py +457 -0
- morphogen/homogenization/xfem.py +1016 -0
- morphogen/homogenization/zmat.py +1258 -0
- morphogen/iga/__init__.py +48 -0
- morphogen/iga/analysis.py +508 -0
- morphogen/iga/basis.py +214 -0
- morphogen/iga/geometry.py +501 -0
- morphogen/iga/homogenization.py +219 -0
- morphogen/iga/optimization.py +700 -0
- morphogen/iga/shapes.py +331 -0
- morphogen/image.py +128 -0
- morphogen/io/__init__.py +246 -0
- morphogen/io/amitex.py +741 -0
- morphogen/io/ebsd.py +881 -0
- morphogen/io/export.py +196 -0
- morphogen/io/geometry.py +158 -0
- morphogen/io/medit.py +147 -0
- morphogen/io/meshes.py +844 -0
- morphogen/io/metaimage.py +97 -0
- morphogen/io/mfront.py +1104 -0
- morphogen/io/native.py +57 -0
- morphogen/io/radioss.py +764 -0
- morphogen/io/solvers.py +371 -0
- morphogen/io/tables.py +278 -0
- morphogen/io/tiff.py +66 -0
- morphogen/io/vtk.py +701 -0
- morphogen/io/xdmf.py +200 -0
- morphogen/kernels/__init__.py +5 -0
- morphogen/kernels/annealing.py +192 -0
- morphogen/kernels/cells.py +69 -0
- morphogen/kernels/collective.py +87 -0
- morphogen/kernels/force_biased.py +595 -0
- morphogen/kernels/implicit.py +145 -0
- morphogen/kernels/leaves.py +132 -0
- morphogen/kernels/packing.py +304 -0
- morphogen/kernels/raster.py +279 -0
- morphogen/kernels/rsa.py +371 -0
- morphogen/kernels/union.py +135 -0
- morphogen/kernels/watershed.py +190 -0
- morphogen/laser/__init__.py +234 -0
- morphogen/laser/architectures.py +375 -0
- morphogen/laser/bending.py +216 -0
- morphogen/laser/cells.py +1694 -0
- morphogen/laser/design.py +940 -0
- morphogen/laser/figures.py +227 -0
- morphogen/laser/heat.py +804 -0
- morphogen/laser/materials.py +691 -0
- morphogen/laser/mechanics.py +1670 -0
- morphogen/laser/metallurgy.py +615 -0
- morphogen/laser/patterns.py +828 -0
- morphogen/laser/periodic.py +392 -0
- morphogen/laser/process.py +362 -0
- morphogen/laser/run.py +534 -0
- morphogen/laser/solid.py +216 -0
- morphogen/laser/specimen.py +200 -0
- morphogen/laser/structures.py +708 -0
- morphogen/learning/__init__.py +81 -0
- morphogen/learning/behaviour.py +398 -0
- morphogen/learning/data.py +328 -0
- morphogen/learning/learned.cpp +668 -0
- morphogen/learning/logarithmic.py +202 -0
- morphogen/learning/mfront.py +409 -0
- morphogen/learning/networks.py +767 -0
- morphogen/learning/run.py +212 -0
- morphogen/learning/standard.py +814 -0
- morphogen/learning/training.py +235 -0
- morphogen/mesh/__init__.py +29 -0
- morphogen/mesh/conforming.py +1423 -0
- morphogen/mesh/curved.py +600 -0
- morphogen/mesh/exact.py +1717 -0
- morphogen/mesh/octree.py +350 -0
- morphogen/mesh/polycrystal.py +1041 -0
- morphogen/mesh/polyhedra.py +677 -0
- morphogen/mesh/regularize.py +570 -0
- morphogen/mesh/surface.py +97 -0
- morphogen/mesh/tetra.py +512 -0
- morphogen/mesh/voxel.py +124 -0
- morphogen/micromorphic/__init__.py +31 -0
- morphogen/micromorphic/damage.py +359 -0
- morphogen/micromorphic/ductile.py +534 -0
- morphogen/micromorphic/finite.py +220 -0
- morphogen/micromorphic/microfoam.py +787 -0
- morphogen/micromorphic/space.py +341 -0
- morphogen/models/__init__.py +195 -0
- morphogen/models/affine.py +384 -0
- morphogen/models/automata.py +592 -0
- morphogen/models/base.py +500 -0
- morphogen/models/boolean.py +310 -0
- morphogen/models/bouligand.py +331 -0
- morphogen/models/branching.py +241 -0
- morphogen/models/combination.py +430 -0
- morphogen/models/deadleaves.py +766 -0
- morphogen/models/design.py +289 -0
- morphogen/models/ebsd.py +206 -0
- morphogen/models/fibers.py +1476 -0
- morphogen/models/foam.py +594 -0
- morphogen/models/gaussian.py +314 -0
- morphogen/models/growth.py +459 -0
- morphogen/models/hardcore.py +317 -0
- morphogen/models/hierarchical.py +269 -0
- morphogen/models/honeycomb.py +749 -0
- morphogen/models/implicit.py +177 -0
- morphogen/models/laminate.py +470 -0
- morphogen/models/lattice.py +351 -0
- morphogen/models/lattice_field.py +345 -0
- morphogen/models/levelset_foam.py +563 -0
- morphogen/models/nacre.py +411 -0
- morphogen/models/nested.py +924 -0
- morphogen/models/osteons.py +374 -0
- morphogen/models/pieces.py +167 -0
- morphogen/models/planar.py +126 -0
- morphogen/models/reconstruction.py +203 -0
- morphogen/models/scale_rich.py +1409 -0
- morphogen/models/scale_rich_3d.py +1616 -0
- morphogen/models/tessellation.py +735 -0
- morphogen/models/tiling_field.py +302 -0
- morphogen/models/tpms.py +197 -0
- morphogen/models/transparent.py +406 -0
- morphogen/models/union.py +141 -0
- morphogen/optimization/__init__.py +43 -0
- morphogen/optimization/cell.py +295 -0
- morphogen/optimization/filters.py +115 -0
- morphogen/optimization/mma.py +226 -0
- morphogen/optimization/run.py +219 -0
- morphogen/optimization/topology.py +632 -0
- morphogen/orientations.py +568 -0
- morphogen/parallel.py +599 -0
- morphogen/pipeline.py +978 -0
- morphogen/primitives.py +188 -0
- morphogen/results.py +564 -0
- morphogen/rve/__init__.py +73 -0
- morphogen/rve/report.py +627 -0
- morphogen/rve/scaling.py +363 -0
- morphogen/rve/study.py +1054 -0
- morphogen/rve/windows.py +345 -0
- morphogen/seeding.py +51 -0
- morphogen/settings.py +118 -0
- morphogen/stopping.py +48 -0
- morphogen/symmetry.py +384 -0
- morphogen/templates/activator_inhibitor.yaml +22 -0
- morphogen/templates/aggregation.yaml +23 -0
- morphogen/templates/boolean_cylinders.yaml +20 -0
- morphogen/templates/boolean_spheres.yaml +22 -0
- morphogen/templates/bouligand.yaml +28 -0
- morphogen/templates/cellular_automaton.yaml +25 -0
- morphogen/templates/coated_spheres.yaml +26 -0
- morphogen/templates/contact_fibers.yaml +27 -0
- morphogen/templates/cox_nanocomposite.yaml +22 -0
- morphogen/templates/cross_linked_fibers.yaml +26 -0
- morphogen/templates/curved_arcs.yaml +28 -0
- morphogen/templates/curved_fibers.yaml +24 -0
- morphogen/templates/dead_leaves.yaml +22 -0
- morphogen/templates/delaunay_network.yaml +22 -0
- morphogen/templates/dense_packing.yaml +22 -0
- morphogen/templates/diffusion.yaml +33 -0
- morphogen/templates/ebsd.yaml +34 -0
- morphogen/templates/ebsd_map.ctf +3087 -0
- morphogen/templates/fracture_composite.yaml +42 -0
- morphogen/templates/fracture_rubber.yaml +47 -0
- morphogen/templates/gaussian_excursion.yaml +17 -0
- morphogen/templates/graded_lattice.yaml +24 -0
- morphogen/templates/hardcore_fibers.yaml +22 -0
- morphogen/templates/hardcore_spheres.yaml +22 -0
- morphogen/templates/hierarchical_lattice.yaml +22 -0
- morphogen/templates/homogenization_acoustic_foam.yaml +36 -0
- morphogen/templates/homogenization_beremin.yaml +50 -0
- morphogen/templates/homogenization_cleavage.yaml +51 -0
- morphogen/templates/homogenization_cleavage_band.yaml +55 -0
- morphogen/templates/homogenization_contact.yaml +43 -0
- morphogen/templates/homogenization_crack_closure.yaml +49 -0
- morphogen/templates/homogenization_crystal_plasticity.yaml +50 -0
- morphogen/templates/homogenization_crystal_plasticity_fft.yaml +52 -0
- morphogen/templates/homogenization_crystallization.yaml +30 -0
- morphogen/templates/homogenization_debonding.yaml +43 -0
- morphogen/templates/homogenization_detwinning.yaml +58 -0
- morphogen/templates/homogenization_ductile_damage.yaml +47 -0
- morphogen/templates/homogenization_fatigue.yaml +40 -0
- morphogen/templates/homogenization_grain_fracture.yaml +56 -0
- morphogen/templates/homogenization_gyroid.yaml +30 -0
- morphogen/templates/homogenization_intergranular.yaml +43 -0
- morphogen/templates/homogenization_interphase.yaml +42 -0
- morphogen/templates/homogenization_mixed_loading.yaml +33 -0
- morphogen/templates/homogenization_ntfa.yaml +56 -0
- morphogen/templates/homogenization_piezoelectric.yaml +27 -0
- morphogen/templates/homogenization_polycrystal.yaml +30 -0
- morphogen/templates/homogenization_polycrystal_inclusions.yaml +30 -0
- morphogen/templates/homogenization_poroelastic.yaml +26 -0
- morphogen/templates/homogenization_rubber.yaml +40 -0
- morphogen/templates/homogenization_slip_cleavage.yaml +50 -0
- morphogen/templates/homogenization_spheres.yaml +31 -0
- morphogen/templates/homogenization_transport.yaml +29 -0
- morphogen/templates/homogenization_twinning.yaml +54 -0
- morphogen/templates/homogenization_viscoelastic.yaml +34 -0
- morphogen/templates/homogenization_viscoplastic.yaml +42 -0
- morphogen/templates/homogenization_voronoi.yaml +26 -0
- morphogen/templates/homogenization_xfem.yaml +23 -0
- morphogen/templates/hyperuniform_cells.yaml +24 -0
- morphogen/templates/laguerre.yaml +18 -0
- morphogen/templates/laser_bending.yaml +35 -0
- morphogen/templates/laser_cells.yaml +38 -0
- morphogen/templates/laser_corrugated.yaml +36 -0
- morphogen/templates/level_set_foam.yaml +29 -0
- morphogen/templates/menger_sponge.yaml +17 -0
- morphogen/templates/nacre.yaml +25 -0
- morphogen/templates/nucleation_growth.yaml +25 -0
- morphogen/templates/optimize_auxetic.yaml +29 -0
- morphogen/templates/optimize_auxetic_3d.yaml +27 -0
- morphogen/templates/optimize_bulk.yaml +23 -0
- morphogen/templates/optimize_conductivity.yaml +20 -0
- morphogen/templates/osteons.yaml +28 -0
- morphogen/templates/penetrable_spheres.yaml +21 -0
- morphogen/templates/poisson_fibers.yaml +21 -0
- morphogen/templates/random_laminate.yaml +26 -0
- morphogen/templates/random_lattice.yaml +27 -0
- morphogen/templates/random_walk_fibers.yaml +26 -0
- morphogen/templates/reaction_diffusion.yaml +22 -0
- morphogen/templates/reconstruction.yaml +22 -0
- morphogen/templates/rve_cellular_automaton.yaml +23 -0
- morphogen/templates/rve_crystal_plasticity_fft.yaml +51 -0
- morphogen/templates/rve_multiphysics.yaml +43 -0
- morphogen/templates/rve_poisson_fibers.yaml +22 -0
- morphogen/templates/rve_poisson_fibers_fe.yaml +33 -0
- morphogen/templates/rve_voronoi_windows.yaml +20 -0
- morphogen/templates/scale_rich_network.yaml +29 -0
- morphogen/templates/scale_rich_plates.yaml +30 -0
- morphogen/templates/sequential_dead_leaves.yaml +25 -0
- morphogen/templates/strut_lattice.yaml +21 -0
- morphogen/templates/tile_assembly.yaml +28 -0
- morphogen/templates/tpms.yaml +19 -0
- morphogen/templates/trabecular_bone.yaml +29 -0
- morphogen/templates/transparent_dead_leaves.yaml +23 -0
- morphogen/templates/vascular_tree.yaml +23 -0
- morphogen/templates/voronoi.yaml +20 -0
- morphogen/templates/wood.yaml +34 -0
- morphogen/templates/workflow.yaml +56 -0
- morphogen/texture.py +665 -0
- morphogen/theory.py +162 -0
- morphogen/viz/__init__.py +12 -0
- morphogen/viz/export.py +244 -0
- morphogen/viz/figures.py +707 -0
- morphogen/viz/png.py +148 -0
- morphogen/viz/sections.py +696 -0
- morphogen/viz/surfaces.py +1352 -0
- morphogen/viz/video.py +904 -0
- morphogen/viz/workflow.py +488 -0
- morphogen-1.0.0.dist-info/METADATA +2316 -0
- morphogen-1.0.0.dist-info/RECORD +381 -0
- morphogen-1.0.0.dist-info/WHEEL +4 -0
- morphogen-1.0.0.dist-info/entry_points.txt +5 -0
- morphogen-1.0.0.dist-info/licenses/LICENSE +674 -0
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
"""Phase fractions."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import numpy as np
|
|
6
|
+
|
|
7
|
+
from morphogen.image import VoxelImage
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
def as_array(image) -> np.ndarray:
|
|
11
|
+
"""The array of an image: the data of a :class:`~morphogen.image.VoxelImage`, or any array-like
|
|
12
|
+
as a NumPy array."""
|
|
13
|
+
return image.data if isinstance(image, VoxelImage) else np.asarray(image)
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def indicator(image, phase: int = 1) -> np.ndarray:
|
|
17
|
+
"""Indicator of ``phase`` (boolean), or the partial-volume field of a float image."""
|
|
18
|
+
data = as_array(image)
|
|
19
|
+
if data.dtype.kind == "f":
|
|
20
|
+
if phase not in (0, 1):
|
|
21
|
+
raise ValueError("fraction images only describe phases 0 and 1")
|
|
22
|
+
return data if phase == 1 else 1.0 - data
|
|
23
|
+
return data == phase
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def volume_fraction(image, phase: int = 1) -> float:
|
|
27
|
+
"""Volume fraction of ``phase`` (mean of the partial volumes for float images)."""
|
|
28
|
+
ind = indicator(image, phase)
|
|
29
|
+
return float(np.mean(ind, dtype=np.float64))
|
|
30
|
+
|
|
31
|
+
|
|
32
|
+
def phase_fractions(image) -> dict[int, float]:
|
|
33
|
+
"""Volume fraction of every phase index present in an integer image."""
|
|
34
|
+
data = as_array(image)
|
|
35
|
+
if data.dtype.kind == "f":
|
|
36
|
+
raise ValueError("phase_fractions needs an integer phase image")
|
|
37
|
+
values, counts = np.unique(data, return_counts=True)
|
|
38
|
+
return {int(v): float(c) / data.size for v, c in zip(values, counts, strict=True)}
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
"""Statistics of label images (cells of tessellations, grains).
|
|
2
|
+
|
|
3
|
+
Negative labels mark voxels outside every cell (e.g. the untransformed matrix of a
|
|
4
|
+
partially crystallized structure): they are ignored.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
import numpy as np
|
|
10
|
+
|
|
11
|
+
from morphogen.analysis.basic import as_array
|
|
12
|
+
from morphogen.image import VoxelImage
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
def cell_volumes(labels, n_cells: int | None = None) -> np.ndarray:
|
|
16
|
+
"""Volume of every label 0..n_cells-1 (voxel counts times the voxel volume)."""
|
|
17
|
+
data = as_array(labels)
|
|
18
|
+
if data.dtype.kind not in "iu":
|
|
19
|
+
raise ValueError("cell_volumes needs an integer label image")
|
|
20
|
+
data = data.ravel()
|
|
21
|
+
counts = np.bincount(data[data >= 0], minlength=n_cells or 0)
|
|
22
|
+
vv = labels.voxel_volume if isinstance(labels, VoxelImage) else 1.0
|
|
23
|
+
return counts * vv
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def cell_adjacency(labels, periodic=None) -> np.ndarray:
|
|
27
|
+
"""Pairs ``(a, b)``, ``a < b``, of labels sharing at least one voxel face."""
|
|
28
|
+
data = as_array(labels).astype(np.int64)
|
|
29
|
+
if periodic is None:
|
|
30
|
+
periodic = labels.periodic if isinstance(labels, VoxelImage) else False
|
|
31
|
+
n = int(data.max()) + 1 if data.size else 0
|
|
32
|
+
keys = []
|
|
33
|
+
for axis in range(3):
|
|
34
|
+
if periodic:
|
|
35
|
+
other = np.roll(data, -1, axis=axis)
|
|
36
|
+
a, b = data.ravel(), other.ravel()
|
|
37
|
+
else:
|
|
38
|
+
a = np.take(data, np.arange(data.shape[axis] - 1), axis=axis).ravel()
|
|
39
|
+
b = np.take(data, np.arange(1, data.shape[axis]), axis=axis).ravel()
|
|
40
|
+
diff = (a != b) & (a >= 0) & (b >= 0)
|
|
41
|
+
lo = np.minimum(a[diff], b[diff])
|
|
42
|
+
hi = np.maximum(a[diff], b[diff])
|
|
43
|
+
keys.append(np.unique(lo * n + hi))
|
|
44
|
+
if not keys:
|
|
45
|
+
return np.empty((0, 2), dtype=np.int64)
|
|
46
|
+
k = np.unique(np.concatenate(keys))
|
|
47
|
+
return np.stack([k // n, k % n], axis=1)
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
def cell_neighbors(labels, periodic=None, n_cells: int | None = None) -> np.ndarray:
|
|
51
|
+
"""Number of face-sharing neighbours of every label (voxel estimate)."""
|
|
52
|
+
pairs = cell_adjacency(labels, periodic)
|
|
53
|
+
n = n_cells or max(0, int(as_array(labels).max(initial=-1)) + 1)
|
|
54
|
+
return np.bincount(pairs.ravel(), minlength=n)
|
|
@@ -0,0 +1,156 @@
|
|
|
1
|
+
"""Connected components and percolation."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from dataclasses import dataclass, field
|
|
6
|
+
|
|
7
|
+
import numpy as np
|
|
8
|
+
from scipy import ndimage
|
|
9
|
+
|
|
10
|
+
from morphogen.analysis.basic import as_array
|
|
11
|
+
from morphogen.image import VoxelImage
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
@dataclass
|
|
15
|
+
class Components:
|
|
16
|
+
"""Connected components of one phase.
|
|
17
|
+
|
|
18
|
+
``percolating[axis]`` tells whether a component joins the two faces normal to
|
|
19
|
+
``axis`` (inside the box, i.e. without using periodicity); ``spanning_fraction`` is
|
|
20
|
+
the fraction of the phase volume in components joining at least one pair of faces.
|
|
21
|
+
For periodic images, components touching across faces are merged before counting.
|
|
22
|
+
"""
|
|
23
|
+
|
|
24
|
+
n_components: int
|
|
25
|
+
sizes: np.ndarray
|
|
26
|
+
percolating: dict[str, bool]
|
|
27
|
+
spanning_fraction: float
|
|
28
|
+
labels: np.ndarray | None = field(default=None, repr=False)
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def _structure(connectivity: int) -> np.ndarray:
|
|
32
|
+
if connectivity == 6:
|
|
33
|
+
return ndimage.generate_binary_structure(3, 1)
|
|
34
|
+
if connectivity == 18:
|
|
35
|
+
return ndimage.generate_binary_structure(3, 2)
|
|
36
|
+
if connectivity == 26:
|
|
37
|
+
return ndimage.generate_binary_structure(3, 3)
|
|
38
|
+
raise ValueError("connectivity: 6, 18 or 26")
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
def _merge_periodic(labels: np.ndarray, n: int) -> np.ndarray:
|
|
42
|
+
"""Map label -> representative after joining components across opposite faces."""
|
|
43
|
+
parent = np.arange(n + 1)
|
|
44
|
+
|
|
45
|
+
def find(a):
|
|
46
|
+
while parent[a] != a:
|
|
47
|
+
parent[a] = parent[parent[a]]
|
|
48
|
+
a = parent[a]
|
|
49
|
+
return a
|
|
50
|
+
|
|
51
|
+
for axis in range(3):
|
|
52
|
+
a = np.take(labels, 0, axis=axis).ravel()
|
|
53
|
+
b = np.take(labels, -1, axis=axis).ravel()
|
|
54
|
+
mask = (a > 0) & (b > 0)
|
|
55
|
+
for u, v in np.unique(np.stack([a[mask], b[mask]], axis=1), axis=0):
|
|
56
|
+
ru, rv = find(int(u)), find(int(v))
|
|
57
|
+
if ru != rv:
|
|
58
|
+
parent[max(ru, rv)] = min(ru, rv)
|
|
59
|
+
return np.array([find(i) for i in range(n + 1)])
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
def connected_components(
|
|
63
|
+
image, phase: int = 1, *, connectivity: int = 6, periodic=None, return_labels=False
|
|
64
|
+
) -> Components:
|
|
65
|
+
"""The connected components of a phase of an image (``connectivity``: 6, 18 or 26 neighbours)
|
|
66
|
+
and whether they percolate along each axis, through the faces of a periodic image
|
|
67
|
+
(``periodic``, by default that of the image); their labels with ``return_labels``."""
|
|
68
|
+
data = as_array(image)
|
|
69
|
+
if periodic is None:
|
|
70
|
+
periodic = image.periodic if isinstance(image, VoxelImage) else False
|
|
71
|
+
mask = data == phase
|
|
72
|
+
labels, n = ndimage.label(mask, structure=_structure(connectivity))
|
|
73
|
+
percolating, spanning = {}, np.zeros(n + 1, dtype=bool)
|
|
74
|
+
for axis, name in enumerate("xyz"):
|
|
75
|
+
first = np.unique(np.take(labels, 0, axis=axis))
|
|
76
|
+
last = np.unique(np.take(labels, -1, axis=axis))
|
|
77
|
+
both = np.intersect1d(first[first > 0], last[last > 0])
|
|
78
|
+
percolating[name] = bool(len(both))
|
|
79
|
+
spanning[both] = True
|
|
80
|
+
sizes_raw = np.bincount(labels.ravel(), minlength=n + 1)
|
|
81
|
+
phase_volume = int(sizes_raw[1:].sum())
|
|
82
|
+
spanning_fraction = float(sizes_raw[spanning].sum() / phase_volume) if phase_volume else 0.0
|
|
83
|
+
if periodic and n:
|
|
84
|
+
rep = _merge_periodic(labels, n)
|
|
85
|
+
roots, inverse = np.unique(rep[1:], return_inverse=True)
|
|
86
|
+
sizes = np.bincount(inverse, weights=sizes_raw[1:]).astype(np.int64)
|
|
87
|
+
if return_labels:
|
|
88
|
+
relabel = np.concatenate([[0], inverse + 1])
|
|
89
|
+
labels = relabel[labels]
|
|
90
|
+
n = len(roots)
|
|
91
|
+
else:
|
|
92
|
+
sizes = sizes_raw[1:]
|
|
93
|
+
return Components(
|
|
94
|
+
n_components=int(n),
|
|
95
|
+
sizes=sizes,
|
|
96
|
+
percolating=percolating,
|
|
97
|
+
spanning_fraction=spanning_fraction,
|
|
98
|
+
labels=labels if return_labels else None,
|
|
99
|
+
)
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
def _wrapping(labels: np.ndarray, structure: np.ndarray) -> np.ndarray:
|
|
103
|
+
"""Whether a component of ``labels`` (labelled inside the box) wraps around the periodic
|
|
104
|
+
box along each axis: a cycle of neighbours through the faces winds around the axis, so
|
|
105
|
+
that the component tiles into a cluster unbounded along it."""
|
|
106
|
+
shape = labels.shape
|
|
107
|
+
edges = [np.empty((0, 5), dtype=np.int64)]
|
|
108
|
+
for d in np.argwhere(structure) - 1:
|
|
109
|
+
if tuple(d) <= (0, 0, 0): # one offset of each opposite pair, not the centre
|
|
110
|
+
continue
|
|
111
|
+
for a in np.flatnonzero(d): # voxels whose neighbour x + d is across the face normal to a
|
|
112
|
+
index = [np.arange(n) for n in shape]
|
|
113
|
+
index[a] = np.array([shape[a] - 1 if d[a] > 0 else 0])
|
|
114
|
+
moved = [i + k for i, k in zip(index, d, strict=True)]
|
|
115
|
+
u = labels[np.ix_(*index)]
|
|
116
|
+
v = labels[np.ix_(*[m % n for m, n in zip(moved, shape, strict=True)])]
|
|
117
|
+
shift = np.ix_(*[m // n for m, n in zip(moved, shape, strict=True)])
|
|
118
|
+
shift = np.stack(np.broadcast_arrays(*shift), axis=-1)
|
|
119
|
+
keep = (u > 0) & (v > 0)
|
|
120
|
+
edges.append(np.column_stack([u[keep], v[keep], shift[keep]]))
|
|
121
|
+
parent = list(range(int(labels.max()) + 1))
|
|
122
|
+
frame = np.zeros((len(parent), 3), dtype=np.int64) # box of a label's copy in its parent's
|
|
123
|
+
|
|
124
|
+
def find(a):
|
|
125
|
+
path = []
|
|
126
|
+
while parent[a] != a:
|
|
127
|
+
path.append(a)
|
|
128
|
+
a = parent[a]
|
|
129
|
+
for b in reversed(path[:-1]): # path compression, frames made relative to the root
|
|
130
|
+
frame[b] += frame[parent[b]]
|
|
131
|
+
parent[b] = a
|
|
132
|
+
return a
|
|
133
|
+
|
|
134
|
+
wraps = np.zeros(3, dtype=bool)
|
|
135
|
+
for u, v, *s in np.unique(np.concatenate(edges), axis=0).tolist():
|
|
136
|
+
ru, rv = find(u), find(v)
|
|
137
|
+
winding = frame[u] + s - frame[v] # copy of v met from u's copy, minus v's own copy
|
|
138
|
+
if ru == rv:
|
|
139
|
+
wraps |= winding != 0
|
|
140
|
+
else:
|
|
141
|
+
parent[rv] = ru
|
|
142
|
+
frame[rv] = winding
|
|
143
|
+
return wraps
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
def wrapping(image, phase: int = 1, *, connectivity: int = 6) -> dict[str, bool]:
|
|
147
|
+
"""Whether a component of a phase of an image wraps around the periodic box along each
|
|
148
|
+
axis (``connectivity``: 6, 18 or 26 neighbours): a cycle of neighbours through the faces
|
|
149
|
+
winds around the axis, so that the tiled component is a cluster unbounded along it, the
|
|
150
|
+
percolation of a periodic medium. Joining the two faces normal to the axis inside the
|
|
151
|
+
box (the flags ``percolating`` of :func:`connected_components`) neither implies it (a
|
|
152
|
+
staircase from face to face closes into no cycle) nor follows from it (a helix through
|
|
153
|
+
the faces normal to y wraps along x and y and joins no pair of faces)."""
|
|
154
|
+
structure = _structure(connectivity)
|
|
155
|
+
labels, _ = ndimage.label(as_array(image) == phase, structure=structure)
|
|
156
|
+
return dict(zip("xyz", _wrapping(labels, structure).tolist(), strict=True))
|
|
@@ -0,0 +1,195 @@
|
|
|
1
|
+
"""Statistical descriptors of random heterogeneous materials (Torquato 2002).
|
|
2
|
+
|
|
3
|
+
* *Lineal-path function* ``L(z)`` (Lu & Torquato 1992): the probability that a segment
|
|
4
|
+
of length ``z`` lies entirely in the phase, along the axes of the grid (segments of
|
|
5
|
+
``k + 1`` voxel centres at the lag ``k``). ``L(0)`` is the volume fraction; ``L`` keeps
|
|
6
|
+
the connectedness along lines that the covariance ``S_2`` ignores.
|
|
7
|
+
* *Two-point cluster function* ``C_2(r)`` (Torquato, Beasley & Chiew 1988): the
|
|
8
|
+
probability that ``x`` and ``x + r`` lie in the same cluster of the phase (connected
|
|
9
|
+
components, merged across the faces of periodic images); ``C_2 <= S_2``, and ``C_2``
|
|
10
|
+
keeps a long-range part only beyond the percolation threshold.
|
|
11
|
+
* *Pore-size function* (Prager 1963; Torquato & Avellaneda 1991): the law of the distance
|
|
12
|
+
``δ`` from a point of the phase to the nearest point of the other phase: its
|
|
13
|
+
exceedance ``F(δ)`` (``F(0) = 1``), density ``P(δ) = -F'(δ)`` and moments; the mean
|
|
14
|
+
pore size is ``∫ F(δ) dδ``. On voxels, ``δ`` is the distance between voxel centres less
|
|
15
|
+
half a voxel (the interface lies between the centres), exact for interfaces along the
|
|
16
|
+
axes and of the first order in the voxel size otherwise (the mean pore size of a
|
|
17
|
+
Boolean model of spheres of five voxels about 4 % low).
|
|
18
|
+
* *Radial distribution function* ``g(r)`` and *structure factor* ``S(k)`` of points in a
|
|
19
|
+
periodic box (the centres of packings): ``g`` is the density of the pairs at the
|
|
20
|
+
distance ``r`` over that of independent points; ``S(k) = |Σ_j e^{-i k·x_j}|² / N`` on
|
|
21
|
+
the wave vectors of the box, whose limit ``S(k → 0) = 0`` defines hyperuniform point
|
|
22
|
+
patterns (Torquato & Stillinger 2003).
|
|
23
|
+
"""
|
|
24
|
+
|
|
25
|
+
from __future__ import annotations
|
|
26
|
+
|
|
27
|
+
import math
|
|
28
|
+
from dataclasses import dataclass
|
|
29
|
+
|
|
30
|
+
import numpy as np
|
|
31
|
+
from scipy.spatial import cKDTree
|
|
32
|
+
|
|
33
|
+
from morphogen.analysis.basic import indicator
|
|
34
|
+
from morphogen.analysis.connectivity import connected_components
|
|
35
|
+
from morphogen.analysis.covariance import AxisFunction
|
|
36
|
+
from morphogen.analysis.morphology import _distance, _periodic, _spacing
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def _runs(lines: np.ndarray, periodic: bool) -> tuple[np.ndarray, int]:
|
|
40
|
+
"""The lengths of the runs of ones of the rows of a boolean array, and the number of
|
|
41
|
+
rows full of ones (periodic rows: the runs wrap around)."""
|
|
42
|
+
n = lines.shape[1]
|
|
43
|
+
full = 0
|
|
44
|
+
if periodic:
|
|
45
|
+
is_full = lines.all(axis=1)
|
|
46
|
+
full = int(is_full.sum())
|
|
47
|
+
lines = lines[~is_full]
|
|
48
|
+
if not len(lines):
|
|
49
|
+
return np.zeros(0, dtype=np.int64), full
|
|
50
|
+
# start every row on a zero: no run wraps around
|
|
51
|
+
shift = np.argmin(lines, axis=1)
|
|
52
|
+
lines = np.take_along_axis(lines, (np.arange(n)[None, :] + shift[:, None]) % n, axis=1)
|
|
53
|
+
d = np.diff(np.pad(lines, ((0, 0), (1, 1))).astype(np.int8), axis=1)
|
|
54
|
+
return (np.nonzero(d == -1)[1] - np.nonzero(d == 1)[1]).astype(np.int64), full
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def lineal_path(image, phase: int = 1, *, max_lag: int | None = None, periodic=None):
|
|
58
|
+
"""Lineal-path function of ``phase`` along the three axes, for the lags 0..max_lag
|
|
59
|
+
voxels (half the image by default): an :class:`AxisFunction`."""
|
|
60
|
+
field = indicator(image, phase)
|
|
61
|
+
spacing = _spacing(image)
|
|
62
|
+
periodic = _periodic(image, periodic)
|
|
63
|
+
lags, values = {}, {}
|
|
64
|
+
for axis, name in enumerate("xyz"):
|
|
65
|
+
n = field.shape[axis]
|
|
66
|
+
m = n // 2 if max_lag is None else min(int(max_lag), n - 1)
|
|
67
|
+
lines = np.moveaxis(field, axis, -1).reshape(-1, n)
|
|
68
|
+
runs, full = _runs(lines, periodic)
|
|
69
|
+
counts = np.bincount(runs, minlength=n + 1).astype(np.float64)
|
|
70
|
+
ell = np.arange(n + 1, dtype=np.float64)
|
|
71
|
+
# the segments of k + 1 voxels in a run of length l: l - k, for l > k
|
|
72
|
+
above = np.cumsum((counts * ell)[::-1])[::-1] # sum over l >= k of l n_l
|
|
73
|
+
number = np.cumsum(counts[::-1])[::-1]
|
|
74
|
+
k = np.arange(m + 1)
|
|
75
|
+
inside = above[k + 1] - k * number[k + 1] + full * n
|
|
76
|
+
positions = lines.shape[0] * (n if periodic else n - k)
|
|
77
|
+
values[name] = inside / positions
|
|
78
|
+
lags[name] = k * spacing[axis]
|
|
79
|
+
return AxisFunction(lags, values, float(np.mean(field, dtype=np.float64)))
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def two_point_cluster(image, phase: int = 1, *, max_lag: int | None = None, periodic=None):
|
|
83
|
+
"""Two-point cluster function of ``phase`` along the three axes (face-connected
|
|
84
|
+
clusters), for the lags 0..max_lag voxels: an :class:`AxisFunction`."""
|
|
85
|
+
periodic = _periodic(image, periodic)
|
|
86
|
+
labels = connected_components(image, phase, periodic=periodic, return_labels=True).labels
|
|
87
|
+
spacing = _spacing(image)
|
|
88
|
+
lags, values = {}, {}
|
|
89
|
+
for axis, name in enumerate("xyz"):
|
|
90
|
+
n = labels.shape[axis]
|
|
91
|
+
m = n // 2 if max_lag is None else min(int(max_lag), n - 1)
|
|
92
|
+
out = np.empty(m + 1)
|
|
93
|
+
for k in range(m + 1):
|
|
94
|
+
if periodic:
|
|
95
|
+
other = np.roll(labels, -k, axis=axis)
|
|
96
|
+
out[k] = np.mean((labels == other) & (labels > 0))
|
|
97
|
+
else:
|
|
98
|
+
a = np.take(labels, np.arange(n - k), axis=axis)
|
|
99
|
+
b = np.take(labels, np.arange(k, n), axis=axis)
|
|
100
|
+
out[k] = np.mean((a == b) & (a > 0))
|
|
101
|
+
values[name] = out
|
|
102
|
+
lags[name] = np.arange(m + 1) * spacing[axis]
|
|
103
|
+
return AxisFunction(lags, values, float(np.mean(labels > 0)))
|
|
104
|
+
|
|
105
|
+
|
|
106
|
+
@dataclass
|
|
107
|
+
class PoreSizes:
|
|
108
|
+
"""The pore-size function of a phase: the bin edges ``delta``, the exceedance ``F``
|
|
109
|
+
at the edges, the density ``P`` in the bins, and the first two moments of ``δ``."""
|
|
110
|
+
|
|
111
|
+
delta: np.ndarray
|
|
112
|
+
exceedance: np.ndarray
|
|
113
|
+
density: np.ndarray
|
|
114
|
+
mean: float
|
|
115
|
+
second_moment: float
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
def pore_size_function(image, phase: int = 0, *, bins: int = 64, periodic=None) -> PoreSizes:
|
|
119
|
+
"""The pore-size function of ``phase`` (by default the pores, phase 0): the law of the
|
|
120
|
+
distance from its points to the other phase (see the module)."""
|
|
121
|
+
mask = indicator(image, phase).astype(bool)
|
|
122
|
+
if not mask.any():
|
|
123
|
+
raise ValueError(f"pore sizes: no voxel of phase {phase}")
|
|
124
|
+
if mask.all():
|
|
125
|
+
raise ValueError(f"pore sizes: the image is all of phase {phase}")
|
|
126
|
+
spacing = _spacing(image)
|
|
127
|
+
periodic = _periodic(image, periodic)
|
|
128
|
+
dist = _distance(mask, spacing, False, 0)
|
|
129
|
+
if periodic: # through the faces: a margin of the largest distance inside the box
|
|
130
|
+
pad = min(int(np.ceil(dist.max() / spacing.min())) + 1, max(mask.shape) // 2)
|
|
131
|
+
dist = _distance(mask, spacing, True, pad)
|
|
132
|
+
delta = np.maximum(dist[mask] - 0.5 * float(spacing.min()), 0.0)
|
|
133
|
+
edges = np.linspace(0.0, float(delta.max()) * (1.0 + 1e-12), bins + 1)
|
|
134
|
+
ordered = np.sort(delta)
|
|
135
|
+
exceedance = 1.0 - np.searchsorted(ordered, edges, side="left") / len(ordered)
|
|
136
|
+
density = -np.diff(exceedance) / np.diff(edges)
|
|
137
|
+
return PoreSizes(edges, exceedance, density, float(delta.mean()), float(np.mean(delta**2)))
|
|
138
|
+
|
|
139
|
+
|
|
140
|
+
def _wrapped(points, box) -> np.ndarray:
|
|
141
|
+
p = np.mod(np.asarray(points, dtype=float), box)
|
|
142
|
+
p[p >= box] = 0.0
|
|
143
|
+
return p
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
def radial_distribution(points, box, *, r_max: float | None = None, bins: int = 100):
|
|
147
|
+
"""The radial distribution function ``g(r)`` of points in a periodic box of edges
|
|
148
|
+
``box``: the centres of the bins of ``r`` (up to ``r_max``, a quarter of the
|
|
149
|
+
smallest edge by default) and ``g`` in them."""
|
|
150
|
+
box = np.asarray(box, dtype=float)
|
|
151
|
+
pts = _wrapped(points, box)
|
|
152
|
+
n = len(pts)
|
|
153
|
+
if n < 2:
|
|
154
|
+
raise ValueError("radial distribution: two points at least")
|
|
155
|
+
r_max = float(box.min()) / 4.0 if r_max is None else float(r_max)
|
|
156
|
+
if r_max > box.min() / 2.0:
|
|
157
|
+
raise ValueError("radial distribution: r_max up to half the box")
|
|
158
|
+
pairs = cKDTree(pts, boxsize=box).query_pairs(r_max, output_type="ndarray")
|
|
159
|
+
d = pts[pairs[:, 0]] - pts[pairs[:, 1]]
|
|
160
|
+
d -= box * np.round(d / box)
|
|
161
|
+
r = np.linalg.norm(d, axis=1)
|
|
162
|
+
edges = np.linspace(0.0, r_max, bins + 1)
|
|
163
|
+
counts = np.histogram(r, bins=edges)[0].astype(np.float64)
|
|
164
|
+
shells = 4.0 / 3.0 * math.pi * np.diff(edges**3)
|
|
165
|
+
density = n / float(np.prod(box))
|
|
166
|
+
return 0.5 * (edges[1:] + edges[:-1]), 2.0 * counts / (n * density * shells)
|
|
167
|
+
|
|
168
|
+
|
|
169
|
+
def structure_factor(points, box, *, k_max: float | None = None, bins: int = 40):
|
|
170
|
+
"""The structure factor ``S(k)`` of points in a periodic box, averaged over the wave
|
|
171
|
+
vectors ``2π n / L`` (``n`` integer, not all zero) in bins of ``|k|`` up to ``k_max``
|
|
172
|
+
(twenty times the smallest wave number by default): the centres of the bins with
|
|
173
|
+
wave vectors and ``S`` in them."""
|
|
174
|
+
box = np.asarray(box, dtype=float)
|
|
175
|
+
pts = _wrapped(points, box)
|
|
176
|
+
n_pts = len(pts)
|
|
177
|
+
k0 = 2.0 * math.pi / box
|
|
178
|
+
k_max = 20.0 * float(k0.min()) if k_max is None else float(k_max)
|
|
179
|
+
n_max = np.floor(k_max / k0).astype(int)
|
|
180
|
+
# the density modes, separable along the axes: rho(k) = sum_j prod_a e^{-i k_a x_ja}
|
|
181
|
+
waves = [np.exp(-1j * np.outer(pts[:, a], k0[a] * np.arange(-n_max[a], n_max[a] + 1)))
|
|
182
|
+
for a in range(3)] # fmt: skip
|
|
183
|
+
rho = np.einsum("ja,jb,jc->abc", waves[0], waves[1], waves[2], optimize=True)
|
|
184
|
+
grids = np.meshgrid(*[k0[a] * np.arange(-n_max[a], n_max[a] + 1) for a in range(3)],
|
|
185
|
+
indexing="ij") # fmt: skip
|
|
186
|
+
k = np.sqrt(sum(g**2 for g in grids))
|
|
187
|
+
s = np.abs(rho) ** 2 / n_pts
|
|
188
|
+
keep = (k > 0) & (k <= k_max)
|
|
189
|
+
edges = np.linspace(0.0, k_max, bins + 1)
|
|
190
|
+
which = np.digitize(k[keep], edges) - 1
|
|
191
|
+
total = np.bincount(which, weights=s[keep], minlength=bins)[:bins]
|
|
192
|
+
count = np.bincount(which, minlength=bins)[:bins]
|
|
193
|
+
centres = 0.5 * (edges[1:] + edges[:-1])
|
|
194
|
+
filled = count > 0
|
|
195
|
+
return centres[filled], total[filled] / count[filled]
|
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
"""Covariance (two-point probability) functions of images.
|
|
2
|
+
|
|
3
|
+
``C(h) = P(x in A, x + h in A)`` is estimated with fast Fourier transforms: circularly
|
|
4
|
+
for periodic images, with zero padding and normalization by the number of pairs
|
|
5
|
+
otherwise. ``C(0)`` is the volume fraction and ``C(h) -> p^2`` when correlations vanish.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
from dataclasses import dataclass
|
|
11
|
+
|
|
12
|
+
import numpy as np
|
|
13
|
+
from scipy import fft as sfft
|
|
14
|
+
|
|
15
|
+
from morphogen import settings
|
|
16
|
+
from morphogen.analysis.basic import indicator
|
|
17
|
+
from morphogen.image import VoxelImage
|
|
18
|
+
|
|
19
|
+
_ROWS = 1 << 15
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
@dataclass
|
|
23
|
+
class AxisFunction:
|
|
24
|
+
"""A function of the lags along the x, y and z axes (the covariance, the lineal-path
|
|
25
|
+
and two-point cluster functions of :mod:`morphogen.analysis.correlation`)."""
|
|
26
|
+
|
|
27
|
+
lags: dict[str, np.ndarray]
|
|
28
|
+
values: dict[str, np.ndarray]
|
|
29
|
+
volume_fraction: float
|
|
30
|
+
|
|
31
|
+
def mean(self) -> tuple[np.ndarray, np.ndarray]:
|
|
32
|
+
"""Average of the three axes (requires cubic voxels and equal lengths)."""
|
|
33
|
+
n = min(len(v) for v in self.values.values())
|
|
34
|
+
lags = self.lags["x"][:n]
|
|
35
|
+
return lags, np.mean([v[:n] for v in self.values.values()], axis=0)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
class AxisCovariance(AxisFunction):
|
|
39
|
+
"""Covariance along the x, y and z axes."""
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def _axis_correlation(field: np.ndarray, axis: int, max_lag: int, periodic: bool) -> np.ndarray:
|
|
43
|
+
x = np.moveaxis(field, axis, -1)
|
|
44
|
+
n = x.shape[-1]
|
|
45
|
+
rows = x.reshape(-1, n)
|
|
46
|
+
size = n if periodic else int(sfft.next_fast_len(2 * n))
|
|
47
|
+
acc = np.zeros(max_lag + 1)
|
|
48
|
+
for start in range(0, rows.shape[0], _ROWS):
|
|
49
|
+
block = rows[start : start + _ROWS].astype(np.float64)
|
|
50
|
+
f = sfft.rfft(block, n=size, axis=-1, workers=settings.workers())
|
|
51
|
+
corr = sfft.irfft(f * np.conj(f), n=size, axis=-1, workers=settings.workers())
|
|
52
|
+
acc += corr[:, : max_lag + 1].sum(axis=0)
|
|
53
|
+
pairs = rows.shape[0] * (n if periodic else (n - np.arange(max_lag + 1)))
|
|
54
|
+
return acc / pairs
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def covariance(image, phase: int = 1, *, max_lag: int | None = None, periodic=None):
|
|
58
|
+
"""Covariance of ``phase`` along the three axes, for lags 0..max_lag voxels.
|
|
59
|
+
|
|
60
|
+
``max_lag`` defaults to half the image size along each axis.
|
|
61
|
+
"""
|
|
62
|
+
field = indicator(image, phase)
|
|
63
|
+
spacing = image.spacing if isinstance(image, VoxelImage) else (1.0, 1.0, 1.0)
|
|
64
|
+
if periodic is None:
|
|
65
|
+
periodic = image.periodic if isinstance(image, VoxelImage) else False
|
|
66
|
+
lags, values = {}, {}
|
|
67
|
+
for axis, name in enumerate("xyz"):
|
|
68
|
+
n = field.shape[axis]
|
|
69
|
+
m = n // 2 if max_lag is None else min(int(max_lag), n - 1)
|
|
70
|
+
values[name] = _axis_correlation(field, axis, m, periodic)
|
|
71
|
+
lags[name] = np.arange(m + 1) * spacing[axis]
|
|
72
|
+
return AxisCovariance(lags, values, float(np.mean(field, dtype=np.float64)))
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def covariance_map(image, phase: int = 1) -> np.ndarray:
|
|
76
|
+
"""Full 3D covariance of a periodic image, zero lag at the centre (fftshift order)."""
|
|
77
|
+
field = indicator(image, phase).astype(np.float64)
|
|
78
|
+
f = sfft.rfftn(field, workers=settings.workers())
|
|
79
|
+
corr = sfft.irfftn(f * np.conj(f), s=field.shape, workers=settings.workers()) / field.size
|
|
80
|
+
return sfft.fftshift(corr)
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
"""Fractal dimension of a phase by box counting (Minkowski-Bouligand dimension)."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import math
|
|
6
|
+
|
|
7
|
+
import numpy as np
|
|
8
|
+
|
|
9
|
+
from morphogen.analysis.basic import as_array
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
def box_counting(image, phase: int = 1, sizes=None) -> dict:
|
|
13
|
+
"""Number ``N(s)`` of boxes of edge ``s`` voxels that contain the phase, and the
|
|
14
|
+
dimension ``D = -d log N / d log s`` (least-squares slope over the sizes).
|
|
15
|
+
|
|
16
|
+
The default sizes are the powers of two from 1 to an eighth of the smallest edge of
|
|
17
|
+
the image; axes of one voxel (2D images) are not divided. For a fractal aggregate,
|
|
18
|
+
use sizes between the particle size and the size of the clusters.
|
|
19
|
+
"""
|
|
20
|
+
data = as_array(image) == phase
|
|
21
|
+
if data.ndim != 3:
|
|
22
|
+
raise ValueError("box_counting needs a 3D image ((nx, ny, 1) for 2D images)")
|
|
23
|
+
axes = [n for n in data.shape if n > 1]
|
|
24
|
+
if not axes:
|
|
25
|
+
raise ValueError("box_counting: the image has a single voxel")
|
|
26
|
+
if sizes is None:
|
|
27
|
+
sizes = [2**k for k in range(int(math.log2(max(1, min(axes) // 8))) + 1)]
|
|
28
|
+
sizes = sorted({int(s) for s in sizes})
|
|
29
|
+
if len(sizes) < 2 or sizes[0] < 1:
|
|
30
|
+
raise ValueError("box_counting: at least two box sizes of one voxel or more")
|
|
31
|
+
counts = []
|
|
32
|
+
for s in sizes:
|
|
33
|
+
steps = [s if n > 1 else 1 for n in data.shape]
|
|
34
|
+
if any(n < st for n, st in zip(data.shape, steps, strict=True)):
|
|
35
|
+
raise ValueError(f"box_counting: boxes of {s} voxels exceed the image")
|
|
36
|
+
trimmed = data[
|
|
37
|
+
tuple(slice(0, (n // st) * st) for n, st in zip(data.shape, steps, strict=True))
|
|
38
|
+
]
|
|
39
|
+
shape = []
|
|
40
|
+
for n, st in zip(trimmed.shape, steps, strict=True):
|
|
41
|
+
shape += [n // st, st]
|
|
42
|
+
counts.append(int(trimmed.reshape(shape).any(axis=(1, 3, 5)).sum()))
|
|
43
|
+
counts = np.asarray(counts)
|
|
44
|
+
valid = counts > 0
|
|
45
|
+
dimension = float("nan")
|
|
46
|
+
if valid.sum() >= 2:
|
|
47
|
+
slope = np.polyfit(np.log(np.asarray(sizes)[valid]), np.log(counts[valid]), 1)[0]
|
|
48
|
+
dimension = float(-slope)
|
|
49
|
+
return {"sizes": sizes, "counts": counts.tolist(), "dimension": dimension}
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def box_dimension(image, phase: int = 1, sizes=None) -> float:
|
|
53
|
+
"""Box-counting dimension of a phase (see :func:`box_counting`)."""
|
|
54
|
+
return box_counting(image, phase, sizes)["dimension"]
|