Commit 8999aeed86b9cf1051c3b3e2d9dafd73da25a083 - gdcm

New upstream version 3.0.7 Gert Wollny 3 years ago

153 changed file(s) with 1409 addition(s) and 944 deletion(s). Raw diff Collapse all Expand all

+13

-0

Applications/Cxx/CMakeLists.txt less more

72	72	list(APPEND libpoppler_flags -DLIBPOPPLER_GLOBALPARAMS_CSTOR_HAS_PARAM)
73	73	endif()
74	74	CHECK_CXX_SOURCE_COMPILES(
	75	"\#include <poppler/GlobalParams.h>\nint main() { globalParams.reset( new GlobalParams()); return 0;}"
	76	LIBPOPPLER_GLOBALPARAMS_HAS_RESET)
	77	set(libpoppler_flags)
	78	if(LIBPOPPLER_GLOBALPARAMS_HAS_RESET)
	79	list(APPEND libpoppler_flags -DLIBPOPPLER_GLOBALPARAMS_HAS_RESET)
	80	endif()
	81	CHECK_CXX_SOURCE_COMPILES(
75	82	"\#include <poppler/PDFDoc.h>\nint main() { PDFDoc d((GooString)NULL,(GooString)NULL,(GooString*)NULL); d.getPDFVersion(); return 0;}"
76	83	LIBPOPPLER_PDFDOC_HAS_PDFVERSION)
77	84	if(LIBPOPPLER_PDFDOC_HAS_PDFVERSION)

100	107	LIBPOPPLER_GOOSTRING_HAS_GETCSTRING)
101	108	if(LIBPOPPLER_GOOSTRING_HAS_GETCSTRING)
102	109	list(APPEND libpoppler_flags -DLIBPOPPLER_GOOSTRING_HAS_GETCSTRING)
	110	endif()
	111	CHECK_CXX_SOURCE_COMPILES(
	112	"\#include <poppler/UnicodeMap.h>\nint main() { Unicode u; char buf[8]; const UnicodeMap *uMap; uMap->mapUnicode(u, buf, sizeof(buf)); return 0; }"
	113	LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE)
	114	if(LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE)
	115	list(APPEND libpoppler_flags -DLIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE)
103	116	endif()
104	117	if(libpoppler_flags)
105	118	string(REPLACE ";" " " libpoppler_flags_string "${libpoppler_flags}")

-1

Applications/Cxx/gdcmconv.cxx less more

925	925	}
926	926
927	927	// Handle here the general file (not required to be image)
928		if ( explicitts \|\| implicit \|\| deflated )
	928	if ( !raw && (explicitts \|\| implicit \|\| deflated) )
929	929	{
930	930	if( explicitts && implicit ) return 1; // guard
931	931	if( explicitts && deflated ) return 1; // guard

1260	1260	if( ts.IsExplicit() )
1261	1261	{
1262	1262	change.SetTransferSyntax( gdcm::TransferSyntax::ExplicitVRLittleEndian );
	1263	if( implicit )
	1264	change.SetTransferSyntax( gdcm::TransferSyntax::ImplicitVRLittleEndian );
1263	1265	}
1264	1266	else
1265	1267	{
1266	1268	assert( ts.IsImplicit() );
1267	1269	change.SetTransferSyntax( gdcm::TransferSyntax::ImplicitVRLittleEndian );
	1270	if( explicitts )
	1271	change.SetTransferSyntax( gdcm::TransferSyntax::ExplicitVRLittleEndian );
1268	1272	}
1269	1273	#endif
1270	1274	}

+12

-0

Applications/Cxx/gdcminfo.cxx less more

257	257	return out;
258	258	}
259	259
	260	#ifdef LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE
	261	static std::string getInfoString(Dict infoDict, const char key, const UnicodeMap *uMap)
	262	#else
260	263	static std::string getInfoString(Dict infoDict, const char key, UnicodeMap *uMap)
	264	#endif
261	265	{
262	266	Object obj;
263	267	#ifdef LIBPOPPLER_GOOSTRING_HAS_CONSTGETCHAR

508	512	std::string creationdate;
509	513	std::string moddate;
510	514
	515	#ifdef LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE
	516	const UnicodeMap *uMap;
	517	#else
511	518	UnicodeMap *uMap;
	519	#endif
512	520	#ifdef LIBPOPPLER_GLOBALPARAMS_CSTOR_HAS_PARAM
513	521	globalParams = new GlobalParams(0);
514	522	#else
	523	#ifdef LIBPOPPLER_GLOBALPARAMS_HAS_RESET
	524	globalParams.reset(new GlobalParams());
	525	#else
515	526	globalParams = new GlobalParams();
	527	#endif
516	528	#endif
517	529	uMap = globalParams->getTextEncoding();
518	530

+12

-0

Applications/Cxx/gdcmpdf.cxx less more

105	105	return out;
106	106	}
107	107
	108	#ifdef LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE
	109	static std::string getInfoString(Dict infoDict, const char key, const UnicodeMap *uMap, bool & unicode)
	110	#else
108	111	static std::string getInfoString(Dict infoDict, const char key, UnicodeMap *uMap, bool & unicode)
	112	#endif
109	113	{
110	114	Object obj;
111	115	#ifdef LIBPOPPLER_GOOSTRING_HAS_CONSTGETCHAR

332	336	GooString *fileName;
333	337	PDFDoc *doc;
334	338	Object info;
	339	#ifdef LIBPOPPLER_UNICODEMAP_HAS_CONSTMAPUNICODE
	340	const UnicodeMap *uMap;
	341	#else
335	342	UnicodeMap *uMap;
	343	#endif
336	344	ownerPW = NULL;
337	345	userPW = NULL;
338	346	#ifdef LIBPOPPLER_GLOBALPARAMS_CSTOR_HAS_PARAM
339	347	globalParams = new GlobalParams(0);
340	348	#else
	349	#ifdef LIBPOPPLER_GLOBALPARAMS_HAS_RESET
	350	globalParams.reset(new GlobalParams());
	351	#else
341	352	globalParams = new GlobalParams();
	353	#endif
342	354	#endif
343	355	uMap = globalParams->getTextEncoding();
344	356

-1

Applications/Cxx/gdcmtar.cxx less more

1391	1391	gdcm::UIDs uid;
1392	1392	uid.SetFromUID( ms.GetString() );
1393	1393
1394		if( uid != gdcm::UIDs::EnhancedMRImageStorage )
	1394	if( uid != gdcm::UIDs::uid_1_2_840_10008_5_1_4_1_1_4_1 ) //NOTE: uid_1_2_840_10008_5_1_4_1_1_4_1 = 121, // Enhanced MR Image Storage
1395	1395	{
1396	1396	std::cerr << "MediaStorage is not handled " << ms << " [" << uid.GetName() << "]" << std::endl;
1397	1397	return 1;

-1

CMakeLists.txt less more

16	16	#----------------------------------------------------------------------------
17	17
18	18	project(GDCM
19		VERSION 3.0.5
	19	VERSION 3.0.7
20	20	LANGUAGES CXX C
21	21	)
22	22	## NOTE: the "DESCRIPTION" feature of project() was introduced in cmake 3.10.0

-5

Examples/Cxx/GetSubSequenceData.cxx less more

76	76	DataSet &subds3 = item3.GetNestedDataSet();
77	77
78	78	const PrivateTag tseq6(0x7fe1,0x26,"GEMS_Ultrasound_MovieGroup_001");
79		if( !subds3.FindDataElement( tseq6 ) ) return 1;
	79	if( !subds3.FindDataElement( tseq6 ) ) return true;
80	80	const DataElement& seq6 = subds3.GetDataElement( tseq6 );
81	81	SmartPointer<SequenceOfItems> sqi6 = seq6.GetValueAsSQ();
82	82	size_t ni6= sqi6->GetNumberOfItems();

99	99	}
100	100
101	101	const PrivateTag tseq3(0x7fe1,0x36,"GEMS_Ultrasound_MovieGroup_001");
102		if( !subds3.FindDataElement( tseq3 ) ) return 1;
	102	if( !subds3.FindDataElement( tseq3 ) ) return true;
103	103	const DataElement& seq3 = subds3.GetDataElement( tseq3 );
104	104
105	105	// std::cout << seq3 << std::endl;

118	118	Item &item4 = sqi4->GetItem(i4);
119	119	DataSet &subds4 = item4.GetNestedDataSet();
120	120
121		if( !subds4.FindDataElement( tseq8 ) ) return 1;
	121	if( !subds4.FindDataElement( tseq8 ) ) return true;
122	122	const DataElement& de8 = subds4.GetDataElement( tseq8 );
123	123	Element<VR::UL,VM::VM1> ldimz;
124	124	ldimz.SetFromDataElement( de8 );
125	125	dimz += ldimz.GetValue();
126		if( !subds4.FindDataElement( tseq4 ) ) return 1;
	126	if( !subds4.FindDataElement( tseq4 ) ) return true;
127	127	const DataElement& seq4 = subds4.GetDataElement( tseq4 );
128		if( !subds4.FindDataElement( tseq5 ) ) return 1;
	128	if( !subds4.FindDataElement( tseq5 ) ) return true;
129	129	const DataElement& seq5 = subds4.GetDataElement( tseq5 );
130	130
131	131	// std::cout << seq4 << std::endl;

-0

Examples/Java/CMakeLists.txt less more

14	14	DecompressImage
15	15	ScanDirectory
16	16	ReadFiles
	17	SimplePrint
17	18	FileAnonymize
18	19	)
19	20	foreach(example ${examples})

+72

-0

Examples/Java/SimplePrint.java less more

	0	/*=========================================================================
	1
	2	Program: GDCM (Grassroots DICOM). A DICOM library
	3
	4	Copyright (c) 2006-2011 Mathieu Malaterre
	5	All rights reserved.
	6	See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
	7
	8	This software is distributed WITHOUT ANY WARRANTY; without even
	9	the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	10	PURPOSE. See the above copyright notice for more information.
	11
	12	=========================================================================*/
	13	/*
	14	* Compilation:
	15	* $ CLASSPATH=gdcm.jar javac ../../gdcm/Examples/Java/SimplePrint.java -d .
	16	*
	17	* Usage:
	18	* $ LD_LIBRARY_PATH=. CLASSPATH=gdcm.jar:. java SimplePrint gdcmData/012345.002.050.dcm
	19	*/
	20	import gdcm.*;
	21
	22	public class SimplePrint
	23	{
	24	public static void RecurseDataSet(File f, DataSet ds, String indent)
	25	{
	26	JavaDataSet cds = new JavaDataSet(ds);
	27	while(!cds.IsAtEnd())
	28	{
	29	DataElement de = cds.GetCurrent();
	30	// Compute VR from the toplevel file, and the currently processed dataset:
	31	VR vr = DataSetHelper.ComputeVR(f, ds, de.GetTag() );
	32
	33	if( vr.Compatible( new VR(VR.VRType.SQ) ) )
	34	{
	35	long uvl = de.GetVL().GetValueLength(); // Test cast is ok
	36	System.out.println( indent + de.GetTag().toString() + ":" + uvl ); // why not ?
	37	//SequenceOfItems sq = de.GetSequenceOfItems();
	38	// GetValueAsSQ handle more cases than GetSequenceOfItems
	39	SmartPtrSQ sq = de.GetValueAsSQ();
	40	long n = sq.GetNumberOfItems();
	41	for( long i = 1; i <= n; i++) // item starts at 1, not 0
	42	{
	43	Item item = sq.GetItem( i );
	44	DataSet nested = item.GetNestedDataSet();
	45	RecurseDataSet( f, nested, indent + " " );
	46	}
	47	}
	48	else
	49	{
	50	System.out.println( indent + de.toString() );
	51	}
	52	cds.Next();
	53	}
	54	}
	55
	56	public static void main(String[] args) throws Exception
	57	{
	58	String filename = args[0];
	59	Reader reader = new Reader();
	60	reader.SetFileName( filename );
	61	boolean ret = reader.Read();
	62	if( !ret )
	63	{
	64	throw new Exception("Could not read: " + filename );
	65	}
	66	File f = reader.GetFile();
	67	DataSet ds = f.GetDataSet();
	68
	69	RecurseDataSet( f, ds, "" );
	70	}
	71	}

-0

Source/Common/CMakeLists.txt less more

7	7	mark_as_advanced(
8	8	GDCM_ALWAYS_TRACE_MACRO
9	9	GDCM_SUPPORT_BROKEN_IMPLEMENTATION
	10	GDCM_AUTOLOAD_GDCMJNI
10	11	)
11	12
12	13	#if(WIN32)

+30

-13

Source/Common/gdcmDirectory.cxx less more

42	42	return 0;
43	43	}
44	44
	45	#ifdef _MSC_VER
	46	static inline std::string ToUtf8(std::wstring const &str) {
	47	std::string ret;
	48	int len = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.length(),
	49	nullptr, 0, NULL, NULL);
	50	if (len > 0) {
	51	ret.resize(len);
	52	WideCharToMultiByte(CP_UTF8, 0, str.c_str(), (int)str.length(), &ret[0],
	53	len, NULL, NULL);
	54	}
	55	return ret;
	56	}
	57	#endif
	58
45	59	unsigned int Directory::Explore(FilenameType const &name, bool recursive)
46	60	{
47	61	unsigned int nFiles = 0;
48		std::string fileName;
49		std::string dirName = name;
50		//assert( System::FileIsDirectory( dirName ) );
51		Directories.push_back( dirName );
52	62	#ifdef _MSC_VER
53		WIN32_FIND_DATA fileData;
54		if ('/' != dirName[dirName.size()-1]) dirName.push_back('/');
55		assert( '/' == dirName[dirName.size()-1] );
56		const FilenameType firstfile = dirName+"*";
57		HANDLE hFile = FindFirstFile(firstfile.c_str(), &fileData);
	63	std::wstring fileName;
	64	std::wstring dirName = System::ConvertToUNC(name.c_str());
	65	Directories.push_back(ToUtf8(dirName));
	66	WIN32_FIND_DATAW fileData;
	67	if ('\\' != dirName[dirName.size()-1]) dirName.push_back('\\');
	68	assert( '\\' == dirName[dirName.size()-1] );
	69	const std::wstring firstfile = dirName+L"*";
	70	HANDLE hFile = FindFirstFileW(firstfile.c_str(), &fileData);
58	71
59	72	for(BOOL b = (hFile != INVALID_HANDLE_VALUE); b;
60		b = FindNextFile(hFile, &fileData))
	73	b = FindNextFileW(hFile, &fileData))
