fast namespace

FAST namespace - All FAST code lives in this namespace.

Namespaces

namespace SceneGraph

Classes

class AddTransformation
Add transformations to spatial data objects.
class AirwaySegmentation
Segment airways from CT using seeded region growing with explosion control.
class AlphaBlendingVolumeRenderer
Renders 3D images/volumes using ray-casting and alpha blending.
class AppearanceModel
class Attribute
class AttributeValue
class AttributeValueBoolean
class AttributeValueFloat
class AttributeValueInteger
class AttributeValueString
class BadCastException
class Batch
Batch data object.
class BinaryThresholding
Segmentation using a threshold value.
class BlockMatching
Block matching tracking of an image stream.
class BoundingBox
A 2D bounding box data object.
class BoundingBoxNetwork
Neural network process object for bounding box detection.
class BoundingBoxRenderer
class BoundingBoxSet
A data object representing a (large) set of bounding boxes.
class BoundingBoxSetAccess
class BoundingBoxSetAccumulator
Accumulate a stream of bounding box sets to a single large bounding box set.
class BoundingBoxSetOpenGLAccess
class Camera
class CameraAccess
class CameraStreamer
Stream images from a (web)camera.
class CameraVideoSurface
class CameraWorker
class CardinalSplineModel
Cardinal spline shape model.
class CenterlineExtraction
Extract centerline from 3D image segmentation.
struct CenterlinePoint
class ClariusStreamer
Stream ultrasound images from a Clarius scanner.
class ClassificationToText
class CoherentPointDrift
Abstract base class for Coherent Point Drift (CPD) registration.
class CoherentPointDriftAffine
Affine coherent point drift registration.
class CoherentPointDriftRigid
Rigid coherent point drift registration.
class Color
class ComputationThread
class Config
class DataBoundingBox
Defines the extent of a spatial data object.
class DataChannel
class DataList
A list of FAST data input/output objects Used in RunLambda.
class DataObject
Abstract data object class.
class DataStream
Object for iterating through a data stream coming from a pipeline.
struct Destroy
struct DetectedEdge
struct deviceAndScore
class DeviceCriteria
class DeviceManager
class DICOMFileImporter
Read DICOM image data (both 2D and 3D).
class Dilation
Perform binary dilation with disk structuring element.
class DoesNotExistException
class DualViewWindow
A Window with 2 views.
class DualViewWindow2D
A Window with 2 views in 2D mode.
class DualViewWindow3D
A Window with 2 views in 3D mode.
class EllipseModel
Ellipse shape model.
class EmptyProcessObject
class Erosion
Perform binary erosion with disk structuring element.
class EulerGradientVectorFlow
Gradient vector flow using Euler method.
class Exception
class ExecutionDevice
class ExistException
class Exporter
Abstract base class for exporters.
class FASTApplication
class FileExporter
Abstract class for file exporters.
class FileImporter
Abstract base class for importers which import a file with a filename.
class FileNotFoundException
class FileStreamer
Abstract file streamer class.
class FlowNetwork
A neural network for optical flow estimation.
class GaussianSmoothing
Smoothing by convolution with a Gaussian mask.
class HDF5TensorExporter
Write a Tensor to a HDF5 file.
class HDF5TensorImporter
Read tensor data stored in HDF5 format.
class HeatmapRenderer
Renders Tensor data objects as heatmaps.
class Host
class HounsefieldConverter
Converts input image to Hounsefield units (if needed)
class IGTLSocketWrapper
class Image
Image data.
class ImageAccess
class ImageAdd
Add two images.
class ImageCaster
Cast image to another data type.
class ImageChannelConverter
Remove and/or reverse channels from an image.
class ImageClassification
Image classification data object.
class ImageClassificationNetwork
Image classification neural network.
class ImageCropper
Process object from cropping an image.
class ImageExporter
Write an Image to a file using image format such as JPG/PNG/BMP/GIF.
class ImageFileExporter
Write image to a file with various formats.
class ImageFileImporter
Read image data stored in various file formats.
class ImageFileStreamer
Stream a sequence of image files from disk.
class ImageGradient
Calculate image gradient using central finite difference method.
class ImageImporter
Read JPG/PNG/BMP/TIFF images.
class ImageInverter
Invert the intensity of an image.
class ImageMovingAverage
Temporal smoothing of image using moving average.
class ImageMultiply
Multiply two images.
class ImagePyramid
Image pyramid data object.
class ImagePyramidAccess
class ImagePyramidLevel
class ImagePyramidLevelExtractor
Extract a level of an image pyramid as an image.
class ImagePyramidPatch
class ImagePyramidPatchExporter
Exports an ImagePyramid to disk as a large set of image patches. Each patch is stored as a PNG image with the file name indicating its position and size. This exporter can handle both an ImagePyramid input and a stream of image patches.
class ImagePyramidPatchImporter
Loads an image pyramid from a set of image patches stored in a folder.
class ImagePyramidRenderer
Renders tiled image pyramids.
class ImageRenderer
Renders 2D Image data objects, both in 2D and 3D.
class ImageResampler
Resample an image to a given spatial resolution.
class ImageResizer
Process object for resizing an image.
class ImageSharpening
Image sharpening by the unsharp masking method.
class ImageSlicer
Slice a 3D image using a defined plane.
class ImagesToSequence
Process object for converting a stream of images to a Sequence data object.
class ImageToBatchGenerator
Converts a stream of images into stream of Batch data objects.
class ImageWeightedMovingAverage
Temporal smoothing of image using weighted moving average.
class Importer
Abstract base class for Importers.
class InferenceDataList
A class containing a list of data objects for inference, either Image or Tensor objects.
struct InferenceDeviceInfo
class InferenceEngine
class InferenceEngineManager
A purely static class to dynamically load inference engines at runtime.
class IntensityClipping
Clips the pixel intensities of an image to specific values.
class IntensityNormalization
Normalize intensities of an image to a 0-1 or custom range.
class InverseGradientSegmentation
Perform segmentation by following inverse direction of gradient vector field.
class IterativeClosestPoint
Registration of two meshes using ICP algorithm.
template<class TImage>
class ITKImageExporter
Export a FAST Image to an ITK image.
template<class TImage>
class ITKImageImporter
Imports and ITK image.
class KalmanFilterModelSegmentation
Kalman filter deformable model segmentation.
class KeyHasher
class KeyPressListener
class KinectStreamer
Streams data RGB and depth data from a kinect device.
class LabelColorRenderer
class LabelModifier
Change labels in a segmentation image.
class LaplacianOfGaussian
Calculate image gradient using Laplacian of Gaussian method.
class LevelSetSegmentation
Level set image segmentation.
class LinePlotter
Plot lines to a graph Qt widget in real-time.
class LineRenderer
Renders lines stored in Mesh data objects.
class Logger
class LungSegmentation
Segment the lung, airways and blood vessels from a CT using seeded region growing and morpohology.
class ManualImageStreamer
class MaximumIntensityProjection
Renders 3D images using ray-casting and maximum intensity projection (MIP)
class MeanValueCoordinatesModel
Mean value coordinates shape model.
class Measurement
class Mesh
Geometry data such as vertices, lines and triangles.
class MeshAccess
class MeshConnection
class MeshFileStreamer
Stream a sequence of Mesh stored in VTK polydata files.
class MeshLine
class MeshOpenCLAccess
class MeshToSegmentation
Converts a line (2D) or triangle (3D) mesh to a segmentation image.
class MeshTriangle
class MeshVertex
class MetaImageExporter
Export an Image to disk with the metaimage format (.mhd/.raw)
class MetaImageImporter
Loads an image stored in the MetaImage format (.mhd/.raw)
class MouseListener
class MovieStreamer
Stream movie files.
class MovieStreamerWorker
class MultigridGradientVectorFlow
Gradient vector flow using the multigrid method.
class MultiViewWindow
Window with multiple views.
class NeuralNetwork
Neural network process object.
class NeuralNetworkNode
class NewestFrameDataChannel
class NoMoreFramesException
class NonLocalMeans
Multiscale Non-Local Means (NLM) smoothing.
class NonMaximumSuppression
Non-maximum suppression of bounding box sets.
class NotImplementedException
class Object
Base class for all FAST objects.
class OpenCLBufferAccess
class OpenCLDevice
class OpenCLImageAccess
class OpenCLProgram
class OpenGLTextureAccess
class OpenIGTLinkStreamer
Stream image or transforms from an OpenIGTLink server.
class OpenVINOEngine
class OutOfBoundsException
class PatchGenerator
Generates a stream of patches from an ImagePyramid or 3D Image.
class PatchStitcher
Stitch a stream of processed patches from the PatchGenerator.
class Pipeline
class PipelineEditor
class PipelineHighlighter
class PipelineSynchronizer
class PipelineWidget
class Plane
Class for a 3D plane.
class Plotter
struct point
class PointComparison
class ProcessObject
Abstract base class for all process objects.
class ProcessObjectRegistry
class ProcessObjectWidget
class QueuedDataChannel
class RandomAccessStreamer
Abstract class of streamer in which any frame can be accessed at any time through an integer index and playbacked can be paused.
class RealSenseStreamer
Streams data RGB and depth data from an Intel RealSense camera.
struct Region
class RegionProperties
Calculate properties, such as area, contour and centroid, for every segmentation region.
class Renderer
Abstract base class for Renderers.
class Reporter
class ReporterEnd
class RidgeEdgeModel
Ridge edge appearance model.
class RidgeTraversalCenterlineExtraction
Extract 3D centerline by following ridge.
class RunLambda
Run a C++ lambda in a FAST pipeline.
class RuntimeMeasurement
A class for runtime measurement.
class RuntimeMeasurementsManager
Manages multiple runtime measurements.
class RunUntilFinished
Calls run on parent PO until output is marked as last frame.
class SceneGraphNode
class SeededRegionGrowing
Segmentation by seeded region growing.
class SegmentationLabelRenderer
Renders text labels on top of Segmentation data.
class SegmentationNetwork
Segmentation neural network process object.
class SegmentationRenderer
Renders 2D segmentation data.
class SegmentationVolumeReconstructor
Reconstruct a stream of 2D segmentation images into a 3D segmentation image.
class Sequence
Sequence data object.
class SetTransformation
Set transformations to spatial data objects.
class Shape
class ShapeModel
template<class DataType>
class SimpleDataObject
class SimpleGUI
class SimpleWindow
A Window with only 1 View.
class SimpleWindow2D
A Window with only 1 View in 2D mode.
class SimpleWindow3D
A Window with only 1 View in 3D mode.
class Skeletonization
Extract the skeleton of 2D segmentation as a 2D image.
class SliceRenderer
Renders a 2D image slice extracted from a 3D image.
class SpatialDataObject
Abstract base class for all spatial data objects.
class StartTimer
class StaticDataChannel
class StepEdgeModel
Step edge appearance model.
class StopTimer
class Streamer
Abstract base class for all Streamers.
class StreamToFileExporter
Write a stream of Mesh or Image data as a sequence of files.
class SurfaceExtraction
Extract triangle mesh from a 3D Image (volume)
class TemplateMatching
Match a template image to an image.
class Tensor
N-Dimensional tensor data object.
class TensorAccess
class TensorFlowEngine
class TensorFlowTensor
class TensorFlowTensorWrapper
class TensorRTEngine
class TensorShape
Object representing the shape of a Tensor.
class TensorToBoundingBoxSet
class TensorToImage
Converts a Tensor with shape HxWxC to a FAST Image.
class TensorToSegmentation
A process object which converts a Tensor to a Segmentation object.
class Text
Text data object.
class TextRenderer
Renders Text data.
class ThreadStopped
class ThresholdVolumeRenderer
Renders 3D images using ray-casting and a threshold.
class TIFFImagePyramidExporter
Export an ImagePyramid to disk in the tiled pyramid TIFF format.
class TIFFImagePyramidImporter
Import image Pyramid stored as tiled multi-page TIFF.
class TissueMicroArrayExtractor
Extract tissue micro arrays (TMAs) from a whole-slide image.
class TissueSegmentation
Segment tissue from a WSI.
class Tracking
class TrackingGUI
class TransferFunction
A class for defining a transfer function used in volume rendering.
class Transform
Data object for a 3D affine transform.
class TransformFileStreamer
class TriangleRenderer
Renders triangle Mesh data.
class TubeSegmentationAndCenterlineExtraction
Segmentation and centerline extraction of tubular structures.
class UFFData
class UFFReader
class UFFScanConvert
class UFFStreamer
Stream ultrasound file format (UFF) data.
class UltrasoundImageCropper
Automatic cropping of an ultrasound scanner image.
class UltrasoundImageEnhancement
Apply a color map and reject on an ultrasound image.
class VectorFieldColorRenderer
Renders a vector field image using colors.
class VectorFieldRenderer
Renders a vector field image using lines.
class VectorMedianFilter
Apply median filter on vector field to reduce noise.
class VertexBufferObjectAccess
class VertexRenderer
Renders vertices as a circular points.
class VideoSurface
class View
class VolumeRenderer
Abstract base class for volume renderers.
class VTKImageExporter
Export a FAST Image to an VTK image.
class VTKImageImporter
Loads a VTK image to FAST.
class VTKMeshExporter
Export a FAST Mesh to an VTK PolyData object.
class VTKMeshFileExporter
Write Mesh to file using the VTK polydata format.
class VTKMeshFileImporter
Reads gemoetry mesh data from a .vtk polydata file.
class VTKtoFAST
class WholeSlideImageImporter
Read a whole slide image from disk.
class Window
class WindowWidget

