Showing preview only (5,331K chars total). Download the full file or copy to clipboard to get everything.
Repository: AljazBozic/NeuralGraph
Branch: main
Commit: 5ac74b668ef4
Files: 372
Total size: 5.0 MB
Directory structure:
gitextract_wl6wrwv6/
├── .gitignore
├── LICENSE
├── README.md
├── build_external.sh
├── config.py
├── dataset/
│ ├── dataset.py
│ └── generate_dataset.py
├── external/
│ ├── PyMarchingCubes/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── MANIFEST.in
│ │ ├── README.md
│ │ ├── examples/
│ │ │ ├── .gitignore
│ │ │ └── spheres.py
│ │ ├── marching_cubes/
│ │ │ ├── __init__.py
│ │ │ ├── exporter.py
│ │ │ ├── numpy_smoothing.py
│ │ │ ├── smoothing.py
│ │ │ └── src/
│ │ │ ├── _mcubes.pyx
│ │ │ ├── marchingcubes.cpp
│ │ │ ├── marchingcubes.h
│ │ │ ├── pyarray_symbol.h
│ │ │ ├── pyarraymodule.h
│ │ │ ├── pywrapper.cpp
│ │ │ └── pywrapper.h
│ │ ├── requirements.txt
│ │ ├── setup.py
│ │ ├── test_mcubes.py
│ │ └── test_smoothing.py
│ ├── eigen3/
│ │ └── Eigen/
│ │ ├── Cholesky
│ │ ├── CholmodSupport
│ │ ├── Core
│ │ ├── Dense
│ │ ├── Eigen
│ │ ├── Eigenvalues
│ │ ├── Geometry
│ │ ├── Householder
│ │ ├── IterativeLinearSolvers
│ │ ├── Jacobi
│ │ ├── LU
│ │ ├── MetisSupport
│ │ ├── OrderingMethods
│ │ ├── PaStiXSupport
│ │ ├── PardisoSupport
│ │ ├── QR
│ │ ├── QtAlignedMalloc
│ │ ├── SPQRSupport
│ │ ├── SVD
│ │ ├── Sparse
│ │ ├── SparseCholesky
│ │ ├── SparseCore
│ │ ├── SparseLU
│ │ ├── SparseQR
│ │ ├── StdDeque
│ │ ├── StdList
│ │ ├── StdVector
│ │ ├── SuperLUSupport
│ │ ├── UmfPackSupport
│ │ └── src/
│ │ ├── Cholesky/
│ │ │ ├── LDLT.h
│ │ │ ├── LLT.h
│ │ │ └── LLT_LAPACKE.h
│ │ ├── CholmodSupport/
│ │ │ └── CholmodSupport.h
│ │ ├── Core/
│ │ │ ├── Array.h
│ │ │ ├── ArrayBase.h
│ │ │ ├── ArrayWrapper.h
│ │ │ ├── Assign.h
│ │ │ ├── AssignEvaluator.h
│ │ │ ├── Assign_MKL.h
│ │ │ ├── BandMatrix.h
│ │ │ ├── Block.h
│ │ │ ├── BooleanRedux.h
│ │ │ ├── CommaInitializer.h
│ │ │ ├── ConditionEstimator.h
│ │ │ ├── CoreEvaluators.h
│ │ │ ├── CoreIterators.h
│ │ │ ├── CwiseBinaryOp.h
│ │ │ ├── CwiseNullaryOp.h
│ │ │ ├── CwiseTernaryOp.h
│ │ │ ├── CwiseUnaryOp.h
│ │ │ ├── CwiseUnaryView.h
│ │ │ ├── DenseBase.h
│ │ │ ├── DenseCoeffsBase.h
│ │ │ ├── DenseStorage.h
│ │ │ ├── Diagonal.h
│ │ │ ├── DiagonalMatrix.h
│ │ │ ├── DiagonalProduct.h
│ │ │ ├── Dot.h
│ │ │ ├── EigenBase.h
│ │ │ ├── ForceAlignedAccess.h
│ │ │ ├── Fuzzy.h
│ │ │ ├── GeneralProduct.h
│ │ │ ├── GenericPacketMath.h
│ │ │ ├── GlobalFunctions.h
│ │ │ ├── IO.h
│ │ │ ├── Inverse.h
│ │ │ ├── Map.h
│ │ │ ├── MapBase.h
│ │ │ ├── MathFunctions.h
│ │ │ ├── MathFunctionsImpl.h
│ │ │ ├── Matrix.h
│ │ │ ├── MatrixBase.h
│ │ │ ├── NestByValue.h
│ │ │ ├── NoAlias.h
│ │ │ ├── NumTraits.h
│ │ │ ├── PermutationMatrix.h
│ │ │ ├── PlainObjectBase.h
│ │ │ ├── Product.h
│ │ │ ├── ProductEvaluators.h
│ │ │ ├── Random.h
│ │ │ ├── Redux.h
│ │ │ ├── Ref.h
│ │ │ ├── Replicate.h
│ │ │ ├── ReturnByValue.h
│ │ │ ├── Reverse.h
│ │ │ ├── Select.h
│ │ │ ├── SelfAdjointView.h
│ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ ├── Solve.h
│ │ │ ├── SolveTriangular.h
│ │ │ ├── SolverBase.h
│ │ │ ├── StableNorm.h
│ │ │ ├── Stride.h
│ │ │ ├── Swap.h
│ │ │ ├── Transpose.h
│ │ │ ├── Transpositions.h
│ │ │ ├── TriangularMatrix.h
│ │ │ ├── VectorBlock.h
│ │ │ ├── VectorwiseOp.h
│ │ │ ├── Visitor.h
│ │ │ ├── arch/
│ │ │ │ ├── AVX/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── AVX512/
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── AltiVec/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── CUDA/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── Half.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ ├── PacketMathHalf.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ ├── Default/
│ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ └── Settings.h
│ │ │ │ ├── NEON/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── SSE/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ └── TypeCasting.h
│ │ │ │ └── ZVector/
│ │ │ │ ├── Complex.h
│ │ │ │ ├── MathFunctions.h
│ │ │ │ └── PacketMath.h
│ │ │ ├── functors/
│ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ ├── BinaryFunctors.h
│ │ │ │ ├── NullaryFunctors.h
│ │ │ │ ├── StlFunctors.h
│ │ │ │ ├── TernaryFunctors.h
│ │ │ │ └── UnaryFunctors.h
│ │ │ ├── products/
│ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ ├── Parallelizer.h
│ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ └── TriangularSolverVector.h
│ │ │ └── util/
│ │ │ ├── BlasUtil.h
│ │ │ ├── Constants.h
│ │ │ ├── DisableStupidWarnings.h
│ │ │ ├── ForwardDeclarations.h
│ │ │ ├── MKL_support.h
│ │ │ ├── Macros.h
│ │ │ ├── Memory.h
│ │ │ ├── Meta.h
│ │ │ ├── NonMPL2.h
│ │ │ ├── ReenableStupidWarnings.h
│ │ │ ├── StaticAssert.h
│ │ │ └── XprHelper.h
│ │ ├── Eigenvalues/
│ │ │ ├── ComplexEigenSolver.h
│ │ │ ├── ComplexSchur.h
│ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ ├── EigenSolver.h
│ │ │ ├── GeneralizedEigenSolver.h
│ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ ├── HessenbergDecomposition.h
│ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ ├── RealQZ.h
│ │ │ ├── RealSchur.h
│ │ │ ├── RealSchur_LAPACKE.h
│ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ └── Tridiagonalization.h
│ │ ├── Geometry/
│ │ │ ├── AlignedBox.h
│ │ │ ├── AngleAxis.h
│ │ │ ├── EulerAngles.h
│ │ │ ├── Homogeneous.h
│ │ │ ├── Hyperplane.h
│ │ │ ├── OrthoMethods.h
│ │ │ ├── ParametrizedLine.h
│ │ │ ├── Quaternion.h
│ │ │ ├── Rotation2D.h
│ │ │ ├── RotationBase.h
│ │ │ ├── Scaling.h
│ │ │ ├── Transform.h
│ │ │ ├── Translation.h
│ │ │ ├── Umeyama.h
│ │ │ └── arch/
│ │ │ └── Geometry_SSE.h
│ │ ├── Householder/
│ │ │ ├── BlockHouseholder.h
│ │ │ ├── Householder.h
│ │ │ └── HouseholderSequence.h
│ │ ├── IterativeLinearSolvers/
│ │ │ ├── BasicPreconditioners.h
│ │ │ ├── BiCGSTAB.h
│ │ │ ├── ConjugateGradient.h
│ │ │ ├── IncompleteCholesky.h
│ │ │ ├── IncompleteLUT.h
│ │ │ ├── IterativeSolverBase.h
│ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ └── SolveWithGuess.h
│ │ ├── Jacobi/
│ │ │ └── Jacobi.h
│ │ ├── LU/
│ │ │ ├── Determinant.h
│ │ │ ├── FullPivLU.h
│ │ │ ├── InverseImpl.h
│ │ │ ├── PartialPivLU.h
│ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ └── arch/
│ │ │ └── Inverse_SSE.h
│ │ ├── MetisSupport/
│ │ │ └── MetisSupport.h
│ │ ├── OrderingMethods/
│ │ │ ├── Amd.h
│ │ │ ├── Eigen_Colamd.h
│ │ │ └── Ordering.h
│ │ ├── PaStiXSupport/
│ │ │ └── PaStiXSupport.h
│ │ ├── PardisoSupport/
│ │ │ └── PardisoSupport.h
│ │ ├── QR/
│ │ │ ├── ColPivHouseholderQR.h
│ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ ├── FullPivHouseholderQR.h
│ │ │ ├── HouseholderQR.h
│ │ │ └── HouseholderQR_LAPACKE.h
│ │ ├── SPQRSupport/
│ │ │ └── SuiteSparseQRSupport.h
│ │ ├── SVD/
│ │ │ ├── BDCSVD.h
│ │ │ ├── JacobiSVD.h
│ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ ├── SVDBase.h
│ │ │ └── UpperBidiagonalization.h
│ │ ├── SparseCholesky/
│ │ │ ├── SimplicialCholesky.h
│ │ │ └── SimplicialCholesky_impl.h
│ │ ├── SparseCore/
│ │ │ ├── AmbiVector.h
│ │ │ ├── CompressedStorage.h
│ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ ├── MappedSparseMatrix.h
│ │ │ ├── SparseAssign.h
│ │ │ ├── SparseBlock.h
│ │ │ ├── SparseColEtree.h
│ │ │ ├── SparseCompressedBase.h
│ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ ├── SparseDenseProduct.h
│ │ │ ├── SparseDiagonalProduct.h
│ │ │ ├── SparseDot.h
│ │ │ ├── SparseFuzzy.h
│ │ │ ├── SparseMap.h
│ │ │ ├── SparseMatrix.h
│ │ │ ├── SparseMatrixBase.h
│ │ │ ├── SparsePermutation.h
│ │ │ ├── SparseProduct.h
│ │ │ ├── SparseRedux.h
│ │ │ ├── SparseRef.h
│ │ │ ├── SparseSelfAdjointView.h
│ │ │ ├── SparseSolverBase.h
│ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ ├── SparseTranspose.h
│ │ │ ├── SparseTriangularView.h
│ │ │ ├── SparseUtil.h
│ │ │ ├── SparseVector.h
│ │ │ ├── SparseView.h
│ │ │ └── TriangularSolver.h
│ │ ├── SparseLU/
│ │ │ ├── SparseLU.h
│ │ │ ├── SparseLUImpl.h
│ │ │ ├── SparseLU_Memory.h
│ │ │ ├── SparseLU_Structs.h
│ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ ├── SparseLU_Utils.h
│ │ │ ├── SparseLU_column_bmod.h
│ │ │ ├── SparseLU_column_dfs.h
│ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ ├── SparseLU_panel_bmod.h
│ │ │ ├── SparseLU_panel_dfs.h
│ │ │ ├── SparseLU_pivotL.h
│ │ │ ├── SparseLU_pruneL.h
│ │ │ └── SparseLU_relax_snode.h
│ │ ├── SparseQR/
│ │ │ └── SparseQR.h
│ │ ├── StlSupport/
│ │ │ ├── StdDeque.h
│ │ │ ├── StdList.h
│ │ │ ├── StdVector.h
│ │ │ └── details.h
│ │ ├── SuperLUSupport/
│ │ │ └── SuperLUSupport.h
│ │ ├── UmfPackSupport/
│ │ │ └── UmfPackSupport.h
│ │ ├── misc/
│ │ │ ├── Image.h
│ │ │ ├── Kernel.h
│ │ │ ├── RealSvd2x2.h
│ │ │ ├── blas.h
│ │ │ ├── lapack.h
│ │ │ ├── lapacke.h
│ │ │ └── lapacke_mangling.h
│ │ └── plugins/
│ │ ├── ArrayCwiseBinaryOps.h
│ │ ├── ArrayCwiseUnaryOps.h
│ │ ├── BlockMethods.h
│ │ ├── CommonCwiseBinaryOps.h
│ │ ├── CommonCwiseUnaryOps.h
│ │ ├── MatrixCwiseBinaryOps.h
│ │ └── MatrixCwiseUnaryOps.h
│ └── qview/
│ ├── Makefile
│ ├── Occnet.h
│ ├── R3Model.cpp
│ ├── R3Quadric.cpp
│ ├── R3Quadric.h
│ ├── R3QuadricSet.cpp
│ ├── R3QuadricSet.h
│ └── qview.cpp
├── generate_data.sh
├── multi_sdf/
│ ├── evaluate.py
│ ├── loss.py
│ └── model.py
├── nnutils/
│ ├── blocks.py
│ ├── geometry.py
│ ├── metrics.py
│ ├── mlp.py
│ └── node_proc.py
├── node_sampler/
│ ├── evaluate.py
│ ├── loss.py
│ └── model.py
├── resources/
│ ├── env.yml
│ └── requirements.txt
├── scripts/
│ ├── make_watertight.sh
│ ├── process_mesh_local.sh
│ └── screened_poisson.mlx
├── train_graph.py
├── train_graph.sh
├── train_shape.py
├── train_shape.sh
├── utils/
│ ├── __init__.py
│ ├── embedder.py
│ ├── gradient_utils.py
│ ├── line_mesh.py
│ ├── mesh_proc.py
│ ├── parser_utils.py
│ ├── pcd_utils.py
│ ├── query.py
│ ├── sdf_utils.py
│ ├── time_statistics.py
│ └── viz_utils.py
├── viz.py
└── viz.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
.python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# VSCode cache
.vscode
# Output folders
/out
# External dependencies
/external/gaps
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2021 Aljaz Bozic
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# Neural Deformation Graphs
### [Project Page](https://aljazbozic.github.io/neural_deformation_graphs/) | [Paper](https://arxiv.org/abs/2012.01451) | [Video](https://www.youtube.com/watch?v=vyq36eFkdWo)
<br />
> Neural Deformation Graphs for Globally-consistent Non-rigid Reconstruction <br />
> [Aljaž Božič](https://aljazbozic.github.io/), [Pablo Palafox](https://pablorpalafox.github.io/), [Michael Zollhöfer](https://zollhoefer.com/), [Justus Thies](https://justusthies.github.io/), [Angela Dai](https://www.3dunderstanding.org/index.html), [Matthias Nießner](https://www.niessnerlab.org/members/matthias_niessner/profile.html) <br />
> CVPR 2021 (Oral Presentation)
<p align="center">
<img width="100%" src="media/reconstructions.gif"/>
</p>
This repository contains the code for the CVPR 2021 paper [Neural Deformation Graphs](https://arxiv.org/abs/2012.01451), a novel approach for globally-consistent deformation tracking and 3D reconstruction of non-rigid objects.
Specifically, we implicitly model a deformation graph via a deep neural network and empose per-frame viewpoint consistency as well as inter-frame graph and surface consistency constraints in a self-supervised fashion.
That results in a differentiable construction of a deformation graph that is able to handle deformations present in the whole sequence.
<p align="center">
<img width="100%" src="media/teaser.jpg"/>
</p>
## Install all dependencies
- Download the latest conda [here](https://docs.conda.io/projects/conda/en/latest/user-guide/install/download.html).
- To create a conda environment with all the required packages using conda run the following command:
```
conda env create -f resources/env.yml
```
> The above command creates a conda environment with the name **ndg**.
- Compile external dependencies inside `external` directory by executing:
```
conda activate ndg
./build_external.sh
```
> The external dependencies are **PyMarchingCubes**, **gaps** and **Eigen**.
## Generate data for visualization & training
In our experiments we use depth inputs from 4 camera views. These depth maps were captured with 4 Kinect Azure sensors. For quantitative evaluation we also used synthetic data, where 4 depth views were rendered from ground truth meshes. In both cases, screened Poisson reconstruction (implemented in [MeshLab](https://www.meshlab.net)) was used to obtain meshes for data generation. An example sequence of meshes of a synthetic **doozy** sequence can be downloaded [here](https://drive.google.com/file/d/12DYzj3CR-1dlnDDWO_ZVFnphoAmMT3hX/view?usp=sharing).
To generate training data from these meshes, they need to be put into a directory `out/meshes/doozy`. Then the following code executes data generation, producing generated data samples in `out/dataset/doozy`:
```
./generate_data.sh
```
## Visualize neural deformation graphs using pre-trained models
After data generation you can already check out the neural deformation graph estimation using a [pre-trained model checkpoint](https://drive.google.com/file/d/1d0Rdb3_bwP6BHRGjxG_mdixfxqpza_Ys/view?usp=sharing). You need to place it into the `out/models` directory, and run visualization:
```
./viz.sh
```
Reconstruction visualization can take longer, if you want to check out graphs only, you can uncomment `--viz_only_graph` argument in `viz.sh`.
Within the [Open3D](http://www.open3d.org/) viewer, you can navigate different settings using these keys:
* `N`: toggle graph nodes and edges
* `G`: toggle ground truth
* `D`: show next
* `A`: show previous
* `S`: toggle smooth shading
## Train a model from scratch
You can train a model from scratch using `train_graph.sh` and `train_shape.sh` scripts, in that order. The model checkpoints and tensorboard stats are going to be stored into `out/experiments`.
### Optimize graph
To estimate a neural deformation graph from input observations, you need to specify the dataset to be used (inside `out/dataset`, should be generated before hand), and then training can be started using the following script:
```
./train_graph.sh
```
We ran all our experiments on NVidia 2080Ti GPU, for about 500k iterations. After the model has converged, you can visualize the optimized neural deformation graph using `viz.sh` script.
To check out convergence, you can visualize loss curves with `tensorboard` by running the following inside `out/experiments` directory:
```
tensorboard --logdir=.
```
### Optimize shape
To optimize shape, you need to initialize the graph with a pre-trained graph model. That means that inside `train_shape.sh` you need to specify the `graph_model_path`, which should point to the converged checkpoint of the graph model (graph model usually converges at around 500k iterations). Multi-MLP model can then be optimized to reconstruct shape geometry by running:
```
./train_shape.sh
```
Similar to graph optimization also shape optimization converges in about 500k iterations.
## Citation
If you find our work useful in your research, please consider citing:
@article{bozic2021neuraldeformationgraphs,
title={Neural Deformation Graphs for Globally-consistent Non-rigid Reconstruction},
author={Bo{\v{z}}i{\v{c}}, Alja{\v{z}} and Palafox, Pablo and Zollh{\"o}fer, Michael and Dai, Angela and Thies, Justus and Nie{\ss}ner, Matthias},
journal={CVPR},
year={2021}
}
## Related work
Some other related works on non-rigid reconstruction by our group:
* [Bozic et al. DeepDeform: Learning Non-rigid RGB-D Reconstruction with Semi-supervised Data (2020)](https://niessnerlab.org/projects/bozic2020deepdeform.html)
* [Li et al. Learning to Optimize Non-Rigid Tracking (2020)](https://niessnerlab.org/projects/li2020learning.html)
* [Bozic et al. Neural Non-Rigid Tracking (2020)](https://www.niessnerlab.org/projects/bozic2020nnrt.html)
## License
The code from this repository is released under the MIT license, except where otherwise stated (i.e., `Eigen`).
================================================
FILE: build_external.sh
================================================
#!/bin/bash
###################################################
# INSTALL GAPS
###################################################
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
set -e
set -v
# CD inside the external directory
cd external
# This should create a gaps/ folder at external/gaps/
if [[ -d gaps ]]
then
echo "GAPS has already been cloned to external/gaps, skipping."
else
git clone https://github.com/tomfunkhouser/gaps.git
fi
# Necessary dependencies:
# Figure out whether we are on MacOS or Linux:
# if [[ $(uname -s) == Darwin* ]]
# then
# echo "On MacOS, GL dependencies should have shipped and OSMesa support is disabled."
# else
# # On linux, the packages need to be installed.
# sudo apt-get install mesa-common-dev libglu1-mesa-dev libosmesa6-dev libxi-dev libgl1-mesa-dev
# # For some reason on Ubuntu there can be a broken link from /usr/lib/x86_64-linux-gnu/libGL.so
# # to libGL.so.1.2.0 in the same directory, which does not exist. However libgl1-mesa-glx should
# # provide libGL.so.1.2.0. Reinstalling libgl1-mesa-glx results in libGL.so.1.2.0 correctly
# # existing in /usr/lib/x86_64-linux-gnu as it should.
# sudo apt-get install --reinstall libgl1-mesa-glx
# fi
# If the above command(s) fail, get the GL/gl.h and GL/glu.h headers, OSMesa and GL
# static libraries (osmesa on macos), delete the above code, and try again.
# Now apply customizations to GAPS:
# This should make a copy of the qview folder at external/gaps/apps/qview/
if [[ -d gaps/apps/qview ]]
then
echo "qview has already been copied into external/gaps/qview, skipping."
else
cp -R ./qview gaps/apps/
fi
# Everything is local to GAPS from this point:
cd gaps
# Ptsview and qview aren't built by default, adjust the makefile to build them.
# sed commands are for script idempotency
sed -i.bak '/ptsview/d' ./apps/Makefile
sed -i.bak '/qview/d' ./apps/Makefile
echo " cd ptsview; \$(MAKE) \$(TARGET)" >> ./apps/Makefile
echo " cd qview; \$(MAKE) \$(TARGET)" >> ./apps/Makefile
# Make GAPS (assuming 8 threads):
# On MacOS, using OSMesa is more difficult, so we don't
if [[ ! $(uname -s) == Darwin* ]]
then
make mesa -j8
else
make -j8
fi
cd ../..
###################################################
# INSTALL PyMarchingCubes
###################################################
cd external/PyMarchingCubes
python setup.py install
cd ../..
================================================
FILE: config.py
================================================
import os
#####################################################################################################################
# DATA OPTIONS
#####################################################################################################################
data_root_dir = "./out/dataset"
experiments_dir = "./out/experiments"
#####################################################################################################################
# DATA LOADING OPTIONS
#####################################################################################################################
num_worker_threads = 0 # 0 means that the base thread does all the job (that makes sense when hdf5 is already loaded into memory).
num_threads = 4
num_samples_eval = 100
cache_data = True
#####################################################################################################################
# MODEL INFO
#####################################################################################################################
# Pretrained model
initialize_from_other = False
saved_model_path = ""
saved_model_iteration = 0
# Freeze model
freeze_node_encoder = False
freeze_scale_estimator = False
freeze_position_estimator = False
freeze_rotation_estimator = False
freeze_affinity = False
freeze_surface_mlp = False
#####################################################################################################################
# GENERAL OPTIONS
#####################################################################################################################
# Do evaluation
do_evaluation = True
# Shuffle batch
shuffle = True
# Detect anomalies, such as when gradients explode
detect_anomaly = False
#####################################################################################################################
# NODE OPTIONS
#####################################################################################################################
num_nodes = 100
position_length = 3 + 1
scale_length = 3
rotation_length = 3
graph_num_point_samples = 3000
shape_num_point_samples = 1500
interior_point_weight = 10.0
soft_transfer_scale = 100.0
level_set = -0.07
num_neighbors = 2
use_constants = True
scaling_type = "isotropic" # ["isotropic", "anisotropic", "none"]
aggregate_coverage_with_max = False
#####################################################################################################################
# MULTI-SDF OPTIONS
#####################################################################################################################
# SDF settings
truncation = 0.1
# Model settings
num_features = 32
use_tanh = True
# Descriptors
descriptor_dim = 32
#####################################################################################################################
# TRAINING OPTIONS
#####################################################################################################################
graph_batch_size = 16
shape_batch_size = 4
evaluation_frequency = 5000
epochs = 1000000
graph_learning_rate = 5e-5
shape_learning_rate = 5e-4
weight_decay = 0
interval_step = 50000
# Losses
lambda_geometry = 1.0
lambda_sampling_uniform = 1.0
lambda_sampling_near_surface = 0.1
lambda_sampling_node_center = 1.0
lambda_viewpoint_position = 10.0
lambda_viewpoint_scale = 1.0
lambda_viewpoint_constant = 1.0
lambda_viewpoint_rotation = 1e-4
lambda_surface_consistency = 1e-6
lambda_surface_consistency_f = 10.0
lambda_surface_consistency_max = 1000.0
lambda_affinity_rel_dist = 0.1
lambda_affinity_rel_dist_f = 10.0
lambda_affinity_rel_dist_max = 10000.0
lambda_affinity_abs_dist = 0.1
lambda_affinity_abs_dist_f = 10.0
lambda_affinity_abs_dist_max = 1.0
lambda_unique_neighbor = 1e-8
lambda_unique_neighbor_f = 10.0
lambda_unique_neighbor_max = 1e-3
#####################################################################################################################
# PRINT HYPERPARAMS
#####################################################################################################################
def print_hyperparams(data, experiment_name):
print()
print("HYPERPARAMETERS:")
print()
print("\tDATA: ", data)
print("\tEXPERIMENT: ", experiment_name)
print()
print("\tnum_worker_threads ", num_worker_threads)
print("\tnum_threads ", num_threads)
print()
print("################# NODE OPTIONS #######################")
print("\tgraph_num_point_samples ", graph_num_point_samples)
print("\tshape_num_point_samples ", shape_num_point_samples)
print("\tuse_constants ", use_constants)
print("\tscaling_type ", scaling_type)
print()
print("############### TRAINING OPTIONS #####################")
print("\tgraph_batch_size ", graph_batch_size)
print("\tshape_batch_size ", shape_batch_size)
print("\tevaluation_frequency ", evaluation_frequency)
print("\tgraph_learning_rate ", graph_learning_rate)
print("\tshape_learning_rate ", shape_learning_rate)
print()
print("\tlambda_geometry ", lambda_geometry)
print("\tlambda_sampling_uniform ", lambda_sampling_uniform)
print("\tlambda_sampling_near_surface ", lambda_sampling_near_surface)
print("\tlambda_sampling_node_center ", lambda_sampling_node_center)
print("\tlambda_viewpoint_position ", lambda_viewpoint_position)
print("\tlambda_viewpoint_scale ", lambda_viewpoint_scale)
print("\tlambda_viewpoint_constant ", lambda_viewpoint_constant)
print("\tlambda_viewpoint_rotation ", lambda_viewpoint_rotation)
print("\tlambda_surface_cons ", lambda_surface_consistency)
print("\tlambda_surface_cons_f ", lambda_surface_consistency_f)
print("\tlambda_surface_cons_max ", lambda_surface_consistency_max)
print("\tlambda_affinity_rel_dist ", lambda_affinity_rel_dist)
print("\tlambda_affinity_rel_dist_f ", lambda_affinity_rel_dist_f)
print("\tlambda_affinity_rel_dist_max ", lambda_affinity_rel_dist_max)
print("\tlambda_affinity_abs_dist ", lambda_affinity_abs_dist)
print("\tlambda_affinity_abs_dist_f ", lambda_affinity_abs_dist_f)
print("\tlambda_affinity_abs_dist_max ", lambda_affinity_abs_dist_max)
print("\tlambda_unique_neighbor ", lambda_unique_neighbor)
print("\tlambda_unique_neighbor_f ", lambda_unique_neighbor_f)
print("\tlambda_unique_neighbor_max ", lambda_unique_neighbor_max)
================================================
FILE: dataset/dataset.py
================================================
import sys,os
import math
import torch
import numpy as np
from skimage import io, transform
from torch.utils.data import Dataset
import json
import open3d as o3d
import pickle
import random
import struct
from timeit import default_timer as timer
from tqdm import tqdm
class MeshDataset(Dataset):
def __init__(
self,
dataset_dir, num_point_samples,
cache_data=False, use_augmentation=False
):
self.dataset_dir = dataset_dir
self.num_point_samples = num_point_samples
self.cache_data = cache_data
self.use_augmentation = use_augmentation
# Load labels.
self.labels = []
self._load()
# Preload data.
if self.cache_data:
print("Preloading cached data ...")
loading_start = timer()
num_samples = len(self.labels)
assert num_samples > 0
data_dir = self.labels[0]["data_dir"]
sample_data = self._load_data(data_dir)
self.cache = {
'uniform_samples': np.zeros((num_samples,) + sample_data['uniform_samples'].shape, dtype=np.float32),
'surface_samples': np.zeros((num_samples,) + sample_data['surface_samples'].shape, dtype=np.float32),
'near_surface_samples': np.zeros((num_samples,) + sample_data['near_surface_samples'].shape, dtype=np.float32),
'grid': np.zeros((num_samples,) + sample_data['grid'].shape, dtype=np.float32),
'world2grid': np.zeros((num_samples,) + sample_data['world2grid'].shape, dtype=np.float32),
'world2orig': np.zeros((num_samples,) + sample_data['world2orig'].shape, dtype=np.float32),
'bbox_lower': np.zeros((num_samples,) + sample_data['bbox_lower'].shape, dtype=np.float32),
'bbox_upper': np.zeros((num_samples,) + sample_data['bbox_upper'].shape, dtype=np.float32)
}
for index in tqdm(range(len(self.labels))):
data_dir = self.labels[index]["data_dir"]
data = self._load_data(data_dir)
self.cache['uniform_samples'][index] = data['uniform_samples']
self.cache['surface_samples'][index] = data['surface_samples']
self.cache['near_surface_samples'][index] = data['near_surface_samples']
self.cache['grid'][index] = data['grid']
self.cache['world2grid'][index] = data['world2grid']
self.cache['world2orig'][index] = data['world2orig']
self.cache['bbox_lower'][index] = data['bbox_lower']
self.cache['bbox_upper'][index] = data['bbox_upper']
print("Done: {} s".format(timer() - loading_start))
print()
def _load(self):
sample_dirs = sorted([os.path.join(self.dataset_dir, f) for f in os.listdir(self.dataset_dir) if os.path.isdir(os.path.join(self.dataset_dir, f))])
for sample_dir in sample_dirs:
self.labels.append({
"data_dir": sample_dir
})
@staticmethod
def load_pts_file(path):
_, ext = os.path.splitext(path)
assert ext in ['.sdf', '.pts']
l = 4 if ext == '.sdf' else 6
with open(path, 'rb') as f:
points = np.fromfile(f, dtype=np.float32)
points = np.reshape(points, [-1, l])
return points
@staticmethod
def load_grid(path):
with open(path, 'rb') as f:
content = f.read()
res = struct.unpack('iii', content[:4 * 3])
vcount = res[0] * res[1] * res[2]
content = content[4 * 3:]
tx = struct.unpack('f' * 16, content[:4 * 16])
tx = np.array(tx).reshape([4, 4]).astype(np.float32)
content = content[4 * 16:]
grd = struct.unpack('f' * vcount, content[:4 * vcount])
grd = np.array(grd).reshape(res).astype(np.float32)
return grd, tx
def __len__(self):
return len(self.labels)
def unpack(self, x):
# We concatenate the first two dimensions, corresponding to
# batch size and sample size.
n_dims = len(x.shape)
new_shape = (x.shape[0] * x.shape[1], )
for i in range(2, n_dims):
new_shape += (x.shape[i],)
return x.view(new_shape)
def _load_data(self, data_dir):
# Load data from directory.
uniform_samples = MeshDataset.load_pts_file(f'{data_dir}/uniform_points.sdf')
near_surface_samples = MeshDataset.load_pts_file(f'{data_dir}/nss_points.sdf')
surface_samples = MeshDataset.load_pts_file(f'{data_dir}/surface_points.pts')
grid, world2grid = MeshDataset.load_grid(f'{data_dir}/coarse_grid.grd')
orig2world = np.reshape(np.loadtxt(f'{data_dir}/orig_to_gaps.txt'), [4, 4])
world2orig = np.linalg.inv(orig2world)
# Compute bounding box of interior uniform samples.
interior_sample_points = uniform_samples[uniform_samples[:, 3] < 0.0, :3]
bbox_upper = interior_sample_points.max(axis=0)
bbox_lower = interior_sample_points.min(axis=0)
return {
'uniform_samples': uniform_samples,
'surface_samples': surface_samples,
'near_surface_samples': near_surface_samples,
'grid': grid,
'world2grid': world2grid,
'world2orig': world2orig,
'bbox_lower': bbox_lower,
'bbox_upper': bbox_upper
}
def _get_cached_data(self, index):
return {
'uniform_samples': self.cache['uniform_samples'][index],
'surface_samples': self.cache['surface_samples'][index],
'near_surface_samples': self.cache['near_surface_samples'][index],
'grid': self.cache['grid'][index],
'world2grid': self.cache['world2grid'][index],
'world2orig': self.cache['world2orig'][index],
'bbox_lower': self.cache['bbox_lower'][index],
'bbox_upper': self.cache['bbox_upper'][index]
}
def __getitem__(self, index):
data_dir = self.labels[index]["data_dir"]
# Check if data is already cached.
if self.cache_data:
data = self._get_cached_data(index)
else:
data = self._load_data(data_dir)
# Subsample points.
uniform_samples = data['uniform_samples']
if uniform_samples.shape[0] > self.num_point_samples:
uniform_samples_idxs = np.random.permutation(uniform_samples.shape[0])[:self.num_point_samples]
uniform_samples = uniform_samples[uniform_samples_idxs, :]
near_surface_samples = data['near_surface_samples']
if near_surface_samples.shape[0] > self.num_point_samples:
near_surface_samples_idxs = np.random.permutation(near_surface_samples.shape[0])[:self.num_point_samples]
near_surface_samples = near_surface_samples[near_surface_samples_idxs, :]
surface_samples = data['surface_samples']
if surface_samples.shape[0] > self.num_point_samples:
surface_samples_idxs = np.random.permutation(surface_samples.shape[0])[:self.num_point_samples]
surface_samples = surface_samples[surface_samples_idxs, :]
if self.use_augmentation:
# We rotate randomly around y axis.
axis = np.array([0, 1, 0])[:, None]
T_array = []
for i in range(2):
angle = random.uniform(0, 2*math.pi)
axis_angle = axis * angle
R = o3d.geometry.get_rotation_matrix_from_axis_angle(axis_angle)
T = np.eye(4)
T[:3, :3] = R
T_array.append(T)
rotated2gaps0 = T_array[0].astype(np.float32)
rotated2gaps1 = T_array[1].astype(np.float32)
return np.stack([uniform_samples, uniform_samples], axis=0), np.stack([near_surface_samples, near_surface_samples], axis=0), \
np.stack([surface_samples, surface_samples], axis=0), np.stack([data['grid'], data['grid']], axis=0), \
np.stack([data['world2grid'], data['world2grid']], axis=0), np.stack([data['world2orig'], data['world2orig']], axis=0), \
np.stack([rotated2gaps0, rotated2gaps1], axis=0), \
np.stack([data['bbox_lower'], data['bbox_lower']], axis=0), np.stack([data['bbox_upper'], data['bbox_upper']], axis=0), \
np.stack([index, index], axis=0)
else:
rotated2gaps = np.eye(4).astype(np.float32)
return uniform_samples[np.newaxis, ...], near_surface_samples[np.newaxis, ...], \
surface_samples[np.newaxis, ...], data['grid'][np.newaxis, ...], \
data['world2grid'][np.newaxis, ...], data['world2orig'][np.newaxis, ...], \
rotated2gaps[np.newaxis, ...], \
data['bbox_lower'][np.newaxis, ...], data['bbox_upper'][np.newaxis, ...], \
[[index]]
def get_metadata(self, index):
return self.labels[index]
================================================
FILE: dataset/generate_dataset.py
================================================
import os
import sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import tqdm
from joblib import Parallel, delayed
from absl import flags
from absl import app
import glob
import argparse
import open3d as o3d
import subprocess as sp
def process_one(mesh_path, mesh_directory, dataset_directory, skip_existing):
"""Processes a single mesh, adding it to the dataset."""
name = os.path.basename(mesh_path)
name, extension = os.path.splitext(name)
valid_extensions = ['.ply']
if extension not in valid_extensions:
raise ValueError(f'File with unsupported extension {extension} found: {f}.'
f' Only {valid_extensions} are supported.')
output_dir = f'{dataset_directory}/{name}/'
scripts_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "scripts")
external_root_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "external")
# This is the last file the processing writes, if it already exists the
# example has already been processed.
if not skip_existing or not os.path.isfile(f'{output_dir}/uniform_points.sdf'):
# print(f'{codebase_root_dir}/scripts/process_mesh_local.sh {mesh_path} {dirpath} {external_root_dir}')
sp.check_output(
f'{scripts_dir}/process_mesh_local.sh {mesh_path} {output_dir} {external_root_dir}',
shell=True)
else:
print(f'Skipping shell script processing for {output_dir},'
' the output already exists.')
return output_dir
def generate_meshes(mesh_directory, dataset_directory, mesh_format, skip_existing=True, max_threads=-1):
raw_files = glob.glob(f'{mesh_directory}/*.{mesh_format}')
if not raw_files:
raise ValueError(f"Didn't find any {mesh_format} files in {mesh_directory}")
if mesh_format != "ply":
print(f"Started mesh conversion from '{mesh_format}' to 'ply'")
for input_mesh_path in raw_files:
base_name = os.path.splitext(input_mesh_path)[0]
output_mesh_path = os.path.join(mesh_directory, base_name + ".ply")
mesh = o3d.io.read_triangle_mesh(input_mesh_path)
o3d.io.write_triangle_mesh(output_mesh_path, mesh)
files = glob.glob(f'{mesh_directory}/*.ply')
else:
files = raw_files
# Make the directories first because it's not threadsafe and also might fail.
print('Creating directories...')
if not os.path.isdir(f'{dataset_directory}'):
os.makedirs(f'{dataset_directory}')
print('Making dataset...')
n_jobs = os.cpu_count()
assert max_threads != 0
if max_threads > 0:
n_jobs = max_threads
output_dirs = Parallel(n_jobs=n_jobs)(
delayed(process_one)(f, mesh_directory, dataset_directory,
skip_existing) for f in tqdm.tqdm(files))
print('Done!')
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--input_mesh_dir', action='store', dest='input_mesh_dir', required=True, help='Provide input watertight mesh directory')
parser.add_argument('--output_data_dir', action='store', dest='output_data_dir', required=True, help='Provide output directory')
parser.add_argument('--mesh_format', action='store', dest='mesh_format', help='Provide mesh format')
parser.add_argument('--max_threads', action='store', type=int, dest='max_threads', help='Maximum number of threads to be used (uses all available threads by default)')
args = parser.parse_args()
input_mesh_dir = args.input_mesh_dir
output_data_dir = args.output_data_dir
mesh_format = args.mesh_format
max_threads = args.max_threads
if not mesh_format:
mesh_format = "ply"
if not max_threads:
max_threads = -1
generate_meshes(input_mesh_dir, output_data_dir, mesh_format, max_threads=max_threads)
================================================
FILE: external/PyMarchingCubes/.gitignore
================================================
.DS_Store
*.dae
_mcubes.cpp
*.py[cod]
.vscode
.mypy_cache
.vscode
# Created by https://www.gitignore.io/api/osx,linux,python
# Edit at https://www.gitignore.io/?templates=osx,linux,python
### Linux ###
*~
# temporary files which can be created if a process still has a handle open of a deleted file
.fuse_hidden*
# KDE directory preferences
.directory
# Linux trash folder which might appear on any partition or disk
.Trash-*
# .nfs files are created when an open file is removed but is still being accessed
.nfs*
### OSX ###
# General
.DS_Store
.AppleDouble
.LSOverride
# Icon must end with two \r
Icon
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/
# Translations
*.mo
*.pot
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# pyenv
.python-version
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# Mr Developer
.mr.developer.cfg
.project
.pydevproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# End of https://www.gitignore.io/api/osx,linux,python
================================================
FILE: external/PyMarchingCubes/.travis.yml
================================================
# vim ft=yaml
# After changing this file, check it on:
# http://yaml-online-parser.appspot.com/
# See doc/travis_notes.txt for some guidelines
language: python
matrix:
include:
- os: linux
dist: trusty
sudo: false
python: '3.6'
- os: linux
dist: xenial
sudo: required
python: '3.7'
# See http://docs.travis-ci.com/user/caching/#pip-cache
cache: pip
before_install:
- sudo apt-get update
- pip install --upgrade pip setuptools
install:
- pip install -r requirements.txt
- pip install nose>=1.3.7 coverage codecov pytest>=3.0.5 pycollada
- python setup.py build
- python setup.py build_ext --inplace
before_script:
- mkdir output
script:
- nosetests -v --exe --with-xunit --with-coverage --cover-package=mcubes
after_success:
- python setup.py install
- codecov # PUBLIC project
# - coverage report && coverage xml
# - python-codacy-coverage -r coverage.xml
================================================
FILE: external/PyMarchingCubes/LICENSE
================================================
Copyright (c) 2012-2015, P. M. Neila (https://github.com/pmneila/PyMCubes)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: external/PyMarchingCubes/MANIFEST.in
================================================
include marching_cubes/*.py
exclude marching_cubes/numpy_smoothing.py
include marching_cubes/src/*.h
include marching_cubes/src/*.cpp
include marching_cubes/src/_mcubes.pyx
exclude marching_cubes/src/_mcubes.cpp
include examples/*.py
include images/binary.jpg
include images/smooth.jpg
include images/smoothing.png
include setup.py
include README.rst
include LICENSE
================================================
FILE: external/PyMarchingCubes/README.md
================================================
# PyMarchingCubes
`PyMarchingCubes` is a fork from `PyMCubes`, with a different implementation of the actual marching function (see 'marching_cubes/src/marchingcubes.h').
It fixes some issues of the original implementation that let to wrong triangulation (visible in triangles that are larger than the actual 'marching cell').
### Color Interpolation
The module also includes a marching cubes with color interpolation:
``` marching_cubes_color ``` and ``` marching_cubes_color_func ```.
Have a look at the 'examples/spheres.py' file.
Basically, it is called with ``` marching_cubes_color(sdf_volume, rgb_volume, iso_level) ``` assuming a 3D grid for the sdf values (dim_x,dim_y,dim_z) and a 4D grid for the colors (dim_x,dim_y,dim_z,3).
The export functions for obj and off files are adapted accordingly to handle the vertex colors.
### Super sampling along the edges
In case you are using a truncated signed distance function, you might miss the correct zero-crossing because of undersampling. Increasing the sample volume grows cubically, instead one can also subsample along the edges of a coarser volume to find a better approximation of the zero-crossing.
This subsampling of the edges is achieved by sampling along the x,y,z axis independently with higher resolution (e.g., you sample (dim_x + (dim_x-1)*edge_sampling, dim_y, dim_z) for the edges along the x axis).
The computational cost grow linear with the number of subsamples (e.g. 10 subsamples result in ~30 times more samples that you have to provide (since you need 10 times more samples per axis)).
A modified marching cubes implementation can be called via ``` marching_cubes_super_sampling(sdf_x, sdf_y, sdf_z, iso_level) ```.
Have a look at the sphere example.
Other than that, this repository is the same as the original (https://github.com/pmneila/PyMCubes).
## Installation
```
git clone https://github.com/JustusThies/PyMarchingCubes.git
cd PyMarchingCubes
git clone https://gitlab.com/libeigen/eigen.git
python setup.py install
```
## Example from the original `PyMCubes`
The following example creates a `NumPy` volume with spherical iso-surfaces and
extracts one of them (i.e., a sphere) with `mcubes.marching_cubes`. The result
is exported to `sphere.dae`:
```Python
>>> import numpy as np
>>> import marching_cubes as mcubes
# Create a data volume (30 x 30 x 30)
>>> X, Y, Z = np.mgrid[:30, :30, :30]
>>> u = (X-15)**2 + (Y-15)**2 + (Z-15)**2 - 8**2
# Extract the 0-isosurface
>>> vertices, triangles = mcubes.marching_cubes(u, 0)
# Export the result to sphere.dae
>>> mcubes.export_mesh(vertices, triangles, "sphere.dae", "MySphere")
```
Alternatively, you can use a Python function to represent the volume instead of
a `NumPy` array:
```Python
>>> import numpy as np
>>> import marching_cubes as mcubes
# Create the volume
>>> f = lambda x, y, z: x**2 + y**2 + z**2
# Extract the 16-isosurface
>>> vertices, triangles = mcubes.marching_cubes_func((-10,-10,-10), (10,10,10),
... 100, 100, 100, f, 16)
# Export the result to sphere.dae (requires PyCollada)
>>> mcubes.export_mesh(vertices, triangles, "sphere.dae", "MySphere")
# Or export to an OBJ file
>>> mcubes.export_obj(vertices, triangles, 'sphere.obj')
```
Note that using a function to represent the volumetric data is **much** slower
than using a `NumPy` array.
## Smoothing binary arrays
Many segmentation methods build binary masks to separate _inside_ and _outside_
areas of the segmented object. When passing these binary mask to the marching
cubes algorithm the resulting mesh looks jagged. The following code shows an
example with a binary array embedding a sphere.
```Python
x, y, z = np.mgrid[:100, :100, :100]
binary_sphere = (x - 50)**2 + (y - 50)**2 + (z - 50)**2 - 25**2 < 0
# Extract the 0.5-levelset since the array is binary
vertices, triangles = mcubes.marching_cubes(binary_sphere, 0.5)
```
`PyMCubes` provides the function `mcubes.smooth` that takes a 2D or 3D binary
embedding function and produces a smooth version of it.
```Python
smoothed_sphere = mcubes.smooth(binary_sphere)
# Extract the 0-levelset (the 0-levelset of the output of mcubes.smooth is the
# smoothed version of the 0.5-levelset of the binary array).
vertices, triangles = mcubes.marching_cubes(smoothed_sphere, 0)
```
`mcubes.smooth` builds a smooth embedding array with negative values in the
areas where the binary embedding array is 0, and positive values in the areas
where it is 1. In this way, `mcubes.smooth` keeps all the information from the
original embedding function, including fine details and thin structures that
are commonly eroded by other standard smoothing methods.
================================================
FILE: external/PyMarchingCubes/examples/.gitignore
================================================
sphere.obj
sphere_color.obj
sphere_color.off
sphere_tsdf_super_res.off
sphere_tsdf_without_super_res.off
================================================
FILE: external/PyMarchingCubes/examples/spheres.py
================================================
import numpy as np
import marching_cubes as mcubes
print("Example 1: Isosurface in NumPy volume...")
#print(mcubes.__dir__())
# Create a data volume (100 x 100 x 100)
X, Y, Z = np.mgrid[:100, :100, :100]
sdf = (X-50)**2 + (Y-50)**2 + (Z-50)**2 - 25**2
# Extract the 0-isosurface
vertices, triangles = mcubes.marching_cubes(sdf, 0)
mcubes.export_obj(vertices, triangles, "sphere.obj")
print("Example 2: Isosurface and color in NumPy volume...")
# Extract isosurface and color
#color = 0.01 * np.concatenate((X[:,:,:,None],X[:,:,:,None],X[:,:,:,None]), axis=3) # color array (grayscale gradient in this example)
color = 0.01 * np.concatenate((X[:,:,:,None],Y[:,:,:,None],Z[:,:,:,None]), axis=3) # color array (positions as color)
vertices_color, triangles_color = mcubes.marching_cubes_color(sdf, color, 0)
mcubes.export_obj(vertices_color, triangles_color, "sphere_color.obj")
mcubes.export_off(vertices_color, triangles_color, "sphere_color.off")
print("Example 3: TSDF isosurface with super resolution...")
dim = 100
# Create a data volume (100 x 100 x 100)
def sphere_tsdf(xyz, x_scale, y_scale, z_scale):
X, Y, Z = xyz
X = X*x_scale
Y = Y*y_scale
Z = Z*z_scale
sdf = (X-0.5)**2 + (Y-0.5)**2 + (Z-0.5)**2 - 0.25**2
truncation = 0.001 # relatively small truncation
return np.clip(sdf, -truncation, truncation)
# Extract the 0-isosurface
sdf = sphere_tsdf(np.mgrid[:dim, :dim, :dim], 1.0/(dim-1.0),1.0/(dim-1.0),1.0/(dim-1.0))
vertices, triangles = mcubes.marching_cubes(sdf, 0)
mcubes.export_off(vertices, triangles, "sphere_tsdf_without_super_res.off")
# Extract the 0-isosurface with super res
edges = dim-1
n_edge_samples = 10
supersamples = dim + edges * n_edge_samples
sdf_x = sphere_tsdf(np.mgrid[:supersamples, :dim, :dim], 1.0/(supersamples-1.0), 1.0/(dim-1.0), 1.0/(dim-1.0)) ## generates 10x more samples in x
sdf_y = sphere_tsdf(np.mgrid[:dim, :supersamples, :dim], 1.0/(dim-1.0), 1.0/(supersamples-1.0), 1.0/(dim-1.0)) ## generates 10x more samples in y
sdf_z = sphere_tsdf(np.mgrid[:dim, :dim, :supersamples], 1.0/(dim-1.0), 1.0/(dim-1.0), 1.0/(supersamples-1.0)) ## generates 10x more samples in z
vertices, triangles = mcubes.marching_cubes_super_sampling(sdf_x, sdf_y, sdf_z, 0)
mcubes.export_off(vertices, triangles, "sphere_tsdf_super_res.off")
# old examples
# Export the result to sphere.dae
#mcubes.export_mesh(vertices1, triangles1, "sphere1.dae", "MySphere")
# print("Done. Result saved in 'sphere1.dae'.")
# print("Example 2: Isosurface in Python function...")
# print("(this might take a while...)")
# # Create the volume
# def f(x, y, z):
# return x**2 + y**2 + z**2
# # Extract the 16-isosurface
# vertices2, triangles2 = mcubes.marching_cubes_func(
# (-10,-10,-10), (10,10,10), # Bounds
# 100, 100, 100, # Number of samples in each dimension
# f, # Implicit function
# 16) # Isosurface value
# # Export the result to sphere2.dae
# mcubes.export_mesh(vertices2, triangles2, "sphere2.dae", "MySphere")
# print("Done. Result saved in 'sphere2.dae'.")
# try:
# print("Plotting mesh...")
# from mayavi import mlab
# mlab.triangular_mesh(
# vertices1[:, 0], vertices1[:, 1], vertices1[:, 2],
# triangles1)
# print("Done.")
# mlab.show()
# except ImportError:
# print("Could not import mayavi. Interactive demo not available.")
================================================
FILE: external/PyMarchingCubes/marching_cubes/__init__.py
================================================
from ._mcubes import marching_cubes, marching_cubes_func, marching_cubes_color, marching_cubes_color_func, marching_cubes_super_sampling
from .exporter import export_mesh, export_obj, export_off
from .smoothing import *
# from .numpy_smoothing import *
================================================
FILE: external/PyMarchingCubes/marching_cubes/exporter.py
================================================
import numpy as np
def export_obj(vertices, triangles, filename):
"""
Exports a mesh in the (.obj) format.
"""
print('export mesh: ', vertices.shape)
with open(filename, 'w') as fh:
if (vertices.shape[1]==6):
for v in vertices:
fh.write("v {} {} {} {} {} {}\n".format(*v))
else:
for v in vertices:
fh.write("v {} {} {}\n".format(*v))
for f in triangles:
fh.write("f {} {} {}\n".format(*(f + 1)))
def export_off(vertices, triangles, filename):
"""
Exports a mesh in the (.off) format.
"""
with open(filename, 'w') as fh:
if (vertices.shape[1]==6):
fh.write('COFF\n')
else:
fh.write('OFF\n')
fh.write('{} {} 0\n'.format(len(vertices), len(triangles)))
if (vertices.shape[1]==6):
for v in vertices:
fh.write("{} {} {} {} {} {}\n".format(*v))
else:
for v in vertices:
fh.write("{} {} {}\n".format(*v))
for f in triangles:
fh.write("3 {} {} {}\n".format(*f))
def export_mesh(vertices, triangles, filename, mesh_name="mcubes_mesh"):
"""
Exports a mesh in the COLLADA (.dae) format.
Needs PyCollada (https://github.com/pycollada/pycollada).
"""
import collada
mesh = collada.Collada()
vert_src = collada.source.FloatSource("verts-array", vertices[:,0:3], ('X','Y','Z'))
geom = collada.geometry.Geometry(mesh, "geometry0", mesh_name, [vert_src])
input_list = collada.source.InputList()
input_list.addInput(0, 'VERTEX', "#verts-array")
triset = geom.createTriangleSet(np.copy(triangles), input_list, "")
geom.primitives.append(triset)
mesh.geometries.append(geom)
geomnode = collada.scene.GeometryNode(geom, [])
node = collada.scene.Node(mesh_name, children=[geomnode])
myscene = collada.scene.Scene("mcubes_scene", [node])
mesh.scenes.append(myscene)
mesh.scene = myscene
mesh.write(filename)
================================================
FILE: external/PyMarchingCubes/marching_cubes/numpy_smoothing.py
================================================
import numpy as np
from scipy import ndimage as ndi
__all__ = [
'numpy_smooth',
]
FILTER = np.array([1, -2, 1], dtype=np.float_)
JACOBI_R_2D = np.array([
[0, 0, 1, 0, 0],
[0, 0, -4, 0, 0],
[1, -4, 0, -4, 1],
[0, 0, -4, 0, 0],
[0, 0, 1, 0, 0]
], dtype=np.float_)
JACOBI_D_2D = 1/12
JACOBI_R_3D = np.array([
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, -4, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]],
[[0, 0, 1, 0, 0],
[0, 0, -4, 0, 0],
[1, -4, 0, -4, 1],
[0, 0, -4, 0, 0],
[0, 0, 1, 0, 0]],
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, -4, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
], dtype=np.float_)
JACOBI_D_3D = 1/18
def signed_distance_function(binary_arr: np.ndarray) -> np.ndarray:
arr = np.where(binary_arr > 0, 1.0, 0.0)
dist_func = ndi.distance_transform_edt
distance = np.where(
binary_arr,
dist_func(arr) - 0.5,
-dist_func(1 - arr) + 0.5
)
return distance
def energy(arr: np.ndarray) -> np.ndarray:
darr2 = [ndi.convolve1d(arr, FILTER, axis=i)**2 for i in range(arr.ndim)]
return np.sum(darr2) / 2
def solve_jacobi(
arr: np.ndarray,
lower_bound: np.ndarray,
upper_bound: np.ndarray,
max_iters: int = 500,
jacobi_weight: float = 0.5
) -> np.ndarray:
jacobi_d = JACOBI_D_2D if arr.ndim == 2 else JACOBI_D_3D
jacobi_r = JACOBI_R_2D if arr.ndim == 2 else JACOBI_R_3D
for it in range(max_iters):
# energy_it = torch.sum(diff_energy(arr) * arr[2:-2, 2:-2, 2:-2]) / 2
energy_it = energy(arr)
print("Energy in iteration {}: {:.4g}".format(it, energy_it))
r_arr = ndi.convolve(arr, jacobi_r, mode='nearest')
arr_1 = - jacobi_d * r_arr
arr = jacobi_weight * arr_1 + (1 - jacobi_weight) * arr
arr = np.maximum(arr, lower_bound)
arr = np.minimum(arr, upper_bound)
return arr
def numpy_smooth(binary_array: np.ndarray, max_iters: int = 500) -> np.ndarray:
arr = signed_distance_function(binary_array)
upper_bound = np.where(arr < 0, arr, np.inf)
lower_bound = np.where(arr > 0, arr, -np.inf)
upper_bound[np.abs(upper_bound) < 1] = 0
lower_bound[np.abs(lower_bound) < 1] = 0
return solve_jacobi(arr, lower_bound, upper_bound, max_iters)
================================================
FILE: external/PyMarchingCubes/marching_cubes/smoothing.py
================================================
# -*- coding: utf-8 -*-
"""
Utilities for smoothing the 0.5 level-set of binary arrays.
"""
import logging
from typing import Tuple
import numpy as np
from scipy import sparse
from scipy import ndimage as ndi
__all__ = [
'smooth',
'smooth_constrained',
'smooth_gaussian',
'signed_distance_function'
]
def _build_variable_indices(band: np.ndarray) -> np.ndarray:
num_variables = np.count_nonzero(band)
variable_indices = np.full(band.shape, -1, dtype=np.int_)
variable_indices[band] = np.arange(num_variables)
return variable_indices
def _buildq3d(variable_indices: np.ndarray):
"""
Builds the filterq matrix for the given variables.
"""
num_variables = variable_indices.max() + 1
filterq = sparse.lil_matrix((3*num_variables, num_variables))
# Pad variable_indices to simplify out-of-bounds accesses
variable_indices = np.pad(
variable_indices,
[(0, 1), (0, 1), (0, 1)],
mode='constant',
constant_values=-1
)
coords = np.nonzero(variable_indices >= 0)
for count, (i, j, k) in enumerate(zip(*coords)):
assert(variable_indices[i, j, k] == count)
filterq[3*count, count] = -2
neighbor = variable_indices[i-1, j, k]
if neighbor >= 0:
filterq[3*count, neighbor] = 1
else:
filterq[3*count, count] += 1
neighbor = variable_indices[i+1, j, k]
if neighbor >= 0:
filterq[3*count, neighbor] = 1
else:
filterq[3*count, count] += 1
filterq[3*count+1, count] = -2
neighbor = variable_indices[i, j-1, k]
if neighbor >= 0:
filterq[3*count+1, neighbor] = 1
else:
filterq[3*count+1, count] += 1
neighbor = variable_indices[i, j+1, k]
if neighbor >= 0:
filterq[3*count+1, neighbor] = 1
else:
filterq[3*count+1, count] += 1
filterq[3*count+2, count] = -2
neighbor = variable_indices[i, j, k-1]
if neighbor >= 0:
filterq[3*count+2, neighbor] = 1
else:
filterq[3*count+2, count] += 1
neighbor = variable_indices[i, j, k+1]
if neighbor >= 0:
filterq[3*count+2, neighbor] = 1
else:
filterq[3*count+2, count] += 1
filterq = filterq.tocsr()
return filterq.T.dot(filterq)
def _buildq2d(variable_indices: np.ndarray):
"""
Builds the filterq matrix for the given variables.
Version for 2 dimensions.
"""
num_variables = variable_indices.max() + 1
filterq = sparse.lil_matrix((3*num_variables, num_variables))
# Pad variable_indices to simplify out-of-bounds accesses
variable_indices = np.pad(
variable_indices,
[(0, 1), (0, 1)],
mode='constant',
constant_values=-1
)
coords = np.nonzero(variable_indices >= 0)
for count, (i, j) in enumerate(zip(*coords)):
assert(variable_indices[i, j] == count)
filterq[2*count, count] = -2
neighbor = variable_indices[i-1, j]
if neighbor >= 0:
filterq[2*count, neighbor] = 1
else:
filterq[2*count, count] += 1
neighbor = variable_indices[i+1, j]
if neighbor >= 0:
filterq[2*count, neighbor] = 1
else:
filterq[2*count, count] += 1
filterq[2*count+1, count] = -2
neighbor = variable_indices[i, j-1]
if neighbor >= 0:
filterq[2*count+1, neighbor] = 1
else:
filterq[2*count+1, count] += 1
neighbor = variable_indices[i, j+1]
if neighbor >= 0:
filterq[2*count+1, neighbor] = 1
else:
filterq[2*count+1, count] += 1
filterq = filterq.tocsr()
return filterq.T.dot(filterq)
def _jacobi(
filterq,
x0: np.ndarray,
lower_bound: np.ndarray,
upper_bound: np.ndarray,
max_iters: int = 10,
rel_tol: float = 1e-6,
weight: float = 0.5):
"""Jacobi method with constraints."""
jacobi_r = sparse.lil_matrix(filterq)
shp = jacobi_r.shape
jacobi_d = 1.0 / filterq.diagonal()
jacobi_r.setdiag((0,) * shp[0])
jacobi_r = jacobi_r.tocsr()
x = x0
# We check the stopping criterion each 10 iterations
check_each = 10
cum_rel_tol = 1 - (1 - rel_tol)**check_each
energy_now = np.dot(x, filterq.dot(x)) / 2
logging.info("Energy at iter %d: %.6g", 0, energy_now)
for i in range(max_iters):
x_1 = - jacobi_d * jacobi_r.dot(x)
x = weight * x_1 + (1 - weight) * x
# Constraints.
x = np.maximum(x, lower_bound)
x = np.minimum(x, upper_bound)
# Stopping criterion
if (i + 1) % check_each == 0:
# Update energy
energy_before = energy_now
energy_now = np.dot(x, filterq.dot(x)) / 2
logging.info("Energy at iter %d: %.6g", i + 1, energy_now)
# Check stopping criterion
cum_rel_improvement = (energy_before - energy_now) / energy_before
if cum_rel_improvement < cum_rel_tol:
break
return x
def signed_distance_function(
levelset: np.ndarray,
band_radius: int
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
"""
Return the distance to the 0.5 levelset of a function, the mask of the
border (i.e., the nearest cells to the 0.5 level-set) and the mask of the
band (i.e., the cells of the function whose distance to the 0.5 level-set
is less of equal to `band_radius`).
"""
binary_array = np.where(levelset > 0, True, False)
# Compute the band and the border.
dist_func = ndi.distance_transform_edt
distance = np.where(
binary_array,
dist_func(binary_array) - 0.5,
-dist_func(~binary_array) + 0.5
)
border = np.abs(distance) < 1
band = np.abs(distance) <= band_radius
return distance, border, band
def smooth_constrained(
binary_array: np.ndarray,
band_radius: int = 4,
max_iters: int = 250,
rel_tol: float = 1e-6
) -> np.ndarray:
"""
Implementation of the smoothing method from
"Surface Extraction from Binary Volumes with Higher-Order Smoothness"
Victor Lempitsky, CVPR10
"""
# # Compute the distance map, the border and the band.
logging.info("Computing distance transform...")
distance, _, band = signed_distance_function(binary_array, band_radius)
variable_indices = _build_variable_indices(band)
# Compute filterq.
logging.info("Building matrix filterq...")
if binary_array.ndim == 3:
filterq = _buildq3d(variable_indices)
elif binary_array.ndim == 2:
filterq = _buildq2d(variable_indices)
else:
raise ValueError("binary_array.ndim not in [2, 3]")
# Initialize the variables.
res = np.asarray(distance, dtype=np.double)
x = res[band]
upper_bound = np.where(x < 0, x, np.inf)
lower_bound = np.where(x > 0, x, -np.inf)
upper_bound[np.abs(upper_bound) < 1] = 0
lower_bound[np.abs(lower_bound) < 1] = 0
# Solve.
logging.info("Minimizing energy...")
x = _jacobi(
filterq=filterq,
x0=x,
lower_bound=lower_bound,
upper_bound=upper_bound,
max_iters=max_iters,
rel_tol=rel_tol
)
res[band] = x
return res
def smooth_gaussian(binary_array: np.ndarray, sigma: float = 3) -> np.ndarray:
vol = np.float_(binary_array) - 0.5
return ndi.gaussian_filter(vol, sigma=sigma)
def smooth(
binary_array: np.ndarray,
method: str = 'auto',
**kwargs
) -> np.ndarray:
"""
Smooths the 0.5 level-set of a binary array. Returns a floating-point
array with a smoothed version of the original level-set in the 0 isovalue.
This function can apply two different methods:
- A constrained smoothing method which preserves details and fine
structures, but it is slow and requires a large amount of memory. This
method is recommended when the input array is small (smaller than
(500, 500, 500)).
- A Gaussian filter applied over the binary array. This method is fast, but
not very precise, as it can destroy fine details. It is only recommended
when the input array is large and the 0.5 level-set does not contain
thin structures.
Parameters
----------
binary_array : ndarray
Input binary array with the 0.5 level-set to smooth.
method : str, one of ['auto', 'gaussian', 'constrained']
Smoothing method. If 'auto' is given, the method will be automatically
chosen based on the size of `binary_array`.
Parameters for 'gaussian'
-------------------------
sigma : float
Size of the Gaussian filter (default 3).
Parameters for 'constrained'
----------------------------
max_iters : positive integer
Number of iterations of the constrained optimization method
(default 250).
rel_tol: float
Relative tolerance as a stopping criterion (default 1e-6).
Output
------
res : ndarray
Floating-point array with a smoothed 0 level-set.
"""
binary_array = np.asarray(binary_array)
if method == 'auto':
if binary_array.size > 500**3:
method = 'gaussian'
else:
method = 'constrained'
if method == 'gaussian':
return smooth_gaussian(binary_array, **kwargs)
if method == 'constrained':
return smooth_constrained(binary_array, **kwargs)
raise ValueError("Unknown method '{}'".format(method))
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/_mcubes.pyx
================================================
# distutils: language = c++
# cython: embedsignature = True
# from libcpp.vector cimport vector
import numpy as np
# Define PY_ARRAY_UNIQUE_SYMBOL
cdef extern from "pyarray_symbol.h":
pass
cimport numpy as np
np.import_array()
cdef extern from "pywrapper.h":
cdef object c_marching_cubes "marching_cubes"(np.ndarray, double) except +
cdef object c_marching_cubes_func "marching_cubes_func"(tuple, tuple, int, int, int, object, double) except +
cdef object c_marching_cubes_color "marching_cubes_color"(np.ndarray, np.ndarray, double) except +
cdef object c_marching_cubes_color_func "marching_cubes_color_func"(tuple, tuple, int, int, int, object, object, object, object, double) except +
cdef object c_marching_cubes_super_sampling "marching_cubes_super_sampling"(np.ndarray, np.ndarray, np.ndarray, double) except +
def marching_cubes(np.ndarray volume, float isovalue):
verts, faces = c_marching_cubes(volume, isovalue)
verts.shape = (-1, 3)
faces.shape = (-1, 3)
return verts, faces
def marching_cubes_super_sampling(np.ndarray volumeX, np.ndarray volumeY, np.ndarray volumeZ, float isovalue):
verts, faces = c_marching_cubes_super_sampling(volumeX, volumeY, volumeZ, isovalue)
verts.shape = (-1, 3)
faces.shape = (-1, 3)
return verts, faces
def marching_cubes_func(tuple lower, tuple upper, int numx, int numy, int numz, object f, double isovalue):
if any(l_i >= u_i for l_i, u_i in zip(lower, upper)):
raise ValueError("lower coordinates cannot be larger than upper coordinates")
if numx < 2 or numy < 2 or numz < 2:
raise ValueError("numx, numy, numz cannot be smaller than 2")
verts, faces = c_marching_cubes_func(lower, upper, numx, numy, numz, f, isovalue)
verts.shape = (-1, 3)
faces.shape = (-1, 3)
return verts, faces
def marching_cubes_color(np.ndarray volume_sdf, np.ndarray volume_color, float isovalue):
verts, faces = c_marching_cubes_color(volume_sdf, volume_color, isovalue)
verts.shape = (-1, 6)
faces.shape = (-1, 3)
return verts, faces
def marching_cubes_color_func(tuple lower, tuple upper, int numx, int numy, int numz, object f_sdf, object f_color_r, object f_color_g, object f_color_b, double isovalue):
if any(l_i >= u_i for l_i, u_i in zip(lower, upper)):
raise ValueError("lower coordinates cannot be larger than upper coordinates")
if numx < 2 or numy < 2 or numz < 2:
raise ValueError("numx, numy, numz cannot be smaller than 2")
verts, faces = c_marching_cubes_color_func(lower, upper, numx, numy, numz, f_sdf, f_color_r, f_color_g, f_color_b, isovalue)
verts.shape = (-1, 6)
faces.shape = (-1, 3)
return verts, faces
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/marchingcubes.cpp
================================================
#include "marchingcubes.h"
namespace mc
{
int edge_table[256] =
{
0x000, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c, 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
0x190, 0x099, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c, 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
0x230, 0x339, 0x033, 0x13a, 0x636, 0x73f, 0x435, 0x53c, 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
0x3a0, 0x2a9, 0x1a3, 0x0aa, 0x7a6, 0x6af, 0x5a5, 0x4ac, 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
0x460, 0x569, 0x663, 0x76a, 0x066, 0x16f, 0x265, 0x36c, 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0x0ff, 0x3f5, 0x2fc, 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x055, 0x15c, 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0x0cc, 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc, 0x0cc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c, 0x15c, 0x055, 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc, 0x2fc, 0x3f5, 0x0ff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c, 0x36c, 0x265, 0x16f, 0x066, 0x76a, 0x663, 0x569, 0x460,
0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac, 0x4ac, 0x5a5, 0x6af, 0x7a6, 0x0aa, 0x1a3, 0x2a9, 0x3a0,
0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c, 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x033, 0x339, 0x230,
0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c, 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x099, 0x190,
0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c, 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x000
};
int triangle_table[256][16] =
{
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
{3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
{1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
{4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
{9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
{2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
{10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
{5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
{5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
{8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
{2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
{7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
{11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
{5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
{11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
{11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
{9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
{6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
{6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
{6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
{8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
{7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
{3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
{5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
{0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
{9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
{8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
{5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
{0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
{6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
{10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
{10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
{0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
{3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
{6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
{9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
{8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
{3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
{6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
{10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
{10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
{7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
{7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
{2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
{1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
{11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
{8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
{0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
{7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
{7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
{1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
{10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
{0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
{7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
{6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
{9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
{6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
{4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
{10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
{8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
{1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
{8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
{10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
{4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
{10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
{9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
{6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
{7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
{3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
{7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
{3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
{6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
{9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
{1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
{4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
{7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
{6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
{0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
{6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
{0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
{11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
{6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
{5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
{9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
{1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
{1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
{10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
{0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
{5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
{10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
{11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
{9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
{7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
{2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
{9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
{9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
{1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
{9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
{9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
{0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
{10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
{2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
{0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
{0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
{9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
{5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
{3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
{5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
{0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
{9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
{1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
{3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
{4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
{9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
{11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
{11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
{2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
{9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
{3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
{1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
{4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
{4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
{3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
{3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
{0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
{9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
{1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
};
namespace private_
{
double mc_isovalue_interpolation(double isovalue, double f1, double f2,
double x1, double x2)
{
if(f2==f1)
return (x2+x1)/2;
return (x2-x1)*(isovalue-f1)/(f2-f1) + x1;
}
void mc_add_vertex(double x1, double y1, double z1, double c2,
int axis, double f1, double f2, double isovalue, std::vector<double>* vertices)
{
if(axis == 0)
{
double x = mc_isovalue_interpolation(isovalue, f1, f2, x1, c2);
vertices->push_back(x);
vertices->push_back(y1);
vertices->push_back(z1);
return;
}
if(axis == 1)
{
double y = mc_isovalue_interpolation(isovalue, f1, f2, y1, c2);
vertices->push_back(x1);
vertices->push_back(y);
vertices->push_back(z1);
return;
}
if(axis == 2)
{
double z = mc_isovalue_interpolation(isovalue, f1, f2, z1, c2);
vertices->push_back(x1);
vertices->push_back(y1);
vertices->push_back(z);
return;
}
}
}
}
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/marchingcubes.h
================================================
#ifndef _MARCHING_CUBES_H
#define _MARCHING_CUBES_H
#include <stddef.h>
#include <array>
#include <vector>
#include <iostream>
#include <functional>
#include "Eigen/Eigen" // git clone https://gitlab.com/libeigen/eigen.git
typedef Eigen::Matrix<double, 6, 1> Vector6d;
namespace mc
{
extern int edge_table[256];
extern int triangle_table[256][16];
namespace private_
{
double mc_isovalue_interpolation(double isovalue, double f1, double f2,
double x1, double x2);
void mc_add_vertex(double x1, double y1, double z1, double c2,
int axis, double f1, double f2, double isovalue, std::vector<double>* vertices);
struct MC_Triangle {
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
int p[3];
};
struct MC_Gridcell {
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
Eigen::Vector3d p[8];
double val[8];
};
struct MC_Gridcell_Color {
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
Vector6d p[8];
double val[8];
};
}
template<typename vector3, typename formula>
void marching_cubes(const vector3& lower, const vector3& upper,
int numx, int numy, int numz, formula f, double isovalue,
std::vector<double>& vertices, std::vector<typename vector3::size_type>& polygons)
{
using coord_type = typename vector3::value_type;
using size_type = typename vector3::size_type;
using namespace private_;
// Some initial checks
if(numx < 2 || numy < 2 || numz < 2)
return;
if(!std::equal(std::begin(lower), std::end(lower), std::begin(upper),
[](double a, double b)->bool {return a <= b;}))
return;
#define OWN_IMPL
#ifdef OWN_IMPL
double dx = (upper[0] - lower[0]) / (numx - 1.0);
double dy = (upper[1] - lower[1]) / (numy - 1.0);
double dz = (upper[2] - lower[2]) / (numz - 1.0);
auto coord_mapper = [&](int x, int y, int z) { return Eigen::Vector3d( lower[0] + x * dx, lower[1] + y * dy, lower[2] + z * dz ); };
auto push_vertex = [&] (Eigen::Vector3d xyz) {int id = vertices.size()/3; vertices.push_back(xyz.x()); vertices.push_back(xyz.y()); vertices.push_back(xyz.z()); return id;};
// vertex zero crossing interpolation
// f(p2) = valp2
// x
// /
// x f(p) = isolevel
// /
// /
// /
// x
// f(p1) = valp1
auto VertexInterp = [&](double isolevel, const Eigen::Vector3d& p1, const Eigen::Vector3d& p2, double valp1, double valp2) -> Eigen::Vector3d
{
double alpha = (valp2 - isolevel) / (valp2 - valp1);
return alpha*p1 + (1 - alpha)*p2;
};
// store intersections of old z plane to avoid duplicated vertices
int* edge_intersections_old_x = new int[(numx-1) * numy];
int* edge_intersections_old_y = new int[numx * (numy-1)];
int* edge_intersections_current_x = new int[(numx-1) * numy];
int* edge_intersections_current_y = new int[numx * (numy-1)];
// store intersections within the z-planes to avoid duplicated vertices
int* edge_intersections_current_z = new int[numx * numy];
for (int z = 0; z < numz - 1; z++)
{
// swap index storage
std::swap(edge_intersections_old_x, edge_intersections_current_x); // old = current
std::swap(edge_intersections_old_y, edge_intersections_current_y);
std::fill_n(edge_intersections_current_x, (numx-1) * numy, -1); // invalidate
std::fill_n(edge_intersections_current_y, (numy-1) * numx, -1); // invalidate
std::fill_n(edge_intersections_current_z, numy * numx, -1); // invalidate
for (int y = 0; y < numy - 1; y++)
{
for (int x = 0; x < numx - 1; x++)
{
// Process Volume Cell
MC_Gridcell cell;
//
// 4---5
// / /|
// 0---1 6
// | |/
// 3---2
// cell corners
cell.p[0] = coord_mapper(x + 1, y, z);
cell.p[1] = coord_mapper(x, y, z);
cell.p[2] = coord_mapper(x, y + 1, z);
cell.p[3] = coord_mapper(x + 1, y + 1, z);
cell.p[4] = coord_mapper(x + 1, y, z + 1);
cell.p[5] = coord_mapper(x, y, z + 1);
cell.p[6] = coord_mapper(x, y + 1, z + 1);
cell.p[7] = coord_mapper(x + 1, y + 1, z + 1);
// cell corner values
cell.val[0] = (double)f(x + 1, y, z);
cell.val[1] = (double)f(x, y, z);
cell.val[2] = (double)f(x, y + 1, z);
cell.val[3] = (double)f(x + 1, y + 1, z);
cell.val[4] = (double)f(x + 1, y, z + 1);
cell.val[5] = (double)f(x, y, z + 1);
cell.val[6] = (double)f(x, y + 1, z + 1);
cell.val[7] = (double)f(x + 1, y + 1, z + 1);
// triangulation code
int cubeindex = 0;
if (cell.val[0] < isovalue) cubeindex |= 1;
if (cell.val[1] < isovalue) cubeindex |= 2;
if (cell.val[2] < isovalue) cubeindex |= 4;
if (cell.val[3] < isovalue) cubeindex |= 8;
if (cell.val[4] < isovalue) cubeindex |= 16;
if (cell.val[5] < isovalue) cubeindex |= 32;
if (cell.val[6] < isovalue) cubeindex |= 64;
if (cell.val[7] < isovalue) cubeindex |= 128;
// Cube is entirely in/out of the surface
if (edge_table[cubeindex] == 0) continue;
/* Find the vertices where the surface intersects the cube */
int vertlist[12];
{ // edges on the old z plane
if (edge_table[cubeindex] & 1) // edge in x at y
{
if(z==0) vertlist[0] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[1], cell.val[0], cell.val[1]));
else vertlist[0] = edge_intersections_old_x[y * (numx-1) + x];
}
if (edge_table[cubeindex] & 2) // edge in y at x
{
if(z==0) vertlist[1] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[2], cell.val[1], cell.val[2]));
else vertlist[1] = edge_intersections_old_y[x * (numy-1) + y];
}
if (edge_table[cubeindex] & 4) // edge in x at y+1
{
if(z==0) vertlist[2] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[3], cell.val[2], cell.val[3]));
else vertlist[2] = edge_intersections_old_x[(y+1) * (numx-1) + x];
}
if (edge_table[cubeindex] & 8) // edge in y at x+1
{
if(z==0) vertlist[3] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[0], cell.val[3], cell.val[0]));
else vertlist[3] = edge_intersections_old_y[(x+1) * (numy-1) + y];
}
}
{ // edges on the new z plane
if (edge_table[cubeindex] & 16) // edge in x at y
{
if (edge_intersections_current_x[y * (numx-1) + x] == -1) // check if already assigned
{
vertlist[4] = push_vertex(VertexInterp(isovalue, cell.p[4], cell.p[5], cell.val[4], cell.val[5]));
edge_intersections_current_x[y * (numx-1) + x] = vertlist[4];
}
else
{
vertlist[4] = edge_intersections_current_x[y * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 32) // edge in y at x
{
if(edge_intersections_current_y[x * (numy-1) + y] == -1)
{
vertlist[5] = push_vertex(VertexInterp(isovalue, cell.p[5], cell.p[6], cell.val[5], cell.val[6]));
edge_intersections_current_y[x * (numy-1) + y] = vertlist[5];
}
else
{
vertlist[5] = edge_intersections_current_y[x * (numy-1) + y];
}
}
if (edge_table[cubeindex] & 64) // edge in x at y+1
{
if (edge_intersections_current_x[(y+1) * (numx-1) + x] == -1)
{
vertlist[6] = push_vertex(VertexInterp(isovalue, cell.p[6], cell.p[7], cell.val[6], cell.val[7]));
edge_intersections_current_x[(y+1) * (numx-1) + x] = vertlist[6];
}
else
{
vertlist[6] = edge_intersections_current_x[(y+1) * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 128) // edge in y at x+1
{
if (edge_intersections_current_y[(x+1) * (numy-1) + y] == -1)
{
vertlist[7] = push_vertex(VertexInterp(isovalue, cell.p[7], cell.p[4], cell.val[7], cell.val[4]));
edge_intersections_current_y[(x+1) * (numy-1) + y] = vertlist[7];
}
else
{
vertlist[7] = edge_intersections_current_y[(x+1) * (numy-1) + y];
}
}
}
{ // between the z planes
if (edge_table[cubeindex] & 256) // 0 -- 4, x + 1, y
{
if (edge_intersections_current_z[y * numx + (x+1)] == -1)
{
vertlist[8] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[4], cell.val[0], cell.val[4]));
edge_intersections_current_z[y * numx + (x+1)] = vertlist[8];
}
else
{
vertlist[8] = edge_intersections_current_z[y * numx + (x+1)];
}
}
if (edge_table[cubeindex] & 512) // 1 -- 5, x, y
{
if (edge_intersections_current_z[y * numx + x] == -1)
{
vertlist[9] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[5], cell.val[1], cell.val[5]));
edge_intersections_current_z[y * numx + x] = vertlist[9];
}
else
{
vertlist[9] = edge_intersections_current_z[y * numx + x];
}
}
if (edge_table[cubeindex] & 1024) // 2 -- 6, x, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + x] == -1)
{
vertlist[10] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[6], cell.val[2], cell.val[6]));
edge_intersections_current_z[(y+1) * numx + x] = vertlist[10];
}
else
{
vertlist[10] = edge_intersections_current_z[(y+1) * numx + x];
}
}
if (edge_table[cubeindex] & 2048) // 3 -- 7, x + 1, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + (x+1)] == -1)
{
vertlist[11] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[7], cell.val[3], cell.val[7]));
edge_intersections_current_z[(y+1) * numx + (x+1)] = vertlist[11];
}
else
{
vertlist[11] = edge_intersections_current_z[(y+1) * numx + (x+1)];
}
}
}
// push face indices
for (int i = 0; triangle_table[cubeindex][i] != -1; ++i)
polygons.push_back(vertlist[triangle_table[cubeindex][i]]);
}
}
}
delete[] edge_intersections_old_x;
delete[] edge_intersections_old_y;
delete[] edge_intersections_current_x;
delete[] edge_intersections_current_y;
delete[] edge_intersections_current_z;
#else
// numx, numy and numz are the numbers of evaluations in each direction
--numx; --numy; --numz;
coord_type dx = (upper[0] - lower[0]) / static_cast<coord_type>(numx);
coord_type dy = (upper[1] - lower[1]) / static_cast<coord_type>(numy);
coord_type dz = (upper[2] - lower[2]) / static_cast<coord_type>(numz);
const int num_shared_indices = 2 * (numy + 1) * (numz + 1);
std::vector<size_type> shared_indices_x(num_shared_indices);
std::vector<size_type> shared_indices_y(num_shared_indices);
std::vector<size_type> shared_indices_z(num_shared_indices);
// const int numz = numz*3;
const int numyz = numy*numz;
for(int i=0; i<numx; ++i)
{
coord_type x = lower[0] + dx*i;
coord_type x_dx = lower[0] + dx*(i+1);
const int i_mod_2 = i % 2;
const int i_mod_2_inv = (i_mod_2 ? 0 : 1);
for(int j=0; j<numy; ++j)
{
coord_type y = lower[1] + dy*j;
coord_type y_dy = lower[1] + dy*(j+1);
double v[8];
v[4] = f(x, y, lower[2]); v[5] = f(x_dx, y, lower[2]);
v[6] = f(x_dx, y_dy, lower[2]); v[7] = f(x, y_dy, lower[2]);
for(int k=0; k<numz; ++k)
{
coord_type z = lower[2] + dz*k;
coord_type z_dz = lower[2] + dz*(k+1);
v[0] = v[4]; v[1] = v[5];
v[2] = v[6]; v[3] = v[7];
v[4] = f(x, y, z_dz); v[5] = f(x_dx, y, z_dz);
v[6] = f(x_dx, y_dy, z_dz); v[7] = f(x, y_dy, z_dz);
unsigned int cubeindex = 0;
for(int m=0; m<8; ++m)
if(v[m] <= isovalue)
cubeindex |= 1<<m;
// Generate vertices AVOIDING DUPLICATES.
int edges = edge_table[cubeindex];
std::array<size_type, 12> indices;
// for three edges we have to compute it for sure (if zerocrossing)
if(edges & 0x040)
{
indices[6] = vertices.size() / 3;
shared_indices_x[i_mod_2_inv*numyz + (j+1)*numz + (k+1)] = indices[6];
mc_add_vertex(x_dx, y_dy, z_dz, x, 0, v[6], v[7], isovalue, &vertices);
}
if(edges & 0x020)
{
indices[5] = vertices.size() / 3;
shared_indices_y[i_mod_2_inv*numyz + (j+1)*numz + (k+1)] = indices[5];
mc_add_vertex(x_dx, y, z_dz, y_dy, 1, v[5], v[6], isovalue, &vertices);
}
if(edges & 0x400)
{
indices[10] = vertices.size() / 3;
shared_indices_z[i_mod_2_inv*numyz + (j+1)*numz + (k+1)] = indices[10];
mc_add_vertex(x_dx, y+dx, z, z_dz, 2, v[2], v[6], isovalue, &vertices);
}
if(edges & 0x001)
{
if(j == 0 && k == 0)
{
indices[0] = vertices.size() / 3;
mc_add_vertex(x, y, z, x_dx, 0, v[0], v[1], isovalue, &vertices);
}
else
indices[0] = shared_indices_x[i_mod_2_inv*numyz + j*numz + k];
}
if(edges & 0x002)
{
if(k == 0)
{
indices[1] = vertices.size() / 3;
shared_indices_y[i_mod_2_inv*numyz + (j+1)*numz + k] = indices[1];
mc_add_vertex(x_dx, y, z, y_dy, 1, v[1], v[2], isovalue, &vertices);
}
else
indices[1] = shared_indices_y[i_mod_2_inv*numyz + (j+1)*numz + k];
}
if(edges & 0x004)
{
if(k == 0)
{
indices[2] = vertices.size() / 3;
shared_indices_x[i_mod_2_inv*numyz + (j+1)*numz + k] = indices[2];
mc_add_vertex(x_dx, y_dy, z, x, 0, v[2], v[3], isovalue, &vertices);
}
else
indices[2] = shared_indices_x[i_mod_2_inv*numyz + (j+1)*numz + k];
}
if(edges & 0x008)
{
if(i == 0 && k == 0)
{
indices[3] = vertices.size() / 3;
mc_add_vertex(x, y_dy, z, y, 1, v[3], v[0], isovalue, &vertices);
}
else
indices[3] = shared_indices_y[i_mod_2*numyz + (j+1)*numz + k];
}
if(edges & 0x010)
{
if(j == 0)
{
indices[4] = vertices.size() / 3;
shared_indices_x[i_mod_2_inv*numyz + j*numz + (k+1)] = indices[4];
mc_add_vertex(x, y, z_dz, x_dx, 0, v[4], v[5], isovalue, &vertices);
}
else
indices[4] = shared_indices_x[i_mod_2_inv*numyz + j*numz + (k+1)];
}
if(edges & 0x080)
{
if(i == 0)
{
indices[7] = vertices.size() / 3;
shared_indices_y[i_mod_2*numyz + (j+1)*numz + (k+1)] = indices[7];
mc_add_vertex(x, y_dy, z_dz, y, 1, v[7], v[4], isovalue, &vertices);
}
else
indices[7] = shared_indices_y[i_mod_2*numyz + (j+1)*numz + (k+1)];
}
if(edges & 0x100)
{
if(i == 0 && j == 0)
{
indices[8] = vertices.size() / 3;
mc_add_vertex(x, y, z, z_dz, 2, v[0], v[4], isovalue, &vertices);
}
else
indices[8] = shared_indices_z[i_mod_2*numyz + j*numz + (k+1)];
}
if(edges & 0x200)
{
if(j == 0)
{
indices[9] = vertices.size() / 3;
shared_indices_z[i_mod_2_inv*numyz + j*numz + (k+1)] = indices[9];
mc_add_vertex(x_dx, y, z, z_dz, 2, v[1], v[5], isovalue, &vertices);
}
else
indices[9] = shared_indices_z[i_mod_2_inv*numyz + j*numz + (k+1)];
}
if(edges & 0x800)
{
if(i == 0)
{
indices[11] = vertices.size() / 3;
shared_indices_z[i_mod_2*numyz + (j+1)*numz + (k+1)] = indices[11];
mc_add_vertex(x, y_dy, z, z_dz, 2, v[3], v[7], isovalue, &vertices);
}
else
indices[11] = shared_indices_z[i_mod_2*numyz + (j+1)*numz + (k+1)];
}
int tri;
int* triangle_table_ptr = triangle_table[cubeindex];
for(int m=0; tri = triangle_table_ptr[m], tri != -1; ++m)
polygons.push_back(indices[tri]);
/*if(triangle_table_ptr[0] == -1) continue;
Eigen::Vector3d last(vertices[3*indices[triangle_table_ptr[0] ]+0], vertices[3*indices[triangle_table_ptr[0] ]+1], vertices[3*indices[triangle_table_ptr[0] ]+2]);
for(int m=0; tri = triangle_table_ptr[m], tri != -1; ++m)
{
Eigen::Vector3d current(vertices[3*indices[tri]+0], vertices[3*indices[tri]+1], vertices[3*indices[tri]+2]);
if ((current-last).norm() > std::sqrt(dx*dx + dy*dy + dz*dz))
{
std::cout << "error: " << (current-last).norm() << std::endl;
std::cout << "cubeindex: " << cubeindex << std::endl;
std::cout << "i: " << i << std::endl;
std::cout << "j: " << j << std::endl;
std::cout << "k: " << k << std::endl;
std::cout << "m: " << m << std::endl;
}
last = current;
polygons.push_back(indices[tri]);
}*/
}
}
}
#endif
}
/////////////////////////////
/////////////////////////////
////////// COLOR //////////
/////////////////////////////
/////////////////////////////
template<typename vector3, typename formula_sdf, typename formula_color>
void marching_cubes_color(const vector3& lower, const vector3& upper,
int numx, int numy, int numz, formula_sdf f_sdf, formula_color f_color, double isovalue,
std::vector<double>& vertices, std::vector<typename vector3::size_type>& polygons)
{
using coord_type = typename vector3::value_type;
using size_type = typename vector3::size_type;
using namespace private_;
// Some initial checks
if(numx < 2 || numy < 2 || numz < 2)
return;
if(!std::equal(std::begin(lower), std::end(lower), std::begin(upper),
[](double a, double b)->bool {return a <= b;}))
return;
double dx = (upper[0] - lower[0]) / (numx - 1.0);
double dy = (upper[1] - lower[1]) / (numy - 1.0);
double dz = (upper[2] - lower[2]) / (numz - 1.0);
auto coord_mapper = [&](int x, int y, int z) { return Eigen::Vector3d( lower[0] + x * dx, lower[1] + y * dy, lower[2] + z * dz ); };
//auto push_vertex = [&] (Eigen::Vector3d xyz) {int id = vertices.size()/3; vertices.push_back(xyz.x()); vertices.push_back(xyz.y()); vertices.push_back(xyz.z()); return id;};
auto push_vertex = [&] (const Vector6d& xyz_rgb)
{
int id = vertices.size()/6;
for(unsigned int i=0; i<6; ++i) vertices.push_back(xyz_rgb[i]);
return id;
};
// vertex zero crossing interpolation
// f(p2) = valp2
// x
// /
// x f(p) = isolevel
// /
// /
// /
// x
// f(p1) = valp1
auto VertexInterp = [&](double isolevel, const Vector6d& p1, const Vector6d& p2, double valp1, double valp2) -> Vector6d
{
double alpha = (valp2 - isolevel) / (valp2 - valp1);
return alpha*p1 + (1 - alpha)*p2;
};
// store intersections of old z plane to avoid duplicated vertices
int* edge_intersections_old_x = new int[(numx-1) * numy];
int* edge_intersections_old_y = new int[numx * (numy-1)];
int* edge_intersections_current_x = new int[(numx-1) * numy];
int* edge_intersections_current_y = new int[numx * (numy-1)];
// store intersections within the z-planes to avoid duplicated vertices
int* edge_intersections_current_z = new int[numx * numy];
for (int z = 0; z < numz - 1; z++)
{
// swap index storage
std::swap(edge_intersections_old_x, edge_intersections_current_x); // old = current
std::swap(edge_intersections_old_y, edge_intersections_current_y);
std::fill_n(edge_intersections_current_x, (numx-1) * numy, -1); // invalidate
std::fill_n(edge_intersections_current_y, (numy-1) * numx, -1); // invalidate
std::fill_n(edge_intersections_current_z, numy * numx, -1); // invalidate
for (int y = 0; y < numy - 1; y++)
{
for (int x = 0; x < numx - 1; x++)
{
// Process Volume Cell
MC_Gridcell_Color cell;
//
// 4---5
// / /|
// 0---1 6
// | |/
// 3---2
// cell corners
cell.p[0].block<3,1>(0,0) = coord_mapper(x + 1, y, z);
cell.p[1].block<3,1>(0,0) = coord_mapper(x, y, z);
cell.p[2].block<3,1>(0,0) = coord_mapper(x, y + 1, z);
cell.p[3].block<3,1>(0,0) = coord_mapper(x + 1, y + 1, z);
cell.p[4].block<3,1>(0,0) = coord_mapper(x + 1, y, z + 1);
cell.p[5].block<3,1>(0,0) = coord_mapper(x, y, z + 1);
cell.p[6].block<3,1>(0,0) = coord_mapper(x, y + 1, z + 1);
cell.p[7].block<3,1>(0,0) = coord_mapper(x + 1, y + 1, z + 1);
// cell colors
cell.p[0].block<3,1>(3,0) = f_color(x + 1, y, z);
cell.p[1].block<3,1>(3,0) = f_color(x, y, z);
cell.p[2].block<3,1>(3,0) = f_color(x, y + 1, z);
cell.p[3].block<3,1>(3,0) = f_color(x + 1, y + 1, z);
cell.p[4].block<3,1>(3,0) = f_color(x + 1, y, z + 1);
cell.p[5].block<3,1>(3,0) = f_color(x, y, z + 1);
cell.p[6].block<3,1>(3,0) = f_color(x, y + 1, z + 1);
cell.p[7].block<3,1>(3,0) = f_color(x + 1, y + 1, z + 1);
// cell corner values
cell.val[0] = (double)f_sdf(x + 1, y, z);
cell.val[1] = (double)f_sdf(x, y, z);
cell.val[2] = (double)f_sdf(x, y + 1, z);
cell.val[3] = (double)f_sdf(x + 1, y + 1, z);
cell.val[4] = (double)f_sdf(x + 1, y, z + 1);
cell.val[5] = (double)f_sdf(x, y, z + 1);
cell.val[6] = (double)f_sdf(x, y + 1, z + 1);
cell.val[7] = (double)f_sdf(x + 1, y + 1, z + 1);
// triangulation code
int cubeindex = 0;
if (cell.val[0] < isovalue) cubeindex |= 1;
if (cell.val[1] < isovalue) cubeindex |= 2;
if (cell.val[2] < isovalue) cubeindex |= 4;
if (cell.val[3] < isovalue) cubeindex |= 8;
if (cell.val[4] < isovalue) cubeindex |= 16;
if (cell.val[5] < isovalue) cubeindex |= 32;
if (cell.val[6] < isovalue) cubeindex |= 64;
if (cell.val[7] < isovalue) cubeindex |= 128;
// Cube is entirely in/out of the surface
if (edge_table[cubeindex] == 0) continue;
/* Find the vertices where the surface intersects the cube */
int vertlist[12];
{ // edges on the old z plane
if (edge_table[cubeindex] & 1) // edge in x at y
{
if(z==0) vertlist[0] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[1], cell.val[0], cell.val[1]));
else vertlist[0] = edge_intersections_old_x[y * (numx-1) + x];
}
if (edge_table[cubeindex] & 2) // edge in y at x
{
if(z==0) vertlist[1] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[2], cell.val[1], cell.val[2]));
else vertlist[1] = edge_intersections_old_y[x * (numy-1) + y];
}
if (edge_table[cubeindex] & 4) // edge in x at y+1
{
if(z==0) vertlist[2] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[3], cell.val[2], cell.val[3]));
else vertlist[2] = edge_intersections_old_x[(y+1) * (numx-1) + x];
}
if (edge_table[cubeindex] & 8) // edge in y at x+1
{
if(z==0) vertlist[3] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[0], cell.val[3], cell.val[0]));
else vertlist[3] = edge_intersections_old_y[(x+1) * (numy-1) + y];
}
}
{ // edges on the new z plane
if (edge_table[cubeindex] & 16) // edge in x at y
{
if (edge_intersections_current_x[y * (numx-1) + x] == -1) // check if already assigned
{
vertlist[4] = push_vertex(VertexInterp(isovalue, cell.p[4], cell.p[5], cell.val[4], cell.val[5]));
edge_intersections_current_x[y * (numx-1) + x] = vertlist[4];
}
else
{
vertlist[4] = edge_intersections_current_x[y * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 32) // edge in y at x
{
if(edge_intersections_current_y[x * (numy-1) + y] == -1)
{
vertlist[5] = push_vertex(VertexInterp(isovalue, cell.p[5], cell.p[6], cell.val[5], cell.val[6]));
edge_intersections_current_y[x * (numy-1) + y] = vertlist[5];
}
else
{
vertlist[5] = edge_intersections_current_y[x * (numy-1) + y];
}
}
if (edge_table[cubeindex] & 64) // edge in x at y+1
{
if (edge_intersections_current_x[(y+1) * (numx-1) + x] == -1)
{
vertlist[6] = push_vertex(VertexInterp(isovalue, cell.p[6], cell.p[7], cell.val[6], cell.val[7]));
edge_intersections_current_x[(y+1) * (numx-1) + x] = vertlist[6];
}
else
{
vertlist[6] = edge_intersections_current_x[(y+1) * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 128) // edge in y at x+1
{
if (edge_intersections_current_y[(x+1) * (numy-1) + y] == -1)
{
vertlist[7] = push_vertex(VertexInterp(isovalue, cell.p[7], cell.p[4], cell.val[7], cell.val[4]));
edge_intersections_current_y[(x+1) * (numy-1) + y] = vertlist[7];
}
else
{
vertlist[7] = edge_intersections_current_y[(x+1) * (numy-1) + y];
}
}
}
{ // between the z planes
if (edge_table[cubeindex] & 256) // 0 -- 4, x + 1, y
{
if (edge_intersections_current_z[y * numx + (x+1)] == -1)
{
vertlist[8] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[4], cell.val[0], cell.val[4]));
edge_intersections_current_z[y * numx + (x+1)] = vertlist[8];
}
else
{
vertlist[8] = edge_intersections_current_z[y * numx + (x+1)];
}
}
if (edge_table[cubeindex] & 512) // 1 -- 5, x, y
{
if (edge_intersections_current_z[y * numx + x] == -1)
{
vertlist[9] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[5], cell.val[1], cell.val[5]));
edge_intersections_current_z[y * numx + x] = vertlist[9];
}
else
{
vertlist[9] = edge_intersections_current_z[y * numx + x];
}
}
if (edge_table[cubeindex] & 1024) // 2 -- 6, x, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + x] == -1)
{
vertlist[10] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[6], cell.val[2], cell.val[6]));
edge_intersections_current_z[(y+1) * numx + x] = vertlist[10];
}
else
{
vertlist[10] = edge_intersections_current_z[(y+1) * numx + x];
}
}
if (edge_table[cubeindex] & 2048) // 3 -- 7, x + 1, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + (x+1)] == -1)
{
vertlist[11] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[7], cell.val[3], cell.val[7]));
edge_intersections_current_z[(y+1) * numx + (x+1)] = vertlist[11];
}
else
{
vertlist[11] = edge_intersections_current_z[(y+1) * numx + (x+1)];
}
}
}
// push face indices
for (int i = 0; triangle_table[cubeindex][i] != -1; ++i)
polygons.push_back(vertlist[triangle_table[cubeindex][i]]);
}
}
}
delete[] edge_intersections_old_x;
delete[] edge_intersections_old_y;
delete[] edge_intersections_current_x;
delete[] edge_intersections_current_y;
delete[] edge_intersections_current_z;
}
//////////////////////////////////////
//////////////////////////////////////
////////// SUPER SAMPLING //////////
//////////////////////////////////////
//////////////////////////////////////
template<typename vector3, typename formula, typename formulaX, typename formulaY, typename formulaZ>
void marching_cubes_super_sampling(const vector3& lower, const vector3& upper,
int numx, int numy, int numz,
int superx, int supery, int superz,
formula f,
formulaX f_superX, formulaY f_superY, formulaZ f_superZ,
double isovalue,
std::vector<double>& vertices, std::vector<typename vector3::size_type>& polygons)
{
using coord_type = typename vector3::value_type;
using size_type = typename vector3::size_type;
using namespace private_;
// Some initial checks
if(numx < 2 || numy < 2 || numz < 2)
return;
if(!std::equal(std::begin(lower), std::end(lower), std::begin(upper),
[](double a, double b)->bool {return a <= b;}))
return;
double dx = (upper[0] - lower[0]) / (numx - 1.0);
double dy = (upper[1] - lower[1]) / (numy - 1.0);
double dz = (upper[2] - lower[2]) / (numz - 1.0);
double scale_x = (numx - 1.0) / ( numx + (numx - 1) * superx - 1.0 ); // map super sampling coordinates back to actual sampling coordinates
double scale_y = (numy - 1.0) / ( numy + (numy - 1) * supery - 1.0 );
double scale_z = (numz - 1.0) / ( numz + (numz - 1) * superz - 1.0 );
//auto coord_mapper = [&](int x, int y, int z) { return Eigen::Vector3d( lower[0] + x * dx, lower[1] + y * dy, lower[2] + z * dz ); };
auto coord_mapper = [&](int x, int y, int z) { return Eigen::Vector3d( x,y,z ); };
auto push_vertex = [&] (Eigen::Vector3d xyz) {int id = vertices.size()/3; vertices.push_back(xyz.x()); vertices.push_back(xyz.y()); vertices.push_back(xyz.z()); return id;};
auto sign = [](double x) { return x > 0.0; };
// vertex zero crossing interpolation
// f(p2) = valp2
// x
// /
// x f(p) = isolevel
// /
// /
// /
// x
// f(p1) = valp1
auto VertexInterp = [&](double isolevel, const Eigen::Vector3d& p1, const Eigen::Vector3d& p2, double valp1, double valp2) -> Eigen::Vector3d
{
bool edge_in_x_dir = p1.x() != p2.x() && p1.y() == p2.y() && p1.z() == p2.z();
bool edge_in_y_dir = p1.x() == p2.x() && p1.y() != p2.y() && p1.z() == p2.z();
bool edge_in_z_dir = p1.x() == p2.x() && p1.y() == p2.y() && p1.z() != p2.z();
//if (edge_in_x_dir == true && edge_in_y_dir==true) std::cout << "ERROR XY" << std::endl;
//if (edge_in_x_dir == true && edge_in_z_dir==true) std::cout << "ERROR XZ" << std::endl;
//if (edge_in_y_dir == true && edge_in_z_dir==true) std::cout << "ERROR YZ" << std::endl;
//if (edge_in_x_dir == false && edge_in_y_dir == false && edge_in_z_dir==false) std::cout << "ERROR XYZ=FALSE" << std::endl;
Eigen::Vector3d p1_ss = p1;
Eigen::Vector3d p2_ss = p2;
double valp1_ss = valp1;
double valp2_ss = valp2;
//if (edge_in_x_dir) std::cout << "edge_in_x_dir" << std::endl;
//if (edge_in_y_dir) std::cout << "edge_in_y_dir" << std::endl;
//if (edge_in_z_dir) std::cout << "edge_in_z_dir" << std::endl;
//if (fabs(valp1-isolevel)!=0.0 && fabs(valp2-isolevel)==0.0)
{
if (edge_in_x_dir)
{
// [ 0.0, 0.0, 0.0, 1.0, 1.0 ] -->valp1 = 0.0, valp2=1.0 --> val_prev=0.0
// [ 1.0, 1.0, 0.0, 0.0, 0.0 ] -->valp1 = 1.0, valp2=0.0 --> val_prev=1.0
int min_x = std::min(p1.x(), p2.x());
double val_prev = valp1;
if(p2.x() == min_x) val_prev=valp2;
int y = p1.y();
int z = p1.z();
for(int i=1; i<=superx+1; ++i) // could do interval halfing / binary search
{
// find isolevel point
int x = min_x*(superx+1) + i;
double val = (double)f_superX(x, y, z);
if (sign(val-isolevel) != sign(val_prev-isolevel) || (fabs(val-isolevel)==0.0 && fabs(val_prev-isolevel)!=0.0 )) // zero crossing
{
valp1_ss = val_prev;
valp2_ss = val;
p1_ss.x() = (x - 1) * scale_x;
p2_ss.x() = x * scale_x;
break;
}
val_prev = val;
}
}
if (edge_in_y_dir)
{
int min_y = std::min(p1.y(), p2.y());
double val_prev = valp1;
if(p2.y() == min_y) val_prev=valp2;
int x = p1.x();
int z = p1.z();
for(int i=1; i<=supery+1; ++i) // could do interval halfing / binary search
{
// find isolevel point
int y = min_y*(supery+1) + i;
double val = (double)f_superY(x, y, z);
if (sign(val-isolevel) != sign(val_prev-isolevel) || (fabs(val-isolevel)==0.0 && fabs(val_prev-isolevel)!=0.0 )) // zero crossing
{
valp1_ss = val_prev;
valp2_ss = val;
p1_ss.y() = (y - 1) * scale_y;
p2_ss.y() = y * scale_y;
break;
}
val_prev = val;
}
}
if (edge_in_z_dir)
{
int min_z = std::min(p1.z(), p2.z());
double val_prev = valp1;
if(p2.z() == min_z) val_prev=valp2;
int x = p1.x();
int y = p1.y();
for(int i=1; i<=superz+1; ++i) // could do interval halfing / binary search
{
// find isolevel point
int z = min_z*(superz+1) + i;
double val = (double)f_superZ(x, y, z);
if (sign(val-isolevel) != sign(val_prev-isolevel) || (fabs(val-isolevel)==0.0 && fabs(val_prev-isolevel)!=0.0 )) // zero crossing
{
valp1_ss = val_prev;
valp2_ss = val;
p1_ss.z() = (z - 1) * scale_z;
p2_ss.z() = z * scale_z;
break;
}
val_prev = val;
}
}
}
// coord mapper
p1_ss = Eigen::Vector3d( lower[0] + p1_ss.x() * dx, lower[1] + p1_ss.y() * dy, lower[2] + p1_ss.z() * dz);
p2_ss = Eigen::Vector3d( lower[0] + p2_ss.x() * dx, lower[1] + p2_ss.y() * dy, lower[2] + p2_ss.z() * dz);
// actual interpolation
double alpha = (valp2_ss - isolevel) / (valp2_ss - valp1_ss);
if (valp2_ss - valp1_ss == 0.0)
{
alpha = 0.5;
}
return alpha*p1_ss + (1 - alpha)*p2_ss;
};
// store intersections of old z plane to avoid duplicated vertices
int* edge_intersections_old_x = new int[(numx-1) * numy];
int* edge_intersections_old_y = new int[numx * (numy-1)];
int* edge_intersections_current_x = new int[(numx-1) * numy];
int* edge_intersections_current_y = new int[numx * (numy-1)];
// store intersections within the z-planes to avoid duplicated vertices
int* edge_intersections_current_z = new int[numx * numy];
for (int z = 0; z < numz - 1; z++)
{
// swap index storage
std::swap(edge_intersections_old_x, edge_intersections_current_x); // old = current
std::swap(edge_intersections_old_y, edge_intersections_current_y);
std::fill_n(edge_intersections_current_x, (numx-1) * numy, -1); // invalidate
std::fill_n(edge_intersections_current_y, (numy-1) * numx, -1); // invalidate
std::fill_n(edge_intersections_current_z, numy * numx, -1); // invalidate
for (int y = 0; y < numy - 1; y++)
{
for (int x = 0; x < numx - 1; x++)
{
// Process Volume Cell
MC_Gridcell cell;
//
// 4---5
// / /|
// 0---1 6
// | |/
// 3---2
// cell corners
cell.p[0] = coord_mapper(x + 1, y, z);
cell.p[1] = coord_mapper(x, y, z);
cell.p[2] = coord_mapper(x, y + 1, z);
cell.p[3] = coord_mapper(x + 1, y + 1, z);
cell.p[4] = coord_mapper(x + 1, y, z + 1);
cell.p[5] = coord_mapper(x, y, z + 1);
cell.p[6] = coord_mapper(x, y + 1, z + 1);
cell.p[7] = coord_mapper(x + 1, y + 1, z + 1);
// cell corner values
cell.val[0] = (double)f(x + 1, y, z);
cell.val[1] = (double)f(x, y, z);
cell.val[2] = (double)f(x, y + 1, z);
cell.val[3] = (double)f(x + 1, y + 1, z);
cell.val[4] = (double)f(x + 1, y, z + 1);
cell.val[5] = (double)f(x, y, z + 1);
cell.val[6] = (double)f(x, y + 1, z + 1);
cell.val[7] = (double)f(x + 1, y + 1, z + 1);
// triangulation code
int cubeindex = 0;
if (cell.val[0] < isovalue) cubeindex |= 1;
if (cell.val[1] < isovalue) cubeindex |= 2;
if (cell.val[2] < isovalue) cubeindex |= 4;
if (cell.val[3] < isovalue) cubeindex |= 8;
if (cell.val[4] < isovalue) cubeindex |= 16;
if (cell.val[5] < isovalue) cubeindex |= 32;
if (cell.val[6] < isovalue) cubeindex |= 64;
if (cell.val[7] < isovalue) cubeindex |= 128;
// Cube is entirely in/out of the surface
if (edge_table[cubeindex] == 0) continue;
/* Find the vertices where the surface intersects the cube */
int vertlist[12];
{ // edges on the old z plane
if (edge_table[cubeindex] & 1) // edge in x at y
{
if(z==0) vertlist[0] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[1], cell.val[0], cell.val[1]));
else vertlist[0] = edge_intersections_old_x[y * (numx-1) + x];
}
if (edge_table[cubeindex] & 2) // edge in y at x
{
if(z==0) vertlist[1] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[2], cell.val[1], cell.val[2]));
else vertlist[1] = edge_intersections_old_y[x * (numy-1) + y];
}
if (edge_table[cubeindex] & 4) // edge in x at y+1
{
if(z==0) vertlist[2] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[3], cell.val[2], cell.val[3]));
else vertlist[2] = edge_intersections_old_x[(y+1) * (numx-1) + x];
}
if (edge_table[cubeindex] & 8) // edge in y at x+1
{
if(z==0) vertlist[3] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[0], cell.val[3], cell.val[0]));
else vertlist[3] = edge_intersections_old_y[(x+1) * (numy-1) + y];
}
}
{ // edges on the new z plane
if (edge_table[cubeindex] & 16) // edge in x at y
{
if (edge_intersections_current_x[y * (numx-1) + x] == -1) // check if already assigned
{
vertlist[4] = push_vertex(VertexInterp(isovalue, cell.p[4], cell.p[5], cell.val[4], cell.val[5]));
edge_intersections_current_x[y * (numx-1) + x] = vertlist[4];
}
else
{
vertlist[4] = edge_intersections_current_x[y * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 32) // edge in y at x
{
if(edge_intersections_current_y[x * (numy-1) + y] == -1)
{
vertlist[5] = push_vertex(VertexInterp(isovalue, cell.p[5], cell.p[6], cell.val[5], cell.val[6]));
edge_intersections_current_y[x * (numy-1) + y] = vertlist[5];
}
else
{
vertlist[5] = edge_intersections_current_y[x * (numy-1) + y];
}
}
if (edge_table[cubeindex] & 64) // edge in x at y+1
{
if (edge_intersections_current_x[(y+1) * (numx-1) + x] == -1)
{
vertlist[6] = push_vertex(VertexInterp(isovalue, cell.p[6], cell.p[7], cell.val[6], cell.val[7]));
edge_intersections_current_x[(y+1) * (numx-1) + x] = vertlist[6];
}
else
{
vertlist[6] = edge_intersections_current_x[(y+1) * (numx-1) + x];
}
}
if (edge_table[cubeindex] & 128) // edge in y at x+1
{
if (edge_intersections_current_y[(x+1) * (numy-1) + y] == -1)
{
vertlist[7] = push_vertex(VertexInterp(isovalue, cell.p[7], cell.p[4], cell.val[7], cell.val[4]));
edge_intersections_current_y[(x+1) * (numy-1) + y] = vertlist[7];
}
else
{
vertlist[7] = edge_intersections_current_y[(x+1) * (numy-1) + y];
}
}
}
{ // between the z planes
if (edge_table[cubeindex] & 256) // 0 -- 4, x + 1, y
{
if (edge_intersections_current_z[y * numx + (x+1)] == -1)
{
vertlist[8] = push_vertex(VertexInterp(isovalue, cell.p[0], cell.p[4], cell.val[0], cell.val[4]));
edge_intersections_current_z[y * numx + (x+1)] = vertlist[8];
}
else
{
vertlist[8] = edge_intersections_current_z[y * numx + (x+1)];
}
}
if (edge_table[cubeindex] & 512) // 1 -- 5, x, y
{
if (edge_intersections_current_z[y * numx + x] == -1)
{
vertlist[9] = push_vertex(VertexInterp(isovalue, cell.p[1], cell.p[5], cell.val[1], cell.val[5]));
edge_intersections_current_z[y * numx + x] = vertlist[9];
}
else
{
vertlist[9] = edge_intersections_current_z[y * numx + x];
}
}
if (edge_table[cubeindex] & 1024) // 2 -- 6, x, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + x] == -1)
{
vertlist[10] = push_vertex(VertexInterp(isovalue, cell.p[2], cell.p[6], cell.val[2], cell.val[6]));
edge_intersections_current_z[(y+1) * numx + x] = vertlist[10];
}
else
{
vertlist[10] = edge_intersections_current_z[(y+1) * numx + x];
}
}
if (edge_table[cubeindex] & 2048) // 3 -- 7, x + 1, y + 1
{
if (edge_intersections_current_z[(y+1) * numx + (x+1)] == -1)
{
vertlist[11] = push_vertex(VertexInterp(isovalue, cell.p[3], cell.p[7], cell.val[3], cell.val[7]));
edge_intersections_current_z[(y+1) * numx + (x+1)] = vertlist[11];
}
else
{
vertlist[11] = edge_intersections_current_z[(y+1) * numx + (x+1)];
}
}
}
// push face indices
for (int i = 0; triangle_table[cubeindex][i] != -1; ++i)
polygons.push_back(vertlist[triangle_table[cubeindex][i]]);
}
}
}
delete[] edge_intersections_old_x;
delete[] edge_intersections_old_y;
delete[] edge_intersections_current_x;
delete[] edge_intersections_current_y;
delete[] edge_intersections_current_z;
}
}
#endif // _MARCHING_CUBES_H
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/pyarray_symbol.h
================================================
#define PY_ARRAY_UNIQUE_SYMBOL mcubes_PyArray_API
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/pyarraymodule.h
================================================
#ifndef _EXTMODULE_H
#define _EXTMODULE_H
#include <Python.h>
#include <stdexcept>
// #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#define PY_ARRAY_UNIQUE_SYMBOL mcubes_PyArray_API
#define NO_IMPORT_ARRAY
#include "numpy/arrayobject.h"
#include <complex>
template<class T>
struct numpy_typemap;
#define define_numpy_type(ctype, dtype) \
template<> \
struct numpy_typemap<ctype> \
{static const int type = dtype;};
define_numpy_type(bool, NPY_BOOL);
define_numpy_type(char, NPY_BYTE);
define_numpy_type(short, NPY_SHORT);
define_numpy_type(int, NPY_INT);
define_numpy_type(long, NPY_LONG);
define_numpy_type(long long, NPY_LONGLONG);
define_numpy_type(unsigned char, NPY_UBYTE);
define_numpy_type(unsigned short, NPY_USHORT);
define_numpy_type(unsigned int, NPY_UINT);
define_numpy_type(unsigned long, NPY_ULONG);
define_numpy_type(unsigned long long, NPY_ULONGLONG);
define_numpy_type(float, NPY_FLOAT);
define_numpy_type(double, NPY_DOUBLE);
define_numpy_type(long double, NPY_LONGDOUBLE);
define_numpy_type(std::complex<float>, NPY_CFLOAT);
define_numpy_type(std::complex<double>, NPY_CDOUBLE);
define_numpy_type(std::complex<long double>, NPY_CLONGDOUBLE);
template<typename T>
T PyArray_SafeGet(const PyArrayObject* aobj, const npy_intp* indaux)
{
// HORROR.
npy_intp* ind = const_cast<npy_intp*>(indaux);
void* ptr = PyArray_GetPtr(const_cast<PyArrayObject*>(aobj), ind);
switch(PyArray_TYPE(aobj))
{
case NPY_BOOL:
return static_cast<T>(*reinterpret_cast<bool*>(ptr));
case NPY_BYTE:
return static_cast<T>(*reinterpret_cast<char*>(ptr));
case NPY_SHORT:
return static_cast<T>(*reinterpret_cast<short*>(ptr));
case NPY_INT:
return static_cast<T>(*reinterpret_cast<int*>(ptr));
case NPY_LONG:
return static_cast<T>(*reinterpret_cast<long*>(ptr));
case NPY_LONGLONG:
return static_cast<T>(*reinterpret_cast<long long*>(ptr));
case NPY_UBYTE:
return static_cast<T>(*reinterpret_cast<unsigned char*>(ptr));
case NPY_USHORT:
return static_cast<T>(*reinterpret_cast<unsigned short*>(ptr));
case NPY_UINT:
return static_cast<T>(*reinterpret_cast<unsigned int*>(ptr));
case NPY_ULONG:
return static_cast<T>(*reinterpret_cast<unsigned long*>(ptr));
case NPY_ULONGLONG:
return static_cast<T>(*reinterpret_cast<unsigned long long*>(ptr));
case NPY_FLOAT:
return static_cast<T>(*reinterpret_cast<float*>(ptr));
case NPY_DOUBLE:
return static_cast<T>(*reinterpret_cast<double*>(ptr));
case NPY_LONGDOUBLE:
return static_cast<T>(*reinterpret_cast<long double*>(ptr));
default:
throw std::runtime_error("data type not supported");
}
}
template<typename T>
T PyArray_SafeSet(PyArrayObject* aobj, const npy_intp* indaux, const T& value)
{
// HORROR.
npy_intp* ind = const_cast<npy_intp*>(indaux);
void* ptr = PyArray_GetPtr(aobj, ind);
switch(PyArray_TYPE(aobj))
{
case NPY_BOOL:
*reinterpret_cast<bool*>(ptr) = static_cast<bool>(value);
break;
case NPY_BYTE:
*reinterpret_cast<char*>(ptr) = static_cast<char>(value);
break;
case NPY_SHORT:
*reinterpret_cast<short*>(ptr) = static_cast<short>(value);
break;
case NPY_INT:
*reinterpret_cast<int*>(ptr) = static_cast<int>(value);
break;
case NPY_LONG:
*reinterpret_cast<long*>(ptr) = static_cast<long>(value);
break;
case NPY_LONGLONG:
*reinterpret_cast<long long*>(ptr) = static_cast<long long>(value);
break;
case NPY_UBYTE:
*reinterpret_cast<unsigned char*>(ptr) = static_cast<unsigned char>(value);
break;
case NPY_USHORT:
*reinterpret_cast<unsigned short*>(ptr) = static_cast<unsigned short>(value);
break;
case NPY_UINT:
*reinterpret_cast<unsigned int*>(ptr) = static_cast<unsigned int>(value);
break;
case NPY_ULONG:
*reinterpret_cast<unsigned long*>(ptr) = static_cast<unsigned long>(value);
break;
case NPY_ULONGLONG:
*reinterpret_cast<unsigned long long*>(ptr) = static_cast<unsigned long long>(value);
break;
case NPY_FLOAT:
*reinterpret_cast<float*>(ptr) = static_cast<float>(value);
break;
case NPY_DOUBLE:
*reinterpret_cast<double*>(ptr) = static_cast<double>(value);
break;
case NPY_LONGDOUBLE:
*reinterpret_cast<long double*>(ptr) = static_cast<long double>(value);
break;
default:
throw std::runtime_error("data type not supported");
}
}
#endif
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/pywrapper.cpp
================================================
#include "pywrapper.h"
#include "marchingcubes.h"
#include <stdexcept>
#include <array>
PyObject* marching_cubes_func(PyObject* lower, PyObject* upper,
int numx, int numy, int numz, PyObject* pyfunc, double isovalue)
{
std::vector<double> vertices;
std::vector<size_t> polygons;
// Copy the lower and upper coordinates to a C array.
std::array<double,3> lower_;
std::array<double,3> upper_;
for(int i=0; i<3; ++i)
{
PyObject* l = PySequence_GetItem(lower, i);
if(l == NULL)
throw std::runtime_error("len(lower) < 3");
PyObject* u = PySequence_GetItem(upper, i);
if(u == NULL)
{
Py_DECREF(l);
throw std::runtime_error("len(upper) < 3");
}
lower_[i] = PyFloat_AsDouble(l);
upper_[i] = PyFloat_AsDouble(u);
Py_DECREF(l);
Py_DECREF(u);
if(lower_[i]==-1.0 || upper_[i]==-1.0)
{
if(PyErr_Occurred())
throw std::runtime_error("unknown error");
}
}
auto pyfunc_to_cfunc = [&](double x, double y, double z) -> double {
PyObject* res = PyObject_CallFunction(pyfunc, "(d,d,d)", x, y, z);
if(res == NULL)
return 0.0;
double result = PyFloat_AsDouble(res);
Py_DECREF(res);
return result;
};
// Marching cubes.
mc::marching_cubes(lower_, upper_, numx, numy, numz, pyfunc_to_cfunc, isovalue, vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
PyObject* marching_cubes(PyArrayObject* arr, double isovalue)
{
if(PyArray_NDIM(arr) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported.");
// Prepare data.
npy_intp* shape = PyArray_DIMS(arr);
std::array<long, 3> lower{0, 0, 0};
std::array<long, 3> upper{shape[0]-1, shape[1]-1, shape[2]-1};
long numx = upper[0] - lower[0] + 1;
long numy = upper[1] - lower[1] + 1;
long numz = upper[2] - lower[2] + 1;
std::vector<double> vertices;
std::vector<size_t> polygons;
auto pyarray_to_cfunc = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x, y, z};
return PyArray_SafeGet<double>(arr, c);
};
// Marching cubes.
mc::marching_cubes(lower, upper, numx, numy, numz, pyarray_to_cfunc, isovalue,
vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
PyObject* marching_cubes_color_func(PyObject* lower, PyObject* upper,
int numx, int numy, int numz, PyObject* pyfunc_sdf, PyObject* pyfunc_r, PyObject* pyfunc_g, PyObject* pyfunc_b, double isovalue)
{
std::vector<double> vertices;
std::vector<size_t> polygons;
// Copy the lower and upper coordinates to a C array.
std::array<double,3> lower_;
std::array<double,3> upper_;
for(int i=0; i<3; ++i)
{
PyObject* l = PySequence_GetItem(lower, i);
if(l == NULL)
throw std::runtime_error("len(lower) < 3");
PyObject* u = PySequence_GetItem(upper, i);
if(u == NULL)
{
Py_DECREF(l);
throw std::runtime_error("len(upper) < 3");
}
lower_[i] = PyFloat_AsDouble(l);
upper_[i] = PyFloat_AsDouble(u);
Py_DECREF(l);
Py_DECREF(u);
if(lower_[i]==-1.0 || upper_[i]==-1.0)
{
if(PyErr_Occurred())
throw std::runtime_error("unknown error");
}
}
auto pyfunc_to_cfunc_sdf = [&](double x, double y, double z) -> double {
PyObject* res = PyObject_CallFunction(pyfunc_sdf, "(d,d,d)", x, y, z);
if(res == NULL)
return 0.0;
double result = PyFloat_AsDouble(res);
Py_DECREF(res);
return result;
};
auto pyfunc_to_cfunc_color = [&](double x, double y, double z) -> Eigen::Vector3d {
Eigen::Vector3d col;
{ // red
PyObject* res = PyObject_CallFunction(pyfunc_r, "(d,d,d)", x, y, z);
if(res == NULL) return Eigen::Vector3d::Zero();
col.x() = PyFloat_AsDouble(res);
Py_DECREF(res);
}
{ // green
PyObject* res = PyObject_CallFunction(pyfunc_g, "(d,d,d)", x, y, z);
if(res == NULL) return Eigen::Vector3d::Zero();
col.y() = PyFloat_AsDouble(res);
Py_DECREF(res);
}
{ // blue
PyObject* res = PyObject_CallFunction(pyfunc_b, "(d,d,d)", x, y, z);
if(res == NULL) return Eigen::Vector3d::Zero();
col.z() = PyFloat_AsDouble(res);
Py_DECREF(res);
}
return col;
};
// Marching cubes.
mc::marching_cubes_color(lower_, upper_, numx, numy, numz, pyfunc_to_cfunc_sdf, pyfunc_to_cfunc_color, isovalue, vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
PyObject* marching_cubes_color(PyArrayObject* arr_sdf, PyArrayObject* arr_color, double isovalue)
{
if(PyArray_NDIM(arr_sdf) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported (SDF).");
if(PyArray_NDIM(arr_color) != 4)
throw std::runtime_error("Only four-dimensional arrays are supported (RGB).");
// Prepare data.
npy_intp* shape = PyArray_DIMS(arr_sdf);
npy_intp* shape_color = PyArray_DIMS(arr_color);
if(shape[0] != shape_color[0] || shape[1] != shape_color[1] || shape[2] != shape_color[2])
throw std::runtime_error("SDF and RGB volumes do not match in size.");
if(shape_color[3] != 3)
throw std::runtime_error("Only RGB colors are supported.");
std::array<long, 3> lower{0, 0, 0};
std::array<long, 3> upper{shape[0]-1, shape[1]-1, shape[2]-1};
long numx = upper[0] - lower[0] + 1;
long numy = upper[1] - lower[1] + 1;
long numz = upper[2] - lower[2] + 1;
std::vector<double> vertices;
std::vector<size_t> polygons;
auto pyarray_to_cfunc_sdf = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x, y, z};
return PyArray_SafeGet<double>(arr_sdf, c);
};
auto pyarray_to_cfunc_color = [&](long x, long y, long z) -> Eigen::Vector3d {
Eigen::Vector3d color;
npy_intp c_r[4] = {x, y, z, 0};
npy_intp c_g[4] = {x, y, z, 1};
npy_intp c_b[4] = {x, y, z, 2};
color.x() = PyArray_SafeGet<double>(arr_color, c_r);
color.y() = PyArray_SafeGet<double>(arr_color, c_g);
color.z() = PyArray_SafeGet<double>(arr_color, c_b);
return color;
};
// Marching cubes.
mc::marching_cubes_color(lower, upper, numx, numy, numz, pyarray_to_cfunc_sdf, pyarray_to_cfunc_color, isovalue, vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
PyObject* marching_cubes_super_sampling(PyArrayObject* arrX, PyArrayObject* arrY, PyArrayObject* arrZ, double isovalue)
{
if(PyArray_NDIM(arrX) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported.");
if(PyArray_NDIM(arrY) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported.");
if(PyArray_NDIM(arrZ) != 3)
throw std::runtime_error("Only three-dimensional arrays are supported.");
// Prepare data.
npy_intp* shapeX = PyArray_DIMS(arrX);
npy_intp* shapeY = PyArray_DIMS(arrY);
npy_intp* shapeZ = PyArray_DIMS(arrZ);
npy_intp shape[3] = {shapeY[0], shapeX[1], shapeX[2]};
npy_intp supersamples[3] = { (shapeX[0]-shape[0]) / (shape[0]-1), // samples along the edge (between two voxel nodes)
(shapeY[1]-shape[1]) / (shape[1]-1),
(shapeZ[2]-shape[2]) / (shape[2]-1)};
if(shapeX[2] != shapeY[2] || shapeX[1] != shapeZ[1] || shapeY[0] != shapeZ[0])
throw std::runtime_error("X,Y,Z supersampled sdf arrays need to be compatible.");
if( shapeX[0] != shape[0] + (shape[0]-1)*supersamples[0]
|| shapeY[1] != shape[1] + (shape[1]-1)*supersamples[1]
|| shapeZ[2] != shape[2] + (shape[2]-1)*supersamples[2])
throw std::runtime_error("X,Y,Z supersampled sdf arrays need to be compatible (must be dim + supersamples*(dim-1) !).");
std::array<long, 3> lower{0, 0, 0};
std::array<long, 3> upper{shape[0]-1, shape[1]-1, shape[2]-1};
long numx = upper[0] - lower[0] + 1;
long numy = upper[1] - lower[1] + 1;
long numz = upper[2] - lower[2] + 1;
std::vector<double> vertices;
std::vector<size_t> polygons;
auto pyarray_to_cfunc = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x * (supersamples[0]+1), y, z};
return PyArray_SafeGet<double>(arrX, c);
};
auto pyarray_to_cfuncX = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x, y, z};
return PyArray_SafeGet<double>(arrX, c);
};
auto pyarray_to_cfuncY = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x, y, z};
return PyArray_SafeGet<double>(arrY, c);
};
auto pyarray_to_cfuncZ = [&](long x, long y, long z) -> double {
const npy_intp c[3] = {x, y, z};
return PyArray_SafeGet<double>(arrZ, c);
};
// Marching cubes.
mc::marching_cubes_super_sampling(lower, upper, numx, numy, numz, supersamples[0], supersamples[1], supersamples[2], pyarray_to_cfunc, pyarray_to_cfuncX, pyarray_to_cfuncY, pyarray_to_cfuncZ, isovalue,
vertices, polygons);
// Copy the result to two Python ndarrays.
npy_intp size_vertices = vertices.size();
npy_intp size_polygons = polygons.size();
PyArrayObject* verticesarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_vertices, PyArray_DOUBLE));
PyArrayObject* polygonsarr = reinterpret_cast<PyArrayObject*>(PyArray_SimpleNew(1, &size_polygons, PyArray_ULONG));
std::vector<double>::const_iterator it = vertices.begin();
for(int i=0; it!=vertices.end(); ++i, ++it)
*reinterpret_cast<double*>(PyArray_GETPTR1(verticesarr, i)) = *it;
std::vector<size_t>::const_iterator it2 = polygons.begin();
for(int i=0; it2!=polygons.end(); ++i, ++it2)
*reinterpret_cast<unsigned long*>(PyArray_GETPTR1(polygonsarr, i)) = *it2;
PyObject* res = Py_BuildValue("(O,O)", verticesarr, polygonsarr);
Py_XDECREF(verticesarr);
Py_XDECREF(polygonsarr);
return res;
}
================================================
FILE: external/PyMarchingCubes/marching_cubes/src/pywrapper.h
================================================
#ifndef _PYWRAPPER_H
#define _PYWRAPPER_H
#include <Python.h>
#include "pyarraymodule.h"
#include <vector>
PyObject* marching_cubes(PyArrayObject* arr, double isovalue);
PyObject* marching_cubes_func(PyObject* lower, PyObject* upper,
int numx, int numy, int numz, PyObject* f, double isovalue);
PyObject* marching_cubes_color(PyArrayObject* arr_sdf, PyArrayObject* arr_color, double isovalue);
PyObject* marching_cubes_color_func(PyObject* lower, PyObject* upper,
int numx, int numy, int numz, PyObject* f_sdf, PyObject* f_color_r, PyObject* f_color_g, PyObject* f_color_b, double isovalue);
PyObject* marching_cubes_super_sampling(PyArrayObject* arrX, PyArrayObject* arrY, PyArrayObject* arrZ, double isovalue);
#endif // _PYWRAPPER_H
================================================
FILE: external/PyMarchingCubes/requirements.txt
================================================
numpy>=1.11.3
scipy>=1.0.0
cython>=0.25.0
================================================
FILE: external/PyMarchingCubes/setup.py
================================================
# -*- encoding: utf-8 -*-
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
from setuptools import setup
from setuptools.extension import Extension
class lazy_cythonize(list):
"""
Lazy evaluate extension definition, to allow correct requirements install.
"""
def __init__(self, callback):
super(lazy_cythonize, self).__init__()
self._list, self.callback = None, callback
def c_list(self):
if self._list is None:
self._list = self.callback()
return self._list
def __iter__(self):
for e in self.c_list():
yield e
def __getitem__(self, ii):
return self.c_list()[ii]
def __len__(self):
return len(self.c_list())
def extensions():
from Cython.Build import cythonize
import numpy
numpy_include_dir = numpy.get_include()
eigen_include_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'eigen3'))
marching_cubes_module = Extension(
"marching_cubes._mcubes",
[
"marching_cubes/src/_mcubes.pyx",
"marching_cubes/src/pywrapper.cpp",
"marching_cubes/src/marchingcubes.cpp"
],
language="c++",
extra_compile_args=['-std=c++11', '-Wall'],
include_dirs=[numpy_include_dir, eigen_include_dir],
depends=[
"marching_cubes/src/marchingcubes.h",
"marching_cubes/src/pyarray_symbol.h",
"marching_cubes/src/pyarraymodule.h",
"marching_cubes/src/pywrapper.h"
],
)
return cythonize([marching_cubes_module])
setup(
name="PyMarchingCubes",
version="0.0.2",
description="Marching cubes for Python",
author="Justus Thies (PyMCubes: Pablo Márquez Neila)",
url="https://github.com/JustusThies/PyMarchingCubes",
license="BSD 3-clause",
long_description="""
Marching cubes for Python
""",
classifiers=[
"Development Status :: 5 - Production/Stable",
"Environment :: Console",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: BSD License",
"Natural Language :: English",
"Operating System :: OS Independent",
"Programming Language :: C++",
"Programming Language :: Python",
"Topic :: Multimedia :: Graphics :: 3D Modeling",
"Topic :: Scientific/Engineering :: Image Recognition",
],
packages=["marching_cubes"],
ext_modules=lazy_cythonize(extensions),
requires=['numpy', 'Cython', 'PyCollada'],
setup_requires=['numpy', 'Cython']
)
================================================
FILE: external/PyMarchingCubes/test_mcubes.py
================================================
import pytest
import numpy as np
from numpy.testing import assert_array_equal, assert_allclose
import marching_cubes as mcubes
def test_empty():
levelset = np.zeros((50, 50, 50))
vertices, triangles = mcubes.marching_cubes(levelset, 0.5)
assert len(vertices) == len(triangles) == 0
def test_sphere():
x, y, z = np.mgrid[:100, :100, :100]
u = (x - 50)**2 + (y - 50)**2 + (z - 50)**2 - 25**2
def func(x, y, z):
return (x - 50)**2 + (y - 50)**2 + (z - 50)**2 - 25**2
vertices1, triangles1 = mcubes.marching_cubes(u, 0.0)
vertices2, triangles2 = mcubes.marching_cubes_func(
(0, 0, 0),
(99, 99, 99),
100, 100, 100,
func, 0.0
)
assert_allclose(vertices1, vertices2)
assert_array_equal(triangles1, triangles2)
def test_no_duplicates():
def sphere(x, y, z):
return np.sqrt((x - 4)**2 + (y - 4)**2 + (z - 4)**2) - 4
vertices, _ = mcubes.marching_cubes_func((2, 2, 2), (9, 9, 9), 20, 20, 20, sphere, 0)
assert len(vertices) == len(np.unique(vertices, axis=0))
def test_export():
u = np.zeros((10, 10, 10))
u[2:-2, 2:-2, 2:-2] = 1.0
vertices, triangles = mcubes.marching_cubes(u, 0.5)
mcubes.export_obj(vertices, triangles, "output/test.obj")
mcubes.export_off(vertices, triangles, "output/test.off")
mcubes.export_mesh(vertices, triangles, "output/test.dae")
def test_invalid_input():
def func(x, y, z):
return x**2 + y**2 + z**2 - 1
mcubes.marching_cubes_func((-1.5, -1.5, -1.5), (1.5, 1.5, 1.5), 10, 10, 10, func, 0)
with pytest.raises(ValueError):
mcubes.marching_cubes_func((0, 0, 0), (0, 0, 0), 10, 10, 10, func, 0)
with pytest.raises(ValueError):
mcubes.marching_cubes_func((-1.5, -1.5, -1.5), (1.5, 1.5, 1.5), 1, 10, 10, func, 0)
with pytest.raises(Exception):
mcubes.marching_cubes_func((-1.5, -1.5), (1.5, 1.5, 1.5), 10, 10, 10, func, 0)
with pytest.raises(Exception):
mcubes.marching_cubes_func((-1.5, -1.5, -1.5), (1.5, 1.5), 10, 10, 10, func, 0)
================================================
FILE: external/PyMarchingCubes/test_smoothing.py
================================================
import pytest
import numpy as np
import marching_cubes as mcubes
def test_sphere():
# Create sphere with radius 25 centered at (50, 50, 50)
x, y, z = np.mgrid[:100, :100, :100]
levelset = np.sqrt((x - 50)**2 + (y - 50)**2 + (z - 50)**2) - 25
# vertices, triangles = mcubes.marching_cubes(levelset, 0)
# mcubes.export_obj(vertices, triangles, 'sphere1.obj')
binary_levelset = levelset > 0
smoothed_levelset = mcubes.smooth(
binary_levelset,
method='constrained',
max_iters=500,
rel_tol=1e-4
)
vertices, _ = mcubes.marching_cubes(smoothed_levelset, 0.0)
# Check all vertices have same distance to (50, 50, 50)
dist = np.sqrt(np.sum((vertices - [50, 50, 50])**2, axis=1))
assert dist.min() > 24.5 and dist.max() < 25.5
assert np.all(np.abs(smoothed_levelset - levelset) < 1)
assert np.all((smoothed_levelset > 0) == binary_levelset)
def test_gaussian_smoothing():
# Create sphere with radius 25 centered at (50, 50, 50)
x, y, z = np.mgrid[:100, :100, :100]
levelset = np.sqrt((x - 50)**2 + (y - 50)**2 + (z - 50)**2) - 25
binary_levelset = levelset > 0
smoothed_levelset = mcubes.smooth(
binary_levelset,
method='gaussian',
sigma=3
)
vertices, _ = mcubes.marching_cubes(smoothed_levelset, 0.0)
# Check all vertices have same distance to (50, 50, 50)
dist = np.sqrt(np.sum((vertices - [50, 50, 50])**2, axis=1))
assert dist.min() > 24 and dist.max() < 25
def test_wrong_ndim():
binary_levelset = np.random.uniform(size=(10)) < 0.5
with pytest.raises(ValueError):
mcubes.smooth(
binary_levelset,
method='constrained',
max_iters=500,
rel_tol=1e-4
)
binary_levelset = np.random.uniform(size=(10, 10, 10, 10)) < 0.5
with pytest.raises(ValueError):
mcubes.smooth(
binary_levelset,
method='constrained',
max_iters=500,
rel_tol=1e-4
)
def test_wrong_method():
with pytest.raises(ValueError):
mcubes.smooth(
np.zeros((10, 10), dtype=np.bool_),
method='wrong',
max_iters=500,
rel_tol=1e-4
)
def test_circle():
x, y = np.mgrid[:100, :100]
levelset = np.sqrt((x - 50)**2 + (y - 50)**2) - 25
binary_levelset = levelset > 0
smoothed_levelset = mcubes.smooth(
binary_levelset,
max_iters=500,
rel_tol=1e-4
)
assert np.all(np.abs(smoothed_levelset - levelset) < 1)
assert np.all((smoothed_levelset > 0) == binary_levelset)
# if __name__ == '__main__':
# # logging.basicConfig(level=logging.DEBUG)
# test_circle()
# test_sphere()
# test_large_sphere()
================================================
FILE: external/eigen3/Eigen/Cholesky
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLESKY_MODULE_H
#define EIGEN_CHOLESKY_MODULE_H
#include "Core"
#include "Jacobi"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Cholesky_Module Cholesky module
*
*
*
* This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
* Those decompositions are also accessible via the following methods:
* - MatrixBase::llt()
* - MatrixBase::ldlt()
* - SelfAdjointView::llt()
* - SelfAdjointView::ldlt()
*
* \code
* #include <Eigen/Cholesky>
* \endcode
*/
#include "src/Cholesky/LLT.h"
#include "src/Cholesky/LDLT.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Cholesky/LLT_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLESKY_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
================================================
FILE: external/eigen3/Eigen/CholmodSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
#define EIGEN_CHOLMODSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <cholmod.h>
}
/** \ingroup Support_modules
* \defgroup CholmodSupport_Module CholmodSupport module
*
* This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the two following main factorization classes:
* - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
* - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
*
* For the sake of completeness, this module also propose the two following classes:
* - class CholmodSimplicialLLT
* - class CholmodSimplicialLDLT
* Note that these classes does not bring any particular advantage compared to the built-in
* SimplicialLLT and SimplicialLDLT factorization classes.
*
* \code
* #include <Eigen/CholmodSupport>
* \endcode
*
* In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
* The dependencies depend on how cholmod has been compiled.
* For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
*
*/
#include "src/CholmodSupport/CholmodSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
================================================
FILE: external/eigen3/Eigen/Core
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CORE_H
#define EIGEN_CORE_H
// first thing Eigen does: stop the compiler from committing suicide
#include "src/Core/util/DisableStupidWarnings.h"
#if defined(__CUDACC__) && !defined(EIGEN_NO_CUDA)
#define EIGEN_CUDACC __CUDACC__
#endif
#if defined(__CUDA_ARCH__) && !defined(EIGEN_NO_CUDA)
#define EIGEN_CUDA_ARCH __CUDA_ARCH__
#endif
#if defined(__CUDACC_VER_MAJOR__) && (__CUDACC_VER_MAJOR__ >= 9)
#define EIGEN_CUDACC_VER ((__CUDACC_VER_MAJOR__ * 10000) + (__CUDACC_VER_MINOR__ * 100))
#elif defined(__CUDACC_VER__)
#define EIGEN_CUDACC_VER __CUDACC_VER__
#else
#define EIGEN_CUDACC_VER 0
#endif
// Handle NVCC/CUDA/SYCL
#if defined(__CUDACC__) || defined(__SYCL_DEVICE_ONLY__)
// Do not try asserts on CUDA and SYCL!
#ifndef EIGEN_NO_DEBUG
#define EIGEN_NO_DEBUG
#endif
#ifdef EIGEN_INTERNAL_DEBUGGING
#undef EIGEN_INTERNAL_DEBUGGING
#endif
#ifdef EIGEN_EXCEPTIONS
#undef EIGEN_EXCEPTIONS
#endif
// All functions callable from CUDA code must be qualified with __device__
#ifdef __CUDACC__
// Do not try to vectorize on CUDA and SYCL!
#ifndef EIGEN_DONT_VECTORIZE
#define EIGEN_DONT_VECTORIZE
#endif
#define EIGEN_DEVICE_FUNC __host__ __device__
// We need cuda_runtime.h to ensure that that EIGEN_USING_STD_MATH macro
// works properly on the device side
#include <cuda_runtime.h>
#else
#define EIGEN_DEVICE_FUNC
#endif
#else
#define EIGEN_DEVICE_FUNC
#endif
// When compiling CUDA device code with NVCC, pull in math functions from the
// global namespace. In host mode, and when device doee with clang, use the
// std versions.
#if defined(__CUDA_ARCH__) && defined(__NVCC__)
#define EIGEN_USING_STD_MATH(FUNC) using ::FUNC;
#else
#define EIGEN_USING_STD_MATH(FUNC) using std::FUNC;
#endif
#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(__CUDA_ARCH__) && !defined(EIGEN_EXCEPTIONS) && !defined(EIGEN_USE_SYCL)
#define EIGEN_EXCEPTIONS
#endif
#ifdef EIGEN_EXCEPTIONS
#include <new>
#endif
// then include this file where all our macros are defined. It's really important to do it first because
// it's where we do all the alignment settings (platform detection and honoring the user's will if he
// defined e.g. EIGEN_DONT_ALIGN) so it needs to be done before we do anything with vectorization.
#include "src/Core/util/Macros.h"
// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6)
#pragma GCC optimize ("-fno-ipa-cp-clone")
#endif
#include <complex>
// this include file manages BLAS and MKL related macros
// and inclusion of their respective header files
#include "src/Core/util/MKL_support.h"
// if alignment is disabled, then disable vectorization. Note: EIGEN_MAX_ALIGN_BYTES is the proper check, it takes into
// account both the user's will (EIGEN_MAX_ALIGN_BYTES,EIGEN_DONT_ALIGN) and our own platform checks
#if EIGEN_MAX_ALIGN_BYTES==0
#ifndef EIGEN_DONT_VECTORIZE
#define EIGEN_DONT_VECTORIZE
#endif
#endif
#if EIGEN_COMP_MSVC
#include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
#if (EIGEN_COMP_MSVC >= 1500) // 2008 or later
// Remember that usage of defined() in a #define is undefined by the standard.
// a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
#if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64
#define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
#endif
#endif
#else
// Remember that usage of defined() in a #define is undefined by the standard
#if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) )
#define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC
#endif
#endif
#ifndef EIGEN_DONT_VECTORIZE
#if defined (EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
// Defines symbols for compile-time detection of which instructions are
// used.
// EIGEN_VECTORIZE_YY is defined if and only if the instruction set YY is used
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_SSE
#define EIGEN_VECTORIZE_SSE2
// Detect sse3/ssse3/sse4:
// gcc and icc defines __SSE3__, ...
// there is no way to know about this on msvc. You can define EIGEN_VECTORIZE_SSE* if you
// want to force the use of those instructions with msvc.
#ifdef __SSE3__
#define EIGEN_VECTORIZE_SSE3
#endif
#ifdef __SSSE3__
#define EIGEN_VECTORIZE_SSSE3
#endif
#ifdef __SSE4_1__
#define EIGEN_VECTORIZE_SSE4_1
#endif
#ifdef __SSE4_2__
#define EIGEN_VECTORIZE_SSE4_2
#endif
#ifdef __AVX__
#define EIGEN_VECTORIZE_AVX
#define EIGEN_VECTORIZE_SSE3
#define EIGEN_VECTORIZE_SSSE3
#define EIGEN_VECTORIZE_SSE4_1
#define EIGEN_VECTORIZE_SSE4_2
#endif
#ifdef __AVX2__
#define EIGEN_VECTORIZE_AVX2
#endif
#ifdef __FMA__
#define EIGEN_VECTORIZE_FMA
#endif
#if defined(__AVX512F__) && defined(EIGEN_ENABLE_AVX512)
#define EIGEN_VECTORIZE_AVX512
#define EIGEN_VECTORIZE_AVX2
#define EIGEN_VECTORIZE_AVX
#define EIGEN_VECTORIZE_FMA
#ifdef __AVX512DQ__
#define EIGEN_VECTORIZE_AVX512DQ
#endif
#ifdef __AVX512ER__
#define EIGEN_VECTORIZE_AVX512ER
#endif
#endif
// include files
// This extern "C" works around a MINGW-w64 compilation issue
// https://sourceforge.net/tracker/index.php?func=detail&aid=3018394&group_id=202880&atid=983354
// In essence, intrin.h is included by windows.h and also declares intrinsics (just as emmintrin.h etc. below do).
// However, intrin.h uses an extern "C" declaration, and g++ thus complains of duplicate declarations
// with conflicting linkage. The linkage for intrinsics doesn't matter, but at that stage the compiler doesn't know;
// so, to avoid compile errors when windows.h is included after Eigen/Core, ensure intrinsics are extern "C" here too.
// notice that since these are C headers, the extern "C" is theoretically needed anyways.
extern "C" {
// In theory we should only include immintrin.h and not the other *mmintrin.h header files directly.
// Doing so triggers some issues with ICC. However old gcc versions seems to not have this file, thus:
#if EIGEN_COMP_ICC >= 1110
#include <immintrin.h>
#else
#include <mmintrin.h>
#include <emmintrin.h>
#include <xmmintrin.h>
#ifdef EIGEN_VECTORIZE_SSE3
#include <pmmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSSE3
#include <tmmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSE4_1
#include <smmintrin.h>
#endif
#ifdef EIGEN_VECTORIZE_SSE4_2
#include <nmmintrin.h>
#endif
#if defined(EIGEN_VECTORIZE_AVX) || defined(EIGEN_VECTORIZE_AVX512)
#include <immintrin.h>
#endif
#endif
} // end extern "C"
#elif defined __VSX__
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_VSX
#include <altivec.h>
// We need to #undef all these ugly tokens defined in <altivec.h>
// => use __vector instead of vector
#undef bool
#undef vector
#undef pixel
#elif defined __ALTIVEC__
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_ALTIVEC
#include <altivec.h>
// We need to #undef all these ugly tokens defined in <altivec.h>
// => use __vector instead of vector
#undef bool
#undef vector
#undef pixel
#elif (defined __ARM_NEON) || (defined __ARM_NEON__)
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_NEON
#include <arm_neon.h>
#elif (defined __s390x__ && defined __VEC__)
#define EIGEN_VECTORIZE
#define EIGEN_VECTORIZE_ZVECTOR
#include <vecintrin.h>
#endif
#endif
#if defined(__F16C__) && !defined(EIGEN_COMP_CLANG)
// We can use the optimized fp16 to float and float to fp16 conversion routines
#define EIGEN_HAS_FP16_C
#endif
#if defined __CUDACC__
#define EIGEN_VECTORIZE_CUDA
#include <vector_types.h>
#if EIGEN_CUDACC_VER >= 70500
#define EIGEN_HAS_CUDA_FP16
#endif
#endif
#if defined EIGEN_HAS_CUDA_FP16
#include <host_defines.h>
#include <cuda_fp16.h>
#endif
#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
#define EIGEN_HAS_OPENMP
#endif
#ifdef EIGEN_HAS_OPENMP
#include <omp.h>
#endif
// MSVC for windows mobile does not have the errno.h file
#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
#define EIGEN_HAS_ERRNO
#endif
#ifdef EIGEN_HAS_ERRNO
#include <cerrno>
#endif
#include <cstddef>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <functional>
#include <iosfwd>
#include <cstring>
#include <string>
#include <limits>
#include <climits> // for CHAR_BIT
// for min/max:
#include <algorithm>
// for std::is_nothrow_move_assignable
#ifdef EIGEN_INCLUDE_TYPE_TRAITS
#include <type_traits>
#endif
// for outputting debug info
#ifdef EIGEN_DEBUG_ASSIGN
#include <iostream>
#endif
// required for __cpuid, needs to be included after cmath
#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
#include <intrin.h>
#endif
/** \brief Namespace containing all symbols from the %Eigen library. */
namespace Eigen {
inline static const char *SimdInstructionSetsInUse(void) {
#if defined(EIGEN_VECTORIZE_AVX512)
return "AVX512, FMA, AVX2, AVX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_AVX)
return "AVX SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_2)
return "SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2";
#elif defined(EIGEN_VECTORIZE_SSE4_1)
return "SSE, SSE2, SSE3, SSSE3, SSE4.1";
#elif defined(EIGEN_VECTORIZE_SSSE3)
return "SSE, SSE2, SSE3, SSSE3";
#elif defined(EIGEN_VECTORIZE_SSE3)
return "SSE, SSE2, SSE3";
#elif defined(EIGEN_VECTORIZE_SSE2)
return "SSE, SSE2";
#elif defined(EIGEN_VECTORIZE_ALTIVEC)
return "AltiVec";
#elif defined(EIGEN_VECTORIZE_VSX)
return "VSX";
#elif defined(EIGEN_VECTORIZE_NEON)
return "ARM NEON";
#elif defined(EIGEN_VECTORIZE_ZVECTOR)
return "S390X ZVECTOR";
#else
return "None";
#endif
}
} // end namespace Eigen
#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
// This will generate an error message:
#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
#endif
namespace Eigen {
// we use size_t frequently and we'll never remember to prepend it with std:: everytime just to
// ensure QNX/QCC support
using std::size_t;
// gcc 4.6.0 wants std:: for ptrdiff_t
using std::ptrdiff_t;
}
/** \defgroup Core_Module Core module
* This is the main module of Eigen providing dense matrix and vector support
* (both fixed and dynamic size) with all the features corresponding to a BLAS library
* and much more...
*
* \code
* #include <Eigen/Core>
* \endcode
*/
#include "src/Core/util/Constants.h"
#include "src/Core/util/Meta.h"
#include "src/Core/util/ForwardDeclarations.h"
#include "src/Core/util/StaticAssert.h"
#include "src/Core/util/XprHelper.h"
#include "src/Core/util/Memory.h"
#include "src/Core/NumTraits.h"
#include "src/Core/MathFunctions.h"
#include "src/Core/GenericPacketMath.h"
#include "src/Core/MathFunctionsImpl.h"
#include "src/Core/arch/Default/ConjHelper.h"
#if defined EIGEN_VECTORIZE_AVX512
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX512/PacketMath.h"
#include "src/Core/arch/AVX512/MathFunctions.h"
#elif defined EIGEN_VECTORIZE_AVX
// Use AVX for floats and doubles, SSE for integers
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX/MathFunctions.h"
#include "src/Core/arch/AVX/Complex.h"
#include "src/Core/arch/AVX/TypeCasting.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#elif defined EIGEN_VECTORIZE_SSE
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
#include "src/Core/arch/AltiVec/PacketMath.h"
#include "src/Core/arch/AltiVec/MathFunctions.h"
#include "src/Core/arch/AltiVec/Complex.h"
#elif defined EIGEN_VECTORIZE_NEON
#include "src/Core/arch/NEON/PacketMath.h"
#include "src/Core/arch/NEON/MathFunctions.h"
#include "src/Core/arch/NEON/Complex.h"
#elif defined EIGEN_VECTORIZE_ZVECTOR
#include "src/Core/arch/ZVector/PacketMath.h"
#include "src/Core/arch/ZVector/MathFunctions.h"
#include "src/Core/arch/ZVector/Complex.h"
#endif
// Half float support
#include "src/Core/arch/CUDA/Half.h"
#include "src/Core/arch/CUDA/PacketMathHalf.h"
#include "src/Core/arch/CUDA/TypeCasting.h"
#if defined EIGEN_VECTORIZE_CUDA
#include "src/Core/arch/CUDA/PacketMath.h"
#include "src/Core/arch/CUDA/MathFunctions.h"
#endif
#include "src/Core/arch/Default/Settings.h"
#include "src/Core/functors/TernaryFunctors.h"
#include "src/Core/functors/BinaryFunctors.h"
#include "src/Core/functors/UnaryFunctors.h"
#include "src/Core/functors/NullaryFunctors.h"
#include "src/Core/functors/StlFunctors.h"
#include "src/Core/functors/AssignmentFunctors.h"
// Specialized functors to enable the processing of complex numbers
// on CUDA devices
#include "src/Core/arch/CUDA/Complex.h"
#include "src/Core/IO.h"
#include "src/Core/DenseCoeffsBase.h"
#include "src/Core/DenseBase.h"
#include "src/Core/MatrixBase.h"
#include "src/Core/EigenBase.h"
#include "src/Core/Product.h"
#include "src/Core/CoreEvaluators.h"
#include "src/Core/AssignEvaluator.h"
#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
// at least confirmed with Doxygen 1.5.5 and 1.5.6
#include "src/Core/Assign.h"
#endif
#include "src/Core/ArrayBase.h"
#include "src/Core/util/BlasUtil.h"
#include "src/Core/DenseStorage.h"
#include "src/Core/NestByValue.h"
// #include "src/Core/ForceAlignedAccess.h"
#include "src/Core/ReturnByValue.h"
#include "src/Core/NoAlias.h"
#include "src/Core/PlainObjectBase.h"
#include "src/Core/Matrix.h"
#include "src/Core/Array.h"
#include "src/Core/CwiseTernaryOp.h"
#include "src/Core/CwiseBinaryOp.h"
#include "src/Core/CwiseUnaryOp.h"
#include "src/Core/CwiseNullaryOp.h"
#include "src/Core/CwiseUnaryView.h"
#include "src/Core/SelfCwiseBinaryOp.h"
#include "src/Core/Dot.h"
#include "src/Core/StableNorm.h"
#include "src/Core/Stride.h"
#include "src/Core/MapBase.h"
#include "src/Core/Map.h"
#include "src/Core/Ref.h"
#include "src/Core/Block.h"
#include "src/Core/VectorBlock.h"
#include "src/Core/Transpose.h"
#include "src/Core/DiagonalMatrix.h"
#include "src/Core/Diagonal.h"
#include "src/Core/DiagonalProduct.h"
#include "src/Core/Redux.h"
#include "src/Core/Visitor.h"
#include "src/Core/Fuzzy.h"
#include "src/Core/Swap.h"
#include "src/Core/CommaInitializer.h"
#include "src/Core/GeneralProduct.h"
#include "src/Core/Solve.h"
#include "src/Core/Inverse.h"
#include "src/Core/SolverBase.h"
#include "src/Core/PermutationMatrix.h"
#include "src/Core/Transpositions.h"
#include "src/Core/TriangularMatrix.h"
#include "src/Core/SelfAdjointView.h"
#include "src/Core/products/GeneralBlockPanelKernel.h"
#include "src/Core/products/Parallelizer.h"
#include "src/Core/ProductEvaluators.h"
#include "src/Core/products/GeneralMatrixVector.h"
#include "src/Core/products/GeneralMatrixMatrix.h"
#include "src/Core/SolveTriangular.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
#include "src/Core/products/SelfadjointMatrixVector.h"
#include "src/Core/products/SelfadjointMatrixMatrix.h"
#include "src/Core/products/SelfadjointProduct.h"
#include "src/Core/products/SelfadjointRank2Update.h"
#include "src/Core/products/TriangularMatrixVector.h"
#include "src/Core/products/TriangularMatrixMatrix.h"
#include "src/Core/products/TriangularSolverMatrix.h"
#include "src/Core/products/TriangularSolverVector.h"
#include "src/Core/BandMatrix.h"
#include "src/Core/CoreIterators.h"
#include "src/Core/ConditionEstimator.h"
#include "src/Core/BooleanRedux.h"
#include "src/Core/Select.h"
#include "src/Core/VectorwiseOp.h"
#include "src/Core/Random.h"
#include "src/Core/Replicate.h"
#include "src/Core/Reverse.h"
#include "src/Core/ArrayWrapper.h"
#ifdef EIGEN_USE_BLAS
#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
#include "src/Core/products/GeneralMatrixVector_BLAS.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
#include "src/Core/products/TriangularMatrixVector_BLAS.h"
#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
#endif // EIGEN_USE_BLAS
#ifdef EIGEN_USE_MKL_VML
#include "src/Core/Assign_MKL.h"
#endif
#include "src/Core/GlobalFunctions.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CORE_H
================================================
FILE: external/eigen3/Eigen/Dense
================================================
#include "Core"
#include "LU"
#include "Cholesky"
#include "QR"
#include "SVD"
#include "Geometry"
#include "Eigenvalues"
================================================
FILE: external/eigen3/Eigen/Eigen
================================================
#include "Dense"
#include "Sparse"
================================================
FILE: external/eigen3/Eigen/Eigenvalues
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_EIGENVALUES_MODULE_H
#define EIGEN_EIGENVALUES_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include "Cholesky"
#include "Jacobi"
#include "Householder"
#include "LU"
#include "Geometry"
/** \defgroup Eigenvalues_Module Eigenvalues module
*
*
*
* This module mainly provides various eigenvalue solvers.
* This module also provides some MatrixBase methods, including:
* - MatrixBase::eigenvalues(),
* - MatrixBase::operatorNorm()
*
* \code
* #include <Eigen/Eigenvalues>
* \endcode
*/
#include "src/misc/RealSvd2x2.h"
#include "src/Eigenvalues/Tridiagonalization.h"
#include "src/Eigenvalues/RealSchur.h"
#include "src/Eigenvalues/EigenSolver.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
#include "src/Eigenvalues/HessenbergDecomposition.h"
#include "src/Eigenvalues/ComplexSchur.h"
#include "src/Eigenvalues/ComplexEigenSolver.h"
#include "src/Eigenvalues/RealQZ.h"
#include "src/Eigenvalues/GeneralizedEigenSolver.h"
#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Eigenvalues/RealSchur_LAPACKE.h"
#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_EIGENVALUES_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
================================================
FILE: external/eigen3/Eigen/Geometry
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_GEOMETRY_MODULE_H
#define EIGEN_GEOMETRY_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include "SVD"
#include "LU"
#include <limits>
/** \defgroup Geometry_Module Geometry module
*
* This module provides support for:
* - fixed-size homogeneous transformations
* - translation, scaling, 2D and 3D rotations
* - \link Quaternion quaternions \endlink
* - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
* - orthognal vector generation (\ref MatrixBase::unitOrthogonal)
* - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes \endlink
* - \link AlignedBox axis aligned bounding boxes \endlink
* - \link umeyama least-square transformation fitting \endlink
*
* \code
* #include <Eigen/Geometry>
* \endcode
*/
#include "src/Geometry/OrthoMethods.h"
#include "src/Geometry/EulerAngles.h"
#include "src/Geometry/Homogeneous.h"
#include "src/Geometry/RotationBase.h"
#include "src/Geometry/Rotation2D.h"
#include "src/Geometry/Quaternion.h"
#include "src/Geometry/AngleAxis.h"
#include "src/Geometry/Transform.h"
#include "src/Geometry/Translation.h"
#include "src/Geometry/Scaling.h"
#include "src/Geometry/Hyperplane.h"
#include "src/Geometry/ParametrizedLine.h"
#include "src/Geometry/AlignedBox.h"
#include "src/Geometry/Umeyama.h"
// Use the SSE optimized version whenever possible. At the moment the
// SSE version doesn't compile when AVX is enabled
#if defined EIGEN_VECTORIZE_SSE && !defined EIGEN_VECTORIZE_AVX
#include "src/Geometry/arch/Geometry_SSE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_GEOMETRY_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
================================================
FILE: external/eigen3/Eigen/Householder
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_HOUSEHOLDER_MODULE_H
#define EIGEN_HOUSEHOLDER_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Householder_Module Householder module
* This module provides Householder transformations.
*
* \code
* #include <Eigen/Householder>
* \endcode
*/
#include "src/Householder/Householder.h"
#include "src/Householder/HouseholderSequence.h"
#include "src/Householder/BlockHouseholder.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_HOUSEHOLDER_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
================================================
FILE: external/eigen3/Eigen/IterativeLinearSolvers
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
*
* This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
* Those solvers are accessible via the following classes:
* - ConjugateGradient for selfadjoint (hermitian) matrices,
* - LeastSquaresConjugateGradient for rectangular least-square problems,
* - BiCGSTAB for general square matrices.
*
* These iterative solvers are associated with some preconditioners:
* - IdentityPreconditioner - not really useful
* - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
* - IncompleteLUT - incomplete LU factorization with dual thresholding
*
* Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
*
\code
#include <Eigen/IterativeLinearSolvers>
\endcode
*/
#include "src/IterativeLinearSolvers/SolveWithGuess.h"
#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
#include "src/IterativeLinearSolvers/ConjugateGradient.h"
#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
#include "src/IterativeLinearSolvers/BiCGSTAB.h"
#include "src/IterativeLinearSolvers/IncompleteLUT.h"
#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
================================================
FILE: external/eigen3/Eigen/Jacobi
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_JACOBI_MODULE_H
#define EIGEN_JACOBI_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Jacobi_Module Jacobi module
* This module provides Jacobi and Givens rotations.
*
* \code
* #include <Eigen/Jacobi>
* \endcode
*
* In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
* - MatrixBase::applyOnTheLeft()
* - MatrixBase::applyOnTheRight().
*/
#include "src/Jacobi/Jacobi.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_JACOBI_MODULE_H
/* vim: set filetype=cpp et sw=2 ts=2 ai: */
================================================
FILE: external/eigen3/Eigen/LU
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LU_MODULE_H
#define EIGEN_LU_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup LU_Module LU module
* This module includes %LU decomposition and related notions such as matrix inversion and determinant.
* This module defines the following MatrixBase methods:
* - MatrixBase::inverse()
* - MatrixBase::determinant()
*
* \code
* #include <Eigen/LU>
* \endcode
*/
#include "src/misc/Kernel.h"
#include "src/misc/Image.h"
#include "src/LU/FullPivLU
gitextract_wl6wrwv6/ ├── .gitignore ├── LICENSE ├── README.md ├── build_external.sh ├── config.py ├── dataset/ │ ├── dataset.py │ └── generate_dataset.py ├── external/ │ ├── PyMarchingCubes/ │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── LICENSE │ │ ├── MANIFEST.in │ │ ├── README.md │ │ ├── examples/ │ │ │ ├── .gitignore │ │ │ └── spheres.py │ │ ├── marching_cubes/ │ │ │ ├── __init__.py │ │ │ ├── exporter.py │ │ │ ├── numpy_smoothing.py │ │ │ ├── smoothing.py │ │ │ └── src/ │ │ │ ├── _mcubes.pyx │ │ │ ├── marchingcubes.cpp │ │ │ ├── marchingcubes.h │ │ │ ├── pyarray_symbol.h │ │ │ ├── pyarraymodule.h │ │ │ ├── pywrapper.cpp │ │ │ └── pywrapper.h │ │ ├── requirements.txt │ │ ├── setup.py │ │ ├── test_mcubes.py │ │ └── test_smoothing.py │ ├── eigen3/ │ │ └── Eigen/ │ │ ├── Cholesky │ │ ├── CholmodSupport │ │ ├── Core │ │ ├── Dense │ │ ├── Eigen │ │ ├── Eigenvalues │ │ ├── Geometry │ │ ├── Householder │ │ ├── IterativeLinearSolvers │ │ ├── Jacobi │ │ ├── LU │ │ ├── MetisSupport │ │ ├── OrderingMethods │ │ ├── PaStiXSupport │ │ ├── PardisoSupport │ │ ├── QR │ │ ├── QtAlignedMalloc │ │ ├── SPQRSupport │ │ ├── SVD │ │ ├── Sparse │ │ ├── SparseCholesky │ │ ├── SparseCore │ │ ├── SparseLU │ │ ├── SparseQR │ │ ├── StdDeque │ │ ├── StdList │ │ ├── StdVector │ │ ├── SuperLUSupport │ │ ├── UmfPackSupport │ │ └── src/ │ │ ├── Cholesky/ │ │ │ ├── LDLT.h │ │ │ ├── LLT.h │ │ │ └── LLT_LAPACKE.h │ │ ├── CholmodSupport/ │ │ │ └── CholmodSupport.h │ │ ├── Core/ │ │ │ ├── Array.h │ │ │ ├── ArrayBase.h │ │ │ ├── ArrayWrapper.h │ │ │ ├── Assign.h │ │ │ ├── AssignEvaluator.h │ │ │ ├── Assign_MKL.h │ │ │ ├── BandMatrix.h │ │ │ ├── Block.h │ │ │ ├── BooleanRedux.h │ │ │ ├── CommaInitializer.h │ │ │ ├── ConditionEstimator.h │ │ │ ├── CoreEvaluators.h │ │ │ ├── CoreIterators.h │ │ │ ├── CwiseBinaryOp.h │ │ │ ├── CwiseNullaryOp.h │ │ │ ├── CwiseTernaryOp.h │ │ │ ├── CwiseUnaryOp.h │ │ │ ├── CwiseUnaryView.h │ │ │ ├── DenseBase.h │ │ │ ├── DenseCoeffsBase.h │ │ │ ├── DenseStorage.h │ │ │ ├── Diagonal.h │ │ │ ├── DiagonalMatrix.h │ │ │ ├── DiagonalProduct.h │ │ │ ├── Dot.h │ │ │ ├── EigenBase.h │ │ │ ├── ForceAlignedAccess.h │ │ │ ├── Fuzzy.h │ │ │ ├── GeneralProduct.h │ │ │ ├── GenericPacketMath.h │ │ │ ├── GlobalFunctions.h │ │ │ ├── IO.h │ │ │ ├── Inverse.h │ │ │ ├── Map.h │ │ │ ├── MapBase.h │ │ │ ├── MathFunctions.h │ │ │ ├── MathFunctionsImpl.h │ │ │ ├── Matrix.h │ │ │ ├── MatrixBase.h │ │ │ ├── NestByValue.h │ │ │ ├── NoAlias.h │ │ │ ├── NumTraits.h │ │ │ ├── PermutationMatrix.h │ │ │ ├── PlainObjectBase.h │ │ │ ├── Product.h │ │ │ ├── ProductEvaluators.h │ │ │ ├── Random.h │ │ │ ├── Redux.h │ │ │ ├── Ref.h │ │ │ ├── Replicate.h │ │ │ ├── ReturnByValue.h │ │ │ ├── Reverse.h │ │ │ ├── Select.h │ │ │ ├── SelfAdjointView.h │ │ │ ├── SelfCwiseBinaryOp.h │ │ │ ├── Solve.h │ │ │ ├── SolveTriangular.h │ │ │ ├── SolverBase.h │ │ │ ├── StableNorm.h │ │ │ ├── Stride.h │ │ │ ├── Swap.h │ │ │ ├── Transpose.h │ │ │ ├── Transpositions.h │ │ │ ├── TriangularMatrix.h │ │ │ ├── VectorBlock.h │ │ │ ├── VectorwiseOp.h │ │ │ ├── Visitor.h │ │ │ ├── arch/ │ │ │ │ ├── AVX/ │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ ├── AVX512/ │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── AltiVec/ │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── CUDA/ │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── Half.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ ├── PacketMathHalf.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ ├── Default/ │ │ │ │ │ ├── ConjHelper.h │ │ │ │ │ └── Settings.h │ │ │ │ ├── NEON/ │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ └── PacketMath.h │ │ │ │ ├── SSE/ │ │ │ │ │ ├── Complex.h │ │ │ │ │ ├── MathFunctions.h │ │ │ │ │ ├── PacketMath.h │ │ │ │ │ └── TypeCasting.h │ │ │ │ └── ZVector/ │ │ │ │ ├── Complex.h │ │ │ │ ├── MathFunctions.h │ │ │ │ └── PacketMath.h │ │ │ ├── functors/ │ │ │ │ ├── AssignmentFunctors.h │ │ │ │ ├── BinaryFunctors.h │ │ │ │ ├── NullaryFunctors.h │ │ │ │ ├── StlFunctors.h │ │ │ │ ├── TernaryFunctors.h │ │ │ │ └── UnaryFunctors.h │ │ │ ├── products/ │ │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ │ ├── GeneralMatrixMatrix.h │ │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h │ │ │ │ ├── GeneralMatrixVector.h │ │ │ │ ├── GeneralMatrixVector_BLAS.h │ │ │ │ ├── Parallelizer.h │ │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h │ │ │ │ ├── SelfadjointMatrixVector.h │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h │ │ │ │ ├── SelfadjointProduct.h │ │ │ │ ├── SelfadjointRank2Update.h │ │ │ │ ├── TriangularMatrixMatrix.h │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h │ │ │ │ ├── TriangularMatrixVector.h │ │ │ │ ├── TriangularMatrixVector_BLAS.h │ │ │ │ ├── TriangularSolverMatrix.h │ │ │ │ ├── TriangularSolverMatrix_BLAS.h │ │ │ │ └── TriangularSolverVector.h │ │ │ └── util/ │ │ │ ├── BlasUtil.h │ │ │ ├── Constants.h │ │ │ ├── DisableStupidWarnings.h │ │ │ ├── ForwardDeclarations.h │ │ │ ├── MKL_support.h │ │ │ ├── Macros.h │ │ │ ├── Memory.h │ │ │ ├── Meta.h │ │ │ ├── NonMPL2.h │ │ │ ├── ReenableStupidWarnings.h │ │ │ ├── StaticAssert.h │ │ │ └── XprHelper.h │ │ ├── Eigenvalues/ │ │ │ ├── ComplexEigenSolver.h │ │ │ ├── ComplexSchur.h │ │ │ ├── ComplexSchur_LAPACKE.h │ │ │ ├── EigenSolver.h │ │ │ ├── GeneralizedEigenSolver.h │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ │ ├── HessenbergDecomposition.h │ │ │ ├── MatrixBaseEigenvalues.h │ │ │ ├── RealQZ.h │ │ │ ├── RealSchur.h │ │ │ ├── RealSchur_LAPACKE.h │ │ │ ├── SelfAdjointEigenSolver.h │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h │ │ │ └── Tridiagonalization.h │ │ ├── Geometry/ │ │ │ ├── AlignedBox.h │ │ │ ├── AngleAxis.h │ │ │ ├── EulerAngles.h │ │ │ ├── Homogeneous.h │ │ │ ├── Hyperplane.h │ │ │ ├── OrthoMethods.h │ │ │ ├── ParametrizedLine.h │ │ │ ├── Quaternion.h │ │ │ ├── Rotation2D.h │ │ │ ├── RotationBase.h │ │ │ ├── Scaling.h │ │ │ ├── Transform.h │ │ │ ├── Translation.h │ │ │ ├── Umeyama.h │ │ │ └── arch/ │ │ │ └── Geometry_SSE.h │ │ ├── Householder/ │ │ │ ├── BlockHouseholder.h │ │ │ ├── Householder.h │ │ │ └── HouseholderSequence.h │ │ ├── IterativeLinearSolvers/ │ │ │ ├── BasicPreconditioners.h │ │ │ ├── BiCGSTAB.h │ │ │ ├── ConjugateGradient.h │ │ │ ├── IncompleteCholesky.h │ │ │ ├── IncompleteLUT.h │ │ │ ├── IterativeSolverBase.h │ │ │ ├── LeastSquareConjugateGradient.h │ │ │ └── SolveWithGuess.h │ │ ├── Jacobi/ │ │ │ └── Jacobi.h │ │ ├── LU/ │ │ │ ├── Determinant.h │ │ │ ├── FullPivLU.h │ │ │ ├── InverseImpl.h │ │ │ ├── PartialPivLU.h │ │ │ ├── PartialPivLU_LAPACKE.h │ │ │ └── arch/ │ │ │ └── Inverse_SSE.h │ │ ├── MetisSupport/ │ │ │ └── MetisSupport.h │ │ ├── OrderingMethods/ │ │ │ ├── Amd.h │ │ │ ├── Eigen_Colamd.h │ │ │ └── Ordering.h │ │ ├── PaStiXSupport/ │ │ │ └── PaStiXSupport.h │ │ ├── PardisoSupport/ │ │ │ └── PardisoSupport.h │ │ ├── QR/ │ │ │ ├── ColPivHouseholderQR.h │ │ │ ├── ColPivHouseholderQR_LAPACKE.h │ │ │ ├── CompleteOrthogonalDecomposition.h │ │ │ ├── FullPivHouseholderQR.h │ │ │ ├── HouseholderQR.h │ │ │ └── HouseholderQR_LAPACKE.h │ │ ├── SPQRSupport/ │ │ │ └── SuiteSparseQRSupport.h │ │ ├── SVD/ │ │ │ ├── BDCSVD.h │ │ │ ├── JacobiSVD.h │ │ │ ├── JacobiSVD_LAPACKE.h │ │ │ ├── SVDBase.h │ │ │ └── UpperBidiagonalization.h │ │ ├── SparseCholesky/ │ │ │ ├── SimplicialCholesky.h │ │ │ └── SimplicialCholesky_impl.h │ │ ├── SparseCore/ │ │ │ ├── AmbiVector.h │ │ │ ├── CompressedStorage.h │ │ │ ├── ConservativeSparseSparseProduct.h │ │ │ ├── MappedSparseMatrix.h │ │ │ ├── SparseAssign.h │ │ │ ├── SparseBlock.h │ │ │ ├── SparseColEtree.h │ │ │ ├── SparseCompressedBase.h │ │ │ ├── SparseCwiseBinaryOp.h │ │ │ ├── SparseCwiseUnaryOp.h │ │ │ ├── SparseDenseProduct.h │ │ │ ├── SparseDiagonalProduct.h │ │ │ ├── SparseDot.h │ │ │ ├── SparseFuzzy.h │ │ │ ├── SparseMap.h │ │ │ ├── SparseMatrix.h │ │ │ ├── SparseMatrixBase.h │ │ │ ├── SparsePermutation.h │ │ │ ├── SparseProduct.h │ │ │ ├── SparseRedux.h │ │ │ ├── SparseRef.h │ │ │ ├── SparseSelfAdjointView.h │ │ │ ├── SparseSolverBase.h │ │ │ ├── SparseSparseProductWithPruning.h │ │ │ ├── SparseTranspose.h │ │ │ ├── SparseTriangularView.h │ │ │ ├── SparseUtil.h │ │ │ ├── SparseVector.h │ │ │ ├── SparseView.h │ │ │ └── TriangularSolver.h │ │ ├── SparseLU/ │ │ │ ├── SparseLU.h │ │ │ ├── SparseLUImpl.h │ │ │ ├── SparseLU_Memory.h │ │ │ ├── SparseLU_Structs.h │ │ │ ├── SparseLU_SupernodalMatrix.h │ │ │ ├── SparseLU_Utils.h │ │ │ ├── SparseLU_column_bmod.h │ │ │ ├── SparseLU_column_dfs.h │ │ │ ├── SparseLU_copy_to_ucol.h │ │ │ ├── SparseLU_gemm_kernel.h │ │ │ ├── SparseLU_heap_relax_snode.h │ │ │ ├── SparseLU_kernel_bmod.h │ │ │ ├── SparseLU_panel_bmod.h │ │ │ ├── SparseLU_panel_dfs.h │ │ │ ├── SparseLU_pivotL.h │ │ │ ├── SparseLU_pruneL.h │ │ │ └── SparseLU_relax_snode.h │ │ ├── SparseQR/ │ │ │ └── SparseQR.h │ │ ├── StlSupport/ │ │ │ ├── StdDeque.h │ │ │ ├── StdList.h │ │ │ ├── StdVector.h │ │ │ └── details.h │ │ ├── SuperLUSupport/ │ │ │ └── SuperLUSupport.h │ │ ├── UmfPackSupport/ │ │ │ └── UmfPackSupport.h │ │ ├── misc/ │ │ │ ├── Image.h │ │ │ ├── Kernel.h │ │ │ ├── RealSvd2x2.h │ │ │ ├── blas.h │ │ │ ├── lapack.h │ │ │ ├── lapacke.h │ │ │ └── lapacke_mangling.h │ │ └── plugins/ │ │ ├── ArrayCwiseBinaryOps.h │ │ ├── ArrayCwiseUnaryOps.h │ │ ├── BlockMethods.h │ │ ├── CommonCwiseBinaryOps.h │ │ ├── CommonCwiseUnaryOps.h │ │ ├── MatrixCwiseBinaryOps.h │ │ └── MatrixCwiseUnaryOps.h │ └── qview/ │ ├── Makefile │ ├── Occnet.h │ ├── R3Model.cpp │ ├── R3Quadric.cpp │ ├── R3Quadric.h │ ├── R3QuadricSet.cpp │ ├── R3QuadricSet.h │ └── qview.cpp ├── generate_data.sh ├── multi_sdf/ │ ├── evaluate.py │ ├── loss.py │ └── model.py ├── nnutils/ │ ├── blocks.py │ ├── geometry.py │ ├── metrics.py │ ├── mlp.py │ └── node_proc.py ├── node_sampler/ │ ├── evaluate.py │ ├── loss.py │ └── model.py ├── resources/ │ ├── env.yml │ └── requirements.txt ├── scripts/ │ ├── make_watertight.sh │ ├── process_mesh_local.sh │ └── screened_poisson.mlx ├── train_graph.py ├── train_graph.sh ├── train_shape.py ├── train_shape.sh ├── utils/ │ ├── __init__.py │ ├── embedder.py │ ├── gradient_utils.py │ ├── line_mesh.py │ ├── mesh_proc.py │ ├── parser_utils.py │ ├── pcd_utils.py │ ├── query.py │ ├── sdf_utils.py │ ├── time_statistics.py │ └── viz_utils.py ├── viz.py └── viz.sh
Showing preview only (265K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3021 symbols across 306 files)
FILE: config.py
function print_hyperparams (line 114) | def print_hyperparams(data, experiment_name):
FILE: dataset/dataset.py
class MeshDataset (line 17) | class MeshDataset(Dataset):
method __init__ (line 18) | def __init__(
method _load (line 70) | def _load(self):
method load_pts_file (line 79) | def load_pts_file(path):
method load_grid (line 89) | def load_grid(path):
method __len__ (line 102) | def __len__(self):
method unpack (line 105) | def unpack(self, x):
method _load_data (line 116) | def _load_data(self, data_dir):
method _get_cached_data (line 141) | def _get_cached_data(self, index):
method __getitem__ (line 153) | def __getitem__(self, index):
method get_metadata (line 214) | def get_metadata(self, index):
FILE: dataset/generate_dataset.py
function process_one (line 15) | def process_one(mesh_path, mesh_directory, dataset_directory, skip_exist...
function generate_meshes (line 42) | def generate_meshes(mesh_directory, dataset_directory, mesh_format, skip...
FILE: external/PyMarchingCubes/examples/spheres.py
function sphere_tsdf (line 36) | def sphere_tsdf(xyz, x_scale, y_scale, z_scale):
FILE: external/PyMarchingCubes/marching_cubes/exporter.py
function export_obj (line 5) | def export_obj(vertices, triangles, filename):
function export_off (line 23) | def export_off(vertices, triangles, filename):
function export_mesh (line 46) | def export_mesh(vertices, triangles, filename, mesh_name="mcubes_mesh"):
FILE: external/PyMarchingCubes/marching_cubes/numpy_smoothing.py
function signed_distance_function (line 51) | def signed_distance_function(binary_arr: np.ndarray) -> np.ndarray:
function energy (line 63) | def energy(arr: np.ndarray) -> np.ndarray:
function solve_jacobi (line 69) | def solve_jacobi(
function numpy_smooth (line 95) | def numpy_smooth(binary_array: np.ndarray, max_iters: int = 500) -> np.n...
FILE: external/PyMarchingCubes/marching_cubes/smoothing.py
function _build_variable_indices (line 22) | def _build_variable_indices(band: np.ndarray) -> np.ndarray:
function _buildq3d (line 29) | def _buildq3d(variable_indices: np.ndarray):
function _buildq2d (line 93) | def _buildq2d(variable_indices: np.ndarray):
function _jacobi (line 145) | def _jacobi(
function signed_distance_function (line 194) | def signed_distance_function(
function smooth_constrained (line 220) | def smooth_constrained(
function smooth_gaussian (line 272) | def smooth_gaussian(binary_array: np.ndarray, sigma: float = 3) -> np.nd...
function smooth (line 277) | def smooth(
FILE: external/PyMarchingCubes/marching_cubes/src/marchingcubes.cpp
type mc (line 4) | namespace mc
type private_ (line 287) | namespace private_
function mc_isovalue_interpolation (line 290) | double mc_isovalue_interpolation(double isovalue, double f1, double f2,
function mc_add_vertex (line 299) | void mc_add_vertex(double x1, double y1, double z1, double c2,
FILE: external/PyMarchingCubes/marching_cubes/src/marchingcubes.h
type Eigen (line 12) | typedef Eigen::Matrix<double, 6, 1> Vector6d;
function namespace (line 20) | namespace private_
FILE: external/PyMarchingCubes/marching_cubes/src/pywrapper.cpp
function PyObject (line 10) | PyObject* marching_cubes_func(PyObject* lower, PyObject* upper,
function PyObject (line 76) | PyObject* marching_cubes(PyArrayObject* arr, double isovalue)
function PyObject (line 125) | PyObject* marching_cubes_color_func(PyObject* lower, PyObject* upper,
function PyObject (line 217) | PyObject* marching_cubes_color(PyArrayObject* arr_sdf, PyArrayObject* ar...
function PyObject (line 284) | PyObject* marching_cubes_super_sampling(PyArrayObject* arrX, PyArrayObje...
FILE: external/PyMarchingCubes/setup.py
class lazy_cythonize (line 10) | class lazy_cythonize(list):
method __init__ (line 15) | def __init__(self, callback):
method c_list (line 19) | def c_list(self):
method __iter__ (line 25) | def __iter__(self):
method __getitem__ (line 29) | def __getitem__(self, ii):
method __len__ (line 32) | def __len__(self):
function extensions (line 36) | def extensions():
FILE: external/PyMarchingCubes/test_mcubes.py
function test_empty (line 10) | def test_empty():
function test_sphere (line 18) | def test_sphere():
function test_no_duplicates (line 37) | def test_no_duplicates():
function test_export (line 46) | def test_export():
function test_invalid_input (line 57) | def test_invalid_input():
FILE: external/PyMarchingCubes/test_smoothing.py
function test_sphere (line 10) | def test_sphere():
function test_gaussian_smoothing (line 37) | def test_gaussian_smoothing():
function test_wrong_ndim (line 57) | def test_wrong_ndim():
function test_wrong_method (line 80) | def test_wrong_method():
function test_circle (line 91) | def test_circle():
FILE: external/eigen3/Eigen/src/Cholesky/LDLT.h
function namespace (line 16) | namespace Eigen {
function namespace (line 287) | namespace internal {
function Upper (line 454) | struct ldlt_inplace<Upper>
type TriangularView (line 474) | typedef const TriangularView<const typename
function MatrixL (line 475) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 476) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
type TriangularView (line 482) | typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
function MatrixL (line 483) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 484) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
type typename (line 535) | typedef typename TranspositionType::StorageIndex IndexType;
FILE: external/eigen3/Eigen/src/Cholesky/LLT.h
function namespace (line 13) | namespace Eigen {
function namespace (line 228) | namespace internal {
type typename (line 372) | typedef typename NumTraits<Scalar>::Real RealScalar;
type TriangularView (line 397) | typedef const TriangularView<const typename
function MatrixL (line 398) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 399) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
function inplace_decomposition (line 400) | static bool inplace_decomposition(MatrixType& m)
type TriangularView (line 407) | typedef const TriangularView<const MatrixType, Upper> MatrixU;
function MatrixL (line 408) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 409) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
function inplace_decomposition (line 410) | static bool inplace_decomposition(MatrixType& m)
FILE: external/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h
function namespace (line 13) | namespace Eigen {
function cholmod_sparse (line 105) | cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>...
function cholmod_sparse (line 112) | cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>...
type typename (line 137) | typedef typename Derived::Scalar Scalar;
type CholmodMode (line 162) | enum CholmodMode {
type typename (line 182) | typedef typename MatrixType::Scalar Scalar;
type typename (line 183) | typedef typename MatrixType::RealScalar RealScalar;
type MatrixType (line 184) | typedef MatrixType CholMatrixType;
type typename (line 185) | typedef typename MatrixType::StorageIndex StorageIndex;
function StorageIndex (line 217) | inline StorageIndex cols() const { return internal::convert_index<Storag...
function analyzePattern (line 245) | void analyzePattern(const MatrixType& matrix)
function factorize (line 267) | void factorize(const MatrixType& matrix)
function Scalar (line 348) | Scalar determinant() const
function Base (line 445) | CholmodSimplicialLLT(const MatrixType& matrix) : Base()
function Base (line 496) | CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
function Base (line 545) | CholmodSupernodalLLT(const MatrixType& matrix) : Base()
function Base (line 596) | CholmodDecomposition(const MatrixType& matrix) : Base()
function setMode (line 604) | void setMode(CholmodMode mode)
FILE: external/eigen3/Eigen/src/Core/Array.h
function namespace (line 13) | namespace Eigen {
function enum (line 51) | EIGEN_DENSE_PUBLIC_INTERFACE(Array)
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 168) | EIGEN_STRONG_INLINE explicit Array(const T& x)
function EIGEN_STRONG_INLINE (line 176) | EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
function Base (line 228) | Array(const Array& other)
type PrivateType (line 233) | struct PrivateType {}
function EIGEN_STRONG_INLINE (line 239) | EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
type internal (line 255) | struct internal
FILE: external/eigen3/Eigen/src/Core/ArrayBase.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/ArrayWrapper.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Assign.h
function namespace (line 15) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/AssignEvaluator.h
function namespace (line 15) | namespace Eigen {
type typename (line 347) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type unaligned_dense_assignment_loop (line 372) | struct unaligned_dense_assignment_loop
type typename (line 400) | typedef typename Kernel::Scalar Scalar;
type typename (line 401) | typedef typename Kernel::PacketType PacketType;
type typename (line 427) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 428) | typedef typename Kernel::PacketType PacketType;
function run (line 451) | void run(Kernel &kernel)
type typename (line 467) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 477) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 478) | typedef typename Kernel::AssignmentTraits Traits;
type typename (line 506) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 520) | typedef typename Kernel::Scalar Scalar;
type typename (line 521) | typedef typename Kernel::PacketType PacketType;
type typename (line 568) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 569) | typedef typename Kernel::PacketType PacketType;
type typename (line 600) | typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
type SrcEvaluatorTypeT (line 604) | typedef SrcEvaluatorTypeT SrcEvaluatorType;
type typename (line 605) | typedef typename DstEvaluatorType::Scalar Scalar;
type copy_using_evaluator_traits (line 606) | typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT...
type typename (line 607) | typedef typename AssignmentTraits::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 625) | EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() { return m_dst; }
function assignCoeff (line 629) | void assignCoeff(Index row, Index col)
function assignCoeff (line 635) | void assignCoeff(Index index)
function assignCoeffByOuterInner (line 641) | void assignCoeffByOuterInner(Index outer, Index inner)
function assignPacket (line 650) | void assignPacket(Index row, Index col)
function assignPacket (line 656) | void assignPacket(Index index)
function assignPacketByOuterInner (line 662) | void assignPacketByOuterInner(Index outer, Index inner)
function Index (line 669) | Index rowIndexByOuterInner(Index outer, Index inner)
function Index (line 678) | Index colIndexByOuterInner(Index outer, Index inner)
function EIGEN_DEVICE_FUNC (line 687) | EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
function resize_if_allowed (line 706) | void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Fun...
type evaluator (line 728) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type generic_dense_assignment_kernel (line 738) | typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorTyp...
function call_dense_assignment_loop (line 745) | void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
type Dense2Dense (line 760) | struct Dense2Dense {}
type EigenBase2EigenBase (line 761) | struct EigenBase2EigenBase {}
type EigenBase2EigenBase (line 763) | typedef EigenBase2EigenBase Kind;
type AssignmentKind (line 764) | struct AssignmentKind
type Dense2Dense (line 764) | typedef Dense2Dense Kind;
function call_assignment (line 780) | void call_assignment(Dst& dst, const Src& src)
function call_assignment (line 786) | void call_assignment(const Dst& dst, const Src& src)
function call_assignment_no_alias (line 819) | void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
function call_assignment_no_alias (line 840) | void call_assignment_no_alias(Dst& dst, const Src& src)
function call_assignment_no_alias_no_transpose (line 847) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, con...
function call_assignment_no_alias_no_transpose (line 858) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
type Assignment (line 888) | struct Assignment
FILE: external/eigen3/Eigen/src/Core/Assign_MKL.h
function namespace (line 37) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/BandMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 103) | typedef typename internal::conditional<Conjugate,
function typename (line 115) | const typename DiagonalIntReturnType<N>::Type diagonal() const
function DenseMatrixType (line 145) | DenseMatrixType toDenseMatrix() const
type Dense (line 181) | typedef Dense StorageKind;
type Eigen (line 182) | typedef Eigen::Index StorageIndex;
type Matrix (line 195) | typedef Matrix<Scalar,DataRowsAtCompileTime,ColsAtCompileTime,Options
type typename (line 203) | typedef typename internal::traits<BandMatrix>::Scalar Scalar;
type typename (line 204) | typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
type typename (line 205) | typedef typename internal::traits<BandMatrix>::CoefficientsType Coeffici...
function CoefficientsType (line 226) | inline CoefficientsType& coeffs() { return m_coeffs; }
type typename (line 243) | typedef typename _CoefficientsType::StorageKind StorageKind;
type typename (line 244) | typedef typename _CoefficientsType::StorageIndex StorageIndex;
type _CoefficientsType (line 257) | typedef _CoefficientsType CoefficientsType;
type typename (line 266) | typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType C...
type typename (line 267) | typedef typename internal::traits<BandMatrixWrapper>::StorageIndex Stora...
type typename (line 315) | typedef typename Base::StorageIndex StorageIndex;
type BandShape (line 331) | struct BandShape {}
type AssignmentKind (line 347) | struct AssignmentKind
type EigenBase2EigenBase (line 347) | typedef EigenBase2EigenBase Kind;
FILE: external/eigen3/Eigen/src/Core/Block.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 117) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 127) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
type typename (line 158) | typedef typename XprType::StorageIndex StorageIndex;
function Impl (line 162) | inline BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC inline BlockImpl(XprType& xpr, Index startRow, Index s...
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC
function namespace (line 169) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/BooleanRedux.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/CommaInitializer.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 116) | EIGEN_DEVICE_FUNC
FILE: external/eigen3/Eigen/src/Core/ConditionEstimator.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/CoreEvaluators.h
function namespace (line 16) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 243) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC evaluator() {}
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& t) : m_argImpl...
type typename (line 277) | typedef typename XprType::Scalar Scalar;
type typename (line 278) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 281) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 287) | CoeffReturnType coeff(Index index) const
function typename (line 299) | typename XprType::Scalar& coeffRef(Index index)
function PacketType (line 306) | PacketType packet(Index row, Index col) const
function PacketType (line 313) | PacketType packet(Index index) const
function writePacket (line 320) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 327) | void writePacket(Index index, const PacketType& x)
function EIGEN_STRONG_INLINE (line 349) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 351) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 352) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 382) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 388) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 390) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 438) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 445) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
type typename (line 459) | typedef typename internal::remove_all<PlainObjectType>::type PlainObject...
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
type typename (line 478) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_STRONG_INLINE (line 481) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 488) | EIGEN_STRONG_INLINE
function PacketType (line 496) | PacketType packet(IndexType row, IndexType col) const
function PacketType (line 503) | PacketType packet(IndexType index) const
function explicit (line 530) | explicit unary_evaluator(const XprType& op)
type typename (line 538) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 541) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 547) | CoeffReturnType coeff(Index index) const
function PacketType (line 554) | PacketType packet(Index row, Index col) const
function PacketType (line 561) | PacketType packet(Index index) const
type ternary_evaluator (line 579) | typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > ...
function EIGEN_DEVICE_FUNC (line 581) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 622) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 625) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 631) | CoeffReturnType coeff(Index index) const
function PacketType (line 638) | PacketType packet(Index row, Index col) const
function PacketType (line 647) | PacketType packet(Index index) const
type binary_evaluator (line 669) | typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
function EIGEN_DEVICE_FUNC (line 671) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
type typename (line 708) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 711) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 717) | CoeffReturnType coeff(Index index) const
function PacketType (line 724) | PacketType packet(Index row, Index col) const
function PacketType (line 732) | PacketType packet(Index index) const
function EIGEN_DEVICE_FUNC (line 760) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type typename (line 768) | typedef typename XprType::Scalar Scalar;
type typename (line 769) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 772) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 778) | CoeffReturnType coeff(Index index) const
type Derived (line 810) | typedef Derived XprType;
type typename (line 811) | typedef typename XprType::PointerType PointerType;
type typename (line 812) | typedef typename XprType::Scalar Scalar;
type typename (line 813) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 832) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 838) | CoeffReturnType coeff(Index index) const
function PacketType (line 857) | PacketType packet(Index row, Index col) const
function PacketType (line 865) | PacketType packet(Index index) const
function writePacket (line 872) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 880) | void writePacket(Index index, const PacketType& x)
type typename (line 900) | typedef typename XprType::Scalar Scalar;
type typename (line 902) | typedef typename packet_traits<Scalar>::type PacketScalar;
function EIGEN_DEVICE_FUNC (line 923) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
function EIGEN_DEVICE_FUNC (line 941) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& ref)
type typename (line 956) | typedef typename XprType::Scalar Scalar;
type typename (line 958) | typedef typename packet_traits<Scalar>::type PacketScalar;
type block_evaluator (line 995) | typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block...
function EIGEN_DEVICE_FUNC (line 996) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& block) : block_evalu...
function EIGEN_DEVICE_FUNC (line 1009) | EIGEN_DEVICE_FUNC explicit block_evaluator(const XprType& block)
function CoeffReturnType (line 1036) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1042) | CoeffReturnType coeff(Index index) const
function PacketType (line 1067) | PacketType packet(Index row, Index col) const
function PacketType (line 1074) | PacketType packet(Index index) const
function writePacket (line 1085) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1092) | void writePacket(Index index, const PacketType& x)
type typename (line 1118) | typedef typename XprType::Scalar Scalar;
type typename (line 1156) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1159) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1168) | CoeffReturnType coeff(Index index) const
type typename (line 1190) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 1194) | typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
type typename (line 1195) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
function CoeffReturnType (line 1227) | CoeffReturnType coeff(Index index) const
function PacketType (line 1239) | PacketType packet(Index row, Index col) const
function PacketType (line 1253) | PacketType packet(Index index) const
type typename (line 1277) | typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
type typename (line 1278) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
type typename (line 1279) | typedef typename ArgType::Scalar InputScalar;
type typename (line 1280) | typedef typename XprType::Scalar Scalar;
type typename (line 1284) | typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)>...
function EIGEN_DEVICE_FUNC (line 1294) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
type typename (line 1301) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function Scalar (line 1304) | const Scalar coeff(Index i, Index j) const
function Scalar (line 1313) | const Scalar coeff(Index index) const
type typename (line 1336) | typedef typename remove_all<typename XprType::NestedExpressionType>::typ...
function EIGEN_DEVICE_FUNC (line 1343) | EIGEN_DEVICE_FUNC explicit evaluator_wrapper_base(const ArgType& arg) : ...
type typename (line 1345) | typedef typename ArgType::Scalar Scalar;
type typename (line 1346) | typedef typename ArgType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1349) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1355) | CoeffReturnType coeff(Index index) const
function PacketType (line 1374) | PacketType packet(Index row, Index col) const
function PacketType (line 1381) | PacketType packet(Index index) const
function writePacket (line 1388) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1395) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1410) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
function EIGEN_DEVICE_FUNC (line 1421) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& wrapper)
type typename (line 1437) | typedef typename XprType::Scalar Scalar;
type typename (line 1438) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1477) | CoeffReturnType coeff(Index index) const
function PacketType (line 1497) | PacketType packet(Index row, Index col) const
function PacketType (line 1512) | PacketType packet(Index index) const
function writePacket (line 1520) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1537) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 1570) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& diagonal)
type typename (line 1575) | typedef typename XprType::Scalar Scalar;
type typename (line 1576) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1579) | CoeffReturnType coeff(Index row, Index) const
function CoeffReturnType (line 1585) | CoeffReturnType coeff(Index index) const
function EvalToTemp (line 1634) | EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
type typename (line 1664) | typedef typename ArgType::PlainObject PlainObject;
type evaluator (line 1665) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 1667) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
function EIGEN_DEVICE_FUNC (line 1674) | EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
FILE: external/eigen3/Eigen/src/Core/CoreIterators.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/CwiseBinaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 88) | typedef typename internal::remove_all<LhsType>::type Lhs;
type typename (line 89) | typedef typename internal::remove_all<RhsType>::type Rhs;
type typename (line 91) | typedef typename CwiseBinaryOpImpl<
type typename (line 99) | typedef typename internal::ref_selector<RhsType>::type RhsNested;
type typename (line 100) | typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
type typename (line 101) | typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
FILE: external/eigen3/Eigen/src/Core/CwiseNullaryOp.h
function namespace (line 13) | namespace Eigen {
function if (line 137) | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
function namespace (line 739) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/CwiseTernaryOp.h
function namespace (line 15) | namespace Eigen {
type typename (line 91) | typedef typename internal::remove_all<Arg2Type>::type Arg2;
type typename (line 92) | typedef typename internal::remove_all<Arg3Type>::type Arg3;
type typename (line 94) | typedef typename CwiseTernaryOpImpl<
type typename (line 100) | typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
type typename (line 101) | typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
type typename (line 102) | typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
type typename (line 103) | typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
type typename (line 104) | typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
FILE: external/eigen3/Eigen/src/Core/CwiseUnaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 62) | typedef typename internal::remove_all<XprType>::type NestedExpression;
function typename (line 84) | typename internal::remove_all<XprTypeNested>::type&
FILE: external/eigen3/Eigen/src/Core/CwiseUnaryView.h
function namespace (line 13) | namespace Eigen {
type typename (line 65) | typedef typename internal::remove_all<MatrixType>::type NestedExpression;
function explicit (line 67) | explicit inline CwiseUnaryView(MatrixType& mat, const ViewOp& func = Vie...
function typename (line 83) | typename internal::remove_reference<MatrixTypeNested>::type&
type typename (line 107) | typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, Matrix...
function EIGEN_INHERIT_ASSIGNMENT_OPERATORS (line 109) | EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
FILE: external/eigen3/Eigen/src/Core/DenseBase.h
function namespace (line 16) | namespace internal {
type typename (line 55) | typedef typename internal::traits<Derived>::StorageKind StorageKind;
type typename (line 63) | typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
type typename (line 66) | typedef typename internal::traits<Derived>::Scalar Scalar;
type Scalar (line 71) | typedef Scalar value_type;
type typename (line 73) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DenseCoeffsBase (line 74) | typedef DenseCoeffsBase<Derived> Base;
type typename (line 96) | typedef typename Base::CoeffReturnType CoeffReturnType;
type typename (line 174) | typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::t...
type Matrix (line 180) | typedef Matrix<typename
type Array (line 190) | typedef Array<typename
type typename (line 204) | typedef typename internal::conditional<internal::is_same<typename
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 251) | EIGEN_DEVICE_FUNC
type CwiseNullaryOp (line 262) | typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject>...
type CwiseNullaryOp (line 264) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type CwiseNullaryOp (line 266) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar,PacketScalar>,Plain...
type Matrix (line 268) | typedef Matrix<typename
type Transpose (line 319) | typedef Transpose<Derived> TransposeReturnType;
type typename (line 322) | typedef typename internal::add_const<Transpose<const Derived> >::type Co...
FILE: external/eigen3/Eigen/src/Core/DenseCoeffsBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 483) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 484) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 513) | inline Index stride() const
type typename (line 557) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 558) | typedef typename NumTraits<Scalar>::Real RealScalar;
function Index (line 587) | inline Index stride() const
function EIGEN_DEVICE_FUNC (line 606) | EIGEN_DEVICE_FUNC
function Index (line 639) | inline Index first_aligned(const DenseBase<Derived>& m)
function Index (line 646) | inline Index first_default_aligned(const DenseBase<Derived>& m)
FILE: external/eigen3/Eigen/src/Core/DenseStorage.h
function namespace (line 21) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 125) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC plain_array() {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert...
function EIGEN_DEVICE_FUNC (line 193) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 203) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
function EIGEN_DEVICE_FUNC (line 211) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 212) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function EIGEN_DEVICE_FUNC (line 213) | EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 214) | EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 215) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 216) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 223) | EIGEN_DEVICE_FUNC DenseStorage() {}
function EIGEN_DEVICE_FUNC (line 224) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 225) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
function EIGEN_DEVICE_FUNC (line 227) | EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 268) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(r...
function EIGEN_DEVICE_FUNC (line 273) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols)...
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = ...
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 276) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 286) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 288) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 298) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
function EIGEN_DEVICE_FUNC (line 300) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 301) | EIGEN_DEVICE_FUNC Index cols(void) const {return _Cols;}
function EIGEN_DEVICE_FUNC (line 302) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_...
function EIGEN_DEVICE_FUNC (line 303) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
function EIGEN_DEVICE_FUNC (line 304) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 305) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 315) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 317) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other) : m_data(other...
function EIGEN_DEVICE_FUNC (line 327) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
function EIGEN_DEVICE_FUNC (line 329) | EIGEN_DEVICE_FUNC Index rows(void) const {return _Rows;}
function EIGEN_DEVICE_FUNC (line 330) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 331) | void conservativeResize(Index, Index, Index cols) { m_cols = cols; }
function resize (line 332) | void resize(Index, Index, Index cols) { m_cols = cols; }
function EIGEN_DEVICE_FUNC (line 333) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 334) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 391) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 394) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 395) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function conservativeResize (line 396) | void conservativeResize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 402) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 416) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 417) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 427) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 428) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 434) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 451) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 468) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 470) | EIGEN_DEVICE_FUNC static Index rows(void) {return _Rows;}
function EIGEN_DEVICE_FUNC (line 471) | EIGEN_DEVICE_FUNC Index cols(void) const {return m_cols;}
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
function resize (line 477) | void resize(Index size, Index, Index cols)
function EIGEN_DEVICE_FUNC (line 490) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 491) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 501) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 502) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 508) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 525) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 542) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 544) | EIGEN_DEVICE_FUNC Index rows(void) const {return m_rows;}
function EIGEN_DEVICE_FUNC (line 545) | EIGEN_DEVICE_FUNC static Index cols(void) {return _Cols;}
function conservativeResize (line 546) | void conservativeResize(Index size, Index rows, Index)
function resize (line 551) | void resize(Index size, Index rows, Index)
function EIGEN_DEVICE_FUNC (line 564) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 565) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
FILE: external/eigen3/Eigen/src/Core/Diagonal.h
function namespace (line 14) | namespace Eigen {
type typename (line 69) | typedef typename internal::dense_xpr_base<Diagonal>::type Base;
function explicit (line 73) | explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) ...
type typename (line 102) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 108) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 110) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 113) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 120) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 126) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 145) | EIGEN_DEVICE_FUNC
FILE: external/eigen3/Eigen/src/Core/DiagonalMatrix.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 142) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 150) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 154) | EIGEN_DEVICE_FUNC
function m_diagonal (line 160) | inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diago...
function m_diagonal (line 164) | inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.di...
function explicit (line 170) | explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : ...
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 198) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 201) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 204) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 207) | EIGEN_DEVICE_FUNC
function namespace (line 225) | namespace internal {
type _DiagonalVectorType (line 250) | typedef _DiagonalVectorType DiagonalVectorType;
type DiagonalWrapper (line 251) | typedef DiagonalWrapper Nested;
function m_diagonal (line 256) | inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_di...
function namespace (line 309) | namespace internal {
function run (line 335) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: external/eigen3/Eigen/src/Core/DiagonalProduct.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Dot.h
function namespace (line 13) | namespace Eigen {
type internal (line 78) | typedef internal::scalar_conj_product_op<Scalar,typename
type typename (line 126) | typedef typename internal::nested_eval<Derived,2>::type _Nested;
type typename (line 169) | typedef typename internal::nested_eval<Derived,3>::type _Nested;
function namespace (line 201) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/EigenBase.h
function namespace (line 14) | namespace Eigen {
function evalTo (line 71) | inline void evalTo(Dest& dst) const
function addTo (line 77) | inline void addTo(Dest& dst) const
function subTo (line 89) | inline void subTo(Dest& dst) const
function applyThisOnTheRight (line 100) | inline void applyThisOnTheRight(Dest& dst) const
function applyThisOnTheLeft (line 109) | inline void applyThisOnTheLeft(Dest& dst) const
FILE: external/eigen3/Eigen/src/Core/ForceAlignedAccess.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Fuzzy.h
function namespace (line 14) | namespace Eigen {
function typename (line 65) | typename Derived::RealScalar& prec)
function EIGEN_DEVICE_FUNC (line 74) | EIGEN_DEVICE_FUNC
FILE: external/eigen3/Eigen/src/Core/GeneralProduct.h
function namespace (line 14) | namespace Eigen {
type product_type_selector (line 93) | struct product_type_selector
type product_type_selector (line 94) | struct product_type_selector
type product_type_selector (line 95) | struct product_type_selector
type product_type_selector (line 96) | struct product_type_selector
type product_type_selector (line 97) | struct product_type_selector
type product_type_selector (line 98) | struct product_type_selector
type product_type_selector (line 99) | struct product_type_selector
type product_type_selector (line 100) | struct product_type_selector
type product_type_selector (line 101) | struct product_type_selector
type product_type_selector (line 102) | struct product_type_selector
type product_type_selector (line 103) | struct product_type_selector
type product_type_selector (line 104) | struct product_type_selector
type product_type_selector (line 105) | struct product_type_selector
type product_type_selector (line 106) | struct product_type_selector
type product_type_selector (line 107) | struct product_type_selector
type product_type_selector (line 108) | struct product_type_selector
type product_type_selector (line 109) | struct product_type_selector
type product_type_selector (line 110) | struct product_type_selector
type product_type_selector (line 111) | struct product_type_selector
type product_type_selector (line 112) | struct product_type_selector
function namespace (line 142) | namespace internal {
function namespace (line 149) | namespace internal {
function EIGEN_STRONG_INLINE (line 174) | EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Scalar* data() {
type gemv_dense_selector (line 201) | struct gemv_dense_selector
function run (line 204) | inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typena...
type gemv_dense_selector (line 295) | struct gemv_dense_selector
function run (line 298) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 348) | struct gemv_dense_selector
function run (line 351) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 362) | struct gemv_dense_selector
function run (line 365) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: external/eigen3/Eigen/src/Core/GenericPacketMath.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 543) | inline void
function Packet (line 556) | inline Packet
function Packet (line 562) | inline Packet
function Packet (line 576) | inline Packet
FILE: external/eigen3/Eigen/src/Core/GlobalFunctions.h
function namespace (line 54) | namespace Eigen
FILE: external/eigen3/Eigen/src/Core/IO.h
function namespace (line 14) | namespace Eigen {
function namespace (line 112) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/Inverse.h
function namespace (line 13) | namespace Eigen {
type typename (line 74) | typedef typename XprType::Scalar Scalar;
function namespace (line 81) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/Map.h
function namespace (line 14) | namespace Eigen {
type PointerType (line 103) | typedef PointerType PointerArgType;
function EIGEN_DEVICE_FUNC (line 104) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 107) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 128) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 155) | EIGEN_DEVICE_FUNC
FILE: external/eigen3/Eigen/src/Core/MapBase.h
function namespace (line 18) | namespace Eigen {
type typename (line 229) | typedef typename Base::Scalar Scalar;
type typename (line 230) | typedef typename Base::PacketScalar PacketScalar;
type typename (line 231) | typedef typename Base::StorageIndex StorageIndex;
type typename (line 232) | typedef typename Base::PointerType PointerType;
type typename (line 246) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 252) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 257) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 263) | EIGEN_DEVICE_FUNC
function writePacket (line 271) | void writePacket(Index row, Index col, const PacketScalar& val)
function writePacket (line 278) | void writePacket(Index index, const PacketScalar& val)
function EIGEN_DEVICE_FUNC (line 285) | EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(da...
function EIGEN_DEVICE_FUNC (line 286) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : B...
function EIGEN_DEVICE_FUNC (line 287) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index ...
FILE: external/eigen3/Eigen/src/Core/MathFunctions.h
function namespace (line 18) | namespace Eigen {
type Scalar (line 549) | typedef Scalar type;
function Scalar (line 562) | static inline Scalar run()
type typename (line 623) | typedef typename make_unsigned<Scalar>::type ScalarU;
type typename (line 627) | typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsi...
function Scalar (line 645) | static inline Scalar run()
function Scalar (line 668) | static inline Scalar run()
function isinf_impl (line 728) | bool>::type
function isinf_msvc_helper (line 760) | bool isinf_msvc_helper(T x)
function EIGEN_DEVICE_FUNC (line 766) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 767) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 768) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return ...
function EIGEN_DEVICE_FUNC (line 770) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 771) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 772) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return ...
function isnan_impl (line 784) | bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
function isnan_impl (line 785) | bool isnan_impl(const double& x) { return __builtin_isnan(x); }
function isnan_impl (line 786) | bool isnan_impl(const float& x) { return __builtin_isnan(x); }
function isinf_impl (line 787) | bool isinf_impl(const double& x) { return __builtin_isinf(x); }
function isinf_impl (line 788) | bool isinf_impl(const float& x) { return __builtin_isinf(x); }
function isinf_impl (line 789) | bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
function namespace (line 810) | namespace numext {
function floor (line 976) | float floor(const float &x) { return ::floorf(x); }
function floor (line 979) | double floor(const double &x) { return ::floor(x); }
function ceil (line 992) | float ceil(const float &x) { return ::ceilf(x); }
function ceil (line 995) | double ceil(const double &x) { return ::ceil(x); }
function log2 (line 1001) | inline int log2(int x)
function log (line 1040) | float log(const float &x) { return ::logf(x); }
function log (line 1043) | double log(const double &x) { return ::log(x); }
function typename (line 1056) | typename NumTraits<T>::Real>::type
function EIGEN_ALWAYS_INLINE (line 1062) | EIGEN_ALWAYS_INLINE float abs(float x) { return cl::sycl::fabs(x); }
function EIGEN_ALWAYS_INLINE (line 1063) | EIGEN_ALWAYS_INLINE double abs(double x) { return cl::sycl::fabs(x); }
function abs (line 1068) | float abs(const float &x) { return ::fabsf(x); }
function abs (line 1071) | double abs(const double &x) { return ::fabs(x); }
function exp (line 1093) | float exp(const float &x) { return ::expf(x); }
function exp (line 1096) | double exp(const double &x) { return ::exp(x); }
function cos (line 1108) | float cos(const float &x) { return ::cosf(x); }
function cos (line 1111) | double cos(const double &x) { return ::cos(x); }
function sin (line 1123) | float sin(const float &x) { return ::sinf(x); }
function sin (line 1126) | double sin(const double &x) { return ::sin(x); }
function tan (line 1138) | float tan(const float &x) { return ::tanf(x); }
function tan (line 1141) | double tan(const double &x) { return ::tan(x); }
function acos (line 1153) | float acos(const float &x) { return ::acosf(x); }
function acos (line 1156) | double acos(const double &x) { return ::acos(x); }
function asin (line 1168) | float asin(const float &x) { return ::asinf(x); }
function asin (line 1171) | double asin(const double &x) { return ::asin(x); }
function atan (line 1183) | float atan(const float &x) { return ::atanf(x); }
function atan (line 1186) | double atan(const double &x) { return ::atan(x); }
function cosh (line 1199) | float cosh(const float &x) { return ::coshf(x); }
function cosh (line 1202) | double cosh(const double &x) { return ::cosh(x); }
function sinh (line 1214) | float sinh(const float &x) { return ::sinhf(x); }
function sinh (line 1217) | double sinh(const double &x) { return ::sinh(x); }
function tanh (line 1229) | float tanh(float x) { return internal::generic_fast_tanh_float(x); }
function tanh (line 1234) | float tanh(const float &x) { return ::tanhf(x); }
function tanh (line 1237) | double tanh(const double &x) { return ::tanh(x); }
function fmod (line 1250) | float fmod(const float& a, const float& b) {
function fmod (line 1256) | double fmod(const double& a, const double& b) {
function namespace (line 1263) | namespace internal {
type typename (line 1316) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1318) | static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, con...
function EIGEN_DEVICE_FUNC (line 1322) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 1327) | EIGEN_DEVICE_FUNC
type typename (line 1337) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1339) | static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar&...
function EIGEN_DEVICE_FUNC (line 1343) | EIGEN_DEVICE_FUNC
function isMuchSmallerThan (line 1354) | bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
function isApprox (line 1361) | bool isApprox(const Scalar& x, const Scalar& y,
function isApproxOrLessThan (line 1368) | bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
function bool (line 1378) | struct random_impl<bool>
function bool (line 1386) | struct scalar_fuzzy_impl<bool>
FILE: external/eigen3/Eigen/src/Core/MathFunctionsImpl.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Matrix.h
function namespace (line 14) | namespace Eigen {
type PlainObjectBase (line 186) | typedef PlainObjectBase<Matrix> Base;
function explicit (line 267) | explicit Matrix(internal::constructor_without_unaligned_array_assert)
function EIGEN_DEVICE_FUNC (line 272) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 291) | EIGEN_STRONG_INLINE explicit Matrix(const T& x)
function EIGEN_STRONG_INLINE (line 299) | EIGEN_STRONG_INLINE Matrix(const T0& x, const T1& y)
function Base (line 368) | Matrix(const Matrix& other) : Base(other)
function EIGEN_STRONG_INLINE (line 376) | EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
type internal (line 399) | struct internal
FILE: external/eigen3/Eigen/src/Core/MatrixBase.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/NestByValue.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/NoAlias.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/NumTraits.h
function namespace (line 13) | namespace Eigen {
type T (line 100) | typedef T Real;
type typename (line 101) | typedef typename internal::conditional<
type T (line 106) | typedef T Nested;
type T (line 107) | typedef T Literal;
function EIGEN_DEVICE_FUNC (line 109) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 115) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 121) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 129) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 139) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
type NumTraits (line 153) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 156) | EIGEN_DEVICE_FUNC
type NumTraits (line 160) | struct NumTraits
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC
type NumTraits (line 166) | struct NumTraits
function dummy_precision (line 169) | static inline long double dummy_precision() { return 1e-15l; }
type _Real (line 175) | typedef _Real Real;
type typename (line 176) | typedef typename NumTraits<_Real>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 185) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 187) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC
type typename (line 197) | typedef typename NumTraits<Scalar>::Real RealScalar;
type Array (line 198) | typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
type typename (line 199) | typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
type Array (line 200) | typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> N...
type ArrayType (line 201) | typedef ArrayType & Nested;
type typename (line 202) | typedef typename NumTraits<Scalar>::Literal Literal;
function EIGEN_DEVICE_FUNC (line 214) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 216) | EIGEN_DEVICE_FUNC
function digits10 (line 219) | static inline int digits10() { return NumTraits<Scalar>::digits10(); }
function string (line 222) | struct NumTraits<std::string>
function void (line 244) | struct NumTraits<void> {}
FILE: external/eigen3/Eigen/src/Core/PermutationMatrix.h
function namespace (line 14) | namespace Eigen {
function namespace (line 282) | namespace internal {
type internal (line 311) | typedef internal::traits<PermutationMatrix> Traits;
type typename (line 317) | typedef typename Traits::IndicesType IndicesType;
type typename (line 318) | typedef typename Traits::StorageIndex StorageIndex;
function explicit (line 326) | explicit inline PermutationMatrix(Index size) : m_indices(size)
function m_indices (line 339) | inline PermutationMatrix(const PermutationMatrix& other) : m_indices(oth...
function m_indices (line 350) | inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(i...
function namespace (line 419) | namespace internal {
type internal (line 436) | typedef internal::traits<Map> Traits;
type typename (line 440) | typedef typename Traits::IndicesType IndicesType;
type typename (line 441) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 444) | inline Map(const StorageIndex* indicesPtr)
function namespace (line 484) | namespace internal {
type internal (line 517) | typedef internal::traits<PermutationWrapper> Traits;
type typename (line 521) | typedef typename Traits::IndicesType IndicesType;
function m_indices (line 524) | inline PermutationWrapper(const IndicesType& indices)
type internal (line 568) | typedef internal::traits<PermutationType> PermTraits;
type typename (line 576) | typedef typename PermutationType::DenseMatrixType DenseMatrixType;
function namespace (line 625) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/PlainObjectBase.h
function namespace (line 25) | namespace Eigen {
function Scalar (line 160) | const Scalar& coeff(Index rowId, Index colId) const
function Scalar (line 173) | const Scalar& coeff(Index index) const
function Scalar (line 204) | const Scalar& coeffRef(Index rowId, Index colId) const
function Scalar (line 215) | const Scalar& coeffRef(Index index) const
function PacketScalar (line 222) | PacketScalar packet(Index rowId, Index colId) const
function PacketScalar (line 232) | PacketScalar packet(Index index) const
function writePacket (line 239) | void writePacket(Index rowId, Index colId, const PacketScalar& val)
function writePacket (line 249) | void writePacket(Index index, const PacketScalar& val)
function Scalar (line 255) | const Scalar *data() const
function Scalar (line 259) | Scalar *data()
function resize (line 279) | void resize(Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 308) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 333) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 347) | EIGEN_DEVICE_FUNC
function conservativeResize (line 390) | void conservativeResize(Index rows, Index cols)
function conservativeResize (line 403) | void conservativeResize(Index rows, NoChange_t)
function conservativeResize (line 417) | void conservativeResize(NoChange_t, Index cols)
function conservativeResize (line 432) | void conservativeResize(Index size)
function EIGEN_DEVICE_FUNC (line 493) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 502) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 521) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 532) | EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 543) | EIGEN_STRONG_INLINE PlainObjectBase(const EigenBase<OtherDerived> &other)
function EIGEN_STRONG_INLINE (line 553) | EIGEN_STRONG_INLINE PlainObjectBase(const ReturnByValue<OtherDerived>& o...
function ConstMapType (line 587) | static inline ConstMapType Map(const Scalar* data)
function MapType (line 589) | static inline MapType Map(Scalar* data)
function ConstMapType (line 591) | static inline ConstMapType Map(const Scalar* data, Index size)
function MapType (line 593) | static inline MapType Map(Scalar* data, Index size)
function ConstMapType (line 595) | static inline ConstMapType Map(const Scalar* data, Index rows, Index cols)
function MapType (line 597) | static inline MapType Map(Scalar* data, Index rows, Index cols)
function ConstAlignedMapType (line 600) | static inline ConstAlignedMapType MapAligned(const Scalar* data)
function AlignedMapType (line 602) | static inline AlignedMapType MapAligned(Scalar* data)
function ConstAlignedMapType (line 604) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index s...
function AlignedMapType (line 606) | static inline AlignedMapType MapAligned(Scalar* data, Index size)
function ConstAlignedMapType (line 608) | static inline ConstAlignedMapType MapAligned(const Scalar* data, Index r...
function AlignedMapType (line 610) | static inline AlignedMapType MapAligned(Scalar* data, Index rows, Index ...
function _init2 (line 757) | void _init2(const Index& val0, const Index& val1,
function _init1 (line 795) | void _init1(const Index& val0,
function _init1 (line 808) | void _init1(const Scalar* data){
function _init1 (line 822) | void _init1(const Derived& other){
function EIGEN_STRONG_INLINE (line 843) | EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCo...
FILE: external/eigen3/Eigen/src/Core/Product.h
function namespace (line 13) | namespace Eigen {
type _Rhs (line 79) | typedef _Rhs Rhs;
type typename (line 81) | typedef typename ProductImpl<
type typename (line 89) | typedef typename internal::ref_selector<Rhs>::type RhsNested;
type typename (line 90) | typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
type typename (line 91) | typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
function EIGEN_DEVICE_FUNC (line 93) | EIGEN_DEVICE_FUNC Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), ...
function namespace (line 112) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/ProductEvaluators.h
function namespace (line 16) | namespace Eigen {
type evaluator (line 56) | typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1...
function explicit (line 58) | explicit evaluator(const XprType& xpr)
type evaluator (line 69) | typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagInd...
function explicit (line 71) | explicit evaluator(const XprType& xpr)
type typename (line 100) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 101) | typedef evaluator<PlainObject> Base;
function explicit (line 107) | explicit product_evaluator(const XprType& xpr)
type Product (line 157) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type Product (line 172) | typedef Product<Lhs,Rhs,Options> SrcXprType;
type CwiseBinaryOp (line 190) | typedef CwiseBinaryOp<internal::scalar_product_op<ScalarBis,Scalar>,
function addTo (line 255) | void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
function subTo (line 261) | void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
type typename (line 489) | typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVec...
type typename (line 490) | typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVec...
function CoeffReturnType (line 550) | const CoeffReturnType coeff(Index row, Index col) const
function EIGEN_DEVICE_FUNC (line 559) | EIGEN_DEVICE_FUNC const CoeffReturnType coeff(Index index) const
function PacketType (line 567) | PacketType packet(Index row, Index col) const
function PacketType (line 578) | PacketType packet(Index index) const
type Product (line 600) | typedef Product<Lhs, Rhs, DefaultProduct> XprType;
type Product (line 601) | typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
type product_evaluator (line 602) | typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape...
function EIGEN_DEVICE_FUNC (line 606) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function EIGEN_STRONG_INLINE (line 618) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 628) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 638) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 647) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 656) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 665) | static EIGEN_STRONG_INLINE void run(Index /*row*/, Index /*col*/, const ...
function EIGEN_STRONG_INLINE (line 674) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
function EIGEN_STRONG_INLINE (line 685) | static EIGEN_STRONG_INLINE void run(Index row, Index col, const Lhs& lhs...
type typename (line 706) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 720) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 741) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 754) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 772) | typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename
function PacketType (line 812) | PacketType packet_impl(Index row, Index col, Index id, internal::true_ty...
function PacketType (line 819) | PacketType packet_impl(Index row, Index col, Index id, internal::false_t...
type typename (line 842) | typedef typename Base::Scalar Scalar;
type Product (line 844) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 845) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 851) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 856) | const Scalar coeff(Index row, Index col) const
function PacketType (line 863) | PacketType packet(Index row, Index col) const
function PacketType (line 872) | PacketType packet(Index idx) const
type typename (line 888) | typedef typename Base::Scalar Scalar;
type Product (line 890) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 891) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 895) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 900) | const Scalar coeff(Index row, Index col) const
function PacketType (line 907) | PacketType packet(Index row, Index col) const
function PacketType (line 914) | PacketType packet(Index idx) const
type typename (line 937) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 940) | inline void run(Dest& dst, const PermutationType& perm, const Expression...
type typename (line 1044) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 1045) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 1048) | inline void run(Dest& dst, const TranspositionType& tr, const Expression...
FILE: external/eigen3/Eigen/src/Core/Random.h
function namespace (line 15) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/Redux.h
function namespace (line 14) | namespace Eigen {
type typename (line 145) | typedef typename Derived::Scalar Scalar;
type typename (line 146) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
type typename (line 166) | typedef typename Derived::Scalar Scalar;
type typename (line 167) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 190) | Scalar run(const Derived &mat, const Func& func)
type typename (line 213) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 215) | static Scalar run(const Derived &mat, const Func& func)
type typename (line 272) | typedef typename redux_traits<Func, Derived>::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC static Scalar run(const Derived &mat, const Func& func)
type typename (line 311) | typedef typename redux_traits<Func, Derived>::PacketType PacketScalar;
function Scalar (line 317) | Scalar run(const Derived &mat, const Func& func)
function EIGEN_DEVICE_FUNC (line 338) | EIGEN_DEVICE_FUNC explicit redux_evaluator(const XprType &xpr) : m_evalu...
type typename (line 340) | typedef typename XprType::Scalar Scalar;
type typename (line 341) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 342) | typedef typename XprType::PacketScalar PacketScalar;
type typename (line 343) | typedef typename XprType::PacketReturnType PacketReturnType;
function EIGEN_DEVICE_FUNC (line 363) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 367) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 379) | EIGEN_DEVICE_FUNC
function typename (line 410) | typename internal::traits<Derived>::Scalar
FILE: external/eigen3/Eigen/src/Core/Ref.h
function namespace (line 13) | namespace Eigen {
type typename (line 61) | typedef typename internal::traits<Derived>::PlainObjectType PlainObjectT...
type typename (line 62) | typedef typename internal::traits<Derived>::StrideType StrideType;
function Index (line 69) | inline Index innerStride() const
function EIGEN_DEVICE_FUNC (line 253) | EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
function construct (line 265) | void construct(const Expression& expr,internal::true_type)
function construct (line 271) | void construct(const Expression& expr, internal::false_type)
FILE: external/eigen3/Eigen/src/Core/Replicate.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTyp...
type typename (line 65) | typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixT...
FILE: external/eigen3/Eigen/src/Core/ReturnByValue.h
function namespace (line 14) | namespace Eigen {
type typename (line 56) | typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
function evalTo (line 61) | inline void evalTo(Dest& dst) const
function class (line 68) | class Unusable{
function namespace (line 88) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/Reverse.h
function namespace (line 15) | namespace Eigen {
type internal (line 85) | typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> revers...
function m_matrix (line 88) | inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
function namespace (line 163) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/Select.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 73) | inline EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 82) | inline EIGEN_DEVICE_FUNC
function typename (line 139) | typename ThenDerived::Scalar& elseScalar) const
FILE: external/eigen3/Eigen/src/Core/SelfAdjointView.h
function namespace (line 13) | namespace Eigen {
type _MatrixType (line 54) | typedef _MatrixType MatrixType;
type TriangularBase (line 55) | typedef TriangularBase<SelfAdjointView> Base;
type typename (line 56) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested Mat...
type typename (line 57) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedClea...
type MatrixTypeNestedCleaned (line 58) | typedef MatrixTypeNestedCleaned NestedExpression;
type typename (line 61) | typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
type typename (line 62) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 63) | typedef typename internal::remove_all<typename
type typename (line 70) | typedef typename MatrixType::PlainObject PlainObject;
function m_matrix (line 73) | inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 90) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 100) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 114) | EIGEN_DEVICE_FUNC
type SelfAdjointView (line 194) | typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateR...
function EIGEN_DEVICE_FUNC (line 196) | EIGEN_DEVICE_FUNC
type typename (line 284) | typedef typename Base::DstXprType DstXprType;
type typename (line 285) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 292) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 293) | typedef typename Base::Scalar Scalar;
type typename (line 294) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 297) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 301) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 309) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 314) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
FILE: external/eigen3/Eigen/src/Core/SelfCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Solve.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
function namespace (line 110) | namespace internal {
type Solve (line 139) | typedef Solve<DecType,RhsType> SrcXprType;
function run (line 140) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type Solve (line 155) | typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
function run (line 156) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 173) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: external/eigen3/Eigen/src/Core/SolveTriangular.h
function namespace (line 13) | namespace Eigen {
function run (line 121) | static void run(const Lhs& lhs, Rhs& rhs)
function run (line 141) | static void run(const Lhs& lhs, Rhs& rhs)
type typename (line 177) | typedef typename internal::conditional<copy,
function namespace (line 197) | namespace internal {
type ReturnByValue (line 210) | typedef ReturnByValue<triangular_solve_retval> Base;
FILE: external/eigen3/Eigen/src/Core/SolverBase.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/StableNorm.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Stride.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Swap.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/Transpose.h
function namespace (line 14) | namespace Eigen {
function namespace (line 90) | namespace internal {
type typename (line 128) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 134) | EIGEN_DEVICE_FUNC inline ScalarWithConstIfNotLvalue* data() { return der...
function EIGEN_DEVICE_FUNC (line 135) | EIGEN_DEVICE_FUNC inline const Scalar* data() const { return derived().n...
function EIGEN_DEVICE_FUNC (line 138) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function namespace (line 221) | namespace internal {
type typename (line 241) | typedef typename MatrixType::Scalar Scalar;
type typename (line 242) | typedef typename internal::packet_traits<typename
function namespace (line 326) | namespace internal {
function run (line 345) | static bool run(const Scalar* dest, const OtherDerived& src)
function run (line 374) | static void run(const Derived& dst, const OtherDerived& other)
FILE: external/eigen3/Eigen/src/Core/Transpositions.h
function namespace (line 13) | namespace Eigen {
type typename (line 164) | typedef typename Traits::IndicesType IndicesType;
type typename (line 165) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 177) | inline Transpositions(const Transpositions& other) : m_indices(other.ind...
function m_indices (line 182) | inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indi...
function m_indices (line 205) | inline Transpositions(Index size) : m_indices(size)
function namespace (line 219) | namespace internal {
type typename (line 238) | typedef typename Traits::IndicesType IndicesType;
type typename (line 239) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 241) | explicit inline Map(const StorageIndex* indicesPtr)
function namespace (line 278) | namespace internal {
type typename (line 295) | typedef typename Traits::IndicesType IndicesType;
type typename (line 296) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 298) | explicit inline TranspositionsWrapper(IndicesType& indices)
function namespace (line 359) | namespace internal {
type TranspositionsDerived (line 371) | typedef TranspositionsDerived TranspositionType;
type typename (line 372) | typedef typename TranspositionType::IndicesType IndicesType;
FILE: external/eigen3/Eigen/src/Core/TriangularMatrix.h
function namespace (line 14) | namespace Eigen {
type typename (line 192) | typedef typename internal::traits<TriangularView>::Scalar Scalar;
type _MatrixType (line 193) | typedef _MatrixType MatrixType;
type typename (line 197) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRe...
type typename (line 199) | typedef typename internal::remove_all<typename
type typename (line 204) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedClean...
function m_matrix (line 217) | inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 234) | EIGEN_DEVICE_FUNC
type TriangularView (line 237) | typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateRe...
function EIGEN_DEVICE_FUNC (line 239) | EIGEN_DEVICE_FUNC
type TriangularBase (line 337) | typedef TriangularBase<TriangularViewType> Base;
type typename (line 338) | typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
type _MatrixType (line 340) | typedef _MatrixType MatrixType;
type typename (line 341) | typedef typename MatrixType::PlainObject DenseMatrixType;
type DenseMatrixType (line 342) | typedef DenseMatrixType PlainObject;
type typename (line 348) | typedef typename internal::traits<TriangularViewType>::StorageKind Stora...
function EIGEN_DEVICE_FUNC (line 387) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 390) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 394) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 397) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 403) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 413) | EIGEN_DEVICE_FUNC
function solveInPlace (line 508) | void solveInPlace(const MatrixBase<OtherDerived>& other) const
function swap (line 517) | void swap(TriangularBase<OtherDerived> const & other)
function namespace (line 701) | namespace internal {
type evaluator (line 719) | typedef evaluator<typename
function Base (line 720) | unary_evaluator(const XprType &xpr) : Base(xpr.nestedExpression()) {}
type Triangular2Triangular (line 724) | struct Triangular2Triangular {}
type Triangular2Dense (line 725) | struct Triangular2Dense {}
type Dense2Triangular (line 726) | struct Dense2Triangular {}
type typename (line 742) | typedef typename Base::DstXprType DstXprType;
type typename (line 743) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 750) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 751) | typedef typename Base::Scalar Scalar;
type typename (line 752) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 755) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 760) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 769) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 776) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
type evaluator (line 788) | typedef evaluator<DstXprType> DstEvaluatorType;
type evaluator (line 789) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type triangular_dense_assignment_kernel (line 799) | typedef triangular_dense_assignment_kernel< Mode
function Kernel (line 801) | Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
type AssignmentKind (line 820) | struct AssignmentKind
type Triangular2Dense (line 820) | typedef Triangular2Dense Kind;
type AssignmentKind (line 821) | struct AssignmentKind
type Dense2Triangular (line 821) | typedef Dense2Triangular Kind;
type typename (line 859) | typedef typename DstEvaluatorType::XprType DstXprType;
type typename (line 866) | typedef typename Kernel::Scalar Scalar;
function namespace (line 941) | namespace internal {
function run (line 964) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 975) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: external/eigen3/Eigen/src/Core/VectorBlock.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/VectorwiseOp.h
function namespace (line 14) | namespace Eigen {
function namespace (line 97) | namespace internal {
type typename (line 161) | typedef typename ExpressionType::RealScalar RealScalar;
type Eigen (line 162) | typedef Eigen::Index Index;
type typename (line 163) | typedef typename internal::ref_selector<ExpressionType>::non_const_type ...
type typename (line 164) | typedef typename internal::remove_all<ExpressionTypeNested>::type Expres...
type PartialReduxExpr (line 169) | typedef PartialReduxExpr<ExpressionType,
type PartialReduxExpr (line 177) | typedef PartialReduxExpr<ExpressionType,
function EIGEN_DEVICE_FUNC (line 195) | EIGEN_DEVICE_FUNC
type Replicate (line 208) | typedef Replicate<OtherDerived,
type Replicate (line 231) | typedef Replicate<OtherDerived,
function m_matrix (line 255) | inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
function EIGEN_DEVICE_FUNC (line 258) | EIGEN_DEVICE_FUNC
FILE: external/eigen3/Eigen/src/Core/Visitor.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename XprType::Scalar Scalar;
type typename (line 67) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_DEVICE_FUNC (line 78) | EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
type typename (line 109) | typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
function namespace (line 119) | namespace internal {
function typename (line 206) | typename internal::traits<Derived>::Scalar
function typename (line 224) | typename internal::traits<Derived>::Scalar
function typename (line 243) | typename internal::traits<Derived>::Scalar
function typename (line 261) | typename internal::traits<Derived>::Scalar
FILE: external/eigen3/Eigen/src/Core/arch/AVX/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet4cf (line 124) | Packet4cf preverse(const Packet4cf& a) {
type conj_helper (line 174) | struct conj_helper
function EIGEN_STRONG_INLINE (line 176) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 185) | struct conj_helper
function EIGEN_STRONG_INLINE (line 187) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 190) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet4cf pmadd(const Packet4cf& x, const Packet4cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet4cf pmul(const Packet4cf& a, const Packet4cf& ...
type Packet2cd (line 224) | struct Packet2cd
type packet_traits (line 231) | struct packet_traits
function default_packet_traits (line 231) | double> > : default_packet_traits
function Packet2cd (line 254) | struct unpacket_traits<Packet2cd> { typedef std::complex<double> type; e...
function Packet2cd (line 258) | Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
function Packet2cd (line 259) | Packet2cd pconj(const Packet2cd& a)
function Packet2cd (line 319) | Packet2cd preverse(const Packet2cd& a) {
type conj_helper (line 354) | struct conj_helper
function EIGEN_STRONG_INLINE (line 356) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 359) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 365) | struct conj_helper
function EIGEN_STRONG_INLINE (line 367) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 370) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
type conj_helper (line 376) | struct conj_helper
function EIGEN_STRONG_INLINE (line 378) | EIGEN_STRONG_INLINE Packet2cd pmadd(const Packet2cd& x, const Packet2cd&...
function EIGEN_STRONG_INLINE (line 381) | EIGEN_STRONG_INLINE Packet2cd pmul(const Packet2cd& a, const Packet2cd& ...
function Packet4cf (line 427) | Packet4cf pinsertfirst(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 432) | Packet2cd pinsertfirst(const Packet2cd& a, std::complex<double> b)
function Packet4cf (line 437) | Packet4cf pinsertlast(const Packet4cf& a, std::complex<float> b)
function Packet2cd (line 442) | Packet2cd pinsertlast(const Packet2cd& a, std::complex<double> b)
FILE: external/eigen3/Eigen/src/Core/arch/AVX/MathFunctions.h
function namespace (line 17) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/AVX/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet8f (line 136) | Packet8f pnegate(const Packet8f& a)
function Packet4d (line 140) | Packet4d pnegate(const Packet4d& a)
function Packet8f (line 145) | Packet8f pconj(const Packet8f& a) { return a; }
function Packet4d (line 146) | Packet4d pconj(const Packet4d& a) { return a; }
function Packet8i (line 147) | Packet8i pconj(const Packet8i& a) { return a; }
function Index (line 285) | Index stride)
FILE: external/eigen3/Eigen/src/Core/arch/AVX/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/AVX512/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/AVX512/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet16f (line 174) | Packet16f pnegate(const Packet16f& a) {
function Packet8d (line 178) | Packet8d pnegate(const Packet8d& a) {
function Packet16f (line 183) | Packet16f pconj(const Packet16f& a) {
function Packet8d (line 187) | Packet8d pconj(const Packet8d& a) {
function Packet16i (line 191) | Packet16i pconj(const Packet16i& a) {
function Packet16f (line 219) | Packet16f pmadd(const Packet16f& a, const Packet16f& b,
function Packet8d (line 224) | Packet8d pmadd(const Packet8d& a, const Packet8d& b,
function Packet16f (line 638) | Packet16f preverse(const Packet16f& a)
function Packet8d (line 643) | Packet8d preverse(const Packet8d& a)
function Packet16f (line 648) | Packet16f pabs(const Packet16f& a)
function Packet8d (line 654) | Packet8d pabs(const Packet8d& a) {
function Packet16f (line 1298) | Packet16f pblend(const Selector<16>& /*ifPacket*/,
function Packet8d (line 1305) | Packet8d pblend(const Selector<8>& /*ifPacket*/,
FILE: external/eigen3/Eigen/src/Core/arch/AltiVec/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 100) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
function Packet2cf (line 101) | Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a....
function Packet2cf (line 137) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 194) | struct conj_helper
function EIGEN_STRONG_INLINE (line 196) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 199) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 205) | struct conj_helper
function EIGEN_STRONG_INLINE (line 207) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 210) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 216) | struct conj_helper
function EIGEN_STRONG_INLINE (line 218) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 221) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function Packet2cf (line 250) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
type Packet1cd (line 259) | struct Packet1cd
type packet_traits (line 266) | struct packet_traits
function default_packet_traits (line 266) | double> > : default_packet_traits
function Packet1cd (line 289) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 316) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 317) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinter...
function Packet1cd (line 354) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 373) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 376) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 382) | struct conj_helper
function EIGEN_STRONG_INLINE (line 384) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 387) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 393) | struct conj_helper
function EIGEN_STRONG_INLINE (line 395) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 398) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 414) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: external/eigen3/Eigen/src/Core/arch/AltiVec/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/AltiVec/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 355) | Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
function Packet4i (line 356) | Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
function Packet4f (line 358) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet4i (line 359) | Packet4i pconj(const Packet4i& a) { return a; }
type __vector (line 774) | typedef __vector double Packet2d;
type Packet2ul (line 775) | typedef __vector unsigned long long Packet2ul;
type Packet2l (line 776) | typedef __vector long long Packet2l;
type Packet2ul (line 778) | typedef Packet2ul Packet2bl;
type __vector (line 780) | typedef __vector __bool
function default_packet_traits (line 807) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 838) | struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, al...
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/Complex.h
function namespace (line 15) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/Half.h
function namespace (line 46) | namespace Eigen {
function namespace (line 150) | namespace std {
function namespace (line 200) | namespace Eigen {
function namespace (line 649) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/PacketMath.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/PacketMathHalf.h
function namespace (line 14) | namespace Eigen {
function ptranspose (line 108) | void
type Packet16h (line 339) | typedef struct {
function Packet16h (line 344) | struct is_arithmetic<Packet16h> { enum { value = true }; }
function default_packet_traits (line 347) | struct packet_traits<half> : default_packet_traits {
function Packet16h (line 376) | struct unpacket_traits<Packet16h> { typedef Eigen::half type; enum {size...
function Packet16h (line 408) | Packet16h
function EIGEN_STRONG_INLINE (line 419) | EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
function EIGEN_STRONG_INLINE (line 447) | EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
type Packet8h (line 707) | typedef struct {
function Packet8h (line 712) | struct is_arithmetic<Packet8h> { enum { value = true }; }
function default_packet_traits (line 715) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet8h (line 744) | struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=...
function EIGEN_STRONG_INLINE (line 785) | EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
function EIGEN_STRONG_INLINE (line 804) | EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
function Packet8h (line 827) | Packet8h pconj(const Packet8h& a) { return a; }
type Packet4h (line 966) | typedef struct {
function Packet4h (line 971) | struct is_arithmetic<Packet4h> { enum { value = true }; }
function default_packet_traits (line 974) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet4h (line 1003) | struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=...
function Packet4h (line 1015) | Packet4h pconj(const Packet4h& a) { return a; }
FILE: external/eigen3/Eigen/src/Core/arch/CUDA/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/NEON/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 154) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 235) | struct conj_helper
function EIGEN_STRONG_INLINE (line 237) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 240) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 246) | struct conj_helper
function EIGEN_STRONG_INLINE (line 248) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 251) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 257) | struct conj_helper
function EIGEN_STRONG_INLINE (line 259) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 262) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type Packet1cd (line 301) | struct Packet1cd
type packet_traits (line 308) | struct packet_traits
function default_packet_traits (line 308) | double> > : default_packet_traits
function Packet1cd (line 331) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 341) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate<Packet2...
function Packet1cd (line 342) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(vreinterpretq_f64...
function Packet1cd (line 410) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 433) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 439) | struct conj_helper
function EIGEN_STRONG_INLINE (line 441) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 444) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 450) | struct conj_helper
function EIGEN_STRONG_INLINE (line 452) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 455) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 473) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: external/eigen3/Eigen/src/Core/arch/NEON/MathFunctions.h
function namespace (line 15) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/NEON/PacketMath.h
function namespace (line 15) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/SSE/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet2cf (line 148) | Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(...
type conj_helper (line 178) | struct conj_helper
function EIGEN_STRONG_INLINE (line 180) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 183) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 196) | struct conj_helper
function EIGEN_STRONG_INLINE (line 198) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 214) | struct conj_helper
function EIGEN_STRONG_INLINE (line 216) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 219) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 242) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf...
type Packet1cd (line 249) | struct Packet1cd
type packet_traits (line 259) | struct packet_traits
function default_packet_traits (line 259) | double> > : default_packet_traits
function Packet1cd (line 283) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 287) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 288) | Packet1cd pconj(const Packet1cd& a)
function Packet1cd (line 336) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 365) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 368) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 381) | struct conj_helper
function EIGEN_STRONG_INLINE (line 383) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 386) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 399) | struct conj_helper
function EIGEN_STRONG_INLINE (line 401) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 404) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
function EIGEN_STRONG_INLINE (line 427) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd...
function Packet2cf (line 442) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
function Packet2cf (line 447) | Packet2cf pinsertfirst(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 452) | Packet1cd pinsertfirst(const Packet1cd&, std::complex<double> b)
function Packet2cf (line 457) | Packet2cf pinsertlast(const Packet2cf& a, std::complex<float> b)
function Packet1cd (line 462) | Packet1cd pinsertlast(const Packet1cd&, std::complex<double> b)
FILE: external/eigen3/Eigen/src/Core/arch/SSE/MathFunctions.h
function namespace (line 18) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/SSE/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 441) | Packet4f preverse(const Packet4f& a)
function Packet2d (line 443) | Packet2d preverse(const Packet2d& a)
function Packet4i (line 445) | Packet4i preverse(const Packet4i& a)
function Packet4f (line 448) | Packet4f pabs(const Packet4f& a)
function Packet2d (line 453) | Packet2d pabs(const Packet2d& a)
function Packet4i (line 458) | Packet4i pabs(const Packet4i& a)
function EIGEN_STRONG_INLINE (line 500) | EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
function Packet4i (line 802) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 812) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 822) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
function Packet4f (line 833) | Packet4f pinsertfirst(const Packet4f& a, float b)
function Packet2d (line 842) | Packet2d pinsertfirst(const Packet2d& a, double b)
function Packet4f (line 851) | Packet4f pinsertlast(const Packet4f& a, float b)
function Packet2d (line 861) | Packet2d pinsertlast(const Packet2d& a, double b)
function pmadd (line 873) | float pmadd(const float& a, const float& b, const float& c) {
function pmadd (line 876) | double pmadd(const double& a, const double& b, const double& c) {
function __m128 (line 887) | static inline __m128 _mm_castpd_ps (__m128d x) { return reinterpret_c...
function __m128i (line 888) | static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_c...
function __m128d (line 889) | static inline __m128d _mm_castps_pd (__m128 x) { return reinterpret_c...
function __m128i (line 890) | static inline __m128i _mm_castps_si128(__m128 x) { return reinterpret_c...
function __m128 (line 891) | static inline __m128 _mm_castsi128_ps(__m128i x) { return reinterpret_c...
function __m128d (line 892) | static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_c...
FILE: external/eigen3/Eigen/src/Core/arch/SSE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/ZVector/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet1cd (line 138) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet2cf (line 139) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4...
function Packet1cd (line 140) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor...
function Packet2cf (line 141) | Packet2cf pconj(const Packet2cf& a)
function Packet1cd (line 204) | Packet1cd preverse(const Packet1cd& a) { return a; }
function Packet2cf (line 205) | Packet2cf preverse(const Packet2cf& a)
type conj_helper (line 273) | struct conj_helper
function EIGEN_STRONG_INLINE (line 275) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 278) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 284) | struct conj_helper
function EIGEN_STRONG_INLINE (line 286) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 289) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 295) | struct conj_helper
function EIGEN_STRONG_INLINE (line 297) | EIGEN_STRONG_INLINE Packet1cd pmadd(const Packet1cd& x, const Packet1cd&...
function EIGEN_STRONG_INLINE (line 300) | EIGEN_STRONG_INLINE Packet1cd pmul(const Packet1cd& a, const Packet1cd& ...
type conj_helper (line 306) | struct conj_helper
function EIGEN_STRONG_INLINE (line 308) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 311) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 317) | struct conj_helper
function EIGEN_STRONG_INLINE (line 319) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 322) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
type conj_helper (line 328) | struct conj_helper
function EIGEN_STRONG_INLINE (line 330) | EIGEN_STRONG_INLINE Packet2cf pmadd(const Packet2cf& x, const Packet2cf&...
function EIGEN_STRONG_INLINE (line 333) | EIGEN_STRONG_INLINE Packet2cf pmul(const Packet2cf& a, const Packet2cf& ...
function EIGEN_STRONG_INLINE (line 359) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
function EIGEN_STRONG_INLINE (line 364) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
function Packet2cf (line 386) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
FILE: external/eigen3/Eigen/src/Core/arch/ZVector/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/arch/ZVector/PacketMath.h
function namespace (line 15) | namespace Eigen {
function Packet4i (line 538) | Packet4i pnegate(const Packet4i& a) { return (-a); }
function Packet4f (line 539) | Packet4f pnegate(const Packet4f& a)
function Packet2d (line 546) | Packet2d pnegate(const Packet2d& a) { return (-a); }
function Packet4i (line 548) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet4f (line 549) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet2d (line 550) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet4i (line 552) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) ...
function Packet4f (line 553) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
function Packet2d (line 560) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet4i (line 688) | Packet4i preverse(const Packet4i& a)
function Packet2d (line 693) | Packet2d preverse(const Packet2d& a)
function Packet4f (line 698) | Packet4f preverse(const Packet4f& a)
function Packet4i (line 918) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 924) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet2d (line 935) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
FILE: external/eigen3/Eigen/src/Core/functors/AssignmentFunctors.h
function namespace (line 13) | namespace Eigen {
function assignCoeff (line 70) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
function assignPacket (line 73) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 92) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
function assignPacket (line 95) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 113) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
function assignPacket (line 116) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 145) | void assignCoeff(Scalar& a, const Scalar& b) const
FILE: external/eigen3/Eigen/src/Core/functors/BinaryFunctors.h
function namespace (line 13) | namespace Eigen {
type typename (line 116) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_pr...
function EIGEN_STRONG_INLINE (line 119) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 123) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 142) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>...
function EIGEN_STRONG_INLINE (line 144) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 146) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 149) | const result_type predux(const Packet& a) const
type typename (line 168) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>...
function EIGEN_STRONG_INLINE (line 170) | EIGEN_STRONG_INLINE const result_type operator() (const LhsScalar& a, co...
function Packet (line 172) | const Packet packetOp(const Packet& a, const Packet& b) const
function result_type (line 175) | const result_type predux(const Packet& a) const
function const (line 211) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a=...
function const (line 218) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
function const (line 225) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<...
function const (line 232) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
function const (line 239) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>...
function const (line 246) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(...
function const (line 253) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!...
function Scalar (line 267) | const Scalar operator() (const Scalar &x, const Scalar &y) const
type typename (line 294) | typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::Re...
type Scalar (line 299) | typedef Scalar LhsScalar;
type Exponent (line 300) | typedef Exponent RhsScalar;
function EIGEN_DEVICE_FUNC (line 304) | EIGEN_DEVICE_FUNC
type typename (line 324) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_differe...
function result_type (line 332) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 334) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 353) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotien...
function result_type (line 361) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 363) | const Packet packetOp(const Packet& a, const Packet& b) const
type scalar_boolean_and_op (line 382) | struct scalar_boolean_and_op {
function scalar_boolean_and_op (line 386) | struct functor_traits<scalar_boolean_and_op> {
type scalar_boolean_or_op (line 398) | struct scalar_boolean_or_op {
function scalar_boolean_or_op (line 402) | struct functor_traits<scalar_boolean_or_op> {
type scalar_boolean_xor_op (line 414) | struct scalar_boolean_xor_op {
function scalar_boolean_xor_op (line 418) | struct functor_traits<scalar_boolean_xor_op> {
type typename (line 435) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 436) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 437) | typedef typename BinaryOp::result_type result_type;
function m_value (line 439) | bind1st_op(const first_argument_type &val) : m_value(val) {}
function result_type (line 441) | const result_type operator() (const second_argument_type& b) const { ret...
function Packet (line 444) | const Packet packetOp(const Packet& b) const
type typename (line 454) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 455) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 456) | typedef typename BinaryOp::result_type result_type;
function m_value (line 458) | bind2nd_op(const second_argument_type &val) : m_value(val) {}
function result_type (line 460) | const result_type operator() (const first_argument_type& a) const { retu...
function Packet (line 463) | const Packet packetOp(const Packet& a) const
FILE: external/eigen3/Eigen/src/Core/functors/NullaryFunctors.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 136) | const Scalar operator() (IndexType i) const { return impl(i); }
function EIGEN_STRONG_INLINE (line 139) | EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return im...
FILE: external/eigen3/Eigen/src/Core/functors/StlFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/functors/TernaryFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/functors/UnaryFunctors.h
function namespace (line 13) | namespace Eigen {
function result_type (line 171) | result_type operator() (const Scalar& a) const { return numext::real(a); }
function result_type (line 187) | result_type operator() (const Scalar& a) const { return numext::imag(a); }
function Scalar (line 233) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 235) | inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
function Scalar (line 273) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 275) | inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
function Scalar (line 304) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 306) | inline Packet packetOp(const Packet& a) const { return internal::plog1p(...
function Scalar (line 324) | inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD...
function Packet (line 326) | inline Packet packetOp(const Packet& a) const { return internal::plog10(...
function Scalar (line 338) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 340) | inline Packet packetOp(const Packet& a) const { return internal::psqrt(a...
function Scalar (line 365) | inline const Scalar operator() (const Scalar& a) const { return Scalar(1...
function Packet (line 367) | inline Packet packetOp(const Packet& a) const { return internal::prsqrt(...
function Scalar (line 384) | inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
function Packet (line 386) | inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
function Scalar (line 403) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 405) | inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
function Scalar (line 423) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 425) | inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
function Scalar (line 442) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 444) | inline Packet packetOp(const Packet& a) const { return internal::pacos(a...
function Scalar (line 461) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 463) | inline Packet packetOp(const Packet& a) const { return internal::pasin(a...
function Scalar (line 481) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 483) | inline Packet packetOp(const Packet& a) const { return internal::patan(a...
function Scalar (line 501) | inline const Scalar operator()(const Scalar& a) const { return numext::t...
function Packet (line 503) | inline Packet packetOp(const Packet& x) const { return ptanh(x); }
function Scalar (line 537) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 539) | inline Packet packetOp(const Packet& a) const { return internal::psinh(a...
function Scalar (line 556) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 558) | inline Packet packetOp(const Packet& a) const { return internal::pcosh(a...
function Scalar (line 576) | inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
function Packet (line 578) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 592) | inline Scalar operator() (const Scalar& a) const { return a*a; }
function Packet (line 594) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 608) | inline Scalar operator() (const Scalar& a) const { return a*a*a; }
function Packet (line 610) | inline const Packet packetOp(const Packet& a) const
function EIGEN_STRONG_INLINE (line 623) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 625) | inline Packet packetOp(const Packet& a) const { return internal::pround(...
function EIGEN_STRONG_INLINE (line 642) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 644) | inline Packet packetOp(const Packet& a) const { return internal::pfloor(...
function EIGEN_STRONG_INLINE (line 661) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 663) | inline Packet packetOp(const Packet& a) const { return internal::pceil(a...
function result_type (line 681) | result_type operator() (const Scalar& a) const { return (numext::isnan)(...
function result_type (line 699) | result_type operator() (const Scalar& a) const { return (numext::isinf)(...
function result_type (line 717) | result_type operator() (const Scalar& a) const { return (numext::isfinit...
function const (line 735) | bool operator() (const bool& a) const { return !a; }
function EIGEN_DEVICE_FUNC (line 753) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_DEVICE_FUNC (line 764) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
FILE: external/eigen3/Eigen/src/Core/products/GeneralBlockPanelKernel.h
function namespace (line 14) | namespace Eigen {
function EIGEN_ALWAYS_INLINE (line 317) | EIGEN_ALWAYS_INLINE static void run(const CJ& cj, A& a, B& b, C& c, T& /...
function gebp_madd (line 331) | void gebp_madd(const CJ& cj, A& a, B& b, C& c, T& t)
type _RhsScalar (line 355) | typedef _RhsScalar RhsScalar;
type typename (line 356) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 386) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 387) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 388) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 390) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 391) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 392) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 394) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 401) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function loadRhs (line 412) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 417) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function loadLhs (line 423) | void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
function loadLhsUnaligned (line 429) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 435) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function EIGEN_STRONG_INLINE (line 450) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
function acc (line 456) | void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHa...
type RealScalar (line 468) | typedef RealScalar RhsScalar;
type typename (line 469) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 492) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 493) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 494) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 496) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 497) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 498) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 500) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 507) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 512) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 517) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 522) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 527) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 537) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 542) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 552) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 557) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type std (line 603) | typedef std::complex<RealScalar> LhsScalar;
type std (line 604) | typedef std::complex<RealScalar> RhsScalar;
type std (line 605) | typedef std::complex<RealScalar> ResScalar;
type typename (line 625) | typedef typename packet_traits<RealScalar>::type RealPacket;
type typename (line 626) | typedef typename packet_traits<Scalar>::type ScalarPacket;
type DoublePacket (line 627) | typedef DoublePacket<RealPacket> DoublePacketType;
type typename (line 629) | typedef typename conditional<Vectorizable,RealPacket, Scalar>::type Lhs...
type typename (line 630) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
type typename (line 631) | typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type Res...
type typename (line 632) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
function EIGEN_STRONG_INLINE (line 643) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ResPacket& dest) const
function EIGEN_STRONG_INLINE (line 649) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, DoublePacketType& d...
function EIGEN_STRONG_INLINE (line 655) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest...
function EIGEN_STRONG_INLINE (line 659) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketTyp...
function EIGEN_STRONG_INLINE (line 665) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsPacket& b0,...
function EIGEN_STRONG_INLINE (line 675) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, DoublePacketTy...
function EIGEN_STRONG_INLINE (line 683) | EIGEN_STRONG_INLINE void broadcastRhs(const RhsScalar* b, RhsScalar& b0,...
function EIGEN_STRONG_INLINE (line 691) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 696) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 701) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Do...
function EIGEN_STRONG_INLINE (line 707) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Re...
function EIGEN_STRONG_INLINE (line 712) | EIGEN_STRONG_INLINE void acc(const Scalar& c, const Scalar& alpha, Scala...
function EIGEN_STRONG_INLINE (line 714) | EIGEN_STRONG_INLINE void acc(const DoublePacketType& c, const ResPacket&...
type RealScalar (line 751) | typedef RealScalar LhsScalar;
type Scalar (line 752) | typedef Scalar RhsScalar;
type Scalar (line 753) | typedef Scalar ResScalar;
type typename (line 773) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 774) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 775) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 777) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 778) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 779) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type ResPacket (line 781) | typedef ResPacket AccPacket;
function EIGEN_STRONG_INLINE (line 788) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacket& dest) const
function broadcastRhs (line 793) | void broadcastRhs(const RhsScalar* b, RhsPacket& b0, RhsPacket& b1, RhsP...
function EIGEN_STRONG_INLINE (line 805) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 810) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 816) | EIGEN_STRONG_INLINE void loadLhsUnaligned(const LhsScalar* a, LhsPacket&...
function EIGEN_STRONG_INLINE (line 821) | EIGEN_STRONG_INLINE void madd(const LhsPacket& a, const RhsPacket& b, Ac...
function EIGEN_STRONG_INLINE (line 826) | EIGEN_STRONG_INLINE void madd_impl(const LhsPacket& a, const RhsPacket& ...
function EIGEN_STRONG_INLINE (line 837) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function EIGEN_STRONG_INLINE (line 842) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
type gebp_traits (line 861) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs> Traits;
type typename (line 862) | typedef typename Traits::ResScalar ResScalar;
type typename (line 863) | typedef typename Traits::LhsPacket LhsPacket;
type typename (line 864) | typedef typename Traits::RhsPacket RhsPacket;
type typename (line 865) | typedef typename Traits::ResPacket ResPacket;
type typename (line 866) | typedef typename Traits::AccPacket AccPacket;
type gebp_traits (line 868) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs> Swapp...
type typename (line 869) | typedef typename SwappedTraits::ResScalar SResScalar;
type typename (line 870) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 871) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 872) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 873) | typedef typename SwappedTraits::AccPacket SAccPacket;
type typename (line 875) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 1591) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1592) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1593) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1594) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1901) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 2025) | typedef typename DataMapper::LinearMapper LinearMapper;
function l1CacheSize (line 2118) | inline std::ptrdiff_t l1CacheSize()
function l2CacheSize (line 2127) | inline std::ptrdiff_t l2CacheSize()
function l3CacheSize (line 2137) | inline std::ptrdiff_t l3CacheSize()
function setCpuCacheSizes (line 2149) | inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::...
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 58) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type const_blas_data_mapper (line 68) | typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMap...
type blas_data_mapper (line 69) | typedef blas_data_mapper<typename
function initParallelSession (line 215) | void initParallelSession(Index num_threads) const
type typename (line 233) | typedef typename Gemm::Traits Traits;
type _LhsScalar (line 249) | typedef _LhsScalar LhsScalar;
type _RhsScalar (line 250) | typedef _RhsScalar RhsScalar;
function LhsScalar (line 270) | inline LhsScalar* blockA() { return m_blockA; }
function RhsScalar (line 271) | inline RhsScalar* blockB() { return m_blockB; }
type typename (line 285) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 286) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 287) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 317) | void initParallel(Index, Index, Index, Index)
function allocateA (line 320) | inline void allocateA() {}
function allocateB (line 321) | inline void allocateB() {}
function allocateAll (line 322) | inline void allocateAll() {}
type typename (line 334) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 335) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 336) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 363) | void initParallel(Index rows, Index cols, Index depth, Index num_threads)
function allocateA (line 376) | void allocateA()
function allocateB (line 382) | void allocateB()
function allocateAll (line 388) | void allocateAll()
function namespace (line 403) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 139) | typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
type typename (line 140) | typedef typename Traits::ResScalar ResScalar;
type blas_data_mapper (line 147) | typedef blas_data_mapper<ResScalar, Index, ColMajor> ResMapper;
type typename (line 206) | typedef typename internal::remove_all<typename
type internal (line 207) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 208) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 209) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 212) | typedef typename internal::remove_all<typename
type internal (line 213) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 214) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 215) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 253) | typedef internal::blas_traits<Lhs> LhsBlasTraits;
type typename (line 254) | typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhs;
type typename (line 255) | typedef typename internal::remove_all<ActualLhs>::type _ActualLhs;
type typename (line 258) | typedef typename internal::remove_all<typename
type internal (line 259) | typedef internal::blas_traits<Rhs> RhsBlasTraits;
type typename (line 260) | typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhs;
type typename (line 261) | typedef typename internal::remove_all<ActualRhs>::type _ActualRhs;
type internal (line 281) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,t...
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h
function namespace (line 38) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixVector.h
function namespace (line 13) | namespace Eigen {
type typename (line 347) | typedef typename packet_traits<LhsScalar>::type _LhsPacket;
type typename (line 348) | typedef typename packet_traits<RhsScalar>::type _RhsPacket;
type typename (line 349) | typedef typename packet_traits<ResScalar>::type _ResPacket;
type typename (line 351) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 352) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 353) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type typename (line 387) | typedef typename LhsMapper::VectorMapper LhsScalars;
FILE: external/eigen3/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/Parallelizer.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 332) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 334) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 335) | typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMaj...
type const_blas_data_mapper (line 336) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 337) | typedef blas_data_mapper<typename
type gebp_traits (line 425) | typedef gebp_traits<Scalar,Scalar> Traits;
type const_blas_data_mapper (line 427) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type blas_data_mapper (line 428) | typedef blas_data_mapper<typename
function namespace (line 466) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector.h
function namespace (line 13) | namespace Eigen {
function namespace (line 160) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/SelfadjointProduct.h
function namespace (line 19) | namespace Eigen {
type internal (line 56) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 57) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 58) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 88) | typedef internal::blas_traits<OtherType> OtherBlasTraits;
type typename (line 89) | typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
type typename (line 90) | typedef typename internal::remove_all<ActualOtherType>::type _ActualOthe...
type internal (line 103) | typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,S...
FILE: external/eigen3/Eigen/src/Core/products/SelfadjointRank2Update.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename UBlasTraits::DirectLinearAccessType ActualUType;
type typename (line 65) | typedef typename internal::remove_all<ActualUType>::type _ActualUType;
type internal (line 68) | typedef internal::blas_traits<DerivedV> VBlasTraits;
type typename (line 69) | typedef typename VBlasTraits::DirectLinearAccessType ActualVType;
type typename (line 70) | typedef typename internal::remove_all<ActualVType>::type _ActualVType;
type typename (line 82) | typedef typename internal::remove_all<typename
type typename (line 83) | typedef typename internal::remove_all<typename
FILE: external/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 120) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 121) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 122) | typedef blas_data_mapper<typename
type const_blas_data_mapper (line 277) | typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
type const_blas_data_mapper (line 278) | typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
type blas_data_mapper (line 279) | typedef blas_data_mapper<typename
function namespace (line 397) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/TriangularMatrixVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 114) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
function LhsMap (line 115) | const LhsMap lhs(_lhs,rows,cols,OuterStride<>(lhsStride));
function namespace (line 171) | namespace internal {
function namespace (line 200) | namespace internal {
function run (line 290) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: external/eigen3/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h
type VectorX (line 96) | typedef VectorX##EIGPREFIX VectorRhs;
type VectorX (line 185) | typedef VectorX##EIGPREFIX VectorRhs;
FILE: external/eigen3/Eigen/src/Core/products/TriangularSolverMatrix.h
function namespace (line 13) | namespace Eigen {
type const_blas_data_mapper (line 56) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
type blas_data_mapper (line 57) | typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
type gebp_traits (line 61) | typedef gebp_traits<Scalar,Scalar> Traits;
type typename (line 205) | typedef typename NumTraits<Scalar>::Real RealScalar;
type blas_data_mapper (line 207) | typedef blas_data_mapper<Scalar, Index, ColMajor> LhsMapper;
type const_blas_data_mapper (line 208) | typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
type gebp_traits (line 212) | typedef gebp_traits<Scalar,Scalar> Traits;
FILE: external/eigen3/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/products/TriangularSolverVector.h
function namespace (line 13) | namespace Eigen {
type Map (line 38) | typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterSt...
FILE: external/eigen3/Eigen/src/Core/util/BlasUtil.h
function namespace (line 16) | namespace Eigen {
function EIGEN_STRONG_INLINE (line 81) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 84) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 91) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 94) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
function EIGEN_STRONG_INLINE (line 101) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const Scalar& y, const...
function EIGEN_STRONG_INLINE (line 104) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const Scalar& y) const
type std (line 110) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 111) | EIGEN_STRONG_INLINE Scalar pmadd(const Scalar& x, const RealScalar& y, c...
function EIGEN_STRONG_INLINE (line 113) | EIGEN_STRONG_INLINE Scalar pmul(const Scalar& x, const RealScalar& y) const
type std (line 119) | typedef std::complex<RealScalar> Scalar;
function EIGEN_STRONG_INLINE (line 120) | EIGEN_STRONG_INLINE Scalar pmadd(const RealScalar& x, const Scalar& y, c...
function EIGEN_STRONG_INLINE (line 122) | EIGEN_STRONG_INLINE Scalar pmul(const RealScalar& x, const Scalar& y) const
function To (line 127) | To run(const From& x) { return To(x); }
function typename (line 132) | typename NumTraits<Scalar>::Real run(const Scalar& x) { return numext::r...
function m_data (line 139) | m_data(data) {}
function Scalar (line 141) | Scalar operator()(Index i) const {
function EIGEN_ALWAYS_INLINE (line 145) | EIGEN_ALWAYS_INLINE Packet load(Index i) const {
function aligned (line 150) | bool aligned(Index i) const {
type typename (line 162) | typedef typename packet_traits<Scalar>::half HalfPacket;
function m_data (line 164) | m_data(data) {}
function prefetch (line 166) | void prefetch(int i) const {
function Packet (line 174) | Packet loadPacket(Index i) const {
function HalfPacket (line 178) | HalfPacket loadHalfPacket(Index i) const {
function storePacket (line 182) | void storePacket(Index i, const Packet &p) const {
type typename (line 195) | typedef typename packet_traits<Scalar>::half HalfPacket;
type BlasLinearMapper (line 197) | typedef BlasLinearMapper<Scalar, Index, AlignmentType> LinearMapper;
type BlasVectorMapper (line 198) | typedef BlasVectorMapper<Scalar, Index> VectorMapper;
function EIGEN_DEVICE_FUNC (line 200) | EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE blas_data_mapper(Scalar* data, Ind...
function LinearMapper (line 207) | LinearMapper getLinearMapper(Index i, Index j) const {
function VectorMapper (line 211) | VectorMapper getVectorMapper(Index i, Index j) const {
function Packet (line 221) | Packet loadPacket(Index i, Index j) const {
function HalfPacket (line 225) | HalfPacket loadHalfPacket(Index i, Index j) const {
function scatterPacket (line 230) | void scatterPacket(Index i, Index j, const SubPacket &p) const {
function EIGEN_ALWAYS_INLINE (line 235) | EIGEN_ALWAYS_INLINE SubPacket gatherPacket(Index i, Index j) const {
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC const Scalar* data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 242) | EIGEN_DEVICE_FUNC Index firstAligned(Index size) const {
type typename (line 271) | typedef typename traits<XprType>::Scalar Scalar;
type XprType (line 272) | typedef const XprType& ExtractType;
type XprType (line 273) | typedef XprType _ExtractType;
type typename (line 283) | typedef typename conditional<bool(HasUsableDirectAccess),
function ExtractType (line 287) | static inline ExtractType extract(const XprType& x) { return x; }
function Scalar (line 288) | static inline const Scalar extractScalarFactor(const XprType&) { return ...
type CwiseUnaryOp (line 297) | typedef CwiseUnaryOp<scalar_conjugate_op<Scalar>, NestedXpr> XprType;
type typename (line 298) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 304) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 305) | static inline Scalar extractScalarFactor(const XprType& x) { return conj...
type CwiseBinaryOp (line 314) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, const
type typename (line 315) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 316) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 317) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseBinaryOp (line 325) | typedef CwiseBinaryOp<scalar_product_op<Scalar>, NestedXpr, const
type typename (line 326) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 327) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 328) | static inline Scalar extractScalarFactor(const XprType& x)
type CwiseUnaryOp (line 343) | typedef CwiseUnaryOp<scalar_opposite_op<Scalar>, NestedXpr> XprType;
type typename (line 344) | typedef typename Base::ExtractType ExtractType;
function ExtractType (line 345) | static inline ExtractType extract(const XprType& x) { return Base::extra...
function Scalar (line 346) | static inline Scalar extractScalarFactor(const XprType& x)
type typename (line 355) | typedef typename NestedXpr::Scalar Scalar;
type blas_traits (line 356) | typedef blas_traits<NestedXpr> Base;
type Transpose (line 357) | typedef Transpose<NestedXpr> XprType;
type Transpose (line 358) | typedef Transpose<const typename
type Transpose (line 359) | typedef Transpose<const typename
type typename (line 360) | typedef typename conditional<bool(Base::HasUsableDirectAccess),
function ExtractType (line 367) | static inline ExtractType extract(const XprType& x) { return ExtractType...
function Scalar (line 368) | static inline Scalar extractScalarFactor(const XprType& x) { return Base...
function typename (line 378) | static const typename T::Scalar* run(const T& m)
function typename (line 386) | static typename T::Scalar* run(const T&) { return 0; }
function typename (line 389) | typename T::Scalar* extract_data(const T& m)
FILE: external/eigen3/Eigen/src/Core/util/Constants.h
type UpLoType (line 202) | enum UpLoType {
type AlignmentType (line 227) | enum AlignmentType {
type CornerType (line 257) | enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight }
type DirectionType (line 262) | enum DirectionType {
type TraversalType (line 276) | enum TraversalType {
type UnrollingType (line 298) | enum UnrollingType {
type SpecializedType (line 310) | enum SpecializedType {
type StorageOptions (line 318) | enum StorageOptions {
type SideType (line 331) | enum SideType {
type NoChange_t (line 350) | enum NoChange_t { NoChange }
type Sequential_t (line 351) | enum Sequential_t { Sequential }
type Default_t (line 352) | enum Default_t { Default }
type AmbiVectorMode (line 356) | enum AmbiVectorMode {
type AccessorLevels (line 364) | enum AccessorLevels {
type DecompositionOptions (line 377) | enum DecompositionOptions {
type QRPreconditioners (line 413) | enum QRPreconditioners {
type ComputationInfo (line 430) | enum ComputationInfo {
type TransformTraits (line 445) | enum TransformTraits {
function namespace (line 459) | namespace Architecture
type ProductImplType (line 483) | enum ProductImplType
type Action (line 488) | enum Action {GetAction, SetAction}
type Dense (line 491) | struct Dense {}
type Sparse (line 494) | struct Sparse {}
type SolverStorage (line 497) | struct SolverStorage {}
type PermutationStorage (line 500) | struct PermutationStorage {}
type TranspositionsStorage (line 503) | struct TranspositionsStorage {}
type MatrixXpr (line 506) | struct MatrixXpr {}
type ArrayXpr (line 509) | struct ArrayXpr {}
type HomogeneousShape (line 514) | struct HomogeneousShape { static std::string debugName() { return ...
FILE: external/eigen3/Eigen/src/Core/util/ForwardDeclarations.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/util/MKL_support.h
function namespace (line 116) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/util/Macros.h
function namespace (line 544) | namespace Eigen {
function namespace (line 555) | namespace Eigen {
function namespace (line 613) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/util/Memory.h
function namespace (line 62) | namespace Eigen {
function conditional_aligned_free (line 228) | inline void conditional_aligned_free(void *ptr)
function destruct_elements_of_array (line 255) | inline void destruct_elements_of_array(T *ptr, std::size_t size)
function T (line 265) | inline T* construct_elements_of_array(T *ptr, std::size_t size)
function check_size_for_overflow (line 286) | void check_size_for_overflow(std::size_t size)
function T (line 296) | inline T* aligned_new(std::size_t size)
function T (line 312) | inline T* conditional_aligned_new(std::size_t size)
function aligned_delete (line 331) | inline void aligned_delete(T *ptr, std::size_t size)
function conditional_aligned_delete (line 340) | inline void conditional_aligned_delete(T *ptr, std::size_t size)
function T (line 346) | inline T* conditional_aligned_realloc_new(T* pts, std::size_t new_size, ...
function T (line 369) | inline T* conditional_aligned_new_auto(std::size_t size)
function conditional_aligned_delete_auto (line 412) | inline void conditional_aligned_delete_auto(T *ptr, std::size_t size)
function Index (line 439) | inline Index first_aligned(const Scalar* array, Index size)
function Index (line 467) | inline Index first_default_aligned(const Scalar* array, Index size)
function Index (line 476) | Index first_multiple(Index size, Index base)
function smart_copy (line 485) | void smart_copy(const T* start, const T* end, T* target)
function EIGEN_DEVICE_FUNC (line 491) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function EIGEN_DEVICE_FUNC (line 501) | EIGEN_DEVICE_FUNC static inline void run(const T* start, const T* end, T...
function run (line 514) | static inline void run(const T* start, const T* end, T* target)
function run (line 524) | static inline void run(const T* start, const T* end, T* target)
function T (line 596) | const T& operator[](std::ptrdiff_t i) const { return m_ptr[i]; }
function T (line 598) | const T* ptr() const { return m_ptr; }
function operator (line 599) | operator const T*() const { return m_ptr; }
function operator (line 682) | operator delete(void *ptr, const std::nothrow_t&) EIGEN_NO_THROW { \
type eigen_aligned_operator_new_marker_type (line 685) | typedef void eigen_aligned_operator_new_marker_type;
type T (line 726) | typedef T* pointer;
type T (line 727) | typedef const T* const_pointer;
type T (line 728) | typedef T& reference;
type T (line 729) | typedef const T& const_reference;
type T (line 730) | typedef T value_type;
type aligned_allocator (line 735) | typedef aligned_allocator<U> other;
function deallocate (line 761) | void deallocate(pointer p, size_type /*num*/)
function namespace (line 792) | namespace internal {
FILE: external/eigen3/Eigen/src/Core/util/Meta.h
function namespace (line 23) | namespace Eigen {
type T (line 140) | typedef const T type;
type T (line 141) | typedef T const& type;
type T (line 142) | typedef T const* type;
type T (line 143) | typedef T const* const type;
type T (line 144) | typedef T const* const type;
type any_conversion (line 151) | struct any_conversion
type yes (line 156) | struct yes {int a[1];}
type no (line 157) | struct no {int a[2];}
type T (line 187) | typedef T type;
function namespace (line 195) | namespace device {
function class (line 294) | class noncopyable
type typename (line 312) | typedef typename std::result_of<T>::type type1;
type typename (line 313) | typedef typename remove_all<type1>::type type;
type has_none (line 318) | struct has_none {int a[1];}
type has_std_result_type (line 319) | struct has_std_result_type {int a[2];}
type has_tr1_result (line 320) | struct has_tr1_result {int a[3];}
type typename (line 323) | typedef typename internal::remove_all<ArgType>::type type;
type typename (line 341) | typedef typename unary_result_of_select<Func, ArgType, FunctorType>::typ...
type typename (line 345) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 365) | typedef typename binary_result_of_select<Func, ArgType0, ArgType1, Funct...
type typename (line 369) | typedef typename internal::remove_all<ArgType0>::type type;
type typename (line 389) | typedef typename ternary_result_of_select<Func, ArgType0, ArgType1, ArgT...
type meta_yes (line 393) | struct meta_yes { char a[1]; }
type meta_no (line 394) | struct meta_no { char a[2]; }
function meta_yes (line 411) | meta_yes testFunctor(C const *,typename enable_if<(sizeof(return_ptr<C>(...
FILE: external/eigen3/Eigen/src/Core/util/StaticAssert.h
function namespace (line 37) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Core/util/XprHelper.h
function namespace (line 25) | namespace Eigen {
function class (line 89) | class no_assignment_operator
type typename (line 191) | typedef typename find_best_packet_helper<Size,typename
type typename (line 282) | typedef typename plain_matrix_type_dense<T,typename
type typename (line 286) | typedef typename T::PlainObject type;
type typename (line 319) | typedef typename plain_matrix_type<T>::type type;
type typename (line 332) | typedef typename plain_matrix_type<T>::type type;
type typename (line 355) | typedef typename plain_matrix_type_dense<T,typename
type Matrix (line 368) | typedef Matrix<typename
type Matrix (line 386) | typedef Matrix<typename
type typename (line 401) | typedef typename conditional<
type typename (line 407) | typedef typename conditional<
type typename (line 418) | typedef typename conditional<
type typename (line 455) | typedef typename conditional<Evaluate, PlainObject, typename
function T (line 460) | inline T* const_cast_ptr(const T* ptr)
type typename (line 494) | typedef typename XprType::Scalar CurrentScalarType;
type typename (line 495) | typedef typename remove_all<CastType>::type _CastType;
type typename (line 496) | typedef typename _CastType::Scalar NewScalarType;
type typename (line 497) | typedef typename conditional<is_same<CurrentScalarType,NewScalarType>::v...
type A (line 505) | typedef A ret;
type A (line 509) | typedef A ret;
type A (line 513) | typedef A ret;
type Matrix (line 584) | typedef Matrix<Scalar, 1, ExpressionType::ColsAtCompileTime,
type Array (line 586) | typedef Array<Scalar, 1, ExpressionType::ColsAtCompileTime,
type typename (line 589) | typedef typename conditional<
type Matrix (line 599) | typedef Matrix<Scalar, ExpressionType::RowsAtCompileTime, 1,
type Array (line 601) | typedef Array<Scalar, ExpressionType::RowsAtCompileTime, 1,
type typename (line 604) | typedef typename conditional<
type Matrix (line 617) | typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type Array (line 618) | typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options
type typename (line 620) | typedef typename conditional<
type Array (line 632) | typedef Array<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>::...
type Matrix (line 635) | typedef Matrix<Scalar, traits<Expr>::RowsAtCompileTime, traits<Expr>:...
type CwiseNullaryOp (line 638) | typedef CwiseNullaryOp<scalar_constant_op<Scalar>, const
type glue_shapes (line 661) | struct glue_shapes
type TriangularShape (line 661) | typedef TriangularShape type;
type ScalarBinaryOpTraits (line 769) | struct ScalarBinaryOpTraits
type T (line 779) | typedef T ReturnType;
type T (line 785) | typedef T ReturnType;
type T (line 790) | typedef T ReturnType;
type T (line 797) | typedef T ReturnType;
type T (line 804) | typedef T ReturnType;
type ReturnType (line 811) | typedef void ReturnType;
FILE: external/eigen3/Eigen/src/Eigenvalues/ComplexEigenSolver.h
function namespace (line 17) | namespace Eigen {
function EigenvalueType (line 182) | const EigenvalueType& eigenvalues() const
function Index (line 233) | Index getMaxIterations()
FILE: external/eigen3/Eigen/src/Eigenvalues/ComplexSchur.h
function namespace (line 17) | namespace Eigen {
function ComplexMatrixType (line 162) | const ComplexMatrixType& matrixT() const
function Index (line 235) | Index getMaxIterations()
function namespace (line 349) | namespace internal {
FILE: external/eigen3/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/EigenSolver.h
function namespace (line 16) | namespace Eigen {
function EigenvalueType (line 244) | const EigenvalueType& eigenvalues() const
function Index (line 295) | Index getMaxIterations()
type Matrix (line 319) | typedef Matrix<Scalar, ColsAtCompileTime, 1, Options
FILE: external/eigen3/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
function namespace (line 17) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/HessenbergDecomposition.h
function namespace (line 14) | namespace Eigen {
function CoeffVectorType (line 179) | const CoeffVectorType& householderCoefficients() const
type typename (line 271) | typedef typename NumTraits<Scalar>::Real RealScalar;
function namespace (line 322) | namespace internal {
FILE: external/eigen3/Eigen/src/Eigenvalues/MatrixBaseEigenvalues.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/RealQZ.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 139) | const MatrixType& matrixS() const {
type Matrix (line 200) | typedef Matrix<Scalar,3,1> Vector3s;
type Matrix (line 201) | typedef Matrix<Scalar,2,1> Vector2s;
type Matrix (line 202) | typedef Matrix<Scalar,2,2> Matrix2s;
type JacobiRotation (line 203) | typedef JacobiRotation<Scalar> JRs;
FILE: external/eigen3/Eigen/src/Eigenvalues/RealSchur.h
function namespace (line 16) | namespace Eigen {
function MatrixType (line 144) | const MatrixType& matrixT() const
function Index (line 213) | Index getMaxIterations()
type Matrix (line 236) | typedef Matrix<Scalar,3,1> Vector3s;
function typename (line 353) | typename MatrixType::Scalar RealSchur<MatrixType>::computeNormOfT()
FILE: external/eigen3/Eigen/src/Eigenvalues/RealSchur_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
function namespace (line 16) | namespace Eigen {
function namespace (line 370) | namespace internal {
function namespace (line 469) | namespace internal {
type typename (line 715) | typedef typename SolverType::RealVectorType VectorType;
type typename (line 716) | typedef typename SolverType::Scalar Scalar;
type typename (line 717) | typedef typename SolverType::EigenvectorsType EigenvectorsType;
function EIGEN_DEVICE_FUNC (line 719) | EIGEN_DEVICE_FUNC
function namespace (line 805) | namespace internal {
FILE: external/eigen3/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Eigenvalues/Tridiagonalization.h
function namespace (line 14) | namespace Eigen {
function namespace (line 321) | namespace internal {
type typename (line 439) | typedef typename Tridiagonalization<MatrixType>::CoeffVectorType CoeffVe...
type typename (line 440) | typedef typename Tridiagonalization<MatrixType>::HouseholderSequenceType...
type typename (line 463) | typedef typename MatrixType::RealScalar RealScalar;
FILE: external/eigen3/Eigen/src/Geometry/AlignedBox.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 146) | EIGEN_DEVICE_FUNC inline VectorType corner(CornerType corner) const
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC inline VectorType sample() const
function contains (line 182) | inline bool contains(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC inline bool contains(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 194) | EIGEN_DEVICE_FUNC inline bool intersects(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 210) | EIGEN_DEVICE_FUNC inline AlignedBox& extend(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 220) | EIGEN_DEVICE_FUNC inline AlignedBox& clamp(const AlignedBox& b)
function EIGEN_DEVICE_FUNC (line 230) | EIGEN_DEVICE_FUNC inline AlignedBox intersection(const AlignedBox& b) const
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC inline AlignedBox merged(const AlignedBox& b) const
function NonInteger (line 267) | inline NonInteger exteriorDistance(const MatrixBase<Derived>& p) const
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC inline NonInteger exteriorDistance(const AlignedBox& b...
function explicit (line 292) | inline explicit AlignedBox(const AlignedBox<OtherScalarType,AmbientDimAt...
FILE: external/eigen3/Eigen/src/Geometry/AngleAxis.h
function namespace (line 13) | namespace Eigen {
function explicit (line 139) | inline explicit AngleAxis(const AngleAxis<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 145) | EIGEN_DEVICE_FUNC static inline const AngleAxis Identity() { return Angl...
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC bool isApprox(const AngleAxis& other, const typename N...
type AngleAxis (line 157) | typedef AngleAxis<float> AngleAxisf;
type AngleAxis (line 160) | typedef AngleAxis<double> AngleAxisd;
FILE: external/eigen3/Eigen/src/Geometry/EulerAngles.h
function namespace (line 13) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Geometry/Homogeneous.h
function namespace (line 13) | namespace Eigen {
type MatrixBase (line 68) | typedef MatrixBase<Homogeneous> Base;
function explicit (line 71) | explicit inline Homogeneous(const MatrixType& matrix)
function EIGEN_DEVICE_FUNC (line 299) | EIGEN_DEVICE_FUNC homogeneous_right_product_impl(const MatrixType& lhs, ...
type HomogeneousShape (line 325) | typedef HomogeneousShape Shape;
type AssignmentKind (line 328) | struct AssignmentKind
type Dense2Dense (line 328) | typedef Dense2Dense Kind;
type typename (line 336) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 337) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 339) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
type Homogeneous (line 370) | typedef Homogeneous<ArgType,Horizontal> SrcXprType;
type typename (line 400) | typedef typename Rhs::template
type typename (line 401) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 402) | typedef typename Rhs::ConstRowXpr Co...
type Replicate (line 403) | typedef Replicate<const ConstantColumn,Rows,1> Co...
type Product (line 404) | typedef Product<Lhs,LinearBlock,LazyProduct> Li...
type CwiseBinaryOp (line 405) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_right_product_refactoring_helper (line 413) | typedef homogeneous_right_product_refactoring_helper<typename
type typename (line 414) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 415) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 416) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 418) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
type typename (line 453) | typedef typename Lhs::template
type typename (line 454) | typedef typename remove_const<LinearBlockConst>::type Li...
type typename (line 455) | typedef typename Lhs::ConstColXpr Co...
type Replicate (line 456) | typedef Replicate<const ConstantColumn,1,Cols> Co...
type Product (line 457) | typedef Product<LinearBlock,Rhs,LazyProduct> Li...
type CwiseBinaryOp (line 458) | typedef CwiseBinaryOp<internal::scalar_sum_op<typename
type homogeneous_left_product_refactoring_helper (line 466) | typedef homogeneous_left_product_refactoring_helper<Lhs,typename
type typename (line 467) | typedef typename helper::ConstantBlock ConstantBlock;
type typename (line 468) | typedef typename helper::Xpr RefactoredXpr;
type evaluator (line 469) | typedef evaluator<RefactoredXpr> Base;
function EIGEN_DEVICE_FUNC (line 471) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function evalTo (line 482) | static void evalTo(Dest& dst, const TransformType& lhs, const Homogeneou...
FILE: external/eigen3/Eigen/src/Geometry/Hyperplane.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Geometry/OrthoMethods.h
function namespace (line 14) | namespace Eigen {
function namespace (line 50) | namespace internal {
type typename (line 87) | typedef typename internal::nested_eval<Derived,2>::type DerivedNested;
type typename (line 88) | typedef typename internal::nested_eval<OtherDerived,2>::type OtherDerive...
function namespace (line 137) | namespace internal {
FILE: external/eigen3/Eigen/src/Geometry/ParametrizedLine.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Geometry/Quaternion.h
function namespace (line 13) | namespace Eigen {
function namespace (line 327) | namespace internal {
type _Scalar (line 357) | typedef _Scalar Scalar;
type typename (line 358) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 368) | EIGEN_STRONG_INLINE Map(const Scalar* coeffs) : m_coeffs(coeffs) {}
type _Scalar (line 394) | typedef _Scalar Scalar;
type typename (line 395) | typedef typename internal::traits<Map>::Coefficients Coefficients;
function EIGEN_STRONG_INLINE (line 405) | EIGEN_STRONG_INLINE Map(Scalar* coeffs) : m_coeffs(coeffs) {}
function EIGEN_DEVICE_FUNC (line 407) | EIGEN_DEVICE_FUNC inline Coefficients& coeffs() { return m_coeffs; }
type Map (line 416) | typedef Map<Quaternion<float>, 0> QuaternionMapf;
type Map (line 419) | typedef Map<Quaternion<double>, 0> QuaternionMapd;
type Map (line 422) | typedef Map<Quaternion<float>, Aligned> QuaternionMapAlignedf;
type Map (line 425) | typedef Map<Quaternion<double>, Aligned> QuaternionMapAlignedd;
function namespace (line 433) | namespace internal {
function typename (line 538) | inline typename QuaternionBase<Derived>::Matrix3
function namespace (line 681) | namespace internal {
function typename (line 710) | inline typename internal::traits<Derived>::Scalar
function namespace (line 759) | namespace internal {
function run (line 807) | static inline void run(QuaternionBase<Derived>& q, const Other& vec)
FILE: external/eigen3/Eigen/src/Geometry/Rotation2D.h
function namespace (line 13) | namespace Eigen {
function explicit (line 147) | inline explicit Rotation2D(const Rotation2D<OtherScalarType>& other)
function EIGEN_DEVICE_FUNC (line 152) | EIGEN_DEVICE_FUNC static inline Rotation2D Identity() { return Rotation2...
function EIGEN_DEVICE_FUNC (line 158) | EIGEN_DEVICE_FUNC bool isApprox(const Rotation2D& other, const typename ...
type Rotation2D (line 165) | typedef Rotation2D<float> Rotation2Df;
type Rotation2D (line 168) | typedef Rotation2D<double> Rotation2Dd;
FILE: external/eigen3/Eigen/src/Geometry/RotationBase.h
function namespace (line 13) | namespace Eigen {
function VectorType (line 93) | inline VectorType _transformVector(const OtherVectorType& v) const
function namespace (line 97) | namespace internal {
function EIGEN_DEVICE_FUNC (line 113) | EIGEN_DEVICE_FUNC static inline ReturnType run(const RotationDerived& r,...
type Matrix (line 125) | typedef Matrix<typename
function ReturnType (line 126) | ReturnType run(const RotationDerived& r, const OtherVectorType& v)
function namespace (line 161) | namespace internal {
FILE: external/eigen3/Eigen/src/Geometry/Scaling.h
function explicit (line 48) | explicit inline UniformScaling(const Scalar& s) : m_factor(s) {}
function Scalar (line 51) | inline Scalar& factor() { return m_factor; }
function UniformScaling (line 54) | inline UniformScaling operator* (const UniformScaling& other) const
function typename (line 73) | typename internal::plain_matrix_type<Derived>::type operator* (const Mat...
function UniformScaling (line 81) | inline UniformScaling inverse() const
type DiagonalMatrix (line 146) | typedef DiagonalMatrix<float, 2> AlignedScaling2f;
type DiagonalMatrix (line 148) | typedef DiagonalMatrix<double,2> AlignedScaling2d;
type DiagonalMatrix (line 150) | typedef DiagonalMatrix<float, 3> AlignedScaling3f;
type DiagonalMatrix (line 152) | typedef DiagonalMatrix<double,3> AlignedScaling3d;
FILE: external/eigen3/Eigen/src/Geometry/Transform.h
function namespace (line 15) | namespace Eigen {
type _Scalar (line 213) | typedef _Scalar Scalar;
type Eigen (line 214) | typedef Eigen::Index StorageIndex;
type Eigen (line 215) | typedef Eigen::Index Index;
type typename (line 217) | typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Opti...
type MatrixType (line 219) | typedef const MatrixType ConstMatrixType;
type Matrix (line 221) | typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
type Block (line 223) | typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (Options&...
type Block (line 225) | typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) &...
type typename (line 227) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type typename (line 231) | typedef typename internal::conditional<int(Mode)==int(AffineCompact),
type Matrix (line 235) | typedef Matrix<Scalar,Dim,1> VectorType;
type Block (line 237) | typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & R...
type Block (line 239) | typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>...
type Translation (line 241) | typedef Translation<Scalar,Dim> TranslationType;
type Transform (line 246) | typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDia...
function EIGEN_DEVICE_FUNC (line 262) | EIGEN_DEVICE_FUNC inline Transform(const Transform& other)
function EIGEN_DEVICE_FUNC (line 268) | EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
function EIGEN_DEVICE_FUNC (line 273) | EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>...
function explicit (line 279) | inline explicit Transform(const RotationBase<Derived, Dim>& r)
type internal (line 288) | typedef internal::transform_take_affine_part<Transform> take_affine_part;
function explicit (line 292) | inline explicit Transform(const EigenBase<OtherDerived>& other)
type typename (line 348) | typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixTyp...
function EIGEN_DEVICE_FUNC (line 389) | EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const ...
function EIGEN_DEVICE_FUNC (line 392) | EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { ret...
function EIGEN_DEVICE_FUNC (line 397) | EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
function EIGEN_DEVICE_FUNC (line 402) | EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matri...
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_af...
type internal (line 509) | typedef internal::transform_transform_product_impl<Transform,Transform<S...
type typename (line 510) | typedef typename ProductType::ResultType ResultType;
type typename (line 519) | typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ...
function EIGEN_DEVICE_FUNC (line 533) | EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
function EIGEN_DEVICE_FUNC (line 539) | EIGEN_DEVICE_FUNC static const Transform Identity()
function Scalar (line 622) | const Scalar* data() const { return m_matrix.data(); }
function EIGEN_DEVICE_FUNC (line 624) | EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
function explicit (line 637) | inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Optio...
function EIGEN_DEVICE_FUNC (line 647) | EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename N...
function EIGEN_DEVICE_FUNC (line 652) | EIGEN_DEVICE_FUNC void makeAffine()
function check_template_params (line 690) | void check_template_params()
function else (line 917) | else
function namespace (line 1140) | namespace internal {
function namespace (line 1231) | namespace internal {
function MatrixType (line 1251) | static inline const MatrixType& run(const MatrixType& m) { return m; }
function EIGEN_STRONG_INLINE (line 1315) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1331) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1333) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1357) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1359) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1382) | typedef typename MatrixType::PlainObject ResultType;
function EIGEN_STRONG_INLINE (line 1384) | static EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const ...
type typename (line 1404) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1405) | typedef Transform<typename
function ResultType (line 1406) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1415) | typedef typename TransformType::MatrixType MatrixType;
type Transform (line 1416) | typedef Transform<typename
function ResultType (line 1417) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1431) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1432) | typedef TransformType ResultType;
function ResultType (line 1433) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1447) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1448) | typedef TransformType ResultType;
function ResultType (line 1449) | static ResultType run(const Other& other,const TransformType& tr)
type typename (line 1463) | typedef typename TransformType::MatrixType MatrixType;
type TransformType (line 1464) | typedef TransformType ResultType;
function ResultType (line 1465) | static ResultType run(const Other& other, const TransformType& tr)
type Transform (line 1484) | typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
type Transform (line 1485) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1486) | typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
function ResultType (line 1487) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1501) | typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
type Transform (line 1502) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1503) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1513) | typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
type Transform (line 1514) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1515) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
type Transform (line 1528) | typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
type Transform (line 1529) | typedef Transform<Scalar,Dim,Projective> ResultType;
function ResultType (line 1530) | static ResultType run(const Lhs& lhs, const Rhs& rhs)
FILE: external/eigen3/Eigen/src/Geometry/Translation.h
function namespace (line 13) | namespace Eigen {
function explicit (line 154) | inline explicit Translation(const Translation<OtherScalarType,Dim>& other)
function EIGEN_DEVICE_FUNC (line 161) | EIGEN_DEVICE_FUNC bool isApprox(const Translation& other, const typename...
type Translation (line 168) | typedef Translation<float, 2> Translation2f;
type Translation (line 169) | typedef Translation<double,2> Translation2d;
type Translation (line 170) | typedef Translation<float, 3> Translation3f;
type Translation (line 171) | typedef Translation<double,3> Translation3d;
FILE: external/eigen3/Eigen/src/Geometry/Umeyama.h
function namespace (line 26) | namespace internal {
type typename (line 97) | typedef typename internal::umeyama_transform_matrix_type<Derived, OtherD...
type typename (line 98) | typedef typename internal::traits<TransformationMatrixType>::Scalar Scalar;
type typename (line 99) | typedef typename NumTraits<Scalar>::Real RealScalar;
function EIGEN_STATIC_ASSERT (line 102) | EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits...
FILE: external/eigen3/Eigen/src/Geometry/arch/Geometry_SSE.h
function namespace (line 14) | namespace Eigen {
function Quaternion (line 91) | static inline Quaternion<double> run(const QuaternionBase<Derived>& _a, ...
function Quaternion (line 146) | static inline Quaternion<double> run(const QuaternionBase<Derived>& q)
FILE: external/eigen3/Eigen/src/Householder/BlockHouseholder.h
function namespace (line 16) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Householder/Householder.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/Householder/HouseholderSequence.h
function namespace (line 14) | namespace Eigen {
type Block (line 88) | typedef Block<const VectorsType, Dynamic, 1> EssentialVectorType;
type HouseholderSequence (line 89) | typedef HouseholderSequence<VectorsType, CoeffsType, OnTheLeft> Househol...
function EssentialVectorType (line 90) | static inline const EssentialVectorType essentialVector(const Householde...
type HouseholderSequence (line 101) | typedef HouseholderSequence<VectorsType, CoeffsType, OnTheRight> Househo...
function EssentialVectorType (line 102) | static inline const EssentialVectorType essentialVector(const Householde...
type typename (line 111) | typedef typename ScalarBinaryOpTraits<OtherScalarType, typename
type Matrix (line 113) | typedef Matrix<ResultScalar, MatrixType::RowsAtCompileTime, MatrixType::...
type typename (line 131) | typedef typename internal::traits<HouseholderSequence>::Scalar Scalar;
type HouseholderSequence (line 133) | typedef HouseholderSequence<
function EssentialVectorType (line 202) | const EssentialVectorType essentialVector(Index k) const
type Block (line 326) | typedef Block<typename
type internal (line 364) | struct internal
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/BasicPreconditioners.h
function namespace (line 13) | namespace Eigen {
type _Scalar (line 130) | typedef _Scalar Scalar;
type typename (line 131) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DiagonalPreconditioner (line 132) | typedef DiagonalPreconditioner<_Scalar> Base;
function Base (line 139) | LeastSquareDiagonalPreconditioner(const MatType& mat) : Base()
function ComputationInfo (line 188) | ComputationInfo info() { return Success; }
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/BiCGSTAB.h
function namespace (line 14) | namespace Eigen {
type typename (line 168) | typedef typename MatrixType::Scalar Scalar;
type typename (line 169) | typedef typename MatrixType::RealScalar RealScalar;
type _Preconditioner (line 170) | typedef _Preconditioner Preconditioner;
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
function namespace (line 13) | namespace Eigen {
type typename (line 168) | typedef typename MatrixType::Scalar Scalar;
type typename (line 169) | typedef typename MatrixType::RealScalar RealScalar;
type _Preconditioner (line 170) | typedef _Preconditioner Preconditioner;
type typename (line 200) | typedef typename Base::MatrixWrapper MatrixWrapper;
type typename (line 201) | typedef typename Base::ActualMatrixType ActualMatrixType;
type typename (line 208) | typedef typename internal::conditional<TransposeInput,Transpose<const Ac...
type typename (line 210) | typedef typename internal::conditional<UpLo==(Lower|Upper),
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/IncompleteCholesky.h
function namespace (line 17) | namespace Eigen {
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/IncompleteLUT.h
function namespace (line 15) | namespace Eigen {
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/IterativeSolverBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 151) | typedef typename internal::traits<Derived>::Preconditioner Preconditioner;
type typename (line 152) | typedef typename MatrixType::Scalar Scalar;
type typename (line 153) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 154) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 341) | typedef typename DestDerived::Scalar DestScalar;
type internal (line 366) | typedef internal::generic_matrix_wrapper<MatrixType> MatrixWrapper;
type typename (line 367) | typedef typename MatrixWrapper::ActualMatrixType ActualMatrixType;
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/LeastSquareConjugateGradient.h
function namespace (line 13) | namespace Eigen {
type typename (line 159) | typedef typename MatrixType::Scalar Scalar;
type typename (line 160) | typedef typename MatrixType::RealScalar RealScalar;
type _Preconditioner (line 161) | typedef _Preconditioner Preconditioner;
FILE: external/eigen3/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
function namespace (line 13) | namespace Eigen {
function namespace (line 70) | namespace internal {
type SolveWithGuess (line 98) | typedef SolveWithGuess<DecType,RhsType,GuessType> SrcXprType;
function run (line 99) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: external/eigen3/Eigen/src/Jacobi/Jacobi.h
function namespace (line 14) | namespace Eigen {
function namespace (line 258) | namespace internal {
function namespace (line 299) | namespace internal {
type typename (line 434) | typedef typename VectorX::Scalar Scalar;
FILE: external/eigen3/Eigen/src/LU/Determinant.h
function namespace (line 15) | namespace internal {
FILE: external/eigen3/Eigen/src/LU/FullPivLU.h
function namespace (line 13) | namespace Eigen {
function MatrixType (line 407) | MatrixType reconstructedMatrix() const;
type internal (line 518) | typedef internal::scalar_score_coeff_op<Scalar> Scoring;
type typename (line 519) | typedef typename Scoring::result_type Score;
function namespace (line 617) | namespace internal {
function namespace (line 858) | namespace internal {
FILE: external/eigen3/Eigen/src/LU/InverseImpl.h
function namespace (line 14) | namespace Eigen {
function compute_inverse_size2_helper (line 76) | inline void compute_inverse_size2_helper(
function run (line 90) | static inline void run(const MatrixType& matrix, ResultType& result)
function run (line 102) | static inline void run(
function typename (line 126) | inline typename MatrixType::Scalar cofactor_3x3(const MatrixType& m)
function compute_inverse_size3_helper (line 140) | inline void compute_inverse_size3_helper(
function run (line 159) | static inline void run(const MatrixType& matrix, ResultType& result)
function run (line 176) | static inline void run(
function typename (line 204) | inline const typename Derived::Scalar general_det3_helper
function typename (line 213) | inline typename MatrixType::Scalar cofactor_4x4(const MatrixType& matrix)
function EIGEN_DEVICE_FUNC (line 231) | EIGEN_DEVICE_FUNC
function run (line 265) | static inline void run(
function namespace (line 286) | namespace internal {
type typename (line 373) | typedef typename internal::conditional<
FILE: external/eigen3/Eigen/src/LU/PartialPivLU.h
function namespace (line 14) | namespace Eigen {
function namespace (line 339) | namespace internal {
function namespace (line 564) | namespace internal {
FILE: external/eigen3/Eigen/src/LU/PartialPivLU_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/LU/arch/Inverse_SSE.h
function namespace (line 30) | namespace Eigen {
FILE: external/eigen3/Eigen/src/MetisSupport/MetisSupport.h
function namespace (line 12) | namespace Eigen {
FILE: external/eigen3/Eigen/src/OrderingMethods/Amd.h
function namespace (line 34) | namespace Eigen {
FILE: external/eigen3/Eigen/src/OrderingMethods/Eigen_Colamd.h
function namespace (line 50) | namespace internal {
FILE: external/eigen3/Eigen/src/OrderingMethods/Ordering.h
function namespace (line 14) | namespace Eigen {
type Matrix (line 122) | typedef Matrix<StorageIndex, Dynamic, 1> IndexVector;
FILE: external/eigen3/Eigen/src/PaStiXSupport/PaStiXSupport.h
function namespace (line 13) | namespace Eigen {
function eigen_pastix (line 67) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 74) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 81) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
function eigen_pastix (line 88) | inline void eigen_pastix(pastix_data_t **pastix_data, int pastix_comm, i...
type typename (line 137) | typedef typename internal::pastix_traits<Derived>::MatrixType _MatrixType;
type _MatrixType (line 138) | typedef _MatrixType MatrixType;
type typename (line 139) | typedef typename MatrixType::Scalar Scalar;
type typename (line 140) | typedef typename MatrixType::RealScalar RealScalar;
type typename (line 141) | typedef typename MatrixType::StorageIndex StorageIndex;
type Matrix (line 142) | typedef Matrix<Scalar,Dynamic,1> Vector;
type SparseMatrix (line 143) | typedef SparseMatrix<Scalar, ColMajor> ColSpMatrix;
function iparm (line 178) | int& iparm(int idxparam)
function dparm (line 196) | double& dparm(int idxparam)
function clean (line 230) | void clean()
type PastixBase (line 416) | typedef PastixBase<PastixLU<MatrixType> > Base;
type typename (line 417) | typedef typename Base::ColSpMatrix ColSpMatrix;
type typename (line 418) | typedef typename MatrixType::StorageIndex StorageIndex;
function explicit (line 426) | explicit PastixLU(const MatrixType& matrix):Base()
function compute (line 436) | void compute (const MatrixType& matrix)
function analyzePattern (line 448) | void analyzePattern(const MatrixType& matrix)
function factorize (line 461) | void factorize(const MatrixType& matrix)
function grabMatrix (line 476) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
type PastixBase (line 528) | typedef PastixBase<PastixLLT<MatrixType, _UpLo> > Base;
type typename (line 529) | typedef typename Base::ColSpMatrix ColSpMatrix;
function explicit (line 538) | explicit PastixLLT(const MatrixType& matrix):Base()
function compute (line 547) | void compute (const MatrixType& matrix)
function analyzePattern (line 558) | void analyzePattern(const MatrixType& matrix)
function factorize (line 567) | void factorize(const MatrixType& matrix)
function init (line 576) | void init()
function grabMatrix (line 582) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
type PastixBase (line 612) | typedef PastixBase<PastixLDLT<MatrixType, _UpLo> > Base;
type typename (line 613) | typedef typename Base::ColSpMatrix ColSpMatrix;
function explicit (line 622) | explicit PastixLDLT(const MatrixType& matrix):Base()
function compute (line 631) | void compute (const MatrixType& matrix)
function analyzePattern (line 642) | void analyzePattern(const MatrixType& matrix)
function factorize (line 651) | void factorize(const MatrixType& matrix)
function init (line 661) | void init()
function grabMatrix (line 667) | void grabMatrix(const MatrixType& matrix, ColSpMatrix& out)
FILE: external/eigen3/Eigen/src/PardisoSupport/PardisoSupport.h
function namespace (line 35) | namespace Eigen {
type internal (line 106) | typedef internal::pardiso_traits<Derived> Traits;
type typename (line 110) | typedef typename Traits::MatrixType MatrixType;
type typename (line 111) | typedef typename Traits::Scalar Scalar;
type typename (line 112) | typedef typename Traits::RealScalar RealScalar;
type typename (line 113) | typedef typename Traits::StorageIndex StorageIndex;
type SparseMatrix (line 114) | typedef SparseMatrix<Scalar,RowMajor,StorageIndex> SparseMatrixType;
type Matrix (line 115) | typedef Matrix<Scalar,Dynamic,1> VectorType;
type Matrix (line 116) | typedef Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime> IntRowVec...
type Matrix (line 117) | typedef Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1> IntColVec...
function pardisoInit (line 192) | void pardisoInit(int type)
type typename (line 388) | typedef typename Base::Scalar Scalar;
type typename (line 389) | typedef typename Base::RealScalar RealScalar;
function explicit (line 405) | explicit PardisoLU(const MatrixType& matrix)
type typename (line 443) | typedef typename Base::Scalar Scalar;
type typename (line 444) | typedef typename Base::RealScalar RealScalar;
function explicit (line 461) | explicit PardisoLLT(const MatrixType& matrix)
type typename (line 506) | typedef typename Base::Scalar Scalar;
type typename (line 507) | typedef typename Base::RealScalar RealScalar;
function explicit (line 524) | explicit PardisoLDLT(const MatrixType& matrix)
function getMatrix (line 531) | void getMatrix(const MatrixType& matrix)
FILE: external/eigen3/Eigen/src/QR/ColPivHouseholderQR.h
function namespace (line 14) | namespace Eigen {
function HouseholderSequenceType (line 181) | HouseholderSequenceType householderQ() const;
function isInjective (line 285) | inline bool isInjective() const
function isInvertible (line 310) | inline bool isInvertible() const
function Index (line 394) | inline Index nonzeroPivots() const
function check_template_parameters (line 427) | static void check_template_parameters()
function namespace (line 614) | namespace internal {
FILE: external/eigen3/Eigen/src/QR/ColPivHouseholderQR_LAPACKE.h
function namespace (line 37) | namespace Eigen {
FILE: external/eigen3/Eigen/src/QR/CompleteOrthogonalDecomposition.h
function namespace (line 13) | namespace Eigen {
function namespace (line 528) | namespace internal {
FILE: external/eigen3/Eigen/src/QR/FullPivHouseholderQR.h
function namespace (line 14) | namespace Eigen {
function MatrixType (line 188) | const MatrixType& matrixQR() const
function isInjective (line 276) | inline bool isInjective() const
function isInvertible (line 301) | inline bool isInvertible() const
function Index (line 385) | inline Index nonzeroPivots() const
type internal (line 485) | typedef internal::scalar_score_coeff_op<Scalar> Scoring;
type typename (line 486) | typedef typename Scoring::result_type Score;
function namespace (line 576) | namespace internal {
FILE: external/eigen3/Eigen/src/QR/HouseholderQR.h
function namespace (line 15) | namespace Eigen {
function namespace (line 252) | namespace internal {
FILE: external/eigen3/Eigen/src/QR/HouseholderQR_LAPACKE.h
function namespace (line 37) | namespace Eigen {
FILE: external/eigen3/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h
function namespace (line 14) | namespace Eigen {
type typename (line 67) | typedef typename _MatrixType::RealScalar RealScalar;
type SuiteSparse_long (line 68) | typedef SuiteSparse_long StorageIndex ;
type SparseMatrix (line 69) | typedef SparseMatrix<Scalar, ColMajor, StorageIndex> MatrixType;
type Map (line 70) | typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > Permutat...
function SPQR_free (line 94) | void SPQR_free()
function compute (line 103) | void compute(const _MatrixType& matrix)
function setSPQROrdering (line 209) | void setSPQROrdering(int ord) { m_ordering = ord;}
function setPivotThreshold (line 211) | void setPivotThreshold(const RealScalar& tol)
function cholmod_common (line 218) | cholmod_common *cholmodCommon() const { return &m_cc; }
type SPQR_QProduct (line 249) | struct SPQR_QProduct
type typename (line 255) | typedef typename SPQRType::Scalar Scalar;
type typename (line 256) | typedef typename SPQRType::StorageIndex StorageIndex;
function m_spqr (line 283) | SPQRMatrixQReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
function m_spqr (line 303) | SPQRMatrixQTransposeReturnType(const SPQRType& spqr) : m_spqr(spqr) {}
FILE: external/eigen3/Eigen/src/SVD/BDCSVD.h
function namespace (line 25) | namespace Eigen {
function setSwitchSize (line 167) | void setSwitchSize(int s)
FILE: external/eigen3/Eigen/src/SVD/JacobiSVD.h
function namespace (line 14) | namespace Eigen {
type typename (line 108) | typedef typename MatrixType::Scalar Scalar;
type Matrix (line 119) | typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, ...
function allocate (line 122) | void allocate(const JacobiSVD<MatrixType, FullPivHouseholderQRPreconditi...
function run (line 133) | bool run(JacobiSVD<MatrixType, FullPivHouseholderQRPreconditioner>& svd,...
function allocate (line 159) | void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditio...
function run (line 170) | bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, ...
type typename (line 198) | typedef typename MatrixType::Scalar Scalar;
type Matrix (line 210) | typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, TrOptions, ...
function allocate (line 213) | void allocate(const JacobiSVD<MatrixType, ColPivHouseholderQRPreconditio...
function run (line 225) | bool run(JacobiSVD<MatrixType, ColPivHouseholderQRPreconditioner>& svd, ...
function allocate (line 258) | void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& ...
function run (line 269) | bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const ...
type typename (line 296) | typedef typename MatrixType::Scalar Scalar;
type Matrix (line 306) | typedef Matrix<Scalar, ColsAtCompileTime, RowsAtCompileTime, Options, Ma...
function allocate (line 309) | void allocate(const JacobiSVD<MatrixType, HouseholderQRPreconditioner>& ...
function run (line 321) | bool run(JacobiSVD<MatrixType, HouseholderQRPreconditioner>& svd, const ...
type typename (line 357) | typedef typename MatrixType::RealScalar RealScalar;
function run (line 358) | static bool run(typename SVD::WorkMatrixType&, SVD&, Index, Index, RealS...
type typename (line 365) | typedef typename MatrixType::Scalar Scalar;
type typename (line 366) | typedef typename MatrixType::RealScalar RealScalar;
function run (line 367) | static bool run(typename SVD::WorkMatrixType& work_matrix, SVD& svd, Ind...
type typename (line 494) | typedef typename MatrixType::Scalar Scalar;
type typename (line 495) | typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
type typename (line 506) | typedef typename Base::MatrixUType MatrixUType;
type typename (line 507) | typedef typename Base::MatrixVType MatrixVType;
type typename (line 508) | typedef typename Base::SingularValuesType SingularValuesType;
type typename (line 510) | typedef typename internal::plain_row_type<MatrixType>::type RowType;
type typename (line 511) | typedef typename internal::plain_col_type<MatrixType>::type ColType;
type Matrix (line 512) | typedef Matrix<Scalar, DiagSizeAtCompileTime, DiagSizeAtCompileTime,
type internal (line 603) | struct internal
type internal (line 605) | struct internal
FILE: external/eigen3/Eigen/src/SVD/JacobiSVD_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: external/eigen3/Eigen/src/SVD/SVDBase.h
function namespace (line 19) | namespace Eigen {
function SingularValuesType (line 111) | const SingularValuesType& singularValues() const
function Index (line 130) | inline Index rank() const
FILE: external/eigen3/Eigen/src/SVD/UpperBidiagonalization.h
function namespace (line 14) | namespace Eigen {
FILE: external/eigen3/Eigen/src/SparseCholesky/SimplicialCholesky.h
function namespace (line 13) | namespace Eigen {
function analyzePattern (line 230) | void analyzePattern(const MatrixType& a, bool doLDLT)
type keep_diag (line 244) | struct keep_diag {
function namespace (line 270) | namespace internal {
type
Condensed preview — 372 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,425K chars).
[
{
"path": ".gitignore",
"chars": 1886,
"preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
},
{
"path": "LICENSE",
"chars": 1068,
"preview": "MIT License\n\nCopyright (c) 2021 Aljaz Bozic\n\nPermission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "README.md",
"chars": 5954,
"preview": "# Neural Deformation Graphs\n\n### [Project Page](https://aljazbozic.github.io/neural_deformation_graphs/) | [Paper](https"
},
{
"path": "build_external.sh",
"chars": 2904,
"preview": "#!/bin/bash\n\n###################################################\n# INSTALL GAPS\n########################################"
},
{
"path": "config.py",
"chars": 6622,
"preview": "import os\n\n#############################################################################################################"
},
{
"path": "dataset/dataset.py",
"chars": 9494,
"preview": "import sys,os\n\nimport math\nimport torch\nimport numpy as np\nfrom skimage import io, transform\nfrom torch.utils.data impor"
},
{
"path": "dataset/generate_dataset.py",
"chars": 3920,
"preview": "import os\nimport sys\nsys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))\n\nimport tqdm\nfrom j"
},
{
"path": "external/PyMarchingCubes/.gitignore",
"chars": 2515,
"preview": ".DS_Store\n*.dae\n_mcubes.cpp\n*.py[cod]\n.vscode\n.mypy_cache\n\n.vscode\n\n# Created by https://www.gitignore.io/api/osx,linux,"
},
{
"path": "external/PyMarchingCubes/.travis.yml",
"chars": 922,
"preview": "# vim ft=yaml\n\n# After changing this file, check it on:\n# http://yaml-online-parser.appspot.com/\n\n# See doc/travis_not"
},
{
"path": "external/PyMarchingCubes/LICENSE",
"chars": 1532,
"preview": "Copyright (c) 2012-2015, P. M. Neila (https://github.com/pmneila/PyMCubes)\nAll rights reserved.\n\nRedistribution and use "
},
{
"path": "external/PyMarchingCubes/MANIFEST.in",
"chars": 370,
"preview": "include marching_cubes/*.py\nexclude marching_cubes/numpy_smoothing.py\n\ninclude marching_cubes/src/*.h\ninclude marching_c"
},
{
"path": "external/PyMarchingCubes/README.md",
"chars": 5260,
"preview": "# PyMarchingCubes\n\n`PyMarchingCubes` is a fork from `PyMCubes`, with a different implementation of the actual marching f"
},
{
"path": "external/PyMarchingCubes/examples/.gitignore",
"chars": 104,
"preview": "sphere.obj\nsphere_color.obj\nsphere_color.off\nsphere_tsdf_super_res.off\nsphere_tsdf_without_super_res.off"
},
{
"path": "external/PyMarchingCubes/examples/spheres.py",
"chars": 3445,
"preview": "\nimport numpy as np\nimport marching_cubes as mcubes\n\nprint(\"Example 1: Isosurface in NumPy volume...\")\n#print(mcubes.__d"
},
{
"path": "external/PyMarchingCubes/marching_cubes/__init__.py",
"chars": 254,
"preview": "\nfrom ._mcubes import marching_cubes, marching_cubes_func, marching_cubes_color, marching_cubes_color_func, marching_cub"
},
{
"path": "external/PyMarchingCubes/marching_cubes/exporter.py",
"chars": 2118,
"preview": "\nimport numpy as np\n\n\ndef export_obj(vertices, triangles, filename):\n \"\"\"\n Exports a mesh in the (.obj) format.\n "
},
{
"path": "external/PyMarchingCubes/marching_cubes/numpy_smoothing.py",
"chars": 2572,
"preview": "\nimport numpy as np\nfrom scipy import ndimage as ndi\n\n__all__ = [\n 'numpy_smooth',\n]\n\nFILTER = np.array([1, -2, 1], d"
},
{
"path": "external/PyMarchingCubes/marching_cubes/smoothing.py",
"chars": 9697,
"preview": "# -*- coding: utf-8 -*-\n\n\"\"\"\nUtilities for smoothing the 0.5 level-set of binary arrays.\n\"\"\"\n\nimport logging\nfrom typing"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/_mcubes.pyx",
"chars": 2759,
"preview": "\n# distutils: language = c++\n# cython: embedsignature = True\n\n# from libcpp.vector cimport vector\nimport numpy as np\n\n# "
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/marchingcubes.cpp",
"chars": 18889,
"preview": "\n#include \"marchingcubes.h\"\n\nnamespace mc\n{\n\nint edge_table[256] =\n{\n 0x000, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/marchingcubes.h",
"chars": 55136,
"preview": "\n#ifndef _MARCHING_CUBES_H\n#define _MARCHING_CUBES_H\n\n#include <stddef.h>\n#include <array>\n#include <vector>\n#include <i"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/pyarray_symbol.h",
"chars": 51,
"preview": "\n#define PY_ARRAY_UNIQUE_SYMBOL mcubes_PyArray_API\n"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/pyarraymodule.h",
"chars": 4645,
"preview": "\n#ifndef _EXTMODULE_H\n#define _EXTMODULE_H\n\n#include <Python.h>\n#include <stdexcept>\n\n// #define NPY_NO_DEPRECATED_API N"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/pywrapper.cpp",
"chars": 13992,
"preview": "\n#include \"pywrapper.h\"\n\n#include \"marchingcubes.h\"\n\n#include <stdexcept>\n#include <array>\n\n\nPyObject* marching_cubes_fu"
},
{
"path": "external/PyMarchingCubes/marching_cubes/src/pywrapper.h",
"chars": 757,
"preview": "\n#ifndef _PYWRAPPER_H\n#define _PYWRAPPER_H\n\n#include <Python.h>\n#include \"pyarraymodule.h\"\n\n#include <vector>\n\nPyObject*"
},
{
"path": "external/PyMarchingCubes/requirements.txt",
"chars": 42,
"preview": "numpy>=1.11.3\nscipy>=1.0.0\ncython>=0.25.0\n"
},
{
"path": "external/PyMarchingCubes/setup.py",
"chars": 2675,
"preview": "# -*- encoding: utf-8 -*-\nimport sys, os\nsys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '"
},
{
"path": "external/PyMarchingCubes/test_mcubes.py",
"chars": 2068,
"preview": "\nimport pytest\n\nimport numpy as np\nfrom numpy.testing import assert_array_equal, assert_allclose\n\nimport marching_cubes "
},
{
"path": "external/PyMarchingCubes/test_smoothing.py",
"chars": 2797,
"preview": "\n\nimport pytest\n\nimport numpy as np\n\nimport marching_cubes as mcubes\n\n\ndef test_sphere():\n\n # Create sphere with radi"
},
{
"path": "external/eigen3/Eigen/Cholesky",
"chars": 1206,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/CholmodSupport",
"chars": 1900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/Core",
"chars": 17961,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/Dense",
"chars": 122,
"preview": "#include \"Core\"\n#include \"LU\"\n#include \"Cholesky\"\n#include \"QR\"\n#include \"SVD\"\n#include \"Geometry\"\n#include \"Eigenvalues"
},
{
"path": "external/eigen3/Eigen/Eigen",
"chars": 35,
"preview": "#include \"Dense\"\n#include \"Sparse\"\n"
},
{
"path": "external/eigen3/Eigen/Eigenvalues",
"chars": 1822,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/Geometry",
"chars": 2050,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/Householder",
"chars": 874,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/IterativeLinearSolvers",
"chars": 2083,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/Jacobi",
"chars": 939,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/LU",
"chars": 1433,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/MetisSupport",
"chars": 991,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/OrderingMethods",
"chars": 2483,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/PaStiXSupport",
"chars": 1676,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/PardisoSupport",
"chars": 1116,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/QR",
"chars": 1317,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/QtAlignedMalloc",
"chars": 945,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/SPQRSupport",
"chars": 1162,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/SVD",
"chars": 1629,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/Sparse",
"chars": 919,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/SparseCholesky",
"chars": 1371,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2013 G"
},
{
"path": "external/eigen3/Eigen/SparseCore",
"chars": 2240,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/SparseLU",
"chars": 1711,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "external/eigen3/Eigen/SparseQR",
"chars": 1222,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/StdDeque",
"chars": 797,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/StdList",
"chars": 726,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Hauke "
},
{
"path": "external/eigen3/Eigen/StdVector",
"chars": 803,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/SuperLUSupport",
"chars": 2243,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/UmfPackSupport",
"chars": 1382,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/src/Cholesky/LDLT.h",
"chars": 24480,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2011 G"
},
{
"path": "external/eigen3/Eigen/src/Cholesky/LLT.h",
"chars": 18395,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Cholesky/LLT_LAPACKE.h",
"chars": 3974,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/CholmodSupport/CholmodSupport.h",
"chars": 22307,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Array.h",
"chars": 12115,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/ArrayBase.h",
"chars": 8237,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/ArrayWrapper.h",
"chars": 6775,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Assign.h",
"chars": 2720,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Michae"
},
{
"path": "external/eigen3/Eigen/src/Core/AssignEvaluator.h",
"chars": 38153,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/Assign_MKL.h",
"chars": 12479,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inr"
},
{
"path": "external/eigen3/Eigen/src/Core/BandMatrix.h",
"chars": 13910,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Block.h",
"chars": 18064,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/BooleanRedux.h",
"chars": 4249,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/CommaInitializer.h",
"chars": 5689,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/ConditionEstimator.h",
"chars": 6990,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Rasmus"
},
{
"path": "external/eigen3/Eigen/src/Core/CoreEvaluators.h",
"chars": 62197,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/CoreIterators.h",
"chars": 4525,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "external/eigen3/Eigen/src/Core/CwiseBinaryOp.h",
"chars": 7593,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "external/eigen3/Eigen/src/Core/CwiseNullaryOp.h",
"chars": 31424,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/CwiseTernaryOp.h",
"chars": 8256,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "external/eigen3/Eigen/src/Core/CwiseUnaryOp.h",
"chars": 3877,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "external/eigen3/Eigen/src/Core/CwiseUnaryView.h",
"chars": 5366,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/DenseBase.h",
"chars": 27473,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/DenseCoeffsBase.h",
"chars": 24212,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/DenseStorage.h",
"chars": 21959,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Diagonal.h",
"chars": 9597,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2009 B"
},
{
"path": "external/eigen3/Eigen/src/Core/DiagonalMatrix.h",
"chars": 12666,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/DiagonalProduct.h",
"chars": 970,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Dot.h",
"chars": 11507,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008, "
},
{
"path": "external/eigen3/Eigen/src/Core/EigenBase.h",
"chars": 5619,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/ForceAlignedAccess.h",
"chars": 4769,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Fuzzy.h",
"chars": 5705,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/GeneralProduct.h",
"chars": 21123,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/GenericPacketMath.h",
"chars": 22185,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/GlobalFunctions.h",
"chars": 10222,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010-2016 G"
},
{
"path": "external/eigen3/Eigen/src/Core/IO.h",
"chars": 7076,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/Inverse.h",
"chars": 3519,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Map.h",
"chars": 7239,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/MapBase.h",
"chars": 11212,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/MathFunctions.h",
"chars": 40865,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/MathFunctionsImpl.h",
"chars": 3369,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Pedro "
},
{
"path": "external/eigen3/Eigen/src/Core/Matrix.h",
"chars": 19067,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/MatrixBase.h",
"chars": 23276,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2009 B"
},
{
"path": "external/eigen3/Eigen/src/Core/NestByValue.h",
"chars": 3400,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/NoAlias.h",
"chars": 3582,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/NumTraits.h",
"chars": 9234,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/PermutationMatrix.h",
"chars": 21646,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/PlainObjectBase.h",
"chars": 45180,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Product.h",
"chars": 7235,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2011 G"
},
{
"path": "external/eigen3/Eigen/src/Core/ProductEvaluators.h",
"chars": 49497,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/Random.h",
"chars": 6379,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Redux.h",
"chars": 17852,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Ref.h",
"chars": 12800,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Replicate.h",
"chars": 5595,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/ReturnByValue.h",
"chars": 4200,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Reverse.h",
"chars": 7073,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/Select.h",
"chars": 6020,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/SelfAdjointView.h",
"chars": 14245,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/SelfCwiseBinaryOp.h",
"chars": 1697,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Solve.h",
"chars": 6795,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/SolveTriangular.h",
"chars": 9136,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/SolverBase.h",
"chars": 4365,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/StableNorm.h",
"chars": 7692,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/Stride.h",
"chars": 3865,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/Swap.h",
"chars": 2683,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/Transpose.h",
"chars": 14856,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "external/eigen3/Eigen/src/Core/Transpositions.h",
"chars": 14386,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010-2011 G"
},
{
"path": "external/eigen3/Eigen/src/Core/TriangularMatrix.h",
"chars": 37304,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/VectorBlock.h",
"chars": 3462,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/VectorwiseOp.h",
"chars": 29441,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/Visitor.h",
"chars": 8074,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX/Complex.h",
"chars": 18037,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX/MathFunctions.h",
"chars": 17776,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Pedro "
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX/PacketMath.h",
"chars": 27841,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX/TypeCasting.h",
"chars": 1194,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX512/MathFunctions.h",
"chars": 15733,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Pedro "
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AVX512/PacketMath.h",
"chars": 50985,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AltiVec/Complex.h",
"chars": 16443,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AltiVec/MathFunctions.h",
"chars": 10797,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/AltiVec/PacketMath.h",
"chars": 37671,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 K"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/Complex.h",
"chars": 4240,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/Half.h",
"chars": 23528,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/MathFunctions.h",
"chars": 2387,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/PacketMath.h",
"chars": 10744,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/PacketMathHalf.h",
"chars": 35538,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/CUDA/TypeCasting.h",
"chars": 5509,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/Default/ConjHelper.h",
"chars": 1989,
"preview": "\n// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael "
},
{
"path": "external/eigen3/Eigen/src/Core/arch/Default/Settings.h",
"chars": 1746,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/NEON/Complex.h",
"chars": 17706,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/NEON/MathFunctions.h",
"chars": 2846,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "external/eigen3/Eigen/src/Core/arch/NEON/PacketMath.h",
"chars": 28726,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/SSE/Complex.h",
"chars": 19426,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/SSE/MathFunctions.h",
"chars": 18888,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/SSE/PacketMath.h",
"chars": 35843,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/SSE/TypeCasting.h",
"chars": 1759,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Benoit"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/ZVector/Complex.h",
"chars": 15366,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/ZVector/MathFunctions.h",
"chars": 4418,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "external/eigen3/Eigen/src/Core/arch/ZVector/PacketMath.h",
"chars": 32283,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Konsta"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/AssignmentFunctors.h",
"chars": 6284,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/BinaryFunctors.h",
"chars": 18263,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/NullaryFunctors.h",
"chars": 8229,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 G"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/StlFunctors.h",
"chars": 4400,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/TernaryFunctors.h",
"chars": 607,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Eugene"
},
{
"path": "external/eigen3/Eigen/src/Core/functors/UnaryFunctors.h",
"chars": 27944,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralBlockPanelKernel.h",
"chars": 81534,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix.h",
"chars": 18478,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h",
"chars": 15188,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h",
"chars": 6907,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h",
"chars": 5017,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixVector.h",
"chars": 26808,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h",
"chars": 6368,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/Parallelizer.h",
"chars": 4905,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointMatrixMatrix.h",
"chars": 19632,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h",
"chars": 11198,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector.h",
"chars": 9901,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h",
"chars": 5209,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointProduct.h",
"chars": 6105,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/SelfadjointRank2Update.h",
"chars": 4066,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix.h",
"chars": 20403,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h",
"chars": 13743,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularMatrixVector.h",
"chars": 14722,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h",
"chars": 10571,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularSolverMatrix.h",
"chars": 13979,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h",
"chars": 6513,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/products/TriangularSolverVector.h",
"chars": 5741,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/BlasUtil.h",
"chars": 15722,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/Constants.h",
"chars": 21579,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/DisableStupidWarnings.h",
"chars": 3981,
"preview": "#ifndef EIGEN_WARNINGS_DISABLED\n#define EIGEN_WARNINGS_DISABLED\n\n#ifdef _MSC_VER\n // 4100 - unreferenced formal paramet"
},
{
"path": "external/eigen3/Eigen/src/Core/util/ForwardDeclarations.h",
"chars": 14150,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "external/eigen3/Eigen/src/Core/util/MKL_support.h",
"chars": 4026,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Core/util/Macros.h",
"chars": 37792,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/Memory.h",
"chars": 40579,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/Meta.h",
"chars": 20586,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/NonMPL2.h",
"chars": 85,
"preview": "#ifdef EIGEN_MPL2_ONLY\n#error Including non-MPL2 code in EIGEN_MPL2_ONLY mode\n#endif\n"
},
{
"path": "external/eigen3/Eigen/src/Core/util/ReenableStupidWarnings.h",
"chars": 856,
"preview": "#ifdef EIGEN_WARNINGS_DISABLED\n#undef EIGEN_WARNINGS_DISABLED\n\n#ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS\n #ifde"
},
{
"path": "external/eigen3/Eigen/src/Core/util/StaticAssert.h",
"chars": 10518,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Core/util/XprHelper.h",
"chars": 34345,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Eigenvalues/ComplexEigenSolver.h",
"chars": 12558,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Claire"
},
{
"path": "external/eigen3/Eigen/src/Eigenvalues/ComplexSchur.h",
"chars": 17021,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Claire"
},
{
"path": "external/eigen3/Eigen/src/Eigenvalues/ComplexSchur_LAPACKE.h",
"chars": 4178,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "external/eigen3/Eigen/src/Eigenvalues/EigenSolver.h",
"chars": 22944,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "external/eigen3/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h",
"chars": 17176,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012-2016 G"
}
]
// ... and 172 more files (download for full content)
About this extraction
This page contains the full source code of the AljazBozic/NeuralGraph GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 372 files (5.0 MB), approximately 1.3M tokens, and a symbol index with 3021 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.