61	74	{
62	75	fileName = fileData.cFileName;
63	76	if ( fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
64	77	{
65	78	// Need to check for . and .. to avoid infinite loop
66		if ( fileName != "." && fileName != ".."
	79	if ( fileName != L"." && fileName != L".."
67	80	&& fileName[0] != '.' // discard any hidden dir
68	81	&& recursive )
69	82	{
70		nFiles += Explore(dirName+fileName,recursive);
	83	nFiles += Explore(ToUtf8(dirName + fileName), recursive);
71	84	}
72	85	}
73	86	else
74	87	{
75	88	if (fileName[0] != '.') // discard "unix like" hidden files such as .git in submodules
76	89	{
77		Filenames.push_back(dirName+fileName);
	90	Filenames.push_back(ToUtf8(dirName+fileName));
78	91	nFiles++;
79	92	}
80	93	}

88	101	}
89	102
90	103	#else
	104	std::string fileName;
	105	std::string dirName = name;
	106	// assert( System::FileIsDirectory( dirName ) );
	107	Directories.push_back(dirName);
91	108	// Real POSIX implementation: scandir is a BSD extension only, and doesn't
92	109	// work on debian for example
93	110

-1

Source/Common/gdcmEvent.h less more

40	40	virtual void Print(std::ostream& os) const;
41	41
42	42	/** Return the StringName associated with the event. */
43		virtual const char * GetEventName(void) const = 0;
	43	virtual const char * GetEventName() const = 0;
44	44
45	45	/** Check if given event matches or derives from this event. */
46	46	virtual bool CheckEvent(const Event*) const = 0;

-3

Source/Common/gdcmException.h less more

53	53	const unsigned int lineNumber,
54	54	const char* const func)
55	55	{
56		assert(desc != NULL);
57		assert(file != NULL);
58		assert(func != NULL);
	56	assert(desc != nullptr);
	57	assert(file != nullptr);
	58	assert(func != nullptr);
59	59	std::ostringstream oswhat;
60	60	oswhat << file << ":" << lineNumber << " (" << func << "):\n";
61	61	oswhat << desc;

+101

-6

Source/Common/gdcmSystem.cxx less more

134	134	*/
135	135	}
136	136
	137	static inline int Mkdir2(const char *utf8)
	138	{
	139	#ifdef _MSC_VER
	140	const std::wstring unc = System::ConvertToUNC(utf8);
	141	return _wmkdir(unc.c_str());
	142	#else
	143	return Mkdir(utf8);
	144	#endif
	145	}
	146
137	147	bool System::MakeDirectory(const char *path)
138	148	{
139	149	if( !path \|\| !*path )

155	165	while(ok && (pos = dir.find('/', pos)) != std::string::npos)
156	166	{
157	167	topdir = dir.substr(0, pos+1);
158		ok = ok && (System::FileIsDirectory(topdir.c_str()) \|\| 0 == Mkdir(topdir.c_str()));
	168	ok = ok && (System::FileIsDirectory(topdir.c_str()) \|\| 0 == Mkdir2(topdir.c_str()));
159	169	pos++;
160	170	}
161	171	if( !ok ) return false;

167	177	{
168	178	topdir = dir;
169	179	}
170		if(Mkdir(topdir.c_str()) != 0)
	180	if(Mkdir2(topdir.c_str()) != 0)
171	181	{
172	182	// There is a bug in the Borland Run time library which makes MKDIR
173	183	// return EACCES when it should return EEXISTS

188	198	// return true if the file exists
189	199	bool System::FileExists(const char* filename)
190	200	{
191		#ifdef _MSC_VER
192		# define access _access
193		#endif
194	201	#ifndef R_OK
195	202	# define R_OK 04
196	203	#endif
	204	#ifdef _MSC_VER
	205	const std::wstring unc = System::ConvertToUNC(filename);
	206	if (_waccess(unc.c_str(), R_OK) != 0)
	207	#else
197	208	if ( access(filename, R_OK) != 0 )
	209	#endif
198	210	{
199	211	return false;
200	212	}

207	219
208	220	bool System::FileIsDirectory(const char* name)
209	221	{
	222	#ifdef _MSC_VER
	223	struct _stat64i32 fs;
	224	const std::wstring wname = System::ConvertToUNC(name);
	225	if (_wstat(wname.c_str(), &fs) == 0)
	226	#else
210	227	struct stat fs;
211	228	if(stat(name, &fs) == 0)
	229	#endif
212	230	{
213	231	#if _WIN32
214	232	return ((fs.st_mode & _S_IFDIR) != 0);

365	383	#define PATH_MAX 4096
366	384	#endif
367	385
	386	#ifdef _MSC_VER
	387	namespace {
	388	static inline std::wstring ToUtf16(std::string const &str) {
	389	std::wstring ret;
	390	int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(),
	391	nullptr, 0);
	392	if (len > 0) {
	393	ret.resize(len);
	394	MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), &ret[0],
	395	len);
	396	}
	397	return ret;
	398	}
	399	// http://arsenmk.blogspot.com/2015/12/handling-long-paths-on-windows.html
	400	static inline bool ComputeFullPath(std::wstring const &in,
	401	std::wstring &out) {
	402	// consider an input fileName of type PCWSTR (const wchar_t*)
	403	const wchar_t *fileName = in.c_str();
	404	DWORD requiredBufferLength =
	405	GetFullPathNameW(fileName, 0, nullptr, nullptr);
	406
	407	if (0 == requiredBufferLength) // means failure
	408	{
	409	return false;
	410	}
	411
	412	out.resize(requiredBufferLength);
	413	wchar_t *buffer = &out[0];
	414
	415	DWORD result =
	416	GetFullPathNameW(fileName, requiredBufferLength, buffer, nullptr);
	417
	418	if (0 == result) {
	419	return false;
	420	}
	421
	422	// buffer now contains the full path name of fileName, use it.
	423	return true;
	424	}
	425
	426	static inline std::wstring HandleMaxPath(std::wstring const &in) {
	427	if (in.size() >= MAX_PATH) {
	428	std::wstring out;
	429	bool ret = ComputeFullPath(in, out);
	430	if (!ret) return in;
	431	if (out.size() < 4) return in;
	432	if (out[0] == '\\' && out[1] == '\\' && out[2] == '?') {
	433	// nothing to do
	434	} else if (out[0] == '\\' && out[1] == '\\' && out[2] != '?') {
	435	// server path
	436	const std::wstring prefix = LR"(\\?\UNC\)";
	437	out = prefix + (out.c_str() + 2);
	438	} else {
	439	// regular C:\ style path:
	440	assert(out[1] == ':');
	441	const std::wstring prefix = LR"(\\?\)";
	442	out = prefix + out.c_str();
	443	}
	444	return out;
	445	}
	446	return in;
	447	}
	448	} // namespace
	449	#endif
	450
	451	std::wstring System::ConvertToUNC(const char *utf8path)
	452	{
	453	#ifdef _MSC_VER
	454	const std::wstring uft16path = ToUtf16(utf8path);
	455	const std::wstring uncpath = HandleMaxPath(uft16path);
	456	return uncpath;
	457	#else
	458	(void)utf8path;
	459	return std::wstring();
	460	#endif
	461	}
	462
368	463	// return size of file; also returns zero if no file exists
369	464	size_t System::FileSize(const char* filename)
370	465	{

471	566	if (dladdr( (void*)&where_am_i, &info ) == 0)
472	567	{
473	568	size_t len = strlen(info.dli_fname);
474		if( len >= PATH_MAX ) return 0; // throw error ?
	569	if( len >= PATH_MAX ) return nullptr; // throw error ?
475	570	// else
476	571	strcpy(path,info.dli_fname);
477	572	return path;

-0

Source/Common/gdcmSystem.h less more

37	37	static bool RemoveFile(const char* source);
38	38	/// remove a directory named source
39	39	static bool DeleteDirectory(const char *source);
	40
	41	/// When needed convert a PATH into a UNC equivalent. This allow
	42	/// transparent support for path longer that MAX_PATH.
	43	/// Only on _MSC_VER compiler, return empty string otherwise.
	44	static std::wstring ConvertToUNC(const char *utf8path);
40	45
41	46	/// Return the last error
42	47	static const char *GetLastSystemError();

-2

Source/Common/gdcmTesting.cxx less more

78	78	{
79	79	if( file < Testing::GetNumberOfMediaStorageDataFiles() ) return gdcmMediaStorageDataFiles[file];
80	80	// else return the {0x0, 0x0} sentinel:
81		assert( *gdcmMediaStorageDataFiles[ Testing::GetNumberOfMediaStorageDataFiles() ] == 0 );
	81	assert( *gdcmMediaStorageDataFiles[ Testing::GetNumberOfMediaStorageDataFiles() ] == nullptr );
82	82	return gdcmMediaStorageDataFiles[ Testing::GetNumberOfMediaStorageDataFiles() ];
83	83	}
84	84	const char * Testing::GetMediaStorageFromFile(const char *filepath)

118	118	{
119	119	if( file < Testing::GetNumberOfMD5DataImages() ) return gdcmMD5DataImages[file];
120	120	// else return the {0x0, 0x0} sentinel:
121		assert( *gdcmMD5DataImages[ Testing::GetNumberOfMD5DataImages() ] == 0 );
	121	assert( *gdcmMD5DataImages[ Testing::GetNumberOfMD5DataImages() ] == nullptr );
122	122	return gdcmMD5DataImages[ Testing::GetNumberOfMD5DataImages() ];
123	123	}
124	124

446	446	{ 0,"FUJI-ffff-MONO1-J2K.dcm" },
447	447	{ 0,"JPEGLosslessSeNonZero.dcm" },
448	448	{ 1,"US-YBR_FULL_422-EVRLE.dcm" },
	449	{ 0,"Osirix10vs8BitsStored.dcm" },
	450	{ 0,"Bug_Siemens_PrivateIconNoItem.dcm" },
	451	{ 0,"HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	452	{ 0,"PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
449	453	{ 0, nullptr }
450	454	};
451	455

+50

-50

Source/Common/zipstreamimpl.h less more

128	128	int memory_level,
129	129	size_t buffer_size);
130	130
131		~basic_zip_streambuf(void) override;
132
133		int sync (void) override;
	131	~basic_zip_streambuf() override;
	132
	133	int sync () override;
134	134	int_type overflow (int_type c) override;
135		std::streamsize flush (void);
136		inline
137		ostream_reference get_ostream (void) const;
138		inline
139		int get_zerr (void) const;
140		inline
141		unsigned long get_crc (void) const;
142		inline
143		unsigned long get_in_size (void) const;
144		inline
145		long get_out_size(void) const;
	135	std::streamsize flush ();
	136	inline
	137	ostream_reference get_ostream () const;
	138	inline
	139	int get_zerr () const;
	140	inline
	141	unsigned long get_crc () const;
	142	inline
	143	unsigned long get_in_size () const;
	144	inline
	145	long get_out_size() const;
146	146
147	147	private:
148	148

188	188	size_t read_buffer_size,
189	189	size_t input_buffer_size);
190	190
191		~basic_unzip_streambuf(void) override;
192
193		int_type underflow(void) override;
	191	~basic_unzip_streambuf() override;
	192
	193	int_type underflow() override;
194	194
195	195	/// returns the compressed input istream
196	196	inline
197		istream_reference get_istream (void);
198		inline
199		z_stream& get_zip_stream (void);
200		inline
201		int get_zerr (void) const;
202		inline
203		unsigned long get_crc (void) const;
204		inline
205		long get_out_size (void) const;
206		inline
207		long get_in_size (void) const;
	197	istream_reference get_istream ();
	198	inline
	199	z_stream& get_zip_stream ();
	200	inline
	201	int get_zerr () const;
	202	inline
	203	unsigned long get_crc () const;
	204	inline
	205	long get_out_size () const;
	206	inline
	207	long get_in_size () const;
208	208
209	209
210	210	private:
211	211
212		void put_back_from_zip_stream (void);
	212	void put_back_from_zip_stream ();
213	213
214	214	std::streamsize unzip_from_stream (char_type* buffer,
215	215	std::streamsize buffer_size);
216	216
217		size_t fill_input_buffer (void);
	217	size_t fill_input_buffer ();
218	218
219	219	istream_reference _istream;
220	220	z_stream _zip_stream;

249	249	int memory_level = 8,
250	250	size_t buffer_size = zstream_default_buffer_size);
251	251
252		~basic_zip_ostream(void) override;
253
254		inline
255		bool is_gzip (void) const;
256		inline
257		basic_zip_ostream<charT, traits>& zflush (void);
258		void finished (void);
	252	~basic_zip_ostream() override;
	253
	254	inline
	255	bool is_gzip () const;
	256	inline
	257	basic_zip_ostream<charT, traits>& zflush ();
	258	void finished ();
259	259
260	260	// void make_gzip()
261	261	// { add_header(); _is_gzip = true; }
262	262
263	263	private:
264	264
265		basic_zip_ostream<charT,traits>& add_header(void);
266		basic_zip_ostream<charT,traits>& add_footer(void);
	265	basic_zip_ostream<charT,traits>& add_header();
	266	basic_zip_ostream<charT,traits>& add_footer();
267	267
268	268	bool _is_gzip;
269	269	bool _added_footer;

289	289	size_t input_buffer_size = zstream_default_buffer_size);
290	290
291	291	inline
292		bool is_gzip (void) const;
293		inline
294		bool check_crc (void);
295		inline
296		bool check_data_size (void) const;
297		inline
298		long get_gzip_crc (void) const;
299		inline
300		long get_gzip_data_size(void) const;
	292	bool is_gzip () const;
	293	inline
	294	bool check_crc ();
	295	inline
	296	bool check_data_size () const;
	297	inline
	298	long get_gzip_crc () const;
	299	inline
	300	long get_gzip_data_size() const;
301	301
302	302	protected:
303	303
304		int check_header (void);
305		void read_footer (void);
	304	int check_header ();
	305	void read_footer ();
306	306
307	307	bool _is_gzip;
308	308	long _gzip_crc;

+31

-31

Source/Common/zipstreamimpl.hpp less more

81	81	/** Destructor
82	82	*/
83	83	template <class charT, class traits>
84		basic_zip_streambuf<charT, traits>::~basic_zip_streambuf(void)
	84	basic_zip_streambuf<charT, traits>::~basic_zip_streambuf()
85	85	{
86	86	flush();
87	87	// _ostream.flush(); CM already done in flush()

93	93	* document correctly!
94	94	*/
95	95	template <class charT, class traits>
96		int basic_zip_streambuf<charT, traits>::sync(void)
	96	int basic_zip_streambuf<charT, traits>::sync()
97	97	{
98	98	if(this->pptr() && this->pptr() > this->pbase())
99	99	{

140	140	* multiple times, will lower the compression ratio.
141	141	*/
142	142	template <class charT, class traits>
143		std::streamsize basic_zip_streambuf<charT, traits>::flush(void)
	143	std::streamsize basic_zip_streambuf<charT, traits>::flush()
144	144	{
145	145	std::streamsize written_byte_size = 0, total_written_byte_size = 0;
146	146

188	188	*/
189	189	template <class charT, class traits> inline
190	190	typename basic_zip_streambuf<charT, traits>::ostream_reference
191		basic_zip_streambuf<charT, traits>::get_ostream(void) const
	191	basic_zip_streambuf<charT, traits>::get_ostream() const
192	192	{
193	193	return _ostream;
194	194	}

196	196	/** returns the latest zlib error status
197	197	*/
198	198	template <class charT, class traits> inline
199		int basic_zip_streambuf<charT, traits>::get_zerr(void) const
	199	int basic_zip_streambuf<charT, traits>::get_zerr() const
200	200	{
201	201	return _err;
202	202	}

205	205	*/
206	206	template <class charT, class traits> inline
207	207	unsigned long
208		basic_zip_streambuf<charT, traits>:: get_crc(void) const
	208	basic_zip_streambuf<charT, traits>:: get_crc() const
209	209	{
210	210	return _crc;
211	211	}

214	214	*/
215	215	template <class charT, class traits> inline
216	216	unsigned long
217		basic_zip_streambuf<charT, traits>::get_in_size(void) const
	217	basic_zip_streambuf<charT, traits>::get_in_size() const
218	218	{
219	219	return _zip_stream.total_in;
220	220	}

223	223	*/
224	224	template <class charT, class traits> inline
225	225	long
226		basic_zip_streambuf<charT, traits>::get_out_size(void) const
	226	basic_zip_streambuf<charT, traits>::get_out_size() const
227	227	{
228	228	return _zip_stream.total_out;
229	229	}

333	333	* @todo document!
334	334	*/
335	335	template <class charT, class traits>
336		basic_unzip_streambuf<charT, traits>::~basic_unzip_streambuf(void)
	336	basic_unzip_streambuf<charT, traits>::~basic_unzip_streambuf()
337	337	{
338	338	inflateEnd(&_zip_stream);
339	339	}

344	344	*/
345	345	template <class charT, class traits>
346	346	typename basic_unzip_streambuf<charT, traits>::int_type
347		basic_unzip_streambuf<charT, traits>::underflow(void)
	347	basic_unzip_streambuf<charT, traits>::underflow()
348	348	{
349	349	if(this->gptr() && ( this->gptr() < this->egptr()))
350	350	return * reinterpret_cast<unsigned char *>(this->gptr());

378	378	*/
379	379	template <class charT, class traits> inline
380	380	typename basic_unzip_streambuf<charT, traits>::istream_reference
381		basic_unzip_streambuf<charT, traits>::get_istream(void)
	381	basic_unzip_streambuf<charT, traits>::get_istream()
382	382	{
383	383	return _istream;
384	384	}

387	387	*/
388	388	template <class charT, class traits> inline
389	389	z_stream &
390		basic_unzip_streambuf<charT, traits>::get_zip_stream(void)
	390	basic_unzip_streambuf<charT, traits>::get_zip_stream()
391	391	{
392	392	return _zip_stream;
393	393	}

396	396	*/
397	397	template <class charT, class traits> inline
398	398	int
399		basic_unzip_streambuf<charT, traits>::get_zerr(void) const
	399	basic_unzip_streambuf<charT, traits>::get_zerr() const
400	400	{
401	401	return _err;
402	402	}

405	405	*/
406	406	template <class charT, class traits> inline
407	407	unsigned long
408		basic_unzip_streambuf<charT, traits>::get_crc(void) const
	408	basic_unzip_streambuf<charT, traits>::get_crc() const
409	409	{
410	410	return _crc;
411	411	}

414	414	*/
415	415	template <class charT, class traits> inline
416	416	long
417		basic_unzip_streambuf<charT, traits>::get_out_size(void) const
	417	basic_unzip_streambuf<charT, traits>::get_out_size() const
418	418	{
419	419	return _zip_stream.total_out;
420	420	}

423	423	*/
424	424	template <class charT, class traits> inline
425	425	long
426		basic_unzip_streambuf<charT, traits>::get_in_size(void) const
	426	basic_unzip_streambuf<charT, traits>::get_in_size() const
427	427	{
428	428	return _zip_stream.total_in;
429	429	}

437	437	*/
438	438	template <class charT, class traits> inline
439	439	void
440		basic_unzip_streambuf<charT, traits>::put_back_from_zip_stream(void)
	440	basic_unzip_streambuf<charT, traits>::put_back_from_zip_stream()
441	441	{
442	442	if(_zip_stream.avail_in == 0)
443	443	return;

495	495	*/
496	496	template <class charT, class traits> inline
497	497	size_t
498		basic_unzip_streambuf<charT, traits>::fill_input_buffer(void)
	498	basic_unzip_streambuf<charT, traits>::fill_input_buffer()
499	499	{
500	500	_zip_stream.next_in = &_input_buffer[0];
501	501	_istream.read((char_type*) &_input_buffer[0],

564	564	/** Destructor
565	565	*/
566	566	template <class charT, class traits>
567		basic_zip_ostream<charT, traits>::~basic_zip_ostream(void)
	567	basic_zip_ostream<charT, traits>::~basic_zip_ostream()
568	568	{
569	569	//if(_is_gzip)
570	570	add_footer();

573	573	/** returns true if it is a gzip
574	574	*/
575	575	template <class charT, class traits> inline
576		bool basic_zip_ostream<charT, traits>::is_gzip(void) const
	576	bool basic_zip_ostream<charT, traits>::is_gzip() const
577	577	{
578	578	return _is_gzip;
579	579	}

582	582	*/
583	583
584	584	template <class charT, class traits> inline
585		basic_zip_ostream<charT, traits>& basic_zip_ostream<charT, traits>::zflush(void)
	585	basic_zip_ostream<charT, traits>& basic_zip_ostream<charT, traits>::zflush()
586	586	{
587	587	static_cast<std::basic_ostream<charT, traits> *>(this)->flush();
588	588	static_cast<basic_zip_streambuf<charT, traits> *>(this)->flush();

590	590	}
591	591
592	592	template <class charT, class traits> inline
593		void basic_zip_ostream<charT, traits>::finished(void)
	593	void basic_zip_ostream<charT, traits>::finished()
594	594	{
595	595	if(_is_gzip)
596	596	add_footer();

607	607	* @todo document!
608	608	*/
609	609	template <class charT, class traits>
610		basic_zip_ostream<charT,traits>& basic_zip_ostream<charT, traits>::add_header(void)
	610	basic_zip_ostream<charT,traits>& basic_zip_ostream<charT, traits>::add_header()
611	611	{
612	612	char_type zero = 0;
613	613

626	626	* @todo document!
627	627	*/
628	628	template <class charT, class traits>
629		basic_zip_ostream<charT,traits>& basic_zip_ostream<charT, traits>::add_footer(void)
	629	basic_zip_ostream<charT,traits>& basic_zip_ostream<charT, traits>::add_footer()
630	630	{
631	631	if(_added_footer)
632	632	return *this;

700	700	*/
701	701	template <class charT, class traits> inline
702	702	bool
703		basic_zip_istream<charT, traits>::is_gzip(void) const
	703	basic_zip_istream<charT, traits>::is_gzip() const
704	704	{
705	705	return _is_gzip;
706	706	}

714	714	*/
715	715	template <class charT, class traits> inline
716	716	bool
717		basic_zip_istream<charT, traits>::check_crc(void)
	717	basic_zip_istream<charT, traits>::check_crc()
718	718	{
719	719	read_footer();
720	720	return this->get_crc() == _gzip_crc;

724	724	*/
725	725	template <class charT, class traits> inline
726	726	bool
727		basic_zip_istream<charT, traits>::check_data_size(void) const
	727	basic_zip_istream<charT, traits>::check_data_size() const
728	728	{
729	729	return this->get_out_size() == _gzip_data_size;
730	730	}

733	733	*/
734	734	template <class charT, class traits> inline
735	735	long
736		basic_zip_istream<charT, traits>::get_gzip_crc(void) const
	736	basic_zip_istream<charT, traits>::get_gzip_crc() const
737	737	{
738	738	return _gzip_crc;
739	739	}

742	742	*/
743	743	template <class charT, class traits> inline
744	744	long
745		basic_zip_istream<charT, traits>::get_gzip_data_size(void) const
	745	basic_zip_istream<charT, traits>::get_gzip_data_size() const
746	746	{
747	747	return _gzip_data_size;
748	748	}

756	756	*/
757	757	template <class charT, class traits>
758	758	int
759		basic_zip_istream<charT, traits>::check_header(void)
	759	basic_zip_istream<charT, traits>::check_header()
760	760	{
761	761	int method; /* method byte */
762	762	int flagsbyte; /* flags byte */

830	830	*/
831	831	template <class charT, class traits>
832	832	void
833		basic_zip_istream<charT, traits>::read_footer(void)
	833	basic_zip_istream<charT, traits>::read_footer()
834	834	{
835	835	if(_is_gzip)
836	836	{

-2

Source/DataDictionary/gdcmDicts.cxx less more

59	59	}
60	60	else if( tag.IsPublic() )
61	61	{
62		assert( owner == NULL );
	62	assert( owner == nullptr );
63	63	return PublicDict.GetDictEntry(tag);
64	64	}
65	65	else

91	91	assert( !tag.IsIllegal() );
92	92	assert( tag.GetElement() ); // Not a group length !
93	93	assert( tag.IsPrivate() );
94		assert( owner == 0x0 );
	94	assert( owner == nullptr );
95	95	{
96	96	static const char pc[] = "Private Creator";
97	97	static const char kw[] = "PrivateCreator";

-2

Source/DataDictionary/gdcmGlobal.cxx less more

75	75	{
76	76	if(++GlobalCount == 1)
77	77	{
78		assert( Internals == NULL ); // paranoid
	78	assert( Internals == nullptr ); // paranoid
79	79	Internals = new GlobalInternal;
80	80	assert( Internals->GlobalDicts.IsEmpty() );
81	81	// Fill in with default values now !

101	101
102	102	bool Global::LoadResourcesFiles()
103	103	{
104		assert( Internals != NULL ); // paranoid
	104	assert( Internals != nullptr ); // paranoid
105	105	const char *filename = Locate( "Part3.xml" );
106	106	if( filename )
107	107	{

+25

-10

Source/DataDictionary/gdcmPrivateDefaultDicts.cxx less more

118	118	{0x0021,0x0049,"SIEMENS MR SDS 01",VR::CS,VM::VM1,"??",false},
119	119	{0x0021,0x0048,"SIEMENS MR SDI 02",VR::IS,VM::VM1,"??",false},
120	120	{0x0021,0x0049,"SIEMENS MR SDI 02",VR::IS,VM::VM1,"??",false},
	121	{0x0021,0x004e,"SIEMENS MR SDI 02",VR::IS,VM::VM1,"??",false},
121	122	{0x0021,0x004f,"SIEMENS MR SDI 02",VR::LO,VM::VM1,"ImaCoilString",false},
122	123	{0x0021,0x0050,"SIEMENS MR SDS 01",VR::US,VM::VM1,"??",false},
123	124	{0x0021,0x0051,"SIEMENS MR SDI 02",VR::UL,VM::VM1,"?SequenceMask?",false},

131	132	{0x0021,0x005a,"SIEMENS MR SDS 01",VR::CS,VM::VM1,"?Sequence Varient 1?",false},
132	133	{0x0021,0x005b,"SIEMENS MR SDI 02",VR::FD,VM::VM3,"Image Position (Patient)",false},
133	134	{0x0021,0x005b,"SIEMENS MR SDS 01",VR::CS,VM::VM1,"?Sequence Varient 2?",false},
	135	{0x0021,0x005c,"SIEMENS MR SDS 01",VR::CS,VM::VM1,"MTR flag. MT => ON",false},
134	136	{0x0021,0x005d,"SIEMENS MR SDS 01",VR::SL,VM::VM1,"??",false},
135	137	{0x0021,0x005e,"SIEMENS MR SDI 02",VR::IS,VM::VM1,"?FrameIndex?",false},
136	138	{0x0021,0x0063,"SIEMENS MR SDI 02",VR::IS,VM::VM1,"?Acquisition Number?",false},

1963	1965	{0x0009,0x0092,"FDMS 1.0",VR::SH,VM::VM1,"Kanji Department Name",false },
1964	1966	{0x0009,0x00f0,"FDMS 1.0",VR::CS,VM::VM1,"Blackening Process Flag",false },
1965	1967	{0x0009,0x00f1,"FDMS 1.0",VR::ST,VM::VM1,"Processing Information Flag",false },
	1968	{0x0009,0x00f2,"FDMS 1.0",VR::CS,VM::VM1,"Normalization Flag",false },
	1969	{0x0009,0x00f3,"FDMS 1.0",VR::CS,VM::VM1,"Tone characteristic",false },
	1970	{0x0009,0x00f4,"FDMS 1.0",VR::CS,VM::VM1,"Window Value Fixed Flag",false },
1966	1971	{0x0019,0x0015,"FDMS 1.0",VR::LO,VM::VM1,"Kanji Body Part for Exposure",false },
1967	1972	{0x0019,0x0030,"FDMS 1.0",VR::LO,VM::VM1,"Menu Character String",false },
1968	1973	{0x0019,0x0032,"FDMS 1.0",VR::LO,VM::VM1,"Kanji Menu Name",false },

2061	2066	{0x50f1,0x0007,"FDMS 1.0",VR::CS,VM::VM1,"Subtraction Registration Result",false },
2062	2067	{0x50f1,0x0008,"FDMS 1.0",VR::CS,VM::VM1,"Energy Subtraction Param. 2",false },
2063	2068	{0x50f1,0x0009,"FDMS 1.0",VR::SL,VM::VM1,"Afin Conversion Coefficient",false },
2064		{0x50f1,0x000a,"FDMS 1.0",VR::SH,VM::VM1,"FNC Parameters",false },
	2069	{0x50f1,0x000a,"FDMS 1.0",VR::ST,VM::VM1,"FNC Parameters",false },
	2070	{0x50f1,0x000b,"FDMS 1.0",VR::SS,VM::VM1,"CRF Parameters",false },
2065	2071	{0x50f1,0x0010,"FDMS 1.0",VR::CS,VM::VM1,"Film Output Format",false },
2066	2072	{0x50f1,0x0020,"FDMS 1.0",VR::CS,VM::VM1,"Image Processing Modification Flag",false },
2067	2073	{0x0009,0x0001,"FFP DATA",VR::UN,VM::VM1,"CR Header Information",false },

2826	2832	{0x0011,0x0016,"GEMS_GDXE_FALCON_04",VR::LT,VM::VM1,"Processing Debug Info",false },
2827	2833	{0x0011,0x0017,"GEMS_GDXE_FALCON_04",VR::CS,VM::VM1,"Override mode",false },
2828	2834	{0x0011,0x0019,"GEMS_GDXE_FALCON_04",VR::DS,VM::VM1,"Film Speed Selection",false },
2829		{0x0011,0x0027,"GEMS_GDXE_FALCON_04",VR::UN,VM::VM1,"?",false },
2830		{0x0011,0x0028,"GEMS_GDXE_FALCON_04",VR::UN,VM::VM1,"?",false },
2831		{0x0011,0x0029,"GEMS_GDXE_FALCON_04",VR::UN,VM::VM1,"?",false },
2832		{0x0011,0x0030,"GEMS_GDXE_FALCON_04",VR::UN,VM::VM1,"?",false },
	2835	{0x0011,0x0027,"GEMS_GDXE_FALCON_04",VR::FL,VM::VM1,"?",false },
	2836	{0x0011,0x0028,"GEMS_GDXE_FALCON_04",VR::FL,VM::VM1,"?",false },
	2837	{0x0011,0x0029,"GEMS_GDXE_FALCON_04",VR::SL,VM::VM1,"?",false },
	2838	{0x0011,0x0030,"GEMS_GDXE_FALCON_04",VR::SL,VM::VM1,"?",false },
2833	2839	{0x0011,0x0031,"GEMS_GDXE_FALCON_04",VR::IS,VM::VM8,"Detected Field of View",false },
2834	2840	{0x0011,0x0032,"GEMS_GDXE_FALCON_04",VR::IS,VM::VM8,"Adjusted Field of View",false },
2835	2841	{0x0011,0x0033,"GEMS_GDXE_FALCON_04",VR::DS,VM::VM1,"Detected Exposure Index",false },

5242	5248	{0x0021,0x0010,"PRIVATE ORIGINAL ATTRIBUTES",VR::LO,VM::VM1,"Replacement Originator Name",false },
5243	5249	{0x0021,0x0012,"PRIVATE ORIGINAL ATTRIBUTES",VR::LO,VM::VM1,"Replacement Reason",false },
5244	5250	{0x0021,0x0070,"PRIVATE ORIGINAL ATTRIBUTES",VR::PN,VM::VM1_n,"Original Operators'Name",false },
	5251	{0x2007,0x00b4,"Philips EV Imaging DD 017",VR::FL,VM::VM2,"?",false },
	5252	{0x2007,0x00ba,"Philips EV Imaging DD 017",VR::FD,VM::VM1,"?",false },
	5253	{0x2007,0x00bb,"Philips EV Imaging DD 017",VR::FD,VM::VM1,"?",false },
	5254	{0x2007,0x00bc,"Philips EV Imaging DD 017",VR::SL,VM::VM1,"?",false },
	5255	{0x2007,0x00d0,"Philips EV Imaging DD 017",VR::FD,VM::VM1,"?",false },
	5256	{0x2007,0x00d1,"Philips EV Imaging DD 017",VR::FD,VM::VM1,"?",false },
	5257	{0x2007,0x00d2,"Philips EV Imaging DD 017",VR::SL,VM::VM1,"?",false },
5245	5258	{0x2007,0x00c1,"Philips EV Imaging DD 017",VR::UI,VM::VM1,"? SOP Instance UID ?",false },
5246	5259	{0x2007,0x00c2,"Philips EV Imaging DD 017",VR::DA,VM::VM1,"?",false },
5247	5260	{0x2007,0x00c3,"Philips EV Imaging DD 017",VR::TM,VM::VM1,"?",false },

5249	5262	{0x2007,0x0000,"Philips EV Imaging DD 019",VR::LO,VM::VM1,"?",false },
5250	5263	{0x2007,0x0001,"Philips EV Imaging DD 019",VR::UT,VM::VM1,"?",false },
5251	5264	{0x2007,0x0004,"Philips EV Imaging DD 021",VR::SL,VM::VM1,"Vol Seg Edit Connectivity",false },
5252		//{0x2007,0x0051,"Philips EV Imaging DD 021",VR::SS,VM::VM1,"??",false },
5253		{0x2007,0x0000,"Philips EV Imaging DD 022",VR::ST,VM::VM1,"",false },
	5265	{0x2007,0x0051,"Philips EV Imaging DD 021",VR::US_SS,VM::VM1,"?US or SS?",false },
	5266	{0x2007,0x0000,"Philips EV Imaging DD 022",VR::ST,VM::VM1,"?",false },
	5267	{0x2007,0x0001,"Philips EV Imaging DD 022",VR::LO,VM::VM2,"?",false },
5254	5268	{0x2007,0x0012,"Philips EV Imaging DD 022",VR::LO,VM::VM1,"Volume Sequence Capture",false },
5255	5269	{0x2007,0x0017,"Philips EV Imaging DD 022",VR::UI,VM::VM1,"Original SOP Instance",false },
5256		{0x2007,0x0033,"Philips EV Imaging DD 022",VR::LO,VM::VM1,"",false },
5257		{0x2007,0x0034,"Philips EV Imaging DD 022",VR::CS,VM::VM1,"",false },
	5270	{0x2007,0x0033,"Philips EV Imaging DD 022",VR::LO,VM::VM1,"?",false },
	5271	{0x2007,0x0034,"Philips EV Imaging DD 022",VR::CS,VM::VM1,"?",false },
5258	5272	{0x7777,0x0001,"Philips EnVisor",VR::DA,VM::VM1,"Date 3D/PanView internal 'dataset' file was acquired",false },
5259	5273	{0x7777,0x0002,"Philips EnVisor",VR::CS,VM::VM1,"Type of 3D or PanView",false },
5260	5274	{0x7777,0x0003,"Philips EnVisor",VR::LO,VM::VM1,"Internal 3D/PanView software version number",false },

8221	8235	{0x0051,0x0011,"SIEMENS MR HEADER",VR::LO,VM::VM1,"PAT Mode (Ima PAT Mode)",false },
8222	8236	{0x0051,0x0012,"SIEMENS MR HEADER",VR::SH,VM::VM1,"?Table Position?",false },
8223	8237	{0x0051,0x0013,"SIEMENS MR HEADER",VR::SH,VM::VM1,"Positive PCS Directions",false },
	8238	{0x0051,0x0014,"SIEMENS MR HEADER",VR::SH,VM::VM1,"?v150_through?",false },
8224	8239	{0x0051,0x0015,"SIEMENS MR HEADER",VR::SH,VM::VM1,"?Data Filter?",false },
8225	8240	{0x0051,0x0016,"SIEMENS MR HEADER",VR::LO,VM::VM1,"?Image Type?",false },
8226	8241	{0x0051,0x0017,"SIEMENS MR HEADER",VR::SH,VM::VM1,"?Slice Thickness?",false },

10414	10429	{
10415	10430	// if( n.group % 2 != 0 )
10416	10431	{
10417		assert( n.owner != 0 );
	10432	assert( n.owner != nullptr );
10418	10433	assert( n.name );
10419	10434	assert( n.group % 2 != 0 \|\| n.group == 0xffff );
10420	10435	assert( n.element <= 0xff \|\| n.element == 0xffff );

-1

Source/DataDictionary/gdcmSOPClassUIDToIOD.cxx less more

126	126	// private:
127	127	{ "1.3.12.2.1107.5.9.1" , "Siemens Non-image IOD Modules"}, // CSA Non-Image Storage
128	128	{ "1.2.392.200036.9125.1.1.2" , "Fuji Private CR Image IOD Modules"}, //
	129	{ "1.2.392.200036.9125.1.1.4" , "Fuji Private Mammo CR Image IOD Modules"}, //
129	130
130	131	{ nullptr, nullptr }
131	132	};

186	187	if( i < SOPClassUIDToIOD::GetNumberOfSOPClassToIOD() )
187	188	return SOPClassUIDToIODStrings[i];
188	189	// else return the {0x0, 0x0} sentinel:
189		assert( *SOPClassUIDToIODStrings[ SOPClassUIDToIOD::GetNumberOfSOPClassToIOD() ] == 0 );
	190	assert( *SOPClassUIDToIODStrings[ SOPClassUIDToIOD::GetNumberOfSOPClassToIOD() ] == nullptr );
190	191	return SOPClassUIDToIODStrings[ SOPClassUIDToIOD::GetNumberOfSOPClassToIOD() ];
191	192
192	193	}

-2

Source/DataDictionary/gdcmUIDs.cxx less more

489	489	{"1.2.840.113619.5.2","Implicit VR Big Endian DLX (G.E Private)"},
490	490	// DICOM_Conformance_Statement_GEMINI_R3.5_R3.6.pdf
491	491	{"1.3.46.670589.33.1.4.1","CT-private-ELE"},
	492	{"1.2.392.200036.9125.1.1.4","Fuji Private Mammo CR Image Storage"},
492	493	//
493	494	//
494	495	//

509	510	{
510	511	if( ts > 0 && ts <= UIDs::GetNumberOfTransferSyntaxStrings() ) return TransferSyntaxStrings[ts];
511	512	// else return the {0x0, 0x0} sentinel (begin or end)
512		assert( *TransferSyntaxStrings[ UIDs::GetNumberOfTransferSyntaxStrings() + 1 ] == 0 );
513		assert( *TransferSyntaxStrings[ 0 ] == 0 );
	513	assert( *TransferSyntaxStrings[ UIDs::GetNumberOfTransferSyntaxStrings() + 1 ] == nullptr );
	514	assert( *TransferSyntaxStrings[ 0 ] == nullptr );
514	515	return TransferSyntaxStrings[ UIDs::GetNumberOfTransferSyntaxStrings() + 1 ];
515	516	}
516	517

-1

Source/DataStructureAndEncodingDefinition/gdcmAttribute.h less more

627	627	}
628	628	Own = own;
629	629	Length = numel;
630		assert( Internal == 0 );
	630	assert( Internal == nullptr );
631	631	if( own ) // make a copy:
632	632	{
633	633	Internal = new ArrayType[numel];

-1

Source/DataStructureAndEncodingDefinition/gdcmBasicOffsetTable.h less more

69	69	bv->SetLength(ValueLengthField);
70	70	if( !bv->Read<TSwap>(is) )
71	71	{
72		assert(0 && "Should not happen");
	72	gdcmAssertAlwaysMacro(0 && "Should not happen");
73	73	return is;
74	74	}
75	75	ValueField = bv;

-0

Source/DataStructureAndEncodingDefinition/gdcmDataSet.txx less more

420	420	}
421	421	else if( /pe.GetLastElement().GetTag() == Tag(0xffd8,0xffe0) &&/ de.GetTag() == Tag(0x7fe0,0x0010) && de.IsUndefinedLength() )
422	422	{
	423	// Bug_Siemens_PrivateIconNoItem.dcm
423	424	// PET-GE-dicomwrite-PixelDataSQUN.dcm
	425	// PET-GE-dicomwrite-PixelDataSQUNv2.dcm
424	426	// some bozo crafted an undefined length Pixel Data but is actually
425	427	// defined length. Since inside SQ/Item it should be possible to
426	428	// compute the proper length

-3

Source/DataStructureAndEncodingDefinition/gdcmElement.h less more

623	623	else {
624	624	// TODO rewrite this stupid code:
625	625	assert( Length == 0 );
626		assert( Internal == 0 );
	626	assert( Internal == nullptr );
627	627	assert( Save == false );
628	628	Length = len / sizeof(Type);
629	629	//assert( (len / sizeof(Type)) * sizeof(Type) == len );

657	657	const Type* array = (const Type*)bv->GetVoidPointer();
658	658	if( array ) {
659	659	assert( array ); // That would be bad...
660		assert( Internal == 0 );
	660	assert( Internal == nullptr );
661	661	SetArray(array, bv->GetLength() ); }
662	662	}
663	663	else

762	762	const Type* array = (const Type*)bv->GetPointer();
763	763	if( array ) {
764	764	assert( array ); // That would be bad...
765		assert( Internal == 0 );
	765	assert( Internal == nullptr );
766	766	SetArray(array, bv->GetLength() ); }
767	767	}
768	768	else

-1

Source/DataStructureAndEncodingDefinition/gdcmExplicitDataElement.txx less more

384	384	if( TagField == itemDelItem )
385	385	{
386	386	assert(0);
387		assert( ValueField == 0 );
	387	assert( ValueField == nullptr );
388	388	#ifdef GDCM_SUPPORT_BROKEN_IMPLEMENTATION
389	389	if( ValueLengthField != 0 )
390	390	{

-0

Source/DataStructureAndEncodingDefinition/gdcmImplicitDataElement.txx less more

537	537	return os;
538	538	}
539	539	// Write Value Length
	540	// The following code should always work since we are in the case of IVRLE - CP246
	541	// however broken file such as PET-GE-dicomwrite-PixelDataSQUNv2.dcm breaks this assumption right here:
	542	// see bug #502
540	543	const SequenceOfItems sqi = dynamic_cast<const SequenceOfItems>( ValueField.GetPointer() ); //GetSequenceOfItems();
541	544	if( sqi && !ValueLengthField.IsUndefined() )
542	545	{

+14

-6

Source/DataStructureAndEncodingDefinition/gdcmMediaStorage.cxx less more

144	144	"1.2.840.10008.5.1.4.1.1.128.1", // Legacy Converted Enhanced PET Image Storage
145	145	"1.2.840.10008.5.1.4.1.1.13.1.4", // Breast Projection X-Ray Image Storage - For Presentation
146	146	"1.2.840.10008.5.1.4.1.1.13.1.5", // Breast Projection X-Ray Image Storage - For Processing
	147	"1.2.840.10008.5.1.1.30", // HardcopyColorImageStorage
	148	"1.2.840.10008.5.1.4.1.1.4.3", // EnhancedMRColorImageStorage
	149	"1.2.392.200036.9125.1.1.4", // FujiPrivateMammoCRImageStorage (aka FUJI MAMMO CR Storage)
	150	"1.2.840.10008.5.1.4.1.1.77.1.5.2", // Ophthalmic Photography 16 Bit Image Storage
147	151
148	152	nullptr
149	153	};

319	323	{"ES", 2, false},// VLEndoscopicImageStorage
320	324	{"MG", 3, false},// BreastTomosynthesisImageStorage
321	325	{"CR", 2, false},// FujiPrivateCRImageStorage
322		{"OP", 2, false},// OphthalmicPhotography8BitImageStorage
	326	{"OP", 3, false},// OphthalmicPhotography8BitImageStorage
323	327	{"OPT", 3, false},// OphthalmicTomographyImageStorage
324	328	{"GM", 3, false},// VLMicroscopicImageStorage
325	329	{"PT", 3, false},//EnhancedPETImageStorage,

327	331	{"DX", 3, false},// XRay3DCraniofacialImageStorage
328	332	{"IVOCT", 3, false},// IVOCTForPresentation,
329	333	{"IVOCT", 3, false},// IVCOTForProcessing,
330		{"CT", 3, false},//LegacyConvertedEnhancedCTImageStorage,
331		{"MR", 3, false},//LegacyConvertedEnhancedMRImageStorage,
332		{"PT", 3, false},//LegacyConvertedEnhancedPETImageStorage,
333		{"MG", 3, false},//BreastProjectionXRayImageStorageForPresentation
334		{"MG", 3, false},//BreastProjectionXRayImageStorageForProcessing
	334	{"CT", 3, false},// LegacyConvertedEnhancedCTImageStorage,
	335	{"MR", 3, false},// LegacyConvertedEnhancedMRImageStorage,
	336	{"PT", 3, false},// LegacyConvertedEnhancedPETImageStorage,
	337	{"MG", 3, false},// BreastProjectionXRayImageStorageForPresentation
	338	{"MG", 3, false},// BreastProjectionXRayImageStorageForProcessing
	339	{"HC", 2, false},// HardcopyGrayscaleImageStorage
	340	{"MR", 3, false},// EnhancedMRColorImageStorage
	341	{"MG", 2, false},// FujiPrivateMammoCRImageStorage
	342	{"OP", 3, false},// OphthalmicPhotography16BitImageStorage
335	343	{nullptr, 0, false} //MS_END
336	344	};
337	345

-0

Source/DataStructureAndEncodingDefinition/gdcmMediaStorage.h less more

137	137	LegacyConvertedEnhancedPETImageStorage,
138	138	BreastProjectionXRayImageStorageForPresentation,
139	139	BreastProjectionXRayImageStorageForProcessing,
	140	HardcopyColorImageStorage,
	141	EnhancedMRColorImageStorage,
	142	FujiPrivateMammoCRImageStorage,
	143	OphthalmicPhotography16BitImageStorage,
140	144	MS_END
141	145	} MSType; // Media Storage Type
142	146

-66

Source/DataStructureAndEncodingDefinition/gdcmReader.cxx less more

826	826	return false;
827	827	}
828	828
829		#ifdef _MSC_VER
830		namespace {
831		static inline std::wstring ToUtf16(std::string const & str) {
832		std::wstring ret;
833		int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), nullptr, 0);
834		if (len > 0) {
835		ret.resize(len);
836		MultiByteToWideChar(CP_UTF8, 0, str.c_str(), (int)str.length(), &ret[0], len);
837		}
838		return ret;
839		}
840		// http://arsenmk.blogspot.com/2015/12/handling-long-paths-on-windows.html
841		static inline bool ComputeFullPath(std::wstring const &in, std::wstring &out) {
842		// consider an input fileName of type PCWSTR (const wchar_t*)
843		const wchar_t *fileName = in.c_str();
844		DWORD requiredBufferLength = GetFullPathNameW(fileName, 0, nullptr, nullptr);
845
846		if (0 == requiredBufferLength) // means failure
847		{
848		return false;
849		}
850
851		out.resize(requiredBufferLength);
852		wchar_t *buffer = &out[0];
853
854		DWORD result =
855		GetFullPathNameW(fileName, requiredBufferLength, buffer, nullptr);
856
857		if (0 == result) {
858		return false;
859		}
860
861		// buffer now contains the full path name of fileName, use it.
862		return true;
863		}
864
865		static inline std::wstring HandleMaxPath(std::wstring const &in) {
866		if (in.size() >= MAX_PATH) {
867		std::wstring out;
868		bool ret = ComputeFullPath(in, out);
869		if (!ret) return in;
870		if (out.size() < 4) return in;
871		if (out[0] == '\\' && out[1] == '\\' && out[2] == '?') {
872		// nothing to do
873		} else if (out[0] == '\\' && out[1] == '\\' && out[2] != '?') {
874		// server path
875		const std::wstring prefix = LR"(\\?\UNC\)";
876		out = prefix + (out.c_str() + 2);
877		} else {
878		// regular C:\ style path:
879		assert(out[1] == ':');
880		const std::wstring prefix = LR"(\\?\)";
881		out = prefix + out.c_str();
882		}
883		return out;
884		}
885		return in;
886		}
887		} // namespace
888		#endif
889
890		void Reader::SetFileName(const char *uft8path)
	829	void Reader::SetFileName(const char *utf8path)
891	830	{
892	831	if(Ifstream) delete Ifstream;
893	832	Ifstream = new std::ifstream();
894		if (uft8path && *uft8path) {
	833	if (utf8path && *utf8path) {
895	834	#ifdef _MSC_VER
896		const std::wstring uft16path = ToUtf16(uft8path);
897		const std::wstring uncpath = HandleMaxPath(uft16path);
	835	const std::wstring uncpath = System::ConvertToUNC(utf8path);
898	836	Ifstream->open(uncpath.c_str(), std::ios::binary);
899	837	#else
900		Ifstream->open( uft8path, std::ios::binary);
	838	Ifstream->open( utf8path, std::ios::binary);
901	839	#endif
902	840	}
903	841	if( Ifstream->is_open() )

-1

Source/DataStructureAndEncodingDefinition/gdcmVR.cxx less more

368	368	assert( r == (VR::VRType)(1 << (p-start)) );
369	369	#else // old version not optimized
370	370	VRType r = VR::VR_END;
371		for (int i = 1; VRStrings[i] != NULL; i++)
	371	for (int i = 1; VRStrings[i] != nullptr; i++)
372	372	{
373	373	const char *ref = VRStrings[i];
374	374	// Use lazy evaluation instead of strncmp

+12

-4

Source/DataStructureAndEncodingDefinition/gdcmWriter.cxx less more

161	161	return !os.fail();
162	162	}
163	163
164		void Writer::SetFileName(const char *filename)
	164	void Writer::SetFileName(const char *utf8path)
165	165	{
166	166	//std::cerr << "Stream: " << filename << std::endl;
167	167	//std::cerr << "Ofstream: " << Ofstream << std::endl;

174	174	delete Ofstream;
175	175	}
176	176	Ofstream = new std::ofstream();
177		Ofstream->open(filename, std::ios::out \| std::ios::binary );
178		assert( Ofstream->is_open() );
179		assert( !Ofstream->fail() );
	177	if (utf8path && *utf8path)
	178	{
	179	#ifdef _MSC_VER
	180	const std::wstring uncpath = System::ConvertToUNC(utf8path);
	181	Ofstream->open(uncpath.c_str(), std::ios::out \| std::ios::binary);
	182	#else
	183	Ofstream->open(utf8path, std::ios::out \| std::ios::binary);
	184	#endif
	185	assert(Ofstream->is_open());
	186	assert(!Ofstream->fail());
	187	}
180	188	//std::cerr << Stream.is_open() << std::endl;
181	189	Stream = Ofstream;
182	190	}

+37

-0

Source/InformationObjectDefinition/Part3.xml less more

2134	2134	<entry ie="Image" name="VOI LUT" ref="C.11.2" usage="U"/>
2135	2135	<entry ie="Image" name="SOP Common" ref="C.12.1" usage="M"/>
2136	2136	</iod>
	2137	<iod table="FUJI.2" name="Fuji Private Mammo CR Image IOD Modules">
	2138	<entry ie="Patient" name="Patient" ref="C.7.1.1" usage="M"/>
	2139	<entry ie="Patient" name="Specimen Identification" ref="C.7.1.2" usage="U"/>
	2140	<entry ie="Patient" name="Clinical Trial Subject" ref="C.7.1.3" usage="U"/>
	2141	<entry ie="Study" name="General Study" ref="C.7.2.1" usage="M"/>
	2142	<entry ie="Study" name="Patient Study" ref="C.7.2.2" usage="U"/>
	2143	<entry ie="Study" name="Clinical Trial Study" ref="C.7.2.3" usage="U"/>
	2144	<entry ie="Series" name="General Series" ref="C.7.3.1" usage="M"/>
	2145	<entry ie="Series" name="Clinical Trial Series" ref="C.7.3.2" usage="U"/>
	2146	<entry ie="Series" name="DX Series" ref="C.8.11.1" usage="M"/>
	2147	<entry ie="Series" name="Mammography Series" ref="C.8.11.6" usage="M"/>
	2148	<entry ie="Frame of Reference" name="Frame of Reference" ref="C.7.4.1" usage="C - Required if multiple images are obtained without releasing breast compression"/>
	2149	<entry ie="Equipment" name="General Equipment" ref="C.7.5.1" usage="M"/>
	2150	<entry ie="Image" name="General Image" ref="C.7.6.1" usage="M"/>
	2151	<entry ie="Image" name="Image Pixel" ref="C.7.6.3" usage="M"/>
	2152	<entry ie="Image" name="Contrast/Bolus" ref="C.7.6.4" usage="U"/>
	2153	<entry ie="Image" name="Display Shutter" ref="C.7.6.11" usage="U"/>
	2154	<entry ie="Image" name="Device" ref="C.7.6.12" usage="U"/>
	2155	<entry ie="Image" name="Intervention" ref="C.7.6.13" usage="U"/>
	2156	<entry ie="Image" name="DX Anatomy Imaged" ref="C.8.11.2" usage="M"/>
	2157	<entry ie="Image" name="DX Image" ref="C.8.11.3" usage="M"/>
	2158	<entry ie="Image" name="DX Detector" ref="C.8.11.4" usage="M"/>
	2159	<entry ie="Image" name="X-Ray Collimator" ref="C.8.7.3" usage="U"/>
	2160	<entry ie="Image" name="DX Positioning" ref="C.8.11.5" usage="U"/>
	2161	<entry ie="Image" name="X-Ray Tomo Acquisition" ref="C.8.7.7" usage="U"/>
	2162	<entry ie="Image" name="X-Ray Acquisition Dose" ref="C.8.7.8" usage="U"/>
	2163	<entry ie="Image" name="X-Ray Generation" ref="C.8.7.9" usage="U"/>
	2164	<entry ie="Image" name="X-Ray Filtration" ref="C.8.7.10" usage="U"/>
	2165	<entry ie="Image" name="X-Ray Grid" ref="C.8.7.11" usage="U"/>
	2166	<entry ie="Image" name="Mammography Image" ref="C.8.11.7" usage="M"/>
	2167	<entry ie="Image" name="Overlay Plane" ref="C.9.2" usage="C - Required if graphic annotation is present - See A.27.3"/>
	2168	<entry ie="Image" name="VOI LUT" ref="C.11.2" usage="C - Required if Presentation Intent Type (0008,0068) is FOR PRESENTATION. Shall not be present otherwise."/>
	2169	<entry ie="Image" name="Image Histogram" ref="C.11.5" usage="U"/>
	2170	<entry ie="Image" name="Acquisition Context" ref="C.7.6.14" usage="M"/>
	2171	<entry ie="Image" name="SOP Common" ref="C.12.1" usage="M"/>
	2172	</iod>
	2173
2137	2174	<module ref="C.2.1" table="C.2-1" name="Patient Relationship Module Attributes">
2138	2175	<entry group="0008" element="1110" name="Referenced Study Sequence">
2139	2176	<description>Uniquely identifies the Study SOP Instances associated with the Patient SOP Instance. One or more Items may be included in this Sequence.</description>

-0

Source/InformationObjectDefinition/gdcmDefs.cxx less more

54	54	tr.Read();
55	55	}
56	56
	57	// http://dicom.nema.org/medical/dicom/current/output/chtml/part04/sect_B.5.html#table_B.5-1
57	58	const char *Defs::GetIODNameFromMediaStorage(MediaStorage const &ms)
58	59	{
59	60	const char *iodname;

231	232	case MediaStorage::FujiPrivateCRImageStorage:
232	233	iodname = "Fuji Private CR Image IOD Modules";
233	234	break;
	235	case MediaStorage::FujiPrivateMammoCRImageStorage:
	236	iodname = "Fuji Private Mammo CR Image IOD Modules";
	237	break;
234	238	case MediaStorage::CSANonImageStorage:
235	239	iodname = "Siemens Non-image IOD Modules";
236	240	break;
237	241	case MediaStorage::VLMicroscopicImageStorage:
238	242	iodname = "VL Microscopic Image IOD Modules";
	243	break;
	244	case MediaStorage::XRay3DCraniofacialImageStorage:
	245	iodname = "X Ray 3D Craniofacial Image IOD Modules";
239	246	break;
240	247	default:
241	248	iodname = nullptr;

-2

Source/InformationObjectDefinition/gdcmTableReader.cxx less more

71	71	(void)atts;
72	72	assert( ParsingMacroEntryDescription == false );
73	73	ParsingMacroEntryDescription = true;
74		assert( *atts == NULL );
	74	assert( *atts == nullptr );
75	75	assert( Description == "" );
76	76	}
77	77

90	90	(void)atts;
91	91	assert( ParsingModuleEntryDescription == false );
92	92	ParsingModuleEntryDescription = true;
93		assert( *atts == NULL );
	93	assert( *atts == nullptr );
94	94	assert( Description == "" );
95	95	}
96	96

-1

Source/MediaStorageAndFileFormat/gdcmAnonymizer.cxx less more

505	505	\|\| ds.FindDataElement( Tag(0x0012,0x0062) )
506	506	\|\| ds.FindDataElement( Tag(0x0012,0x0063) ) )
507	507	{
508		gdcmDebugMacro( "EncryptedContentTransferSyntax Attribute is present !" );
	508	gdcmErrorMacro( "EncryptedContentTransferSyntax Attribute is present !" );
509	509	return false;
510	510	}
511	511	#if 0

+46

-0

Source/MediaStorageAndFileFormat/gdcmBitmap.cxx less more

430	430	{
431	431	Bitmap i = const_cast<Bitmap>(this);
432	432	gdcmWarningMacro( "Encapsulated stream has fewer bits actually stored on disk. correcting." );
	433	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
	434	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
	435	}
	436	else if( cpf.GetBitsStored() < pf.GetBitsStored() )
	437	{
	438	Bitmap i = const_cast<Bitmap>(this);
	439	gdcmWarningMacro( "Encapsulated stream has more bits actually stored on disk. correcting." );
433	440	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
434	441	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
435	442	}

731	738	{
732	739	gdcmErrorMacro( "EVIL file, it is declared as lossless but is in fact lossy." );
733	740	}
	741	const PixelFormat & cpf = codec.GetPixelFormat();
	742	const PixelFormat & pf = GetPixelFormat();
	743	if( cpf.GetBitsAllocated() == pf.GetBitsAllocated() )
	744	{
	745	if( cpf.GetPixelRepresentation() == pf.GetPixelRepresentation() )
	746	{
	747	if( cpf.GetSamplesPerPixel() == pf.GetSamplesPerPixel() )
	748	{
	749	if( cpf.GetBitsStored() < pf.GetBitsStored() )
	750	{
	751	Bitmap i = const_cast<Bitmap>(this);
	752	gdcmWarningMacro( "Encapsulated stream has fewer bits actually stored on disk. correcting." );
	753	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
	754	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
	755	}
	756	else if( cpf.GetBitsStored() > pf.GetBitsStored() )
	757	{
	758	Bitmap i = const_cast<Bitmap>(this);
	759	gdcmWarningMacro( "Encapsulated stream has more bits actually stored on disk. correcting." );
	760	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
	761	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
	762	}
	763	}
	764	}
	765	}
	766	else
	767	{
	768	gdcmWarningMacro( "Bits Allocated are different. This is pretty bad using info from codestream" );
	769	Bitmap i = const_cast<Bitmap>(this);
	770	i->SetPixelFormat( codec.GetPixelFormat() );
	771	}
734	772
735	773	return r;
736	774	}

802	840	{
803	841	Bitmap i = const_cast<Bitmap>(this);
804	842	gdcmWarningMacro( "Encapsulated stream has fewer bits actually stored on disk. correcting." );
	843	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
	844	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
	845	}
	846	else if( cpf.GetBitsStored() > pf.GetBitsStored() )
	847	{
	848	Bitmap i = const_cast<Bitmap>(this);
	849	gdcmWarningMacro( "Encapsulated stream has more bits actually stored on disk. correcting." );
	850	i->GetPixelFormat().SetBitsAllocated( cpf.GetBitsAllocated() );
805	851	i->GetPixelFormat().SetBitsStored( cpf.GetBitsStored() );
806	852	}
807	853	}

-1

Source/MediaStorageAndFileFormat/gdcmDataSetHelper.cxx less more

103	103	const VR &devr = de.GetVR();
104	104	if( devr != VR::INVALID && devr != VR::UN )
105	105	{
106		gdcmWarningMacro("Please report. Missing dict entry for: " << de );
	106	gdcmWarningMacro("Please report. Missing dict entry for: [" << owner << "]" << " de is: " << de );
107	107	return devr;
108	108	}
109	109	// CP-246

-2

Source/MediaStorageAndFileFormat/gdcmFileExplicitFilter.cxx less more

94	94	//assert( de.GetVR() == VR::INVALID );
95	95	VR cvr = DataSetHelper::ComputeVR(*F,ds, t);
96	96	VR oldvr = de.GetVR();
	97	if( cvr == VR::SQ ) { assert( oldvr == VR::SQ \|\| oldvr == VR::UN \|\| oldvr == VR::INVALID ); }
97	98	//SequenceOfItems *sqi = de.GetSequenceOfItems();
98	99	//SequenceOfItems sqi = dynamic_cast<SequenceOfItems>(&de.GetValue());
99	100	SmartPointer<SequenceOfItems> sqi = nullptr;
100		if( vr == VR::SQ )
	101	if( vr == VR::SQ
	102	\|\| cvr == VR::SQ ) // CP-246 + Private SQ (not in dict)
101	103	{
102	104	sqi = de.GetValueAsSQ();
103	105	if(!sqi)
104	106	{
105	107	if( !de.IsEmpty() )
106	108	{
107		gdcmErrorMacro("DICOM file written out may not be readable" );
	109	gdcmWarningMacro("DICOM file written out may not be readable" );
108	110	cvr = VR::UN;
109	111	}
110	112	}

-3

Source/MediaStorageAndFileFormat/gdcmFileStreamer.cxx less more

308	308	{
309	309	// if you trigger this assertion, this means we have been allocating
310	310	// memory for an element when not needed.
311		assert( (de.GetByteValue() && de.GetByteValue()->GetPointer() == 0) \|\| de.GetSequenceOfFragments() );
	311	assert( (de.GetByteValue() && de.GetByteValue()->GetPointer() == nullptr) \|\| de.GetSequenceOfFragments() );
312	312	}
313	313	actualde = de.GetVL() + 2 * de.GetVR().GetLength() + 4;
314	314	thepos -= actualde;

318	318	// no attribute found, easy case !
319	319	}
320	320	}
321		assert( pFile == NULL );
	321	assert( pFile == nullptr );
322	322	pFile = fopen(outfilename, "r+b");
323	323	assert( pFile );
324	324	CurrentDataLenth = 0;

585	585	}
586	586
587	587	const size_t pclen = dicomdata.size();
588		assert( pFile == NULL );
	588	assert( pFile == nullptr );
589	589	pFile = fopen(outfilename, "r+b");
590	590	assert( pFile );
591	591

-1

Source/MediaStorageAndFileFormat/gdcmIPPSorter.cxx less more

172	172	return false;
173	173	}
174	174
175		// http://www.itk.org/pipermail/insight-users/2003-September/004762.html
	175	// https://www.itk.org/pipermail/insight-users/2003-September/004762.html
176	176	// Compute normal:
177	177	// The steps I take when reconstructing a volume are these: First,
178	178	// calculate the slice normal from IOP:

-1

Source/MediaStorageAndFileFormat/gdcmImageChangeTransferSyntax.cxx less more

442	442	{
443	443	Bitmap &outbitmap = *Output;
444	444	Pixmap outpixmap = dynamic_cast<Pixmap>( &outbitmap );
445		assert( outpixmap != NULL );
	445	assert( outpixmap != nullptr );
446	446	if( !pixmap->GetIconImage().IsEmpty() )
447	447	{
448	448	// same goes for icon

+30

-6

Source/MediaStorageAndFileFormat/gdcmImageHelper.cxx less more

281	281	}
282	282	}
283	283	} else {
284		// single slice
	284	// single slice, this is not an error to not find the zspacing in this case.
	285	zspacing = 1.0;
285	286	const Tag tfgs0(0x5200,0x9229);
286		if( !ds.FindDataElement( tfgs0 ) ) return false;
	287	if( !ds.FindDataElement( tfgs0 ) ) return true;
287	288	SmartPointer<SequenceOfItems> sqi0 = ds.GetDataElement( tfgs0 ).GetValueAsSQ();
288		if( !(sqi0 && sqi0->GetNumberOfItems() > 0) ) return false;
	289	if( !(sqi0 && sqi0->GetNumberOfItems() > 0) ) return true;
289	290	// Get first item:
290	291	const Item &item = sqi0->GetItem(1);
291	292	const DataSet & subds = item.GetNestedDataSet();
292	293	// <entry group="0028" element="9110" vr="SQ" vm="1" name="Pixel Measures Sequence"/>
293	294	const Tag tpms(0x0028,0x9110);
294		if( !subds.FindDataElement(tpms) ) return false;
	295	if( !subds.FindDataElement(tpms) ) return true;
295	296	//const SequenceOfItems * sqi2 = subds.GetDataElement( tpms ).GetSequenceOfItems();
296	297	SmartPointer<SequenceOfItems> sqi2 = subds.GetDataElement( tpms ).GetValueAsSQ();
297	298	assert( sqi2 );

299	300	const DataSet & subds2 = item2.GetNestedDataSet();
300	301	// <entry group="0028" element="0030" vr="DS" vm="2" name="Pixel Spacing"/>
301	302	const Tag tps(0x0018,0x0088);
302		if( !subds2.FindDataElement(tps) ) return false;
	303	if( !subds2.FindDataElement(tps) ) return true;
303	304	const DataElement &de = subds2.GetDataElement( tps );
304	305	Attribute<0x0018,0x0088> at;
305	306	at.SetFromDataElement( de );

447	448
448	449	if( ms == MediaStorage::EnhancedCTImageStorage
449	450	\|\| ms == MediaStorage::EnhancedMRImageStorage
	451	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
450	452	\|\| ms == MediaStorage::EnhancedPETImageStorage
451	453	\|\| ms == MediaStorage::OphthalmicTomographyImageStorage
452	454	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage

580	582
581	583	if( ms == MediaStorage::EnhancedCTImageStorage
582	584	\|\| ms == MediaStorage::EnhancedMRImageStorage
	585	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
583	586	\|\| ms == MediaStorage::EnhancedPETImageStorage
584	587	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage
585	588	\|\| ms == MediaStorage::MultiframeGrayscaleByteSecondaryCaptureImageStorage

915	918	// cleanup pass:
916	919	if( ms == MediaStorage::EnhancedCTImageStorage
917	920	\|\| ms == MediaStorage::EnhancedMRImageStorage
	921	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
918	922	\|\| ms == MediaStorage::EnhancedPETImageStorage
919	923	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage
920	924	\|\| ms == MediaStorage::MultiframeGrayscaleByteSecondaryCaptureImageStorage

953	957
954	958	if( ms == MediaStorage::EnhancedCTImageStorage
955	959	\|\| ms == MediaStorage::EnhancedMRImageStorage
	960	/\|\| ms == MediaStorage::EnhancedMRColorImageStorage/
956	961	\|\| ms == MediaStorage::EnhancedPETImageStorage
957	962	\|\| ms == MediaStorage::XRay3DAngiographicImageStorage
958	963	\|\| ms == MediaStorage::XRay3DCraniofacialImageStorage

1166	1171	case MediaStorage::XRayAngiographicImageStorage:
1167	1172	case MediaStorage::XRayRadiofluoroscopingImageStorage:
1168	1173	case MediaStorage::XRayAngiographicBiPlaneImageStorageRetired:
	1174	case MediaStorage::FujiPrivateMammoCRImageStorage:
1169	1175	// (0018,1164) DS [0.5\0.5] # 8, 2 ImagerPixelSpacing
1170	1176	t = Tag(0x0018,0x1164);
1171	1177	break;

1182	1188	t = Tag(0x0018,0x2010);
1183	1189	break;
1184	1190	case MediaStorage::HardcopyGrayscaleImageStorage:
1185		t = Tag(0xffff,0xffff);
	1191	case MediaStorage::HardcopyColorImageStorage:
	1192	t = Tag(0x0018,0x2010); // Nominal Scanned Pixel Spacing
1186	1193	break;
1187	1194	case MediaStorage::GEPrivate3DModelStorage: // FIXME FIXME !!!
1188	1195	case MediaStorage::Philips3D:

1300	1307
1301	1308	if( ms == MediaStorage::EnhancedCTImageStorage
1302	1309	\|\| ms == MediaStorage::EnhancedMRImageStorage
	1310	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
1303	1311	\|\| ms == MediaStorage::EnhancedPETImageStorage
1304	1312	\|\| ms == MediaStorage::OphthalmicTomographyImageStorage
1305	1313	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage

1605	1613
1606	1614	if( ms == MediaStorage::EnhancedCTImageStorage
1607	1615	\|\| ms == MediaStorage::EnhancedMRImageStorage
	1616	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
1608	1617	\|\| ms == MediaStorage::EnhancedPETImageStorage
1609	1618	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage
1610	1619	\|\| ms == MediaStorage::MultiframeGrayscaleByteSecondaryCaptureImageStorage

1888	1897	&& ms != MediaStorage::XRay3DAngiographicImageStorage
1889	1898	&& ms != MediaStorage::XRay3DCraniofacialImageStorage
1890	1899	&& ms != MediaStorage::EnhancedMRImageStorage
	1900	&& ms != MediaStorage::EnhancedMRColorImageStorage
1891	1901	&& ms != MediaStorage::EnhancedPETImageStorage
1892	1902	&& ms != MediaStorage::EnhancedCTImageStorage
1893	1903	&& ms != MediaStorage::IVOCTForPresentation

1905	1915
1906	1916	if( ms == MediaStorage::EnhancedCTImageStorage
1907	1917	\|\| ms == MediaStorage::EnhancedMRImageStorage
	1918	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
1908	1919	\|\| ms == MediaStorage::EnhancedPETImageStorage
1909	1920	\|\| ms == MediaStorage::XRay3DAngiographicImageStorage
1910	1921	\|\| ms == MediaStorage::XRay3DCraniofacialImageStorage

2036	2047	&& ms != MediaStorage::XRay3DAngiographicImageStorage
2037	2048	&& ms != MediaStorage::XRay3DCraniofacialImageStorage
2038	2049	&& ms != MediaStorage::EnhancedMRImageStorage
	2050	&& ms != MediaStorage::EnhancedMRColorImageStorage
2039	2051	&& ms != MediaStorage::EnhancedPETImageStorage
2040	2052	&& ms != MediaStorage::EnhancedCTImageStorage
2041	2053	&& ms != MediaStorage::IVOCTForPresentation

2072	2084
2073	2085	if( ms == MediaStorage::EnhancedCTImageStorage
2074	2086	\|\| ms == MediaStorage::EnhancedMRImageStorage
	2087	\|\| ms == MediaStorage::EnhancedMRColorImageStorage
2075	2088	\|\| ms == MediaStorage::EnhancedPETImageStorage
2076	2089	\|\| ms == MediaStorage::MultiframeSingleBitSecondaryCaptureImageStorage
2077	2090	\|\| ms == MediaStorage::MultiframeGrayscaleByteSecondaryCaptureImageStorage

2171	2184	&& ms != MediaStorage::MultiframeGrayscaleWordSecondaryCaptureImageStorage
2172	2185	&& ms != MediaStorage::MultiframeTrueColorSecondaryCaptureImageStorage
2173	2186	&& ms != MediaStorage::EnhancedMRImageStorage
	2187	/&& ms != MediaStorage::EnhancedMRColorImageStorage/
2174	2188	&& ms != MediaStorage::EnhancedCTImageStorage
2175	2189	&& ms != MediaStorage::EnhancedPETImageStorage
2176	2190	&& ms != MediaStorage::XRay3DAngiographicImageStorage

2195	2209	if( ms == MediaStorage::SegmentationStorage ) return; // seg storage cannot have rescale slope
2196	2210	if( ms == MediaStorage::EnhancedCTImageStorage
2197	2211	\|\| ms == MediaStorage::EnhancedMRImageStorage
	2212	/\|\| ms == MediaStorage::EnhancedMRColorImageStorage/
2198	2213	\|\| ms == MediaStorage::EnhancedPETImageStorage
2199	2214	\|\| ms == MediaStorage::XRay3DAngiographicImageStorage
2200	2215	\|\| ms == MediaStorage::XRay3DCraniofacialImageStorage

2836	2851	}
2837	2852	}
2838	2853	}
	2854	// check 'DX' / dim == 2:
	2855	if( ms == MediaStorage::DigitalXRayImageStorageForPresentation )
	2856	{
	2857	if( intercept != 0.0 \|\| slope != 1.0 )
	2858	{
	2859	// hopefully this is not a lame choice:
	2860	ms = MediaStorage::XRay3DCraniofacialImageStorage;
	2861	}
	2862	}
2839	2863	return ms;
2840	2864	}
2841	2865

-0

Source/MediaStorageAndFileFormat/gdcmImageWriter.h less more

22	22	class Image;
23	23	/**
24	24	* \brief ImageWriter
	25	*
	26	* This is an extended version of the PixmapWriter. Pay attention that:
	27	* 1. It will populate missing attribute for Secondary Capture Image Storage instances,
	28	* 2. It may also change an input MR Image Storage instance into a pseudo Enhanced MR Image Storage instance whenever Modality LUT is required.
	29	* 3. Some DataElement related to gdcm::Image may be slightly altered.
25	30	*/
26	31	class GDCM_EXPORT ImageWriter : public PixmapWriter
27	32	{

-1

Source/MediaStorageAndFileFormat/gdcmJPEGCodec.cxx less more

100	100	{
101	101	BitSample = bit;
102	102	delete Internal; Internal = nullptr;
103		assert( Internal == NULL );
	103	assert( Internal == nullptr );
104	104	// what should I do with those single bit images ?
105	105	if ( BitSample <= 8 )
106	106	{

-1

Source/MediaStorageAndFileFormat/gdcmOverlay.cxx less more

259	259	if( Internal->BitsAllocated == 16 )
260	260	{
261	261	//assert( Internal->BitPosition >= 12 );
262		if( ds.FindDataElement( Tag(0x7fe0,0x0010) ) )
	262	if( !ds.FindDataElement( Tag(0x7fe0,0x0010) ) )
263	263	{
264	264	gdcmWarningMacro("Could not find Pixel Data. Cannot extract Overlay." );
265	265	return false;

-1

Source/MediaStorageAndFileFormat/gdcmPixelFormat.h less more

66	66	} ScalarType;
67	67
68	68	// default cstor:
	69	PixelFormat () : PixelFormat(1, 8, 8, 7, 0) {}
	70
69	71	explicit PixelFormat (
70		unsigned short samplesperpixel = 1,
	72	unsigned short samplesperpixel,
71	73	unsigned short bitsallocated = 8,
72	74	unsigned short bitsstored = 8,
73	75	unsigned short highbit = 7,

-1

Source/MediaStorageAndFileFormat/gdcmPixmapReader.cxx less more

615	615	isacrnema = true;
616	616	const char *str = ds.GetDataElement( trecognitioncode ).GetByteValue()->GetPointer();
617	617	assert( strncmp( str, "ACR-NEMA", strlen( "ACR-NEMA" ) ) == 0 \|\|
618		strncmp( str, "ACRNEMA", strlen( "ACRNEMA" ) ) == 0 );
	618	strncmp( str, "ACRNEMA", strlen( "ACRNEMA" ) ) == 0 \|\|
	619	strncmp( str, "MIPS 2.0", strlen( "MIPS 2.0" ) ) == 0 );
619	620	(void)str;//warning removal
620	621	}
621	622

-1

Source/MediaStorageAndFileFormat/gdcmPixmapWriter.cxx less more

620	620	case 12:
621	621	case 16:
622	622	case 32:
623		depixdata.SetVR( VR::OW );
	623	if( depixdata.GetSequenceOfFragments() )
	624	depixdata.SetVR( VR::OB );
	625	else
	626	depixdata.SetVR( VR::OW );
624	627	break;
625	628	default:
626	629	assert( 0 && "should not happen" );

-5

Source/MediaStorageAndFileFormat/gdcmRescaler.cxx less more

145	145	{
146	146	st = PixelFormat::UINT32;
147	147	}
148		else if( max <= std::numeric_limits<uint64_t>::max() )
	148	else if( max <= static_cast<double>(std::numeric_limits<uint64_t>::max()) )
149	149	{
150	150	// very large value in Rescale Slope ?
151	151	return PixelFormat::FLOAT64;

173	173	{
174	174	st = PixelFormat::INT32;
175	175	}
176		else if( max <= std::numeric_limits<int64_t>::max()
177		&& min >= std::numeric_limits<int64_t>::min() )
	176	else if( max <= static_cast<double>(std::numeric_limits<int64_t>::max())
	177	&& min >= static_cast<double>(std::numeric_limits<int64_t>::min() ) )
178	178	{
179	179	// very large value in Rescale Slope ?
180	180	return PixelFormat::FLOAT64;

424	424	dmax = (_min - intercept ) / slope;
425	425	}
426	426	assert( dmin <= dmax );
427		assert( dmax <= std::numeric_limits<int64_t>::max() );
428		assert( dmin >= std::numeric_limits<int64_t>::min() );
	427	assert( dmax <= static_cast<double>(std::numeric_limits<int64_t>::max() ) );
	428	assert( dmin >= static_cast<double>(std::numeric_limits<int64_t>::min() ) );
429	429	/*
430	430	* Tricky: what happen in the case where floating point approximate dmax as: 65535.000244081035
431	431	* Take for instance: _max = 64527, intercept = -1024, slope = 1.000244140625

-7

Source/MediaStorageAndFileFormat/gdcmRescaler.h less more

51	51	* Example: Let say input is FLOAT64, and we want UINT16 as ouput, we would do:
52	52	*
53	53	*\code
54		* Rescaler ir;
55		* ir.SetIntercept( 0 );
56		* ir.SetSlope( 5.6789 );
57		* ir.SetPixelFormat( FLOAT64 );
58		* ir.SetMinMaxForPixelType( ((PixelFormat)UINT16).GetMin(), ((PixelFormat)UINT16).GetMax() );
59		* ir.InverseRescale(output,input,numberofbytes );
60		*\endcode
	54	Rescaler ir;
	55	ir.SetIntercept( 0 );
	56	ir.SetSlope( 5.6789 );
	57	ir.SetPixelFormat( FLOAT64 );
	58	ir.SetMinMaxForPixelType( ((PixelFormat)UINT16).GetMin(), ((PixelFormat)UINT16).GetMax() );
	59	ir.InverseRescale(output,input,numberofbytes );
	60	\endcode
61	61	*
62	62	* \note handle floating point transformation back and forth to integer
63	63	* properly (no loss)

-2

Source/MediaStorageAndFileFormat/gdcmSerieHelper.h less more

92	92	bool ImageNumberOrdering( FileList *fileList );
93	93	bool FileNameOrdering( FileList *fileList );
94	94
95		typedef struct {
	95	using Rule = struct RuleStructure{
96	96	uint16_t group;
97	97	uint16_t elem;
98	98	std::string value;
99	99	int op;
100		} Rule;
	100	};
101	101	typedef std::vector<Rule> SerieRestrictions;
102	102
103	103	typedef std::map<std::string, FileList *> SingleSerieUIDFileSetmap;

-1

Source/MediaStorageAndFileFormat/gdcmStreamImageReader.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MediaStorageAndFileFormat/gdcmStreamImageReader.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MediaStorageAndFileFormat/gdcmStreamImageWriter.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MediaStorageAndFileFormat/gdcmStreamImageWriter.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-0

Source/MediaStorageAndFileFormat/gdcmStringFilter.cxx less more

39	39	std::string StringFilter::ToString(const Tag& t) const
40	40	{
41	41	return ToStringPair(t).second;
	42	}
	43
	44	std::string StringFilter::ToString(const PrivateTag& privTag) const
	45	{
	46	const DataSet &ds = GetFile().GetDataSet();
	47	const DataElement &de = ds.GetDataElement(privTag);
	48	return ToStringPair(de).second;
42	49	}
43	50
44	51	std::string StringFilter::ToString(const DataElement& de) const

-0

Source/MediaStorageAndFileFormat/gdcmStringFilter.h less more

45	45	/// Directly from a Tag:
46	46	std::string ToString(const Tag& t) const;
47	47
	48	std::string ToString(const PrivateTag& t) const;
	49
48	50	/// Convert to string the ByteValue contained in a DataElement
49	51	/// the returned elements are:
50	52	/// pair.first : the name as found in the dictionary of DataElement

-1

Source/MessageExchangeDefinition/gdcmARTIMTimer.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmARTIMTimer.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBaseCompositeMessage.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBasePDU.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBaseQuery.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBaseQuery.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBaseRootQuery.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmBaseRootQuery.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCEchoMessages.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCEchoMessages.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCFindMessages.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCFindMessages.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCMoveMessages.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCMoveMessages.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCStoreMessages.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCStoreMessages.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCompositeMessageFactory.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCompositeMessageFactory.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCompositeNetworkFunctions.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmCompositeNetworkFunctions.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmNetworkEvents.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmNetworkStateID.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmPDUFactory.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmPDUFactory.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryBase.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryFactory.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryFactory.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryImage.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryImage.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryPatient.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryPatient.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQuerySeries.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQuerySeries.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryStudy.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmQueryStudy.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULAction.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAA.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAA.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAE.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAE.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAR.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionAR.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionDT.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULActionDT.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULBasicCallback.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULBasicCallback.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnection.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnection.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnectionCallback.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnectionInfo.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnectionInfo.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnectionManager.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULConnectionManager.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULEvent.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULTransitionTable.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULTransitionTable.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULWritingCallback.cxx less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-1

Source/MessageExchangeDefinition/gdcmULWritingCallback.h less more

0	0	/*=========================================================================
1	1	*
2		* Copyright Insight Software Consortium
	2	* Copyright NumFOCUS
3	3	*
4	4	* Licensed under the Apache License, Version 2.0 (the "License");
5	5	* you may not use this file except in compliance with the License.

-0

Testing/Source/Common/Cxx/TestMD5.cxx less more

243	243	{ "2fd5ad3e9265861be43b6a341314cc52" , "FUJI-ffff-MONO1-J2K.dcm" },
244	244	{ "69648b9be35a621e9e5b447df656ab18" , "JPEGLosslessSeNonZero.dcm" },
245	245	{ "c0ee318130c0fcf35b0f57670a8f1e0d" , "US-YBR_FULL_422-EVRLE.dcm" },
	246	{ "3d873e4c19bf5513959c6cc1a184e2df" , "Osirix10vs8BitsStored.dcm" },
	247	{ "5141fe286ad2e39259dac231e3d10b41" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	248	{ "3155af485dc3f490cc9e212f95499615" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	249	{ "ab93bd11ce0f48e2e9e1c700df160a30" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
246	250
247	251	{ nullptr, nullptr}
248	252	};

-0

Testing/Source/Common/Cxx/TestSHA1.cxx less more

240	240	{ "566387063a28df033d891ac48a42dbb3f6b6a65f" , "FUJI-ffff-MONO1-J2K.dcm" },
241	241	{ "cb4be6eb5b38940067a1b74ca0360bbb8c66c449" , "JPEGLosslessSeNonZero.dcm" },
242	242	{ "53137beb3f73345771ff853d670addd81e58906e" , "US-YBR_FULL_422-EVRLE.dcm" },
	243	{ "78088c2bfe34911c46476f5fd110c9e0d9813044" , "Osirix10vs8BitsStored.dcm" },
	244	{ "31f0556c75829dee3850414e166863220f9e03da" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	245	{ "129b3cebd15fd1edb55c8fae75976501f2601dce" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	246	{ "2ac195a776c8cb9f0e6eb2e297bd2bf37bb11697" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
243	247
244	248	{ NULL, NULL}
245	249	};

-7

Testing/Source/Common/Cxx/TestString2.cxx less more

15	15	#include <iostream>
16	16
17	17	#include <string.h> // strlen
18		#include <stdio.h> // EOF
19	18
20	19	int TestString2(int , char *[])
21	20	{

25	24	gdcm::String<> s2 = "coucou!";
26	25	std::cout << s2 << " -> " << s2.size() << std::endl;
27	26
28		gdcm::String<EOF,64,0> s3 = "coucou";
	27	gdcm::String<'\0',64,0> s3 = "coucou";
29	28	std::cout << s3.c_str() << " -> " << s3.size() << std::endl;
30	29
31		gdcm::String<EOF,64,0> s4 = "coucou!";
	30	gdcm::String<'\0',64,0> s4 = "coucou!";
32	31	std::cout << s4.c_str() << " -> " << s4.size() << std::endl;
33	32
34	33	const char *s = "coucou!";
35		gdcm::String<EOF,64,0> s5( s, strlen(s) );
	34	gdcm::String<'\0',64,0> s5( s, strlen(s) );
36	35	std::cout << s5.c_str() << " -> " << s5.size() << std::endl;
37	36
38	37	std::string ss = "coucou!";
39		gdcm::String<EOF,64,0> s6( ss );
	38	gdcm::String<'\0',64,0> s6( ss );
40	39	std::cout << s6.c_str() << " -> " << s6.size() << std::endl;
41	40
42		gdcm::String<EOF,64,0> s7( ss, 1, 5 );
	41	gdcm::String<'\0',64,0> s7( ss, 1, 5 );
43	42	std::cout << s7.c_str() << " -> " << s7.size() << std::endl;
44	43
45		gdcm::String<EOF,64,0> s8( ss, 1, 6 );
	44	gdcm::String<'\0',64,0> s8( ss, 1, 6 );
46	45	std::cout << s8.c_str() << " -> " << s8.size() << std::endl;
47	46
48	47	return 0;

-0

Testing/Source/Data/CMakeLists.txt less more

49	49	PET-cardio-Multiframe-Papyrus.dcm
50	50	# No way to read this image:
51	51	ELSCINT1_LOSSLESS_RICE.dcm
	52	# SignedShortLossless has never really been supported anyway:
	53	SignedShortLosslessBug.dcm
	54	# Would need to process ALL Pixel Data element when decompressing:
	55	PET-GE-dicomwrite-PixelDataSQUNv3.dcm
52	56	# Toshiba US Private Data Storage 1.2.392.200036.9116.7.8.1.1.1
53	57	TOSHIBA_MDW_HEADER.dcm
54	58	# TODO, nasty:

-0

Testing/Source/Data/gdcmMD5DataBrokenImages.cxx less more

92	92	// Two Items in a single Frame JPEG compressed DICOM image:
93	93	{ "cd00658f54dbd2d2a9d02d64c6f6497e" , "JPEGInvalidSecondFrag.dcm" },
94	94
	95	// VR is set to 'OX'
	96	{ "5793021ffb7b3506ae22ae9329d67d29" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	97
95	98	{ nullptr ,nullptr }
96	99	};
97	100

-1

Testing/Source/Data/gdcmMD5DataImages.cxx less more

706	706
707	707	{ "b9697e3615a841e4c04f45ede6923278" , "JPEGLosslessSeNonZero.dcm" },
708	708	{ "5fcd7d6573cab16d2ef575bba878ec78" , "US-YBR_FULL_422-EVRLE.dcm" },
709
	709	{ "d62b4c13e8108671f1c66626c5bdee55" , "Osirix10vs8BitsStored.dcm" },
	710
	711	{ "b7c6fb507da1b7a3f81f821a2e3eaf49" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	712	{ "56238d3665ebdb0251d1161fb7f4edc6" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	713	{ "5fe2b8742f05a0ba06d354f965266dbc" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
710	714
711	715	/* Stopping condition */
712	716	{ nullptr ,nullptr }

-0

Testing/Source/Data/gdcmMediaStorageDataFiles.cxx less more

255	255	{ "JPEGLosslessSeNonZero.dcm" , "1.2.840.10008.5.1.4.1.1.7" },
256	256	{ "US-YBR_FULL_422-EVRLE.dcm" , "1.2.840.10008.5.1.4.1.1.6.1" },
257	257	{ "PET-GE-dicomwrite-PixelDataSQUN.dcm" , "1.2.840.10008.5.1.4.1.1.128" },
	258	{ "Osirix10vs8BitsStored.dcm" , "1.2.840.10008.5.1.4.1.1.4" },
	259	{ "Bug_Siemens_PrivateIconNoItem.dcm" , "1.2.840.10008.5.1.4.1.1.2" },
	260	{ "HardcopyColor_YBR_RCT_J2K_PC1.dcm" , "1.2.840.10008.5.1.1.30" },
	261	{ "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" , "1.2.840.10008.5.1.4.1.1.128" },
258	262
259	263	/* Stopping condition */
260	264	{ nullptr ,nullptr }

-0

Testing/Source/Data/gdcmSelectedPrivateGroupOffsetDataFiles.cxx less more

235	235	{ "FUJI-ffff-MONO1-J2K.dcm",982},
236	236	{ "JPEGLosslessSeNonZero.dcm",530},
237	237	{ "US-YBR_FULL_422-EVRLE.dcm",744},
	238	{ "Osirix10vs8BitsStored.dcm",1512},
	239	{ "Bug_Siemens_PrivateIconNoItem.dcm",1360},
	240	{ "HardcopyColor_YBR_RCT_J2K_PC1.dcm",1284},
	241	{ "PET-GE-dicomwrite-PixelDataSQUNv2.dcm",4620},
238	242	{ "dicomdir_With_embedded_icons",7125212 },
239	243	{ "dicomdir_Pms_WithVisit_WithPrivate_WithStudyComponents",37218 },
240	244	{ "dicomdir_Acusson_WithPrivate_WithSR",3826 },

-0

Testing/Source/Data/gdcmSelectedTagsOffsetDataFiles.cxx less more

237	237	{ "FUJI-ffff-MONO1-J2K.dcm",2040},
238	238	{ "JPEGLosslessSeNonZero.dcm",748},
239	239	{ "US-YBR_FULL_422-EVRLE.dcm",1542},
	240	{ "Osirix10vs8BitsStored.dcm",73966},
	241	{ "Bug_Siemens_PrivateIconNoItem.dcm",12966},
	242	{ "HardcopyColor_YBR_RCT_J2K_PC1.dcm",2614},
	243	{ "PET-GE-dicomwrite-PixelDataSQUNv2.dcm",7706},
240	244	{ "dicomdir_Acusson_WithPrivate_WithSR",3826 },
241	245	{ "dicomdir_Pms_WithVisit_WithPrivate_WithStudyComponents",37218 },
242	246	{ "dicomdir_Pms_With_heavy_embedded_sequence",3003414 },

-0

Testing/Source/Data/gdcmStreamOffsetDataFiles.cxx less more

242	242	{ "FUJI-ffff-MONO1-J2K.dcm",2052 },
243	243	{ "JPEGLosslessSeNonZero.dcm",760 },
244	244	{ "US-YBR_FULL_422-EVRLE.dcm",1554 },
	245	{ "Osirix10vs8BitsStored.dcm",73978 },
	246	{ "Bug_Siemens_PrivateIconNoItem.dcm",12978 },
	247	{ "HardcopyColor_YBR_RCT_J2K_PC1.dcm",2626 },
	248	{ "PET-GE-dicomwrite-PixelDataSQUNv2.dcm",7718 },
245	249
246	250	/* Stopping condition */
247	251	{ nullptr ,0 },

-3

Testing/Source/DataDictionary/Cxx/TestSOPClassUIDToIOD.cxx less more

24	24	if( std::string(s[1] ) != "Basic Directory IOD Modules" ) return 1;
25	25
26	26	// points to { nullptr, nullptr }, hardcoded
27		gdcm::SOPClassUIDToIOD::SOPClassUIDToIODType& s2 = gdcm::SOPClassUIDToIOD::GetSOPClassUIDToIOD(106);
	27	gdcm::SOPClassUIDToIOD::SOPClassUIDToIODType& s2 = gdcm::SOPClassUIDToIOD::GetSOPClassUIDToIOD(107);
28	28	std::cout << ( s2[0] == nullptr ) << std::endl;
29		if( !(s2[0] == nullptr) ) return 1;
30		std::cout << ( s2[1] == nullptr ) << std::endl;
	29	if( !(s2[0] == nullptr) ) {
	30	std::cerr << s2[1] << std::endl;
	31	return 1;
	32	}
31	33	if( !(s2[1] == nullptr) ) return 1;
32	34
33	35	const char *sopclassuid = gdcm::SOPClassUIDToIOD::GetSOPClassUIDFromIOD( s[1] );

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/CMakeLists.txt less more

59	59	TestStringFilter1
60	60	TestStringFilter2
61	61	TestStringFilter3
	62	TestStringFilter4
62	63	TestUIDGenerator
63	64	TestUUIDGenerator
64	65	#TestUIDGenerator3

+11

-2

Testing/Source/MediaStorageAndFileFormat/Cxx/TestAnonymizer2.cxx less more

28	28
29	29	namespace gdcm
30	30	{
31		int TestAnonymize2(const char subdir, const char filename)
	31	int TestAnonymize2(const char subdir, const char filename, bool verbose = false)
32	32	{
33	33	gdcm::Global& g = gdcm::Global::GetInstance();
34	34	if( !g.LoadResourcesFiles() )

46	46	System::MakeDirectory( tmpdir.c_str() );
47	47	//return 1;
48	48	}
	49	if(verbose) std::cout << "Processing: " << filename << std::endl;
49	50	std::string outfilename = Testing::GetTempFilename( filename, subdir );
50	51
51	52	// Create directory first:

102	103	ano->SetFile( reader.GetFile() );
103	104	if( !ano->BasicApplicationLevelConfidentialityProfile() )
104	105	{
	106	gdcm::Filename fn( filename );
	107	if( strcmp(fn.GetName(), "EmptyIcon_Bug417.dcm") == 0 // not supported for now (already anonymized)
	108	\|\| strcmp(fn.GetName(), "PET-GE-dicomwrite-PixelDataSQUNv2.dcm") == 0 // not supported for now (already anonymized)
	109	\|\| strcmp(fn.GetName(), "HardcopyColor_YBR_RCT_J2K_PC1.dcm") == 0 // deprecated SOP Class UID
	110	)
	111	{
	112	return 0;
	113	}
105	114	if( ms != gdcm::MediaStorage::MS_END )
106	115	{
107	116	std::cerr << "BasicApplicationLevelConfidentialityProfile fails for: " << filename << std::endl;

192	201	if( argc == 2 )
193	202	{
194	203	const char *filename = argv[1];
195		return gdcm::TestAnonymize2(argv[0], filename);
	204	return gdcm::TestAnonymize2(argv[0], filename, true);
196	205	}
197	206
198	207	// else

-2

Testing/Source/MediaStorageAndFileFormat/Cxx/TestDataSetHelper.cxx less more

105	105	{
106	106	assert( vr == VR::DS \|\| vr == VR::SS \|\| vr == VR::SH );
107	107	assert( vr2 == VR::IS \|\| vr2 == VR::US \|\| vr2 == VR::CS );
	108	return vr;
	109	}
	110	// PHILIPS_Gyroscan-12-Jpeg_Extended_Process_2_4.dcm
	111	if( de.GetTag() == Tag(0x0008,0x0040) )
	112	{
	113	assert( vr == VR::SS );
	114	assert( vr2 == VR::US );
108	115	return vr;
109	116	}
110	117	if( vr == VR::SQ \|\| vr2 == VR::SQ )

228	235	return 1;
229	236	}
230	237
231		const gdcm::Global &g = gdcm::GlobalInstance;
232		const gdcm::Dicts &dicts = g.GetDicts();
233	238	const gdcm::File & file = r.GetFile();
234	239	gdcm::Printer2 print;
235	240	print.SetFile( file );

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestEquipmentManufacturer.cxx less more

75	75	\|\| strcmp(name, "PICKER-16-MONO2-No_DicomV3_Preamble.dcm" ) == 0
76	76	\|\| strcmp(name, "OT-PAL-8-face.dcm" ) == 0
77	77	\|\| strcmp(name, "TG18-CH-2k-01.dcm" ) == 0 // wotsit ?
	78	\|\| strcmp(name, "HardcopyColor_YBR_RCT_J2K_PC1.dcm" ) == 0 // RamSoft Inc.
78	79	\|\| strncmp(name, "D_CLUNIE", 8) == 0 // D_CLUNIE*
79	80	\|\| strncmp(name, "LEADTOOLS_FLOWERS", 17) == 0 // LEADTOOLS_FLOWERS*
80	81	\|\| strncmp(name, "JDDICOM", 7) == 0 // JDDICOM*

-1

Testing/Source/MediaStorageAndFileFormat/Cxx/TestIconImageFilter.cxx less more

36	36	{ "620f0b67a91f7f74151bc5be745b7110" , "MR-SIEMENS-DICOM-WithOverlays-extracted-overlays.dcm" },
37	37	{ "938f6ea0bea13ff5c45c7934e603caac" , "US-GE-4AICL142.dcm" },
38	38	{ "9c145bbfd00e867d5f9f6efe9651a71e" , "SIEMENS_SYNGO-12-MONO2-LUTWrongLength512.dcm" },
	39	{ "48bf71ea2e18b0632ec318d55fb455ab" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	40	{ "a29e9def9a1478c9f8b957c68b33885b" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
39	41
40	42	// VEPRO VIF
41	43	{ "ea4673b2aa72f477188bac340e115f4c" , "PHILIPS_Gyroscan-12-MONO2-Jpeg_Lossless.dcm" },

113	115	}
114	116	else
115	117	{
116		assert( refmd5 == 0 );
	118	assert( refmd5 == nullptr );
117	119	}
118	120
119	121	return 0;

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestIconImageGenerator3.cxx less more

209	209	{"f4f35d60b3cc18aaa6d8d92f0cd3708a" , "NM-PAL-16-PixRep1.dcm" },
210	210	{"843f097f2161014cd1b11be5413eace9" , "MEDILABInvalidCP246_EVRLESQasUN.dcm" },
211	211	{"c103d405ae61aa4ed148e17157e5afc1" , "JPEGInvalidSecondFrag.dcm" },
	212	{"c103d405ae61aa4ed148e17157e5afc1" , "Osirix10vs8BitsStored.dcm" },
	213	{"c103d405ae61aa4ed148e17157e5afc1" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	214	{"c103d405ae61aa4ed148e17157e5afc1" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	215	{"c103d405ae61aa4ed148e17157e5afc1" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
212	216
213	217	// sentinel
214	218	{ 0, 0 }

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestIconImageGenerator4.cxx less more

213	213	{"560881eca73809ac358aa14733ee64af" , "JPEGInvalidSecondFrag.dcm" },
214	214	{"7c70c2aaacf9a4206cbe2191fa4d2041" , "SC16BitsAllocated_8BitsStoredJ2K.dcm" },
215	215	{"da0922a02f8e763ec878089617e0bc4c" , "SC16BitsAllocated_8BitsStoredJPEG.dcm" },
	216	{"da0922a02f8e763ec878089617e0bc4c" , "Osirix10vs8BitsStored.dcm" },
	217	{"da0922a02f8e763ec878089617e0bc4c" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	218	{"da0922a02f8e763ec878089617e0bc4c" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	219	{"da0922a02f8e763ec878089617e0bc4c" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
216	220
217	221	// sentinel
218	222	{ 0, 0 }

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestImageChangePlanarConfiguration.cxx less more

15	15	#include "gdcmImageWriter.h"
16	16	#include "gdcmTesting.h"
17	17	#include "gdcmFilename.h"
	18	#include "gdcmByteSwap.h"
18	19	#include "gdcmSystem.h"
19	20
20	21	int TestImageChangePlanarConfigurationFunc(const char *filename, bool verbose = false)

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestPixelFormat.cxx less more

11	11
12	12	=========================================================================*/
13	13	#include "gdcmPixelFormat.h"
	14
	15	struct frame_info {
	16	gdcm::PixelFormat pixeltype;
	17	};
14	18
15	19	int TestPixelFormat(int , char *[])
16	20	{

137	141	pf4.SetPixelRepresentation(1);
138	142	if( pf4.GetScalarType() != gdcm::PixelFormat::INT16 ) return 1;
139	143
	144	frame_info fi = {};
140	145
141	146	return 0;
142	147	}

-1

Testing/Source/MediaStorageAndFileFormat/Cxx/TestPrinter1.cxx less more

105	105	{ "d576bf8e8b2ca71fd543d29698807e85" , "ExplicitVRforPublicElementsImplicitVRforShadowElements.dcm" } ,
106	106	{ "3199cd21166043d619209d7a2073fb56" , "fffc0000UN.dcm" } ,
107	107	{ "9b426b02521cbc2f3ee25ab383ca835e" , "FUJI-10-MONO1-ACR_NEMA_2.dcm" } ,
108		{ "68948325d590458fa6a648a93ef46f04" , "FUJI-ffff-MONO1-J2K.dcm"} ,
	108	{ "f705cfe771a299023c8dcc94b2184960" , "FUJI-ffff-MONO1-J2K.dcm"} ,
109	109	{ "2aba3dacd00a0bc14a06e2d7142b916a" , "gdcm-ACR-LibIDO.acr" } ,
110	110	{ "b808c747b59f9d1a91a01491103abea5" , "gdcm-CR-DCMTK-16-NonSamplePerPix.dcm" } ,
111	111	{ "e7b5089a2a007221993ee5a7e6d44959" , "gdcm-JPEG-Extended.dcm" } ,

245	245	{ "df3327313dadcc29e88779c7bc884abb" , "EmptyIcon_Bug417.dcm" },
246	246	{ "7d0db54d48964c813d513b472f29155c" , "JPEGLosslessSeNonZero.dcm" },
247	247	{ "44e6c3eef66b555ec3ae3e6dec6e8157" , "US-YBR_FULL_422-EVRLE.dcm" },
	248	{ "80deb837f8cfc1edc95f636ef099d431" , "Osirix10vs8BitsStored.dcm" },
	249	{ "a638f2bc00e67f35257f36e5d5caa6b0" , "Bug_Siemens_PrivateIconNoItem.dcm" },
	250	{ "f64bcbdf9396df3eb3cedd28457042da" , "HardcopyColor_YBR_RCT_J2K_PC1.dcm" },
	251	{ "4f9b4e5530f1d60472d85a641105c009" , "PET-GE-dicomwrite-PixelDataSQUNv2.dcm" },
248	252
249	253
250	254	{ nullptr ,nullptr }

+53

-0

Testing/Source/MediaStorageAndFileFormat/Cxx/TestStringFilter4.cxx less more

	0	/*=========================================================================
	1
	2	Program: GDCM (Grassroots DICOM). A DICOM library
	3
	4	Copyright (c) 2006-2011 Mathieu Malaterre
	5	All rights reserved.
	6	See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
	7
	8	This software is distributed WITHOUT ANY WARRANTY; without even
	9	the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	10	PURPOSE. See the above copyright notice for more information.
	11
	12	=========================================================================*/
	13	#include "gdcmStringFilter.h"
	14	#include "gdcmAttribute.h"
	15	#include "gdcmSmartPointer.h"
	16
	17	// https://sourceforge.net/p/gdcm/bugs/485/
	18	int TestStringFilter4(int , char *[])
	19	{
	20	gdcm::SmartPointer<gdcm::File> f = new gdcm::File;
	21	gdcm::DataSet & ds = f->GetDataSet();
	22
	23	{
	24	gdcm::Element<gdcm::VR::LO,gdcm::VM::VM1> priv_creator;
	25	priv_creator.SetValue( "SIEMENS MED SP DXMG WH AWS 1" );
	26	gdcm::DataElement de1 = priv_creator.GetAsDataElement();
	27	de1.SetTag( gdcm::Tag(0x19,0x10) );
	28	ds.Insert( de1 );
	29
	30	gdcm::Element<gdcm::VR::ST,gdcm::VM::VM1> el;
	31	el.SetValue( "TestStringFilter4" );
	32	gdcm::DataElement de2 = el.GetAsDataElement();
	33	de2.SetTag( gdcm::Tag(0x19,0x1010) );
	34	ds.Insert( de2 );
	35	// std::cout << ds << std::endl;
	36
	37	gdcm::StringFilter filter;
	38	filter.SetFile(*f);
	39
	40	gdcm::PrivateTag privTag(0x0019, 0x10, "SIEMENS MED SP DXMG WH AWS 1");
	41
	42	// Works as intended
	43	std::string privTagValue1 = filter.ToString(ds.GetDataElement(privTag));
	44	std::cout << privTagValue1 << std::endl;
	45
	46	// Does not work, returns string value of the private creator instead of the actual tag
	47	std::string privTagValue2 = filter.ToString(privTag);
	48	std::cout << privTagValue2 << std::endl;
	49	}
	50
	51	return 0;
	52	}

-3

Testing/Source/MediaStorageAndFileFormat/Python/TestModifyFields.py less more

33	33	if ds.FindDataElement( replacetag ):
34	34	de = ds.GetDataElement( replacetag )
35	35	#print dir(de)
36		patname = "This^is^an^example"
	36	patname = b"This^is^an^example"
37	37	de.SetByteStringValue( patname )
38	38
39	39	# let's insert a new dataelement
40	40	# <entry group="0012" element="0062" vr="CS" vm="1" name="Patient Identity Removed"/>
41	41	pir = gdcm.DataElement( gdcm.Tag(0x0012,0x0062) )
42	42	pir.SetVR( gdcm.VR( gdcm.VR.CS ) ) # specify the VR explicitly
43		yes = "YES"
	43	yes = b"YES"
44	44	pir.SetByteStringValue( yes )
45	45	ds.Insert( pir )
46	46

53	53	#print dictel.GetVR()
54	54	deid = gdcm.DataElement( deidmethod )
55	55	deid.SetVR( dictel.GetVR() )
56		methodstr = "Well known Company"
	56	methodstr = b"Well known Company"
57	57	#deid.SetByteStringValue( methodstr )
58	58	deid.SetByteStringValue( methodstr )
59	59	ds.Insert( deid )

-1

Utilities/VTK/Testing/Python/TestMultiframeGrayscaleWordSecondaryCaptureImageStorage.py less more

31	31	#print v16.GetOutput()
32	32
33	33	w = vtkgdcm.vtkGDCMImageWriter()
34		w.SetInput( v16.GetOutput() )
	34	w.SetInputConnection( v16.GetOutputPort() )
35	35	w.SetFileDimensionality( 3 )
36	36	w.SetFileName( "sc.dcm" )
37	37	w.Write()

-1

Utilities/VTK/vtkGDCMPolyDataReader.cxx less more

645	645	const gdcm::DataElement &wd = nestedds.GetDataElement( twd );
646	646	const gdcm::ByteValue *bv = wd.GetByteValue();
647	647	size_t len = bv->GetLength();
648		int16_t p = (int16_t)bv;
	648	const int16_t p = (const int16_t)bv;
649	649
650	650	// get the info object
651	651	int pd = 0;

+10

-13

Utilities/VTK/vtkgdcm.i less more

340	340	%ignore vtkGDCMImageReader::PrintSelf;
341	341	%ignore vtkGDCMImageWriter::PrintSelf;
342	342
343		%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") vtkGDCMTesting {
	343	%typemap(csdisposing_derived, methodname="Dispose", methodmodifiers="protected", parameters="bool disposing") vtkGDCMTesting {
344	344	lock(this) {
345	345	if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
346	346	swigCMemOwn = false;
347	347	vtkgdcmPINVOKE.vtkObjectBase_Delete(swigCPtr);
348	348	}
349	349	swigCPtr = new HandleRef(null, IntPtr.Zero);
350		GC.SuppressFinalize(this);
351		base.Dispose();
352		}
353		}
354		%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") vtkGDCMImageReader {
	350	base.Dispose(disposing);
	351	}
	352	}
	353	%typemap(csdisposing_derived, methodname="Dispose", methodmodifiers="protected", parameters="bool disposing") vtkGDCMImageReader {
355	354	lock(this) {
356	355	if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
357	356	swigCMemOwn = false;
358	357	vtkgdcmPINVOKE.vtkObjectBase_Delete(swigCPtr);
359	358	}
360	359	swigCPtr = new HandleRef(null, IntPtr.Zero);
361		GC.SuppressFinalize(this);
362		base.Dispose();
363		}
364		}
365		%typemap(csdestruct_derived, methodname="Dispose", methodmodifiers="public") vtkGDCMImageWriter {
	360	base.Dispose(disposing);
	361	}
	362	}
	363	%typemap(csdisposing_derived, methodname="Dispose", methodmodifiers="protected", parameters="bool disposing") vtkGDCMImageWriter {
366	364	lock(this) {
367	365	if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
368	366	swigCMemOwn = false;
369	367	vtkgdcmPINVOKE.vtkObjectBase_Delete(swigCPtr);
370	368	}
371	369	swigCPtr = new HandleRef(null, IntPtr.Zero);
372		GC.SuppressFinalize(this);
373		base.Dispose();
	370	base.Dispose(disposing);
374	371	}
375	372	}
376	373

-0

Utilities/doxygen/man/gdcmconv.xml less more

302	302
303	303	<para><literallayout>$ gdcmconv --raw compressed.dcm uncompressed.dcm
304	304	</literallayout></para>
	305	<para>In the case of uncompress file (Explicit and Implicit) the behavior is to keep the original Transfer Syntax (so Implicit remains Implit)</para>
	306	</refsection>
	307	<refsection xml:id="gdcmconv_1decompress_raw_imp">
	308	<title>Decompressing a Compressed DICOM as implicit</title>
	309
	310	<para><literallayout>$ gdcmconv --raw --implicit compressed.dcm uncompressed_implicit.dcm
	311	</literallayout></para>
	312	<para>By symmetry it is also possible to use gdcmconv --raw --explicit to make sure that target file is always Explicit TS.</para>
305	313	</refsection>
306	314	<refsection xml:id="gdcmconv_1compress_icon">
307	315	<title>Compressing an uncompressed Icon</title>

-4

Utilities/doxygen/vtk/CMakeLists.txt less more

25	25	set(DOCUMENTATION_HTML_TARZ ON)
26	26	set(DOXYGEN_PROJECT_NAME "vtkgdcm")
27	27	if(VTK_SOURCE_DIR)
28		message(${VTK_SOURCE_DIR})
29		#set(DOXYGEN_SOURCE_DIR "${vtkgdcm_SOURCE_DIR}/VTK/Utilities/Doxygen")
30		set(DOXYGEN_SOURCE_DIR "${VTK_SOURCE_DIR}/Utilities/Doxygen")
	28	message(STATUS ${VTK_SOURCE_DIR})
	29	#set(DOXYGEN_SOURCE_DIR "${vtkgdcm_SOURCE_DIR}/VTK/Utilities/Doxygen")
	30	set(DOXYGEN_SOURCE_DIR "${VTK_SOURCE_DIR}/Utilities/Doxygen")
	31	elseif(VTK_CMAKE_DIR)
	32	set(DOXYGEN_SOURCE_DIR "${VTK_CMAKE_DIR}/../Utilities/Doxygen")
31	33	else()
32	34	# sudo apt-get install vtk-doc
33	35	if(EXISTS "/usr/share/doc/vtk-doc/html")

35	37	elseif(EXISTS "/usr/share/doc/vtk6-doc/doxygen")
36	38	set(DOXYGEN_SOURCE_DIR "/usr/share/doc/vtk6-doc/doxygen")
37	39	else()
38		message(WARNING "DOXYGEN_SOURCE_DIR need to be set.")
	40	message(ERROR "DOXYGEN_SOURCE_DIR need to be set.")
39	41	endif()
40	42	endif()
41	43	set(DOXYGEN_PROJECT_SOURCE_DIR "${vtkgdcm_SOURCE_DIR}")

-4

Utilities/gdcmjpeg/CMakeLists.txt less more

127	127	set(JPEGSTATIC 1)
128	128	endif ()
129	129
130		# By default support DICOMObjects bug, if this is a speed penalty for you
131		# you should consider disabling it
132		set(SUPPORT_DICOMOBJECTS_BUG ON)
133
134	130	# Generate three libraries: jpeg 8bits, 12bits and 16bits
135	131	# using only one source directory
136	132

-60

Utilities/gdcmjpeg/jdpred.c less more

71	71	* logically AND the result with 0xFFFF.
72	72	*/
73	73
74		#define UNDIFFERENCE_2D_BUG(PREDICTOR) \
	74	#define UNDIFFERENCE_2D(PREDICTOR) \
	75	unsigned int xindex; \
	76	int Ra, Rb, Rc; \
	77	\
75	78	Rb = GETJSAMPLE(prev_row[0]); \
76	79	Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \
77	80	undiff_buf[0] = Ra; \

83	86	undiff_buf[xindex] = Ra; \
84	87	}
85	88
86		#define UNDIFFERENCE_2D(PREDICTOR) \
87		unsigned int xindex; \
88		int Ra, Rb, Rc; \
89		\
90		Rb = GETJSAMPLE(prev_row[0]); \
91		Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF; \
92		undiff_buf[0] = Ra; \
93		\
94		for (xindex = 1; xindex < width; xindex++) { \
95		Rc = Rb; \
96		Rb = GETJSAMPLE(prev_row[xindex]); \
97		Ra = (diff_buf[xindex] + PREDICTOR) & 0xFFFF; \
98		undiff_buf[xindex] = Ra; \
99		}
100
101	89
102	90	/*
103	91	* Undifferencers for the all rows but the first in a scan or restart interval.

152	140	(void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
153	141	}
154	142
155		#ifdef SUPPORT_DICOMOBJECTS_BUG
156		/* uninitialized */
157		static int dicomobjectsbug = -1; /* 0 == nobug, 1 == bug */
158		#endif
159
160	143	METHODDEF(void)
161	144	jpeg_undifference6(j_decompress_ptr cinfo, int comp_index,
162	145	JDIFFROW diff_buf, JDIFFROW prev_row,
163	146	JDIFFROW undiff_buf, JDIMENSION width)
164	147	{
165		#ifdef SUPPORT_DICOMOBJECTS_BUG
166		unsigned int xindex;
167		int Ra, Rb, Rc;
168		int min, max, temp;
169		SHIFT_TEMPS
170		if( dicomobjectsbug == -1 )
171		{
172		dicomobjectsbug = 0; /* no bug by default */
173
174		Rb = GETJSAMPLE(prev_row[0]);
175		Ra = (diff_buf[0] + PREDICTOR2) & 0xFFFF;
176		undiff_buf[0] = Ra;
177		temp = min = max = undiff_buf[0];
178
179		for (xindex = 1; xindex < width; xindex++) {
180		Rc = Rb;
181		Rb = GETJSAMPLE(prev_row[xindex]);
182		Ra = (diff_buf[xindex] + PREDICTOR6) & 0xFFFF;
183		temp = Ra;
184		min = temp < min ? temp : min;
185		max = temp > max ? temp : max;
186		}
187		if( (max - min) > 50000) /* magic number */
188		{
189		dicomobjectsbug = 1;
190		WARNMS(cinfo, JWRN_SIGNED_ARITH);
191		}
192		}
193		if(dicomobjectsbug)
194		{
195		UNDIFFERENCE_2D_BUG(PREDICTOR6_BUG);
196		}
197		else
198		{
199		UNDIFFERENCE_2D_BUG(PREDICTOR6);
200		}
201		#else
202	148	SHIFT_TEMPS
203	149	UNDIFFERENCE_2D(PREDICTOR6);
204		#endif
205		(void)comp_index;(void)cinfo;
	150	(void)cinfo;(void)comp_index;(void)diff_buf;(void)prev_row;(void)undiff_buf;(void)width;
206	151	}
207	152
208	153	METHODDEF(void)

-1

Utilities/gdcmjpeg/jlossls.h less more

22	22	#define PREDICTOR4 (int) ((INT32) Ra + (INT32) Rb - (INT32) Rc)
23	23	#define PREDICTOR5 (int) ((INT32) Ra + RIGHT_SHIFT((INT32) Rb - (INT32) Rc, 1))
24	24	#define PREDICTOR6 (int) ((INT32) Rb + RIGHT_SHIFT((INT32) Ra - (INT32) Rc, 1))
25		#define PREDICTOR6_BUG (int) ((INT16) Rb + RIGHT_SHIFT((INT16) Ra - (INT16) Rc, 1))
26	25	#define PREDICTOR7 (int) RIGHT_SHIFT((INT32) Ra + (INT32) Rb, 1)
27	26
28	27

-7

Utilities/gdcmjpeg/jpegcmake.h.in less more

21	21	#cmakedefine JPEGDLL
22	22	#cmakedefine JPEGSTATIC
23	23
24		/* For more info on this bug see:
25		* [Broken JPEG from GE station] on comp.protocols.dicom
26		* and official publication at:
27		* http://www.medicalconnections.co.uk/html/lossless_bug.html
28		*/
29		#cmakedefine SUPPORT_DICOMOBJECTS_BUG
30
31	24	#define BITS_IN_JSAMPLE @CMAKE_BITS_IN_JSAMPLE@
32	25
33	26	#if BITS_IN_JSAMPLE == 8

-2

Utilities/gdcmopenjpeg/src/lib/openjp2/j2k.c less more

6920	6920	image->comps[0].h * image->comps[0].prec) /
6921	6921	((double)parameters->tcp_rates[parameters->tcp_numlayers - 1] * 8 *
6922	6922	image->comps[0].dx * image->comps[0].dy));
6923		if (temp_size > INT_MAX) {
6924		parameters->max_cs_size = INT_MAX;
	6923	if (temp_size > (OPJ_FLOAT32)INT_MAX) {
	6924	parameters->max_cs_size = (OPJ_FLOAT32)INT_MAX;
6925	6925	} else {
6926	6926	parameters->max_cs_size = (int) floor(temp_size);
6927	6927	}

-2

Utilities/gdcmopenjpeg/src/lib/openjp2/tcd.c less more

2223	2223	for (j = 0; j < l_height; ++j) {
2224	2224	for (i = 0; i < l_width; ++i) {
2225	2225	OPJ_FLOAT32 l_value = ((OPJ_FLOAT32 ) l_current_ptr);
2226		if (l_value > INT_MAX) {
	2226	if (l_value > (OPJ_FLOAT32)INT_MAX) {
2227	2227	*l_current_ptr = l_max;
2228		} else if (l_value < INT_MIN) {
	2228	} else if (l_value < (OPJ_FLOAT32)INT_MIN) {
2229	2229	*l_current_ptr = l_min;
2230	2230	} else {
2231	2231	/* Do addition on int64 to avoid overflows */

+565

-517

Wrapping/Python/docstrings.i less more

155	155	";
156	156
157	157	%feature("docstring")
158		gdcm::network::AAssociateRQPDU::GetPresentationContext "PresentationContextRQ const&
	158	gdcm::network::AAssociateRQPDU::GetPresentationContext "const
	159	PresentationContextRQ&
159	160	gdcm::network::AAssociateRQPDU::GetPresentationContext(SizeType i)
160	161	const ";
161	162

172	173	const ";
173	174
174	175	%feature("docstring")
175		gdcm::network::AAssociateRQPDU::GetPresentationContexts "PresentationContextArrayType const&
	176	gdcm::network::AAssociateRQPDU::GetPresentationContexts "const
	177	PresentationContextArrayType&
176	178	gdcm::network::AAssociateRQPDU::GetPresentationContexts() ";
177	179
178	180	%feature("docstring")

272	274
273	275	C++ includes: gdcmAnonymizeEvent.h ";
274	276
	277	%feature("docstring") gdcm::AnonymizeEvent::AnonymizeEvent "gdcm::AnonymizeEvent::AnonymizeEvent(const Self &s) ";
	278
275	279	%feature("docstring") gdcm::AnonymizeEvent::AnonymizeEvent "gdcm::AnonymizeEvent::AnonymizeEvent(Tag const &tag=0) ";
276
277		%feature("docstring") gdcm::AnonymizeEvent::AnonymizeEvent "gdcm::AnonymizeEvent::AnonymizeEvent(const Self &s) ";
278	280
279	281	%feature("docstring") gdcm::AnonymizeEvent::~AnonymizeEvent "gdcm::AnonymizeEvent::~AnonymizeEvent() override=default ";
280	282

287	289
288	290	Return the StringName associated with the event. ";
289	291
290		%feature("docstring") gdcm::AnonymizeEvent::GetTag "Tag const&
	292	%feature("docstring") gdcm::AnonymizeEvent::GetTag "const Tag&
291	293	gdcm::AnonymizeEvent::GetTag() const ";
292	294
293	295	%feature("docstring") gdcm::AnonymizeEvent::MakeObject "::gdcm::Event* gdcm::AnonymizeEvent::MakeObject() const override

674	676	C++ includes: gdcmAttribute.h ";
675	677
676	678	%feature("docstring") gdcm::Attribute::GDCM_STATIC_ASSERT "gdcm::Attribute< Group, Element, TVR, TVM
677		>::GDCM_STATIC_ASSERT(((VR::VRType) TVR &(VR::VRType)(TagToType<
678		Group, Element >::VRType))) ";
	679	>::GDCM_STATIC_ASSERT(((((VR::VRType) TVR &VR::VR_VM1) &&((VM::VMType)
	680	TVM==VM::VM1))\|\|!((VR::VRType) TVR &VR::VR_VM1))) ";
679	681
680	682	%feature("docstring") gdcm::Attribute::GDCM_STATIC_ASSERT "gdcm::Attribute< Group, Element, TVR, TVM
681	683	>::GDCM_STATIC_ASSERT(((VM::VMType) TVM &(VM::VMType)(TagToType<
682	684	Group, Element >::VMType))) ";
683	685
684	686	%feature("docstring") gdcm::Attribute::GDCM_STATIC_ASSERT "gdcm::Attribute< Group, Element, TVR, TVM
685		>::GDCM_STATIC_ASSERT(((((VR::VRType) TVR &VR::VR_VM1) &&((VM::VMType)
686		TVM==VM::VM1))\|\|!((VR::VRType) TVR &VR::VR_VM1))) ";
	687	>::GDCM_STATIC_ASSERT(((VR::VRType) TVR &(VR::VRType)(TagToType<
	688	Group, Element >::VRType))) ";
687	689
688	690	%feature("docstring") gdcm::Attribute::GetAsDataElement "DataElement
689	691	gdcm::Attribute< Group, Element, TVR, TVM >::GetAsDataElement() const

697	699	gdcm::Attribute< Group, Element, TVR, TVM >::GetValue(unsigned int
698	700	idx=0) ";
699	701
700		%feature("docstring") gdcm::Attribute::GetValue "ArrayType const&
	702	%feature("docstring") gdcm::Attribute::GetValue "const ArrayType&
701	703	gdcm::Attribute< Group, Element, TVR, TVM >::GetValue(unsigned int
702	704	idx=0) const ";
703	705

733	735
734	736	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
735	737	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR, VM::VM1
736		>::GDCM_STATIC_ASSERT(VMToLength< VM::VM1 >::Length==1) ";
	738	>::GDCM_STATIC_ASSERT(((((VR::VRType) TVR &VR::VR_VM1) &&((VM::VMType)
	739	VM::VM1==VM::VM1))\|\|!((VR::VRType) TVR &VR::VR_VM1))) ";
	740
	741	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
	742	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR, VM::VM1
	743	>::GDCM_STATIC_ASSERT(((VM::VMType) VM::VM1 &(VM::VMType)(TagToType<
	744	Group, Element >::VMType))) ";
737	745
738	746	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
739	747	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR, VM::VM1

742	750
743	751	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
744	752	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR, VM::VM1
745		>::GDCM_STATIC_ASSERT(((VM::VMType) VM::VM1 &(VM::VMType)(TagToType<
746		Group, Element >::VMType))) ";
747
748		%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
749		>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR, VM::VM1
750		>::GDCM_STATIC_ASSERT(((((VR::VRType) TVR &VR::VR_VM1) &&((VM::VMType)
751		VM::VM1==VM::VM1))\|\|!((VR::VRType) TVR &VR::VR_VM1))) ";
	753	>::GDCM_STATIC_ASSERT(VMToLength< VM::VM1 >::Length==1) ";
752	754
753	755	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
754	756	>::GetAsDataElement " DataElement gdcm::Attribute< Group, Element,

763	765	>::GetValue() ";
764	766
765	767	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1
766		>::GetValue " ArrayType const& gdcm::Attribute< Group, Element, TVR,
	768	>::GetValue " const ArrayType& gdcm::Attribute< Group, Element, TVR,
767	769	VM::VM1 >::GetValue() const ";
768	770
769	771	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1

820	822	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
821	823	>::~Attribute " gdcm::Attribute< Group, Element, TVR, VM::VM1_n
822	824	>::~Attribute() ";
823
824		%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
825		>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR,
826		VM::VM1_n >::GDCM_STATIC_ASSERT(((VR::VRType) TVR
827		&(VR::VRType)(TagToType< Group, Element >::VRType))) ";
828
829		%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
830		>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR,
831		VM::VM1_n >::GDCM_STATIC_ASSERT((VM::VM1_n &(VM::VMType)(TagToType<
832		Group, Element >::VMType))) ";
833	825
834	826	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
835	827	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR,

838	830	>::VMType==VM::VM1))\|\|!((VR::VRType) TVR &VR::VR_VM1))) ";
839	831
840	832	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
	833	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR,
	834	VM::VM1_n >::GDCM_STATIC_ASSERT(((VR::VRType) TVR
	835	&(VR::VRType)(TagToType< Group, Element >::VRType))) ";
	836
	837	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
	838	>::GDCM_STATIC_ASSERT " gdcm::Attribute< Group, Element, TVR,
	839	VM::VM1_n >::GDCM_STATIC_ASSERT((VM::VM1_n &(VM::VMType)(TagToType<
	840	Group, Element >::VMType))) ";
	841
	842	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
841	843	>::GetAsDataElement " DataElement gdcm::Attribute< Group, Element,
842	844	TVR, VM::VM1_n >::GetAsDataElement() const ";
843	845

850	852	VM::VM1_n >::GetValue(unsigned int idx=0) ";
851	853
852	854	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
853		>::GetValue " ArrayType const& gdcm::Attribute< Group, Element, TVR,
	855	>::GetValue " const ArrayType& gdcm::Attribute< Group, Element, TVR,
854	856	VM::VM1_n >::GetValue(unsigned int idx=0) const ";
855	857
856	858	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n

879	881
880	882	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
881	883	>::SetValue " void gdcm::Attribute< Group, Element, TVR, VM::VM1_n
882		>::SetValue(unsigned int idx, ArrayType v) ";
	884	>::SetValue(ArrayType v) ";
883	885
884	886	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
885	887	>::SetValue " void gdcm::Attribute< Group, Element, TVR, VM::VM1_n
886		>::SetValue(ArrayType v) ";
	888	>::SetValue(unsigned int idx, ArrayType v) ";
887	889
888	890	%feature("docstring") gdcm::Attribute< Group, Element, TVR, VM::VM1_n
889	891	>::SetValues " void gdcm::Attribute< Group, Element, TVR, VM::VM1_n

1099	1101	%feature("docstring") gdcm::BaseQuery::GetAbstractSyntaxUID "virtual
1100	1102	UIDs::TSName gdcm::BaseQuery::GetAbstractSyntaxUID() const =0 ";
1101	1103
1102		%feature("docstring") gdcm::BaseQuery::GetQueryDataSet "DataSet
1103		const& gdcm::BaseQuery::GetQueryDataSet() const
1104
1105		Set/Get the internal representation of the query as a DataSet. ";
1106
1107	1104	%feature("docstring") gdcm::BaseQuery::GetQueryDataSet "DataSet&
1108	1105	gdcm::BaseQuery::GetQueryDataSet() ";
1109	1106
	1107	%feature("docstring") gdcm::BaseQuery::GetQueryDataSet "const
	1108	DataSet& gdcm::BaseQuery::GetQueryDataSet() const
	1109
	1110	Set/Get the internal representation of the query as a DataSet. ";
	1111
1110	1112	%feature("docstring") gdcm::BaseQuery::GetSOPInstanceUID "std::string gdcm::BaseQuery::GetSOPInstanceUID() const ";
1111	1113
1112	1114	%feature("docstring") gdcm::BaseQuery::Print "void
1113	1115	gdcm::BaseQuery::Print(std::ostream &os) const override ";
	1116
	1117	%feature("docstring") gdcm::BaseQuery::SetSearchParameter "void
	1118	gdcm::BaseQuery::SetSearchParameter(const std::string &inKeyword,
	1119	const std::string &inValue) ";
1114	1120
1115	1121	%feature("docstring") gdcm::BaseQuery::SetSearchParameter "void
1116	1122	gdcm::BaseQuery::SetSearchParameter(const Tag &inTag, const
1117	1123	std::string &inValue) ";
1118
1119		%feature("docstring") gdcm::BaseQuery::SetSearchParameter "void
1120		gdcm::BaseQuery::SetSearchParameter(const std::string &inKeyword,
1121		const std::string &inValue) ";
1122	1124
1123	1125	%feature("docstring") gdcm::BaseQuery::SetSOPInstanceUID "void
1124	1126	gdcm::BaseQuery::SetSOPInstanceUID(const std::string &iSopInstanceUID)

1285	1287	%feature("docstring") gdcm::Bitmap::GetColumns "unsigned int
1286	1288	gdcm::Bitmap::GetColumns() const ";
1287	1289
	1290	%feature("docstring") gdcm::Bitmap::GetDataElement "DataElement&
	1291	gdcm::Bitmap::GetDataElement() ";
	1292
1288	1293	%feature("docstring") gdcm::Bitmap::GetDataElement "const
1289	1294	DataElement& gdcm::Bitmap::GetDataElement() const ";
1290	1295
1291		%feature("docstring") gdcm::Bitmap::GetDataElement "DataElement&
1292		gdcm::Bitmap::GetDataElement() ";
1293
1294	1296	%feature("docstring") gdcm::Bitmap::GetDimension "unsigned int
1295	1297	gdcm::Bitmap::GetDimension(unsigned int idx) const ";
1296	1298

1300	1302	Return the dimension of the pixel data, first dimension (x), then 2nd
1301	1303	(y), then 3rd (z)... ";
1302	1304
	1305	%feature("docstring") gdcm::Bitmap::GetLUT "LookupTable&
	1306	gdcm::Bitmap::GetLUT() ";
	1307
1303	1308	%feature("docstring") gdcm::Bitmap::GetLUT "const LookupTable&
1304	1309	gdcm::Bitmap::GetLUT() const ";
1305	1310
1306		%feature("docstring") gdcm::Bitmap::GetLUT "LookupTable&
1307		gdcm::Bitmap::GetLUT() ";
1308
1309	1311	%feature("docstring") gdcm::Bitmap::GetNeedByteSwap "bool
1310	1312	gdcm::Bitmap::GetNeedByteSwap() const
1311	1313

1322	1324
1323	1325	return the photometric interpretation ";
1324	1326
	1327	%feature("docstring") gdcm::Bitmap::GetPixelFormat "PixelFormat&
	1328	gdcm::Bitmap::GetPixelFormat() ";
	1329
1325	1330	%feature("docstring") gdcm::Bitmap::GetPixelFormat "const
1326	1331	PixelFormat& gdcm::Bitmap::GetPixelFormat() const
1327	1332
1328	1333	Get/Set PixelFormat. ";
1329
1330		%feature("docstring") gdcm::Bitmap::GetPixelFormat "PixelFormat&
1331		gdcm::Bitmap::GetPixelFormat() ";
1332	1334
1333	1335	%feature("docstring") gdcm::Bitmap::GetPlanarConfiguration "unsigned
1334	1336	int gdcm::Bitmap::GetPlanarConfiguration() const

1559	1561
1560	1562	C++ includes: gdcmByteSwapFilter.h ";
1561	1563
	1564	%feature("docstring") gdcm::ByteSwapFilter::ByteSwapFilter "gdcm::ByteSwapFilter::ByteSwapFilter(const ByteSwapFilter &)=delete ";
	1565
1562	1566	%feature("docstring") gdcm::ByteSwapFilter::ByteSwapFilter "gdcm::ByteSwapFilter::ByteSwapFilter(DataSet &ds) ";
1563
1564		%feature("docstring") gdcm::ByteSwapFilter::ByteSwapFilter "gdcm::ByteSwapFilter::ByteSwapFilter(const ByteSwapFilter &)=delete ";
1565	1567
1566	1568	%feature("docstring") gdcm::ByteSwapFilter::~ByteSwapFilter "gdcm::ByteSwapFilter::~ByteSwapFilter() ";
1567	1569

1610	1612	%feature("docstring") gdcm::ByteValue::GetPointer "const char*
1611	1613	gdcm::ByteValue::GetPointer() const ";
1612	1614
	1615	%feature("docstring") gdcm::ByteValue::GetVoidPointer "void*
	1616	gdcm::ByteValue::GetVoidPointer() ";
	1617
1613	1618	%feature("docstring") gdcm::ByteValue::GetVoidPointer "const void*
1614	1619	gdcm::ByteValue::GetVoidPointer() const ";
1615
1616		%feature("docstring") gdcm::ByteValue::GetVoidPointer "void*
1617		gdcm::ByteValue::GetVoidPointer() ";
1618	1620
1619	1621	%feature("docstring") gdcm::ByteValue::IsEmpty "bool
1620	1622	gdcm::ByteValue::IsEmpty() const ";

1648	1650	To Print Values in Native DICOM format ";
1649	1651
1650	1652	%feature("docstring") gdcm::ByteValue::Read "std::istream&
	1653	gdcm::ByteValue::Read(std::istream &is) ";
	1654
	1655	%feature("docstring") gdcm::ByteValue::Read "std::istream&
1651	1656	gdcm::ByteValue::Read(std::istream &is, bool readvalues=true) ";
1652
1653		%feature("docstring") gdcm::ByteValue::Read "std::istream&
1654		gdcm::ByteValue::Read(std::istream &is) ";
1655	1657
1656	1658	%feature("docstring") gdcm::ByteValue::SetLength "void
1657	1659	gdcm::ByteValue::SetLength(VL vl) override ";
1658	1660
1659		%feature("docstring") gdcm::ByteValue::Write "std::ostream const&
	1661	%feature("docstring") gdcm::ByteValue::Write "const std::ostream&
1660	1662	gdcm::ByteValue::Write(std::ostream &os) const ";
1661	1663
1662		%feature("docstring") gdcm::ByteValue::Write "std::ostream const&
	1664	%feature("docstring") gdcm::ByteValue::Write "const std::ostream&
1663	1665	gdcm::ByteValue::Write(std::ostream &os) const ";
1664	1666
1665	1667	%feature("docstring") gdcm::ByteValue::WriteBuffer "bool

1897	1899
1898	1900	CodeString constructors. ";
1899	1901
1900		%feature("docstring") gdcm::CodeString::CodeString "gdcm::CodeString::CodeString(const value_type *s) ";
1901
1902		%feature("docstring") gdcm::CodeString::CodeString "gdcm::CodeString::CodeString(const value_type *s, size_type n) ";
1903
1904	1902	%feature("docstring") gdcm::CodeString::CodeString "gdcm::CodeString::CodeString(const InternalClass &s, size_type pos=0,
1905	1903	size_type n=InternalClass::npos) ";
1906	1904
	1905	%feature("docstring") gdcm::CodeString::CodeString "gdcm::CodeString::CodeString(const value_type *s) ";
	1906
	1907	%feature("docstring") gdcm::CodeString::CodeString "gdcm::CodeString::CodeString(const value_type *s, size_type n) ";
	1908
1907	1909	%feature("docstring") gdcm::CodeString::GetAsString "std::string
1908	1910	gdcm::CodeString::GetAsString() const
1909	1911

1930	1932	C++ includes: gdcmCommand.h ";
1931	1933
1932	1934	%feature("docstring") gdcm::Command::Command "gdcm::Command::Command(const Command &)=delete ";
1933
1934		%feature("docstring") gdcm::Command::Execute "virtual void
1935		gdcm::Command::Execute(Subject *caller, const Event &event)=0
1936
1937		Abstract method that defines the action to be taken by the command. ";
1938	1935
1939	1936	%feature("docstring") gdcm::Command::Execute "virtual void
1940	1937	gdcm::Command::Execute(const Subject *caller, const Event &event)=0

1942	1939	Abstract method that defines the action to be taken by the command.
1943	1940	This variant is expected to be used when requests comes from a const
1944	1941	Object ";
	1942
	1943	%feature("docstring") gdcm::Command::Execute "virtual void
	1944	gdcm::Command::Execute(Subject *caller, const Event &event)=0
	1945
	1946	Abstract method that defines the action to be taken by the command. ";
1945	1947
1946	1948
1947	1949	// File: classgdcm_1_1CommandDataSet.xml

2130	2132
2131	2133	C++ includes: gdcmCSAElement.h ";
2132	2134
	2135	%feature("docstring") gdcm::CSAElement::CSAElement "gdcm::CSAElement::CSAElement(const CSAElement &_val) ";
	2136
2133	2137	%feature("docstring") gdcm::CSAElement::CSAElement "gdcm::CSAElement::CSAElement(unsigned int kf=0) ";
2134
2135		%feature("docstring") gdcm::CSAElement::CSAElement "gdcm::CSAElement::CSAElement(const CSAElement &_val) ";
2136	2138
2137	2139	%feature("docstring") gdcm::CSAElement::GetByteValue "const
2138	2140	ByteValue* gdcm::CSAElement::GetByteValue() const

2160	2162
2161	2163	Set/Get SyngoDT. ";
2162	2164
2163		%feature("docstring") gdcm::CSAElement::GetValue "Value const&
2164		gdcm::CSAElement::GetValue() const
2165
2166		Set/Get Value (bytes array, SQ of items, SQ of fragments): ";
2167
2168	2165	%feature("docstring") gdcm::CSAElement::GetValue "Value&
2169	2166	gdcm::CSAElement::GetValue() ";
2170	2167
	2168	%feature("docstring") gdcm::CSAElement::GetValue "const Value&
	2169	gdcm::CSAElement::GetValue() const
	2170
	2171	Set/Get Value (bytes array, SQ of items, SQ of fragments): ";
	2172
2171	2173	%feature("docstring") gdcm::CSAElement::GetVM "const VM&
2172	2174	gdcm::CSAElement::GetVM() const
2173	2175
2174	2176	Set/Get VM. ";
2175	2177
2176		%feature("docstring") gdcm::CSAElement::GetVR "VR const&
	2178	%feature("docstring") gdcm::CSAElement::GetVR "const VR&
2177	2179	gdcm::CSAElement::GetVR() const
2178	2180
2179	2181	Set/Get VR. ";

2425	2427	%feature("docstring") gdcm::Curve::GetAsPoints "void
2426	2428	gdcm::Curve::GetAsPoints(float *array) const ";
2427	2429
2428		%feature("docstring") gdcm::Curve::GetCurveDataDescriptor "std::vector<unsigned short> const&
2429		gdcm::Curve::GetCurveDataDescriptor() const ";
	2430	%feature("docstring") gdcm::Curve::GetCurveDataDescriptor "const
	2431	std::vector<unsigned short>& gdcm::Curve::GetCurveDataDescriptor()
	2432	const ";
2430	2433
2431	2434	%feature("docstring") gdcm::Curve::GetDataValueRepresentation "unsigned short gdcm::Curve::GetDataValueRepresentation() const ";
2432	2435

2511	2514
2512	2515	C++ includes: gdcmDataElement.h ";
2513	2516
	2517	%feature("docstring") gdcm::DataElement::DataElement "gdcm::DataElement::DataElement(const DataElement &_val) ";
	2518
2514	2519	%feature("docstring") gdcm::DataElement::DataElement "gdcm::DataElement::DataElement(const Tag &t=Tag(0), const VL &vl=0,
2515	2520	const VR &vr=VR::INVALID) ";
2516	2521
2517		%feature("docstring") gdcm::DataElement::DataElement "gdcm::DataElement::DataElement(const DataElement &_val) ";
2518
2519	2522	%feature("docstring") gdcm::DataElement::Clear "void
2520	2523	gdcm::DataElement::Clear()
2521	2524

2535	2538	%feature("docstring") gdcm::DataElement::GetLength "VL
2536	2539	gdcm::DataElement::GetLength() const ";
2537	2540
	2541	%feature("docstring") gdcm::DataElement::GetSequenceOfFragments "SequenceOfFragments* gdcm::DataElement::GetSequenceOfFragments() ";
	2542
2538	2543	%feature("docstring") gdcm::DataElement::GetSequenceOfFragments "const SequenceOfFragments* gdcm::DataElement::GetSequenceOfFragments()
2539	2544	const
2540	2545
2541	2546	Return the Value of DataElement as a Sequence Of Fragments (if
2542	2547	possible) WARNING: : You need to check for NULL return value ";
2543	2548
2544		%feature("docstring") gdcm::DataElement::GetSequenceOfFragments "SequenceOfFragments* gdcm::DataElement::GetSequenceOfFragments() ";
	2549	%feature("docstring") gdcm::DataElement::GetTag "Tag&
	2550	gdcm::DataElement::GetTag() ";
2545	2551
2546	2552	%feature("docstring") gdcm::DataElement::GetTag "const Tag&
2547	2553	gdcm::DataElement::GetTag() const
2548	2554
2549	2555	Get Tag. ";
2550	2556
2551		%feature("docstring") gdcm::DataElement::GetTag "Tag&
2552		gdcm::DataElement::GetTag() ";
2553
2554		%feature("docstring") gdcm::DataElement::GetValue "Value const&
2555		gdcm::DataElement::GetValue() const
2556
2557		Set/Get Value (bytes array, SQ of items, SQ of fragments): ";
2558
2559	2557	%feature("docstring") gdcm::DataElement::GetValue "Value&
2560	2558	gdcm::DataElement::GetValue() ";
	2559
	2560	%feature("docstring") gdcm::DataElement::GetValue "const Value&
	2561	gdcm::DataElement::GetValue() const
	2562
	2563	Set/Get Value (bytes array, SQ of items, SQ of fragments): ";
2561	2564
2562	2565	%feature("docstring") gdcm::DataElement::GetValueAsSQ "SmartPointer<SequenceOfItems> gdcm::DataElement::GetValueAsSQ() const
2563	2566

2570	2573	for instance: SmartPointer<SequenceOfItems> sqi = de.GetValueAsSQ();
2571	2574	";
2572	2575
	2576	%feature("docstring") gdcm::DataElement::GetVL "VL&
	2577	gdcm::DataElement::GetVL() ";
	2578
2573	2579	%feature("docstring") gdcm::DataElement::GetVL "const VL&
2574	2580	gdcm::DataElement::GetVL() const
2575	2581
2576	2582	Get VL. ";
2577	2583
2578		%feature("docstring") gdcm::DataElement::GetVL "VL&
2579		gdcm::DataElement::GetVL() ";
2580
2581		%feature("docstring") gdcm::DataElement::GetVR "VR const&
	2584	%feature("docstring") gdcm::DataElement::GetVR "const VR&
2582	2585	gdcm::DataElement::GetVR() const
2583	2586
2584	2587	Get VR do not set VR::SQ on bytevalue data element ";

2718	2721
2719	2722	C++ includes: gdcmDataSet.h ";
2720	2723
	2724	%feature("docstring") gdcm::DataSet::Begin "Iterator
	2725	gdcm::DataSet::Begin() ";
	2726
2721	2727	%feature("docstring") gdcm::DataSet::Begin "ConstIterator
2722	2728	gdcm::DataSet::Begin() const ";
2723	2729
2724		%feature("docstring") gdcm::DataSet::Begin "Iterator
2725		gdcm::DataSet::Begin() ";
2726
2727	2730	%feature("docstring") gdcm::DataSet::Clear "void
2728	2731	gdcm::DataSet::Clear() ";
2729	2732
2730	2733	%feature("docstring") gdcm::DataSet::ComputeGroupLength "unsigned
2731	2734	int gdcm::DataSet::ComputeGroupLength(Tag const &tag) const ";
2732	2735
	2736	%feature("docstring") gdcm::DataSet::End "Iterator
	2737	gdcm::DataSet::End() ";
	2738
2733	2739	%feature("docstring") gdcm::DataSet::End "ConstIterator
2734	2740	gdcm::DataSet::End() const ";
2735	2741
2736		%feature("docstring") gdcm::DataSet::End "Iterator
2737		gdcm::DataSet::End() ";
2738
2739	2742	%feature("docstring") gdcm::DataSet::FindDataElement "bool
2740	2743	gdcm::DataSet::FindDataElement(const PrivateTag &t) const
2741	2744

2748	2751	DataElement& gdcm::DataSet::FindNextDataElement(const Tag &t) const ";
2749	2752
2750	2753	%feature("docstring") gdcm::DataSet::GetDataElement "const
	2754	DataElement& gdcm::DataSet::GetDataElement(const PrivateTag &t) const
	2755
	2756	Return the dataelement. ";
	2757
	2758	%feature("docstring") gdcm::DataSet::GetDataElement "const
2751	2759	DataElement& gdcm::DataSet::GetDataElement(const Tag &t) const
2752	2760
2753	2761	Return the DataElement with Tag 't' WARNING: : This only search at
2754	2762	the 'root level' of the DataSet ";
2755	2763
2756		%feature("docstring") gdcm::DataSet::GetDataElement "const
2757		DataElement& gdcm::DataSet::GetDataElement(const PrivateTag &t) const
2758
2759		Return the dataelement. ";
	2764	%feature("docstring") gdcm::DataSet::GetDES "DataElementSet&
	2765	gdcm::DataSet::GetDES() ";
2760	2766
2761	2767	%feature("docstring") gdcm::DataSet::GetDES "const DataElementSet&
2762	2768	gdcm::DataSet::GetDES() const ";
2763
2764		%feature("docstring") gdcm::DataSet::GetDES "DataElementSet&
2765		gdcm::DataSet::GetDES() ";
2766	2769
2767	2770	%feature("docstring") gdcm::DataSet::GetLength "VL
2768	2771	gdcm::DataSet::GetLength() const ";

2840	2843	%feature("docstring") gdcm::DataSet::Size "SizeType
2841	2844	gdcm::DataSet::Size() const ";
2842	2845
2843		%feature("docstring") gdcm::DataSet::Write "std::ostream const&
	2846	%feature("docstring") gdcm::DataSet::Write "const std::ostream&
2844	2847	gdcm::DataSet::Write(std::ostream &os) const ";
2845	2848
2846	2849

2855	2858
2856	2859	C++ includes: gdcmDataSetEvent.h ";
2857	2860
	2861	%feature("docstring") gdcm::DataSetEvent::DataSetEvent "gdcm::DataSetEvent::DataSetEvent(const Self &s) ";
	2862
2858	2863	%feature("docstring") gdcm::DataSetEvent::DataSetEvent "gdcm::DataSetEvent::DataSetEvent(DataSet const *ds=nullptr) ";
2859
2860		%feature("docstring") gdcm::DataSetEvent::DataSetEvent "gdcm::DataSetEvent::DataSetEvent(const Self &s) ";
2861	2864
2862	2865	%feature("docstring") gdcm::DataSetEvent::~DataSetEvent "gdcm::DataSetEvent::~DataSetEvent() override=default ";
2863	2866

2865	2868	gdcm::DataSetEvent::CheckEvent(const ::gdcm::Event *e) const override
2866	2869	";
2867	2870
2868		%feature("docstring") gdcm::DataSetEvent::GetDataSet "DataSet const&
	2871	%feature("docstring") gdcm::DataSetEvent::GetDataSet "const DataSet&
2869	2872	gdcm::DataSetEvent::GetDataSet() const ";
2870	2873
2871	2874	%feature("docstring") gdcm::DataSetEvent::GetEventName "const char*

2950	2953	%feature("docstring") gdcm::Defs::GetIODFromFile "const IOD&
2951	2954	gdcm::Defs::GetIODFromFile(const File &file) const ";
2952	2955
	2956	%feature("docstring") gdcm::Defs::GetIODs "IODs&
	2957	gdcm::Defs::GetIODs() ";
	2958
2953	2959	%feature("docstring") gdcm::Defs::GetIODs "const IODs&
2954	2960	gdcm::Defs::GetIODs() const ";
2955	2961
2956		%feature("docstring") gdcm::Defs::GetIODs "IODs&
2957		gdcm::Defs::GetIODs() ";
	2962	%feature("docstring") gdcm::Defs::GetMacros "Macros&
	2963	gdcm::Defs::GetMacros() ";
2958	2964
2959	2965	%feature("docstring") gdcm::Defs::GetMacros "const Macros&
2960	2966	gdcm::Defs::GetMacros() const

2963	2969	WG to re-use Tables. Macros are conviently wraped within Modules. See
2964	2970	gdcm::Module API directly ";
2965	2971
2966		%feature("docstring") gdcm::Defs::GetMacros "Macros&
2967		gdcm::Defs::GetMacros() ";
	2972	%feature("docstring") gdcm::Defs::GetModules "Modules&
	2973	gdcm::Defs::GetModules() ";
2968	2974
2969	2975	%feature("docstring") gdcm::Defs::GetModules "const Modules&
2970	2976	gdcm::Defs::GetModules() const ";
2971	2977
2972		%feature("docstring") gdcm::Defs::GetModules "Modules&
2973		gdcm::Defs::GetModules() ";
2974
2975	2978	%feature("docstring") gdcm::Defs::GetTypeFromTag "Type
2976	2979	gdcm::Defs::GetTypeFromTag(const File &file, const Tag &tag) const ";
2977	2980

2979	2982	gdcm::Defs::IsEmpty() const ";
2980	2983
2981	2984	%feature("docstring") gdcm::Defs::Verify "bool
	2985	gdcm::Defs::Verify(const DataSet &ds) const ";
	2986
	2987	%feature("docstring") gdcm::Defs::Verify "bool
2982	2988	gdcm::Defs::Verify(const File &file) const ";
2983
2984		%feature("docstring") gdcm::Defs::Verify "bool
2985		gdcm::Defs::Verify(const DataSet &ds) const ";
2986	2989
2987	2990
2988	2991	// File: classgdcm_1_1DeltaEncodingCodec.xml

3300	3303	CSAHeaderDict& gdcm::Dicts::GetCSAHeaderDict() const ";
3301	3304
3302	3305	%feature("docstring") gdcm::Dicts::GetDictEntry "const DictEntry&
	3306	gdcm::Dicts::GetDictEntry(const PrivateTag &tag) const ";
	3307
	3308	%feature("docstring") gdcm::Dicts::GetDictEntry "const DictEntry&
3303	3309	gdcm::Dicts::GetDictEntry(const Tag &tag, const char *owner=nullptr)
3304	3310	const
3305	3311

3309	3315	WARNING: owner need to be set to appropriate owner for call to work.
3310	3316	see ";
3311	3317
3312		%feature("docstring") gdcm::Dicts::GetDictEntry "const DictEntry&
3313		gdcm::Dicts::GetDictEntry(const PrivateTag &tag) const ";
	3318	%feature("docstring") gdcm::Dicts::GetPrivateDict "PrivateDict&
	3319	gdcm::Dicts::GetPrivateDict() ";
3314	3320
3315	3321	%feature("docstring") gdcm::Dicts::GetPrivateDict "const
3316	3322	PrivateDict& gdcm::Dicts::GetPrivateDict() const ";
3317
3318		%feature("docstring") gdcm::Dicts::GetPrivateDict "PrivateDict&
3319		gdcm::Dicts::GetPrivateDict() ";
3320	3323
3321	3324	%feature("docstring") gdcm::Dicts::GetPublicDict "const Dict&
3322	3325	gdcm::Dicts::GetPublicDict() const ";

3414	3417
3415	3418	%feature("docstring") gdcm::Directory::~Directory "gdcm::Directory::~Directory()=default ";
3416	3419
3417		%feature("docstring") gdcm::Directory::GetDirectories "FilenamesType
3418		const& gdcm::Directory::GetDirectories() const
	3420	%feature("docstring") gdcm::Directory::GetDirectories "const
	3421	FilenamesType& gdcm::Directory::GetDirectories() const
3419	3422
3420	3423	Return the Directories traversed. ";
3421	3424
3422		%feature("docstring") gdcm::Directory::GetFilenames "FilenamesType
3423		const& gdcm::Directory::GetFilenames() const
	3425	%feature("docstring") gdcm::Directory::GetFilenames "const
	3426	FilenamesType& gdcm::Directory::GetFilenames() const
3424	3427
3425	3428	Set/Get the file names within the directory. ";
3426	3429
3427		%feature("docstring") gdcm::Directory::GetToplevel "FilenameType
3428		const& gdcm::Directory::GetToplevel() const
	3430	%feature("docstring") gdcm::Directory::GetToplevel "const
	3431	FilenameType& gdcm::Directory::GetToplevel() const
3429	3432
3430	3433	Get the name of the toplevel directory. ";
3431	3434

3500	3503	%feature("docstring") gdcm::Element::GetLength "unsigned long
3501	3504	gdcm::Element< TVR, TVM >::GetLength() const ";
3502	3505
	3506	%feature("docstring") gdcm::Element::GetValue "VRToType<TVR>::Type&
	3507	gdcm::Element< TVR, TVM >::GetValue(unsigned int idx=0) ";
	3508
3503	3509	%feature("docstring") gdcm::Element::GetValue "const
3504	3510	VRToType<TVR>::Type& gdcm::Element< TVR, TVM >::GetValue(unsigned int
3505	3511	idx=0) const ";
3506	3512
3507		%feature("docstring") gdcm::Element::GetValue "VRToType<TVR>::Type&
3508		gdcm::Element< TVR, TVM >::GetValue(unsigned int idx=0) ";
3509
3510	3513	%feature("docstring") gdcm::Element::GetValues "const
3511	3514	VRToType<TVR>::Type* gdcm::Element< TVR, TVM >::GetValues() const ";
3512	3515

3560	3563	unsigned long gdcm::Element< TVR, VM::VM1_n >::GetLength() const ";
3561	3564
3562	3565	%feature("docstring") gdcm::Element< TVR, VM::VM1_n >::GetValue "
	3566	VRToType<TVR>::Type& gdcm::Element< TVR, VM::VM1_n
	3567	>::GetValue(unsigned int idx=0) ";
	3568
	3569	%feature("docstring") gdcm::Element< TVR, VM::VM1_n >::GetValue "
3563	3570	const VRToType<TVR>::Type& gdcm::Element< TVR, VM::VM1_n
3564	3571	>::GetValue(unsigned int idx=0) const ";
3565
3566		%feature("docstring") gdcm::Element< TVR, VM::VM1_n >::GetValue "
3567		VRToType<TVR>::Type& gdcm::Element< TVR, VM::VM1_n
3568		>::GetValue(unsigned int idx=0) ";
3569	3572
3570	3573	%feature("docstring") gdcm::Element< TVR, VM::VM1_n >::Print " void
3571	3574	gdcm::Element< TVR, VM::VM1_n >::Print(std::ostream &_os) const ";

3798	3801
3799	3802
3800	3803	// File: classgdcm_1_1EquipmentManufacturer.xml
3801		%feature("docstring") gdcm::EquipmentManufacturer "C++ includes:
3802		gdcmEquipmentManufacturer.h ";
	3804	%feature("docstring") gdcm::EquipmentManufacturer "
	3805
	3806	C++ includes: gdcmEquipmentManufacturer.h ";
3803	3807
3804	3808
3805	3809	// File: classgdcm_1_1Event.xml

3825	3829	Check if given event matches or derives from this event. ";
3826	3830
3827	3831	%feature("docstring") gdcm::Event::GetEventName "virtual const char*
3828		gdcm::Event::GetEventName(void) const =0
	3832	gdcm::Event::GetEventName() const =0
3829	3833
3830	3834	Return the StringName associated with the event. ";
3831	3835

3966	3970	%feature("docstring") gdcm::File::~File "gdcm::File::~File()
3967	3971	override ";
3968	3972
	3973	%feature("docstring") gdcm::File::GetDataSet "DataSet&
	3974	gdcm::File::GetDataSet()
	3975
	3976	Get Data Set. ";
	3977
3969	3978	%feature("docstring") gdcm::File::GetDataSet "const DataSet&
3970	3979	gdcm::File::GetDataSet() const
3971	3980
3972	3981	Get Data Set. ";
3973	3982
3974		%feature("docstring") gdcm::File::GetDataSet "DataSet&
3975		gdcm::File::GetDataSet()
3976
3977		Get Data Set. ";
	3983	%feature("docstring") gdcm::File::GetHeader "FileMetaInformation&
	3984	gdcm::File::GetHeader()
	3985
	3986	Get File Meta Information. ";
3978	3987
3979	3988	%feature("docstring") gdcm::File::GetHeader "const
3980	3989	FileMetaInformation& gdcm::File::GetHeader() const
3981	3990
3982	3991	Get File Meta Information. ";
3983	3992
3984		%feature("docstring") gdcm::File::GetHeader "FileMetaInformation&
3985		gdcm::File::GetHeader()
3986
3987		Get File Meta Information. ";
3988
3989	3993	%feature("docstring") gdcm::File::Read "std::istream&
3990	3994	gdcm::File::Read(std::istream &is)
3991	3995

4001	4005
4002	4006	Set File Meta Information. ";
4003	4007
4004		%feature("docstring") gdcm::File::Write "std::ostream const&
	4008	%feature("docstring") gdcm::File::Write "const std::ostream&
4005	4009	gdcm::File::Write(std::ostream &os) const
4006	4010
4007	4011	Write. ";

4049	4053	remove a tag (even a SQ can be removed) ";
4050	4054
4051	4055	%feature("docstring") gdcm::FileAnonymizer::Replace "void
	4056	gdcm::FileAnonymizer::Replace(Tag const &t, const char *value_data, VL
	4057	const &vl)
	4058
	4059	when the value contains \\\\0, it is a good idea to specify the
	4060	length. This function is required when dealing with VRBINARY tag ";
	4061
	4062	%feature("docstring") gdcm::FileAnonymizer::Replace "void
4052	4063	gdcm::FileAnonymizer::Replace(Tag const &t, const char *value_str)
4053	4064
4054	4065	Replace tag with another value, if tag is not found it will be
4055	4066	created: WARNING: this function can only execute if tag is a VRASCII
4056	4067	WARNING: Do not ever try to write a value in a SQ Data Element ! ";
4057
4058		%feature("docstring") gdcm::FileAnonymizer::Replace "void
4059		gdcm::FileAnonymizer::Replace(Tag const &t, const char *value_data, VL
4060		const &vl)
4061
4062		when the value contains \\\\0, it is a good idea to specify the
4063		length. This function is required when dealing with VRBINARY tag ";
4064	4068
4065	4069	%feature("docstring") gdcm::FileAnonymizer::SetInputFileName "void
4066	4070	gdcm::FileAnonymizer::SetInputFileName(const char *filename_native)

4161	4165
4162	4166	%feature("docstring") gdcm::FileDecompressLookupTable::GetFile "File& gdcm::FileDecompressLookupTable::GetFile() ";
4163	4167
	4168	%feature("docstring") gdcm::FileDecompressLookupTable::GetPixmap "Pixmap& gdcm::FileDecompressLookupTable::GetPixmap() ";
	4169
4164	4170	%feature("docstring") gdcm::FileDecompressLookupTable::GetPixmap "const Pixmap& gdcm::FileDecompressLookupTable::GetPixmap() const ";
4165
4166		%feature("docstring") gdcm::FileDecompressLookupTable::GetPixmap "Pixmap& gdcm::FileDecompressLookupTable::GetPixmap() ";
4167	4171
4168	4172	%feature("docstring") gdcm::FileDecompressLookupTable::SetFile "void
4169	4173	gdcm::FileDecompressLookupTable::SetFile(const File &f)

4368	4372	"TransferSyntax::NegociatedType
4369	4373	gdcm::FileMetaInformation::GetMetaInformationTS() const ";
4370	4374
	4375	%feature("docstring") gdcm::FileMetaInformation::GetPreamble "Preamble& gdcm::FileMetaInformation::GetPreamble() ";
	4376
4371	4377	%feature("docstring") gdcm::FileMetaInformation::GetPreamble "const
4372	4378	Preamble& gdcm::FileMetaInformation::GetPreamble() const
4373	4379
4374	4380	Get Preamble. ";
4375
4376		%feature("docstring") gdcm::FileMetaInformation::GetPreamble "Preamble& gdcm::FileMetaInformation::GetPreamble() ";
4377	4381
4378	4382	%feature("docstring") gdcm::FileMetaInformation::Insert "void
4379	4383	gdcm::FileMetaInformation::Insert(const DataElement &de) ";

4529	4533
4530	4534	Get a particular filename (call after Generate) ";
4531	4535
4532		%feature("docstring") gdcm::FilenameGenerator::GetFilenames "FilenamesType const& gdcm::FilenameGenerator::GetFilenames() const
	4536	%feature("docstring") gdcm::FilenameGenerator::GetFilenames "const
	4537	FilenamesType& gdcm::FilenameGenerator::GetFilenames() const
4533	4538
4534	4539	Return all filenames. ";
4535	4540

4567	4572
4568	4573	%feature("docstring") gdcm::FileSet::FileSet "gdcm::FileSet::FileSet() ";
4569	4574
	4575	%feature("docstring") gdcm::FileSet::AddFile "bool
	4576	gdcm::FileSet::AddFile(const char *filename)
	4577
	4578	Add a file 'filename' to the list of files. Return true on success,
	4579	false in case filename could not be found on system. ";
	4580
4570	4581	%feature("docstring") gdcm::FileSet::AddFile "void
4571	4582	gdcm::FileSet::AddFile(File const &)
4572	4583
4573	4584	Deprecated . Does nothing ";
4574	4585
4575		%feature("docstring") gdcm::FileSet::AddFile "bool
4576		gdcm::FileSet::AddFile(const char *filename)
4577
4578		Add a file 'filename' to the list of files. Return true on success,
4579		false in case filename could not be found on system. ";
4580
4581		%feature("docstring") gdcm::FileSet::GetFiles "FilesType const&
	4586	%feature("docstring") gdcm::FileSet::GetFiles "const FilesType&
4582	4587	gdcm::FileSet::GetFiles() const ";
4583	4588
4584	4589	%feature("docstring") gdcm::FileSet::SetFiles "void

4850	4855
4851	4856	Append path at the end of the path list WARNING: not thread safe ! ";
4852	4857
4853		%feature("docstring") gdcm::Global::GetDefs "Defs const&
	4858	%feature("docstring") gdcm::Global::GetDefs "const Defs&
4854	4859	gdcm::Global::GetDefs() const
4855	4860
4856	4861	retrieve the default/internal (Part 3) You need to explicitly call
4857	4862	LoadResourcesFiles before ";
4858	4863
4859		%feature("docstring") gdcm::Global::GetDicts "Dicts const&
	4864	%feature("docstring") gdcm::Global::GetDicts "Dicts&
	4865	gdcm::Global::GetDicts() ";
	4866
	4867	%feature("docstring") gdcm::Global::GetDicts "const Dicts&
4860	4868	gdcm::Global::GetDicts() const
4861	4869
4862	4870	retrieve the default/internal dicts (Part 6) This dict is filled up at
4863	4871	load time ";
4864
4865		%feature("docstring") gdcm::Global::GetDicts "Dicts&
4866		gdcm::Global::GetDicts() ";
4867	4872
4868	4873	%feature("docstring") gdcm::Global::LoadResourcesFiles "bool
4869	4874	gdcm::Global::LoadResourcesFiles()

4894	4899
4895	4900	%feature("docstring") gdcm::GroupDict::~GroupDict "gdcm::GroupDict::~GroupDict()=default ";
4896	4901
4897		%feature("docstring") gdcm::GroupDict::GetAbbreviation "std::string
4898		const& gdcm::GroupDict::GetAbbreviation(uint16_t num) const ";
4899
4900		%feature("docstring") gdcm::GroupDict::GetName "std::string const&
	4902	%feature("docstring") gdcm::GroupDict::GetAbbreviation "const
	4903	std::string& gdcm::GroupDict::GetAbbreviation(uint16_t num) const ";
	4904
	4905	%feature("docstring") gdcm::GroupDict::GetName "const std::string&
4901	4906	gdcm::GroupDict::GetName(uint16_t num) const ";
4902	4907
4903	4908	%feature("docstring") gdcm::GroupDict::Size "size_t

5129	5134	print ";
5130	5135
5131	5136	%feature("docstring") gdcm::Image::SetDirectionCosines "void
	5137	gdcm::Image::SetDirectionCosines(const double dircos[6]) ";
	5138
	5139	%feature("docstring") gdcm::Image::SetDirectionCosines "void
5132	5140	gdcm::Image::SetDirectionCosines(const float dircos[6]) ";
5133
5134		%feature("docstring") gdcm::Image::SetDirectionCosines "void
5135		gdcm::Image::SetDirectionCosines(const double dircos[6]) ";
5136	5141
5137	5142	%feature("docstring") gdcm::Image::SetDirectionCosines "void
5138	5143	gdcm::Image::SetDirectionCosines(unsigned int idx, double dircos) ";

5143	5148	intercept ";
5144	5149
5145	5150	%feature("docstring") gdcm::Image::SetOrigin "void
	5151	gdcm::Image::SetOrigin(const double origin[3]) ";
	5152
	5153	%feature("docstring") gdcm::Image::SetOrigin "void
5146	5154	gdcm::Image::SetOrigin(const float origin[3]) ";
5147
5148		%feature("docstring") gdcm::Image::SetOrigin "void
5149		gdcm::Image::SetOrigin(const double origin[3]) ";
5150	5155
5151	5156	%feature("docstring") gdcm::Image::SetOrigin "void
5152	5157	gdcm::Image::SetOrigin(unsigned int idx, double ori) ";

5407	5412	gdcm::ImageCodec::IsLossy() const ";
5408	5413
5409	5414	%feature("docstring") gdcm::ImageCodec::SetDimensions "void
	5415	gdcm::ImageCodec::SetDimensions(const std::vector< unsigned int > &d)
	5416	";
	5417
	5418	%feature("docstring") gdcm::ImageCodec::SetDimensions "void
5410	5419	gdcm::ImageCodec::SetDimensions(const unsigned int d[3]) ";
5411
5412		%feature("docstring") gdcm::ImageCodec::SetDimensions "void
5413		gdcm::ImageCodec::SetDimensions(const std::vector< unsigned int > &d)
5414		";
5415	5420
5416	5421	%feature("docstring") gdcm::ImageCodec::SetLossyFlag "void
5417	5422	gdcm::ImageCodec::SetLossyFlag(bool l) ";

5543	5548
5544	5549	%feature("docstring") gdcm::ImageReader::~ImageReader "gdcm::ImageReader::~ImageReader() override ";
5545	5550
	5551	%feature("docstring") gdcm::ImageReader::GetImage "Image&
	5552	gdcm::ImageReader::GetImage() ";
	5553
5546	5554	%feature("docstring") gdcm::ImageReader::GetImage "const Image&
5547	5555	gdcm::ImageReader::GetImage() const
5548	5556
5549	5557	Return the read image. ";
5550
5551		%feature("docstring") gdcm::ImageReader::GetImage "Image&
5552		gdcm::ImageReader::GetImage() ";
5553	5558
5554	5559	%feature("docstring") gdcm::ImageReader::Read "bool
5555	5560	gdcm::ImageReader::Read() override

5585	5590	hold the whole uncompressed image as defined by Region region. 0 upon
5586	5591	error ";
5587	5592
5588		%feature("docstring") gdcm::ImageRegionReader::GetRegion "Region
5589		const& gdcm::ImageRegionReader::GetRegion() const ";
	5593	%feature("docstring") gdcm::ImageRegionReader::GetRegion "const
	5594	Region& gdcm::ImageRegionReader::GetRegion() const ";
5590	5595
5591	5596	%feature("docstring") gdcm::ImageRegionReader::ReadInformation "bool
5592	5597	gdcm::ImageRegionReader::ReadInformation()

5598	5603	gdcm::ImageRegionReader::ReadIntoBuffer(char *inreadbuffer, size_t
5599	5604	buflen)
5600	5605
5601		Read into buffer: false upon error ";
	5606	Read into buffer: For Python, the buflen param is deduced directly
	5607	from the input bytearray passed as parameter (function only takes one
	5608	param). false upon error ";
5602	5609
5603	5610	%feature("docstring") gdcm::ImageRegionReader::SetRegion "void
5604	5611	gdcm::ImageRegionReader::SetRegion(Region const &region)

5633	5640	%feature("docstring") gdcm::ImageWriter "
5634	5641
5635	5642	ImageWriter.
	5643
	5644	This is an extended version of the PixmapWriter. Pay attention that:
	5645	It will populate missing attribute for Secondary Capture Image Storage
	5646	instances,
	5647
	5648	It may also change an input MR Image Storage instance into a pseudo
	5649	Enhanced MR Image Storage instance whenever Modality LUT is required.
	5650
	5651	Some DataElement related to gdcm::Image may be slightly altered.
5636	5652
5637	5653	C++ includes: gdcmImageWriter.h ";
5638	5654

6028	6044	%feature("docstring") gdcm::Item::GetLength "VL
6029	6045	gdcm::Item::GetLength() const ";
6030	6046
	6047	%feature("docstring") gdcm::Item::GetNestedDataSet "DataSet&
	6048	gdcm::Item::GetNestedDataSet() ";
	6049
6031	6050	%feature("docstring") gdcm::Item::GetNestedDataSet "const DataSet&
6032	6051	gdcm::Item::GetNestedDataSet() const ";
6033
6034		%feature("docstring") gdcm::Item::GetNestedDataSet "DataSet&
6035		gdcm::Item::GetNestedDataSet() ";
6036	6052
6037	6053	%feature("docstring") gdcm::Item::InsertDataElement "void
6038	6054	gdcm::Item::InsertDataElement(const DataElement &de) ";

6332	6348	Code. ";
6333	6349
6334	6350	%feature("docstring") gdcm::JPEGLSCodec::Decode "bool
6335		gdcm::JPEGLSCodec::Decode(DataElement const &is, DataElement &os)
6336		override
6337
6338		Decode. ";
6339
6340		%feature("docstring") gdcm::JPEGLSCodec::Decode "bool
6341	6351	gdcm::JPEGLSCodec::Decode(DataElement const &in, char *outBuffer,
6342	6352	size_t inBufferLength, uint32_t inXMin, uint32_t inXMax, uint32_t
6343	6353	inYMin, uint32_t inYMax, uint32_t inZMin, uint32_t inZMax) ";
6344	6354
	6355	%feature("docstring") gdcm::JPEGLSCodec::Decode "bool
	6356	gdcm::JPEGLSCodec::Decode(DataElement const &is, DataElement &os)
	6357	override
	6358
	6359	Decode. ";
	6360
6345	6361	%feature("docstring") gdcm::JPEGLSCodec::GetBufferLength "unsigned
6346	6362	long gdcm::JPEGLSCodec::GetBufferLength() const ";
6347	6363

6440	6456
6441	6457	%feature("docstring") gdcm::LO::LO "gdcm::LO::LO() ";
6442	6458
	6459	%feature("docstring") gdcm::LO::LO "gdcm::LO::LO(const Superclass
	6460	&s, size_type pos=0, size_type n=npos) ";
	6461
6443	6462	%feature("docstring") gdcm::LO::LO "gdcm::LO::LO(const value_type
6444	6463	*s) ";
6445	6464
6446	6465	%feature("docstring") gdcm::LO::LO "gdcm::LO::LO(const value_type
6447	6466	*s, size_type n) ";
6448	6467
6449		%feature("docstring") gdcm::LO::LO "gdcm::LO::LO(const Superclass
6450		&s, size_type pos=0, size_type n=npos) ";
6451
6452	6468	%feature("docstring") gdcm::LO::IsValid "bool gdcm::LO::IsValid()
6453	6469	const ";
6454	6470

6475	6491	gdcm::LookupTable::Clear()
6476	6492
6477	6493	Clear the LUT. ";
6478
6479		%feature("docstring") gdcm::LookupTable::Decode "void
6480		gdcm::LookupTable::Decode(std::istream &is, std::ostream &os) const
6481
6482		Decode the LUT. ";
6483	6494
6484	6495	%feature("docstring") gdcm::LookupTable::Decode "bool
6485	6496	gdcm::LookupTable::Decode(char *outputbuffer, size_t outlen, const

6488	6499	Decode the LUT outputbuffer will contains the RGB decoded PALETTE
6489	6500	COLOR input image of size inlen the outputbuffer should be at least 3
6490	6501	times the size of inlen ";
	6502
	6503	%feature("docstring") gdcm::LookupTable::Decode "void
	6504	gdcm::LookupTable::Decode(std::istream &is, std::ostream &os) const
	6505
	6506	Decode the LUT. ";
6491	6507
6492	6508	%feature("docstring") gdcm::LookupTable::Decode8 "bool
6493	6509	gdcm::LookupTable::Decode8(char *outputbuffer, size_t outlen, const

6778	6794	%feature("docstring") gdcm::MemberCommand::MemberCommand "gdcm::MemberCommand< T >::MemberCommand(const Self &)=delete ";
6779	6795
6780	6796	%feature("docstring") gdcm::MemberCommand::Execute "void
	6797	gdcm::MemberCommand< T >::Execute(const Subject *caller, const Event
	6798	&event) override
	6799
	6800	Invoke the member function with a const object. ";
	6801
	6802	%feature("docstring") gdcm::MemberCommand::Execute "void
6781	6803	gdcm::MemberCommand< T >::Execute(Subject *caller, const Event &event)
6782	6804	override
6783	6805
6784	6806	Invoke the member function. ";
6785	6807
6786		%feature("docstring") gdcm::MemberCommand::Execute "void
6787		gdcm::MemberCommand< T >::Execute(const Subject *caller, const Event
6788		&event) override
6789
6790		Invoke the member function with a const object. ";
	6808	%feature("docstring") gdcm::MemberCommand::SetCallbackFunction "void
	6809	gdcm::MemberCommand< T >::SetCallbackFunction(T *object,
	6810	TConstMemberFunctionPointer memberFunction) ";
6791	6811
6792	6812	%feature("docstring") gdcm::MemberCommand::SetCallbackFunction "void
6793	6813	gdcm::MemberCommand< T >::SetCallbackFunction(T *object,

6796	6816	Run-time type information (and related methods). Set the callback
6797	6817	function along with the object that it will be invoked on. ";
6798	6818
6799		%feature("docstring") gdcm::MemberCommand::SetCallbackFunction "void
6800		gdcm::MemberCommand< T >::SetCallbackFunction(T *object,
6801		TConstMemberFunctionPointer memberFunction) ";
6802
6803	6819
6804	6820	// File: classgdcm_1_1MeshPrimitive.xml
6805	6821	%feature("docstring") gdcm::MeshPrimitive "

6823	6839	"unsigned int gdcm::MeshPrimitive::GetNumberOfPrimitivesData() const
6824	6840	";
6825	6841
	6842	%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "DataElement& gdcm::MeshPrimitive::GetPrimitiveData() ";
	6843
6826	6844	%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "const
6827	6845	DataElement& gdcm::MeshPrimitive::GetPrimitiveData() const ";
6828	6846
6829		%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "DataElement& gdcm::MeshPrimitive::GetPrimitiveData() ";
	6847	%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "DataElement& gdcm::MeshPrimitive::GetPrimitiveData(const unsigned int
	6848	idx) ";
6830	6849
6831	6850	%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "const
6832	6851	DataElement& gdcm::MeshPrimitive::GetPrimitiveData(const unsigned int
6833	6852	idx) const ";
6834	6853
6835		%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveData "DataElement& gdcm::MeshPrimitive::GetPrimitiveData(const unsigned int
6836		idx) ";
	6854	%feature("docstring") gdcm::MeshPrimitive::GetPrimitivesData "PrimitivesData& gdcm::MeshPrimitive::GetPrimitivesData() ";
6837	6855
6838	6856	%feature("docstring") gdcm::MeshPrimitive::GetPrimitivesData "const
6839	6857	PrimitivesData& gdcm::MeshPrimitive::GetPrimitivesData() const ";
6840	6858
6841		%feature("docstring") gdcm::MeshPrimitive::GetPrimitivesData "PrimitivesData& gdcm::MeshPrimitive::GetPrimitivesData() ";
6842
6843	6859	%feature("docstring") gdcm::MeshPrimitive::GetPrimitiveType "MPType
6844	6860	gdcm::MeshPrimitive::GetPrimitiveType() const ";
6845
6846		%feature("docstring") gdcm::MeshPrimitive::SetPrimitiveData "void
6847		gdcm::MeshPrimitive::SetPrimitiveData(DataElement const &de) ";
6848	6861
6849	6862	%feature("docstring") gdcm::MeshPrimitive::SetPrimitiveData "void
6850	6863	gdcm::MeshPrimitive::SetPrimitiveData(const unsigned int idx,
6851	6864	DataElement const &de) ";
	6865
	6866	%feature("docstring") gdcm::MeshPrimitive::SetPrimitiveData "void
	6867	gdcm::MeshPrimitive::SetPrimitiveData(DataElement const &de) ";
6852	6868
6853	6869	%feature("docstring") gdcm::MeshPrimitive::SetPrimitivesData "void
6854	6870	gdcm::MeshPrimitive::SetPrimitivesData(PrimitivesData const &DEs) ";

7266	7282	%feature("docstring") gdcm::NestedModuleEntries::AddModuleEntry "void gdcm::NestedModuleEntries::AddModuleEntry(const ModuleEntry &me)
7267	7283	";
7268	7284
	7285	%feature("docstring") gdcm::NestedModuleEntries::GetModuleEntry "ModuleEntry& gdcm::NestedModuleEntries::GetModuleEntry(SizeType idx)
	7286	";
	7287
7269	7288	%feature("docstring") gdcm::NestedModuleEntries::GetModuleEntry "const ModuleEntry& gdcm::NestedModuleEntries::GetModuleEntry(SizeType
7270	7289	idx) const ";
7271
7272		%feature("docstring") gdcm::NestedModuleEntries::GetModuleEntry "ModuleEntry& gdcm::NestedModuleEntries::GetModuleEntry(SizeType idx)
7273		";
7274	7290
7275	7291	%feature("docstring")
7276	7292	gdcm::NestedModuleEntries::GetNumberOfModuleEntries "SizeType

7845	7861	";
7846	7862
7847	7863	%feature("docstring")
7848		gdcm::network::PDataTFPDU::GetPresentationDataValue "PresentationDataValue const&
	7864	gdcm::network::PDataTFPDU::GetPresentationDataValue "const
	7865	PresentationDataValue&
7849	7866	gdcm::network::PDataTFPDU::GetPresentationDataValue(SizeType i) const
7850	7867	";
7851	7868

8104	8121
8105	8122	C++ includes: gdcmPixelFormat.h ";
8106	8123
8107		%feature("docstring") gdcm::PixelFormat::PixelFormat "gdcm::PixelFormat::PixelFormat(unsigned short samplesperpixel=1,
	8124	%feature("docstring") gdcm::PixelFormat::PixelFormat "gdcm::PixelFormat::PixelFormat() ";
	8125
	8126	%feature("docstring") gdcm::PixelFormat::PixelFormat "gdcm::PixelFormat::PixelFormat(ScalarType st) ";
	8127
	8128	%feature("docstring") gdcm::PixelFormat::PixelFormat "gdcm::PixelFormat::PixelFormat(unsigned short samplesperpixel,
8108	8129	unsigned short bitsallocated=8, unsigned short bitsstored=8, unsigned
8109	8130	short highbit=7, unsigned short pixelrepresentation=0) ";
8110
8111		%feature("docstring") gdcm::PixelFormat::PixelFormat "gdcm::PixelFormat::PixelFormat(ScalarType st) ";
8112	8131
8113	8132	%feature("docstring") gdcm::PixelFormat::GetBitsAllocated "unsigned
8114	8133	short gdcm::PixelFormat::GetBitsAllocated() const

8230	8249	%feature("docstring") gdcm::Pixmap::GetCurve "const Curve&
8231	8250	gdcm::Pixmap::GetCurve(size_t i=0) const ";
8232	8251
	8252	%feature("docstring") gdcm::Pixmap::GetIconImage "IconImage&
	8253	gdcm::Pixmap::GetIconImage() ";
	8254
8233	8255	%feature("docstring") gdcm::Pixmap::GetIconImage "const IconImage&
8234	8256	gdcm::Pixmap::GetIconImage() const
8235	8257
8236	8258	Set/Get Icon Image. ";
8237
8238		%feature("docstring") gdcm::Pixmap::GetIconImage "IconImage&
8239		gdcm::Pixmap::GetIconImage() ";
8240	8259
8241	8260	%feature("docstring") gdcm::Pixmap::GetNumberOfCurves "size_t
8242	8261	gdcm::Pixmap::GetNumberOfCurves() const ";

8293	8312
8294	8313	%feature("docstring") gdcm::PixmapReader::~PixmapReader "gdcm::PixmapReader::~PixmapReader() override ";
8295	8314
	8315	%feature("docstring") gdcm::PixmapReader::GetPixmap "Pixmap&
	8316	gdcm::PixmapReader::GetPixmap() ";
	8317
8296	8318	%feature("docstring") gdcm::PixmapReader::GetPixmap "const Pixmap&
8297	8319	gdcm::PixmapReader::GetPixmap() const
8298	8320
8299	8321	Return the read image (need to call Read() first) ";
8300
8301		%feature("docstring") gdcm::PixmapReader::GetPixmap "Pixmap&
8302		gdcm::PixmapReader::GetPixmap() ";
8303	8322
8304	8323	%feature("docstring") gdcm::PixmapReader::Read "bool
8305	8324	gdcm::PixmapReader::Read() override

8357	8376
8358	8377	%feature("docstring") gdcm::PixmapWriter::~PixmapWriter "gdcm::PixmapWriter::~PixmapWriter() override ";
8359	8378
	8379	%feature("docstring") gdcm::PixmapWriter::GetImage "virtual Pixmap&
	8380	gdcm::PixmapWriter::GetImage() ";
	8381
8360	8382	%feature("docstring") gdcm::PixmapWriter::GetImage "virtual const
8361	8383	Pixmap& gdcm::PixmapWriter::GetImage() const
8362	8384
8363	8385	Set/Get Pixmap to be written It will overwrite anything Pixmap infos
8364	8386	found in DataSet (see parent class to see how to pass dataset) ";
8365	8387
8366		%feature("docstring") gdcm::PixmapWriter::GetImage "virtual Pixmap&
8367		gdcm::PixmapWriter::GetImage() ";
	8388	%feature("docstring") gdcm::PixmapWriter::GetPixmap "Pixmap&
	8389	gdcm::PixmapWriter::GetPixmap() ";
8368	8390
8369	8391	%feature("docstring") gdcm::PixmapWriter::GetPixmap "const Pixmap&
8370	8392	gdcm::PixmapWriter::GetPixmap() const ";
8371
8372		%feature("docstring") gdcm::PixmapWriter::GetPixmap "Pixmap&
8373		gdcm::PixmapWriter::GetPixmap() ";
8374	8393
8375	8394	%feature("docstring") gdcm::PixmapWriter::SetImage "virtual void
8376	8395	gdcm::PixmapWriter::SetImage(Pixmap const &img) ";

8486	8505
8487	8506	Set Preamble to the default one. ";
8488	8507
8489		%feature("docstring") gdcm::Preamble::Write "std::ostream const&
	8508	%feature("docstring") gdcm::Preamble::Write "const std::ostream&
8490	8509	gdcm::Preamble::Write(std::ostream &os) const
8491	8510
8492	8511	Write Preamble. ";

8561	8580	"uint8_t gdcm::network::PresentationContextAC::GetReason() const ";
8562	8581
8563	8582	%feature("docstring")
8564		gdcm::network::PresentationContextAC::GetTransferSyntax "TransferSyntaxSub const&
	8583	gdcm::network::PresentationContextAC::GetTransferSyntax "const
	8584	TransferSyntaxSub&
8565	8585	gdcm::network::PresentationContextAC::GetTransferSyntax() const ";
8566	8586
8567	8587	%feature("docstring") gdcm::network::PresentationContextAC::Print "void gdcm::network::PresentationContextAC::Print(std::ostream &os)

8650	8670	VerificationSOPClass) ";
8651	8671
8652	8672	%feature("docstring")
8653		gdcm::PresentationContextGenerator::GetPresentationContexts "PresentationContextArrayType const&
	8673	gdcm::PresentationContextGenerator::GetPresentationContexts "const
	8674	PresentationContextArrayType&
8654	8675	gdcm::PresentationContextGenerator::GetPresentationContexts() ";
8655	8676
8656	8677	%feature("docstring")

8684	8705	gdcm::network::PresentationContextRQ::PresentationContextRQ "gdcm::network::PresentationContextRQ::PresentationContextRQ() ";
8685	8706
8686	8707	%feature("docstring")
	8708	gdcm::network::PresentationContextRQ::PresentationContextRQ "gdcm::network::PresentationContextRQ::PresentationContextRQ(const
	8709	PresentationContext &pc) ";
	8710
	8711	%feature("docstring")
8687	8712	gdcm::network::PresentationContextRQ::PresentationContextRQ "gdcm::network::PresentationContextRQ::PresentationContextRQ(UIDs::TSName
8688	8713	asname, UIDs::TSName
8689	8714	tsname=UIDs::ImplicitVRLittleEndianDefaultTransferSyntaxforDICOM)

8693	8718	LittleEndian when not specified ). ";
8694	8719
8695	8720	%feature("docstring")
8696		gdcm::network::PresentationContextRQ::PresentationContextRQ "gdcm::network::PresentationContextRQ::PresentationContextRQ(const
8697		PresentationContext &pc) ";
8698
8699		%feature("docstring")
8700	8721	gdcm::network::PresentationContextRQ::AddTransferSyntax "void
8701	8722	gdcm::network::PresentationContextRQ::AddTransferSyntax(TransferSyntaxSub
8702	8723	const &ts) ";
8703	8724
8704	8725	%feature("docstring")
8705		gdcm::network::PresentationContextRQ::GetAbstractSyntax "AbstractSyntax const&
8706		gdcm::network::PresentationContextRQ::GetAbstractSyntax() const ";
8707
8708		%feature("docstring")
8709	8726	gdcm::network::PresentationContextRQ::GetAbstractSyntax "AbstractSyntax&
8710	8727	gdcm::network::PresentationContextRQ::GetAbstractSyntax() ";
	8728
	8729	%feature("docstring")
	8730	gdcm::network::PresentationContextRQ::GetAbstractSyntax "const
	8731	AbstractSyntax&
	8732	gdcm::network::PresentationContextRQ::GetAbstractSyntax() const ";
8711	8733
8712	8734	%feature("docstring")
8713	8735	gdcm::network::PresentationContextRQ::GetNumberOfTransferSyntaxes "SizeType

8720	8742	";
8721	8743
8722	8744	%feature("docstring")
8723		gdcm::network::PresentationContextRQ::GetTransferSyntax "TransferSyntaxSub const&
	8745	gdcm::network::PresentationContextRQ::GetTransferSyntax "TransferSyntaxSub&
	8746	gdcm::network::PresentationContextRQ::GetTransferSyntax(SizeType i) ";
	8747
	8748	%feature("docstring")
	8749	gdcm::network::PresentationContextRQ::GetTransferSyntax "const
	8750	TransferSyntaxSub&
8724	8751	gdcm::network::PresentationContextRQ::GetTransferSyntax(SizeType i)
8725	8752	const ";
8726	8753
8727	8754	%feature("docstring")
8728		gdcm::network::PresentationContextRQ::GetTransferSyntax "TransferSyntaxSub&
8729		gdcm::network::PresentationContextRQ::GetTransferSyntax(SizeType i) ";
8730
8731		%feature("docstring")
8732		gdcm::network::PresentationContextRQ::GetTransferSyntaxes "std::vector<TransferSyntaxSub> const&
	8755	gdcm::network::PresentationContextRQ::GetTransferSyntaxes "const
	8756	std::vector<TransferSyntaxSub>&
8733	8757	gdcm::network::PresentationContextRQ::GetTransferSyntaxes() const ";
8734	8758
8735	8759	%feature("docstring") gdcm::network::PresentationContextRQ::Print "void gdcm::network::PresentationContextRQ::Print(std::ostream &os)

8920	8944
8921	8945	C++ includes: gdcmPrivateTag.h ";
8922	8946
	8947	%feature("docstring") gdcm::PrivateTag::PrivateTag "gdcm::PrivateTag::PrivateTag(Tag const &t, const char *owner=\"\") ";
	8948
8923	8949	%feature("docstring") gdcm::PrivateTag::PrivateTag "gdcm::PrivateTag::PrivateTag(uint16_t group=0, uint16_t element=0,
8924	8950	const char *owner=\"\") ";
8925	8951
8926		%feature("docstring") gdcm::PrivateTag::PrivateTag "gdcm::PrivateTag::PrivateTag(Tag const &t, const char *owner=\"\") ";
8927
8928	8952	%feature("docstring") gdcm::PrivateTag::GetAsDataElement "DataElement gdcm::PrivateTag::GetAsDataElement() const ";
8929	8953
8930	8954	%feature("docstring") gdcm::PrivateTag::GetOwner "const char*

8951	8975
8952	8976	C++ includes: gdcmProgressEvent.h ";
8953	8977
	8978	%feature("docstring") gdcm::ProgressEvent::ProgressEvent "gdcm::ProgressEvent::ProgressEvent(const Self &s) ";
	8979
8954	8980	%feature("docstring") gdcm::ProgressEvent::ProgressEvent "gdcm::ProgressEvent::ProgressEvent(double p=0) ";
8955
8956		%feature("docstring") gdcm::ProgressEvent::ProgressEvent "gdcm::ProgressEvent::ProgressEvent(const Self &s) ";
8957	8981
8958	8982	%feature("docstring") gdcm::ProgressEvent::~ProgressEvent "gdcm::ProgressEvent::~ProgressEvent() override=default ";
8959	8983

9373	9397	Test whether this is a DICOM file WARNING: need to call either
9374	9398	SetFileName or SetStream first ";
9375	9399
	9400	%feature("docstring") gdcm::Reader::GetFile "File&
	9401	gdcm::Reader::GetFile()
	9402
	9403	Set/Get File. ";
	9404
9376	9405	%feature("docstring") gdcm::Reader::GetFile "const File&
9377	9406	gdcm::Reader::GetFile() const
9378
9379		Set/Get File. ";
9380
9381		%feature("docstring") gdcm::Reader::GetFile "File&
9382		gdcm::Reader::GetFile()
9383	9407
9384	9408	Set/Get File. ";
9385	9409

9675	9699	const ";
9676	9700
9677	9701
9678		// File: structgdcm_1_1SerieHelper_1_1Rule.xml
9679
9680
9681	9702	// File: classgdcm_1_1Scanner.xml
9682	9703	%feature("docstring") gdcm::Scanner "
9683	9704

9749	9770	Will loop over all files and return the first file where value match
9750	9771	the reference value 'valueref' ";
9751	9772
9752		%feature("docstring") gdcm::Scanner::GetFilenames "Directory::FilenamesType const& gdcm::Scanner::GetFilenames() const ";
	9773	%feature("docstring") gdcm::Scanner::GetFilenames "const
	9774	Directory::FilenamesType& gdcm::Scanner::GetFilenames() const ";
9753	9775
9754	9776	%feature("docstring") gdcm::Scanner::GetKeys "Directory::FilenamesType gdcm::Scanner::GetKeys() const
9755	9777
9756	9778	Return the list of filename that are key in the internal map, which
9757	9779	means those filename were properly parsed ";
9758	9780
9759		%feature("docstring") gdcm::Scanner::GetMapping "TagToValue const&
	9781	%feature("docstring") gdcm::Scanner::GetMapping "const TagToValue&
9760	9782	gdcm::Scanner::GetMapping(const char *filename) const
9761	9783
9762	9784	Get the std::map mapping filenames to value for file 'filename'. ";
9763	9785
9764		%feature("docstring") gdcm::Scanner::GetMappingFromTagToValue "TagToValue const& gdcm::Scanner::GetMappingFromTagToValue(Tag const
9765		&t, const char *value) const
	9786	%feature("docstring") gdcm::Scanner::GetMappingFromTagToValue "const
	9787	TagToValue& gdcm::Scanner::GetMappingFromTagToValue(Tag const &t,
	9788	const char *value) const
9766	9789
9767	9790	See GetFilenameFromTagToValue(). This is simply
9768	9791	GetFilenameFromTagToValue followed. ";
9769	9792
9770		%feature("docstring") gdcm::Scanner::GetMappings "MappingType const&
	9793	%feature("docstring") gdcm::Scanner::GetMappings "const MappingType&
9771	9794	gdcm::Scanner::GetMappings() const
9772	9795
9773	9796	Mappings are the mapping from a particular tag to the map, mapping

9789	9812	the TagToValue hash table. WARNING: Tag 't' should have been added
9790	9813	via AddTag() prior to the Scan() call ! ";
9791	9814
9792		%feature("docstring") gdcm::Scanner::GetValues "ValuesType const&
	9815	%feature("docstring") gdcm::Scanner::GetValues "const ValuesType&
9793	9816	gdcm::Scanner::GetValues() const
9794	9817
9795	9818	Get all the values found (in lexicographic order) ";

9840	9863	%feature("docstring") gdcm::Segment::AddSurface "void
9841	9864	gdcm::Segment::AddSurface(SmartPointer< Surface > surface) ";
9842	9865
9843		%feature("docstring") gdcm::Segment::GetAnatomicRegion "SegmentHelper::BasicCodedEntry const&
9844		gdcm::Segment::GetAnatomicRegion() const ";
9845
9846	9866	%feature("docstring") gdcm::Segment::GetAnatomicRegion "SegmentHelper::BasicCodedEntry& gdcm::Segment::GetAnatomicRegion() ";
9847	9867
9848		%feature("docstring") gdcm::Segment::GetAnatomicRegionModifiers "BasicCodedEntryVector const&
	9868	%feature("docstring") gdcm::Segment::GetAnatomicRegion "const
	9869	SegmentHelper::BasicCodedEntry& gdcm::Segment::GetAnatomicRegion()
	9870	const ";
	9871
	9872	%feature("docstring") gdcm::Segment::GetAnatomicRegionModifiers "BasicCodedEntryVector& gdcm::Segment::GetAnatomicRegionModifiers() ";
	9873
	9874	%feature("docstring") gdcm::Segment::GetAnatomicRegionModifiers "const BasicCodedEntryVector&
9849	9875	gdcm::Segment::GetAnatomicRegionModifiers() const ";
9850	9876
9851		%feature("docstring") gdcm::Segment::GetAnatomicRegionModifiers "BasicCodedEntryVector& gdcm::Segment::GetAnatomicRegionModifiers() ";
9852
9853		%feature("docstring") gdcm::Segment::GetPropertyCategory "SegmentHelper::BasicCodedEntry const&
9854		gdcm::Segment::GetPropertyCategory() const ";
9855
9856	9877	%feature("docstring") gdcm::Segment::GetPropertyCategory "SegmentHelper::BasicCodedEntry& gdcm::Segment::GetPropertyCategory()
9857	9878	";
9858	9879
9859		%feature("docstring") gdcm::Segment::GetPropertyType "SegmentHelper::BasicCodedEntry const& gdcm::Segment::GetPropertyType()
	9880	%feature("docstring") gdcm::Segment::GetPropertyCategory "const
	9881	SegmentHelper::BasicCodedEntry& gdcm::Segment::GetPropertyCategory()
9860	9882	const ";
9861	9883
9862	9884	%feature("docstring") gdcm::Segment::GetPropertyType "SegmentHelper::BasicCodedEntry& gdcm::Segment::GetPropertyType() ";
9863	9885
9864		%feature("docstring") gdcm::Segment::GetPropertyTypeModifiers "BasicCodedEntryVector const& gdcm::Segment::GetPropertyTypeModifiers()
9865		const ";
	9886	%feature("docstring") gdcm::Segment::GetPropertyType "const
	9887	SegmentHelper::BasicCodedEntry& gdcm::Segment::GetPropertyType() const
	9888	";
9866	9889
9867	9890	%feature("docstring") gdcm::Segment::GetPropertyTypeModifiers "BasicCodedEntryVector& gdcm::Segment::GetPropertyTypeModifiers() ";
	9891
	9892	%feature("docstring") gdcm::Segment::GetPropertyTypeModifiers "const
	9893	BasicCodedEntryVector& gdcm::Segment::GetPropertyTypeModifiers() const
	9894	";
9868	9895
9869	9896	%feature("docstring") gdcm::Segment::GetSegmentAlgorithmName "const
9870	9897	char* gdcm::Segment::GetSegmentAlgorithmName() const ";

9886	9913	%feature("docstring") gdcm::Segment::GetSurfaceCount "unsigned long
9887	9914	gdcm::Segment::GetSurfaceCount() ";
9888	9915
9889		%feature("docstring") gdcm::Segment::GetSurfaces "SurfaceVector
9890		const& gdcm::Segment::GetSurfaces() const ";
9891
9892	9916	%feature("docstring") gdcm::Segment::GetSurfaces "SurfaceVector&
9893	9917	gdcm::Segment::GetSurfaces() ";
	9918
	9919	%feature("docstring") gdcm::Segment::GetSurfaces "const
	9920	SurfaceVector& gdcm::Segment::GetSurfaces() const ";
9894	9921
9895	9922	%feature("docstring") gdcm::Segment::SetAnatomicRegion "void
9896	9923	gdcm::Segment::SetAnatomicRegion(SegmentHelper::BasicCodedEntry const

9975	10002
9976	10003	%feature("docstring") gdcm::SegmentReader::~SegmentReader "gdcm::SegmentReader::~SegmentReader() override ";
9977	10004
	10005	%feature("docstring") gdcm::SegmentReader::GetSegments "SegmentVector gdcm::SegmentReader::GetSegments() ";
	10006
9978	10007	%feature("docstring") gdcm::SegmentReader::GetSegments "const
9979	10008	SegmentVector gdcm::SegmentReader::GetSegments() const ";
9980
9981		%feature("docstring") gdcm::SegmentReader::GetSegments "SegmentVector gdcm::SegmentReader::GetSegments() ";
9982	10009
9983	10010	%feature("docstring") gdcm::SegmentReader::Read "bool
9984	10011	gdcm::SegmentReader::Read() override

10010	10037	Segment > gdcm::SegmentWriter::GetSegment(const unsigned int idx=0)
10011	10038	const ";
10012	10039
	10040	%feature("docstring") gdcm::SegmentWriter::GetSegments "SegmentVector& gdcm::SegmentWriter::GetSegments() ";
	10041
10013	10042	%feature("docstring") gdcm::SegmentWriter::GetSegments "const
10014	10043	SegmentVector& gdcm::SegmentWriter::GetSegments() const ";
10015
10016		%feature("docstring") gdcm::SegmentWriter::GetSegments "SegmentVector& gdcm::SegmentWriter::GetSegments() ";
10017	10044
10018	10045	%feature("docstring") gdcm::SegmentWriter::SetNumberOfSegments "void
10019	10046	gdcm::SegmentWriter::SetNumberOfSegments(const unsigned int size) ";

10088	10115	%feature("docstring") gdcm::SequenceOfFragments::GetNumberOfFragments
10089	10116	"SizeType gdcm::SequenceOfFragments::GetNumberOfFragments() const ";
10090	10117
	10118	%feature("docstring") gdcm::SequenceOfFragments::GetTable "BasicOffsetTable& gdcm::SequenceOfFragments::GetTable() ";
	10119
10091	10120	%feature("docstring") gdcm::SequenceOfFragments::GetTable "const
10092	10121	BasicOffsetTable& gdcm::SequenceOfFragments::GetTable() const ";
10093
10094		%feature("docstring") gdcm::SequenceOfFragments::GetTable "BasicOffsetTable& gdcm::SequenceOfFragments::GetTable() ";
10095	10122
10096	10123	%feature("docstring") gdcm::SequenceOfFragments::Print "void
10097	10124	gdcm::SequenceOfFragments::Print(std::ostream &os) const override ";

10111	10138
10112	10139	Sets the actual SQ length. ";
10113	10140
10114		%feature("docstring") gdcm::SequenceOfFragments::Write "std::ostream
10115		const& gdcm::SequenceOfFragments::Write(std::ostream &os) const ";
	10141	%feature("docstring") gdcm::SequenceOfFragments::Write "const
	10142	std::ostream& gdcm::SequenceOfFragments::Write(std::ostream &os) const
	10143	";
10116	10144
10117	10145	%feature("docstring") gdcm::SequenceOfFragments::WriteBuffer "bool
10118	10146	gdcm::SequenceOfFragments::WriteBuffer(std::ostream &os) const ";

10173	10201	%feature("docstring") gdcm::SequenceOfItems::FindDataElement "bool
10174	10202	gdcm::SequenceOfItems::FindDataElement(const Tag &t) const ";
10175	10203
	10204	%feature("docstring") gdcm::SequenceOfItems::GetItem "Item&
	10205	gdcm::SequenceOfItems::GetItem(SizeType position) ";
	10206
10176	10207	%feature("docstring") gdcm::SequenceOfItems::GetItem "const Item&
10177	10208	gdcm::SequenceOfItems::GetItem(SizeType position) const ";
10178	10209
10179		%feature("docstring") gdcm::SequenceOfItems::GetItem "Item&
10180		gdcm::SequenceOfItems::GetItem(SizeType position) ";
10181
10182	10210	%feature("docstring") gdcm::SequenceOfItems::GetLength "VL
10183	10211	gdcm::SequenceOfItems::GetLength() const override
10184	10212

10218	10246	%feature("docstring") gdcm::SequenceOfItems::SetNumberOfItems "void
10219	10247	gdcm::SequenceOfItems::SetNumberOfItems(SizeType n) ";
10220	10248
10221		%feature("docstring") gdcm::SequenceOfItems::Write "std::ostream
10222		const& gdcm::SequenceOfItems::Write(std::ostream &os) const ";
	10249	%feature("docstring") gdcm::SequenceOfItems::Write "const
	10250	std::ostream& gdcm::SequenceOfItems::Write(std::ostream &os) const ";
10223	10251
10224	10252
10225	10253	// File: classgdcm_1_1SerieHelper.xml

10402	10430	Execute a C-STORE on file on disk, named filename. ";
10403	10431
10404	10432	%feature("docstring") gdcm::ServiceClassUser::SendStore "bool
	10433	gdcm::ServiceClassUser::SendStore(DataSet const &ds)
	10434
	10435	Execute a C-STORE on a DataSet, the transfer syntax used will be
	10436	Implicit. ";
	10437
	10438	%feature("docstring") gdcm::ServiceClassUser::SendStore "bool
10405	10439	gdcm::ServiceClassUser::SendStore(File const &file)
10406	10440
10407	10441	Execute a C-STORE on a File, the transfer syntax used for the query is
10408	10442	based on the file. ";
10409
10410		%feature("docstring") gdcm::ServiceClassUser::SendStore "bool
10411		gdcm::ServiceClassUser::SendStore(DataSet const &ds)
10412
10413		Execute a C-STORE on a DataSet, the transfer syntax used will be
10414		Implicit. ";
10415	10443
10416	10444	%feature("docstring") gdcm::ServiceClassUser::SetAETitle "void
10417	10445	gdcm::ServiceClassUser::SetAETitle(const char *aetitle)

10497	10525	&)=delete ";
10498	10526
10499	10527	%feature("docstring") gdcm::SimpleMemberCommand::Execute "void
10500		gdcm::SimpleMemberCommand< T >::Execute(Subject *, const Event &)
10501		override
10502
10503		Invoke the callback function. ";
10504
10505		%feature("docstring") gdcm::SimpleMemberCommand::Execute "void
10506	10528	gdcm::SimpleMemberCommand< T >::Execute(const Subject *, const Event
10507	10529	&) override
10508	10530

10510	10532	This variant is expected to be used when requests comes from a const
10511	10533	Object ";
10512	10534
	10535	%feature("docstring") gdcm::SimpleMemberCommand::Execute "void
	10536	gdcm::SimpleMemberCommand< T >::Execute(Subject *, const Event &)
	10537	override
	10538
	10539	Invoke the callback function. ";
	10540
10513	10541	%feature("docstring") gdcm::SimpleMemberCommand::SetCallbackFunction
10514	10542	"void gdcm::SimpleMemberCommand< T >::SetCallbackFunction(T *object,
10515	10543	TMemberFunctionPointer memberFunction)

10527	10555	C++ includes: gdcmSimpleSubjectWatcher.h ";
10528	10556
10529	10557	%feature("docstring")
	10558	gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher "gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher(const
	10559	SimpleSubjectWatcher &)=delete ";
	10560
	10561	%feature("docstring")
10530	10562	gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher "gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher(Subject *s, const
10531	10563	char *comment=\"\") ";
10532
10533		%feature("docstring")
10534		gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher "gdcm::SimpleSubjectWatcher::SimpleSubjectWatcher(const
10535		SimpleSubjectWatcher &)=delete ";
10536	10564
10537	10565	%feature("docstring")
10538	10566	gdcm::SimpleSubjectWatcher::~SimpleSubjectWatcher "virtual

10811	10839	%feature("docstring") gdcm::SplitMosaicFilter::GetFile "const File&
10812	10840	gdcm::SplitMosaicFilter::GetFile() const ";
10813	10841
	10842	%feature("docstring") gdcm::SplitMosaicFilter::GetImage "Image&
	10843	gdcm::SplitMosaicFilter::GetImage() ";
	10844
10814	10845	%feature("docstring") gdcm::SplitMosaicFilter::GetImage "const
10815	10846	Image& gdcm::SplitMosaicFilter::GetImage() const ";
10816
10817		%feature("docstring") gdcm::SplitMosaicFilter::GetImage "Image&
10818		gdcm::SplitMosaicFilter::GetImage() ";
10819	10847
10820	10848	%feature("docstring") gdcm::SplitMosaicFilter::SetFile "void
10821	10849	gdcm::SplitMosaicFilter::SetFile(const File &f) ";

10905	10933	gdcm::StreamImageReader::GetDimensionsValueForResolution(unsigned int)
10906	10934	";
10907	10935
10908		%feature("docstring") gdcm::StreamImageReader::GetFile "File const&
	10936	%feature("docstring") gdcm::StreamImageReader::GetFile "const File&
10909	10937	gdcm::StreamImageReader::GetFile() const
10910	10938
10911	10939	Returns the dataset read by ReadImageInformation Couple this with the

11110	11138	Will loop over all files and return the first file where value match
11111	11139	the reference value 'valueref' ";
11112	11140
11113		%feature("docstring") gdcm::StrictScanner::GetFilenames "Directory::FilenamesType const& gdcm::StrictScanner::GetFilenames()
11114		const ";
	11141	%feature("docstring") gdcm::StrictScanner::GetFilenames "const
	11142	Directory::FilenamesType& gdcm::StrictScanner::GetFilenames() const ";
11115	11143
11116	11144	%feature("docstring") gdcm::StrictScanner::GetKeys "Directory::FilenamesType gdcm::StrictScanner::GetKeys() const
11117	11145
11118	11146	Return the list of filename that are key in the internal map, which
11119	11147	means those filename were properly parsed ";
11120	11148
11121		%feature("docstring") gdcm::StrictScanner::GetMapping "TagToValue
11122		const& gdcm::StrictScanner::GetMapping(const char *filename) const
	11149	%feature("docstring") gdcm::StrictScanner::GetMapping "const
	11150	TagToValue& gdcm::StrictScanner::GetMapping(const char *filename)
	11151	const
11123	11152
11124	11153	Get the std::map mapping filenames to value for file 'filename'. ";
11125	11154
11126		%feature("docstring") gdcm::StrictScanner::GetMappingFromTagToValue "TagToValue const& gdcm::StrictScanner::GetMappingFromTagToValue(Tag
	11155	%feature("docstring") gdcm::StrictScanner::GetMappingFromTagToValue "const TagToValue& gdcm::StrictScanner::GetMappingFromTagToValue(Tag
11127	11156	const &t, const char *value) const
11128	11157
11129	11158	See GetFilenameFromTagToValue(). This is simply
11130	11159	GetFilenameFromTagToValue followed. ";
11131	11160
11132		%feature("docstring") gdcm::StrictScanner::GetMappings "MappingType
11133		const& gdcm::StrictScanner::GetMappings() const
	11161	%feature("docstring") gdcm::StrictScanner::GetMappings "const
	11162	MappingType& gdcm::StrictScanner::GetMappings() const
11134	11163
11135	11164	Mappings are the mapping from a particular tag to the map, mapping
11136	11165	filename to value: ";

11152	11181	the TagToValue hash table. WARNING: Tag 't' should have been added
11153	11182	via AddTag() prior to the Scan() call ! ";
11154	11183
11155		%feature("docstring") gdcm::StrictScanner::GetValues "ValuesType
11156		const& gdcm::StrictScanner::GetValues() const
	11184	%feature("docstring") gdcm::StrictScanner::GetValues "const
	11185	ValuesType& gdcm::StrictScanner::GetValues() const
11157	11186
11158	11187	Get all the values found (in lexicographic order) ";
11159	11188

11201	11230	String constructors. ";
11202	11231
11203	11232	%feature("docstring") gdcm::String::String "gdcm::String<
	11233	TDelimiter, TMaxLength, TPadChar >::String(const std::string &s,
	11234	size_type pos=0, size_type n=npos) ";
	11235
	11236	%feature("docstring") gdcm::String::String "gdcm::String<
11204	11237	TDelimiter, TMaxLength, TPadChar >::String(const value_type *s) ";
11205	11238
11206	11239	%feature("docstring") gdcm::String::String "gdcm::String<
11207	11240	TDelimiter, TMaxLength, TPadChar >::String(const value_type *s,
11208	11241	size_type n) ";
11209	11242
11210		%feature("docstring") gdcm::String::String "gdcm::String<
11211		TDelimiter, TMaxLength, TPadChar >::String(const std::string &s,
11212		size_type pos=0, size_type n=npos) ";
11213
11214	11243	%feature("docstring") gdcm::String::IsValid "bool gdcm::String<
11215	11244	TDelimiter, TMaxLength, TPadChar >::IsValid() const
11216	11245

11278	11307	Convert to string the ByteValue contained in a DataElement. The
11279	11308	DataElement must be coming from the actual DataSet associated with
11280	11309	File (see SetFile). ";
	11310
	11311	%feature("docstring") gdcm::StringFilter::ToString "std::string
	11312	gdcm::StringFilter::ToString(const PrivateTag &t) const ";
11281	11313
11282	11314	%feature("docstring") gdcm::StringFilter::ToString "std::string
11283	11315	gdcm::StringFilter::ToString(const Tag &t) const

11389	11421
11390	11422	%feature("docstring") gdcm::Surface::~Surface "gdcm::Surface::~Surface() override ";
11391	11423
11392		%feature("docstring") gdcm::Surface::GetAlgorithmFamily "SegmentHelper::BasicCodedEntry const&
11393		gdcm::Surface::GetAlgorithmFamily() const ";
11394
11395	11424	%feature("docstring") gdcm::Surface::GetAlgorithmFamily "SegmentHelper::BasicCodedEntry& gdcm::Surface::GetAlgorithmFamily() ";
	11425
	11426	%feature("docstring") gdcm::Surface::GetAlgorithmFamily "const
	11427	SegmentHelper::BasicCodedEntry& gdcm::Surface::GetAlgorithmFamily()
	11428	const ";
11396	11429
11397	11430	%feature("docstring") gdcm::Surface::GetAlgorithmName "const char*
11398	11431	gdcm::Surface::GetAlgorithmName() const ";

11422	11455	%feature("docstring") gdcm::Surface::GetMeanPointDistance "float
11423	11456	gdcm::Surface::GetMeanPointDistance() const ";
11424	11457
11425		%feature("docstring") gdcm::Surface::GetMeshPrimitive "MeshPrimitive
11426		const& gdcm::Surface::GetMeshPrimitive() const ";
11427
11428	11458	%feature("docstring") gdcm::Surface::GetMeshPrimitive "MeshPrimitive& gdcm::Surface::GetMeshPrimitive() ";
	11459
	11460	%feature("docstring") gdcm::Surface::GetMeshPrimitive "const
	11461	MeshPrimitive& gdcm::Surface::GetMeshPrimitive() const ";
11429	11462
11430	11463	%feature("docstring") gdcm::Surface::GetNumberOfSurfacePoints "unsigned long gdcm::Surface::GetNumberOfSurfacePoints() const ";
11431	11464
11432	11465	%feature("docstring") gdcm::Surface::GetNumberOfVectors "unsigned
11433	11466	long gdcm::Surface::GetNumberOfVectors() const ";
11434	11467
	11468	%feature("docstring") gdcm::Surface::GetPointCoordinatesData "DataElement& gdcm::Surface::GetPointCoordinatesData() ";
	11469
11435	11470	%feature("docstring") gdcm::Surface::GetPointCoordinatesData "const
11436	11471	DataElement& gdcm::Surface::GetPointCoordinatesData() const ";
11437	11472
11438		%feature("docstring") gdcm::Surface::GetPointCoordinatesData "DataElement& gdcm::Surface::GetPointCoordinatesData() ";
11439
11440	11473	%feature("docstring") gdcm::Surface::GetPointPositionAccuracy "const
11441	11474	float* gdcm::Surface::GetPointPositionAccuracy() const
11442	11475

11447	11480
11448	11481	Pointer is null if undefined ";
11449	11482
11450		%feature("docstring") gdcm::Surface::GetProcessingAlgorithm "SegmentHelper::BasicCodedEntry const&
11451		gdcm::Surface::GetProcessingAlgorithm() const ";
11452
11453	11483	%feature("docstring") gdcm::Surface::GetProcessingAlgorithm "SegmentHelper::BasicCodedEntry&
11454	11484	gdcm::Surface::GetProcessingAlgorithm() ";
	11485
	11486	%feature("docstring") gdcm::Surface::GetProcessingAlgorithm "const
	11487	SegmentHelper::BasicCodedEntry&
	11488	gdcm::Surface::GetProcessingAlgorithm() const ";
11455	11489
11456	11490	%feature("docstring") gdcm::Surface::GetRecommendedDisplayCIELabValue
11457	11491	"const unsigned short*

11489	11523	%feature("docstring") gdcm::Surface::GetVectorAccuracy "const float*
11490	11524	gdcm::Surface::GetVectorAccuracy() const ";
11491	11525
	11526	%feature("docstring") gdcm::Surface::GetVectorCoordinateData "DataElement& gdcm::Surface::GetVectorCoordinateData() ";
	11527
11492	11528	%feature("docstring") gdcm::Surface::GetVectorCoordinateData "const
11493	11529	DataElement& gdcm::Surface::GetVectorCoordinateData() const ";
11494
11495		%feature("docstring") gdcm::Surface::GetVectorCoordinateData "DataElement& gdcm::Surface::GetVectorCoordinateData() ";
11496	11530
11497	11531	%feature("docstring") gdcm::Surface::GetVectorDimensionality "unsigned short gdcm::Surface::GetVectorDimensionality() const ";
11498	11532

11548	11582	const &BSE) ";
11549	11583
11550	11584	%feature("docstring") gdcm::Surface::SetRecommendedDisplayCIELabValue
11551		"void gdcm::Surface::SetRecommendedDisplayCIELabValue(const unsigned
11552		short vl[3]) ";
	11585	"void gdcm::Surface::SetRecommendedDisplayCIELabValue(const
	11586	std::vector< unsigned short > &vl) ";
