fast namespace

FAST namespace - All FAST code lives in this namespace.

Namespaces

namespace SceneGraph

Classes

class AddTransformation
Add transformations to spatial data objects.
class AffineTransformation
class AffineTransformationFileStreamer
class AirwaySegmentation
class AlphaBlendingVolumeRenderer
Renders 3D images/volumes using ray-casting and alpha blending.
class AppearanceModel
class Attribute
class AttributeValue
class BadCastException
class Batch
Batch data object.
class BinaryThresholding
class BlockMatching
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
class BoundingBoxSetOpenGLAccess
class Camera
class CameraAccess
class CameraStreamer
Stream images from a (web)camera.
class CameraVideoSurface
class CameraWorker
class CardinalSplineModel
class CenterlineExtraction
struct CenterlinePoint
class ClariusStreamer
Stream ultrasound images from a Clarius scanner.
class ClassificationToText
class CoherentPointDrift
class CoherentPointDriftAffine
class CoherentPointDriftRigid
class Color
class ComputationThread
class Config
template<class DataType>
class DataAccess
class DataBoundingBox
Defines the extent of a spatial data object.
class DataChannel
class DataObject
Abstract data object class.
struct Destroy
struct DetectedEdge
struct deviceAndScore
class DeviceCriteria
class DeviceManager
class DICOMFileImporter
Read DICOM image data (both 2D and 3D).
class Dilation
class DoesNotExistException
class DualViewWindow
class EllipseModel
class EmptyProcessObject
class Erosion
class EulerGradientVectorFlow
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 GaussianSmoothingFilter
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
class IGTLSocketWrapper
class Image
Image data.
class ImageAccess
class ImageChannelConverter
class ImageClassificationNetwork
Image classification data object.
class ImageCropper
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
class ImageImporter
Read JPG/PNG/BMP/TIFF images.
class ImageInverter
class ImageMovingAverage
class ImageMultiply
class ImagePyramid
Image pyramid data object.
class ImagePyramidAccess
class ImagePyramidLevel
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
class ImageRenderer
Renders 2D Image data objects, both in 2D and 3D.
class ImageResampler
class ImageResizer
class ImageSharpening
class ImageSlicer
class ImagesToSequence
Process object for converting a stream of images to a Sequence data object.
class ImageToBatchGenerator
class ImageWeightedMovingAverage
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 InverseGradientSegmentation
class IterativeClosestPoint
template<class TImage>
class ITKImageExporter
Export a FAST Image to an ITK image.
template<class TImage>
class ITKImageImporter
Imports and ITK image.
class KalmanFilter
class KeyHasher
class KeyPressListener
class KinectStreamer
Streams data RGB and depth data from a kinect device.
class KinectTracking
class KinectTrackingGUI
class LabelColorRenderer
class LabelModifier
class LaplacianOfGaussian
class LevelSetSegmentation
class LinePlotter
class LineRenderer
Renders lines stored in Mesh data objects.
class Logger
class LungSegmentation
class ManualImageStreamer
class MaximumIntensityProjection
Renders 3D images using ray-casting and maximum intensity projection (MIP)
class MeanValueCoordinatesModel
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
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
class MultiViewWindow
class NeuralNetwork
Neural network process object.
class NewestFrameDataChannel
class NoMoreFramesException
class NonLocalMeans
class NonMaximumSuppression
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
class PatchStitcher
class Pipeline
class PipelineEditor
class PipelineHighlighter
class PipelineSynchronizer
class PipelineWidget
class Plane
class Plotter
struct point
class PointComparison
class ProcessObject
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
class Renderer
Abstract base class for Renderers.
class Reporter
class ReporterEnd
class RidgeEdgeModel
class RidgeTraversalCenterlineExtraction
class RunLambda
class RunLambdaOnLastFrame
class RuntimeMeasurement
A class for runtime measurement.
class RuntimeMeasurementsManager
class ScaleImage
class SceneGraphNode
class SeededRegionGrowing
class Segmentation
Segmentation image data object.
class SegmentationAlgorithm
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
class Sequence
Sequence data object.
class SetTransformation
class Shape
class ShapeModel
template<class DataType, typename AccessObject>
class SimpleDataObject
class SimpleGUI
class SimpleWindow
class Skeletonization
class SliceRenderer
Renders a 2D image slice extracted from a 3D image.
class SpatialDataObject
class StaticDataChannel
class StepEdgeModel
class Streamer
Abstract base class for all Streamers.
class StreamExporter
class StreamToFileExporter
Write a stream of Mesh or Image data as a sequence of files.
class SurfaceExtraction
class TemplateMatching
class Tensor
N-Dimensional tensor data object.
class TensorAccess
class TensorFlowEngine
class TensorFlowTensor
class TensorFlowTensorWrapper
class TensorRTEngine
class TensorShape
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 TissueSegmentation
class TransferFunction
A class for defining a transfer function used in volume rendering.
class TriangleRenderer
Renders triangle Mesh data.
class TubeSegmentationAndCenterlineExtraction
class UFFData
class UFFReader
class UFFScanConvert
class UFFStreamer
Stream ultrasound file format (UFF) data.
class UltrasoundImageCropper
class UltrasoundImageEnhancement
class VectorFieldColorRenderer
Renders a vector field image using colors.
class VectorFieldRenderer
Renders a vector field image using lines.
class VectorMedianFilter
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 ImageOrdering { ChannelFirst, ChannelLast }
enum class NodeType { IMAGE, TENSOR }
enum class InferenceDeviceType { ANY, CPU, GPU, VPU, OTHER }
enum class ModelFormat { PROTOBUF, SAVEDMODEL, ONNX, OPENVINO, UFF }
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 { 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_UKNOWN }
enum DeviceVendor { DEVICE_VENDOR_AMD, DEVICE_VENDOR_INTEL, DEVICE_VENDOR_NVIDIA, DEVICE_VENDOR_UKNOWN }
enum StreamingMode { STREAMING_MODE_NEWEST_FRAME_ONLY, STREAMING_MODE_STORE_ALL_FRAMES, STREAMING_MODE_PROCESS_ALL_FRAMES }

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>>
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>>

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, Segmentation::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 getPosition(int x, int y, int nrOfClasses, int j, int width, int height, ImageOrdering ordering) -> int
auto sigmoid(float x) -> float
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
auto elementSize(nvinfer1::DataType t) -> unsigned int
auto safeCudaMalloc(size_t memSize) -> void*
auto shapeToDims(TensorShape shape) -> nvinfer1::Dims
static auto getTensorShape(nvinfer1::Dims dims) -> TensorShape
auto getPosition(int x, int nrOfClasses, int j, int size, ImageOrdering ordering) -> int
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 getProcessObject(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::ImageCompression

Image compression types for ImagePyramids (TIFF)

enum fast::StreamingMode

Typedef documentation

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

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

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

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)

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)

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

Parameters
x
y
nrOfClasses
j
width
height
ordering

Calculate array position based on image ordering

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

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::getProcessObject(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