Enums

enum class MatchingMetric { NORMALIZED_CROSS_CORRELATION, SUM_OF_SQUARED_DIFFERENCES, SUM_OF_ABSOLUTE_DIFFERENCES }
Matching metrics for tracking.
enum class ImageOrdering { ChannelFirst, ChannelLast }
enum class NodeType { UNSPECIFIED, IMAGE, TENSOR }
enum class InferenceDeviceType { ANY, CPU, GPU, VPU, OTHER }
enum class ModelFormat { PROTOBUF, SAVEDMODEL, ONNX, OPENVINO, UFF }
enum class BoundingBoxNetworkType { YOLOv3 }
enum AttributeType { ATTRIBUTE_TYPE_STRING, ATTRIBUTE_TYPE_FLOAT, ATTRIBUTE_TYPE_INTEGER, ATTRIBUTE_TYPE_BOOLEAN }
enum DataType { TYPE_FLOAT, TYPE_UINT8, TYPE_INT8, TYPE_UINT16, TYPE_INT16, TYPE_UNORM_INT16, TYPE_SNORM_INT16 }
enum PlaneType { PLANE_X, PLANE_Y, PLANE_Z }
enum class ImageCompression { UNSPECIFIED, RAW, JPEG, JPEG2000, LZW }
Image compression types for ImagePyramids (TIFF)
enum DeviceType { DEVICE_TYPE_ANY, DEVICE_TYPE_GPU, DEVICE_TYPE_CPU }
enum DevicePlatform { DEVICE_PLATFORM_ANY, DEVICE_PLATFORM_AMD, DEVICE_PLATFORM_NVIDIA, DEVICE_PLATFORM_INTEL, DEVICE_PLATFORM_APPLE, DEVICE_PLATFORM_POCL, DEVICE_PLATFORM_UNKNOWN }
enum DeviceCapability { DEVICE_CAPABILITY_OPENGL_INTEROP }
enum DevicePreference { DEVICE_PREFERENCE_NONE, DEVICE_PREFERENCE_NOT_CONNECTED_TO_SCREEN, DEVICE_PREFERENCE_COMPUTE_UNITS, DEVICE_PREFERENCE_GLOBAL_MEMORY }
enum OpenCLPlatformVendor { PLATFORM_VENDOR_APPLE, PLATFORM_VENDOR_AMD, PLATFORM_VENDOR_INTEL, PLATFORM_VENDOR_NVIDIA, PLATFORM_VENDOR_POCL, PLATFORM_VENDOR_UNKNOWN }
enum DeviceVendor { DEVICE_VENDOR_AMD, DEVICE_VENDOR_INTEL, DEVICE_VENDOR_NVIDIA, DEVICE_VENDOR_UKNOWN }
enum class StreamingMode { NewestFrameOnly, ProcessAllFrames, StoreAllFrames }
Defines the streaming mode for a streamer.
enum class PlottingStyle { BRIGHT, DARK }

