├── .github ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── ISSUE_TEMPLATE │ ├── bug_report.md │ └── feature_request.md └── workflows │ ├── CI-mac-arm64.yml │ ├── CI-mac-x86_64.yml │ ├── CI-ubuntu.yml │ ├── CI-windows.yml │ ├── FP-mac-arm64.yml │ ├── FP-mac.yml │ ├── FP-ubuntu.yml │ └── FP-windows.yml ├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── cmake ├── Depdendencies.cmake ├── Documentation.cmake ├── ExternalClarius.cmake ├── ExternalEigen.cmake ├── ExternalFreenect2.cmake ├── ExternalLibJPEG.cmake ├── ExternalMCSS.cmake ├── ExternalOpenSlide.cmake ├── ExternalZip.cmake ├── ExternalZlib.cmake ├── Externals.cmake ├── FASTConfig.cmake.in ├── FASTCustomCommands.cmake ├── FASTUse.cmake.in ├── FetchSwig.cmake ├── FindOpenCL.cmake ├── FindOpenSlide.cmake ├── FindTensorRT.cmake ├── FixRPaths.cmake ├── ImageCompressionDependencies.cmake ├── InstallFAST.cmake ├── InstallFiles │ ├── MSVC_redis_files_license.txt │ ├── README_default.md │ └── Semaphore_LICENSE.txt ├── Macros.cmake ├── ModuleClarius.cmake ├── ModuleDicom.cmake ├── ModuleHDF5.cmake ├── ModuleITK.cmake ├── ModuleKinect.cmake ├── ModuleONNXRuntime.cmake ├── ModuleOpenIGTLink.cmake ├── ModuleOpenVINO.cmake ├── ModulePlotting.cmake ├── ModulePython.cmake ├── ModuleRealSense.cmake ├── ModuleTensorFlow.cmake ├── ModuleTensorRT.cmake ├── ModuleVTK.cmake ├── ModuleWholeSlideImaging.cmake ├── OpenMP.cmake ├── Package.cmake ├── PackageConfig.txt ├── PythonWheel.cmake ├── Qt5 │ ├── Qt5Config.cmake │ ├── Qt5ConfigVersion.cmake │ └── Qt5ModuleLocation.cmake ├── Qt5Core │ ├── Qt5CTestMacros.cmake │ ├── Qt5CoreConfig.cmake │ ├── Qt5CoreConfigExtras.cmake │ ├── Qt5CoreConfigExtrasMkspecDir.cmake │ ├── Qt5CoreConfigVersion.cmake │ └── Qt5CoreMacros.cmake ├── Qt5Gui │ ├── Qt5GuiConfig.cmake │ ├── Qt5GuiConfigExtras.cmake │ └── Qt5GuiConfigVersion.cmake ├── Qt5Multimedia │ ├── Qt5MultimediaConfig.cmake │ ├── Qt5MultimediaConfigVersion.cmake │ ├── Qt5Multimedia_AudioCaptureServicePlugin.cmake │ └── Qt5Multimedia_QM3uPlaylistPlugin.cmake ├── Qt5MultimediaWidgets │ ├── Qt5MultimediaWidgetsConfig.cmake │ └── Qt5MultimediaWidgetsConfigVersion.cmake ├── Qt5Network │ ├── Qt5NetworkConfig.cmake │ ├── Qt5NetworkConfigVersion.cmake │ ├── Qt5Network_QConnmanEnginePlugin.cmake │ ├── Qt5Network_QGenericEnginePlugin.cmake │ └── Qt5Network_QNetworkManagerEnginePlugin.cmake ├── Qt5OpenGL │ ├── Qt5OpenGLConfig.cmake │ └── Qt5OpenGLConfigVersion.cmake ├── Qt5PrintSupport │ ├── Qt5PrintSupportConfig.cmake │ ├── Qt5PrintSupportConfigVersion.cmake │ └── Qt5PrintSupport_QWindowsPrinterSupportPlugin.cmake ├── Qt5SerialPort │ ├── Qt5SerialPortConfig.cmake │ └── Qt5SerialPortConfigVersion.cmake └── Qt5Widgets │ ├── Qt5WidgetsConfig.cmake │ ├── Qt5WidgetsConfigExtras.cmake │ ├── Qt5WidgetsConfigVersion.cmake │ └── Qt5WidgetsMacros.cmake ├── doc ├── Doxyfile.in ├── bright-plotting-style.ini ├── conf.py ├── dark-plotting-style.ini ├── fast.css ├── fonts │ ├── UFL.txt │ ├── Ubuntu-Bold.ttf │ ├── Ubuntu-BoldItalic.ttf │ ├── Ubuntu-Italic.ttf │ ├── Ubuntu-Light.ttf │ ├── Ubuntu-LightItalic.ttf │ ├── Ubuntu-Medium.ttf │ ├── Ubuntu-MediumItalic.ttf │ ├── Ubuntu-Regular.ttf │ ├── UbuntuMono-Bold.ttf │ ├── UbuntuMono-BoldItalic.ttf │ ├── UbuntuMono-Italic.ttf │ └── UbuntuMono-Regular.ttf ├── images │ ├── FAST_logo_square.png │ ├── examples │ │ └── python │ │ │ ├── block_matching_tracking.jpg │ │ │ ├── clarius_streaming.jpg │ │ │ ├── display_uff_data.jpg │ │ │ ├── extract_surface_and_render.jpg │ │ │ ├── left_ventricle.jpg │ │ │ ├── neural_network_segmentation.jpg │ │ │ ├── non_local_means.jpg │ │ │ ├── pyfast_and_pyside.jpg │ │ │ ├── pyfast_and_pyside_custom_window.jpg │ │ │ ├── pyside_surface_extraction.jpg │ │ │ ├── python_process_object.jpg │ │ │ ├── python_random_access_streamer.jpg │ │ │ ├── real_time_line_plotter.jpg │ │ │ ├── rotating_3D.gif │ │ │ ├── scan_convert_iq_data.jpg │ │ │ ├── slicer_window_CT.jpg │ │ │ ├── slicer_window_MRI.jpg │ │ │ ├── stream_uff_data_and_filter.jpg │ │ │ ├── vbeam_example.jpg │ │ │ ├── video_frames.jpg │ │ │ ├── webcamera.jpg │ │ │ ├── wsi.jpg │ │ │ └── wsi_patches.jpg │ ├── fast_icon.ico │ ├── fast_icon.png │ ├── fast_logo_wide.png │ └── tutorials │ │ ├── left_ventricle_nlm_dual_view.jpg │ │ ├── left_ventricle_non_local_means.jpg │ │ ├── mri_ct │ │ ├── LICENSE.txt │ │ ├── alpha_blending_volume_renderer_CT.jpg │ │ ├── alpha_blending_volume_renderer_CT_custom.jpg │ │ ├── brain-segmentation.jpg │ │ ├── gui_example.jpg │ │ ├── gui_example2.jpg │ │ ├── maximum_intensity_projection.jpg │ │ ├── mri_slice.jpg │ │ ├── skull_strip.jpg │ │ ├── slicer_window_CT.jpg │ │ ├── slicer_window_segmentation.jpg │ │ ├── surface_extraction_CT.jpg │ │ └── threshold_volume_renderer.jpg │ │ ├── ultrasound │ │ ├── colormap.jpg │ │ ├── export_visualization_to_video_vlc.jpg │ │ ├── neural_network_segmentation.jpg │ │ ├── nlm_denoising.jpg │ │ ├── playback_widget.jpg │ │ ├── python_process_object.jpg │ │ ├── read_3d_ultrasound_slicer_window.jpg │ │ ├── read_3d_ultrasound_volume_rendering.jpg │ │ ├── read_uff_data.jpg │ │ ├── read_uff_data_beamspace.jpg │ │ ├── read_video.jpg │ │ ├── scan_convert.jpg │ │ ├── simple_gui.jpg │ │ ├── simple_gui2.jpg │ │ └── ultrasound_image_cropper.jpg │ │ └── wsi │ │ ├── get_level_as_image.jpg │ │ ├── get_patch_as_image.jpg │ │ ├── image_pyramid_patch_exporter.jpg │ │ ├── nuclei_segmentation.jpg │ │ ├── nuclei_segmentation_export_import.jpg │ │ ├── nuclei_segmentation_full.jpg │ │ ├── open_wsi.jpg │ │ ├── tissue_patches.jpg │ │ ├── tissue_segmentation.jpg │ │ └── tma_extractor.jpg ├── mainpage.dox └── pages │ ├── Building-FAST.md │ ├── CXX-examples.md │ ├── CXX-tutorial-intro.dox │ ├── CXX-tutorial-neural-networks.dox │ ├── CXX-tutorial-wsi.dox │ ├── CXX-tutorials.md │ ├── Clarius-module.md │ ├── Concepts.md │ ├── Download-stats.md │ ├── FAST-Text-Pipelines.md │ ├── Framework-Design.md │ ├── Get-started.md │ ├── HDF5-module.md │ ├── Install-FAST-for-Python.md │ ├── Install-FAST-on-Linux.md │ ├── Install-FAST-on-Mac.md │ ├── Install-FAST-on-Windows.md │ ├── Install-FAST.md │ ├── Kinect-module.md │ ├── Learn-FAST.md │ ├── Linux-instructions.md │ ├── Mac-OS-X-instructions.md │ ├── Modules.md │ ├── Movie-streamer.md │ ├── OpenVINO-module.md │ ├── Pipeline-data-streaming.md │ ├── Plotting-module.md │ ├── Projects-using-FAST.md │ ├── Python-examples.md │ ├── Python-module.md │ ├── Python-tutorial-intro.dox │ ├── Python-tutorial-mri-ct.dox │ ├── Python-tutorial-neural-networks.dox │ ├── Python-tutorial-ultrasound.dox │ ├── Python-tutorial-wsi.dox │ ├── Python-tutorials.md │ ├── RealSense-module.md │ ├── Requirements.md │ ├── Running-FAST-on-a-remote-server.md │ ├── Running-the-tests.md │ ├── TensorFlow-module.md │ ├── TensorRT-module.md │ ├── VTK-module.md │ ├── Visualization-module.md │ └── Windows-instructions.md ├── pipelines ├── block_matching.fpl ├── camera_streaming.fpl ├── image_renderer.fpl ├── movie_streaming.fpl ├── neural_network_segmentation.fpl ├── openigtlink_image.fpl ├── stream_uff_data_and_enhance.fpl ├── temporal_image_averaging.fpl ├── uff_viewer │ ├── colormap_and_reject.fpl │ ├── default.fpl │ └── non_local_means.fpl ├── wsi_high_res_segmentation.fpl ├── wsi_patch_bounding_box_detection.fpl ├── wsi_patch_classification.fpl ├── wsi_patch_segmentation.fpl └── wsi_view.fpl └── source ├── FAST ├── Algorithms │ ├── AddTransformation │ │ ├── AddTransformation.cpp │ │ ├── AddTransformation.hpp │ │ ├── CMakeLists.txt │ │ ├── SetTransformation.cpp │ │ └── SetTransformation.hpp │ ├── AirwaySegmentation │ │ ├── AirwaySegmentation.cl │ │ ├── AirwaySegmentation.cpp │ │ ├── AirwaySegmentation.hpp │ │ ├── CMakeLists.txt │ │ └── airwaySegmentationTests.cpp │ ├── ApplyColormap │ │ ├── ApplyColormap.cl │ │ ├── ApplyColormap.cpp │ │ ├── ApplyColormap.hpp │ │ ├── CMakeLists.txt │ │ └── Tests.cpp │ ├── BinaryThresholding │ │ ├── BinaryThresholding.cpp │ │ ├── BinaryThresholding.hpp │ │ ├── BinaryThresholding2D.cl │ │ ├── BinaryThresholding3D.cl │ │ └── CMakeLists.txt │ ├── BlockMatching │ │ ├── BlockMatching.cl │ │ ├── BlockMatching.cpp │ │ ├── BlockMatching.hpp │ │ ├── CMakeLists.txt │ │ └── Tests.cpp │ ├── CMakeLists.txt │ ├── CenterlineExtraction │ │ ├── CMakeLists.txt │ │ ├── CenterlineExtraction.cl │ │ ├── CenterlineExtraction.cpp │ │ ├── CenterlineExtraction.hpp │ │ └── Tests.cpp │ ├── CoherentPointDrift │ │ ├── Affine.cpp │ │ ├── Affine.hpp │ │ ├── CMakeLists.txt │ │ ├── CoherentPointDrift.cl │ │ ├── CoherentPointDrift.cpp │ │ ├── CoherentPointDrift.hpp │ │ ├── Rigid.cpp │ │ ├── Rigid.hpp │ │ └── Tests.cpp │ ├── Color │ │ ├── CMakeLists.txt │ │ ├── ColorToGrayscale.cl │ │ ├── ColorToGrayscale.cpp │ │ ├── ColorToGrayscale.hpp │ │ ├── ColorToGrayscaleTests.cpp │ │ ├── GrayscaleToColor.cl │ │ ├── GrayscaleToColor.cpp │ │ ├── GrayscaleToColor.hpp │ │ └── GrayscaleToColorTests.cpp │ ├── Compression │ │ ├── CMakeLists.txt │ │ ├── JPEGCompression.cpp │ │ ├── JPEGCompression.hpp │ │ ├── JPEGXLCompression.cpp │ │ └── JPEGXLCompression.hpp │ ├── GaussianSmoothing │ │ ├── CMakeLists.txt │ │ ├── GaussianSmoothing.cpp │ │ ├── GaussianSmoothing.hpp │ │ ├── GaussianSmoothing2D.cl │ │ ├── GaussianSmoothing3D.cl │ │ └── GaussianSmoothingTests.cpp │ ├── GradientVectorFlow │ │ ├── CMakeLists.txt │ │ ├── EulerGradientVectorFlow.cl │ │ ├── EulerGradientVectorFlow.cpp │ │ ├── EulerGradientVectorFlow.hpp │ │ ├── GradientVectorFlowTests.cpp │ │ ├── MultigridGradientVectorFlow.cl │ │ ├── MultigridGradientVectorFlow.cpp │ │ └── MultigridGradientVectorFlow.hpp │ ├── HounsefieldConverter │ │ ├── CMakeLists.txt │ │ ├── HounsefieldConverter.cl │ │ ├── HounsefieldConverter.cpp │ │ └── HounsefieldConverter.hpp │ ├── ImageAdd │ │ ├── CMakeLists.txt │ │ ├── ImageAdd.cl │ │ ├── ImageAdd.cpp │ │ └── ImageAdd.hpp │ ├── ImageCaster │ │ ├── CMakeLists.txt │ │ ├── ImageCaster.cl │ │ ├── ImageCaster.cpp │ │ └── ImageCaster.hpp │ ├── ImageChannelConverter │ │ ├── CMakeLists.txt │ │ ├── ImageChannelConverter.cl │ │ ├── ImageChannelConverter.cpp │ │ └── ImageChannelConverter.hpp │ ├── ImageCropper │ │ ├── CMakeLists.txt │ │ ├── ImageCropper.cpp │ │ ├── ImageCropper.hpp │ │ └── Tests.cpp │ ├── ImageFlipper │ │ ├── CMakeLists.txt │ │ ├── ImageFlipper.cpp │ │ ├── ImageFlipper.hpp │ │ ├── ImageFlipper2D.cl │ │ ├── ImageFlipper3D.cl │ │ └── Tests.cpp │ ├── ImageGradient │ │ ├── CMakeLists.txt │ │ ├── ImageGradient.cl │ │ ├── ImageGradient.cpp │ │ ├── ImageGradient.hpp │ │ └── ImageGradientTests.cpp │ ├── ImageInverter │ │ ├── CMakeLists.txt │ │ ├── ImageInverter.cl │ │ ├── ImageInverter.cpp │ │ └── ImageInverter.hpp │ ├── ImageMultiply │ │ ├── CMakeLists.txt │ │ ├── ImageMultiply.cl │ │ ├── ImageMultiply.cpp │ │ └── ImageMultiply.hpp │ ├── ImagePatch │ │ ├── CMakeLists.txt │ │ ├── ImageToBatchGenerator.cpp │ │ ├── ImageToBatchGenerator.hpp │ │ ├── PatchGenerator.cpp │ │ ├── PatchGenerator.hpp │ │ ├── PatchStitcher.cpp │ │ ├── PatchStitcher.hpp │ │ ├── PatchStitcher2D.cl │ │ ├── PatchStitcher3D.cl │ │ └── Tests.cpp │ ├── ImagePyramidLevelExtractor │ │ ├── CMakeLists.txt │ │ ├── ImagePyramidLevelExtractor.cpp │ │ ├── ImagePyramidLevelExtractor.hpp │ │ └── Tests.cpp │ ├── ImageResampler │ │ ├── CMakeLists.txt │ │ ├── ImageResampler.cpp │ │ ├── ImageResampler.hpp │ │ ├── ImageResampler2D.cl │ │ ├── ImageResampler3D.cl │ │ ├── ImageResamplerTests.cpp │ │ ├── IsotropicResampler.cpp │ │ ├── IsotropicResampler.hpp │ │ └── IsotropicResamplerTests.cpp │ ├── ImageResizer │ │ ├── CMakeLists.txt │ │ ├── ImageResizer.cl │ │ ├── ImageResizer.cpp │ │ ├── ImageResizer.hpp │ │ └── Tests.cpp │ ├── ImageSharpening │ │ ├── CMakeLists.txt │ │ ├── ImageSharpening.cl │ │ ├── ImageSharpening.cpp │ │ ├── ImageSharpening.hpp │ │ └── Tests.cpp │ ├── ImageSlicer │ │ ├── CMakeLists.txt │ │ ├── ImageSlicer.cl │ │ ├── ImageSlicer.cpp │ │ ├── ImageSlicer.hpp │ │ └── ImageSlicerTests.cpp │ ├── ImageTransposer │ │ ├── CMakeLists.txt │ │ ├── ImageTransposer.cpp │ │ ├── ImageTransposer.hpp │ │ ├── ImageTransposer2D.cl │ │ ├── ImageTransposer3D.cl │ │ └── Tests.cpp │ ├── IntensityClipping │ │ ├── CMakeLists.txt │ │ ├── IntensityClipping.cpp │ │ ├── IntensityClipping.hpp │ │ ├── IntensityClipping2D.cl │ │ └── IntensityClipping3D.cl │ ├── IntensityNormalization │ │ ├── CMakeLists.txt │ │ ├── IntensityNormalization.cl │ │ ├── IntensityNormalization.cpp │ │ ├── IntensityNormalization.hpp │ │ ├── IntensityNormalizationTests.cpp │ │ ├── ZeroMeanUnitVariance.cl │ │ ├── ZeroMeanUnitVariance.cpp │ │ └── ZeroMeanUnitVariance.hpp │ ├── Interleave │ │ ├── CMakeLists.txt │ │ ├── Interleave.cpp │ │ ├── Interleave.hpp │ │ └── Tests.cpp │ ├── IterativeClosestPoint │ │ ├── CMakeLists.txt │ │ ├── IterativeClosestPoint.cpp │ │ ├── IterativeClosestPoint.hpp │ │ └── IterativeClosestPointTests.cpp │ ├── KalmanFilterModelSegmentation │ │ ├── AppearanceModel.hpp │ │ ├── AppearanceModels │ │ │ ├── CMakeLists.txt │ │ │ ├── RidgeEdge │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── RidgeEdgeModel.cl │ │ │ │ ├── RidgeEdgeModel.cpp │ │ │ │ └── RidgeEdgeModel.hpp │ │ │ └── StepEdge │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── StepEdgeModel.cpp │ │ │ │ └── StepEdgeModel.hpp │ │ ├── CMakeLists.txt │ │ ├── KalmanFilterModelSegmentation.cpp │ │ ├── KalmanFilterModelSegmentation.hpp │ │ ├── Shape.cpp │ │ ├── Shape.hpp │ │ ├── ShapeModel.hpp │ │ ├── ShapeModels │ │ │ ├── CMakeLists.txt │ │ │ ├── CardinalSpline │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CardinalSplineModel.cpp │ │ │ │ └── CardinalSplineModel.hpp │ │ │ ├── Ellipse │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── EllipseModel.cpp │ │ │ │ └── EllipseModel.hpp │ │ │ └── MeanValueCoordinates │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── MeanValueCoordinatesModel.cpp │ │ │ │ └── MeanValueCoordinatesModel.hpp │ │ ├── Tests.cpp │ │ ├── exportLVmeshes.cpp │ │ └── exportLVmeshes3D.cpp │ ├── LabelModifier │ │ ├── CMakeLists.txt │ │ ├── LabelModifier.cl │ │ ├── LabelModifier.cpp │ │ └── LabelModifier.hpp │ ├── Lambda │ │ ├── CMakeLists.txt │ │ ├── RunLambda.cpp │ │ ├── RunLambda.hpp │ │ └── Tests.cpp │ ├── LaplacianOfGaussian │ │ ├── CMakeLists.txt │ │ ├── LaplacianOfGaussian.cpp │ │ ├── LaplacianOfGaussian.hpp │ │ ├── LaplacianOfGaussian2D.cl │ │ └── LaplacianOfGaussianTests.cpp │ ├── LevelSet │ │ ├── CMakeLists.txt │ │ ├── LevelSetSegmentation.cl │ │ ├── LevelSetSegmentation.cpp │ │ ├── LevelSetSegmentation.hpp │ │ └── LevelSetTests.cpp │ ├── LungSegmentation │ │ ├── CMakeLists.txt │ │ ├── LungSegmentation.cl │ │ ├── LungSegmentation.cpp │ │ └── LungSegmentation.hpp │ ├── MeshToSegmentation │ │ ├── CMakeLists.txt │ │ ├── MeshToSegmentation.cl │ │ ├── MeshToSegmentation.cpp │ │ ├── MeshToSegmentation.hpp │ │ └── Tests.cpp │ ├── Morphology │ │ ├── CMakeLists.txt │ │ ├── Dilation.cl │ │ ├── Dilation.cpp │ │ ├── Dilation.hpp │ │ ├── Erosion.cl │ │ ├── Erosion.cpp │ │ └── Erosion.hpp │ ├── NeuralNetwork │ │ ├── BoundingBoxNetwork.cpp │ │ ├── BoundingBoxNetwork.hpp │ │ ├── CMakeLists.txt │ │ ├── FlowNetwork.cpp │ │ ├── FlowNetwork.hpp │ │ ├── ImageClassificationNetwork.cpp │ │ ├── ImageClassificationNetwork.hpp │ │ ├── ImageToImageNetwork.cpp │ │ ├── ImageToImageNetwork.hpp │ │ ├── InferenceEngine.cpp │ │ ├── InferenceEngine.hpp │ │ ├── InferenceEngineManager.cpp │ │ ├── InferenceEngineManager.hpp │ │ ├── InferenceEngines │ │ │ ├── CMakeLists.txt │ │ │ ├── ONNXRuntimeEngine.cpp │ │ │ ├── ONNXRuntimeEngine.hpp │ │ │ ├── OpenVINOEngine.cpp │ │ │ ├── OpenVINOEngine.hpp │ │ │ ├── TensorFlowEngine.cpp │ │ │ ├── TensorFlowEngine.hpp │ │ │ ├── TensorRTEngine.cpp │ │ │ └── TensorRTEngine.hpp │ │ ├── NeuralNetwork.cl │ │ ├── NeuralNetwork.cpp │ │ ├── NeuralNetwork.hpp │ │ ├── SegmentationNetwork.cpp │ │ ├── SegmentationNetwork.hpp │ │ ├── TensorToBoundingBoxSet.cpp │ │ ├── TensorToBoundingBoxSet.hpp │ │ ├── TensorToImage.cpp │ │ ├── TensorToImage.hpp │ │ ├── TensorToSegmentation.cpp │ │ ├── TensorToSegmentation.hpp │ │ ├── Tests.cpp │ │ ├── VertexTensorToSegmentation.cl │ │ ├── VertexTensorToSegmentation.cpp │ │ ├── VertexTensorToSegmentation.hpp │ │ └── imageClassification.cpp │ ├── NonLocalMeans │ │ ├── CMakeLists.txt │ │ ├── NonLocalMeans.cpp │ │ ├── NonLocalMeans.hpp │ │ ├── NonLocalMeans2D.cl │ │ └── NonLocalMeansTests.cpp │ ├── NonMaximumSuppression │ │ ├── CMakeLists.txt │ │ ├── NonMaximumSuppression.cpp │ │ └── NonMaximumSuppression.hpp │ ├── RegionProperties │ │ ├── CMakeLists.txt │ │ ├── RegionProperties.cpp │ │ ├── RegionProperties.hpp │ │ └── Tests.cpp │ ├── RunUntilFinished │ │ ├── CMakeLists.txt │ │ ├── RunUntilFinished.cpp │ │ ├── RunUntilFinished.hpp │ │ └── Tests.cpp │ ├── SeededRegionGrowing │ │ ├── CMakeLists.txt │ │ ├── SeededRegionGrowing.cpp │ │ ├── SeededRegionGrowing.hpp │ │ ├── SeededRegionGrowing2D.cl │ │ ├── SeededRegionGrowing3D.cl │ │ └── SeededRegionGrowingTests.cpp │ ├── SegmentationVolumeReconstructor │ │ ├── CMakeLists.txt │ │ ├── SegmentationVolumeReconstructor.cpp │ │ ├── SegmentationVolumeReconstructor.hpp │ │ └── Tests.cpp │ ├── Skeletonization │ │ ├── CMakeLists.txt │ │ ├── Skeletonization.cpp │ │ ├── Skeletonization.hpp │ │ ├── Skeletonization2D.cl │ │ └── SkeletonizationTests.cpp │ ├── SurfaceExtraction │ │ ├── CMakeLists.txt │ │ ├── SurfaceExtraction.cl │ │ ├── SurfaceExtraction.cpp │ │ ├── SurfaceExtraction.hpp │ │ └── SurfaceExtraction_no_3d_write.cl │ ├── TemplateMatching │ │ ├── CMakeLists.txt │ │ ├── TemplateMatching.cpp │ │ ├── TemplateMatching.hpp │ │ └── Tests.cpp │ ├── TemporalSmoothing │ │ ├── CMakeLists.txt │ │ ├── ImageMovingAverage.cl │ │ ├── ImageMovingAverage.cpp │ │ ├── ImageMovingAverage.hpp │ │ ├── ImageWeightedMovingAverage.cl │ │ ├── ImageWeightedMovingAverage.cpp │ │ ├── ImageWeightedMovingAverage.hpp │ │ └── Tests.cpp │ ├── Timing │ │ ├── CMakeLists.txt │ │ ├── Timing.cpp │ │ └── Timing.hpp │ ├── TissueMicroArrayExtractor │ │ ├── CMakeLists.txt │ │ ├── TissueMicroArrayExtractor.cpp │ │ ├── TissueMicroArrayExtractor.hpp │ │ └── TissueMicroArrayExtractorTests.cpp │ ├── TissueSegmentation │ │ ├── CMakeLists.txt │ │ ├── Tests.cpp │ │ ├── TissueSegmentation.cl │ │ ├── TissueSegmentation.cpp │ │ └── TissueSegmentation.hpp │ ├── TubeSegmentationAndCenterlineExtraction │ │ ├── CMakeLists.txt │ │ ├── InverseGradientSegmentation.cl │ │ ├── InverseGradientSegmentation.cpp │ │ ├── InverseGradientSegmentation.hpp │ │ ├── RidgeTraversalCenterlineExtraction.cpp │ │ ├── RidgeTraversalCenterlineExtraction.hpp │ │ ├── TubeSegmentationAndCenterlineExtraction.cl │ │ ├── TubeSegmentationAndCenterlineExtraction.cpp │ │ ├── TubeSegmentationAndCenterlineExtraction.hpp │ │ └── TubeSegmentationAndCenterlineExtractionTests.cpp │ ├── Ultrasound │ │ ├── CMakeLists.txt │ │ ├── EnvelopeAndLogCompressor.cl │ │ ├── EnvelopeAndLogCompressor.cpp │ │ ├── EnvelopeAndLogCompressor.hpp │ │ ├── ScanConverter.cl │ │ ├── ScanConverter.cpp │ │ └── ScanConverter.hpp │ ├── UltrasoundImageCropper │ │ ├── CMakeLists.txt │ │ ├── UltrasoundImageCropper.cl │ │ ├── UltrasoundImageCropper.cpp │ │ └── UltrasoundImageCropper.hpp │ ├── UltrasoundImageEnhancement │ │ ├── CMakeLists.txt │ │ ├── Tests.cpp │ │ ├── UltrasoundImageEnhancement.cl │ │ ├── UltrasoundImageEnhancement.cpp │ │ └── UltrasoundImageEnhancement.hpp │ └── VectorMedianFilter │ │ ├── CMakeLists.txt │ │ ├── VectorMedianFilter.cl │ │ ├── VectorMedianFilter.cpp │ │ └── VectorMedianFilter.hpp ├── Attribute.cpp ├── Attribute.hpp ├── CMakeLists.txt ├── Config.cpp ├── Config.hpp ├── Data │ ├── Access │ │ ├── Access.hpp │ │ ├── BoundingBoxSetAccess.cpp │ │ ├── BoundingBoxSetAccess.hpp │ │ ├── CMakeLists.txt │ │ ├── CameraAccess.cpp │ │ ├── CameraAccess.hpp │ │ ├── ImageAccess.cpp │ │ ├── ImageAccess.hpp │ │ ├── ImagePyramidAccess.cpp │ │ ├── ImagePyramidAccess.hpp │ │ ├── MeshAccess.cpp │ │ ├── MeshAccess.hpp │ │ ├── MeshOpenCLAccess.cpp │ │ ├── MeshOpenCLAccess.hpp │ │ ├── OpenCLBufferAccess.cpp │ │ ├── OpenCLBufferAccess.hpp │ │ ├── OpenCLImageAccess.cpp │ │ ├── OpenCLImageAccess.hpp │ │ ├── OpenGLTextureAccess.cpp │ │ ├── OpenGLTextureAccess.hpp │ │ ├── TensorAccess.cpp │ │ ├── TensorAccess.hpp │ │ ├── VertexBufferObjectAccess.cpp │ │ └── VertexBufferObjectAccess.hpp │ ├── BoundingBox.cpp │ ├── BoundingBox.hpp │ ├── CMakeLists.txt │ ├── Camera.cpp │ ├── Camera.hpp │ ├── Color.hpp │ ├── DataBoundingBox.cpp │ ├── DataBoundingBox.hpp │ ├── DataObject.cpp │ ├── DataObject.hpp │ ├── DataTypes.cpp │ ├── DataTypes.hpp │ ├── Image.cpp │ ├── Image.hpp │ ├── ImagePyramid.cpp │ ├── ImagePyramid.hpp │ ├── Mesh.cpp │ ├── Mesh.hpp │ ├── MeshVertex.cpp │ ├── MeshVertex.hpp │ ├── SimpleDataObject.hpp │ ├── SpatialDataObject.cpp │ ├── SpatialDataObject.hpp │ ├── Tensor.cpp │ ├── Tensor.hpp │ ├── TensorShape.cpp │ ├── TensorShape.hpp │ ├── Tests │ │ ├── DataObjectTests.cpp │ │ ├── ImagePyramidTests.cpp │ │ └── ImageTests.cpp │ ├── Text.cpp │ ├── Text.hpp │ ├── Transform.cpp │ └── Transform.hpp ├── DataChannels │ ├── CMakeLists.txt │ ├── DataChannel.cpp │ ├── DataChannel.hpp │ ├── NewestFrameDataChannel.cpp │ ├── NewestFrameDataChannel.hpp │ ├── QueuedDataChannel.cpp │ ├── QueuedDataChannel.hpp │ ├── StaticDataChannel.cpp │ └── StaticDataChannel.hpp ├── DataHub.cpp ├── DataHub.hpp ├── DataStream.cpp ├── DataStream.hpp ├── DeviceCriteria.cpp ├── DeviceCriteria.hpp ├── DeviceManager.cpp ├── DeviceManager.hpp ├── Examples │ ├── CMakeLists.txt │ ├── DataExport │ │ ├── CMakeLists.txt │ │ ├── convertVideoToImages.cpp │ │ └── exportMeshToVTKFile.cpp │ ├── DataImport │ │ ├── CMakeLists.txt │ │ ├── OpenIGTLinkStreaming.cpp │ │ ├── cameraStreaming.cpp │ │ ├── clariusStreaming.cpp │ │ ├── importImageFromFile.cpp │ │ ├── importLineMeshFromFile.cpp │ │ ├── importTriangleMeshFromFile.cpp │ │ ├── importVertexMeshFromFile.cpp │ │ ├── importWholeSlideImage.cpp │ │ ├── realSenseStreaming.cpp │ │ ├── streamImagesFromDisk.cpp │ │ └── streamUFFData.cpp │ ├── Filtering │ │ ├── CMakeLists.txt │ │ ├── gaussianSmoothing.cpp │ │ └── nonLocalMeans.cpp │ ├── GUI │ │ ├── CMakeLists.txt │ │ └── SimpleGUI │ │ │ ├── CMakeLists.txt │ │ │ ├── SimpleGUI.cpp │ │ │ ├── SimpleGUI.hpp │ │ │ └── main.cpp │ ├── Interoperability │ │ ├── CMakeLists.txt │ │ ├── qtInteroperability.cpp │ │ └── qtInteroperability.hpp │ ├── Python │ │ ├── block_matching_speckle_tracking.py │ │ ├── convert_video_to_image_frames.py │ │ ├── create_rotating_3D_gif.py │ │ ├── display_ultrasound_file_format_data_with_matplotlib.py │ │ ├── export_visualization_to_video.py │ │ ├── extract_surface_mesh.py │ │ ├── filter_image_and_display_with_matplotlib.py │ │ ├── generate_tissue_patches_from_wsi.py │ │ ├── load_and_display_image.py │ │ ├── load_and_display_wsi.py │ │ ├── neural_network_image_segmentation.py │ │ ├── numpy_image_to_fast.py │ │ ├── pyfast_and_pyside2.py │ │ ├── pyfast_and_pyside2_custom_window.py │ │ ├── python_process_object.py │ │ ├── python_random_access_streamer.py │ │ ├── python_streamer.py │ │ ├── real_time_line_plotter.py │ │ ├── render_to_image.py │ │ ├── scan_convert_iq_data.py │ │ ├── slicer_window_CT.py │ │ ├── slicer_window_MRI.py │ │ ├── stream_from_clarius_ultrasound_scanner.py │ │ ├── stream_from_webcamera.py │ │ ├── stream_uff_ultrasound_file_format_data.py │ │ ├── surface_extraction_gui_with_pyside2.py │ │ └── vbeam │ │ │ ├── vbeam.py │ │ │ ├── vbeam_streamer.py │ │ │ └── vbeam_streamer_pipeline.py │ ├── RealSense │ │ ├── CMakeLists.txt │ │ ├── Tracking.cpp │ │ ├── Tracking.hpp │ │ ├── TrackingGUI.cpp │ │ ├── TrackingGUI.hpp │ │ └── main.cpp │ ├── Registration │ │ ├── CMakeLists.txt │ │ ├── blockMatching.cpp │ │ ├── coherentPointDriftExample.cpp │ │ └── iterativeClosestPoint.cpp │ ├── Segmentation │ │ ├── CMakeLists.txt │ │ ├── airwaySegmentation.cpp │ │ ├── binaryThresholding.cpp │ │ ├── convertMeshToSegmentation.cpp │ │ ├── liverVesselSegmentation.cpp │ │ ├── lungSegmentation.cpp │ │ ├── neuralNetworkCTSegmentation.cpp │ │ ├── neuralNetworkUltrasoundSegmentation.cpp │ │ ├── neuralNetworkWSIClassification.cpp │ │ └── seededRegionGrowingSegmentation.cpp │ └── Visualization │ │ ├── CMakeLists.txt │ │ └── extractSurfaceAndRender.cpp ├── Exception.cpp ├── Exception.hpp ├── ExecutionDevice.cpp ├── ExecutionDevice.hpp ├── Exporters │ ├── CMakeLists.txt │ ├── Exporter.hpp │ ├── FileExporter.cpp │ ├── FileExporter.hpp │ ├── HDF5TensorExporter.cpp │ ├── HDF5TensorExporter.hpp │ ├── ITKImageExporter.hpp │ ├── ImageExporter.cpp │ ├── ImageExporter.hpp │ ├── ImageFileExporter.cpp │ ├── ImageFileExporter.hpp │ ├── ImagePyramidPatchExporter.cpp │ ├── ImagePyramidPatchExporter.hpp │ ├── MetaImageExporter.cpp │ ├── MetaImageExporter.hpp │ ├── StreamToFileExporter.cpp │ ├── StreamToFileExporter.hpp │ ├── TIFFImagePyramidExporter.cpp │ ├── TIFFImagePyramidExporter.hpp │ ├── Tests │ │ ├── HDF5TensorExporterTests.cpp │ │ ├── ITKImageExporterTests.cpp │ │ ├── ImageExporterTests.cpp │ │ ├── ImagePyramidPatchExporterTests.cpp │ │ ├── MetaImageExporterTests.cpp │ │ ├── TIFFImagePyramidExporterTests.cpp │ │ ├── VTKImageExporterTests.cpp │ │ ├── VTKMeshExporterTests.cpp │ │ └── VTKMeshFileExporterTests.cpp │ ├── VTKImageExporter.cpp │ ├── VTKImageExporter.hpp │ ├── VTKMeshExporter.cpp │ ├── VTKMeshExporter.hpp │ ├── VTKMeshFileExporter.cpp │ └── VTKMeshFileExporter.hpp ├── FramerateSynchronizer.cpp ├── FramerateSynchronizer.hpp ├── ImageFill.cl ├── ImageMinMax.cl ├── ImageSum.cl ├── Importers │ ├── CMakeLists.txt │ ├── DICOMFileImporter.cpp │ ├── DICOMFileImporter.hpp │ ├── FileImporter.hpp │ ├── HDF5TensorImporter.cpp │ ├── HDF5TensorImporter.hpp │ ├── ITKImageImporter.hpp │ ├── ImageFileImporter.cpp │ ├── ImageFileImporter.hpp │ ├── ImageImporter.cpp │ ├── ImageImporter.hpp │ ├── ImagePyramidPatchImporter.cpp │ ├── ImagePyramidPatchImporter.hpp │ ├── Importer.hpp │ ├── MetaImageImporter.cpp │ ├── MetaImageImporter.hpp │ ├── NIFTIImporter.cpp │ ├── NIFTIImporter.hpp │ ├── TIFFImagePyramidImporter.cpp │ ├── TIFFImagePyramidImporter.hpp │ ├── Tests │ │ ├── DICOMFileImporterTests.cpp │ │ ├── HDF5TensorImporterTests.cpp │ │ ├── ITKImageImporterTests.cpp │ │ ├── ImageFileImporterTests.cpp │ │ ├── ImageImporterTests.cpp │ │ ├── MetaImageImporterTests.cpp │ │ ├── NIFTIImporterTests.cpp │ │ ├── VTKImageImporterTests.cpp │ │ ├── VTKMeshFileImporterTests.cpp │ │ └── WholeSlideImageImporterTests.cpp │ ├── VTKImageImporter.cpp │ ├── VTKImageImporter.hpp │ ├── VTKMeshFileImporter.cpp │ ├── VTKMeshFileImporter.hpp │ ├── WholeSlideImageImporter.cpp │ └── WholeSlideImageImporter.hpp ├── Object.cpp ├── Object.hpp ├── OpenCL.hpp ├── OpenCLProgram.cpp ├── OpenCLProgram.hpp ├── Pipeline.cpp ├── Pipeline.hpp ├── PipelineEditor.cpp ├── PipelineEditor.hpp ├── ProcessObject.cpp ├── ProcessObject.hpp ├── ProcessObjectRegistry.hpp ├── Python │ ├── Core.i.in │ ├── DataStream.py │ ├── EigenTypemaps.i │ ├── ProcessObjectExtensions.py │ ├── ProcessObjects.i.in │ ├── Tests │ │ ├── test_array_interface.py │ │ ├── test_data_stream_object.py │ │ ├── test_eigen_typemaps.py │ │ ├── test_python_process_object.py │ │ └── test_python_streamer.py │ ├── __init__fast.py │ ├── entry_points.py │ ├── setup.py.in │ └── std_unique_ptr.i ├── Reporter.cpp ├── Reporter.hpp ├── RuntimeMeasurement.cpp ├── RuntimeMeasurement.hpp ├── RuntimeMeasurementManager.cpp ├── RuntimeMeasurementManager.hpp ├── SceneGraph.cpp ├── SceneGraph.hpp ├── Semaphore.hpp ├── Streamers │ ├── CMakeLists.txt │ ├── CameraStreamer.cpp │ ├── CameraStreamer.hpp │ ├── ClariusStreamer.cpp │ ├── ClariusStreamer.hpp │ ├── DicomMultiFrameStreamer.cpp │ ├── DicomMultiFrameStreamer.hpp │ ├── FileStreamer.cpp │ ├── FileStreamer.hpp │ ├── ImageFileStreamer.cpp │ ├── ImageFileStreamer.hpp │ ├── KinectStreamer.cpp │ ├── KinectStreamer.hpp │ ├── ManualImageStreamer.cpp │ ├── ManualImageStreamer.hpp │ ├── MeshFileStreamer.cpp │ ├── MeshFileStreamer.hpp │ ├── MovieStreamer.cpp │ ├── MovieStreamer.hpp │ ├── OpenIGTLinkStreamer.cpp │ ├── OpenIGTLinkStreamer.hpp │ ├── RandomAccessStreamer.cpp │ ├── RandomAccessStreamer.hpp │ ├── RealSenseStreamer.cpp │ ├── RealSenseStreamer.hpp │ ├── Streamer.cpp │ ├── Streamer.hpp │ ├── Tests │ │ ├── CameraStreamerTests.cpp │ │ ├── DicomMultiFrameStreamerTests.cpp │ │ ├── DummyIGTLServer.cpp │ │ ├── DummyIGTLServer.hpp │ │ ├── ImageFileStreamerTests.cpp │ │ ├── MovieStreamerTests.cpp │ │ └── OpenIGTLinkStreamerTests.cpp │ ├── TransformFileStreamer.cpp │ ├── TransformFileStreamer.hpp │ ├── UFFStreamer.cpp │ └── UFFStreamer.hpp ├── Testing.hpp ├── Tests │ ├── Algorithms │ │ ├── DoubleFilter.cl │ │ ├── DoubleFilter.cpp │ │ ├── DoubleFilter.hpp │ │ └── DoubleFilterTests.cpp │ ├── Benchmarks.cpp │ ├── CMakeLists.txt │ ├── CatchMain.cpp │ ├── DataComparison.cpp │ ├── DataComparison.hpp │ ├── DataHubTests.cpp │ ├── DummyObjects.cpp │ ├── DummyObjects.hpp │ ├── FramerateSynchronizerTests.cpp │ ├── PipelineTests.cpp │ ├── ProcessObjectTests.cpp │ ├── SceneGraphTests.cpp │ ├── SystemTests.cpp │ ├── UtilityTests.cpp │ └── catch.hpp ├── Tools │ ├── CMakeLists.txt │ ├── CommandLineParser.cpp │ ├── CommandLineParser.hpp │ ├── OpenIGTLinkServer │ │ ├── CMakeLists.txt │ │ ├── GUI.cpp │ │ ├── GUI.hpp │ │ └── main.cpp │ ├── Pipeline │ │ ├── CMakeLists.txt │ │ ├── GUI.cpp │ │ ├── GUI.hpp │ │ └── main.cpp │ ├── SonixGPSClient │ │ ├── OpenIGTLinkClient.cpp │ │ └── OpenIGTLinkClient.hpp │ ├── SystemCheck │ │ ├── CMakeLists.txt │ │ └── main.cpp │ ├── UFFViewer │ │ ├── CMakeLists.txt │ │ ├── GUI.cpp │ │ ├── GUI.hpp │ │ └── main.cpp │ └── downloadTestData.cpp ├── Utility.cpp ├── Utility.hpp └── Visualization │ ├── BoundingBoxRenderer │ ├── BoundingBoxRenderer.cpp │ ├── BoundingBoxRenderer.frag │ ├── BoundingBoxRenderer.geom │ ├── BoundingBoxRenderer.hpp │ ├── BoundingBoxRenderer.vert │ ├── BoundingBoxRendererTests.cpp │ └── CMakeLists.txt │ ├── CMakeLists.txt │ ├── ComputationThread.cpp │ ├── ComputationThread.hpp │ ├── DualViewWindow.cpp │ ├── DualViewWindow.hpp │ ├── HeatmapRenderer │ ├── CMakeLists.txt │ ├── HeatmapRenderer.cl │ ├── HeatmapRenderer.cpp │ └── HeatmapRenderer.hpp │ ├── ImagePyramidRenderer │ ├── CMakeLists.txt │ ├── ImagePyramidRenderer.cpp │ ├── ImagePyramidRenderer.frag │ ├── ImagePyramidRenderer.hpp │ └── ImagePyramidRenderer.vert │ ├── ImageRenderer │ ├── CMakeLists.txt │ ├── ImageRenderer.cpp │ ├── ImageRenderer.hpp │ ├── ImageRenderer.vert │ ├── ImageRendererFLOAT.frag │ ├── ImageRendererINT.frag │ ├── ImageRendererTests.cpp │ └── ImageRendererUINT.frag │ ├── LabelColorRenderer.cpp │ ├── LabelColorRenderer.hpp │ ├── LineRenderer │ ├── CMakeLists.txt │ ├── LineRenderer.cpp │ ├── LineRenderer.frag │ ├── LineRenderer.geom │ ├── LineRenderer.hpp │ ├── LineRenderer.vert │ ├── LineRenderer3D.frag │ ├── LineRenderer3D.vert │ ├── LineRendererJoints.frag │ ├── LineRendererJoints.vert │ └── LineRendererTests.cpp │ ├── MultiViewWindow.cpp │ ├── MultiViewWindow.hpp │ ├── Plane.cpp │ ├── Plane.hpp │ ├── Plotting │ ├── CMakeLists.txt │ ├── LinePlotter.cpp │ ├── LinePlotter.hpp │ ├── Plotter.cpp │ └── Plotter.hpp │ ├── RenderToImage │ ├── CMakeLists.txt │ ├── RenderToImage.cpp │ ├── RenderToImage.hpp │ └── Tests.cpp │ ├── Renderer.cpp │ ├── Renderer.hpp │ ├── SegmentationLabelRenderer │ ├── CMakeLists.txt │ ├── SegmentationLabelRenderer.cpp │ ├── SegmentationLabelRenderer.frag │ ├── SegmentationLabelRenderer.hpp │ ├── SegmentationLabelRenderer.vert │ └── Tests.cpp │ ├── SegmentationRenderer │ ├── CMakeLists.txt │ ├── SegmentationPyramidRenderer.frag │ ├── SegmentationRenderer.cpp │ ├── SegmentationRenderer.frag │ ├── SegmentationRenderer.hpp │ ├── SegmentationRenderer.vert │ └── SegmentationRendererTests.cpp │ ├── SimpleWindow.cpp │ ├── SimpleWindow.hpp │ ├── SliceRenderer │ ├── CMakeLists.txt │ ├── SliceRenderer.cpp │ ├── SliceRenderer.hpp │ └── SliceRendererTests.cpp │ ├── SlicerWindow.cpp │ ├── SlicerWindow.hpp │ ├── Tests │ ├── CMakeLists.txt │ ├── DualViewWindowTests.cpp │ ├── MultiViewWindowTests.cpp │ └── SlicerWindowTests.cpp │ ├── TextRenderer │ ├── CMakeLists.txt │ ├── Tests.cpp │ ├── TextRenderer.cpp │ ├── TextRenderer.frag │ ├── TextRenderer.hpp │ └── TextRenderer.vert │ ├── TriangleRenderer │ ├── CMakeLists.txt │ ├── TriangleRenderer.cpp │ ├── TriangleRenderer.frag │ ├── TriangleRenderer.hpp │ ├── TriangleRenderer.vert │ └── TriangleRendererTests.cpp │ ├── VectorFieldRenderer │ ├── CMakeLists.txt │ ├── VectorFieldColorRenderer.cl │ ├── VectorFieldColorRenderer.cpp │ ├── VectorFieldColorRenderer.hpp │ ├── VectorFieldRenderer.cpp │ └── VectorFieldRenderer.hpp │ ├── VertexRenderer │ ├── CMakeLists.txt │ ├── VertexRenderer.cpp │ ├── VertexRenderer.frag │ ├── VertexRenderer.hpp │ ├── VertexRenderer.vert │ └── VertexRendererTests.cpp │ ├── View.cl │ ├── View.cpp │ ├── View.hpp │ ├── VolumeRenderer │ ├── AlphaBlendingVolumeRenderer.cl │ ├── AlphaBlendingVolumeRenderer.cpp │ ├── AlphaBlendingVolumeRenderer.hpp │ ├── CMakeLists.txt │ ├── MaximumIntensityProjection.cl │ ├── MaximumIntensityProjection.cpp │ ├── MaximumIntensityProjection.hpp │ ├── Tests.cpp │ ├── ThresholdVolumeRenderer.cl │ ├── ThresholdVolumeRenderer.cpp │ ├── ThresholdVolumeRenderer.hpp │ ├── TransferFunction.cpp │ ├── TransferFunction.hpp │ ├── VolumeRenderer.cpp │ └── VolumeRenderer.hpp │ ├── Widgets │ ├── ButtonWidget │ │ ├── ButtonWidget.cpp │ │ ├── ButtonWidget.hpp │ │ ├── ButtonWidgetTests.cpp │ │ └── CMakeLists.txt │ ├── CMakeLists.txt │ ├── PlaybackWidget │ │ ├── CMakeLists.txt │ │ ├── PlaybackWidget.cpp │ │ └── PlaybackWidget.hpp │ └── SliderWidget │ │ ├── CMakeLists.txt │ │ ├── SliderWidget.cpp │ │ ├── SliderWidget.hpp │ │ └── SliderWidgetTests.cpp │ ├── Window.cpp │ ├── Window.hpp │ ├── WindowWidget.cpp │ └── WindowWidget.hpp ├── FASTVersion.hpp.in ├── ProcessObjectList.hpp.in └── fast_configuration.txt.in /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: 'Suggest a new feature for FAST. Please do not use issues for questions. Use discussions Q&A https://github.com/smistad/FAST/discussions/new?category=q-a or the chat https://gitter.im/smistad/FAST. ' 4 | title: '' 5 | labels: new feature 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Do you have an idea of how it can/should be implemented?** 17 | If applicable, how do you think this feature can be implemented in FAST. 18 | Ex. bullet point list of things that need to be done. 19 | 20 | **Are you willing to contribute to the implementation of this feature** 21 | If yes, which parts can you implement, and which parts do you need help from others. 22 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build*/ 2 | TestData/ 3 | .idea/ 4 | .vs/ 5 | *.cl.bin 6 | *cl.cache 7 | .cproject 8 | .project 9 | *.xml 10 | /data/ 11 | *.zip 12 | cmake-* 13 | *.pyc 14 | -------------------------------------------------------------------------------- /cmake/Documentation.cmake: -------------------------------------------------------------------------------- 1 | find_package(Doxygen REQUIRED) 2 | find_package(PythonInterp 3 REQUIRED) 3 | 4 | file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/documentation/) 5 | 6 | set(doxyfile_in ${PROJECT_SOURCE_DIR}/doc/Doxyfile.in) 7 | set(doxyfile ${CMAKE_CURRENT_BINARY_DIR}/documentation/Doxyfile) 8 | 9 | configure_file(${doxyfile_in} ${doxyfile} @ONLY) 10 | configure_file(${PROJECT_SOURCE_DIR}/doc/conf.py ${CMAKE_CURRENT_BINARY_DIR}/documentation/conf.py COPYONLY) 11 | 12 | add_custom_target(documentation 13 | COMMAND ${PYTHON_EXECUTABLE} ${FAST_EXTERNAL_BUILD_DIR}/mcss/src/mcss/documentation/doxygen.py ${CMAKE_CURRENT_BINARY_DIR}/documentation/conf.py 14 | WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/documentation/ 15 | COMMENT "Generating API documentation with Doxygen and M.CSS" 16 | DEPENDS mcss 17 | VERBATIM 18 | ) 19 | -------------------------------------------------------------------------------- /cmake/ExternalEigen.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up Eigen 2 | 3 | include(cmake/Externals.cmake) 4 | 5 | ExternalProject_Add(eigen 6 | PREFIX ${FAST_EXTERNAL_BUILD_DIR}/eigen 7 | BINARY_DIR ${FAST_EXTERNAL_BUILD_DIR}/eigen 8 | URL "https://gitlab.com/libeigen/eigen/-/archive/55967f87d1dc5cf2c33145ddcff73f349e406635/eigen-55967f87d1dc5cf2c33145ddcff73f349e406635.tar.gz" 9 | INSTALL_DIR ${FAST_EXTERNAL_INSTALL_DIR} 10 | CMAKE_CACHE_ARGS 11 | -DCMAKE_BUILD_TYPE:STRING=Release 12 | -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF 13 | -DCMAKE_INSTALL_MESSAGE:BOOL=LAZY 14 | -DCMAKE_INSTALL_PREFIX:STRING=${FAST_EXTERNAL_INSTALL_DIR} 15 | -DBUILD_TESTING:BOOL=OFF 16 | ) 17 | 18 | list(APPEND FAST_INCLUDE_DIRS ${FAST_EXTERNAL_INSTALL_DIR}/include/eigen3/) 19 | list(APPEND FAST_EXTERNAL_DEPENDENCIES eigen) 20 | -------------------------------------------------------------------------------- /cmake/ExternalFreenect2.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up libfreenect2 2 | 3 | include(cmake/Externals.cmake) 4 | 5 | ExternalProject_Add(freenect2 6 | PREFIX ${FAST_EXTERNAL_BUILD_DIR}/freenect2 7 | BINARY_DIR ${FAST_EXTERNAL_BUILD_DIR}/freenect2 8 | GIT_REPOSITORY "https://github.com/OpenKinect/libfreenect2.git" 9 | GIT_TAG "v0.2.0" 10 | CMAKE_ARGS 11 | -DENABLE_VAAPI:BOOL=OFF 12 | CMAKE_CACHE_ARGS 13 | -DCMAKE_BUILD_TYPE:STRING=Release 14 | -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF 15 | -DCMAKE_INSTALL_MESSAGE:BOOL=LAZY 16 | -DCMAKE_INSTALL_PREFIX:STRING=${FAST_EXTERNAL_INSTALL_DIR} 17 | ) 18 | 19 | list(APPEND LIBRARIES libfreenect2${CMAKE_SHARED_LIBRARY_SUFFIX}) 20 | list(APPEND FAST_EXTERNAL_DEPENDENCIES freenect2) 21 | -------------------------------------------------------------------------------- /cmake/ExternalLibJPEG.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up LibJPEG library 2 | 3 | include(cmake/Externals.cmake) 4 | 5 | if(WIN32) 6 | ExternalProject_Add(libjpeg 7 | PREFIX ${FAST_EXTERNAL_BUILD_DIR}/libjpeg 8 | URL "https://github.com/smistad/FAST-dependencies/releases/download/v4.0.0/LibJPEG-9d-Win-pc064.zip" 9 | UPDATE_COMMAND "" 10 | CONFIGURE_COMMAND "" 11 | BUILD_COMMAND "" 12 | INSTALL_COMMAND ${CMAKE_COMMAND} -E copy ${FAST_EXTERNAL_BUILD_DIR}/libjpeg/src/libjpeg/LibJPEG/9d/bin/libjpeg.dll ${FAST_EXTERNAL_INSTALL_DIR}/bin/ COMMAND 13 | ${CMAKE_COMMAND} -E copy ${FAST_EXTERNAL_BUILD_DIR}/libjpeg/src/libjpeg/LibJPEG/9d/lib/libjpeg.lib ${FAST_EXTERNAL_INSTALL_DIR}/lib/ COMMAND 14 | ${CMAKE_COMMAND} -E copy_directory ${FAST_EXTERNAL_BUILD_DIR}/libjpeg/src/libjpeg/LibJPEG/9d/include/ ${FAST_EXTERNAL_INSTALL_DIR}/include/ 15 | ) 16 | list(APPEND LIBRARIES libjpeg.lib) 17 | endif() 18 | -------------------------------------------------------------------------------- /cmake/ExternalMCSS.cmake: -------------------------------------------------------------------------------- 1 | # Download M.CSS for building the documentation 2 | include(cmake/Externals.cmake) 3 | 4 | ExternalProject_Add(mcss 5 | PREFIX ${FAST_EXTERNAL_BUILD_DIR}/mcss 6 | BINARY_DIR ${FAST_EXTERNAL_BUILD_DIR}/mcss 7 | GIT_REPOSITORY "https://github.com/smistad/m.css" 8 | GIT_TAG "fast_constructor_hack" 9 | UPDATE_COMMAND "" 10 | CONFIGURE_COMMAND "" 11 | BUILD_COMMAND "" 12 | INSTALL_COMMAND "" 13 | ) -------------------------------------------------------------------------------- /cmake/ExternalOpenSlide.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up OpenSlide 2 | 3 | include(cmake/Externals.cmake) 4 | 5 | if(WIN32) 6 | 7 | ExternalProject_Add(openslide 8 | PREFIX ${FAST_EXTERNAL_BUILD_DIR}/openslide 9 | BINARY_DIR ${FAST_EXTERNAL_BUILD_DIR}/openslide 10 | URL "https://github.com/openslide/openslide-bin/releases/download/v20231011/openslide-win64-20231011.zip" 11 | CONFIGURE_COMMAND ${CMAKE_COMMAND} -E copy_directory ${FAST_EXTERNAL_BUILD_DIR}/openslide/src/openslide/ ${FAST_EXTERNAL_INSTALL_DIR} 12 | BUILD_COMMAND "" 13 | INSTALL_COMMAND "" 14 | ) 15 | 16 | list(APPEND FAST_EXTERNAL_DEPENDENCIES openslide) 17 | endif() 18 | -------------------------------------------------------------------------------- /cmake/ExternalZip.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up zip library 2 | 3 | if(WIN32) 4 | fast_download_dependency(zip 5 | 0.2.0 6 | 63454fc97117e3f336b0fdc56308ddc7d3d4c2d775ee5d82916cf0d7f34e6bbc 7 | zip.lib 8 | ) 9 | elseif(APPLE) 10 | if(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64") 11 | fast_download_dependency(zip 12 | 0.2.0 13 | 98b462abc0acdb8d7db3c80db647c48fb619d786986d188a120ebd74c201bfd2 14 | libzip.a 15 | ) 16 | else() 17 | fast_download_dependency(zip 18 | 0.2.0 19 | 6a1ed7b737265a50459b418bd5ee6f90463a2edeea73e8378519347ba333ab11 20 | libzip.a 21 | ) 22 | endif() 23 | else() 24 | fast_download_dependency(zip 25 | 0.2.0 26 | 091a2f73263ebdfe36d0a489db8b758c9bac77169f133274513bc862a2f09eef 27 | libzip.a 28 | ) 29 | endif() 30 | -------------------------------------------------------------------------------- /cmake/ExternalZlib.cmake: -------------------------------------------------------------------------------- 1 | # Download and set up zlib 2 | 3 | if(WIN32) 4 | fast_download_dependency(zlib 5 | 1.2.9 6 | bf6971104e98a8ac64c8b172f01508e95b7e4fd81e427511b5531dd1b6376b29 7 | zlib.lib 8 | ) 9 | elseif(APPLE) 10 | if(CMAKE_OSX_ARCHITECTURES STREQUAL "arm64") 11 | fast_download_dependency(zlib 12 | 1.2.9 13 | bf91823e4782458629b816c01fdf1f013d5767d977d6a35cc2fff1072082a33a 14 | libz.dylib 15 | ) 16 | else() 17 | fast_download_dependency(zlib 18 | 1.2.9 19 | 74f790268fe20c564345e404f5836df9e24d1a603075adf4581cf58a85cc4dba 20 | libz.dylib 21 | ) 22 | endif() 23 | else() 24 | fast_download_dependency(zlib 25 | 1.2.9 26 | 72d5aa4d2e12266858ff668ad9e0d44e707a42112008f566777f9bea1a792274 27 | libz.so 28 | ) 29 | endif() 30 | -------------------------------------------------------------------------------- /cmake/Externals.cmake: -------------------------------------------------------------------------------- 1 | include(ExternalProject) 2 | 3 | set(FAST_DOWNLOAD_DIR ${PROJECT_SOURCE_DIR}/external/) 4 | set(FAST_EXTERNAL_BUILD_DIR ${PROJECT_BINARY_DIR}/external) 5 | set(FAST_EXTERNAL_INSTALL_DIR ${PROJECT_BINARY_DIR}) 6 | -------------------------------------------------------------------------------- /cmake/FASTCustomCommands.cmake: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_Visualization) 2 | add_custom_command(TARGET FAST POST_BUILD 3 | COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ 4 | COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ 5 | COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ 6 | COMMAND ${CMAKE_COMMAND} -E copy_if_different $ $ 7 | ) 8 | endif() 9 | -------------------------------------------------------------------------------- /cmake/InstallFiles/Semaphore_LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2015 Jeff Preshing 2 | 3 | This software is provided 'as-is', without any express or implied 4 | warranty. In no event will the authors be held liable for any damages 5 | arising from the use of this software. 6 | 7 | Permission is granted to anyone to use this software for any purpose, 8 | including commercial applications, and to alter it and redistribute it 9 | freely, subject to the following restrictions: 10 | 11 | 1. The origin of this software must not be misrepresented; you must not 12 | claim that you wrote the original software. If you use this software 13 | in a product, an acknowledgement in the product documentation would be 14 | appreciated but is not required. 15 | 2. Altered source versions must be plainly marked as such, and must not be 16 | misrepresented as being the original software. 17 | 3. This notice may not be removed or altered from any source distribution. -------------------------------------------------------------------------------- /cmake/ModuleClarius.cmake: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_Clarius) 2 | message(STATUS "-- Clarius ultrasound module enabled.") 3 | include(cmake/ExternalClarius.cmake) 4 | endif() 5 | -------------------------------------------------------------------------------- /cmake/ModuleITK.cmake: -------------------------------------------------------------------------------- 1 | ## ITK 2 | if(FAST_MODULE_ITK) 3 | find_package(ITK REQUIRED) 4 | include(${ITK_USE_FILE}) 5 | message("-- Enabling ITK interoperability") 6 | set(LIBRARIES ${LIBRARIES} ${ITK_LIBRARIES}) 7 | endif() -------------------------------------------------------------------------------- /cmake/ModuleKinect.cmake: -------------------------------------------------------------------------------- 1 | 2 | if(FAST_MODULE_Kinect) 3 | message("-- Enabling Kinect module.") 4 | include(cmake/ExternalFreenect2.cmake) 5 | endif() -------------------------------------------------------------------------------- /cmake/ModuleOpenVINO.cmake: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_OpenVINO) 2 | message("-- Enabling Intel OpenVINO inference engine module") 3 | if(WIN32) 4 | fast_download_dependency(openvino 5 | 2022.3.0 6 | 6f652dc6c533d2894650db728a0c2bc6e60e817ff6343f1dc30756b6ccadad0c 7 | ) 8 | elseif(APPLE) 9 | fast_download_dependency(openvino 10 | 2022.3.0 11 | 69f11b1cd008db87d972346a2ff4036c7c4d8371c2192f661911b357c8eb4fe4 12 | ) 13 | else() 14 | fast_download_dependency(openvino 15 | 2022.3.0 16 | 405b1e4156b96877606501a10402b992d04b54431dbf81605e435bcbd9d9f2bd 17 | ) 18 | 19 | endif() 20 | endif() 21 | -------------------------------------------------------------------------------- /cmake/ModuleRealSense.cmake: -------------------------------------------------------------------------------- 1 | 2 | if(FAST_MODULE_RealSense) 3 | message("-- Enabling real sense module.") 4 | if(WIN32) 5 | fast_download_dependency(realsense 6 | 2.40.0 7 | f13f1435ef9498b0b53c869c2f389b66bcae220591625ab6059319a0c4acfa2e 8 | realsense2.lib 9 | ) 10 | else() 11 | fast_download_dependency(realsense 12 | 2.40.0 13 | a18181ea9c4ce56e117882f441c59f528fca9181087da9ac29e870046dbd2906 14 | librealsense2.so 15 | ) 16 | endif() 17 | endif() 18 | -------------------------------------------------------------------------------- /cmake/ModuleTensorFlow.cmake: -------------------------------------------------------------------------------- 1 | ## TensorFlow module 2 | 3 | if(FAST_MODULE_TensorFlow) 4 | message("-- TensorFlow module enabled.") 5 | 6 | if(WIN32) 7 | fast_download_dependency(tensorflow 8 | 2.4.0 9 | ff6b590025dd7b9a736987ff082ef0af20fe4f91a9b3fe846d25828d806a094b 10 | ) 11 | set(TensorFlow_LIBRARIES tensorflow_cc.lib) 12 | elseif(APPLE) 13 | fast_download_dependency(tensorflow 14 | 2.4.0 15 | 9cb561c8dd8b77423c49407f7b13478a507e8ceccac660829c36d3bd68f1ad64 16 | ) 17 | set(TensorFlow_LIBRARIES libtensorflow_cc.dylib libtensorflow_framework.2.dylib) 18 | else() 19 | fast_download_dependency(tensorflow 20 | 2.4.0 21 | 58c3988c5f5b95d49cdb87d3b42f665691fc6975ab2272ab581a31882364fab3 22 | ) 23 | set(TensorFlow_LIBRARIES tensorflow_cc.so) 24 | endif() 25 | endif() 26 | -------------------------------------------------------------------------------- /cmake/ModuleTensorRT.cmake: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_TensorRT) 2 | message("-- Enabling TensorRT inference engine module") 3 | find_package(TensorRT 8 REQUIRED) 4 | find_package(CUDA REQUIRED) 5 | endif() -------------------------------------------------------------------------------- /cmake/ModuleVTK.cmake: -------------------------------------------------------------------------------- 1 | ## VTK 2 | if(FAST_MODULE_VTK) 3 | find_package(VTK REQUIRED) 4 | include(${VTK_USE_FILE}) 5 | message("-- Enabling VTK interoperability. VTK version ${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}") 6 | set(LIBRARIES ${LIBRARIES} ${VTK_LIBRARIES}) 7 | endif() 8 | -------------------------------------------------------------------------------- /cmake/PackageConfig.txt: -------------------------------------------------------------------------------- 1 | if(CPACK_GENERATOR MATCHES "DEB") 2 | set(CPACK_PACKAGING_INSTALL_PREFIX "/opt") 3 | elseif(CPACK_GENERATOR MATCHES "TXZ") 4 | set(CPACK_PACKAGING_INSTALL_PREFIX "") 5 | endif() -------------------------------------------------------------------------------- /cmake/PythonWheel.cmake: -------------------------------------------------------------------------------- 1 | message(STATUS "Creating setup.py for python ${PYTHON_VERSION} wheel...") 2 | 3 | configure_file(${FAST_SOURCE_DIR}/source/FAST/Python/setup.py.in ${FAST_BINARY_DIR}/python/setup.py @ONLY IMMEDIATE) 4 | 5 | execute_process(COMMAND ${PYTHON_EXECUTABLE} setup.py bdist_wheel --py-limited-api cp36 WORKING_DIRECTORY "${FAST_BINARY_DIR}/python/") 6 | -------------------------------------------------------------------------------- /cmake/Qt5/Qt5ConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.15.2) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5/Qt5ModuleLocation.cmake: -------------------------------------------------------------------------------- 1 | set(_qt5_root_dir ${_qt5_install_prefix}) 2 | set(_qt5_module_paths ${_qt5_install_prefix}) 3 | 4 | set(_qt5_at @) 5 | set(_qt5_module_location_template ${_qt5_install_prefix}/Qt5${_qt5_at}module${_qt5_at}/Qt5${_qt5_at}module${_qt5_at}Config.cmake) 6 | unset(_qt5_at) 7 | -------------------------------------------------------------------------------- /cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(_qt5_corelib_extra_includes "${_qt5Core_install_prefix}/external/qt5/src/qt5/qtbase//mkspecs/linux-g++") 3 | -------------------------------------------------------------------------------- /cmake/Qt5Core/Qt5CoreConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Gui/Qt5GuiConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Multimedia/Qt5Multimedia_AudioCaptureServicePlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::AudioCaptureServicePlugin MODULE IMPORTED) 3 | 4 | _populate_Multimedia_plugin_properties(AudioCaptureServicePlugin RELEASE "mediaservice/libqtmedia_audioengine.so") 5 | 6 | list(APPEND Qt5Multimedia_PLUGINS Qt5::AudioCaptureServicePlugin) 7 | -------------------------------------------------------------------------------- /cmake/Qt5Multimedia/Qt5Multimedia_QM3uPlaylistPlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::QM3uPlaylistPlugin MODULE IMPORTED) 3 | 4 | _populate_Multimedia_plugin_properties(QM3uPlaylistPlugin RELEASE "playlistformats/libqtmultimedia_m3u.so") 5 | 6 | list(APPEND Qt5Multimedia_PLUGINS Qt5::QM3uPlaylistPlugin) 7 | -------------------------------------------------------------------------------- /cmake/Qt5MultimediaWidgets/Qt5MultimediaWidgetsConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Network/Qt5NetworkConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::QConnmanEnginePlugin MODULE IMPORTED) 3 | 4 | _populate_Network_plugin_properties(QConnmanEnginePlugin RELEASE "bearer/libqconnmanbearer.so") 5 | 6 | list(APPEND Qt5Network_PLUGINS Qt5::QConnmanEnginePlugin) 7 | -------------------------------------------------------------------------------- /cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::QGenericEnginePlugin MODULE IMPORTED) 3 | 4 | _populate_Network_plugin_properties(QGenericEnginePlugin RELEASE "bearer/libqgenericbearer.so") 5 | 6 | list(APPEND Qt5Network_PLUGINS Qt5::QGenericEnginePlugin) 7 | -------------------------------------------------------------------------------- /cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::QNetworkManagerEnginePlugin MODULE IMPORTED) 3 | 4 | _populate_Network_plugin_properties(QNetworkManagerEnginePlugin RELEASE "bearer/libqnmbearer.so") 5 | 6 | list(APPEND Qt5Network_PLUGINS Qt5::QNetworkManagerEnginePlugin) 7 | -------------------------------------------------------------------------------- /cmake/Qt5OpenGL/Qt5OpenGLConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5PrintSupport/Qt5PrintSupportConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.15.2) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5PrintSupport/Qt5PrintSupport_QWindowsPrinterSupportPlugin.cmake: -------------------------------------------------------------------------------- 1 | 2 | add_library(Qt5::QWindowsPrinterSupportPlugin MODULE IMPORTED) 3 | 4 | 5 | _populate_PrintSupport_plugin_properties(QWindowsPrinterSupportPlugin RELEASE "printsupport/windowsprintersupport.dll" FALSE) 6 | 7 | list(APPEND Qt5PrintSupport_PLUGINS Qt5::QWindowsPrinterSupportPlugin) 8 | set_property(TARGET Qt5::PrintSupport APPEND PROPERTY QT_ALL_PLUGINS_printsupport Qt5::QWindowsPrinterSupportPlugin) 9 | set_property(TARGET Qt5::QWindowsPrinterSupportPlugin PROPERTY QT_PLUGIN_TYPE "printsupport") 10 | set_property(TARGET Qt5::QWindowsPrinterSupportPlugin PROPERTY QT_PLUGIN_EXTENDS "") 11 | -------------------------------------------------------------------------------- /cmake/Qt5SerialPort/Qt5SerialPortConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.9.4) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake: -------------------------------------------------------------------------------- 1 | 2 | if (NOT TARGET Qt5::uic) 3 | add_executable(Qt5::uic IMPORTED) 4 | 5 | set(imported_location "${_qt5Widgets_install_prefix}/bin/uic") 6 | _qt5_Widgets_check_file_exists(${imported_location}) 7 | 8 | set_target_properties(Qt5::uic PROPERTIES 9 | IMPORTED_LOCATION ${imported_location} 10 | ) 11 | endif() 12 | 13 | include("${CMAKE_CURRENT_LIST_DIR}/Qt5Widgets_AccessibleFactory.cmake" OPTIONAL) 14 | 15 | set(Qt5Widgets_UIC_EXECUTABLE Qt5::uic) 16 | -------------------------------------------------------------------------------- /cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake: -------------------------------------------------------------------------------- 1 | 2 | set(PACKAGE_VERSION 5.8.0) 3 | 4 | if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) 5 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 6 | else() 7 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 8 | if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) 9 | set(PACKAGE_VERSION_EXACT TRUE) 10 | endif() 11 | endif() 12 | -------------------------------------------------------------------------------- /doc/fast.css: -------------------------------------------------------------------------------- 1 | p { 2 | text-indent: 0px !important; 3 | } 4 | 5 | .m-image { 6 | margin: 0px !important; 7 | border-radius: 0px !important; 8 | display: inline-block !important; 9 | } 10 | 11 | li { 12 | margin-bottom: 4px; 13 | } 14 | 15 | * { 16 | text-align: left !important; 17 | } 18 | 19 | img { 20 | object-fit: contain; 21 | } -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-Bold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-Bold.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-BoldItalic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-BoldItalic.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-Italic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-Italic.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-Light.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-Light.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-LightItalic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-LightItalic.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-Medium.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-Medium.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-MediumItalic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-MediumItalic.ttf -------------------------------------------------------------------------------- /doc/fonts/Ubuntu-Regular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/Ubuntu-Regular.ttf -------------------------------------------------------------------------------- /doc/fonts/UbuntuMono-Bold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/UbuntuMono-Bold.ttf -------------------------------------------------------------------------------- /doc/fonts/UbuntuMono-BoldItalic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/UbuntuMono-BoldItalic.ttf -------------------------------------------------------------------------------- /doc/fonts/UbuntuMono-Italic.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/UbuntuMono-Italic.ttf -------------------------------------------------------------------------------- /doc/fonts/UbuntuMono-Regular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/fonts/UbuntuMono-Regular.ttf -------------------------------------------------------------------------------- /doc/images/FAST_logo_square.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/FAST_logo_square.png -------------------------------------------------------------------------------- /doc/images/examples/python/block_matching_tracking.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/block_matching_tracking.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/clarius_streaming.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/clarius_streaming.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/display_uff_data.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/display_uff_data.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/extract_surface_and_render.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/extract_surface_and_render.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/left_ventricle.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/left_ventricle.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/neural_network_segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/neural_network_segmentation.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/non_local_means.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/non_local_means.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/pyfast_and_pyside.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/pyfast_and_pyside.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/pyfast_and_pyside_custom_window.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/pyfast_and_pyside_custom_window.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/pyside_surface_extraction.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/pyside_surface_extraction.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/python_process_object.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/python_process_object.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/python_random_access_streamer.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/python_random_access_streamer.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/real_time_line_plotter.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/real_time_line_plotter.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/rotating_3D.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/rotating_3D.gif -------------------------------------------------------------------------------- /doc/images/examples/python/scan_convert_iq_data.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/scan_convert_iq_data.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/slicer_window_CT.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/slicer_window_CT.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/slicer_window_MRI.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/slicer_window_MRI.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/stream_uff_data_and_filter.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/stream_uff_data_and_filter.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/vbeam_example.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/vbeam_example.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/video_frames.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/video_frames.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/webcamera.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/webcamera.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/wsi.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/wsi.jpg -------------------------------------------------------------------------------- /doc/images/examples/python/wsi_patches.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/examples/python/wsi_patches.jpg -------------------------------------------------------------------------------- /doc/images/fast_icon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/fast_icon.ico -------------------------------------------------------------------------------- /doc/images/fast_icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/fast_icon.png -------------------------------------------------------------------------------- /doc/images/fast_logo_wide.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/fast_logo_wide.png -------------------------------------------------------------------------------- /doc/images/tutorials/left_ventricle_nlm_dual_view.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/left_ventricle_nlm_dual_view.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/left_ventricle_non_local_means.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/left_ventricle_non_local_means.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/LICENSE.txt: -------------------------------------------------------------------------------- 1 | The data used to create the example images in the files brain-segmentation.jpg and skull_strip.jpg is from The Cancer Imaging Archive (TCIA). 2 | It is licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/): 3 | Bakas, S., Sako, C., Akbari, H., Bilello, M., Sotiras, A., Shukla, G., Rudie, J. D., Flores Santamaria, N., Fathi Kazerooni, A., Pati, S., Rathore, S., Mamourian, E., Ha, S. M., Parker, W., Doshi, J., Baid, U., Bergman, M., Binder, Z. A., Verma, R., … Davatzikos, C. (2021). 4 | Multi-parametric magnetic resonance imaging (mpMRI) scans for de novo Glioblastoma (GBM) patients from the University of Pennsylvania Health System (UPENN-GBM) (Version 2) [Data set]. 5 | The Cancer Imaging Archive. 6 | https://doi.org/10.7937/TCIA.709X-DN49 -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/alpha_blending_volume_renderer_CT.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/alpha_blending_volume_renderer_CT.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/alpha_blending_volume_renderer_CT_custom.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/alpha_blending_volume_renderer_CT_custom.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/brain-segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/brain-segmentation.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/gui_example.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/gui_example.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/gui_example2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/gui_example2.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/maximum_intensity_projection.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/maximum_intensity_projection.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/mri_slice.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/mri_slice.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/skull_strip.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/skull_strip.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/slicer_window_CT.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/slicer_window_CT.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/slicer_window_segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/slicer_window_segmentation.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/surface_extraction_CT.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/surface_extraction_CT.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/mri_ct/threshold_volume_renderer.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/mri_ct/threshold_volume_renderer.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/colormap.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/colormap.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/export_visualization_to_video_vlc.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/export_visualization_to_video_vlc.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/neural_network_segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/neural_network_segmentation.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/nlm_denoising.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/nlm_denoising.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/playback_widget.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/playback_widget.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/python_process_object.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/python_process_object.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/read_3d_ultrasound_slicer_window.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/read_3d_ultrasound_slicer_window.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/read_3d_ultrasound_volume_rendering.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/read_3d_ultrasound_volume_rendering.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/read_uff_data.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/read_uff_data.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/read_uff_data_beamspace.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/read_uff_data_beamspace.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/read_video.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/read_video.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/scan_convert.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/scan_convert.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/simple_gui.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/simple_gui.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/simple_gui2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/simple_gui2.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/ultrasound/ultrasound_image_cropper.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/ultrasound/ultrasound_image_cropper.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/get_level_as_image.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/get_level_as_image.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/get_patch_as_image.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/get_patch_as_image.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/image_pyramid_patch_exporter.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/image_pyramid_patch_exporter.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/nuclei_segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/nuclei_segmentation.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/nuclei_segmentation_export_import.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/nuclei_segmentation_export_import.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/nuclei_segmentation_full.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/nuclei_segmentation_full.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/open_wsi.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/open_wsi.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/tissue_patches.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/tissue_patches.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/tissue_segmentation.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/tissue_segmentation.jpg -------------------------------------------------------------------------------- /doc/images/tutorials/wsi/tma_extractor.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/doc/images/tutorials/wsi/tma_extractor.jpg -------------------------------------------------------------------------------- /doc/pages/Building-FAST.md: -------------------------------------------------------------------------------- 1 | Building FAST {#building-fast} 2 | =============================== 3 | 4 | To setup and build the framework, see the instructions for your operating system: 5 | - [Ubuntu Linux](@ref building-on-linux) 6 | - [Windows](@ref building-on-windows) 7 | - [Mac OS](@ref building-on-mac) 8 | -------------------------------------------------------------------------------- /doc/pages/CXX-tutorials.md: -------------------------------------------------------------------------------- 1 | C++ Tutorials {#cpp-tutorials} 2 | =================== 3 | 4 | * [Introduction (Start here)](@ref cpp-tutorial-intro) 5 | * [Neural network processing](@ref cpp-tutorial-neural-networks) 6 | * [Whole slide image (WSI) processing](@ref cpp-tutorial-wsi) 7 | * [Making your own FAST image processing algorithm](@ref cpp-tutorial-process-object) 8 | * [Making your own FAST renderer](@ref cpp-tutorial-renderer) 9 | -------------------------------------------------------------------------------- /doc/pages/Clarius-module.md: -------------------------------------------------------------------------------- 1 | Clarius module {#clarius-module} 2 | =================================== 3 | 4 | The Clarius ultrasound module features a ClariusStreamer object which can be used to stream B-mode and Doppler data in real-time from a [Clarius ultrasound scanner](https://clarius.com/). 5 | 6 | FAST uses the [Clarius listen API](https://clarius.com/research-toolkits/) for streaming, and you need a research license from Clarius to use this API. 7 | 8 | In the clarius app, make sure you have selected "Research (5828)" under Clarius Cast in settings. After this done connect to the clarius probe's wifi access point with your machine running FAST. You should then be able to use the clarius streamer in FAST. The password for the access point is added to the clipboard on your mobile device when connecting using the device. 9 | 10 | **Note for Windows:** The windows firewall will block the images sent from the Clarius scanner. Thus you need to disable the windows firewall or add an exception in the firewall. -------------------------------------------------------------------------------- /doc/pages/Download-stats.md: -------------------------------------------------------------------------------- 1 | Download Statistics {#download-stats} 2 | ================================== 3 | 4 | PyPi (pip) Downloads 5 | -------------------- 6 | 7 | * ![](https://shields.io/pypi/dd/pyfast) 8 | * ![](https://shields.io/pypi/dw/pyfast) 9 | * ![](https://shields.io/pypi/dm/pyfast) 10 | 11 | 12 | GitHub Downloads 13 | -------------------- 14 | 15 | * ![](https://shields.io/github/downloads/smistad/fast/v4.9.0/total) -------------------------------------------------------------------------------- /doc/pages/Get-started.md: -------------------------------------------------------------------------------- 1 | Get started {#get-started} 2 | ================================= 3 | 4 | Here are some resources to help your get started with FAST: 5 | * Install FAST 6 | * [Install FAST on Windows](@ref install-windows) 7 | * [Install FAST on Ubuntu Linux](@ref install-ubuntu-linux) 8 | * [Install FAST on macOS](@ref install-mac) 9 | * [C++ Introduction Tutorial](@ref cpp-tutorial-intro) 10 | * [Python Introduction Tutorial](@ref python-tutorial-intro) 11 | * [Text Pipelines Tutorial](@ref text-pipelines) 12 | -------------------------------------------------------------------------------- /doc/pages/HDF5-module.md: -------------------------------------------------------------------------------- 1 | HDF5 module {#hdf5-module} 2 | ============================ 3 | 4 | This module uses libhdf5 to support import and export of data stored in the HDF5 file format. 5 | It is used mainly to facilitate import and export of data in the [ultrasound file format (UFF)](http://www.ustb.no/examples/uff/) used in the [ultrasound toolbox](https://www.ustb.no). -------------------------------------------------------------------------------- /doc/pages/Install-FAST.md: -------------------------------------------------------------------------------- 1 | Install FAST {#install} 2 | ===================== 3 | 4 | * [Install FAST for Windows](@ref install-windows) 5 | * [Install FAST for Ubuntu Linux](@ref install-ubuntu-linux) 6 | * [Install FAST for macOS](@ref install-mac) 7 | -------------------------------------------------------------------------------- /doc/pages/Kinect-module.md: -------------------------------------------------------------------------------- 1 | The Kinect module in FAST uses [libfreenect2](https://github.com/OpenKinect/libfreenect2) to enable streaming of RGB and depth data for a Kinect v2 device. [Here is an example on how to use the KinectStreamer.](https://github.com/smistad/FAST/wiki/Example:-Kinect-Streaming) 2 | 3 | Need libusb and turbo jpeg: 4 | ```bash 5 | sudo apt install libusb-1.0.0-dev libturbojpeg0-dev 6 | ``` -------------------------------------------------------------------------------- /doc/pages/Movie-streamer.md: -------------------------------------------------------------------------------- 1 | The movie streamer can stream each image frame of a video file through a FAST pipeline. 2 | 3 | ## Troubleshoot 4 | For windows if you get an error like: `DirectShowPlayerService::doRender: Unresolved error code 0x80040266 (IDispatch error #102)` 5 | You are probably missing some codecs, downloading K-lite basic codec package should fix this: https://www.codecguide.com/download_kl.htm -------------------------------------------------------------------------------- /doc/pages/OpenVINO-module.md: -------------------------------------------------------------------------------- 1 | OpenVINO module {#openvino-module} 2 | ================================= 3 | 4 | The OpenVINO module enables use of Intel's OpenVINO inference engine for neural networks. 5 | This enables you run execute neural networks on Intel's CPUs and integrated GPUs. 6 | FAST will download and build OpenVINO automatically when FAST_MODULE_OpenVINO is enabled in cmake. -------------------------------------------------------------------------------- /doc/pages/Plotting-module.md: -------------------------------------------------------------------------------- 1 | Plotting module {#plotting-module} 2 | ===================================== 3 | 4 | The plotting module uses the library [JKQTPlotter](https://github.com/jkriege2/JKQtPlotter) which is based on Qt 5. The reason for using this library instead of the official QtCharts is mainly because QtCharts is GPL licensed, while JKQTPlotter is LGPL licensed. 5 | 6 | This module enables you to do real-time plotting by connecting a plotter process object to a FAST pipeline. The plotting process object is updated continuously as it gets new data from its input connections. 7 | 8 | You may also use JKQTPlotter directly without plugging it in a FAST pipeline, see examples of how to create great looking plots here: https://github.com/jkriege2/JKQtPlotter/tree/master/examples -------------------------------------------------------------------------------- /doc/pages/Python-tutorials.md: -------------------------------------------------------------------------------- 1 | Python Tutorials {#python-tutorials} 2 | =================== 3 | 4 | * [Introduction (Start here)](@ref python-tutorial-intro) 5 | * [Neural network processing](@ref python-tutorial-neural-networks) 6 | * [Using FAST on Whole-Slide Images (WSI)](@ref python-tutorial-wsi) 7 | * [Using FAST on MRI and CT images](@ref python-tutorial-mri-ct) 8 | * [Using FAST on Ultrasound data](@ref python-tutorial-ultrasound) 9 | -------------------------------------------------------------------------------- /doc/pages/RealSense-module.md: -------------------------------------------------------------------------------- 1 | RealSense module {#realsense-module} 2 | ========================================== 3 | 4 | The RealSense module in FAST uses librealsense2 to enable streaming of RGB and depth data for a Intel RealSense device. -------------------------------------------------------------------------------- /doc/pages/Running-the-tests.md: -------------------------------------------------------------------------------- 1 | After the framework has been compiled you can download the test data and run the unit and system tests to make sure the framework is working properly on your system. Note that the CMake option FAST_BUILD_TESTS must be set for the tests to be compiled. 2 | 3 | Download and install test data 4 | ---------------------------------------------------------- 5 | To be able to run all the tests you must download the test data set. 6 | 7 | Running the tests 8 | ----------------------------------------------------------------------- 9 | The test framework used is called Catch and here are some examples of how to use it: 10 | 11 | ```bash 12 | # Run all tests 13 | ./bin/testFAST 14 | 15 | # See a list of all tests available 16 | ./bin/testFAST -l 17 | 18 | # Run tests with a specific tag 19 | ./bin/testFAST [SliceRenderer] 20 | ``` -------------------------------------------------------------------------------- /doc/pages/TensorRT-module.md: -------------------------------------------------------------------------------- 1 | TensorRT module {#tensorrt-module} 2 | ===================================== 3 | 4 | This module enables neural network inference in NVIDIA GPUs using the the TensorRT library. 5 | 6 | ## Requirements 7 | * [CUDA](https://developer.nvidia.com/cuda-downloads) 8 | * [TensorRT](https://developer.nvidia.com/nvidia-tensorrt-download) -------------------------------------------------------------------------------- /doc/pages/VTK-module.md: -------------------------------------------------------------------------------- 1 | VTK module {#vtk-module} 2 | ===================== 3 | 4 | The VTK module allows connecting VTK and FAST image pipelines. 5 | 6 | ## Usage 7 | Set FAST_MODULE_VTK to ON in CMake to enable this module, if CMake is unable to find VTK automatically you will have to set VTK_DIR in CMake to where you have VTK installed on your system. 8 | 9 | Tested with version VTK 7.1 -------------------------------------------------------------------------------- /doc/pages/Visualization-module.md: -------------------------------------------------------------------------------- 1 | This module is enabled by default, but if you don't need visualization, you can turn this off with the FAST_MODULE_Visualization CMake option. This will remove the Qt dependency when building FAST. 2 | Currently, the following will not work when the visualization module is disabled: 3 | 4 | * All visualization naturally (windows, renderers etc.) 5 | * Import and export of png/jpg/bmp images. The QImage class is used for this. 6 | * SurfaceExtraction algorithm. This is because Qt is used to get OpenGL extension function pointers. -------------------------------------------------------------------------------- /pipelines/camera_streaming.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Camera streaming" 2 | PipelineDescription "Stream images from a camera connected to the system" 3 | 4 | ProcessObject camera CameraStreamer 5 | 6 | Renderer renderer ImageRenderer 7 | Input 0 camera 0 8 | 9 | View view renderer 10 | Attribute 2Dmode true 11 | Attribute background-color white -------------------------------------------------------------------------------- /pipelines/image_renderer.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "2D Image renderer" 2 | PipelineDescription "Simple 2D image rendering" 3 | 4 | ProcessObject importer ImageFileImporter 5 | Attribute filename @@filename=$TEST_DATA_PATH$/US/US-2D.png@@ 6 | 7 | Renderer renderer ImageRenderer 8 | Input 0 importer 0 9 | 10 | View view renderer 11 | Attribute 2Dmode true 12 | Attribute background-color black -------------------------------------------------------------------------------- /pipelines/movie_streaming.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Movie Streaming" 2 | PipelineDescription "Stream a movie from file and render it" 3 | 4 | ProcessObject streamer MovieStreamer 5 | Attribute filename @@file=$TEST_DATA_PATH$/US/sagittal_spine.avi@@ 6 | 7 | Renderer renderer ImageRenderer 8 | Input 0 streamer 0 9 | 10 | View view renderer 11 | Attribute 2Dmode true 12 | Attribute background-color black -------------------------------------------------------------------------------- /pipelines/neural_network_segmentation.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Neural network segmentation" 2 | PipelineDescription "asd" 3 | 4 | ### Processing chain 5 | 6 | ProcessObject streamer ImageFileStreamer 7 | Attribute fileformat @@fileformat=$TEST_DATA_PATH$/US/JugularVein/US-2D_#.mhd@@ 8 | Attribute loop true 9 | 10 | ProcessObject network SegmentationNetwork 11 | Attribute scale-factor 0.003921568627451 12 | Attribute model @@model=$TEST_DATA_PATH$/NeuralNetworkModels/jugular_vein_segmentation.xml@@ 13 | Input 0 streamer 0 14 | 15 | ### Renderers 16 | 17 | Renderer imgRenderer ImageRenderer 18 | Input 0 streamer 0 19 | 20 | Renderer segRenderer SegmentationRenderer 21 | Attribute opacity 0.2 22 | Attribute label-colors "1" "red" "2" "blue" 23 | Input 0 network 0 24 | 25 | ### Views 26 | 27 | View view1 imgRenderer segRenderer 28 | Attribute 2Dmode true 29 | Attribute background-color black 30 | -------------------------------------------------------------------------------- /pipelines/openigtlink_image.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "OpenIGTLink streaming of images" 2 | PipelineDescription "Simple 2D image rendering of an OpenIGTLinkStream" 3 | 4 | ProcessObject streamer OpenIGTLinkStreamer 5 | Attribute address localhost 6 | 7 | Renderer renderer ImageRenderer 8 | Input 0 streamer 0 9 | 10 | View view renderer 11 | Attribute 2Dmode true 12 | Attribute background-color black 13 | -------------------------------------------------------------------------------- /pipelines/stream_uff_data_and_enhance.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "UFF Streamer and NLM filtering" 2 | PipelineDescription "asd" 3 | 4 | ### Processing chain 5 | 6 | ProcessObject streamer UFFStreamer 7 | Attribute filename @@filename@@ 8 | Attribute loop true 9 | 10 | ProcessObject filter NonLocalMeans 11 | Attribute smoothing 0.2 12 | Attribute search-size 11 13 | Attribute filter-size 3 14 | Attribute iterations 6 15 | Attribute preprocess false 16 | Input 0 streamer 0 17 | 18 | ProcessObject enhance UltrasoundImageEnhancement 19 | Attribute reject 60 20 | Input 0 filter 0 21 | 22 | ### Renderers 23 | 24 | Renderer renderer1 ImageRenderer 25 | Input 0 streamer 0 26 | 27 | Renderer renderer2 ImageRenderer 28 | Input 0 enhance 0 29 | 30 | ### Views 31 | 32 | View view1 renderer1 33 | Attribute 2Dmode true 34 | Attribute background-color black 35 | 36 | View view2 renderer2 37 | Attribute 2Dmode true 38 | Attribute background-color black 39 | -------------------------------------------------------------------------------- /pipelines/temporal_image_averaging.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "2D Image renderer" 2 | PipelineDescription "Simple 2D image rendering" 3 | 4 | ProcessObject streamer ImageFileStreamer 5 | Attribute fileformat @@fileformat=$TEST_DATA_PATH$/US/Axillary/US-2D_#.mhd@@ 6 | 7 | ProcessObject thresholding BinaryThresholding 8 | Attribute lower-threshold 100 9 | Input 0 streamer 0 10 | 11 | ProcessObject temporalSmoothing ImageWeightedMovingAverage 12 | Attribute frame-count 20 13 | Attribute keep-datatype true 14 | Input 0 thresholding 0 15 | 16 | Renderer renderer ImageRenderer 17 | Attribute level 0.5 18 | Attribute window 1 19 | Input 0 temporalSmoothing 0 20 | 21 | View view renderer 22 | Attribute 2Dmode true 23 | Attribute background-color black 24 | -------------------------------------------------------------------------------- /pipelines/uff_viewer/colormap_and_reject.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Colormap and reject" 2 | PipelineDescription "asd" 3 | 4 | ### Processing chain 5 | 6 | ProcessObject enhance UltrasoundImageEnhancement 7 | Attribute reject 40 8 | Input 0 UFFstream 0 9 | 10 | ### Renderers 11 | 12 | #Renderer renderer1 ImageRenderer 13 | #Input 0 UFFstream 0 14 | 15 | Renderer renderer2 ImageRenderer 16 | Input 0 enhance 0 17 | 18 | ### Views 19 | 20 | #View view1 renderer1 21 | #Attribute 2Dmode true 22 | #Attribute background-color black 23 | 24 | View view2 renderer2 25 | Attribute 2Dmode true 26 | Attribute background-color black 27 | -------------------------------------------------------------------------------- /pipelines/uff_viewer/default.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Default" 2 | PipelineDescription "Only render UFF data" 3 | 4 | Renderer renderer ImageRenderer 5 | Input 0 UFFstream 0 6 | 7 | View view renderer 8 | Attribute 2Dmode true 9 | Attribute background-color black -------------------------------------------------------------------------------- /pipelines/uff_viewer/non_local_means.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "Non Local Means Filtering" 2 | PipelineDescription "asd" 3 | 4 | ### Processing chain 5 | 6 | ProcessObject filter NonLocalMeans 7 | Attribute smoothing 0.2 8 | Attribute search-size 11 9 | Attribute filter-size 3 10 | Attribute iterations 3 11 | Attribute preprocess false 12 | Input 0 UFFstream 0 13 | 14 | ProcessObject enhance UltrasoundImageEnhancement 15 | Attribute reject 40 16 | Input 0 filter 0 17 | 18 | ### Renderers 19 | 20 | Renderer renderer1 ImageRenderer 21 | Input 0 UFFstream 0 22 | 23 | Renderer renderer2 ImageRenderer 24 | Input 0 enhance 0 25 | 26 | ### Views 27 | 28 | View view1 renderer1 29 | Attribute 2Dmode true 30 | Attribute background-color black 31 | 32 | View view2 renderer2 33 | Attribute 2Dmode true 34 | Attribute background-color black 35 | -------------------------------------------------------------------------------- /pipelines/wsi_view.fpl: -------------------------------------------------------------------------------- 1 | PipelineName "View WSI" 2 | PipelineDescription "asd" 3 | 4 | ### Processing chain 5 | 6 | ProcessObject importer WholeSlideImageImporter 7 | Attribute filename $TEST_DATA_PATH$/WSI/CMU-1.svs 8 | 9 | ### Renderers 10 | 11 | Renderer imgRenderer ImagePyramidRenderer 12 | Input 0 importer 0 13 | 14 | ### Views 15 | 16 | View view1 imgRenderer 17 | Attribute 2Dmode true 18 | Attribute background-color white 19 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/AddTransformation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | AddTransformation.cpp 3 | AddTransformation.hpp 4 | SetTransformation.cpp 5 | SetTransformation.hpp 6 | ) 7 | fast_add_process_object(AddTransformation AddTransformation.hpp) 8 | fast_add_process_object(SetTransformation SetTransformation.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/AddTransformation/SetTransformation.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Algorithms/AddTransformation/SetTransformation.hpp" 2 | #include "FAST/SceneGraph.hpp" 3 | #include "FAST/Data/Image.hpp" 4 | 5 | namespace fast { 6 | 7 | SetTransformation::SetTransformation() { 8 | createInputPort(0); 9 | createInputPort(1); 10 | createOutputPort(0); 11 | } 12 | 13 | void SetTransformation::execute() { 14 | auto data = getInputData(0); 15 | auto transform = getInputData(1); 16 | auto dataNode = data->getSceneGraphNode(); 17 | 18 | dataNode->setTransform(transform); 19 | 20 | addOutputData(0, data); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/AddTransformation/SetTransformation.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | #include "FAST/Data/SpatialDataObject.hpp" 5 | 6 | namespace fast { 7 | 8 | /** 9 | * @brief Set transformations to spatial data objects 10 | * 11 | * This class will set the transform for spatial data object. 12 | * 13 | * Inputs: 14 | * - 0: SpatialDataObject - Object to set transform to 15 | * - 1: AffineTransformation - Transform to set 16 | * 17 | * Outputs: 18 | * - 0: SpatialDataObject - Same as input 0 19 | */ 20 | class FAST_EXPORT SetTransformation : public ProcessObject { 21 | FAST_PROCESS_OBJECT(SetTransformation) 22 | public: 23 | /** 24 | * @brief Create instance 25 | * @return instance 26 | */ 27 | FAST_CONSTRUCTOR(SetTransformation); 28 | private: 29 | void execute(); 30 | }; 31 | 32 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/AirwaySegmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | AirwaySegmentation.cpp 3 | AirwaySegmentation.hpp 4 | ) 5 | fast_add_process_object(AirwaySegmentation AirwaySegmentation.hpp) 6 | if(FAST_MODULE_Visualization) 7 | fast_add_test_sources( 8 | airwaySegmentationTests.cpp 9 | ) 10 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/ApplyColormap/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ApplyColormap.cpp 3 | ApplyColormap.hpp 4 | ) 5 | fast_add_process_object(ApplyColormap ApplyColormap.hpp) 6 | fast_add_test_sources(Tests.cpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/BinaryThresholding/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | BinaryThresholding.cpp 3 | BinaryThresholding.hpp 4 | ) 5 | fast_add_process_object(BinaryThresholding BinaryThresholding.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/BlockMatching/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(BlockMatching.hpp BlockMatching.cpp) 2 | fast_add_process_object(BlockMatching BlockMatching.hpp) 3 | fast_add_test_sources(Tests.cpp) 4 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_all_subdirectories() 2 | fast_add_test_sources() 3 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/CenterlineExtraction/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | CenterlineExtraction.cpp 3 | CenterlineExtraction.hpp 4 | ) 5 | fast_add_process_object(CenterlineExtraction CenterlineExtraction.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/CoherentPointDrift/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | CoherentPointDrift.cpp 3 | CoherentPointDrift.hpp 4 | Rigid.cpp 5 | Rigid.hpp 6 | Affine.cpp 7 | Affine.hpp 8 | ) 9 | fast_add_test_sources(Tests.cpp) 10 | fast_add_python_interfaces(CoherentPointDrift.hpp) 11 | fast_add_python_shared_pointers(CoherentPointDrift) 12 | fast_add_process_object(CoherentPointDriftAffine Affine.hpp) 13 | fast_add_process_object(CoherentPointDriftRigid Rigid.hpp) 14 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/CoherentPointDrift/CoherentPointDrift.cl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/smistad/FAST/1f616da06c7e529b75a9b2fb3f02ede2fe415828/source/FAST/Algorithms/CoherentPointDrift/CoherentPointDrift.cl -------------------------------------------------------------------------------- /source/FAST/Algorithms/Color/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | GrayscaleToColor.cpp 3 | GrayscaleToColor.hpp 4 | ColorToGrayscale.cpp 5 | ColorToGrayscale.hpp 6 | ) 7 | fast_add_process_object(GrayscaleToColor GrayscaleToColor.hpp) 8 | fast_add_process_object(ColorToGrayscale ColorToGrayscale.hpp) 9 | fast_add_test_sources( 10 | ColorToGrayscaleTests.cpp 11 | GrayscaleToColorTests.cpp 12 | ) 13 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Color/ColorToGrayscale.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | class FAST_EXPORT ColorToGrayscale : public ProcessObject { 8 | FAST_PROCESS_OBJECT(ColorToGrayscale) 9 | public: 10 | FAST_CONSTRUCTOR(ColorToGrayscale) 11 | protected: 12 | void execute() override; 13 | }; 14 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Color/ColorToGrayscaleTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "ColorToGrayscale.hpp" 3 | #include 4 | #include 5 | 6 | using namespace fast; 7 | 8 | TEST_CASE("Color to grayscale", "[fast][ColorToGrayscale]") { 9 | auto importer = ImageFileImporter::create(Config::getTestDataPath() + "US/Heart/ApicalFourChamber/US-2D_0.mhd"); 10 | auto input = importer->runAndGetOutputData(); 11 | 12 | { 13 | auto converter = ColorToGrayscale::create()->connect(input); 14 | auto output = converter->runAndGetOutputData(); 15 | REQUIRE(output->getNrOfChannels() == 1); 16 | REQUIRE(output->getWidth() == input->getWidth()); 17 | REQUIRE(output->getHeight() == input->getHeight()); 18 | REQUIRE(output->getDataType() == input->getDataType()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Color/GrayscaleToColor.cl: -------------------------------------------------------------------------------- 1 | __const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE; 2 | 3 | __kernel void convert( 4 | __read_only image2d_t input, 5 | __write_only image2d_t output 6 | ) { 7 | const int2 pos = {get_global_id(0), get_global_id(1)}; 8 | int dataType = get_image_channel_data_type(input); 9 | if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) { 10 | uint value = read_imageui(input, sampler, pos).x; 11 | write_imageui(output, pos, (uint4)(value, value, value, 255)); 12 | } else if(dataType == CLK_FLOAT) { 13 | float value = read_imagef(input, sampler, pos).x; 14 | write_imagef(output, pos, (float4)(value, value, value, 1.0f)); 15 | } else { 16 | int value = read_imagei(input, sampler, pos).x; 17 | write_imagei(output, pos, (int4)(value, value, value, 1)); 18 | } 19 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Color/GrayscaleToColor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | class FAST_EXPORT GrayscaleToColor : public ProcessObject { 7 | FAST_PROCESS_OBJECT(GrayscaleToColor) 8 | public: 9 | FAST_CONSTRUCTOR(GrayscaleToColor, bool, addAlphaChannel, = false) 10 | protected: 11 | void execute() override; 12 | 13 | bool m_addAlphaChannel = false; 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Compression/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources( 3 | JPEGCompression.cpp 4 | JPEGCompression.hpp 5 | JPEGXLCompression.cpp 6 | JPEGXLCompression.hpp 7 | ) 8 | endif() 9 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Compression/JPEGCompression.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Class for JPEG image compression 9 | * 10 | * Only supports 8 bit RGB images for now. 11 | */ 12 | class JPEGCompression { 13 | public: 14 | JPEGCompression(); 15 | void compress(void* data, int width, int height, std::vector* compressedData, int quality = 90); 16 | /** 17 | * @brief Decompress 18 | * @param compressedData 19 | * @param bytes 20 | * @param widthOut 21 | * @param heightOut 22 | * @param outputBuffer if nullptr this buffer will be used to store data 23 | * @return decompressed data 24 | */ 25 | void* decompress(uchar* compressedData, std::size_t bytes, int* widthOut, int* heightOut, uchar* outputBuffer = nullptr); 26 | 27 | }; 28 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Compression/JPEGXLCompression.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Class for JPEG XL image compression 9 | * 10 | * Only supports 8 bit RGB images for now. 11 | */ 12 | class JPEGXLCompression { 13 | public: 14 | JPEGXLCompression(); 15 | void compress(void* data, int width, int height, std::vector* compressedData, int quality = 90); 16 | /** 17 | * @brief Decompress 18 | * @param compressedData 19 | * @param bytes 20 | * @param widthOut 21 | * @param heightOut 22 | * @param outputBuffer if nullptr this buffer will be used to store data 23 | * @return decompressed data 24 | */ 25 | void* decompress(uchar* compressedData, std::size_t bytes, int* widthOut, int* heightOut, uchar* outputBuffer = nullptr); 26 | 27 | }; 28 | } 29 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/GaussianSmoothing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | GaussianSmoothing.cpp 3 | GaussianSmoothing.hpp 4 | ) 5 | fast_add_test_sources( 6 | GaussianSmoothingTests.cpp 7 | ) 8 | fast_add_process_object(GaussianSmoothing GaussianSmoothing.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/GradientVectorFlow/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | EulerGradientVectorFlow.cpp 3 | EulerGradientVectorFlow.hpp 4 | MultigridGradientVectorFlow.cpp 5 | MultigridGradientVectorFlow.hpp 6 | ) 7 | fast_add_test_sources( 8 | GradientVectorFlowTests.cpp 9 | ) 10 | fast_add_process_object(EulerGradientVectorFlow EulerGradientVectorFlow.hpp) 11 | fast_add_process_object(MultigridGradientVectorFlow MultigridGradientVectorFlow.hpp) 12 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/HounsefieldConverter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | HounsefieldConverter.cpp 3 | HounsefieldConverter.hpp 4 | ) 5 | fast_add_process_object(HounsefieldConverter HounsefieldConverter.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/HounsefieldConverter/HounsefieldConverter.cl: -------------------------------------------------------------------------------- 1 | __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; 2 | 3 | #define LPOS(pos) pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1) 4 | 5 | __kernel void convertToHU( 6 | __read_only image3d_t input, 7 | #ifdef fast_3d_image_writes 8 | __write_only image3d_t output 9 | #else 10 | __global short* output 11 | #endif 12 | ) { 13 | const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0}; 14 | 15 | int value = read_imageui(input, sampler, pos).x; 16 | value -= 1024; 17 | #ifdef fast_3d_image_writes 18 | write_imagei(output, pos, value); 19 | #else 20 | output[LPOS(pos)] = value; 21 | #endif 22 | } 23 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageAdd/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageAdd.cpp 3 | ImageAdd.hpp 4 | ) 5 | fast_add_process_object(ImageAdd ImageAdd.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageAdd/ImageAdd.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Add two images 9 | */ 10 | class FAST_EXPORT ImageAdd: public ProcessObject { 11 | FAST_PROCESS_OBJECT(ImageAdd) 12 | public: 13 | /** 14 | * @brief Create instance 15 | * @return instance 16 | */ 17 | FAST_CONSTRUCTOR(ImageAdd); 18 | private: 19 | void execute(); 20 | }; 21 | 22 | } 23 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageCaster/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageCaster.cpp 3 | ImageCaster.hpp 4 | ) 5 | fast_add_process_object(ImageCaster ImageCaster.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageCaster/ImageCaster.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Cast image to another data type 9 | * 10 | * @ingroup filter 11 | */ 12 | class FAST_EXPORT ImageCaster : public ProcessObject { 13 | FAST_PROCESS_OBJECT(ImageCaster) 14 | public: 15 | /** 16 | * @brief Create instance 17 | * @param outputType The data type to cast the input image to 18 | * @param scaleFactor Value to multiply each pixel with when casting to other type 19 | * @return instance 20 | */ 21 | FAST_CONSTRUCTOR(ImageCaster, 22 | DataType, outputType,, 23 | float, scaleFactor, = 1.0f 24 | ) 25 | private: 26 | ImageCaster(); 27 | void execute() override; 28 | float m_scaleFactor; 29 | DataType m_outputType; 30 | }; 31 | 32 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageChannelConverter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageChannelConverter.cpp 3 | ImageChannelConverter.hpp 4 | ) 5 | fast_add_process_object(ImageChannelConverter ImageChannelConverter.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageCropper/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageCropper.cpp 3 | ImageCropper.hpp 4 | ) 5 | fast_add_test_sources(Tests.cpp) 6 | fast_add_process_object(ImageCropper ImageCropper.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageFlipper/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(ImageFlipper.cpp ImageFlipper.hpp) 2 | fast_add_test_sources(Tests.cpp) 3 | fast_add_process_object(ImageFlipper ImageFlipper.hpp) 4 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageGradient/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageGradient.cpp 3 | ImageGradient.hpp 4 | ) 5 | fast_add_test_sources( 6 | ImageGradientTests.cpp 7 | ) 8 | fast_add_process_object(ImageGradient ImageGradient.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageGradient/ImageGradientTests.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Testing.hpp" 2 | #include "FAST/Algorithms/ImageGradient/ImageGradient.hpp" 3 | #include "FAST/Importers/MetaImageImporter.hpp" 4 | 5 | using namespace fast; 6 | 7 | TEST_CASE("Run ImageGradient on 2D image and OpenCL device", "[fast][ImageGradient]") { 8 | auto importer = MetaImageImporter::create(Config::getTestDataPath() + "US/CarotidArtery/Right/US-2D_0.mhd"); 9 | auto gradientFilter = ImageGradient::create()->connect(importer); 10 | CHECK_NOTHROW(gradientFilter->update()); 11 | } 12 | 13 | TEST_CASE("Run ImageGradient on 2D image and OpenCL device 16 bit", "[fast][ImageGradient]") { 14 | auto importer = MetaImageImporter::create(Config::getTestDataPath() + "US/CarotidArtery/Right/US-2D_0.mhd"); 15 | auto gradientFilter = ImageGradient::create(true)->connect(importer); 16 | CHECK_NOTHROW(gradientFilter->update()); 17 | } 18 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageInverter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageInverter.cpp 3 | ImageInverter.hpp 4 | ) 5 | fast_add_process_object(ImageInverter ImageInverter.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageInverter/ImageInverter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Invert the intensity of an image 9 | */ 10 | class FAST_EXPORT ImageInverter : public ProcessObject { 11 | FAST_PROCESS_OBJECT(ImageInverter) 12 | public: 13 | /** 14 | * @brief Create instance 15 | * @return instance 16 | */ 17 | FAST_CONSTRUCTOR(ImageInverter); 18 | private: 19 | void execute(); 20 | }; 21 | 22 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageMultiply/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageMultiply.cpp 3 | ImageMultiply.hpp 4 | ) 5 | fast_add_process_object(ImageMultiply ImageMultiply.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageMultiply/ImageMultiply.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Multiply two images 9 | */ 10 | class FAST_EXPORT ImageMultiply : public ProcessObject { 11 | FAST_PROCESS_OBJECT(ImageMultiply) 12 | public: 13 | /** 14 | * @brief Create instance 15 | * @return instance 16 | */ 17 | FAST_CONSTRUCTOR(ImageMultiply); 18 | private: 19 | void execute(); 20 | }; 21 | 22 | } 23 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImagePatch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources( 3 | PatchGenerator.cpp 4 | PatchGenerator.hpp 5 | ImageToBatchGenerator.cpp 6 | ImageToBatchGenerator.hpp 7 | PatchStitcher.cpp 8 | PatchStitcher.hpp 9 | ) 10 | fast_add_test_sources( 11 | Tests.cpp 12 | ) 13 | fast_add_process_object(PatchGenerator PatchGenerator.hpp) 14 | fast_add_process_object(PatchStitcher PatchStitcher.hpp) 15 | fast_add_process_object(ImageToBatchGenerator ImageToBatchGenerator.hpp) 16 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImagePyramidLevelExtractor/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources(ImagePyramidLevelExtractor.cpp ImagePyramidLevelExtractor.hpp) 3 | fast_add_test_sources(Tests.cpp) 4 | fast_add_process_object(ImagePyramidLevelExtractor ImagePyramidLevelExtractor.hpp) 5 | endif() 6 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImagePyramidLevelExtractor/Tests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "ImagePyramidLevelExtractor.hpp" 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace fast; 8 | 9 | TEST_CASE("Image pyramid level extractor", "[fast][ImagePyramidLevelExtractor]") { 10 | auto importer = WholeSlideImageImporter::create(Config::getTestDataPath() + "/WSI/CMU-1.svs"); 11 | auto pyramid = importer->runAndGetOutputData(); 12 | 13 | auto extractor = ImagePyramidLevelExtractor::create(-1)->connect(pyramid); 14 | auto level = extractor->runAndGetOutputData(); 15 | 16 | CHECK(pyramid->getLevelWidth(-1) == level->getWidth()); 17 | CHECK(pyramid->getLevelHeight(-1) == level->getHeight()); 18 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageResampler/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageResampler.cpp 3 | ImageResampler.hpp 4 | IsotropicResampler.cpp 5 | IsotropicResampler.hpp 6 | ) 7 | if(FAST_MODULE_Visualization) 8 | fast_add_test_sources( 9 | ImageResamplerTests.cpp 10 | IsotropicResamplerTests.cpp 11 | ) 12 | endif() 13 | fast_add_process_object(ImageResampler ImageResampler.hpp) 14 | fast_add_process_object(IsotropicResampler IsotropicResampler.hpp) 15 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageResizer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageResizer.cpp 3 | ImageResizer.hpp 4 | ) 5 | fast_add_test_sources( 6 | Tests.cpp 7 | ) 8 | fast_add_process_object(ImageResizer ImageResizer.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageSharpening/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageSharpening.hpp 3 | ImageSharpening.cpp 4 | ) 5 | fast_add_process_object(ImageSharpening ImageSharpening.hpp) 6 | if(FAST_MODULE_WholeSlideImaging) 7 | fast_add_test_sources(Tests.cpp) 8 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageSlicer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageSlicer.cpp 3 | ImageSlicer.hpp 4 | ) 5 | fast_add_process_object(ImageSlicer ImageSlicer.hpp) 6 | if(FAST_MODULE_Visualization) 7 | fast_add_test_sources( 8 | ImageSlicerTests.cpp 9 | ) 10 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageTransposer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(ImageTransposer.cpp ImageTransposer.hpp) 2 | fast_add_test_sources(Tests.cpp) 3 | fast_add_process_object(ImageTransposer ImageTransposer.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageTransposer/ImageTransposer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Transpose images 9 | * 10 | * Inputs: 11 | * - 0: Image 12 | * 13 | * Outputs: 14 | * - 0: Image transposed 15 | * 16 | * @ingroup filter 17 | */ 18 | class FAST_EXPORT ImageTransposer : public ProcessObject { 19 | FAST_PROCESS_OBJECT(ImageTransposer) 20 | public: 21 | /** 22 | * @brief Create instance 23 | * @param axes Specify axes to swap for 3D images. If not supplied, X and Y will be transposed. 24 | * @return instance 25 | */ 26 | FAST_CONSTRUCTOR(ImageTransposer, std::vector, axes, = std::vector()) 27 | void setAxes(std::vector axes); 28 | void loadAttributes() override; 29 | private: 30 | void execute() override; 31 | 32 | std::vector m_axes; 33 | }; 34 | 35 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/ImageTransposer/ImageTransposer2D.cl: -------------------------------------------------------------------------------- 1 | const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE; 2 | 3 | __kernel void transpose2D( 4 | __read_only image2d_t input, 5 | __write_only image2d_t output 6 | ) { 7 | const int2 pos = {get_global_id(0), get_global_id(1)}; 8 | int dataType = get_image_channel_data_type(input); 9 | if(dataType == CLK_FLOAT) { 10 | write_imagef(output, pos.yx, read_imagef(input, sampler, pos)); 11 | } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) { 12 | write_imageui(output, pos.yx, read_imageui(input, sampler, pos)); 13 | } else { 14 | write_imagei(output, pos.yx, read_imagei(input, sampler, pos)); 15 | } 16 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/IntensityClipping/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | IntensityClipping.cpp 3 | IntensityClipping.hpp 4 | ) 5 | fast_add_process_object(IntensityClipping IntensityClipping.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/IntensityClipping/IntensityClipping2D.cl: -------------------------------------------------------------------------------- 1 | __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; 2 | 3 | __kernel void clip2D( 4 | __read_only image2d_t input, 5 | __write_only image2d_t output, 6 | __private float min, 7 | __private float max 8 | ) { 9 | const int2 pos = {get_global_id(0), get_global_id(1)}; 10 | const int dataType = get_image_channel_data_type(input); 11 | 12 | if(dataType == CLK_FLOAT) { 13 | write_imagef(output, pos, clamp(read_imagef(input, sampler, pos), min, max)); 14 | } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) { 15 | write_imageui(output, pos, clamp(read_imageui(input, sampler, pos), (uint)min, (uint)max)); 16 | } else { 17 | write_imagei(output, pos, clamp(read_imagei(input, sampler, pos), (int)min, (int)max)); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/IntensityNormalization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | IntensityNormalization.cpp 3 | IntensityNormalization.hpp 4 | ZeroMeanUnitVariance.cpp 5 | ZeroMeanUnitVariance.hpp 6 | ) 7 | fast_add_process_object(IntensityNormalization IntensityNormalization.hpp) 8 | fast_add_process_object(ZeroMeanUnitVariance ZeroMeanUnitVariance.hpp) 9 | fast_add_test_sources( 10 | IntensityNormalizationTests.cpp 11 | ) 12 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/IntensityNormalization/ZeroMeanUnitVariance.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Normalize intensities of an image to have zero mean and unit variance 9 | * 10 | * This process object will scale the pixel values so that the resulting image 11 | * has a zero mean and unit variance. 12 | * This achieved by doing (image - mean(image)) / std(image) 13 | * 14 | * Inputs: 15 | * - 0: Image 16 | * 17 | * Outputs: 18 | * - 0: Image float 19 | * 20 | * @ingroup filter 21 | */ 22 | class FAST_EXPORT ZeroMeanUnitVariance : public ProcessObject { 23 | FAST_PROCESS_OBJECT(ZeroMeanUnitVariance) 24 | public: 25 | /** 26 | * @brief Create instance 27 | * @return instance 28 | */ 29 | FAST_CONSTRUCTOR(ZeroMeanUnitVariance) 30 | private: 31 | void execute() override; 32 | }; 33 | 34 | } 35 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Interleave/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | Interleave.cpp 3 | Interleave.hpp 4 | ) 5 | fast_add_test_sources(Tests.cpp) 6 | fast_add_process_object(Interleave Interleave.hpp) 7 | fast_add_process_object(InterleavePlayback Interleave.hpp) 8 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/IterativeClosestPoint/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | IterativeClosestPoint.cpp 3 | IterativeClosestPoint.hpp 4 | ) 5 | fast_add_test_sources( 6 | IterativeClosestPointTests.cpp 7 | ) 8 | fast_add_process_object(IterativeClosestPoint IterativeClosestPoint.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/AppearanceModel.hpp: -------------------------------------------------------------------------------- 1 | #ifndef APPEARANCE_MODEL_HPP 2 | #define APPEARANCE_MODEL_HPP 3 | 4 | #include "FAST/Data/DataTypes.hpp" 5 | #include "Shape.hpp" 6 | 7 | namespace fast { 8 | 9 | class Image; 10 | 11 | class FAST_EXPORT Measurement { 12 | public: 13 | float displacement; 14 | float uncertainty; 15 | }; 16 | 17 | /** 18 | * This is a base class for appearance models. 19 | * These classes model of an object appears in an image. 20 | * They are used by the Kalman filter to collect measurements. 21 | */ 22 | class FAST_EXPORT AppearanceModel : public Object { 23 | public: 24 | typedef std::shared_ptr pointer; 25 | virtual std::vector getMeasurements(std::shared_ptr image, std::shared_ptr shape, ExecutionDevice::pointer device) = 0; 26 | 27 | 28 | }; 29 | 30 | } 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/AppearanceModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_all_subdirectories() -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/AppearanceModels/RidgeEdge/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | RidgeEdgeModel.cpp 3 | RidgeEdgeModel.hpp 4 | ) 5 | fast_add_python_interfaces(RidgeEdgeModel.hpp) 6 | fast_add_python_shared_pointers(RidgeEdgeModel) -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/AppearanceModels/StepEdge/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | StepEdgeModel.cpp 3 | StepEdgeModel.hpp 4 | ) 5 | fast_add_python_interfaces(StepEdgeModel.hpp) 6 | fast_add_python_shared_pointers(StepEdgeModel) -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | KalmanFilterModelSegmentation.cpp 3 | KalmanFilterModelSegmentation.hpp 4 | AppearanceModel.hpp 5 | ShapeModel.hpp 6 | Shape.cpp 7 | Shape.hpp 8 | ) 9 | fast_add_python_interfaces(KalmanFilterModelSegmentation.hpp AppearanceModel.hpp ShapeModel.hpp Shape.hpp) 10 | fast_add_python_shared_pointers(KalmanFilterModelSegmentation AppearanceModel ShapeModel Shape) 11 | if(FAST_MODULE_Visualization) 12 | fast_add_test_sources( 13 | Tests.cpp 14 | ) 15 | endif() 16 | #fast_add_example(exportLVmeshes exportLVmeshes.cpp) 17 | #fast_add_example(exportLVmeshes3D exportLVmeshes3D.cpp) 18 | fast_add_all_subdirectories() 19 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/Shape.cpp: -------------------------------------------------------------------------------- 1 | #include "Shape.hpp" 2 | 3 | namespace fast { 4 | 5 | void Shape::setMesh(Mesh::pointer mesh) { 6 | mMesh = mesh; 7 | } 8 | 9 | Mesh::pointer Shape::getMesh() const { 10 | return mMesh; 11 | } 12 | 13 | Vector3f Shape::getCentroid() { 14 | if(!mMesh) 15 | throw Exception("Mesh must be set in Shape before getting centroid"); 16 | 17 | MeshAccess::pointer access = mMesh->getMeshAccess(ACCESS_READ); 18 | Vector3f centroid = Vector3f::Zero(); 19 | for(int i = 0; i < mMesh->getNrOfVertices(); ++i) { 20 | centroid += access->getVertex(i).getPosition(); 21 | } 22 | 23 | centroid /= mMesh->getNrOfVertices(); 24 | return centroid; 25 | } 26 | 27 | Shape::Shape() { 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/Shape.hpp: -------------------------------------------------------------------------------- 1 | #ifndef SHAPE_HPP_ 2 | #define SHAPE_HPP_ 3 | 4 | #include "FAST/Data/Mesh.hpp" 5 | 6 | namespace fast { 7 | 8 | /** 9 | * Class used to represent a mesh shape. 10 | * 11 | */ 12 | class FAST_EXPORT Shape : public Object { 13 | FAST_OBJECT(Shape) 14 | public: 15 | Mesh::pointer getMesh() const; 16 | void setMesh(Mesh::pointer mesh); 17 | Vector3f getCentroid(); 18 | private: 19 | Shape(); 20 | Mesh::pointer mMesh; 21 | }; 22 | 23 | } 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/ShapeModels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_all_subdirectories() -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/ShapeModels/CardinalSpline/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | CardinalSplineModel.cpp 3 | CardinalSplineModel.hpp 4 | ) 5 | fast_add_python_interfaces(CardinalSplineModel.hpp) 6 | fast_add_python_shared_pointers(CardinalSplineModel) -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/ShapeModels/Ellipse/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | EllipseModel.cpp 3 | EllipseModel.hpp 4 | ) 5 | fast_add_python_interfaces(EllipseModel.hpp) 6 | fast_add_python_shared_pointers(EllipseModel) -------------------------------------------------------------------------------- /source/FAST/Algorithms/KalmanFilterModelSegmentation/ShapeModels/MeanValueCoordinates/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | MeanValueCoordinatesModel.hpp 3 | MeanValueCoordinatesModel.cpp 4 | ) 5 | fast_add_python_interfaces(MeanValueCoordinatesModel.hpp) 6 | fast_add_python_shared_pointers(MeanValueCoordinatesModel) -------------------------------------------------------------------------------- /source/FAST/Algorithms/LabelModifier/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | LabelModifier.cpp 3 | LabelModifier.hpp 4 | ) 5 | fast_add_process_object(LabelModifier LabelModifier.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/LabelModifier/LabelModifier.cl: -------------------------------------------------------------------------------- 1 | __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; 2 | 3 | __kernel void modifyLabels( 4 | __read_only image2d_t input, 5 | __write_only image2d_t output, 6 | __global uchar* labelChanges, 7 | __private int count 8 | ) { 9 | 10 | const int2 pos = {get_global_id(0), get_global_id(1)}; 11 | uchar value = read_imageui(input, sampler, pos).x; 12 | uchar newValue = value; 13 | for(int i = 0; i < count-1; ++i) { 14 | if(value == labelChanges[i*2]) { 15 | newValue = labelChanges[i*2+1]; 16 | } 17 | } 18 | 19 | write_imageui(output, pos, newValue); 20 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Lambda/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | RunLambda.cpp 3 | RunLambda.hpp 4 | ) 5 | fast_add_test_sources( 6 | Tests.cpp 7 | ) -------------------------------------------------------------------------------- /source/FAST/Algorithms/LaplacianOfGaussian/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | LaplacianOfGaussian.cpp 3 | LaplacianOfGaussian.hpp 4 | ) 5 | if(FAST_MODULE_Visualization) 6 | fast_add_test_sources( 7 | LaplacianOfGaussianTests.cpp 8 | ) 9 | endif() 10 | fast_add_process_object(LaplacianOfGaussian LaplacianOfGaussian.hpp) 11 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/LevelSet/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | LevelSetSegmentation.cpp 3 | LevelSetSegmentation.hpp 4 | ) 5 | if(FAST_MODULE_Visualization) 6 | fast_add_test_sources( 7 | LevelSetTests.cpp 8 | ) 9 | endif() 10 | fast_add_process_object(LevelSetSegmentation LevelSetSegmentation.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/LungSegmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | LungSegmentation.cpp 3 | LungSegmentation.hpp 4 | ) 5 | fast_add_process_object(LungSegmentation LungSegmentation.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/LungSegmentation/LungSegmentation.cl: -------------------------------------------------------------------------------- 1 | __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; 2 | 3 | #define LPOS(pos) pos.x+pos.y*get_global_size(0)+pos.z*get_global_size(0)*get_global_size(1) 4 | 5 | __kernel void convertToHU( 6 | __read_only image3d_t input, 7 | #ifdef fast_3d_image_writes 8 | __write_only image3d_t output 9 | #else 10 | __global short* output 11 | #endif 12 | ) { 13 | const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0}; 14 | 15 | int value = read_imageui(input, sampler, pos).x; 16 | value -= 1024; 17 | #ifdef fast_3d_image_writes 18 | write_imagei(output, pos, value); 19 | #else 20 | output[LPOS(pos)] = value; 21 | #endif 22 | } 23 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/MeshToSegmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | MeshToSegmentation.cpp 3 | MeshToSegmentation.hpp 4 | ) 5 | if(FAST_MODULE_Visualization) 6 | fast_add_test_sources( 7 | Tests.cpp 8 | ) 9 | endif() 10 | fast_add_process_object(MeshToSegmentation MeshToSegmentation.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/Morphology/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | Dilation.cpp 3 | Dilation.hpp 4 | Erosion.cpp 5 | Erosion.hpp 6 | ) 7 | fast_add_process_object(Dilation Dilation.hpp) 8 | fast_add_process_object(Erosion Erosion.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/Morphology/Dilation.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | /** 7 | * @brief Perform binary dilation with disk structuring element 8 | * 9 | * @ingroup morphology segmentation 10 | */ 11 | class FAST_EXPORT Dilation : public ProcessObject { 12 | FAST_PROCESS_OBJECT(Dilation) 13 | public: 14 | /** 15 | * @brief Create instance 16 | * @param size Size of square dilation structuring element. Default 3: 3x3 17 | * @return instance 18 | */ 19 | FAST_CONSTRUCTOR(Dilation, int, size, = 3) 20 | /** 21 | * Set size of structuring element, must be odd 22 | * @param size 23 | */ 24 | void setStructuringElementSize(int size); 25 | void loadAttributes() override; 26 | private: 27 | void execute() override; 28 | 29 | int mSize; 30 | 31 | }; 32 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Morphology/Erosion.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Perform binary erosion with disk structuring element 9 | * 10 | * @ingroup morphology segmentation 11 | */ 12 | class FAST_EXPORT Erosion : public ProcessObject { 13 | FAST_PROCESS_OBJECT(Erosion) 14 | public: 15 | /** 16 | * @brief Create instance 17 | * @param size Size of square dilation structuring element. Default 3: 3x3 18 | * @return instance 19 | */ 20 | FAST_CONSTRUCTOR(Erosion, int, size, = 3) 21 | /** 22 | * Set size of structuring element, must be odd 23 | * @param size 24 | */ 25 | void setStructuringElementSize(int size); 26 | void loadAttributes() override; 27 | private: 28 | void execute() override; 29 | 30 | int mSize; 31 | 32 | }; 33 | } 34 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/NeuralNetwork/InferenceEngineManager.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief A purely static class to dynamically load inference engines at runtime 9 | */ 10 | class FAST_EXPORT InferenceEngineManager { 11 | public: 12 | static std::vector getEngineList(); 13 | static void loadAll(); 14 | static std::shared_ptr loadEngine(std::string name); 15 | static std::shared_ptr loadBestAvailableEngine(); 16 | static std::shared_ptr loadBestAvailableEngine(ModelFormat modelFormat); 17 | static bool isEngineAvailable(std::string name); 18 | private: 19 | static bool m_loaded; 20 | static std::unordered_map> m_engines; 21 | }; 22 | 23 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/NeuralNetwork/TensorToImage.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Converts a Tensor with shape HxWxC to a FAST Image 9 | * 10 | * @ingroup neural-network 11 | */ 12 | class FAST_EXPORT TensorToImage : public ProcessObject { 13 | FAST_PROCESS_OBJECT(TensorToImage) 14 | public: 15 | /** 16 | * @brief Create instance 17 | * @param channels which channels to extract from tensor. 18 | * If empty all channels are used. Nr of channels has to be <= 4 19 | * @return instance 20 | */ 21 | FAST_CONSTRUCTOR(TensorToImage, std::vector, channels, = std::vector()) 22 | void setChannels(std::vector channels); 23 | void loadAttributes(); 24 | protected: 25 | void execute() override; 26 | std::vector m_channels; 27 | }; 28 | 29 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/NeuralNetwork/VertexTensorToSegmentation.cl: -------------------------------------------------------------------------------- 1 | __const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_FILTER_NEAREST | CLK_ADDRESS_NONE; 2 | 3 | __kernel void writeSegmentation( 4 | __write_only image2d_t current, 5 | __read_only image2d_t new, 6 | int label 7 | ) { 8 | const int2 pos = {get_global_id(0), get_global_id(1)}; 9 | 10 | if(read_imageui(new, sampler, pos).x > 0) { 11 | write_imageui(current, pos, label); 12 | } 13 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/NonLocalMeans/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | NonLocalMeans.cpp 3 | NonLocalMeans.hpp 4 | ) 5 | fast_add_test_sources( 6 | NonLocalMeansTests.cpp 7 | ) 8 | fast_add_process_object(NonLocalMeans NonLocalMeans.hpp) 9 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/NonMaximumSuppression/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | NonMaximumSuppression.cpp 3 | NonMaximumSuppression.hpp 4 | ) 5 | fast_add_process_object(NonMaximumSuppression NonMaximumSuppression.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/RegionProperties/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(RegionProperties.cpp RegionProperties.hpp) 2 | fast_add_process_object(RegionProperties RegionProperties.hpp) 3 | fast_add_test_sources(Tests.cpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/RunUntilFinished/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(RunUntilFinished.cpp RunUntilFinished.hpp) 2 | fast_add_test_sources(Tests.cpp) 3 | fast_add_process_object(RunUntilFinished RunUntilFinished.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/RunUntilFinished/RunUntilFinished.cpp: -------------------------------------------------------------------------------- 1 | #include "RunUntilFinished.hpp" 2 | 3 | namespace fast { 4 | 5 | RunUntilFinished::RunUntilFinished() { 6 | createInputPort(0); 7 | createOutputPort(0); 8 | m_finished = false; 9 | } 10 | 11 | void RunUntilFinished::execute() { 12 | auto parentPO = mInputConnections[0]->getProcessObject(); 13 | if(m_finished) { 14 | return; 15 | } 16 | // TODO this assumes the parent only has 1 output port 17 | DataObject::pointer inputData; 18 | Progress progress(1000); 19 | progress.setText("Running "); 20 | do { 21 | inputData = parentPO->runAndGetOutputData(); 22 | if(inputData->hasFrameData("progress")) 23 | progress.update(round(1000*inputData->getFrameData("progress"))); 24 | } while(!inputData->isLastFrame()); 25 | progress.update(1000); 26 | m_finished = true; 27 | addOutputData(0, inputData); 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/RunUntilFinished/RunUntilFinished.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Calls run on parent PO until output is marked as last frame 9 | * 10 | * This PO is useful when having multi-step processsing and a previous step needs to run on 11 | * a stream of data before it is finished. 12 | * 13 | */ 14 | class FAST_EXPORT RunUntilFinished : public ProcessObject { 15 | FAST_PROCESS_OBJECT(RunUntilFinished) 16 | public: 17 | FAST_CONSTRUCTOR(RunUntilFinished); 18 | private: 19 | void execute() override; 20 | bool m_finished = false; 21 | }; 22 | 23 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/RunUntilFinished/Tests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "RunUntilFinished.hpp" 3 | #include 4 | 5 | using namespace fast; 6 | 7 | TEST_CASE("Run until finished", "[fast][RunUntilFinished]") { 8 | auto streamer = DummyStreamer::New(); 9 | streamer->setTotalFrames(10); 10 | 11 | auto runUntilFinished = RunUntilFinished::create() 12 | ->connect(streamer); 13 | auto data = runUntilFinished->runAndGetOutputData(); 14 | CHECK(data->getID() == 9); 15 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/SeededRegionGrowing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SeededRegionGrowing.cpp 3 | SeededRegionGrowing.hpp 4 | ) 5 | fast_add_process_object(SeededRegionGrowing SeededRegionGrowing.hpp) 6 | fast_add_test_sources( 7 | SeededRegionGrowingTests.cpp 8 | ) -------------------------------------------------------------------------------- /source/FAST/Algorithms/SegmentationVolumeReconstructor/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SegmentationVolumeReconstructor.cpp 3 | SegmentationVolumeReconstructor.hpp 4 | ) 5 | fast_add_process_object(SegmentationVolumeReconstructor SegmentationVolumeReconstructor.hpp) 6 | fast_add_test_sources( 7 | Tests.cpp 8 | ) 9 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/SegmentationVolumeReconstructor/SegmentationVolumeReconstructor.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | class Image; 8 | 9 | /** 10 | * @brief Reconstruct a stream of 2D segmentation images into a 3D segmentation image 11 | * 12 | * @ingroup segmentation 13 | */ 14 | class FAST_EXPORT SegmentationVolumeReconstructor : public ProcessObject { 15 | FAST_PROCESS_OBJECT(SegmentationVolumeReconstructor) 16 | public: 17 | FAST_CONSTRUCTOR(SegmentationVolumeReconstructor) 18 | private: 19 | void execute() override; 20 | 21 | std::shared_ptr m_volume; 22 | }; 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/Skeletonization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | Skeletonization.cpp 3 | Skeletonization.hpp 4 | ) 5 | fast_add_process_object(Skeletonization Skeletonization.hpp) 6 | if(FAST_MODULE_Visualization) 7 | fast_add_test_sources( 8 | SkeletonizationTests.cpp 9 | ) 10 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/Skeletonization/Skeletonization.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Extract the skeleton of 2D segmentation as a 2D image 9 | * 10 | * Inputs: 11 | * - 0: Image segmentation 2D 12 | * 13 | * Outputs: 14 | * - 0: Image Skeleton of input 0 15 | * 16 | * @ingroup segmentation 17 | */ 18 | class FAST_EXPORT Skeletonization : public ProcessObject { 19 | FAST_PROCESS_OBJECT(Skeletonization) 20 | public: 21 | FAST_CONSTRUCTOR(Skeletonization) 22 | private: 23 | void execute(); 24 | }; 25 | 26 | } // end namespace fast 27 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/SurfaceExtraction/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SurfaceExtraction.cpp 3 | SurfaceExtraction.hpp 4 | ) 5 | fast_add_process_object(SurfaceExtraction SurfaceExtraction.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/TemplateMatching/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | TemplateMatching.hpp 3 | TemplateMatching.cpp 4 | ) 5 | fast_add_process_object(TemplateMatching TemplateMatching.hpp) 6 | fast_add_test_sources(Tests.cpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/TemporalSmoothing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageMovingAverage.cpp 3 | ImageMovingAverage.hpp 4 | ImageWeightedMovingAverage.cpp 5 | ImageWeightedMovingAverage.hpp 6 | ) 7 | fast_add_test_sources(Tests.cpp) 8 | fast_add_process_object(ImageWeightedMovingAverage ImageWeightedMovingAverage.hpp) 9 | fast_add_process_object(ImageMovingAverage ImageMovingAverage.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/Timing/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(Timing.hpp Timing.cpp) 2 | fast_add_process_object(StartTimer Timing.hpp) 3 | fast_add_process_object(StopTimer Timing.hpp) 4 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/TissueMicroArrayExtractor/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources(TissueMicroArrayExtractor.hpp TissueMicroArrayExtractor.cpp) 3 | fast_add_process_object(TissueMicroArrayExtractor TissueMicroArrayExtractor.hpp) 4 | fast_add_test_sources(TissueMicroArrayExtractorTests.cpp) 5 | endif() 6 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/TissueSegmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources( 3 | TissueSegmentation.cpp 4 | TissueSegmentation.hpp 5 | ) 6 | fast_add_process_object(TissueSegmentation TissueSegmentation.hpp) 7 | 8 | fast_add_test_sources(Tests.cpp) 9 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/TissueSegmentation/TissueSegmentation.cl: -------------------------------------------------------------------------------- 1 | __constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; 2 | 3 | __kernel void segment( 4 | __read_only image2d_t input, 5 | __write_only image2d_t output, 6 | __private int m_thresh, 7 | __private int m_filterZeros 8 | ) { 9 | const int2 pos = {get_global_id(0), get_global_id(1)}; 10 | float3 color = convert_float4(read_imageui(input, sampler, pos)).xyz; 11 | 12 | uchar result = 0; 13 | if ((!(m_filterZeros && all(color == 0))) && (length(color - (float3)(255, 255, 255)) > m_thresh)) { 14 | result = 1; 15 | } 16 | 17 | write_imageui(output, pos, result); 18 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/TubeSegmentationAndCenterlineExtraction/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | TubeSegmentationAndCenterlineExtraction.cpp 3 | TubeSegmentationAndCenterlineExtraction.hpp 4 | RidgeTraversalCenterlineExtraction.cpp 5 | RidgeTraversalCenterlineExtraction.hpp 6 | # CircleFittingTDF.cpp 7 | # CircleFittingTDF.hpp 8 | # ParallelCenterlineExtraction.cpp 9 | # ParallelCenterlineExtraction.hpp 10 | InverseGradientSegmentation.cpp 11 | InverseGradientSegmentation.hpp 12 | ) 13 | fast_add_process_object(TubeSegmentationAndCenterlineExtraction TubeSegmentationAndCenterlineExtraction.hpp) 14 | if(FAST_MODULE_Visualization) 15 | fast_add_test_sources( 16 | TubeSegmentationAndCenterlineExtractionTests.cpp 17 | ) 18 | endif() -------------------------------------------------------------------------------- /source/FAST/Algorithms/TubeSegmentationAndCenterlineExtraction/InverseGradientSegmentation.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Perform segmentation by following inverse direction of gradient vector field 9 | * 10 | * Used in TubeSegmentationAndCenterlineExtraction 11 | * 12 | */ 13 | class FAST_EXPORT InverseGradientSegmentation : public ProcessObject { 14 | FAST_PROCESS_OBJECT(InverseGradientSegmentation) 15 | public: 16 | FAST_CONSTRUCTOR(InverseGradientSegmentation) 17 | void setCenterlineInputConnection(DataChannel::pointer port); 18 | void setVectorFieldInputConnection(DataChannel::pointer port); 19 | private: 20 | void execute(); 21 | 22 | }; 23 | 24 | } 25 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/TubeSegmentationAndCenterlineExtraction/RidgeTraversalCenterlineExtraction.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | /** 7 | * @brief Extract 3D centerline by following ridge 8 | * 9 | * Used in TubeSegmentationAndCenterlineExtraction 10 | * 11 | */ 12 | class FAST_EXPORT RidgeTraversalCenterlineExtraction : public ProcessObject { 13 | FAST_PROCESS_OBJECT(RidgeTraversalCenterlineExtraction) 14 | public: 15 | FAST_CONSTRUCTOR(RidgeTraversalCenterlineExtraction) 16 | private: 17 | void execute(); 18 | }; 19 | 20 | } 21 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/Ultrasound/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | EnvelopeAndLogCompressor.cpp 3 | EnvelopeAndLogCompressor.hpp 4 | ScanConverter.cpp 5 | ScanConverter.hpp 6 | ) 7 | fast_add_process_object(EnvelopeAndLogCompressor EnvelopeAndLogCompressor.hpp) 8 | fast_add_process_object(ScanConverter ScanConverter.hpp) 9 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/UltrasoundImageCropper/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | UltrasoundImageCropper.cpp 3 | UltrasoundImageCropper.hpp 4 | ) 5 | fast_add_process_object(UltrasoundImageCropper UltrasoundImageCropper.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/UltrasoundImageEnhancement/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | UltrasoundImageEnhancement.cpp 3 | UltrasoundImageEnhancement.hpp 4 | ) 5 | 6 | fast_add_test_sources( 7 | Tests.cpp 8 | ) 9 | 10 | fast_add_process_object(UltrasoundImageEnhancement UltrasoundImageEnhancement.hpp) 11 | -------------------------------------------------------------------------------- /source/FAST/Algorithms/UltrasoundImageEnhancement/Tests.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Testing.hpp" 2 | #include "UltrasoundImageEnhancement.hpp" 3 | #include "FAST/Streamers/ImageFileStreamer.hpp" 4 | #include "FAST/Visualization/ImageRenderer/ImageRenderer.hpp" 5 | #include "FAST/Visualization/SimpleWindow.hpp" 6 | 7 | namespace fast { 8 | 9 | TEST_CASE("Ultrasound image enhancement", "[fast][ultrasoundimageenhancement][visual]") { 10 | auto streamer = ImageFileStreamer::create(Config::getTestDataPath() + "US/Heart/ApicalFourChamber/US-2D_#.mhd"); 11 | 12 | auto enhancement = UltrasoundImageEnhancement::create()->connect(streamer); 13 | 14 | ImageRenderer::pointer renderer = ImageRenderer::New(); 15 | renderer->addInputConnection(enhancement->getOutputPort()); 16 | 17 | SimpleWindow::pointer window = SimpleWindow::New(); 18 | window->addRenderer(renderer); 19 | window->set2DMode(); 20 | window->setTimeout(500), 21 | window->start(); 22 | 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/UltrasoundImageEnhancement/UltrasoundImageEnhancement.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Apply a color map and reject on an ultrasound image 9 | * 10 | * Inputs: 11 | * - 0: Image grayscale 12 | * 13 | * Outputs: 14 | * - 0: Image color 15 | * 16 | * @ingroup ultrasound filter 17 | */ 18 | class FAST_EXPORT UltrasoundImageEnhancement : public ProcessObject { 19 | FAST_PROCESS_OBJECT(UltrasoundImageEnhancement) 20 | public: 21 | FAST_CONSTRUCTOR(UltrasoundImageEnhancement, int, reject, = 0); 22 | void loadAttributes(); 23 | void setReject(int value); 24 | private: 25 | void execute(); 26 | 27 | int m_reject; 28 | 29 | }; 30 | 31 | } -------------------------------------------------------------------------------- /source/FAST/Algorithms/VectorMedianFilter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(VectorMedianFilter.cpp VectorMedianFilter.hpp) 2 | fast_add_process_object(VectorMedianFilter VectorMedianFilter.hpp) -------------------------------------------------------------------------------- /source/FAST/Algorithms/VectorMedianFilter/VectorMedianFilter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Apply median filter on vector field to reduce noise 9 | * 10 | * Inputs: 11 | * - 0: Image vector field 12 | * 13 | * Outputs: 14 | * - 0: Image vector field 15 | * 16 | * @ingroup filter 17 | */ 18 | class FAST_EXPORT VectorMedianFilter : public ProcessObject { 19 | FAST_PROCESS_OBJECT(VectorMedianFilter) 20 | public: 21 | FAST_CONSTRUCTOR(VectorMedianFilter, int, size, = 7) 22 | /** 23 | * Set window size of median filter. Must be odd 24 | * @param size 25 | */ 26 | void setWindowSize(int size); 27 | void loadAttributes() override; 28 | private: 29 | void execute() override; 30 | 31 | int m_windowSize = 7; 32 | }; 33 | 34 | } -------------------------------------------------------------------------------- /source/FAST/Data/Access/Access.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef ACCESS_HPP_ 3 | #define ACCESS_HPP_ 4 | 5 | enum accessType {ACCESS_READ, ACCESS_READ_WRITE}; 6 | 7 | 8 | 9 | #endif /* ACCESS_HPP_ */ 10 | -------------------------------------------------------------------------------- /source/FAST/Data/Access/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | Access.hpp 3 | OpenCLBufferAccess.cpp 4 | OpenCLBufferAccess.hpp 5 | OpenCLImageAccess.cpp 6 | OpenCLImageAccess.hpp 7 | ImageAccess.cpp 8 | ImageAccess.hpp 9 | VertexBufferObjectAccess.cpp 10 | VertexBufferObjectAccess.hpp 11 | MeshAccess.cpp 12 | MeshAccess.hpp 13 | MeshOpenCLAccess.cpp 14 | MeshOpenCLAccess.hpp 15 | CameraAccess.cpp 16 | CameraAccess.hpp 17 | TensorAccess.cpp 18 | TensorAccess.hpp 19 | BoundingBoxSetAccess.cpp 20 | BoundingBoxSetAccess.hpp 21 | OpenGLTextureAccess.cpp 22 | OpenGLTextureAccess.hpp 23 | ) 24 | fast_add_python_interfaces(MeshAccess.hpp MeshOpenCLAccess.hpp VertexBufferObjectAccess.hpp TensorAccess.hpp) 25 | if(FAST_MODULE_WholeSlideImaging) 26 | fast_add_sources( 27 | ImagePyramidAccess.cpp 28 | ImagePyramidAccess.hpp 29 | ) 30 | fast_add_python_interfaces(ImagePyramidAccess.hpp) 31 | endif() -------------------------------------------------------------------------------- /source/FAST/Data/Access/CameraAccess.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CAMERA_ACCESS_HPP_ 2 | #define CAMERA_ACCESS_HPP_ 3 | 4 | 5 | #include "FAST/Data/DataTypes.hpp" 6 | 7 | namespace fast { 8 | 9 | class FAST_EXPORT CameraAccess { 10 | public: 11 | CameraAccess(Vector3f* position, Vector3f* upVector, Vector3f* target); 12 | Affine3f getCameraTransformation() const; 13 | Vector3f getTargetPosition() const; 14 | Vector3f getPosition() const; 15 | Vector3f getUpVector() const; 16 | void setTargetPosition(Vector3f position); 17 | void setPosition(Vector3f position); 18 | void setUpVector(Vector3f upVector); 19 | typedef std::unique_ptr pointer; 20 | private: 21 | Vector3f* mPosition; 22 | Vector3f* mUpVector; 23 | Vector3f* mTarget; 24 | }; 25 | 26 | } 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /source/FAST/Data/Access/MeshOpenCLAccess.hpp: -------------------------------------------------------------------------------- 1 | #ifndef MESH_OPENCL_ACCESS_HPP_ 2 | #define MESH_OPENCL_ACCESS_HPP_ 3 | 4 | #include "FAST/OpenCL.hpp" 5 | #include "FAST/Object.hpp" 6 | 7 | 8 | namespace fast { 9 | 10 | class Mesh; 11 | 12 | class FAST_EXPORT MeshOpenCLAccess { 13 | public: 14 | typedef std::unique_ptr pointer; 15 | MeshOpenCLAccess(cl::Buffer* coordinatesBuffer, cl::Buffer* lineBuffer, cl::Buffer* triangleBuffer, std::shared_ptr mesh); 16 | cl::Buffer* getCoordinatesBuffer() const; 17 | cl::Buffer* getLineBuffer() const; 18 | cl::Buffer* getTriangleBuffer() const; 19 | void release(); 20 | ~MeshOpenCLAccess(); 21 | private: 22 | MeshOpenCLAccess(const MeshOpenCLAccess& other); 23 | MeshOpenCLAccess& operator=(const MeshOpenCLAccess& other); 24 | cl::Buffer* mCoordinates; 25 | cl::Buffer* mLineBuffer; 26 | cl::Buffer* mTriangleBuffer; 27 | std::shared_ptr mMesh; 28 | bool mIsDeleted; 29 | }; 30 | 31 | } 32 | 33 | #endif -------------------------------------------------------------------------------- /source/FAST/Data/Access/OpenCLBufferAccess.cpp: -------------------------------------------------------------------------------- 1 | #include "OpenCLBufferAccess.hpp" 2 | #include 3 | #include "FAST/Data/Image.hpp" 4 | #include "FAST/ExecutionDevice.hpp" 5 | 6 | namespace fast { 7 | 8 | cl::Buffer* OpenCLBufferAccess::get() const { 9 | return mBuffer; 10 | } 11 | 12 | OpenCLBufferAccess::OpenCLBufferAccess(cl::Buffer* buffer, std::shared_ptr dataObject) { 13 | // Copy the image 14 | mBuffer = new cl::Buffer(*buffer); 15 | mIsDeleted = false; 16 | mDataObject = dataObject; 17 | } 18 | 19 | void OpenCLBufferAccess::release() { 20 | if(!mIsDeleted) { 21 | delete mBuffer; 22 | mBuffer = nullptr; 23 | mIsDeleted = true; 24 | } 25 | mDataObject->accessFinished(); 26 | } 27 | 28 | OpenCLBufferAccess::~OpenCLBufferAccess() { 29 | if(!mIsDeleted) 30 | release(); 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /source/FAST/Data/Access/OpenCLBufferAccess.hpp: -------------------------------------------------------------------------------- 1 | #ifndef OPENCLBUFFERACCESS_HPP_ 2 | #define OPENCLBUFFERACCESS_HPP_ 3 | 4 | #include "FAST/OpenCL.hpp" 5 | #include "FAST/Object.hpp" 6 | 7 | 8 | namespace fast { 9 | 10 | class OpenCLDevice; 11 | class DataObject; 12 | 13 | class FAST_EXPORT OpenCLBufferAccess { 14 | public: 15 | cl::Buffer* get() const; 16 | OpenCLBufferAccess(cl::Buffer* buffer, std::shared_ptr dataObject); 17 | void release(); 18 | ~OpenCLBufferAccess(); 19 | typedef std::unique_ptr pointer; 20 | private: 21 | OpenCLBufferAccess(const OpenCLBufferAccess& other); 22 | OpenCLBufferAccess& operator=(const OpenCLBufferAccess& other); 23 | cl::Buffer* mBuffer; 24 | bool mIsDeleted; 25 | std::shared_ptr mDataObject; 26 | }; 27 | 28 | } // end namespace fast 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /source/FAST/Data/Access/OpenGLTextureAccess.cpp: -------------------------------------------------------------------------------- 1 | #include "OpenGLTextureAccess.hpp" 2 | #include 3 | 4 | namespace fast { 5 | 6 | uint OpenGLTextureAccess::get() const { 7 | return m_textureID; 8 | } 9 | 10 | OpenGLTextureAccess::OpenGLTextureAccess(uint textureID, std::shared_ptr object) { 11 | m_textureID = textureID; 12 | mImageObject = object; 13 | } 14 | 15 | void OpenGLTextureAccess::release() { 16 | mImageObject->accessFinished(); 17 | } 18 | 19 | OpenGLTextureAccess::~OpenGLTextureAccess() { 20 | release(); 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /source/FAST/Data/Access/OpenGLTextureAccess.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | 7 | namespace fast { 8 | 9 | class Image; 10 | 11 | class FAST_EXPORT OpenGLTextureAccess { 12 | public: 13 | uint get() const; 14 | OpenGLTextureAccess(uint textureID, std::shared_ptr object); 15 | void release(); 16 | ~OpenGLTextureAccess(); 17 | typedef std::unique_ptr pointer; 18 | private: 19 | OpenGLTextureAccess(const OpenGLTextureAccess& other); 20 | OpenGLTextureAccess& operator=(const OpenGLTextureAccess& other); 21 | uint m_textureID; 22 | bool mIsDeleted; 23 | std::shared_ptr mImageObject; 24 | 25 | }; 26 | 27 | } // end namespace fast 28 | -------------------------------------------------------------------------------- /source/FAST/Data/Access/TensorAccess.cpp: -------------------------------------------------------------------------------- 1 | #include "TensorAccess.hpp" 2 | #include 3 | 4 | namespace fast { 5 | 6 | TensorAccess::TensorAccess(float *data, TensorShape shape, std::shared_ptr tensor) { 7 | m_data = data; 8 | m_shape = shape; 9 | m_tensor = tensor; 10 | } 11 | 12 | TensorShape TensorAccess::getShape() const { 13 | return m_shape; 14 | } 15 | 16 | TensorAccess::~TensorAccess() { 17 | release(); 18 | } 19 | 20 | void TensorAccess::release() { 21 | m_tensor->accessFinished(); 22 | } 23 | 24 | float* TensorAccess::getRawData() { 25 | return m_data; 26 | } 27 | 28 | } -------------------------------------------------------------------------------- /source/FAST/Data/Camera.cpp: -------------------------------------------------------------------------------- 1 | #include "Camera.hpp" 2 | 3 | namespace fast { 4 | 5 | 6 | void Camera::create(Vector3f position, Vector3f upVector, 7 | Vector3f target) { 8 | mPosition = position; 9 | mUpVector = upVector; 10 | mTarget = target; 11 | } 12 | 13 | CameraAccess::pointer Camera::getAccess(accessType accessType) { 14 | CameraAccess::pointer accessObject(new CameraAccess(&mPosition, &mUpVector, &mTarget)); 15 | 16 | return accessObject; 17 | } 18 | 19 | Camera::Camera() { 20 | mPosition = Vector3f(0,0,0); 21 | mUpVector = Vector3f(0,0,0); 22 | mTarget = Vector3f(0,0,0); 23 | } 24 | 25 | void Camera::freeAll() { 26 | } 27 | 28 | void Camera::free(ExecutionDevice::pointer device) { 29 | } 30 | 31 | } // end namespace fast 32 | -------------------------------------------------------------------------------- /source/FAST/Data/Camera.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CAMERA_HPP_ 2 | #define CAMERA_HPP_ 3 | 4 | #include "SpatialDataObject.hpp" 5 | #include "FAST/Data/Access/Access.hpp" 6 | #include "FAST/Data/Access/CameraAccess.hpp" 7 | 8 | namespace fast { 9 | 10 | class FAST_EXPORT Camera : public DataObject { 11 | FAST_OBJECT(Camera) 12 | public: 13 | void create(Vector3f position, Vector3f upVector, Vector3f target); 14 | CameraAccess::pointer getAccess(accessType accessType); 15 | ~Camera() {}; 16 | private: 17 | Camera(); 18 | void freeAll(); 19 | void free(ExecutionDevice::pointer device); 20 | 21 | Vector3f mPosition; 22 | Vector3f mUpVector; 23 | Vector3f mTarget; 24 | 25 | }; 26 | 27 | } // end namespace fast 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /source/FAST/Data/Tests/DataObjectTests.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Testing.hpp" 2 | #include "FAST/Tests/DummyObjects.hpp" 3 | #include "FAST/DeviceManager.hpp" 4 | 5 | namespace fast { 6 | 7 | TEST_CASE("Update timestamp on DataObject", "[fast][DataObject]") { 8 | DummyDataObject::pointer data = DummyDataObject::New(); 9 | unsigned long timestamp = data->getTimestamp(); 10 | data->updateModifiedTimestamp(); 11 | 12 | CHECK(timestamp != data->getTimestamp()); 13 | } 14 | 15 | 16 | 17 | }; 18 | -------------------------------------------------------------------------------- /source/FAST/DataChannels/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | DataChannel.cpp 3 | DataChannel.hpp 4 | StaticDataChannel.cpp 5 | StaticDataChannel.hpp 6 | NewestFrameDataChannel.cpp 7 | NewestFrameDataChannel.hpp 8 | QueuedDataChannel.cpp 9 | QueuedDataChannel.hpp 10 | ) 11 | -------------------------------------------------------------------------------- /source/FAST/DataChannels/DataChannel.cpp: -------------------------------------------------------------------------------- 1 | #include "DataChannel.hpp" 2 | 3 | namespace fast { 4 | void DataChannel::stop(std::string errorMessage) { 5 | { 6 | std::lock_guard lock(m_mutex); 7 | m_stop = true; 8 | m_errorMessage = errorMessage; 9 | } 10 | } 11 | 12 | DataChannel::DataChannel() { 13 | m_stop = false; 14 | } 15 | 16 | std::shared_ptr DataChannel::getProcessObject() const { 17 | return m_processObject; 18 | } 19 | 20 | void DataChannel::setProcessObject(std::shared_ptr po) { 21 | m_processObject = po; 22 | } 23 | 24 | template <> 25 | std::shared_ptr DataChannel::getNextFrame() { 26 | return getNextDataFrame(); 27 | } 28 | 29 | } -------------------------------------------------------------------------------- /source/FAST/DataChannels/StaticDataChannel.cpp: -------------------------------------------------------------------------------- 1 | #include "StaticDataChannel.hpp" 2 | 3 | namespace fast { 4 | 5 | DataObject::pointer StaticDataChannel::getNextDataFrame() { 6 | std::unique_lock lock(m_mutex); 7 | 8 | // Block until we get any data or a stop signal 9 | while(getSize() == 0 && !m_stop) { 10 | m_frameConditionVariable.wait(lock); 11 | } 12 | 13 | // If stop is signaled, throw an exception to stop the entire computation thread 14 | if(m_stop) 15 | throw ThreadStopped(); 16 | 17 | DataObject::pointer data = m_frame; 18 | 19 | // For static channels the data is not removed 20 | 21 | return data; 22 | } 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/DataChannels/StaticDataChannel.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace fast { 7 | 8 | /** 9 | * This data channel is used for all POs that are not streamers 10 | */ 11 | class FAST_EXPORT StaticDataChannel : public NewestFrameDataChannel { 12 | FAST_OBJECT(StaticDataChannel) 13 | public: 14 | protected: 15 | DataObject::pointer getNextDataFrame() override; 16 | 17 | }; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /source/FAST/Examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(DataImport) 2 | add_subdirectory(DataExport) 3 | add_subdirectory(Filtering) 4 | add_subdirectory(Segmentation) 5 | add_subdirectory(Registration) 6 | add_subdirectory(Visualization) 7 | add_subdirectory(GUI) 8 | add_subdirectory(Interoperability) 9 | 10 | if(FAST_MODULE_Kinect) 11 | add_subdirectory(Kinect) 12 | endif() 13 | if(FAST_MODULE_RealSense) 14 | add_subdirectory(RealSense) 15 | endif() 16 | -------------------------------------------------------------------------------- /source/FAST/Examples/DataExport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(exportMeshToVTKFile exportMeshToVTKFile.cpp) 2 | fast_add_example(convertVideoToImages convertVideoToImages.cpp) 3 | -------------------------------------------------------------------------------- /source/FAST/Examples/DataImport/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(importImageFromFile importImageFromFile.cpp) 2 | fast_add_example(streamImagesFromDisk streamImagesFromDisk.cpp) 3 | fast_add_example(importTriangleMeshFromFile importTriangleMeshFromFile.cpp) 4 | fast_add_example(importLineMeshFromFile importLineMeshFromFile.cpp) 5 | fast_add_example(importVertexMeshFromFile importVertexMeshFromFile.cpp) 6 | fast_add_example(cameraStreaming cameraStreaming.cpp) 7 | if(FAST_MODULE_RealSense) 8 | fast_add_example(realSenseStreaming realSenseStreaming.cpp) 9 | endif() 10 | if(FAST_MODULE_Clarius) 11 | fast_add_example(clariusStreaming clariusStreaming.cpp) 12 | endif() 13 | if(FAST_MODULE_WholeSlideImaging) 14 | fast_add_example(importWholeSlideImage importWholeSlideImage.cpp) 15 | endif() 16 | if(FAST_MODULE_HDF5) 17 | fast_add_example(streamUFFData streamUFFData.cpp) 18 | endif() 19 | if(FAST_MODULE_OpenIGTLink) 20 | fast_add_example(OpenIGTLinkStreaming OpenIGTLinkStreaming.cpp) 21 | endif() -------------------------------------------------------------------------------- /source/FAST/Examples/DataImport/cameraStreaming.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @example cameraStreaming.cpp 3 | * Stream from a (web) camera connected to your computer 4 | */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace fast; 11 | 12 | int main(int argc, char ** argv) { 13 | CommandLineParser parser("Camera streaming example"); 14 | parser.addVariable("index", "0", "Camera index"); 15 | parser.addOption("grayscale", "Convert incoming camera images to grayscale"); 16 | parser.parse(argc, argv); 17 | 18 | auto streamer = CameraStreamer::create(parser.getOption("grayscale"), parser.get("index")); 19 | 20 | auto renderer = ImageRenderer::create() 21 | ->connect(streamer); 22 | 23 | auto window = SimpleWindow2D::create() 24 | ->connect(renderer); 25 | window->run(); 26 | } -------------------------------------------------------------------------------- /source/FAST/Examples/DataImport/clariusStreaming.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @example clariusStreaming.cpp 3 | */ 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace fast; 10 | 11 | int main(int argc, char**argv) { 12 | CommandLineParser parser("Clarius streaming example"); 13 | parser.addVariable("port", "5828", "Port to use for clarius connection"); 14 | parser.addVariable("ip", "192.168.1.1", "Address to use for clarius connection"); 15 | parser.parse(argc, argv); 16 | 17 | auto streamer = ClariusStreamer::create(parser.get("ip"), parser.get("port")); 18 | 19 | auto renderer = ImageRenderer::create() 20 | ->connect(streamer); 21 | 22 | auto window = SimpleWindow2D::create() 23 | ->connect(renderer); 24 | window->getView()->setAutoUpdateCamera(true); 25 | window->run(); 26 | } -------------------------------------------------------------------------------- /source/FAST/Examples/Filtering/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(gaussianSmoothing gaussianSmoothing.cpp) 2 | fast_add_example(nonLocalMeans nonLocalMeans.cpp) 3 | -------------------------------------------------------------------------------- /source/FAST/Examples/GUI/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(SimpleGUI) -------------------------------------------------------------------------------- /source/FAST/Examples/GUI/SimpleGUI/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(surfaceExtractionGUIExample main.cpp SimpleGUI.hpp SimpleGUI.cpp) -------------------------------------------------------------------------------- /source/FAST/Examples/GUI/SimpleGUI/SimpleGUI.hpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @example SimpleGUI.hpp 3 | */ 4 | #pragma once 5 | 6 | #include "FAST/Visualization/Window.hpp" 7 | #include "FAST/Algorithms/SurfaceExtraction/SurfaceExtraction.hpp" 8 | #include 9 | #include 10 | 11 | namespace fast { 12 | 13 | class SimpleGUI : public Window { 14 | FAST_OBJECT_V4(SimpleGUI) 15 | public: 16 | FAST_CONSTRUCTOR(SimpleGUI) 17 | void updateThreshold(int value); 18 | void updateSmoothingParameter(int value); 19 | private: 20 | 21 | SurfaceExtraction::pointer mSurfaceExtraction; 22 | GaussianSmoothing::pointer mSmoothing; 23 | QLabel* mSmoothingLabel; 24 | QLabel* mThresholdLabel; 25 | }; 26 | 27 | } // end namespace fast 28 | -------------------------------------------------------------------------------- /source/FAST/Examples/GUI/SimpleGUI/main.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @example surfaceExtractionGUIExample.cpp 3 | * An example of a GUI for performing surface extraction from a volume in real-time. 4 | * 5 | * main.cpp: 6 | * @include GUI/SimpleGUI/main.cpp 7 | * SimpleGUI.hpp: 8 | * @include GUI/SimpleGUI/SimpleGUI.hpp 9 | * SimpleGUI.cpp: 10 | * @include GUI/SimpleGUI/SimpleGUI.cpp 11 | */ 12 | #include "SimpleGUI.hpp" 13 | 14 | using namespace fast; 15 | 16 | int main() { 17 | 18 | auto window = SimpleGUI::create(); 19 | #ifdef FAST_CONTINUOUS_INTEGRATION 20 | // This will automatically close the window after 5 seconds, used for CI testing 21 | window->setTimeout(5*1000); 22 | #endif 23 | window->run(); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /source/FAST/Examples/Interoperability/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | #fast_add_example(qtInteroperability qtInteroperability.cpp qtInteroperability.hpp) -------------------------------------------------------------------------------- /source/FAST/Examples/Interoperability/qtInteroperability.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Examples/Interoperability/qtInteroperability.cpp 3 | * 4 | * If you edit this example, please also update the wiki and source code file in the repository. 5 | */ 6 | #include "qtInteroperability.hpp" 7 | 8 | int main(int argc, char** argv) { 9 | 10 | // Create Qt Application 11 | QScopedPointer app(new QApplication(argc, argv)); 12 | 13 | // Create Qt widget 14 | QScopedPointer window(new WindowWidget); 15 | 16 | // Show widget 17 | window->show(); 18 | 19 | // Start application event handling (this call blocks until application is closed) 20 | app->exec(); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /source/FAST/Examples/Python/load_and_display_image.py: -------------------------------------------------------------------------------- 1 | ## @example load_and_display_image.py 2 | # This example simply loads a metaimage (.mhd) and displays it on screen 3 | # @image html images/examples/python/left_ventricle.jpg 4 | import fast 5 | 6 | # This will download the test data needed to run the example 7 | fast.downloadTestDataIfNotExists() 8 | 9 | importer = fast.ImageFileImporter.create(fast.Config.getTestDataPath() + 'US/Heart/ApicalFourChamber/US-2D_0.mhd') 10 | 11 | renderer = fast.ImageRenderer.create().connect(importer) 12 | 13 | window = fast.SimpleWindow2D.create(bgcolor=fast.Color.Black())\ 14 | .connect(renderer)\ 15 | .run() 16 | -------------------------------------------------------------------------------- /source/FAST/Examples/Python/load_and_display_wsi.py: -------------------------------------------------------------------------------- 1 | ## @example load_and_display_wsi.py 2 | # An example of loading a whole slide image (WSI) from disk and rendering it 3 | # using an image pyramid renderer. 4 | # @image html images/examples/python/wsi.jpg 5 | import fast 6 | 7 | fast.downloadTestDataIfNotExists() # This will download the test data needed to run the example 8 | 9 | importer = fast.WholeSlideImageImporter.create(fast.Config.getTestDataPath() + 'WSI/CMU-1.svs') 10 | 11 | renderer = fast.ImagePyramidRenderer.create().connect(importer) 12 | 13 | fast.SimpleWindow2D.create().connect(renderer).run() 14 | -------------------------------------------------------------------------------- /source/FAST/Examples/Python/numpy_image_to_fast.py: -------------------------------------------------------------------------------- 1 | ## @example numpy_image_to_fast.py 2 | # This example demonstrates how a numpy ndarray image can be passed 3 | # on to FAST and visualized using FAST. 4 | import fast 5 | import numpy as np 6 | from PIL import Image 7 | 8 | fast.downloadTestDataIfNotExists() # This will download the test data needed to run the example 9 | 10 | # Open image from file using PIL/pillow and convert to numpy ndarray 11 | numpy_image = np.asarray(Image.open(fast.Config.getTestDataPath() + 'US/US-2D.bmp')) 12 | 13 | # Make FAST image from the numpy ndarray 14 | fast_image = fast.Image.createFromArray(numpy_image) 15 | 16 | # Display using FAST 17 | renderer = fast.ImageRenderer.create().connect(fast_image) 18 | 19 | window = fast.SimpleWindow2D.create().connect(renderer).run() 20 | -------------------------------------------------------------------------------- /source/FAST/Examples/Python/render_to_image.py: -------------------------------------------------------------------------------- 1 | ## @example render_to_image.py 2 | # This example renders an image with FAST, then converts it to an image which is displayed by matplotlib 3 | 4 | import fast 5 | import matplotlib.pyplot as plt 6 | 7 | fast.downloadTestDataIfNotExists() # This will download the test data needed to run the example 8 | 9 | importer = fast.ImageFileImporter.create(fast.Config.getTestDataPath() + 'US/US-2D.jpg') 10 | 11 | segmentation = fast.BinaryThresholding.create(50).connect(importer) 12 | 13 | renderer = fast.ImageRenderer.create().connect(importer) 14 | 15 | segmentationRenderer = fast.SegmentationRenderer.create(opacity=0.1, borderOpacity=0.9) \ 16 | .connect(segmentation) 17 | 18 | toImage = fast.RenderToImage.create().connect([renderer, segmentationRenderer]) 19 | image = toImage.runAndGetOutputData() 20 | 21 | plt.title('Rendered by FAST!') 22 | plt.imshow(image) 23 | plt.show() -------------------------------------------------------------------------------- /source/FAST/Examples/Python/slicer_window_CT.py: -------------------------------------------------------------------------------- 1 | ## @example slicer_window_CT.py 2 | # This example shows how the SlicerWindow can be used to visualize 3 slice planes of a 3D CT volume along with a segmentation. 3 | # @image html images/examples/python/slicer_window_CT.jpg 4 | import fast 5 | 6 | importer = fast.ImageFileImporter.create(fast.Config.getTestDataPath() + '/CT/CT-Thorax.mhd') 7 | 8 | segmentation = fast.BinaryThresholding.create(150)\ 9 | .connect(importer) 10 | 11 | fast.SlicerWindow.create()\ 12 | .connectImage(importer)\ 13 | .connectSegmentation(segmentation, opacity=0.25, borderOpacity=0.75)\ 14 | .run() -------------------------------------------------------------------------------- /source/FAST/Examples/Python/slicer_window_MRI.py: -------------------------------------------------------------------------------- 1 | ## @example slicer_window_MRI.py 2 | # This example shows how the SlicerWindow can be used to visualize 3 slice planes of a 3D MRI volume along with a segmentation. 3 | # @image html images/examples/python/slicer_window_MRI.jpg 4 | import fast 5 | 6 | importer = fast.ImageFileImporter.create(fast.Config.getTestDataPath() + '/MRI/MR-Abdomen.mhd') 7 | 8 | segmentation = fast.BinaryThresholding.create(600)\ 9 | .connect(importer) 10 | 11 | fast.SlicerWindow.create()\ 12 | .connectImage(importer)\ 13 | .connectSegmentation(segmentation, opacity=0.25, borderOpacity=0.75, colors={1: fast.Color.Red()})\ 14 | .run() -------------------------------------------------------------------------------- /source/FAST/Examples/Python/stream_from_clarius_ultrasound_scanner.py: -------------------------------------------------------------------------------- 1 | ## @example stream_from_clarius_ultrasound_scanner.py 2 | # This example will stream images from a clarius ultrasound scanner, apply a non-local-means filter 3 | # and display it in real-time. Note: Do run this example you have to have: 4 | # * A Clarius ultrasound probe running with the research cast API enabled. 5 | # * Unfreeze the ultrasond probe. 6 | # * Your machine has to be connected to the Clarius probe wifi. 7 | # * If on windows, disable the windows firewall, or add an exception. 8 | import fast 9 | 10 | streamer = fast.ClariusStreamer.create() 11 | 12 | filter = fast.NonLocalMeans.create().connect(streamer) 13 | 14 | renderer = fast.ImageRenderer.create().connect(streamer) 15 | 16 | renderer2 = fast.ImageRenderer.create().connect(filter) 17 | 18 | fast.DualViewWindow2D.create()\ 19 | .connectLeft(renderer)\ 20 | .connectRight(renderer2)\ 21 | .run() -------------------------------------------------------------------------------- /source/FAST/Examples/Python/stream_from_webcamera.py: -------------------------------------------------------------------------------- 1 | ## @example stream_from_webcamera.py 2 | # This example will stream images from your webcamera and run it through a simple edge detection filter (LaplacianOfGaussian) 3 | # and display it in real-time. 4 | import fast 5 | 6 | streamer = fast.CameraStreamer.create() 7 | 8 | filter = fast.LaplacianOfGaussian.create().connect(streamer) 9 | 10 | renderer = fast.ImageRenderer.create().connect(filter) 11 | 12 | window = fast.SimpleWindow2D.create().connect(renderer).run() 13 | -------------------------------------------------------------------------------- /source/FAST/Examples/RealSense/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(realSenseObjectTracking 2 | main.cpp 3 | TrackingGUI.cpp 4 | TrackingGUI.hpp 5 | Tracking.cpp 6 | Tracking.hpp 7 | ) 8 | -------------------------------------------------------------------------------- /source/FAST/Examples/RealSense/main.cpp: -------------------------------------------------------------------------------- 1 | #include "TrackingGUI.hpp" 2 | 3 | using namespace fast; 4 | 5 | int main() { 6 | auto window = TrackingGUI::New(); 7 | window->start(); 8 | } -------------------------------------------------------------------------------- /source/FAST/Examples/Registration/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(iterativeClosestPoint iterativeClosestPoint.cpp) 2 | fast_add_example(coherentPointDrift coherentPointDriftExample.cpp) 3 | fast_add_example(blockMatching blockMatching.cpp) -------------------------------------------------------------------------------- /source/FAST/Examples/Segmentation/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(seededRegionGrowingSegmentation seededRegionGrowingSegmentation.cpp) 2 | fast_add_example(binaryThresholding binaryThresholding.cpp) 3 | fast_add_example(airwaySegmentation airwaySegmentation.cpp) 4 | fast_add_example(lungSegmentation lungSegmentation.cpp) 5 | fast_add_example(liverVesselSegmentation liverVesselSegmentation.cpp) 6 | fast_add_example(convertMeshToSegmentation convertMeshToSegmentation.cpp) 7 | if(FAST_MODULE_WholeSlideImaging) 8 | fast_add_example(neuralNetworkCTSegmentation neuralNetworkCTSegmentation.cpp) 9 | fast_add_example(neuralNetworkWSIClassification neuralNetworkWSIClassification.cpp) 10 | endif() 11 | fast_add_example(neuralNetworkUltrasoundSegmentation neuralNetworkUltrasoundSegmentation.cpp) 12 | -------------------------------------------------------------------------------- /source/FAST/Examples/Visualization/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_example(extractSurfaceAndRender extractSurfaceAndRender.cpp) -------------------------------------------------------------------------------- /source/FAST/Exception.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Exception.hpp" 2 | using namespace fast; 3 | -------------------------------------------------------------------------------- /source/FAST/Exporters/Exporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @defgroup exporters Exporters 9 | * Process objects used to export FAST data to files on disk or other formats. 10 | */ 11 | 12 | /** 13 | * @brief Abstract base class for exporters 14 | * 15 | * @ingroup exporters 16 | */ 17 | class FAST_EXPORT Exporter : public ProcessObject { 18 | 19 | }; 20 | 21 | } -------------------------------------------------------------------------------- /source/FAST/Exporters/FileExporter.cpp: -------------------------------------------------------------------------------- 1 | #include "FileExporter.hpp" 2 | 3 | namespace fast { 4 | 5 | void FileExporter::setFilename(std::string filename) { 6 | #ifdef WIN32 7 | m_filename = replace(filename, "\\", "/"); 8 | #else 9 | m_filename = filename; 10 | #endif 11 | setModified(true); 12 | } 13 | 14 | FileExporter::FileExporter() { 15 | m_filename = ""; 16 | createStringAttribute("filename", "Filename", "Filename to export to", ""); 17 | } 18 | 19 | void FileExporter::loadAttributes() { 20 | setFilename(getStringAttribute("filename")) ; 21 | } 22 | 23 | } -------------------------------------------------------------------------------- /source/FAST/Exporters/FileExporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | /** 7 | * @brief Abstract class for file exporters 8 | */ 9 | class FAST_EXPORT FileExporter : public Exporter { 10 | public: 11 | virtual void setFilename(std::string filename); 12 | void loadAttributes(); 13 | protected: 14 | std::string m_filename; 15 | protected: 16 | FileExporter(); 17 | FileExporter(std::string filename) : FileExporter() { 18 | setFilename(filename); 19 | } 20 | void execute() = 0; 21 | 22 | }; 23 | } 24 | -------------------------------------------------------------------------------- /source/FAST/Exporters/TIFFImagePyramidExporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace fast { 7 | 8 | /** 9 | * @brief Export an ImagePyramid to disk in the tiled pyramid TIFF format. 10 | * 11 | * @ingroup exporter wsi 12 | * @sa TIFFImagePyramidImporter 13 | */ 14 | class FAST_EXPORT TIFFImagePyramidExporter : public FileExporter { 15 | FAST_PROCESS_OBJECT(TIFFImagePyramidExporter) 16 | public: 17 | FAST_CONSTRUCTOR(TIFFImagePyramidExporter, 18 | std::string, filename,, 19 | ImageCompression, compression, = ImageCompression::UNSPECIFIED 20 | ) 21 | void setCompression(ImageCompression compression); 22 | void loadAttributes() override; 23 | protected: 24 | TIFFImagePyramidExporter(); 25 | void execute() override; 26 | 27 | bool m_compressionSet = false; 28 | ImageCompression m_compression; 29 | }; 30 | 31 | } -------------------------------------------------------------------------------- /source/FAST/Exporters/Tests/HDF5TensorExporterTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | namespace fast { 6 | 7 | TEST_CASE("Write tensor as HDF5", "[fast][HDF5TensorExporter][HDF5]") { 8 | TensorShape shape({32, 32, 8}); 9 | auto tensor = Tensor::create(shape); 10 | 11 | auto exporter = HDF5TensorExporter::New(); 12 | exporter->setFilename("tensor.hd5"); 13 | exporter->setInputData(tensor); 14 | exporter->update(); 15 | } 16 | 17 | } -------------------------------------------------------------------------------- /source/FAST/Exporters/VTKImageExporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "FAST/ProcessObject.hpp" 5 | #include "FAST/Data/Image.hpp" 6 | 7 | namespace fast { 8 | 9 | /** 10 | * @brief Export a FAST Image to an VTK image 11 | * 12 | * This can be used to connect a FAST pipeline to an VTK pipeline. 13 | * @warning This class is not included in the release builds. 14 | * 15 | *

