1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#ifndef GDCMSTREAMIMAGEREADER_H
#define GDCMSTREAMIMAGEREADER_H
#include "gdcmPixmapReader.h"
#include "gdcmImage.h"
#include "gdcmReader.h"
#include <iostream>
#include "gdcmDataSet.h"
namespace gdcm
{
class MediaStorage;
/**
* \brief StreamImageReader
* \note its role is to convert the DICOM DataSet into a gdcm::Image
* representation via an ITK streaming (ie, multithreaded) interface
* Image is different from Pixmap has it has a position and a direction in
* Space.
* Currently, this class is threadsafe in that it can read a single extent
* in a single thread. Multiple versions can be used for multiple extents/threads.
*
* \see Image
*/
class GDCM_EXPORT StreamImageReader
{
public:
StreamImageReader();
~StreamImageReader();
/// One of either SetFileName or SetStream must be called prior
/// to any other functions. These initialize an internal Reader class
/// to be able to get non-pixel image information.
void SetFileName(const char* inFileName);
void SetStream(std::istream& inStream);
std::vector<unsigned int> GetDimensionsValueForResolution( unsigned int );
/// Defines an image extent for the Read function.
/// DICOM states that an image can have no more than 2^16 pixels per edge (as of 2009)
/// In this case, the pixel extents ignore the direction cosines entirely, and
/// assumes that the origin of the image is at location 0,0 (regardless of the definition
/// in space per the tags). So, if the first 100 pixels of the first row are to be read in,
/// this function should be called with DefinePixelExtent(0, 100, 0, 1), regardless
/// of pixel size or orientation.
/// 15 nov 2010: added z dimension, defaults to being 1 plane large
void DefinePixelExtent(uint16_t inXMin, uint16_t inXMax,
uint16_t inYMin, uint16_t inYMax, uint16_t inZMin = 0, uint16_t inZMax = 1);
/// Paying attention to the pixel format and so forth, define the proper buffer length for the user.
/// The return amount is in bytes. Call this function to determine the size of the char* buffer
/// that will need to be passed in to ReadImageSubregion().
/// If the return is 0, then that means that the pixel extent was not defined prior
uint32_t DefineProperBufferLength() const;
/// Read the DICOM image. There are three reasons for failure:
/// 1. The extent is not set
/// 2. the conversion from void* to std::ostream (internally) fails
/// 3. the given buffer isn't large enough to accomodate the desired pixel extent.
/// This method has been implemented to look similar to the metaimageio in itk
/// MUST have an extent defined, or else Read will return false.
/// If no particular extent is required, use ImageReader instead.
bool Read(void* inReadBuffer, const std::size_t& inBufferLength);
/// Only RAW images are currently readable by the stream reader. As more
/// streaming codecs are added, then this function will be updated to reflect
/// those changes. Calling this function prior to reading will ensure that
/// only streamable files are streamed. Make sure to call ReadImageInformation
/// prior to calling this function.
bool CanReadImage() const;
/// Set the spacing and dimension information for the set filename.
/// returns false if the file is not initialized or not an image,
/// with the pixel 0x7fe0, 0x0010 tag.
virtual bool ReadImageInformation();
/// Returns the dataset read by ReadImageInformation
/// Couple this with the ImageHelper to get statistics about the image,
/// like pixel extent, to be able to initialize buffers for reading
File const & GetFile() const;
protected:
//contains a reader for being able to ReadUpToTag
//however, we don't want the user to be able to call Read
//either directly or via a parent class call, so we hide the reader in here.
Reader mReader;
std::streamoff mFileOffset; //the fileoffset for getting header information
std::streamoff mFileOffset1;
DataSet mHeaderInformation; //all the non-pixel information
//for thread safety, these should not be stored here, but should be used
//for every read subregion operation.
uint16_t mXMin, mYMin, mXMax, mYMax, mZMin, mZMax;
/// Using the min, max, etc set by DefinePixelExtent, this will fill the given buffer
/// Make sure to call DefinePixelExtent and to initialize the buffer with the
/// amount given by DefineProperBufferLength prior to calling this.
/// reads by the RAW codec; other codecs are added once implemented
//virtual bool ReadImageSubregionRAW(std::ostream& os);
virtual bool ReadImageSubregionRAW(char* inReadBuffer, const std::size_t& inBufferLength);
/// Reads the file via JpegLS. The JpegLS codec, as of this writing, requires that the
/// entire file be read in in order to decode a subregion, so that's what's done here.
bool ReadImageSubregionJpegLS(char* inReadBuffer, const std::size_t& inBufferLength);
};
//see http://stackoverflow.com/questions/1448467/initializing-a-c-stdistringstream-from-an-in-memory-buffer/1449527#1449527
struct OneShotReadBuf : public std::streambuf
{
OneShotReadBuf(void* s, std::size_t n){
char* cast = (char*)s;
setg(cast, cast, cast+n);
}
};
} // end namespace gdcm
#endif //GDCMSTREAMIMAGEREADER_H
|