Typedefs

using DetectedEdge = struct fast::DetectedEdge
using classifications = std::map<std::string, float>
using point = struct fast::point
using CenterlinePoint = struct fast::CenterlinePoint
template<int NumDimensions>
using TensorData = Eigen::TensorMap<Eigen::Tensor<float, NumDimensions, Eigen::RowMajor, int>>
using LabelColors = std::map<uint, Color>
using VectorXui = Eigen::Matrix<uint, Eigen::Dynamic, 1>
using Vector4ui = Eigen::Matrix<uint, 4, 1>
using Vector3ui = Eigen::Matrix<uint, 3, 1>
using Vector2ui = Eigen::Matrix<uint, 2, 1>
using pixel_deleter_t = std::function<void(void*)>
using unique_pixel_ptr = std::unique_ptr<void, pixel_deleter_t>
using deviceAndScore = struct fast::deviceAndScore
using PlatformDevices = std::pair<cl::Platform, std::vector<cl::Device>>
using LabelNames = std::map<uint, std::string>
Map from label id to label name.

Functions

static auto grow(uchar* segmentation, std::vector<Vector3i> neighbors, std::vector<Vector3i>& voxels, short* data, float threshold, int width, int height, int depth, float previousVolume, float volumeIncreaseLimit, int volumeMinimum) -> int
void regionGrowing(Image::pointer volume, Image::pointer segmentation, const Vector3i seed)
auto linearPosition(Vector3i pos, Vector3i size) -> uint
auto position3D(int pos, Vector3i size) -> Vector3i
auto solveQuadratic(const std::vector<double>& G, const std::unique_ptr<double[]>& speed, Vector3i pos, Vector3i size) -> double
void growFromPointsAdded(const std::vector<Vector3i>& points, const std::vector<double>& G, std::unordered_set<int>& Sc, std::unordered_set<int>& processed, Vector3i size)
auto getPeakMemoryUsage(Image::pointer input, bool use16bit, bool writingTo3DTextures) -> uint
auto calculateLaplacian(ImageAccess::pointer& input, ImageAccess::pointer& result, Vector2i position) -> Vector2f
auto calculateLaplacian(ImageAccess::pointer& input, ImageAccess::pointer& result, Vector3i position) -> Vector3f
auto calculateGVFVectorFieldResidual(Image::pointer inputVectorField, Image::pointer vectorField, float mu) -> double
auto calculateNewSize(Vector3ui size) -> Vector3ui
auto cornersAreAdjacent(Vector3f cornerA, Vector3f cornerB, Image::pointer input) -> bool
void getWidth(std::vector<Vector3f> intersectionPoints, Image::pointer input)
auto colorDistance(Vector3f e1, Vector3f e2) -> double
auto RGB2YIQ(Vector3f rgb) -> Vector3f
auto rearrangeMatrixToClosestPoints(const MatrixXf& A, const MatrixXf& B, const MatrixXf& Acolors, const MatrixXf& Bcolors, float colorWeight) -> MatrixXf
auto getCentroid(const MatrixXf m) -> Vector3f
auto sign(float value) -> float
auto findEdge(std::vector<float> intensityProfile, const float intensityThreshold, const int size, const RidgeEdgeModel::EdgeType edgeType) -> DetectedEdge
auto findEdge(std::vector<float> intensityProfile, const float intensityThreshold, StepEdgeModel::EdgeType type) -> DetectedEdge
auto isInBounds(Image::pointer image, const Vector4f& position) -> bool
auto getValue(void* pixelPointer, Image::pointer image, const Vector4f& position) -> float
auto transformPosition(Vector2f position, Matrix2f RS, Vector2f T, Vector2f C) -> Vector2f
auto getModelFileExtension(ModelFormat format) -> std::string
auto getModelFormat(std::string filename) -> ModelFormat
auto getModelFormatName(ModelFormat format) -> std::string
static auto getShape(const tensorflow::NodeDef& node) -> TensorShape
static auto getTensorShape(nvinfer1::Dims dims) -> TensorShape
auto elementSize(nvinfer1::DataType t) -> unsigned int
auto safeCudaMalloc(size_t memSize) -> void*
auto shapeToDims(TensorShape shape) -> nvinfer1::Dims
auto getPosition(int x, int nrOfClasses, int j, int size, ImageOrdering ordering) -> int
auto getPosition(int x, int y, int nrOfClasses, int j, int width, int height) -> int
auto sigmoid(float x) -> float
auto getRequiredHistogramPyramidSize(Image::pointer input) -> unsigned int
static auto calculateMeanIntensity(ImageAccess::pointer& access, const Vector2i start, const Vector2i size) -> float
auto squaredMagnitude(ImageAccess::pointer& vectorFieldAccess, Vector3i position) -> float
auto getNormalizedValue(ImageAccess::pointer& vectorField, Vector3i pos, uint component) -> float
auto gradientNormalized(ImageAccess::pointer& vectorField, Vector3i pos, int volumeComponent, int dimensions) -> Vector3f
auto gradient(ImageAccess::pointer& vectorField, Vector3i pos, int volumeComponent, int dimensions) -> Vector3f
void sortEigenvaluesAndVectors(Vector3f* eigenvaluesOut, Matrix3f* eigenvectorsOut)
auto getTubeDirection(ImageAccess::pointer& vectorField, Vector3i pos, Vector3ui size, bool normalize) -> Vector3f
void doEigen(ImageAccess::pointer& vectorField, Vector3i pos, Vector3ui size, bool normalize, Vector3f* lambda, Vector3f* e1, Vector3f* e2, Vector3f* e3)
void copyToLineSet(std::stack<CenterlinePoint> points, std::vector<MeshVertex>& vertices, std::vector<MeshLine>& lines, Vector3f spacing)
void extractCenterlines(Image::pointer TDF, Image::pointer vectorField, Image::pointer radius, int* centerlines, unordered_map<int, int>& centerlineDistances, unordered_map<int, std::stack<CenterlinePoint>>& centerlineStacks, std::vector<MeshVertex>& vertices, std::vector<MeshLine>& lines, int maxBelowTlow, bool* useFirstRadius)
auto floodFill(ImageAccess::pointer& access, Vector3ui size, Vector3i startPosition) -> std::vector<Vector3i>
static void copyPipelineFilesRecursivly(std::string pipelineSourcePath, std::string pipelineDestinationPath)
void downloadTestDataIfNotExists(std::string destination, bool force)
template<typename T>
auto getScalarAsFloat(T* data, VectorXi position, Image::pointer image, uchar channel) -> float
template<typename T>
auto getScalarAsFloat(T* data, uint position, Image::pointer image, uchar channel) -> float
template<typename T>
void setScalarAsFloat(T* data, VectorXi position, Image::pointer image, float value, uchar channel)
template<typename T>
void setScalarAsFloat(T* data, uint position, Image::pointer image, float value, uchar channel)
auto operator<<(std::ostream& os, DataBoundingBox& object) -> std::ostream&
auto getCTypeAsString(DataType type) -> std::string
auto getOpenCLImageFormat(OpenCLDevice::pointer device, cl_mem_object_type imageType, DataType type, unsigned int channels) -> cl::ImageFormat
auto getSizeOfDataType(DataType type, unsigned int nrOfComponents) -> size_t
auto getDefaultIntensityLevel(DataType type) -> float
auto getDefaultIntensityWindow(DataType type) -> float
void deleteArray(void* data, DataType type)
auto allocatePixelArray(std::size_t size, DataType type) -> unique_pixel_ptr
template<class T>
auto padData(T* data, unsigned int size, unsigned int nrOfChannels) -> void*
auto adaptDataToImage(const void*const data, cl_channel_order order, unsigned int size, DataType type, unsigned int nrOfChannels) -> const void*const
template<class T>
auto removePadding(T* data, unsigned int size, unsigned int nrOfChannels) -> void*
auto adaptImageDataToHostData(unique_pixel_ptr data, cl_channel_order order, unsigned int size, DataType type, unsigned int nrOfChannels) -> unique_pixel_ptr
template<typename T>
auto pixel_deleter(void const* data) -> void -> auto
template<typename T>
auto make_unique_pixel(T* ptr) -> unique_pixel_ptr -> auto
auto operator==(const MeshVertex& a, const MeshVertex& b) -> bool
auto createInteropContextProperties(const cl_platform_id& platform, cl_context_properties OpenGLContext, cl_context_properties display) -> cl_context_properties*
auto compareScores(deviceAndScore a, deviceAndScore b) -> bool
auto intToString(int number) -> std::string
auto createInteropContextProperties(const cl::Platform& platform, cl_context_properties OpenGLContext, cl_context_properties display) -> cl_context_properties*
auto readFile(std::string filename) -> std::string
auto getDevice(cl::CommandQueue queue) -> cl::Device
auto matchExtension(std::string extension, std::string extension2) -> bool
template<class T>
auto writeToRawFile(std::string filename, T* data, unsigned int numberOfElements, bool useCompression) -> std::size_t
template<class T>
static auto readRawData(const DiPixel* pixelData) -> void*
static auto getDataType(const DicomImage& image) -> DataType
static auto getDataFromImage(const DicomImage& image, DataType& type) -> void*
static auto inserSliceFromImage(const DicomImage& image, int width, int height, int sliceNr, void* data) -> void*
static void terminateHandler()
auto getProcessObjectFromRegistry(std::string name) -> std::shared_ptr<ProcessObject>
auto getAvailablePipelines(std::string path = "") -> std::vector<Pipeline>
static auto isStreamer(ProcessObject* po) -> bool
template<>
auto operator<<(Reporter report, const ReporterEnd& end) -> Reporter
template<class T>
auto operator<<(Reporter report, const T& content) -> Reporter
static auto createFASTImageFromMessage(igtl::ImageMessage::Pointer message, ExecutionDevice::pointer device) -> Image::pointer
static auto get_depth_scale(rs2::device dev) -> float
auto linearInterpolate(double a, double b, double t) -> double
void cart2pol(double x, double y, double& r, double& th)
void pol2cart(double r, double th, double& x, double& y)
auto normalizeToGrayScale(double dBPixel, int dynamic_range = 60, int gain = 10) -> unsigned int
auto file_info(hid_t loc_id, const char* name, const H5L_info_t* linfo, void* opdata) -> herr_t
static auto readStringAttribute(const H5::Attribute& att) -> std::string
auto log2(double n) -> double
auto round(double n) -> double
auto round(double n, int decimals) -> double
auto allocateDataArray(unsigned int voxels, DataType type, unsigned int nrOfComponents) -> void*
template<class T>
void getMaxAndMinFromOpenCLImageResult(void* voidData, unsigned int size, unsigned int nrOfComponents, float* min, float* max)
auto getPowerOfTwoSize(unsigned int size) -> unsigned int
void getIntensitySumFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* sum)
void getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* min, float* max)
void getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float* min, float* max)
void getMaxAndMinFromOpenCLBuffer(OpenCLDevice::pointer device, cl::Buffer buffer, unsigned int size, DataType type, float* min, float* max)
auto createRegion(unsigned int x, unsigned int y, unsigned int z) -> cl::size_t<3>
auto createRegion(Vector3ui size) -> cl::size_t<3>
auto createOrigoRegion() -> cl::size_t<3>
auto getCLErrorString(cl_int err) -> std::string
auto replace(std::string str, std::string find, std::string replacement) -> std::string
auto split(const std::string input, const std::string& delimiter = " ", float removeEmpty = true) -> std::vector<std::string>
auto loadPerspectiveMatrix(float fovy, float aspect, float zNear, float zFar) -> Matrix4f
auto loadOrthographicMatrix(float left, float right, float bottom, float top, float zNear, float zFar) -> Matrix4f
void createDirectory(std::string path)
void createDirectories(std::string path)
auto fileExists(std::string filename) -> bool
auto isFile(const std::string& path) -> bool
auto isDir(const std::string& path) -> bool
auto join(std::string path) -> std::string
static auto compare_nocase(const std::string& first, const std::string& second) -> bool
auto getDirectoryList(std::string path, bool getFiles = true, bool getDirectories = false) -> std::vector<std::string>
auto getDirName(std::string path) -> std::string
auto currentDateTime(std::string format = "%Y-%m-%d-%H%M%S") -> std::string
auto getModifiedDate(std::string filename) -> std::string
void extractZipFile(std::string zipFilepath, std::string destination)
auto stringToLower(std::string s) -> std::string
auto stringToUpper(std::string s) -> std::string
template<class T>
auto square(T x) -> T
template<typename ... Args>
auto format(std::string format, Args && ... args) -> std::string
template<class T>
auto min(T a, T b) -> T
template<class T>
auto max(T a, T b) -> T
template<class T>
auto sign(T value) -> T
template<class T>
auto getSumFromOpenCLImageResult(void* voidData, unsigned int size, unsigned int nrOfComponents) -> float
template<class T>
void getMaxAndMinFromData(void* voidData, unsigned int nrOfElements, float* min, float* max)
template<class T>
auto getSumFromData(void* voidData, unsigned int nrOfElements) -> float
static void ltrim(std::string& s)
static void rtrim(std::string& s)
static void trim(std::string& s)
template<class T>
static void hash_combine(std::size_t& seed, const T& v)
template<typename ... T>
auto join(const std::string& path1, T... args) -> std::string
template<class T>
auto make_uninitialized_unique(std::size_t size) -> std::unique_ptr<T>
FAST_SIMPLE_DATA_OBJECT(FloatScalar, float)
FAST_SIMPLE_DATA_OBJECT(FloatPoint, Vector2f)

