|
| void | setProgressCB (void *userData, MLHostProgressCB *callback) |
| | Sets callback for progress/busy cursor updates.
|
| MLHostProgressCB * | getProgressCB () const |
| | Returns current callback for progress/busy cursor updates.
|
| void * | getProgressCBUserData () const |
| | Returns user data of current callback for progress/busy cursor updates.
|
| void | updateProgress (const char *info1, const char *info2) |
| void | setBreakCheckCB (void *userData, MLHostBreakCheckCB *callback) |
| | Sets callback for break checking.
|
| MLHostBreakCheckCB * | getBreakCheckCB () const |
| | Returns the current callback for break checking.
|
| void * | getBreakCheckCBUserData () const |
| | Returns user data of the current callback for break checking.
|
| bool | shouldTerminate () const |
| Field * | getPressedNotifyField () |
| void | setMaxNumThreads (MLint32 numThreads) |
| MLint32 | getMaxNumThreads () const |
| | Returns the maximum number of permitted worker threads.
|
| void | setRestrictMaxNumThreads (MLint32 numThreads) |
| MLint32 | getRestrictMaxNumThreads () const |
| | Returns the restriction for setMaxNumThreads().
|
| MLuint32 | isProcessingActive () const |
| | Non-zero return values mean that (image) processing is currently active.
|
| ClassicHost * | getClassicHostDebug () |
| | Returns access to the classic ML host (for debugging purposes only!).
|
| void | setUseClassicHost (bool flag) |
| | Enables/disables usage of the classic ML host.
|
| bool | getUseClassicHost () const |
| | Returns whether the classic ML host is used.
|
| PageRequestProcessor * | getPageRequestProcessor () |
| | Returns the currently responsible page request processor.
|
| ProcessingTimeLine & | getProcessingTimeLine () |
| | Returns access to the processing timeline.
|
| void | enableTimeLineProfiling (bool flag) |
| | Enables/disables timeline profiling.
|
| MLErrorCode | getTile (PagedImage &outputImage, SubImageBox location, MLDataType dataType, void **data, const ScaleShiftData &scaleShiftData=ScaleShiftData(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | getTile (PagedImage &outputImage, SubImage &subImage, const ScaleShiftData &scaleShiftData=ScaleShiftData(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| void | freeTile (void *data) |
| MLErrorCode | processAllPages (Module &module, MLint outputIndex, SubImageBox region=SubImageBox(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | processAllPages (Module &module, ProcessAllPagesHandler &handler, SubImageBox region=SubImageBox(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | processMissingPages (Module &module, MLint outputIndex, SubImageBox region=SubImageBox(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | processAllPagesWithInputImage (PagedImage &inputImage, ProcessAllPagesHandler &handler, const SubImageBox ®ion=SubImageBox(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | processAllPagesWithInputImages (const std::vector< PagedImage * > &inputImages, ProcessAllPagesHandler &handler, const SubImageBox ®ion=SubImageBox(), MLRequestProgressCB *progressCallback=nullptr, void *progressCallbackUserData=nullptr) |
| MLErrorCode | updateImageProperties (Module &module, MLint outputIndex) |
| MLErrorCode | updateImageProperties (PagedImage &outputImage) |
The Host is the central image processing class in the ML. It contains the entire management of pages, their transport between modules, their (temporary) storage in the cache, the parallel processing of pages (multithreading), and the (de)composition of images and image fragments from/to pages or subimages.
The host operates on a network of modules derived from the class Module, which must be a organized in a directed and non-cyclic graph.
Typically modules are only working on demand - all of their image processing behavior is completely controlled by the Host; it is responsible to solve an image processing request by making use of the module interface available by the Module class interface. The image processing interface of a module is basically defined by the virtual calculate* method defined in the Module class interface.
Properties of image processing:
- For the memory optimized image processing of images or image fragments, each module support the so-called page-based image processing, i.e., each image is decomposed into pages (up to 6D-rectangular, non overlapping subimages). These pages are processed and propagated subsequently through the modules and in the end, they are composed to the result (sub)image. The extents of these pages is an image property, which can be controlled by any module and which is also supported by many file formats. Using pages with extents of the entire image should be avoided, as it degrades page based image processing to standard image processing. However, this sometimes can be difficult; please read ML literature for specialized base classes that support global image processing without leaving the page based approach. For example, see VirtualVolume, Module::processAllPages, slice based image processing, mlKernel(Base)Module.
For the time-optimized image processing, all calculated result pages of each module are stored within the Cache (a Host instance always has a Cache member) as long as they do not need more than Cache::setMaxCacheSizeKB(), which is set by default or by the environment variable ML_CACHE_SIZE_IN_KB. This way, already calculated pages can be recycled without recalculation. This can drastically speed up applications using the ML. If the cache reaches its limit, then pages are cleaned up dependent on their priority, which is assigned to them when they are calculated. This way, expensive pages (in the context of calculation time) are maintained longer than pages that can be recalculated fast.
Exception handling is controlled by mlUtils. If MLIsExceptionHandlingEnabled==0 (False), exceptions typically cause program termination. This is especially useful for debugging purposes. So Module::Module (mlAPI) Module::~Module (mlAPI) Module::calculateOutputSubImage (mlHost) Module::calculateInputSubImageBox (mlHost) Module::calculateOutputImageProperties (mlHost) Module::handleNotification (mlHost) are not checked with exception catching, i.e., the ML crashes on errors. Otherwise, exceptions are caught and redirected to the ErrorOutput class.
The default is off in debug mode so that all bugs lead to a crash that needs to be debugged. In release mode, this flag will always be set to true so that all exceptions are passed to the ML error output class to handled the errors.
Definition at line 114 of file mlHost.h.
Requests the image region subImage.getBox() from output image outputImage. If subImage.getData() is a non-NULL pointer, it must be large enough to hold the entire requested image data. If subImage.getData() is NULL, the getTile function will allocate enough memory for the image data and update the pointer in subImage. The image data will be stored in that memory as data type subImage.getDataType. The data will be scaled linearly depending on the settings of the scaleShiftData (see ScaleShiftData). The value subImage.getData() then will point to the (allocated) image data.
A progressCallback and its user data can be passed to the method and will be called with a value from 0 to 1 indicating the progress of the request. Note that this callback will only be called when the request takes longer than the internal update interval and that the Host will take care of updating the GUI afterwards. This way, you can simply forward the progress value to, e.g., a DoubleField::setValueCallback and show the value with a ProgressBar on the GUI. There is no guarantee that the progress starts at 0 and reaches 1, you should set the progress to 1 on success in your module instead.
IMPORTANT: Memory allocated with any Host::getTile function must be freed with the Host::freeTile function or with the corresponding mapped freeTile function of the class Module. This subImg will only be a wrapper for that memory chunk but it will not deallocate it if subImg is deleted or changed.
Requests the image region location from the image outputImage. If *data is a non-NULL pointer, it must be large enough to hold the entire requested image data. If *data is NULL, the getTile function will allocate enough memory for the image data. The image data will be stored in that memory as data type dataType. The data will be scaled linearly depending on the settings of the scaleShiftData (see ScaleShiftData). The returned value data then points to the allocated memory.
A progressCallback and its user data can be passed to the method and will be called with a value from 0 to 1 indicating the progress of the request. Note that this callback will only be called when the request takes longer than the internal update interval, and that the Host will take care of updating the GUI afterwards. This way, you can simply forward the progress value to, e.g., a DoubleField::setValueCallback and show the value with a ProgressBar on the GUI. There is no guarantee that the progress starts at 0 and reaches 1, you should set the progress to 1 on success in your module instead.
IMPORTANT: Memory allocated with any Host::getTile function must be freed with the Host::freeTile function or with the corresponding mapped freeTile function of the class Module.
1.15.0