Input ports

16 | * 0: Image 17 | * 18 | * @ingroup exporters 19 | */ 20 | class FAST_EXPORT VTKImageExporter : public vtkImageAlgorithm, public ProcessObject { 21 | public: 22 | vtkTypeMacro(VTKImageExporter,vtkImageAlgorithm); 23 | static VTKImageExporter *New(); 24 | std::string getNameOfClass() const { return "VTKImageExporter"; }; 25 | private: 26 | VTKImageExporter(); 27 | int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *); 28 | void execute() {}; 29 | 30 | }; 31 | 32 | } // end namespace fast 33 | -------------------------------------------------------------------------------- /source/FAST/Exporters/VTKMeshExporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include "FAST/ProcessObject.hpp" 5 | 6 | namespace fast { 7 | 8 | /** 9 | * @brief Export a FAST Mesh to an VTK PolyData object 10 | * 11 | * This can be used to connect a FAST pipeline to an VTK pipeline. 12 | * @warning This class is not included in the release builds. 13 | * 14 | *

Input ports

15 | * 0: Mesh 16 | * 17 | * @ingroup exporters 18 | */ 19 | class FAST_EXPORT VTKMeshExporter : public vtkPolyDataAlgorithm, public ProcessObject { 20 | public: 21 | vtkTypeMacro(VTKMeshExporter,vtkPolyDataAlgorithm); 22 | static VTKMeshExporter *New(); 23 | std::string getNameOfClass() const { return "VTKMeshExporter"; }; 24 | private: 25 | VTKMeshExporter(); 26 | int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *); 27 | void execute() {}; 28 | 29 | }; 30 | 31 | } // end namespace fast 32 | -------------------------------------------------------------------------------- /source/FAST/Exporters/VTKMeshFileExporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/Exporters/FileExporter.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Write Mesh to file using the VTK polydata format 9 | * 10 | *