Variables

fast::Logger gLogger
std::mutex buildBinaryMutex

Enum documentation

enum class fast::ImageOrdering

Different engines prefer different image dimension orderings.

enum class fast::ModelFormat

Neural network modell formats

enum fast::AttributeType

enum fast::DataType

enum fast::PlaneType

enum class fast::StreamingMode

Defines the streaming mode for a streamer.

Typedef documentation

typedef std::map<std::string, float> fast::classifications

template<int NumDimensions>
using fast::TensorData = Eigen::TensorMap<Eigen::Tensor<float, NumDimensions, Eigen::RowMajor, int>>

using fast::LabelColors = std::map<uint, Color>

typedef Eigen::Matrix<uint, Eigen::Dynamic, 1> fast::VectorXui

typedef Eigen::Matrix<uint, 4, 1> fast::Vector4ui

typedef Eigen::Matrix<uint, 3, 1> fast::Vector3ui

typedef Eigen::Matrix<uint, 2, 1> fast::Vector2ui

using fast::pixel_deleter_t = std::function<void(void*)>

using fast::unique_pixel_ptr = std::unique_ptr<void, pixel_deleter_t>

typedef std::pair<cl::Platform, std::vector<cl::Device>> fast::PlatformDevices

using fast::LabelNames = std::map<uint, std::string>

