System and method for segmentation network synchronization

Abstract

A computing device (101), a method, and a computer program product for replicating a three-dimensional label mask (20) of a three-dimensional volumetric data set (190) in a network of computing devices (100), wherein the device (101) receives, from a further computing device (102) of the network, a set of segmentation input data (21) describing an edit (2-1) of the label mask (20) at the further computing device (102), the set of segmentation input data comprising current position data, size data, and a label identifier associated with a spherical segmentation object (102-1) used by the second computing device (102) to interactively edit the label mask. The replication module (101-10) replicates an edited label mask of a further computing device (102) associated with a set of segmentation input data by calculating respective ellipsoids corresponding to the spherical segmentation object (102-1) stretched inversely proportional to the shapes of the voxels in the label mask, determining voxels (vi) of the label mask having positions inside the segmentation object based on the ratio of the distance between each voxel position in all three dimensions and the center position of the ellipsoid divided by the respective semi-axis lengths of the ellipsoid, the division being performed by negating the exponents of each denominator using respective bitwise operations on a graphics processing unit of the computing device (101), and updating the determined voxels in the replicated label mask (10) according to the label identifiers of the segmentation input data (21).

Description

[Technical Field]

[0001] This invention generally relates to 3D rendering, and more particularly to the replication of 3D label masks across multiple computing devices in a network. [Background technology]

[0002] Typically, multi-user applications support collaborative sessions that allow multiple users' front-end devices to connect over a network. The connection can be established over a local network, for example, multiple connected computing devices at the same physical location (e.g., a VR station), or over a wide-area network (e.g., the internet). In a collaborative session, connected users share a virtual environment. This virtual environment includes a volumetric representation of items as data objects visualized on a display device, with the potential for interaction between connected users. Actions taken by a particular user that affect the virtual environment must be replicated (or synchronized) to other users' front-end devices so that each user ultimately sees the virtual environment in the same state.

[0003] Generally, there are two approaches to achieving such state reproduction. a) Synchronization of the state of the virtual environment. This involves periodically sending and updating relevant data. The term “synchronization” of application state across multiple devices is used herein as a synonym for “duplicating” such state on the devices and does not mean time-based synchronization of signals. Typically, one user's device (or a single dedicated server in a server farm) acts as the host for a multi-user session. Each user’s application sends user input to the host, such as “I want to grab this object” or “I want to move this object up.” The host updates the state within a local copy of the virtual environment and periodically sends the latest state information to all connected users, such as “Object A is at location X” or “User 1 has object B.” Each user’s application on each front-end device uses this information to update its own local virtual environment state. b) Synchronization of user input. This approach is similar to a) in that each user sends their respective input to the host. However, when using approach b), the host does not update its local copy of the virtual environment state. Instead, the host simply forwards each user's input to all other connected users. Special care must be taken to ensure that all connected users receive and process the exact same sequence of inputs. Each user's application can use this information to replicate the events represented by the received data within their respective local applications on the user's front-end device.

[0004] In (a), even if the virtual environment state is not synchronized between different users (for example, one user sees an object at location X, and another user sees the same object at a slightly different location), the state will always return to a synchronized state after a short period (usually around 1 second) because the host periodically sends the same official version of the virtual environment state to all users.

[0005] In case b), during a collaborative session, the virtual environment state is not explicitly synchronized (only when initializing users joining the collaborative session). Only user input is synchronized. Therefore, any changes to the relevant virtual environment state must be made in a completely deterministic manner. In other words, given the same list of user inputs, all users' local applications must reach the exact same virtual environment state. Otherwise, the states will become out of sync over time.

[0006] State synchronization works well when the state is not extremely complex. In this regard, state complexity refers to the amount of data required to store and transmit the state. Thus, approach a) can be used by collaborative applications with relatively simple (low complexity) states. For example, an online whiteboard application typically has around 50 movable objects. In such a case, the entire state fits into a few hundred bytes. However, in collaborative sessions with large amounts of data (e.g., the state of thousands of objects or a few very complex objects), approach a) is not a viable option because the amount of data describing the entire virtual environment state is too large to be transmitted over a network fast enough to support real-time collaboration among connected users. Updates in such highly complex state applications result in a waiting period of several seconds after each update for each user, making it unacceptable in real-time collaborative scenarios.

[0007] Approach b) is typically used in applications where each user interacts with one (or more) objects within a virtual environment. In this case, the application developer does not need to worry about achieving fully deterministic behavior; it is usually sufficient to simply transmit the positions of several objects within the virtual environment. The position and orientation of objects in 3D space can easily be represented in 24 bytes or less.

[0008] However, the state-synchronized approach b) becomes impossible if the amount of data required to represent the state is excessively large and cannot be efficiently transmitted over the network used by the real-time collaborative session. For example, in the case of an application with thousands of objects, or objects that require a large amount of data to represent their state (highly complex states), the amount of data required to describe the state of all objects quickly exceeds the amount of data that can be reliably transmitted at the desired update rate (typically 10-60 Hz). Another example concerns medical imaging where segmentation techniques are used to collaboratively label voxels in volumetric medical images. That is, segmentation labels applied by one user must be visible to all connected users in the collaborative session. In particular, in such medical applications, an accurate replica of each state for all connected users is essential. However, the amount of data required to store the assigned labels can easily exceed the amount that can be reliably transmitted at the desired update rate.

[0009] Examples of prior art solutions are described in the following documents. U.S. Patent Application US2022346888A1 discloses a system for the visualization and interaction of multidimensional data in an augmented reality, virtual reality, or mixed reality environment. In a medical setting, the disclosed embodiments provide a tool for physicians, surgeons, or other medical technicians to quickly load and review patient scans in an AR / VR / MR environment. U.S. Patent Application US2020054398A1 discloses a method for presenting medical imaging data in an interactive virtual reality environment. The system comprises a head-mounted display (HMD) that determines, based on a medical imaging scan, whether a transparent 3D object overlaps a 3D model of an anatomical site, sets pixel values ​​corresponding to portions of the 3D model not obscured by the transparent object by performing shading, sets pixel values ​​corresponding to portions of the 3D model at the boundary of the transparent object to intensity values ​​obtained from the medical imaging data, displays a 3D model in which the outer surface is shaded to invoke the 3D object and the inner surface at the boundary of the transparent object is not shaded to preserve details embedded in the medical imaging data. The paper “A Collaborative Virtual Reality Environment for Liver Surgery Planning” (Chheang Vuthea et al., July 2021, Computers & Graphics 99(6)) discloses surgical planning software used in the treatment of tumor diseases. A collaborative virtual reality environment is presented to assist liver surgeons in tumor surgery planning to improve virtual resection planning among surgeons in remote or same-location environments. This system allows surgeons to define and adjust virtual resections on 3D surfaces and 2D image slices of patient-specific organs. Changes to both modalities are synchronized, allowing surgeons to rapidly iterate and fine-tune the resection surface.The paper “Liver segmentation in contrast enhanced CT data using graph cuts and interactive 3D segmentation refinement methods” (by Beichel Reinhard et al., Med Phys, March 2012, 39(3), 1361-1373, published online February 21, 2012) evaluates a novel approach to liver segmentation. It combines graph-cut segmentation with a segmentation refinement approach based on 3D virtual reality. The developed interactive segmentation system allows users to manipulate volume chunks and / or surfaces in cross-sectional images instead of 2D contours. [Overview of the Initiative]