11553	11587
11554	11588	%feature("docstring") gdcm::Surface::SetRecommendedDisplayCIELabValue
11555	11589	"void gdcm::Surface::SetRecommendedDisplayCIELabValue(const unsigned
11556	11590	short vl, const unsigned int idx=0) ";
11557	11591
11558	11592	%feature("docstring") gdcm::Surface::SetRecommendedDisplayCIELabValue
11559		"void gdcm::Surface::SetRecommendedDisplayCIELabValue(const
11560		std::vector< unsigned short > &vl) ";
	11593	"void gdcm::Surface::SetRecommendedDisplayCIELabValue(const unsigned
	11594	short vl[3]) ";
11561	11595
11562	11596	%feature("docstring")
11563	11597	gdcm::Surface::SetRecommendedDisplayGrayscaleValue "void

11811	11845
11812	11846	C++ includes: gdcmTag.h ";
11813	11847
	11848	%feature("docstring") gdcm::Tag::Tag "gdcm::Tag::Tag(const Tag
	11849	&_val) ";
	11850
11814	11851	%feature("docstring") gdcm::Tag::Tag "gdcm::Tag::Tag(uint16_t group,
11815	11852	uint16_t element)
11816	11853

11820	11857
11821	11858	Constructor with 1*uint32_t Prefer the cstor that takes two uint16_t.
11822	11859	";
11823
11824		%feature("docstring") gdcm::Tag::Tag "gdcm::Tag::Tag(const Tag
11825		&_val) ";
11826	11860
11827	11861	%feature("docstring") gdcm::Tag::GetElement "uint16_t
11828	11862	gdcm::Tag::GetElement() const