Map from label id to label name.

Function documentation

static int fast::grow(uchar* segmentation, std::vector<Vector3i> neighbors, std::vector<Vector3i>& voxels, short* data, float threshold, int width, int height, int depth, float previousVolume, float volumeIncreaseLimit, int volumeMinimum)

void fast::regionGrowing(Image::pointer volume, Image::pointer segmentation, const Vector3i seed)

Vector3i fast::position3D(int pos, Vector3i size)

double fast::solveQuadratic(const std::vector<double>& G, const std::unique_ptr<double[]>& speed, Vector3i pos, Vector3i size)

void fast::growFromPointsAdded(const std::vector<Vector3i>& points, const std::vector<double>& G, std::unordered_set<int>& Sc, std::unordered_set<int>& processed, Vector3i size)

uint fast::getPeakMemoryUsage(Image::pointer input, bool use16bit, bool writingTo3DTextures)

double fast::calculateGVFVectorFieldResidual(Image::pointer inputVectorField, Image::pointer vectorField, float mu)

Calculate average error/residual for each pixel

bool fast::cornersAreAdjacent(Vector3f cornerA, Vector3f cornerB, Image::pointer input)

void fast::getWidth(std::vector<Vector3f> intersectionPoints, Image::pointer input)

Vector3f fast::RGB2YIQ(Vector3f rgb)