[0010] Therefore, there is a need to provide methods and systems for efficient state replication to connected devices in a collaborative session, particularly with respect to the state of volume data processed in real time by connected devices. The term “real time” as used herein will be understood by those skilled in the art of digital data processing as “near real time” or “semi-real time.” Any digital data processing step (e.g., image processing step) applied to data captured from the real world (e.g., sensor data converted into a visual representation of sensor data) will always result in a delay imposed by the digital data processing step. For convenience, only the term “real time” will be used herein when referring to, for example, the “near real time” behavior of the disclosed methods and systems.

[0011] In particular, the approach disclosed herein is useful for medical imaging applications where segmentation is used to label various organs or pathologies within a 3D dataset. For example, label information can be used to hide, show, or highlight specific organs or regions. When segmenting a volume image (e.g., a CT scan), labels can be assigned to every voxel in the 3D dataset, since each label mask is also volume-based. Generally, segmentation in imaging refers to assigning labels to individual 2D pixels in 2D or individual 3D voxels in 3D. Labels are stored in a separate image data structure referred to herein as a label mask. Each pixel / voxel in the mask stores the label index of the assigned label. A label index "0" may be used to indicate that there is no assigned label for each voxel. Typically, the resolution of the label mask is the same as the resolution of the corresponding volume image (3D dataset), but this is not mandatory. A separate data structure may be used to assign additional metadata to each label, such as a user-modifiable name, description, highlight color, or opacity. Subsequently, the volumetric image visualization can be modified so that the color and opacity of each voxel are combined with the color and opacity of the assigned label. In short, this makes it possible to apply a highlight color and change the opacity of an entire segment, such as an organ or pathological region.

[0012] Simple modifications to standard ray marching processes can be used to hide or highlight segmented areas within a 3D volume. In standard ray marching, a transfer function is used at every step along a ray through the 3D volume to map the scalar raw data of each voxel to the respective opacity and color values ​​of each voxel. In addition to checking the opacity and color of the current ray-marching voxel position in the 3D volume, the same voxel position is checked within each 3D label mask. If an arbitrary label is assigned to the current voxel position (voxel), the color and opacity assigned to that label are taken into consideration when calculating the final color of the voxel. However, it should be noted that ray marching is not the focus of this specification. Those skilled in the art can use ray marching to render a 3D volume with the relevant 3D label mask. Rather, the focus of this specification is to replicate a label mask being edited by one user to connected users in a collaborative session.

[0013] For example, a user can interact with a virtual environment (including 3D volumes) using a motion-tracking controller to grasp, move, and rotate a loaded dataset. To edit the segmentation of a dataset, a user can activate a spherical segmentation object (e.g., a spherical brush tool) and interactively draw on a label mask. The brush can be represented by the outline of a sphere. When a user moves this brush tool into a 3D dataset (e.g., CT data) and presses a button on the controller, the voxels within the brush tool's sphere are assigned to the label currently selected for the brush tool (label setting mode). Alternatively, in subtraction mode (label setting de-assignment mode), voxels within the sphere that have already been assigned to the currently selected label are removed from that assignment.

[0014] Determining which voxels are inside the sphere at a given moment, and therefore should be included in the processing of a label mask modification command (e.g., assigning or erasing the currently selected label associated with the segmentation object), is in principle a trivial mathematical problem. The distance from the center point of every voxel to the center of the sphere is calculated and compared to the radius of the sphere. If the distance is greater than the radius, the voxel can be considered outside the sphere; otherwise, a label is assigned to the voxel inside the sphere. However, when determining whether a voxel is inside the sphere based on segmentation input data generated by the user during editing, the opposite conclusion may be reached due to different GPUs on other connected users' front-end devices calculating different results. This is permitted by some graphics libraries, as stated in IEEE 754 (IEEE Standard for Floating-Point Arithmetic), in IEEE Std 754-2019 (Revision of IEEE 754-2008), vol., no, pp.1-84, 22 July 2019, doi: This is due to deviations from 10.1109 / IEEESTD.2019.8766229). For example, GPU manufacturers are permitted to choose different processing for certain edge cases in floating-point operations. These permitted deviations result in different outcomes with respect to voxels determined to be inside the sphere of a segmentation object. As a result, different connected users may see different virtual environments at the voxel level when their GPU attempts to replicate the virtual environment state corresponding to the segmentation state on the user's front-end device during editing. This problem arises when replicating the state based on the respective segmentation input data, according to approach b). In particular, for medical applications, even slight deviations in the rendered label mask are unacceptable.

[0015] The above problem is solved by an embodiment described in an independent claim, a computer implementation method for replicating a three-dimensional label mask of a three-dimensional volume dataset in a network of computing devices, a computer program product having instructions configured to cause the computer program product to be executed when executed on a computing device, and a computer system capable of loading and executing the computer program product to execute the above method.

[0016] In one embodiment, a computer implementation method is provided for replicating a three-dimensional label mask of a three-dimensional volume dataset in a network of computing devices.

[0017] A collaborative session is assumed to already be running on a network where multiple users are connected via their respective computing devices. When a new user joins the collaborative session via their own computing device, this additional computing device is initialized and synchronized with the entire current label mask dataset and the 3D volume dataset. Hereafter, this additional computing device of a joining user will also be referred to as the first computing device. The entire 3D volume dataset includes the 3D volumes already loaded by the computing devices of all previously connected users. The entire current label mask includes a 3D label mask where all voxels are assigned to one or more respective labels, as set after the most recent editing / segmentation activity by already connected users. Thus, the voxels in the current label mask are associated with the corresponding voxels in the 3D volume dataset. For each voxel in the label mask, a label index relating to the corresponding voxel in the 3D volume may be stored. Multiple label masks relating to multiple 3D volumes may be duplicated independently of each other.