12561	12595	%feature("docstring")
12562	12596	gdcm::network::ULBasicCallback::~ULBasicCallback "gdcm::network::ULBasicCallback::~ULBasicCallback() override=default ";
12563	12597
12564		%feature("docstring") gdcm::network::ULBasicCallback::GetDataSets "std::vector<DataSet> const&
	12598	%feature("docstring") gdcm::network::ULBasicCallback::GetDataSets "const std::vector<DataSet>&
12565	12599	gdcm::network::ULBasicCallback::GetDataSets() const ";
12566	12600
12567		%feature("docstring") gdcm::network::ULBasicCallback::GetResponses "std::vector<DataSet> const&
	12601	%feature("docstring") gdcm::network::ULBasicCallback::GetResponses "const std::vector<DataSet>&
12568	12602	gdcm::network::ULBasicCallback::GetResponses() const ";
12569	12603
12570	12604	%feature("docstring") gdcm::network::ULBasicCallback::HandleDataSet "void gdcm::network::ULBasicCallback::HandleDataSet(const DataSet

12603	12637
12604	12638	C++ includes: gdcmULConnection.h ";
12605	12639
	12640	%feature("docstring") gdcm::network::ULConnection::ULConnection "gdcm::network::ULConnection::ULConnection(const ULConnection &)=delete
	12641	";
	12642