Parameters
rgb

Convert RGB vector to YIQ color space. Y is luminance, while I and Q represent the color in a 2D space.

MatrixXf fast::rearrangeMatrixToClosestPoints(const MatrixXf& A, const MatrixXf& B, const MatrixXf& Acolors, const MatrixXf& Bcolors, float colorWeight)

Create a new matrix which is matrix A rearranged. This matrix has the same size as B

DetectedEdge fast::findEdge(std::vector<float> intensityProfile, const float intensityThreshold, const int size, const RidgeEdgeModel::EdgeType edgeType)

DetectedEdge fast::findEdge(std::vector<float> intensityProfile, const float intensityThreshold, StepEdgeModel::EdgeType type)

float fast::getValue(void* pixelPointer, Image::pointer image, const Vector4f& position)

Vector2f fast::transformPosition(Vector2f position, Matrix2f RS, Vector2f T, Vector2f C)

std::string fast::getModelFileExtension(ModelFormat format)

Get model format file extension.

ModelFormat fast::getModelFormat(std::string filename)

Get model format of the given file.

std::string fast::getModelFormatName(ModelFormat format)

Parameters
format

Get name of model format as string

static TensorShape fast::getShape(const tensorflow::NodeDef& node)

unsigned int fast::elementSize(nvinfer1::DataType t)