[0018] When the first computing device is initialized, it is ready to receive a set of segmentation input data generated by the second computing device. The received segmentation input data reflects drawing commands that result in changes to the label mask compared to the current label mask on the first computing device. This received set of segmentation input data is generated while the user of the second computing device edits the label mask. To edit the label mask, the second computing device uses a spherical segmentation object, allowing the user to draw on the label mask interactively. The segmentation input data is also received by the first computing device, as it is sent to all connected users (possibly via the host). The segmentation input data includes current position data, size data (i.e., the radius of the sphere), and a label identifier associated with the spherical segmentation object. Typically, during an edit / segmentation activity, the set of segmentation input data includes several label mask editing commands that describe changes in the position of the segmentation object during the segmentation activity, while keeping the radius and labels of the segmentation object constant. However, during segmentation activity, it is also possible for the user to change the associated label identifier (for example, to switch to a label index that represents a different segmentation color), and / or change the mode of the segmentation object (for example, label setting mode or unlabeling mode), and / or change the radius of the sphere (to adjust the size of the segmentation object).

[0019] Subsequently, the first computing device replicates the edited label mask of the second computing device based on the received set of segmentation input data. Thus, the first computing device performs the following steps for each of the received set of segmentation input data.

[0020] Firstly, an ellipsoid is calculated for each spherical segmentation object, stretched inversely proportional to the shape of the voxels within the label mask. Typically, volume voxels have a rectangular prism shape (rather than a cubic shape). In particular, there are volume voxels generated by medical imaging techniques such as computed tomography, magnetic resonance imaging, optical coherence tomography, positron emission tomography, single-photon emission computed tomography, and 3D ultrasound imaging. In such techniques, multiple 2D scan images are combined into a 3D volume. However, typically, the distance between two 2D scan images differs from the edge size of the 2D pixels in the 2D scan images. This results in a rectangular prism shape for the voxels. The purpose of the calculated ellipsoid is to map the spherical segmentation object to a rectangular voxel shape.

[0021] In the next step, the first computing device determines the voxels of the label mask that have positions inside the segmentation object. For this purpose, the first computing device calculates a ratio of the distance between each voxel position in all three dimensions (referred to as the numerator) and the center position of the ellipsoid, divided by the respective half-axis length of the ellipsoid (referred to as the denominator). As a result, the division is performed using bitwise operations in the graphics processing unit of the first computing device. Therefore, each half-axis length is a floating-point number represented by an integer with respect to the sign, mantissa, and exponent. The division is performed by approximating the multiplicative inverse of each denominator by inverting the exponent of each half-axis length, and multiplying the approximated multiplicative inverse of each denominator with each numerator. By using such bitwise operations, a deterministic determination of the voxels inside the segmentation object is ensured. In contrast, when using the standard division instruction of the GPU, if different types of GPUs (e.g., GPUs from different manufacturers) are used by two devices, in the first computing device, a label mask that deviates from the label mask generated by the second computing device will occur. Of course, the bitwise operations also function when the GPUs of the first and second computing devices are the same. In this case, the method described in the claims provides an alternative implementation for an implementation using the GPU standard operation algorithm. It should be noted that the implementation using bitwise operations results in slightly different results from the normal division implementation, and there may be a slight difference in the effective sphere size. However, this is irrelevant regarding the requirement that all connected users need to see the same label mask, which is always ensured by bitwise operations that enable deterministic calculations for any GPU.

[0022] Finally, the first computing device updates the voxels determined according to the label identifiers of the segmentation input data in the replicated label mask. That is, after all pending segmentation input data has been processed (i.e., after the update step is complete), the label mask of the first computing device is, in all cases, identical to the current label mask of the second computing device, regardless of the type of GPU used by the computing device. In other words, after the replication of the label mask, users of each device see an image rendered with the same segmentation information. For example, all voxels labeled with a specific intention by the editing device are rendered with that specific color on the replicated device as well. This is a critical requirement in collaborative sessions performed within medical applications. Often, in such collaborative scenarios, different users use different VR devices from different manufacturers and different GPUs. The bitwise computation-based solution proposed herein provides an accurate replication of the current label mask on each of the connected devices.

[0023] To explain bitwise division in more detail, a specific implementation of division is described below. Division A / B is performed with respect to the reciprocal of A and B, B. -1 It can be expressed by multiplying an approximate value of by , and the above approximate value is calculated by subtracting B, which is interpreted as an integer, from a given integer constant. According to the IEEE 754 standard for floating-point arithmetic, the exponent of a 32-bit floating number is stored in the 8 bits following the sign bit. Since the exponent can be negative, it is implemented using a bias of 128-1=127. That is, "127" is added to the actual exponent to keep it always positive.

[0024] The compiler of the first computing device is instructed to interpret 32-bit floating-point numbers as integers without changing the binary representation. This can be achieved by using programming language-specific instructions such as "floatBitsToUnit" or "floatBitsToInt" in the OpenGL Shading Language (GLSL), "asuint" or "asint" in the High-Level Shading Language (HLSL), or by dereferencing an integer pointer set to the address of a floating-point number in a language with explicit pointer support. The resulting integer is subtracted from a predetermined integer constant that approximates the reciprocal of the floating-point number by leveraging the positions of the exponent and fraction in the normalized encoded format of the floating point, particularly the binary representation. The result of the subtraction is reinterpreted as a floating-point number, yielding an approximation of the reciprocal of the original floating-point number.

[0025] For example, the interpreted integer can be subtracted from the hexadecimal number "0x7F000000" which is a predetermined integer constant (equal to the integer "127" shifted 8 bits used for the exponent in a 32-bit float). By using "0x7F000000" as the predetermined integer constant, it is possible to implement a bitwise division operation where 1 / 1 is exactly equal to "1". The bitwise division operation may also use other predetermined integer constants such as "0x7EEEEEEE", which also provides very good overall accuracy.

[0026] Particularly in the context of medical applications, it is crucial to prove the identity between the original label mask (second computing device) and the replicated label mask (first computing device). For this purpose, in an optional embodiment, the first computing device periodically receives the hash value of the corresponding edited label mask from the second computing device, in addition to the segmentation input data. The first computing device then calculates the hash value of each replicated label mask. If the two values ​​are the same, the accuracy of the label mask replication between the computing devices is verified.