12606	12643	%feature("docstring") gdcm::network::ULConnection::ULConnection "gdcm::network::ULConnection::ULConnection(const ULConnectionInfo
12607	12644	&inUserInformation) ";
12608
12609		%feature("docstring") gdcm::network::ULConnection::ULConnection "gdcm::network::ULConnection::ULConnection(const ULConnection &)=delete
12610		";
12611	12645
12612	12646	%feature("docstring") gdcm::network::ULConnection::~ULConnection "virtual gdcm::network::ULConnection::~ULConnection() ";
12613	12647

12620	12654	DataElement &de) const ";
12621	12655
12622	12656	%feature("docstring")
12623		gdcm::network::ULConnection::GetAcceptedPresentationContexts "std::vector<PresentationContextAC> const&
12624		gdcm::network::ULConnection::GetAcceptedPresentationContexts() const
12625		";
12626
12627		%feature("docstring")
12628	12657	gdcm::network::ULConnection::GetAcceptedPresentationContexts "std::vector<PresentationContextAC>&
12629	12658	gdcm::network::ULConnection::GetAcceptedPresentationContexts() ";
	12659
	12660	%feature("docstring")
	12661	gdcm::network::ULConnection::GetAcceptedPresentationContexts "const
	12662	std::vector<PresentationContextAC>&
	12663	gdcm::network::ULConnection::GetAcceptedPresentationContexts() const
	12664	";