Input ports

11 | * - 0: Mesh 12 | * 13 | * @sa VTKMeshFileImporter 14 | * @ingroup exporters 15 | */ 16 | class FAST_EXPORT VTKMeshFileExporter : public FileExporter { 17 | FAST_PROCESS_OBJECT(VTKMeshFileExporter); 18 | public: 19 | FAST_CONSTRUCTOR(VTKMeshFileExporter, 20 | std::string, filename,, 21 | bool, writeNormals, = false, 22 | bool, writeColors, = false 23 | ) 24 | void setWriteNormals(bool writeNormals); 25 | void setWriteColors(bool writeColors); 26 | private: 27 | VTKMeshFileExporter(); 28 | void execute(); 29 | 30 | bool mWriteNormals; 31 | bool mWriteColors; 32 | }; 33 | 34 | } -------------------------------------------------------------------------------- /source/FAST/Importers/DICOMFileImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace fast { 7 | 8 | /** 9 | * @brief Read DICOM image data (both 2D and 3D). 10 | * 11 | * This importer uses the DCMTK library to load DICOM image data from disk. 12 | * 13 | * @ingroup importers 14 | */ 15 | class FAST_EXPORT DICOMFileImporter : public FileImporter { 16 | FAST_PROCESS_OBJECT(DICOMFileImporter) 17 | public: 18 | FAST_CONSTRUCTOR(DICOMFileImporter, 19 | std::string, filename,, 20 | bool, loadSeries, = true 21 | ) 22 | void setLoadSeries(bool load); 23 | private: 24 | DICOMFileImporter(); 25 | void execute() override; 26 | 27 | bool mLoadSeries = true; 28 | }; 29 | 30 | } 31 | -------------------------------------------------------------------------------- /source/FAST/Importers/ImageImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace fast { 7 | 8 | /** 9 | * @brief Read JPG/PNG/BMP/TIFF images 10 | * 11 | * Uses Qt5 to read and output plain JPG/PNG/BMP/GIF images from disk. 12 | * 13 | * @ingroup importers 14 | */ 15 | class FAST_EXPORT ImageImporter : public FileImporter { 16 | FAST_PROCESS_OBJECT(ImageImporter) 17 | public: 18 | FAST_CONSTRUCTOR(ImageImporter, 19 | std::string, filename,, 20 | bool, grayscale, = false 21 | ) 22 | void setGrayscale(bool grayscale); 23 | void loadAttributes() override; 24 | private: 25 | ImageImporter(); 26 | bool mGrayscale; 27 | void execute() override; 28 | }; 29 | 30 | } // end namespace fast 31 | 32 | 33 | -------------------------------------------------------------------------------- /source/FAST/Importers/ImagePyramidPatchImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Loads an image pyramid from a set of image patches stored in a folder. 9 | * 10 | * Imports an ImagePyramid stored as a set of image patches stored in a folder. 11 | * Each patch is stored as a PNG image with the file name indicating its position and size. 12 | * 13 | * @sa ImagePyramidPatchExporter 14 | * @ingroup importers 15 | */ 16 | class FAST_EXPORT ImagePyramidPatchImporter : public ProcessObject { 17 | FAST_PROCESS_OBJECT(ImagePyramidPatchImporter) 18 | public: 19 | FAST_CONSTRUCTOR(ImagePyramidPatchImporter, std::string, path,) 20 | void setPath(std::string path); 21 | void loadAttributes() override; 22 | private: 23 | ImagePyramidPatchImporter(); 24 | void execute() override; 25 | 26 | std::string m_path; 27 | }; 28 | 29 | } -------------------------------------------------------------------------------- /source/FAST/Importers/Importer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/ProcessObject.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @defgroup importers Importers 9 | * Process objects used to load and output data such as images, tensors and geometry. 10 | */ 11 | 12 | /** 13 | * @brief Abstract base class for @ref importers 14 | * 15 | * @ingroup importers 16 | */ 17 | class FAST_EXPORT Importer : public ProcessObject { 18 | 19 | }; 20 | 21 | } // end namespace fast 22 | 23 | -------------------------------------------------------------------------------- /source/FAST/Importers/MetaImageImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Loads an image stored in the MetaImage format (.mhd/.raw) 9 | * 10 | * This importer loads 2D and 3D images stored in the MetaImage format which are pairs of .mhd text files and .raw files 11 | * contain the raw pixel data. 12 | * It supports the compressed .zraw format as well using zlib. 13 | * It also loads all meta data stored in the .mhd text file which can be retrived by Image::getMetaData 14 | * 15 | * @ingroup importers 16 | */ 17 | class FAST_EXPORT MetaImageImporter : public FileImporter { 18 | FAST_PROCESS_OBJECT(MetaImageImporter) 19 | public: 20 | FAST_CONSTRUCTOR(MetaImageImporter, std::string, filename,) 21 | private: 22 | MetaImageImporter(); 23 | void execute(); 24 | }; 25 | 26 | } // end namespace fast 27 | -------------------------------------------------------------------------------- /source/FAST/Importers/NIFTIImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Import NIfTI image files 9 | * 10 | * Supports reading both compressed (.nii.gz) and uncompressed (.nii) NIFTI files. 11 | * Supports version 1 and 2 of the NIFTI format. 12 | * 13 | * Outputs: 14 | * - 0: Image 15 | * 16 | * @todo Read orientation information 17 | * 18 | * @ingroup importers 19 | */ 20 | class FAST_EXPORT NIFTIImporter : public FileImporter { 21 | FAST_PROCESS_OBJECT(NIFTIImporter) 22 | public: 23 | FAST_CONSTRUCTOR(NIFTIImporter, std::string, filename,) 24 | protected: 25 | NIFTIImporter(); 26 | void execute(); 27 | 28 | 29 | }; 30 | } -------------------------------------------------------------------------------- /source/FAST/Importers/TIFFImagePyramidImporter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Import image Pyramid stored as tiled multi-page TIFF 9 | * 10 | * This TIFFImagePyramidImporter is best used for important single channel 11 | * image pyramids such as high-res segmentations. 12 | * For instance if exported using the TIFFImagePyramidExporter. 13 | * This exporter uses libtiff. 14 | * 15 | * Outputs: 16 | * - 0: ImagePyramid 17 | * 18 | * @sa WholeSlideImageImporter TIFFImagePyramidExporter 19 | * @ingroup importers 20 | */ 21 | class FAST_EXPORT TIFFImagePyramidImporter : public FileImporter { 22 | FAST_PROCESS_OBJECT(TIFFImagePyramidImporter) 23 | public: 24 | FAST_CONSTRUCTOR(TIFFImagePyramidImporter, std::string, filename,) 25 | void loadAttributes() override; 26 | private: 27 | TIFFImagePyramidImporter(); 28 | void execute() override; 29 | }; 30 | 31 | } -------------------------------------------------------------------------------- /source/FAST/Importers/Tests/HDF5TensorImporterTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace fast; 7 | 8 | TEST_CASE("HDF5TensorImporter", "[fast][HDF5][HDF5TensorImporter]") { 9 | // Export a file first 10 | TensorShape shape({2, 32, 32, 8}); 11 | auto tensor = Tensor::create(shape); 12 | 13 | auto exporter = HDF5TensorExporter::New(); 14 | exporter->setFilename("tensor.hd5"); 15 | exporter->setInputData(tensor); 16 | exporter->update(); 17 | 18 | auto importer = HDF5TensorImporter::New(); 19 | importer->setFilename("tensor.hd5"); 20 | importer->setDatasetName("tensor"); 21 | auto resultTensor = importer->updateAndGetOutputData(); 22 | auto resultShape = resultTensor->getShape(); 23 | CHECK(resultShape[0] == 2); 24 | CHECK(resultShape[1] == 32); 25 | CHECK(resultShape[2] == 32); 26 | CHECK(resultShape[3] == 8); 27 | 28 | } -------------------------------------------------------------------------------- /source/FAST/Importers/Tests/ImageFileImporterTests.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Testing.hpp" 2 | #include "FAST/Importers/ImageFileImporter.hpp" 3 | 4 | using namespace fast; 5 | 6 | TEST_CASE("ImageFileImporter MetaImage", "[fast][ImageFileImporter]") { 7 | ImageFileImporter::pointer importer = ImageFileImporter::New(); 8 | importer->setFilename(Config::getTestDataPath()+"US/CarotidArtery/Right/US-2D_0.mhd"); 9 | CHECK_NOTHROW(importer->update()); 10 | } 11 | 12 | #ifdef FAST_MODULE_VISUALIZATION 13 | TEST_CASE("ImageFileImporter JPG", "[fast][ImageFileImporter]") { 14 | ImageFileImporter::pointer importer = ImageFileImporter::New(); 15 | importer->setFilename(Config::getTestDataPath()+"US/US-2D.jpg"); 16 | CHECK_NOTHROW(importer->update()); 17 | } 18 | #endif 19 | -------------------------------------------------------------------------------- /source/FAST/Importers/Tests/NIFTIImporterTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace fast; 8 | 9 | /* 10 | TEST_CASE("NIFT Importer", "[NIFTIImporter][fast]") { 11 | auto importer = NIFTIImporter::create(Config::getTestDataPath() + "/MRI/MR-Abdomen.nii.gz"); 12 | auto image = importer->runAndGetOutputData(); 13 | float max = image->calculateMaximumIntensity(); 14 | float min = image->calculateMinimumIntensity(); 15 | std::cout << max << " " << min << std::endl; 16 | 17 | auto renderer = SliceRenderer::create(fast::PLANE_Y)->connect(image); 18 | renderer->setIntensityLevel((max-min)/2.0f); 19 | renderer->setIntensityWindow(max-min); 20 | SimpleWindow2D::create()->connect(renderer)->run(); 21 | }*/ -------------------------------------------------------------------------------- /source/FAST/OpenCL.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define CL_HPP_ENABLE_EXCEPTIONS 4 | #define CL_HPP_TARGET_OPENCL_VERSION 120 5 | #define CL_HPP_MINIMUM_OPENCL_VERSION 120 6 | #define CL_HPP_ENABLE_SIZE_T_COMPATIBILITY 7 | #define CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY 8 | #include "CL/opencl.hpp" 9 | -------------------------------------------------------------------------------- /source/FAST/Python/entry_points.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | import sys 3 | import os 4 | 5 | bin_path = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'bin')) 6 | 7 | def runUFFviewer(): 8 | subprocess.run([os.path.join(bin_path, 'UFFviewer')] + sys.argv[1:]) 9 | 10 | def runSystemCheck(): 11 | subprocess.run([os.path.join(bin_path, 'systemCheck')] + sys.argv[1:]) 12 | 13 | def runRunPipeline(): 14 | subprocess.run([os.path.join(bin_path, 'runPipeline')] + sys.argv[1:]) 15 | -------------------------------------------------------------------------------- /source/FAST/Python/std_unique_ptr.i: -------------------------------------------------------------------------------- 1 | %define %unique_ptr(TYPE) 2 | %typemap (out) std::unique_ptr %{ 3 | %set_output(SWIG_NewPointerObj($1.release(), $descriptor(TYPE *), SWIG_POINTER_OWN | %newpointer_flags)); 4 | %} 5 | %template() std::unique_ptr; 6 | %enddef 7 | 8 | namespace std { 9 | template class unique_ptr {}; 10 | } 11 | -------------------------------------------------------------------------------- /source/FAST/Streamers/MeshFileStreamer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "MeshFileStreamer.hpp" 4 | 5 | namespace fast { 6 | 7 | MeshFileStreamer::MeshFileStreamer() { 8 | createOutputPort(0); 9 | } 10 | MeshFileStreamer::MeshFileStreamer(std::string filenameFormat, bool loop) { 11 | createOutputPort(0); 12 | setFilenameFormat(filenameFormat); 13 | if(loop) 14 | enableLooping(); 15 | } 16 | 17 | DataObject::pointer MeshFileStreamer::getDataFrame(std::string filename) { 18 | VTKMeshFileImporter::pointer importer = VTKMeshFileImporter::New(); 19 | importer->setFilename(filename); 20 | importer->setMainDevice(getMainDevice()); 21 | DataChannel::pointer port = importer->getOutputPort(); 22 | importer->update(); 23 | return port->getNextFrame(); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /source/FAST/Streamers/Tests/CameraStreamerTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace fast; 8 | 9 | TEST_CASE("CameraStreamer", "[fast][camerastreamer][visual]") { 10 | auto cameras = QCameraInfo::availableCameras(); 11 | if(!cameras.empty()) { 12 | auto streamer = CameraStreamer::New(); 13 | 14 | auto renderer = ImageRenderer::New(); 15 | renderer->addInputConnection(streamer->getOutputPort()); 16 | 17 | auto window = SimpleWindow::New(); 18 | window->addRenderer(renderer); 19 | window->set2DMode(); 20 | window->setTimeout(1000); 21 | window->start(); 22 | } 23 | } -------------------------------------------------------------------------------- /source/FAST/Streamers/Tests/DicomMultiFrameStreamerTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace fast; 8 | 9 | TEST_CASE("DicomMultiFrameStreamer", "[fast][DicomMultiFrameStreamer][visual]") { 10 | auto streamer = DicomMultiFrameStreamer::create( 11 | "file", 12 | false, 13 | true, 14 | -1, 15 | true, 16 | true 17 | ); 18 | 19 | CHECK_THROWS( 20 | auto playbackWidget = new PlaybackWidget(streamer); 21 | auto renderer = ImageRenderer::create()->connect(streamer); 22 | 23 | auto window = SimpleWindow2D::create()->connect(renderer)->connect(playbackWidget); 24 | window->setTimeout(2000); 25 | window->run(); 26 | ); 27 | } 28 | -------------------------------------------------------------------------------- /source/FAST/Streamers/Tests/DummyIGTLServer.hpp: -------------------------------------------------------------------------------- 1 | #ifndef DUMMY_IGTL_IMAGE_SERVER_HPP 2 | #define DUMMY_IGTL_IMAGE_SERVER_HPP 3 | 4 | #include "FASTExport.hpp" 5 | #include "FAST/Streamers/ImageFileStreamer.hpp" 6 | #include 7 | 8 | namespace fast { 9 | 10 | class FAST_EXPORT DummyIGTLServer { 11 | public: 12 | DummyIGTLServer(); 13 | ~DummyIGTLServer(); 14 | void setPort(uint port); 15 | void setFramesPerSecond(uint fps); 16 | void setMaximumFramesToSend(uint frames); 17 | void setImageStreamer(ImageFileStreamer::pointer streamer); 18 | void start(); 19 | void stream(); 20 | private: 21 | uint mPort; 22 | uint mFPS; 23 | int mFrames; 24 | ImageFileStreamer::pointer mStreamer; 25 | std::thread mThread; 26 | 27 | 28 | }; 29 | 30 | }; 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /source/FAST/Streamers/Tests/ImageFileStreamerTests.cpp: -------------------------------------------------------------------------------- 1 | #include "FAST/Testing.hpp" 2 | #include "FAST/DeviceManager.hpp" 3 | #include 4 | #include "FAST/Streamers/ImageFileStreamer.hpp" 5 | #include "FAST/Tests/DummyObjects.hpp" 6 | #include "FAST/Data/Image.hpp" 7 | 8 | using namespace fast; 9 | 10 | TEST_CASE("No filename format given to ImageFileStreamer", "[fast][ImageFileStreamer]") { 11 | ImageFileStreamer::pointer mhdStreamer = ImageFileStreamer::New(); 12 | CHECK_THROWS(mhdStreamer->update()); 13 | } 14 | 15 | TEST_CASE("No hash tag in filename format given to ImageFileStreamer", "[fast][ImageFileStreamer]") { 16 | ImageFileStreamer::pointer mhdStreamer = ImageFileStreamer::New(); 17 | CHECK_THROWS(mhdStreamer->setFilenameFormat("asd")); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /source/FAST/Streamers/Tests/MovieStreamerTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace fast; 7 | 8 | TEST_CASE("MovieStreamer", "[fast][moviestreamer][visual]") { 9 | MovieStreamer::pointer streamer = MovieStreamer::create( 10 | Config::getTestDataPath() + "US/sagittal_spine.avi", 11 | true, 12 | false 13 | ); 14 | 15 | ImageRenderer::pointer renderer = ImageRenderer::New(); 16 | renderer->addInputConnection(streamer->getOutputPort()); 17 | 18 | SimpleWindow::pointer window = SimpleWindow::New(); 19 | window->addRenderer(renderer); 20 | window->set2DMode(); 21 | window->setTimeout(1000); 22 | window->start(); 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Testing.hpp: -------------------------------------------------------------------------------- 1 | #ifndef TESTING_HPP_ 2 | #define TESTING_HPP_ 3 | 4 | #include "FAST/Tests/catch.hpp" 5 | 6 | #endif 7 | -------------------------------------------------------------------------------- /source/FAST/Tests/Algorithms/DoubleFilter.cl: -------------------------------------------------------------------------------- 1 | 2 | __kernel void doubleFilter( 3 | __global TYPE * input, 4 | __global TYPE * output 5 | ) { 6 | output[get_global_id(0)] = input[get_global_id(0)]*2; 7 | } 8 | -------------------------------------------------------------------------------- /source/FAST/Tests/Algorithms/DoubleFilter.hpp: -------------------------------------------------------------------------------- 1 | #ifndef DOUBLEFILTER_HPP 2 | #define DOUBLEFILTER_HPP 3 | 4 | #include "FAST/ProcessObject.hpp" 5 | 6 | namespace fast { 7 | 8 | /** 9 | * This is an example filter which doubles the value of each element in an image 10 | */ 11 | class DoubleFilter : public ProcessObject { 12 | FAST_OBJECT(DoubleFilter) 13 | private: 14 | // Constructor 15 | DoubleFilter(); 16 | // This method will execute the algorithm 17 | void execute(); 18 | }; 19 | 20 | }; // namespace fast 21 | 22 | #endif // DOUBLEFILTER_HPP 23 | -------------------------------------------------------------------------------- /source/FAST/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_test_sources( 2 | catch.hpp 3 | CatchMain.cpp 4 | DataComparison.cpp 5 | DataComparison.hpp 6 | DummyObjects.cpp 7 | DummyObjects.hpp 8 | ProcessObjectTests.cpp 9 | Algorithms/DoubleFilter.cpp 10 | Algorithms/DoubleFilter.hpp 11 | Algorithms/DoubleFilterTests.cpp 12 | SceneGraphTests.cpp 13 | UtilityTests.cpp 14 | FramerateSynchronizerTests.cpp 15 | PipelineTests.cpp 16 | ) 17 | if(FAST_MODULE_Visualization) 18 | fast_add_test_sources( 19 | SystemTests.cpp 20 | Benchmarks.cpp 21 | DataHubTests.cpp 22 | ) 23 | endif() -------------------------------------------------------------------------------- /source/FAST/Tests/CatchMain.cpp: -------------------------------------------------------------------------------- 1 | #define CATCH_CONFIG_RUNNER 2 | #include "catch.hpp" 3 | #include "FAST/Reporter.hpp" 4 | 5 | int main(int argc, char* argv[]) { 6 | fast::Reporter::setGlobalReportMethod(fast::Reporter::COUT); 7 | int result = Catch::Session().run(argc, argv); 8 | 9 | return result; 10 | } 11 | -------------------------------------------------------------------------------- /source/FAST/Tests/DataHubTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace fast; 6 | 7 | /* 8 | TEST_CASE("Data hub", "[fast][DataHub]") { 9 | auto hub = DataHub(); 10 | hub.getItems("wsi"); 11 | 12 | auto res = hub.getItem("breast-tumour-segmentation"); 13 | 14 | auto browser = new DataHubBrowser("fast-pathology"); 15 | browser->show(); 16 | QApplication::instance()->exec(); 17 | } 18 | */ -------------------------------------------------------------------------------- /source/FAST/Tools/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_subdirectories( 2 | #OpenIGTLinkClient 3 | OpenIGTLinkServer 4 | Pipeline 5 | UFFViewer 6 | SystemCheck 7 | ) 8 | fast_add_sources( 9 | CommandLineParser.cpp 10 | CommandLineParser.hpp 11 | ) 12 | fast_add_tool(downloadTestData downloadTestData.cpp) -------------------------------------------------------------------------------- /source/FAST/Tools/OpenIGTLinkServer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_OpenIGTLink) 2 | fast_add_tool(OpenIGTLinkServer 3 | main.cpp 4 | GUI.cpp 5 | GUI.hpp 6 | ) 7 | endif() -------------------------------------------------------------------------------- /source/FAST/Tools/Pipeline/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_tool( 2 | runPipeline 3 | main.cpp 4 | GUI.cpp 5 | GUI.hpp 6 | ) 7 | -------------------------------------------------------------------------------- /source/FAST/Tools/Pipeline/GUI.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class QComboBox; 7 | class QHBoxLayout; 8 | class QVBoxLayout; 9 | 10 | namespace fast { 11 | 12 | class GUI : public Window { 13 | FAST_OBJECT(GUI) 14 | public: 15 | void setPipeline(Pipeline &pipeline); 16 | private: 17 | void loadPipeline(); 18 | void updateAvailablePipelines(); 19 | GUI(); 20 | bool m_running = false; 21 | int m_currentPipeline = 0; 22 | std::vector m_availablePipelines; 23 | 24 | QComboBox* m_pipelineSelector; 25 | 26 | QHBoxLayout* m_viewLayout; 27 | QVBoxLayout* m_mainLayout; 28 | }; 29 | 30 | } -------------------------------------------------------------------------------- /source/FAST/Tools/SonixGPSClient/OpenIGTLinkClient.hpp: -------------------------------------------------------------------------------- 1 | #ifndef FAST_OPENIGTLINKCLIENT_HPP_ 2 | #define FAST_OPENIGTLINKCLIENT_HPP_ 3 | 4 | #include "FAST/ProcessObject.hpp" 5 | 6 | namespace fast { 7 | 8 | class OpenIGTLinkClient : public ProcessObject { 9 | FAST_OBJECT(OpenIGTLinkClient) 10 | public: 11 | bool toggleRecord(std::string storageDir); 12 | bool isRecording(); 13 | std::string getRecordingName(); 14 | uint getFramesStored(); 15 | private: 16 | OpenIGTLinkClient(); 17 | void execute(); 18 | 19 | bool mRecording; 20 | uint mRecordFrameNr; 21 | std::string mRecordStoragePath; 22 | std::string mRecordingName; 23 | }; 24 | 25 | } 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /source/FAST/Tools/SystemCheck/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_tool(systemCheck main.cpp) -------------------------------------------------------------------------------- /source/FAST/Tools/UFFViewer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_HDF5) 2 | fast_add_tool(UFFviewer main.cpp GUI.cpp GUI.hpp) 3 | endif() -------------------------------------------------------------------------------- /source/FAST/Tools/UFFViewer/GUI.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class QHBoxLayout; 6 | class QVBoxLayout; 7 | class QComboBox; 8 | class QSlider; 9 | class QPushButton; 10 | 11 | namespace fast { 12 | 13 | class UFFStreamer; 14 | 15 | class UFFViewerWindow : public Window { 16 | FAST_OBJECT(UFFViewerWindow) 17 | public: 18 | void setFilename(std::string filename); 19 | //void start() override; 20 | protected: 21 | UFFViewerWindow(); 22 | void loadView(); 23 | //void createLayout(); 24 | 25 | std::string m_filename; 26 | int m_framerate = 30; 27 | std::string m_pipelineFile = "default.fpl"; 28 | 29 | QHBoxLayout* m_viewLayout; 30 | QVBoxLayout* m_rightSideLayout; 31 | QComboBox* m_framerateInput; 32 | QComboBox* m_gainInput; 33 | QComboBox* m_dynamicRangeInput; 34 | QSlider* m_slider; 35 | QPushButton* m_playButton; 36 | std::shared_ptr m_streamer; 37 | }; 38 | 39 | } -------------------------------------------------------------------------------- /source/FAST/Tools/UFFViewer/main.cpp: -------------------------------------------------------------------------------- 1 | #include "GUI.hpp" 2 | #include 3 | 4 | using namespace fast; 5 | 6 | int main(int argc, char** argv) { 7 | CommandLineParser parser("Ultasound File Format FAST Viewer"); 8 | parser.addPositionVariable(1, "filename", false, "Path to uff file to open"); 9 | parser.addOption("verbose"); 10 | parser.parse(argc, argv); 11 | 12 | if(parser.getOption("verbose")) 13 | Reporter::setGlobalReportMethod(Reporter::COUT); 14 | 15 | auto window = UFFViewerWindow::New(); 16 | if(parser.gotValue("filename")) { 17 | window->setFilename(parser.get("filename")); 18 | } 19 | window->start(); 20 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/BoundingBoxRenderer/BoundingBoxRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec4 geomColor; 4 | out vec4 fragColor; 5 | 6 | void main() { 7 | fragColor = geomColor; 8 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/BoundingBoxRenderer/BoundingBoxRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 in_position; 3 | layout (location = 1) in uint in_label; 4 | layout (std140) uniform Colors { 5 | vec4 color[256]; 6 | }; 7 | 8 | out vec4 vertexColor; 9 | 10 | uniform mat4 transform; 11 | uniform mat4 viewTransform; 12 | uniform mat4 perspectiveTransform; 13 | 14 | void main() { 15 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(in_position, 1.0); 16 | vertexColor = in_label < uint(256) ? color[in_label] : vec4(0.0, 0.0, 0.0, 0.0); 17 | } 18 | -------------------------------------------------------------------------------- /source/FAST/Visualization/BoundingBoxRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | BoundingBoxRenderer.hpp 3 | BoundingBoxRenderer.cpp 4 | ) 5 | fast_add_test_sources( 6 | BoundingBoxRendererTests.cpp 7 | ) 8 | fast_add_process_object(BoundingBoxRenderer BoundingBoxRenderer.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/HeatmapRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | HeatmapRenderer.hpp 3 | HeatmapRenderer.cpp 4 | ) 5 | fast_add_process_object(HeatmapRenderer HeatmapRenderer.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/ImagePyramidRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_WholeSlideImaging) 2 | fast_add_sources( 3 | ImagePyramidRenderer.cpp 4 | ImagePyramidRenderer.hpp 5 | ) 6 | fast_add_process_object(ImagePyramidRenderer ImagePyramidRenderer.hpp) 7 | endif() -------------------------------------------------------------------------------- /source/FAST/Visualization/ImagePyramidRenderer/ImagePyramidRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform sampler2D ourTexture; 7 | 8 | void main() 9 | { 10 | FragColor = texture(ourTexture, TexCoord); 11 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/ImagePyramidRenderer/ImagePyramidRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec2 aTexCoord; 4 | 5 | out vec2 TexCoord; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | 11 | void main() 12 | { 13 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 14 | TexCoord = aTexCoord; 15 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/ImageRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ImageRenderer.cpp 3 | ImageRenderer.hpp 4 | ) 5 | fast_add_test_sources( 6 | ImageRendererTests.cpp 7 | ) -------------------------------------------------------------------------------- /source/FAST/Visualization/ImageRenderer/ImageRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec2 aTexCoord; 4 | 5 | out vec2 TexCoord; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | 11 | void main() 12 | { 13 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 14 | TexCoord = aTexCoord; 15 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/ImageRenderer/ImageRendererFLOAT.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform sampler2D ourTexture; 7 | uniform float window; 8 | uniform float level; 9 | uniform float opacity; 10 | 11 | void main() 12 | { 13 | vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y))); 14 | color.rgb = (color.rgb - level + window/2.0f) / window; 15 | if(opacity >= 0.0) 16 | color.w = opacity; 17 | FragColor = clamp(color, 0.0f, 1.0f); 18 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/ImageRenderer/ImageRendererINT.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform isampler2D ourTexture; 7 | uniform float window; 8 | uniform float level; 9 | uniform float opacity; 10 | 11 | void main() 12 | { 13 | vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y))); 14 | color.rgb = (color.rgb - level + window/2.0f) / window; 15 | if(opacity >= 0.0) 16 | color.w = opacity; 17 | FragColor = clamp(color, 0.0f, 1.0f); 18 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/ImageRenderer/ImageRendererUINT.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform usampler2D ourTexture; 7 | uniform float window; 8 | uniform float level; 9 | uniform float opacity; 10 | 11 | void main() { 12 | vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y))); 13 | color.rgb = (color.rgb - level + window/2.0f) / window; // Normalize RGB 14 | color.a = color.a/255.0; // Normalize alpha 15 | if(opacity >= 0.0) 16 | color.w = opacity; 17 | FragColor = clamp(color, 0.0f, 1.0f); 18 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | LineRenderer.cpp 3 | LineRenderer.hpp 4 | ) 5 | fast_add_test_sources( 6 | LineRendererTests.cpp 7 | ) 8 | fast_add_process_object(LineRenderer LineRenderer.hpp) 9 | -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec4 geomColor; 4 | out vec4 FragColor; 5 | 6 | void main() { 7 | FragColor = geomColor; 8 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 in_position; 3 | layout (location = 1) in vec3 in_color; 4 | 5 | out vec4 vertexColor; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform bool useGlobalColor; 11 | uniform vec3 globalColor; 12 | 13 | void main() { 14 | gl_Position = vec4(in_position, 1.0); 15 | if(useGlobalColor) { 16 | vertexColor = vec4(globalColor, 1.0); 17 | } else { 18 | vertexColor = vec4(in_color, 1.0); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRenderer3D.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | in vec4 vertexColor; 4 | out vec4 FragColor; 5 | 6 | void main() { 7 | FragColor = vertexColor; 8 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRenderer3D.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 in_position; 3 | layout (location = 1) in vec3 in_color; 4 | 5 | out vec4 vertexColor; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform bool useGlobalColor; 11 | uniform vec3 globalColor; 12 | 13 | void main() { 14 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(in_position, 1.0); 15 | if(useGlobalColor) { 16 | vertexColor = vec4(globalColor, 1.0); 17 | } else { 18 | vertexColor = vec4(in_color, 1.0); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRendererJoints.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | out vec4 FragColor; 4 | in vec4 vertex_color; 5 | 6 | void main() 7 | { 8 | // Convert squares to circles 9 | vec2 circCoord = gl_PointCoord - vec2(0.5, 0.5); 10 | if(dot(circCoord, circCoord) > 0.25) { // x dot x = |x|*|x| = r^2, radius = 0.5, r^2=0.25 11 | discard; 12 | } else { 13 | FragColor = vertex_color; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /source/FAST/Visualization/LineRenderer/LineRendererJoints.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec3 aColor; 4 | 5 | out vec4 vertex_color; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform float pointSize; 11 | uniform bool useGlobalColor; 12 | uniform vec3 globalColor; 13 | uniform int viewportWidth; 14 | 15 | void main() 16 | { 17 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 18 | gl_PointSize = (pointSize/100.0)*viewportWidth; // gl_PointSize unit is in pixels 19 | if(useGlobalColor) { 20 | vertex_color = vec4(globalColor, 1.0); 21 | } else { 22 | vertex_color = vec4(aColor, 1.0); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /source/FAST/Visualization/Plane.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "FAST/Data/DataTypes.hpp" 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Class for a 3D plane 9 | * 10 | * A plane is defined by a 3D position and a 3D normal 11 | */ 12 | class FAST_EXPORT Plane { 13 | public: 14 | Plane(); 15 | Plane(Vector3f normal); 16 | Plane(Vector3f normal, Vector3f position); 17 | void setPosition(Vector3f position); 18 | void setNormal(Vector3f normal); 19 | Vector3f getPosition() const; 20 | Vector3f getNormal() const; 21 | Vector3f getIntersectionPoint(Vector3f pointA, Vector3f pointB) const; 22 | bool hasPosition() const; 23 | static Plane Sagittal(); 24 | static Plane Coronal(); 25 | static Plane Axial(); 26 | private: 27 | 28 | bool mHasPosition; 29 | Vector3f mNormal; 30 | Vector3f mPosition; 31 | }; 32 | 33 | } 34 | -------------------------------------------------------------------------------- /source/FAST/Visualization/Plotting/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(FAST_MODULE_Plotting) 2 | fast_add_sources( 3 | Plotter.cpp 4 | Plotter.hpp 5 | LinePlotter.cpp 6 | LinePlotter.hpp 7 | ) 8 | fast_add_python_interfaces(Plotter.hpp) 9 | fast_add_python_shared_pointers(Plotter) 10 | fast_add_process_object(LinePlotter LinePlotter.hpp) 11 | endif() -------------------------------------------------------------------------------- /source/FAST/Visualization/Plotting/Plotter.cpp: -------------------------------------------------------------------------------- 1 | #include "Plotter.hpp" 2 | #include 3 | #include 4 | 5 | namespace fast { 6 | 7 | void Plotter::setUpdateFrequency(float frequency) { 8 | if(m_timer != nullptr) 9 | delete m_timer; 10 | if(frequency > 0) { 11 | m_timer = new QTimer(m_plotterWidget); 12 | QObject::connect(m_timer, &QTimer::timeout, this, &Plotter::processQueue); 13 | m_timer->setSingleShot(false); 14 | m_timer->start(1000.0f / frequency); 15 | } else { 16 | m_timer = nullptr; 17 | } 18 | } 19 | 20 | JKQTPlotter* Plotter::getPlotterWidget() { 21 | return m_plotterWidget; 22 | } 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/Plotting/Plotter.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | class QTimer; 10 | class JKQTPlotter; 11 | 12 | namespace fast{ 13 | 14 | 15 | // Abstract Plot object 16 | class FAST_EXPORT Plotter : public QObject, public ProcessObject { 17 | Q_OBJECT 18 | public: 19 | /** 20 | * @brief How often to update plot 21 | * 22 | * Set how many times per second the plot should update. 23 | * This setting impacts performance. 24 | * 25 | * @param frequency 26 | */ 27 | virtual void setUpdateFrequency(float frequency); 28 | virtual JKQTPlotter* getPlotterWidget(); 29 | protected: 30 | JKQTPlotter* m_plotterWidget; 31 | QTimer* m_timer = nullptr; 32 | public Q_SLOTS: 33 | virtual void processQueue() = 0; 34 | Q_SIGNALS: 35 | void newData(); 36 | }; 37 | } 38 | -------------------------------------------------------------------------------- /source/FAST/Visualization/RenderToImage/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | RenderToImage.cpp 3 | RenderToImage.hpp 4 | ) 5 | fast_add_process_object(RenderToImage RenderToImage.hpp) 6 | 7 | fast_add_test_sources(Tests.cpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/SegmentationLabelRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources(SegmentationLabelRenderer.cpp SegmentationLabelRenderer.hpp) 2 | fast_add_test_sources(Tests.cpp) 3 | fast_add_process_object(SegmentationLabelRenderer SegmentationLabelRenderer.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/SegmentationLabelRenderer/SegmentationLabelRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform sampler2D ourTexture; 7 | 8 | void main() 9 | { 10 | FragColor = texture(ourTexture, TexCoord); 11 | } 12 | -------------------------------------------------------------------------------- /source/FAST/Visualization/SegmentationLabelRenderer/SegmentationLabelRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec2 aTexCoord; 4 | 5 | out vec2 TexCoord; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform int positionType; 11 | 12 | void main() 13 | { 14 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 15 | TexCoord = aTexCoord; 16 | } 17 | -------------------------------------------------------------------------------- /source/FAST/Visualization/SegmentationRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SegmentationRenderer.cpp 3 | SegmentationRenderer.hpp 4 | ) 5 | fast_add_process_object(SegmentationRenderer SegmentationRenderer.hpp) 6 | fast_add_test_sources( 7 | SegmentationRendererTests.cpp 8 | ) -------------------------------------------------------------------------------- /source/FAST/Visualization/SegmentationRenderer/SegmentationRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec2 aTexCoord; 4 | 5 | out vec2 TexCoord; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | 11 | void main() 12 | { 13 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 14 | TexCoord = aTexCoord; 15 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/SliceRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SliceRenderer.cpp 3 | SliceRenderer.hpp 4 | ) 5 | fast_add_test_sources( 6 | SliceRendererTests.cpp 7 | ) 8 | fast_add_process_object(SliceRenderer SliceRenderer.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/Tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_test_sources( 2 | DualViewWindowTests.cpp 3 | MultiViewWindowTests.cpp 4 | SlicerWindowTests.cpp 5 | ) -------------------------------------------------------------------------------- /source/FAST/Visualization/Tests/MultiViewWindowTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace fast; 7 | 8 | TEST_CASE("Multi view window", "[fast][MultiViewWindow][visual]") { 9 | auto importer = ImageFileImporter::create(Config::getTestDataPath() + "US/Heart/ApicalFourChamber/US-2D_0.mhd"); 10 | 11 | auto renderer1 = ImageRenderer::create(100, 100)->connect(importer); 12 | auto renderer2 = ImageRenderer::create(200, 100)->connect(importer); 13 | auto renderer3 = ImageRenderer::create(50, 200)->connect(importer); 14 | 15 | auto window = MultiViewWindow::create(3) 16 | ->connect(0, renderer1) 17 | ->connect(1, renderer2) 18 | ->connect(2, renderer3); 19 | 20 | window->setTimeout(1000); 21 | window->run(); 22 | 23 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/TextRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | TextRenderer.cpp 3 | TextRenderer.hpp 4 | ) 5 | fast_add_test_sources(Tests.cpp) 6 | fast_add_process_object(TextRenderer TextRenderer.hpp) 7 | -------------------------------------------------------------------------------- /source/FAST/Visualization/TextRenderer/TextRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 TexCoord; 5 | 6 | uniform sampler2D ourTexture; 7 | 8 | void main() 9 | { 10 | FragColor = texture(ourTexture, TexCoord); 11 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/TextRenderer/TextRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec2 aTexCoord; 4 | 5 | out vec2 TexCoord; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform int positionType; 11 | 12 | void main() 13 | { 14 | if(positionType == 2) { 15 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 16 | } else { 17 | gl_Position = transform * vec4(aPos, 1.0); 18 | } 19 | TexCoord = aTexCoord; 20 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/TriangleRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | TriangleRenderer.cpp 3 | TriangleRenderer.hpp 4 | ) 5 | fast_add_process_object(TriangleRenderer TriangleRenderer.hpp) 6 | fast_add_test_sources( 7 | TriangleRendererTests.cpp 8 | ) 9 | -------------------------------------------------------------------------------- /source/FAST/Visualization/VectorFieldRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | VectorFieldRenderer.hpp 3 | VectorFieldRenderer.cpp 4 | VectorFieldColorRenderer.hpp 5 | VectorFieldColorRenderer.cpp 6 | ) 7 | fast_add_process_object(VectorFieldRenderer VectorFieldRenderer.hpp) 8 | fast_add_process_object(VectorFieldColorRenderer VectorFieldColorRenderer.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/VectorFieldRenderer/VectorFieldRenderer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Renders a vector field image using lines 9 | * 10 | * @ingroup renderers 11 | */ 12 | class FAST_EXPORT VectorFieldRenderer : public LineRenderer { 13 | FAST_PROCESS_OBJECT(VectorFieldRenderer) 14 | public: 15 | private: 16 | void execute() override; 17 | }; 18 | 19 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/VertexRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | VertexRenderer.cpp 3 | VertexRenderer.hpp 4 | ) 5 | fast_add_process_object(VertexRenderer VertexRenderer.hpp) 6 | fast_add_test_sources( 7 | VertexRendererTests.cpp 8 | ) 9 | -------------------------------------------------------------------------------- /source/FAST/Visualization/VertexRenderer/VertexRenderer.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | out vec4 FragColor; 4 | in vec4 vertex_color; 5 | 6 | void main() 7 | { 8 | vec2 circCoord = gl_PointCoord - vec2(0.5, 0.5); 9 | if(dot(circCoord, circCoord) > 0.25) { 10 | discard; 11 | } else { 12 | FragColor = vertex_color; 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /source/FAST/Visualization/VertexRenderer/VertexRenderer.vert: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec3 aColor; 4 | 5 | out vec4 vertex_color; 6 | 7 | uniform mat4 transform; 8 | uniform mat4 viewTransform; 9 | uniform mat4 perspectiveTransform; 10 | uniform float pointSize; 11 | uniform bool useGlobalColor; 12 | uniform vec3 globalColor; 13 | 14 | void main() 15 | { 16 | gl_PointSize = pointSize; 17 | gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0); 18 | if(useGlobalColor) { 19 | vertex_color = vec4(globalColor, 1.0); 20 | } else { 21 | vertex_color = vec4(aColor, 1.0); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /source/FAST/Visualization/View.cl: -------------------------------------------------------------------------------- 1 | 2 | __kernel void initializePBO( 3 | __global float* PBO, 4 | __private float red, 5 | __private float green, 6 | __private float blue 7 | ) { 8 | const float4 value = {red, green, blue, 1.0}; 9 | vstore4(value, get_global_id(0), PBO); 10 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/VolumeRenderer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | VolumeRenderer.cpp 3 | VolumeRenderer.hpp 4 | MaximumIntensityProjection.cpp 5 | MaximumIntensityProjection.hpp 6 | ThresholdVolumeRenderer.cpp 7 | ThresholdVolumeRenderer.hpp 8 | AlphaBlendingVolumeRenderer.cpp 9 | AlphaBlendingVolumeRenderer.hpp 10 | TransferFunction.cpp 11 | TransferFunction.hpp 12 | ) 13 | fast_add_test_sources(Tests.cpp) 14 | fast_add_python_interfaces(VolumeRenderer.hpp TransferFunction.hpp) 15 | fast_add_python_shared_pointers(VolumeRenderer) 16 | fast_add_process_object(AlphaBlendingVolumeRenderer AlphaBlendingVolumeRenderer.hpp) 17 | fast_add_process_object(ThresholdVolumeRenderer ThresholdVolumeRenderer.hpp) 18 | fast_add_process_object(MaximumIntensityProjection MaximumIntensityProjection.hpp) 19 | -------------------------------------------------------------------------------- /source/FAST/Visualization/VolumeRenderer/MaximumIntensityProjection.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Renders 3D images using ray-casting and maximum intensity projection (MIP) 9 | * 10 | * Uses the highest intensity observed along the ray. 11 | * 12 | * @ingroup renderers 13 | */ 14 | class FAST_EXPORT MaximumIntensityProjection : public VolumeRenderer { 15 | FAST_PROCESS_OBJECT(MaximumIntensityProjection) 16 | public: 17 | FAST_CONSTRUCTOR(MaximumIntensityProjection) 18 | protected: 19 | void 20 | draw(Matrix4f perspectiveMatrix, Matrix4f viewingMatrix, float zNear, float zFar, bool mode2D, int viewWidth, 21 | int viewHeight) override; 22 | }; 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/VolumeRenderer/ThresholdVolumeRenderer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace fast { 6 | 7 | /** 8 | * @brief Renders 3D images using ray-casting and a threshold 9 | * 10 | * @ingroup renderers 11 | */ 12 | class FAST_EXPORT ThresholdVolumeRenderer : public VolumeRenderer { 13 | FAST_PROCESS_OBJECT(ThresholdVolumeRenderer) 14 | public: 15 | FAST_CONSTRUCTOR(ThresholdVolumeRenderer, float, threshold, = 0) 16 | void setThreshold(float threshold); 17 | protected: 18 | void 19 | draw(Matrix4f perspectiveMatrix, Matrix4f viewingMatrix, float zNear, float zFar, bool mode2D, int viewWidth, 20 | int viewHeight) override; 21 | float m_threshold = 0; 22 | }; 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/ButtonWidget/ButtonWidgetTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "ButtonWidget.hpp" 6 | 7 | using namespace fast; 8 | 9 | TEST_CASE("Button widget", "[fast][ButtonWidget][visual]") { 10 | auto importer = ImageFileImporter::create(Config::getTestDataPath() + "US/Heart/ApicalFourChamber/US-2D_0.mhd"); 11 | 12 | auto renderer = ImageRenderer::create()->connect(importer); 13 | 14 | auto widget = new ButtonWidget("Show renderer", true, [=](bool checked) { 15 | renderer->setDisabled(!renderer->isDisabled()); 16 | }); 17 | 18 | auto window = SimpleWindow2D::create() 19 | ->connect(renderer) 20 | ->connect(widget); 21 | window->setTimeout(2000); 22 | window->run(); 23 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/ButtonWidget/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | ButtonWidget.cpp 3 | ButtonWidget.hpp 4 | ) 5 | fast_add_python_interfaces(ButtonWidget.hpp) 6 | fast_add_test_sources(ButtonWidgetTests.cpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_all_subdirectories() 2 | -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/PlaybackWidget/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | PlaybackWidget.cpp 3 | PlaybackWidget.hpp 4 | ) 5 | fast_add_python_interfaces(PlaybackWidget.hpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/PlaybackWidget/PlaybackWidget.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | class QSlider; 7 | class QPushButton; 8 | 9 | namespace fast { 10 | /** 11 | * @brief A widget to control playback of a RandomAccessStreamer 12 | * @ingroup widgets 13 | */ 14 | class FAST_EXPORT PlaybackWidget : public QWidget { 15 | public: 16 | PlaybackWidget(std::shared_ptr streamer, QWidget* parent = nullptr); 17 | void show() { QWidget::show(); }; 18 | private: 19 | std::shared_ptr m_streamer; 20 | QSlider* m_slider; 21 | QPushButton* m_playButton; 22 | }; 23 | 24 | } -------------------------------------------------------------------------------- /source/FAST/Visualization/Widgets/SliderWidget/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | fast_add_sources( 2 | SliderWidget.cpp 3 | SliderWidget.hpp 4 | ) 5 | fast_add_python_interfaces(SliderWidget.hpp) 6 | fast_add_test_sources(SliderWidgetTests.cpp) -------------------------------------------------------------------------------- /source/FAST/Visualization/WindowWidget.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include "View.hpp" 6 | #include 7 | #include 8 | 9 | namespace fast { 10 | 11 | class FAST_EXPORT WindowWidget : public QWidget { 12 | Q_OBJECT 13 | public: 14 | WindowWidget(); 15 | void keyPressEvent(QKeyEvent* event); 16 | void closeEvent(QCloseEvent* event); 17 | ~WindowWidget(); 18 | protected: 19 | void dragEnterEvent(QDragEnterEvent *event) override; 20 | void dropEvent(QDropEvent *event) override; 21 | private: 22 | signals: 23 | void widgetHasClosed(); 24 | void filesDropped(const QList &filenames); 25 | 26 | }; 27 | } // end namespace fast 28 | -------------------------------------------------------------------------------- /source/FASTVersion.hpp.in: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define FAST_VERSION_MAJOR @VERSION_MAJOR@ 4 | #define FAST_VERSION_MINOR @VERSION_MINOR@ 5 | #define FAST_VERSION_PATCH @VERSION_PATCH@ 6 | 7 | namespace fast { 8 | static std::string getVersion() { 9 | std::string version = "v" + std::to_string(FAST_VERSION_MAJOR) + "." + std::to_string(FAST_VERSION_MINOR) + "." + std::to_string(FAST_VERSION_PATCH); 10 | return version; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /source/ProcessObjectList.hpp.in: -------------------------------------------------------------------------------- 1 | #ifndef FAST_PROCESS_OBJECT_LIST_HPP_ 2 | #define FAST_PROCESS_OBJECT_LIST_HPP_ 3 | 4 | #include "FAST/ProcessObjectRegistry.hpp" 5 | 6 | ${FAST_PROCESS_OBJECT_INCLUDES} 7 | 8 | namespace fast { 9 | ${FAST_PROCESS_OBJECT_REGISTRATION} 10 | } 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /source/fast_configuration.txt.in: -------------------------------------------------------------------------------- 1 | ## FAST Configuration file 2 | #TestDataPath = /path/to/data/ 3 | #KernelSourcePath = /path/to/kernel/source/FAST/ 4 | #KernelBinaryPath = /path/to/kernel/binary/ 5 | #DocumentationPath = /path/to/doc/ 6 | #PipelinePath = /path/to/pipeline/ 7 | 8 | #@CONFIG_TEST_DATA_PATH@ 9 | @CONFIG_KERNEL_SOURCE_PATH@ 10 | @CONFIG_KERNEL_BINARY_PATH@ 11 | @CONFIG_DOCUMENTATION_PATH@ 12 | @CONFIG_PIPELINE_PATH@ 13 | @CONFIG_LIBRARY_PATH@ 14 | @CONFIG_QT_PLUGINS_PATH@ 15 | --------------------------------------------------------------------------------