[0027] In a further optional embodiment, the first computing device (and the second computing device) may support a variety of update modes. In addition to the “label setting mode,” which sets determined voxels in the replicated label mask to label identifiers of segmentation input data, and the “unlabel setting mode,” which removes specific previously set label identifiers from determined voxels in the replicated label mask, as already mentioned, any of the following update modes may be supported: “label clearing mode,” which resets all label identifiers of determined voxels in the replicated label mask; “label setting mode for unassigned voxels,” which sets label identifiers of segmentation input data in the replicated label mask only to determined voxels that have not yet been labeled; and “label setting mode for visible voxels,” which sets label identifiers of segmentation input data in the replicated label mask only to determined voxels that are visible according to the applied transfer function. Those skilled in the art may define further update modes supported by connected computing devices.

[0028] An optional embodiment may support label identifiers in label masks of different sizes. For example, label identifiers may be stored as 8-bit, 16-bit, or 32-bit values ​​for each voxel. For example, a label mask with 8-bit integer values ​​for all voxels can have up to 2 ∧ This allows for the definition of 8-1=255 different labels. According to the 32-bit embodiment, this is 2 ∧ The number of labels can be expanded to 32-1=4294967295. In an alternative embodiment, the value stored for each voxel in the label mask can be thought of as a bit field where each bit corresponds to a different label. In this embodiment, the label mask can be used to assign multiple different labels to each voxel in a volume image. The number of different labels that can be assigned to a voxel simultaneously corresponds to the number of bits used to store the value of the label mask.

[0029] In one embodiment, a computer program product is provided for replicating a three-dimensional label mask of a three-dimensional volume dataset in a network of computing devices. The computer program product, when loaded into the memory of a computing device and executed by at least one processor of a computing device, comprises computer-readable instructions that cause the computing device to perform a computer implementation method as disclosed herein.

[0030] In one embodiment, a computing device is provided for replicating a three-dimensional label mask of a three-dimensional volume dataset in a network of computing devices. The computing device implements a functional software module configured to enable the computing device to perform the functions disclosed herein in order to carry out the above computer implementation method.

[0031] In particular, when a device joins a collaborative session on the network to initialize the computing device, it has an interface adapted to receive the current label mask dataset and the entire 3D volume dataset from the network of computing devices. The collaborative session used herein is an interactive session involving multiple users, each having their own computing device, who work towards a shared purpose in real time. The interface is further adapted to receive a set of segmentation input data from further computing devices on the network. The set of segmentation input data (edit commands) describes the editing of the label mask on the further computing device. In this regard, the particular segmentation input data comprises current position data, size data, and a label identifier associated with a spherical segmentation object used by the second computing device to interactively edit the label mask.

[0032] The system further processes each of the series of segmentation input data, An ellipsoid module adapted to calculate each ellipsoid corresponding to a spherical segmentation object stretched inversely proportional to the shape of the voxels in the label mask. A voxel identifier module adapted to determine the voxels of a label mask having an inside position of a segmentation object based on the ratio obtained by dividing the distance between each voxel position and the center position of the ellipsoid in all three dimensions by the respective semi-axis lengths of the ellipsoid, wherein the division is implemented by inverting the sign of the exponents of each denominator using bitwise operations on the graphics processing unit of a computing device, and An update module adapted to update the voxels determined according to the label identifiers of the segmentation input data in the replicated label mask. By processing, it has a replication module adapted to replicate the edited label masks of further computing devices associated with a series of segmentation input data.

[0033] Advantageously, the voxel identifier is the reciprocal of A and B, which is B. -1 A bitwise division operation on division A / B is performed by multiplying an approximation of B by a predetermined integer constant. This approximation is calculated by subtracting B, which is interpreted as an integer, from a predetermined integer constant. This integer constant is predetermined so that the result of the integer subtraction approximates the reciprocal of the floating-point number, by utilizing the standardized encoding format of floating-point numbers, particularly the positions of the exponent and fraction in the binary representation. The compiler of the computing device is instructed to interpret the 32-bit floating-point number as an integer without changing the binary representation. The interpreted integer is then subtracted from a predetermined integer constant, for example, the hexadecimal number "0x7F000000", the hexadecimal number "0x7FEEEEEE" (or another hexadecimal number that matches the predetermined criterion above). Finally, the result of the subtraction is reinterpreted as a floating-point number, yielding an approximation of the reciprocal of the original floating-point number with the exponent sign reversed.

[0034] Further aspects of the present invention are realized and achieved using elements and combinations particularly shown in the appended claims. It should be understood that neither the general description above nor the detailed description below is for illustrative and explanatory purposes only and does not limit the invention as described. [Brief explanation of the drawing]

[0035] [Figure 1] A block diagram is shown, including an embodiment of a computing device for replicating a 3D label mask of a 3D volume dataset in a network of computing devices. [Figure 2A]This is a simplified flowchart illustrating a computer implementation method for replicating a 3D label mask of a 3D volume dataset in a network of computing devices according to an embodiment. [Figure 2B] This is a simplified flowchart illustrating an example of bitwise operation for performing partitioning on a GPU to determine voxels within a segmentation object. [Figure 3A] ~ [Figure 3B] This screenshot shows an example of an editing activity to modify the segmentation of a 3D object that has segmentation objects. [Figure 4A] This shows the voxels of a 3D volume and their coordinate system. [Figure 4B] This shows the typical elongated rectangular prism shape of voxels in a volume dataset and the spherical shape of the segmentation tool as seen by the user. [Figure 4C] This shows the same volume dataset and segmentation tool after the voxels have been transformed to form a rectangular prism shape. [Figure 5] This is a 32-bit representation of a real number. [Figure 6A] , [Figure 6B] This shows a simplified 2D view of the segmentation and replicated segmentation results on two different GPUs. [Figure 7] This example shows segmentation results in a medical application using segmentation applied to the spine of a human skeleton. [Figure 8] The image shows a collaborative session involving four users and four connected computing devices. [Modes for carrying out the invention]

[0036] Figure 1 shows a block diagram including an embodiment of computing device 101 for replicating a 3D label mask 20 of a 3D volume dataset 190 in a network 100 of computing devices 101-10n (computing devices communicating over the network). In the example of Figure 1, only the visible voxels of the volume dataset 190 are shown. However, the entire 3D volume dataset has a rectangular parallelepiped shape. Figure 2A is a simplified flowchart showing a computer implementation method 1000 for replicating a 3D label mask of a 3D volume dataset in a network of computing devices according to an embodiment. For example, method 1000 may be performed by computing device 101. Thus, Figure 1 is described here in the context of Figure 2. For this reason, the reference numbers of Figures 1 and 2 are used in the following description. Furthermore, Figures 3A-3B are screenshots showing an example of editing activity to modify the segmentation 32a, 32b of a 3D object (3D volume dataset 390) in a segmentation object 30. This example is also used in the context of the description of Figures 1 and 2A.