12630	12665
12631	12666	%feature("docstring") gdcm::network::ULConnection::GetConnectionInfo
12632	12667	"const ULConnectionInfo&

12655	12690	const ";
12656	12691
12657	12692	%feature("docstring")
12658		gdcm::network::ULConnection::GetPresentationContexts "std::vector<PresentationContextRQ> const&
	12693	gdcm::network::ULConnection::GetPresentationContexts "const
	12694	std::vector<PresentationContextRQ>&
12659	12695	gdcm::network::ULConnection::GetPresentationContexts() const ";
12660	12696
12661	12697	%feature("docstring") gdcm::network::ULConnection::GetProtocol "std::iostream* gdcm::network::ULConnection::GetProtocol() ";

12677	12713	used to establish scp connections ";
12678	12714
12679	12715	%feature("docstring") gdcm::network::ULConnection::SetMaxPDUSize "void gdcm::network::ULConnection::SetMaxPDUSize(uint32_t inSize) ";
	12716
	12717	%feature("docstring")
	12718	gdcm::network::ULConnection::SetPresentationContexts "void
	12719	gdcm::network::ULConnection::SetPresentationContexts(const
	12720	std::vector< PresentationContext > &inContexts) ";
12680	12721
12681	12722	%feature("docstring")
12682	12723	gdcm::network::ULConnection::SetPresentationContexts "void
12683	12724	gdcm::network::ULConnection::SetPresentationContexts(const
12684	12725	std::vector< PresentationContextRQ > &inContexts) ";
12685
12686		%feature("docstring")
12687		gdcm::network::ULConnection::SetPresentationContexts "void
12688		gdcm::network::ULConnection::SetPresentationContexts(const
12689		std::vector< PresentationContext > &inContexts) ";
12690	12726
12691	12727	%feature("docstring") gdcm::network::ULConnection::SetState "void
12692	12728	gdcm::network::ULConnection::SetState(const EStateID &inState) ";