int fast::getPosition(int x, int nrOfClasses, int j, int size, ImageOrdering ordering)

Parameters
x
nrOfClasses
j
size
ordering

Calculate array position based on image ordering

int fast::getPosition(int x, int y, int nrOfClasses, int j, int width, int height)

Parameters
x
y
nrOfClasses
j
width
height

Calculate array position based on image ordering

static float fast::calculateMeanIntensity(ImageAccess::pointer& access, const Vector2i start, const Vector2i size)

Vector3f fast::gradientNormalized(ImageAccess::pointer& vectorField, Vector3i pos, int volumeComponent, int dimensions)

Vector3f fast::gradient(ImageAccess::pointer& vectorField, Vector3i pos, int volumeComponent, int dimensions)

void fast::doEigen(ImageAccess::pointer& vectorField, Vector3i pos, Vector3ui size, bool normalize, Vector3f* lambda, Vector3f* e1, Vector3f* e2, Vector3f* e3)

void fast::copyToLineSet(std::stack<CenterlinePoint> points, std::vector<MeshVertex>& vertices, std::vector<MeshLine>& lines, Vector3f spacing)

void fast::extractCenterlines(Image::pointer TDF, Image::pointer vectorField, Image::pointer radius, int* centerlines, unordered_map<int, int>& centerlineDistances, unordered_map<int, std::stack<CenterlinePoint>>& centerlineStacks, std::vector<MeshVertex>& vertices, std::vector<MeshLine>& lines, int maxBelowTlow, bool* useFirstRadius)

static void fast::copyPipelineFilesRecursivly(std::string pipelineSourcePath, std::string pipelineDestinationPath)

void fast::downloadTestDataIfNotExists(std::string destination, bool force)

template<typename T>
float fast::getScalarAsFloat(T* data, VectorXi position, Image::pointer image, uchar channel)

template<typename T>
float fast::getScalarAsFloat(T* data, uint position, Image::pointer image, uchar channel)

template<typename T>
void fast::setScalarAsFloat(T* data, VectorXi position, Image::pointer image, float value, uchar channel)

template<typename T>
void fast::setScalarAsFloat(T* data, uint position, Image::pointer image, float value, uchar channel)

std::ostream& fast::operator<<(std::ostream& os, DataBoundingBox& object)

std::string fast::getCTypeAsString(DataType type)

cl::ImageFormat fast::getOpenCLImageFormat(OpenCLDevice::pointer device, cl_mem_object_type imageType, DataType type, unsigned int channels)

size_t fast::getSizeOfDataType(DataType type, unsigned int nrOfComponents)

void fast::deleteArray(void* data, DataType type)

unique_pixel_ptr fast::allocatePixelArray(std::size_t size, DataType type)

template<class T>
void* fast::padData(T* data, unsigned int size, unsigned int nrOfChannels)

const void*const fast::adaptDataToImage(const void*const data, cl_channel_order order, unsigned int size, DataType type, unsigned int nrOfChannels)

template<class T>
void* fast::removePadding(T* data, unsigned int size, unsigned int nrOfChannels)

unique_pixel_ptr fast::adaptImageDataToHostData(unique_pixel_ptr data, cl_channel_order order, unsigned int size, DataType type, unsigned int nrOfChannels)

template<typename T>
auto fast::pixel_deleter(void const* data) -> void

template<typename T>
auto fast::make_unique_pixel(T* ptr) -> unique_pixel_ptr

bool fast::operator==(const MeshVertex& a, const MeshVertex& b)

cl_context_properties* fast::createInteropContextProperties(const cl_platform_id& platform, cl_context_properties OpenGLContext, cl_context_properties display)

std::string fast::intToString(int number)

cl_context_properties* fast::createInteropContextProperties(const cl::Platform& platform, cl_context_properties OpenGLContext, cl_context_properties display)

std::string fast::readFile(std::string filename)

cl::Device fast::getDevice(cl::CommandQueue queue)

bool fast::matchExtension(std::string extension, std::string extension2)

template<class T>
std::size_t fast::writeToRawFile(std::string filename, T* data, unsigned int numberOfElements, bool useCompression)

template<class T>
static void* fast::readRawData(const DiPixel* pixelData)

static DataType fast::getDataType(const DicomImage& image)

static void* fast::getDataFromImage(const DicomImage& image, DataType& type)

static void* fast::inserSliceFromImage(const DicomImage& image, int width, int height, int sliceNr, void* data)

static void fast::terminateHandler()