[0037] Computing device 101 is connected to other computing devices 102, 103, ..., 10n via network 100 to perform a collaborative session (by running a collaborative application). The computing devices have a standard communication interface that enables data exchange between devices. Each computing device is operated by its respective user 1, 2, 3, ..., n. Below is an example in which computing device 101 receives data from computing device 102 to replicate a label mask 20. It should be noted that in the described example scenario, computing devices 103-10n perform the same functions as computing device 101 and can replicate the label mask 20 of computing device 102 using their respective GPUs. Furthermore, one or more of computing devices 101, 103-10n may each be used as an editing device for its own label mask, in which case all other connected devices can replicate the corresponding modified label mask.

[0038] In the collaborative session example in Figure 1, computing device 102 is running an application that enables editing 2-1 of a 3D volume dataset 190. In this example, the application is a medical application that renders a 3D volume from a CT scan of a human skull. However, any other application for visualizing 3D objects for a user can utilize the approach described herein. A volume is composed of so-called voxels. Figure 4A shows some voxels pv_n of Vn. The voxels of a volume have a rectangular shape. In a complete volume Vn, each voxel layer has the same number of voxels arranged in a rectangular shape, resulting in a rectangular volume. Voxels may have a cubic shape, but generally, a volume Vn is usually composed of layers of 2D images where each pixel of the 2D image is rectangular. In this example, it is assumed that the 2D image layers are located in the xn-yn plane of the local coordinate system CSn of Vn. When examining pointillist voxels, it becomes clear that the depth of a voxel in zn dimension is different from the edge length of a voxel in xn-zn dimension. The distance at which a 2D image is captured (for example, by one of the volume imaging techniques mentioned above) corresponds to the depth of the voxel in zn dimension. Typically, the depth of a voxel is different from the edge length of each pixel in the underlying 2D image layer.

[0039] Returning to the example in Figure 1, User 2 uses a spherical segmentation object 102-1 to interactively draw on a label mask 20 associated with a 3D volume dataset 190. In this regard, the segmentation object is used as a brush tool that the user can use to interactively draw on the 3D dataset. Voxels touched by the brush tool are labeled accordingly. The label mask 20 is also a 3D volume dataset that can store label values ​​for each voxel in the 3D dataset 190. The segmentation area 22 shows the voxels of the label mask that were touched by the brush tool 102-1 during editing 2-1. Labeled voxels (for example, those with color labels set for the segmentation object) are visualized to User 2 so that labeled voxels can be clearly distinguished from unlabeled voxels.

[0040] The editing commands generated while User 2 is editing the label mask 20 2-1 are also referred to herein as segmentation input data 21. During the editing 2-1 activity, a series of segmentation input data are typically generated as the segmentation object 102-1 moves. Specific segmentation input data comprises current position data, size data, and a label identifier associated with the spherical segmentation object. Examples in Figures 3A-3C show the editing of a label mask associated with a 3D volume dataset (skull) 390 at three different time points t1, t2, and t3. At t1 (see Figure 3A), the user approaches the skull 390 with the segmentation object 30, but the segmentation object has not yet intersected the skull. At t2 (see Figure 3B), the segmentation object has already labeled several voxels 32a of the label mask. While the segmentation object 30 is intersecting the skull 390, the system records the corresponding editing command ECa as segmentation input data. That is, ECa represents a set of segmentation input data that reflects the position data, size data, and label identifiers of each during the editing operation. At t2, the segmentation object "penetrates" the skull, and the right-hand portion of the sphere intersecting the skull defines the current edge of the labeled voxel area 32a. At t3 (see Figure 3C), the segmentation activity is complete, and the user is moving the segmentation object 30 away from the skull. The area 32b, which shows the labeled voxels during the editing operation, is now larger than at t2. That is, a further set of editing commands ECb were applied to the label mask between t3 and t2.

[0041] Returning to Figure 1, in a collaborative session via network 100, the current label mask 20 with labeled voxels 22 on computing device 102 needs to be replicated in real time to connected computing devices. Below, the replication of the label mask will be described only for computing device 101. However, any other connected device can perform the same replication method as computing device 101.

[0042] When computing device 101 first joins a collaborative session on network 100, an initialization step 1100 is performed, and computing device 101 first receives the current label mask of the collaborative session and the entire 3D volume dataset 190 from the collaborative session host (via its own communication interface). The collaborative session host receives all edit commands from all connected devices and therefore knows the exact current label mask (to know the true order of all edit commands). The current label mask can then be provided to any replication device. The collaborative session host can be considered an intermediary for transferring edit commands from editing devices to replication devices, while ensuring that all edit commands originating from different editing devices are always processed in the correct order. Once initialized, computing device 101 can replicate changes to the label mask applied by any of the connected devices. In this example, computing device 102 has performed the most recent edit action on label mask 20. Each set of segmentation input data (edit commands) is provided to network 100 by computing device 102 and received by computing device 101 1200. As described above, the series of segmentation input data 21 describes the editing 2-1 of the label mask 20 by editing commands generated in the computing device 102. That is, after receiving the segmentation input data 21, the computing device 101 knows the position, size, and associated labels of the segmentation object 102-1 that need to be assigned to the voxels of the label mask that intersect with the spherical segmentation object during the editing activity in the computing device 102.

[0043] Computing device 101 has a duplicator module 101-10 adapted to duplicate 1300 an edited label mask of computing device 102 associated with a series of segmentation input data 21 by processing each of the series of segmentation input data in subsequent (sub) modules.

[0044] Ellipsoid module 101-11 calculates 1320 respective ellipsoids corresponding to spherical segmentation objects 102-1 stretched inversely proportional to the shape of the voxels in the label mask. FIGS. 4B and 4C show the inverse stretching of such spherical segmentation objects to the corresponding ellipsoids. To check whether a voxel is inside the sphere of SP1, the distance D from the voxel at position (v x , v y , v z ) to the center of the sphere (c x , c y , c z ) is obtained by equation F1, and the voxel position is assumed to be defined at the center of the voxel.

Equation

[0045] However, as described above, in an actual volume, the size of voxels in three dimensions is usually not uniform. That is, the edge length of the voxel cuboid reflecting the distance between two image layers in a 3D volume is different from the edge length defining the pixel size within a single layer. For example, in a CT image, the CT slice distance (z-axis) is usually larger than the pixel size within each slice. A typical voxel size in a CT scan is 0.3 mm × 0.3 mm × 1.5 mm.