12945	12981
12946	12982	C++ includes: gdcmULEvent.h ";
12947	12983
12948		%feature("docstring") gdcm::network::ULEvent::ULEvent "gdcm::network::ULEvent::ULEvent(const EEventID &inEventID,
12949		std::vector< BasePDU > inBasePDU, std::istream iStream=nullptr,
12950		std::streampos posDataSet=0) ";
12951
12952	12984	%feature("docstring") gdcm::network::ULEvent::ULEvent "gdcm::network::ULEvent::ULEvent(const EEventID &inEventID, BasePDU
12953	12985	inBasePDU, std::istream iStream=nullptr, std::streampos
12954	12986	posDataSet=0) ";
12955	12987
	12988	%feature("docstring") gdcm::network::ULEvent::ULEvent "gdcm::network::ULEvent::ULEvent(const EEventID &inEventID,
	12989	std::vector< BasePDU * > inBasePDU, std::istream *iStream=nullptr,
	12990	std::streampos posDataSet=0) ";
	12991
12956	12992	%feature("docstring") gdcm::network::ULEvent::~ULEvent "gdcm::network::ULEvent::~ULEvent() ";
12957	12993
12958	12994	%feature("docstring") gdcm::network::ULEvent::GetDataSetPos "std::streampos gdcm::network::ULEvent::GetDataSetPos() const ";