std::shared_ptr<ProcessObject> fast::getProcessObjectFromRegistry(std::string name)

std::vector<Pipeline> fast::getAvailablePipelines(std::string path = "")

Retrieve a list of all pipelines stored in .fpl files in the specified pipeline directory

static bool fast::isStreamer(ProcessObject* po)

template<>
Reporter fast::operator<<(Reporter report, const ReporterEnd& end)

template<class T>
Reporter fast::operator<<(Reporter report, const T& content)

static Image::pointer fast::createFASTImageFromMessage(igtl::ImageMessage::Pointer message, ExecutionDevice::pointer device)

static float fast::get_depth_scale(rs2::device dev)

double fast::linearInterpolate(double a, double b, double t)

void fast::cart2pol(double x, double y, double& r, double& th)

void fast::pol2cart(double r, double th, double& x, double& y)

unsigned int fast::normalizeToGrayScale(double dBPixel, int dynamic_range = 60, int gain = 10)

herr_t fast::file_info(hid_t loc_id, const char* name, const H5L_info_t* linfo, void* opdata)

static std::string fast::readStringAttribute(const H5::Attribute& att)

double fast::log2(double n)

double fast::round(double n)

double fast::round(double n, int decimals)

void* fast::allocateDataArray(unsigned int voxels, DataType type, unsigned int nrOfComponents)

template<class T>
void fast::getMaxAndMinFromOpenCLImageResult(void* voidData, unsigned int size, unsigned int nrOfComponents, float* min, float* max)

unsigned int fast::getPowerOfTwoSize(unsigned int size)

void fast::getIntensitySumFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* sum)

void fast::getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* min, float* max)

void fast::getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float* min, float* max)

void fast::getMaxAndMinFromOpenCLBuffer(OpenCLDevice::pointer device, cl::Buffer buffer, unsigned int size, DataType type, float* min, float* max)

cl::size_t<3> fast::createRegion(unsigned int x, unsigned int y, unsigned int z)

cl::size_t<3> fast::createRegion(Vector3ui size)

cl::size_t<3> fast::createOrigoRegion()

std::string fast::getCLErrorString(cl_int err)

std::string fast::replace(std::string str, std::string find, std::string replacement)

std::vector<std::string> fast::split(const std::string input, const std::string& delimiter = " ", float removeEmpty = true)

Parameters
input string
delimiter string
removeEmpty
Returns vector of strings

Function for splitting a string

Matrix4f fast::loadPerspectiveMatrix(float fovy, float aspect, float zNear, float zFar)

Matrix4f fast::loadOrthographicMatrix(float left, float right, float bottom, float top, float zNear, float zFar)

void fast::createDirectory(std::string path)

Creates a directory at the given path. Throws exception if it fails

void fast::createDirectories(std::string path)

Creates all directories in the given path. Throws exception if it fails

bool fast::fileExists(std::string filename)

Parameters
filename

Check if file exists

bool fast::isFile(const std::string& path)

Parameters
path

Check if path is a file.

bool fast::isDir(const std::string& path)

Parameters
path

Check if path is a directory.

std::string fast::join(std::string path)

Parameters
path

Removes trailing /

static bool fast::compare_nocase(const std::string& first, const std::string& second)

std::vector<std::string> fast::getDirectoryList(std::string path, bool getFiles = true, bool getDirectories = false)

Parameters
path
getFiles Set to true to find files in directory
getDirectories Set to true to find subdirectories
Returns list of files or subdirectories

Returns a list of all files in a directory

std::string fast::getDirName(std::string path)

Parameters
path

Returns the dir name of the given path. Example: getDirName("/home/user/something/file.txt") returns home/user/something/.

std::string fast::currentDateTime(std::string format = "%Y-%m-%d-%H%M%S")

Parameters
format see http://en.cppreference.com/w/cpp/chrono/c/strftime

Returns a string of the current date

std::string fast::getModifiedDate(std::string filename)

Parameters
filename

Get modified date of a file as a string

void fast::extractZipFile(std::string zipFilepath, std::string destination)

Parameters
zipFilepath path to zip file to extract
destination path to where to extract the conents of the zip file

Extract the contents of a zip file to a given destination.

std::string fast::stringToLower(std::string s)

std::string fast::stringToUpper(std::string s)

template<class T>
T fast::square(T x)

Template parameters
T
Parameters
x a numeric value
Returns x*x

Does simply x^2 = x*x

template<typename ... Args>
std::string fast::format(std::string format, Args && ... args)

template<class T>
T fast::min(T a, T b)

template<class T>
T fast::max(T a, T b)

template<class T>
T fast::sign(T value)

template<class T>
float fast::getSumFromOpenCLImageResult(void* voidData, unsigned int size, unsigned int nrOfComponents)

template<class T>
void fast::getMaxAndMinFromData(void* voidData, unsigned int nrOfElements, float* min, float* max)

template<class T>
float fast::getSumFromData(void* voidData, unsigned int nrOfElements)

static void fast::ltrim(std::string& s)

static void fast::rtrim(std::string& s)

static void fast::trim(std::string& s)

template<class T>
static void fast::hash_combine(std::size_t& seed, const T& v)

template<typename ... T>
std::string fast::join(const std::string& path1, T... args)

Template parameters
T
Parameters
path1
args

Join multiple paths.

template<class T>
std::unique_ptr<T> fast::make_uninitialized_unique(std::size_t size)

Template parameters
T
Parameters
size

Same as make_unique(std::size_t size), except this version will not value initialize the dynamic array. This is useful for large arrays.

Variable documentation

std::mutex fast::buildBinaryMutex