[0046] Figure 4B shows a situation where the cubic voxel shape of the voxels in volume Vb is obtained because the edge length of pixels in a layer (slice) is a', but the edge length (slice distance) between two layers is c' > a'. When the spherical segmentation object SP1 intersects with the voxels of volume Vb, there are fewer voxels that fit in c' dimension than voxels that fit in a' dimension. Since cuboid voxels (whether 2D or 3D images) cannot be represented as textures on the GPU, it is advantageous to work with cubic voxels for subsequent calculations. Such textures are always simply a uniform grid of 2D or 3D values. This is shown as volume Vc in Figure 4C. Therefore, a segmentation object that appears as a spherical shape to the user must be treated as an ellipsoid, i.e., a sphere stretched inversely proportional to the shape of the voxels. This can be achieved by using an inversely proportional stretched ellipsoid E1, where the c-axis length is inversely proportional to the semi-axis c.

[0047] position(v x ,v y ,v z To determine if a voxel at ) is inside a spherical segmentation object, the center position (c x ,c y ,c z Formula F2 can be used for the ) and semi-axis length (ax, ay, az).

number

[0048] Therefore, the voxel identifier modules 101-12 of the computing device 101 are adapted to determine the voxels of the label mask having positions inside the segmentation object based on the ratio of the distance between each voxel position in all three dimensions and the center position of the ellipsoid divided by the respective semi-axis lengths of the ellipsoid. Since the ellipsoid position and radius can be arbitrary real numbers, the system needs to operate with floating-point numbers, which presents problems when performing such division on the GPU. However, even with integer values, the division is likely to produce fractions. Floating-point numbers in CPU and GPU memory are represented by three integers: sign, mantissa, and exponent.

[0049] Floating-point numbers in CPU and GPU memory are represented by three integers: the sign, mantissa, and exponent. Figure 5 shows an example of a single-precision (32-bit) floating-point number 500 as defined by the IEEE 754 standard for floating-point arithmetic. The 23-bit fractional part of floating-point 500 is stored in bits "0" through "22". The 8-bit exponent is stored in bits "23" through "30", and the sign bit is stored in bit 31. The floating-point value represented by the 32-bit floating-point number 500 is "0.15625". Because the precision of floating-point numbers is limited, problems arise because not all possible real numbers can be represented in 32 bits. As a result, some of the results of the division of F2 described above will be real numbers that cannot be accurately represented as floating-point numbers.

[0050] IEEE 754 requires exact rounding, meaning the rounded result is equivalent to calculating the value using infinitely precise arithmetic and rounding it to the nearest value that can be represented as a floating-point number. Alternative rounding modes are specified in Section 4.3 of IEEE 754. In GPUs, certain deviations from the standard are permitted by some graphics libraries, such as Microsoft's DirectX. This is mainly because GPUs are primarily used for video games and visual effects, where minor inaccuracies are not a concern and determinism is rarely required. Crucially, GPU manufacturers are permitted to choose non-standard rounding modes and lower-precision results for operations such as square roots or division (see White, S., Coulter, D., Jacobs, M., Satran, M., "Floating-point rules (Direct3D 11)", Programming Guide for Direct3D 11, Microsoft, 2020, Accessed 23.11.2022, https: / / learn.microsoft.com / en-us / windows / win32 / direct3d11 / floating-point-rules). "IEEE 754 requires that floating-point operations produce results that are the closest representable value to an infinitely accurate result, known as rounding to the nearest even. Direct3D11 defines the same requirement as 32-bit floating-point operations producing results within 0.5 least significant units (ULPs) of an infinitely accurate result. This means, for example, that hardware is allowed to truncate the result to 32 bits instead of performing rounding to the nearest even, resulting in an error of up to 0.5 ULP. This rule applies only to addition, subtraction, and multiplication. sqrt and rcp have a tolerance of 1 ULP. The shader reciprocal and reciprocal square root instructions, rcp and rsq, each have their own separate, relaxed precision requirements. Each of multiplication and division operates at 32-bit floating-point precision levels (0.5 ULP precision for multiplication and 1.0 ULP precision for reciprocal division)."If x / y is performed directly, the results must have greater or equivalent accuracy than the two-step method.

[0051] As a result of these tolerable rounding deviations, when two connected computing devices use GPUs from different manufacturers, the devices may arrive at different label mask duplication results, even though they start from the same initial state and execute the same label mask drawing command (i.e., the same segmentation input data). Theoretically, different GPU models or series from the same manufacturer, or even the exact same GPU after an updated graphics driver, may exhibit different behavior in the situations described above, as the decision is left to the manufacturer.

[0052] This problem is visualized in Figures 6A and 6B. For simplicity, only the 2D projections of the segmentation object and each voxel are shown. Figure 6A is assumed to show a label mask 610 edited by the user on each computing device. The label mask is assumed to be empty (no signed voxels) before the user's editing command. The user positions the segmentation object SO1 such that the center CP1 of SO1 lies inside the voxel at the label mask position (6,5). Typically, the center CP1 does not coincide with the center of the voxel. The radius R1 of SO1 is indicated by a dashed line. For example, the GPU of the editing device conforms to IEEE754 and always rounds the result of floating-point arithmetic to the nearest representable floating point. Voxels determined to be inside SO1 according to F2 (i.e., the center of each voxel lies inside SO1) have a stippled texture. In this example, the voxels at positions (7,2) and (9,4) have center points CP11 and CP12 near the surface of SO1, but the editing device's GPU concludes that they are not inside SO1.

[0053] Figure 6B shows a label mask 620 generated by a replicated computing device with a GPU that uses a different rounding method. For example, the editing device's GPU conforms to IEEE 754 and always rounds the result of floating-point operations to the nearest representable floating point. The replicated device's GPU may choose the permitted shortcut of truncating the result (always truncating). The sphere SO2 is reconstructed based on the segmentation input data, position CP1=CP2, and radius R1=R2 in the editing computing device. However, because the replicated device's GPU calculates the distance to the center of the sphere for a given voxel slightly differently than the editing device, the replicated device's GPU concludes that the voxels at positions (7,2) and (9,4) have center points CP21, CP22 inside the replicated sphere SO2. Therefore, these voxels are also labeled with the labels shown in the segmentation input data (indicated by the stippling texture). Thus, to users of the editing device and the replicated device, there appears to be a difference in the label assignments in the label mask. In medical applications in particular, such deviations in the label mask of a replica device, which is expected to reflect the segmentation results on the editing device, are unacceptable.