12962	12998
12963	12999	%feature("docstring") gdcm::network::ULEvent::GetIStream "std::istream* gdcm::network::ULEvent::GetIStream() const ";
12964	13000
12965		%feature("docstring") gdcm::network::ULEvent::GetPDUs "std::vector<BasePDU*> const& gdcm::network::ULEvent::GetPDUs() const
12966		";
	13001	%feature("docstring") gdcm::network::ULEvent::GetPDUs "const
	13002	std::vector<BasePDU*>& gdcm::network::ULEvent::GetPDUs() const ";
12967	13003
12968	13004	%feature("docstring") gdcm::network::ULEvent::SetEvent "void
12969	13005	gdcm::network::ULEvent::SetEvent(const EEventID &inEvent) ";
12970	13006
12971	13007	%feature("docstring") gdcm::network::ULEvent::SetPDU "void
12972		gdcm::network::ULEvent::SetPDU(std::vector< BasePDU *> const &inPDU)
	13008	gdcm::network::ULEvent::SetPDU(std::vector< BasePDU * > const &inPDU)
12973	13009	";
12974	13010
12975	13011

13179	13215	const &s) ";
13180	13216
13181	13217	%feature("docstring")
	13218	gdcm::network::UserInformation::GetMaximumLengthSub "MaximumLengthSub&
	13219	gdcm::network::UserInformation::GetMaximumLengthSub() ";
	13220
	13221	%feature("docstring")
13182	13222	gdcm::network::UserInformation::GetMaximumLengthSub "const
13183	13223	MaximumLengthSub&
13184	13224	gdcm::network::UserInformation::GetMaximumLengthSub() const ";
13185
13186		%feature("docstring")
13187		gdcm::network::UserInformation::GetMaximumLengthSub "MaximumLengthSub&
13188		gdcm::network::UserInformation::GetMaximumLengthSub() ";
13189	13225
13190	13226	%feature("docstring") gdcm::network::UserInformation::Print "void
13191	13227	gdcm::network::UserInformation::Print(std::ostream &os) const ";

13485	13521	vtkGDCMImageReader::SetMedicalImageProperties(vtkMedicalImageProperties
13486	13522	*pd) ";
13487	13523
13488		%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LoadOverlays, int) ";
13489
13490		%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LoadIconImage, int) ";
13491
13492		%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LossyFlag, int) ";
13493
13494	13524	%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(ApplyLookupTable, int) ";
13495	13525
13496	13526	%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "int
13497	13527	vtkGDCMImageReader::vtkBooleanMacro(ApplyYBRToRGB, int) ";
13498	13528
13499		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LoadOverlays, int) ";
13500
13501		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LoadIconImage, int) ";
13502
13503		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LossyFlag, int) ";
13504
13505		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(NumberOfOverlays, int) ";
13506
13507		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(NumberOfIconImages, int) ";
	13529	%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LoadIconImage, int) ";
	13530
	13531	%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LoadOverlays, int) ";
	13532
	13533	%feature("docstring") vtkGDCMImageReader::vtkBooleanMacro "vtkGDCMImageReader::vtkBooleanMacro(LossyFlag, int) ";
13508	13534
13509	13535	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(ApplyLookupTable, int) ";
13510	13536

13513	13539
13514	13540	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(ImageFormat, int) ";
13515	13541
	13542	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LoadIconImage, int) ";
	13543
	13544	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LoadOverlays, int) ";
	13545
	13546	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(LossyFlag, int) ";
	13547
	13548	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(NumberOfIconImages, int) ";
	13549
	13550	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(NumberOfOverlays, int) ";
	13551
13516	13552	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(PlanarConfiguration, int) ";
13517	13553
	13554	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(Scale, double) ";
	13555
13518	13556	%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(Shift, double) ";
13519	13557
13520		%feature("docstring") vtkGDCMImageReader::vtkGetMacro "vtkGDCMImageReader::vtkGetMacro(Scale, double) ";
	13558	%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(Curve, vtkPolyData) ";
13521	13559
13522	13560	%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(DirectionCosines, vtkMatrix4x4)
13523	13561	";
	13562
	13563	%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(FileNames, vtkStringArray) ";
13524	13564
13525	13565	%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(MedicalImageProperties,
13526	13566	vtkMedicalImageProperties) ";
13527	13567
13528		%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(FileNames, vtkStringArray) ";
13529
13530		%feature("docstring") vtkGDCMImageReader::vtkGetObjectMacro "vtkGDCMImageReader::vtkGetObjectMacro(Curve, vtkPolyData) ";
13531
13532	13568	%feature("docstring") vtkGDCMImageReader::vtkGetVector3Macro "vtkGDCMImageReader::vtkGetVector3Macro(ImagePositionPatient, double)
13533	13569	";
13534	13570
13535	13571	%feature("docstring") vtkGDCMImageReader::vtkGetVector6Macro "vtkGDCMImageReader::vtkGetVector6Macro(ImageOrientationPatient,
13536	13572	double) ";
13537	13573
	13574	%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(ApplyLookupTable, int) ";
	13575
	13576	%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(LoadIconImage, int) ";
	13577
13538	13578	%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(LoadOverlays, int) ";
13539	13579
13540		%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(LoadIconImage, int) ";
13541
13542	13580	%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(LossyFlag, int) ";
13543
13544		%feature("docstring") vtkGDCMImageReader::vtkSetMacro "vtkGDCMImageReader::vtkSetMacro(ApplyLookupTable, int) ";
13545	13581
13546	13582	%feature("docstring") vtkGDCMImageReader::vtkTypeMacro "vtkGDCMImageReader::vtkTypeMacro(vtkGDCMImageReader,
13547	13583	vtkMedicalImageReader2) ";

13578	13614	vtkGDCMImageReader2::SetMedicalImageProperties(vtkMedicalImageProperties
13579	13615	*pd) ";
13580	13616
13581		%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LoadOverlays, int) ";
13582
13583		%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LoadIconImage, int) ";
13584
13585		%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LossyFlag, int) ";
13586
13587	13617	%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(ApplyLookupTable, int) ";
13588	13618
13589	13619	%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "int
13590	13620	vtkGDCMImageReader2::vtkBooleanMacro(ApplyYBRToRGB, int) ";
13591	13621
13592		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LoadOverlays, int) ";
13593
13594		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LoadIconImage, int) ";
13595
13596		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LossyFlag, int) ";
13597
13598		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(NumberOfOverlays, int) ";
13599
13600		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(NumberOfIconImages, int) ";
	13622	%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LoadIconImage, int) ";
	13623
	13624	%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LoadOverlays, int) ";
	13625
	13626	%feature("docstring") vtkGDCMImageReader2::vtkBooleanMacro "vtkGDCMImageReader2::vtkBooleanMacro(LossyFlag, int) ";
13601	13627
13602	13628	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(ApplyLookupTable, int) ";
13603	13629

13606	13632
13607	13633	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(ImageFormat, int) ";
13608	13634
	13635	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LoadIconImage, int) ";
	13636
	13637	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LoadOverlays, int) ";
	13638
	13639	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(LossyFlag, int) ";
	13640
	13641	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(NumberOfIconImages, int) ";
	13642
	13643	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(NumberOfOverlays, int) ";
	13644
13609	13645	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(PlanarConfiguration, int) ";
13610	13646
	13647	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(Scale, double) ";
	13648
13611	13649	%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(Shift, double) ";
13612	13650
13613		%feature("docstring") vtkGDCMImageReader2::vtkGetMacro "vtkGDCMImageReader2::vtkGetMacro(Scale, double) ";
	13651	%feature("docstring") vtkGDCMImageReader2::vtkGetObjectMacro "vtkGDCMImageReader2::vtkGetObjectMacro(Curve, vtkPolyData) ";
13614	13652
13615	13653	%feature("docstring") vtkGDCMImageReader2::vtkGetObjectMacro "vtkGDCMImageReader2::vtkGetObjectMacro(DirectionCosines, vtkMatrix4x4)
13616	13654	";
13617
13618		%feature("docstring") vtkGDCMImageReader2::vtkGetObjectMacro "vtkGDCMImageReader2::vtkGetObjectMacro(Curve, vtkPolyData) ";
13619	13655
13620	13656	%feature("docstring") vtkGDCMImageReader2::vtkGetVector3Macro "vtkGDCMImageReader2::vtkGetVector3Macro(ImagePositionPatient, double)
13621	13657	";

13623	13659	%feature("docstring") vtkGDCMImageReader2::vtkGetVector6Macro "vtkGDCMImageReader2::vtkGetVector6Macro(ImageOrientationPatient,
13624	13660	double) ";
13625	13661
	13662	%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(ApplyLookupTable, int) ";
	13663
	13664	%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(LoadIconImage, int) ";
	13665
13626	13666	%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(LoadOverlays, int) ";
13627	13667
13628		%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(LoadIconImage, int) ";
13629
13630	13668	%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(LossyFlag, int) ";
13631
13632		%feature("docstring") vtkGDCMImageReader2::vtkSetMacro "vtkGDCMImageReader2::vtkSetMacro(ApplyLookupTable, int) ";
13633	13669
13634	13670	%feature("docstring") vtkGDCMImageReader2::vtkTypeMacro "vtkGDCMImageReader2::vtkTypeMacro(vtkGDCMImageReader2,
13635	13671	vtkMedicalImageReader2) ";

13662	13698	vtkGDCMImageWriter::SetMedicalImageProperties(vtkMedicalImageProperties
13663	13699	*) ";
13664	13700
	13701	%feature("docstring") vtkGDCMImageWriter::vtkBooleanMacro "vtkGDCMImageWriter::vtkBooleanMacro(FileLowerLeft, int) ";
	13702
13665	13703	%feature("docstring") vtkGDCMImageWriter::vtkBooleanMacro "vtkGDCMImageWriter::vtkBooleanMacro(LossyFlag, int) ";
13666	13704
13667		%feature("docstring") vtkGDCMImageWriter::vtkBooleanMacro "vtkGDCMImageWriter::vtkBooleanMacro(FileLowerLeft, int) ";
	13705	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(CompressionType, int) ";
	13706
	13707	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(FileLowerLeft, int) ";
	13708
	13709	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(ImageFormat, int) ";
13668	13710
13669	13711	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(LossyFlag, int) ";
13670	13712
	13713	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(PlanarConfiguration, int) ";
	13714
	13715	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(Scale, double) ";
	13716
13671	13717	%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(Shift, double) ";
13672	13718
13673		%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(Scale, double) ";
13674
13675		%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(ImageFormat, int) ";
13676
13677		%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(FileLowerLeft, int) ";
13678
13679		%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(PlanarConfiguration, int) ";
13680
13681		%feature("docstring") vtkGDCMImageWriter::vtkGetMacro "vtkGDCMImageWriter::vtkGetMacro(CompressionType, int) ";
	13719	%feature("docstring") vtkGDCMImageWriter::vtkGetObjectMacro "vtkGDCMImageWriter::vtkGetObjectMacro(DirectionCosines, vtkMatrix4x4)
	13720	";
	13721
	13722	%feature("docstring") vtkGDCMImageWriter::vtkGetObjectMacro "vtkGDCMImageWriter::vtkGetObjectMacro(FileNames, vtkStringArray) ";
13682	13723
13683	13724	%feature("docstring") vtkGDCMImageWriter::vtkGetObjectMacro "vtkGDCMImageWriter::vtkGetObjectMacro(MedicalImageProperties,
13684	13725	vtkMedicalImageProperties) ";
13685	13726
13686		%feature("docstring") vtkGDCMImageWriter::vtkGetObjectMacro "vtkGDCMImageWriter::vtkGetObjectMacro(FileNames, vtkStringArray) ";
13687
13688		%feature("docstring") vtkGDCMImageWriter::vtkGetObjectMacro "vtkGDCMImageWriter::vtkGetObjectMacro(DirectionCosines, vtkMatrix4x4)
13689		";
	13727	%feature("docstring") vtkGDCMImageWriter::vtkGetStringMacro "vtkGDCMImageWriter::vtkGetStringMacro(SeriesUID) ";
13690	13728
13691	13729	%feature("docstring") vtkGDCMImageWriter::vtkGetStringMacro "vtkGDCMImageWriter::vtkGetStringMacro(StudyUID) ";
13692	13730
13693		%feature("docstring") vtkGDCMImageWriter::vtkGetStringMacro "vtkGDCMImageWriter::vtkGetStringMacro(SeriesUID) ";
	13731	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(CompressionType, int) ";
	13732
	13733	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(FileLowerLeft, int) ";
	13734
	13735	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(ImageFormat, int) ";
13694	13736
13695	13737	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(LossyFlag, int) ";
13696	13738
	13739	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(PlanarConfiguration, int) ";
	13740
	13741	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(Scale, double) ";
	13742
13697	13743	%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(Shift, double) ";
13698	13744
13699		%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(Scale, double) ";
13700
13701		%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(ImageFormat, int) ";
13702
13703		%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(FileLowerLeft, int) ";
13704
13705		%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(PlanarConfiguration, int) ";
13706
13707		%feature("docstring") vtkGDCMImageWriter::vtkSetMacro "vtkGDCMImageWriter::vtkSetMacro(CompressionType, int) ";
	13745	%feature("docstring") vtkGDCMImageWriter::vtkSetStringMacro "vtkGDCMImageWriter::vtkSetStringMacro(SeriesUID) ";
13708	13746
13709	13747	%feature("docstring") vtkGDCMImageWriter::vtkSetStringMacro "vtkGDCMImageWriter::vtkSetStringMacro(StudyUID) ";
13710
13711		%feature("docstring") vtkGDCMImageWriter::vtkSetStringMacro "vtkGDCMImageWriter::vtkSetStringMacro(SeriesUID) ";
13712	13748
13713	13749	%feature("docstring") vtkGDCMImageWriter::vtkTypeMacro "vtkGDCMImageWriter::vtkTypeMacro(vtkGDCMImageWriter, vtkImageWriter)
13714	13750	";

13803	13839
13804	13840	%feature("docstring") vtkGDCMThreadedImageReader::vtkGetMacro "vtkGDCMThreadedImageReader::vtkGetMacro(UseShiftScale, int) ";
13805	13841
	13842	%feature("docstring") vtkGDCMThreadedImageReader::vtkSetMacro "vtkGDCMThreadedImageReader::vtkSetMacro(Scale, double) ";
	13843
13806	13844	%feature("docstring") vtkGDCMThreadedImageReader::vtkSetMacro "vtkGDCMThreadedImageReader::vtkSetMacro(Shift, double) ";
13807
13808		%feature("docstring") vtkGDCMThreadedImageReader::vtkSetMacro "vtkGDCMThreadedImageReader::vtkSetMacro(Scale, double) ";
13809	13845
13810	13846	%feature("docstring") vtkGDCMThreadedImageReader::vtkSetMacro "vtkGDCMThreadedImageReader::vtkSetMacro(UseShiftScale, int) ";
13811	13847

13839	13875
13840	13876	%feature("docstring") vtkGDCMThreadedImageReader2::vtkBooleanMacro "vtkGDCMThreadedImageReader2::vtkBooleanMacro(UseShiftScale, int) ";
13841	13877
	13878	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(DataScalarType, int) ";
	13879
13842	13880	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(FileLowerLeft, int) ";
13843	13881
	13882	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(LoadOverlays, int) ";
	13883
13844	13884	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(NumberOfOverlays, int) ";
13845
13846		%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(DataScalarType, int) ";
13847	13885
13848	13886	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(NumberOfScalarComponents,
13849	13887	int) ";
13850	13888
13851		%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(LoadOverlays, int) ";
	13889	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(Scale, double) ";
13852	13890
13853	13891	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(Shift, double) ";
13854
13855		%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(Scale, double) ";
13856	13892
13857	13893	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetMacro "vtkGDCMThreadedImageReader2::vtkGetMacro(UseShiftScale, int) ";
13858	13894

13871	13907	%feature("docstring") vtkGDCMThreadedImageReader2::vtkGetVector6Macro
13872	13908	"vtkGDCMThreadedImageReader2::vtkGetVector6Macro(DataExtent, int) ";
13873	13909
	13910	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(DataScalarType, int) ";
	13911
13874	13912	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(FileLowerLeft, int) ";
13875	13913
13876		%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(DataScalarType, int) ";
	13914	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(LoadOverlays, int) ";
13877	13915
13878	13916	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(NumberOfScalarComponents,
13879	13917	int) ";
13880	13918
13881		%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(LoadOverlays, int) ";
	13919	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(Scale, double) ";
13882	13920
13883	13921	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(Shift, double) ";
13884
13885		%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(Scale, double) ";
13886	13922
13887	13923	%feature("docstring") vtkGDCMThreadedImageReader2::vtkSetMacro "vtkGDCMThreadedImageReader2::vtkSetMacro(UseShiftScale, int) ";
13888	13924

13937	13973	vtkImageColorViewer::GetSliceMin() ";
13938	13974
13939	13975	%feature("docstring") vtkImageColorViewer::GetSliceRange "virtual
13940		void vtkImageColorViewer::GetSliceRange(int range[2]) ";
	13976	int* vtkImageColorViewer::GetSliceRange() ";
13941	13977
13942	13978	%feature("docstring") vtkImageColorViewer::GetSliceRange "virtual
13943	13979	void vtkImageColorViewer::GetSliceRange(int &min, int &max) ";
13944	13980
13945	13981	%feature("docstring") vtkImageColorViewer::GetSliceRange "virtual
13946		int* vtkImageColorViewer::GetSliceRange() ";
	13982	void vtkImageColorViewer::GetSliceRange(int range[2]) ";
13947	13983
13948	13984	%feature("docstring") vtkImageColorViewer::GetWindowName "virtual
13949	13985	const char* vtkImageColorViewer::GetWindowName() ";

14015	14051
14016	14052	%feature("docstring") vtkImageColorViewer::UpdateDisplayExtent "virtual void vtkImageColorViewer::UpdateDisplayExtent() ";
14017	14053
	14054	%feature("docstring") vtkImageColorViewer::VTK_LEGACY "vtkImageColorViewer::VTK_LEGACY(int GetWholeZMax()) ";
	14055
14018	14056	%feature("docstring") vtkImageColorViewer::VTK_LEGACY "vtkImageColorViewer::VTK_LEGACY(int GetWholeZMin()) ";
14019	14057
14020		%feature("docstring") vtkImageColorViewer::VTK_LEGACY "vtkImageColorViewer::VTK_LEGACY(int GetWholeZMax()) ";
14021
14022	14058	%feature("docstring") vtkImageColorViewer::VTK_LEGACY "vtkImageColorViewer::VTK_LEGACY(int GetZSlice()) ";
14023	14059
14024	14060	%feature("docstring") vtkImageColorViewer::VTK_LEGACY "vtkImageColorViewer::VTK_LEGACY(void SetZSlice(int)) ";
14025	14061
14026	14062	%feature("docstring") vtkImageColorViewer::vtkBooleanMacro "vtkImageColorViewer::vtkBooleanMacro(OffScreenRendering, int) ";
14027	14063
	14064	%feature("docstring") vtkImageColorViewer::vtkGetMacro "vtkImageColorViewer::vtkGetMacro(Slice, int) ";
	14065
14028	14066	%feature("docstring") vtkImageColorViewer::vtkGetMacro "vtkImageColorViewer::vtkGetMacro(SliceOrientation, int) ";
14029	14067
14030		%feature("docstring") vtkImageColorViewer::vtkGetMacro "vtkImageColorViewer::vtkGetMacro(Slice, int) ";
	14068	%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(ImageActor, vtkImageActor) ";
	14069
	14070	%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(InteractorStyle,
	14071	vtkInteractorStyleImage) ";
	14072
	14073	%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(Renderer, vtkRenderer) ";
14031	14074
14032	14075	%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(RenderWindow, vtkRenderWindow)
14033	14076	";
14034
14035		%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(Renderer, vtkRenderer) ";
14036
14037		%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(ImageActor, vtkImageActor) ";
14038	14077
14039	14078	%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(WindowLevel,
14040	14079	vtkImageMapToWindowLevelColors2) ";
14041
14042		%feature("docstring") vtkImageColorViewer::vtkGetObjectMacro "vtkImageColorViewer::vtkGetObjectMacro(InteractorStyle,
14043		vtkInteractorStyleImage) ";
14044	14080
14045	14081	%feature("docstring") vtkImageColorViewer::vtkTypeMacro "vtkImageColorViewer::vtkTypeMacro(vtkImageColorViewer, vtkObject) ";
14046	14082

14072	14108
14073	14109	%feature("docstring") vtkImageMapToColors16::vtkBooleanMacro "vtkImageMapToColors16::vtkBooleanMacro(PassAlphaToOutput, int) ";
14074	14110
	14111	%feature("docstring") vtkImageMapToColors16::vtkGetMacro "vtkImageMapToColors16::vtkGetMacro(ActiveComponent, int) ";
	14112
14075	14113	%feature("docstring") vtkImageMapToColors16::vtkGetMacro "vtkImageMapToColors16::vtkGetMacro(OutputFormat, int) ";
14076
14077		%feature("docstring") vtkImageMapToColors16::vtkGetMacro "vtkImageMapToColors16::vtkGetMacro(ActiveComponent, int) ";
14078	14114
14079	14115	%feature("docstring") vtkImageMapToColors16::vtkGetMacro "vtkImageMapToColors16::vtkGetMacro(PassAlphaToOutput, int) ";
14080	14116
14081	14117	%feature("docstring") vtkImageMapToColors16::vtkGetObjectMacro "vtkImageMapToColors16::vtkGetObjectMacro(LookupTable,
14082	14118	vtkScalarsToColors) ";
14083	14119
	14120	%feature("docstring") vtkImageMapToColors16::vtkSetMacro "vtkImageMapToColors16::vtkSetMacro(ActiveComponent, int) ";
	14121
14084	14122	%feature("docstring") vtkImageMapToColors16::vtkSetMacro "vtkImageMapToColors16::vtkSetMacro(OutputFormat, int) ";
14085
14086		%feature("docstring") vtkImageMapToColors16::vtkSetMacro "vtkImageMapToColors16::vtkSetMacro(ActiveComponent, int) ";
14087	14123
14088	14124	%feature("docstring") vtkImageMapToColors16::vtkSetMacro "vtkImageMapToColors16::vtkSetMacro(PassAlphaToOutput, int) ";
14089	14125

14098	14134	%feature("docstring") vtkImageMapToWindowLevelColors2::PrintSelf "void vtkImageMapToWindowLevelColors2::PrintSelf(ostream &os, vtkIndent
14099	14135	indent) ";
14100	14136
	14137	%feature("docstring") vtkImageMapToWindowLevelColors2::vtkGetMacro "vtkImageMapToWindowLevelColors2::vtkGetMacro(Level, double) ";
	14138
14101	14139	%feature("docstring") vtkImageMapToWindowLevelColors2::vtkGetMacro "vtkImageMapToWindowLevelColors2::vtkGetMacro(Window, double) ";
14102	14140
14103		%feature("docstring") vtkImageMapToWindowLevelColors2::vtkGetMacro "vtkImageMapToWindowLevelColors2::vtkGetMacro(Level, double) ";
	14141	%feature("docstring") vtkImageMapToWindowLevelColors2::vtkSetMacro "vtkImageMapToWindowLevelColors2::vtkSetMacro(Level, double) ";
14104	14142
14105	14143	%feature("docstring") vtkImageMapToWindowLevelColors2::vtkSetMacro "vtkImageMapToWindowLevelColors2::vtkSetMacro(Window, double) ";
14106
14107		%feature("docstring") vtkImageMapToWindowLevelColors2::vtkSetMacro "vtkImageMapToWindowLevelColors2::vtkSetMacro(Level, double) ";
14108	14144
14109	14145	%feature("docstring") vtkImageMapToWindowLevelColors2::vtkTypeMacro "vtkImageMapToWindowLevelColors2::vtkTypeMacro(vtkImageMapToWindowLevelColors2,
14110	14146	vtkImageMapToColors) ";

14285	14321	%feature("docstring") vtkRTStructSetProperties::PrintSelf "void
14286	14322	vtkRTStructSetProperties::PrintSelf(ostream &os, vtkIndent indent) ";
14287	14323
	14324	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(ReferenceFrameOfReferenceUID)
	14325	";
	14326
	14327	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(ReferenceSeriesInstanceUID)
	14328	";
	14329
	14330	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(SeriesInstanceUID) ";
	14331
	14332	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(SOPInstanceUID) ";
	14333
	14334	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StructureSetDate) ";
	14335
14288	14336	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StructureSetLabel) ";
14289	14337
14290	14338	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StructureSetName) ";
14291	14339
14292		%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StructureSetDate) ";
14293
14294	14340	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StructureSetTime) ";
14295	14341
14296		%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(SOPInstanceUID) ";
14297
14298	14342	%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(StudyInstanceUID) ";
14299	14343
14300		%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(SeriesInstanceUID) ";
14301
14302		%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(ReferenceSeriesInstanceUID)
14303		";
14304
14305		%feature("docstring") vtkRTStructSetProperties::vtkGetStringMacro "vtkRTStructSetProperties::vtkGetStringMacro(ReferenceFrameOfReferenceUID)
14306		";
	14344	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(ReferenceFrameOfReferenceUID)
	14345	";
	14346
	14347	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(ReferenceSeriesInstanceUID)
	14348	";
	14349
	14350	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(SeriesInstanceUID) ";
	14351
	14352	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(SOPInstanceUID) ";
	14353
	14354	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StructureSetDate) ";
14307	14355
14308	14356	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StructureSetLabel) ";
14309	14357
14310	14358	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StructureSetName) ";
14311	14359
14312		%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StructureSetDate) ";
14313
14314	14360	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StructureSetTime) ";
14315	14361
14316		%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(SOPInstanceUID) ";
14317
14318	14362	%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(StudyInstanceUID) ";
14319
14320		%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(SeriesInstanceUID) ";
14321
14322		%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(ReferenceSeriesInstanceUID)
14323		";
14324
14325		%feature("docstring") vtkRTStructSetProperties::vtkSetStringMacro "vtkRTStructSetProperties::vtkSetStringMacro(ReferenceFrameOfReferenceUID)
14326		";
14327	14363
14328	14364	%feature("docstring") vtkRTStructSetProperties::vtkTypeMacro "vtkRTStructSetProperties::vtkTypeMacro(vtkRTStructSetProperties,
14329	14365	vtkObject) ";

14552	14588	%feature("docstring") gdcm::network::add1 "static int
14553	14589	gdcm::add1(char *buf, int n) ";
14554	14590
14555		%feature("docstring") gdcm::network::backslash "ignore_char const
	14591	%feature("docstring") gdcm::network::backslash "const ignore_char
14556	14592	gdcm::backslash('\\\\\\\\') ";
14557	14593
14558	14594	%feature("docstring") gdcm::network::Clamp "static T gdcm::Clamp(int

15570	15606	// File: dir_dbf95c1d90c5a901881337453263e002.xml
15571	15607
15572	15608
	15609	// File: dir_952e636b135cd251326f90c6c3f1b54a.xml
	15610
	15611
15573	15612	// File: dir_18f0eb58264c0e5251b09e2a1c43e69e.xml
15574	15613
15575	15614
	15615	// File: dir_a8ec3c19f3c7e072ef6deff7fa46dee5.xml
	15616
	15617
15576	15618	// File: dir_43e0a1f539e00dcfa1a6bc4d4fee4fc2.xml
15577	15619
15578	15620

15594	15636	// File: dir_c65ec574e088a3fb8c01ccf67a472041.xml
15595	15637
15596	15638
	15639	// File: dir_7f79c74866d8aba106fb47a8e7816411.xml
	15640
	15641
15597	15642	// File: dir_b7bc1d3f8c76b5f778038891003f2f25.xml
15598	15643
15599	15644

16074	16119	// File: SimplePrint_8cs-example.xml
16075	16120
16076	16121
	16122	// File: SimplePrint_8java-example.xml
	16123
	16124
16077	16125	// File: SimplePrintPatientName_8cs-example.xml
16078	16126
16079	16127