System and method for rendering an oblique slice through volumetric data accessed via a client-server architecture
View Patent ↗A system renders oblique slices through volumetric data accessed via a network using a client-server architecture. The system includes a server for processing and storing volumetric data comprising axial slices obtained from a diagnostic scanning system, a client for processing user requests related to specific views of the volumetric data, and a network protocol for connecting the client with the server over the network and obtaining data from the server for use by the client. A processing stage at the client specifies an oblique slice and communicates particulars of the oblique slice to the server, thereupon obtaining axial slice data from the server specifically for portions of the axial slices that are needed to render the oblique slice. Memory at the client stores the axial slice data, and a rendering stage at the client renders the oblique slice from the axial slice data in the memory.
1. A system for rendering an oblique slice through volumetric data accessed via a network using a client-server architecture, the system comprising:
a server for processing and storing volumetric data comprising axial slices obtained from a diagnostic scanning system;
a client for processing user requests related to specific views of the volumetric data;
a network protocol for connecting the client with the server over the network and obtaining data from the server for use by the client;
a processing stage at the client for specifying an oblique slice responsive to user input and communicating particulars of the oblique slice to the server, thereupon obtaining axial slice data from the server specifically for portions of the axial slices that are needed to render the oblique slice;
memory at the client for storing the axial slice data; and
a rendering stage at the client for rendering the oblique slice from the axial slice data in the memory.
2. The system as claimed in claim 1 wherein the processing stage at the client specifies a position of the oblique slice, identifies portions of the axial slices that are needed to render the oblique slice, and requests needed axial slice data from the server specifically comprising the portions of the axial slices identified by the client that are needed to render the oblique slice.
3. The system as claimed in claim 1 wherein the processing stage at the client generates an equation of a plane comprising the oblique slice and communicates the equation of the plane to the server, which identifies portions of the axial slices that are needed to render the oblique slice, whereby the client then obtains the portions of axial slices from the server.
4. The system as claimed in claim 1 further comprising a stage for determining if any of the axial slice data is already stored in the memory at the client, whereby the processing stage thereupon obtains only new axial slice data that is not already in the memory and the rendering stage utilizes both the new axial slice data and the axial slice data already stored in the memory.
5. The system as claimed in claim 1 wherein the server uses JPEG2000 compression to transform the data from the diagnostic scanning system into wavelet coefficients that are grouped into rectangular structures.
6. The system as claimed in claim 5 wherein the processing stage at the client identifies wavelet coefficients in the axial slices that are needed to render the oblique slice, and requests needed compressed data from the server comprising the wavelet coefficients of the axial slices that are needed to render the oblique slice.
7. The system as claimed in claim 6 wherein the rectangular structures comprise subbands including precincts and the processing stage requests needed compressed data belonging to the precincts corresponding to the portions of the axial slices that are needed to render the oblique slice.
8. The system as claimed in claim 1 wherein the processing stage at the client for specifying an oblique slice specifies the oblique slice responsive to user input.
9. The system as claimed in claim 5 wherein the network protocol is a JPIP protocol associated with JPEG2000-compressed data.
10. The system as claimed in claim 9 wherein a “model=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “not necessary” as well as all precincts which have been tagged as “necessary” but already stored in the memory, resulting in their non-transmission by the server.
11. The system as claimed in claim 9 wherein a “need=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “necessary” but are not stored in the memory, resulting in their transmission by the server.
12. A method for rendering oblique slices through volumetric data accessed via a network using a client-server architecture, the method comprising the steps of:
processing and storing volumetric data at the server comprising axial slices obtained from a diagnostic scanning system;
connecting the client with the server over the network according to a network protocol and obtaining data from the server for use by the client;
specifying an oblique slice at the client and communicating particulars of the oblique slice to the server;
identifying portions of the axial slices that are needed to render the oblique slice;
obtaining needed data from the server specifically for the portions of the axial slices that are needed to render the oblique slice;
storing the needed data in memory at the client; and
rendering the oblique slice at the client from the needed data in the memory.
13. The method as claimed in claim 12 wherein the identifying steps occurs at the client.
14. The method as claimed in claim 12 wherein the identifying step occurs at the server.
15. The method as claimed in claim 12 further comprising the steps of determining if any of the needed data is already stored in the memory at the client and transmitting only new needed data that is not already in the memory, whereby the step of rendering utilizes both new needed data and needed data already stored in the memory.
16. A method for rendering oblique slices through volumetric data accessed via a network using a client-server architecture, whereby JPEG2000 compression is used to transform the volumetric data into wavelet coefficients that are grouped into precincts, the method comprising the steps of:
processing and storing JPEG2000-compressed volumetric data at the server, wherein the volumetric data comprises axial slices obtained from a diagnostic scanning system;
connecting the client with the server over the network according to a JPIP protocol;
specifying an oblique slice within the volumetric data;
identifying wavelet coefficients in the axial slices that are needed to render the oblique slice;
requesting compressed data belonging to specific precincts from the server, wherein the specific precincts include the wavelet coefficients that are needed to render the oblique slice, whereby the specifying, identifying and requesting steps occur at the client;
storing compressed data belonging to the specific precincts in memory at the client; and
rendering the oblique slice from the wavelet coefficients included in the compressed data belonging to the specific precincts in the memory.
17. The method as claimed in claim 16 further comprising the steps of determining if any of the requested precincts are already stored in the memory at the client and transmitting only compressed data belonging to new precincts that are not already in the memory, whereby the step of rendering utilizes compressed data belonging to both new precincts and precincts already stored in the memory.
18. The method as claimed in claim 17 wherein a “model=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “not necessary” as well as all precincts which have been tagged as “necessary” but already stored in the memory, resulting in their non-transmission by the server.
19. The method as claimed in claim 17 wherein a “need=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “necessary” but are not stored in the memory, resulting in their transmission by the server.
20. A method for rendering oblique slices through volumetric data accessed via a network using a client-server architecture, whereby JPEG2000 compression is used to transform the volumetric data into wavelet coefficients that are grouped into precincts, the method comprising the steps of:
processing and storing JPEG2000-compressed volumetric data at the server, wherein the volumetric data comprises axial slices obtained from a diagnostic scanning system;
connecting the client with the server over the network according to a JPIP protocol;
specifying an oblique slice within the volumetric data;
deriving an equation of a plane that contains the oblique slice;
utilizing the equation to identify wavelet coefficients in the axial slices that are needed to render the oblique slice;
obtaining compressed data belonging to specific precincts from the server, wherein the specific precincts include the wavelet coefficients that are needed to render the oblique slice, whereby the specifying and deriving steps occur at the client and the utilizing step occurs at the server;
storing the compressed data belonging to the specific precincts in memory at the client; and
rendering the oblique slice from the wavelet coefficients included in the compressed data belonging to the specific precincts in the memory.
21. The method as claimed in claim 20 further comprising the steps of determining if any of the requested precincts are already stored in the memory at the client and transmitting only compressed data belonging to new precincts that are not already in the memory, whereby the step of rendering utilizes compressed data belonging to both new precincts and precincts already stored in the memory.
22. The method as claimed in claim 20 wherein a “model=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “not necessary” as well as all precincts which have been tagged as “necessary” but already stored in the memory, resulting in their non-transmission by the server.
23. The method as claimed in claim 20 wherein a “need=” field of the JPIP protocol is used to notify the server of all precincts that have been tagged as “necessary” but are not stored in the memory, resulting in their transmission by the server.
24. A computer program product having at least one computer storage medium having instructions stored therein causing one or more computers to perform the method of claim 12 .
25. A computer program product having at least one computer storage medium having instructions stored therein causing one or more computers to perform the method of claim 16 .
26. A computer program product having at least one computer storage medium having instructions stored therein causing one or more computers to perform the method of claim 20 .