[0054] Optionally, to detect such differences between label masks on different computing devices, a hash of the entire label mask may be calculated on each computing device and compared to the hash value on the co-op session host's computing device. If the hash values ​​differ, the session host may send the official version of the label mask to the user's connected computing device with the out-of-sync hash value. However, this process can take several seconds and may result in data loss, and should preferably be avoided in real-time co-op sessions.

[0055] To avoid such drawbacks, the approach disclosed herein provides a method and system for avoiding the generation of different label masks on a replica computing device, regardless of the GPU used. This is achieved by performing the division of equation F2 to determine whether a voxel lies inside an ellipsoid by using bitwise operations on the GPUs of the connected computing devices (specifically editing device 102 and replica device 101 in the example of Figure 1) to reverse the sign of the exponents of each denominator. This can be done by equation F3.

number

[0056] Finally, the update module 101-13 of the replicated computing device 101 is adapted to update the replicated label mask 10 (i.e., the label mask generated by the replicated device 101 in response to the received segmentation input data 21) to update the voxels determined according to the label identifiers of the received segmentation input data 21.

[0057] Figure 2B shows that the exponent is stored in the 8 bits following the sign bit of a 32-bit floating-point number using a bias of "127" (see Figure 5), according to equation F3, the reciprocal of A and B is B. -1A substep of decision step 1340 is shown, detailing an example of performing a bitwise division operation for division A / B by multiplying an approximation of by . In this implementation, the compiler of the computing device is instructed to interpret the 32-bit floating-point number as an integer 1342 without changing its binary representation. In the example implementation, the interpreted integer is subtracted 1344 from the hexadecimal 0 × 7F000000 (corresponding to the integer value "127" shifted to an 8-bit position that stores the exponent), and the result of the subtraction is reinterpreted 1346 as a floating-point number to obtain an approximation of the reciprocal of the original floating-point number (with the exponent sign reversed in this implementation).

[0058] Returning to Figure 1, the segmentation input data 21 may further include update modes associated with the segmentation object while editing the label mask 20 on the computing device 102 (i.e., the editing device). When using a spherical segmentation object, user 2 can select a segmentation mode that determines how the voxels contained within the spherical segmentation object are labeled. From the perspective of the replication device, the segmentation mode is applied when updating the corresponding replicated label mask. Therefore, the segmentation mode is also referred to as the update mode when received as part of the segmentation input data. That is, the selected segmentation (update) mode then becomes part of the segmentation input data 21 provided to the device connected by the editing device 102. The following list shows examples of possible update modes (however this list is not intended to be limiting, and those skilled in the art may define further update modes). • Label setting mode: A mode that sets the determined voxels within the duplicated label mask as label identifiers for the segmentation input data. • Label Deselection Mode: A mode that removes specific previously set label identifiers from determined voxels within a duplicated label mask. • Label erase mode: A mode that resets all label identifiers of determined voxels within the duplicated label mask (resetting label identifiers means setting the label values ​​to their initial values, for example, "0"). • Labeling mode for unassigned voxels: A mode that sets label identifiers for segmentation input data within a replicated label mask only for determined voxels that have not yet been labeled. • Visible voxel labeling mode: A mode in which label identifiers of segmentation input data in the replicated label mask are set only for voxels determined to be visible according to the applied transfer function.

[0059] Label identifiers within a label mask can typically be stored in each voxel as 8-bit, 16-bit, or 32-bit values. Larger bit sizes are possible by using multiple texture channels and / or multiple textures. Label values ​​can be interpreted in various ways. In one implementation, the bits of the label identifier in the label mask are interpreted as a single integer label value for each voxel. That is, the label value can cover a large range of values, but only one label can exist for each voxel. In another implementation, each bit of the label identifier may be interpreted as a label. That is, the same number of labels as the number of bits in the label identifier can be assigned to a voxel.

[0060] Figure 7 shows an example of segmentation results in a medical application where segmentation is applied to the vertebrae of a human skeleton of 700. Each vertebra, 700-1 to 700-n, is segmented with a distinguishable segmentation color such that adjacent vertebrae are assigned different segmentation colors. That is, each voxel in the label mask is assigned to a label indicator associated with a color value associated with the segmentation object during each editing activity. When the label mask is duplicated based on editing commands for a spherical segmentation object according to the approach disclosed herein, which uses bitwise division operations, the exact label mask is reproduced on each connected duplication device.

[0061] Figure 8 shows a photograph of a real-world collaborative session 800 involving four users 800-1 to 800-4 and four connected computing devices 800-11 to 800-14. In this example, the collaborative session is part of a neurosurgery course, with surgeon 800-3 and three students 800-1, 800-2, and 800-4 performing a virtual surgery in a shared virtual environment. The surgeon is removing a portion of bone from a patient's CT scan using a spherical segmentation object in eraser mode. Eraser mode can be implemented by using the segmentation object's labeling mode in combination with labels that are assigned completely transparent color values. This operation is then synchronized over the network to the students' virtual reality devices so that the students can visually see the changes (edits) applied to the label mask by the surgeon (from their own perspective).

Claims

1. A computer implementation method (1000) for replicating a three-dimensional label mask (20) of a three-dimensional volume dataset (190) in a network (100) of computing devices (101 to 10n), When the first computing device (101) joins a collaborative session on the network (100), the first computing device (101) is initialized (1100) with the entire current label mask dataset and the three-dimensional volume dataset (190), The first computing device (101) receives (1200) a series of segmentation input data (21) generated by the second computing device (102), wherein the particular segmentation input data comprises current position data, size data, and a label identifier associated with a spherical segmentation object (102-1) used by the second computing device (102) to interactively edit the label mask. For each of the aforementioned series of segmentation input data, Calculating each ellipsoid corresponding to the spherical segmentation object (102-1) stretched in inverse proportion to the shape of the voxels in the label mask (1320), Determining the voxels (vi) of the label mask having positions inside the segmentation object based on a ratio obtained by dividing the distance between each voxel position in all three dimensions and the center position of the ellipsoid by the semi-axis length of the ellipsoid as the numerator (1340), wherein each semi-axis length is a floating-point number represented as an integer with respect to sign, mantissa, and exponent, and the division is performed on the graphics processing unit of the first computing device (101) by approximating the reciprocal multiplicative of each denominator by sign inverting the exponent of each semi-axis length using bitwise operations, and multiplying the approximated reciprocal multiplicative of each denominator by each numerator, In the replicated label mask (10), the determined voxels are updated according to the label identifier of the segmentation input data (21) (1360) This involves the first computing device (101) replicating the edited label mask of the second computing device (102) associated with the series of segmentation input data (1300), A method that includes [a certain feature].

