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

Applies a colormap on an image to create a new image.

class Attribute

class AttributeObject

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

Renders a set of bounding boxes.

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 ButtonWidget

A button widget.

class ButtonWidgetCallback

Callback class for ButtonWidget Used primarily by pyFAST.

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 Colormap

Colormap data structure.

class ColorToGrayscale

class Compressed

class ComputationThread

class Concatenate

Concatenate two images or two tensors.

class Config

class DataBoundingBox

Defines the extent of a spatial data object.

class DataChannel

class DataHub

Object uses to browse and download data, models and pipelines from the FAST DataHub.

class DataHubBrowser

A widget to browse the DataHub.

class DataHubItemWidget

A widget representing an item in the DataHubBrowser.

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 DownloadProgressWidget

A widget to display progress of downloading and item from DataHub.

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 EnvelopeAndLogCompressor

Performs normalized envelope detection and log compression on IQ data.

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 GrayscaleToColor

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 ImageFlipper

Flip images.

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 ImageToImageNetwork

Image-to-Image neural network process object.

class ImageTransposer

Transpose images.

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 Interleave

Interleaves input data streams into one output stream.

class InterleavePlayback

Interleaves input data streams into one output stream with playback control.

class InverseGradientSegmentation

Perform segmentation by following inverse direction of gradient vector field.

class IsotropicResampler

Resample an image so that the the pixel spacing is equal in both directions.

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

A struct/class representing a neural network input/output node.

class NewestFrameDataChannel

class NIFTIFile

class NIFTIImporter

Import NIfTI image files.

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 ONNXRuntimeEngine

Microsofts ONNX Runtime inference engine with DirectX/ML support.

class OpenCLBufferAccess

class OpenCLDevice

class OpenCLImageAccess

class OpenCLProgram

class OpenGLTextureAccess

class OpenIGTLinkStreamer

Stream image or transforms from an OpenIGTLink server.

class OpenVINOEngine

class OpenVINOInfer

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

A class representing a text pipeline.

class PipelineEditor

class PipelineHighlighter

class PipelineSynchronizer

Synchronize multiple process objects This PO takes in N input connections and creates N output connections. It keeps the last frame of every connection, and every time a connection has a new data frame, it send out the latest frame to all output connections.

class PipelineWidget

class Plane

Class for a 3D plane.

class PlaybackWidget

A widget to control playback of a RandomAccessStreamer.

class Plotter

struct point

class PointComparison

class ProcessObject

Abstract base class for all process objects.

class ProcessObjectRegistry

class ProcessObjectWidget

class Progress

A utility class for keeping track of progress and printing progress to the console.

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 RenderToImage

Render to an image.

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 ScanConverter

Scan convert beamspace image.

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 SlicerWindow

Window for showing slices of 3D data.

class SliderWidget

A slider widget to change a numerical parameter.

class SliderWidgetCallback

Callback class for SliderWidget Used primarily by pyFAST.

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

Convert a tensor to a set of bounding boxes.

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

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 VertexTensorToSegmentation

Convert a tensor of vertex positions (graph) to a segmentation.

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

Abstract base class for windows.

class WindowWidget

class ZeroMeanUnitVariance

Normalize intensities of an image to have zero mean and unit variance.

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 }

Type of bounding box network Used to determine how the output tensor of a bounding box network should be converted to a set of bounding boxes.

enum AttributeType { ATTRIBUTE_TYPE_STRING, ATTRIBUTE_TYPE_FLOAT, ATTRIBUTE_TYPE_INTEGER, ATTRIBUTE_TYPE_BOOLEAN }

enum class ImageCompression { UNSPECIFIED, RAW, JPEG, JPEG2000, LZW, NEURAL_NETWORK, DEFLATE }

Image compression types for ImagePyramids.

enum DataType { TYPE_FLOAT, TYPE_UINT8, TYPE_INT8, TYPE_UINT16, TYPE_INT16, TYPE_UNORM_INT16, TYPE_SNORM_INT16, TYPE_UINT32, TYPE_INT32 }

enum PlaneType { PLANE_X, PLANE_Y, PLANE_Z }

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 }

enum class WidgetPosition { BOTTOM, TOP, LEFT, RIGHT }

Typedefs

using DetectedEdge = struct fast::DetectedEdge

using classifications = std::map<std::string, float>

using Connections = std::vector<std::vector<MeshLine>>

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 StringMap = std::map<std::string, std::string>

using DataMap = std::map<std::string, std::shared_ptr<DataObject>>

using ProcessObjectMap = std::map<std::string, std::shared_ptr<ProcessObject>>

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

template<typename T>

auto to_string_with_precision(const T a_value, const int n = 6) -> std::string

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

auto print_shape(const std::vector<int64_t>& v) -> 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 getPosition(int x, int nrOfClasses, int j) -> 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 pol2cart(float r, float th, float& x, float& y)

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

auto getHomePath() -> std::string

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)

void jpegErrorExit(j_common_ptr cinfo)

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 operator!=(const TensorShape& a, const TensorShape& b) -> bool

auto operator==(const TensorShape& a, const TensorShape& b) -> bool

static auto getJSONFromURL(const std::string& url) -> QJsonDocument

static auto getConsoleWidth() -> int

static auto checkMinVersion(std::string version, std::string minVersion) -> bool

static auto checkMaxVersion(std::string version, std::string maxVersion) -> 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*

template<class T>

void read(std::unique_ptr<NIFTIFile>& file, int64_t offset, T& data)

template<class T>

void read(std::unique_ptr<NIFTIFile>& file, T& data)

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

FAST_SIMPLE_DATA_OBJECT(String, std::string)

static auto get_depth_scale(rs2::device dev) -> float

static void pol2cart(float r, float th, float& x, float& y)

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 getIntensitySumFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float* sum)

void getIntensityStdDevFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float average, float* stddev)

void getIntensityStdDevFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float average, float* stddev)

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 getFileName(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) -> std::string

Convert string to only upper case.

auto stringToUpper(std::string) -> std::string

Convert string to only lower case.

auto fileSize(std::string filename) -> uint64_t

Returns size in bytes of file.

auto generateRandomString(int length) -> std::string

Generate random alphanumeric string of a given length.

auto roundToString(double value, int decimals = 0) -> std::string

Round double to a certain number of decimals, then convert to string.

auto roundToString(float value, int decimals = 0) -> std::string

Round float to a certain number of decimals, then convert to string.

static auto getConsoleWidth() -> int

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

template<class T>

auto getStandardDeviationFromData(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

Typedef documentation

Function documentation

Variable documentation