Showing preview only (7,419K chars total). Download the full file or copy to clipboard to get everything.
Repository: SimonRit/RTK
Branch: main
Commit: 4d124fc7fa19
Files: 1343
Total size: 6.8 MB
Directory structure:
gitextract_m7pjdl55/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── build-test-cxx-cuda.yml
│ ├── build-test-package-python-cuda.yml
│ ├── build-test-package.yml
│ └── clang-format-linter.yml
├── .gitignore
├── .readthedocs.yml
├── CMakeLists.txt
├── COPYRIGHT.TXT
├── CTestConfig.cmake
├── CodeContribution.md
├── GettingStarted.md
├── HEADER.TXT
├── INSTALLATION.md
├── ITKKWStyleFiles.txt.in
├── LICENSE.TXT
├── ORGANIZATION.TXT
├── README.md
├── applications/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── rtk3Doutputimage_group.py
│ ├── rtk3Doutputimage_section.ggo
│ ├── rtk4Doutputimage_section.ggo
│ ├── rtkVersion.ggo.in
│ ├── rtkadmmtotalvariation/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── TotalVariationRegularizedReconstruction.sh
│ │ ├── rtkadmmtotalvariation.cxx
│ │ ├── rtkadmmtotalvariation.ggo
│ │ └── rtkadmmtotalvariation.py
│ ├── rtkadmmwavelets/
│ │ ├── CMakeLists.txt
│ │ ├── DaubechiesWavelets.sh
│ │ ├── README.md
│ │ ├── rtkadmmwavelets.cxx
│ │ └── rtkadmmwavelets.ggo
│ ├── rtkamsterdamshroud/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkamsterdamshroud.cxx
│ │ ├── rtkamsterdamshroud.ggo
│ │ └── rtkamsterdamshroud.py
│ ├── rtkargumentparser.py
│ ├── rtkbackprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkbackprojections.cxx
│ │ ├── rtkbackprojections.ggo
│ │ └── rtkbackprojections.py
│ ├── rtkbioscangeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkbioscangeometry.cxx
│ │ ├── rtkbioscangeometry.ggo
│ │ └── rtkbioscangeometry.py
│ ├── rtkcheckimagequality/
│ │ ├── CMakeLists.txt
│ │ ├── rtkcheckimagequality.cxx
│ │ ├── rtkcheckimagequality.ggo
│ │ └── rtkcheckimagequality.py
│ ├── rtkconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── ConjugateGradient2D.sh
│ │ ├── ConjugateGradient3D.sh
│ │ ├── NoisyConjugateGradient.sh
│ │ ├── README.md
│ │ ├── rtkconjugategradient.cxx
│ │ ├── rtkconjugategradient.ggo
│ │ └── rtkconjugategradient.py
│ ├── rtkdigisensgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdigisensgeometry.cxx
│ │ ├── rtkdigisensgeometry.ggo
│ │ └── rtkdigisensgeometry.py
│ ├── rtkdrawgeometricphantom/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkdrawgeometricphantom.cxx
│ │ ├── rtkdrawgeometricphantom.ggo
│ │ └── rtkdrawgeometricphantom.py
│ ├── rtkdrawshepploganphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdrawshepploganphantom.cxx
│ │ ├── rtkdrawshepploganphantom.ggo
│ │ └── rtkdrawshepploganphantom.py
│ ├── rtkdualenergyforwardmodel/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdualenergyforwardmodel.cxx
│ │ ├── rtkdualenergyforwardmodel.ggo
│ │ └── rtkdualenergyforwardmodel.py
│ ├── rtkdualenergysimplexdecomposition/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdualenergysimplexdecomposition.cxx
│ │ ├── rtkdualenergysimplexdecomposition.ggo
│ │ └── rtkdualenergysimplexdecomposition.py
│ ├── rtkelektasynergygeometry/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkelektasynergygeometry.cxx
│ │ ├── rtkelektasynergygeometry.ggo
│ │ └── rtkelektasynergygeometry.py
│ ├── rtkextractphasesignal/
│ │ ├── CMakeLists.txt
│ │ ├── rtkextractphasesignal.cxx
│ │ ├── rtkextractphasesignal.ggo
│ │ └── rtkextractphasesignal.py
│ ├── rtkextractshroudsignal/
│ │ ├── CMakeLists.txt
│ │ ├── rtkextractshroudsignal.cxx
│ │ └── rtkextractshroudsignal.ggo
│ ├── rtkfdk/
│ │ ├── CMakeLists.txt
│ │ ├── FDK2D.sh
│ │ ├── FDK3D.sh
│ │ ├── README.md
│ │ ├── rtkfdk.cxx
│ │ ├── rtkfdk.ggo
│ │ └── rtkfdk.py
│ ├── rtkfieldofview/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfieldofview.cxx
│ │ ├── rtkfieldofview.ggo
│ │ └── rtkfieldofview.py
│ ├── rtkforwardprojections/
│ │ ├── CMakeLists.txt
│ │ ├── ForwardProjection.sh
│ │ ├── README.md
│ │ ├── rtkforwardprojections.cxx
│ │ ├── rtkforwardprojections.ggo
│ │ └── rtkforwardprojections.py
│ ├── rtkfourdconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdconjugategradient.cxx
│ │ └── rtkfourdconjugategradient.ggo
│ ├── rtkfourdfdk/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdfdk.cxx
│ │ └── rtkfourdfdk.ggo
│ ├── rtkfourdrooster/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkfourdrooster.cxx
│ │ └── rtkfourdrooster.ggo
│ ├── rtkfourdsart/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdsart.cxx
│ │ └── rtkfourdsart.ggo
│ ├── rtkgaincorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtkgaincorrection.cxx
│ │ └── rtkgaincorrection.ggo
│ ├── rtki0estimation/
│ │ ├── CMakeLists.txt
│ │ ├── rtki0estimation.cxx
│ │ └── rtki0estimation.ggo
│ ├── rtkimagxgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkimagxgeometry.cxx
│ │ └── rtkimagxgeometry.ggo
│ ├── rtkinputprojections_group.py
│ ├── rtkinputprojections_section.ggo
│ ├── rtkiterations_group.py
│ ├── rtkiterations_section.ggo
│ ├── rtkiterativefdk/
│ │ ├── CMakeLists.txt
│ │ ├── rtkiterativefdk.cxx
│ │ └── rtkiterativefdk.ggo
│ ├── rtklagcorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtklagcorrection.cxx
│ │ └── rtklagcorrection.ggo
│ ├── rtkmaskcollimation/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmaskcollimation.cxx
│ │ └── rtkmaskcollimation.ggo
│ ├── rtkmcrooster/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmcrooster.cxx
│ │ └── rtkmcrooster.ggo
│ ├── rtkmotioncompensatedfourdconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmotioncompensatedfourdconjugategradient.cxx
│ │ └── rtkmotioncompensatedfourdconjugategradient.ggo
│ ├── rtkorageometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkorageometry.cxx
│ │ ├── rtkorageometry.ggo
│ │ └── rtkorageometry.py
│ ├── rtkosem/
│ │ ├── CMakeLists.txt
│ │ ├── rtkosem.cxx
│ │ └── rtkosem.ggo
│ ├── rtkoverlayphaseandshroud/
│ │ ├── CMakeLists.txt
│ │ ├── rtkoverlayphaseandshroud.cxx
│ │ └── rtkoverlayphaseandshroud.ggo
│ ├── rtkprojectgeometricphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojectgeometricphantom.cxx
│ │ ├── rtkprojectgeometricphantom.ggo
│ │ └── rtkprojectgeometricphantom.py
│ ├── rtkprojectionmatrix/
│ │ ├── CMakeLists.txt
│ │ ├── rtkMatlabSparseMatrix.h
│ │ ├── rtkMatlabSparseMatrix.hxx
│ │ ├── rtkprojectionmatrix.cxx
│ │ └── rtkprojectionmatrix.ggo
│ ├── rtkprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojections.cxx
│ │ ├── rtkprojections.ggo
│ │ └── rtkprojections.py
│ ├── rtkprojectors_group.py
│ ├── rtkprojectors_section.ggo
│ ├── rtkprojectshepploganphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojectshepploganphantom.cxx
│ │ ├── rtkprojectshepploganphantom.ggo
│ │ └── rtkprojectshepploganphantom.py
│ ├── rtkregularizedconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkregularizedconjugategradient.cxx
│ │ └── rtkregularizedconjugategradient.ggo
│ ├── rtksart/
│ │ ├── CMakeLists.txt
│ │ ├── rtksart.cxx
│ │ └── rtksart.ggo
│ ├── rtkscatterglarecorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtkscatterglarecorrection.cxx
│ │ └── rtkscatterglarecorrection.ggo
│ ├── rtkshowgeometry/
│ │ ├── README.md
│ │ ├── rtkshowgeometry.py
│ │ └── showgeometry.sh
│ ├── rtksimulatedgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtksimulatedgeometry.cxx
│ │ ├── rtksimulatedgeometry.ggo
│ │ └── rtksimulatedgeometry.py
│ ├── rtkspectraldenoiseprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectraldenoiseprojections.cxx
│ │ └── rtkspectraldenoiseprojections.ggo
│ ├── rtkspectralforwardmodel/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralforwardmodel.cxx
│ │ └── rtkspectralforwardmodel.ggo
│ ├── rtkspectralonestep/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralonestep.cxx
│ │ └── rtkspectralonestep.ggo
│ ├── rtkspectralrooster/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralrooster.cxx
│ │ └── rtkspectralrooster.ggo
│ ├── rtkspectralsimplexdecomposition/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralsimplexdecomposition.cxx
│ │ └── rtkspectralsimplexdecomposition.ggo
│ ├── rtksubselect/
│ │ ├── CMakeLists.txt
│ │ ├── rtksubselect.cxx
│ │ └── rtksubselect.ggo
│ ├── rtktotalnuclearvariationdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtktotalnuclearvariationdenoising.cxx
│ │ └── rtktotalnuclearvariationdenoising.ggo
│ ├── rtktotalvariationdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtktotalvariationdenoising.cxx
│ │ └── rtktotalvariationdenoising.ggo
│ ├── rtktutorialapplication/
│ │ ├── CMakeLists.txt
│ │ ├── rtktutorialapplication.cxx
│ │ └── rtktutorialapplication.ggo
│ ├── rtkvarianobigeometry/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkvarianobigeometry.cxx
│ │ ├── rtkvarianobigeometry.ggo
│ │ └── rtkvarianobigeometry.py
│ ├── rtkvarianprobeamgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkvarianprobeamgeometry.cxx
│ │ └── rtkvarianprobeamgeometry.ggo
│ ├── rtkvectorconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkvectorconjugategradient.cxx
│ │ └── rtkvectorconjugategradient.ggo
│ ├── rtkversion.py.in
│ ├── rtkwaveletsdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtkwaveletsdenoising.cxx
│ │ └── rtkwaveletsdenoising.ggo
│ └── rtkxradgeometry/
│ ├── CMakeLists.txt
│ ├── rtkxradgeometry.cxx
│ └── rtkxradgeometry.ggo
├── cmake/
│ ├── FindGengetopt.cmake
│ ├── GetGitRevisionDescription.cmake
│ ├── GetGitRevisionDescription.cmake.in
│ ├── Hooks/
│ │ ├── pre-commit
│ │ └── pre-commit-style.bash
│ ├── KWStyle/
│ │ ├── RTK.kws.xml
│ │ ├── RTKHeader.h
│ │ └── RTKOverwrite.txt
│ └── rtkCompilerFlags.cmake
├── conf.py
├── documentation/
│ ├── Doxygen/
│ │ ├── CMakeLists.txt
│ │ ├── DoxygenFooter.html
│ │ ├── DoxygenHeader.html
│ │ ├── DoxygenStyle.css
│ │ ├── MainPage.dox
│ │ ├── Modules.dox
│ │ ├── doxygen.config.in
│ │ ├── itkdoxygen.pl.in
│ │ ├── itkgroup.pl
│ │ ├── rtkThreeDCirculationProjectionGeometry.dox
│ │ └── vxl_doxy.pl
│ └── docs/
│ ├── CMakeLists.txt
│ ├── ExternalData/
│ │ ├── AddNoise.png.sha512
│ │ ├── AdmmWavelets.png.sha512
│ │ ├── Admmtv.png.sha512
│ │ ├── Amsterdam.png.sha512
│ │ ├── Blurred.jpg.sha512
│ │ ├── Blurred_vs_mc.gif.sha512
│ │ ├── ConjugateGradient-2D.png.sha512
│ │ ├── ConjugateGradient-3D.png.sha512
│ │ ├── ConjugateGradient-Sinogram-2D.png.sha512
│ │ ├── Elekta.png.sha512
│ │ ├── Fdk-2D.png.sha512
│ │ ├── Fdk-3D.png.sha512
│ │ ├── GammexPhantom.png.sha512
│ │ ├── MotionMask.jpg.sha512
│ │ ├── Moving-Phantom-Sinogram.png.sha512
│ │ ├── POPI-Reconstruction.png.sha512
│ │ ├── POPI-Sinogram.png.sha512
│ │ ├── SheppLogan-Sinogram-2D.png.sha512
│ │ ├── SheppLogan-Sinogram-3D.png.sha512
│ │ ├── ShowGeometry.png.sha512
│ │ ├── Signal.jpg.sha512
│ │ ├── Thorax-Sinogram.png.sha512
│ │ ├── Thorax-fdk.png.sha512
│ │ ├── Thorax-visualisation.png.sha512
│ │ ├── Varian.png.sha512
│ │ ├── VarianProBeam.png.sha512
│ │ └── VectorField.gif.sha512
│ ├── Geometry.md
│ ├── Phantom.md
│ ├── Projectors.md
│ ├── README.md
│ ├── Release.md
│ ├── copy_and_fetch_sphinx_doc_files.cmake
│ ├── requirements.txt
│ └── rtk_3_migration_guide.md
├── examples/
│ ├── AddNoise/
│ │ ├── AddNoise.cxx
│ │ ├── AddNoise.py
│ │ ├── CMakeLists.txt
│ │ └── README.md
│ ├── ConjugateGradient/
│ │ ├── CMakeLists.txt
│ │ ├── ConjugateGradient.cxx
│ │ ├── ConjugateGradient.py
│ │ └── README.md
│ ├── FirstReconstruction/
│ │ ├── CMakeLists.txt
│ │ ├── FirstCudaReconstruction.cxx
│ │ ├── FirstCudaReconstruction.py
│ │ ├── FirstReconstruction.cxx
│ │ ├── FirstReconstruction.py
│ │ └── README.md
│ ├── GeometricPhantom/
│ │ ├── CMakeLists.txt
│ │ ├── GeometricPhantom.cxx
│ │ ├── GeometricPhantom.py
│ │ └── README.md
│ ├── InlineReconstruction/
│ │ ├── CMakeLists.txt
│ │ ├── InlineReconstruction.cxx
│ │ ├── InlineReconstruction.py
│ │ └── README.md
│ ├── README.md
│ └── WaterPreCorrection/
│ ├── Profile.png.sha512
│ ├── README.md
│ └── WaterPreCorrection.py
├── include/
│ ├── rtkADMMTotalVariationConeBeamReconstructionFilter.h
│ ├── rtkADMMTotalVariationConeBeamReconstructionFilter.hxx
│ ├── rtkADMMTotalVariationConjugateGradientOperator.h
│ ├── rtkADMMTotalVariationConjugateGradientOperator.hxx
│ ├── rtkADMMWaveletsConeBeamReconstructionFilter.h
│ ├── rtkADMMWaveletsConeBeamReconstructionFilter.hxx
│ ├── rtkADMMWaveletsConjugateGradientOperator.h
│ ├── rtkADMMWaveletsConjugateGradientOperator.hxx
│ ├── rtkAddMatrixAndDiagonalImageFilter.h
│ ├── rtkAddMatrixAndDiagonalImageFilter.hxx
│ ├── rtkAdditiveGaussianNoiseImageFilter.h
│ ├── rtkAdditiveGaussianNoiseImageFilter.hxx
│ ├── rtkAmsterdamShroudImageFilter.h
│ ├── rtkAmsterdamShroudImageFilter.hxx
│ ├── rtkAverageOutOfROIImageFilter.h
│ ├── rtkAverageOutOfROIImageFilter.hxx
│ ├── rtkBackProjectionImageFilter.h
│ ├── rtkBackProjectionImageFilter.hxx
│ ├── rtkBackwardDifferenceDivergenceImageFilter.h
│ ├── rtkBackwardDifferenceDivergenceImageFilter.hxx
│ ├── rtkBioscanGeometryReader.h
│ ├── rtkBlockDiagonalMatrixVectorMultiplyImageFilter.h
│ ├── rtkBlockDiagonalMatrixVectorMultiplyImageFilter.hxx
│ ├── rtkBoellaardScatterCorrectionImageFilter.h
│ ├── rtkBoellaardScatterCorrectionImageFilter.hxx
│ ├── rtkBoxShape.h
│ ├── rtkConditionalMedianImageFilter.h
│ ├── rtkConditionalMedianImageFilter.hxx
│ ├── rtkConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkConjugateGradientGetP_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetP_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientGetR_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetR_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientGetX_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetX_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientImageFilter.h
│ ├── rtkConjugateGradientImageFilter.hxx
│ ├── rtkConjugateGradientOperator.h
│ ├── rtkConjugateGradientOperator.hxx
│ ├── rtkConstantImageSource.h
│ ├── rtkConstantImageSource.hxx
│ ├── rtkConvexShape.h
│ ├── rtkCudaAverageOutOfROIImageFilter.h
│ ├── rtkCudaAverageOutOfROIImageFilter.hcu
│ ├── rtkCudaBackProjectionImageFilter.h
│ ├── rtkCudaBackProjectionImageFilter.hcu
│ ├── rtkCudaBackProjectionImageFilter.hxx
│ ├── rtkCudaConjugateGradientImageFilter.h
│ ├── rtkCudaConjugateGradientImageFilter.hcu
│ ├── rtkCudaConjugateGradientImageFilter.hxx
│ ├── rtkCudaConstantVolumeSeriesSource.h
│ ├── rtkCudaConstantVolumeSeriesSource.hcu
│ ├── rtkCudaConstantVolumeSource.h
│ ├── rtkCudaConstantVolumeSource.hcu
│ ├── rtkCudaCropImageFilter.h
│ ├── rtkCudaCropImageFilter.hcu
│ ├── rtkCudaCyclicDeformationImageFilter.h
│ ├── rtkCudaCyclicDeformationImageFilter.hcu
│ ├── rtkCudaDisplacedDetectorImageFilter.h
│ ├── rtkCudaDisplacedDetectorImageFilter.hcu
│ ├── rtkCudaFDKBackProjectionImageFilter.h
│ ├── rtkCudaFDKBackProjectionImageFilter.hcu
│ ├── rtkCudaFDKConeBeamReconstructionFilter.h
│ ├── rtkCudaFDKWeightProjectionFilter.h
│ ├── rtkCudaFDKWeightProjectionFilter.hcu
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.h
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.hcu
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.hxx
│ ├── rtkCudaFFTRampImageFilter.h
│ ├── rtkCudaFirstOrderKernels.hcu
│ ├── rtkCudaForwardProjectionImageFilter.h
│ ├── rtkCudaForwardProjectionImageFilter.hcu
│ ├── rtkCudaForwardProjectionImageFilter.hxx
│ ├── rtkCudaForwardWarpImageFilter.h
│ ├── rtkCudaForwardWarpImageFilter.hcu
│ ├── rtkCudaInterpolateImageFilter.h
│ ├── rtkCudaInterpolateImageFilter.hcu
│ ├── rtkCudaIntersectBox.hcu
│ ├── rtkCudaIterativeFDKConeBeamReconstructionFilter.h
│ ├── rtkCudaLagCorrectionImageFilter.h
│ ├── rtkCudaLagCorrectionImageFilter.hcu
│ ├── rtkCudaLaplacianImageFilter.h
│ ├── rtkCudaLaplacianImageFilter.hcu
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.h
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.hcu
│ ├── rtkCudaParkerShortScanImageFilter.h
│ ├── rtkCudaParkerShortScanImageFilter.hcu
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.h
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.hcu
│ ├── rtkCudaRayCastBackProjectionImageFilter.h
│ ├── rtkCudaRayCastBackProjectionImageFilter.hcu
│ ├── rtkCudaScatterGlareCorrectionImageFilter.h
│ ├── rtkCudaSplatImageFilter.h
│ ├── rtkCudaSplatImageFilter.hcu
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.h
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.hcu
│ ├── rtkCudaUtilities.hcu
│ ├── rtkCudaWarpBackProjectionImageFilter.h
│ ├── rtkCudaWarpBackProjectionImageFilter.hcu
│ ├── rtkCudaWarpForwardProjectionImageFilter.h
│ ├── rtkCudaWarpForwardProjectionImageFilter.hcu
│ ├── rtkCudaWarpImageFilter.h
│ ├── rtkCudaWarpImageFilter.hcu
│ ├── rtkCudaWeidingerForwardModelImageFilter.h
│ ├── rtkCudaWeidingerForwardModelImageFilter.hcu
│ ├── rtkCudaWeidingerForwardModelImageFilter.hxx
│ ├── rtkCyclicDeformationImageFilter.h
│ ├── rtkCyclicDeformationImageFilter.hxx
│ ├── rtkDCMImagXImageIO.h
│ ├── rtkDCMImagXImageIOFactory.h
│ ├── rtkDPExtractShroudSignalImageFilter.h
│ ├── rtkDPExtractShroudSignalImageFilter.hxx
│ ├── rtkDaubechiesWaveletsConvolutionImageFilter.h
│ ├── rtkDaubechiesWaveletsConvolutionImageFilter.hxx
│ ├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.h
│ ├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.hxx
│ ├── rtkDbf.h
│ ├── rtkDePierroRegularizationImageFilter.h
│ ├── rtkDePierroRegularizationImageFilter.hxx
│ ├── rtkDeconstructImageFilter.h
│ ├── rtkDeconstructImageFilter.hxx
│ ├── rtkDeconstructSoftThresholdReconstructImageFilter.h
│ ├── rtkDeconstructSoftThresholdReconstructImageFilter.hxx
│ ├── rtkDenoisingBPDQImageFilter.h
│ ├── rtkDenoisingBPDQImageFilter.hxx
│ ├── rtkDigisensGeometryReader.h
│ ├── rtkDigisensGeometryXMLFileReader.h
│ ├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.h
│ ├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.hxx
│ ├── rtkDisplacedDetectorImageFilter.h
│ ├── rtkDisplacedDetectorImageFilter.hxx
│ ├── rtkDivergenceOfGradientConjugateGradientOperator.h
│ ├── rtkDivergenceOfGradientConjugateGradientOperator.hxx
│ ├── rtkDownsampleImageFilter.h
│ ├── rtkDownsampleImageFilter.hxx
│ ├── rtkDrawBoxImageFilter.h
│ ├── rtkDrawBoxImageFilter.hxx
│ ├── rtkDrawConeImageFilter.h
│ ├── rtkDrawConeImageFilter.hxx
│ ├── rtkDrawConvexImageFilter.h
│ ├── rtkDrawConvexImageFilter.hxx
│ ├── rtkDrawCubeImageFilter.h
│ ├── rtkDrawCylinderImageFilter.h
│ ├── rtkDrawCylinderImageFilter.hxx
│ ├── rtkDrawEllipsoidImageFilter.h
│ ├── rtkDrawEllipsoidImageFilter.hxx
│ ├── rtkDrawGeometricPhantomImageFilter.h
│ ├── rtkDrawGeometricPhantomImageFilter.hxx
│ ├── rtkDrawQuadricImageFilter.h
│ ├── rtkDrawQuadricImageFilter.hxx
│ ├── rtkDrawSheppLoganFilter.h
│ ├── rtkDrawSheppLoganFilter.hxx
│ ├── rtkDualEnergyNegativeLogLikelihood.h
│ ├── rtkEdfImageIO.h
│ ├── rtkEdfImageIOFactory.h
│ ├── rtkEdfRawToAttenuationImageFilter.h
│ ├── rtkEdfRawToAttenuationImageFilter.hxx
│ ├── rtkElektaSynergyGeometryReader.h
│ ├── rtkElektaSynergyLookupTableImageFilter.h
│ ├── rtkElektaSynergyLookupTableImageFilter.hxx
│ ├── rtkElektaSynergyRawLookupTableImageFilter.h
│ ├── rtkElektaSynergyRawLookupTableImageFilter.hxx
│ ├── rtkElektaXVI5GeometryXMLFileReader.h
│ ├── rtkExtractPhaseImageFilter.h
│ ├── rtkExtractPhaseImageFilter.hxx
│ ├── rtkFDKBackProjectionImageFilter.h
│ ├── rtkFDKBackProjectionImageFilter.hxx
│ ├── rtkFDKConeBeamReconstructionFilter.h
│ ├── rtkFDKConeBeamReconstructionFilter.hxx
│ ├── rtkFDKVarianceReconstructionFilter.h
│ ├── rtkFDKVarianceReconstructionFilter.hxx
│ ├── rtkFDKWarpBackProjectionImageFilter.h
│ ├── rtkFDKWarpBackProjectionImageFilter.hxx
│ ├── rtkFDKWeightProjectionFilter.h
│ ├── rtkFDKWeightProjectionFilter.hxx
│ ├── rtkFFTHilbertImageFilter.h
│ ├── rtkFFTHilbertImageFilter.hxx
│ ├── rtkFFTProjectionsConvolutionImageFilter.h
│ ├── rtkFFTProjectionsConvolutionImageFilter.hxx
│ ├── rtkFFTRampImageFilter.h
│ ├── rtkFFTRampImageFilter.hxx
│ ├── rtkFFTVarianceRampImageFilter.h
│ ├── rtkFFTVarianceRampImageFilter.hxx
│ ├── rtkFieldOfViewImageFilter.h
│ ├── rtkFieldOfViewImageFilter.hxx
│ ├── rtkForbildPhantomFileReader.h
│ ├── rtkForwardDifferenceGradientImageFilter.h
│ ├── rtkForwardDifferenceGradientImageFilter.hxx
│ ├── rtkForwardProjectionImageFilter.h
│ ├── rtkForwardProjectionImageFilter.hxx
│ ├── rtkForwardWarpImageFilter.h
│ ├── rtkForwardWarpImageFilter.hxx
│ ├── rtkFourDConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkFourDConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkFourDROOSTERConeBeamReconstructionFilter.h
│ ├── rtkFourDROOSTERConeBeamReconstructionFilter.hxx
│ ├── rtkFourDReconstructionConjugateGradientOperator.h
│ ├── rtkFourDReconstructionConjugateGradientOperator.hxx
│ ├── rtkFourDSARTConeBeamReconstructionFilter.h
│ ├── rtkFourDSARTConeBeamReconstructionFilter.hxx
│ ├── rtkFourDToProjectionStackImageFilter.h
│ ├── rtkFourDToProjectionStackImageFilter.hxx
│ ├── rtkGeneralPurposeFunctions.h
│ ├── rtkGeometricPhantom.h
│ ├── rtkGetNewtonUpdateImageFilter.h
│ ├── rtkGetNewtonUpdateImageFilter.hxx
│ ├── rtkGgoArgsInfoManager.h
│ ├── rtkGgoFunctions.h
│ ├── rtkGlobalResourceProbe.h
│ ├── rtkHilbertImageFilter.h
│ ├── rtkHilbertImageFilter.hxx
│ ├── rtkHisImageIO.h
│ ├── rtkHisImageIOFactory.h
│ ├── rtkHncImageIO.h
│ ├── rtkHncImageIOFactory.h
│ ├── rtkHndImageIO.h
│ ├── rtkHndImageIOFactory.h
│ ├── rtkHomogeneousMatrix.h
│ ├── rtkI0EstimationProjectionFilter.h
│ ├── rtkI0EstimationProjectionFilter.hxx
│ ├── rtkIOFactories.h
│ ├── rtkImagXGeometryReader.h
│ ├── rtkImagXGeometryReader.hxx
│ ├── rtkImagXImageIO.h
│ ├── rtkImagXImageIOFactory.h
│ ├── rtkImagXXMLFileReader.h
│ ├── rtkImageToVectorImageFilter.h
│ ├── rtkImageToVectorImageFilter.hxx
│ ├── rtkImportImageFilter.h
│ ├── rtkImportImageFilter.hxx
│ ├── rtkInterpolatorWithKnownWeightsImageFilter.h
│ ├── rtkInterpolatorWithKnownWeightsImageFilter.hxx
│ ├── rtkIntersectionOfConvexShapes.h
│ ├── rtkIterationCommands.h
│ ├── rtkIterativeConeBeamReconstructionFilter.h
│ ├── rtkIterativeConeBeamReconstructionFilter.hxx
│ ├── rtkIterativeFDKConeBeamReconstructionFilter.h
│ ├── rtkIterativeFDKConeBeamReconstructionFilter.hxx
│ ├── rtkJosephBackAttenuatedProjectionImageFilter.h
│ ├── rtkJosephBackAttenuatedProjectionImageFilter.hxx
│ ├── rtkJosephBackProjectionImageFilter.h
│ ├── rtkJosephBackProjectionImageFilter.hxx
│ ├── rtkJosephForwardAttenuatedProjectionImageFilter.h
│ ├── rtkJosephForwardAttenuatedProjectionImageFilter.hxx
│ ├── rtkJosephForwardProjectionImageFilter.h
│ ├── rtkJosephForwardProjectionImageFilter.hxx
│ ├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.h
│ ├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.hxx
│ ├── rtkLagCorrectionImageFilter.h
│ ├── rtkLagCorrectionImageFilter.hxx
│ ├── rtkLaplacianImageFilter.h
│ ├── rtkLaplacianImageFilter.hxx
│ ├── rtkLastDimensionL0GradientDenoisingImageFilter.h
│ ├── rtkLastDimensionL0GradientDenoisingImageFilter.hxx
│ ├── rtkLookupTableImageFilter.h
│ ├── rtkLookupTableImageFilter.hxx
│ ├── rtkMacro.h
│ ├── rtkMagnitudeThresholdImageFilter.h
│ ├── rtkMagnitudeThresholdImageFilter.hxx
│ ├── rtkMaskCollimationImageFilter.h
│ ├── rtkMaskCollimationImageFilter.hxx
│ ├── rtkMaximumIntensityProjectionImageFilter.h
│ ├── rtkMechlemOneStepSpectralReconstructionFilter.h
│ ├── rtkMechlemOneStepSpectralReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.h
│ ├── rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.h
│ ├── rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.hxx
│ ├── rtkMultiplyByVectorImageFilter.h
│ ├── rtkMultiplyByVectorImageFilter.hxx
│ ├── rtkNesterovUpdateImageFilter.h
│ ├── rtkNesterovUpdateImageFilter.hxx
│ ├── rtkOSEMConeBeamReconstructionFilter.h
│ ├── rtkOSEMConeBeamReconstructionFilter.hxx
│ ├── rtkOraGeometryReader.h
│ ├── rtkOraImageIO.h
│ ├── rtkOraImageIOFactory.h
│ ├── rtkOraLookupTableImageFilter.h
│ ├── rtkOraLookupTableImageFilter.hxx
│ ├── rtkOraXMLFileReader.h
│ ├── rtkParkerShortScanImageFilter.h
│ ├── rtkParkerShortScanImageFilter.hxx
│ ├── rtkPhaseGatingImageFilter.h
│ ├── rtkPhaseGatingImageFilter.hxx
│ ├── rtkPhaseReader.h
│ ├── rtkPhasesToInterpolationWeights.h
│ ├── rtkPolynomialGainCorrectionImageFilter.h
│ ├── rtkPolynomialGainCorrectionImageFilter.hxx
│ ├── rtkProgressCommands.h
│ ├── rtkProjectGeometricPhantomImageFilter.h
│ ├── rtkProjectGeometricPhantomImageFilter.hxx
│ ├── rtkProjectionGeometry.h
│ ├── rtkProjectionGeometry.hxx
│ ├── rtkProjectionStackToFourDImageFilter.h
│ ├── rtkProjectionStackToFourDImageFilter.hxx
│ ├── rtkProjectionsDecompositionNegativeLogLikelihood.h
│ ├── rtkProjectionsReader.h
│ ├── rtkProjectionsReader.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBased.h
│ ├── rtkProjectionsRegionConstIteratorRayBased.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedParallel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedParallel.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithCylindricalPanel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithCylindricalPanel.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.hxx
│ ├── rtkQuadricShape.h
│ ├── rtkRayBoxIntersectionImageFilter.h
│ ├── rtkRayBoxIntersectionImageFilter.hxx
│ ├── rtkRayConvexIntersectionImageFilter.h
│ ├── rtkRayConvexIntersectionImageFilter.hxx
│ ├── rtkRayEllipsoidIntersectionImageFilter.h
│ ├── rtkRayEllipsoidIntersectionImageFilter.hxx
│ ├── rtkRayQuadricIntersectionImageFilter.h
│ ├── rtkRayQuadricIntersectionImageFilter.hxx
│ ├── rtkReconstructImageFilter.h
│ ├── rtkReconstructImageFilter.hxx
│ ├── rtkReconstructionConjugateGradientOperator.h
│ ├── rtkReconstructionConjugateGradientOperator.hxx
│ ├── rtkReg1DExtractShroudSignalImageFilter.h
│ ├── rtkReg1DExtractShroudSignalImageFilter.hxx
│ ├── rtkReg23ProjectionGeometry.h
│ ├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkReorderProjectionsImageFilter.h
│ ├── rtkReorderProjectionsImageFilter.hxx
│ ├── rtkResourceProbesCollector.h
│ ├── rtkSARTConeBeamReconstructionFilter.h
│ ├── rtkSARTConeBeamReconstructionFilter.hxx
│ ├── rtkScatterGlareCorrectionImageFilter.h
│ ├── rtkScatterGlareCorrectionImageFilter.hxx
│ ├── rtkSchlomka2008NegativeLogLikelihood.h
│ ├── rtkSelectOneProjectionPerCycleImageFilter.h
│ ├── rtkSelectOneProjectionPerCycleImageFilter.hxx
│ ├── rtkSeparableQuadraticSurrogateRegularizationImageFilter.h
│ ├── rtkSeparableQuadraticSurrogateRegularizationImageFilter.hxx
│ ├── rtkSheppLoganPhantom.h
│ ├── rtkSheppLoganPhantomFilter.h
│ ├── rtkSheppLoganPhantomFilter.hxx
│ ├── rtkSignalToInterpolationWeights.h
│ ├── rtkSimplexSpectralProjectionsDecompositionImageFilter.h
│ ├── rtkSimplexSpectralProjectionsDecompositionImageFilter.hxx
│ ├── rtkSingularValueThresholdImageFilter.h
│ ├── rtkSingularValueThresholdImageFilter.hxx
│ ├── rtkSoftThresholdImageFilter.h
│ ├── rtkSoftThresholdImageFilter.hxx
│ ├── rtkSoftThresholdTVImageFilter.h
│ ├── rtkSoftThresholdTVImageFilter.hxx
│ ├── rtkSpectralForwardModelImageFilter.h
│ ├── rtkSpectralForwardModelImageFilter.hxx
│ ├── rtkSplatWithKnownWeightsImageFilter.h
│ ├── rtkSplatWithKnownWeightsImageFilter.hxx
│ ├── rtkSubSelectFromListImageFilter.h
│ ├── rtkSubSelectFromListImageFilter.hxx
│ ├── rtkSubSelectImageFilter.h
│ ├── rtkSubSelectImageFilter.hxx
│ ├── rtkSumOfSquaresImageFilter.h
│ ├── rtkSumOfSquaresImageFilter.hxx
│ ├── rtkThreeDCircularProjectionGeometry.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFile.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFileReader.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFileWriter.h
│ ├── rtkTotalNuclearVariationDenoisingBPDQImageFilter.h
│ ├── rtkTotalNuclearVariationDenoisingBPDQImageFilter.hxx
│ ├── rtkTotalVariationDenoiseSequenceImageFilter.h
│ ├── rtkTotalVariationDenoiseSequenceImageFilter.hxx
│ ├── rtkTotalVariationDenoisingBPDQImageFilter.h
│ ├── rtkTotalVariationDenoisingBPDQImageFilter.hxx
│ ├── rtkTotalVariationImageFilter.h
│ ├── rtkTotalVariationImageFilter.hxx
│ ├── rtkUnwarpSequenceConjugateGradientOperator.h
│ ├── rtkUnwarpSequenceConjugateGradientOperator.hxx
│ ├── rtkUnwarpSequenceImageFilter.h
│ ├── rtkUnwarpSequenceImageFilter.hxx
│ ├── rtkUpsampleImageFilter.h
│ ├── rtkUpsampleImageFilter.hxx
│ ├── rtkVarianObiGeometryReader.h
│ ├── rtkVarianObiRawImageFilter.h
│ ├── rtkVarianObiRawImageFilter.hxx
│ ├── rtkVarianObiXMLFileReader.h
│ ├── rtkVarianProBeamGeometryReader.h
│ ├── rtkVarianProBeamXMLFileReader.h
│ ├── rtkVectorImageToImageFilter.h
│ ├── rtkVectorImageToImageFilter.hxx
│ ├── rtkWarpFourDToProjectionStackImageFilter.h
│ ├── rtkWarpFourDToProjectionStackImageFilter.hxx
│ ├── rtkWarpProjectionStackToFourDImageFilter.h
│ ├── rtkWarpProjectionStackToFourDImageFilter.hxx
│ ├── rtkWarpSequenceImageFilter.h
│ ├── rtkWarpSequenceImageFilter.hxx
│ ├── rtkWatcherForResourceProbe.h
│ ├── rtkWaterPrecorrectionImageFilter.h
│ ├── rtkWaterPrecorrectionImageFilter.hxx
│ ├── rtkWeidingerForwardModelImageFilter.h
│ ├── rtkWeidingerForwardModelImageFilter.hxx
│ ├── rtkXRadGeometryReader.h
│ ├── rtkXRadImageIO.h
│ ├── rtkXRadImageIOFactory.h
│ ├── rtkXRadRawToAttenuationImageFilter.h
│ ├── rtkXRadRawToAttenuationImageFilter.hxx
│ ├── rtkXimImageIO.h
│ ├── rtkXimImageIOFactory.h
│ ├── rtkZengBackProjectionImageFilter.h
│ ├── rtkZengBackProjectionImageFilter.hxx
│ ├── rtkZengForwardProjectionImageFilter.h
│ └── rtkZengForwardProjectionImageFilter.hxx
├── index.md
├── itk-module-init.cmake
├── itk-module.cmake
├── pyproject.toml
├── rtkConfiguration.h.in
├── src/
│ ├── CMakeLists.txt
│ ├── rtkBioscanGeometryReader.cxx
│ ├── rtkBoxShape.cxx
│ ├── rtkConditionalMedianImageFilter.cxx
│ ├── rtkConvexShape.cxx
│ ├── rtkCudaAverageOutOfROIImageFilter.cu
│ ├── rtkCudaAverageOutOfROIImageFilter.cxx
│ ├── rtkCudaBackProjectionImageFilter.cu
│ ├── rtkCudaConjugateGradientImageFilter.cu
│ ├── rtkCudaConstantVolumeSeriesSource.cu
│ ├── rtkCudaConstantVolumeSeriesSource.cxx
│ ├── rtkCudaConstantVolumeSource.cu
│ ├── rtkCudaConstantVolumeSource.cxx
│ ├── rtkCudaCropImageFilter.cu
│ ├── rtkCudaCropImageFilter.cxx
│ ├── rtkCudaCyclicDeformationImageFilter.cu
│ ├── rtkCudaCyclicDeformationImageFilter.cxx
│ ├── rtkCudaDisplacedDetectorImageFilter.cu
│ ├── rtkCudaDisplacedDetectorImageFilter.cxx
│ ├── rtkCudaFDKBackProjectionImageFilter.cu
│ ├── rtkCudaFDKBackProjectionImageFilter.cxx
│ ├── rtkCudaFDKConeBeamReconstructionFilter.cxx
│ ├── rtkCudaFDKWeightProjectionFilter.cu
│ ├── rtkCudaFDKWeightProjectionFilter.cxx
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.cu
│ ├── rtkCudaFirstOrderKernels.cu
│ ├── rtkCudaForwardProjectionImageFilter.cu
│ ├── rtkCudaForwardWarpImageFilter.cu
│ ├── rtkCudaForwardWarpImageFilter.cxx
│ ├── rtkCudaInterpolateImageFilter.cu
│ ├── rtkCudaInterpolateImageFilter.cxx
│ ├── rtkCudaIterativeFDKConeBeamReconstructionFilter.cxx
│ ├── rtkCudaLagCorrectionImageFilter.cu
│ ├── rtkCudaLagCorrectionImageFilter.cxx
│ ├── rtkCudaLaplacianImageFilter.cu
│ ├── rtkCudaLaplacianImageFilter.cxx
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.cu
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.cxx
│ ├── rtkCudaParkerShortScanImageFilter.cu
│ ├── rtkCudaParkerShortScanImageFilter.cxx
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.cu
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.cxx
│ ├── rtkCudaRayCastBackProjectionImageFilter.cu
│ ├── rtkCudaRayCastBackProjectionImageFilter.cxx
│ ├── rtkCudaSplatImageFilter.cu
│ ├── rtkCudaSplatImageFilter.cxx
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.cu
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.cxx
│ ├── rtkCudaUtilities.cu
│ ├── rtkCudaWarpBackProjectionImageFilter.cu
│ ├── rtkCudaWarpBackProjectionImageFilter.cxx
│ ├── rtkCudaWarpForwardProjectionImageFilter.cu
│ ├── rtkCudaWarpForwardProjectionImageFilter.cxx
│ ├── rtkCudaWarpImageFilter.cu
│ ├── rtkCudaWarpImageFilter.cxx
│ ├── rtkCudaWeidingerForwardModelImageFilter.cu
│ ├── rtkDCMImagXImageIO.cxx
│ ├── rtkDCMImagXImageIOFactory.cxx
│ ├── rtkDbf.cxx
│ ├── rtkDigisensGeometryReader.cxx
│ ├── rtkDigisensGeometryXMLFileReader.cxx
│ ├── rtkEdfImageIO.cxx
│ ├── rtkEdfImageIOFactory.cxx
│ ├── rtkElektaSynergyGeometryReader.cxx
│ ├── rtkElektaXVI5GeometryXMLFileReader.cxx
│ ├── rtkForbildPhantomFileReader.cxx
│ ├── rtkGeometricPhantom.cxx
│ ├── rtkGlobalResourceProbe.cxx
│ ├── rtkHisImageIO.cxx
│ ├── rtkHisImageIOFactory.cxx
│ ├── rtkHncImageIO.cxx
│ ├── rtkHncImageIOFactory.cxx
│ ├── rtkHndImageIO.cxx
│ ├── rtkHndImageIOFactory.cxx
│ ├── rtkIOFactories.cxx
│ ├── rtkImagXImageIO.cxx
│ ├── rtkImagXImageIOFactory.cxx
│ ├── rtkImagXXMLFileReader.cxx
│ ├── rtkIntersectionOfConvexShapes.cxx
│ ├── rtkOraGeometryReader.cxx
│ ├── rtkOraImageIO.cxx
│ ├── rtkOraImageIOFactory.cxx
│ ├── rtkOraXMLFileReader.cxx
│ ├── rtkPhaseReader.cxx
│ ├── rtkPhasesToInterpolationWeights.cxx
│ ├── rtkQuadricShape.cxx
│ ├── rtkReg23ProjectionGeometry.cxx
│ ├── rtkResourceProbesCollector.cxx
│ ├── rtkSheppLoganPhantom.cxx
│ ├── rtkSignalToInterpolationWeights.cxx
│ ├── rtkThreeDCircularProjectionGeometry.cxx
│ ├── rtkThreeDCircularProjectionGeometryXMLFileReader.cxx
│ ├── rtkThreeDCircularProjectionGeometryXMLFileWriter.cxx
│ ├── rtkVarianObiGeometryReader.cxx
│ ├── rtkVarianObiXMLFileReader.cxx
│ ├── rtkVarianProBeamGeometryReader.cxx
│ ├── rtkVarianProBeamXMLFileReader.cxx
│ ├── rtkWatcherForResourceProbe.cxx
│ ├── rtkXRadGeometryReader.cxx
│ ├── rtkXRadImageIO.cxx
│ ├── rtkXRadImageIOFactory.cxx
│ ├── rtkXimImageIO.cxx
│ └── rtkXimImageIOFactory.cxx
├── test/
│ ├── Baseline/
│ │ ├── AmsterdamShroud/
│ │ │ ├── Amsterdam.mha.sha512
│ │ │ └── Amsterdam_crop.mha.sha512
│ │ ├── Bioscan/
│ │ │ └── geometry.xml.sha512
│ │ ├── Digisens/
│ │ │ ├── attenuation.mha.sha512
│ │ │ └── geometry.xml.sha512
│ │ ├── ESRF/
│ │ │ └── attenuation.mha.sha512
│ │ ├── Elekta/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ └── geometry5.xml.sha512
│ │ ├── ImagX/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── attenuationDCM.mha.sha512
│ │ │ └── geo.xml.sha512
│ │ ├── Laplacian/
│ │ │ └── Laplacian.mha.sha512
│ │ ├── Ora/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ ├── geometry_optitrack.xml.sha512
│ │ │ └── geometry_yawtilt.xml.sha512
│ │ ├── Spectral/
│ │ │ └── OneStep/
│ │ │ ├── newtonUpdate.mha.sha512
│ │ │ ├── out1.mha.sha512
│ │ │ └── out2.mha.sha512
│ │ ├── Varian/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── attenuationHnc.mha.sha512
│ │ │ ├── attenuationProBeam.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ ├── geometryHnc.xml.sha512
│ │ │ └── geometryProBeam.xml.sha512
│ │ └── XRad/
│ │ ├── attenuation.mha.sha512
│ │ └── geometry.xml.sha512
│ ├── CMakeLists.txt
│ ├── Input/
│ │ ├── Bioscan/
│ │ │ └── bioscan.dcm.sha512
│ │ ├── Digisens/
│ │ │ ├── calibration.cal.sha512
│ │ │ └── ima0010.tif.sha512
│ │ ├── ESRF/
│ │ │ ├── dark.edf.sha512
│ │ │ ├── raw.edf.sha512
│ │ │ └── refHST0000.edf.sha512
│ │ ├── Elekta/
│ │ │ ├── FRAME.DBF.sha512
│ │ │ ├── IMAGE.DBF.sha512
│ │ │ ├── _Frames.xml.sha512
│ │ │ └── raw.his.sha512
│ │ ├── Forbild/
│ │ │ └── Thorax.sha512
│ │ ├── GeometricPhantom/
│ │ │ ├── Geometries.txt.sha512
│ │ │ ├── Geometries_Forbild.txt.sha512
│ │ │ ├── SheppLogan.txt.sha512
│ │ │ └── SheppLogan_forbild.txt.sha512
│ │ ├── ImagX/
│ │ │ ├── 1.dcm.sha512
│ │ │ ├── calibration.xml.sha512
│ │ │ ├── raw.raw.sha512
│ │ │ ├── raw.xml.sha512
│ │ │ └── room.xml.sha512
│ │ ├── Ora/
│ │ │ ├── 084183_20211217170607335.mhd.sha512
│ │ │ ├── 084183_20211217170607335.ora.xml.sha512
│ │ │ ├── 0_afterLog.mhd.sha512
│ │ │ ├── 0_afterLog.ora.xml.sha512
│ │ │ ├── 0_afterLog.raw.sha512
│ │ │ ├── 2006137_20220918183246810.mhd.sha512
│ │ │ └── 2006137_20220918183246810.ora.xml.sha512
│ │ ├── Phases/
│ │ │ ├── phases.txt.sha512
│ │ │ ├── phases_3projs.txt.sha512
│ │ │ └── phases_slow.txt.sha512
│ │ ├── Spectral/
│ │ │ ├── OneStep/
│ │ │ │ ├── binnedDetectorResponse.csv.sha512
│ │ │ │ ├── gradient.mha.sha512
│ │ │ │ ├── hessian.mha.sha512
│ │ │ │ ├── incident_spectrum_64_rows.mha.sha512
│ │ │ │ ├── materialAttenuations.csv.sha512
│ │ │ │ ├── materialProjections.mha.sha512
│ │ │ │ ├── no_vector_incident_spectrum_64_rows.mha.sha512
│ │ │ │ ├── photonCounts.mha.sha512
│ │ │ │ ├── projOfOnes.mha.sha512
│ │ │ │ └── spectrum.mha.sha512
│ │ │ ├── detector_response.mha.sha512
│ │ │ ├── incident_spectrum.mha.sha512
│ │ │ ├── material_attenuations.mha.sha512
│ │ │ └── no_vector_incident_spectrum.mha.sha512
│ │ ├── Varian/
│ │ │ ├── Proj_00000.xim.sha512
│ │ │ ├── acqui.xml.sha512
│ │ │ ├── acqui_probeam.xml.sha512
│ │ │ ├── image_00052.hnc.sha512
│ │ │ └── raw.hnd.sha512
│ │ └── XRad/
│ │ ├── SolidWater_HiGain1x1.header.sha512
│ │ ├── SolidWater_HiGain1x1_firstProj.header.sha512
│ │ ├── SolidWater_HiGain1x1_firstProj.img.sha512
│ │ ├── dark.header.sha512
│ │ ├── dark.img.sha512
│ │ ├── flat.header.sha512
│ │ └── flat.img.sha512
│ ├── rtkI0estimationtest.cxx
│ ├── rtkMaximumIntensity.py
│ ├── rtkOutputArgumentWrapping.py
│ ├── rtkTest.h
│ ├── rtkTestConfiguration.h.in
│ ├── rtkTestReg23ProjectionGeometry.cxx
│ ├── rtkadjointoperatorstest.cxx
│ ├── rtkadmmtotalvariationtest.cxx
│ ├── rtkadmmwaveletstest.cxx
│ ├── rtkamsterdamshroudtest.cxx
│ ├── rtkapplicationtest.py
│ ├── rtkargsinfomanagertest.cxx
│ ├── rtkbinningtest.cxx
│ ├── rtkbioscantest.cxx
│ ├── rtkconjugategradientreconstructiontest.cxx
│ ├── rtkconjugategradienttest.cxx
│ ├── rtkcroptest.cxx
│ ├── rtkcudaraycastadjointoperatorstest.cxx
│ ├── rtkcyclicdeformationtest.cxx
│ ├── rtkcylindricaldetectorreconstructiontest.cxx
│ ├── rtkdecomposespectralprojectionstest.cxx
│ ├── rtkdigisenstest.cxx
│ ├── rtkdisplaceddetectorcompcudatest.cxx
│ ├── rtkdisplaceddetectorcompoffsettest.cxx
│ ├── rtkdisplaceddetectortest.cxx
│ ├── rtkdivergencetest.cxx
│ ├── rtkdrawgeometricphantomtest.cxx
│ ├── rtkedftest.cxx
│ ├── rtkelektatest.cxx
│ ├── rtkfbpparalleltest.cxx
│ ├── rtkfdkprojweightcompcudatest.cxx
│ ├── rtkfdktest.cxx
│ ├── rtkforbildtest.cxx
│ ├── rtkforwardattenuatedprojectiontest.cxx
│ ├── rtkforwardprojectiontest.cxx
│ ├── rtkfourdadjointoperatorstest.cxx
│ ├── rtkfourdconjugategradienttest.cxx
│ ├── rtkfourdroostertest.cxx
│ ├── rtkfourdsarttest.cxx
│ ├── rtkfovtest.cxx
│ ├── rtkgaincorrectiontest.cxx
│ ├── rtkgeometryclonetest.cxx
│ ├── rtkgeometryfiletest.cxx
│ ├── rtkgeometryfrommatrixtest.cxx
│ ├── rtkgradienttest.cxx
│ ├── rtkheadertestfooter.cxx
│ ├── rtkhilbertfiltertest.cxx
│ ├── rtkimagxtest.cxx
│ ├── rtkimporttest.cxx
│ ├── rtkinterpolatesplatadjointtest.cxx
│ ├── rtkiterativefdktest.cxx
│ ├── rtkl0gradientnormtest.cxx
│ ├── rtklagcorrectiontest.cxx
│ ├── rtklaplaciantest.cxx
│ ├── rtklutbasedvarI0rawtoatttest.cxx
│ ├── rtkluttest.cxx
│ ├── rtkmaximumintensityprojectiontest.cxx
│ ├── rtkmotioncompensatedfdktest.cxx
│ ├── rtknewtonupdatetest.cxx
│ ├── rtkoratest.cxx
│ ├── rtkosemtest.cxx
│ ├── rtkparallelgeometryfrommatrixtest.cxx
│ ├── rtkprojectgeometricphantomtest.cxx
│ ├── rtkrampfiltertest.cxx
│ ├── rtkrampfiltertest2.cxx
│ ├── rtkregularizedconjugategradienttest.cxx
│ ├── rtksarttest.cxx
│ ├── rtkscatterglarefiltertest.cxx
│ ├── rtkselectoneprojpercycletest.cxx
│ ├── rtkshortscancompcudatest.cxx
│ ├── rtkshortscantest.cxx
│ ├── rtkspectralonesteptest.cxx
│ ├── rtktestexamples.py
│ ├── rtktotalvariationtest.cxx
│ ├── rtkvariancereconstructiontest.cxx
│ ├── rtkvariantest.cxx
│ ├── rtkvectorimageconverterstest.cxx
│ ├── rtkwarpfourdtoprojectionstacktest.cxx
│ ├── rtkwarpprojectionstacktofourdtest.cxx
│ ├── rtkwarptest.cxx
│ ├── rtkwaterprecorrectiontest.cxx
│ ├── rtkwaveletstest.cxx
│ ├── rtkweidingerforwardmodeltest.cxx
│ ├── rtkxradtest.cxx
│ └── rtkzengforwardprojectiontest.cxx
├── utilities/
│ ├── SetupForDevelopment.sh
│ ├── UploadTestData.py
│ ├── clang-format.bash
│ ├── gengetopt/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile.am
│ │ ├── acceptedvalues.cpp
│ │ ├── acceptedvalues.h
│ │ ├── argsdef.c
│ │ ├── argsdef.h
│ │ ├── cmdline.c
│ │ ├── cmdline.ggo
│ │ ├── cmdline.h
│ │ ├── errorcodes.h
│ │ ├── fileutils.cpp
│ │ ├── fileutils.h
│ │ ├── gengetopt.cc
│ │ ├── gengetopt.h
│ │ ├── getopt.c
│ │ ├── getopt.h
│ │ ├── getopt1.c
│ │ ├── ggo_options.h
│ │ ├── ggos.cpp
│ │ ├── ggos.h
│ │ ├── global_opts.h
│ │ ├── globals.cpp
│ │ ├── globals.h
│ │ ├── gm.cc
│ │ ├── gm.h
│ │ ├── gm_utils.cpp
│ │ ├── gm_utils.h
│ │ ├── groups.h
│ │ ├── my_map.h
│ │ ├── my_sstream.h
│ │ ├── my_string.h
│ │ ├── parser.cc
│ │ ├── parser.h
│ │ ├── parser.yy
│ │ ├── scanner.cc
│ │ ├── skels/
│ │ │ ├── Makefile.am
│ │ │ ├── c_source.cc
│ │ │ ├── c_source.h
│ │ │ ├── check_modes.cc
│ │ │ ├── check_modes.h
│ │ │ ├── clear_arg.cc
│ │ │ ├── clear_arg.h
│ │ │ ├── clear_given.cc
│ │ │ ├── clear_given.h
│ │ │ ├── copyright.cc
│ │ │ ├── copyright.h
│ │ │ ├── custom_getopt_gen.cc
│ │ │ ├── custom_getopt_gen.h
│ │ │ ├── dependant_option.cc
│ │ │ ├── dependant_option.h
│ │ │ ├── enum_decl.cc
│ │ │ ├── enum_decl.h
│ │ │ ├── exit_failure.cc
│ │ │ ├── exit_failure.h
│ │ │ ├── file_save.cc
│ │ │ ├── file_save.h
│ │ │ ├── file_save_multiple.cc
│ │ │ ├── file_save_multiple.h
│ │ │ ├── free_list.cc
│ │ │ ├── free_list.h
│ │ │ ├── free_multiple.cc
│ │ │ ├── free_multiple.h
│ │ │ ├── free_string.cc
│ │ │ ├── free_string.h
│ │ │ ├── generic_option.cc
│ │ │ ├── generic_option.h
│ │ │ ├── given_field.cc
│ │ │ ├── given_field.h
│ │ │ ├── group_counter.cc
│ │ │ ├── group_counter.h
│ │ │ ├── group_option.cc
│ │ │ ├── group_option.h
│ │ │ ├── handle_help.cc
│ │ │ ├── handle_help.h
│ │ │ ├── handle_version.cc
│ │ │ ├── handle_version.h
│ │ │ ├── header.cc
│ │ │ ├── header.h
│ │ │ ├── init_args_info.cc
│ │ │ ├── init_args_info.h
│ │ │ ├── multiple_fill_array.cc
│ │ │ ├── multiple_fill_array.h
│ │ │ ├── multiple_opt_list.cc
│ │ │ ├── multiple_opt_list.h
│ │ │ ├── option_arg.cc
│ │ │ ├── option_arg.h
│ │ │ ├── print_help_string.cc
│ │ │ ├── print_help_string.h
│ │ │ ├── required_option.cc
│ │ │ ├── required_option.h
│ │ │ ├── reset_group.cc
│ │ │ ├── reset_group.h
│ │ │ ├── update_given.cc
│ │ │ └── update_given.h
│ │ ├── yyerror.cc
│ │ ├── yyerror.h
│ │ └── yywrap.c
│ └── lp_solve/
│ ├── CMakeLists.txt
│ ├── README.txt
│ ├── bfp/
│ │ ├── bfp_LUSOL/
│ │ │ ├── LUSOL/
│ │ │ │ ├── LUSOL_LGPL.txt
│ │ │ │ ├── LUSOL_Overview.txt
│ │ │ │ ├── LUSOL_README.txt
│ │ │ │ ├── lusol.c
│ │ │ │ ├── lusol.h
│ │ │ │ ├── lusol1.c
│ │ │ │ ├── lusol2.c
│ │ │ │ ├── lusol6a.c
│ │ │ │ ├── lusol6l0.c
│ │ │ │ ├── lusol6u.c
│ │ │ │ ├── lusol7a.c
│ │ │ │ └── lusol8a.c
│ │ │ ├── lp_LUSOL.c
│ │ │ └── lp_LUSOL.h
│ │ ├── lp_BFP.h
│ │ ├── lp_BFP1.c
│ │ └── lp_BFP2.c
│ ├── colamd/
│ │ ├── colamd.c
│ │ └── colamd.h
│ ├── fortify.c
│ ├── ini.c
│ ├── ini.h
│ ├── lp_Hash.c
│ ├── lp_Hash.h
│ ├── lp_MDO.c
│ ├── lp_MDO.h
│ ├── lp_MPS.c
│ ├── lp_MPS.h
│ ├── lp_SOS.c
│ ├── lp_SOS.h
│ ├── lp_bit.h
│ ├── lp_crash.c
│ ├── lp_crash.h
│ ├── lp_explicit.h
│ ├── lp_fortify.h
│ ├── lp_lib.c
│ ├── lp_lib.h
│ ├── lp_matrix.c
│ ├── lp_matrix.h
│ ├── lp_mipbb.c
│ ├── lp_mipbb.h
│ ├── lp_params.c
│ ├── lp_presolve.c
│ ├── lp_presolve.h
│ ├── lp_price.c
│ ├── lp_price.h
│ ├── lp_pricePSE.c
│ ├── lp_pricePSE.h
│ ├── lp_report.c
│ ├── lp_report.h
│ ├── lp_rlp.c
│ ├── lp_rlp.h
│ ├── lp_scale.c
│ ├── lp_scale.h
│ ├── lp_simplex.c
│ ├── lp_simplex.h
│ ├── lp_solveDLL.h
│ ├── lp_types.h
│ ├── lp_utils.c
│ ├── lp_utils.h
│ ├── lp_wlp.c
│ ├── lp_wlp.h
│ ├── lpkit.h
│ ├── shared/
│ │ ├── commonlib.c
│ │ ├── commonlib.h
│ │ ├── mmio.c
│ │ ├── mmio.h
│ │ ├── myblas.c
│ │ └── myblas.h
│ ├── yacc_read.c
│ └── yacc_read.h
└── wrapping/
├── CMakeLists.txt
├── ConvexShape.i
├── FieldOfViewImageFilter.i
├── __init_rtk__.py
├── itkContinuousIndexRTK.wrap
├── itkCovariantVectorRTK.wrap
├── itkCudaImageDataManagerRTK.wrap
├── itkCudaImageRTK.wrap
├── itkCudaImageToImageFilterRTK.wrap
├── itkCudaInPlaceImageFilterRTK.wrap
├── itkFixedArrayRTK.wrap
├── itkImageBaseRTK.wrap
├── itkImageDuplicatorRTK.wrap
├── itkImageFileReaderRTK.wrap
├── itkImageFileWriterRTK.wrap
├── itkImageRTK.wrap
├── itkImageRegionRTK.wrap
├── itkImageSourceRTK.wrap
├── itkImageToImageFilterRTK.wrap
├── itkInPlaceImageFilterRTK.wrap
├── itkMatrixRTK.wrap
├── itkPointRTK.wrap
├── itkPyBufferRTK.wrap
├── itkVariableLengthVectorRTK.wrap
├── itkVectorImageRTK.wrap
├── itkVectorRTK.wrap
├── itkWarpImageFilterRTK.wrap
├── rtkADMMTotalVariationConeBeamReconstructionFilter.wrap
├── rtkADMMWaveletsConeBeamReconstructionFilter.wrap
├── rtkAmsterdamShroudImageFilter.wrap
├── rtkBackProjectionImageFilter.wrap
├── rtkBioscanGeometryReader.wrap
├── rtkBoellaardScatterCorrectionImageFilter.wrap
├── rtkBoxShape.wrap
├── rtkConditionalMedianImageFilter.wrap
├── rtkConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkConstantImageSource.wrap
├── rtkConvexShape.wrap
├── rtkCudaBackProjectionImageFilter.wrap
├── rtkCudaConstantVolumeSource.wrap
├── rtkCudaDisplacedDetectorImageFilter.wrap
├── rtkCudaFDKBackProjectionImageFilter.wrap
├── rtkCudaFDKConeBeamReconstructionFilter.wrap
├── rtkCudaFFTProjectionsConvolutionImageFilter.wrap
├── rtkCudaFFTRampImageFilter.wrap
├── rtkCudaForwardProjectionImageFilter.wrap
├── rtkCudaIterativeFDKConeBeamReconstructionFilter.wrap
├── rtkCudaParkerShortScanImageFilter.wrap
├── rtkCudaRayCastBackProjectionImageFilter.wrap
├── rtkCudaScatterGlareCorrectionImageFilter.wrap
├── rtkCudaSplatImageFilter.wrap
├── rtkCudaWarpForwardProjectionImageFilter.wrap
├── rtkCyclicDeformationImageFilter.wrap
├── rtkDCMImagXImageIO.wrap
├── rtkDPExtractShroudSignalImageFilter.notwrap
├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.wrap
├── rtkDeconstructSoftThresholdReconstructImageFilter.wrap
├── rtkDenoisingBPDQImageFilter.wrap
├── rtkDigisensGeometryReader.wrap
├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.wrap
├── rtkDisplacedDetectorImageFilter.wrap
├── rtkDrawConvexImageFilter.wrap
├── rtkDrawEllipsoidImageFilter.wrap
├── rtkDrawGeometricPhantomImageFilter.wrap
├── rtkDrawQuadricImageFilter.wrap
├── rtkDrawSheppLoganFilter.wrap
├── rtkEdfImageIO.wrap
├── rtkEdfRawToAttenuationImageFilter.wrap
├── rtkElektaSynergyGeometryReader.wrap
├── rtkElektaSynergyRawLookupTableImageFilter.wrap
├── rtkElektaXVI5GeometryXMLFileReader.wrap
├── rtkExtractPhaseImageFilter.wrap
├── rtkExtras.py
├── rtkFDKBackProjectionImageFilter.wrap
├── rtkFDKConeBeamReconstructionFilter.wrap
├── rtkFDKVarianceReconstructionFilter.wrap
├── rtkFDKWarpBackProjectionImageFilter.wrap
├── rtkFDKWeightProjectionFilter.wrap
├── rtkFFTHilbertImageFilter.wrap
├── rtkFFTProjectionsConvolutionImageFilter.wrap
├── rtkFFTRampImageFilter.wrap
├── rtkFFTVarianceRampImageFilter.wrap
├── rtkFieldOfViewImageFilter.wrap
├── rtkForwardProjectionImageFilter.wrap
├── rtkForwardWarpImageFilter.wrap
├── rtkFourDConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkFourDROOSTERConeBeamReconstructionFilter.wrap
├── rtkFourDSARTConeBeamReconstructionFilter.wrap
├── rtkFourDToProjectionStackImageFilter.wrap
├── rtkGeometricPhantom.wrap
├── rtkGlobalResourceProbe.wrap
├── rtkHilbertImageFilter.notwrap
├── rtkHisImageIO.wrap
├── rtkHncImageIO.wrap
├── rtkHndImageIO.wrap
├── rtkI0EstimationProjectionFilter.wrap
├── rtkImagXImageIO.wrap
├── rtkImageToVectorImageFilter.wrap
├── rtkIntersectionOfConvexShapes.wrap
├── rtkIterativeConeBeamReconstructionFilter.wrap
├── rtkIterativeFDKConeBeamReconstructionFilter.wrap
├── rtkJosephBackAttenuatedProjectionImageFilter.wrap
├── rtkJosephBackProjectionImageFilter.wrap
├── rtkJosephForwardAttenuatedProjectionImageFilter.wrap
├── rtkJosephForwardProjectionImageFilter.wrap
├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.wrap
├── rtkLagCorrectionImageFilter.wrap
├── rtkLastDimensionL0GradientDenoisingImageFilter.wrap
├── rtkLookupTableImageFilter.wrap
├── rtkMaskCollimationImageFilter.wrap
├── rtkMaximumIntensityProjectionImageFilter.wrap
├── rtkMechlemOneStepSpectralReconstructionFilter.wrap
├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkOSEMConeBeamReconstructionFilter.wrap
├── rtkOraGeometryReader.wrap
├── rtkOraImageIO.wrap
├── rtkParkerShortScanImageFilter.wrap
├── rtkPhaseGatingImageFilter.wrap
├── rtkPolynomialGainCorrectionImageFilter.wrap
├── rtkProjectGeometricPhantomImageFilter.wrap
├── rtkProjectionGeometry.wrap
├── rtkProjectionStackToFourDImageFilter.wrap
├── rtkProjectionsReader.wrap
├── rtkQuadricShape.wrap
├── rtkRayBoxIntersectionImageFilter.wrap
├── rtkRayConvexIntersectionImageFilter.wrap
├── rtkRayEllipsoidIntersectionImageFilter.wrap
├── rtkRayQuadricIntersectionImageFilter.wrap
├── rtkReg1DExtractShroudSignalImageFilter.notwrap
├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkReorderProjectionsImageFilter.wrap
├── rtkSARTConeBeamReconstructionFilter.wrap
├── rtkScatterGlareCorrectionImageFilter.wrap
├── rtkSelectOneProjectionPerCycleImageFilter.wrap
├── rtkSheppLoganPhantomFilter.wrap
├── rtkSimplexSpectralProjectionsDecompositionImageFilter.wrap
├── rtkSoftThresholdImageFilter.wrap
├── rtkSpectralForwardModelImageFilter.wrap
├── rtkSplatWithKnownWeightsImageFilter.wrap
├── rtkSubSelectFromListImageFilter.wrap
├── rtkSubSelectImageFilter.wrap
├── rtkThreeDCircularProjectionGeometry.wrap
├── rtkThreeDCircularProjectionGeometryXMLFileReader.wrap
├── rtkThreeDCircularProjectionGeometryXMLFileWriter.wrap
├── rtkTotalVariationDenoisingBPDQImageFilter.wrap
├── rtkTotalVariationImageFilter.wrap
├── rtkVarianObiGeometryReader.wrap
├── rtkVarianObiRawImageFilter.wrap
├── rtkVarianProBeamGeometryReader.wrap
├── rtkVectorImageToImageFilter.wrap
├── rtkWaterPrecorrectionImageFilter.wrap
├── rtkXRadGeometryReader.wrap
├── rtkXRadImageIO.wrap
├── rtkXRadRawToAttenuationImageFilter.wrap
├── rtkXimImageIO.wrap
├── rtkZengBackProjectionImageFilter.wrap
└── rtkZengForwardProjectionImageFilter.wrap
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
## This config file is only relevant for clang-format version 19.1.4
##
## Examples of each format style can be found on the in the clang-format documentation
## See: https://clang.llvm.org/docs/ClangFormatStyleOptions.html for details of each option
##
## The clang-format binaries can be downloaded as part of the clang binary distributions
## from https://releases.llvm.org/download.html
##
## Use the script Utilities/Maintenance/clang-format.bash to faciliate
## maintaining a consistent code style.
##
## EXAMPLE apply code style enforcement before commit:
# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_19.1.4} --modified
## EXAMPLE apply code style enforcement after commit:
# Utilities/Maintenance/clang-format.bash --clang ${PATH_TO_CLANG_FORMAT_19.1.4} --last
---
# This configuration requires clang-format version 19.1.4 exactly.
Language: Cpp
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveAssignments:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: true
AlignConsecutiveBitFields:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveDeclarations:
Enabled: true
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: true
AlignConsecutiveMacros:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveShortCaseStatements:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCaseArrows: false
AlignCaseColons: false
AlignConsecutiveTableGenBreakingDAGArgColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenCondOperatorColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenDefinitionColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionPointers: false
PadOperators: false
AlignEscapedNewlines: Left
AlignOperands: Align
AlignTrailingComments:
Kind: Always
OverEmptyLines: 0
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowBreakBeforeNoexceptSpecifier: Never
AllowShortBlocksOnASingleLine: Never
AllowShortCaseExpressionOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: false
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: true
#AllowShortFunctionsOnASingleLine: Inline Only merge functions defined inside a class. Implies empty.
#AllowShortFunctionsOnASingleLine: None (in configuration: None) Never merge functions into a single line.
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AttributeMacros:
- __capability
BinPackArguments: false
BinPackParameters: false
BitFieldColonSpacing: Both
BraceWrapping:
AfterCaseLabel: true
AfterClass: true
AfterControlStatement: Always
AfterEnum: true
AfterExternBlock: true
AfterFunction: true
AfterNamespace: true
AfterObjCDeclaration: true
AfterStruct: true
AfterUnion: true
BeforeCatch: true
BeforeElse: true
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: false
SplitEmptyNamespace: false
BreakAdjacentStringLiterals: true
BreakAfterAttributes: Leave
BreakAfterJavaFieldAnnotations: false
BreakAfterReturnType: All
BreakArrays: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: Always
BreakBeforeBraces: Custom
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeComma
BreakFunctionDefinitionParameters: false
BreakInheritanceList: BeforeComma
BreakStringLiterals: true
BreakTemplateDeclarations: Yes
## The following line allows larger lines in non-documentation code
ColumnLimit: 120
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerIndentWidth: 2
ContinuationIndentWidth: 2
Cpp11BracedListStyle: false
DerivePointerAlignment: false
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IfMacros:
- KJ_IF_MAYBE
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
CaseSensitive: false
- Regex: '.*'
Priority: 1
SortPriority: 0
CaseSensitive: false
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: true
IndentExternBlock: AfterExternBlock
IndentGotoLabels: true
IndentPPDirectives: AfterHash
IndentRequiresClause: true
IndentWidth: 2
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: false
InsertTrailingCommas: None
IntegerLiteralSeparator:
Binary: 0
BinaryMinDigits: 0
Decimal: 0
DecimalMinDigits: 0
Hex: 0
HexMinDigits: 0
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLines:
AtEndOfFile: false
AtStartOfBlock: true
AtStartOfFile: true
LambdaBodyIndentation: Signature
LineEnding: DeriveLF
MacroBlockBegin: ''
MacroBlockEnd: ''
MainIncludeChar: Quote
MaxEmptyLinesToKeep: 2
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: false
PackConstructorInitializers: BinPack
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
## The following line allows larger lines in non-documentation code
PenaltyBreakFirstLessLess: 120
PenaltyBreakOpenParenthesis: 0
PenaltyBreakScopeResolution: 500
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Middle
PPIndentWidth: -1
QualifierAlignment: Custom
QualifierOrder:
- friend
- static
- inline
- constexpr
- const
- type
ReferenceAlignment: Pointer
ReflowComments: true
RemoveBracesLLVM: false
RemoveParentheses: Leave
RemoveSemicolon: false
RequiresClausePosition: OwnLine
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Leave
ShortNamespaceLines: 1
SkipMacroDefinitionBody: false
# We may want to sort the includes as a separate pass
SortIncludes: Never
SortJavaStaticImport: Before
# We may want to revisit this later
SortUsingDeclarations: Never
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeJsonColon: false
SpaceBeforeParens: ControlStatements
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterForeachMacros: true
AfterFunctionDefinitionName: false
AfterFunctionDeclarationName: false
AfterIfMacros: true
AfterOverloadedOperator: false
AfterPlacementOperator: true
AfterRequiresInClause: false
AfterRequiresInExpression: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: Never
SpacesInContainerLiterals: false
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: -1
SpacesInParens: Never
SpacesInParensOptions:
ExceptDoubleParentheses: false
InCStyleCasts: false
InConditionalStatements: false
InEmptyParentheses: false
Other: false
SpacesInSquareBrackets: false
Standard: Latest
StatementAttributeLikeMacros:
- Q_EMIT
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
- ITK_GCC_PRAGMA_PUSH
- ITK_GCC_PRAGMA_POP
- ITK_GCC_SUPPRESS_Wfloat_equal
- ITK_GCC_SUPPRESS_Wformat_nonliteral
- ITK_GCC_SUPPRESS_Warray_bounds
- ITK_CLANG_PRAGMA_PUSH
- ITK_CLANG_PRAGMA_POP
- ITK_CLANG_SUPPRESS_Wzero_as_null_pointer_constant
- CLANG_PRAGMA_PUSH
- CLANG_PRAGMA_POP
- CLANG_SUPPRESS_Wfloat_equal
- INTEL_PRAGMA_WARN_PUSH
- INTEL_PRAGMA_WARN_POP
- INTEL_SUPPRESS_warning_1292
- itkTemplateFloatingToIntegerMacro
- itkLegacyMacro
TableGenBreakInsideDAGArg: DontBreak
TabWidth: 2
UseTab: Never
VerilogBreakBetweenInstancePorts: true
WhitespaceSensitiveMacros:
- BOOST_PP_STRINGIZE
- CF_SWIFT_NAME
- NS_SWIFT_NAME
- PP_STRINGIZE
- STRINGIZE
...
================================================
FILE: .gitattributes
================================================
.git* export-ignore
# Custom attribute to mark sources as using our C++/C code style.
[attr]our-c-style whitespace=tab-in-indent,no-lf-at-eof hooks.style=KWStyle,clangformat,uncrustify
cmake/*.cxx our-c-style
include/*.h* our-c-style
src/*.c* our-c-style
applications/**/*.h our-c-style
applications/**/*.cxx our-c-style
applications/**/*.hxx our-c-style
examples/**/*.cxx our-c-style
utilities/ITKCudaCommon/include/*.h* our-c-style
utilities/ITKCudaCommon/src/*.cxx our-c-style
test/*h our-c-style
test/*cxx our-c-style
*.txt whitespace=tab-in-indent,no-lf-at-eof
*.cmake whitespace=tab-in-indent,no-lf-at-eof
# ExternalData content links must have LF newlines
*.md5 crlf=input
================================================
FILE: .github/workflows/build-test-cxx-cuda.yml
================================================
name: 'Build, Test RTK with CUDA'
on: [push,pull_request]
env:
itk-git-tag: "v5.4.3"
itk-module-deps: "CudaCommon@8baef219d19d8f320898c3c649539bbb5ba3f509"
concurrency:
group: '${{ github.workflow }}@${{ github.head_ref || github.run_id }}'
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
jobs:
build-test-cxx:
runs-on: ${{ matrix.os }}
strategy:
max-parallel: 3
matrix:
os: [self-hosted-linux, self-hosted-windows]
include:
- os: self-hosted-linux
c-compiler: "gcc"
cxx-compiler: "g++"
cmake-build-type: "MinSizeRel"
- os: self-hosted-windows
c-compiler: "cl.exe"
cxx-compiler: "cl.exe"
cmake-build-type: "Release"
steps:
- uses: actions/checkout@v4
- name: Install build dependencies
run: |
python -m pip install --upgrade pip
python -m pip install ninja
- name: self-hosted cleanup
shell: bash
run: |
rm -fr ../ITK
rm -fr ../ITK-build
rm -fr ../build
- name: Download ITK
run: |
cd ..
git clone https://github.com/InsightSoftwareConsortium/ITK.git
cd ITK
git checkout ${{ env.itk-git-tag }}
- name: Build ITK
if: matrix.os != 'self-hosted-windows'
shell: bash
run: |
cd ..
mkdir ITK-build
cd ITK-build
MODULE_ARGS=""
MODULE_DEPS=${{ env.itk-module-deps }}
for MODULE_INFO in ${MODULE_DEPS//:/ }; do
MODULE_NAME=`(echo ${MODULE_INFO} | cut -d'@' -f 1)`
MODULE_ARGS="${MODULE_ARGS} -DModule_${MODULE_NAME}:BOOL=ON"
MODULE_TAG=`(echo ${MODULE_INFO} | cut -d'@' -f 2)`
if [[ -n ${MODULE_TAG} ]]; then
MODULE_ARGS+=" -DModule_${MODULE_NAME}_GIT_TAG:STRING=${MODULE_TAG}"
fi
done
if [[ -n $MODULE_ARGS ]]; then
echo "Building with modules: $MODULE_ARGS"
fi
cmake -DCMAKE_C_COMPILER:FILEPATH="${{ matrix.c-compiler }}" -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_CXX_COMPILER="${{ matrix.cxx-compiler }}" -DCMAKE_BUILD_TYPE:STRING=${{ matrix.cmake-build-type }} -DBUILD_TESTING:BOOL=OFF ${{ env.itk-cmake-options }} ${MODULE_ARGS} -GNinja ../ITK
ninja
- name: Build ITK
if: matrix.os == 'self-hosted-windows'
shell: pwsh
run: |
Set-PSDebug -Trace 1
cd ..
& "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Launch-VsDevShell.ps1" -Arch amd64 -SkipAutomaticLocation
mkdir ITK-build
cd ITK-build
$MODULE_ARGS=""
$MODULE_DEPS="${{ env.itk-module-deps }}"
$MODULES_LIST = $MODULE_DEPS.split(":")
foreach($MODULE_INFO in $MODULES_LIST) {
if($MODULE_ARGS) { $MODULE_ARGS += " " }
$MODULE_NAME = $MODULE_INFO.split("@")[0]
$MODULE_ARGS += "-DModule_$MODULE_NAME`:BOOL=ON"
$MODULE_TAG = $MODULE_INFO.split("@")[1]
if($MODULE_TAG) {
$MODULE_ARGS += " -DModule_$MODULE_NAME`_GIT_TAG:STRING=$MODULE_TAG"
}
}
if($MODULE_ARGS) {
echo "Building with parameters: ${{ env.itk-cmake-options }} $MODULE_ARGS"
}
cmake -DCMAKE_C_COMPILER:FILEPATH="${{ matrix.c-compiler }}" -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_CXX_COMPILER="${{ matrix.cxx-compiler }}" -DCMAKE_BUILD_TYPE:STRING=${{ matrix.cmake-build-type }} -DBUILD_TESTING:BOOL=OFF ${{ env.itk-cmake-options }} $MODULE_ARGS.split(" ") -GNinja ../ITK
ninja
- name: Fetch CTest driver script
run: |
curl -L https://raw.githubusercontent.com/InsightSoftwareConsortium/ITK/dashboard/itk_common.cmake -O
- name: Configure CTest script
shell: bash
run: |
operating_system="${{ matrix.os }}"
cat > dashboard.cmake << EOF
set(CTEST_SITE "GitHubActions")
file(TO_CMAKE_PATH "\$ENV{GITHUB_WORKSPACE}/.." CTEST_DASHBOARD_ROOT)
file(TO_CMAKE_PATH "\$ENV{GITHUB_WORKSPACE}/" CTEST_SOURCE_DIRECTORY)
file(TO_CMAKE_PATH "\$ENV{GITHUB_WORKSPACE}/../build" CTEST_BINARY_DIRECTORY)
set(dashboard_source_name "${GITHUB_REPOSITORY}")
if(ENV{GITHUB_REF_NAME} MATCHES "main")
set(branch "-main")
set(dashboard_model "Continuous")
else()
set(branch "-${GITHUB_REF}")
set(dashboard_model "Experimental")
endif()
set(CTEST_BUILD_NAME "${GITHUB_REPOSITORY}-${operating_system}-\${branch}")
set(CTEST_UPDATE_VERSION_ONLY 1)
set(CTEST_TEST_ARGS \${CTEST_TEST_ARGS} PARALLEL_LEVEL \${PARALLEL_LEVEL})
set(CTEST_BUILD_CONFIGURATION "Release")
set(CTEST_CMAKE_GENERATOR "Ninja")
set(CTEST_CUSTOM_WARNING_EXCEPTION
\${CTEST_CUSTOM_WARNING_EXCEPTION}
# macOS Azure VM Warning
"ld: warning: text-based stub file"
${{ env.warnings-to-ignore }}
)
set(dashboard_no_clean 1)
set(ENV{CC} ${{ matrix.c-compiler }})
set(ENV{CXX} ${{ matrix.cxx-compiler }})
if(WIN32)
set(ENV{PATH} "\${CTEST_DASHBOARD_ROOT}/ITK-build/bin;\$ENV{PATH}")
endif()
set(dashboard_cache "
ITK_DIR:PATH=\${CTEST_DASHBOARD_ROOT}/ITK-build
BUILD_TESTING:BOOL=ON
${{ env.cmake-options }}
")
string(TIMESTAMP build_date "%Y-%m-%d")
message("CDash Build Identifier: \${build_date} \${CTEST_BUILD_NAME}")
message("CTEST_SITE = \${CTEST_SITE}")
include(\${CTEST_SCRIPT_DIRECTORY}/itk_common.cmake)
EOF
cat dashboard.cmake
- name: Build and test
if: matrix.os != 'self-hosted-windows'
run: |
ctest --output-on-failure -j 2 -VV -S dashboard.cmake ${{ env.ctest-options }}
- name: Build and test
if: matrix.os == 'self-hosted-windows'
shell: pwsh
run: |
& "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Launch-VsDevShell.ps1" -Arch amd64 -SkipAutomaticLocation
ctest --output-on-failure -j 2 -VV -S dashboard.cmake ${{ env.ctest-options }}
================================================
FILE: .github/workflows/build-test-package-python-cuda.yml
================================================
name: 'Package RTK with CUDA'
on: [push,pull_request]
env:
itk-wheel-tag: 'v5.4.3'
itk-python-package-tag: 'release'
itk-python-package-org: 'InsightSoftwareConsortium'
itk-module-deps: "RTKConsortium/ITKCudaCommon@8baef219d19d8f320898c3c649539bbb5ba3f509"
concurrency:
group: '${{ github.workflow }}@${{ github.head_ref || github.run_id }}'
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
jobs:
build-linux-cuda-python-packages:
runs-on: self-hosted-linux
strategy:
max-parallel: 2
matrix:
python3-minor-version: ${{ github.event_name == 'pull_request' && fromJSON('["11"]') || fromJSON('["9","10","11"]') }}
manylinux-platform: ["_2_28-x64","2014-x64"]
cuda-version: ["116","121","124"]
steps:
- uses: actions/checkout@v4
- name: 'Fetch build script'
run: |
IPP_DOWNLOAD_GIT_TAG=${{ env.itk-python-package-tag }}
IPP_DOWNLOAD_ORG=${{ env.itk-python-package-org }}
curl -L https://raw.githubusercontent.com/${IPP_DOWNLOAD_ORG:=InsightSoftwareConsortium}/ITKPythonPackage/${IPP_DOWNLOAD_GIT_TAG:=master}/scripts/dockcross-manylinux-download-cache-and-build-module-wheels.sh -O
chmod u+x dockcross-manylinux-download-cache-and-build-module-wheels.sh
- name: 'Build 🐍 Python 📦 package'
shell: bash
run: |
rm -rf dist
export ITK_PACKAGE_VERSION=${{ env.itk-wheel-tag }}
export ITKPYTHONPACKAGE_TAG=${{ env.itk-python-package-tag }}
export ITKPYTHONPACKAGE_ORG=${{ env.itk-python-package-org }}
export ITK_MODULE_PREQ=${{ env.itk-module-deps }}
export CUDA_VERSION=${{ matrix.cuda-version }}
export CUDA_VERSION_MAJOR=`(echo ${CUDA_VERSION} | cut -b1-2)`
export CUDA_VERSION_MINOR=`(echo ${CUDA_VERSION} | cut -b3-)`
CMAKE_OPTIONS="-DRTK_CUDA_VERSION=${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}"
CMAKE_OPTIONS="${CMAKE_OPTIONS} -DRTK_BUILD_APPLICATIONS:BOOL=OFF"
CMAKE_OPTIONS="${CMAKE_OPTIONS} -DCUDAToolkit_ROOT=/usr/lib64/cuda${CUDA_VERSION}"
CMAKE_OPTIONS="${CMAKE_OPTIONS} -DCMAKE_CUDA_COMPILER=/usr/lib64/cuda${CUDA_VERSION}/bin/nvcc"
CMAKE_OPTIONS="${CMAKE_OPTIONS} --config-setting=build.tool-args=-j16"
# The first two are not library paths but are included to be mounted in the
# docker by dockcross-manylinux-build-module-wheels.sh
export LD_LIBRARY_PATH="/home/srit/Downloads/cuda${CUDA_VERSION}"
export LD_LIBRARY_PATH="/usr/lib64/libcuda.so.1:$LD_LIBRARY_PATH"
export LD_LIBRARY_PATH="/home/srit/Downloads/cuda${CUDA_VERSION}/targets/x86_64-linux/lib:$LD_LIBRARY_PATH"
if test -e ../../ITKPythonBuilds-linux-manylinux2014.tar.zst ; then
mv ../../*zst .
fi
MANYLINUX_PLATFORM=${{ matrix.manylinux-platform }}
if test ${MANYLINUX_PLATFORM} == "_2_28-x64" && test ${CUDA_VERSION} -lt 120; then
export IMAGE_TAG=20230106-1aeaea0
CMAKE_OPTIONS="${CMAKE_OPTIONS} -DITK_USE_PYTHON_LIMITED_API=FALSE"
fi
CMAKE_OPTIONS=(--cmake_options "${CMAKE_OPTIONS}")
echo "Manylinux platform ${MANYLINUX_PLATFORM}"
rm -rf ITKPythonPackage
export MANYLINUX_VERSION=`(echo ${MANYLINUX_PLATFORM} | cut -d '-' -f 1)`
export TARGET_ARCH=`(echo ${MANYLINUX_PLATFORM} | cut -d '-' -f 2)`
export ITK_MODULE_NO_CLEANUP=TRUE
echo "Building for manylinux specialization ${MANYLINUX_VERSION} and target architecture ${TARGET_ARCH}"
LIBCUDART=`basename /home/srit/Downloads/cuda${CUDA_VERSION}/targets/x86_64-linux/lib/libcudart.so.${CUDA_VERSION_MAJOR}*`
LIBCUBLAS=`basename /home/srit/Downloads/cuda${CUDA_VERSION}/targets/x86_64-linux/lib/libcublas.so.${CUDA_VERSION_MAJOR}*`
LIBCUBLASLT=`basename /home/srit/Downloads/cuda${CUDA_VERSION}/targets/x86_64-linux/lib/libcublasLt.so.${CUDA_VERSION_MAJOR}*`
LIBCUFFT=`basename /home/srit/Downloads/cuda${CUDA_VERSION}/targets/x86_64-linux/lib/libcufft.so.$((${CUDA_VERSION_MAJOR}-1))*`
sed -i "s/dependencies = \[/dependencies = [ \"itk-cudacommon-cuda${CUDA_VERSION} == 1.1.*\",/g" pyproject.toml
sed -i "s/itk-rtk/itk-rtk-cuda${CUDA_VERSION}/g" pyproject.toml
./dockcross-manylinux-download-cache-and-build-module-wheels.sh "${CMAKE_OPTIONS[@]}" -x "libcuda.so.1;${LIBCUDART};${LIBCUBLAS};${LIBCUBLASLT};${LIBCUFFT}" cp3${{ matrix.python3-minor-version }}
mv *zst ../..
- name: Validate build output
shell: bash
run: |
python -m pip install twine
ls dist/
MANYLINUX_PLATFORM=${{ matrix.manylinux-platform }}
MANYLINUX_VERSION=`(echo ${MANYLINUX_PLATFORM} | cut -d '-' -f 1)`
TARGET_ARCH_NAME=`(echo ${MANYLINUX_PLATFORM} | cut -d '-' -f 2)`
if [[ ${TARGET_ARCH_NAME} == "x64" ]]; then
TARGET_ARCH_NAME="x86_64" # Match auditwheel naming convention
fi
WHEEL_PATTERN="dist/itk_*cp3${{ matrix.python3-minor-version }}*manylinux${MANYLINUX_VERSION}*${TARGET_ARCH_NAME}.whl"
echo "Searching for wheels matching pattern ${WHEEL_PATTERN}"
python -m twine check ${WHEEL_PATTERN}
- name: Publish Python package as GitHub Artifact
uses: actions/upload-artifact@v4
with:
name: LinuxWheel3${{ matrix.python3-minor-version }}${{ matrix.manylinux-platform }}-cuda${{ matrix.cuda-version }}
path: dist/*.whl
build-windows-cuda-python-packages:
runs-on: self-hosted-windows
strategy:
max-parallel: 2
matrix:
python3-minor-version: ${{ github.event_name == 'pull_request' && fromJSON('["11"]') || fromJSON('["9","10","11"]') }}
cuda-version: ["124"]
steps:
- uses: actions/checkout@v4
with:
path: "im"
- name: 'Reduce source path length'
shell: bash
run: |
# Move ITKPythonBuilds archive to the checked-out source
if test -f ../../im/ITKPythonBuilds-windows.zip; then
mv ../../im/*.zip im
fi
rm -fr ../../im
# Move checked-out source to a shorter path to avoid Windows path length issues
mv im ../../
- name: 'Fetch build script'
shell: pwsh
run: |
cd ../../im
$ITKPYTHONPACKAGE_TAG = "${{ env.itk-python-package-tag }}"
$ITKPYTHONPACKAGE_ORG = "${{ env.itk-python-package-org }}"
$SCRIPT_UPSTREAM = "https://raw.githubusercontent.com/$ITKPYTHONPACKAGE_ORG/ITKPythonPackage/$ITKPYTHONPACKAGE_TAG/scripts/windows-download-cache-and-build-module-wheels.ps1"
echo "Fetching $SCRIPT_UPSTREAM"
(new-object net.webclient).DownloadString($SCRIPT_UPSTREAM) > windows-download-cache-and-build-module-wheels.ps1
- name: 'Build 🐍 Python 📦 package'
shell: pwsh
run: |
if (Test-Path dist) { rm dist -r -fo }
cd ../../im
& "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\Launch-VsDevShell.ps1" -Arch amd64 -SkipAutomaticLocation
$env:CC="cl.exe"
$env:CXX="cl.exe"
$env:ITK_PACKAGE_VERSION = "${{ env.itk-wheel-tag }}"
$env:ITKPYTHONPACKAGE_TAG = "${{ env.itk-python-package-tag }}"
$env:ITKPYTHONPACKAGE_ORG = "${{ env.itk-python-package-org }}"
$env:ITK_MODULE_PREQ = "${{ env.itk-module-deps }}"
$CUDA_VERSION = "${{ matrix.cuda-version }}"
$CUDA_VERSION_MAJOR=$CUDA_VERSION.substring(0,2)
$CUDA_VERSION_MINOR=$CUDA_VERSION.substring(2,$CUDA_VERSION.Length-2)
$env:CUDA_PATH = "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}"
$env:CUDACXX = "$env:CUDA_PATH\bin\nvcc.exe"
$env:Path = "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}\bin;" + $env:Path
$LIBCUDART= (Get-Item "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}\bin\cudart64*dll" ).Name
$LIBCUBLAS= (Get-Item "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}\bin\cublas64*dll" ).Name
$LIBCUBLASLT= (Get-Item "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}\bin\cublasLt64*dll" ).Name
$LIBCUFFT= (Get-Item "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}\bin\cufft64*dll" ).Name
((Get-Content -Path pyproject.toml) -replace "itk-rtk","itk-rtk-cuda${CUDA_VERSION}") | Set-Content -Path pyproject.toml
((Get-Content -Path pyproject.toml) -replace "dependencies = \[","dependencies = [""itk-cudacommon-cuda${CUDA_VERSION} == 1.1.*"",") | Set-Content -Path pyproject.toml
./windows-download-cache-and-build-module-wheels.ps1 "${{ matrix.python3-minor-version }}" -setup_options "--lib-paths ""C:/Program\ Files/NVIDIA\ GPU\ Computing\ Toolkit/CUDA/v${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}/bin"" --exclude-libs ""nvcuda.dll;concrt140.dll;${LIBCUDART};${LIBCUBLAS};${LIBCUBLASLT};${LIBCUFFT}""" -cmake_options """-DRTK_CUDA_VERSION=${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}"" ""-DCMAKE_CUDA_COMPILER=$env:CUDACXX"" ""-DRTK_BUILD_APPLICATIONS:BOOL=OFF"""
mkdir -p '${{ github.workspace }}\dist'
cp 'dist\*.whl' '${{ github.workspace }}\dist'
- name: Validate build output
shell: pwsh
run: |
python -m pip install twine
ls dist/
$WHEEL_PATTERN = "dist/itk_*cp3${{ matrix.python3-minor-version }}*win*.whl"
echo "Searching for wheels matching pattern ${WHEEL_PATTERN}"
python -m twine check ${WHEEL_PATTERN}
- name: Publish Python package as GitHub Artifact
uses: actions/upload-artifact@v4
with:
name: WindowsWheel3${{ matrix.python3-minor-version }}-cuda${{ matrix.cuda-version }}
path: dist/*.whl
publish-python-packages-to-pypi:
needs:
- build-linux-cuda-python-packages
- build-windows-cuda-python-packages
runs-on: ubuntu-22.04
steps:
- name: Download Python Packages
uses: actions/download-artifact@v4
- name: Prepare packages for upload
run: |
ls -R
for d in */; do
mv ${d}/*.whl .
done
mkdir dist
mv *.whl dist/
ls dist
- name: Publish 🐍 Python 📦 package to PyPI
if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')
uses: pypa/gh-action-pypi-publish@v1.5.1
with:
skip_existing: true
user: __token__
password: ${{ secrets.pypi_password }}
test-python-wheel:
needs:
- build-linux-cuda-python-packages
runs-on: self-hosted-linux
steps:
- uses: actions/checkout@v4
- name: Download all wheel artifacts
uses: actions/download-artifact@v4
with:
path: wheels
- name: Set up Python 3.11
uses: actions/setup-python@v4
with:
python-version: '3.11'
- name: Test python wheel
run: |
# Find the CUDA 124 wheel for Python 3.11 dynamically
wheel=$(find wheels -name "*cuda124*cp311*manylinux_2_28_x86_64.whl" -type f | head -1)
pip uninstall -y $(pip list | grep -E '^itk-')
echo "Installing wheel: $wheel"
pip install $wheel
pip install pytest matplotlib
pytest $GITHUB_WORKSPACE/test/*.py -vv -W "ignore:builtin type swig"
================================================
FILE: .github/workflows/build-test-package.yml
================================================
name: Build, test, package
on: [push,pull_request]
concurrency:
group: '${{ github.workflow }}@${{ github.head_ref || github.run_id }}'
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
jobs:
cxx-build-workflow:
uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-cxx.yml@v5.4.3
python-build-workflow:
uses: InsightSoftwareConsortium/ITKRemoteModuleBuildTestPackageAction/.github/workflows/build-test-package-python.yml@v5.4.3
with:
cmake-options: '-DRTK_BUILD_APPLICATIONS:BOOL=OFF'
python3-minor-versions: ${{ github.event_name == 'pull_request' && '["11"]' || '["9","10","11"]' }}
itk-python-package-tag: 'release'
secrets:
pypi_password: ${{ secrets.pypi_password }}
test-python-wheel:
needs:
- python-build-workflow
runs-on: self-hosted-linux
steps:
- uses: actions/checkout@v4
- name: Download all wheel artifacts
uses: actions/download-artifact@v4
with:
path: wheels
- name: Set up Python 3.11
uses: actions/setup-python@v4
with:
python-version: '3.11'
- name: Test python wheel
run: |
# Find wheel for Python 3.11 dynamically
wheel=$(find wheels -name "*cp311*manylinux_2_28_x86_64.whl" -type f | head -1)
pip uninstall -y $(pip list | grep -E '^itk-')
echo "Installing wheel: $wheel"
pip install $wheel
pip install pytest matplotlib
pytest $GITHUB_WORKSPACE/test/*.py -vv -W "ignore:builtin type swig"
================================================
FILE: .github/workflows/clang-format-linter.yml
================================================
name: clang-format linter
on: [push,pull_request]
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: InsightSoftwareConsortium/ITKClangFormatLinterAction@master
with:
itk-branch: main
================================================
FILE: .gitignore
================================================
# Do not add ExternalData module staging files
.ExternalData*
# back-up files
*~
*.bak
# vim swp files
*.swp
## Ignore files that are used for auto_completion with clang
*.clang_complete
## YouCompleteMe vim plugin configuration file
.ycm_extra_conf.py
# KWStyle hook output
*.kws
# compiled python files
*.pyc
# qtcreator
CMakeLists.txt.user*
# kdevelop
*.kdev*
.kdev*
# back-up files when conflicts occur
*.orig
# Clion editor internal project information
.idea
# Mac System File
.DS_Store
================================================
FILE: .readthedocs.yml
================================================
# .readthedocs.yml
# Read the Docs configuration file
# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
# Required
version: 2
build:
os: ubuntu-22.04
tools:
python: "3.11"
apt_packages:
- fonts-roboto
- graphviz
sphinx:
configuration: conf.py
python:
install:
- requirements: documentation/docs/requirements.txt
================================================
FILE: CMakeLists.txt
================================================
#=========================================================
# RTK : Reconstruction Toolkit
#=========================================================
# Respect the CMAKE_CXX_STANDARD flags when building for
# ITKv5 or C++11.
cmake_minimum_required(VERSION 3.16.3 FATAL_ERROR)
## Only policies introduced after the cmake_minimum_required
## version need to explicitly be set to NEW.
## Refer to https://cmake.org/cmake/help/v3.11/manual/cmake-policies.7.html
set(CMAKE_POLICIES
CMP0135)
foreach(p ${CMAKE_POLICIES})
if(POLICY ${p})
cmake_policy(SET ${p} NEW)
endif()
endforeach()
#=========================================================
# Help function to debug CMake
macro (DD in)
message(${in}=[${${in}}])
endmacro()
#=========================================================
project(RTK)
## RTK Version
set(RTK_VERSION_MAJOR "2")
set(RTK_VERSION_MINOR "7")
set(RTK_VERSION_PATCH "0")
set(RTK_VERSION_STRING "${RTK_VERSION_MAJOR}.${RTK_VERSION_MINOR}")
set(RTK_LIBRARIES RTK)
#=========================================================
# Installation variables
#=========================================================
if(NOT CMAKE_INSTALL_LIBDIR)
set(CMAKE_INSTALL_LIBDIR lib)
endif()
if(NOT RTK_INSTALL_RUNTIME_DIR)
set(RTK_INSTALL_RUNTIME_DIR bin)
endif()
if(NOT RTK_INSTALL_LIB_DIR)
set(RTK_INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR})
endif()
if(NOT RTK_INSTALL_ARCHIVE_DIR)
set(RTK_INSTALL_ARCHIVE_DIR ${CMAKE_INSTALL_LIBDIR})
endif()
if(NOT RTK_INSTALL_INCLUDE_DIR)
set(RTK_INSTALL_INCLUDE_DIR include/RTK)
endif()
if(NOT RTK_INSTALL_PACKAGE_DIR)
set(RTK_INSTALL_PACKAGE_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/RTK")
endif()
#Set position independent code for Unix (-fPIC)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
#=========================================================
# Remove some MS Visual c++ flags
if(MSVC)
add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
endif()
#=========================================================
# Remove some Intel compiler warnings
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
string(REPLACE "-Wno-unused-parameter" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
if(WIN32)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qwd1268")
else()
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -wd1268")
endif()
endif()
include(cmake/rtkCompilerFlags.cmake)
# --------------------------------------------------------
# Find ITK (required)
if(NOT ITK_SOURCE_DIR)
find_package(ITK 5.1 REQUIRED)
endif()
# --------------------------------------------------------
# Shared libraries option
if(NOT ITK_SOURCE_DIR)
set(RTK_BUILD_SHARED_LIBS ${ITK_BUILD_SHARED})
else()
set(RTK_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
endif()
# ----------------------------------------------------------------------------
# Set RTK_DATA_ROOT
# Internally used by XRadRawToAttenuationImageFilter to set the path for its
# flat and dark headers.
if(NOT ITK_SOURCE_DIR)
set(RTK_DATA_ROOT ${CMAKE_BINARY_DIR}/ExternalData/test CACHE PATH "Path of the data root" FORCE)
else()
file(RELATIVE_PATH RTK_RELATIVE_PATH ${ITK_SOURCE_DIR} ${RTK_SOURCE_DIR})
set(RTK_DATA_ROOT ${ExternalData_BINARY_ROOT}/${RTK_RELATIVE_PATH}/test CACHE PATH "Path of the data root" FORCE)
endif()
mark_as_advanced(RTK_DATA_ROOT)
# --------------------------------------------------------
# Initialization
if(NOT ITK_SOURCE_DIR)
include(itk-module-init.cmake)
if(RTK_BUILD_SHARED_LIBS)
set(ITK_LIBRARY_BUILD_TYPE "SHARED")
else()
set(ITK_LIBRARY_BUILD_TYPE "STATIC")
endif()
endif()
#=========================================================
# If choose to build documentation, then search for Doxygen/Sphinx executables.
option(RTK_BUILD_DOXYGEN "Build Doxygen Documentation" OFF)
if(RTK_BUILD_DOXYGEN)
add_subdirectory(documentation/Doxygen)
endif()
option(RTK_BUILD_SPHINX "Build Sphinx Documentation" OFF)
if(RTK_BUILD_SPHINX)
add_subdirectory(documentation/docs)
endif()
# Setup build locations.
if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${RTK_BINARY_DIR}/bin)
endif()
if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${RTK_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
endif()
if(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY)
# Python builds CI workflows expects archives to be placed in the ITK lib
# directory. This makes sure that other remote modules that depends on RTK
# can link against the RTK libraries.
if (WRAP_ITK_INSTALL_COMPONENT_IDENTIFIER STREQUAL "PythonWheel")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${ITK_DIR}/${CMAKE_INSTALL_LIBDIR})
else()
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${RTK_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
endif()
endif()
#=========================================================
# lp_solve library
#=========================================================
add_subdirectory(utilities/lp_solve)
set(LPSOLVE_INCLUDE_DIRS
${PROJECT_SOURCE_DIR}/utilities/lp_solve
${PROJECT_SOURCE_DIR}/utilities/lp_solve/shared
${PROJECT_SOURCE_DIR}/utilities/lp_solve/bfp
${PROJECT_SOURCE_DIR}/utilities/lp_solve/bfp/bfp_LUSOL
${PROJECT_SOURCE_DIR}/utilities/lp_solve/bfp/bfp_LUSOL/LUSOL
${PROJECT_SOURCE_DIR}/utilities/lp_solve/colamd
)
list(APPEND RTK_INCLUDE_DIRS
"${LPSOLVE_INCLUDE_DIRS}")
#=========================================================
# Include directories
#=========================================================
list(APPEND RTK_INCLUDE_DIRS
${RTK_BINARY_DIR}/include)
#=========================================================
# Generate RTKConfig.cmake for the build tree.
set(RTK_MODULE_PATH_CONFIG ${CMAKE_MODULE_PATH})
# Add option to control the generation of RTK applications
option(RTK_BUILD_APPLICATIONS "Build RTK applications" ON)
#-----------------------------------------------------------------------------
# Common revision info between applications
include(GetGitRevisionDescription)
get_git_head_revision(GIT_REFSPEC GIT_SHA1)
if(GIT_SHA1 MATCHES ".*NOTFOUND")
set(RTK_VERSION_HASH "")
else()
set(RTK_VERSION_HASH ", git hash ${GIT_SHA1}")
endif()
set(RTK_EXPORT_CODE_BUILD "
# The RTK version number
set(RTK_VERSION_MAJOR ${RTK_VERSION_MAJOR})
set(RTK_VERSION_MINOR ${RTK_VERSION_MINOR})
set(RTK_VERSION_PATCH ${RTK_VERSION_PATCH})
# Whether the compiled version of RTK uses CUDA
set(RTK_USE_CUDA ${RTK_USE_CUDA})
# Whether RTK applications were built
set(RTK_BUILD_APPLICATIONS ${RTK_BUILD_APPLICATIONS})
if(RTK_USE_CUDA)
find_package(CUDAToolkit)
set(RTK_CUDA_PROJECTIONS_SLAB_SIZE \"16\" CACHE STRING \"Number of projections processed simultaneously in CUDA forward and back projections\")
endif()
")
set(RTK_EXPORT_CODE_INSTALL "
# The RTK version number
set(RTK_VERSION_MAJOR ${RTK_VERSION_MAJOR})
set(RTK_VERSION_MINOR ${RTK_VERSION_MINOR})
set(RTK_VERSION_PATCH ${RTK_VERSION_PATCH})
# Whether the compiled version of RTK uses CUDA
set(RTK_USE_CUDA ${RTK_USE_CUDA})
# Whether RTK applications were built
set(RTK_BUILD_APPLICATIONS ${RTK_BUILD_APPLICATIONS})
if(RTK_USE_CUDA)
find_package(CUDAToolkit)
set(RTK_CUDA_PROJECTIONS_SLAB_SIZE \"16\" CACHE STRING \"Number of projections processed simultaneously in CUDA forward and back projections\")
endif()
")
#=========================================================
# Configure and build ITK external module
#=========================================================
if(NOT ITK_SOURCE_DIR)
if(NOT EXISTS ${ITK_CMAKE_DIR}/ITKModuleMacros.cmake)
message(FATAL_ERROR "Modules can only be built against an ITK build tree; they cannot be built against an ITK install tree.")
endif()
list(APPEND CMAKE_MODULE_PATH ${ITK_CMAKE_DIR})
include(ITKModuleExternal)
# Add third party to RTK build targets.
# This must be done after RTK has been loaded by ITK to make sure
# ${itk-module} variables are defined for RTK.
itk_module_target(lpsolve55)
if(${ITK_VERSION} VERSION_LESS 5.3)
## Set the default target properties for RTK
if(NOT CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD 14) # Supported values are ``11``, ``14``, and ``17``.
endif()
if(NOT CMAKE_CXX_STANDARD_REQUIRED)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif()
if(NOT CMAKE_CXX_EXTENSIONS)
set(CMAKE_CXX_EXTENSIONS OFF)
endif()
## Default to release
if (NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release)
endif()
endif()
else()
itk_module_impl()
endif()
# Propagate cmake options in a header file
# Must be done after the external module configuration to make sure CudaCommon_VERSION is defined
configure_file(${RTK_SOURCE_DIR}/rtkConfiguration.h.in
${RTK_BINARY_DIR}/include/rtkConfiguration.h)
# Install lpsolve headers
install(FILES ${RTK_SOURCE_DIR}/utilities/lp_solve/lp_bit.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_crash.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_explicit.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_fortify.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_Hash.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_lib.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_matrix.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_MDO.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_mipbb.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_MPS.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_presolve.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_price.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_pricePSE.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_report.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_rlp.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_scale.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_simplex.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_solveDLL.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_SOS.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_types.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_utils.h
${RTK_SOURCE_DIR}/utilities/lp_solve/lp_wlp.h
DESTINATION ${RTK_INSTALL_INCLUDE_DIR}/lpsolve
COMPONENT Development)
target_include_directories(lpsolve55 PUBLIC $<INSTALL_INTERFACE:${RTK_INSTALL_INCLUDE_DIR}/lpsolve>)
# Install configuration file
install(FILES ${RTK_BINARY_DIR}/include/rtkConfiguration.h DESTINATION ${RTK_INSTALL_INCLUDE_DIR})
install(FILES ${RTK_SOURCE_DIR}/cmake/FindGengetopt.cmake
${RTK_SOURCE_DIR}/cmake/GetGitRevisionDescription.cmake
${RTK_SOURCE_DIR}/cmake/GetGitRevisionDescription.cmake.in
DESTINATION ${ITK_INSTALL_PACKAGE_DIR})
if(NOT ITK_SOURCE_DIR)
install(CODE "MESSAGE(FATAL_ERROR \"Cannot install, RTK is compiled separately from ITK. Installation is only functional if RTK is compiled within ITK.\")")
endif()
#=========================================================
# Build applications
#=========================================================
option(RTK_PROBE_EACH_FILTER "Probe each RTK filter in a global object and report times and memory used in RTK applications" OFF)
if(RTK_BUILD_APPLICATIONS)
add_subdirectory(applications)
endif()
# --------------------------------------------------------
# Setup KWStyle from ITK
if(ITK_USE_KWSTYLE)
find_package( Git )
if(GIT_FOUND AND EXISTS "${RTK_SOURCE_DIR}/.git/config")
execute_process( COMMAND ${GIT_EXECUTABLE} config hooks.KWStyle.path
"${KWSTYLE_EXECUTABLE}"
WORKING_DIRECTORY ${RTK_SOURCE_DIR} )
endif()
endif()
# --------------------------------------------------------
# Setup ClangFormat from ITK
if(ITK_USE_CLANGFORMAT)
find_package( Git )
if(GIT_FOUND AND EXISTS "${RTK_SOURCE_DIR}/.git/config")
execute_process(COMMAND ${GIT_EXECUTABLE} config clangFormat.binary
"${CLANG_FORMAT_EXECUTABLE}"
WORKING_DIRECTORY ${RTK_SOURCE_DIR})
endif()
endif()
#=========================================================
# Install pre-commit hook
#=========================================================
if(EXISTS "${RTK_SOURCE_DIR}/.git/config" AND
NOT EXISTS "${RTK_SOURCE_DIR}/.git/hooks/pre-commit")
# Silently ignore the error if the hooks directory is read-only.
execute_process(
COMMAND ${CMAKE_COMMAND} -E copy ${RTK_SOURCE_DIR}/cmake/Hooks/pre-commit
${RTK_SOURCE_DIR}/.git/hooks/pre-commit
OUTPUT_VARIABLE _output
ERROR_VARIABLE _output
RESULT_VARIABLE _result
)
if(_result AND NOT "${_output}" MATCHES "Error copying file")
message("${_output}")
endif()
endif()
================================================
FILE: COPYRIGHT.TXT
================================================
RTK is copyrighted software.
Copyright (c) 2010-2012 RTK consortium
All rights reserved
You can freely use and distribute RTK under an Apache 2.0 license.
See LICENSE.TXT for details
------------------------------------------------------------------------
Some code is modified from plastimatch.org:
- hnd_io.c in itkHndImageIO.cxx
- fdk_cuda.cu in itkCudaFDKBackProjectionImageFilter.cu
Plastimatch Software License ("Software License") Version 1.0
This Software License covers downloads from the Plastimatch project
("Plastimatch") maintained by The General Hospital Corporation
Inc. ("MGH").
Your downloading, copying, modifying, displaying, distributing or use
of any software and/or data from Plastimatch (collectively, the
"Software") constitutes acceptance of all of the terms and conditions
of this Software License. If you do not agree to such terms and
conditions, you have no right to download, copy, modify, display,
distribute or use the Software.
1. As used in this Software License, "you" means the individual
downloading and/or using, reproducing, modifying, displaying and/or
distributing the Software and the institution or entity which
employs or is otherwise affiliated with such individual in
connection therewith. The MGH hereby grants you, with right to
sublicense, with respect to MGH's rights in the software, and data,
if any, which is the subject of this Software License
(collectively, the "Software"), a royalty-free, non-exclusive
license to use, reproduce, make derivative works of, display and
distribute the Software, provided that:
(a) you accept and adhere to all of the terms and conditions of
this Software License;
(b) in connection with any copy of or sublicense of all or any
portion of the Software, all of the terms and conditions in this
Software License shall appear in and shall apply to such copy and
such sublicense, including without limitation all source and
executable forms and on any user documentation, prefaced with the
following words: "All or portions of this licensed product (such
portions are the "Software") have been obtained under license from
MGH and are subject to the following terms and conditions:"
(c) you preserve and maintain all applicable attributions,
copyright notices and licenses included in or applicable to the
Software;
(d) modified versions of the Software must be clearly identified
and marked as such, and must not be misrepresented as being the
original Software; and
(e) you consider making, but are under no obligation to make, the
source code of any of your modifications to the Software freely
available to others on an open source basis.
2. The license granted under this Software License includes without
limitation the right to (i) incorporate the Software into
proprietary programs (subject to any restrictions applicable to
such programs), (ii) add your own copyright statement to your
modifications of the Software, and (iii) provide additional or
different license terms and conditions in your sublicenses of
modifications of the Software; provided that in each case your use,
reproduction or distribution of such modifications otherwise
complies with the conditions stated in this Software License.
3. This Software License does not grant any rights with respect to
third party software, except those rights that MGH has been
authorized by a third party to grant to you, and accordingly you
are solely responsible for (i) obtaining any permissions from third
parties that you need to use, reproduce, make derivative works of,
display and distribute the Software, and (ii) informing your
sublicensees, including without limitation your end-users, of their
obligations to secure any such required permissions.
4. The Software has been designed for research purposes only and has
not been reviewed or approved by the Food and Drug Administration
or by any other agency. YOU ACKNOWLEDGE AND AGREE THAT CLINICAL
APPLICATIONS ARE NEITHER RECOMMENDED NOR ADVISED. Any
commercialization of the Software is at the sole risk of the party
or parties engaged in such commercialization. You further agree to
use, reproduce, make derivative works of, display and distribute
the Software in compliance with all applicable governmental laws,
regulations and orders, including without limitation those relating
to export and import control.
5. The Software is provided "AS IS" and neither MGH nor any
contributor to the software (each a "Contributor") shall have any
obligation to provide maintenance, support, updates, enhancements
or modifications thereto. MGH AND ALL CONTRIBUTORS SPECIFICALLY
DISCLAIM ALL EXPRESS AND IMPLIED WARRANTIES OF ANY KIND INCLUDING,
BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR
A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL MGH
OR ANY CONTRIBUTOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
SPECIAL, INCIDENTAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY ARISING IN ANY WAY RELATED TO
THE SOFTWARE, EVEN IF MGH OR ANY CONTRIBUTOR HAS BEEN ADVISED OF
THE POSSIBILITY OF SUCH DAMAGES. TO THE MAXIMUM EXTENT NOT
PROHIBITED BY LAW OR REGULATION, YOU FURTHER ASSUME ALL LIABILITY
FOR YOUR USE, REPRODUCTION, MAKING OF DERIVATIVE WORKS, DISPLAY,
LICENSE OR DISTRIBUTION OF THE SOFTWARE AND AGREE TO INDEMNIFY AND
HOLD HARMLESS MGH AND ALL CONTRIBUTORS FROM AND AGAINST ANY AND ALL
CLAIMS, SUITS, ACTIONS, DEMANDS AND JUDGMENTS ARISING THEREFROM.
6. None of the names, logos or trademarks of MGH or any of MGH's
affiliates or any of the Contributors, or any funding agency, may
be used to endorse or promote products produced in whole or in part
by operation of the Software or derived from or based on the
Software without specific prior written permission from the
applicable party.
7. Any use, reproduction or distribution of the Software which is not
in accordance with this Software License shall automatically revoke
all rights granted to you under this Software License and render
Paragraphs 1 and 2 of this Software License null and void.
8. This Software License does not grant any rights in or to any
intellectual property owned by MGH or any Contributor except those
rights expressly granted hereunder.
------------------------------------------------------------------------
gengetopt code has been taken from git://git.sv.gnu.org/gengetopt.git
tag rel_2_22_4
gengetopt - generate a C function that uses getopt_long
to parse command line arguments
Copyright (C) 1999, 2011, 2012, 2013-2007, Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
Use of gengetopt does not impose any particular license on the
generated code.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
The included file 'COPYING' is a copy of the GNU General Public License.
------------------------------------------------------------------------
itkBinShrinkImageFilter has been taken from https://hdl.handle.net/10380/3450
It uses the same Apache 2.0 license as RTK
------------------------------------------------------------------------
itkImageScanlineConstIterator has been taken from ITK 4.5.0
It uses the same Apache 2.0 license as RTK
------------------------------------------------------------------------
Some code is modified (a lot) from GIFT, the Generalized Image Fusion Toolkit
(https://hdl.handle.net/1926/216)
- rtkDaubechiesWaveletsKernelSource.h
- rtkDaubechiesWaveletsKernelSource.hxx
- rtkDeconstructImageFilter.h
- rtkDeconstructImageFilter.hxx
- rtkReconstructImageFilter.h
- rtkReconstructImageFilter.hxx
- rtkDownsampleImageFilter.h
- rtkDownsampleImageFilter.hxx
- rtkUpsampleImageFilter.h
- rtkUpsampleImageFilter.hxx
------------------------------------------------------------------------
Some code is modified from https://sourceforge.net/projects/niftyrec/:
- tt_project_ray_gpu_kernels.cu in rtkCudaForwardProjectionImageFilter.h
NIFTYREC TOMOGRAPHY TOOLBOX
Copyright (c) 2009-2013, University College London, United-Kingdom.
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 University College London 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.
------------------------------------------------------------------------
utilities/lpsolve has been taken from
https://sourceforge.net/projects/lpsolve/files/lpsolve/5.5.2.0/lp_solve_5.5.2.0_source.tar.gz/download
and is distributed under the following license GNU lesser general public
license.
------------------------------------------------------------------------
The CMakeLists.txt file for lpsolve has been taken from
https://github.com/PADrend/ThirdParty. There is no license specified on this
repository, https://github.com/PADrend/Rendering is distributed under the
Mozilla Public License Version 2.0.
------------------------------------------------------------------------
GetGitRevisionDescription.cmake and GetGitRevisionDescription.cmake.in have
been taken from https://github.com/rpavlik/cmake-modules with the following
license:
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: CTestConfig.cmake
================================================
set(CTEST_PROJECT_NAME "RTK")
set(CTEST_NIGHTLY_START_TIME "1:00:00 UTC")
set(CTEST_DROP_METHOD "https")
set(CTEST_DROP_SITE "my.cdash.org")
set(CTEST_DROP_LOCATION "/submit.php?project=RTK")
set(CTEST_DROP_SITE_CDASH TRUE)
================================================
FILE: CodeContribution.md
================================================
# Code contribution
## Coding style
RTK is based on ITK and aims at following its coding conventions. Any developer should follow these conventions when submitting new code or contributions to the existing one. We strongly recommend you to read thoroughly [ITK's style guide](http://www.itk.org/Wiki/ITK/Coding_Style_Guide).
## Testing
This section describes how to add/edit datasets for testing purposes for RTK. Datasets are not stored in the GIT repository for efficiency and also to avoid having large history due to binary files. Instead the files are stored on a [Girder](http://data.kitware.com) instance. Here's the recipe to add new datasets:
1. Register/Login to Girder hosted at Kitware: [http://data.kitware.com](http://data.kitware.com)
2. Locate the RTK collection: [https://data.kitware.com/#collection/5a7706878d777f0649e04776](https://data.kitware.com/#collection/5a7706878d777f0649e04776)
3. Upload the new datasets in the appropriate folder. If you don't have the necessary privileges please email the mailing list
4. In the GIT repository, add in testing/Data a file with the exact filename of the original file **but with the .md5 extension**. Inside that file put the md5sum of the file on Girder.
5. When adding a test use the new macro 'RTK_ADD_TEST' instead of 'ADD_TEST' and specify the datasets you want CTest to download by appending the data to 'DATA{}'. For example:
```
RTK_ADD_TEST(NAME rtkimagxtest
COMMAND ${EXECUTABLE\_OUTPUT\_PATH}/rtkimagxtest
DATA{Data/Input/ImagX/raw.xml,raw.raw}
DATA{Data/Baseline/ImagX/attenuation.mha})
```
## Dashboard
* The RTK dashboard is available at [RTK Dashboard](http://my.cdash.org/index.php?project=RTK)
================================================
FILE: GettingStarted.md
================================================
Getting started
===============
Here are suggested steps for the RTK beginner.
1. Install the software following [INSTALLATION.md](INSTALLATION.md).
2. If you are not already familiar with ITK, [get started with ITK](https://github.com/InsightSoftwareConsortium/ITK/blob/master/GettingStarted.md).
3. Check out the [First reconstruction](examples/FirstReconstruction/README.md) example (both the [CMake](https://github.com/RTKConsortium/RTK/blob/master/examples/FirstReconstruction/CMakeLists.txt) and the [C++](https://github.com/RTKConsortium/RTK/blob/master/examples/FirstReconstruction/FirstReconstruction.cxx) codes). Many other examples are in the [documentation](https://docs.openrtk.org/).
4. Ask questions to the [user mailing list](https://www.creatis.insa-lyon.fr/mailman/listinfo/rtk-users).
================================================
FILE: HEADER.TXT
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
================================================
FILE: INSTALLATION.md
================================================
RTK installation
================
Configuration, compilation and installation with ITK
----------------------------------------------------
RTK is a module of [ITK](https://www.itk.org), the Insight Toolkit. Follow the instructions of the [ITK software guide](https://itk.org/ITKSoftwareGuide/html) ([chapter 2](https://itk.org/ITKSoftwareGuide/html/Book1/ITKSoftwareGuide-Book1ch2.html) mainly) for configuring and compiling ITK. The following CMake options are RTK specific:
* `Module_RTK`: Activates RTK download and compilation. Default is `OFF`. Turn it `ON` to activate RTK or compile RTK independently (see below).
* `Module_RTK_GIT_TAG`: Git tag for the RTK download. By default, the RTK version which is downloaded and compiled is the one given in the [RTK.remote.cmake](https://github.com/InsightSoftwareConsortium/ITK/blob/main/Modules/Remote/RTK.remote.cmake). Change this option to build another version. For example, you can change it to `main` to build the latest RTK version. RTK is only maintained to be backward compatible with the latest ITK release and ITK main branch.
* `RTK_BUILD_APPLICATIONS`: Activates the compilation of RTK's command line tools. Although RTK is mainly a toolkit, we also provide several command line tools for doing most of the available processing. These command line tools use [gengetopt](https://www.gnu.org/software/gengetopt/gengetopt.html). Several examples are available in the [documentation](http://docs.openrtk.org).
* `RTK_USE_CUDA`: Activates CUDA computation. Default is `ON` if CMake has automatically found the CUDA package and a CUDA-compatible GPU, and `OFF` otherwise.
* `RTK_CUDA_VERSION`: Specifies an exact version of the CUDA toolkit which must be used. If unspecified, RTK only checks if the found version is recent enough.
* `RTK_CUDA_PROJECTIONS_SLAB_SIZE`: Set the number of projections processed at once in CUDA processing. Default is 16.
* `RTK_PROBE_EACH_FILTER`: Activates the timing, CPU and CUDA memory consumption of each filter. Defaults is `OFF`. When activated, each filter processing is probed and a summary can be displayed. All command line applications display the result with `--verbose`.
RTK will automatically be installed when installing ITK.
Independent configuration and compilation
-----------------------------------------
For RTK developpers, it may be useful to compile RTK independently from ITK. This is possible, simply:
* Compile ITK with `Module_RTK=OFF`.
* If you want to use CUDA, also activate `Module_CudaCommon` or compile it separately as RTK in the following two bullet points (cloning its [GitHub repository](https://github.com/RTKConsortium/ITKCudaCommon) or downloading it as a [zip package](https://codeload.github.com/RTKConsortium/ITKCudaCommon/zip/main)).
* Manually download RTK's source repository from [GitHub](https://github.com/RTKConsortium/RTK) with `git` (recommended) or as a [zip package](https://codeload.github.com/RTKConsortium/RTK/zip/main).
* Configure the project with CMake pointing to RTK's source directory and setting the CMake option `ITK_DIR` to ITK's compilation directory. All CMake options above can be set except `Module_RTK`.
Installation is currently not supported for independent RTK compilations.
Pre-compiled binaries
---------------------
We only provide pre-compiled binaries for the Python package which depends on ITK. Use the following commands to install the RTK module with `pip`.
```
python -m pip install --upgrade pip
python -m pip install itk-rtk
```
The same operating systems and Python versions are supported as ITK's packages, see the list on [Pypi](https://pypi.org/project/itk-rtk).
We also provide pre-compiled [CUDA](https://developer.nvidia.com/cuda-toolkit) packages for Windows and Linux. They require an installed version of CUDA compatible with the package. Currently, RTK is available for CUDA 12.4 on Windows and Linux via:
```
python -m pip install itk-rtk-cuda124
```
```
python -m pip install itk-rtk-cuda124
```
Getting started
---------------
See [GettingStarted.md](GettingStarted.md). Your `CMakeLists.txt` can now use RTK when importing ITK as shown in the [FirstReconstruction's CMakeLists.txt](https://github.com/RTKConsortium/RTK/blob/main/examples/FirstReconstruction/CMakeLists.txt#L7).
================================================
FILE: ITKKWStyleFiles.txt.in
================================================
<?xml version="1.0" encoding="iso-8859-1"?>
<Description>
<LineLength>200</LineLength>
<DeclarationOrder>0,1,2</DeclarationOrder>
<Typedefs>[A-Z]</Typedefs>
<InternalVariables>m_[A-Z]</InternalVariables>
<SemicolonSpace>0</SemicolonSpace>
<EndOfFileNewLine>1</EndOfFileNewLine>
<Tabs>1</Tabs>
<Spaces>3</Spaces>
<Comments>/**, *, */,true</Comments>
<Namespace>rtk</Namespace>
<NameOfClass>[NameOfClass],itk</NameOfClass>
<IfNDefDefine>[NameOfClass]_[Extension]</IfNDefDefine>
<EmptyLines>2</EmptyLines>
<Template>[TNV]</Template>
<Operator>1,1</Operator>
<Header>@RTK_SOURCE_DIR@/cmake/KWStyle/RTKHeader.h,false,true</Header>
</Description>
================================================
FILE: LICENSE.TXT
================================================
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [2010-2012] [RTK Consortium]
The RTK consortium comprises:
- CREATIS CNRS laboratory https://www.creatis.insa-lyon.fr/
- Massachusetts General Hospital https://www.mgh.harvard.edu/
- Université Catholique de Louvain https://www.uclouvain.be/
- IBA https://www.iba-protontherapy.com/
- Kitware https://www.kitware.com/
- medPhoton https://www.medphoton.at/
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.
================================================
FILE: ORGANIZATION.TXT
================================================
The software system known as the Reconstruction Toolkit, hereafter referred to as RTK, is an open-source platform for tomographic reconstruction. RTK consists of source code, data, tests, examples and documentation.
Members of the RTK collaboration are bound by a gentleman's agreement. In this agreement, all partners agree to work together to the development, validation and support of RTK. A member can either be a person or an institute.
Each RTK member provides an on-going contribution to the development, validation and support of RTK as approved by the Steering Committee of the collaboration. Examples of contributions are the design of the software architecture, the development of new features, the writing of the documentation, and so on.
Each RTK member also agrees upon a common review process of any presentation and publication related to the development of new RTK features. Any RTK presentation and publication must circulate through the mailing list of the steering committee for approval.
Every member should identify one technical contact person the technical coordinator of the RTK collaboration can address specific requests to. An elected technical coordinator organizes technical meetings, and attends the meetings of the Steering Committee. The technical coordinator is in charge of the smoothness of the collaborative developments, i.e., good communication between contributors to ensure that RTK is consistent.
Every member must also be represented by one representative in the Steering Committee of the collaboration at least once a year. This Steering Committee decides the development strategy of RTK. The elected spokesman of the collaboration chairs this Steering Committee. The elected spokesperson and the elected technical coordinator will be confirmed in their functions or elected every other year by a simple majority of votes cast by the members of the Steering Committee.
The RTK collaboration is open to new memberships. If you wish to join the collaboration, please contact Simon RIT, CREATIS CNRS UMR 5220 - INSERM U1044 - Universit Lyon 1 - INSA Lyon, France. Membership is confirmed or granted by the Steering Committe every other year by a simple majority of votes cast by the members of the Steering Committee.
================================================
FILE: README.md
================================================
RTK: The Reconstruction ToolKit
===============================
[](https://github.com/RTKConsortium/RTK/releases/latest)
[](https://pypi.python.org/pypi/itk-rtk)
[](https://pypi.org/project/itk-rtk)
[](https://github.com/RTKConsortium/RTK/blob/master/LICENSE.TXT)
[![][gha-img]][gha-link]
[gha-img]: https://github.com/RTKConsortium/RTK/actions/workflows/build-test-package.yml/badge.svg
[gha-link]: https://github.com/RTKConsortium/RTK/actions/workflows/build-test-package.yml
Links
-----
* [Homepage](https://www.openrtk.org)
* [Download](https://www.openrtk.org/RTK/resources/software.html)
* [Mailing List](https://www.creatis.insa-lyon.fr/mailman/listinfo/rtk-users)
* [Getting Started](GettingStarted.md)
* [Help](https://docs.openrtk.org)
* [Issue tracking](https://github.com/RTKConsortium/RTK/issues)
Copyright RTK Consortium
------------------------
Licensed under the Apache License, Version 2.0 (the
"[License](https://www.apache.org/licenses/LICENSE-2.0.txt)"); you may not use
this file except in compliance with the
[License](https://www.apache.org/licenses/LICENSE-2.0.txt).
Unless required by applicable law or agreed to in writing, software
distributed under the
[License](https://www.apache.org/licenses/LICENSE-2.0.txt) is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
express or implied. See the
[License](https://www.apache.org/licenses/LICENSE-2.0.txt) for the specific
language governing permissions and limitations under the
[License](https://www.apache.org/licenses/LICENSE-2.0.txt).
================================================
FILE: applications/CMakeLists.txt
================================================
find_package(Gengetopt)
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/rtkVersion.ggo.in ${RTK_BINARY_DIR}/rtkVersion.ggo)
#-----------------------------------------------------------------------------
# Setup RPATH :
#
# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
# add path to RTK libraries to the install path
set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${RTK_INSTALL_LIB_DIR}")
#-----------------------------------------------------------------------------
# Find ITK.
# Required to include ITK_USE_FILE in order to Register IO factories
# Force requested modules to be RTK dependencies only, otherwise all
# available factories will try to register themselves.
if (NOT ITK_DIR)
set(ITK_DIR ${ITK_BINARY_DIR}/CMakeTmp)
endif()
find_package(ITK REQUIRED COMPONENTS ${ITK_MODULE_RTK_DEPENDS})
include(${ITK_USE_FILE})
#-----------------------------------------------------------------------------
# Executables
add_subdirectory(rtkamsterdamshroud)
add_subdirectory(rtkbackprojections)
add_subdirectory(rtkfdk)
add_subdirectory(rtkfieldofview)
add_subdirectory(rtkforwardprojections)
add_subdirectory(rtkfourdfdk)
add_subdirectory(rtkfourdsart)
add_subdirectory(rtkiterativefdk)
add_subdirectory(rtkosem)
add_subdirectory(rtkprojectgeometricphantom)
add_subdirectory(rtkprojections)
add_subdirectory(rtkprojectshepploganphantom)
add_subdirectory(rtksart)
add_subdirectory(rtksubselect)
add_subdirectory(rtkdrawgeometricphantom)
add_subdirectory(rtkdrawshepploganphantom)
add_subdirectory(rtkextractshroudsignal)
add_subdirectory(rtkextractphasesignal)
add_subdirectory(rtkoverlayphaseandshroud)
add_subdirectory(rtktotalvariationdenoising)
add_subdirectory(rtktotalnuclearvariationdenoising)
add_subdirectory(rtkadmmwavelets)
add_subdirectory(rtkadmmtotalvariation)
add_subdirectory(rtkfourdrooster)
add_subdirectory(rtkmcrooster)
add_subdirectory(rtkfourdconjugategradient)
add_subdirectory(rtkspectralonestep)
add_subdirectory(rtkconjugategradient)
add_subdirectory(rtkregularizedconjugategradient)
add_subdirectory(rtkwaveletsdenoising)
add_subdirectory(rtki0estimation)
add_subdirectory(rtktutorialapplication)
add_subdirectory(rtkscatterglarecorrection)
add_subdirectory(rtkmotioncompensatedfourdconjugategradient)
add_subdirectory(rtklagcorrection)
add_subdirectory(rtkgaincorrection)
add_subdirectory(rtkspectralsimplexdecomposition)
add_subdirectory(rtkdualenergysimplexdecomposition)
add_subdirectory(rtkspectralrooster)
add_subdirectory(rtkspectralforwardmodel)
add_subdirectory(rtkmaskcollimation)
add_subdirectory(rtkspectraldenoiseprojections)
add_subdirectory(rtkprojectionmatrix)
add_subdirectory(rtkvectorconjugategradient)
add_subdirectory(rtkdualenergyforwardmodel)
add_subdirectory(rtkcheckimagequality)
#All the executables below are meant to create RTK ThreeDCircularProjectionGeometry files
add_subdirectory(rtkvarianobigeometry)
add_subdirectory(rtkvarianprobeamgeometry)
add_subdirectory(rtksimulatedgeometry)
add_subdirectory(rtkelektasynergygeometry)
add_subdirectory(rtkdigisensgeometry)
add_subdirectory(rtkxradgeometry)
add_subdirectory(rtkimagxgeometry)
add_subdirectory(rtkorageometry)
add_subdirectory(rtkbioscangeometry)
#=========================================================
#-----------------------------------------------------------------------------
# Testing of the applications
if(BUILD_TESTING)
# Reference data (geometry, reference Shepp Logan and corresponding projections)
add_test(rtkappsimulatedgeometrytest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtksimulatedgeometry -n 45 --sid 1000 --sdd 1500 -o geo)
add_test(rtkappdrawshepploganphantomtest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkdrawshepploganphantom -o reference.mha --size 21 --phantomscale 10)
add_test(rtkappprojectshepploganphantomtest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkprojectshepploganphantom -o sheppy.mha -g geo --phantomscale 10 --size 32)
set_tests_properties(rtkappprojectshepploganphantomtest PROPERTIES DEPENDS rtkappsimulatedgeometrytest)
# FDK test
if(RTK_USE_CUDA)
add_test(rtkappfdktest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkfdk -g geo -p . -r sheppy.mha -o fdk.mha --hardware cuda --size 21)
else()
add_test(rtkappfdktest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkfdk -g geo -p . -r sheppy.mha -o fdk.mha --size 21)
endif()
set_tests_properties(rtkappfdktest PROPERTIES DEPENDS rtkappprojectshepploganphantomtest)
add_test(rtkappfdkchecktest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkcheckimagequality -i reference.mha -j fdk.mha -t 400)
set_tests_properties(rtkappfdkchecktest PROPERTIES DEPENDS "rtkappdrawshepploganphantomtest;rtkappfdktest")
# Iteration reporting testing
add_test(rtkapposemtest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkosem -g geo -p . -r sheppy.mha -o osem.mha -n 3 --size 21 --output-every 1 --nprojpersubset 15 --iteration-file-name osem%d.mha)
set_tests_properties(rtkapposemtest PROPERTIES DEPENDS rtkappprojectshepploganphantomtest)
add_test(rtkapposemchecktest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/rtkcheckimagequality -i reference.mha -j osem1.mha,osem2.mha,osem3.mha -t 800,550,455)
set_tests_properties(rtkapposemchecktest PROPERTIES DEPENDS "rtkapposemtest;rtkappdrawshepploganphantomtest")
endif()
================================================
FILE: applications/README.md
================================================
# Command-line applications
RTK provides command line applications which can be built from the C++ code by turning `ON` the `RTK_BUILD_APPLICATIONS` CMake option. A few of these applications have also been translated to Python and integrated in the [Pypi package](https://pypi.org/project/itk-rtk/). The options of each command line application can be listed with the `--help option`.
The following are examples using RTK applications:
```{toctree}
:maxdepth: 1
./rtkfdk/README.md
./rtkconjugategradient/README.md
./rtkforwardprojections/README.md
./rtkdrawgeometricphantom/README.md
./rtkamsterdamshroud/README.md
./rtkelektasynergygeometry/README.md
./rtkvarianobigeometry/README.md
./rtkadmmtotalvariation/README.md
./rtkadmmwavelets/README.md
./rtkfourdrooster/README.md
./rtkshowgeometry/README.md
```
In [applications/rtktutorialapplication/](https://github.com/RTKConsortium/RTK/blob/main/applications/rtktutorialapplication), you will find a very basic RTK application that can be used as a starting point for building your own new application.
## Using RTK applications in Python
RTK applications which have been translated to Python can also be called from Python in addition to the command line, thus avoiding reloading the RTK package (which is slow) and enabling the flexibility of Python scripting. The Python interface dynamically maps the RTK applications to Python functions. You can use `help(rtk.<application_name>)` to see all required and optional arguments. Note that only file paths are supported as input, ITK images or RTK geometry objects cannot be passed directly.
Each Python application accepts either:
1. **A single positional string argument**: This mimics the command-line usage.
2. **A list of keyword arguments**: This provides a more Pythonic interface.
```python
rtk.<application_name>(<arguments>)
```
For example,
```bash
rtkfdk -p . -r projections.mha -o fdk.mha -g geometry.xml --spacing 2 --dimension 256
```
is equivalent to execute from Python
```python
from itk import RTK as rtk
rtk.rtkfdk(
"-p . -r projections.mha -o fdk.mha -g geometry.xml --spacing 2 --dimension 256"
)
```
or
```python
from itk import RTK as rtk
rtk.rtkfdk(
path=".",
regexp="projections.mha",
output="fdk.mha",
geometry="geometry.xml",
spacing="2,2,2",
dimension=[256,256,256] # You can use a string or a list
)
```
================================================
FILE: applications/rtk3Doutputimage_group.py
================================================
import itk
from itk import RTK as rtk
__all__ = [
"add_rtk3Doutputimage_group",
"SetConstantImageSourceFromArgParse",
]
# Mimicks rtk3Doutputimage_section.ggo
def add_rtk3Doutputimage_group(parser):
rtk3Doutputimage_group = parser.add_argument_group("Output 3D image properties")
rtk3Doutputimage_group.add_argument(
"--origin",
help="Origin (default=centered)",
type=float,
nargs='+',
)
rtk3Doutputimage_group.add_argument(
"--size",
help="Size",
type=int,
nargs='+',
default=[256],
)
rtk3Doutputimage_group.add_argument(
"--dimension",
help="Dimension",
type=int,
nargs='+',
)
rtk3Doutputimage_group.add_argument(
"--spacing", help="Spacing", type=float, nargs='+', default=[1]
)
rtk3Doutputimage_group.add_argument(
"--direction", help="Direction", type=float, nargs='+'
)
rtk3Doutputimage_group.add_argument(
"--like",
help="Copy information from this image (origin, size, spacing, direction)",
)
# Mimicks SetConstantImageSourceFromGgo
def SetConstantImageSourceFromArgParse(source, args_info):
ImageType = type(source.GetOutput())
# Handle deprecated --dimension argument
if args_info.dimension is not None:
print(
"Warning: '--dimension' is deprecated and will be removed in a future release. "
"Please use '--size' instead."
)
args_info.size = args_info.dimension
Dimension = ImageType.GetImageDimension()
imageDimension = itk.Size[Dimension]()
imageDimension.Fill(args_info.size[0])
for i in range(min(len(args_info.size), Dimension)):
imageDimension[i] = args_info.size[i]
imageSpacing = itk.Vector[itk.D, Dimension]()
imageSpacing.Fill(args_info.spacing[0])
for i in range(min(len(args_info.spacing), Dimension)):
imageSpacing[i] = args_info.spacing[i]
imageOrigin = itk.Point[itk.D, Dimension]()
for i in range(Dimension):
imageOrigin[i] = imageSpacing[i] * (imageDimension[i] - 1) * -0.5
if args_info.origin is not None:
for i in range(min(len(args_info.origin), Dimension)):
imageOrigin[i] = args_info.origin[i]
imageDirection = source.GetOutput().GetDirection()
if args_info.direction is not None:
for i in range(Dimension):
for j in range(Dimension):
imageDirection[i][j] = args_info.direction[i * Dimension + j]
source.SetOrigin(imageOrigin)
source.SetSpacing(imageSpacing)
source.SetDirection(imageDirection)
source.SetSize(imageDimension)
source.SetConstant(0.0)
# Copy output image information from an existing file, if requested
# Overwrites parameters given in command line, if any
if args_info.like is not None:
LikeReaderType = itk.ImageFileReader[ImageType]
likeReader = LikeReaderType.New()
likeReader.SetFileName(args_info.like)
likeReader.UpdateOutputInformation()
source.SetInformationFromImage(likeReader.GetOutput())
source.UpdateOutputInformation()
================================================
FILE: applications/rtk3Doutputimage_section.ggo
================================================
section "Output 3D image properties"
option "origin" - "Origin (default=centered)" double multiple no
option "dimension" - "Dimension(Deprecated) Use --size instead." int multiple no default="256"
option "size" - "Size" int multiple no default="256"
option "spacing" - "Spacing" double multiple no default="1"
option "direction" - "Direction" double multiple no
option "like" - "Copy information from this image (origin, size, spacing, direction)" string no
================================================
FILE: applications/rtk4Doutputimage_section.ggo
================================================
section "Output 4D image properties"
option "origin" - "Origin (default=centered)" double multiple no
option "dimension" - "Dimension(Deprecated) Use --size instead." int multiple no default="256"
option "size" - "Size" int multiple no default="256"
option "spacing" - "Spacing" double multiple no default="1"
option "direction" - "Direction" double multiple no
option "frames" - "Number of time frames in the 4D reconstruction" int no default="10"
option "like" - "Copy information from this image (origin, size, spacing, direction, frames)" string no
================================================
FILE: applications/rtkVersion.ggo.in
================================================
version "@RTK_VERSION_MAJOR@.@RTK_VERSION_MINOR@.@RTK_VERSION_PATCH@@RTK_VERSION_HASH@"
================================================
FILE: applications/rtkadmmtotalvariation/CMakeLists.txt
================================================
WRAP_GGO(rtkadmmtotalvariation_GGO_C rtkadmmtotalvariation.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ../rtkprojectors_section.ggo ../rtkiterations_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkadmmtotalvariation rtkadmmtotalvariation.cxx ${rtkadmmtotalvariation_GGO_C})
target_link_libraries(rtkadmmtotalvariation RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkadmmtotalvariation)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkadmmtotalvariation/README.md
================================================
# Total Variation Regularized Reconstruction
{w=300px alt="SheppLogan sinogram 3D"}
{w=300px alt="Admmtv reconstruction"}
This script uses the SheppLogan phantom
```{literalinclude} TotalVariationRegularizedReconstruction.sh
```
================================================
FILE: applications/rtkadmmtotalvariation/TotalVariationRegularizedReconstruction.sh
================================================
# Create a simulated geometry
rtksimulatedgeometry -n 180 -o geometry.xml
# You may add "--arc 200" to make the scan short or "--proj_iso_x 200" to offset the detector
# Create projections of the phantom file
rtkprojectshepploganphantom -g geometry.xml -o projections.mha --spacing 2 --size 256
# Reconstruct
rtkadmmtotalvariation -p . -r projections.mha -o admmtv.mha -g geometry.xml --spacing 2 --size 256 --alpha 1 --beta 1000 -n 3
# Create a reference volume for comparison
rtkdrawshepploganphantom --spacing 2 --size 256 -o ref.mha
================================================
FILE: applications/rtkadmmtotalvariation/rtkadmmtotalvariation.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkadmmtotalvariation_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkConfiguration.h"
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
#include "rtkProjectionsReader.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkConstantImageSource.h"
#include "rtkADMMTotalVariationConeBeamReconstructionFilter.h"
#include "rtkPhaseGatingImageFilter.h"
int
main(int argc, char * argv[])
{
GGO(rtkadmmtotalvariation, args_info);
using OutputPixelType = float;
constexpr unsigned int Dimension = 3;
#ifdef RTK_USE_CUDA
using OutputImageType = itk::CudaImage<OutputPixelType, Dimension>;
#else
using OutputImageType = itk::Image<OutputPixelType, Dimension>;
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Read all the inputs
//////////////////////////////////////////////////////////////////////////////////////////
// Projections reader
using projectionsReaderType = rtk::ProjectionsReader<OutputImageType>;
auto projectionsReader = projectionsReaderType::New();
rtk::SetProjectionsReaderFromGgo<projectionsReaderType, args_info_rtkadmmtotalvariation>(projectionsReader,
args_info);
// Geometry
if (args_info.verbose_flag)
std::cout << "Reading geometry information from " << args_info.geometry_arg << "..." << std::endl;
rtk::ThreeDCircularProjectionGeometry::Pointer geometry;
TRY_AND_EXIT_ON_ITK_EXCEPTION(geometry = rtk::ReadGeometry(args_info.geometry_arg));
// Phase gating weights reader
auto phaseGating = rtk::PhaseGatingImageFilter<OutputImageType>::New();
if (args_info.phases_given)
{
phaseGating->SetPhasesFileName(args_info.phases_arg);
phaseGating->SetGatingWindowWidth(args_info.windowwidth_arg);
phaseGating->SetGatingWindowCenter(args_info.windowcenter_arg);
phaseGating->SetGatingWindowShape(args_info.windowshape_arg);
phaseGating->SetInputProjectionStack(projectionsReader->GetOutput());
phaseGating->SetInputGeometry(geometry);
TRY_AND_EXIT_ON_ITK_EXCEPTION(phaseGating->Update())
}
// Create input: either an existing volume read from a file or a blank image
itk::ImageSource<OutputImageType>::Pointer inputFilter;
if (args_info.input_given)
{
// Read an existing image to initialize the volume
auto inputReader = itk::ImageFileReader<OutputImageType>::New();
inputReader->SetFileName(args_info.input_arg);
inputFilter = inputReader;
}
else
{
// Create new empty volume
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkadmmtotalvariation>(constantImageSource,
args_info);
inputFilter = constantImageSource;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Setup the ADMM filter and run it
//////////////////////////////////////////////////////////////////////////////////////////
// Set the reconstruction filter
using ADMM_TV_FilterType = rtk::ADMMTotalVariationConeBeamReconstructionFilter<OutputImageType>;
auto admmFilter = ADMM_TV_FilterType::New();
// Set the forward and back projection filters to be used inside admmFilter
SetForwardProjectionFromGgo(args_info, admmFilter.GetPointer());
SetBackProjectionFromGgo(args_info, admmFilter.GetPointer());
// Set all four numerical parameters
admmFilter->SetCG_iterations(args_info.CGiter_arg);
admmFilter->SetAL_iterations(args_info.niterations_arg);
admmFilter->SetAlpha(args_info.alpha_arg);
admmFilter->SetBeta(args_info.beta_arg);
// Set the inputs of the ADMM filter
admmFilter->SetInput(0, inputFilter->GetOutput());
if (args_info.phases_given)
{
admmFilter->SetInput(1, phaseGating->GetOutput());
admmFilter->SetGeometry(phaseGating->GetOutputGeometry());
admmFilter->SetGatingWeights(phaseGating->GetGatingWeightsOnSelectedProjections());
}
else
{
admmFilter->SetInput(1, projectionsReader->GetOutput());
admmFilter->SetGeometry(geometry);
}
admmFilter->SetDisableDisplacedDetectorFilter(args_info.nodisplaced_flag);
REPORT_ITERATIONS(admmFilter, ADMM_TV_FilterType, OutputImageType)
TRY_AND_EXIT_ON_ITK_EXCEPTION(admmFilter->Update())
// Write the output
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(admmFilter->GetOutput(), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkadmmtotalvariation/rtkadmmtotalvariation.ggo
================================================
purpose "Performs an iterative 3D reconstruction with 3D TV regularization"
option "verbose" v "Verbose execution" flag off
option "geometry" g "XML geometry file name" string yes
option "output" o "Output file name" string yes
option "niterations" n "Number of iterations" int no default="1"
option "alpha" - "Regularization parameter" float no default="0.1"
option "beta" - "Augmented Lagrangian constraint multiplier" float no default="1"
option "CGiter" - "Number of nested iterations of conjugate gradient" int no default="5"
option "input" i "Input volume" string no
option "nodisplaced" - "Disable the displaced detector filter" flag off
section "Phase gating"
option "phases" - "File containing the phase of each projection" string no
option "windowcenter" c "Target reconstruction phase" float no default="0"
option "windowwidth" w "Tolerance around the target phase to determine in-phase and out-of-phase projections" float no default="1"
option "windowshape" s "Shape of the gating window" values="Rectangular","Triangular" enum no default="Rectangular"
================================================
FILE: applications/rtkadmmtotalvariation/rtkadmmtotalvariation.py
================================================
#!/usr/bin/env python
import argparse
import sys
import itk
from itk import RTK as rtk
def build_parser():
# Argument parsing
parser = rtk.RTKArgumentParser(
description="Perform ADMM total variation reconstruction on cone-beam projections."
)
# General options
parser.add_argument(
"-v", "--verbose", help="Verbose execution", action="store_true"
)
parser.add_argument(
"-g", "--geometry", help="XML geometry file name", type=str, required=True
)
parser.add_argument(
"-o", "--output", help="Output file name", type=str, required=True
)
parser.add_argument(
"-n", "--niterations", help="Number of iterations", type=int, default=1
)
parser.add_argument(
"--alpha", help="Regularization parameter", type=float, default=0.1
)
parser.add_argument(
"--beta",
help="Augmented Lagrangian constraint multiplier",
type=float,
default=1.0,
)
parser.add_argument(
"--CGiter",
help="Number of nested iterations of conjugate gradient",
type=int,
default=5,
)
parser.add_argument("-i", "--input", help="Input volume", type=str)
parser.add_argument(
"--nodisplaced",
help="Disable the displaced detector filter",
action="store_true",
)
# Phase gating options
parser.add_argument(
"--phases", help="File containing the phase of each projection", type=str
)
parser.add_argument(
"-c",
"--windowcenter",
help="Target reconstruction phase",
type=float,
default=0.0,
)
parser.add_argument(
"-w",
"--windowwidth",
help="Tolerance around the target phase",
type=float,
default=1.0,
)
parser.add_argument(
"-s",
"--windowshape",
help="Shape of the gating window",
type=str,
choices=["Rectangular", "Triangular"],
default="Rectangular",
)
# RTK specific groups
rtk.add_rtkprojectors_group(parser)
rtk.add_rtkiterations_group(parser)
rtk.add_rtkinputprojections_group(parser)
rtk.add_rtk3Doutputimage_group(parser)
# Parse the command line arguments
return parser
def process(args_info: argparse.Namespace):
# Define output pixel type and dimension
OutputPixelType = itk.F
Dimension = 3
OutputImageType = itk.Image[OutputPixelType, Dimension]
# Projections reader
projectionsReader = rtk.ProjectionsReader[OutputImageType].New()
rtk.SetProjectionsReaderFromArgParse(projectionsReader, args_info)
# Geometry
if args_info.verbose:
print(f"Reading geometry from {args_info.geometry}...")
geometry = rtk.read_geometry(args_info.geometry)
# Phase gating weights reader
phaseGating = rtk.PhaseGatingImageFilter[OutputImageType].New()
if args_info.phases:
phaseGating.SetPhasesFileName(args_info.phases)
phaseGating.SetGatingWindowWidth(args_info.windowwidth)
phaseGating.SetGatingWindowCenter(args_info.windowcenter)
# Rectangular=0, Triangular=1
if args_info.windowshape == "Triangular":
phaseGating.SetGatingWindowShape(1)
else:
phaseGating.SetGatingWindowShape(0)
phaseGating.SetInputProjectionStack(projectionsReader.GetOutput())
phaseGating.SetInputGeometry(geometry)
phaseGating.Update()
# Create input: either an existing volume read from a file or a blank image
if args_info.input:
# Read an existing image to initialize the volume
inputFilter = itk.imread(args_info.input)
else:
# Create new empty volume
constantImageSource = rtk.ConstantImageSource[OutputImageType].New()
rtk.SetConstantImageSourceFromArgParse(constantImageSource, args_info)
constantImageSource.Update()
inputFilter = constantImageSource
# Set the reconstruction filter
if hasattr(itk, "CudaImage"):
CudaOutputImageType = itk.CudaImage[OutputPixelType, Dimension]
admmFilter = rtk.ADMMTotalVariationConeBeamReconstructionFilter[CudaOutputImageType].New()
admmFilter.SetInput(0, itk.cuda_image_from_image(inputFilter.GetOutput()))
if args_info.phases:
admmFilter.SetInput(1, itk.cuda_image_from_image(phaseGating.GetOutput()))
else:
admmFilter.SetInput(
1, itk.cuda_image_from_image(projectionsReader.GetOutput())
)
else:
admmFilter = rtk.ADMMTotalVariationConeBeamReconstructionFilter[
OutputImageType
].New()
admmFilter.SetInput(0, inputFilter.GetOutput())
if args_info.phases:
admmFilter.SetInput(1, phaseGating.GetOutput())
else:
admmFilter.SetInput(1, projectionsReader.GetOutput())
# Set the forward and back projection filters to be used inside admmFilter
rtk.SetForwardProjectionFromArgParse(args_info, admmFilter)
rtk.SetBackProjectionFromArgParse(args_info, admmFilter)
# Set all four numerical parameters
admmFilter.SetCG_iterations(args_info.CGiter)
admmFilter.SetAL_iterations(args_info.niterations)
admmFilter.SetAlpha(args_info.alpha)
admmFilter.SetBeta(args_info.beta)
admmFilter.SetDisableDisplacedDetectorFilter(args_info.nodisplaced)
# Set the inputs of the ADMM filter
if args_info.phases:
admmFilter.SetGeometry(phaseGating.GetOutputGeometry())
admmFilter.SetGatingWeights(phaseGating.GetGatingWeightsOnSelectedProjections())
else:
admmFilter.SetGeometry(geometry)
rtk.SetIterationsReportFromArgParse(args_info, admmFilter)
admmFilter.Update()
writer = itk.ImageFileWriter[OutputImageType].New()
writer.SetFileName(args_info.output)
writer.SetInput(admmFilter.GetOutput())
writer.Update()
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkadmmwavelets/CMakeLists.txt
================================================
WRAP_GGO(rtkadmmwavelets_GGO_C rtkadmmwavelets.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ../rtkprojectors_section.ggo ../rtkiterations_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkadmmwavelets rtkadmmwavelets.cxx ${rtkadmmwavelets_GGO_C})
target_link_libraries(rtkadmmwavelets RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkadmmwavelets)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkadmmwavelets/DaubechiesWavelets.sh
================================================
# Create a simulated geometry
rtksimulatedgeometry -n 180 -o geometry.xml
# You may add "--arc 200" to make the scan short or "--proj_iso_x 200" to offset the detector
# Create projections of the phantom file
rtkprojectshepploganphantom -g geometry.xml -o projections.mha --spacing 2 --size 256
# Reconstruct
rtkadmmwavelets -p . -r projections.mha -o admmwavelets.mha -g geometry.xml --spacing 2 --size 256 --alpha 1 --beta 1000 -n 3
# Create a reference volume for comparison
rtkdrawshepploganphantom --spacing 2 --size 256 -o ref.mha
================================================
FILE: applications/rtkadmmwavelets/README.md
================================================
# Daubechies Wavelets Regularized Reconstruction
{w=300px alt="SheppLogan sinogram 3D"}
{w=300px alt="AdmmWavelets reconstruction"}
This script uses the SheppLogan phantom
```{literalinclude} DaubechiesWavelets.sh
```
================================================
FILE: applications/rtkadmmwavelets/rtkadmmwavelets.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkadmmwavelets_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkConfiguration.h"
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
#include "rtkProjectionsReader.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkConstantImageSource.h"
#include "rtkDisplacedDetectorImageFilter.h"
#include "rtkADMMWaveletsConeBeamReconstructionFilter.h"
int
main(int argc, char * argv[])
{
GGO(rtkadmmwavelets, args_info);
using OutputPixelType = float;
constexpr unsigned int Dimension = 3;
#ifdef RTK_USE_CUDA
using OutputImageType = itk::CudaImage<OutputPixelType, Dimension>;
#else
using OutputImageType = itk::Image<OutputPixelType, Dimension>;
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Read all the inputs
//////////////////////////////////////////////////////////////////////////////////////////
// Projections reader
using projectionsReaderType = rtk::ProjectionsReader<OutputImageType>;
auto projectionsReader = projectionsReaderType::New();
rtk::SetProjectionsReaderFromGgo<projectionsReaderType, args_info_rtkadmmwavelets>(projectionsReader, args_info);
// Geometry
if (args_info.verbose_flag)
std::cout << "Reading geometry information from " << args_info.geometry_arg << "..." << std::endl;
rtk::ThreeDCircularProjectionGeometry::Pointer geometry;
TRY_AND_EXIT_ON_ITK_EXCEPTION(geometry = rtk::ReadGeometry(args_info.geometry_arg));
// Displaced detector weighting
auto ddf = rtk::DisplacedDetectorImageFilter<OutputImageType>::New();
ddf->SetInput(projectionsReader->GetOutput());
ddf->SetGeometry(geometry);
// Create input: either an existing volume read from a file or a blank image
itk::ImageSource<OutputImageType>::Pointer inputFilter;
if (args_info.input_given)
{
// Read an existing image to initialize the volume
auto inputReader = itk::ImageFileReader<OutputImageType>::New();
inputReader->SetFileName(args_info.input_arg);
inputFilter = inputReader;
}
else
{
// Create new empty volume
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkadmmwavelets>(constantImageSource,
args_info);
inputFilter = constantImageSource;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Setup the ADMM filter and run it
//////////////////////////////////////////////////////////////////////////////////////////
// Set the reconstruction filter
using ADMM_Wavelets_FilterType = rtk::ADMMWaveletsConeBeamReconstructionFilter<OutputImageType>;
auto admmFilter = ADMM_Wavelets_FilterType::New();
// Set the forward and back projection filters to be used inside admmFilter
SetForwardProjectionFromGgo(args_info, admmFilter.GetPointer());
SetBackProjectionFromGgo(args_info, admmFilter.GetPointer());
// Set the geometry and interpolation weights
admmFilter->SetGeometry(geometry);
// Set all numerical parameters
admmFilter->SetCG_iterations(args_info.CGiter_arg);
admmFilter->SetAL_iterations(args_info.niterations_arg);
admmFilter->SetAlpha(args_info.alpha_arg);
admmFilter->SetBeta(args_info.beta_arg);
admmFilter->SetNumberOfLevels(args_info.levels_arg);
admmFilter->SetOrder(args_info.order_arg);
// Set the inputs of the ADMM filter
admmFilter->SetInput(0, inputFilter->GetOutput());
admmFilter->SetInput(1, projectionsReader->GetOutput());
admmFilter->SetDisableDisplacedDetectorFilter(args_info.nodisplaced_flag);
REPORT_ITERATIONS(admmFilter, ADMM_Wavelets_FilterType, OutputImageType);
TRY_AND_EXIT_ON_ITK_EXCEPTION(admmFilter->Update())
// Write the output
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(admmFilter->GetOutput(), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkadmmwavelets/rtkadmmwavelets.ggo
================================================
purpose "Performs an iterative 3D reconstruction with Daubechies wavelets regularization"
option "verbose" v "Verbose execution" flag off
option "geometry" g "XML geometry file name" string yes
option "output" o "Output file name" string yes
option "niterations" n "Number of iterations" int no default="1"
option "alpha" - "Regularization parameter" float no default="0.1"
option "beta" - "Augmented Lagrangian constraint multiplier" float no default="1"
option "CGiter" - "Number of nested iterations of conjugate gradient" int no default="5"
option "order" - "The order of the Daubechies wavelets" int no default="3"
option "levels" - "The number of decomposition levels in the wavelets transform" int no default="5"
option "input" i "Input volume" string no
option "nodisplaced" - "Disable the displaced detector filter" flag off
================================================
FILE: applications/rtkamsterdamshroud/CMakeLists.txt
================================================
WRAP_GGO(rtkamsterdamshroud_GGO_C rtkamsterdamshroud.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkamsterdamshroud rtkamsterdamshroud.cxx ${rtkamsterdamshroud_GGO_C})
target_link_libraries(rtkamsterdamshroud RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkamsterdamshroud)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkamsterdamshroud/README.md
================================================
# Amsterdam Shroud
{w=400px alt="Moving phantom sinogram"}
{w=400px alt="Amsterdam image"}
Picture 1 shows the sinogram of the input and picture 2 the shroud image that was created using the command line below.
The script uses the file [movingPhantom.mha](https://data.kitware.com/api/v1/file/5be99c428d777f2179a2e537/download) as input:
```
# Creating an Amsterdam Shroud image from a set of projections
rtkamsterdamshroud -p . -r movingPhantom.mha -o Amsterdam.mha
```
================================================
FILE: applications/rtkamsterdamshroud/rtkamsterdamshroud.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkamsterdamshroud_ggo.h"
#include "rtkMacro.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkAmsterdamShroudImageFilter.h"
#include "rtkGgoFunctions.h"
#include <itkImageFileWriter.h>
int
main(int argc, char * argv[])
{
GGO(rtkamsterdamshroud, args_info);
constexpr unsigned int Dimension = 3;
using OutputImageType = itk::Image<double, Dimension>;
// Projections reader
using ReaderType = rtk::ProjectionsReader<OutputImageType>;
auto reader = ReaderType::New();
rtk::SetProjectionsReaderFromGgo<ReaderType, args_info_rtkamsterdamshroud>(reader, args_info);
// Amsterdam shroud
using ShroudFilterType = rtk::AmsterdamShroudImageFilter<OutputImageType>;
auto shroudFilter = ShroudFilterType::New();
shroudFilter->SetInput(reader->GetOutput());
shroudFilter->SetUnsharpMaskSize(args_info.unsharp_arg);
// Corners (if given)
if (args_info.clipbox_given)
{
if (args_info.clipbox_given != 6)
{
std::cerr << "--clipbox requires 6 values, only" << args_info.clipbox_given << " given." << std::endl;
return EXIT_FAILURE;
}
if (!args_info.geometry_given)
{
std::cerr << "You must provide the geometry to use --clipbox." << std::endl;
return EXIT_FAILURE;
}
ShroudFilterType::PointType c1, c2;
for (int i = 0; i < 3; i++)
{
c1[i] = args_info.clipbox_arg[i * 2];
c2[i] = args_info.clipbox_arg[i * 2 + 1];
}
shroudFilter->SetCorner1(c1);
shroudFilter->SetCorner2(c2);
// Geometry
rtk::ThreeDCircularProjectionGeometry::Pointer geometry;
if (args_info.geometry_given)
{
TRY_AND_EXIT_ON_ITK_EXCEPTION(geometry = rtk::ReadGeometry(args_info.geometry_arg));
shroudFilter->SetGeometry(geometry);
}
}
TRY_AND_EXIT_ON_ITK_EXCEPTION(shroudFilter->UpdateOutputInformation())
// Write
auto writer = itk::ImageFileWriter<ShroudFilterType::OutputImageType>::New();
writer->SetFileName(args_info.output_arg);
writer->SetInput(shroudFilter->GetOutput());
writer->SetNumberOfStreamDivisions(shroudFilter->GetOutput()->GetLargestPossibleRegion().GetSize(1));
TRY_AND_EXIT_ON_ITK_EXCEPTION(writer->Update())
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkamsterdamshroud/rtkamsterdamshroud.ggo
================================================
purpose "Creates an Amsterdam Shroud image from a sequence of projections [Zijp et al, ICCR, 2004]."
option "verbose" v "Verbose execution" flag off
option "output" o "Output file name" string yes
option "unsharp" u "Unsharp mask size" int no default="17"
option "clipbox" c "3D clipbox for cropping projections (x1,x2,y1,y2,z1,z2) mm" double multiple no
option "geometry" g "XML geometry file name" string no
================================================
FILE: applications/rtkamsterdamshroud/rtkamsterdamshroud.py
================================================
#!/usr/bin/env python
import sys
import argparse
import itk
from itk import RTK as rtk
def build_parser():
parser = rtk.RTKArgumentParser(
description="Creates an Amsterdam Shroud image from a sequence of projections [Zijp et al, ICCR, 2004]."
)
# General options
parser.add_argument(
"--verbose", "-v", help="Verbose execution", action="store_true"
)
parser.add_argument(
"--output", "-o", help="Output file name", type=str, required=True
)
parser.add_argument(
"--unsharp", "-u", help="Unsharp mask size", type=int, default=17
)
parser.add_argument(
"--clipbox",
"-c",
help="3D clipbox for cropping projections (x1, x2, y1, y2, z1, z2) in mm",
type=float,
nargs="+"
)
parser.add_argument("--geometry", "-g", help="XML geometry file name", type=str)
rtk.add_rtkinputprojections_group(parser)
# Parse the command line arguments
return parser
def process(args_info: argparse.Namespace):
if args_info.verbose:
print("Running Amsterdam Shroud computation...")
# Define output image type
OutputPixelType = itk.F
Dimension = 3
OutputImageType = itk.Image[OutputPixelType, Dimension]
# Projections reader
reader = rtk.ProjectionsReader[OutputImageType].New()
rtk.SetProjectionsReaderFromArgParse(reader, args_info)
# Amsterdam Shroud
shroudFilter = rtk.AmsterdamShroudImageFilter[OutputImageType].New()
shroudFilter.SetInput(reader.GetOutput())
shroudFilter.SetUnsharpMaskSize(args_info.unsharp)
# Corners (if given)
if args_info.clipbox:
if len(args_info.clipbox) != 6:
print(
"--clipbox requires exactly 6 values, only ",
args_info.clipbox,
" given.",
)
sys.exit(1)
if not args_info.geometry:
print("You must provide the geometry to use --clipbox.")
sys.exit(1)
c1 = itk.Point[itk.F, Dimension](args_info.clipbox[0:6:2])
c2 = itk.Point[itk.F, Dimension](args_info.clipbox[1:6:2])
shroudFilter.SetCorner1(c1)
shroudFilter.SetCorner2(c2)
# Geometry
if args_info.geometry:
geometry = rtk.read_geometry(args_info.geometry)
shroudFilter.SetGeometry(geometry)
shroudFilter.UpdateOutputInformation()
# Write output
writer = itk.ImageFileWriter[itk.Image[itk.D, 2]].New()
writer.SetFileName(args_info.output)
writer.SetInput(shroudFilter.GetOutput())
writer.SetNumberOfStreamDivisions(
shroudFilter.GetOutput().GetLargestPossibleRegion().GetSize()[1]
)
writer.Update()
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkargumentparser.py
================================================
import re
import argparse
from itk import RTK as rtk
import difflib
import inspect
__all__ = [
"RTKArgumentParser"
]
class RTKHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
def _format_usage(self, usage, actions, groups, prefix=None):
if prefix is None:
prefix = rtk.version() + "\n\nusage: "
return super()._format_usage(usage, actions, groups, prefix)
class RTKArgumentParser(argparse.ArgumentParser):
def __init__(self, description=None, **kwargs):
super().__init__(description=description, **kwargs)
self.formatter_class = RTKHelpFormatter
# allow negative numeric tokens to be treated as values, not options. This mirrors CPython behavior in python 3.14
self._negative_number_matcher = re.compile(r'-\.?\d')
self.add_argument('-V', '--version', action='version', version=rtk.version())
def build_signature(self) -> inspect.Signature:
"""Build a compact Python signature: only required kwargs + **kwargs."""
required_params = []
for action in self._actions:
name = getattr(action, 'dest', None)
if not name or name in ("help", "version"):
continue
if getattr(action, 'required', False):
required_params.append(
inspect.Parameter(name=name, kind=inspect.Parameter.KEYWORD_ONLY)
)
# Add catch-all for the many optional CLI options to keep help inline
var_kw = inspect.Parameter('kwargs', kind=inspect.Parameter.VAR_KEYWORD)
return inspect.Signature(required_params + [var_kw])
def build_usage_examples(self, app_name: str | None = None) -> str:
"""Return a Usage examples block for Python help()."""
name = app_name or self.prog
# Collect required destinations
req = [a.dest for a in self._actions
if getattr(a, 'required', False) and a.dest and a.dest not in ("help", "version")]
shell = f"{name}(\"{' '.join([f'--{d} {d.upper()}' for d in req])}\")"
py = f"{name}({', '.join([f'{d}={d.upper()}' for d in req])})"
return (
"Usage:\n"
f" • Shell-style: {shell}\n"
f" • Python API: {py}\n\n"
)
def apply_signature(self, func):
"""Apply the built signature to a callable and return it."""
func.__signature__ = self.build_signature()
return func
def parse_args(self, args=None, namespace=None):
"""Parse args with optional single-token comma list support for multi-value options.
Supported forms:
--opt A B C (space separated)
--opt A,B,C (single token, comma separated)
"""
neutralized = {}
for action in self._actions:
dest = getattr(action, 'dest', None)
if not dest or dest in ("help", "version"):
continue
nargs = getattr(action, 'nargs', None)
if nargs != '+':
continue
t = getattr(action, 'type', None)
if t and t is not str:
neutralized[dest] = t
action.type = str
namespace = super().parse_args(args, namespace)
for action in self._actions:
dest = getattr(action, 'dest', None)
if dest not in neutralized:
continue
caster = neutralized[dest]
val = getattr(namespace, dest, None)
if isinstance(val, list):
# Case 1: user supplied a single token containing commas (e.g. "1,2,3").
# Split on commas, strip whitespace, drop empty pieces, then cast each element.
if len(val) == 1 and isinstance(val[0], str) and ',' in val[0]:
pieces = [s for s in (p.strip() for p in val[0].split(',')) if s]
setattr(namespace, dest, [caster(p) for p in pieces])
else:
# Case 2: normal space-separated form (e.g. "1 2 3"). Just cast every token.
setattr(namespace, dest, [caster(tk) for tk in val])
action.type = neutralized[dest]
return namespace
def parse_kwargs(self, func_name: str | None = None, **kwargs):
"""Convert Python kwargs to argv and parse them.
Lists/tuples for multi-value options are serialized as a single comma token."""
actions = {a.dest: a for a in self._actions if a.dest and a.dest not in ("help", "version")}
for key in kwargs:
if key not in actions:
matches = difflib.get_close_matches(key, actions.keys(), n=3, cutoff=0.5)
name = func_name or self.prog or "function"
msg = f"{name}() got an unexpected keyword argument '{key}'"
if matches:
msg += f"\nDid you mean: {', '.join(matches)}?"
else:
msg += f"\nValid arguments are: {', '.join(sorted(actions.keys()))}"
raise TypeError(msg)
argv = []
for key, val in kwargs.items():
action = actions[key]
opt_strings = list(action.option_strings)
flag = next((o for o in opt_strings if o.startswith('--')), opt_strings[0])
if isinstance(val, bool):
if val:
argv.append(flag)
elif isinstance(val, (list, tuple)):
argv += [flag, ",".join(map(str, val))]
else:
argv += [flag, str(val)]
return self.parse_args(argv)
================================================
FILE: applications/rtkbackprojections/CMakeLists.txt
================================================
WRAP_GGO(rtkbackprojections_GGO_C rtkbackprojections.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkbackprojections rtkbackprojections.cxx ${rtkbackprojections_GGO_C})
target_link_libraries(rtkbackprojections RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkbackprojections)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkbackprojections/rtkbackprojections.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkbackprojections_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkFDKBackProjectionImageFilter.h"
#include "rtkFDKWarpBackProjectionImageFilter.h"
#include "rtkJosephBackProjectionImageFilter.h"
#include "rtkJosephBackAttenuatedProjectionImageFilter.h"
#include "rtkZengBackProjectionImageFilter.h"
#ifdef RTK_USE_CUDA
# include "rtkCudaFDKBackProjectionImageFilter.h"
# include "rtkCudaBackProjectionImageFilter.h"
# include "rtkCudaRayCastBackProjectionImageFilter.h"
#endif
#include "rtkCyclicDeformationImageFilter.h"
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
int
main(int argc, char * argv[])
{
GGO(rtkbackprojections, args_info);
using OutputPixelType = float;
constexpr unsigned int Dimension = 3;
#ifdef RTK_USE_CUDA
using OutputImageType = itk::CudaImage<OutputPixelType, Dimension>;
#else
using OutputImageType = itk::Image<OutputPixelType, Dimension>;
#endif
// Geometry
if (args_info.verbose_flag)
std::cout << "Reading geometry information from " << args_info.geometry_arg << "..." << std::flush;
rtk::ThreeDCircularProjectionGeometry::Pointer geometry;
TRY_AND_EXIT_ON_ITK_EXCEPTION(geometry = rtk::ReadGeometry(args_info.geometry_arg));
if (args_info.verbose_flag)
std::cout << " done." << std::endl;
// Create an empty volume
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkbackprojections>(constantImageSource,
args_info);
// Projections reader
using ReaderType = rtk::ProjectionsReader<OutputImageType>;
auto reader = ReaderType::New();
rtk::SetProjectionsReaderFromGgo<ReaderType, args_info_rtkbackprojections>(reader, args_info);
TRY_AND_EXIT_ON_ITK_EXCEPTION(reader->Update())
OutputImageType::Pointer attenuationMap;
if (args_info.attenuationmap_given)
{
if (args_info.verbose_flag)
std::cout << "Reading attenuation map " << args_info.attenuationmap_arg << "..." << std::endl;
// Read an existing image to initialize the attenuation map
attenuationMap = itk::ReadImage<OutputImageType>(args_info.attenuationmap_arg);
}
// Create back projection image filter
if (args_info.verbose_flag)
std::cout << "Backprojecting volume..." << std::endl;
rtk::BackProjectionImageFilter<OutputImageType, OutputImageType>::Pointer bp;
// In case warp backprojection is used, we create a deformation
using DVFPixelType = itk::Vector<float, 3>;
using DeformationType = rtk::CyclicDeformationImageFilter<itk::Image<DVFPixelType, 4>, itk::Image<DVFPixelType, 3>>;
auto def = DeformationType::New();
switch (args_info.bp_arg)
{
case (bp_arg_VoxelBasedBackProjection):
bp = rtk::BackProjectionImageFilter<OutputImageType, OutputImageType>::New();
break;
case (bp_arg_FDKBackProjection):
bp = rtk::FDKBackProjectionImageFilter<OutputImageType, OutputImageType>::New();
break;
case (bp_arg_FDKWarpBackProjection):
if (!args_info.signal_given || !args_info.dvf_given)
{
std::cerr << "FDKWarpBackProjection requires input 4D deformation "
<< "vector field and signal file names" << std::endl;
return EXIT_FAILURE;
}
def->SetInput(itk::ReadImage<DeformationType::InputImageType>(args_info.dvf_arg));
bp = rtk::FDKWarpBackProjectionImageFilter<OutputImageType, OutputImageType, DeformationType>::New();
def->SetSignalFilename(args_info.signal_arg);
dynamic_cast<rtk::FDKWarpBackProjectionImageFilter<OutputImageType, OutputImageType, DeformationType> *>(
bp.GetPointer())
->SetDeformation(def);
break;
case (bp_arg_Joseph):
bp = rtk::JosephBackProjectionImageFilter<OutputImageType, OutputImageType>::New();
break;
case (bp_arg_JosephAttenuated):
bp = rtk::JosephBackAttenuatedProjectionImageFilter<OutputImageType, OutputImageType>::New();
break;
case (bp_arg_Zeng):
bp = rtk::ZengBackProjectionImageFilter<OutputImageType, OutputImageType>::New();
break;
case (bp_arg_CudaFDKBackProjection):
#ifdef RTK_USE_CUDA
bp = rtk::CudaFDKBackProjectionImageFilter::New();
#else
std::cerr << "The program has not been compiled with cuda option" << std::endl;
return EXIT_FAILURE;
#endif
break;
case (bp_arg_CudaBackProjection):
#ifdef RTK_USE_CUDA
bp = rtk::CudaBackProjectionImageFilter<OutputImageType>::New();
#else
std::cerr << "The program has not been compiled with cuda option" << std::endl;
return EXIT_FAILURE;
#endif
break;
case (bp_arg_CudaRayCast):
#ifdef RTK_USE_CUDA
bp = rtk::CudaRayCastBackProjectionImageFilter::New();
#else
std::cerr << "The program has not been compiled with cuda option" << std::endl;
return EXIT_FAILURE;
#endif
break;
default:
std::cerr << "Unhandled --method value." << std::endl;
return EXIT_FAILURE;
}
bp->SetInput(constantImageSource->GetOutput());
bp->SetInput(1, reader->GetOutput());
if (args_info.attenuationmap_given)
bp->SetInput(2, attenuationMap);
if (args_info.sigmazero_given && args_info.bp_arg == bp_arg_Zeng)
dynamic_cast<rtk::ZengBackProjectionImageFilter<OutputImageType, OutputImageType> *>(bp.GetPointer())
->SetSigmaZero(args_info.sigmazero_arg);
if (args_info.alphapsf_given && args_info.bp_arg == bp_arg_Zeng)
dynamic_cast<rtk::ZengBackProjectionImageFilter<OutputImageType, OutputImageType> *>(bp.GetPointer())
->SetAlpha(args_info.alphapsf_arg);
bp->SetGeometry(geometry);
TRY_AND_EXIT_ON_ITK_EXCEPTION(bp->Update())
// Write
if (args_info.verbose_flag)
std::cout << "Writing... " << std::endl;
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(bp->GetOutput(), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkbackprojections/rtkbackprojections.ggo
================================================
purpose "Backprojects a volume according to a geometry file."
option "verbose" v "Verbose execution" flag off
option "geometry" g "XML geometry file name" string yes
option "output" o "Output volume file name" string yes
section "Projectors"
option "bp" - "Backprojection method" values="VoxelBasedBackProjection","FDKBackProjection","FDKWarpBackProjection","Joseph","JosephAttenuated", "Zeng", "CudaFDKBackProjection","CudaBackProjection","CudaRayCast" enum no default="VoxelBasedBackProjection"
option "attenuationmap" - "Attenuation map relative to the volume to perfom the attenuation correction" string no
option "sigmazero" - "PSF value at a distance of 0 meter of the detector" double no
option "alphapsf" - "Slope of the PSF against the detector distance" double no
section "Warped backprojection"
option "signal" - "Signal file name" string no
option "dvf" - "Input 4D DVF" string no
================================================
FILE: applications/rtkbackprojections/rtkbackprojections.py
================================================
#!/usr/bin/env python
import sys
import argparse
import itk
from itk import RTK as rtk
def build_parser():
parser = rtk.RTKArgumentParser(
description="Backprojects a volume according to a geometry file."
)
# General arguments
parser.add_argument(
"--verbose", "-v", help="Verbose execution", action="store_true"
)
parser.add_argument(
"--geometry", "-g", help="XML geometry file name", type=str, required=True
)
parser.add_argument(
"--output", "-o", help="Output volume file name", type=str, required=True
)
# Projectors group
rtkprojectors_group = parser.add_argument_group("Projectors")
rtkprojectors_group.add_argument(
"--bp",
help="Backprojection method",
type=str,
choices=[
"VoxelBasedBackProjection",
"FDKBackProjection",
"FDKWarpBackProjection",
"Joseph",
"JosephAttenuated",
"Zeng",
"CudaFDKBackProjection",
"CudaBackProjection",
"CudaRayCast",
],
default="VoxelBasedBackProjection",
)
rtkprojectors_group.add_argument(
"--attenuationmap", help="Attenuation map for attenuation correction", type=str
)
rtkprojectors_group.add_argument(
"--sigmazero",
help="PSF value at a distance of 0 meter of the detector",
type=float,
)
rtkprojectors_group.add_argument(
"--alphapsf", help="Slope of the PSF against the detector distance", type=float
)
# Warped backprojections group
Warped_backprojection_group = parser.add_argument_group(
"Warped backprojections group"
)
Warped_backprojection_group.add_argument(
"--signal", help="Signal file name", type=str
)
Warped_backprojection_group.add_argument("--dvf", help="Input 4D DVF", type=str)
rtk.add_rtk3Doutputimage_group(parser)
rtk.add_rtkinputprojections_group(parser)
# Parse the command line arguments
return parser
def process(args_info: argparse.Namespace):
# Define output pixel type and dimension
OutputPixelType = itk.F
Dimension = 3
OutputImageType = itk.Image[OutputPixelType, Dimension]
if hasattr(itk, "CudaImage"):
OutputCudaImageType = itk.CudaImage[OutputPixelType, Dimension]
# Geometry
if args_info.verbose:
print(f"Reading geometry from {args_info.geometry}...")
geometry = rtk.read_geometry(args_info.geometry)
if args_info.verbose:
print(f"done.")
# Create empty volume
constantImageSource = rtk.ConstantImageSource[OutputImageType].New()
rtk.SetConstantImageSourceFromArgParse(constantImageSource, args_info)
# Projections reader
reader = rtk.ProjectionsReader[itk.Image[itk.F, 3]].New()
rtk.SetProjectionsReaderFromArgParse(reader, args_info)
reader.Update()
attenuation_map = None
if args_info.attenuationmap:
if args_info.verbose:
print(f"Reading attenuation map from {args_info.attenuationmap}...")
# Read an existing image to initialize the attenuation map
attenuation_map = itk.imread(args_info.attenuationmap)
# In case warp backprojection is used, we create a deformation
DVFPixelType = itk.Vector[itk.F, 3]
DVFImageSequenceType = itk.Image[DVFPixelType, 4]
DVFImageType = itk.Image[DVFPixelType, 3]
DeformationType = rtk.CyclicDeformationImageFilter[
DVFImageSequenceType, DVFImageType
]
bp = None
if args_info.bp == "VoxelBasedBackProjection":
bp = rtk.BackProjectionImageFilter[OutputImageType, OutputImageType].New()
elif args_info.bp == "FDKBackProjection":
bp = rtk.FDKBackProjectionImageFilter[OutputImageType, OutputImageType].New()
elif args_info.bp == "FDKWarpBackProjection":
if not args_info.dvf or not args_info.signal:
raise ValueError(
"FDKWarpBackProjection requires input 4D deformation vector field and signal file names"
)
deformation = rtk.CyclicDeformationImageFilter[
DVFImageSequenceType, DVFImageType
].New()
deformation.SetInput(itk.imread(args_info.dvf))
bp = rtk.FDKWarpBackProjectionImageFilter[
OutputImageType, OutputImageType, DeformationType
].New()
deformation.SetSignalFilename(args_info.signal)
bp.SetDeformation(deformation)
elif args_info.bp == "Joseph":
bp = rtk.JosephBackProjectionImageFilter[OutputImageType, OutputImageType].New()
elif args_info.bp == "JosephAttenuated":
bp = rtk.JosephBackAttenuatedProjectionImageFilter[
OutputImageType, OutputImageType
].New()
elif args_info.bp == "Zeng":
bp = rtk.ZengBackProjectionImageFilter[OutputImageType, OutputImageType].New()
if args_info.sigmazero:
bp.SetSigmaZero(args_info.sigmazero)
if args_info.alphapsf:
bp.SetAlpha(args_info.alphapsf)
elif args_info.bp == "CudaFDKBackProjection":
if hasattr(itk, "CudaImage"):
bp = rtk.CudaFDKBackProjectionImageFilter.New()
else:
print("The program has not been compiled with cuda option")
sys.exit(1)
elif args_info.bp == "CudaBackProjection":
if hasattr(itk, "CudaImage"):
bp = rtk.CudaBackProjectionImageFilter[OutputCudaImageType].New()
else:
print("The program has not been compiled with cuda option")
sys.exit(1)
elif args_info.bp == "CudaRayCast":
if hasattr(itk, "CudaImage"):
bp = rtk.CudaRayCastBackProjectionImageFilter.New()
else:
print("The program has not been compiled with cuda option")
sys.exit(1)
if args_info.bp in ["CudaFDKBackProjection", "CudaBackProjection", "CudaRayCast"]:
bp.SetInput(itk.cuda_image_from_image(constantImageSource.GetOutput()))
bp.SetInput(1, itk.cuda_image_from_image(reader.GetOutput()))
if attenuation_map:
bp.SetInput(2, itk.cuda_image_from_image(attenuation_map))
else:
bp.SetInput(constantImageSource.GetOutput())
bp.SetInput(1, reader.GetOutput())
if attenuation_map:
bp.SetInput(2, attenuation_map)
bp.SetGeometry(geometry)
bp.Update()
# Write
if args_info.verbose:
print(f"Writing output to {args_info.output}...")
writter = itk.ImageFileWriter[OutputImageType].New()
writter.SetFileName(args_info.output)
writter.SetInput(bp.GetOutput())
writter.Update()
if args_info.verbose:
print("Processing completed successfully.")
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkbioscangeometry/CMakeLists.txt
================================================
WRAP_GGO(rtkbioscangeometry_GGO_C rtkbioscangeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkbioscangeometry rtkbioscangeometry.cxx ${rtkbioscangeometry_GGO_C})
target_link_libraries(rtkbioscangeometry RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkbioscangeometry)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkbioscangeometry/rtkbioscangeometry.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkbioscangeometry_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkBioscanGeometryReader.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
int
main(int argc, char * argv[])
{
GGO(rtkbioscangeometry, args_info);
// Create geometry reader
auto bioscanReader = rtk::BioscanGeometryReader::New();
bioscanReader->SetProjectionsFileNames(rtk::GetProjectionsFileNamesFromGgo(args_info));
TRY_AND_EXIT_ON_ITK_EXCEPTION(bioscanReader->UpdateOutputData())
// Write
TRY_AND_EXIT_ON_ITK_EXCEPTION(rtk::WriteGeometry(
const_cast<rtk::ThreeDCircularProjectionGeometry *>(bioscanReader->GetGeometry()), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkbioscangeometry/rtkbioscangeometry.ggo
================================================
purpose "Creates an RTK geometry file from a sequence of x-ray projections of a Bioscan NanoSPECT/CT scanner."
option "verbose" v "Verbose execution" flag off
option "output" o "Output file name" string yes
section "Projections"
option "path" p "Path containing projections" string yes
option "regexp" r "Regular expression to select projection files in path" string yes
option "nsort" - "Numeric sort for regular expression matches" flag off
option "submatch" - "Index of the submatch that will be used to sort matches" int no default="0"
================================================
FILE: applications/rtkbioscangeometry/rtkbioscangeometry.py
================================================
import argparse
import sys
from itk import RTK as rtk
def build_parser():
parser = rtk.RTKArgumentParser(
description="Read Bioscan geometry and write RTK geometry XML file."
)
parser.add_argument(
"--output", "-o", required=True, help="Output geometry XML file"
)
parser.add_argument(
"--verbose", "-v", action="store_true", help="Enable verbose output"
)
rtk.add_rtkinputprojections_group(parser)
return parser
def process(args_info: argparse.Namespace):
# Create geometry reader
bioscanReader = rtk.BioscanGeometryReader.New()
bioscanReader.SetProjectionsFileNames(rtk.GetProjectionsFileNamesFromArgParse(args_info))
if args_info.verbose:
print("Reading Bioscan geometry...")
bioscanReader.UpdateOutputData()
# Write geometry
if args_info.verbose:
print(f"Writing geometry to {args_info.output}...")
rtk.write_geometry(bioscanReader.GetGeometry(), args_info.output)
if args_info.verbose:
print("Done.")
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkcheckimagequality/CMakeLists.txt
================================================
WRAP_GGO(rtkcheckimagequality_GGO_C rtkcheckimagequality.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkcheckimagequality rtkcheckimagequality.cxx ${rtkcheckimagequality_GGO_C})
target_link_libraries(rtkcheckimagequality RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkcheckimagequality)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkcheckimagequality/rtkcheckimagequality.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkcheckimagequality_ggo.h"
#include "rtkConfiguration.h"
#include "rtkMacro.h"
#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkImageRegionConstIterator.h"
namespace rtk
{
/**
* \file rtkcheckimagequality.cxx
*
* \brief Checks that an image has a satisfactory MSE against a reference.
*
* \author Aurélien Coussat
*/
template <class TImage>
double
MSE(typename TImage::Pointer reference, typename TImage::Pointer reconstruction)
{
using ImageIteratorType = itk::ImageRegionConstIterator<TImage>;
ImageIteratorType itTest(reconstruction, reconstruction->GetBufferedRegion());
ImageIteratorType itRef(reference, reference->GetBufferedRegion());
using ErrorType = double;
ErrorType EnerError = 0.;
itTest.GoToBegin();
itRef.GoToBegin();
while (!itRef.IsAtEnd())
{
typename TImage::PixelType TestVal = itTest.Get();
typename TImage::PixelType RefVal = itRef.Get();
EnerError += std::pow(ErrorType(RefVal - TestVal), 2.);
++itTest;
++itRef;
}
return EnerError;
}
} // namespace rtk
int
main(int argc, char ** argv)
{
GGO(rtkcheckimagequality, args_info);
constexpr unsigned int Dimension = 3;
using PixelType = float;
using ImageType = itk::Image<PixelType, Dimension>;
// Maximum number of comparisons to perform (depends on the number of inputs)
unsigned int n_max =
std::max({ args_info.reference_given, args_info.reconstruction_given, args_info.threshold_given });
for (unsigned int i = 0; i < n_max; i++)
{
unsigned int reference_index = std::min(args_info.reference_given - 1, i);
unsigned int reconstruction_index = std::min(args_info.reconstruction_given - 1, i);
unsigned int threshold_index = std::min(args_info.threshold_given - 1, i);
ImageType::Pointer reference, reconstruction;
try
{
reference = itk::ReadImage<ImageType>(args_info.reference_arg[reference_index]);
}
catch (::itk::ExceptionObject & e)
{
std::cerr << e.GetDescription();
return EXIT_FAILURE;
}
try
{
reconstruction = itk::ReadImage<ImageType>(args_info.reconstruction_arg[reconstruction_index]);
}
catch (::itk::ExceptionObject & e)
{
std::cerr << e.GetDescription();
return EXIT_FAILURE;
}
double mse = rtk::MSE<ImageType>(reference, reconstruction);
if (mse > args_info.threshold_arg[threshold_index])
{
std::cerr << "Error comparing " << args_info.reference_arg[reference_index] << " and "
<< args_info.reconstruction_arg[reconstruction_index] << ":" << std::endl
<< "MSE " << mse << " above given threshold " << args_info.threshold_arg[threshold_index] << std::endl;
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkcheckimagequality/rtkcheckimagequality.ggo
================================================
purpose "Checks the MSE of a reconstructed image against a reference."
option "verbose" v "Verbose execution" flag off
option "reference" i "Reference volume(s)" string multiple yes
option "reconstruction" j "Reconstructed volume(s)" string multiple yes
option "threshold" t "MSE threshold(s)" int multiple yes
================================================
FILE: applications/rtkcheckimagequality/rtkcheckimagequality.py
================================================
import argparse
import sys
import itk
from itk import RTK as rtk
def build_parser():
parser = rtk.RTKArgumentParser(
description="Checks the MSE of a reconstructed image against a reference."
)
parser.add_argument(
"--reference",
"-i",
required=True,
type=str,
nargs="+",
help="Reference volume(s)",
)
parser.add_argument(
"--reconstruction",
"-j",
required=True,
type=str,
nargs="+",
help="Reconstructed volume(s)",
)
parser.add_argument(
"--threshold",
"-t",
required=True,
type=float,
nargs="+",
help="MSE threshold(s)",
)
parser.add_argument(
"--verbose", "-v", action="store_true", help="Enable verbose output"
)
return parser
def mse(reference, reconstruction):
arr_ref = itk.array_view_from_image(reference)
arr_rec = itk.array_view_from_image(reconstruction)
return float(((arr_ref - arr_rec) ** 2).sum())
def process(args_info: argparse.Namespace):
# Maximum number of comparisons to perform (depends on the number of inputs)
n_max = max(
len(args_info.reference),
len(args_info.reconstruction),
len(args_info.threshold),
)
for i in range(n_max):
reference_index = min(len(args_info.reference) - 1, i)
reconstruction_index = min(len(args_info.reconstruction) - 1, i)
threshold_index = min(len(args_info.threshold) - 1, i)
if args_info.verbose:
print(f"Reading reference image: {args_info.reference[reference_index]}")
reference = itk.imread(args_info.reference[reference_index])
if args_info.verbose:
print(f"Reading reconstruction image: {args_info.reconstruction[reconstruction_index]}")
reconstruction = itk.imread(args_info.reconstruction[reconstruction_index])
mse_val = mse(reference, reconstruction)
if args_info.verbose:
print(f"MSE: {mse_val} (threshold: {args_info.threshold[threshold_index]})")
if mse_val > args_info.threshold[threshold_index]:
print(
f"Error comparing {args_info.reference[reference_index]} and {args_info.reconstruction[reconstruction_index]}:\n"
f"MSE {mse_val} above given threshold {args_info.threshold[threshold_index]}",
file=sys.stderr,
)
sys.exit(1)
if args_info.verbose:
print("All comparisons passed.")
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkconjugategradient/CMakeLists.txt
================================================
WRAP_GGO(rtkconjugategradient_GGO_C rtkconjugategradient.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ../rtkprojectors_section.ggo ../rtkiterations_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkconjugategradient rtkconjugategradient.cxx ${rtkconjugategradient_GGO_C})
target_link_libraries(rtkconjugategradient RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkconjugategradient)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkconjugategradient/ConjugateGradient2D.sh
================================================
# Generate geometry for fan-beam setup
rtksimulatedgeometry -n 720 -o geometry.xml --arc 360
# Create projections of the phantom file
# Note the sinogram being 3 pixels wide in the y direction to allow back-projection interpolation in a 2D image
rtkprojectgeometricphantom -g geometry.xml -o projections.mha --spacing 2 --size=512,3,512 --phantomfile SheppLogan-2d.txt --phantomscale=256,1,256
# Perform Conjugate Gradient reconstruction
rtkconjugategradient -p . -r projections.mha -o cg.mha -g geometry.xml --spacing 2 --size 256 1 256 -n 10
# Create a reference volume for comparison
rtkdrawgeometricphantom --spacing 2 --size=256,1,256 --phantomfile SheppLogan-2d.txt -o ref.mha --phantomscale=256,1,256
================================================
FILE: applications/rtkconjugategradient/ConjugateGradient3D.sh
================================================
# Create a simulated geometry
rtksimulatedgeometry -n 180 -o geometry.xml
# You may add "--arc 200" to make the scan short or "--proj_iso_x 200" to offset the detector
# Create projections of the phantom file
rtkprojectshepploganphantom -g geometry.xml -o projections.mha --spacing 2 --size 256
# Reconstruct
rtkconjugategradient -p . -r projections.mha -o 3dcg.mha -g geometry.xml --spacing 2 --size 256 -n 10
# Create a reference volume for comparison
rtkdrawshepploganphantom --spacing 2 --size 256 -o ref.mha
================================================
FILE: applications/rtkconjugategradient/NoisyConjugateGradient.sh
================================================
# Create a simulated geometry
rtksimulatedgeometry -n 180 -o geometry.xml
# You may add "--arc 200" to make the scan short or "--proj_iso_x 200" to offset the detector
# Create projections of the phantom file
rtkprojectshepploganphantom -g geometry.xml -o projections.mha --spacing 2 --size 256
# Perform least squares reconstruction
rtkconjugategradient -p . -r noisyLineIntegrals.mha -o LeastSquares.mha -g geom.xml -n 20
# Perform weighted least squares reconstruction
rtkconjugategradient -p . -r noisyLineIntegrals.mha -o WeightedLeastSquares.mha -g geom.xml -w weightsmap.mha -n 10
# Create a reference volume for comparison
rtkdrawshepploganphantom --spacing 2 --size 256 -o ref.mha
================================================
FILE: applications/rtkconjugategradient/README.md
================================================
# Conjugate gradient
`````{tab-set}
````{tab-item} 3D
## 3D
{w=200px alt="SheppLogan sinogram 3D"}
{w=200px alt="ConjugateGradient reconstruction"}
This script uses the SheppLogan phantom.
```{literalinclude} ConjugateGradient3D.sh
```
````
````{tab-item} 2D
## 2D
{w=200px alt="SHeppLogan sinogram 2D"}
{w=200px alt="ConjugateGradient reconstruction"}
The same reconstruction can be performed using the original 2D Shepp-Logan phantom.
RTK can perform 2D reconstructions through images wide of 1 pixel in the y direction.
The following script performs the same reconstruction as above in a 2D environment and use the Shepp–Logan phantom (https://data.kitware.com/api/v1/file/67d1ff45c6dec2fc9c534d0d/download).
```{literalinclude} ConjugateGradient2D.sh
```
````
````{tab-item} Noisy Reconstruction
## Noisy Reconstruction
In the presence of noise, all projection data may not be equally reliable. The conjugate gradient algorithm can be modified to take this into account, and each pixel of the projections can be associated with a weight. The higher the weight, the more reliable the pixel data. Download [noisy projections](https://data.kitware.com/api/v1/item/5be99cdf8d777f2179a2e63d/download) and [the associated weights](https://data.kitware.com/api/v1/item/5be99d268d777f2179a2e6f8/download), as well as [the geometry](https://data.kitware.com/api/v1/item/5be99d268d777f2179a2e700/download), and run the following to compare the regular least squares reconstruction (without weights) and the weighted least squares reconstruction.
```{literalinclude} NoisyConjugateGradient.sh
```
````
`````
================================================
FILE: applications/rtkconjugategradient/rtkconjugategradient.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkconjugategradient_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkConjugateGradientConeBeamReconstructionFilter.h"
#include "rtkIterationCommands.h"
#include <iostream>
#include <fstream>
#include <iterator>
#ifdef RTK_USE_CUDA
# include <itkCudaImage.h>
#endif
#include <itkImageFileWriter.h>
int
main(int argc, char * argv[])
{
GGO(rtkconjugategradient, args_info);
using OutputPixelType = float;
constexpr unsigned int Dimension = 3;
#ifdef RTK_USE_CUDA
using OutputImageType = itk::CudaImage<OutputPixelType, Dimension>;
#else
using OutputImageType = itk::Image<OutputPixelType, Dimension>;
#endif
// Projections reader
using ReaderType = rtk::ProjectionsReader<OutputImageType>;
auto reader = ReaderType::New();
rtk::SetProjectionsReaderFromGgo<ReaderType, args_info_rtkconjugategradient>(reader, args_info);
// Geometry
if (args_info.verbose_flag)
std::cout << "Reading geometry information from " << args_info.geometry_arg << "..." << std::endl;
rtk::ThreeDCircularProjectionGeometry::Pointer geometry;
TRY_AND_EXIT_ON_ITK_EXCEPTION(geometry = rtk::ReadGeometry(args_info.geometry_arg));
// Create input: either an existing volume read from a file or a blank image
itk::ImageSource<OutputImageType>::Pointer inputFilter;
if (args_info.input_given)
{
// Read an existing image to initialize the volume
auto inputReader = itk::ImageFileReader<OutputImageType>::New();
inputReader->SetFileName(args_info.input_arg);
inputFilter = inputReader;
}
else
{
// Create new empty volume
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkconjugategradient>(constantImageSource,
args_info);
inputFilter = constantImageSource;
}
// Read weights if given
OutputImageType::Pointer inputWeights;
if (args_info.weights_given)
{
using WeightsReaderType = itk::ImageFileReader<OutputImageType>;
auto weightsReader = WeightsReaderType::New();
weightsReader->SetFileName(args_info.weights_arg);
inputWeights = weightsReader->GetOutput();
TRY_AND_EXIT_ON_ITK_EXCEPTION(inputWeights->Update())
}
// Read regularization weights if given
OutputImageType::Pointer localRegWeights;
if (args_info.regweights_given)
{
using WeightsReaderType = itk::ImageFileReader<OutputImageType>;
auto localRegWeightsReader = WeightsReaderType::New();
localRegWeightsReader->SetFileName(args_info.regweights_arg);
localRegWeights = localRegWeightsReader->GetOutput();
localRegWeights->Update();
}
// Read Support Mask if given
OutputImageType::Pointer supportmaskSource;
if (args_info.mask_given)
{
supportmaskSource = itk::ReadImage<OutputImageType>(args_info.mask_arg);
}
// Set the forward and back projection filters to be used
auto conjugategradient = rtk::ConjugateGradientConeBeamReconstructionFilter<OutputImageType>::New();
SetForwardProjectionFromGgo(args_info, conjugategradient.GetPointer());
SetBackProjectionFromGgo(args_info, conjugategradient.GetPointer());
conjugategradient->SetInputVolume(inputFilter->GetOutput());
conjugategradient->SetInputProjectionStack(reader->GetOutput());
conjugategradient->SetInputWeights(inputWeights);
conjugategradient->SetLocalRegularizationWeights(localRegWeights);
conjugategradient->SetCudaConjugateGradient(!args_info.nocudacg_flag);
if (args_info.mask_given)
{
conjugategradient->SetSupportMask(supportmaskSource);
}
if (args_info.gamma_given)
conjugategradient->SetGamma(args_info.gamma_arg);
if (args_info.tikhonov_given)
conjugategradient->SetTikhonov(args_info.tikhonov_arg);
conjugategradient->SetGeometry(geometry);
conjugategradient->SetNumberOfIterations(args_info.niterations_arg);
conjugategradient->SetDisableDisplacedDetectorFilter(args_info.nodisplaced_flag);
REPORT_ITERATIONS(
conjugategradient, rtk::ConjugateGradientConeBeamReconstructionFilter<OutputImageType>, OutputImageType)
itk::TimeProbe readerProbe;
if (args_info.time_flag)
{
std::cout << "Recording elapsed time... " << std::flush;
readerProbe.Start();
}
TRY_AND_EXIT_ON_ITK_EXCEPTION(conjugategradient->Update())
if (args_info.time_flag)
{
// conjugategradient->PrintTiming(std::cout);
readerProbe.Stop();
std::cout << "It took... " << readerProbe.GetMean() << ' ' << readerProbe.GetUnit() << std::endl;
}
// Write
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(conjugategradient->GetOutput(), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkconjugategradient/rtkconjugategradient.ggo
================================================
purpose "Reconstructs a 3D volume from a sequence of projections with a conjugate gradient technique"
option "verbose" v "Verbose execution" flag off
option "geometry" g "XML geometry file name" string yes
option "output" o "Output file name" string yes
option "niterations" n "Number of iterations" int no default="5"
option "time" t "Records elapsed time during the process" flag off
option "input" i "Input volume" string no
option "weights" w "Weights file for Weighted Least Squares (WLS)" string no
option "regweights" - "Local regularization weights file" string no
option "gamma" - "Laplacian regularization weight" float no default="0"
option "tikhonov" - "Tikhonov regularization weight" float no default="0"
option "nocudacg" - "Do not perform conjugate gradient calculations on GPU" flag off
option "mask" m "Apply a support binary mask: reconstruction kept null outside the mask)" string no
option "nodisplaced" - "Disable the displaced detector filter" flag off
================================================
FILE: applications/rtkconjugategradient/rtkconjugategradient.py
================================================
#!/usr/bin/env python
import argparse
import itk
from itk import RTK as rtk
def build_parser():
# argument parsing
parser = rtk.RTKArgumentParser(
description="Reconstructs a 3D volume from a sequence of projections with a conjugate gradient technique"
)
parser.add_argument(
"--verbose", "-v", help="Verbose execution", action="store_true"
)
parser.add_argument("--geometry", "-g", help="Geometry file name", required=True)
parser.add_argument("--output", "-o", help="Output file name", required=True)
parser.add_argument(
"--niterations", "-n", type=int, default=5, help="Number of iterations"
)
parser.add_argument("--input", "-i", help="Input volume")
parser.add_argument(
"--weights", "-w", help="Weights file for Weighted Least Squares (WLS)"
)
parser.add_argument("--gamma", help="Laplacian regularization weight")
parser.add_argument("--tikhonov", help="Tikhonov regularization weight")
parser.add_argument(
"--nocudacg",
help="Do not perform conjugate gradient calculations on GPU",
action="store_true",
)
parser.add_argument(
"--mask",
"-m",
help="Apply a support binary mask: reconstruction kept null outside the mask)",
)
parser.add_argument(
"--nodisplaced",
help="Disable the displaced detector filter",
action="store_true",
)
rtk.add_rtkinputprojections_group(parser)
rtk.add_rtk3Doutputimage_group(parser)
rtk.add_rtkprojectors_group(parser)
rtk.add_rtkiterations_group(parser)
# Parse the command line arguments
return parser
def process(args_info: argparse.Namespace):
OutputPixelType = itk.F
Dimension = 3
OutputImageType = itk.Image[OutputPixelType, Dimension]
# Projections reader
reader = rtk.ProjectionsReader[OutputImageType].New()
rtk.SetProjectionsReaderFromArgParse(reader, args_info)
# Geometry
if args_info.verbose:
print(f"Reading geometry information from {args_info.geometry}")
geometry = rtk.read_geometry(args_info.geometry)
# Create input: either an existing volume read from a file or a blank image
if args_info.input is not None:
# Read an existing image to initialize the volume
InputReaderType = itk.ImageFileReader[OutputImageType]
inputReader = InputReaderType.New()
inputReader.SetFileName(args_info.input)
inputFilter = inputReader
else:
# Create new empty volume
ConstantImageSourceType = rtk.ConstantImageSource[OutputImageType]
constantImageSource = ConstantImageSourceType.New()
rtk.SetConstantImageSourceFromArgParse(constantImageSource, args_info)
inputFilter = constantImageSource
# Read weights if given, otherwise default to weights all equal to one
if args_info.weights is not None:
WeightsReaderType = itk.ImageFileReader[OutputImageType]
weightsReader = WeightsReaderType.New()
weightsReader.SetFileName(args_info.weights)
weightsSource = weightsReader
else:
ConstantWeightsSourceType = rtk.ConstantImageSource[OutputImageType]
constantWeightsSource = ConstantWeightsSourceType.New()
# Set the weights to be like the projections
reader.UpdateOutputInformation()
constantWeightsSource.SetInformationFromImage(reader.GetOutput())
constantWeightsSource.SetConstant(1.0)
weightsSource = constantWeightsSource
# Read Support Mask if given
if args_info.mask is not None:
supportmask = itk.imread(args_info.mask)
# Set the forward and back projection filters to be used
if hasattr(itk, "CudaImage"):
OutputCudaImageType = itk.CudaImage[OutputPixelType, Dimension]
ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
OutputCudaImageType
]
conjugategradient = ConjugateGradientFilterType.New()
conjugategradient.SetInput(itk.cuda_image_from_image(inputFilter.GetOutput()))
conjugategradient.SetInput(1, itk.cuda_image_from_image(reader.GetOutput()))
conjugategradient.SetInput(
2, itk.cuda_image_from_image(weightsSource.GetOutput())
)
conjugategradient.SetCudaConjugateGradient(not args_info.nocudacg)
if args_info.mask is not None:
conjugategradient.SetSupportMask(itk.cuda_image_from_image(supportmask))
else:
ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
OutputImageType
]
conjugategradient = ConjugateGradientFilterType.New()
conjugategradient.SetInput(inputFilter.GetOutput())
conjugategradient.SetInput(1, reader.GetOutput())
conjugategradient.SetInput(2, weightsSource.GetOutput())
if args_info.mask is not None:
conjugategradient.SetSupportMask(supportmask)
rtk.SetForwardProjectionFromArgParse(args_info, conjugategradient)
rtk.SetBackProjectionFromArgParse(args_info, conjugategradient)
rtk.SetIterationsReportFromArgParse(args_info, conjugategradient)
if args_info.gamma is not None:
conjugategradient.SetGamma(args_info.gamma)
if args_info.tikhonov is not None:
conjugategradient.SetTikhonov(args_info.tikhonov)
conjugategradient.SetGeometry(geometry)
conjugategradient.SetNumberOfIterations(args_info.niterations)
conjugategradient.SetDisableDisplacedDetectorFilter(args_info.nodisplaced)
rtk.SetIterationsReportFromArgParse(args_info, conjugategradient)
conjugategradient.Update()
# Write
writer = itk.ImageFileWriter[OutputImageType].New()
writer.SetFileName(args_info.output)
writer.SetInput(conjugategradient.GetOutput())
writer.Update()
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkdigisensgeometry/CMakeLists.txt
================================================
WRAP_GGO(rtkdigisensgeometry_GGO_C rtkdigisensgeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkdigisensgeometry rtkdigisensgeometry.cxx ${rtkdigisensgeometry_GGO_C})
target_link_libraries(rtkdigisensgeometry RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkdigisensgeometry)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkdigisensgeometry/rtkdigisensgeometry.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkdigisensgeometry_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkThreeDCircularProjectionGeometryXMLFile.h"
#include "rtkDigisensGeometryReader.h"
int
main(int argc, char * argv[])
{
GGO(rtkdigisensgeometry, args_info);
// Create geometry reader
auto reader = rtk::DigisensGeometryReader::New();
reader->SetXMLFileName(args_info.xml_file_arg);
TRY_AND_EXIT_ON_ITK_EXCEPTION(reader->UpdateOutputData())
// Write
TRY_AND_EXIT_ON_ITK_EXCEPTION(rtk::WriteGeometry(reader->GetGeometry(), args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkdigisensgeometry/rtkdigisensgeometry.ggo
================================================
purpose "Creates an RTK geometry file from a Digisens geometry calibration."
option "verbose" v "Verbose execution" flag off
option "xml_file" x "Digisens XML information file" string yes
option "output" o "Output file name" string yes
================================================
FILE: applications/rtkdigisensgeometry/rtkdigisensgeometry.py
================================================
import argparse
from itk import RTK as rtk
def build_parser():
parser = rtk.RTKArgumentParser(
description="Read Digisens geometry XML and write RTK geometry XML file."
)
parser.add_argument(
"--xml_file", "-x", required=True, help="Input Digisens XML calibration file"
)
parser.add_argument(
"--output", "-o", required=True, help="Output geometry XML file"
)
parser.add_argument(
"--verbose", "-v", action="store_true", help="Enable verbose output"
)
return parser
def process(args_info: argparse.Namespace):
# Create geometry reader
reader = rtk.DigisensGeometryReader.New()
reader.SetXMLFileName(args_info.xml_file)
if args_info.verbose:
print(f"Reading Digisens XML: {args_info.xml_file}")
reader.UpdateOutputData()
# Write geometry
if args_info.verbose:
print(f"Writing geometry to {args_info.output}")
rtk.write_geometry(reader.GetGeometry(), args_info.output)
if args_info.verbose:
print("Done.")
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkdrawgeometricphantom/CMakeLists.txt
================================================
WRAP_GGO(rtkdrawgeometricphantom_GGO_C rtkdrawgeometricphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkdrawgeometricphantom rtkdrawgeometricphantom.cxx ${rtkdrawgeometricphantom_GGO_C})
target_link_libraries(rtkdrawgeometricphantom RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkdrawgeometricphantom)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkdrawgeometricphantom/README.md
================================================
# Create gammex phantom
{w=400px alt="Gammex"}
This script uses the file [Gammex.txt](https://data.kitware.com/api/v1/file/6762da8a290777363f95c293/download) as configuration file which creates a Gammex phantom.
```
# Create a 3D Gammex phantom
rtkdrawgeometricphantom --phantomfile Gammex.txt -o gammex.mha
```
================================================
FILE: applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkdrawgeometricphantom_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkDrawGeometricPhantomImageFilter.h"
#include "itkImageFileWriter.h"
#include "rtkAdditiveGaussianNoiseImageFilter.h"
int
main(int argc, char * argv[])
{
GGO(rtkdrawgeometricphantom, args_info);
constexpr unsigned int Dimension = 3;
using OutputImageType = itk::Image<float, Dimension>;
// Empty volume image
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkdrawgeometricphantom>(constantImageSource,
args_info);
using DQType = rtk::DrawGeometricPhantomImageFilter<OutputImageType, OutputImageType>;
// Offset, scale, rotation
DQType::VectorType offset(0.);
if (args_info.offset_given)
{
if (args_info.offset_given > 3)
{
std::cerr << "--offset needs up to 3 values" << std::endl;
exit(EXIT_FAILURE);
}
offset[0] = args_info.offset_arg[0];
offset[1] = args_info.offset_arg[1];
offset[2] = args_info.offset_arg[2];
}
DQType::VectorType scale;
scale.Fill(args_info.phantomscale_arg[0]);
if (args_info.phantomscale_given)
{
if (args_info.phantomscale_given > 3)
{
std::cerr << "--phantomscale needs up to 3 values" << std::endl;
exit(EXIT_FAILURE);
}
for (unsigned int i = 0; i < std::min(args_info.phantomscale_given, Dimension); i++)
scale[i] = args_info.phantomscale_arg[i];
}
DQType::RotationMatrixType rot;
rot.SetIdentity();
if (args_info.rotation_given)
{
if (args_info.rotation_given != 9)
{
std::cerr << "--rotation needs exactly 9 values" << std::endl;
exit(EXIT_FAILURE);
}
for (unsigned int i = 0; i < Dimension; i++)
for (unsigned int j = 0; j < Dimension; j++)
rot[i][j] = args_info.rotation_arg[i * Dimension + j];
}
// Reference
if (args_info.verbose_flag)
std::cout << "Creating reference... " << std::flush;
auto dq = DQType::New();
dq->SetInput(constantImageSource->GetOutput());
dq->SetPhantomScale(scale);
dq->SetOriginOffset(offset);
dq->SetRotationMatrix(rot);
dq->SetConfigFile(args_info.phantomfile_arg);
TRY_AND_EXIT_ON_ITK_EXCEPTION(dq->Update())
// Add noise
OutputImageType::Pointer output = dq->GetOutput();
if (args_info.noise_given)
{
auto noisy = rtk::AdditiveGaussianNoiseImageFilter<OutputImageType>::New();
noisy->SetInput(output);
noisy->SetMean(0.0);
noisy->SetStandardDeviation(args_info.noise_arg);
TRY_AND_EXIT_ON_ITK_EXCEPTION(noisy->Update())
output = noisy->GetOutput();
}
// Write
if (args_info.verbose_flag)
std::cout << "Writing reference... " << std::flush;
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(output, args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.ggo
================================================
purpose "Computes a 3D voxelized phantom from a phantom description file"
option "verbose" v "Verbose execution" flag off
option "output" o "Output projections file name" string yes
option "phantomfile" - "Parameters of the phantom reference" string yes
option "noise" - "Gaussian noise parameter (SD)" double no
option "phantomscale" - "Scaling factor for the phantom dimensions" double multiple no default="1."
option "offset" - "3D spatial offset of the phantom center" double multiple no
option "rotation" - "Rotation matrix for the phantom" double multiple no
================================================
FILE: applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.py
================================================
#!/usr/bin/env python
import argparse
import sys
import itk
from itk import RTK as rtk
import numpy as np
def build_parser():
# Argument parsing
parser = rtk.RTKArgumentParser(
description="Computes a 3D voxelized phantom from a phantom description file."
)
# General options
parser.add_argument(
"--verbose", "-v", help="Verbose execution", action="store_true"
)
parser.add_argument(
"--output", "-o", help="Output projections file name", type=str, required=True
)
parser.add_argument(
"--phantomfile",
help="Parameters of the phantom reference",
type=str,
required=True,
)
parser.add_argument("--noise", help="Gaussian noise parameter (SD)", type=float)
parser.add_argument(
"--phantomscale",
help="Scaling factor for the phantom dimensions",
type=float,
nargs="+",
default=[1.0],
)
parser.add_argument(
"--offset",
help="3D spatial offset of the phantom center",
type=float,
nargs="+",
)
parser.add_argument(
"--rotation",
help="Rotation matrix for the phantom",
type=float,
nargs="+",
)
rtk.add_rtk3Doutputimage_group(parser)
# Parse the command line arguments
return parser
def process(args_info: argparse.Namespace):
# Define output pixel type and dimension
OutputPixelType = itk.F
Dimension = 3
OutputImageType = itk.Image[OutputPixelType, Dimension]
# Empty volume image
constant_image_source = rtk.ConstantImageSource[OutputImageType].New()
rtk.SetConstantImageSourceFromArgParse(constant_image_source, args_info)
# Offset, scale, rotation
offset = [0.0] * 3
if args_info.offset:
if len(args_info.offset) > 3:
print("--offset needs up to 3 values", file=sys.stderr)
sys.exit(1)
offset = args_info.offset
scale = [args_info.phantomscale[0]] * Dimension
if args_info.phantomscale:
if len(args_info.phantomscale) > 3:
print("--phantomscale needs up to 3 values", file=sys.stderr)
sys.exit(1)
for i in range(len(args_info.phantomscale)):
scale[i] = args_info.phantomscale[i]
rot = itk.Matrix[itk.D, Dimension, Dimension]()
rot.SetIdentity()
if args_info.rotation:
if len(args_info.rotation) != 9:
print("--rotation needs exactly 9 values", file=sys.stderr)
sys.exit(1)
rot = itk.matrix_from_array(np.array(args_info.rotation).reshape(3, 3))
# Reference
if args_info.verbose:
print("Creating reference... ", flush=True)
# DrawGeometricPhantomImageFilter
dq = rtk.DrawGeometricPhantomImageFilter[OutputImageType, OutputImageType].New()
dq.SetInput(constant_image_source.GetOutput())
dq.SetPhantomScale(scale)
dq.SetOriginOffset(offset)
dq.SetRotationMatrix(rot)
dq.SetConfigFile(args_info.phantomfile)
dq.Update()
# Add noise
output = dq.GetOutput()
if args_info.noise:
noisy = rtk.AdditiveGaussianNoiseImageFilter[OutputImageType].New()
noisy.SetInput(output)
noisy.SetMean(0.0)
noisy.SetStandardDeviation(args_info.noise)
noisy.Update()
output = noisy.GetOutput()
# Write
if args_info.verbose:
print("Writing reference... ", flush=True)
itk.imwrite(output, args_info.output)
def main(argv=None):
parser = build_parser()
args_info = parser.parse_args(argv)
process(args_info)
if __name__ == "__main__":
main()
================================================
FILE: applications/rtkdrawshepploganphantom/CMakeLists.txt
================================================
WRAP_GGO(rtkdrawshepploganphantom_GGO_C rtkdrawshepploganphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)
add_executable(rtkdrawshepploganphantom rtkdrawshepploganphantom.cxx ${rtkdrawshepploganphantom_GGO_C})
target_link_libraries(rtkdrawshepploganphantom RTK)
# Installation code
if(NOT RTK_INSTALL_NO_EXECUTABLES)
foreach(EXE_NAME rtkdrawshepploganphantom)
install(TARGETS ${EXE_NAME}
RUNTIME DESTINATION ${RTK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
LIBRARY DESTINATION ${RTK_INSTALL_LIB_DIR} COMPONENT RuntimeLibraries
ARCHIVE DESTINATION ${RTK_INSTALL_ARCHIVE_DIR} COMPONENT Development)
endforeach()
endif()
================================================
FILE: applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.cxx
================================================
/*=========================================================================
*
* Copyright RTK Consortium
*
* 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.txt
*
* 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.
*
*=========================================================================*/
#include "rtkdrawshepploganphantom_ggo.h"
#include "rtkGgoFunctions.h"
#include "rtkSheppLoganPhantomFilter.h"
#include "rtkDrawSheppLoganFilter.h"
#include "rtkConstantImageSource.h"
#include "rtkAdditiveGaussianNoiseImageFilter.h"
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
int
main(int argc, char * argv[])
{
GGO(rtkdrawshepploganphantom, args_info);
constexpr unsigned int Dimension = 3;
using OutputImageType = itk::Image<float, Dimension>;
// Create a stack of empty projection images
using ConstantImageSourceType = rtk::ConstantImageSource<OutputImageType>;
auto constantImageSource = ConstantImageSourceType::New();
rtk::SetConstantImageSourceFromGgo<ConstantImageSourceType, args_info_rtkdrawshepploganphantom>(constantImageSource,
args_info);
// Create a reference object (in this case a 3D phantom reference).
using DSLType = rtk::DrawSheppLoganFilter<OutputImageType, OutputImageType>;
DSLType::VectorType offset(0.);
DSLType::VectorType scale;
for (unsigned int i = 0; i < std::min(args_info.offset_given, Dimension); i++)
offset[i] = args_info.offset_arg[i];
scale.Fill(args_info.phantomscale_arg[0]);
for (unsigned int i = 0; i < std::min(args_info.phantomscale_given, Dimension); i++)
scale[i] = args_info.phantomscale_arg[i];
auto dsl = DSLType::New();
dsl->SetPhantomScale(scale);
dsl->SetInput(constantImageSource->GetOutput());
dsl->SetOriginOffset(offset);
TRY_AND_EXIT_ON_ITK_EXCEPTION(dsl->Update())
// Add noise
OutputImageType::Pointer output = dsl->GetOutput();
if (args_info.noise_given)
{
auto noisy = rtk::AdditiveGaussianNoiseImageFilter<OutputImageType>::New();
noisy->SetInput(output);
noisy->SetMean(0.0);
noisy->SetStandardDeviation(args_info.noise_arg);
TRY_AND_EXIT_ON_ITK_EXCEPTION(noisy->Update())
output = noisy->GetOutput();
}
// Write
TRY_AND_EXIT_ON_ITK_EXCEPTION(itk::WriteImage(output, args_info.output_arg))
return EXIT_SUCCESS;
}
================================================
FILE: applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.ggo
================================================
purpose "Computes a 3D voxelized Shepp & Logan phantom with noise [https://www.slaney.org/pct/pct-errata.html]"
option "verbose" v "Verbose execution" flag off
option "output" o "Output projections file name" string yes
option "phantomscale" - "Scaling factor for the phantom dimensions" double mul
gitextract_m7pjdl55/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ ├── build-test-cxx-cuda.yml
│ ├── build-test-package-python-cuda.yml
│ ├── build-test-package.yml
│ └── clang-format-linter.yml
├── .gitignore
├── .readthedocs.yml
├── CMakeLists.txt
├── COPYRIGHT.TXT
├── CTestConfig.cmake
├── CodeContribution.md
├── GettingStarted.md
├── HEADER.TXT
├── INSTALLATION.md
├── ITKKWStyleFiles.txt.in
├── LICENSE.TXT
├── ORGANIZATION.TXT
├── README.md
├── applications/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── rtk3Doutputimage_group.py
│ ├── rtk3Doutputimage_section.ggo
│ ├── rtk4Doutputimage_section.ggo
│ ├── rtkVersion.ggo.in
│ ├── rtkadmmtotalvariation/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── TotalVariationRegularizedReconstruction.sh
│ │ ├── rtkadmmtotalvariation.cxx
│ │ ├── rtkadmmtotalvariation.ggo
│ │ └── rtkadmmtotalvariation.py
│ ├── rtkadmmwavelets/
│ │ ├── CMakeLists.txt
│ │ ├── DaubechiesWavelets.sh
│ │ ├── README.md
│ │ ├── rtkadmmwavelets.cxx
│ │ └── rtkadmmwavelets.ggo
│ ├── rtkamsterdamshroud/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkamsterdamshroud.cxx
│ │ ├── rtkamsterdamshroud.ggo
│ │ └── rtkamsterdamshroud.py
│ ├── rtkargumentparser.py
│ ├── rtkbackprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkbackprojections.cxx
│ │ ├── rtkbackprojections.ggo
│ │ └── rtkbackprojections.py
│ ├── rtkbioscangeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkbioscangeometry.cxx
│ │ ├── rtkbioscangeometry.ggo
│ │ └── rtkbioscangeometry.py
│ ├── rtkcheckimagequality/
│ │ ├── CMakeLists.txt
│ │ ├── rtkcheckimagequality.cxx
│ │ ├── rtkcheckimagequality.ggo
│ │ └── rtkcheckimagequality.py
│ ├── rtkconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── ConjugateGradient2D.sh
│ │ ├── ConjugateGradient3D.sh
│ │ ├── NoisyConjugateGradient.sh
│ │ ├── README.md
│ │ ├── rtkconjugategradient.cxx
│ │ ├── rtkconjugategradient.ggo
│ │ └── rtkconjugategradient.py
│ ├── rtkdigisensgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdigisensgeometry.cxx
│ │ ├── rtkdigisensgeometry.ggo
│ │ └── rtkdigisensgeometry.py
│ ├── rtkdrawgeometricphantom/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkdrawgeometricphantom.cxx
│ │ ├── rtkdrawgeometricphantom.ggo
│ │ └── rtkdrawgeometricphantom.py
│ ├── rtkdrawshepploganphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdrawshepploganphantom.cxx
│ │ ├── rtkdrawshepploganphantom.ggo
│ │ └── rtkdrawshepploganphantom.py
│ ├── rtkdualenergyforwardmodel/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdualenergyforwardmodel.cxx
│ │ ├── rtkdualenergyforwardmodel.ggo
│ │ └── rtkdualenergyforwardmodel.py
│ ├── rtkdualenergysimplexdecomposition/
│ │ ├── CMakeLists.txt
│ │ ├── rtkdualenergysimplexdecomposition.cxx
│ │ ├── rtkdualenergysimplexdecomposition.ggo
│ │ └── rtkdualenergysimplexdecomposition.py
│ ├── rtkelektasynergygeometry/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkelektasynergygeometry.cxx
│ │ ├── rtkelektasynergygeometry.ggo
│ │ └── rtkelektasynergygeometry.py
│ ├── rtkextractphasesignal/
│ │ ├── CMakeLists.txt
│ │ ├── rtkextractphasesignal.cxx
│ │ ├── rtkextractphasesignal.ggo
│ │ └── rtkextractphasesignal.py
│ ├── rtkextractshroudsignal/
│ │ ├── CMakeLists.txt
│ │ ├── rtkextractshroudsignal.cxx
│ │ └── rtkextractshroudsignal.ggo
│ ├── rtkfdk/
│ │ ├── CMakeLists.txt
│ │ ├── FDK2D.sh
│ │ ├── FDK3D.sh
│ │ ├── README.md
│ │ ├── rtkfdk.cxx
│ │ ├── rtkfdk.ggo
│ │ └── rtkfdk.py
│ ├── rtkfieldofview/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfieldofview.cxx
│ │ ├── rtkfieldofview.ggo
│ │ └── rtkfieldofview.py
│ ├── rtkforwardprojections/
│ │ ├── CMakeLists.txt
│ │ ├── ForwardProjection.sh
│ │ ├── README.md
│ │ ├── rtkforwardprojections.cxx
│ │ ├── rtkforwardprojections.ggo
│ │ └── rtkforwardprojections.py
│ ├── rtkfourdconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdconjugategradient.cxx
│ │ └── rtkfourdconjugategradient.ggo
│ ├── rtkfourdfdk/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdfdk.cxx
│ │ └── rtkfourdfdk.ggo
│ ├── rtkfourdrooster/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkfourdrooster.cxx
│ │ └── rtkfourdrooster.ggo
│ ├── rtkfourdsart/
│ │ ├── CMakeLists.txt
│ │ ├── rtkfourdsart.cxx
│ │ └── rtkfourdsart.ggo
│ ├── rtkgaincorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtkgaincorrection.cxx
│ │ └── rtkgaincorrection.ggo
│ ├── rtki0estimation/
│ │ ├── CMakeLists.txt
│ │ ├── rtki0estimation.cxx
│ │ └── rtki0estimation.ggo
│ ├── rtkimagxgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkimagxgeometry.cxx
│ │ └── rtkimagxgeometry.ggo
│ ├── rtkinputprojections_group.py
│ ├── rtkinputprojections_section.ggo
│ ├── rtkiterations_group.py
│ ├── rtkiterations_section.ggo
│ ├── rtkiterativefdk/
│ │ ├── CMakeLists.txt
│ │ ├── rtkiterativefdk.cxx
│ │ └── rtkiterativefdk.ggo
│ ├── rtklagcorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtklagcorrection.cxx
│ │ └── rtklagcorrection.ggo
│ ├── rtkmaskcollimation/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmaskcollimation.cxx
│ │ └── rtkmaskcollimation.ggo
│ ├── rtkmcrooster/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmcrooster.cxx
│ │ └── rtkmcrooster.ggo
│ ├── rtkmotioncompensatedfourdconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkmotioncompensatedfourdconjugategradient.cxx
│ │ └── rtkmotioncompensatedfourdconjugategradient.ggo
│ ├── rtkorageometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkorageometry.cxx
│ │ ├── rtkorageometry.ggo
│ │ └── rtkorageometry.py
│ ├── rtkosem/
│ │ ├── CMakeLists.txt
│ │ ├── rtkosem.cxx
│ │ └── rtkosem.ggo
│ ├── rtkoverlayphaseandshroud/
│ │ ├── CMakeLists.txt
│ │ ├── rtkoverlayphaseandshroud.cxx
│ │ └── rtkoverlayphaseandshroud.ggo
│ ├── rtkprojectgeometricphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojectgeometricphantom.cxx
│ │ ├── rtkprojectgeometricphantom.ggo
│ │ └── rtkprojectgeometricphantom.py
│ ├── rtkprojectionmatrix/
│ │ ├── CMakeLists.txt
│ │ ├── rtkMatlabSparseMatrix.h
│ │ ├── rtkMatlabSparseMatrix.hxx
│ │ ├── rtkprojectionmatrix.cxx
│ │ └── rtkprojectionmatrix.ggo
│ ├── rtkprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojections.cxx
│ │ ├── rtkprojections.ggo
│ │ └── rtkprojections.py
│ ├── rtkprojectors_group.py
│ ├── rtkprojectors_section.ggo
│ ├── rtkprojectshepploganphantom/
│ │ ├── CMakeLists.txt
│ │ ├── rtkprojectshepploganphantom.cxx
│ │ ├── rtkprojectshepploganphantom.ggo
│ │ └── rtkprojectshepploganphantom.py
│ ├── rtkregularizedconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkregularizedconjugategradient.cxx
│ │ └── rtkregularizedconjugategradient.ggo
│ ├── rtksart/
│ │ ├── CMakeLists.txt
│ │ ├── rtksart.cxx
│ │ └── rtksart.ggo
│ ├── rtkscatterglarecorrection/
│ │ ├── CMakeLists.txt
│ │ ├── rtkscatterglarecorrection.cxx
│ │ └── rtkscatterglarecorrection.ggo
│ ├── rtkshowgeometry/
│ │ ├── README.md
│ │ ├── rtkshowgeometry.py
│ │ └── showgeometry.sh
│ ├── rtksimulatedgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtksimulatedgeometry.cxx
│ │ ├── rtksimulatedgeometry.ggo
│ │ └── rtksimulatedgeometry.py
│ ├── rtkspectraldenoiseprojections/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectraldenoiseprojections.cxx
│ │ └── rtkspectraldenoiseprojections.ggo
│ ├── rtkspectralforwardmodel/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralforwardmodel.cxx
│ │ └── rtkspectralforwardmodel.ggo
│ ├── rtkspectralonestep/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralonestep.cxx
│ │ └── rtkspectralonestep.ggo
│ ├── rtkspectralrooster/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralrooster.cxx
│ │ └── rtkspectralrooster.ggo
│ ├── rtkspectralsimplexdecomposition/
│ │ ├── CMakeLists.txt
│ │ ├── rtkspectralsimplexdecomposition.cxx
│ │ └── rtkspectralsimplexdecomposition.ggo
│ ├── rtksubselect/
│ │ ├── CMakeLists.txt
│ │ ├── rtksubselect.cxx
│ │ └── rtksubselect.ggo
│ ├── rtktotalnuclearvariationdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtktotalnuclearvariationdenoising.cxx
│ │ └── rtktotalnuclearvariationdenoising.ggo
│ ├── rtktotalvariationdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtktotalvariationdenoising.cxx
│ │ └── rtktotalvariationdenoising.ggo
│ ├── rtktutorialapplication/
│ │ ├── CMakeLists.txt
│ │ ├── rtktutorialapplication.cxx
│ │ └── rtktutorialapplication.ggo
│ ├── rtkvarianobigeometry/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── rtkvarianobigeometry.cxx
│ │ ├── rtkvarianobigeometry.ggo
│ │ └── rtkvarianobigeometry.py
│ ├── rtkvarianprobeamgeometry/
│ │ ├── CMakeLists.txt
│ │ ├── rtkvarianprobeamgeometry.cxx
│ │ └── rtkvarianprobeamgeometry.ggo
│ ├── rtkvectorconjugategradient/
│ │ ├── CMakeLists.txt
│ │ ├── rtkvectorconjugategradient.cxx
│ │ └── rtkvectorconjugategradient.ggo
│ ├── rtkversion.py.in
│ ├── rtkwaveletsdenoising/
│ │ ├── CMakeLists.txt
│ │ ├── rtkwaveletsdenoising.cxx
│ │ └── rtkwaveletsdenoising.ggo
│ └── rtkxradgeometry/
│ ├── CMakeLists.txt
│ ├── rtkxradgeometry.cxx
│ └── rtkxradgeometry.ggo
├── cmake/
│ ├── FindGengetopt.cmake
│ ├── GetGitRevisionDescription.cmake
│ ├── GetGitRevisionDescription.cmake.in
│ ├── Hooks/
│ │ ├── pre-commit
│ │ └── pre-commit-style.bash
│ ├── KWStyle/
│ │ ├── RTK.kws.xml
│ │ ├── RTKHeader.h
│ │ └── RTKOverwrite.txt
│ └── rtkCompilerFlags.cmake
├── conf.py
├── documentation/
│ ├── Doxygen/
│ │ ├── CMakeLists.txt
│ │ ├── DoxygenFooter.html
│ │ ├── DoxygenHeader.html
│ │ ├── DoxygenStyle.css
│ │ ├── MainPage.dox
│ │ ├── Modules.dox
│ │ ├── doxygen.config.in
│ │ ├── itkdoxygen.pl.in
│ │ ├── itkgroup.pl
│ │ ├── rtkThreeDCirculationProjectionGeometry.dox
│ │ └── vxl_doxy.pl
│ └── docs/
│ ├── CMakeLists.txt
│ ├── ExternalData/
│ │ ├── AddNoise.png.sha512
│ │ ├── AdmmWavelets.png.sha512
│ │ ├── Admmtv.png.sha512
│ │ ├── Amsterdam.png.sha512
│ │ ├── Blurred.jpg.sha512
│ │ ├── Blurred_vs_mc.gif.sha512
│ │ ├── ConjugateGradient-2D.png.sha512
│ │ ├── ConjugateGradient-3D.png.sha512
│ │ ├── ConjugateGradient-Sinogram-2D.png.sha512
│ │ ├── Elekta.png.sha512
│ │ ├── Fdk-2D.png.sha512
│ │ ├── Fdk-3D.png.sha512
│ │ ├── GammexPhantom.png.sha512
│ │ ├── MotionMask.jpg.sha512
│ │ ├── Moving-Phantom-Sinogram.png.sha512
│ │ ├── POPI-Reconstruction.png.sha512
│ │ ├── POPI-Sinogram.png.sha512
│ │ ├── SheppLogan-Sinogram-2D.png.sha512
│ │ ├── SheppLogan-Sinogram-3D.png.sha512
│ │ ├── ShowGeometry.png.sha512
│ │ ├── Signal.jpg.sha512
│ │ ├── Thorax-Sinogram.png.sha512
│ │ ├── Thorax-fdk.png.sha512
│ │ ├── Thorax-visualisation.png.sha512
│ │ ├── Varian.png.sha512
│ │ ├── VarianProBeam.png.sha512
│ │ └── VectorField.gif.sha512
│ ├── Geometry.md
│ ├── Phantom.md
│ ├── Projectors.md
│ ├── README.md
│ ├── Release.md
│ ├── copy_and_fetch_sphinx_doc_files.cmake
│ ├── requirements.txt
│ └── rtk_3_migration_guide.md
├── examples/
│ ├── AddNoise/
│ │ ├── AddNoise.cxx
│ │ ├── AddNoise.py
│ │ ├── CMakeLists.txt
│ │ └── README.md
│ ├── ConjugateGradient/
│ │ ├── CMakeLists.txt
│ │ ├── ConjugateGradient.cxx
│ │ ├── ConjugateGradient.py
│ │ └── README.md
│ ├── FirstReconstruction/
│ │ ├── CMakeLists.txt
│ │ ├── FirstCudaReconstruction.cxx
│ │ ├── FirstCudaReconstruction.py
│ │ ├── FirstReconstruction.cxx
│ │ ├── FirstReconstruction.py
│ │ └── README.md
│ ├── GeometricPhantom/
│ │ ├── CMakeLists.txt
│ │ ├── GeometricPhantom.cxx
│ │ ├── GeometricPhantom.py
│ │ └── README.md
│ ├── InlineReconstruction/
│ │ ├── CMakeLists.txt
│ │ ├── InlineReconstruction.cxx
│ │ ├── InlineReconstruction.py
│ │ └── README.md
│ ├── README.md
│ └── WaterPreCorrection/
│ ├── Profile.png.sha512
│ ├── README.md
│ └── WaterPreCorrection.py
├── include/
│ ├── rtkADMMTotalVariationConeBeamReconstructionFilter.h
│ ├── rtkADMMTotalVariationConeBeamReconstructionFilter.hxx
│ ├── rtkADMMTotalVariationConjugateGradientOperator.h
│ ├── rtkADMMTotalVariationConjugateGradientOperator.hxx
│ ├── rtkADMMWaveletsConeBeamReconstructionFilter.h
│ ├── rtkADMMWaveletsConeBeamReconstructionFilter.hxx
│ ├── rtkADMMWaveletsConjugateGradientOperator.h
│ ├── rtkADMMWaveletsConjugateGradientOperator.hxx
│ ├── rtkAddMatrixAndDiagonalImageFilter.h
│ ├── rtkAddMatrixAndDiagonalImageFilter.hxx
│ ├── rtkAdditiveGaussianNoiseImageFilter.h
│ ├── rtkAdditiveGaussianNoiseImageFilter.hxx
│ ├── rtkAmsterdamShroudImageFilter.h
│ ├── rtkAmsterdamShroudImageFilter.hxx
│ ├── rtkAverageOutOfROIImageFilter.h
│ ├── rtkAverageOutOfROIImageFilter.hxx
│ ├── rtkBackProjectionImageFilter.h
│ ├── rtkBackProjectionImageFilter.hxx
│ ├── rtkBackwardDifferenceDivergenceImageFilter.h
│ ├── rtkBackwardDifferenceDivergenceImageFilter.hxx
│ ├── rtkBioscanGeometryReader.h
│ ├── rtkBlockDiagonalMatrixVectorMultiplyImageFilter.h
│ ├── rtkBlockDiagonalMatrixVectorMultiplyImageFilter.hxx
│ ├── rtkBoellaardScatterCorrectionImageFilter.h
│ ├── rtkBoellaardScatterCorrectionImageFilter.hxx
│ ├── rtkBoxShape.h
│ ├── rtkConditionalMedianImageFilter.h
│ ├── rtkConditionalMedianImageFilter.hxx
│ ├── rtkConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkConjugateGradientGetP_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetP_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientGetR_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetR_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientGetX_kPlusOneImageFilter.h
│ ├── rtkConjugateGradientGetX_kPlusOneImageFilter.hxx
│ ├── rtkConjugateGradientImageFilter.h
│ ├── rtkConjugateGradientImageFilter.hxx
│ ├── rtkConjugateGradientOperator.h
│ ├── rtkConjugateGradientOperator.hxx
│ ├── rtkConstantImageSource.h
│ ├── rtkConstantImageSource.hxx
│ ├── rtkConvexShape.h
│ ├── rtkCudaAverageOutOfROIImageFilter.h
│ ├── rtkCudaAverageOutOfROIImageFilter.hcu
│ ├── rtkCudaBackProjectionImageFilter.h
│ ├── rtkCudaBackProjectionImageFilter.hcu
│ ├── rtkCudaBackProjectionImageFilter.hxx
│ ├── rtkCudaConjugateGradientImageFilter.h
│ ├── rtkCudaConjugateGradientImageFilter.hcu
│ ├── rtkCudaConjugateGradientImageFilter.hxx
│ ├── rtkCudaConstantVolumeSeriesSource.h
│ ├── rtkCudaConstantVolumeSeriesSource.hcu
│ ├── rtkCudaConstantVolumeSource.h
│ ├── rtkCudaConstantVolumeSource.hcu
│ ├── rtkCudaCropImageFilter.h
│ ├── rtkCudaCropImageFilter.hcu
│ ├── rtkCudaCyclicDeformationImageFilter.h
│ ├── rtkCudaCyclicDeformationImageFilter.hcu
│ ├── rtkCudaDisplacedDetectorImageFilter.h
│ ├── rtkCudaDisplacedDetectorImageFilter.hcu
│ ├── rtkCudaFDKBackProjectionImageFilter.h
│ ├── rtkCudaFDKBackProjectionImageFilter.hcu
│ ├── rtkCudaFDKConeBeamReconstructionFilter.h
│ ├── rtkCudaFDKWeightProjectionFilter.h
│ ├── rtkCudaFDKWeightProjectionFilter.hcu
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.h
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.hcu
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.hxx
│ ├── rtkCudaFFTRampImageFilter.h
│ ├── rtkCudaFirstOrderKernels.hcu
│ ├── rtkCudaForwardProjectionImageFilter.h
│ ├── rtkCudaForwardProjectionImageFilter.hcu
│ ├── rtkCudaForwardProjectionImageFilter.hxx
│ ├── rtkCudaForwardWarpImageFilter.h
│ ├── rtkCudaForwardWarpImageFilter.hcu
│ ├── rtkCudaInterpolateImageFilter.h
│ ├── rtkCudaInterpolateImageFilter.hcu
│ ├── rtkCudaIntersectBox.hcu
│ ├── rtkCudaIterativeFDKConeBeamReconstructionFilter.h
│ ├── rtkCudaLagCorrectionImageFilter.h
│ ├── rtkCudaLagCorrectionImageFilter.hcu
│ ├── rtkCudaLaplacianImageFilter.h
│ ├── rtkCudaLaplacianImageFilter.hcu
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.h
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.hcu
│ ├── rtkCudaParkerShortScanImageFilter.h
│ ├── rtkCudaParkerShortScanImageFilter.hcu
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.h
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.hcu
│ ├── rtkCudaRayCastBackProjectionImageFilter.h
│ ├── rtkCudaRayCastBackProjectionImageFilter.hcu
│ ├── rtkCudaScatterGlareCorrectionImageFilter.h
│ ├── rtkCudaSplatImageFilter.h
│ ├── rtkCudaSplatImageFilter.hcu
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.h
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.hcu
│ ├── rtkCudaUtilities.hcu
│ ├── rtkCudaWarpBackProjectionImageFilter.h
│ ├── rtkCudaWarpBackProjectionImageFilter.hcu
│ ├── rtkCudaWarpForwardProjectionImageFilter.h
│ ├── rtkCudaWarpForwardProjectionImageFilter.hcu
│ ├── rtkCudaWarpImageFilter.h
│ ├── rtkCudaWarpImageFilter.hcu
│ ├── rtkCudaWeidingerForwardModelImageFilter.h
│ ├── rtkCudaWeidingerForwardModelImageFilter.hcu
│ ├── rtkCudaWeidingerForwardModelImageFilter.hxx
│ ├── rtkCyclicDeformationImageFilter.h
│ ├── rtkCyclicDeformationImageFilter.hxx
│ ├── rtkDCMImagXImageIO.h
│ ├── rtkDCMImagXImageIOFactory.h
│ ├── rtkDPExtractShroudSignalImageFilter.h
│ ├── rtkDPExtractShroudSignalImageFilter.hxx
│ ├── rtkDaubechiesWaveletsConvolutionImageFilter.h
│ ├── rtkDaubechiesWaveletsConvolutionImageFilter.hxx
│ ├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.h
│ ├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.hxx
│ ├── rtkDbf.h
│ ├── rtkDePierroRegularizationImageFilter.h
│ ├── rtkDePierroRegularizationImageFilter.hxx
│ ├── rtkDeconstructImageFilter.h
│ ├── rtkDeconstructImageFilter.hxx
│ ├── rtkDeconstructSoftThresholdReconstructImageFilter.h
│ ├── rtkDeconstructSoftThresholdReconstructImageFilter.hxx
│ ├── rtkDenoisingBPDQImageFilter.h
│ ├── rtkDenoisingBPDQImageFilter.hxx
│ ├── rtkDigisensGeometryReader.h
│ ├── rtkDigisensGeometryXMLFileReader.h
│ ├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.h
│ ├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.hxx
│ ├── rtkDisplacedDetectorImageFilter.h
│ ├── rtkDisplacedDetectorImageFilter.hxx
│ ├── rtkDivergenceOfGradientConjugateGradientOperator.h
│ ├── rtkDivergenceOfGradientConjugateGradientOperator.hxx
│ ├── rtkDownsampleImageFilter.h
│ ├── rtkDownsampleImageFilter.hxx
│ ├── rtkDrawBoxImageFilter.h
│ ├── rtkDrawBoxImageFilter.hxx
│ ├── rtkDrawConeImageFilter.h
│ ├── rtkDrawConeImageFilter.hxx
│ ├── rtkDrawConvexImageFilter.h
│ ├── rtkDrawConvexImageFilter.hxx
│ ├── rtkDrawCubeImageFilter.h
│ ├── rtkDrawCylinderImageFilter.h
│ ├── rtkDrawCylinderImageFilter.hxx
│ ├── rtkDrawEllipsoidImageFilter.h
│ ├── rtkDrawEllipsoidImageFilter.hxx
│ ├── rtkDrawGeometricPhantomImageFilter.h
│ ├── rtkDrawGeometricPhantomImageFilter.hxx
│ ├── rtkDrawQuadricImageFilter.h
│ ├── rtkDrawQuadricImageFilter.hxx
│ ├── rtkDrawSheppLoganFilter.h
│ ├── rtkDrawSheppLoganFilter.hxx
│ ├── rtkDualEnergyNegativeLogLikelihood.h
│ ├── rtkEdfImageIO.h
│ ├── rtkEdfImageIOFactory.h
│ ├── rtkEdfRawToAttenuationImageFilter.h
│ ├── rtkEdfRawToAttenuationImageFilter.hxx
│ ├── rtkElektaSynergyGeometryReader.h
│ ├── rtkElektaSynergyLookupTableImageFilter.h
│ ├── rtkElektaSynergyLookupTableImageFilter.hxx
│ ├── rtkElektaSynergyRawLookupTableImageFilter.h
│ ├── rtkElektaSynergyRawLookupTableImageFilter.hxx
│ ├── rtkElektaXVI5GeometryXMLFileReader.h
│ ├── rtkExtractPhaseImageFilter.h
│ ├── rtkExtractPhaseImageFilter.hxx
│ ├── rtkFDKBackProjectionImageFilter.h
│ ├── rtkFDKBackProjectionImageFilter.hxx
│ ├── rtkFDKConeBeamReconstructionFilter.h
│ ├── rtkFDKConeBeamReconstructionFilter.hxx
│ ├── rtkFDKVarianceReconstructionFilter.h
│ ├── rtkFDKVarianceReconstructionFilter.hxx
│ ├── rtkFDKWarpBackProjectionImageFilter.h
│ ├── rtkFDKWarpBackProjectionImageFilter.hxx
│ ├── rtkFDKWeightProjectionFilter.h
│ ├── rtkFDKWeightProjectionFilter.hxx
│ ├── rtkFFTHilbertImageFilter.h
│ ├── rtkFFTHilbertImageFilter.hxx
│ ├── rtkFFTProjectionsConvolutionImageFilter.h
│ ├── rtkFFTProjectionsConvolutionImageFilter.hxx
│ ├── rtkFFTRampImageFilter.h
│ ├── rtkFFTRampImageFilter.hxx
│ ├── rtkFFTVarianceRampImageFilter.h
│ ├── rtkFFTVarianceRampImageFilter.hxx
│ ├── rtkFieldOfViewImageFilter.h
│ ├── rtkFieldOfViewImageFilter.hxx
│ ├── rtkForbildPhantomFileReader.h
│ ├── rtkForwardDifferenceGradientImageFilter.h
│ ├── rtkForwardDifferenceGradientImageFilter.hxx
│ ├── rtkForwardProjectionImageFilter.h
│ ├── rtkForwardProjectionImageFilter.hxx
│ ├── rtkForwardWarpImageFilter.h
│ ├── rtkForwardWarpImageFilter.hxx
│ ├── rtkFourDConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkFourDConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkFourDROOSTERConeBeamReconstructionFilter.h
│ ├── rtkFourDROOSTERConeBeamReconstructionFilter.hxx
│ ├── rtkFourDReconstructionConjugateGradientOperator.h
│ ├── rtkFourDReconstructionConjugateGradientOperator.hxx
│ ├── rtkFourDSARTConeBeamReconstructionFilter.h
│ ├── rtkFourDSARTConeBeamReconstructionFilter.hxx
│ ├── rtkFourDToProjectionStackImageFilter.h
│ ├── rtkFourDToProjectionStackImageFilter.hxx
│ ├── rtkGeneralPurposeFunctions.h
│ ├── rtkGeometricPhantom.h
│ ├── rtkGetNewtonUpdateImageFilter.h
│ ├── rtkGetNewtonUpdateImageFilter.hxx
│ ├── rtkGgoArgsInfoManager.h
│ ├── rtkGgoFunctions.h
│ ├── rtkGlobalResourceProbe.h
│ ├── rtkHilbertImageFilter.h
│ ├── rtkHilbertImageFilter.hxx
│ ├── rtkHisImageIO.h
│ ├── rtkHisImageIOFactory.h
│ ├── rtkHncImageIO.h
│ ├── rtkHncImageIOFactory.h
│ ├── rtkHndImageIO.h
│ ├── rtkHndImageIOFactory.h
│ ├── rtkHomogeneousMatrix.h
│ ├── rtkI0EstimationProjectionFilter.h
│ ├── rtkI0EstimationProjectionFilter.hxx
│ ├── rtkIOFactories.h
│ ├── rtkImagXGeometryReader.h
│ ├── rtkImagXGeometryReader.hxx
│ ├── rtkImagXImageIO.h
│ ├── rtkImagXImageIOFactory.h
│ ├── rtkImagXXMLFileReader.h
│ ├── rtkImageToVectorImageFilter.h
│ ├── rtkImageToVectorImageFilter.hxx
│ ├── rtkImportImageFilter.h
│ ├── rtkImportImageFilter.hxx
│ ├── rtkInterpolatorWithKnownWeightsImageFilter.h
│ ├── rtkInterpolatorWithKnownWeightsImageFilter.hxx
│ ├── rtkIntersectionOfConvexShapes.h
│ ├── rtkIterationCommands.h
│ ├── rtkIterativeConeBeamReconstructionFilter.h
│ ├── rtkIterativeConeBeamReconstructionFilter.hxx
│ ├── rtkIterativeFDKConeBeamReconstructionFilter.h
│ ├── rtkIterativeFDKConeBeamReconstructionFilter.hxx
│ ├── rtkJosephBackAttenuatedProjectionImageFilter.h
│ ├── rtkJosephBackAttenuatedProjectionImageFilter.hxx
│ ├── rtkJosephBackProjectionImageFilter.h
│ ├── rtkJosephBackProjectionImageFilter.hxx
│ ├── rtkJosephForwardAttenuatedProjectionImageFilter.h
│ ├── rtkJosephForwardAttenuatedProjectionImageFilter.hxx
│ ├── rtkJosephForwardProjectionImageFilter.h
│ ├── rtkJosephForwardProjectionImageFilter.hxx
│ ├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.h
│ ├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.hxx
│ ├── rtkLagCorrectionImageFilter.h
│ ├── rtkLagCorrectionImageFilter.hxx
│ ├── rtkLaplacianImageFilter.h
│ ├── rtkLaplacianImageFilter.hxx
│ ├── rtkLastDimensionL0GradientDenoisingImageFilter.h
│ ├── rtkLastDimensionL0GradientDenoisingImageFilter.hxx
│ ├── rtkLookupTableImageFilter.h
│ ├── rtkLookupTableImageFilter.hxx
│ ├── rtkMacro.h
│ ├── rtkMagnitudeThresholdImageFilter.h
│ ├── rtkMagnitudeThresholdImageFilter.hxx
│ ├── rtkMaskCollimationImageFilter.h
│ ├── rtkMaskCollimationImageFilter.hxx
│ ├── rtkMaximumIntensityProjectionImageFilter.h
│ ├── rtkMechlemOneStepSpectralReconstructionFilter.h
│ ├── rtkMechlemOneStepSpectralReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.h
│ ├── rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.hxx
│ ├── rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.h
│ ├── rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.hxx
│ ├── rtkMultiplyByVectorImageFilter.h
│ ├── rtkMultiplyByVectorImageFilter.hxx
│ ├── rtkNesterovUpdateImageFilter.h
│ ├── rtkNesterovUpdateImageFilter.hxx
│ ├── rtkOSEMConeBeamReconstructionFilter.h
│ ├── rtkOSEMConeBeamReconstructionFilter.hxx
│ ├── rtkOraGeometryReader.h
│ ├── rtkOraImageIO.h
│ ├── rtkOraImageIOFactory.h
│ ├── rtkOraLookupTableImageFilter.h
│ ├── rtkOraLookupTableImageFilter.hxx
│ ├── rtkOraXMLFileReader.h
│ ├── rtkParkerShortScanImageFilter.h
│ ├── rtkParkerShortScanImageFilter.hxx
│ ├── rtkPhaseGatingImageFilter.h
│ ├── rtkPhaseGatingImageFilter.hxx
│ ├── rtkPhaseReader.h
│ ├── rtkPhasesToInterpolationWeights.h
│ ├── rtkPolynomialGainCorrectionImageFilter.h
│ ├── rtkPolynomialGainCorrectionImageFilter.hxx
│ ├── rtkProgressCommands.h
│ ├── rtkProjectGeometricPhantomImageFilter.h
│ ├── rtkProjectGeometricPhantomImageFilter.hxx
│ ├── rtkProjectionGeometry.h
│ ├── rtkProjectionGeometry.hxx
│ ├── rtkProjectionStackToFourDImageFilter.h
│ ├── rtkProjectionStackToFourDImageFilter.hxx
│ ├── rtkProjectionsDecompositionNegativeLogLikelihood.h
│ ├── rtkProjectionsReader.h
│ ├── rtkProjectionsReader.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBased.h
│ ├── rtkProjectionsRegionConstIteratorRayBased.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedParallel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedParallel.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithCylindricalPanel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithCylindricalPanel.hxx
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.h
│ ├── rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.hxx
│ ├── rtkQuadricShape.h
│ ├── rtkRayBoxIntersectionImageFilter.h
│ ├── rtkRayBoxIntersectionImageFilter.hxx
│ ├── rtkRayConvexIntersectionImageFilter.h
│ ├── rtkRayConvexIntersectionImageFilter.hxx
│ ├── rtkRayEllipsoidIntersectionImageFilter.h
│ ├── rtkRayEllipsoidIntersectionImageFilter.hxx
│ ├── rtkRayQuadricIntersectionImageFilter.h
│ ├── rtkRayQuadricIntersectionImageFilter.hxx
│ ├── rtkReconstructImageFilter.h
│ ├── rtkReconstructImageFilter.hxx
│ ├── rtkReconstructionConjugateGradientOperator.h
│ ├── rtkReconstructionConjugateGradientOperator.hxx
│ ├── rtkReg1DExtractShroudSignalImageFilter.h
│ ├── rtkReg1DExtractShroudSignalImageFilter.hxx
│ ├── rtkReg23ProjectionGeometry.h
│ ├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.h
│ ├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.hxx
│ ├── rtkReorderProjectionsImageFilter.h
│ ├── rtkReorderProjectionsImageFilter.hxx
│ ├── rtkResourceProbesCollector.h
│ ├── rtkSARTConeBeamReconstructionFilter.h
│ ├── rtkSARTConeBeamReconstructionFilter.hxx
│ ├── rtkScatterGlareCorrectionImageFilter.h
│ ├── rtkScatterGlareCorrectionImageFilter.hxx
│ ├── rtkSchlomka2008NegativeLogLikelihood.h
│ ├── rtkSelectOneProjectionPerCycleImageFilter.h
│ ├── rtkSelectOneProjectionPerCycleImageFilter.hxx
│ ├── rtkSeparableQuadraticSurrogateRegularizationImageFilter.h
│ ├── rtkSeparableQuadraticSurrogateRegularizationImageFilter.hxx
│ ├── rtkSheppLoganPhantom.h
│ ├── rtkSheppLoganPhantomFilter.h
│ ├── rtkSheppLoganPhantomFilter.hxx
│ ├── rtkSignalToInterpolationWeights.h
│ ├── rtkSimplexSpectralProjectionsDecompositionImageFilter.h
│ ├── rtkSimplexSpectralProjectionsDecompositionImageFilter.hxx
│ ├── rtkSingularValueThresholdImageFilter.h
│ ├── rtkSingularValueThresholdImageFilter.hxx
│ ├── rtkSoftThresholdImageFilter.h
│ ├── rtkSoftThresholdImageFilter.hxx
│ ├── rtkSoftThresholdTVImageFilter.h
│ ├── rtkSoftThresholdTVImageFilter.hxx
│ ├── rtkSpectralForwardModelImageFilter.h
│ ├── rtkSpectralForwardModelImageFilter.hxx
│ ├── rtkSplatWithKnownWeightsImageFilter.h
│ ├── rtkSplatWithKnownWeightsImageFilter.hxx
│ ├── rtkSubSelectFromListImageFilter.h
│ ├── rtkSubSelectFromListImageFilter.hxx
│ ├── rtkSubSelectImageFilter.h
│ ├── rtkSubSelectImageFilter.hxx
│ ├── rtkSumOfSquaresImageFilter.h
│ ├── rtkSumOfSquaresImageFilter.hxx
│ ├── rtkThreeDCircularProjectionGeometry.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFile.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFileReader.h
│ ├── rtkThreeDCircularProjectionGeometryXMLFileWriter.h
│ ├── rtkTotalNuclearVariationDenoisingBPDQImageFilter.h
│ ├── rtkTotalNuclearVariationDenoisingBPDQImageFilter.hxx
│ ├── rtkTotalVariationDenoiseSequenceImageFilter.h
│ ├── rtkTotalVariationDenoiseSequenceImageFilter.hxx
│ ├── rtkTotalVariationDenoisingBPDQImageFilter.h
│ ├── rtkTotalVariationDenoisingBPDQImageFilter.hxx
│ ├── rtkTotalVariationImageFilter.h
│ ├── rtkTotalVariationImageFilter.hxx
│ ├── rtkUnwarpSequenceConjugateGradientOperator.h
│ ├── rtkUnwarpSequenceConjugateGradientOperator.hxx
│ ├── rtkUnwarpSequenceImageFilter.h
│ ├── rtkUnwarpSequenceImageFilter.hxx
│ ├── rtkUpsampleImageFilter.h
│ ├── rtkUpsampleImageFilter.hxx
│ ├── rtkVarianObiGeometryReader.h
│ ├── rtkVarianObiRawImageFilter.h
│ ├── rtkVarianObiRawImageFilter.hxx
│ ├── rtkVarianObiXMLFileReader.h
│ ├── rtkVarianProBeamGeometryReader.h
│ ├── rtkVarianProBeamXMLFileReader.h
│ ├── rtkVectorImageToImageFilter.h
│ ├── rtkVectorImageToImageFilter.hxx
│ ├── rtkWarpFourDToProjectionStackImageFilter.h
│ ├── rtkWarpFourDToProjectionStackImageFilter.hxx
│ ├── rtkWarpProjectionStackToFourDImageFilter.h
│ ├── rtkWarpProjectionStackToFourDImageFilter.hxx
│ ├── rtkWarpSequenceImageFilter.h
│ ├── rtkWarpSequenceImageFilter.hxx
│ ├── rtkWatcherForResourceProbe.h
│ ├── rtkWaterPrecorrectionImageFilter.h
│ ├── rtkWaterPrecorrectionImageFilter.hxx
│ ├── rtkWeidingerForwardModelImageFilter.h
│ ├── rtkWeidingerForwardModelImageFilter.hxx
│ ├── rtkXRadGeometryReader.h
│ ├── rtkXRadImageIO.h
│ ├── rtkXRadImageIOFactory.h
│ ├── rtkXRadRawToAttenuationImageFilter.h
│ ├── rtkXRadRawToAttenuationImageFilter.hxx
│ ├── rtkXimImageIO.h
│ ├── rtkXimImageIOFactory.h
│ ├── rtkZengBackProjectionImageFilter.h
│ ├── rtkZengBackProjectionImageFilter.hxx
│ ├── rtkZengForwardProjectionImageFilter.h
│ └── rtkZengForwardProjectionImageFilter.hxx
├── index.md
├── itk-module-init.cmake
├── itk-module.cmake
├── pyproject.toml
├── rtkConfiguration.h.in
├── src/
│ ├── CMakeLists.txt
│ ├── rtkBioscanGeometryReader.cxx
│ ├── rtkBoxShape.cxx
│ ├── rtkConditionalMedianImageFilter.cxx
│ ├── rtkConvexShape.cxx
│ ├── rtkCudaAverageOutOfROIImageFilter.cu
│ ├── rtkCudaAverageOutOfROIImageFilter.cxx
│ ├── rtkCudaBackProjectionImageFilter.cu
│ ├── rtkCudaConjugateGradientImageFilter.cu
│ ├── rtkCudaConstantVolumeSeriesSource.cu
│ ├── rtkCudaConstantVolumeSeriesSource.cxx
│ ├── rtkCudaConstantVolumeSource.cu
│ ├── rtkCudaConstantVolumeSource.cxx
│ ├── rtkCudaCropImageFilter.cu
│ ├── rtkCudaCropImageFilter.cxx
│ ├── rtkCudaCyclicDeformationImageFilter.cu
│ ├── rtkCudaCyclicDeformationImageFilter.cxx
│ ├── rtkCudaDisplacedDetectorImageFilter.cu
│ ├── rtkCudaDisplacedDetectorImageFilter.cxx
│ ├── rtkCudaFDKBackProjectionImageFilter.cu
│ ├── rtkCudaFDKBackProjectionImageFilter.cxx
│ ├── rtkCudaFDKConeBeamReconstructionFilter.cxx
│ ├── rtkCudaFDKWeightProjectionFilter.cu
│ ├── rtkCudaFDKWeightProjectionFilter.cxx
│ ├── rtkCudaFFTProjectionsConvolutionImageFilter.cu
│ ├── rtkCudaFirstOrderKernels.cu
│ ├── rtkCudaForwardProjectionImageFilter.cu
│ ├── rtkCudaForwardWarpImageFilter.cu
│ ├── rtkCudaForwardWarpImageFilter.cxx
│ ├── rtkCudaInterpolateImageFilter.cu
│ ├── rtkCudaInterpolateImageFilter.cxx
│ ├── rtkCudaIterativeFDKConeBeamReconstructionFilter.cxx
│ ├── rtkCudaLagCorrectionImageFilter.cu
│ ├── rtkCudaLagCorrectionImageFilter.cxx
│ ├── rtkCudaLaplacianImageFilter.cu
│ ├── rtkCudaLaplacianImageFilter.cxx
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.cu
│ ├── rtkCudaLastDimensionTVDenoisingImageFilter.cxx
│ ├── rtkCudaParkerShortScanImageFilter.cu
│ ├── rtkCudaParkerShortScanImageFilter.cxx
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.cu
│ ├── rtkCudaPolynomialGainCorrectionImageFilter.cxx
│ ├── rtkCudaRayCastBackProjectionImageFilter.cu
│ ├── rtkCudaRayCastBackProjectionImageFilter.cxx
│ ├── rtkCudaSplatImageFilter.cu
│ ├── rtkCudaSplatImageFilter.cxx
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.cu
│ ├── rtkCudaTotalVariationDenoisingBPDQImageFilter.cxx
│ ├── rtkCudaUtilities.cu
│ ├── rtkCudaWarpBackProjectionImageFilter.cu
│ ├── rtkCudaWarpBackProjectionImageFilter.cxx
│ ├── rtkCudaWarpForwardProjectionImageFilter.cu
│ ├── rtkCudaWarpForwardProjectionImageFilter.cxx
│ ├── rtkCudaWarpImageFilter.cu
│ ├── rtkCudaWarpImageFilter.cxx
│ ├── rtkCudaWeidingerForwardModelImageFilter.cu
│ ├── rtkDCMImagXImageIO.cxx
│ ├── rtkDCMImagXImageIOFactory.cxx
│ ├── rtkDbf.cxx
│ ├── rtkDigisensGeometryReader.cxx
│ ├── rtkDigisensGeometryXMLFileReader.cxx
│ ├── rtkEdfImageIO.cxx
│ ├── rtkEdfImageIOFactory.cxx
│ ├── rtkElektaSynergyGeometryReader.cxx
│ ├── rtkElektaXVI5GeometryXMLFileReader.cxx
│ ├── rtkForbildPhantomFileReader.cxx
│ ├── rtkGeometricPhantom.cxx
│ ├── rtkGlobalResourceProbe.cxx
│ ├── rtkHisImageIO.cxx
│ ├── rtkHisImageIOFactory.cxx
│ ├── rtkHncImageIO.cxx
│ ├── rtkHncImageIOFactory.cxx
│ ├── rtkHndImageIO.cxx
│ ├── rtkHndImageIOFactory.cxx
│ ├── rtkIOFactories.cxx
│ ├── rtkImagXImageIO.cxx
│ ├── rtkImagXImageIOFactory.cxx
│ ├── rtkImagXXMLFileReader.cxx
│ ├── rtkIntersectionOfConvexShapes.cxx
│ ├── rtkOraGeometryReader.cxx
│ ├── rtkOraImageIO.cxx
│ ├── rtkOraImageIOFactory.cxx
│ ├── rtkOraXMLFileReader.cxx
│ ├── rtkPhaseReader.cxx
│ ├── rtkPhasesToInterpolationWeights.cxx
│ ├── rtkQuadricShape.cxx
│ ├── rtkReg23ProjectionGeometry.cxx
│ ├── rtkResourceProbesCollector.cxx
│ ├── rtkSheppLoganPhantom.cxx
│ ├── rtkSignalToInterpolationWeights.cxx
│ ├── rtkThreeDCircularProjectionGeometry.cxx
│ ├── rtkThreeDCircularProjectionGeometryXMLFileReader.cxx
│ ├── rtkThreeDCircularProjectionGeometryXMLFileWriter.cxx
│ ├── rtkVarianObiGeometryReader.cxx
│ ├── rtkVarianObiXMLFileReader.cxx
│ ├── rtkVarianProBeamGeometryReader.cxx
│ ├── rtkVarianProBeamXMLFileReader.cxx
│ ├── rtkWatcherForResourceProbe.cxx
│ ├── rtkXRadGeometryReader.cxx
│ ├── rtkXRadImageIO.cxx
│ ├── rtkXRadImageIOFactory.cxx
│ ├── rtkXimImageIO.cxx
│ └── rtkXimImageIOFactory.cxx
├── test/
│ ├── Baseline/
│ │ ├── AmsterdamShroud/
│ │ │ ├── Amsterdam.mha.sha512
│ │ │ └── Amsterdam_crop.mha.sha512
│ │ ├── Bioscan/
│ │ │ └── geometry.xml.sha512
│ │ ├── Digisens/
│ │ │ ├── attenuation.mha.sha512
│ │ │ └── geometry.xml.sha512
│ │ ├── ESRF/
│ │ │ └── attenuation.mha.sha512
│ │ ├── Elekta/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ └── geometry5.xml.sha512
│ │ ├── ImagX/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── attenuationDCM.mha.sha512
│ │ │ └── geo.xml.sha512
│ │ ├── Laplacian/
│ │ │ └── Laplacian.mha.sha512
│ │ ├── Ora/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ ├── geometry_optitrack.xml.sha512
│ │ │ └── geometry_yawtilt.xml.sha512
│ │ ├── Spectral/
│ │ │ └── OneStep/
│ │ │ ├── newtonUpdate.mha.sha512
│ │ │ ├── out1.mha.sha512
│ │ │ └── out2.mha.sha512
│ │ ├── Varian/
│ │ │ ├── attenuation.mha.sha512
│ │ │ ├── attenuationHnc.mha.sha512
│ │ │ ├── attenuationProBeam.mha.sha512
│ │ │ ├── geometry.xml.sha512
│ │ │ ├── geometryHnc.xml.sha512
│ │ │ └── geometryProBeam.xml.sha512
│ │ └── XRad/
│ │ ├── attenuation.mha.sha512
│ │ └── geometry.xml.sha512
│ ├── CMakeLists.txt
│ ├── Input/
│ │ ├── Bioscan/
│ │ │ └── bioscan.dcm.sha512
│ │ ├── Digisens/
│ │ │ ├── calibration.cal.sha512
│ │ │ └── ima0010.tif.sha512
│ │ ├── ESRF/
│ │ │ ├── dark.edf.sha512
│ │ │ ├── raw.edf.sha512
│ │ │ └── refHST0000.edf.sha512
│ │ ├── Elekta/
│ │ │ ├── FRAME.DBF.sha512
│ │ │ ├── IMAGE.DBF.sha512
│ │ │ ├── _Frames.xml.sha512
│ │ │ └── raw.his.sha512
│ │ ├── Forbild/
│ │ │ └── Thorax.sha512
│ │ ├── GeometricPhantom/
│ │ │ ├── Geometries.txt.sha512
│ │ │ ├── Geometries_Forbild.txt.sha512
│ │ │ ├── SheppLogan.txt.sha512
│ │ │ └── SheppLogan_forbild.txt.sha512
│ │ ├── ImagX/
│ │ │ ├── 1.dcm.sha512
│ │ │ ├── calibration.xml.sha512
│ │ │ ├── raw.raw.sha512
│ │ │ ├── raw.xml.sha512
│ │ │ └── room.xml.sha512
│ │ ├── Ora/
│ │ │ ├── 084183_20211217170607335.mhd.sha512
│ │ │ ├── 084183_20211217170607335.ora.xml.sha512
│ │ │ ├── 0_afterLog.mhd.sha512
│ │ │ ├── 0_afterLog.ora.xml.sha512
│ │ │ ├── 0_afterLog.raw.sha512
│ │ │ ├── 2006137_20220918183246810.mhd.sha512
│ │ │ └── 2006137_20220918183246810.ora.xml.sha512
│ │ ├── Phases/
│ │ │ ├── phases.txt.sha512
│ │ │ ├── phases_3projs.txt.sha512
│ │ │ └── phases_slow.txt.sha512
│ │ ├── Spectral/
│ │ │ ├── OneStep/
│ │ │ │ ├── binnedDetectorResponse.csv.sha512
│ │ │ │ ├── gradient.mha.sha512
│ │ │ │ ├── hessian.mha.sha512
│ │ │ │ ├── incident_spectrum_64_rows.mha.sha512
│ │ │ │ ├── materialAttenuations.csv.sha512
│ │ │ │ ├── materialProjections.mha.sha512
│ │ │ │ ├── no_vector_incident_spectrum_64_rows.mha.sha512
│ │ │ │ ├── photonCounts.mha.sha512
│ │ │ │ ├── projOfOnes.mha.sha512
│ │ │ │ └── spectrum.mha.sha512
│ │ │ ├── detector_response.mha.sha512
│ │ │ ├── incident_spectrum.mha.sha512
│ │ │ ├── material_attenuations.mha.sha512
│ │ │ └── no_vector_incident_spectrum.mha.sha512
│ │ ├── Varian/
│ │ │ ├── Proj_00000.xim.sha512
│ │ │ ├── acqui.xml.sha512
│ │ │ ├── acqui_probeam.xml.sha512
│ │ │ ├── image_00052.hnc.sha512
│ │ │ └── raw.hnd.sha512
│ │ └── XRad/
│ │ ├── SolidWater_HiGain1x1.header.sha512
│ │ ├── SolidWater_HiGain1x1_firstProj.header.sha512
│ │ ├── SolidWater_HiGain1x1_firstProj.img.sha512
│ │ ├── dark.header.sha512
│ │ ├── dark.img.sha512
│ │ ├── flat.header.sha512
│ │ └── flat.img.sha512
│ ├── rtkI0estimationtest.cxx
│ ├── rtkMaximumIntensity.py
│ ├── rtkOutputArgumentWrapping.py
│ ├── rtkTest.h
│ ├── rtkTestConfiguration.h.in
│ ├── rtkTestReg23ProjectionGeometry.cxx
│ ├── rtkadjointoperatorstest.cxx
│ ├── rtkadmmtotalvariationtest.cxx
│ ├── rtkadmmwaveletstest.cxx
│ ├── rtkamsterdamshroudtest.cxx
│ ├── rtkapplicationtest.py
│ ├── rtkargsinfomanagertest.cxx
│ ├── rtkbinningtest.cxx
│ ├── rtkbioscantest.cxx
│ ├── rtkconjugategradientreconstructiontest.cxx
│ ├── rtkconjugategradienttest.cxx
│ ├── rtkcroptest.cxx
│ ├── rtkcudaraycastadjointoperatorstest.cxx
│ ├── rtkcyclicdeformationtest.cxx
│ ├── rtkcylindricaldetectorreconstructiontest.cxx
│ ├── rtkdecomposespectralprojectionstest.cxx
│ ├── rtkdigisenstest.cxx
│ ├── rtkdisplaceddetectorcompcudatest.cxx
│ ├── rtkdisplaceddetectorcompoffsettest.cxx
│ ├── rtkdisplaceddetectortest.cxx
│ ├── rtkdivergencetest.cxx
│ ├── rtkdrawgeometricphantomtest.cxx
│ ├── rtkedftest.cxx
│ ├── rtkelektatest.cxx
│ ├── rtkfbpparalleltest.cxx
│ ├── rtkfdkprojweightcompcudatest.cxx
│ ├── rtkfdktest.cxx
│ ├── rtkforbildtest.cxx
│ ├── rtkforwardattenuatedprojectiontest.cxx
│ ├── rtkforwardprojectiontest.cxx
│ ├── rtkfourdadjointoperatorstest.cxx
│ ├── rtkfourdconjugategradienttest.cxx
│ ├── rtkfourdroostertest.cxx
│ ├── rtkfourdsarttest.cxx
│ ├── rtkfovtest.cxx
│ ├── rtkgaincorrectiontest.cxx
│ ├── rtkgeometryclonetest.cxx
│ ├── rtkgeometryfiletest.cxx
│ ├── rtkgeometryfrommatrixtest.cxx
│ ├── rtkgradienttest.cxx
│ ├── rtkheadertestfooter.cxx
│ ├── rtkhilbertfiltertest.cxx
│ ├── rtkimagxtest.cxx
│ ├── rtkimporttest.cxx
│ ├── rtkinterpolatesplatadjointtest.cxx
│ ├── rtkiterativefdktest.cxx
│ ├── rtkl0gradientnormtest.cxx
│ ├── rtklagcorrectiontest.cxx
│ ├── rtklaplaciantest.cxx
│ ├── rtklutbasedvarI0rawtoatttest.cxx
│ ├── rtkluttest.cxx
│ ├── rtkmaximumintensityprojectiontest.cxx
│ ├── rtkmotioncompensatedfdktest.cxx
│ ├── rtknewtonupdatetest.cxx
│ ├── rtkoratest.cxx
│ ├── rtkosemtest.cxx
│ ├── rtkparallelgeometryfrommatrixtest.cxx
│ ├── rtkprojectgeometricphantomtest.cxx
│ ├── rtkrampfiltertest.cxx
│ ├── rtkrampfiltertest2.cxx
│ ├── rtkregularizedconjugategradienttest.cxx
│ ├── rtksarttest.cxx
│ ├── rtkscatterglarefiltertest.cxx
│ ├── rtkselectoneprojpercycletest.cxx
│ ├── rtkshortscancompcudatest.cxx
│ ├── rtkshortscantest.cxx
│ ├── rtkspectralonesteptest.cxx
│ ├── rtktestexamples.py
│ ├── rtktotalvariationtest.cxx
│ ├── rtkvariancereconstructiontest.cxx
│ ├── rtkvariantest.cxx
│ ├── rtkvectorimageconverterstest.cxx
│ ├── rtkwarpfourdtoprojectionstacktest.cxx
│ ├── rtkwarpprojectionstacktofourdtest.cxx
│ ├── rtkwarptest.cxx
│ ├── rtkwaterprecorrectiontest.cxx
│ ├── rtkwaveletstest.cxx
│ ├── rtkweidingerforwardmodeltest.cxx
│ ├── rtkxradtest.cxx
│ └── rtkzengforwardprojectiontest.cxx
├── utilities/
│ ├── SetupForDevelopment.sh
│ ├── UploadTestData.py
│ ├── clang-format.bash
│ ├── gengetopt/
│ │ ├── CMakeLists.txt
│ │ ├── Makefile.am
│ │ ├── acceptedvalues.cpp
│ │ ├── acceptedvalues.h
│ │ ├── argsdef.c
│ │ ├── argsdef.h
│ │ ├── cmdline.c
│ │ ├── cmdline.ggo
│ │ ├── cmdline.h
│ │ ├── errorcodes.h
│ │ ├── fileutils.cpp
│ │ ├── fileutils.h
│ │ ├── gengetopt.cc
│ │ ├── gengetopt.h
│ │ ├── getopt.c
│ │ ├── getopt.h
│ │ ├── getopt1.c
│ │ ├── ggo_options.h
│ │ ├── ggos.cpp
│ │ ├── ggos.h
│ │ ├── global_opts.h
│ │ ├── globals.cpp
│ │ ├── globals.h
│ │ ├── gm.cc
│ │ ├── gm.h
│ │ ├── gm_utils.cpp
│ │ ├── gm_utils.h
│ │ ├── groups.h
│ │ ├── my_map.h
│ │ ├── my_sstream.h
│ │ ├── my_string.h
│ │ ├── parser.cc
│ │ ├── parser.h
│ │ ├── parser.yy
│ │ ├── scanner.cc
│ │ ├── skels/
│ │ │ ├── Makefile.am
│ │ │ ├── c_source.cc
│ │ │ ├── c_source.h
│ │ │ ├── check_modes.cc
│ │ │ ├── check_modes.h
│ │ │ ├── clear_arg.cc
│ │ │ ├── clear_arg.h
│ │ │ ├── clear_given.cc
│ │ │ ├── clear_given.h
│ │ │ ├── copyright.cc
│ │ │ ├── copyright.h
│ │ │ ├── custom_getopt_gen.cc
│ │ │ ├── custom_getopt_gen.h
│ │ │ ├── dependant_option.cc
│ │ │ ├── dependant_option.h
│ │ │ ├── enum_decl.cc
│ │ │ ├── enum_decl.h
│ │ │ ├── exit_failure.cc
│ │ │ ├── exit_failure.h
│ │ │ ├── file_save.cc
│ │ │ ├── file_save.h
│ │ │ ├── file_save_multiple.cc
│ │ │ ├── file_save_multiple.h
│ │ │ ├── free_list.cc
│ │ │ ├── free_list.h
│ │ │ ├── free_multiple.cc
│ │ │ ├── free_multiple.h
│ │ │ ├── free_string.cc
│ │ │ ├── free_string.h
│ │ │ ├── generic_option.cc
│ │ │ ├── generic_option.h
│ │ │ ├── given_field.cc
│ │ │ ├── given_field.h
│ │ │ ├── group_counter.cc
│ │ │ ├── group_counter.h
│ │ │ ├── group_option.cc
│ │ │ ├── group_option.h
│ │ │ ├── handle_help.cc
│ │ │ ├── handle_help.h
│ │ │ ├── handle_version.cc
│ │ │ ├── handle_version.h
│ │ │ ├── header.cc
│ │ │ ├── header.h
│ │ │ ├── init_args_info.cc
│ │ │ ├── init_args_info.h
│ │ │ ├── multiple_fill_array.cc
│ │ │ ├── multiple_fill_array.h
│ │ │ ├── multiple_opt_list.cc
│ │ │ ├── multiple_opt_list.h
│ │ │ ├── option_arg.cc
│ │ │ ├── option_arg.h
│ │ │ ├── print_help_string.cc
│ │ │ ├── print_help_string.h
│ │ │ ├── required_option.cc
│ │ │ ├── required_option.h
│ │ │ ├── reset_group.cc
│ │ │ ├── reset_group.h
│ │ │ ├── update_given.cc
│ │ │ └── update_given.h
│ │ ├── yyerror.cc
│ │ ├── yyerror.h
│ │ └── yywrap.c
│ └── lp_solve/
│ ├── CMakeLists.txt
│ ├── README.txt
│ ├── bfp/
│ │ ├── bfp_LUSOL/
│ │ │ ├── LUSOL/
│ │ │ │ ├── LUSOL_LGPL.txt
│ │ │ │ ├── LUSOL_Overview.txt
│ │ │ │ ├── LUSOL_README.txt
│ │ │ │ ├── lusol.c
│ │ │ │ ├── lusol.h
│ │ │ │ ├── lusol1.c
│ │ │ │ ├── lusol2.c
│ │ │ │ ├── lusol6a.c
│ │ │ │ ├── lusol6l0.c
│ │ │ │ ├── lusol6u.c
│ │ │ │ ├── lusol7a.c
│ │ │ │ └── lusol8a.c
│ │ │ ├── lp_LUSOL.c
│ │ │ └── lp_LUSOL.h
│ │ ├── lp_BFP.h
│ │ ├── lp_BFP1.c
│ │ └── lp_BFP2.c
│ ├── colamd/
│ │ ├── colamd.c
│ │ └── colamd.h
│ ├── fortify.c
│ ├── ini.c
│ ├── ini.h
│ ├── lp_Hash.c
│ ├── lp_Hash.h
│ ├── lp_MDO.c
│ ├── lp_MDO.h
│ ├── lp_MPS.c
│ ├── lp_MPS.h
│ ├── lp_SOS.c
│ ├── lp_SOS.h
│ ├── lp_bit.h
│ ├── lp_crash.c
│ ├── lp_crash.h
│ ├── lp_explicit.h
│ ├── lp_fortify.h
│ ├── lp_lib.c
│ ├── lp_lib.h
│ ├── lp_matrix.c
│ ├── lp_matrix.h
│ ├── lp_mipbb.c
│ ├── lp_mipbb.h
│ ├── lp_params.c
│ ├── lp_presolve.c
│ ├── lp_presolve.h
│ ├── lp_price.c
│ ├── lp_price.h
│ ├── lp_pricePSE.c
│ ├── lp_pricePSE.h
│ ├── lp_report.c
│ ├── lp_report.h
│ ├── lp_rlp.c
│ ├── lp_rlp.h
│ ├── lp_scale.c
│ ├── lp_scale.h
│ ├── lp_simplex.c
│ ├── lp_simplex.h
│ ├── lp_solveDLL.h
│ ├── lp_types.h
│ ├── lp_utils.c
│ ├── lp_utils.h
│ ├── lp_wlp.c
│ ├── lp_wlp.h
│ ├── lpkit.h
│ ├── shared/
│ │ ├── commonlib.c
│ │ ├── commonlib.h
│ │ ├── mmio.c
│ │ ├── mmio.h
│ │ ├── myblas.c
│ │ └── myblas.h
│ ├── yacc_read.c
│ └── yacc_read.h
└── wrapping/
├── CMakeLists.txt
├── ConvexShape.i
├── FieldOfViewImageFilter.i
├── __init_rtk__.py
├── itkContinuousIndexRTK.wrap
├── itkCovariantVectorRTK.wrap
├── itkCudaImageDataManagerRTK.wrap
├── itkCudaImageRTK.wrap
├── itkCudaImageToImageFilterRTK.wrap
├── itkCudaInPlaceImageFilterRTK.wrap
├── itkFixedArrayRTK.wrap
├── itkImageBaseRTK.wrap
├── itkImageDuplicatorRTK.wrap
├── itkImageFileReaderRTK.wrap
├── itkImageFileWriterRTK.wrap
├── itkImageRTK.wrap
├── itkImageRegionRTK.wrap
├── itkImageSourceRTK.wrap
├── itkImageToImageFilterRTK.wrap
├── itkInPlaceImageFilterRTK.wrap
├── itkMatrixRTK.wrap
├── itkPointRTK.wrap
├── itkPyBufferRTK.wrap
├── itkVariableLengthVectorRTK.wrap
├── itkVectorImageRTK.wrap
├── itkVectorRTK.wrap
├── itkWarpImageFilterRTK.wrap
├── rtkADMMTotalVariationConeBeamReconstructionFilter.wrap
├── rtkADMMWaveletsConeBeamReconstructionFilter.wrap
├── rtkAmsterdamShroudImageFilter.wrap
├── rtkBackProjectionImageFilter.wrap
├── rtkBioscanGeometryReader.wrap
├── rtkBoellaardScatterCorrectionImageFilter.wrap
├── rtkBoxShape.wrap
├── rtkConditionalMedianImageFilter.wrap
├── rtkConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkConstantImageSource.wrap
├── rtkConvexShape.wrap
├── rtkCudaBackProjectionImageFilter.wrap
├── rtkCudaConstantVolumeSource.wrap
├── rtkCudaDisplacedDetectorImageFilter.wrap
├── rtkCudaFDKBackProjectionImageFilter.wrap
├── rtkCudaFDKConeBeamReconstructionFilter.wrap
├── rtkCudaFFTProjectionsConvolutionImageFilter.wrap
├── rtkCudaFFTRampImageFilter.wrap
├── rtkCudaForwardProjectionImageFilter.wrap
├── rtkCudaIterativeFDKConeBeamReconstructionFilter.wrap
├── rtkCudaParkerShortScanImageFilter.wrap
├── rtkCudaRayCastBackProjectionImageFilter.wrap
├── rtkCudaScatterGlareCorrectionImageFilter.wrap
├── rtkCudaSplatImageFilter.wrap
├── rtkCudaWarpForwardProjectionImageFilter.wrap
├── rtkCyclicDeformationImageFilter.wrap
├── rtkDCMImagXImageIO.wrap
├── rtkDPExtractShroudSignalImageFilter.notwrap
├── rtkDaubechiesWaveletsDenoiseSequenceImageFilter.wrap
├── rtkDeconstructSoftThresholdReconstructImageFilter.wrap
├── rtkDenoisingBPDQImageFilter.wrap
├── rtkDigisensGeometryReader.wrap
├── rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.wrap
├── rtkDisplacedDetectorImageFilter.wrap
├── rtkDrawConvexImageFilter.wrap
├── rtkDrawEllipsoidImageFilter.wrap
├── rtkDrawGeometricPhantomImageFilter.wrap
├── rtkDrawQuadricImageFilter.wrap
├── rtkDrawSheppLoganFilter.wrap
├── rtkEdfImageIO.wrap
├── rtkEdfRawToAttenuationImageFilter.wrap
├── rtkElektaSynergyGeometryReader.wrap
├── rtkElektaSynergyRawLookupTableImageFilter.wrap
├── rtkElektaXVI5GeometryXMLFileReader.wrap
├── rtkExtractPhaseImageFilter.wrap
├── rtkExtras.py
├── rtkFDKBackProjectionImageFilter.wrap
├── rtkFDKConeBeamReconstructionFilter.wrap
├── rtkFDKVarianceReconstructionFilter.wrap
├── rtkFDKWarpBackProjectionImageFilter.wrap
├── rtkFDKWeightProjectionFilter.wrap
├── rtkFFTHilbertImageFilter.wrap
├── rtkFFTProjectionsConvolutionImageFilter.wrap
├── rtkFFTRampImageFilter.wrap
├── rtkFFTVarianceRampImageFilter.wrap
├── rtkFieldOfViewImageFilter.wrap
├── rtkForwardProjectionImageFilter.wrap
├── rtkForwardWarpImageFilter.wrap
├── rtkFourDConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkFourDROOSTERConeBeamReconstructionFilter.wrap
├── rtkFourDSARTConeBeamReconstructionFilter.wrap
├── rtkFourDToProjectionStackImageFilter.wrap
├── rtkGeometricPhantom.wrap
├── rtkGlobalResourceProbe.wrap
├── rtkHilbertImageFilter.notwrap
├── rtkHisImageIO.wrap
├── rtkHncImageIO.wrap
├── rtkHndImageIO.wrap
├── rtkI0EstimationProjectionFilter.wrap
├── rtkImagXImageIO.wrap
├── rtkImageToVectorImageFilter.wrap
├── rtkIntersectionOfConvexShapes.wrap
├── rtkIterativeConeBeamReconstructionFilter.wrap
├── rtkIterativeFDKConeBeamReconstructionFilter.wrap
├── rtkJosephBackAttenuatedProjectionImageFilter.wrap
├── rtkJosephBackProjectionImageFilter.wrap
├── rtkJosephForwardAttenuatedProjectionImageFilter.wrap
├── rtkJosephForwardProjectionImageFilter.wrap
├── rtkLUTbasedVariableI0RawToAttenuationImageFilter.wrap
├── rtkLagCorrectionImageFilter.wrap
├── rtkLastDimensionL0GradientDenoisingImageFilter.wrap
├── rtkLookupTableImageFilter.wrap
├── rtkMaskCollimationImageFilter.wrap
├── rtkMaximumIntensityProjectionImageFilter.wrap
├── rtkMechlemOneStepSpectralReconstructionFilter.wrap
├── rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkOSEMConeBeamReconstructionFilter.wrap
├── rtkOraGeometryReader.wrap
├── rtkOraImageIO.wrap
├── rtkParkerShortScanImageFilter.wrap
├── rtkPhaseGatingImageFilter.wrap
├── rtkPolynomialGainCorrectionImageFilter.wrap
├── rtkProjectGeometricPhantomImageFilter.wrap
├── rtkProjectionGeometry.wrap
├── rtkProjectionStackToFourDImageFilter.wrap
├── rtkProjectionsReader.wrap
├── rtkQuadricShape.wrap
├── rtkRayBoxIntersectionImageFilter.wrap
├── rtkRayConvexIntersectionImageFilter.wrap
├── rtkRayEllipsoidIntersectionImageFilter.wrap
├── rtkRayQuadricIntersectionImageFilter.wrap
├── rtkReg1DExtractShroudSignalImageFilter.notwrap
├── rtkRegularizedConjugateGradientConeBeamReconstructionFilter.wrap
├── rtkReorderProjectionsImageFilter.wrap
├── rtkSARTConeBeamReconstructionFilter.wrap
├── rtkScatterGlareCorrectionImageFilter.wrap
├── rtkSelectOneProjectionPerCycleImageFilter.wrap
├── rtkSheppLoganPhantomFilter.wrap
├── rtkSimplexSpectralProjectionsDecompositionImageFilter.wrap
├── rtkSoftThresholdImageFilter.wrap
├── rtkSpectralForwardModelImageFilter.wrap
├── rtkSplatWithKnownWeightsImageFilter.wrap
├── rtkSubSelectFromListImageFilter.wrap
├── rtkSubSelectImageFilter.wrap
├── rtkThreeDCircularProjectionGeometry.wrap
├── rtkThreeDCircularProjectionGeometryXMLFileReader.wrap
├── rtkThreeDCircularProjectionGeometryXMLFileWriter.wrap
├── rtkTotalVariationDenoisingBPDQImageFilter.wrap
├── rtkTotalVariationImageFilter.wrap
├── rtkVarianObiGeometryReader.wrap
├── rtkVarianObiRawImageFilter.wrap
├── rtkVarianProBeamGeometryReader.wrap
├── rtkVectorImageToImageFilter.wrap
├── rtkWaterPrecorrectionImageFilter.wrap
├── rtkXRadGeometryReader.wrap
├── rtkXRadImageIO.wrap
├── rtkXRadRawToAttenuationImageFilter.wrap
├── rtkXimImageIO.wrap
├── rtkZengBackProjectionImageFilter.wrap
└── rtkZengForwardProjectionImageFilter.wrap
Showing preview only (202K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2359 symbols across 664 files)
FILE: applications/rtk3Doutputimage_group.py
function add_rtk3Doutputimage_group (line 11) | def add_rtk3Doutputimage_group(parser):
function SetConstantImageSourceFromArgParse (line 45) | def SetConstantImageSourceFromArgParse(source, args_info):
FILE: applications/rtkadmmtotalvariation/rtkadmmtotalvariation.cxx
function main (line 32) | int
FILE: applications/rtkadmmtotalvariation/rtkadmmtotalvariation.py
function build_parser (line 8) | def build_parser():
function process (line 86) | def process(args_info: argparse.Namespace):
function main (line 180) | def main(argv=None):
FILE: applications/rtkadmmwavelets/rtkadmmwavelets.cxx
function main (line 32) | int
FILE: applications/rtkamsterdamshroud/rtkamsterdamshroud.cxx
function main (line 28) | int
FILE: applications/rtkamsterdamshroud/rtkamsterdamshroud.py
function build_parser (line 8) | def build_parser():
function process (line 38) | def process(args_info: argparse.Namespace):
function main (line 93) | def main(argv=None):
FILE: applications/rtkargumentparser.py
class RTKHelpFormatter (line 11) | class RTKHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
method _format_usage (line 12) | def _format_usage(self, usage, actions, groups, prefix=None):
class RTKArgumentParser (line 17) | class RTKArgumentParser(argparse.ArgumentParser):
method __init__ (line 18) | def __init__(self, description=None, **kwargs):
method build_signature (line 25) | def build_signature(self) -> inspect.Signature:
method build_usage_examples (line 40) | def build_usage_examples(self, app_name: str | None = None) -> str:
method apply_signature (line 54) | def apply_signature(self, func):
method parse_args (line 59) | def parse_args(self, args=None, namespace=None):
method parse_kwargs (line 96) | def parse_kwargs(self, func_name: str | None = None, **kwargs):
FILE: applications/rtkbackprojections/rtkbackprojections.cxx
function main (line 38) | int
FILE: applications/rtkbackprojections/rtkbackprojections.py
function build_parser (line 8) | def build_parser():
function process (line 72) | def process(args_info: argparse.Namespace):
function main (line 190) | def main(argv=None):
FILE: applications/rtkbioscangeometry/rtkbioscangeometry.cxx
function main (line 24) | int
FILE: applications/rtkbioscangeometry/rtkbioscangeometry.py
function build_parser (line 5) | def build_parser():
function process (line 18) | def process(args_info: argparse.Namespace):
function main (line 33) | def main(argv=None):
FILE: applications/rtkcheckimagequality/rtkcheckimagequality.cxx
type rtk (line 26) | namespace rtk
function MSE (line 37) | double
function main (line 63) | int
FILE: applications/rtkcheckimagequality/rtkcheckimagequality.py
function build_parser (line 6) | def build_parser():
function mse (line 39) | def mse(reference, reconstruction):
function process (line 44) | def process(args_info: argparse.Namespace):
function main (line 79) | def main(argv=None):
FILE: applications/rtkconjugategradient/rtkconjugategradient.cxx
function main (line 35) | int
FILE: applications/rtkconjugategradient/rtkconjugategradient.py
function build_parser (line 7) | def build_parser():
function process (line 51) | def process(args_info: argparse.Namespace):
function main (line 151) | def main(argv=None):
FILE: applications/rtkdigisensgeometry/rtkdigisensgeometry.cxx
function main (line 25) | int
FILE: applications/rtkdigisensgeometry/rtkdigisensgeometry.py
function build_parser (line 4) | def build_parser():
function process (line 19) | def process(args_info: argparse.Namespace):
function main (line 34) | def main(argv=None):
FILE: applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.cxx
function main (line 26) | int
FILE: applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.py
function build_parser (line 9) | def build_parser():
function process (line 55) | def process(args_info: argparse.Namespace):
function main (line 122) | def main(argv=None):
FILE: applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.cxx
function main (line 31) | int
FILE: applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.py
function build_parser (line 8) | def build_parser():
function process (line 42) | def process(args_info: argparse.Namespace):
function main (line 99) | def main(argv=None):
FILE: applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.cxx
function main (line 29) | int
FILE: applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.py
function build_parser (line 8) | def build_parser():
function process (line 42) | def process(args_info: argparse.Namespace):
function main (line 148) | def main(argv=None):
FILE: applications/rtkdualenergysimplexdecomposition/rtkdualenergysimplexdecomposition.cxx
function main (line 29) | int
FILE: applications/rtkdualenergysimplexdecomposition/rtkdualenergysimplexdecomposition.py
function build_parser (line 8) | def build_parser():
function process (line 54) | def process(args_info: argparse.Namespace):
function main (line 170) | def main(argv=None):
FILE: applications/rtkelektasynergygeometry/rtkelektasynergygeometry.cxx
function main (line 25) | int
FILE: applications/rtkelektasynergygeometry/rtkelektasynergygeometry.py
function build_parser (line 6) | def build_parser():
function process (line 21) | def process(args_info: argparse.Namespace):
function main (line 30) | def main(argv=None):
FILE: applications/rtkextractphasesignal/rtkextractphasesignal.cxx
type rtk (line 27) | namespace rtk
function WriteSignalToTextFile (line 30) | void
function main (line 43) | int
FILE: applications/rtkextractphasesignal/rtkextractphasesignal.py
function write_signal_to_text_file (line 7) | def write_signal_to_text_file(signal_image, filename):
function build_parser (line 18) | def build_parser():
function process (line 49) | def process(args_info: argparse.Namespace):
function main (line 89) | def main(argv=None):
FILE: applications/rtkextractshroudsignal/rtkextractshroudsignal.cxx
type rtk (line 29) | namespace rtk
function WriteSignalToTextFile (line 32) | void
function main (line 45) | int
FILE: applications/rtkfdk/rtkfdk.cxx
function main (line 41) | int
FILE: applications/rtkfdk/rtkfdk.py
function build_parser (line 9) | def build_parser():
function process (line 97) | def process(args_info: argparse.Namespace):
function main (line 221) | def main(argv=None):
FILE: applications/rtkfieldofview/rtkfieldofview.cxx
function main (line 36) | int
FILE: applications/rtkfieldofview/rtkfieldofview.py
function build_parser (line 7) | def build_parser():
function process (line 22) | def process(args_info: argparse.Namespace):
function main (line 95) | def main(argv=None):
FILE: applications/rtkforwardprojections/rtkforwardprojections.cxx
function main (line 34) | int
FILE: applications/rtkforwardprojections/rtkforwardprojections.py
function build_parser (line 8) | def build_parser():
function process (line 92) | def process(args_info):
function main (line 245) | def main(argv=None):
FILE: applications/rtkfourdconjugategradient/rtkfourdconjugategradient.cxx
function main (line 34) | int
FILE: applications/rtkfourdfdk/rtkfourdfdk.cxx
function main (line 38) | int
FILE: applications/rtkfourdrooster/rtkfourdrooster.cxx
function main (line 32) | int
FILE: applications/rtkfourdsart/rtkfourdsart.cxx
function main (line 34) | int
FILE: applications/rtkgaincorrection/rtkgaincorrection.cxx
function main (line 34) | int
FILE: applications/rtki0estimation/rtki0estimation.cxx
function main (line 31) | int
FILE: applications/rtkimagxgeometry/rtkimagxgeometry.cxx
function main (line 24) | int
FILE: applications/rtkinputprojections_group.py
function add_rtkinputprojections_group (line 11) | def add_rtkinputprojections_group(parser):
function GetProjectionsFileNamesFromArgParse (line 133) | def GetProjectionsFileNamesFromArgParse(args_info):
function SetProjectionsReaderFromArgParse (line 158) | def SetProjectionsReaderFromArgParse(reader, args_info):
FILE: applications/rtkiterations_group.py
function add_rtkiterations_group (line 9) | def add_rtkiterations_group(parser):
class VerboseIterationCommand (line 23) | class VerboseIterationCommand:
method __init__ (line 24) | def __init__(self):
method callback (line 27) | def callback(self):
class VerboseEndCommand (line 32) | class VerboseEndCommand:
method callback (line 33) | def callback(self):
class OutputIterationCommand (line 38) | class OutputIterationCommand:
method __init__ (line 39) | def __init__(self, reconstruction_filter, outputevery, iterationfilena...
method callback (line 45) | def callback(self):
function SetIterationsReportFromArgParse (line 59) | def SetIterationsReportFromArgParse(args_info, filt):
FILE: applications/rtkiterativefdk/rtkiterativefdk.cxx
function main (line 32) | int
FILE: applications/rtklagcorrection/rtklagcorrection.cxx
function main (line 37) | int
FILE: applications/rtkmaskcollimation/rtkmaskcollimation.cxx
function main (line 28) | int
FILE: applications/rtkmcrooster/rtkmcrooster.cxx
function main (line 34) | int
FILE: applications/rtkmotioncompensatedfourdconjugategradient/rtkmotioncompensatedfourdconjugategradient.cxx
function main (line 32) | int
FILE: applications/rtkorageometry/rtkorageometry.cxx
function main (line 24) | int
FILE: applications/rtkorageometry/rtkorageometry.py
function build_parser (line 7) | def build_parser():
function process (line 37) | def process(args: argparse.Namespace):
function main (line 58) | def main(argv=None):
FILE: applications/rtkosem/rtkosem.cxx
function main (line 33) | int
FILE: applications/rtkoverlayphaseandshroud/rtkoverlayphaseandshroud.cxx
function main (line 32) | int
FILE: applications/rtkprojectgeometricphantom/rtkprojectgeometricphantom.cxx
function main (line 28) | int
FILE: applications/rtkprojectgeometricphantom/rtkprojectgeometricphantom.py
function build_parser (line 8) | def build_parser():
function process (line 55) | def process(args_info: argparse.Namespace):
function main (line 116) | def main(argv=None):
FILE: applications/rtkprojectionmatrix/rtkMatlabSparseMatrix.h
function namespace (line 24) | namespace rtk
FILE: applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx
type rtk (line 29) | namespace rtk
type Functor (line 31) | namespace Functor
class StoreSparseMatrixSplatWeightMultiplication (line 34) | class StoreSparseMatrixSplatWeightMultiplication
method StoreSparseMatrixSplatWeightMultiplication (line 37) | StoreSparseMatrixSplatWeightMultiplication() = default;
method SetProjectionsBuffer (line 67) | void
method SetVolumeBuffer (line 72) | void
function main (line 94) | int
FILE: applications/rtkprojections/rtkprojections.cxx
function main (line 25) | int
FILE: applications/rtkprojections/rtkprojections.py
function build_parser (line 6) | def build_parser():
function process (line 22) | def process(args_info: argparse.Namespace):
function main (line 43) | def main(argv=None):
FILE: applications/rtkprojectors_group.py
function add_rtkprojectors_group (line 9) | def add_rtkprojectors_group(parser):
function SetBackProjectionFromArgParse (line 57) | def SetBackProjectionFromArgParse(args_info, recon):
function SetForwardProjectionFromArgParse (line 92) | def SetForwardProjectionFromArgParse(args_info, recon):
FILE: applications/rtkprojectshepploganphantom/rtkprojectshepploganphantom.cxx
function main (line 29) | int
FILE: applications/rtkprojectshepploganphantom/rtkprojectshepploganphantom.py
function build_parser (line 6) | def build_parser():
function process (line 42) | def process(args_info: argparse.Namespace):
function main (line 99) | def main(argv=None):
FILE: applications/rtkregularizedconjugategradient/rtkregularizedconjugategradient.cxx
function main (line 31) | int
FILE: applications/rtksart/rtksart.cxx
function main (line 33) | int
FILE: applications/rtkscatterglarecorrection/rtkscatterglarecorrection.cxx
function main (line 40) | int
FILE: applications/rtkshowgeometry/rtkshowgeometry.py
function build_parser (line 8) | def build_parser():
function process (line 36) | def process(args_info: argparse.Namespace):
function main (line 483) | def main(argv=None):
FILE: applications/rtksimulatedgeometry/rtksimulatedgeometry.cxx
function main (line 24) | int
FILE: applications/rtksimulatedgeometry/rtksimulatedgeometry.py
function build_parser (line 6) | def build_parser():
function process (line 72) | def process(args: argparse.Namespace):
function main (line 96) | def main(argv=None):
FILE: applications/rtkspectraldenoiseprojections/rtkspectraldenoiseprojections.cxx
function main (line 27) | int
FILE: applications/rtkspectralforwardmodel/rtkspectralforwardmodel.cxx
function main (line 28) | int
FILE: applications/rtkspectralonestep/rtkspectralonestep.cxx
function GetFileHeader (line 35) | itk::ImageIOBase::Pointer
type rtk (line 49) | namespace rtk
function rtkspectralonestep (line 52) | void
function main (line 218) | int
FILE: applications/rtkspectralrooster/rtkspectralrooster.cxx
function main (line 38) | int
FILE: applications/rtkspectralsimplexdecomposition/rtkspectralsimplexdecomposition.cxx
function main (line 28) | int
FILE: applications/rtksubselect/rtksubselect.cxx
function main (line 30) | int
FILE: applications/rtktotalnuclearvariationdenoising/rtktotalnuclearvariationdenoising.cxx
function main (line 29) | int
FILE: applications/rtktotalvariationdenoising/rtktotalvariationdenoising.cxx
function main (line 34) | int
FILE: applications/rtktutorialapplication/rtktutorialapplication.cxx
function main (line 26) | int
FILE: applications/rtkvarianobigeometry/rtkvarianobigeometry.cxx
function main (line 27) | int
FILE: applications/rtkvarianobigeometry/rtkvarianobigeometry.py
function build_parser (line 7) | def build_parser():
function process (line 35) | def process(args: argparse.Namespace):
function main (line 49) | def main(argv=None):
FILE: applications/rtkvarianprobeamgeometry/rtkvarianprobeamgeometry.cxx
function main (line 25) | int
FILE: applications/rtkvectorconjugategradient/rtkvectorconjugategradient.cxx
function main (line 34) | int
FILE: applications/rtkwaveletsdenoising/rtkwaveletsdenoising.cxx
function main (line 28) | int
FILE: applications/rtkxradgeometry/rtkxradgeometry.cxx
function main (line 24) | int
FILE: conf.py
function setup (line 13) | def setup(app):
FILE: examples/AddNoise/AddNoise.cxx
function main (line 17) | int
FILE: examples/ConjugateGradient/ConjugateGradient.cxx
function main (line 11) | int
FILE: examples/ConjugateGradient/ConjugateGradient.py
class VerboseIterationCommand (line 80) | class VerboseIterationCommand:
method __init__ (line 81) | def __init__(self):
method callback (line 84) | def callback(self):
class VerboseEndCommand (line 89) | class VerboseEndCommand:
method callback (line 90) | def callback(self):
FILE: examples/FirstReconstruction/FirstCudaReconstruction.cxx
function main (line 11) | int
FILE: examples/FirstReconstruction/FirstReconstruction.cxx
function main (line 11) | int
FILE: examples/GeometricPhantom/GeometricPhantom.cxx
function main (line 7) | int
FILE: examples/InlineReconstruction/InlineReconstruction.cxx
function Acquisition (line 42) | void
function main (line 76) | int
FILE: examples/InlineReconstruction/InlineReconstruction.py
function acquisition (line 24) | def acquisition():
FILE: include/rtkADMMTotalVariationConeBeamReconstructionFilter.h
type typename (line 163) | typedef
type rtk (line 175) | typedef rtk::SoftThresholdTVImageFilter<GradientImageType> SoftThreshold...
function VerifyPreconditions (line 217) | void
FILE: include/rtkADMMTotalVariationConeBeamReconstructionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkADMMTotalVariationConjugateGradientOperator.h
function namespace (line 38) | namespace rtk
FILE: include/rtkADMMTotalVariationConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkADMMWaveletsConeBeamReconstructionFilter.h
function VerifyPreconditions (line 209) | void
function m_Beta (line 248) | float m_Beta{ 1 }
function m_AL_iterations (line 249) | unsigned int m_AL_iterations{ 10 };
FILE: include/rtkADMMWaveletsConeBeamReconstructionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkADMMWaveletsConjugateGradientOperator.h
function namespace (line 32) | namespace rtk
FILE: include/rtkADMMWaveletsConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkAddMatrixAndDiagonalImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkAdditiveGaussianNoiseImageFilter.h
function namespace (line 45) | namespace rtk
FILE: include/rtkAdditiveGaussianNoiseImageFilter.hxx
type rtk (line 40) | namespace rtk
FILE: include/rtkAmsterdamShroudImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkAverageOutOfROIImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkBackProjectionImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkBackProjectionImageFilter.hxx
type rtk (line 32) | namespace rtk
FILE: include/rtkBackwardDifferenceDivergenceImageFilter.h
function SetUseImageSpacingOn (line 66) | void
function SetUseImageSpacingOff (line 74) | void
FILE: include/rtkBackwardDifferenceDivergenceImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkBioscanGeometryReader.h
function namespace (line 28) | namespace rtk
function namespace (line 33) | namespace gdcm
function namespace (line 38) | namespace rtk
FILE: include/rtkBlockDiagonalMatrixVectorMultiplyImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkBoellaardScatterCorrectionImageFilter.h
function m_ScatterToPrimaryRatio (line 109) | double m_ScatterToPrimaryRatio{ 0. };
FILE: include/rtkBoellaardScatterCorrectionImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkBoxShape.h
function namespace (line 28) | namespace rtk
FILE: include/rtkConditionalMedianImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkConjugateGradientConeBeamReconstructionFilter.h
function VerifyPreconditions (line 217) | void
FILE: include/rtkConjugateGradientConeBeamReconstructionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkConjugateGradientGetP_kPlusOneImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkConjugateGradientGetR_kPlusOneImageFilter.h
function m_SquaredNormR_k (line 83) | double m_SquaredNormR_k{ 0. };
FILE: include/rtkConjugateGradientGetR_kPlusOneImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkConjugateGradientGetX_kPlusOneImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkConjugateGradientImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkConjugateGradientOperator.h
function namespace (line 23) | namespace rtk
FILE: include/rtkConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkConstantImageSource.h
type SizeValueType (line 83) | typedef SizeValueType SizeValueArrayType[TOutputImage::ImageDimension];
type SpacingValueType (line 85) | typedef SpacingValueType SpacingValueArrayType[TOutputImage::ImageDimens...
type PointValueType (line 87) | typedef PointValueType PointValueArrayType[TOutputImage::ImageDimension];
FILE: include/rtkConstantImageSource.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkConvexShape.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaAverageOutOfROIImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkCudaBackProjectionImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaBackProjectionImageFilter.hxx
type rtk (line 35) | namespace rtk
FILE: include/rtkCudaConjugateGradientImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaConjugateGradientImageFilter.hxx
type rtk (line 33) | namespace rtk
FILE: include/rtkCudaConstantVolumeSeriesSource.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaConstantVolumeSource.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaCropImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkCudaCyclicDeformationImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaDisplacedDetectorImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaFDKBackProjectionImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaFDKConeBeamReconstructionFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaFDKWeightProjectionFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaFFTProjectionsConvolutionImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkCudaFFTProjectionsConvolutionImageFilter.hxx
type rtk (line 34) | namespace rtk
FILE: include/rtkCudaFFTRampImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaForwardProjectionImageFilter.h
function namespace (line 48) | namespace rtk
FILE: include/rtkCudaForwardProjectionImageFilter.hxx
type rtk (line 37) | namespace rtk
FILE: include/rtkCudaForwardWarpImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaInterpolateImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkCudaIterativeFDKConeBeamReconstructionFilter.h
function namespace (line 33) | namespace rtk
FILE: include/rtkCudaLagCorrectionImageFilter.h
function namespace (line 34) | namespace rtk
FILE: include/rtkCudaLaplacianImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaLastDimensionTVDenoisingImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaParkerShortScanImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaPolynomialGainCorrectionImageFilter.h
function namespace (line 34) | namespace rtk
FILE: include/rtkCudaRayCastBackProjectionImageFilter.h
function namespace (line 33) | namespace rtk
FILE: include/rtkCudaScatterGlareCorrectionImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkCudaSplatImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkCudaTotalVariationDenoisingBPDQImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkCudaWarpBackProjectionImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaWarpForwardProjectionImageFilter.h
function namespace (line 44) | namespace rtk
FILE: include/rtkCudaWarpImageFilter.h
function namespace (line 32) | namespace rtk
FILE: include/rtkCudaWeidingerForwardModelImageFilter.h
function namespace (line 39) | namespace rtk
FILE: include/rtkCudaWeidingerForwardModelImageFilter.hxx
type rtk (line 34) | namespace rtk
FILE: include/rtkCyclicDeformationImageFilter.h
function namespace (line 27) | namespace rtk
FILE: include/rtkCyclicDeformationImageFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkDCMImagXImageIO.h
function namespace (line 27) | namespace rtk
FILE: include/rtkDCMImagXImageIOFactory.h
function namespace (line 28) | namespace rtk
FILE: include/rtkDPExtractShroudSignalImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkDaubechiesWaveletsConvolutionImageFilter.h
type Pass (line 50) | enum Pass
type Type (line 56) | enum Type
FILE: include/rtkDaubechiesWaveletsConvolutionImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkDaubechiesWaveletsDenoiseSequenceImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkDaubechiesWaveletsDenoiseSequenceImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkDbf.h
function namespace (line 30) | namespace rtk
FILE: include/rtkDePierroRegularizationImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkDePierroRegularizationImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkDeconstructImageFilter.h
function virtual (line 163) | virtual void
function GetNumberOfLevels (line 171) | virtual unsigned int
function GenerateOutputInformation (line 181) | void
function typename (line 211) | typename InputImageType::IndexType *
function GenerateData (line 230) | void
function m_Order (line 243) | unsigned int m_Order{ 3 }
function m_PipelineConstructed (line 244) | bool m_PipelineConstructed{
FILE: include/rtkDeconstructImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkDeconstructSoftThresholdReconstructImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkDenoisingBPDQImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkDenoisingBPDQImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkDigisensGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkDigisensGeometryXMLFileReader.h
function namespace (line 28) | namespace rtk
FILE: include/rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.h
function GenerateOutputInformation (line 72) | void
FILE: include/rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkDisplacedDetectorImageFilter.h
function m_SuperiorCorner (line 156) | double m_SuperiorCorner{ 0. };
FILE: include/rtkDisplacedDetectorImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkDivergenceOfGradientConjugateGradientOperator.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkDownsampleImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkDrawBoxImageFilter.h
function VectorType (line 99) | VectorType m_BoxMin{ 0. };
FILE: include/rtkDrawBoxImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkDrawConeImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkDrawConeImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkDrawConvexImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkDrawCylinderImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkDrawCylinderImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkDrawEllipsoidImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkDrawEllipsoidImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkDrawGeometricPhantomImageFilter.h
function virtual (line 76) | virtual void
function VectorType (line 108) | VectorType m_PhantomScale{ 1. };
FILE: include/rtkDrawGeometricPhantomImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkDrawQuadricImageFilter.h
function ScalarType (line 112) | ScalarType m_I{ 0. };
FILE: include/rtkDrawQuadricImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkDrawSheppLoganFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkDrawSheppLoganFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkDualEnergyNegativeLogLikelihood.h
function namespace (line 29) | namespace rtk
FILE: include/rtkEdfImageIO.h
function namespace (line 29) | namespace rtk
FILE: include/rtkEdfImageIOFactory.h
function namespace (line 28) | namespace rtk
FILE: include/rtkEdfRawToAttenuationImageFilter.h
function SetFileNames (line 65) | void
FILE: include/rtkEdfRawToAttenuationImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkElektaSynergyGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkElektaSynergyLookupTableImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkElektaSynergyLookupTableImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkElektaSynergyRawLookupTableImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkElektaSynergyRawLookupTableImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkElektaXVI5GeometryXMLFileReader.h
function m_ProjectionOffsetX (line 108) | double m_ProjectionOffsetX{ 0. };
FILE: include/rtkExtractPhaseImageFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkExtractPhaseImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkFDKConeBeamReconstructionFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkFDKConeBeamReconstructionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkFDKVarianceReconstructionFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkFDKVarianceReconstructionFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkFDKWarpBackProjectionImageFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkFDKWarpBackProjectionImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkFDKWeightProjectionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkFFTHilbertImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkFFTProjectionsConvolutionImageFilter.h
function namespace (line 28) | namespace rtk
FILE: include/rtkFFTProjectionsConvolutionImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkFFTRampImageFilter.h
function m_RamLakCutFrequency (line 166) | double m_RamLakCutFrequency{ 0. };
FILE: include/rtkFFTRampImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkFFTVarianceRampImageFilter.h
function namespace (line 26) | namespace rtk
FILE: include/rtkFFTVarianceRampImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkFieldOfViewImageFilter.h
type _lprec (line 27) | struct _lprec
function m_InsideValue (line 149) | double m_InsideValue{ 1. };
FILE: include/rtkFieldOfViewImageFilter.hxx
type rtk (line 33) | namespace rtk
FILE: include/rtkForbildPhantomFileReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkForwardDifferenceGradientImageFilter.h
function namespace (line 28) | namespace rtk
FILE: include/rtkForwardDifferenceGradientImageFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkForwardProjectionImageFilter.h
function namespace (line 26) | namespace rtk
FILE: include/rtkForwardProjectionImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkForwardWarpImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkFourDConjugateGradientConeBeamReconstructionFilter.h
function namespace (line 38) | namespace rtk
FILE: include/rtkFourDConjugateGradientConeBeamReconstructionFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkFourDROOSTERConeBeamReconstructionFilter.h
function namespace (line 45) | namespace rtk
FILE: include/rtkFourDROOSTERConeBeamReconstructionFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkFourDReconstructionConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkFourDSARTConeBeamReconstructionFilter.h
function namespace (line 40) | namespace rtk
FILE: include/rtkFourDSARTConeBeamReconstructionFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkFourDToProjectionStackImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkGeneralPurposeFunctions.h
function namespace (line 31) | namespace rtk
FILE: include/rtkGeometricPhantom.h
function namespace (line 25) | namespace rtk
FILE: include/rtkGetNewtonUpdateImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkGgoArgsInfoManager.h
function namespace (line 26) | namespace rtk
FILE: include/rtkGlobalResourceProbe.h
function namespace (line 27) | namespace rtk
FILE: include/rtkHilbertImageFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkHilbertImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkHisImageIO.h
function namespace (line 27) | namespace rtk
FILE: include/rtkHisImageIOFactory.h
function namespace (line 31) | namespace rtk
FILE: include/rtkHncImageIO.h
function namespace (line 36) | namespace rtk
FILE: include/rtkHncImageIOFactory.h
function namespace (line 30) | namespace rtk
FILE: include/rtkHndImageIO.h
function namespace (line 34) | namespace rtk
FILE: include/rtkHndImageIOFactory.h
function namespace (line 33) | namespace rtk
FILE: include/rtkHomogeneousMatrix.h
function namespace (line 25) | namespace rtk
FILE: include/rtkI0EstimationProjectionFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkIOFactories.h
function namespace (line 24) | namespace rtk
FILE: include/rtkImagXGeometryReader.h
function namespace (line 27) | namespace rtk
FILE: include/rtkImagXGeometryReader.hxx
type rtk (line 33) | namespace rtk
FILE: include/rtkImagXImageIO.h
function namespace (line 29) | namespace rtk
FILE: include/rtkImagXImageIOFactory.h
function namespace (line 28) | namespace rtk
FILE: include/rtkImagXXMLFileReader.h
function namespace (line 34) | namespace rtk
FILE: include/rtkImageToVectorImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkImportImageFilter.h
function SetRegion (line 98) | void
FILE: include/rtkImportImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkInterpolatorWithKnownWeightsImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkIntersectionOfConvexShapes.h
function namespace (line 26) | namespace rtk
FILE: include/rtkIterationCommands.h
function namespace (line 24) | namespace rtk
FILE: include/rtkIterativeConeBeamReconstructionFilter.h
type ForwardProjectionType (line 72) | typedef enum
type BackProjectionType (line 79) | typedef enum
function ForwardProjectionType (line 104) | ForwardProjectionType
function BackProjectionType (line 111) | BackProjectionType
function SetAttenuationMap (line 119) | void
function typename (line 125) | typename VolumeType::ConstPointer
function SetInferiorClipImage (line 134) | void
function typename (line 140) | typename TClipImageType::ConstPointer
function SetSuperiorClipImage (line 149) | void
function typename (line 155) | typename TClipImageType::ConstPointer
function m_AlphaPSF (line 198) | double m_AlphaPSF{ 0.016241189545787734 };
FILE: include/rtkIterativeConeBeamReconstructionFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkIterativeFDKConeBeamReconstructionFilter.h
function namespace (line 34) | namespace rtk
FILE: include/rtkIterativeFDKConeBeamReconstructionFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkJosephBackAttenuatedProjectionImageFilter.h
function namespace (line 26) | namespace rtk
FILE: include/rtkJosephBackAttenuatedProjectionImageFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkJosephBackProjectionImageFilter.h
function namespace (line 30) | namespace Functor
function SetInterpolationWeightMultiplication (line 199) | void
function SetSplatWeightMultiplication (line 220) | void
function SetSumAlongRay (line 241) | void
function GenerateData (line 263) | void
function m_InferiorClip (line 332) | double m_InferiorClip{ 0. };
FILE: include/rtkJosephBackProjectionImageFilter.hxx
type rtk (line 33) | namespace rtk
FILE: include/rtkJosephForwardAttenuatedProjectionImageFilter.h
function namespace (line 32) | namespace Functor
FILE: include/rtkJosephForwardAttenuatedProjectionImageFilter.hxx
type rtk (line 32) | namespace rtk
FILE: include/rtkJosephForwardProjectionImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkJosephForwardProjectionImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkLUTbasedVariableI0RawToAttenuationImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkLUTbasedVariableI0RawToAttenuationImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkLagCorrectionImageFilter.h
function virtual (line 83) | virtual void
FILE: include/rtkLagCorrectionImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkLaplacianImageFilter.h
type typename (line 60) | typedef
FILE: include/rtkLaplacianImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkLastDimensionL0GradientDenoisingImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkLookupTableImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkLookupTableImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkMagnitudeThresholdImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkMagnitudeThresholdImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkMaskCollimationImageFilter.h
function namespace (line 26) | namespace rtk
FILE: include/rtkMaskCollimationImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkMaximumIntensityProjectionImageFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkMechlemOneStepSpectralReconstructionFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.h
function SetForwardProjectionFilter (line 158) | void
function SetBackProjectionFilter (line 163) | void
function GenerateOutputInformation (line 192) | void
FILE: include/rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkMultiplyByVectorImageFilter.h
function namespace (line 23) | namespace rtk
FILE: include/rtkMultiplyByVectorImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkNesterovUpdateImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkOSEMConeBeamReconstructionFilter.h
function VerifyPreconditions (line 183) | void
function m_NumberOfIterations (line 222) | unsigned int m_NumberOfIterations{ 3 }
function m_BetaRegularization (line 225) | double m_BetaRegularization{ 0. };
FILE: include/rtkOSEMConeBeamReconstructionFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkOraGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkOraImageIO.h
function namespace (line 32) | namespace rtk
FILE: include/rtkOraImageIOFactory.h
function namespace (line 30) | namespace rtk
FILE: include/rtkOraLookupTableImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkOraLookupTableImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkOraXMLFileReader.h
function namespace (line 29) | namespace rtk
FILE: include/rtkParkerShortScanImageFilter.h
function namespace (line 27) | namespace rtk
FILE: include/rtkParkerShortScanImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkPhaseGatingImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkPhaseReader.h
function namespace (line 24) | namespace rtk
FILE: include/rtkPhasesToInterpolationWeights.h
function namespace (line 26) | namespace rtk
FILE: include/rtkPolynomialGainCorrectionImageFilter.h
function GenerateOutputInformation (line 89) | void
FILE: include/rtkPolynomialGainCorrectionImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkProgressCommands.h
function namespace (line 24) | namespace rtk
FILE: include/rtkProjectGeometricPhantomImageFilter.h
function virtual (line 83) | virtual void
FILE: include/rtkProjectGeometricPhantomImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkProjectionGeometry.h
function namespace (line 28) | namespace rtk
FILE: include/rtkProjectionGeometry.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkProjectionStackToFourDImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkProjectionsDecompositionNegativeLogLikelihood.h
function namespace (line 28) | namespace rtk
FILE: include/rtkProjectionsReader.h
function SetFileNames (line 166) | void
function virtual (line 232) | virtual void
function m_ConditionalMedianThresholdMultiplier (line 337) | double m_ConditionalMedianThresholdMultiplier{ 1. };
FILE: include/rtkProjectionsReader.hxx
function SET_INPUT_IMAGE_VECTOR_TYPE (line 370) | SET_INPUT_IMAGE_VECTOR_TYPE(float, 1)
FILE: include/rtkProjectionsRegionConstIteratorRayBased.h
function namespace (line 26) | namespace rtk
FILE: include/rtkProjectionsRegionConstIteratorRayBased.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkProjectionsRegionConstIteratorRayBasedParallel.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkProjectionsRegionConstIteratorRayBasedWithCylindricalPanel.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.h
function namespace (line 24) | namespace rtk
FILE: include/rtkProjectionsRegionConstIteratorRayBasedWithFlatPanel.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkQuadricShape.h
function ScalarType (line 132) | ScalarType m_I{ 0. };
FILE: include/rtkRayBoxIntersectionImageFilter.h
function PointType (line 100) | PointType m_BoxMin{ 0. };
FILE: include/rtkRayBoxIntersectionImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkRayConvexIntersectionImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkRayEllipsoidIntersectionImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkRayEllipsoidIntersectionImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkRayQuadricIntersectionImageFilter.h
function ScalarType (line 115) | ScalarType m_I{ 0. };
FILE: include/rtkRayQuadricIntersectionImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkReconstructImageFilter.h
function virtual (line 158) | virtual void
function GetNumberOfLevels (line 166) | virtual unsigned int
function GenerateOutputInformation (line 176) | void
function SetSizes (line 192) | void
function SetIndices (line 198) | void
function GenerateData (line 222) | void
function m_Order (line 235) | unsigned int m_Order{ 3 }
function m_PipelineConstructed (line 236) | bool m_PipelineConstructed{
FILE: include/rtkReconstructImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkReconstructionConjugateGradientOperator.h
function VerifyPreconditions (line 209) | void
FILE: include/rtkReconstructionConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkReg1DExtractShroudSignalImageFilter.hxx
type rtk (line 31) | namespace rtk
function TOutputPixel (line 87) | TOutputPixel
FILE: include/rtkReg23ProjectionGeometry.h
function namespace (line 30) | namespace rtk
FILE: include/rtkRegularizedConjugateGradientConeBeamReconstructionFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkRegularizedConjugateGradientConeBeamReconstructionFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkReorderProjectionsImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkResourceProbesCollector.h
function namespace (line 31) | namespace rtk
FILE: include/rtkSARTConeBeamReconstructionFilter.h
function namespace (line 38) | namespace rtk
FILE: include/rtkSARTConeBeamReconstructionFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkScatterGlareCorrectionImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkScatterGlareCorrectionImageFilter.hxx
type rtk (line 31) | namespace rtk
FILE: include/rtkSchlomka2008NegativeLogLikelihood.h
function namespace (line 29) | namespace rtk
FILE: include/rtkSelectOneProjectionPerCycleImageFilter.h
function ITK_TEMPLATE_EXPORT (line 39) | ITK_TEMPLATE_EXPORT SelectOneProjectionPerCycleImageFilter : public SubS...
FILE: include/rtkSelectOneProjectionPerCycleImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkSeparableQuadraticSurrogateRegularizationImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkSheppLoganPhantom.h
function namespace (line 26) | namespace rtk
FILE: include/rtkSheppLoganPhantomFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkSheppLoganPhantomFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkSignalToInterpolationWeights.h
function namespace (line 26) | namespace rtk
FILE: include/rtkSimplexSpectralProjectionsDecompositionImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkSimplexSpectralProjectionsDecompositionImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkSingularValueThresholdImageFilter.h
function namespace (line 27) | namespace rtk
FILE: include/rtkSingularValueThresholdImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkSoftThresholdImageFilter.h
function namespace (line 26) | namespace rtk
FILE: include/rtkSoftThresholdImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkSoftThresholdTVImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkSoftThresholdTVImageFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkSpectralForwardModelImageFilter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkSpectralForwardModelImageFilter.hxx
type rtk (line 25) | namespace rtk
function SpectralBinDetectorResponse (line 765) | vnl_matrix<OutputElementType>
FILE: include/rtkSplatWithKnownWeightsImageFilter.h
function namespace (line 28) | namespace rtk
FILE: include/rtkSplatWithKnownWeightsImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkSubSelectFromListImageFilter.h
function namespace (line 24) | namespace rtk
FILE: include/rtkSubSelectFromListImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkSubSelectImageFilter.hxx
type rtk (line 22) | namespace rtk
FILE: include/rtkSumOfSquaresImageFilter.h
function namespace (line 33) | namespace rtk
FILE: include/rtkSumOfSquaresImageFilter.hxx
type rtk (line 25) | namespace rtk
FILE: include/rtkThreeDCircularProjectionGeometry.h
function Clear (line 150) | void
function std (line 212) | const std::vector<double>
function ThreeDHomogeneousMatrixType (line 268) | ThreeDHomogeneousMatrixType
function ThreeDHomogeneousMatrixType (line 279) | ThreeDHomogeneousMatrixType
function virtual (line 379) | virtual void
function virtual (line 385) | virtual void
function virtual (line 391) | virtual void
function virtual (line 397) | virtual void
function m_VerifyAnglesTolerance (line 489) | double m_VerifyAnglesTolerance{ 1e-4 };
FILE: include/rtkThreeDCircularProjectionGeometryXMLFileReader.h
function m_CollimationVInf (line 110) | double m_CollimationVInf{ std::numeric_limits<double>::max() };
FILE: include/rtkThreeDCircularProjectionGeometryXMLFileWriter.h
function namespace (line 30) | namespace rtk
FILE: include/rtkTotalNuclearVariationDenoisingBPDQImageFilter.h
function namespace (line 25) | namespace rtk
FILE: include/rtkTotalNuclearVariationDenoisingBPDQImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkTotalVariationDenoiseSequenceImageFilter.h
function namespace (line 34) | namespace rtk
FILE: include/rtkTotalVariationDenoiseSequenceImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkTotalVariationDenoisingBPDQImageFilter.h
function namespace (line 27) | namespace rtk
FILE: include/rtkTotalVariationDenoisingBPDQImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkTotalVariationImageFilter.h
function SetUseImageSpacingOn (line 113) | void
function SetUseImageSpacingOff (line 121) | void
FILE: include/rtkTotalVariationImageFilter.hxx
type rtk (line 28) | namespace rtk
FILE: include/rtkUnwarpSequenceConjugateGradientOperator.h
function namespace (line 25) | namespace rtk
FILE: include/rtkUnwarpSequenceConjugateGradientOperator.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkUnwarpSequenceImageFilter.h
function GenerateData (line 147) | void
FILE: include/rtkUnwarpSequenceImageFilter.hxx
type rtk (line 23) | namespace rtk
FILE: include/rtkUpsampleImageFilter.hxx
type rtk (line 29) | namespace rtk
FILE: include/rtkVarianObiGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkVarianObiRawImageFilter.h
function namespace (line 28) | namespace rtk
FILE: include/rtkVarianObiRawImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkVarianObiXMLFileReader.h
function namespace (line 33) | namespace rtk
FILE: include/rtkVarianProBeamGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkVarianProBeamXMLFileReader.h
function namespace (line 32) | namespace rtk
FILE: include/rtkVectorImageToImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkWarpFourDToProjectionStackImageFilter.h
function namespace (line 31) | namespace rtk
FILE: include/rtkWarpFourDToProjectionStackImageFilter.hxx
type rtk (line 22) | namespace rtk
FILE: include/rtkWarpProjectionStackToFourDImageFilter.h
function namespace (line 29) | namespace rtk
FILE: include/rtkWarpProjectionStackToFourDImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkWarpSequenceImageFilter.h
function GenerateData (line 170) | void
FILE: include/rtkWarpSequenceImageFilter.hxx
type rtk (line 30) | namespace rtk
FILE: include/rtkWatcherForResourceProbe.h
function namespace (line 25) | namespace rtk
FILE: include/rtkWaterPrecorrectionImageFilter.h
function namespace (line 27) | namespace rtk
FILE: include/rtkWaterPrecorrectionImageFilter.hxx
type rtk (line 26) | namespace rtk
FILE: include/rtkWeidingerForwardModelImageFilter.h
function namespace (line 28) | namespace rtk
FILE: include/rtkWeidingerForwardModelImageFilter.hxx
type rtk (line 24) | namespace rtk
FILE: include/rtkXRadGeometryReader.h
function namespace (line 26) | namespace rtk
FILE: include/rtkXRadImageIO.h
function namespace (line 29) | namespace rtk
FILE: include/rtkXRadImageIOFactory.h
function namespace (line 28) | namespace rtk
FILE: include/rtkXRadRawToAttenuationImageFilter.hxx
type rtk (line 27) | namespace rtk
FILE: include/rtkXimImageIO.h
function namespace (line 35) | namespace rtk
FILE: include/rtkXimImageIOFactory.h
function namespace (line 34) | namespace rtk
FILE: include/rtkZengBackProjectionImageFilter.h
function GenerateInputRequestedRegion (line 178) | void
FILE: include/rtkZengBackProjectionImageFilter.hxx
type rtk (line 34) | namespace rtk
FILE: include/rtkZengForwardProjectionImageFilter.h
function GenerateInputRequestedRegion (line 122) | void
FILE: include/rtkZengForwardProjectionImageFilter.hxx
type rtk (line 34) | namespace rtk
FILE: src/rtkBioscanGeometryReader.cxx
type rtk (line 30) | namespace rtk
FILE: src/rtkBoxShape.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkConvexShape.cxx
type rtk (line 21) | namespace rtk
FILE: src/rtkCudaCropImageFilter.cxx
type rtk (line 25) | namespace rtk
FILE: src/rtkCudaDisplacedDetectorImageFilter.cxx
type rtk (line 22) | namespace rtk
FILE: src/rtkCudaFDKBackProjectionImageFilter.cxx
type rtk (line 29) | namespace rtk
FILE: src/rtkCudaFDKWeightProjectionFilter.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkCudaForwardWarpImageFilter.cxx
type rtk (line 29) | namespace rtk
FILE: src/rtkCudaLagCorrectionImageFilter.cxx
type rtk (line 22) | namespace rtk
FILE: src/rtkCudaParkerShortScanImageFilter.cxx
type rtk (line 22) | namespace rtk
FILE: src/rtkCudaPolynomialGainCorrectionImageFilter.cxx
type rtk (line 22) | namespace rtk
FILE: src/rtkCudaRayCastBackProjectionImageFilter.cxx
type rtk (line 28) | namespace rtk
FILE: src/rtkCudaWarpBackProjectionImageFilter.cxx
type rtk (line 28) | namespace rtk
FILE: src/rtkCudaWarpForwardProjectionImageFilter.cxx
type rtk (line 36) | namespace rtk
FILE: src/rtkCudaWarpImageFilter.cxx
type rtk (line 29) | namespace rtk
FILE: src/rtkDCMImagXImageIOFactory.cxx
type itk (line 34) | namespace itk
FILE: src/rtkDbf.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkDigisensGeometryXMLFileReader.cxx
type rtk (line 25) | namespace rtk
FILE: src/rtkEdfImageIO.cxx
type table3 (line 106) | struct table3
type table (line 166) | struct table
FILE: src/rtkElektaXVI5GeometryXMLFileReader.cxx
type rtk (line 27) | namespace rtk
FILE: src/rtkForbildPhantomFileReader.cxx
type rtk (line 30) | namespace rtk
FILE: src/rtkGeometricPhantom.cxx
type rtk (line 21) | namespace rtk
FILE: src/rtkGlobalResourceProbe.cxx
type rtk (line 21) | namespace rtk
FILE: src/rtkHisImageIOFactory.cxx
type itk (line 32) | namespace itk
FILE: src/rtkHncImageIOFactory.cxx
type itk (line 33) | namespace itk
FILE: src/rtkHndImageIO.cxx
function T (line 147) | inline T
function T (line 156) | inline T
function lut_to_bytes (line 175) | inline size_t
FILE: src/rtkHndImageIOFactory.cxx
type itk (line 33) | namespace itk
FILE: src/rtkIOFactories.cxx
type rtk (line 46) | namespace rtk
function RegisterIOFactories (line 49) | void
FILE: src/rtkImagXImageIOFactory.cxx
type itk (line 31) | namespace itk
FILE: src/rtkImagXXMLFileReader.cxx
type rtk (line 25) | namespace rtk
FILE: src/rtkIntersectionOfConvexShapes.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkOraGeometryReader.cxx
type rtk (line 32) | namespace rtk
FILE: src/rtkOraImageIOFactory.cxx
type itk (line 33) | namespace itk
FILE: src/rtkOraXMLFileReader.cxx
type rtk (line 24) | namespace rtk
FILE: src/rtkPhaseReader.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkPhasesToInterpolationWeights.cxx
type rtk (line 23) | namespace rtk
FILE: src/rtkQuadricShape.cxx
type rtk (line 21) | namespace rtk
FILE: src/rtkResourceProbesCollector.cxx
type rtk (line 22) | namespace rtk
FILE: src/rtkSheppLoganPhantom.cxx
type rtk (line 21) | namespace rtk
FILE: src/rtkSignalToInterpolationWeights.cxx
type rtk (line 24) | namespace rtk
FILE: src/rtkThreeDCircularProjectionGeometryXMLFileReader.cxx
type rtk (line 30) | namespace rtk
function ReadGeometry (line 175) | ThreeDCircularProjectionGeometry::Pointer
FILE: src/rtkThreeDCircularProjectionGeometryXMLFileWriter.cxx
type rtk (line 31) | namespace rtk
FILE: src/rtkVarianObiXMLFileReader.cxx
type rtk (line 25) | namespace rtk
FILE: src/rtkVarianProBeamXMLFileReader.cxx
type rtk (line 25) | namespace rtk
FILE: src/rtkWatcherForResourceProbe.cxx
type rtk (line 21) | namespace rtk
function WatcherForResourceProbe (line 118) | WatcherForResourceProbe &
FILE: src/rtkXRadImageIOFactory.cxx
type itk (line 31) | namespace itk
FILE: src/rtkXimImageIO.cxx
function T (line 312) | inline T
function T (line 321) | inline T
function lut_to_bytes (line 340) | inline size_t
FILE: src/rtkXimImageIOFactory.cxx
type itk (line 33) | namespace itk
FILE: test/rtkI0estimationtest.cxx
function main (line 14) | int
FILE: test/rtkMaximumIntensity.py
function test_MaximumIntensity (line 6) | def test_MaximumIntensity():
FILE: test/rtkOutputArgumentWrapping.py
function test_IsIntersectedByRay (line 6) | def test_IsIntersectedByRay():
function test_ComputeFOVRadius (line 27) | def test_ComputeFOVRadius():
FILE: test/rtkTest.h
function CheckImageQuality (line 30) | void
function CheckImageQuality (line 38) | void
function CheckVectorImageQuality (line 110) | void
function CheckVectorImageQuality (line 118) | void
function CheckVariableLengthVectorImageQuality (line 191) | void
function CheckVariableLengthVectorImageQuality (line 199) | void
function CheckGeometries (line 281) | void
function CheckScalarProducts (line 340) | void
function CheckScalarProducts (line 347) | void
function CheckVectorScalarProducts (line 417) | void
function CheckVectorScalarProducts (line 424) | void
FILE: test/rtkTestReg23ProjectionGeometry.cxx
function PrintHelp (line 26) | void
function IntersectPlaneWithLine (line 55) | void
function main (line 88) | int
FILE: test/rtkadjointoperatorstest.cxx
function main (line 30) | int
FILE: test/rtkadmmtotalvariationtest.cxx
function main (line 25) | int
FILE: test/rtkadmmwaveletstest.cxx
function CheckImageQuality (line 16) | void
function CheckImageQuality (line 20) | void
function main (line 83) | int
FILE: test/rtkamsterdamshroudtest.cxx
function main (line 29) | int
FILE: test/rtkapplicationtest.py
function rtk_reference (line 10) | def rtk_reference(tmp_path_factory):
function rtk_workdir (line 27) | def rtk_workdir(tmp_path, rtk_reference):
function test_fdk_application (line 39) | def test_fdk_application(rtk_workdir):
function test_application_invocation_modes (line 44) | def test_application_invocation_modes(rtk_workdir):
function test_conjugategradient_application (line 70) | def test_conjugategradient_application(rtk_workdir):
function test_admmtotalvariation_application (line 75) | def test_admmtotalvariation_application(rtk_workdir):
FILE: test/rtkargsinfomanagertest.cxx
class args_info_test (line 5) | class args_info_test
method args_info_test (line 10) | args_info_test() = default;
class cleanup_functor (line 13) | class cleanup_functor
function cleanup_function (line 23) | void
function main (line 29) | int
FILE: test/rtkbinningtest.cxx
function main (line 18) | int
FILE: test/rtkbioscantest.cxx
function main (line 18) | int
FILE: test/rtkconjugategradientreconstructiontest.cxx
function main (line 24) | int
FILE: test/rtkconjugategradienttest.cxx
function CheckImageQuality (line 15) | void
function CheckImageQuality (line 19) | void
function main (line 104) | int
FILE: test/rtkcroptest.cxx
function main (line 9) | int
FILE: test/rtkcudaraycastadjointoperatorstest.cxx
function main (line 21) | int
FILE: test/rtkcyclicdeformationtest.cxx
function main (line 28) | int
FILE: test/rtkcylindricaldetectorreconstructiontest.cxx
function main (line 25) | int
FILE: test/rtkdecomposespectralprojectionstest.cxx
function main (line 25) | int
FILE: test/rtkdigisenstest.cxx
function main (line 23) | int
FILE: test/rtkdisplaceddetectorcompcudatest.cxx
function main (line 21) | int
FILE: test/rtkdisplaceddetectorcompoffsettest.cxx
function main (line 21) | int
FILE: test/rtkdisplaceddetectortest.cxx
function main (line 28) | int
FILE: test/rtkdivergencetest.cxx
function main (line 28) | int
FILE: test/rtkdrawgeometricphantomtest.cxx
function main (line 28) | int
FILE: test/rtkedftest.cxx
function main (line 17) | int
FILE: test/rtkelektatest.cxx
function main (line 23) | int
FILE: test/rtkfbpparalleltest.cxx
function main (line 30) | int
FILE: test/rtkfdkprojweightcompcudatest.cxx
function main (line 22) | int
FILE: test/rtkfdktest.cxx
function main (line 30) | int
FILE: test/rtkforbildtest.cxx
function main (line 18) | int
FILE: test/rtkforwardattenuatedprojectiontest.cxx
function main (line 34) | int
FILE: test/rtkforwardprojectiontest.cxx
function main (line 29) | int
FILE: test/rtkfourdadjointoperatorstest.cxx
function main (line 27) | int
FILE: test/rtkfourdconjugategradienttest.cxx
function main (line 28) | int
FILE: test/rtkfourdroostertest.cxx
function main (line 28) | int
FILE: test/rtkfourdsarttest.cxx
function main (line 29) | int
FILE: test/rtkfovtest.cxx
function main (line 23) | int
FILE: test/rtkgaincorrectiontest.cxx
function createDarkImage (line 55) | InputImageType::Pointer
function createGainImage (line 88) | OutputImageType::Pointer
function createInputImage (line 123) | InputImageType::Pointer
function generateExpectedOutput (line 141) | OutputImageType::Pointer
function main (line 206) | int
FILE: test/rtkgeometryclonetest.cxx
function main (line 5) | int
FILE: test/rtkgeometryfiletest.cxx
function WriteReadAndCheck (line 8) | void
function main (line 64) | int
FILE: test/rtkgeometryfrommatrixtest.cxx
function main (line 5) | int
FILE: test/rtkgradienttest.cxx
function CheckGradient (line 12) | void
function CheckGradient (line 18) | void
function main (line 88) | int
FILE: test/rtkheadertestfooter.cxx
function main (line 12) | int
FILE: test/rtkhilbertfiltertest.cxx
function main (line 15) | int
FILE: test/rtkimagxtest.cxx
function main (line 19) | int
FILE: test/rtkimporttest.cxx
function CheckError (line 20) | void
function CheckError (line 28) | void
function main (line 80) | int
FILE: test/rtkinterpolatesplatadjointtest.cxx
function main (line 27) | int
FILE: test/rtkiterativefdktest.cxx
function main (line 31) | int
FILE: test/rtkl0gradientnormtest.cxx
function ComputeL0NormAlongLastDimension (line 23) | static unsigned int
function CheckL0NormOfGradient (line 80) | void
function main (line 101) | int
FILE: test/rtklagcorrectiontest.cxx
function main (line 23) | int
FILE: test/rtklaplaciantest.cxx
function main (line 23) | int
FILE: test/rtklutbasedvarI0rawtoatttest.cxx
function fillImageWithRawData (line 16) | void
function main (line 31) | int
FILE: test/rtkluttest.cxx
function main (line 19) | int
FILE: test/rtkmaximumintensityprojectiontest.cxx
function main (line 23) | int
FILE: test/rtkmotioncompensatedfdktest.cxx
function main (line 27) | int
FILE: test/rtknewtonupdatetest.cxx
function main (line 19) | int
FILE: test/rtkoratest.cxx
function main (line 20) | int
FILE: test/rtkosemtest.cxx
function main (line 27) | int
FILE: test/rtkparallelgeometryfrommatrixtest.cxx
function main (line 5) | int
FILE: test/rtkprojectgeometricphantomtest.cxx
function main (line 24) | int
FILE: test/rtkrampfiltertest.cxx
function main (line 31) | int
FILE: test/rtkrampfiltertest2.cxx
function main (line 19) | int
FILE: test/rtkregularizedconjugategradienttest.cxx
function main (line 26) | int
FILE: test/rtksarttest.cxx
function main (line 26) | int
FILE: test/rtkscatterglarefiltertest.cxx
function createInputImage (line 52) | ImageType::Pointer
function main (line 93) | int
FILE: test/rtkselectoneprojpercycletest.cxx
function main (line 20) | int
FILE: test/rtkshortscancompcudatest.cxx
function main (line 21) | int
FILE: test/rtkshortscantest.cxx
function main (line 27) | int
FILE: test/rtkspectralonesteptest.cxx
function main (line 29) | int
FILE: test/rtktestexamples.py
function run_example (line 12) | def run_example(tmp_path, rel_script, *args):
function thorax_file (line 20) | def thorax_file(tmp_path):
function test_FirstCudaReconstructionExample (line 30) | def test_FirstCudaReconstructionExample(tmp_path):
function test_InlineReconstructionExample (line 35) | def test_InlineReconstructionExample(tmp_path):
function test_AddNoiseExample (line 38) | def test_AddNoiseExample(tmp_path):
function test_GeometricPhantomExample (line 41) | def test_GeometricPhantomExample(tmp_path, thorax_file):
function test_FirstReconstructionExample (line 44) | def test_FirstReconstructionExample(tmp_path):
function test_ConjugateGradient (line 49) | def test_ConjugateGradient(tmp_path, thorax_file):
FILE: test/rtktotalvariationtest.cxx
function CheckTotalVariation (line 9) | void
function main (line 51) | int
FILE: test/rtkvariancereconstructiontest.cxx
function main (line 27) | int
FILE: test/rtkvariantest.cxx
function main (line 23) | int
FILE: test/rtkvectorimageconverterstest.cxx
function main (line 24) | int
FILE: test/rtkwarpfourdtoprojectionstacktest.cxx
function main (line 28) | int
FILE: test/rtkwarpprojectionstacktofourdtest.cxx
function main (line 29) | int
FILE: test/rtkwarptest.cxx
function main (line 27) | int
FILE: test/rtkwaterprecorrectiontest.cxx
function main (line 14) | int
FILE: test/rtkwaveletstest.cxx
function CheckImageQuality (line 10) | void
function CheckImageQuality (line 14) | void
function main (line 75) | int
FILE: test/rtkweidingerforwardmodeltest.cxx
function main (line 20) | int
FILE: test/rtkxradtest.cxx
function main (line 22) | int
FILE: test/rtkzengforwardprojectiontest.cxx
function main (line 23) | int
FILE: utilities/UploadTestData.py
class GirderExternalDataCli (line 14) | class GirderExternalDataCli(GirderClient):
method __init__ (line 20) | def __init__(self, apiKey):
method _uploadContentLinkItem (line 28) | def _uploadContentLinkItem(
function main (line 96) | def main():
FILE: utilities/gengetopt/acceptedvalues.cpp
function string (line 31) | const string
FILE: utilities/gengetopt/acceptedvalues.h
function class (line 24) | class AcceptedValues : protected std::list<std::string>
FILE: utilities/gengetopt/cmdline.c
function init_help_array (line 81) | static void
type cmdline_parser_arg_type (line 127) | typedef enum {ARG_NO
type gengetopt_args_info (line 133) | struct gengetopt_args_info
type gengetopt_args_info (line 135) | struct gengetopt_args_info
type gengetopt_args_info (line 138) | struct gengetopt_args_info
type cmdline_parser_params (line 139) | struct cmdline_parser_params
type line_list (line 141) | struct line_list
type line_list (line 147) | struct line_list
type line_list (line 148) | struct line_list
function free_cmd_list (line 150) | static void
function clear_given (line 169) | static
function clear_args (line 205) | static
function init_args_info (line 239) | static
function cmdline_parser_print_version (line 278) | void
function print_help_common (line 286) | static void print_help_common(void) {
function cmdline_parser_print_help (line 301) | void
function cmdline_parser_print_detailed_help (line 310) | void
function cmdline_parser_init (line 319) | void
function cmdline_parser_params_init (line 327) | void
type cmdline_parser_params (line 340) | struct cmdline_parser_params
type cmdline_parser_params (line 343) | struct cmdline_parser_params
type cmdline_parser_params (line 344) | struct cmdline_parser_params
type cmdline_parser_params (line 344) | struct cmdline_parser_params
function free_string_field (line 349) | static void
function cmdline_parser_release (line 360) | static void
function write_into_file (line 397) | static void
function cmdline_parser_dump (line 409) | int
function cmdline_parser_file_save (line 488) | int
function cmdline_parser_free (line 508) | void
function cmdline_parser (line 529) | int
function cmdline_parser_ext (line 535) | int
function cmdline_parser2 (line 545) | int
function cmdline_parser_required (line 562) | int
function update_arg (line 591) | static
function cmdline_parser_internal (line 673) | int
function cmdline_parser_create_argv (line 1184) | static unsigned int
function cmdline_parser_string (line 1244) | int
function cmdline_parser_string2 (line 1250) | int
function cmdline_parser_string_ext (line 1265) | int
FILE: utilities/gengetopt/cmdline.h
type gengetopt_args_info (line 42) | struct gengetopt_args_info
type cmdline_parser_params (line 138) | struct cmdline_parser_params
type gengetopt_args_info (line 164) | struct gengetopt_args_info
type gengetopt_args_info (line 178) | struct gengetopt_args_info
type gengetopt_args_info (line 190) | struct gengetopt_args_info
type cmdline_parser_params (line 191) | struct cmdline_parser_params
type gengetopt_args_info (line 200) | struct gengetopt_args_info
type gengetopt_args_info (line 210) | struct gengetopt_args_info
type cmdline_parser_params (line 230) | struct cmdline_parser_params
type cmdline_parser_params (line 237) | struct cmdline_parser_params
type gengetopt_args_info (line 244) | struct gengetopt_args_info
type gengetopt_args_info (line 250) | struct gengetopt_args_info
type gengetopt_args_info (line 260) | struct gengetopt_args_info
type gengetopt_args_info (line 274) | struct gengetopt_args_info
type gengetopt_args_info (line 286) | struct gengetopt_args_info
type cmdline_parser_params (line 288) | struct cmdline_parser_params
type gengetopt_args_info (line 297) | struct gengetopt_args_info
FILE: utilities/gengetopt/fileutils.cpp
function ofstream (line 40) | ofstream *
FILE: utilities/gengetopt/gengetopt.cc
type gengetopt_args_info (line 101) | struct gengetopt_args_info
function main (line 103) | int
function output_formatted_string (line 335) | void
function gengetopt_define_package (line 355) | int
function gengetopt_define_version (line 364) | int
function gengetopt_define_purpose (line 373) | int
function gengetopt_define_description (line 382) | int
function gengetopt_define_usage (line 391) | int gengetopt_define_usage (char * s)
function gengetopt_add_group (line 399) | int
function gengetopt_add_mode (line 412) | int
function gengetopt_set_section (line 425) | void
function gengetopt_set_text (line 439) | void
function gengetopt_set_args (line 469) | void gengetopt_set_args(const char *a)
function gengetopt_has_option (line 480) | int
function check_numeric_validity (line 497) | bool check_numeric_validity(const char *val, int opt_type)
function check_values (line 527) | bool
function gengetopt_create_option (line 539) | int
function gengetopt_check_option (line 663) | int
function gengetopt_add_option (line 783) | int
function gengetopt_add_option (line 813) | int
function gengetopt_has_option (line 826) | int
function check_dependencies (line 844) | bool
function gengetopt_free (line 881) | void
function canonize_var (line 900) | static void
function canonize_vars (line 915) | int
function set_default_required_prop (line 923) | static void
function set_default_required_properties (line 930) | static void set_default_required_properties(void)
function print_copyright (line 935) | void
function print_reportbugs (line 944) | void
FILE: utilities/gengetopt/getopt.c
function exchange (line 298) | static void
function _getopt_internal (line 505) | int
function getopt (line 971) | int
function main (line 990) | int
FILE: utilities/gengetopt/getopt.h
type option (line 94) | struct option
type option (line 152) | struct option
type option (line 155) | struct option
type option (line 160) | struct option
FILE: utilities/gengetopt/getopt1.c
function getopt_long (line 66) | int
function getopt_long_only (line 82) | int
function main (line 100) | int
FILE: utilities/gengetopt/ggos.cpp
function ostream (line 28) | ostream & operator <<(std::ostream &s, gengetopt_option &opt) {
FILE: utilities/gengetopt/ggos.h
type gengetopt_option (line 23) | struct gengetopt_option
type std (line 65) | typedef std::list<gengetopt_option *> gengetopt_option_list;
FILE: utilities/gengetopt/gm.cc
function ModeOptionMap (line 107) | static const ModeOptionMap &getModeOptionMap() {
function ModeOptMap (line 128) | static const ModeOptMap &getModeOptMap() {
type gengetopt_option (line 144) | struct gengetopt_option
type gengetopt_option (line 259) | struct gengetopt_option
type gengetopt_option (line 294) | struct gengetopt_option
function string (line 406) | static const string from_value_to_enum(const string &name, const string ...
type gengetopt_option (line 414) | struct gengetopt_option
type gengetopt_option (line 451) | struct gengetopt_option
function _generate_option_arg (line 458) | void
type gengetopt_option (line 515) | struct gengetopt_option
type gengetopt_option (line 565) | struct gengetopt_option
type gengetopt_option (line 589) | struct gengetopt_option
function generate_option_usage_string (line 610) | static void generate_option_usage_string(gengetopt_option * opt, ostream...
function string (line 653) | const string
function generate_help_desc_print (line 722) | static void
type gengetopt_option (line 913) | struct gengetopt_option
function string (line 1001) | const string
function string (line 1014) | const string
function OptionHelpList (line 1028) | OptionHelpList *
function generate_counter_init (line 1268) | void generate_counter_init(const Collection &collection, const string &n...
type gengetopt_option (line 1286) | struct gengetopt_option
type gengetopt_option (line 1310) | struct gengetopt_option
type gengetopt_option (line 1354) | struct gengetopt_option
type gengetopt_option (line 1387) | struct gengetopt_option
type gengetopt_option (line 1410) | struct gengetopt_option
type gengetopt_option (line 1453) | struct gengetopt_option
type gengetopt_option (line 1515) | struct gengetopt_option
type gengetopt_option (line 1572) | struct gengetopt_option
function string (line 1592) | string
type gengetopt_option (line 1627) | struct gengetopt_option
type gengetopt_option (line 1818) | struct gengetopt_option
type gengetopt_option (line 1889) | struct gengetopt_option
function generate_counters (line 1917) | void generate_counters(const Collection &collection, const string &name,...
type gengetopt_option (line 1977) | struct gengetopt_option
type gengetopt_option (line 1989) | struct gengetopt_option
type gengetopt_option (line 2009) | struct gengetopt_option
FILE: utilities/gengetopt/gm.h
type gengetopt_option (line 32) | struct gengetopt_option
type std (line 34) | typedef std::list<std::string> OptionHelpList;
function inc_indent (line 64) | void inc_indent()
function dec_indent (line 69) | void dec_indent()
function indent (line 74) | void indent()
type gengetopt_option (line 82) | struct gengetopt_option
FILE: utilities/gengetopt/gm_utils.cpp
function string (line 42) | const string strip_path(const string &s) {
function string (line 55) | const string to_upper(const string &old) {
function string (line 64) | const string canonize_name(const string &old) {
function string (line 74) | const string canonize_enum(const string &old) {
function has_multiple_options_all_string (line 88) | bool has_multiple_options_all_string() {
function has_multiple_options_string (line 102) | bool has_multiple_options_string() {
function has_multiple_options (line 116) | bool has_multiple_options() {
function has_multiple_options_with_type (line 127) | bool has_multiple_options_with_type() {
function has_multiple_options_with_default (line 138) | bool has_multiple_options_with_default() {
function has_options_with_details (line 149) | bool has_options_with_details() {
function has_options_with_type (line 160) | bool has_options_with_type() {
function has_options_with_mode (line 171) | bool has_options_with_mode() {
function has_required (line 182) | bool has_required() {
function has_dependencies (line 201) | bool has_dependencies() {
function has_options (line 212) | bool has_options() {
function has_hidden_options (line 225) | bool has_hidden_options() {
function has_values (line 237) | bool has_values() {
function not_newlines (line 251) | int not_newlines(const string &buf, int &num_of_newlines) {
function wrap_cstr (line 271) | void wrap_cstr(string& wrapped, unsigned int from_column,
function is_numeric (line 322) | bool is_numeric(const gengetopt_option *opt) {
FILE: utilities/gengetopt/parser.cc
function check_result (line 110) | void check_result(int o, gengetopt_option *opt)
type multiple_size (line 179) | struct multiple_size
method multiple_size (line 189) | multiple_size(const char *m = "0", const char *M = "0") :
type yytokentype (line 225) | enum yytokentype {
class AcceptedValues (line 314) | class AcceptedValues
type gengetopt_option (line 315) | struct gengetopt_option
type multiple_size (line 316) | struct multiple_size
method multiple_size (line 189) | multiple_size(const char *m = "0", const char *M = "0") :
type YYLTYPE (line 329) | struct YYLTYPE
function YYSIZE_T (line 1172) | static YYSIZE_T
function YYSIZE_T (line 1219) | static YYSIZE_T
FILE: utilities/gengetopt/parser.h
type yytokentype (line 41) | enum yytokentype {
type YYSTYPE (line 120) | typedef union YYSTYPE
type YYLTYPE (line 147) | typedef struct YYLTYPE
FILE: utilities/gengetopt/scanner.cc
type yy_buffer_state (line 162) | struct yy_buffer_state
type yy_buffer_state (line 211) | struct yy_buffer_state
type yy_trans_info (line 392) | struct yy_trans_info
function yy_get_next_buffer (line 1442) | static int yy_get_next_buffer (void)
function yy_state_type (line 1576) | static yy_state_type yy_get_previous_state (void)
function yy_state_type (line 1608) | static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
function input (line 1635) | static int input (void)
function yyrestart (line 1715) | void yyrestart (FILE * input_file )
function yy_switch_to_buffer (line 1732) | void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
function yy_load_buffer_state (line 1763) | static void yy_load_buffer_state (void)
function YY_BUFFER_STATE (line 1777) | YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
function yy_delete_buffer (line 1805) | void yy_delete_buffer (YY_BUFFER_STATE b )
function yy_init_buffer (line 1828) | static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
function yy_flush_buffer (line 1856) | void yy_flush_buffer (YY_BUFFER_STATE b )
function yypush_buffer_state (line 1885) | void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
function yypop_buffer_state (line 1915) | void yypop_buffer_state (void)
function yyensure_buffer_stack (line 1934) | static void yyensure_buffer_stack (void)
function YY_BUFFER_STATE (line 1983) | YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
function YY_BUFFER_STATE (line 2020) | YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
function YY_BUFFER_STATE (line 2033) | YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
function yy_push_state (line 2063) | static void yy_push_state (int new_state )
function yy_pop_state (line 2087) | static void yy_pop_state (void)
function yy_top_state (line 2095) | static int yy_top_state (void)
function yy_fatal_error (line 2104) | static void yy_fatal_error (yyconst char* msg )
FILE: utilities/gengetopt/skels/c_source.h
function class (line 16) | class c_source_gen_class
FILE: utilities/gengetopt/skels/check_modes.h
function class (line 16) | class check_modes_gen_class
FILE: utilities/gengetopt/skels/clear_arg.h
function class (line 16) | class clear_arg_gen_class
function set_has_arg (line 59) | void set_has_arg(bool _has_arg)
function set_has_orig (line 64) | void set_has_orig(bool _has_orig)
function set_name (line 69) | void set_name(const string &_name)
function set_suffix (line 74) | void set_suffix(const string &_suffix)
function set_value (line 79) | void set_value(const string &_value)
FILE: utilities/gengetopt/skels/clear_given.h
function class (line 16) | class clear_given_gen_class
FILE: utilities/gengetopt/skels/copyright.h
function class (line 16) | class copyright_gen_class
FILE: utilities/gengetopt/skels/custom_getopt_gen.h
function class (line 16) | class custom_getopt_gen_gen_class
FILE: utilities/gengetopt/skels/dependant_option.h
function class (line 16) | class dependant_option_gen_class
FILE: utilities/gengetopt/skels/enum_decl.h
function class (line 16) | class enum_decl_gen_class
FILE: utilities/gengetopt/skels/exit_failure.h
function class (line 16) | class exit_failure_gen_class
function set_handle_error (line 56) | void set_handle_error(bool _handle_error)
function set_parser_name (line 61) | void set_parser_name(const string &_parser_name)
FILE: utilities/gengetopt/skels/file_save.h
function class (line 16) | class file_save_gen_class
FILE: utilities/gengetopt/skels/file_save_multiple.h
function class (line 16) | class file_save_multiple_gen_class
function set_has_arg (line 58) | void set_has_arg(bool _has_arg)
function set_opt_name (line 63) | void set_opt_name(const string &_opt_name)
function set_opt_var (line 68) | void set_opt_var(const string &_opt_var)
function set_values (line 73) | void set_values(const string &_values)
FILE: utilities/gengetopt/skels/free_list.h
function class (line 16) | class free_list_gen_class
FILE: utilities/gengetopt/skels/free_multiple.h
function class (line 16) | class free_multiple_gen_class
function set_has_string_type (line 57) | void set_has_string_type(bool _has_string_type)
function set_opt_var (line 62) | void set_opt_var(const string &_opt_var)
function set_structure (line 67) | void set_structure(const string &_structure)
FILE: utilities/gengetopt/skels/free_string.h
function class (line 16) | class free_string_gen_class
function set_has_string_type (line 57) | void set_has_string_type(bool _has_string_type)
function set_opt_var (line 62) | void set_opt_var(const string &_opt_var)
function set_structure (line 67) | void set_structure(const string &_structure)
FILE: utilities/gengetopt/skels/generic_option.h
function class (line 16) | class generic_option_gen_class
function set_arg_type (line 70) | void set_arg_type(const string &_arg_type)
function set_default_value (line 75) | void set_default_value(const string &_default_value)
function set_final_instructions (line 80) | void set_final_instructions(const string &_final_instructions)
function set_gen_else (line 85) | void set_gen_else(const string &_gen_else)
function set_group_var_name (line 90) | void set_group_var_name(const string &_group_var_name)
function set_has_short_option (line 95) | void set_has_short_option(bool _has_short_option)
function set_long_option (line 100) | void set_long_option(const string &_long_option)
function set_multiple (line 105) | void set_multiple(bool _multiple)
function set_option_comment (line 110) | void set_option_comment(const string &_option_comment)
function set_option_has_group (line 115) | void set_option_has_group(bool _option_has_group)
function set_option_has_mode (line 120) | void set_option_has_mode(bool _option_has_mode)
function set_option_has_type (line 125) | void set_option_has_type(bool _option_has_type)
function set_option_var_name (line 130) | void set_option_var_name(const string &_option_var_name)
function set_possible_values (line 135) | void set_possible_values(const string &_possible_values)
function set_short_option (line 140) | void set_short_option(const string &_short_option)
function set_structure (line 145) | void set_structure(const string &_structure)
FILE: utilities/gengetopt/skels/given_field.h
function class (line 16) | class given_field_gen_class
FILE: utilities/gengetopt/skels/group_counter.h
function class (line 16) | class group_counter_gen_class
FILE: utilities/gengetopt/skels/group_option.h
function class (line 16) | class group_option_gen_class
FILE: utilities/gengetopt/skels/handle_help.h
function class (line 16) | class handle_help_gen_class
function set_detailed_help (line 58) | void set_detailed_help(bool _detailed_help)
function set_full_help (line 63) | void set_full_help(bool _full_help)
function set_parser_name (line 68) | void set_parser_name(const string &_parser_name)
function set_short_opt (line 73) | void set_short_opt(bool _short_opt)
FILE: utilities/gengetopt/skels/handle_version.h
function class (line 16) | class handle_version_gen_class
FILE: utilities/gengetopt/skels/header.h
function class (line 16) | class header_gen_class
FILE: utilities/gengetopt/skels/init_args_info.h
function class (line 16) | class init_args_info_gen_class
FILE: utilities/gengetopt/skels/multiple_fill_array.h
function class (line 16) | class multiple_fill_array_gen_class
FILE: utilities/gengetopt/skels/multiple_opt_list.h
function class (line 16) | class multiple_opt_list_gen_class
FILE: utilities/gengetopt/skels/option_arg.h
function class (line 16) | class option_arg_gen_class
function set_default_on (line 67) | void set_default_on(bool _default_on)
function set_default_value (line 72) | void set_default_value(const string &_default_value)
function set_desc (line 77) | void set_desc(const string &_desc)
function set_flag_arg (line 82) | void set_flag_arg(bool _flag_arg)
function set_has_arg (line 87) | void set_has_arg(bool _has_arg)
function set_has_default (line 92) | void set_has_default(bool _has_default)
function set_has_enum (line 97) | void set_has_enum(bool _has_enum)
function set_long_long_arg (line 102) | void set_long_long_arg(bool _long_long_arg)
function set_longtype (line 107) | void set_longtype(const string &_longtype)
function set_multiple (line 112) | void set_multiple(bool _multiple)
function set_name (line 117) | void set_name(const string &_name)
function set_origtype (line 122) | void set_origtype(const string &_origtype)
function set_type (line 127) | void set_type(const string &_type)
FILE: utilities/gengetopt/skels/print_help_string.h
function class (line 16) | class print_help_string_gen_class
FILE: utilities/gengetopt/skels/required_option.h
function class (line 16) | class required_option_gen_class
function set_checkrange (line 59) | void set_checkrange(bool _checkrange)
function set_mode_condition (line 64) | void set_mode_condition(const string &_mode_condition)
function set_option_descr (line 69) | void set_option_descr(const string &_option_descr)
function set_option_var_name (line 74) | void set_option_var_name(const string &_option_var_name)
function set_package_var_name (line 79) | void set_package_var_name(const string &_package_var_name)
FILE: utilities/gengetopt/skels/reset_group.h
function class (line 16) | class reset_group_gen_class
FILE: utilities/gengetopt/skels/update_given.h
function class (line 16) | class update_given_gen_class
FILE: utilities/gengetopt/yyerror.cc
function yyerror (line 26) | void
function yyerror (line 42) | void
FILE: utilities/gengetopt/yywrap.c
function yywrap (line 12) | int
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol.c
function MYBOOL (line 73) | MYBOOL LUSOL_realloc_a(LUSOLrec *LUSOL, int newsize)
function MYBOOL (line 100) | MYBOOL LUSOL_expand_a(LUSOLrec *LUSOL, int *delta_lena, int *right_shift)
function MYBOOL (line 135) | MYBOOL LUSOL_realloc_r(LUSOLrec *LUSOL, int newsize)
function MYBOOL (line 182) | MYBOOL LUSOL_realloc_c(LUSOLrec *LUSOL, int newsize)
function LUSOLrec (line 248) | LUSOLrec *LUSOL_create(FILE *outstream, int msgfil, int pivotmodel, int ...
function MYBOOL (line 288) | MYBOOL LUSOL_sizeto(LUSOLrec *LUSOL, int init_r, int init_c, int init_a)
function LUSOL_setpivotmodel (line 307) | void LUSOL_setpivotmodel(LUSOLrec *LUSOL, int pivotmodel, int initlevel)
function MYBOOL (line 358) | MYBOOL LUSOL_tightenpivot(LUSOLrec *LUSOL)
function MYBOOL (line 389) | MYBOOL LUSOL_addSingularity(LUSOLrec *LUSOL, int singcol, int *inform)
function LUSOL_getSingularity (line 426) | int LUSOL_getSingularity(LUSOLrec *LUSOL, int singitem)
function LUSOL_findSingularityPosition (line 439) | int LUSOL_findSingularityPosition(LUSOLrec *LUSOL, int singcol)
function LUSOL_clear (line 479) | void LUSOL_clear(LUSOLrec *LUSOL, MYBOOL nzonly)
function MYBOOL (line 532) | MYBOOL LUSOL_assign(LUSOLrec *LUSOL, int iA[], int jA[], REAL Aij[], int...
function LUSOL_loadColumn (line 581) | int LUSOL_loadColumn(LUSOLrec *LUSOL, int iA[], int jA, REAL Aij[], int ...
function LUSOL_free (line 612) | void LUSOL_free(LUSOLrec *LUSOL)
function LUSOL_report (line 626) | void LUSOL_report(LUSOLrec *LUSOL, int msglevel, const char *format, ...)
function LUSOL_timer (line 653) | void LUSOL_timer(LUSOLrec *LUSOL, int timerid, const char *text)
function LUSOL_factorize (line 659) | int LUSOL_factorize(LUSOLrec *LUSOL)
function LUSOL_ftran (line 667) | int LUSOL_ftran(LUSOLrec *LUSOL, REAL b[], int NZidx[], MYBOOL prepareup...
function LUSOL_btran (line 691) | int LUSOL_btran(LUSOLrec *LUSOL, REAL b[], int NZidx[])
function LUSOL_replaceColumn (line 709) | int LUSOL_replaceColumn(LUSOLrec *LUSOL, int jcol, REAL v[])
function REAL (line 722) | REAL LUSOL_vecdensity(LUSOLrec *LUSOL, REAL V[])
function relationChar (line 732) | char relationChar(REAL left, REAL right)
function LUSOL_dump (line 751) | void LUSOL_dump(FILE *output, LUSOLrec *LUSOL)
function LUSOLmat (line 779) | LUSOLmat *LUSOL_matcreate(int dim, int nz)
function LUSOL_matfree (line 797) | void LUSOL_matfree(LUSOLmat **mat)
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol.h
type LUSOLmat (line 259) | typedef struct _LUSOLmat {
type LUSOLrec (line 267) | typedef struct _LUSOLrec {
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol1.c
function else (line 301) | else if(M>K) {
function LU1PQ1 (line 355) | void LU1PQ1(LUSOLrec *LUSOL, int M, int N, int LEN[],
function LU1PQ2 (line 412) | void LU1PQ2(LUSOLrec *LUSOL, int NZPIV, int *NZCHNG,
function LU1PQ3 (line 471) | void LU1PQ3(LUSOLrec *LUSOL, int MN, int LEN[], int IPERM[], int IW[], i...
function LU1REC (line 522) | void LU1REC(LUSOLrec *LUSOL, int N, MYBOOL REALS, int *LTOP,
function LU1SLK (line 594) | void LU1SLK(LUSOLrec *LUSOL)
function LU1MAR (line 905) | void LU1MAR(LUSOLrec *LUSOL, int MAXMN, MYBOOL TCP, REAL AIJTOL, REAL LTOL,
function LU1MCP (line 1156) | void LU1MCP(LUSOLrec *LUSOL, REAL AIJTOL, int *IBEST, int *JBEST, int *M...
function LU1MRP (line 1267) | void LU1MRP(LUSOLrec *LUSOL, int MAXMN, REAL LTOL, int MAXCOL, int MAXROW,
function LU1MSP (line 1458) | void LU1MSP(LUSOLrec *LUSOL, int MAXMN, REAL LTOL, int MAXCOL,
function LU1MXC (line 1571) | void LU1MXC(LUSOLrec *LUSOL, int K1, int K2, int IX[])
function LU1MXR (line 1607) | void LU1MXR(LUSOLrec *LUSOL, int K1, int K2, int IX[], REAL AMAXR[])
function LU1FUL (line 1664) | void LU1FUL(LUSOLrec *LUSOL, int LEND, int LU1, MYBOOL TPP,
function LU1OR1 (line 1813) | void LU1OR1(LUSOLrec *LUSOL, REAL SMALL,
function LU1OR2 (line 1876) | void LU1OR2(LUSOLrec *LUSOL)
function LU1OR3 (line 1937) | void LU1OR3(LUSOLrec *LUSOL, int *LERR, int *INFORM)
function LU1OR4 (line 1975) | void LU1OR4(LUSOLrec *LUSOL)
function LU1FAD (line 2231) | void LU1FAD(LUSOLrec *LUSOL,
function LU1FAC (line 3361) | void LU1FAC(LUSOLrec *LUSOL, int *INFORM)
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol2.c
function HDOWN (line 42) | void HDOWN(REAL HA[], int HJ[], int HK[], int N, int K, int *HOPS)
function HUP (line 85) | void HUP(REAL HA[], int HJ[], int HK[], int K, int *HOPS)
function HINSERT (line 126) | void HINSERT(REAL HA[], int HJ[], int HK[], int N,
function HCHANGE (line 142) | void HCHANGE(REAL HA[], int HJ[], int HK[], int N, int K,
function HDELETE (line 165) | void HDELETE(REAL HA[], int HJ[], int HK[], int *N, int K, int *HOPS)
function HBUILD (line 191) | void HBUILD(REAL HA[], int HJ[], int HK[], int N, int *HOPS)
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol6a.c
function LU6CHK (line 70) | void LU6CHK(LUSOLrec *LUSOL, int MODE, int LENA2, int *INFORM)
function LU6CHK (line 194) | void LU6CHK(LUSOLrec *LUSOL, int MODE, int LENA2, int *INFORM)
function LU6L (line 355) | void LU6L(LUSOLrec *LUSOL, int *INFORM, REAL V[], int NZidx[])
function LU6LD (line 449) | void LU6LD(LUSOLrec *LUSOL, int *INFORM, int MODE, REAL V[], int NZidx[])
function LU6LT (line 512) | void LU6LT(LUSOLrec *LUSOL, int *INFORM, REAL V[], int NZidx[])
function print_L0 (line 603) | void print_L0(LUSOLrec *LUSOL)
function LU6U (line 646) | void LU6U(LUSOLrec *LUSOL, int *INFORM, REAL V[], REAL W[], int NZidx[])
function LU6SOL (line 842) | void LU6SOL(LUSOLrec *LUSOL, int MODE, REAL V[], REAL W[], int NZidx[], ...
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol6l0.c
function MYBOOL (line 6) | MYBOOL LU1L0(LUSOLrec *LUSOL, LUSOLmat **mat, int *inform)
function LU6L0T_v (line 106) | void LU6L0T_v(LUSOLrec *LUSOL, LUSOLmat *mat, REAL V[], int NZidx[], int...
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol6u.c
function MYBOOL (line 6) | MYBOOL LU1U0(LUSOLrec *LUSOL, LUSOLmat **mat, int *inform)
function LU6U0_v (line 95) | void LU6U0_v(LUSOLrec *LUSOL, LUSOLmat *mat, REAL V[], REAL W[], int NZi...
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol7a.c
function LU7ADD (line 21) | void LU7ADD(LUSOLrec *LUSOL, int JADD, REAL V[], int LENL, int *LENU,
function LU7CYC (line 108) | void LU7CYC(LUSOLrec *LUSOL, int KFIRST, int KLAST, int IX[])
function LU7ELM (line 150) | void LU7ELM(LUSOLrec *LUSOL, int JELM, REAL V[], int *LENL,
function LU7FOR (line 267) | void LU7FOR(LUSOLrec *LUSOL, int KFIRST, int KLAST, int *LENL, int *LENU,
function LU7RNK (line 570) | void LU7RNK(LUSOLrec *LUSOL, int JSING, int *LENU,
function LU7ZAP (line 660) | void LU7ZAP(LUSOLrec *LUSOL, int JZAP, int *KZAP, int *LENU, int *LROW,
FILE: utilities/lp_solve/bfp/bfp_LUSOL/LUSOL/lusol8a.c
function LU8RPC (line 47) | void LU8RPC(LUSOLrec *LUSOL, int MODE1, int MODE2,
FILE: utilities/lp_solve/bfp/bfp_LUSOL/lp_LUSOL.c
function bfp_name (line 42) | bfp_name(void)
function MYBOOL (line 49) | MYBOOL BFP_CALLMODEL bfp_resize(lprec *lp, int newsize)
function bfp_free (line 129) | void BFP_CALLMODEL bfp_free(lprec *lp)
function bfp_nonzeros (line 150) | int BFP_CALLMODEL bfp_nonzeros(lprec *lp, MYBOOL maximum)
function bfp_memallocated (line 166) | int BFP_CALLMODEL bfp_memallocated(lprec *lp)
function bfp_preparefactorization (line 184) | int BFP_CALLMODEL bfp_preparefactorization(lprec *lp)
function bfp_LUSOLsetcolumn (line 207) | int bfp_LUSOLsetcolumn(lprec *lp, int posnr, int colnr)
function bfp_LUSOLidentity (line 218) | int bfp_LUSOLidentity(lprec *lp, int *rownum)
function bfp_LUSOLfactorize (line 242) | int bfp_LUSOLfactorize(lprec *lp, MYBOOL *usedpos, int *rownum, int *sin...
function bfp_LUSOLtighten (line 318) | void bfp_LUSOLtighten(lprec *lp)
function MYBOOL (line 335) | static MYBOOL is_fixedvar(lprec *lp, int variable)
function bfp_factorize (line 344) | int BFP_CALLMODEL bfp_factorize(lprec *lp, int uservars, int Bsize, MYBO...
function MYBOOL (line 476) | MYBOOL BFP_CALLMODEL bfp_finishupdate(lprec *lp, MYBOOL changesign)
function bfp_ftran_normal (line 584) | void BFP_CALLMODEL bfp_ftran_normal(lprec *lp, REAL *pcol, int *nzidx)
function bfp_ftran_prepare (line 602) | void BFP_CALLMODEL bfp_ftran_prepare(lprec *lp, REAL *pcol, int *nzidx)
function bfp_btran_normal (line 620) | void BFP_CALLMODEL bfp_btran_normal(lprec *lp, REAL *prow, int *nzidx)
function bfp_findredundant (line 653) | int BFP_CALLMODEL bfp_findredundant(lprec *lp, int items, getcolumnex_fu...
FILE: utilities/lp_solve/bfp/bfp_LUSOL/lp_LUSOL.h
type _INVrec (line 19) | struct _INVrec
FILE: utilities/lp_solve/bfp/lp_BFP1.c
function MYBOOL (line 15) | MYBOOL BFP_CALLMODEL bfp_compatible(lprec *lp, int bfpversion, int lpver...
function bfp_status (line 32) | int BFP_CALLMODEL bfp_status(lprec *lp)
function bfp_indexbase (line 38) | int BFP_CALLMODEL bfp_indexbase(lprec *lp)
function bfp_rowoffset (line 45) | int BFP_CALLMODEL bfp_rowoffset(lprec *lp)
function bfp_pivotmax (line 54) | int BFP_CALLMODEL bfp_pivotmax(lprec *lp)
function REAL (line 69) | REAL BFP_CALLMODEL bfp_efficiency(lprec *lp)
function bfp_pivotcount (line 82) | int BFP_CALLMODEL bfp_pivotcount(lprec *lp)
function bfp_refactcount (line 89) | int BFP_CALLMODEL bfp_refactcount(lprec *lp, int kind)
function MYBOOL (line 102) | MYBOOL BFP_CALLMODEL bfp_mustrefactorize(lprec *lp)
function MYBOOL (line 147) | MYBOOL BFP_CALLMODEL bfp_isSetI(lprec *lp)
function bfp_updaterefactstats (line 184) | void BFP_CALLMODEL bfp_updaterefactstats(lprec *lp)
function bfp_rowextra (line 204) | int BFP_CALLMODEL bfp_rowextra(lprec *lp)
FILE: utilities/lp_solve/bfp/lp_BFP2.c
function MYBOOL (line 9) | MYBOOL BFP_CALLMODEL bfp_init(lprec *lp, int size, int delta, const char...
function MYBOOL (line 37) | MYBOOL BFP_CALLMODEL bfp_restart(lprec *lp)
function MYBOOL (line 60) | MYBOOL BFP_CALLMODEL bfp_implicitslack(lprec *lp)
function bfp_colcount (line 67) | int BFP_CALLMODEL bfp_colcount(lprec *lp)
function MYBOOL (line 74) | MYBOOL BFP_CALLMODEL bfp_canresetbasis(lprec *lp)
function MYBOOL (line 82) | MYBOOL BFP_CALLMODEL bfp_pivotalloc(lprec *lp, int newsize)
function bfp_finishfactorization (line 92) | void BFP_CALLMODEL bfp_finishfactorization(lprec *lp)
function LREAL (line 113) | LREAL BFP_CALLMODEL bfp_prepareupdate(lprec *lp, int row_nr, int col_nr,...
function REAL (line 143) | REAL BFP_CALLMODEL bfp_pivotRHS(lprec *lp, LREAL theta, REAL *pcol)
function bfp_btran_double (line 176) | void BFP_CALLMODEL bfp_btran_double(lprec *lp, REAL *prow, int *pnzidx, ...
FILE: utilities/lp_solve/colamd/colamd.c
function PUBLIC (line 954) | PUBLIC int colamd_recommended /* returns recommended value of Alen. */
function PUBLIC (line 988) | PUBLIC void colamd_set_defaults
function PUBLIC (line 1016) | PUBLIC int symamd /* return TRUE if OK, FALSE otherwise */
function PUBLIC (line 1361) | PUBLIC int colamd /* returns TRUE if successful, FALSE otherwise*/
function PUBLIC (line 1520) | PUBLIC void colamd_report
function PUBLIC (line 1533) | PUBLIC void symamd_report
function PRIVATE (line 1563) | PRIVATE int init_rows_cols /* returns TRUE if OK, or FALSE otherwise */
function PRIVATE (line 1800) | PRIVATE void init_scoring
function PRIVATE (line 2056) | PRIVATE int find_ordering /* return the number of garbage collections */
function PRIVATE (line 2620) | PRIVATE void order_children
function PRIVATE (line 2878) | PRIVATE int garbage_collection /* returns the new value of pfree */
function PRIVATE (line 3014) | PRIVATE int clear_mark /* return the new value for tag_mark */
function PRIVATE (line 3041) | PRIVATE void print_report
function PRIVATE (line 3189) | PRIVATE void debug_structures
function PRIVATE (line 3276) | PRIVATE void debug_deg_lists
function PRIVATE (line 3350) | PRIVATE void debug_mark
function PRIVATE (line 3386) | PRIVATE void debug_matrix
function PRIVATE (line 3451) | PRIVATE void colamd_get_debug
FILE: utilities/lp_solve/colamd/colamd.h
type Colamd_Col (line 120) | typedef struct Colamd_Col_struct
type Colamd_Row (line 153) | typedef struct Colamd_Row_struct
FILE: utilities/lp_solve/fortify.c
type Header (line 76) | struct Header
type Header (line 95) | struct Header
type Header (line 100) | struct Header
type Header (line 101) | struct Header
type Header (line 102) | struct Header
type Header (line 103) | struct Header
type Header (line 104) | struct Header
type Header (line 105) | struct Header
function strnicmp (line 113) | static int strnicmp(s1,s2,maxlen)
function stricmp (line 125) | static int stricmp(s1,s2)
function TimeToCheck (line 145) | int TimeToCheck()
function _Fortify_NoOutput (line 165) | static void _Fortify_NoOutput()
function st_DefaultOutput (line 169) | static void st_DefaultOutput(char *String)
function WaitIfstdOutput (line 324) | static void WaitIfstdOutput()
type Header (line 407) | struct Header
function _Fortify_Init (line 417) | void FORTIFY_STORAGE
type Header (line 455) | struct Header
type Header (line 512) | struct Header
type Header (line 528) | struct Header
type Header (line 546) | struct Header
type Header (line 572) | struct Header
type Header (line 574) | struct Header
type Header (line 581) | struct Header
type Header (line 592) | struct Header
function _Fortify_free (line 609) | void FORTIFY_STORAGE
type Header (line 715) | struct Header
type Header (line 723) | struct Header
type Header (line 723) | struct Header
function __Fortify_CheckPointer (line 793) | static int FORTIFY_STORAGE
function _Fortify_CheckPointer (line 831) | int FORTIFY_STORAGE
function Fortify_OutputFuncPtr (line 843) | Fortify_OutputFuncPtr FORTIFY_STORAGE
function _Fortify_SetMallocFailRate (line 859) | int FORTIFY_STORAGE
function _Fortify_CheckAllMemory (line 876) | int FORTIFY_STORAGE
function _Fortify_EnterScope (line 914) | int FORTIFY_STORAGE
function _Fortify_LeaveScope (line 924) | int FORTIFY_STORAGE
function _Fortify_OutputAllMemory (line 988) | int FORTIFY_STORAGE
function _Fortify_DumpAllMemory (line 1044) | int FORTIFY_STORAGE
function _Fortify_Disable (line 1111) | int FORTIFY_STORAGE
function CheckBlock (line 1152) | static int CheckBlock(struct Header *h,char *file,unsigned long line)
function CheckPointer (line 1211) | static int CheckPointer(unsigned char *ptr,unsigned long size,char *file...
function CheckFortification (line 1280) | static int CheckFortification(unsigned char *ptr,unsigned char value,siz...
function SetFortification (line 1292) | static void SetFortification(unsigned char *ptr,unsigned char value,size...
function OutputFortification (line 1301) | static void
function IsHeaderValid (line 1356) | static int IsHeaderValid(struct Header *h)
function MakeHeaderValid (line 1364) | static void MakeHeaderValid(struct Header *h)
function ChecksumHeader (line 1375) | static int ChecksumHeader(struct Header *h)
function IsOnList (line 1388) | static int IsOnList(struct Header *h)
function OutputMemory (line 1407) | static void
function OutputHeader (line 1418) | static void OutputHeader(struct Header *h)
function OutputLastVerifiedPoint (line 1427) | static void OutputLastVerifiedPoint()
function _Fortify_free (line 1446) | void FORTIFY_STORAGE
function _Fortify_CheckPointer (line 1465) | int FORTIFY_STORAGE
function Fortify_OutputFuncPtr (line 1474) | Fortify_OutputFuncPtr FORTIFY_STORAGE
function _Fortify_SetMallocFailRate (line 1481) | int FORTIFY_STORAGE
function _Fortify_CheckAllMemory (line 1488) | int FORTIFY_STORAGE
function _Fortify_EnterScope (line 1496) | int FORTIFY_STORAGE
function _Fortify_LeaveScope (line 1504) | int FORTIFY_STORAGE
function _Fortify_OutputAllMemory (line 1512) | int FORTIFY_STORAGE
function _Fortify_DumpAllMemory (line 1520) | int FORTIFY_STORAGE
function _Fortify_Disable (line 1529) | int FORTIFY_STORAGE
function _Fortify_memcmp (line 1754) | int FORTIFY_STORAGE
function _Fortify_memicmp (line 1779) | int FORTIFY_STORAGE
function _Fortify_strcoll (line 1804) | int FORTIFY_STORAGE
function _Fortify_strcspn (line 1829) | size_t FORTIFY_STORAGE
function _Fortify_strcmp (line 1854) | int FORTIFY_STORAGE
function _Fortify_strcmpi (line 1879) | int FORTIFY_STORAGE
function _Fortify_strncmp (line 1904) | int FORTIFY_STORAGE
function _Fortify_strnicmp (line 1929) | int FORTIFY_STORAGE
function _Fortify_strlen (line 2049) | size_t FORTIFY_STORAGE
function _Fortify_strtol (line 2155) | long FORTIFY_STORAGE
function _Fortify_atoi (line 2176) | int FORTIFY_STORAGE
function _Fortify_atol (line 2197) | long FORTIFY_STORAGE
function _Fortify_atof (line 2218) | double FORTIFY_STORAGE
function _Fortify_strtoul (line 2239) | unsigned long FORTIFY_STORAGE
function _Fortify_strtod (line 2260) | double FORTIFY_STORAGE
FILE: utilities/lp_solve/ini.c
function FILE (line 9) | FILE *ini_create(const char *filename)
function FILE (line 18) | FILE *ini_open(const char *filename)
function ini_writecomment (line 27) | void ini_writecomment(FILE *fp, const char *comment)
function ini_writeheader (line 32) | void ini_writeheader(FILE *fp, const char *header, int addnewline)
function ini_writedata (line 39) | void ini_writedata(FILE *fp, const char *name, const char *data)
function ini_readdata (line 47) | int ini_readdata(FILE *fp, char * const data, int szdata, int withcomment)
function ini_close (line 73) | void ini_close(FILE *fp)
FILE: utilities/lp_solve/lp_Hash.c
function STATIC (line 17) | STATIC hashtable *create_hash_table(int size, int base)
function STATIC (line 47) | STATIC void free_hash_item(hashelem **hp)
function STATIC (line 54) | STATIC void free_hash_table(hashtable *ht)
function STATIC (line 75) | STATIC int hashval(const char *string, int size)
function STATIC (line 91) | STATIC hashelem *findhash(const char *name, hashtable *ht)
function STATIC (line 103) | STATIC hashelem *puthash(const char *name, int index, hashelem **list, h...
function STATIC (line 137) | STATIC void drophash(const char *name, hashelem **list, hashtable *ht) {
function STATIC (line 179) | STATIC hashtable *copy_hash_table(hashtable *ht, hashelem **list, int ne...
function STATIC (line 202) | STATIC int find_row(lprec *lp, const char *name, MYBOOL Unconstrained_ro...
function STATIC (line 222) | STATIC int find_var(lprec *lp, const char *name, MYBOOL verbose)
FILE: utilities/lp_solve/lp_Hash.h
type hashelem (line 6) | typedef struct _hashelem
type hashtable (line 14) | typedef struct /* _hashtable */
FILE: utilities/lp_solve/lp_MDO.c
function STATIC (line 31) | STATIC MYBOOL includeMDO(MYBOOL *usedpos, int item)
function STATIC (line 54) | STATIC int prepareMDO(lprec *lp, MYBOOL *usedpos, int *colorder, int *da...
function STATIC (line 128) | STATIC MYBOOL verifyMDO(lprec *lp, int *col_end, int *row_nr, int rowmax...
function mdo_free (line 151) | void mdo_free(void *mem)
function getMDO (line 157) | int __WINAPI getMDO(lprec *lp, MYBOOL *usedpos, int *colorder, int *size...
FILE: utilities/lp_solve/lp_MPS.c
function STATIC (line 92) | STATIC void namecpy(char *into, const char *from)
function STATIC (line 112) | STATIC int scan_lineFIXED(lprec *lp, int section, char* line, char *fiel...
function STATIC (line 222) | STATIC int spaces(char *line, int line_len)
function STATIC (line 235) | STATIC int lenfield(char *line, int line_len)
function STATIC (line 249) | STATIC int scan_lineFREE(lprec *lp, int section, char* line, char *field...
function STATIC (line 455) | STATIC int addmpscolumn(lprec *lp, MYBOOL Int_section, int typeMPS, MYBO...
function STATIC (line 477) | STATIC MYBOOL appendmpsitem(int *count, int rowIndex[], REAL rowValue[])
function STATIC (line 494) | STATIC MYBOOL appendmpsitem(int *count, int rowIndex[], REAL rowValue[])
function MYBOOL (line 526) | MYBOOL MPS_readfile(lprec **newlp, const char *filename, int typeMPS, in...
function MPS_input (line 539) | static int __WINAPI MPS_input(void *fpin, char *buf, int max_size)
function MYBOOL (line 544) | MYBOOL __WINAPI MPS_readhandle(lprec **newlp, FILE *filehandle, int type...
function MYBOOL (line 549) | MYBOOL __WINAPI MPS_readex(lprec **newlp, void *userhandle, read_modelda...
function number (line 1179) | static void number(char *str,REAL value)
function STATIC (line 1279) | STATIC const char *MPSnameFIXED(char *name0, const char *name)
function STATIC (line 1285) | STATIC const char *MPSnameFREE(char *name0, const char *name)
function write_data (line 1293) | static void write_data(void *userhandle, write_modeldata_func write_mode...
function MYBOOL (line 1304) | MYBOOL __WINAPI MPS_writefileex(lprec *lp, int typeMPS, void *userhandle...
function write_lpdata (line 1578) | static int __WINAPI write_lpdata(void *userhandle, char *buf)
function MYBOOL (line 1584) | MYBOOL MPS_writefile(lprec *lp, int typeMPS, const char *filename)
function MYBOOL (line 1605) | MYBOOL MPS_writehandle(lprec *lp, int typeMPS, FILE *output)
function MPS_getnameidx (line 1623) | static int MPS_getnameidx(lprec *lp, const char *varname, MYBOOL isrow)
function MPS_getnameidx (line 1635) | static int MPS_getnameidx(lprec *lp, const char *varname, MYBOOL tryrowf...
function MYBOOL (line 1672) | MYBOOL MPS_readBAS(lprec *lp, int typeMPS, const char *filename, char *i...
function MYBOOL (line 1792) | MYBOOL MPS_writeBAS(lprec *lp, int typeMPS, const char *filename)
FILE: utilities/lp_solve/lp_SOS.c
function STATIC (line 36) | STATIC SOSgroup *create_SOSgroup(lprec *lp)
function STATIC (line 47) | STATIC void resize_SOSgroup(SOSgroup *group)
function STATIC (line 56) | STATIC int append_SOSgroup(SOSgroup *group, SOSrec *SOS)
function STATIC (line 91) | STATIC int clean_SOSgroup(SOSgroup *group, MYBOOL forceupdatemap)
function STATIC (line 122) | STATIC void free_SOSgroup(SOSgroup **group)
function STATIC (line 139) | STATIC SOSrec *create_SOSrec(SOSgroup *group, const char *name, int type...
function STATIC (line 170) | STATIC int append_SOSrec(SOSrec *SOS, int size, int *variables, REAL *we...
function STATIC (line 233) | STATIC int make_SOSchain(lprec *lp, MYBOOL forceresort)
function STATIC (line 294) | STATIC MYBOOL delete_SOSrec(SOSgroup *group, int sosindex)
function STATIC (line 323) | STATIC void free_SOSrec(SOSrec *SOS)
function STATIC (line 337) | STATIC MYBOOL SOS_member_sortlist(SOSgroup *group, int sosindex)
function STATIC (line 381) | STATIC int SOS_member_updatemap(SOSgroup *group)
function STATIC (line 442) | STATIC MYBOOL SOS_shift_col(SOSgroup *group, int sosindex, int column, i...
function SOS_member_count (line 545) | int SOS_member_count(SOSgroup *group, int sosindex)
function SOS_member_delete (line 559) | int SOS_member_delete(SOSgroup *group, int sosindex, int member)
function SOS_get_type (line 627) | int SOS_get_type(SOSgroup *group, int sosindex)
function SOS_infeasible (line 640) | int SOS_infeasible(SOSgroup *group, int sosindex)
function SOS_member_index (line 690) | int SOS_member_index(SOSgroup *group, int sosindex, int member)
function SOS_memberships (line 706) | int SOS_memberships(SOSgroup *group, int varnr)
function SOS_is_member (line 734) | int SOS_is_member(SOSgroup *group, int sosindex, int column)
function MYBOOL (line 772) | MYBOOL SOS_is_member_of_type(SOSgroup *group, int column, int sostype)
function MYBOOL (line 788) | MYBOOL SOS_set_GUB(SOSgroup *group, int sosindex, MYBOOL state)
function MYBOOL (line 811) | MYBOOL SOS_is_GUB(SOSgroup *group, int sosindex)
function MYBOOL (line 837) | MYBOOL SOS_is_marked(SOSgroup *group, int sosindex, int column)
function MYBOOL (line 878) | MYBOOL SOS_is_active(SOSgroup *group, int sosindex, int column)
function MYBOOL (line 916) | MYBOOL SOS_is_full(SOSgroup *group, int sosindex, int column, MYBOOL act...
function MYBOOL (line 966) | MYBOOL SOS_can_activate(SOSgroup *group, int sosindex, int column)
function MYBOOL (line 1078) | MYBOOL SOS_set_marked(SOSgroup *group, int sosindex, int column, MYBOOL ...
function MYBOOL (line 1140) | MYBOOL SOS_unmark(SOSgroup *group, int sosindex, int column)
function SOS_fix_unmarked (line 1208) | int SOS_fix_unmarked(SOSgroup *group, int sosindex, int variable, REAL *...
function SOS_fix_list (line 1358) | int SOS_fix_list(SOSgroup *group, int sosindex, int variable, REAL *bound,
function SOS_is_satisfied (line 1415) | int SOS_is_satisfied(SOSgroup *group, int sosindex, REAL *solution)
function MYBOOL (line 1529) | MYBOOL SOS_is_feasible(SOSgroup *group, int sosindex, REAL *solution)
FILE: utilities/lp_solve/lp_SOS.h
type SOSgroup (line 29) | typedef struct _SOSgroup SOSgroup;
type SOSrec (line 31) | typedef struct _SOSrec
type _SOSgroup (line 46) | struct _SOSgroup
FILE: utilities/lp_solve/lp_bit.h
function MYINLINE (line 13) | MYINLINE void set_biton(MYBOOL *bitarray, int item)
function MYINLINE (line 25) | MYINLINE MYBOOL is_biton(MYBOOL *bitarray, int item)
FILE: utilities/lp_solve/lp_crash.c
function MYBOOL (line 34) | MYBOOL crash_basis(lprec *lp)
function MYBOOL (line 338) | MYBOOL __WINAPI guess_basis(lprec *lp, REAL *guessvector, int *basisvector)
function MYBOOL (line 440) | MYBOOL __WINAPI guess_basis(lprec *lp, REAL *guessvector, int *basisvector)
function MYBOOL (line 584) | MYBOOL __WINAPI guess_basis(lprec *lp, REAL *guessvector, int *basisvector)
function MYBOOL (line 731) | MYBOOL __WINAPI guess_basis(lprec *lp, REAL *guessvector, int *basisvector)
FILE: utilities/lp_solve/lp_explicit.h
function init_lpsolve (line 268) | static int init_lpsolve(lprec *lp)
function hlpsolve (line 531) | static hlpsolve open_lpsolve_lib(char *filename)
function close_lpsolve_lib (line 544) | static int close_lpsolve_lib(hlpsolve lpsolve)
function init_lpsolve (line 555) | static int init_lpsolve(hlpsolve lpsolve)
FILE: utilities/lp_solve/lp_lib.c
function lp_solve_version (line 92) | void __WINAPI lp_solve_version(int *majorversion, int *minorversion, int...
function MYBOOL (line 109) | MYBOOL __WINAPI userabort(lprec *lp, int message)
function STATIC (line 129) | STATIC int yieldformessages(lprec *lp)
function set_outputstream (line 148) | void __WINAPI set_outputstream(lprec *lp, FILE *stream)
function MYBOOL (line 163) | MYBOOL __WINAPI set_outputfile(lprec *lp, const char *filename)
function REAL (line 180) | REAL __WINAPI time_elapsed(lprec *lp)
function put_bb_nodefunc (line 188) | void __WINAPI put_bb_nodefunc(lprec *lp, lphandleint_intfunc newnode, vo...
function put_bb_branchfunc (line 193) | void __WINAPI put_bb_branchfunc(lprec *lp, lphandleint_intfunc newbranch...
function put_abortfunc (line 198) | void __WINAPI put_abortfunc(lprec *lp, lphandle_intfunc newctrlc, void *...
function put_logfunc (line 203) | void __WINAPI put_logfunc(lprec *lp, lphandlestr_func newlog, void *logh...
function put_msgfunc (line 208) | void __WINAPI put_msgfunc(lprec *lp, lphandleint_func newmsg, void *msgh...
function MYBOOL (line 301) | MYBOOL __WINAPI write_mps(lprec *lp, const char *filename)
function MYBOOL (line 305) | MYBOOL __WINAPI write_MPS(lprec *lp, FILE *output)
function MYBOOL (line 310) | MYBOOL __WINAPI write_freemps(lprec *lp, const char *filename)
function MYBOOL (line 314) | MYBOOL __WINAPI write_freeMPS(lprec *lp, FILE *output)
function MYBOOL (line 319) | MYBOOL __WINAPI write_lp(lprec *lp, const char *filename)
function MYBOOL (line 323) | MYBOOL __WINAPI write_LP(lprec *lp, FILE *output)
function MYBOOL (line 328) | MYBOOL __WINAPI LP_readhandle(lprec **lp, FILE *filename, int verbose, c...
function MYBOOL (line 342) | MYBOOL __WINAPI write_basis(lprec *lp, const char *filename)
function MYBOOL (line 347) | MYBOOL __WINAPI read_basis(lprec *lp, const char *filename, char *info)
function unscale (line 441) | void __WINAPI unscale(lprec *lp)
function solve (line 445) | int __WINAPI solve(lprec *lp)
function print_lp (line 460) | void __WINAPI print_lp(lprec *lp)
function print_tableau (line 464) | void __WINAPI print_tableau(lprec *lp)
function print_objective (line 468) | void __WINAPI print_objective(lprec *lp)
function print_solution (line 472) | void __WINAPI print_solution(lprec *lp, int columns)
function print_constraints (line 476) | void __WINAPI print_constraints(lprec *lp, int columns)
function print_duals (line 480) | void __WINAPI print_duals(lprec *lp)
function print_scales (line 484) | void __WINAPI print_scales(lprec *lp)
function MYBOOL (line 488) | MYBOOL __WINAPI print_debugdump(lprec *lp, const char *filename)
function print_str (line 492) | void __WINAPI print_str(lprec *lp, const char *str)
function set_timeout (line 503) | void __WINAPI set_timeout(lprec *lp, long sectimeout)
function get_timeout (line 508) | long __WINAPI get_timeout(lprec *lp)
function set_verbose (line 513) | void __WINAPI set_verbose(lprec *lp, int verbose)
function get_verbose (line 518) | int __WINAPI get_verbose(lprec *lp)
function set_print_sol (line 523) | void __WINAPI set_print_sol(lprec *lp, int print_sol)
function get_print_sol (line 528) | int __WINAPI get_print_sol(lprec *lp)
function set_debug (line 533) | void __WINAPI set_debug(lprec *lp, MYBOOL debug)
function MYBOOL (line 538) | MYBOOL __WINAPI is_debug(lprec *lp)
function set_trace (line 543) | void __WINAPI set_trace(lprec *lp, MYBOOL trace)
function MYBOOL (line 548) | MYBOOL __WINAPI is_trace(lprec *lp)
function set_anti_degen (line 553) | void __WINAPI set_anti_degen(lprec *lp, int anti_degen)
function get_anti_degen (line 558) | int __WINAPI get_anti_degen(lprec *lp)
function MYBOOL (line 563) | MYBOOL __WINAPI is_anti_degen(lprec *lp, int testmask)
function set_presolve (line 568) | void __WINAPI set_presolve(lprec *lp, int presolvemode, int maxloops)
function get_presolve (line 575) | int __WINAPI get_presolve(lprec *lp)
function get_presolveloops (line 580) | int __WINAPI get_presolveloops(lprec *lp)
function MYBOOL (line 590) | MYBOOL __WINAPI is_presolve(lprec *lp, int testmask)
function set_maxpivot (line 595) | void __WINAPI set_maxpivot(lprec *lp, int maxpivot)
function get_maxpivot (line 600) | int __WINAPI get_maxpivot(lprec *lp)
function set_bb_rule (line 605) | void __WINAPI set_bb_rule(lprec *lp, int bb_rule)
function get_bb_rule (line 610) | int __WINAPI get_bb_rule(lprec *lp)
function MYBOOL (line 615) | MYBOOL is_bb_rule(lprec *lp, int bb_rule)
function MYBOOL (line 620) | MYBOOL is_bb_mode(lprec *lp, int bb_mask)
function set_action (line 625) | void __WINAPI set_action(int *actionvar, int actionmask)
function clear_action (line 630) | void __WINAPI clear_action(int *actionvar, int actionmask)
function MYBOOL (line 635) | MYBOOL __WINAPI is_action(int actionvar, int testmask)
function set_bb_depthlimit (line 640) | void __WINAPI set_bb_depthlimit(lprec *lp, int bb_maxlevel)
function get_bb_depthlimit (line 645) | int __WINAPI get_bb_depthlimit(lprec *lp)
function set_obj_bound (line 650) | void __WINAPI set_obj_bound(lprec *lp, REAL bb_heuristicOF)
function REAL (line 655) | REAL __WINAPI get_obj_bound(lprec *lp)
function set_mip_gap (line 660) | void __WINAPI set_mip_gap(lprec *lp, MYBOOL absolute, REAL mip_gap)
function REAL (line 668) | REAL __WINAPI get_mip_gap(lprec *lp, MYBOOL absolute)
function MYBOOL (line 676) | MYBOOL __WINAPI set_var_branch(lprec *lp, int colnr, int branch_mode)
function get_var_branch (line 695) | int __WINAPI get_var_branch(lprec *lp, int colnr)
function set_infiniteex (line 710) | static void set_infiniteex(lprec *lp, REAL infinite, MYBOOL init)
function MYBOOL (line 729) | MYBOOL __WINAPI is_infinite(lprec *lp, REAL value)
function set_infinite (line 741) | void __WINAPI set_infinite(lprec *lp, REAL infinite)
function REAL (line 746) | REAL __WINAPI get_infinite(lprec *lp)
function set_epsperturb (line 751) | void __WINAPI set_epsperturb(lprec *lp, REAL epsperturb)
function REAL (line 756) | REAL __WINAPI get_epsperturb(lprec *lp)
function set_epspivot (line 761) | void __WINAPI set_epspivot(lprec *lp, REAL epspivot)
function REAL (line 766) | REAL __WINAPI get_epspivot(lprec *lp)
function set_epsint (line 771) | void __WINAPI set_epsint(lprec *lp, REAL epsint)
function REAL (line 776) | REAL __WINAPI get_epsint(lprec *lp)
function set_epsb (line 781) | void __WINAPI set_epsb(lprec *lp, REAL epsb)
function REAL (line 786) | REAL __WINAPI get_epsb(lprec *lp)
function set_epsd (line 791) | void __WINAPI set_epsd(lprec *lp, REAL epsd)
function REAL (line 796) | REAL __WINAPI get_epsd(lprec *lp)
function set_epsel (line 801) | void __WINAPI set_epsel(lprec *lp, REAL epsel)
function REAL (line 806) | REAL __WINAPI get_epsel(lprec *lp)
function MYBOOL (line 811) | MYBOOL __WINAPI set_epslevel(lprec *lp, int epslevel)
function set_scaling (line 842) | void __WINAPI set_scaling(lprec *lp, int scalemode)
function get_scaling (line 847) | int __WINAPI get_scaling(lprec *lp)
function MYBOOL (line 852) | MYBOOL __WINAPI is_scalemode(lprec *lp, int testmask)
function MYBOOL (line 857) | MYBOOL __WINAPI is_scaletype(lprec *lp, int scaletype)
function set_scalelimit (line 865) | void __WINAPI set_scalelimit(lprec *lp, REAL scalelimit)
function REAL (line 872) | REAL __WINAPI get_scalelimit(lprec *lp)
function MYBOOL (line 877) | MYBOOL __WINAPI is_integerscaling(lprec *lp)
function set_improve (line 882) | void __WINAPI set_improve(lprec *lp, int improve)
function get_improve (line 887) | int __WINAPI get_improve(lprec *lp)
function set_lag_trace (line 892) | void __WINAPI set_lag_trace(lprec *lp, MYBOOL lag_trace)
function MYBOOL (line 897) | MYBOOL __WINAPI is_lag_trace(lprec *lp)
function set_pivoting (line 902) | void __WINAPI set_pivoting(lprec *lp, int pivoting)
function get_pivoting (line 910) | int __WINAPI get_pivoting(lprec *lp)
function get_piv_rule (line 915) | int get_piv_rule(lprec *lp)
function STATIC (line 920) | STATIC const char *get_str_piv_rule(int rule)
function MYBOOL (line 928) | MYBOOL __WINAPI is_piv_rule(lprec *lp, int rule)
function MYBOOL (line 933) | MYBOOL __WINAPI is_piv_mode(lprec *lp, int testmask)
function set_break_at_first (line 939) | void __WINAPI set_break_at_first(lprec *lp, MYBOOL break_at_first)
function MYBOOL (line 944) | MYBOOL __WINAPI is_break_at_first(lprec *lp)
function set_bb_floorfirst (line 949) | void __WINAPI set_bb_floorfirst(lprec *lp, int bb_floorfirst)
function get_bb_floorfirst (line 954) | int __WINAPI get_bb_floorfirst(lprec *lp)
function set_break_at_value (line 959) | void __WINAPI set_break_at_value(lprec *lp, REAL break_at_value)
function REAL (line 964) | REAL __WINAPI get_break_at_value(lprec *lp)
function set_negrange (line 969) | void __WINAPI set_negrange(lprec *lp, REAL negrange)
function REAL (line 977) | REAL __WINAPI get_negrange(lprec *lp)
function get_max_level (line 982) | int __WINAPI get_max_level(lprec *lp)
function COUNTER (line 987) | COUNTER __WINAPI get_total_nodes(lprec *lp)
function COUNTER (line 992) | COUNTER __WINAPI get_total_iter(lprec *lp)
function REAL (line 997) | REAL __WINAPI get_objective(lprec *lp)
function get_nonzeros (line 1009) | int __WINAPI get_nonzeros(lprec *lp)
function MYBOOL (line 1014) | MYBOOL __WINAPI set_mat(lprec *lp, int rownr, int colnr, REAL value)
function REAL (line 1038) | REAL __WINAPI get_working_objective(lprec *lp)
function REAL (line 1052) | REAL __WINAPI get_var_primalresult(lprec *lp, int index)
function REAL (line 1064) | REAL __WINAPI get_var_dualresult(lprec *lp, int index)
function MYBOOL (line 1084) | MYBOOL __WINAPI get_variables(lprec *lp, REAL *var)
function MYBOOL (line 1097) | MYBOOL __WINAPI get_ptr_variables(lprec *lp, REAL **var)
function MYBOOL (line 1111) | MYBOOL __WINAPI get_constraints(lprec *lp, REAL *constr)
function MYBOOL (line 1124) | MYBOOL __WINAPI get_ptr_constraints(lprec *lp, REAL **constr)
function MYBOOL (line 1138) | MYBOOL __WINAPI get_sensitivity_rhs(lprec *lp, REAL *duals, REAL *dualsf...
function MYBOOL (line 1162) | MYBOOL __WINAPI get_ptr_sensitivity_rhs(lprec *lp, REAL **duals, REAL **...
function MYBOOL (line 1199) | MYBOOL __WINAPI get_sensitivity_objex(lprec *lp, REAL *objfrom, REAL *ob...
function MYBOOL (line 1225) | MYBOOL __WINAPI get_sensitivity_obj(lprec *lp, REAL *objfrom, REAL *objt...
function MYBOOL (line 1230) | MYBOOL __WINAPI get_ptr_sensitivity_objex(lprec *lp, REAL **objfrom, REA...
function MYBOOL (line 1274) | MYBOOL __WINAPI get_ptr_sensitivity_obj(lprec *lp, REAL **objfrom, REAL ...
function set_solutionlimit (line 1279) | void __WINAPI set_solutionlimit(lprec *lp, int limit)
function get_solutionlimit (line 1283) | int __WINAPI get_solutionlimit(lprec *lp)
function get_solutioncount (line 1287) | int __WINAPI get_solutioncount(lprec *lp)
function get_Nrows (line 1292) | int __WINAPI get_Nrows(lprec *lp)
function get_Norig_rows (line 1297) | int __WINAPI get_Norig_rows(lprec *lp)
function get_Lrows (line 1305) | int __WINAPI get_Lrows(lprec *lp)
function get_Ncolumns (line 1313) | int __WINAPI get_Ncolumns(lprec *lp)
function get_Norig_columns (line 1318) | int __WINAPI get_Norig_columns(lprec *lp)
function get_status (line 1330) | int __WINAPI get_status(lprec *lp)
function MYBOOL (line 1360) | MYBOOL __WINAPI is_obj_in_basis(lprec *lp)
function set_obj_in_basis (line 1365) | void __WINAPI set_obj_in_basis(lprec *lp, MYBOOL obj_in_basis)
function MYBOOL (line 1512) | MYBOOL __WINAPI resize_lp(lprec *lp, int rows, int columns)
function free_lp (line 1531) | void __WINAPI free_lp(lprec **plp)
function delete_lp (line 1541) | void __WINAPI delete_lp(lprec *lp)
function MYBOOL (line 1653) | static MYBOOL get_SOS(lprec *lp, int index, char *name, int *sostype, in...
function MYBOOL (line 1834) | MYBOOL __WINAPI dualize_lp(lprec *lp)
function STATIC (line 1883) | STATIC MYBOOL memopt_lp(lprec *lp, int rowextra, int colextra, int nzextra)
function STATIC (line 1910) | STATIC void varmap_lock(lprec *lp)
function STATIC (line 1915) | STATIC void varmap_clear(lprec *lp)
function STATIC (line 1920) | STATIC MYBOOL varmap_canunlock(lprec *lp)
function STATIC (line 1945) | STATIC void varmap_add(lprec *lp, int base, int delta)
function STATIC (line 1968) | STATIC void varmap_delete(lprec *lp, int base, int delta, LLrec *varmap)
function STATIC (line 2060) | STATIC MYBOOL varmap_validate(lprec *lp, int varno)
function STATIC (line 2097) | STATIC void varmap_compact(lprec *lp, int prev_rows, int prev_cols)
function STATIC (line 2152) | STATIC MYBOOL shift_rowcoldata(lprec *lp, int base, int delta, LLrec *us...
function STATIC (line 2276) | STATIC MYBOOL shift_basis(lprec *lp, int base, int delta, LLrec *usedmap...
function STATIC (line 2377) | STATIC MYBOOL shift_rowdata(lprec *lp, int base, int delta, LLrec *usedmap)
function STATIC (line 2442) | STATIC MYBOOL shift_coldata(lprec *lp, int base, int delta, LLrec *usedmap)
function STATIC (line 2680) | STATIC void inc_rows(lprec *lp, int delta)
function STATIC (line 2695) | STATIC void inc_columns(lprec *lp, int delta)
function STATIC (line 2712) | STATIC MYBOOL inc_rowcol_space(lprec *lp, int delta, MYBOOL isrows)
function STATIC (line 2759) | STATIC MYBOOL inc_lag_space(lprec *lp, int deltarows, MYBOOL ignoreMAT)
function STATIC (line 2792) | STATIC MYBOOL inc_row_space(lprec *lp, int deltarows)
function STATIC (line 2876) | STATIC MYBOOL inc_col_space(lprec *lp, int deltacols)
function MYBOOL (line 2966) | MYBOOL __WINAPI set_obj(lprec *lp, int colnr, REAL value)
function MYBOOL (line 2975) | MYBOOL __WINAPI set_obj_fnex(lprec *lp, int count, REAL *row, int *colno)
function MYBOOL (line 3010) | MYBOOL __WINAPI set_obj_fn(lprec *lp, REAL *row)
function MYBOOL (line 3015) | MYBOOL __WINAPI str_set_obj_fn(lprec *lp, const char *row_string)
function STATIC (line 3042) | STATIC MYBOOL append_columns(lprec *lp, int deltacolumns)
function STATIC (line 3051) | STATIC MYBOOL append_rows(lprec *lp, int deltarows)
function MYBOOL (line 3061) | MYBOOL __WINAPI set_add_rowmode(lprec *lp, MYBOOL turnon)
function MYBOOL (line 3069) | MYBOOL __WINAPI is_add_rowmode(lprec *lp)
function MYBOOL (line 3074) | MYBOOL __WINAPI set_row(lprec *lp, int rownr, REAL *row)
function MYBOOL (line 3086) | MYBOOL __WINAPI set_rowex(lprec *lp, int rownr, int count, REAL *row, in...
function MYBOOL (line 3098) | MYBOOL __WINAPI add_constraintex(lprec *lp, int count, REAL *row, int *c...
function MYBOOL (line 3152) | MYBOOL __WINAPI add_constraint(lprec *lp, REAL *row, int constr_type, RE...
function MYBOOL (line 3157) | MYBOOL __WINAPI str_add_constraint(lprec *lp, const char *row_string, in...
function STATIC (line 3185) | STATIC MYBOOL del_constraintex(lprec *lp, LLrec *rowmap)
function MYBOOL (line 3215) | MYBOOL __WINAPI del_constraint(lprec *lp, int rownr)
function MYBOOL (line 3275) | MYBOOL __WINAPI add_lag_con(lprec *lp, REAL *row, int con_type, REAL rhs)
function MYBOOL (line 3300) | MYBOOL __WINAPI str_add_lag_con(lprec *lp, const char *row_string, int c...
function MYBOOL (line 3328) | MYBOOL is_splitvar(lprec *lp, int colnr)
function del_splitvars (line 3344) | void del_splitvars(lprec *lp)
function MYBOOL (line 3365) | MYBOOL __WINAPI set_column(lprec *lp, int colnr, REAL *column)
function MYBOOL (line 3370) | MYBOOL __WINAPI set_columnex(lprec *lp, int colnr, int count, REAL *colu...
function MYBOOL (line 3375) | MYBOOL __WINAPI add_columnex(lprec *lp, int count, REAL *column, int *ro...
function MYBOOL (line 3414) | MYBOOL __WINAPI add_column(lprec *lp, REAL *column)
function MYBOOL (line 3420) | MYBOOL __WINAPI str_add_column(lprec *lp, const char *col_string)
function STATIC (line 3448) | STATIC MYBOOL del_varnameex(lprec *lp, hashelem **namelist, int items, h...
function STATIC (line 3495) | STATIC MYBOOL del_columnex(lprec *lp, LLrec *colmap)
function MYBOOL (line 3511) | MYBOOL __WINAPI del_column(lprec *lp, int colnr)
function set_simplextype (line 3546) | void __WINAPI set_simplextype(lprec *lp, int simplextype)
function get_simplextype (line 3551) | int __WINAPI get_simplextype(lprec *lp)
function set_preferdual (line 3556) | void __WINAPI set_preferdual(lprec *lp, MYBOOL dodual)
function set_bounds_tighter (line 3564) | void __WINAPI set_bounds_tighter(lprec *lp, MYBOOL tighten)
function MYBOOL (line 3568) | MYBOOL __WINAPI get_bounds_tighter(lprec *lp)
function MYBOOL (line 3573) | MYBOOL __WINAPI set_upbo(lprec *lp, int colnr, REAL value)
function REAL (line 3607) | REAL __WINAPI get_upbo(lprec *lp, int colnr)
function MYBOOL (line 3621) | MYBOOL __WINAPI set_lowbo(lprec *lp, int colnr, REAL value)
function REAL (line 3655) | REAL __WINAPI get_lowbo(lprec *lp, int colnr)
function MYBOOL (line 3669) | MYBOOL __WINAPI set_bounds(lprec *lp, int colnr, REAL lower, REAL upper)
function MYBOOL (line 3714) | MYBOOL get_bounds(lprec *lp, int column, REAL *lower, REAL *upper)
function MYBOOL (line 3729) | MYBOOL __WINAPI set_int(lprec *lp, int colnr, MYBOOL var_type)
function MYBOOL (line 3749) | MYBOOL __WINAPI is_int(lprec *lp, int colnr)
function MYBOOL (line 3759) | MYBOOL __WINAPI is_SOS_var(lprec *lp, int colnr)
function add_SOS (line 3769) | int __WINAPI add_SOS(lprec *lp, const char *name, int sostype, int prior...
function STATIC (line 3802) | STATIC int add_GUB(lprec *lp, const char *name, int priority, int count,...
function MYBOOL (line 3826) | MYBOOL __WINAPI set_binary(lprec *lp, int colnr, MYBOOL must_be_bin)
function MYBOOL (line 3841) | MYBOOL __WINAPI is_binary(lprec *lp, int colnr)
function MYBOOL (line 3853) | MYBOOL __WINAPI set_unbounded(lprec *lp, int colnr)
function MYBOOL (line 3863) | MYBOOL __WINAPI is_unbounded(lprec *lp, int colnr)
function MYBOOL (line 3881) | MYBOOL __WINAPI is_negative(lprec *lp, int colnr)
function MYBOOL (line 3893) | MYBOOL __WINAPI set_var_weights(lprec *lp, REAL *weights)
function MYBOOL (line 3909) | MYBOOL __WINAPI set_var_priority(lprec *lp)
function get_var_priority (line 3951) | int __WINAPI get_var_priority(lprec *lp, int colnr)
function MYBOOL (line 3964) | MYBOOL __WINAPI set_semicont(lprec *lp, int colnr, MYBOOL must_be_sc)
function MYBOOL (line 3983) | MYBOOL __WINAPI is_semicont(lprec *lp, int colnr)
function MYBOOL (line 3993) | MYBOOL __WINAPI set_rh(lprec *lp, int rownr, REAL value)
function REAL (line 4019) | REAL __WINAPI get_rh(lprec *lp, int rownr)
function REAL (line 4036) | REAL get_rh_upper(lprec *lp, int rownr)
function REAL (line 4052) | REAL get_rh_lower(lprec *lp, int rownr)
function MYBOOL (line 4069) | MYBOOL set_rh_upper(lprec *lp, int rownr, REAL value)
function MYBOOL (line 4114) | MYBOOL set_rh_lower(lprec *lp, int rownr, REAL value)
function MYBOOL (line 4160) | MYBOOL __WINAPI set_rh_range(lprec *lp, int rownr, REAL deltavalue)
function REAL (line 4197) | REAL __WINAPI get_rh_range(lprec *lp, int rownr)
function set_rh_vec (line 4210) | void __WINAPI set_rh_vec(lprec *lp, REAL *rh)
function MYBOOL (line 4225) | MYBOOL __WINAPI str_set_rh_vec(lprec *lp, const char *rh_string)
function set_sense (line 4253) | void __WINAPI set_sense(lprec *lp, MYBOOL maximize)
function set_maxim (line 4273) | void __WINAPI set_maxim(lprec *lp)
function set_minim (line 4278) | void __WINAPI set_minim(lprec *lp)
function MYBOOL (line 4283) | MYBOOL __WINAPI is_maxim(lprec *lp)
function MYBOOL (line 4289) | MYBOOL __WINAPI set_constr_type(lprec *lp, int rownr, int con_type)
function MYBOOL (line 4344) | MYBOOL is_chsign(lprec *lp, int rownr)
function MYBOOL (line 4349) | MYBOOL __WINAPI is_constr_type(lprec *lp, int rownr, int mask)
function get_constr_type (line 4358) | int __WINAPI get_constr_type(lprec *lp, int rownr)
function REAL (line 4366) | REAL __WINAPI get_constr_value(lprec *lp, int rownr, int count, REAL *pr...
function STATIC (line 4417) | STATIC const char *get_str_constr_class(lprec *lp, int con_class)
function STATIC (line 4436) | STATIC const char *get_str_constr_type(lprec *lp, int con_type)
function STATIC (line 4448) | STATIC int get_constr_class(lprec *lp, int rownr)
function REAL (line 4533) | REAL __WINAPI get_mat(lprec *lp, int rownr, int colnr)
function REAL (line 4567) | REAL __WINAPI get_mat_byindex(lprec *lp, int matindex, MYBOOL isrow, MYB...
function mat_getrow (line 4584) | static int mat_getrow(lprec *lp, int rownr, REAL *row, int *colno)
function mat_getcolumn (line 4647) | static int mat_getcolumn(lprec *lp, int colnr, REAL *column, int *nzrow)
function get_columnex (line 4693) | int __WINAPI get_columnex(lprec *lp, int colnr, REAL *column, int *nzrow)
function MYBOOL (line 4706) | MYBOOL __WINAPI get_column(lprec *lp, int colnr, REAL *column)
function get_rowex (line 4711) | int __WINAPI get_rowex(lprec *lp, int rownr, REAL *row, int *colno)
function MYBOOL (line 4724) | MYBOOL __WINAPI get_row(lprec *lp, int rownr, REAL *row)
function STATIC (line 4729) | STATIC void set_OF_override(lprec *lp, REAL *ofVector)
function MYBOOL (line 4737) | MYBOOL modifyOF1(lprec *lp, int index, REAL *ofValue, REAL mult)
function STATIC (line 4790) | STATIC void set_OF_p1extra(lprec *lp, REAL p1extra)
function STATIC (line 4807) | STATIC void unset_OF_p1extra(lprec *lp)
function REAL (line 4813) | REAL __WINAPI get_OF_active(lprec *lp, int varnr, REAL mult)
function STATIC (line 4835) | STATIC MYBOOL is_OF_nz(lprec *lp, int colnr)
function STATIC (line 4840) | STATIC int singleton_column(lprec *lp, int row_nr, REAL *column, int *nz...
function STATIC (line 4858) | STATIC int expand_column(lprec *lp, int col_nr, REAL *column, int *nzlis...
function obtain_column (line 4938) | int __WINAPI obtain_column(lprec *lp, int varin, REAL *pcol, int *nzlist...
function MYBOOL (line 4954) | MYBOOL set_callbacks(lprec *lp)
function MYBOOL (line 5215) | MYBOOL __WINAPI has_BFP(lprec *lp)
function MYBOOL (line 5224) | MYBOOL __WINAPI is_nativeBFP(lprec *lp)
function MYBOOL (line 5235) | MYBOOL __WINAPI set_BFP(lprec *lp, const char *filename)
function MYBOOL (line 5565) | MYBOOL __WINAPI write_XLI(lprec *lp, const char *filename, const char *o...
function MYBOOL (line 5570) | MYBOOL __WINAPI has_XLI(lprec *lp)
function MYBOOL (line 5579) | MYBOOL __WINAPI is_nativeXLI(lprec *lp)
function MYBOOL (line 5591) | MYBOOL __WINAPI set_XLI(lprec *lp, const char *filename)
function STATIC (line 5715) | STATIC int get_basisOF(lprec *lp, int coltarget[], REAL crow[], int coln...
function get_basiscolumn (line 5775) | int __WINAPI get_basiscolumn(lprec *lp, int j, int rn[], double bj[])
function MYBOOL (line 5810) | MYBOOL __WINAPI get_primal_solution(lprec *lp, REAL *pv)
function MYBOOL (line 5823) | MYBOOL __WINAPI get_ptr_primal_solution(lprec *lp, REAL **pv)
function MYBOOL (line 5829) | MYBOOL __WINAPI get_dual_solution(lprec *lp, REAL *rc)
function MYBOOL (line 5846) | MYBOOL __WINAPI get_ptr_dual_solution(lprec *lp, REAL **rc)
function MYBOOL (line 5867) | MYBOOL __WINAPI get_lambda(lprec *lp, REAL *lambda)
function MYBOOL (line 5878) | MYBOOL __WINAPI get_ptr_lambda(lprec *lp, REAL **lambda)
function get_orig_index (line 5884) | int __WINAPI get_orig_index(lprec *lp, int lp_index)
function get_lp_index (line 5893) | int __WINAPI get_lp_index(lprec *lp, int orig_index)
function MYBOOL (line 5903) | MYBOOL __WINAPI is_feasible(lprec *lp, REAL *values, REAL threshold)
function column_in_lp (line 5951) | int __WINAPI column_in_lp(lprec *lp, REAL *testcolumn)
function MYBOOL (line 5987) | MYBOOL __WINAPI set_lp_name(lprec *lp, const char *name)
function STATIC (line 6005) | STATIC MYBOOL init_rowcol_names(lprec *lp)
function MYBOOL (line 6017) | MYBOOL rename_var(lprec *lp, int varindex, const char *new_name, hashele...
function MYBOOL (line 6040) | MYBOOL __WINAPI is_use_names(lprec *lp, MYBOOL isrow)
function set_use_names (line 6048) | void __WINAPI set_use_names(lprec *lp, MYBOOL isrow, MYBOOL use_names)
function get_nameindex (line 6056) | int __WINAPI get_nameindex(lprec *lp, const char *varname, MYBOOL isrow)
function MYBOOL (line 6064) | MYBOOL __WINAPI set_row_name(lprec *lp, int rownr, const char *new_name)
function MYBOOL (line 6136) | MYBOOL __WINAPI set_col_name(lprec *lp, int colnr, const char *new_name)
function STATIC (line 6204) | STATIC int MIP_count(lprec *lp)
function STATIC (line 6208) | STATIC int bin_count(lprec *lp, MYBOOL working)
function STATIC (line 6224) | STATIC int SOS_count(lprec *lp)
function STATIC (line 6231) | STATIC int GUB_count(lprec *lp)
function STATIC (line 6239) | STATIC REAL compute_violation(lprec *lp, int row_nr)
function STATIC (line 6259) | STATIC REAL feasibilityOffset(lprec *lp, MYBOOL isdual)
function STATIC (line 6314) | STATIC REAL compute_dualslacks(lprec *lp, int target, REAL **dvalues, in...
function STATIC (line 6383) | STATIC REAL compute_feasibilitygap(lprec *lp, MYBOOL isdual, MYBOOL dosum)
function STATIC (line 6414) | STATIC int row_decimals(lprec *lp, int rownr, MYBOOL intsonly, REAL *int...
function STATIC (line 6453) | STATIC int row_intstats(lprec *lp, int rownr, int pivcolnr, int *maxndec,
function REAL (line 6534) | REAL MIP_stepOF(lprec *lp)
function REAL (line 6639) | REAL MIP_stepOF(lprec *lp)
function STATIC (line 6727) | STATIC REAL row_plusdelta(lprec *lp, int rownr, int excludecol, int *int...
function STATIC (line 6852) | STATIC REAL MIP_stepOF(lprec *lp)
function STATIC (line 6921) | STATIC MYBOOL isPrimalSimplex(lprec *lp)
function STATIC (line 6927) | STATIC MYBOOL isPhase1(lprec *lp)
function STATIC (line 6933) | STATIC MYBOOL isP1extra(lprec *lp)
function STATIC (line 6938) | STATIC MYBOOL feasiblePhase1(lprec *lp, REAL epsvalue)
function STATIC (line 6948) | STATIC MYBOOL isDegenerateBasis(lprec *lp, int basisvar)
function STATIC (line 6960) | STATIC int findBasicFixedvar(lprec *lp, int afternr, MYBOOL slacksonly)
function STATIC (line 6985) | STATIC MYBOOL isBasisVarFeasible(lprec *lp, REAL tol, int basis_row)
function STATIC (line 7046) | STATIC MYBOOL isDualFeasible(lprec *lp, REAL tol, int *boundflipcount, i...
function default_basis (line 7141) | void __WINAPI default_basis(lprec *lp)
function get_basiscrash (line 7166) | int __WINAPI get_basiscrash(lprec *lp)
function set_basiscrash (line 7171) | void __WINAPI set_basiscrash(lprec *lp, int mode)
function MYBOOL (line 7176) | MYBOOL __WINAPI set_basis(lprec *lp, int *bascolumn, MYBOOL nonbasic) ...
function reset_basis (line 7227) | void __WINAPI reset_basis(lprec *lp)
function MYBOOL (line 7232) | MYBOOL __WINAPI get_basis(lprec *lp, int *bascolumn, MYBOOL nonbasic)
function STATIC (line 7261) | STATIC MYBOOL is_BasisReady(lprec *lp)
function STATIC (line 7266) | STATIC MYBOOL is_slackbasis(lprec *lp)
function STATIC (line 7291) | STATIC MYBOOL verify_basis(lprec *lp)
function set_basisvar (line 7320) | int __WINAPI set_basisvar(lprec *lp, int basisPos, int enteringCol)
function STATIC (line 7359) | STATIC int perturb_bounds(lprec *lp, BBrec *perturbed, MYBOOL doRows, MY...
function STATIC (line 7417) | STATIC MYBOOL impose_bounds(lprec *lp, REAL *upbo, REAL *lowbo)
function STATIC (line 7436) | STATIC MYBOOL validate_bounds(lprec *lp, REAL *upbo, REAL *lowbo)
function STATIC (line 7452) | STATIC int unload_BB(lprec *lp)
function STATIC (line 7465) | STATIC basisrec *push_basis(lprec *lp, int *basisvar, MYBOOL *isbasic, M...
function STATIC (line 7514) | STATIC MYBOOL compare_basis(lprec *lp)
function STATIC (line 7544) | STATIC MYBOOL restore_basis(lprec *lp)
function STATIC (line 7571) | STATIC MYBOOL pop_basis(lprec *lp, MYBOOL restore)
function STATIC (line 7595) | STATIC int unload_basis(lprec *lp, MYBOOL restorelast)
function STATIC (line 7606) | STATIC REAL scaled_floor(lprec *lp, int colnr, REAL value, REAL epsscale)
function STATIC (line 7620) | STATIC REAL scaled_ceil(lprec *lp, int colnr, REAL value, REAL epsscale)
function STATIC (line 7636) | STATIC MYBOOL is_sc_violated(lprec *lp, int column)
function STATIC (line 7649) | STATIC int find_sc_bbvar(lprec *lp, int *count)
function STATIC (line 7754) | STATIC int find_sos_bbvar(lprec *lp, int *count, MYBOOL intsos)
function STATIC (line 7794) | STATIC int find_int_bbvar(lprec *lp, int *count, BBrec *BB, MYBOOL *isfe...
function STATIC (line 8028) | STATIC BBPSrec *init_pseudocost(lprec *lp, int pseudotype)
function STATIC (line 8083) | STATIC MYBOOL free_pseudoclass(BBPSrec **PseudoClass)
function STATIC (line 8096) | STATIC void free_pseudocost(lprec *lp)
function MYBOOL (line 8103) | MYBOOL __WINAPI set_pseudocosts(lprec *lp, REAL *clower, REAL *cupper, i...
function MYBOOL (line 8120) | MYBOOL __WINAPI get_pseudocosts(lprec *lp, REAL *clower, REAL *cupper, i...
function STATIC (line 8137) | STATIC REAL get_pseudorange(BBPSrec *pc, int mipvar, int varcode)
function STATIC (line 8145) | STATIC void update_pseudocost(BBPSrec *pc, int mipvar, int varcode, MYBO...
function STATIC (line 8207) | STATIC REAL get_pseudobranchcost(BBPSrec *pc, int mipvar, MYBOOL dofloor)
function STATIC (line 8215) | STATIC REAL get_pseudonodecost(BBPSrec *pc, int mipvar, int vartype, REA...
function STATIC (line 8230) | STATIC int compute_theta(lprec *lp, int rownr, LREAL *theta, int isupbou...
function STATIC (line 8295) | STATIC MYBOOL check_degeneracy(lprec *lp, REAL *pcol, int *degencount)
function STATIC (line 8541) | STATIC REAL get_refactfrequency(lprec *lp, MYBOOL final)
function MYBOOL (line 8564) | MYBOOL is_fixedvar(lprec *lp, int variable)
function MYBOOL (line 8572) | MYBOOL is_fixedvar(lprec *lp, int varnr)
function STATIC (line 8587) | STATIC MYBOOL solution_is_int(lprec *lp, int index, MYBOOL checkfixed)
function MYBOOL (line 8603) | MYBOOL __WINAPI set_multiprice(lprec *lp, int multiblockdiv)
function get_multiprice (line 8615) | int __WINAPI get_multiprice(lprec *lp, MYBOOL getabssize)
function MYBOOL (line 8625) | MYBOOL __WINAPI set_partialprice(lprec *lp, int blockcount, int *blockst...
function get_partialprice (line 8719) | void __WINAPI get_partialprice(lprec *lp, int *blockcount, int *blocksta...
function STATIC (line 8745) | STATIC MYBOOL bb_better(lprec *lp, int target, int mode)
function STATIC (line 8824) | STATIC void construct_solution(lprec *lp, REAL *target)
function STATIC (line 8973) | STATIC int check_solution(lprec *lp, int lastcolumn, REAL *solution,
function REAL (line 9238) | REAL __WINAPI get_accuracy(lprec *lp)
function set_break_numeric_accuracy (line 9243) | void __WINAPI set_break_numeric_accuracy(lprec *lp, REAL accuracy)
function REAL (line 9248) | REAL __WINAPI get_break_numeric_accuracy(lprec *lp)
function STATIC (line 9253) | STATIC void transfer_solution_var(lprec *lp, int uservar)
function STATIC (line 9261) | STATIC void transfer_solution(lprec *lp, MYBOOL dofinal)
function STATIC (line 9304) | STATIC MYBOOL construct_duals(lprec *lp)
function STATIC (line 9408) | STATIC MYBOOL construct_sensitivity_duals(lprec *lp)
function STATIC (line 9502) | STATIC MYBOOL construct_sensitivity_obj(lprec *lp)
function STATIC (line 9627) | STATIC MYBOOL refactRecent(lprec *lp)
function STATIC (line 9638) | STATIC MYBOOL check_if_less(lprec *lp, REAL x, REAL y, int variable)
function STATIC (line 9652) | STATIC int findNonBasicSlack(lprec *lp, MYBOOL *is_basic)
function STATIC (line 9662) | STATIC int findBasisPos(lprec *lp, int notint, int *var_basic)
function STATIC (line 9674) | STATIC void replaceBasisVar(lprec *lp, int rownr, int var, int *var_basi...
function STATIC (line 9686) | STATIC void free_duals(lprec *lp)
function STATIC (line 9699) | STATIC void initialize_solution(lprec *lp, MYBOOL shiftbounds)
function STATIC (line 9824) | STATIC void recompute_solution(lprec *lp, MYBOOL shiftbounds)
function STATIC (line 9849) | STATIC int verify_solution(lprec *lp, MYBOOL reinvert, char *info)
function STATIC (line 9927) | STATIC int identify_GUB(lprec *lp, MYBOOL mark)
function STATIC (line 9983) | STATIC int prepare_GUB(lprec *lp)
function STATIC (line 10033) | STATIC MYBOOL pre_MIPOBJ(lprec *lp)
function STATIC (line 10050) | STATIC MYBOOL post_MIPOBJ(lprec *lp)
function preprocess (line 10065) | int preprocess(lprec *lp)
function postprocess (line 10277) | void postprocess(lprec *lp)
FILE: utilities/lp_solve/lp_lib.h
type basisrec (line 744) | typedef struct _basisrec
type presolveundorec (line 755) | typedef struct _presolveundorec
type BBPSrec (line 776) | typedef struct _BBPSrec
type partialrec (line 792) | typedef struct _partialrec {
type lprec (line 829) | typedef lprec * (__WINAPI copy_lp_func)(lprec *lp);
type lprec (line 954) | typedef lprec * (__WINAPI make_lp_func)(int rows, int columns);
type lprec (line 969) | typedef lprec * (__WINAPI read_LP_func)(char *filename, int verbose, cha...
type lprec (line 970) | typedef lprec * (__WINAPI read_MPS_func)(char *filename, int options);
type lprec (line 971) | typedef lprec * (__WINAPI read_XLI_func)(char *xliname, const char *mode...
type const (line 974) | typedef MYBOOL (__WINAPI read_params_func)(lprec *lp, const char *filena...
type constr_type (line 1051) | typedef MYBOOL (__WINAPI str_add_constraint_func)(lprec *lp, const char ...
type con_type (line 1052) | typedef MYBOOL (__WINAPI str_add_lag_con_func)(lprec *lp, const char *ro...
type const (line 1063) | typedef MYBOOL (__WINAPI write_XLI_func)(lprec *lp, const char *filename...
type const (line 1065) | typedef MYBOOL (__WINAPI write_params_func)(lprec *lp, const char *filen...
type REAL (line 1091) | typedef REAL *(BFP_CALLMODEL BFPrealp_lp)(lprec *lp);
type const (line 1100) | typedef MYBOOL (BFP_CALLMODEL BFPbool_lpintintchar)(lprec *lp, int size,...
type const (line 1112) | typedef MYBOOL (XLI_CALLMODEL XLIbool_lpcharcharcharint)(lprec *lp, cons...
type const (line 1113) | typedef MYBOOL (XLI_CALLMODEL XLIbool_lpcharcharbool)(lprec *lp, const c...
type _lprec (line 1118) | struct _lprec
FILE: utilities/lp_solve/lp_matrix.c
function STATIC (line 36) | STATIC MATrec *mat_create(lprec *lp, int rows, int columns, REAL epsvalue)
function STATIC (line 58) | STATIC void mat_free(MATrec **matrix)
function STATIC (line 91) | STATIC MYBOOL mat_memopt(MATrec *mat, int rowextra, int colextra, int nz...
function STATIC (line 151) | STATIC MYBOOL inc_mat_space(MATrec *mat, int mindelta)
function STATIC (line 195) | STATIC MYBOOL inc_matrow_space(MATrec *mat, int deltarows)
function STATIC (line 217) | STATIC MYBOOL inc_matcol_space(MATrec *mat, int deltacols)
function STATIC (line 243) | STATIC int mat_collength(MATrec *mat, int colnr)
function STATIC (line 248) | STATIC int mat_rowlength(MATrec *mat, int rownr)
function STATIC (line 260) | STATIC int mat_nonzeros(MATrec *mat)
function STATIC (line 265) | STATIC MYBOOL mat_indexrange(MATrec *mat, int index, MYBOOL isrow, int *...
function STATIC (line 288) | STATIC int mat_shiftrows(MATrec *mat, int *bbase, int delta, LLrec *varmap)
function STATIC (line 410) | STATIC int mat_mapreplace(MATrec *mat, LLrec *rowmap, LLrec *colmap, MAT...
function STATIC (line 584) | STATIC int mat_zerocompact(MATrec *mat)
function STATIC (line 588) | STATIC int mat_rowcompact(MATrec *mat, MYBOOL dozeros)
function STATIC (line 619) | STATIC int mat_colcompact(MATrec *mat, int prev_rows, int prev_cols)
function STATIC (line 668) | STATIC int mat_shiftcols(MATrec *mat, int *bbase, int delta, LLrec *varmap)
function STATIC (line 766) | STATIC MATrec *mat_extractmat(MATrec *mat, LLrec *rowmap, LLrec *colmap,...
function STATIC (line 791) | STATIC MYBOOL mat_setcol(MATrec *mat, int colno, int count, REAL *column...
function STATIC (line 945) | STATIC MYBOOL mat_mergemat(MATrec *target, MATrec *source, MYBOOL usecol...
function STATIC (line 986) | STATIC int mat_nz_unused(MATrec *mat)
function STATIC (line 992) | STATIC MYBOOL mat_setrow(MATrec *mat, int rowno, int count, REAL *row, i...
function STATIC (line 1386) | STATIC MYBOOL mat_setrow(MATrec *mat, int rowno, int count, REAL *row, i...
function STATIC (line 1623) | STATIC int mat_appendrow(MATrec *mat, int count, REAL *row, int *colno, ...
function STATIC (line 1758) | STATIC int mat_appendcol(MATrec *mat, int count, REAL *column, int *rown...
function STATIC (line 1853) | STATIC int mat_checkcounts(MATrec *mat, int *rownum, int *colnum, MYBOOL...
function STATIC (line 1900) | STATIC MYBOOL mat_validate(MATrec *mat)
function MYBOOL (line 1955) | MYBOOL mat_get_data(lprec *lp, int matindex, MYBOOL isrow, int **rownr, ...
function MYBOOL (line 1993) | MYBOOL mat_set_rowmap(MATrec *mat, int row_mat_index, int rownr, int col...
function mat_findelm (line 2016) | int mat_findelm(MATrec *mat, int row, int column)
function mat_findins (line 2077) | int mat_findins(MATrec *mat, int row, int column, int *insertpos, MYBOOL...
function STATIC (line 2167) | STATIC REAL mat_getitem(MATrec *mat, int row, int column)
function STATIC (line 2185) | STATIC MYBOOL mat_additem(MATrec *mat, int row, int column, REAL delta)
function STATIC (line 2207) | STATIC MYBOOL mat_setitem(MATrec *mat, int row, int column, REAL value)
function STATIC (line 2243) | STATIC void mat_multcol(MATrec *mat, int col_nr, REAL mult, MYBOOL DoObj)
function STATIC (line 2270) | STATIC void mat_multadd(MATrec *mat, REAL *lhsvector, int varnr, REAL mult)
function STATIC (line 2305) | STATIC MYBOOL mat_setvalue(MATrec *mat, int Row, int Column, REAL Value,...
function STATIC (line 2416) | STATIC MYBOOL mat_appendvalue(MATrec *mat, int Row, REAL Value)
function STATIC (line 2451) | STATIC MYBOOL mat_equalRows(MATrec *mat, int baserow, int comprow)
function STATIC (line 2485) | STATIC int mat_findcolumn(MATrec *mat, int matindex)
function STATIC (line 2496) | STATIC int mat_expandcolumn(MATrec *mat, int colnr, REAL *column, int *n...
function STATIC (line 2532) | STATIC MYBOOL mat_computemax(MATrec *mat)
function STATIC (line 2575) | STATIC MYBOOL mat_transpose(MATrec *mat)
function STATIC (line 2654) | STATIC DeltaVrec *createUndoLadder(lprec *lp, int levelitems, int maxlev...
function STATIC (line 2665) | STATIC int incrementUndoLadder(DeltaVrec *DV)
function STATIC (line 2673) | STATIC MYBOOL modifyUndoLadder(DeltaVrec *DV, int itemno, REAL target[],...
function STATIC (line 2686) | STATIC int countsUndoLadder(DeltaVrec *DV)
function STATIC (line 2693) | STATIC int restoreUndoLadder(DeltaVrec *DV, REAL target[])
function STATIC (line 2722) | STATIC int decrementUndoLadder(DeltaVrec *DV)
function STATIC (line 2733) | STATIC MYBOOL freeUndoLadder(DeltaVrec **DV)
function STATIC (line 2743) | STATIC MYBOOL appendUndoPresolve(lprec *lp, MYBOOL isprimal, REAL beta, ...
function STATIC (line 2778) | STATIC MYBOOL addUndoPresolve(lprec *lp, MYBOOL isprimal, int colnrElim,...
function __WINAPI (line 2952) | __WINAPI invert(lprec *lp, MYBOOL shiftbounds, MYBOOL final)
function STATIC (line 3054) | STATIC MYBOOL fimprove(lprec *lp, REAL *pcol, int *nzidx, REAL roundzero)
function STATIC (line 3086) | STATIC MYBOOL bimprove(lprec *lp, REAL *rhsvector, int *nzidx, REAL roun...
function STATIC (line 3135) | STATIC void ftran(lprec *lp, REAL *rhsvector, int *nzidx, REAL roundzero)
function STATIC (line 3146) | STATIC void btran(lprec *lp, REAL *rhsvector, int *nzidx, REAL roundzero)
function STATIC (line 3157) | STATIC MYBOOL fsolve(lprec *lp, int varin, REAL *pcol, int *nzidx, REAL ...
function STATIC (line 3177) | STATIC MYBOOL bsolve(lprec *lp, int row_nr, REAL *rhsvector, int *nzidx,...
function STATIC (line 3194) | STATIC MYBOOL vec_compress(REAL *densevector, int startpos, int endpos, ...
function STATIC (line 3218) | STATIC MYBOOL vec_expand(REAL *nzvector, int *nzindex, REAL *densevector...
function STATIC (line 3244) | STATIC MYBOOL get_colIndexA(lprec *lp, int varset, int *colindex, MYBOOL...
function STATIC (line 3324) | STATIC int prod_Ax(lprec *lp, int *coltarget, REAL *input, int *nzinput,
function STATIC (line 3628) | STATIC MYBOOL prod_xA2(lprec *lp, int *coltarget,
function STATIC (line 3809) | STATIC void bsolve_xA2(lprec *lp, int* coltarget,
FILE: utilities/lp_solve/lp_matrix.h
type MATitem (line 9) | typedef struct _MATitem
type MATrec (line 104) | typedef struct _MATrec
type DeltaVrec (line 157) | typedef struct _DeltaVrec
FILE: utilities/lp_solve/lp_mipbb.c
function STATIC (line 43) | STATIC BBrec *create_BB(lprec *lp, BBrec *parentBB, MYBOOL dofullcopy)
function STATIC (line 80) | STATIC BBrec *push_BB(lprec *lp, BBrec *parentBB, int varno, int vartype...
function STATIC (line 169) | STATIC MYBOOL free_BB(BBrec **BB)
function STATIC (line 191) | STATIC BBrec *pop_BB(BBrec *BB)
function STATIC (line 278) | STATIC REAL probe_BB(BBrec *BB)
function STATIC (line 307) | STATIC REAL presolve_BB(BBrec *BB)
function STATIC (line 314) | STATIC MYBOOL initbranches_BB(BBrec *BB)
function STATIC (line 430) | STATIC MYBOOL fillbranches_BB(BBrec *BB)
FILE: utilities/lp_solve/lp_mipbb.h
type BBrec (line 9) | typedef struct _BBrec
FILE: utilities/lp_solve/lp_params.c
type _values (line 36) | struct _values {
type _functions (line 41) | struct _functions {
type _values (line 62) | struct _values
type _values (line 77) | struct _values
type _values (line 85) | struct _values
type _values (line 92) | struct _values
type _values (line 117) | struct _values
function REAL (line 126) | static REAL __WINAPI get_mip_gap_abs(lprec *lp)
function REAL (line 131) | static REAL __WINAPI get_mip_gap_rel(lprec *lp)
function set_mip_gap_abs (line 136) | static void __WINAPI set_mip_gap_abs(lprec *lp, REAL mip_gap)
function set_mip_gap_rel (line 141) | static void __WINAPI set_mip_gap_rel(lprec *lp, REAL mip_gap)
type _values (line 146) | struct _values
type _values (line 164) | struct _values
function set_presolve1 (line 210) | static void __WINAPI set_presolve1(lprec *lp, int do_presolve)
function set_presolve2 (line 215) | static void __WINAPI set_presolve2(lprec *lp, int maxloops)
type _values (line 220) | struct _values
type _values (line 227) | struct _values
type _values (line 246) | struct _values
type _values (line 254) | struct _values
type _functions (line 265) | struct _functions
function write_params1 (line 309) | static void write_params1(lprec *lp, FILE *fp, const char *header, int n...
function readoptions (line 395) | static void readoptions(const char *options, char **header)
function MYBOOL (line 420) | MYBOOL __WINAPI write_params(lprec *lp, const char *filename, const char...
function MYBOOL (line 519) | MYBOOL __WINAPI read_params(lprec *lp, const char *filename, const char ...
FILE: utilities/lp_solve/lp_presolve.c
function STATIC (line 49) | STATIC int presolve_setstatusex(presolverec *psdata, int status, int lin...
function STATIC (line 64) | STATIC MYBOOL presolve_statuscheck(presolverec *psdata, int *status)
function STATIC (line 76) | STATIC MYBOOL presolve_createUndo(lprec *lp)
function STATIC (line 86) | STATIC MYBOOL inc_presolve_space(lprec *lp, int delta, MYBOOL isrows)
function STATIC (line 127) | STATIC MYBOOL presolve_setOrig(lprec *lp, int orig_rows, int orig_cols)
function STATIC (line 140) | STATIC MYBOOL presolve_fillUndo(lprec *lp, int orig_rows, int orig_cols,...
function STATIC (line 160) | STATIC MYBOOL presolve_rebuildUndo(lprec *lp, MYBOOL isprimal)
function STATIC (line 222) | STATIC MYBOOL presolve_freeUndo(lprec *lp)
function STATIC (line 242) | STATIC void presolve_storeDualUndo(presolverec *psdata, int rownr, int c...
function STATIC (line 271) | STATIC MYBOOL presolve_SOScheck(presolverec *psdata)
function INLINE (line 344) | INLINE REAL presolve_roundrhs(lprec *lp, REAL value, MYBOOL isGE)
function INLINE (line 368) | INLINE REAL presolve_roundval(lprec *lp, REAL value)
function INLINE (line 390) | INLINE REAL presolve_sumplumin(lprec *lp, int item, psrec *ps, MYBOOL do...
function INLINE (line 403) | INLINE void presolve_range(lprec *lp, int rownr, psrec *ps, REAL *loValu...
function STATIC (line 409) | STATIC void presolve_rangeorig(lprec *lp, int rownr, psrec *ps, REAL *lo...
function STATIC (line 416) | STATIC MYBOOL presolve_rowfeasible(presolverec *psdata, int rownr, MYBOO...
function STATIC (line 460) | STATIC MYBOOL presolve_debugmap(presolverec *psdata, const char *caption)
function STATIC (line 510) | STATIC MYBOOL presolve_validate(presolverec *psdata, MYBOOL forceupdate)
function STATIC (line 610) | STATIC MYBOOL presolve_rowtallies(presolverec *psdata, int rownr, int *p...
function STATIC (line 640) | STATIC MYBOOL presolve_debugrowtallies(presolverec *psdata)
function STATIC (line 658) | STATIC int presolve_debugcheck(lprec *lp, LLrec *rowmap, LLrec *colmap)
function STATIC (line 689) | STATIC MYBOOL presolve_candeletevar(presolverec *psdata, int colnr)
function STATIC (line 700) | STATIC int presolve_rowlengthex(presolverec *psdata, int rownr)
function STATIC (line 715) | STATIC int presolve_rowlengthdebug(presolverec *psdata)
function INLINE (line 725) | INLINE int presolve_nextrecord(psrec *ps, int recnr, int *previtem)
function INLINE (line 751) | INLINE int presolve_nextcol(presolverec *psdata, int rownr, int *previtem)
function INLINE (line 756) | INLINE int presolve_lastcol(presolverec *psdata, int rownr)
function INLINE (line 760) | INLINE int presolve_nextrow(presolverec *psdata, int colnr, int *previtem)
function INLINE (line 765) | INLINE int presolve_lastrow(presolverec *psdata, int colnr)
function INLINE (line 770) | INLINE void presolve_adjustrhs(presolverec *psdata, int rownr, REAL fixd...
function STATIC (line 784) | STATIC int presolve_shrink(presolverec *psdata, int *nConRemove, int *nV...
function STATIC (line 830) | STATIC void presolve_rowremove(presolverec *psdata, int rownr, MYBOOL al...
function STATIC (line 889) | STATIC int presolve_colremove(presolverec *psdata, int colnr, MYBOOL all...
function STATIC (line 960) | STATIC int presolve_redundantSOS(presolverec *psdata, int *nb, int *nSum)
function STATIC (line 1053) | STATIC MYBOOL presolve_fixSOS1(presolverec *psdata, int colnr, REAL fixv...
function STATIC (line 1153) | STATIC void presolve_setEQ(presolverec *psdata, int rownr)
function STATIC (line 1165) | STATIC MYBOOL presolve_singletonbounds(presolverec *psdata, int rownr, i...
function STATIC (line 1264) | STATIC MYBOOL presolve_multibounds(presolverec *psdata, int rownr, int c...
function STATIC (line 1341) | STATIC MYBOOL isnz_origobj(lprec *lp, int colnr)
function STATIC (line 1346) | STATIC MYBOOL presolve_testrow(presolverec *psdata, int lastrow)
function STATIC (line 1359) | STATIC MYBOOL presolve_coltighten(presolverec *psdata, int colnr, REAL L...
function STATIC (line 1509) | STATIC int presolve_rowtighten(presolverec *psdata, int rownr, int *tall...
function STATIC (line 1577) | STATIC void set_dv_bounds(presolverec *psdata, int rownr, REAL lowbo, RE...
function STATIC (line 1582) | STATIC REAL get_dv_lower(presolverec *psdata, int rownr)
function STATIC (line 1587) | STATIC REAL get_dv_upper(presolverec *psdata, int rownr)
function STATIC (line 1592) | STATIC MYBOOL presolve_rowfix(presolverec *psdata, int rownr, REAL newva...
function STATIC (line 1742) | STATIC int presolve_colsingleton(presolverec *psdata, int i, int j, int ...
function STATIC (line 1779) | STATIC MYBOOL presolve_colfix(presolverec *psdata, int colnr, REAL newva...
function STATIC (line 1973) | STATIC int presolve_rowfixzero(presolverec *psdata, int rownr, int *nv)
function STATIC (line 1995) | STATIC MYBOOL presolve_colfixdual(presolverec *psdata, int colnr, REAL *...
function STATIC (line 2090) | STATIC MYBOOL presolve_probefix01(presolverec *psdata, int colnr, REAL *...
function STATIC (line 2136) | STATIC MYBOOL presolve_probefix01(presolverec *psdata, int colnr, REAL *...
function STATIC (line 2203) | STATIC int presolve_probetighten01(presolverec *psdata, int colnr)
function STATIC (line 2249) | STATIC int presolve_mergerows(presolverec *psdata, int *nRows, int *nSum)
function STATIC (line 2402) | STATIC MYBOOL presolve_reduceGCD(presolverec *psdata, int *nn, int *nb, ...
function STATIC (line 2457) | STATIC int presolve_knapsack(presolverec *psdata, int *nn)
function STATIC (line 2547) | STATIC MYBOOL presolve_invalideq2(lprec *lp, presolverec *psdata)
function presolve_getcolumnEQ (line 2586) | int BFP_CALLMODEL presolve_getcolumnEQ(lprec *lp, int colnr, REAL nzvalu...
function STATIC (line 2606) | STATIC int presolve_singularities(presolverec *psdata, int *nn, int *nr,...
function STATIC (line 3022) | STATIC MYBOOL presolve_impliedfree(lprec *lp, presolverec *psdata, int c...
function STATIC (line 3046) | STATIC MYBOOL presolve_impliedcolfix(presolverec *psdata, int rownr, int...
function STATIC (line 3257) | STATIC psrec *presolve_initpsrec(lprec *lp, int size)
function STATIC (line 3285) | STATIC void presolve_freepsrec(psrec **ps)
function STATIC (line 3311) | STATIC presolverec *presolve_init(lprec *lp)
function STATIC (line 3424) | STATIC void presolve_free(presolverec **psdata)
function STATIC (line 3438) | STATIC int presolve_makefree(presolverec *psdata)
function STATIC (line 3511) | STATIC MYBOOL presolve_updatesums(presolverec *psdata)
function STATIC (line 3547) | STATIC MYBOOL presolve_finalize(presolverec *psdata)
function STATIC (line 3614) | STATIC MYBOOL presolve_debugdump(lprec *lp, presolverec *psdata, const c...
function compRedundant (line 3654) | int CMP_CALLMODEL compRedundant(const UNIONTYPE QSORTrec *current, const...
function compSparsity (line 3667) | int CMP_CALLMODEL compSparsity(const UNIONTYPE QSORTrec *current, const ...
function compAggregate (line 3686) | int CMP_CALLMODEL compAggregate(const UNIONTYPE QSORTrec *current, const...
function STATIC (line 3715) | STATIC int presolve_rowdominance(presolverec *psdata, int *nCoeffChanged...
function STATIC (line 3901) | STATIC int presolve_coldominance01(presolverec *psdata, int *nConRemoved...
function STATIC (line 4082) | STATIC int presolve_coldominance01(presolverec *psdata, NATURAL *nConRem...
function STATIC (line 4277) | STATIC int presolve_aggregate(presolverec *psdata, int *nConRemoved, int...
function STATIC (line 4495) | STATIC int presolve_makesparser(presolverec *psdata, int *nCoeffChanged,...
function STATIC (line 4773) | STATIC int presolve_SOS1(presolverec *psdata, int *nCoeffChanged, int *n...
function STATIC (line 4842) | STATIC int presolve_boundconflict(presolverec *psdata, int baserowno, in...
function STATIC (line 4878) | STATIC int presolve_columns(presolverec *psdata, int *nCoeffChanged, int...
function STATIC (line 5052) | STATIC int presolve_freeandslacks(presolverec *psdata, int *nCoeffChange...
function STATIC (line 5424) | STATIC int presolve(lprec *lp)
function STATIC (line 5873) | STATIC MYBOOL postsolve(lprec *lp, int status)
FILE: utilities/lp_solve/lp_presolve.h
type psrec (line 37) | typedef struct _psrec
type presolverec (line 53) | typedef struct _presolverec
function INLINE (line 112) | INLINE int presolve_rowlength(presolverec *psdata, int rownr)
function INLINE (line 121) | INLINE int presolve_collength(presolverec *psdata, int colnr)
FILE: utilities/lp_solve/lp_price.c
function compareImprovementVar (line 42) | int CMP_CALLMODEL compareImprovementVar(const pricerec *current, const p...
function compareSubstitutionVar (line 153) | int CMP_CALLMODEL compareSubstitutionVar(const pricerec *current, const ...
function compareBoundFlipVar (line 293) | int CMP_CALLMODEL compareBoundFlipVar(const pricerec *current, const pri...
function STATIC (line 373) | STATIC MYBOOL validImprovementVar(pricerec *candidate)
function STATIC (line 384) | STATIC MYBOOL validSubstitutionVar(pricerec *candidate)
function compareImprovementQS (line 401) | int CMP_CALLMODEL compareImprovementQS(const UNIONTYPE QSORTrec *current...
function compareSubstitutionQS (line 405) | int CMP_CALLMODEL compareSubstitutionQS(const UNIONTYPE QSORTrec *curren...
function STATIC (line 412) | STATIC int addCandidateVar(pricerec *candidate, multirec *multi, findCom...
function STATIC (line 498) | STATIC MYBOOL findImprovementVar(pricerec *current, pricerec *candidate,...
function STATIC (line 533) | STATIC MYBOOL collectMinorVar(pricerec *candidate, multirec *longsteps, ...
function STATIC (line 569) | STATIC MYBOOL findSubstitutionVar(pricerec *current, pricerec *candidate...
function STATIC (line 602) | STATIC partialrec *partial_createBlocks(lprec *lp, MYBOOL isrow)
function STATIC (line 614) | STATIC int partial_countBlocks(lprec *lp, MYBOOL isrow)
function STATIC (line 623) | STATIC int partial_activeBlocks(lprec *lp, MYBOOL isrow)
function STATIC (line 632) | STATIC void partial_freeBlocks(partialrec **blockdata)
function STATIC (line 644) | STATIC void makePriceLoop(lprec *lp, int *start, int *end, int *delta)
function STATIC (line 661) | STATIC MYBOOL serious_facterror(lprec *lp, REAL *bvector, int maxcols, R...
function STATIC (line 699) | STATIC void update_reducedcosts(lprec *lp, MYBOOL isdual, int leave_nr, ...
function STATIC (line 723) | STATIC void compute_reducedcosts(lprec *lp, MYBOOL isdual, int row_nr, i...
function STATIC (line 766) | STATIC MYBOOL verify_stability(lprec *lp, MYBOOL isprimal, REAL xfeas, R...
function STATIC (line 799) | STATIC int find_rowReplacement(lprec *lp, int rownr, REAL *prow, int *nz...
function STATIC (line 833) | STATIC int colprim(lprec *lp, REAL *drow, int *nzdrow, MYBOOL skipupdate...
function STATIC (line 960) | STATIC int rowprim(lprec *lp, int colnr, LREAL *theta, REAL *pcol, int *...
function STATIC (line 1175) | STATIC int rowdual(lprec *lp, REAL *rhvec, MYBOOL forceoutEQ, MYBOOL upd...
function STATIC (line 1295) | STATIC void longdual_testset(lprec *lp, int which, int rownr, REAL *prow...
function STATIC (line 1353) | STATIC int coldual(lprec *lp, int row_nr, REAL *prow, int *nzprow,
function INLINE (line 1551) | INLINE REAL normalizeEdge(lprec *lp, int item, REAL edge, MYBOOL isdual)
function STATIC (line 1566) | STATIC int partial_findBlocks(lprec *lp, MYBOOL autodefine, MYBOOL isrow)
function STATIC (line 1655) | STATIC int partial_blockStart(lprec *lp, MYBOOL isrow)
function STATIC (line 1668) | STATIC int partial_blockEnd(lprec *lp, MYBOOL isrow)
function STATIC (line 1681) | STATIC int partial_blockNextPos(lprec *lp, int block, MYBOOL isrow)
function STATIC (line 1700) | STATIC MYBOOL partial_blockStep(lprec *lp, MYBOOL isrow)
function STATIC (line 1716) | STATIC MYBOOL partial_isVarActive(lprec *lp, int varno, MYBOOL isrow)
function STATIC (line 1731) | STATIC multirec *multi_create(lprec *lp, MYBOOL truncinf)
function STATIC (line 1745) | STATIC void multi_free(multirec **multi)
function STATIC (line 1756) | STATIC MYBOOL multi_mustupdate(multirec *multi)
function STATIC (line 1761) | STATIC MYBOOL multi_resize(multirec *multi, int blocksize, int blockdiv,...
function STATIC (line 1812) | STATIC int multi_size(multirec *multi)
function STATIC (line 1820) | STATIC int multi_used(multirec *multi)
function STATIC (line 1828) | STATIC int multi_restart(multirec *multi)
function STATIC (line 1847) | STATIC void multi_valueInit(multirec *multi, REAL step_base, REAL obj_base)
function STATIC (line 1858) | STATIC REAL *multi_valueList(multirec *multi)
function STATIC (line 1863) | STATIC int *multi_indexSet(multirec *multi, MYBOOL regenerate)
function STATIC (line 1870) | STATIC int multi_getvar(multirec *multi, int item)
function STATIC (line 1879) | STATIC MYBOOL multi_recompute(multirec *multi, int index, MYBOOL isphase...
function STATIC (line 1967) | STATIC MYBOOL multi_truncatingvar(multirec *multi, int varnr)
function STATIC (line 1972) | STATIC MYBOOL multi_removevar(multirec *multi, int varnr)
function STATIC (line 1993) | STATIC int multi_enteringvar(multirec *multi, pricerec *current, int pri...
function STATIC (line 2086) | STATIC REAL multi_enteringtheta(multirec *multi)
function STATIC (line 2091) | STATIC int multi_populateSet(multirec *multi, int **list, int excludenr)
FILE: utilities/lp_solve/lp_pricePSE.c
function INLINE (line 44) | INLINE MYBOOL applyPricer(lprec *lp)
function STATIC (line 51) | STATIC void simplexPricer(lprec *lp, MYBOOL isdual)
function STATIC (line 58) | STATIC void freePricer(lprec *lp)
function STATIC (line 64) | STATIC MYBOOL resizePricer(lprec *lp)
function STATIC (line 80) | STATIC MYBOOL initPricer(lprec *lp)
function STATIC (line 93) | STATIC REAL getPricer(lprec *lp, int item, MYBOOL isdual)
function STATIC (line 137) | STATIC MYBOOL restartPricer(lprec *lp, MYBOOL isdual)
function STATIC (line 227) | STATIC MYBOOL formWeights(lprec *lp, int colnr, REAL *pcol, REAL **w)
function STATIC (line 258) | STATIC void freeWeights(REAL *w)
function STATIC (line 264) | STATIC MYBOOL updatePricer(lprec *lp, int rownr, int colnr, REAL *pcol, ...
function STATIC (line 498) | STATIC MYBOOL verifyPricer(lprec *lp)
FILE: utilities/lp_solve/lp_report.c
function report (line 55) | void __VACALL report(lprec *lp, int level, const char * format, ...)
function STATIC (line 86) | STATIC void print_indent(lprec *lp)
function STATIC (line 99) | STATIC void debug_print(lprec *lp, const char *format, ...)
function STATIC (line 123) | STATIC void debug_print_solution(lprec *lp)
function STATIC (line 136) | STATIC void debug_print_bounds(lprec *lp, REAL *upbo, REAL *lowbo)
function blockWriteLREAL (line 163) | void blockWriteLREAL(FILE *output, const char *label, LREAL *vector, int...
function blockWriteAMAT (line 182) | void blockWriteAMAT(FILE *output, const char *label, lprec* lp, int firs...
function blockWriteBMAT (line 251) | void blockWriteBMAT(FILE *output, const char *label, lprec* lp, int firs...
function MYBOOL (line 296) | MYBOOL REPORT_debugdump(lprec *lp, const char *filename, MYBOOL livedata)
function REPORT_objective (line 355) | void REPORT_objective(lprec *lp)
function REPORT_solution (line 366) | void REPORT_solution(lprec *lp, int columns)
function REPORT_constraints (line 396) | void REPORT_constraints(lprec *lp, int columns)
function REPORT_duals (line 425) | void REPORT_duals(lprec *lp)
function REPORT_extended (line 457) | void REPORT_extended(lprec *lp)
function REPORT_lp (line 511) | void REPORT_lp(lprec *lp)
function REPORT_scales (line 578) | void REPORT_scales(lprec *lp)
function MYBOOL (line 598) | MYBOOL REPORT_tableau(lprec *lp)
function REPORT_constraintinfo (line 667) | void REPORT_constraintinfo(lprec *lp, const char *datainfo)
function REPORT_modelinfo (line 683) | void REPORT_modelinfo(lprec *lp, MYBOOL doName, const char *datainfo)
function MYBOOL (line 707) | MYBOOL REPORT_mat_mmsave(lprec *lp, const char *filename, int *colndx, M...
FILE: utilities/lp_solve/lp_rlp.c
type lp_yytokentype (line 68) | enum lp_yytokentype {
type parse_vars (line 139) | typedef struct parse_vars_s
function isatty (line 170) | static int isatty(int f)
function lp_input_lp_yyin (line 180) | static int __WINAPI lp_input_lp_yyin(void *fpin, char *buf, int max_size)
function lp_input (line 189) | static int __WINAPI lp_input(void *vpp, char *buf, int max_size)
type YYSTYPE (line 230) | typedef int YYSTYPE;
type YYTYPE_UINT8 (line 249) | typedef YYTYPE_UINT8 lp_yytype_uint8;
type lp_yytype_uint8 (line 251) | typedef unsigned char lp_yytype_uint8;
type YYTYPE_INT8 (line 255) | typedef YYTYPE_INT8 lp_yytype_int8;
type lp_yytype_int8 (line 258) | typedef signed char lp_yytype_int8;
type lp_yytype_int8 (line 260) | typedef short int lp_yytype_int8;
type YYTYPE_UINT16 (line 264) | typedef YYTYPE_UINT16 lp_yytype_uint16;
type lp_yytype_uint16 (line 266) | typedef unsigned short int lp_yytype_uint16;
type YYTYPE_INT16 (line 270) | typedef YYTYPE_INT16 lp_yytype_int16;
type lp_yytype_int16 (line 272) | typedef short int lp_yytype_int16;
function YYID (line 319) | static int
function lp_yy_symbol_value_print (line 875) | static void
function lp_yy_symbol_print (line 911) | static void
function lp_yy_stack_print (line 939) | static void
function lp_yy_reduce_print (line 967) | static void
function YYSIZE_T (line 1038) | static YYSIZE_T
function YYSIZE_T (line 1087) | static YYSIZE_T
function YYSIZE_T (line 1134) | static YYSIZE_T
function lp_yydestruct (line 1247) | static void
function lp_yyparse (line 1314) | int
function lp_yy_delete_allocated_memory (line 2388) | static void lp_yy_delete_allocated_memory(parse_parm *pp)
function parse (line 2419) | static int parse(parse_parm *pp)
function lprec (line 2424) | lprec *read_lp1(lprec *lp, void *userhandle, read_modeldata_func read_mo...
function lprec (line 2459) | lprec *read_LP1(lprec *lp, const char *filename, int verbose, char *lp_n...
function MYBOOL (line 2477) | MYBOOL __WINAPI LP_readhandle(lprec **lp, FILE *filename, int verbose, c...
FILE: utilities/lp_solve/lp_rlp.h
type flex_int8_t (line 43) | typedef int8_t flex_int8_t;
type flex_uint8_t (line 44) | typedef uint8_t flex_uint8_t;
type flex_int16_t (line 45) | typedef int16_t flex_int16_t;
type flex_uint16_t (line 46) | typedef uint16_t flex_uint16_t;
type flex_int32_t (line 47) | typedef int32_t flex_int32_t;
type flex_uint32_t (line 48) | typedef uint32_t flex_uint32_t;
type flex_int8_t (line 50) | typedef signed char flex_int8_t;
type flex_int16_t (line 51) | typedef short int flex_int16_t;
type flex_int32_t (line 52) | typedef int flex_int32_t;
type flex_uint8_t (line 53) | typedef unsigned char flex_uint8_t;
type flex_uint16_t (line 54) | typedef unsigned short int flex_uint16_t;
type flex_uint32_t (line 55) | typedef unsigned int flex_uint32_t;
type lp_yy_buffer_state (line 169) | struct lp_yy_buffer_state
type lp_yy_size_t (line 209) | typedef size_t lp_yy_size_t;
type lp_yy_buffer_state (line 214) | struct lp_yy_buffer_state
type YY_CHAR (line 343) | typedef unsigned char YY_CHAR;
type lp_yy_state_type (line 345) | typedef int lp_yy_state_type;
type lp_yy_trans_info (line 368) | struct lp_yy_trans_info
type lp_yyguts_t (line 620) | struct lp_yyguts_t
type lp_yyguts_t (line 837) | struct lp_yyguts_t
type lp_yyguts_t (line 837) | struct lp_yyguts_t
function YY_RESTORE_YY_MORE_OFFSET (line 1285) | YY_RESTORE_YY_MORE_OFFSET
function lp_yy_get_next_buffer (line 1414) | static int lp_yy_get_next_buffer (lp_yyscan_t lp_yyscanner)
function lp_yy_state_type (line 1549) | static lp_yy_state_type lp_yy_get_previous_state (lp_yyscan_t lp_yyscanner)
function lp_yy_state_type (line 1583) | static lp_yy_state_type lp_yy_try_NUL_trans (lp_yy_state_type lp_yy_cur...
function lp_yyunput (line 1607) | static void lp_yyunput (int c, char * lp_yy_bp , lp_yyscan_t lp_yyscanner)
function input (line 1653) | static inline int input (lp_yyscan_t lp_yyscanner)
function lp_yyrestart (line 1737) | void lp_yyrestart (FILE * input_file , lp_yyscan_t lp_yyscanner)
function lp_yy_switch_to_buffer (line 1755) | void lp_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , lp_yyscan_t ...
function lp_yy_load_buffer_state (line 1787) | static void lp_yy_load_buffer_state (lp_yyscan_t lp_yyscanner)
function YY_BUFFER_STATE (line 1802) | YY_BUFFER_STATE lp_yy_create_buffer (FILE * file, int size , lp_yyscan...
function lp_yy_delete_buffer (line 1830) | void lp_yy_delete_buffer (YY_BUFFER_STATE b , lp_yyscan_t lp_yyscanner)
function lp_yy_init_buffer (line 1854) | static void lp_yy_init_buffer (YY_BUFFER_STATE b, FILE * file , lp_yys...
function lp_yy_flush_buffer (line 1883) | void lp_yy_flush_buffer (YY_BUFFER_STATE b , lp_yyscan_t lp_yyscanner)
function lp_yypush_buffer_state (line 1913) | void lp_yypush_buffer_state (YY_BUFFER_STATE new_buffer , lp_yyscan_t lp...
function lp_yypop_buffer_state (line 1944) | void lp_yypop_buffer_state (lp_yyscan_t lp_yyscanner)
function lp_yyensure_buffer_stack (line 1964) | static void lp_yyensure_buffer_stack (lp_yyscan_t lp_yyscanner)
function YY_BUFFER_STATE (line 2014) | YY_BUFFER_STATE lp_yy_scan_buffer (char * base, lp_yy_size_t size , lp...
function YY_BUFFER_STATE (line 2051) | YY_BUFFER_STATE lp_yy_scan_string (lp_yyconst char * lp_yystr , lp_yysca...
function YY_BUFFER_STATE (line 2064) | YY_BUFFER_STATE lp_yy_scan_bytes (lp_yyconst char * lp_yybytes, int _l...
function lp_yy_fatal_error (line 2098) | static void lp_yy_fatal_error (lp_yyconst char* msg , lp_yyscan_t lp_yys...
function YY_EXTRA_TYPE (line 2127) | YY_EXTRA_TYPE lp_yyget_extra (lp_yyscan_t lp_yyscanner)
function lp_yyget_lineno (line 2136) | int lp_yyget_lineno (lp_yyscan_t lp_yyscanner)
function lp_yyget_column (line 2149) | int lp_yyget_column (lp_yyscan_t lp_yyscanner)
function FILE (line 2162) | FILE *lp_yyget_in (lp_yyscan_t lp_yyscanner)
function FILE (line 2171) | FILE *lp_yyget_out (lp_yyscan_t lp_yyscanner)
function lp_yyget_leng (line 2180) | int lp_yyget_leng (lp_yyscan_t lp_yyscanner)
type lp_yyguts_t (line 2192) | struct lp_yyguts_t
type lp_yyguts_t (line 2192) | struct lp_yyguts_t
function lp_yyset_extra (line 2200) | void lp_yyset_extra (YY_EXTRA_TYPE user_defined , lp_yyscan_t lp_yyscan...
function lp_yyset_lineno (line 2210) | void lp_yyset_lineno (int line_number , lp_yyscan_t lp_yyscanner)
function lp_yyset_column (line 2225) | void lp_yyset_column (int column_no , lp_yyscan_t lp_yyscanner)
function lp_yyset_in (line 2242) | void lp_yyset_in (FILE * in_str , lp_yyscan_t lp_yyscanner)
function lp_yyset_out (line 2248) | void lp_yyset_out (FILE * out_str , lp_yyscan_t lp_yyscanner)
function lp_yyget_debug (line 2254) | int lp_yyget_debug (lp_yyscan_t lp_yyscanner)
function lp_yyset_debug (line 2260) | void lp_yyset_debug (int bdebug , lp_yyscan_t lp_yyscanner)
function YYSTYPE (line 2268) | YYSTYPE * lp_yyget_lval (lp_yyscan_t lp_yyscanner)
function lp_yyset_lval (line 2274) | void lp_yyset_lval (YYSTYPE * lp_yylval_param , lp_yyscan_t lp_yyscanner)
function lp_yylex_init (line 2287) | int lp_yylex_init(lp_yyscan_t* ptr_lp_yy_globals)
function lp_yylex_init_extra (line 2316) | int lp_yylex_init_extra(YY_EXTRA_TYPE lp_yy_user_defined,lp_yyscan_t* pt...
function lp_yy_init_globals (line 2344) | static int lp_yy_init_globals (lp_yyscan_t lp_yyscanner)
function lp_yylex_destroy (line 2378) | int lp_yylex_destroy (lp_yyscan_t lp_yyscanner)
function lp_yy_flex_strncpy (line 2412) | static void lp_yy_flex_strncpy (char* s1, lp_yyconst char * s2, int n , ...
function lp_yy_flex_strlen (line 2421) | static int lp_yy_flex_strlen (lp_yyconst char * s , lp_yyscan_t lp_yysca...
function lp_yyfree (line 2450) | void lp_yyfree (void * ptr , lp_yyscan_t lp_yyscanner)
FILE: utilities/lp_solve/lp_scale.c
function REAL (line 34) | REAL scaled_value(lprec *lp, REAL value, int index)
function REAL (line 49) | REAL unscaled_value(lprec *lp, REAL value, int index)
function STATIC (line 64) | STATIC REAL scaled_mat(lprec *lp, REAL value, int rownr, int colnr)
function STATIC (line 71) | STATIC REAL unscaled_mat(lprec *lp, REAL value, int rownr, int colnr)
function REAL (line 81) | REAL CurtisReidMeasure(lprec *lp, MYBOOL _Advanced, REAL *FRowScale, REA...
function CurtisReidScales (line 142) | int CurtisReidScales(lprec *lp, MYBOOL _Advanced, REAL *FRowScale, REAL ...
function STATIC (line 442) | STATIC MYBOOL scaleCR(lprec *lp, REAL *scaledelta)
function STATIC (line 476) | STATIC MYBOOL transform_for_scale(lprec *lp, REAL *value)
function STATIC (line 494) | STATIC void accumulate_for_scale(lprec *lp, REAL *min, REAL *max, REAL v...
function STATIC (line 508) | STATIC REAL minmax_to_scale(lprec *lp, REAL min, REAL max, int itemcount)
function STATIC (line 555) | STATIC REAL roundPower2(REAL scale)
function STATIC (line 585) | STATIC MYBOOL scale_updatecolumns(lprec *lp, REAL *scalechange, MYBOOL u...
function STATIC (line 607) | STATIC MYBOOL scale_updaterows(lprec *lp, REAL *scalechange, MYBOOL upda...
function STATIC (line 630) | STATIC MYBOOL scale_columns(lprec *lp, REAL *scaledelta)
function STATIC (line 679) | STATIC MYBOOL scale_rows(lprec *lp, REAL *scaledelta)
function STATIC (line 733) | STATIC REAL scale(lprec *lp, REAL *scaledelta)
function STATIC (line 884) | STATIC MYBOOL finalize_scaling(lprec *lp, REAL *scaledelta)
function STATIC (line 915) | STATIC REAL auto_scale(lprec *lp)
function STATIC (line 986) | STATIC void unscale_columns(lprec *lp)
function undoscale (line 1026) | void undoscale(lprec *lp)
FILE: utilities/lp_solve/lp_simplex.c
function STATIC (line 42) | STATIC void stallMonitor_update(lprec *lp, REAL newOF)
function STATIC (line 57) | STATIC MYBOOL stallMonitor_creepingObj(lprec *lp)
function STATIC (line 73) | STATIC MYBOOL stallMonitor_shortSteps(lprec *lp)
function STATIC (line 87) | STATIC void stallMonitor_reset(lprec *lp)
function STATIC (line 102) | STATIC MYBOOL stallMonitor_create(lprec *lp, MYBOOL isdual, const char *...
function STATIC (line 141) | STATIC MYBOOL stallMonitor_check(lprec *lp, int rownr, int colnr, int la...
function STATIC (line 330) | STATIC void stallMonitor_finish(lprec *lp)
function STATIC (line 342) | STATIC MYBOOL add_artificial(lprec *lp, int forrownr, REAL *nzarray, int...
function STATIC (line 449) | STATIC int get_artificialRow(lprec *lp, int colnr)
function STATIC (line 466) | STATIC int findAnti_artificial(lprec *lp, int colnr)
function STATIC (line 489) | STATIC int findBasicArtificial(lprec *lp, int before)
function STATIC (line 506) | STATIC void eliminate_artificials(lprec *lp, REAL *prow)
function STATIC (line 529) | STATIC void clear_artificials(lprec *lp)
function STATIC (line 563) | STATIC int primloop(lprec *lp, MYBOOL primalfeasible, REAL primaloffset)
function else (line 1267) | else if(lp->rejectpivot[0] < DEF_MAXPIVOTRETRY) {
function else (line 1277) | else if(dualphase1 && (dualoffset != 0)) {
function STATIC (line 1527) | STATIC int spx_run(lprec *lp, MYBOOL validInvB)
function lprec (line 1702) | lprec *make_lag(lprec *lpserver)
function STATIC (line 1740) | STATIC int heuristics(lprec *lp, int mode)
function STATIC (line 1773) | STATIC int lag_solve(lprec *lp, REAL start_bound, int num_iter)
function STATIC (line 2038) | STATIC int spx_solve(lprec *lp)
function lin_solve (line 2147) | int lin_solve(lprec *lp)
FILE: utilities/lp_solve/lp_types.h
type lprec (line 248) | typedef struct _lprec lprec;
type INVrec (line 249) | typedef struct _INVrec INVrec;
type B4rec (line 261) | typedef struct _B4rec
type OBJmonrec (line 272) | typedef struct _OBJmonrec {
type edgerec (line 289) | typedef struct _edgerec
type pricerec (line 294) | typedef struct _pricerec
type multirec (line 303) | typedef struct _multirec
FILE: utilities/lp_solve/lp_utils.c
function STATIC (line 36) | STATIC MYBOOL allocCHAR(lprec *lp, char **ptr, int size, MYBOOL clear)
function STATIC (line 55) | STATIC MYBOOL allocMYBOOL(lprec *lp, MYBOOL **ptr, int size, MYBOOL clear)
function STATIC (line 74) | STATIC MYBOOL allocINT(lprec *lp, int **ptr, int size, MYBOOL clear)
function STATIC (line 93) | STATIC MYBOOL allocREAL(lprec *lp, REAL **ptr, int size, MYBOOL clear)
function STATIC (line 112) | STATIC MYBOOL allocLREAL(lprec *lp, LREAL **ptr, int size, MYBOOL clear)
function STATIC (line 132) | STATIC MYBOOL allocFREE(lprec *lp, void **ptr)
function comp_bits (line 153) | int comp_bits(MYBOOL *bitarray1, MYBOOL *bitarray2, int items)
function STATIC (line 215) | STATIC workarraysrec *mempool_create(lprec *lp)
function STATIC (line 222) | STATIC char *mempool_obtainVector(workarraysrec *mempool, int count, int...
function STATIC (line 308) | STATIC MYBOOL mempool_releaseVector(workarraysrec *mempool, const char *...
function STATIC (line 334) | STATIC MYBOOL mempool_free(workarraysrec **mempool)
function REAL (line 350) | REAL *cloneREAL(lprec *lp, REAL *origlist, int size)
function MYBOOL (line 359) | MYBOOL *cloneMYBOOL(lprec *lp, MYBOOL *origlist, int size)
function STATIC (line 378) | STATIC void roundVector(LREAL *myvector, int endpos, LREAL roundzero)
function STATIC (line 386) | STATIC REAL normalizeVector(REAL *myvector, int endpos)
function STATIC (line 410) | STATIC void swapINT(int *item1, int *item2)
function STATIC (line 417) | STATIC void swapREAL(REAL *item1, REAL *item2)
function STATIC (line 424) | STATIC void swapPTR(void **item1, void **item2)
function STATIC (line 433) | STATIC REAL restoreINT(REAL valREAL, REAL epsilon)
function STATIC (line 450) | STATIC REAL roundToPrecision(REAL value, REAL precision)
function STATIC (line 501) | STATIC int searchFor(int target, int *attributes, int size, int offset, ...
function STATIC (line 564) | STATIC MYBOOL isINT(lprec *lp, REAL value)
function STATIC (line 585) | STATIC MYBOOL isOrigFixed(lprec *lp, int varno)
function STATIC (line 590) | STATIC void chsign_bounds(REAL *lobound, REAL *upbound)
function STATIC (line 608) | STATIC REAL rand_uniform(lprec *lp, REAL range)
function STATIC (line 627) | STATIC int createLink(int size, LLrec **linkmap, MYBOOL *usedpos)
function STATIC (line 666) | STATIC MYBOOL freeLink(LLrec **linkmap)
function STATIC (line 681) | STATIC int sizeLink(LLrec *linkmap)
function STATIC (line 686) | STATIC MYBOOL isActiveLink(LLrec *linkmap, int itemnr)
function STATIC (line 696) | STATIC int countActiveLink(LLrec *linkmap)
function STATIC (line 701) | STATIC int countInactiveLink(LLrec *linkmap)
function STATIC (line 706) | STATIC int firstActiveLink(LLrec *linkmap)
function STATIC (line 711) | STATIC int lastActiveLink(LLrec *linkmap)
function STATIC (line 716) | STATIC MYBOOL appendLink(LLrec *linkmap, int newitem)
function STATIC (line 741) | STATIC MYBOOL insertLink(LLrec *linkmap, int afteritem, int newitem)
function STATIC (line 771) | STATIC MYBOOL setLink(LLrec *linkmap, int newitem)
function STATIC (line 779) | STATIC MYBOOL fillLink(LLrec *linkmap)
function STATIC (line 792) | STATIC int nextActiveLink(LLrec *linkmap, int backitemnr)
function STATIC (line 804) | STATIC int prevActiveLink(LLrec *linkmap, int forwitemnr)
function STATIC (line 822) | STATIC int firstInactiveLink(LLrec *linkmap)
function STATIC (line 837) | STATIC int lastInactiveLink(LLrec *linkmap)
function STATIC (line 852) | STATIC int nextInactiveLink(LLrec *linkmap, int backitemnr)
function STATIC (line 863) | STATIC int prevInactiveLink(LLrec *linkmap, int forwitemnr)
function STATIC (line 870) | STATIC int removeLink(LLrec *linkmap, int itemnr)
function STATIC (line 908) | STATIC LLrec *cloneLink(LLrec *sourcemap, int newsize, MYBOOL freesource)
function STATIC (line 933) | STATIC int compareLink(LLrec *linkmap1, LLrec *linkmap2)
function STATIC (line 946) | STATIC MYBOOL verifyLink(LLrec *linkmap, int itemnr, MYBOOL doappend)
function STATIC (line 966) | STATIC PVrec *createPackedVector(int size, REAL *values, int *workvector)
function STATIC (line 1013) | STATIC MYBOOL unpackPackedVector(PVrec *PV, REAL **target)
function STATIC (line 1037) | STATIC REAL getvaluePackedVector(PVrec *PV, int index)
function STATIC (line 1047) | STATIC MYBOOL freePackedVector(PVrec **PV)
function STATIC (line 1058) | STATIC void pushPackedVector(PVrec *PV, PVrec *parent)
function STATIC (line 1063) | STATIC PVrec *popPackedVector(PVrec *PV)
FILE: utilities/lp_solve/lp_utils.h
type workarraysrec (line 19) | typedef struct _workarraysrec
type LLrec (line 28) | typedef struct _LLrec
type PVrec (line 37) | typedef struct _PVrec
FILE: utilities/lp_solve/lp_wlp.c
function write_data (line 26) | static int write_data(void *userhandle, write_modeldata_func write_model...
function STATIC (line 39) | STATIC void write_lpcomment(void *userhandle, write_modeldata_func write...
function STATIC (line 44) | STATIC int write_lprow(lprec *lp, int rowno, void *userhandle, write_mod...
function MYBOOL (line 85) | MYBOOL __WINAPI write_lpex(lprec *lp, void *userhandle, write_modeldata_...
function write_lpdata (line 324) | static int __WINAPI write_lpdata(void *userhandle, char *buf)
function MYBOOL (line 329) | MYBOOL LP_writefile(lprec *lp, const char *filename)
function MYBOOL (line 350) | MYBOOL LP_writehandle(lprec *lp, FILE *output)
FILE: utilities/lp_solve/shared/commonlib.c
function clearFPU (line 29) | unsigned int clearFPU()
function resetFPU (line 33) | unsigned int resetFPU(unsigned int mask)
function catchFPU (line 39) | unsigned int catchFPU(unsigned int mask)
function intpow (line 55) | int intpow(int base, int exponent)
function mod (line 68) | int mod(int n, int d)
function strtoup (line 74) | void strtoup(char *s)
function strtolo (line 82) | void strtolo(char *s)
function strcpyup (line 90) | void strcpyup(char *t, const char *s)
function strcpylo (line 101) | void strcpylo(char *t, const char *s)
function MYBOOL (line 114) | MYBOOL so_stdname(char *stdname, const char *descname, int buflen)
function gcd (line 138) | int gcd(LLONG a, LLONG b, int *c, int *d)
function findIndex (line 200) | int findIndex(int target, int *attributes, int count, int offset)
function findIndexEx (line 277) | int findIndexEx(void *target, void *attributes, int count, int offset, i...
function compareCHAR (line 354) | int CMP_CALLMODEL compareCHAR(const void *current, const void *candidate)
function compareINT (line 358) | int CMP_CALLMODEL compareINT(const void *current, const void *candidate)
function compareREAL (line 362) | int CMP_CALLMODEL compareREAL(const void *current, const void *candidate)
function hpsort (line 371) | void hpsort(void *attributes, int count, int offset, int recsize, MYBOOL...
function hpsortex (line 426) | void hpsortex(void *attributes, int count, int offset, int recsize, MYBO...
function qsortex_swap (line 504) | void qsortex_swap(void *attributes, int l, int r, int recsize,
function qsortex_sort (line 517) | int qsortex_sort(void *attributes, int l, int r, int recsize, int sortor...
function qsortex_finish (line 552) | int qsortex_finish(void *attributes, int lo0, int hi0, int recsize, int ...
function qsortex (line 583) | int qsortex(void *attributes, int count, int offset, int recsize, MYBOOL...
function QS_swap (line 623) | void QS_swap(UNIONTYPE QSORTrec a[], int i, int j)
function QS_addfirst (line 629) | int QS_addfirst(UNIONTYPE QSORTrec a[], void *mydata)
function QS_append (line 634) | int QS_append(UNIONTYPE QSORTrec a[], int ipos, void *mydata)
function QS_replace (line 642) | void QS_replace(UNIONTYPE QSORTrec a[], int ipos, void *mydata)
function QS_insert (line 646) | void QS_insert(UNIONTYPE QSORTrec a[], int ipos, void *mydata, int epos)
function QS_delete (line 652) | void QS_delete(UNIONTYPE QSORTrec a[], int ipos, int epos)
function QS_sort (line 657) | int QS_sort(UNIONTYPE QSORTrec a[], int l, int r, findCompare_func findC...
function QS_finish (line 690) | int QS_finish(UNIONTYPE QSORTrec a[], int lo0, int hi0, findCompare_func...
function MYBOOL (line 714) | MYBOOL QS_execute(UNIONTYPE QSORTrec a[], int count, findCompare_func fi...
function sortByREAL (line 738) | int sortByREAL(int *item, REAL *weight, int size, int offset, MYBOOL uni...
function sortByINT (line 763) | int sortByINT(int *item, int *weight, int size, int offset, MYBOOL unique)
function REAL (line 788) | REAL sortREALByINT(REAL *item, int *weight, int size, int offset, MYBOOL...
function timeNow (line 816) | double timeNow(void)
function blockWriteINT (line 858) | void blockWriteINT(FILE *output, const char *label, int *myvector, int f...
function blockWriteBOOL (line 877) | void blockWriteBOOL(FILE *output, const char *label, MYBOOL *myvector, i...
function blockWriteREAL (line 899) | void blockWriteREAL(FILE *output, const char *label, REAL *myvector, int...
function printvec (line 919) | void printvec( int n, REAL *x, int modulo )
function printmatUT (line 934) | void printmatUT( int size, int n, REAL *U, int modulo)
function printmatSQ (line 945) | void printmatSQ( int size, int n, REAL *X, int modulo)
function fileCount (line 962) | int fileCount( const char *filemask )
function MYBOOL (line 979) | MYBOOL fileSearchPath( const char *envvar, const char *searchfile, const...
FILE: utilities/lp_solve/shared/commonlib.h
type QSORTrec1 (line 221) | typedef struct _QSORTrec1
type QSORTrec2 (line 226) | typedef struct _QSORTrec2
type QSORTrec3 (line 231) | typedef struct _QSORTrec3
type QSORTrec4 (line 237) | typedef struct _QSORTrec4
type QSORTrec5 (line 243) | typedef struct _QSORTrec5
type QSORTrec6 (line 248) | typedef struct _QSORTrec6
type QSORTrec7 (line 253) | typedef struct _QSORTrec7
FILE: utilities/lp_solve/shared/mmio.c
function mm_read_unsymmetric_sparse (line 17) | int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int ...
function mm_is_valid (line 87) | int mm_is_valid(MM_typecode matcode)
function mm_read_banner (line 97) | int mm_read_banner(FILE *f, MM_typecode *matcode)
function mm_write_mtx_crd_size (line 183) | int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
function mm_read_mtx_crd_size (line 191) | int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz )
function mm_read_mtx_array_size (line 219) | int mm_read_mtx_array_size(FILE *f, int *M, int *N)
function mm_write_mtx_array_size (line 248) | int mm_write_mtx_array_size(FILE *f, int M, int N)
function mm_read_mtx_crd_data (line 264) | int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
function mm_read_mtx_crd_entry (line 301) | int mm_read_mtx_crd_entry(FILE *f, int *I, int *J,
function mm_read_mtx_crd (line 336) | int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J,
function mm_write_banner (line 389) | int mm_write_banner(FILE *f, MM_typecode matcode)
function mm_write_mtx_crd (line 402) | int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
FILE: utilities/lp_solve/shared/myblas.c
function init_BLAS (line 41) | void init_BLAS(void)
function MYBOOL (line 49) | MYBOOL is_nativeBLAS(void)
function MYBOOL (line 58) | MYBOOL load_BLAS(const char *libname)
function MYBOOL (line 160) | MYBOOL unload_BLAS(void)
function daxpy (line 169) | void daxpy( int n, REAL da, REAL *dx, int incx, REAL *dy, int incy)
function my_daxpy (line 175) | void BLAS_CALLMODEL my_daxpy( int *_n, REAL *_da, REAL *dx, int *_incx, ...
function dcopy (line 247) | void dcopy( int n, REAL *dx, int incx, REAL *dy, int incy)
function BLAS_CALLMODEL (line 254) | void BLAS_CALLMODEL my_dcopy (int *_n, REAL *dx, int *_incx, REAL *dy, i...
function dscal (line 335) | void dscal (int n, REAL da, REAL *dx, int incx)
function BLAS_CALLMODEL (line 341) | void BLAS_CALLMODEL my_dscal (int *_n, REAL *_da, REAL *dx, int *_incx)
function REAL (line 418) | REAL ddot(int n, REAL *dx, int incx, REAL *dy, int incy)
function REAL (line 425) | REAL BLAS_CALLMODEL my_ddot(int *_n, REAL *dx, int *_incx, REAL *dy, int...
function dswap (line 501) | void dswap( int n, REAL *dx, int incx, REAL *dy, int incy )
function my_dswap (line 508) | void BLAS_CALLMODEL my_dswap( int *_n, REAL *dx, int *_incx, REAL *dy, i...
function dload (line 601) | void dload(int n, REAL da, REAL *dx, int incx)
function BLAS_CALLMODEL (line 607) | void BLAS_CALLMODEL my_dload (int *_n, REAL *_da, REAL *dx, int *_incx)
function idamax (line 669) | int idamax( int n, REAL *x, int is )
function my_idamax (line 675) | int BLAS_CALLMODEL my_idamax( int *_n, REAL *x, int *_is )
function REAL (line 716) | REAL dnormi( int n, REAL *x )
function REAL (line 722) | REAL BLAS_CALLMODEL my_dnormi( int *_n, REAL *x )
function subvec (line 748) | int subvec( int item)
function submat (line 754) | int submat( int nrowb, int row, int col)
function posmat (line 759) | int posmat( int nrowb, int row, int col)
function randomseed (line 768) | void randomseed(int seeds[])
function randomdens (line 776) | void randomdens( int n, REAL *x, REAL r1, REAL r2, REAL densty, int *see...
function ddrand (line 803) | void ddrand( int n, REAL *x, int incx, int *seeds )
FILE: utilities/lp_solve/yacc_read.c
type structSOSvars (line 48) | struct structSOSvars {
type structSOS (line 55) | struct structSOS {
type SOSrow (line 64) | struct SOSrow {
type SOSrowdata (line 70) | struct SOSrowdata {
type rside (line 76) | struct rside /* contains relational operator and rhs value */
type column (line 88) | struct column
type structcoldata (line 96) | struct structcoldata {
function error (line 106) | static void error(parse_parm *pp, int verbose, const char *string)
function read_error (line 117) | void read_error(parse_parm *pp, void *scanner, const char * string)
function lex_fatal_error (line 124) | void lex_fatal_error(parse_parm *pp, void *scanner, const char * msg)
function add_row (line 130) | void add_row(parse_parm *pp)
function add_sos_row (line 137) | void add_sos_row(parse_parm *pp, short SOStype)
function check_int_sec_sos_free_decl (line 146) | void check_int_sec_sos_free_decl(parse_parm *pp, int within_int_decl, in...
function add_int_var (line 169) | static void add_int_var(parse_parm *pp, const char *name, short int_decl)
function add_sec_var (line 210) | static void add_sec_var(parse_parm *pp, const char *name)
function set_sec_threshold (line 230) | int set_sec_threshold(parse_parm *pp, const char *name, REAL threshold)
function add_free_var (line 255) | static void add_free_var(parse_parm *pp, const char *name)
function add_sos_name (line 291) | static int add_sos_name(parse_parm *pp, const char *name)
function add_sos_var (line 315) | static int add_sos_v
Condensed preview — 1343 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (7,516K chars).
[
{
"path": ".clang-format",
"chars": 9459,
"preview": "## This config file is only relevant for clang-format version 19.1.4\n##\n## Examples of each format style can be found on"
},
{
"path": ".gitattributes",
"chars": 1053,
"preview": ".git* export-ignore\n# Custom attribute to mark sources as using our C++/C code style.\n"
},
{
"path": ".github/workflows/build-test-cxx-cuda.yml",
"chars": 6166,
"preview": "name: 'Build, Test RTK with CUDA'\n\non: [push,pull_request]\n\nenv:\n itk-git-tag: \"v5.4.3\"\n itk-module-deps: \"CudaCommon@"
},
{
"path": ".github/workflows/build-test-package-python-cuda.yml",
"chars": 11441,
"preview": "name: 'Package RTK with CUDA'\n\non: [push,pull_request]\n\nenv:\n itk-wheel-tag: 'v5.4.3'\n itk-python-package-tag: 'releas"
},
{
"path": ".github/workflows/build-test-package.yml",
"chars": 1568,
"preview": "name: Build, test, package\n\non: [push,pull_request]\n\nconcurrency:\n group: '${{ github.workflow }}@${{ github.head_ref |"
},
{
"path": ".github/workflows/clang-format-linter.yml",
"chars": 247,
"preview": "name: clang-format linter\n\non: [push,pull_request]\n\njobs:\n lint:\n runs-on: ubuntu-latest\n\n steps:\n - uses: act"
},
{
"path": ".gitignore",
"chars": 501,
"preview": "# Do not add ExternalData module staging files\n.ExternalData*\n\n# back-up files\n*~\n*.bak\n# vim swp files\n*.swp\n## Ignore "
},
{
"path": ".readthedocs.yml",
"chars": 368,
"preview": "# .readthedocs.yml\n# Read the Docs configuration file\n# See https://docs.readthedocs.io/en/stable/config-file/v2.html fo"
},
{
"path": "CMakeLists.txt",
"chars": 12548,
"preview": "#=========================================================\n# RTK : Reconstruction Toolkit\n#============================="
},
{
"path": "COPYRIGHT.TXT",
"chars": 12267,
"preview": "RTK is copyrighted software.\n\n Copyright (c) 2010-2012 RTK consortium\n All rights reserved\n\n You can freely use and d"
},
{
"path": "CTestConfig.cmake",
"chars": 225,
"preview": "set(CTEST_PROJECT_NAME \"RTK\")\nset(CTEST_NIGHTLY_START_TIME \"1:00:00 UTC\")\n\nset(CTEST_DROP_METHOD \"https\")\nset(CTEST_DROP"
},
{
"path": "CodeContribution.md",
"chars": 1700,
"preview": "# Code contribution\n\n## Coding style\n\nRTK is based on ITK and aims at following its coding conventions. Any developer sh"
},
{
"path": "GettingStarted.md",
"chars": 817,
"preview": "Getting started\n===============\n\nHere are suggested steps for the RTK beginner.\n\n 1. Install the software following [IN"
},
{
"path": "HEADER.TXT",
"chars": 765,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "INSTALLATION.md",
"chars": 4278,
"preview": "RTK installation\n================\n\nConfiguration, compilation and installation with ITK\n--------------------------------"
},
{
"path": "ITKKWStyleFiles.txt.in",
"chars": 641,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n<Description>\n<LineLength>200</LineLength>\n<DeclarationOrder>0,1,2</Declarat"
},
{
"path": "LICENSE.TXT",
"chars": 11823,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "ORGANIZATION.TXT",
"chars": 2265,
"preview": "The software system known as the Reconstruction Toolkit, hereafter referred to as RTK, is an open-source platform for to"
},
{
"path": "README.md",
"chars": 1837,
"preview": "RTK: The Reconstruction ToolKit\n===============================\n\n[![GitHub release](https://img.shields.io/github/releas"
},
{
"path": "applications/CMakeLists.txt",
"chars": 5323,
"preview": "find_package(Gengetopt)\n\nconfigure_file (${CMAKE_CURRENT_SOURCE_DIR}/rtkVersion.ggo.in ${RTK_BINARY_DIR}/rtkVersion.ggo)"
},
{
"path": "applications/README.md",
"chars": 2380,
"preview": "# Command-line applications\n\nRTK provides command line applications which can be built from the C++ code by turning `ON`"
},
{
"path": "applications/rtk3Doutputimage_group.py",
"chars": 3155,
"preview": "import itk\nfrom itk import RTK as rtk\n\n__all__ = [\n \"add_rtk3Doutputimage_group\",\n \"SetConstantImageSourceFromArgP"
},
{
"path": "applications/rtk3Doutputimage_section.ggo",
"chars": 531,
"preview": "section \"Output 3D image properties\"\noption \"origin\" - \"Origin (default=centered)\" double multiple no\noption \"dimensi"
},
{
"path": "applications/rtk4Doutputimage_section.ggo",
"chars": 737,
"preview": "section \"Output 4D image properties\"\noption \"origin\" - \"Origin (default=centered)\" double multi"
},
{
"path": "applications/rtkVersion.ggo.in",
"chars": 89,
"preview": "version \"@RTK_VERSION_MAJOR@.@RTK_VERSION_MINOR@.@RTK_VERSION_PATCH@@RTK_VERSION_HASH@\"\n\n"
},
{
"path": "applications/rtkadmmtotalvariation/CMakeLists.txt",
"chars": 743,
"preview": "WRAP_GGO(rtkadmmtotalvariation_GGO_C rtkadmmtotalvariation.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_se"
},
{
"path": "applications/rtkadmmtotalvariation/README.md",
"chars": 359,
"preview": "# Total Variation Regularized Reconstruction\n\n{w"
},
{
"path": "applications/rtkadmmtotalvariation/TotalVariationRegularizedReconstruction.sh",
"chars": 548,
"preview": " # Create a simulated geometry\n rtksimulatedgeometry -n 180 -o geometry.xml\n # You may add \"--arc 200\" to make the scan "
},
{
"path": "applications/rtkadmmtotalvariation/rtkadmmtotalvariation.cxx",
"chars": 5425,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkadmmtotalvariation/rtkadmmtotalvariation.ggo",
"chars": 1669,
"preview": "purpose \"Performs an iterative 3D reconstruction with 3D TV regularization\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkadmmtotalvariation/rtkadmmtotalvariation.py",
"chars": 6055,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argum"
},
{
"path": "applications/rtkadmmwavelets/CMakeLists.txt",
"chars": 701,
"preview": "WRAP_GGO(rtkadmmwavelets_GGO_C rtkadmmwavelets.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo .."
},
{
"path": "applications/rtkadmmwavelets/DaubechiesWavelets.sh",
"chars": 548,
"preview": " # Create a simulated geometry\n rtksimulatedgeometry -n 180 -o geometry.xml\n # You may add \"--arc 200\" to make the scan "
},
{
"path": "applications/rtkadmmwavelets/README.md",
"chars": 354,
"preview": "# Daubechies Wavelets Regularized Reconstruction\n\n![sin](../../documentation/docs/ExternalData/SheppLogan-Sinogram-3D.pn"
},
{
"path": "applications/rtkadmmwavelets/rtkadmmwavelets.cxx",
"chars": 4805,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkadmmwavelets/rtkadmmwavelets.ggo",
"chars": 1335,
"preview": "purpose \"Performs an iterative 3D reconstruction with Daubechies wavelets regularization\"\n\noption \"verbose\" v \"Verbose"
},
{
"path": "applications/rtkamsterdamshroud/CMakeLists.txt",
"chars": 632,
"preview": "WRAP_GGO(rtkamsterdamshroud_GGO_C rtkamsterdamshroud.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion"
},
{
"path": "applications/rtkamsterdamshroud/README.md",
"chars": 607,
"preview": "# Amsterdam Shroud\n\n{w=400px alt=\"Moving phanto"
},
{
"path": "applications/rtkamsterdamshroud/rtkamsterdamshroud.cxx",
"chars": 2978,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkamsterdamshroud/rtkamsterdamshroud.ggo",
"chars": 618,
"preview": "purpose \"Creates an Amsterdam Shroud image from a sequence of projections [Zijp et al, ICCR, 2004].\"\n\noption \"verbose\" "
},
{
"path": "applications/rtkamsterdamshroud/rtkamsterdamshroud.py",
"chars": 2860,
"preview": "#!/usr/bin/env python\nimport sys\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser "
},
{
"path": "applications/rtkargumentparser.py",
"chars": 5589,
"preview": "import re\nimport argparse\nfrom itk import RTK as rtk\nimport difflib\nimport inspect\n\n__all__ = [\n \"RTKArgumentParser\"\n"
},
{
"path": "applications/rtkbackprojections/CMakeLists.txt",
"chars": 664,
"preview": "WRAP_GGO(rtkbackprojections_GGO_C rtkbackprojections.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section."
},
{
"path": "applications/rtkbackprojections/rtkbackprojections.cxx",
"chars": 6805,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkbackprojections/rtkbackprojections.ggo",
"chars": 1071,
"preview": "purpose \"Backprojects a volume according to a geometry file.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkbackprojections/rtkbackprojections.py",
"chars": 6845,
"preview": "#!/usr/bin/env python\nimport sys\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser "
},
{
"path": "applications/rtkbioscangeometry/CMakeLists.txt",
"chars": 597,
"preview": "WRAP_GGO(rtkbioscangeometry_GGO_C rtkbioscangeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkbioscangeom"
},
{
"path": "applications/rtkbioscangeometry/rtkbioscangeometry.cxx",
"chars": 1443,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkbioscangeometry/rtkbioscangeometry.ggo",
"chars": 669,
"preview": "purpose \"Creates an RTK geometry file from a sequence of x-ray projections of a Bioscan NanoSPECT/CT scanner.\"\n\noption \""
},
{
"path": "applications/rtkbioscangeometry/rtkbioscangeometry.py",
"chars": 1176,
"preview": "import argparse\nimport sys\nfrom itk import RTK as rtk\n\ndef build_parser():\n parser = rtk.RTKArgumentParser(\n d"
},
{
"path": "applications/rtkcheckimagequality/CMakeLists.txt",
"chars": 611,
"preview": "WRAP_GGO(rtkcheckimagequality_GGO_C rtkcheckimagequality.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkcheckim"
},
{
"path": "applications/rtkcheckimagequality/rtkcheckimagequality.cxx",
"chars": 3535,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkcheckimagequality/rtkcheckimagequality.ggo",
"chars": 325,
"preview": "purpose \"Checks the MSE of a reconstructed image against a reference.\"\n\noption \"verbose\" v \"Verbose execution\" flag of"
},
{
"path": "applications/rtkcheckimagequality/rtkcheckimagequality.py",
"chars": 2680,
"preview": "import argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\n\ndef build_parser():\n parser = rtk.RTKArgumentParser"
},
{
"path": "applications/rtkconjugategradient/CMakeLists.txt",
"chars": 736,
"preview": "WRAP_GGO(rtkconjugategradient_GGO_C rtkconjugategradient.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_sect"
},
{
"path": "applications/rtkconjugategradient/ConjugateGradient2D.sh",
"chars": 710,
"preview": "# Generate geometry for fan-beam setup\nrtksimulatedgeometry -n 720 -o geometry.xml --arc 360\n\n# Create projections of th"
},
{
"path": "applications/rtkconjugategradient/ConjugateGradient3D.sh",
"chars": 524,
"preview": " # Create a simulated geometry\n rtksimulatedgeometry -n 180 -o geometry.xml\n # You may add \"--arc 200\" to make the scan "
},
{
"path": "applications/rtkconjugategradient/NoisyConjugateGradient.sh",
"chars": 694,
"preview": "# Create a simulated geometry\nrtksimulatedgeometry -n 180 -o geometry.xml\n# You may add \"--arc 200\" to make the scan sho"
},
{
"path": "applications/rtkconjugategradient/README.md",
"chars": 1906,
"preview": "# Conjugate gradient\n\n`````{tab-set}\n\n````{tab-item} 3D\n\n## 3D\n\n![sin](../../documentation/docs/ExternalData/SheppLogan-"
},
{
"path": "applications/rtkconjugategradient/rtkconjugategradient.cxx",
"chars": 5599,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkconjugategradient/rtkconjugategradient.ggo",
"chars": 1815,
"preview": "purpose \"Reconstructs a 3D volume from a sequence of projections with a conjugate gradient technique\"\n\noption \"verbose\" "
},
{
"path": "applications/rtkconjugategradient/rtkconjugategradient.py",
"chars": 5985,
"preview": "#!/usr/bin/env python\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # argument parsing"
},
{
"path": "applications/rtkdigisensgeometry/CMakeLists.txt",
"chars": 604,
"preview": "WRAP_GGO(rtkdigisensgeometry_GGO_C rtkdigisensgeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkdigisensg"
},
{
"path": "applications/rtkdigisensgeometry/rtkdigisensgeometry.cxx",
"chars": 1329,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkdigisensgeometry/rtkdigisensgeometry.ggo",
"chars": 369,
"preview": "purpose \"Creates an RTK geometry file from a Digisens geometry calibration.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkdigisensgeometry/rtkdigisensgeometry.py",
"chars": 1186,
"preview": "import argparse\nfrom itk import RTK as rtk\n\ndef build_parser():\n parser = rtk.RTKArgumentParser(\n description="
},
{
"path": "applications/rtkdrawgeometricphantom/CMakeLists.txt",
"chars": 664,
"preview": "WRAP_GGO(rtkdrawgeometricphantom_GGO_C rtkdrawgeometricphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rtk"
},
{
"path": "applications/rtkdrawgeometricphantom/README.md",
"chars": 380,
"preview": "# Create gammex phantom\n\n{w=400px alt=\"Gammex\"}\n\nThis scr"
},
{
"path": "applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.cxx",
"chars": 3740,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.ggo",
"chars": 701,
"preview": "purpose \"Computes a 3D voxelized phantom from a phantom description file\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkdrawgeometricphantom/rtkdrawgeometricphantom.py",
"chars": 3613,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\nimport numpy as np\n\n\ndef build_pa"
},
{
"path": "applications/rtkdrawshepploganphantom/CMakeLists.txt",
"chars": 671,
"preview": "WRAP_GGO(rtkdrawshepploganphantom_GGO_C rtkdrawshepploganphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/r"
},
{
"path": "applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.cxx",
"chars": 2858,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.ggo",
"chars": 564,
"preview": "purpose \"Computes a 3D voxelized Shepp & Logan phantom with noise [https://www.slaney.org/pct/pct-errata.html]\"\n\noption "
},
{
"path": "applications/rtkdrawshepploganphantom/rtkdrawshepploganphantom.py",
"chars": 2945,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argum"
},
{
"path": "applications/rtkdualenergyforwardmodel/CMakeLists.txt",
"chars": 645,
"preview": "WRAP_GGO(rtkdualenergyforwardmodel_GGO_C rtkdualenergyforwardmodel.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable("
},
{
"path": "applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.cxx",
"chars": 5541,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.ggo",
"chars": 1126,
"preview": "purpose \"Computes expected photon counts from incident spectrum, material attenuations, detector response and material-d"
},
{
"path": "applications/rtkdualenergyforwardmodel/rtkdualenergyforwardmodel.py",
"chars": 6451,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser "
},
{
"path": "applications/rtkdualenergysimplexdecomposition/CMakeLists.txt",
"chars": 701,
"preview": "WRAP_GGO(rtkdualenergysimplexdecomposition_GGO_C rtkdualenergysimplexdecomposition.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)"
},
{
"path": "applications/rtkdualenergysimplexdecomposition/rtkdualenergysimplexdecomposition.cxx",
"chars": 5463,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkdualenergysimplexdecomposition/rtkdualenergysimplexdecomposition.ggo",
"chars": 1624,
"preview": "purpose \"Decomposes dual energy projections into materials\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkdualenergysimplexdecomposition/rtkdualenergysimplexdecomposition.py",
"chars": 7225,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser "
},
{
"path": "applications/rtkelektasynergygeometry/CMakeLists.txt",
"chars": 639,
"preview": "WRAP_GGO(rtkelektasynergygeometry_GGO_C rtkelektasynergygeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rt"
},
{
"path": "applications/rtkelektasynergygeometry/README.md",
"chars": 2745,
"preview": "# Elekta Reconstruction\n\nElekta provides easy access to raw data. The data and projection images are stored in a single "
},
{
"path": "applications/rtkelektasynergygeometry/rtkelektasynergygeometry.cxx",
"chars": 2390,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkelektasynergygeometry/rtkelektasynergygeometry.ggo",
"chars": 498,
"preview": "purpose \"Creates an RTK geometry file from an Elekta Synergy acquisition.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkelektasynergygeometry/rtkelektasynergygeometry.py",
"chars": 929,
"preview": "#!/usr/bin/env python\nimport argparse\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argument parsing\n parser"
},
{
"path": "applications/rtkextractphasesignal/CMakeLists.txt",
"chars": 618,
"preview": "WRAP_GGO(rtkextractphasesignal_GGO_C rtkextractphasesignal.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkextra"
},
{
"path": "applications/rtkextractphasesignal/rtkextractphasesignal.cxx",
"chars": 2095,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkextractphasesignal/rtkextractphasesignal.ggo",
"chars": 712,
"preview": "purpose \"Extracts the phase from a signal.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkextractphasesignal/rtkextractphasesignal.py",
"chars": 2668,
"preview": "#!/usr/bin/env python\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef write_signal_to_text_file(signal_image"
},
{
"path": "applications/rtkextractshroudsignal/CMakeLists.txt",
"chars": 625,
"preview": "WRAP_GGO(rtkextractshroudsignal_GGO_C rtkextractshroudsignal.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkext"
},
{
"path": "applications/rtkextractshroudsignal/rtkextractshroudsignal.cxx",
"chars": 3578,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkextractshroudsignal/rtkextractshroudsignal.ggo",
"chars": 1029,
"preview": "purpose \"Extracts the breathing signal from a shroud image.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkfdk/CMakeLists.txt",
"chars": 580,
"preview": "WRAP_GGO(rtkfdk_GGO_C rtkfdk.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rt"
},
{
"path": "applications/rtkfdk/FDK2D.sh",
"chars": 642,
"preview": "# Create a simulated geometry\nrtksimulatedgeometry -n 180 -o geometry.xml\n\n# Create projections of the phantom file\n# No"
},
{
"path": "applications/rtkfdk/FDK3D.sh",
"chars": 487,
"preview": "# Create a simulated geometry\nrtksimulatedgeometry -n 180 -o geometry.xml\n# You may add \"--arc 200\" to make the scan sho"
},
{
"path": "applications/rtkfdk/README.md",
"chars": 10100,
"preview": "# 3D, 2D and motion-compensated FDK\n\nThe following exampels illustrates the command line application `rtkfdk` by reconst"
},
{
"path": "applications/rtkfdk/rtkfdk.cxx",
"chars": 8153,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfdk/rtkfdk.ggo",
"chars": 1841,
"preview": "purpose \"Reconstructs a 3D volume from a sequence of projections [Feldkamp, David, Kress, 1984].\"\n\noption \"verbose\" v"
},
{
"path": "applications/rtkfdk/rtkfdk.py",
"chars": 7738,
"preview": "#!/usr/bin/env python\nimport argparse\nimport sys\nimport math\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():"
},
{
"path": "applications/rtkfieldofview/CMakeLists.txt",
"chars": 604,
"preview": "WRAP_GGO(rtkfieldofview_GGO_C rtkfieldofview.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nad"
},
{
"path": "applications/rtkfieldofview/rtkfieldofview.cxx",
"chars": 4859,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfieldofview/rtkfieldofview.ggo",
"chars": 937,
"preview": "purpose \"Computes the field of view of a reconstruction.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkfieldofview/rtkfieldofview.py",
"chars": 4555,
"preview": "#!/usr/bin/env python\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser = rtk.RTKAr"
},
{
"path": "applications/rtkforwardprojections/CMakeLists.txt",
"chars": 650,
"preview": "WRAP_GGO(rtkforwardprojections_GGO_C rtkforwardprojections.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DIR}/rtkVers"
},
{
"path": "applications/rtkforwardprojections/ForwardProjection.sh",
"chars": 376,
"preview": " # Create a simulated geometry\n rtksimulatedgeometry -n 180 -o geometry.xml\n\n # Forward project\n rtkforwardprojections -"
},
{
"path": "applications/rtkforwardprojections/README.md",
"chars": 974,
"preview": "# Forward Projection\n\n{w=400px alt=\"POPI sinogram\"}\n![img"
},
{
"path": "applications/rtkforwardprojections/rtkforwardprojections.cxx",
"chars": 8329,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkforwardprojections/rtkforwardprojections.ggo",
"chars": 1372,
"preview": "purpose \"Projects a volume according to a geometry file.\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkforwardprojections/rtkforwardprojections.py",
"chars": 8827,
"preview": "#!/usr/bin/env python\nimport sys\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser "
},
{
"path": "applications/rtkfourdconjugategradient/CMakeLists.txt",
"chars": 771,
"preview": "WRAP_GGO(rtkfourdconjugategradient_GGO_C rtkfourdconjugategradient.ggo ../rtkinputprojections_section.ggo ../rtk4Doutput"
},
{
"path": "applications/rtkfourdconjugategradient/rtkfourdconjugategradient.cxx",
"chars": 5968,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfourdconjugategradient/rtkfourdconjugategradient.ggo",
"chars": 931,
"preview": "purpose \"Reconstructs a 3D + time sequence of volumes from a projection stack and a respiratory/cardiac signal, with a c"
},
{
"path": "applications/rtkfourdfdk/CMakeLists.txt",
"chars": 615,
"preview": "WRAP_GGO(rtkfourdfdk_GGO_C rtkfourdfdk.ggo ../rtkinputprojections_section.ggo ../rtk4Doutputimage_section.ggo ${RTK_BINA"
},
{
"path": "applications/rtkfourdfdk/rtkfourdfdk.cxx",
"chars": 8194,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfourdfdk/rtkfourdfdk.ggo",
"chars": 1475,
"preview": "purpose \"Reconstructs a 4D volume from a sequence of projections using FDK with one projection per respiratory cycle in "
},
{
"path": "applications/rtkfourdrooster/CMakeLists.txt",
"chars": 701,
"preview": "WRAP_GGO(rtkfourdrooster_GGO_C rtkfourdrooster.ggo ../rtkinputprojections_section.ggo ../rtk4Doutputimage_section.ggo .."
},
{
"path": "applications/rtkfourdrooster/README.md",
"chars": 11395,
"preview": "# 4DROOSTER: Total variation-regularized 3D + time reconstruction\n\nRTK provides a tool to reconstruct a 3D + time image "
},
{
"path": "applications/rtkfourdrooster/rtkfourdrooster.cxx",
"chars": 9009,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfourdrooster/rtkfourdrooster.ggo",
"chars": 3111,
"preview": "purpose \"Reconstructs a 3D + time sequence of volumes from a projection stack and a respiratory/cardiac signal, applying"
},
{
"path": "applications/rtkfourdsart/CMakeLists.txt",
"chars": 680,
"preview": "WRAP_GGO(rtkfourdsart_GGO_C rtkfourdsart.ggo ../rtkinputprojections_section.ggo ../rtk4Doutputimage_section.ggo ../rtkpr"
},
{
"path": "applications/rtkfourdsart/rtkfourdsart.cxx",
"chars": 5238,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkfourdsart/rtkfourdsart.ggo",
"chars": 1235,
"preview": "purpose \"Reconstructs a 4D sequence of volumes from a sequence of projections with a 4D version of the Simulatenous Alge"
},
{
"path": "applications/rtkgaincorrection/CMakeLists.txt",
"chars": 624,
"preview": "WRAP_GGO(rtkgaincorrection_GGO_C rtkgaincorrection.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.g"
},
{
"path": "applications/rtkgaincorrection/rtkgaincorrection.cxx",
"chars": 6423,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkgaincorrection/rtkgaincorrection.ggo",
"chars": 806,
"preview": "purpose \"Polynomial gain correction projections\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtki0estimation/CMakeLists.txt",
"chars": 611,
"preview": "WRAP_GGO(rtki0estimation_GGO_C rtki0estimation.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\n"
},
{
"path": "applications/rtki0estimation/rtki0estimation.cxx",
"chars": 3731,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtki0estimation/rtki0estimation.ggo",
"chars": 704,
"preview": "purpose \"Reads projection images and estimates the I0 value for each of them\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkimagxgeometry/CMakeLists.txt",
"chars": 583,
"preview": "WRAP_GGO(rtkimagxgeometry_GGO_C rtkimagxgeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkimagxgeometry r"
},
{
"path": "applications/rtkimagxgeometry/rtkimagxgeometry.cxx",
"chars": 1675,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkimagxgeometry/rtkimagxgeometry.ggo",
"chars": 839,
"preview": "purpose \"Creates an RTK geometry file from an iMagX acquisition.\"\n\noption \"calibration\" c \"iMagX Calibration file\" "
},
{
"path": "applications/rtkinputprojections_group.py",
"chars": 7735,
"preview": "import itk\nfrom itk import RTK as rtk\nimport numpy as np\n\n__all__ = [\n \"add_rtkinputprojections_group\",\n \"GetProje"
},
{
"path": "applications/rtkinputprojections_section.ggo",
"chars": 2343,
"preview": "section \"Input projections and their pre-processing\"\noption \"path\" p \"Path containing projections\" "
},
{
"path": "applications/rtkiterations_group.py",
"chars": 2256,
"preview": "import itk\n\n__all__ = [\n \"add_rtkiterations_group\",\n \"SetIterationsReportFromArgParse\",\n]\n\n# Mimicks rtkiterations"
},
{
"path": "applications/rtkiterations_section.ggo",
"chars": 291,
"preview": "section \"Iteration reporting\"\noption \"output-every\" - \"Output intermediate reconstruction after some iterations\" "
},
{
"path": "applications/rtkiterativefdk/CMakeLists.txt",
"chars": 672,
"preview": "WRAP_GGO(rtkiterativefdk_GGO_C rtkiterativefdk.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo .."
},
{
"path": "applications/rtkiterativefdk/rtkiterativefdk.cxx",
"chars": 4768,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkiterativefdk/rtkiterativefdk.ggo",
"chars": 2450,
"preview": "purpose \"Reconstructs a 3D volume from a sequence of projections [Feldkamp, David, Kress, 1984].\"\n\noption \"verbose\" v"
},
{
"path": "applications/rtklagcorrection/CMakeLists.txt",
"chars": 617,
"preview": "WRAP_GGO(rtklagcorrection_GGO_C rtklagcorrection.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo"
},
{
"path": "applications/rtklagcorrection/rtklagcorrection.cxx",
"chars": 2957,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtklagcorrection/rtklagcorrection.ggo",
"chars": 424,
"preview": "purpose \"4th order LTI Lag correction\"\n\noption \"verbose\" v \"Verbose execution\" fla"
},
{
"path": "applications/rtkmaskcollimation/CMakeLists.txt",
"chars": 632,
"preview": "WRAP_GGO(rtkmaskcollimation_GGO_C rtkmaskcollimation.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion"
},
{
"path": "applications/rtkmaskcollimation/rtkmaskcollimation.cxx",
"chars": 2361,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkmaskcollimation/rtkmaskcollimation.ggo",
"chars": 343,
"preview": "purpose \"Masks out the collimator from the projections\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkmcrooster/CMakeLists.txt",
"chars": 651,
"preview": "WRAP_GGO(rtkmcrooster_GGO_C rtkmcrooster.ggo ../rtkinputprojections_section.ggo ../rtk4Doutputimage_section.ggo ../rtkpr"
},
{
"path": "applications/rtkmcrooster/rtkmcrooster.cxx",
"chars": 9194,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkmcrooster/rtkmcrooster.ggo",
"chars": 2772,
"preview": "purpose \"Reconstructs a 3D + time sequence of volumes from a projection stack and a respiratory/cardiac signal, applying"
},
{
"path": "applications/rtkmotioncompensatedfourdconjugategradient/CMakeLists.txt",
"chars": 861,
"preview": "WRAP_GGO(rtkmotioncompensatedfourdconjugategradient_GGO_C rtkmotioncompensatedfourdconjugategradient.ggo ../rtkinputproj"
},
{
"path": "applications/rtkmotioncompensatedfourdconjugategradient/rtkmotioncompensatedfourdconjugategradient.cxx",
"chars": 6299,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkmotioncompensatedfourdconjugategradient/rtkmotioncompensatedfourdconjugategradient.ggo",
"chars": 1138,
"preview": "purpose \"Performs a motion-compensated 4D reconstruction by the conjugate gradient method\"\n\noption \"verbose\" v \"Verb"
},
{
"path": "applications/rtkorageometry/CMakeLists.txt",
"chars": 569,
"preview": "WRAP_GGO(rtkorageometry_GGO_C rtkorageometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtkorageometry rtkorag"
},
{
"path": "applications/rtkorageometry/rtkorageometry.cxx",
"chars": 1746,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkorageometry/rtkorageometry.ggo",
"chars": 855,
"preview": "purpose \"Creates an RTK geometry file from a sequence of ora.xml files (radART / medPhoton file format).\"\n\noption \"verbo"
},
{
"path": "applications/rtkorageometry/rtkorageometry.py",
"chars": 1716,
"preview": "#!/usr/bin/env python\nimport argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argument parsing"
},
{
"path": "applications/rtkosem/CMakeLists.txt",
"chars": 645,
"preview": "WRAP_GGO(rtkosem_GGO_C rtkosem.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ../rtkprojectors_s"
},
{
"path": "applications/rtkosem/rtkosem.cxx",
"chars": 3606,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkosem/rtkosem.ggo",
"chars": 940,
"preview": "purpose \"Reconstructs a 3D volume from a sequence of projections with Ordered subset expectation maximization.\"\n\noption "
},
{
"path": "applications/rtkoverlayphaseandshroud/CMakeLists.txt",
"chars": 639,
"preview": "WRAP_GGO(rtkoverlayphaseandshroud_GGO_C rtkoverlayphaseandshroud.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rt"
},
{
"path": "applications/rtkoverlayphaseandshroud/rtkoverlayphaseandshroud.cxx",
"chars": 3412,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkoverlayphaseandshroud/rtkoverlayphaseandshroud.ggo",
"chars": 478,
"preview": "purpose \"Generates an RGB image showing the phase peaks on top of the shroud\"\n\noption \"verbose\" v \"Verbose executio"
},
{
"path": "applications/rtkprojectgeometricphantom/CMakeLists.txt",
"chars": 685,
"preview": "WRAP_GGO(rtkprojectgeometricphantom_GGO_C rtkprojectgeometricphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_DI"
},
{
"path": "applications/rtkprojectgeometricphantom/rtkprojectgeometricphantom.cxx",
"chars": 3913,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojectgeometricphantom/rtkprojectgeometricphantom.ggo",
"chars": 725,
"preview": "purpose \"Computes projections through a 3D phantom described by a file, according to a geometry\"\n\noption \"verbose\" "
},
{
"path": "applications/rtkprojectgeometricphantom/rtkprojectgeometricphantom.py",
"chars": 3547,
"preview": "import argparse\nimport sys\nimport itk\nfrom itk import RTK as rtk\nimport numpy as np\n\n\ndef build_parser():\n # Argument"
},
{
"path": "applications/rtkprojectionmatrix/CMakeLists.txt",
"chars": 671,
"preview": "WRAP_GGO(rtkprojectionmatrix_GGO_C rtkprojectionmatrix.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_sectio"
},
{
"path": "applications/rtkprojectionmatrix/rtkMatlabSparseMatrix.h",
"chars": 2689,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojectionmatrix/rtkMatlabSparseMatrix.hxx",
"chars": 20262,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx",
"chars": 7128,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojectionmatrix/rtkprojectionmatrix.ggo",
"chars": 379,
"preview": "purpose \"Saves the sparse system matrix of rtk::JosephForwardProjectionImageFilter in a file. Only works in 2D.\"\n\noption"
},
{
"path": "applications/rtkprojections/CMakeLists.txt",
"chars": 604,
"preview": "WRAP_GGO(rtkprojections_GGO_C rtkprojections.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nad"
},
{
"path": "applications/rtkprojections/rtkprojections.cxx",
"chars": 1742,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojections/rtkprojections.ggo",
"chars": 306,
"preview": "purpose \"Reads raw projection images, converts them to attenuation and stacks them into a single output image file\"\n\nopt"
},
{
"path": "applications/rtkprojections/rtkprojections.py",
"chars": 1330,
"preview": "import argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n parser = rtk.RTKArgumentParser(\n "
},
{
"path": "applications/rtkprojectors_group.py",
"chars": 4904,
"preview": "__all__ = [\n \"add_rtkprojectors_group\",\n \"SetForwardProjectionFromArgParse\",\n \"SetBackProjectionFromArgParse\",\n"
},
{
"path": "applications/rtkprojectors_section.ggo",
"chars": 1001,
"preview": "section \"Projectors\"\noption \"fp\" f \"Forward projection method\" values=\"Joseph\",\"CudaRayCast\",\"JosephAttenuated\",\"Zeng"
},
{
"path": "applications/rtkprojectshepploganphantom/CMakeLists.txt",
"chars": 692,
"preview": "WRAP_GGO(rtkprojectshepploganphantom_GGO_C rtkprojectshepploganphantom.ggo ../rtk3Doutputimage_section.ggo ${RTK_BINARY_"
},
{
"path": "applications/rtkprojectshepploganphantom/rtkprojectshepploganphantom.cxx",
"chars": 3435,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkprojectshepploganphantom/rtkprojectshepploganphantom.ggo",
"chars": 607,
"preview": "purpose \"Computes projections through a 3D Shepp & Logan phantom, according to a geometry\"\n\noption \"verbose\" v \"Ver"
},
{
"path": "applications/rtkprojectshepploganphantom/rtkprojectshepploganphantom.py",
"chars": 3059,
"preview": "import argparse\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argument parsing\n parser = rtk.RTKA"
},
{
"path": "applications/rtkregularizedconjugategradient/CMakeLists.txt",
"chars": 813,
"preview": "WRAP_GGO(rtkregularizedconjugategradient_GGO_C rtkregularizedconjugategradient.ggo ../rtkinputprojections_section.ggo .."
},
{
"path": "applications/rtkregularizedconjugategradient/rtkregularizedconjugategradient.cxx",
"chars": 6562,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkregularizedconjugategradient/rtkregularizedconjugategradient.ggo",
"chars": 2600,
"preview": "purpose \"Alternates between conjugate gradient reconstruction and regularization\"\n\noption \"verbose\" v \"Verbose ex"
},
{
"path": "applications/rtksart/CMakeLists.txt",
"chars": 645,
"preview": "WRAP_GGO(rtksart_GGO_C rtksart.ggo ../rtkinputprojections_section.ggo ../rtk3Doutputimage_section.ggo ../rtkprojectors_s"
},
{
"path": "applications/rtksart/rtksart.cxx",
"chars": 4605,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtksart/rtksart.ggo",
"chars": 1991,
"preview": "purpose \"Reconstructs a 3D volume from a sequence of projections with Simulatenous Algebraic Reconstruction Technique [A"
},
{
"path": "applications/rtkscatterglarecorrection/CMakeLists.txt",
"chars": 681,
"preview": "WRAP_GGO(rtkscatterglarecorrection_GGO_C rtkscatterglarecorrection.ggo ../rtkinputprojections_section.ggo ${RTK_BINARY_D"
},
{
"path": "applications/rtkscatterglarecorrection/rtkscatterglarecorrection.cxx",
"chars": 5904,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtkscatterglarecorrection/rtkscatterglarecorrection.ggo",
"chars": 608,
"preview": "purpose \"Reads projection images and correct them for scatter glare\"\n\noption \"verbose\" v \"Verbose execution\" "
},
{
"path": "applications/rtkshowgeometry/README.md",
"chars": 922,
"preview": "# Geometry viewer\n\n`rtkshowgeometry` is a Python-only command line tool which provides an **interactive three-dimensiona"
},
{
"path": "applications/rtkshowgeometry/rtkshowgeometry.py",
"chars": 18428,
"preview": "#!/usr/bin/env python\nimport argparse\nimport numpy as np\nimport itk\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n "
},
{
"path": "applications/rtkshowgeometry/showgeometry.sh",
"chars": 414,
"preview": "# Create a simulated geometry\nrtksimulatedgeometry -n 180 -o geometry.xml\n\n# Create projections of the phantom file\nrtkp"
},
{
"path": "applications/rtksimulatedgeometry/CMakeLists.txt",
"chars": 611,
"preview": "WRAP_GGO(rtksimulatedgeometry_GGO_C rtksimulatedgeometry.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_executable(rtksimulat"
},
{
"path": "applications/rtksimulatedgeometry/rtksimulatedgeometry.cxx",
"chars": 1955,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
},
{
"path": "applications/rtksimulatedgeometry/rtksimulatedgeometry.ggo",
"chars": 1781,
"preview": "purpose \"Creates an RTK geometry file from simulated/regular trajectory. See https://docs.openrtk.org/en/latest/document"
},
{
"path": "applications/rtksimulatedgeometry/rtksimulatedgeometry.py",
"chars": 2998,
"preview": "#!/usr/bin/env python\nimport argparse\nfrom itk import RTK as rtk\n\n\ndef build_parser():\n # Argument parsing\n parser"
},
{
"path": "applications/rtkspectraldenoiseprojections/CMakeLists.txt",
"chars": 674,
"preview": "WRAP_GGO(rtkspectraldenoiseprojections_GGO_C rtkspectraldenoiseprojections.ggo ${RTK_BINARY_DIR}/rtkVersion.ggo)\nadd_exe"
},
{
"path": "applications/rtkspectraldenoiseprojections/rtkspectraldenoiseprojections.cxx",
"chars": 1910,
"preview": "/*=========================================================================\n *\n * Copyright RTK Consortium\n *\n * Licen"
}
]
// ... and 1143 more files (download for full content)
About this extraction
This page contains the full source code of the SimonRit/RTK GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1343 files (6.8 MB), approximately 1.9M tokens, and a symbol index with 2359 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.