2. The bitwise division operation is performed by multiplying A by an approximate value of B-1, which is the reciprocal of B, to perform the division A / B. The approximate value is calculated by subtracting B, which is interpreted as an integer, from a predetermined integer constant, that is, The compiler of the first computing device is instructed to interpret a 32-bit floating-point number as an integer (1342) without changing its binary representation. The resulting integer is subtracted (1344) from the predetermined integer constant, and by utilizing a standardized encoding format for floating-point numbers that includes the positions of exponents and fractions in the binary representation, the result of the integer subtraction approximates the reciprocal of the floating-point number. The method according to claim 1, wherein the result of the subtraction is reinterpreted as a floating-point number (1346) and an approximate value of the reciprocal of the original floating-point number is obtained.

3. The method according to claim 1, wherein the collaborative session is performed within a medical application.

4. The method according to claim 1, wherein the first computing device (101) receives the hash value of the corresponding edited label mask (20) of the second computing device (102) along with the segmentation input data (21), and further calculates the hash value of each of the duplicated label masks (10) to ensure the accuracy of the duplication of the label masks between the computing devices.

5. The method according to claim 1, wherein the update is performed using at least a label setting mode that sets the determined voxel in the duplicated label mask to the label identifier of the segmentation input data, and a label desetting mode that deletes a specific previously set label identifier from the determined voxel in the duplicated label mask.

6. The method according to claim 5, wherein the update is performed using one of the following update modes: a label clearing mode that resets all label identifiers of the determined voxels in the duplicated label mask; a label setting mode for unassigned voxels that sets the label identifiers of the segmentation input data in the duplicated label mask only for determined voxels that have not yet been labeled; and a label setting mode for visible voxels that sets the label identifiers of the segmentation input data in the duplicated label mask only for determined voxels that are visible according to the applied transfer function.

7. The method according to claim 1, wherein for each voxel of the label mask, the label identifier of a single label is stored as an 8-bit, 16-bit, or 32-bit value.

8. The method according to claim 7, wherein each voxel of the label mask stores an 8-bit, 16-bit, 32-bit, or longer bit field, and each bit corresponds to a label, thereby allowing multiple labels to be set for each voxel.

9. A computer program for replicating a three-dimensional label mask (20) of a three-dimensional volume dataset (190) in a network (100) of computing devices (101 to 10n), the computer program comprising, when loaded into the memory of a computing device and executed by at least one processor of the computing device, computer-readable instructions causing the computing device to perform the method according to any one of claims 1 to 8.

10. A computing device (101) for replicating a three-dimensional label mask (20) of a three-dimensional volume dataset (190) in a network (100) of computing devices, To initialize the computing device (101), the interface (110) is adapted to receive from the network the current label mask dataset and the entire three-dimensional volume dataset (190) from the network the computing device, and further adapted to receive a set of segmentation input data (21) generated by a further computing device (102) on the network, describing the editing (2-1) of the label mask (20) in the further computing device (102), wherein the specific segmentation input data comprises current position data, size data, and a label identifier associated with a spherical segmentation object (102-1) used by the second computing device (102) to interactively edit the label mask. Each of the aforementioned series of segmentation input data is, Ellipsoid module (101-11) adapted to calculate each ellipsoid corresponding to the spherical segmentation object (102-1) stretched inversely proportional to the shape of the voxels in the label mask, A voxel identifier module (101-12) adapted to determine the voxels (vi) of the label mask having an inside position of the segmentation object based on a ratio obtained by dividing the distance between each voxel position in all three dimensions and the center position of the ellipsoid by the semi-axis length of the ellipsoid as the numerator, wherein each semi-axis length is a floating-point number represented as an integer with respect to sign, mantissa, and exponent, and the division is performed on the graphics processing unit of the computing device (101) by approximating the multiplicative reciprocal of each denominator by sign inverting the exponent of each semi-axis length using bitwise operations, and multiplying the approximated multiplicative reciprocal of each denominator by each numerator, and Update modules (101-13) adapted to update the voxels determined in the replicated label mask (10) according to the label identifiers of the segmentation input data (21). By processing, a replication module (101-10) adapted to replicate the edited label mask of the further computing device (102) associated with the series of segmentation input data, A computing device equipped with [a certain feature].

11. The voxel identifier module performs the bitwise division operation A / B by multiplying A by an approximate value of B-1, which is the reciprocal of B. The approximate value is calculated by subtracting B, which is interpreted as an integer, from a predetermined integer constant. The predetermined integer constant is predetermined so that the result of the integer subtraction approximates the reciprocal of the floating-point number, by utilizing a standardized encoding format for floating-point numbers that includes the positions of exponents and fractions in binary representation. The compiler of the computing device is instructed to interpret the 32-bit floating-point number as an integer without changing the binary representation. The resulting integer is subtracted from the predetermined integer constant. The device according to claim 10, wherein the result of the subtraction is reinterpreted as a floating-point number, and an approximate value of the reciprocal of the original floating-point number is obtained.

12. The device according to claim 10, wherein the collaborative session is a session executed within a medical application.

13. The device according to claim 10, wherein the computing device (101) further receives the hash value of the corresponding edited label mask (20) of the further computing device (102) along with the segmentation input data (21), and is adapted to calculate the hash value of each of the replicated label masks (10) in order to ensure the accuracy of the replication of the label mask between the two computing devices.

14. The device according to claim 10, wherein the update module is further adapted to support one of a plurality of update modes, the plurality of update modes comprising: a label setting mode for setting the determined voxels in the duplicated label mask to the label identifiers of the segmentation input data; an unlabeling mode for removing a specific previously set label identifier from the determined voxels in the duplicated label mask; a label erasure mode for resetting all label identifiers of the determined voxels in the duplicated label mask; a label setting mode for unassigned voxels for setting the label identifiers of the segmentation input data in the duplicated label mask only to determined voxels that have not yet been labeled; and a label setting mode for visible voxels for setting the label identifiers of the segmentation input data in the duplicated label mask only to determined voxels that are visible according to the applied transfer function.

15. The device according to claim 10, wherein the bits of the voxel value in the label mask represent a single integer label value for each voxel, or each bit of the voxel value in the label mask corresponds to an individual label of the corresponding voxel.

Images