Iris Core API Types and Structure Definitions. More...
Go to the source code of this file.
Classes | |
| struct | Iris::ViewerCreateInfo |
| Defines necesary runtime parameters for starting the Iris rendering engine. More... | |
| struct | Iris::ViewerBindExternalSurfaceInfo |
| System specific binding information to configure Iris' rendering engine for the given operating system draw surface. More... | |
| struct | Iris::ViewerTranslateScope |
| Information to translate the rendered scope view as a fraction of the active view space with direction given by the sign. More... | |
| struct | Iris::ViewerZoomScope |
| Information to change the zoom objective. More... | |
| struct | Iris::SlideAnnotation |
| Structure defining requirements to create an image-based slide annotation. More... | |
| struct | Iris::LayerExtent |
| Slide objective layer extent detailing the extent of each objective layer in the number of 256 pixel tiles in each dimension. More... | |
| struct | Iris::Extent |
| The extent, in pixels, of a whole side image file. More... | |
| struct | Iris::LocalSlideOpenInfo |
| Information to open a slide file located on a local volume. More... | |
| struct | Iris::NetworkSlideOpenInfo |
| Information needed to open a server-hosted slide file. More... | |
| struct | Iris::SlideOpenInfo |
| Parameters required to create an Iris::Slide WSI file handle. More... | |
Typedefs | |
| using | Iris::Buffer = std::shared_ptr<class __INTERNAL__Buffer> |
| Reference counted data object used to wrap datablocks. | |
| using | Iris::Viewer = std::shared_ptr <class __INTERNAL__Viewer> |
| Access point to Iris API and controls all elements of Iris viewspace. | |
| using | Iris::Slide = std::shared_ptr<class __INTERNAL__Slide> |
| Handle to Slide File and Slide Loading Routines (Slide Loader) | |
| using | Iris::LayerExtents = std::vector<LayerExtent> |
| using | Iris::LambdaPtr = std::function<void()> |
| using | Iris::LambdaPtrs = std::vector<LambdaPtr> |
Enumerations | |
| enum | Iris::Result : uint32_t { IRIS_SUCCESS = 0 , IRIS_FAILURE = 0x00000001 , IRIS_UNINITIALIZED = 0x00000002 } |
| Result flags returned by Iris as part of API calls. | |
| enum | Iris::BufferReferenceStrength { Iris::REFERENCE_WEAK = 0 , Iris::REFERENCE_STRONG = 1 } |
| Iris Buffer ownership strength to underlying data. A weak reference only wraps data blocks by reference but has no responsibility over the creation or freeing of that datablock. Strong references have responsibility over the data backing the buffer and will free the memory on buffer destruction. More... | |
| enum | Iris::AnnotationFormat { ANNOTATION_FORMAT_UNDEFINED = -1 , ANNOTATION_FORMAT_PNG , ANNOTATION_FORMAT_JPEG } |
| Defines the image encoding format for an image annotation. | |
| enum | Iris::Format { Iris::FORMAT_UNDEFINED , Iris::FORMAT_B8G8R8 , Iris::FORMAT_R8G8B8 , Iris::FORMAT_B8G8R8A8 , Iris::FORMAT_R8G8B8A8 } |
| Image channel byte order in little-endian format. More... | |
Detailed Description
Iris Core API Types and Structure Definitions.
- Version
- 2024.0.3
- Date
- 2023-08-26
- Copyright
- Copyright (c) 2023-24 Created by Ryan Landvater on 8/26/23.
- Note
- ALL STRUCTURE Variables SHALL have variables named in cammelCase
- ALL CLASSES Variables SHALL have underscores with _cammelCase
- ALL LOCAL variables SHALL use lower-case snake_case
Typedef Documentation
◆ Buffer
| using Iris::Buffer = std::shared_ptr<class __INTERNAL__Buffer> |
Reference counted data object used to wrap datablocks.
It can either strong reference or weak reference the underlying data. The buffer can also shift between weak and strong referrences if chosen; however, this is very dangerous obviously and you need to ensure you are tracking if you have switched from weak to strong or vice versa.
- Note
- __INTERNAL__Buffer is an internally defined class. You may optionally include it in your implementation; however, many class methods are unsafe as they were created for exclusive use by Iris developers and use of these methods comes with risk.
- Warning
- Buffer is currently NOT safe for concurrent use on muplitple threads. This will be fixed in future updates.
◆ Slide
| using Iris::Slide = std::shared_ptr<class __INTERNAL__Slide> |
Handle to Slide File and Slide Loading Routines (Slide Loader)
The Slide object represents a mapped slide file and high-performance loading routines to bring slide data into RAM with limited overhead
◆ Viewer
| using Iris::Viewer = std::shared_ptr <class __INTERNAL__Viewer> |
Access point to Iris API and controls all elements of Iris viewspace.
The viewer the the primary control class that interfaces between external applications and their views, and the iris rendering system. It contains interface capabilities between external controllers, coordinates display presentations between external surfaces, and creates any user interface functionalities. It is created using the Iris::create_viewer(const Iris::ViewerCreateInfo&) method and initialized using the Iris::viewer_bind_external_surface(const Iris::ViewerBindExternalSurfaceInfo&) method.
- See also
- ViewerCreateInfo and ViewerBindExternalSurfaceInfo
- Note
- __INTERNAL__Viewer is an internally defined class and not externally exposed.
Enumeration Type Documentation
◆ BufferReferenceStrength
Iris Buffer ownership strength to underlying data. A weak reference only wraps data blocks by reference but has no responsibility over the creation or freeing of that datablock. Strong references have responsibility over the data backing the buffer and will free the memory on buffer destruction.
- Note
- A weak buffer explicitly is forbidden from resizing the buffer as it may invalidate the original pointer.
- Warning
- Changing a strong to weak buffer requires the calling program take responsibility for the buffer data pointer. It is now that program's responsibility to free that data once finished or a memory leak will ensue.
◆ Format
| enum Iris::Format |
Image channel byte order in little-endian format.
Assign this format to match the image source bits per pixel and bit-ordering.
Generated by
1.12.0