Mercurial > hg > orthanc
annotate UnitTestsSources/FromDcmtkTests.cpp @ 3705:d8b214a46b91 storage-commitment
integration mainline->storage-commitment
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Thu, 27 Feb 2020 12:07:19 +0100 |
parents | 4922bdd046dd |
children | 2a170a8f1faf |
rev | line source |
---|---|
827
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
1 /** |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
2 * Orthanc - A Lightweight, RESTful DICOM Store |
1900 | 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
1288
6e7e5ed91c2d
upgrade to year 2015
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1091
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
3640
94f4a18a79cc
upgrade to year 2020
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3518
diff
changeset
|
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium |
827
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
6 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
7 * This program is free software: you can redistribute it and/or |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
8 * modify it under the terms of the GNU General Public License as |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
9 * published by the Free Software Foundation, either version 3 of the |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
10 * License, or (at your option) any later version. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
11 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
12 * In addition, as a special exception, the copyright holders of this |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
13 * program give permission to link the code of its release with the |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
14 * OpenSSL project's "OpenSSL" library (or with modified versions of it |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
15 * that use the same license as the "OpenSSL" library), and distribute |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
16 * the linked executables. You must obey the GNU General Public License |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
17 * in all respects for all of the code used other than "OpenSSL". If you |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
18 * modify file(s) with this exception, you may extend this exception to |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
19 * your version of the file(s), but you are not obligated to do so. If |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
20 * you do not wish to do so, delete this exception statement from your |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
21 * version. If you delete this exception statement from all source files |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
22 * in the program, then also delete it here. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
23 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
24 * This program is distributed in the hope that it will be useful, but |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
25 * WITHOUT ANY WARRANTY; without even the implied warranty of |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
27 * General Public License for more details. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
28 * |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
29 * You should have received a copy of the GNU General Public License |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
30 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
31 **/ |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
32 |
3d6f9b7d0add
precompiled headers in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
33 |
831
84513f2ee1f3
pch for unit tests and server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
827
diff
changeset
|
34 #include "PrecompiledHeadersUnitTests.h" |
782 | 35 #include "gtest/gtest.h" |
36 | |
3083
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
37 #include "../Core/DicomNetworking/DicomFindAnswers.h" |
2382
7284093111b0
big reorganization to cleanly separate framework vs. server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2381
diff
changeset
|
38 #include "../Core/DicomParsing/DicomModification.h" |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
39 #include "../Core/DicomParsing/DicomWebJsonVisitor.h" |
3083
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
40 #include "../Core/DicomParsing/FromDcmtkBridge.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
41 #include "../Core/DicomParsing/Internals/DicomImageDecoder.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
42 #include "../Core/DicomParsing/ToDcmtkBridge.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
43 #include "../Core/Endianness.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
44 #include "../Core/Images/Image.h" |
1612
96582230ddcb
Core/ImageFormats folder renamed as Core/Images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1562
diff
changeset
|
45 #include "../Core/Images/ImageBuffer.h" |
3083
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
46 #include "../Core/Images/ImageProcessing.h" |
1612
96582230ddcb
Core/ImageFormats folder renamed as Core/Images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1562
diff
changeset
|
47 #include "../Core/Images/PngReader.h" |
96582230ddcb
Core/ImageFormats folder renamed as Core/Images
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1562
diff
changeset
|
48 #include "../Core/Images/PngWriter.h" |
3083
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
49 #include "../Core/OrthancException.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
50 #include "../Core/SystemToolbox.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
51 #include "../OrthancServer/ServerToolbox.h" |
683d572424b6
IDatabaseWrapper::SetResourcesContent
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
52 #include "../Plugins/Engine/PluginsEnumerations.h" |
1088
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
53 #include "../Resources/EncodingTests.h" |
782 | 54 |
1690 | 55 #include <dcmtk/dcmdata/dcelem.h> |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
56 #include <dcmtk/dcmdata/dcdeftag.h> |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
57 #include <boost/algorithm/string/predicate.hpp> |
1690 | 58 |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
59 #if ORTHANC_ENABLE_PUGIXML == 1 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
60 # include <pugixml.hpp> |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
61 #endif |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
62 |
782 | 63 using namespace Orthanc; |
64 | |
65 TEST(DicomFormat, Tag) | |
66 { | |
2115
a657f7772e69
Handling of private tags/creators in the "Dictionary" configuration option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2107
diff
changeset
|
67 ASSERT_EQ("PatientName", FromDcmtkBridge::GetTagName(DicomTag(0x0010, 0x0010), "")); |
782 | 68 |
69 DicomTag t = FromDcmtkBridge::ParseTag("SeriesDescription"); | |
70 ASSERT_EQ(0x0008, t.GetGroup()); | |
71 ASSERT_EQ(0x103E, t.GetElement()); | |
72 | |
73 t = FromDcmtkBridge::ParseTag("0020-e040"); | |
74 ASSERT_EQ(0x0020, t.GetGroup()); | |
75 ASSERT_EQ(0xe040, t.GetElement()); | |
76 | |
77 // Test ==() and !=() operators | |
78 ASSERT_TRUE(DICOM_TAG_PATIENT_ID == DicomTag(0x0010, 0x0020)); | |
79 ASSERT_FALSE(DICOM_TAG_PATIENT_ID != DicomTag(0x0010, 0x0020)); | |
80 } | |
81 | |
82 | |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
83 TEST(DicomModification, Basic) |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
84 { |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
85 DicomModification m; |
2309
4dc313b9a20a
Argument "DicomVersion" in URIs "/{...}/{...}/anonymization"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
86 m.SetupAnonymization(DicomVersion_2008); |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
87 //m.SetLevel(DicomRootLevel_Study); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
88 //m.ReplacePlainString(DICOM_TAG_PATIENT_ID, "coucou"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
89 //m.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "coucou"); |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
90 |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
91 ParsedDicomFile o(true); |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
92 o.SaveToFile("UnitTestsResults/anon.dcm"); |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
93 |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
94 for (int i = 0; i < 10; i++) |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
95 { |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
96 char b[1024]; |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
97 sprintf(b, "UnitTestsResults/anon%06d.dcm", i); |
2521
6db878376018
support anonymization of CurrentRequestedProcedureEvidenceSequence
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
98 std::auto_ptr<ParsedDicomFile> f(o.Clone(false)); |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
99 if (i > 4) |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
100 o.ReplacePlainString(DICOM_TAG_SERIES_INSTANCE_UID, "coucou"); |
784
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
101 m.Apply(*f); |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
102 f->SaveToFile(b); |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
103 } |
efd0215736d9
start of anonymization refactoring
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
782
diff
changeset
|
104 } |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
105 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
106 |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
107 TEST(DicomModification, Anonymization) |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
108 { |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
109 ASSERT_EQ(DICOM_TAG_PATIENT_NAME, FromDcmtkBridge::ParseTag("PatientName")); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
110 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
111 const DicomTag privateTag(0x0045, 0x1010); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
112 const DicomTag privateTag2(FromDcmtkBridge::ParseTag("0031-1020")); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
113 ASSERT_TRUE(privateTag.IsPrivate()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
114 ASSERT_TRUE(privateTag2.IsPrivate()); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
115 ASSERT_EQ(0x0031, privateTag2.GetGroup()); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
116 ASSERT_EQ(0x1020, privateTag2.GetElement()); |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
117 |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
118 std::string s; |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
119 ParsedDicomFile o(true); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
120 o.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "coucou"); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
121 ASSERT_FALSE(o.GetTagValue(s, privateTag)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
122 o.Insert(privateTag, "private tag", false, "OrthancCreator"); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
123 ASSERT_TRUE(o.GetTagValue(s, privateTag)); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
124 ASSERT_STREQ("private tag", s.c_str()); |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
125 |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
126 ASSERT_FALSE(o.GetTagValue(s, privateTag2)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
127 ASSERT_THROW(o.Replace(privateTag2, std::string("hello"), false, DicomReplaceMode_ThrowIfAbsent, "OrthancCreator"), OrthancException); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
128 ASSERT_FALSE(o.GetTagValue(s, privateTag2)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
129 o.Replace(privateTag2, std::string("hello"), false, DicomReplaceMode_IgnoreIfAbsent, "OrthancCreator"); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
130 ASSERT_FALSE(o.GetTagValue(s, privateTag2)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
131 o.Replace(privateTag2, std::string("hello"), false, DicomReplaceMode_InsertIfAbsent, "OrthancCreator"); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
132 ASSERT_TRUE(o.GetTagValue(s, privateTag2)); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
133 ASSERT_STREQ("hello", s.c_str()); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
134 o.Replace(privateTag2, std::string("hello world"), false, DicomReplaceMode_InsertIfAbsent, "OrthancCreator"); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
135 ASSERT_TRUE(o.GetTagValue(s, privateTag2)); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
136 ASSERT_STREQ("hello world", s.c_str()); |
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
137 |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
138 ASSERT_TRUE(o.GetTagValue(s, DICOM_TAG_PATIENT_NAME)); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
139 ASSERT_FALSE(Toolbox::IsUuid(s)); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
140 |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
141 DicomModification m; |
2309
4dc313b9a20a
Argument "DicomVersion" in URIs "/{...}/{...}/anonymization"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
142 m.SetupAnonymization(DicomVersion_2008); |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
143 m.Keep(privateTag); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
144 |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
145 m.Apply(o); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
146 |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
147 ASSERT_TRUE(o.GetTagValue(s, DICOM_TAG_PATIENT_NAME)); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
148 ASSERT_TRUE(Toolbox::IsUuid(s)); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
149 ASSERT_TRUE(o.GetTagValue(s, privateTag)); |
1307
f796207e3df1
Fix replacement and insertion of private DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
150 ASSERT_STREQ("private tag", s.c_str()); |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
151 |
2309
4dc313b9a20a
Argument "DicomVersion" in URIs "/{...}/{...}/anonymization"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2244
diff
changeset
|
152 m.SetupAnonymization(DicomVersion_2008); |
991
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
153 m.Apply(o); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
154 ASSERT_FALSE(o.GetTagValue(s, privateTag)); |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
155 } |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
156 |
2f76b92addd4
keep private tags during anonymization
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
967
diff
changeset
|
157 |
802 | 158 #include <dcmtk/dcmdata/dcuid.h> |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
159 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
160 TEST(DicomModification, Png) |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
161 { |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
162 // Red dot in http://en.wikipedia.org/wiki/Data_URI_scheme (RGBA image) |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
163 std::string s = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
164 |
1641
4e56b5a206b7
Support of binary tags encoded using data URI scheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1612
diff
changeset
|
165 std::string m, cc; |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1971
diff
changeset
|
166 ASSERT_TRUE(Toolbox::DecodeDataUriScheme(m, cc, s)); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
167 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
168 ASSERT_EQ("image/png", m); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
169 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
170 PngReader reader; |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
171 reader.ReadFromMemory(cc); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
172 |
1492 | 173 ASSERT_EQ(5u, reader.GetHeight()); |
174 ASSERT_EQ(5u, reader.GetWidth()); | |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
175 ASSERT_EQ(PixelFormat_RGBA32, reader.GetFormat()); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
176 |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
177 ParsedDicomFile o(true); |
1562 | 178 o.EmbedContent(s); |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
179 o.SaveToFile("UnitTestsResults/png1.dcm"); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
180 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
181 // Red dot, without alpha channel |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
182 s = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAIAAAACDbGyAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3gUGDTcIn2+8BgAAACJJREFUCNdj/P//PwMjIwME/P/P+J8BBTAxEOL/R9Lx/z8AynoKAXOeiV8AAAAASUVORK5CYII="; |
1562 | 183 o.EmbedContent(s); |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
184 o.SaveToFile("UnitTestsResults/png2.dcm"); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
185 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
186 // Check box in Graylevel8 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
187 s = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAB3RJTUUH3gUGDDcB53FulQAAAElJREFUGNNtj0sSAEEEQ1+U+185s1CtmRkblQ9CZldsKHJDk6DLGLJa6chjh0ooQmpjXMM86zPwydGEj6Ed/UGykkEM8X+p3u8/8LcOJIWLGeMAAAAASUVORK5CYII="; |
1562 | 188 o.EmbedContent(s); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
189 //o.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, UID_DigitalXRayImageStorageForProcessing); |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
190 o.SaveToFile("UnitTestsResults/png3.dcm"); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
191 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
192 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
193 { |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
194 // Gradient in Graylevel16 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
195 |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
196 ImageBuffer img; |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
197 img.SetWidth(256); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
198 img.SetHeight(256); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
199 img.SetFormat(PixelFormat_Grayscale16); |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
200 |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
201 ImageAccessor accessor; |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
202 img.GetWriteableAccessor(accessor); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
203 |
1654
3727a09e7b53
fix some icc warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1641
diff
changeset
|
204 uint16_t v = 0; |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
205 for (unsigned int y = 0; y < img.GetHeight(); y++) |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
206 { |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
207 uint16_t *p = reinterpret_cast<uint16_t*>(accessor.GetRow(y)); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
208 for (unsigned int x = 0; x < img.GetWidth(); x++, p++, v++) |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
209 { |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
210 *p = v; |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
211 } |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
212 } |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
213 |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
214 o.EmbedImage(accessor); |
803
4689e400e0fa
directory to store the results of the unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
802
diff
changeset
|
215 o.SaveToFile("UnitTestsResults/png4.dcm"); |
800
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
216 } |
ecedd89055db
generation of DICOM images from PNG files
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
786
diff
changeset
|
217 } |
1088
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
218 |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
219 |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
220 TEST(FromDcmtkBridge, Encodings1) |
1088
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
221 { |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
222 for (unsigned int i = 0; i < testEncodingsCount; i++) |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
223 { |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
224 std::string source(testEncodingsEncoded[i]); |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
225 std::string expected(testEncodingsExpected[i]); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
226 std::string s = Toolbox::ConvertToUtf8(source, testEncodings[i], false); |
1695 | 227 //std::cout << EnumerationToString(testEncodings[i]) << std::endl; |
1089 | 228 EXPECT_EQ(expected, s); |
1088
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
229 } |
6fd4434c1bcf
unit tests for encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
991
diff
changeset
|
230 } |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
231 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
232 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
233 TEST(FromDcmtkBridge, Enumerations) |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
234 { |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
235 // http://dicom.nema.org/medical/dicom/current/output/html/part03.html#sect_C.12.1.1.2 |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
236 Encoding e; |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
237 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
238 ASSERT_FALSE(GetDicomEncoding(e, "")); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
239 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 6")); ASSERT_EQ(Encoding_Ascii, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
240 |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
241 // http://dicom.nema.org/medical/dicom/current/output/html/part03.html#table_C.12-2 |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
242 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 100")); ASSERT_EQ(Encoding_Latin1, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
243 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 101")); ASSERT_EQ(Encoding_Latin2, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
244 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 109")); ASSERT_EQ(Encoding_Latin3, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
245 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 110")); ASSERT_EQ(Encoding_Latin4, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
246 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 144")); ASSERT_EQ(Encoding_Cyrillic, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
247 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 127")); ASSERT_EQ(Encoding_Arabic, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
248 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 126")); ASSERT_EQ(Encoding_Greek, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
249 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 138")); ASSERT_EQ(Encoding_Hebrew, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
250 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 148")); ASSERT_EQ(Encoding_Latin5, e); |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
251 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 13")); ASSERT_EQ(Encoding_Japanese, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
252 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 166")); ASSERT_EQ(Encoding_Thai, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
253 |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
254 // http://dicom.nema.org/medical/dicom/current/output/html/part03.html#table_C.12-3 |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
255 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 6")); ASSERT_EQ(Encoding_Ascii, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
256 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 100")); ASSERT_EQ(Encoding_Latin1, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
257 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 101")); ASSERT_EQ(Encoding_Latin2, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
258 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 109")); ASSERT_EQ(Encoding_Latin3, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
259 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 110")); ASSERT_EQ(Encoding_Latin4, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
260 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 144")); ASSERT_EQ(Encoding_Cyrillic, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
261 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 127")); ASSERT_EQ(Encoding_Arabic, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
262 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 126")); ASSERT_EQ(Encoding_Greek, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
263 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 138")); ASSERT_EQ(Encoding_Hebrew, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
264 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 148")); ASSERT_EQ(Encoding_Latin5, e); |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
265 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 13")); ASSERT_EQ(Encoding_Japanese, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
266 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 166")); ASSERT_EQ(Encoding_Thai, e); |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
267 |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
268 // http://dicom.nema.org/medical/dicom/current/output/html/part03.html#table_C.12-4 |
3219 | 269 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 87")); ASSERT_EQ(Encoding_JapaneseKanji, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
270 ASSERT_FALSE(GetDicomEncoding(e, "ISO 2022 IR 159")); //ASSERT_EQ(Encoding_JapaneseKanjiSupplementary, e); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
271 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 149")); ASSERT_EQ(Encoding_Korean, e); |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
272 ASSERT_TRUE(GetDicomEncoding(e, "ISO 2022 IR 58")); ASSERT_EQ(Encoding_SimplifiedChinese, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
273 |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
274 // http://dicom.nema.org/medical/dicom/current/output/html/part03.html#table_C.12-5 |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
275 ASSERT_TRUE(GetDicomEncoding(e, "ISO_IR 192")); ASSERT_EQ(Encoding_Utf8, e); |
1908
5096681efce6
direct hyperlinks to the DICOM standard
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1900
diff
changeset
|
276 ASSERT_TRUE(GetDicomEncoding(e, "GB18030")); ASSERT_EQ(Encoding_Chinese, e); |
2401
a051aba0037c
Use "GBK" (frequently used in China) as an alias for "GB18030"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2382
diff
changeset
|
277 ASSERT_TRUE(GetDicomEncoding(e, "GBK")); ASSERT_EQ(Encoding_Chinese, e); |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
278 } |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
279 |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
280 |
1091 | 281 TEST(FromDcmtkBridge, Encodings3) |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
282 { |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
283 for (unsigned int i = 0; i < testEncodingsCount; i++) |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
284 { |
1695 | 285 //std::cout << EnumerationToString(testEncodings[i]) << std::endl; |
1091 | 286 std::string dicom; |
287 | |
288 { | |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
289 ParsedDicomFile f(true); |
1091 | 290 f.SetEncoding(testEncodings[i]); |
1695 | 291 |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
292 std::string s = Toolbox::ConvertToUtf8(testEncodingsEncoded[i], testEncodings[i], false); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
293 f.Insert(DICOM_TAG_PATIENT_NAME, s, false, ""); |
1091 | 294 f.SaveToMemoryBuffer(dicom); |
295 } | |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
296 |
1347 | 297 if (testEncodings[i] != Encoding_Windows1251) |
1091 | 298 { |
299 ParsedDicomFile g(dicom); | |
300 | |
301 if (testEncodings[i] != Encoding_Ascii) | |
302 { | |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
303 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
304 ASSERT_EQ(testEncodings[i], g.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
305 ASSERT_FALSE(hasCodeExtensions); |
1091 | 306 } |
307 | |
308 std::string tag; | |
309 ASSERT_TRUE(g.GetTagValue(tag, DICOM_TAG_PATIENT_NAME)); | |
310 ASSERT_EQ(std::string(testEncodingsExpected[i]), tag); | |
311 } | |
1090
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
312 } |
e494ceb8d763
support more encodings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1089
diff
changeset
|
313 } |
1360 | 314 |
315 | |
1417
8e23f16a198d
fix issues 35 and 37
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1360
diff
changeset
|
316 TEST(FromDcmtkBridge, ValueRepresentation) |
1360 | 317 { |
2007
655489d9165d
DicomMap::ParseDicomMetaInformation()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2006
diff
changeset
|
318 ASSERT_EQ(ValueRepresentation_PersonName, |
2006
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
319 FromDcmtkBridge::LookupValueRepresentation(DICOM_TAG_PATIENT_NAME)); |
1417
8e23f16a198d
fix issues 35 and 37
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1360
diff
changeset
|
320 ASSERT_EQ(ValueRepresentation_Date, |
2006
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
321 FromDcmtkBridge::LookupValueRepresentation(DicomTag(0x0008, 0x0020) /* StudyDate */)); |
1417
8e23f16a198d
fix issues 35 and 37
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1360
diff
changeset
|
322 ASSERT_EQ(ValueRepresentation_Time, |
2006
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
323 FromDcmtkBridge::LookupValueRepresentation(DicomTag(0x0008, 0x0030) /* StudyTime */)); |
1417
8e23f16a198d
fix issues 35 and 37
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1360
diff
changeset
|
324 ASSERT_EQ(ValueRepresentation_DateTime, |
2006
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
325 FromDcmtkBridge::LookupValueRepresentation(DicomTag(0x0008, 0x002a) /* AcquisitionDateTime */)); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
326 ASSERT_EQ(ValueRepresentation_NotSupported, |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
327 FromDcmtkBridge::LookupValueRepresentation(DicomTag(0x0001, 0x0001) /* some private tag */)); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
328 } |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
329 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
330 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
331 TEST(FromDcmtkBridge, ValueRepresentationConversions) |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
332 { |
3048
8b331be57606
fix build without plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2861
diff
changeset
|
333 #if ORTHANC_ENABLE_PLUGINS == 1 |
2006
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
334 ASSERT_EQ(1, ValueRepresentation_ApplicationEntity); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
335 ASSERT_EQ(1, OrthancPluginValueRepresentation_AE); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
336 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
337 for (int i = ValueRepresentation_ApplicationEntity; |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
338 i <= ValueRepresentation_NotSupported; i++) |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
339 { |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
340 ValueRepresentation vr = static_cast<ValueRepresentation>(i); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
341 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
342 if (vr == ValueRepresentation_NotSupported) |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
343 { |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
344 ASSERT_THROW(ToDcmtkBridge::Convert(vr), OrthancException); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
345 ASSERT_THROW(Plugins::Convert(vr), OrthancException); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
346 } |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
347 else if (vr == ValueRepresentation_OtherDouble || |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
348 vr == ValueRepresentation_OtherLong || |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
349 vr == ValueRepresentation_UniversalResource || |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
350 vr == ValueRepresentation_UnlimitedCharacters) |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
351 { |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
352 // These VR are not supported as of DCMTK 3.6.0 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
353 ASSERT_THROW(ToDcmtkBridge::Convert(vr), OrthancException); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
354 ASSERT_EQ(OrthancPluginValueRepresentation_UN, Plugins::Convert(vr)); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
355 } |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
356 else |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
357 { |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
358 ASSERT_EQ(vr, FromDcmtkBridge::Convert(ToDcmtkBridge::Convert(vr))); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
359 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
360 OrthancPluginValueRepresentation plugins = Plugins::Convert(vr); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
361 ASSERT_EQ(vr, Plugins::Convert(plugins)); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
362 } |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
363 } |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
364 |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
365 for (int i = OrthancPluginValueRepresentation_AE; |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
366 i <= OrthancPluginValueRepresentation_UT; i++) |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
367 { |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
368 OrthancPluginValueRepresentation plugins = static_cast<OrthancPluginValueRepresentation>(i); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
369 ValueRepresentation orthanc = Plugins::Convert(plugins); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
370 ASSERT_EQ(plugins, Plugins::Convert(orthanc)); |
6301bbcbcaed
more generic support of value representations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1982
diff
changeset
|
371 } |
3048
8b331be57606
fix build without plugins
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2861
diff
changeset
|
372 #endif |
1360 | 373 } |
1690 | 374 |
375 | |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
376 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
377 static const DicomTag REFERENCED_STUDY_SEQUENCE(0x0008, 0x1110); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
378 static const DicomTag REFERENCED_PATIENT_SEQUENCE(0x0008, 0x1120); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
379 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
380 static void CreateSampleJson(Json::Value& a) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
381 { |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
382 { |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
383 Json::Value b = Json::objectValue; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
384 b["PatientName"] = "Hello"; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
385 b["PatientID"] = "World"; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
386 b["StudyDescription"] = "Toto"; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
387 a.append(b); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
388 } |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
389 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
390 { |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
391 Json::Value b = Json::objectValue; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
392 b["PatientName"] = "data:application/octet-stream;base64,SGVsbG8y"; // echo -n "Hello2" | base64 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
393 b["PatientID"] = "World2"; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
394 a.append(b); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
395 } |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
396 } |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
397 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
398 |
2126 | 399 namespace Orthanc |
1690 | 400 { |
2126 | 401 // Namespace for the "FRIEND_TEST()" directive in "FromDcmtkBridge" to apply: |
402 // https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md#private-class-members | |
403 TEST(FromDcmtkBridge, FromJson) | |
1690 | 404 { |
2126 | 405 std::auto_ptr<DcmElement> element; |
1690 | 406 |
407 { | |
2126 | 408 Json::Value a; |
409 a = "Hello"; | |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
410 element.reset(FromDcmtkBridge::FromJson(DICOM_TAG_PATIENT_NAME, a, false, Encoding_Utf8, "")); |
2126 | 411 |
1690 | 412 Json::Value b; |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
413 std::set<DicomTag> ignoreTagLength; |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
414 ignoreTagLength.insert(DICOM_TAG_PATIENT_ID); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
415 |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
416 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Short, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
417 DicomToJsonFlags_Default, 0, Encoding_Ascii, false, ignoreTagLength); |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
418 ASSERT_TRUE(b.isMember("0010,0010")); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
419 ASSERT_EQ("Hello", b["0010,0010"].asString()); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
420 |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
421 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Short, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
422 DicomToJsonFlags_Default, 3, Encoding_Ascii, false, ignoreTagLength); |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
423 ASSERT_TRUE(b["0010,0010"].isNull()); // "Hello" has more than 3 characters |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
424 |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
425 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Full, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
426 DicomToJsonFlags_Default, 3, Encoding_Ascii, false, ignoreTagLength); |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
427 ASSERT_TRUE(b["0010,0010"].isObject()); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
428 ASSERT_EQ("PatientName", b["0010,0010"]["Name"].asString()); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
429 ASSERT_EQ("TooLong", b["0010,0010"]["Type"].asString()); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
430 ASSERT_TRUE(b["0010,0010"]["Value"].isNull()); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
431 |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
432 ignoreTagLength.insert(DICOM_TAG_PATIENT_NAME); |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
433 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Short, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
434 DicomToJsonFlags_Default, 3, Encoding_Ascii, false, ignoreTagLength); |
2126 | 435 ASSERT_EQ("Hello", b["0010,0010"].asString()); |
436 } | |
1690 | 437 |
2126 | 438 { |
439 Json::Value a; | |
440 a = "Hello"; | |
441 // Cannot assign a string to a sequence | |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
442 ASSERT_THROW(element.reset(FromDcmtkBridge::FromJson(REFERENCED_STUDY_SEQUENCE, a, false, Encoding_Utf8, "")), OrthancException); |
2126 | 443 } |
444 | |
445 { | |
446 Json::Value a = Json::arrayValue; | |
447 a.append("Hello"); | |
448 // Cannot assign an array to a string | |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
449 ASSERT_THROW(element.reset(FromDcmtkBridge::FromJson(DICOM_TAG_PATIENT_NAME, a, false, Encoding_Utf8, "")), OrthancException); |
1690 | 450 } |
451 | |
1692 | 452 { |
2126 | 453 Json::Value a; |
454 a = "data:application/octet-stream;base64,SGVsbG8="; // echo -n "Hello" | base64 | |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
455 element.reset(FromDcmtkBridge::FromJson(DICOM_TAG_PATIENT_NAME, a, true, Encoding_Utf8, "")); |
2126 | 456 |
1692 | 457 Json::Value b; |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
458 std::set<DicomTag> ignoreTagLength; |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
459 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Short, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
460 DicomToJsonFlags_Default, 0, Encoding_Ascii, false, ignoreTagLength); |
2126 | 461 ASSERT_EQ("Hello", b["0010,0010"].asString()); |
462 } | |
463 | |
464 { | |
465 Json::Value a = Json::arrayValue; | |
466 CreateSampleJson(a); | |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
467 element.reset(FromDcmtkBridge::FromJson(REFERENCED_STUDY_SEQUENCE, a, true, Encoding_Utf8, "")); |
1690 | 468 |
2126 | 469 { |
470 Json::Value b; | |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
471 std::set<DicomTag> ignoreTagLength; |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
472 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Short, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
473 DicomToJsonFlags_Default, 0, Encoding_Ascii, false, ignoreTagLength); |
2126 | 474 ASSERT_EQ(Json::arrayValue, b["0008,1110"].type()); |
475 ASSERT_EQ(2u, b["0008,1110"].size()); | |
476 | |
477 Json::Value::ArrayIndex i = (b["0008,1110"][0]["0010,0010"].asString() == "Hello") ? 0 : 1; | |
1690 | 478 |
2126 | 479 ASSERT_EQ(3u, b["0008,1110"][i].size()); |
480 ASSERT_EQ(2u, b["0008,1110"][1 - i].size()); | |
481 ASSERT_EQ(b["0008,1110"][i]["0010,0010"].asString(), "Hello"); | |
482 ASSERT_EQ(b["0008,1110"][i]["0010,0020"].asString(), "World"); | |
483 ASSERT_EQ(b["0008,1110"][i]["0008,1030"].asString(), "Toto"); | |
484 ASSERT_EQ(b["0008,1110"][1 - i]["0010,0010"].asString(), "Hello2"); | |
485 ASSERT_EQ(b["0008,1110"][1 - i]["0010,0020"].asString(), "World2"); | |
486 } | |
487 | |
488 { | |
489 Json::Value b; | |
2409
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
490 std::set<DicomTag> ignoreTagLength; |
e4045b3c9772
ignore-length argument if retrieving DICOM tags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2401
diff
changeset
|
491 FromDcmtkBridge::ElementToJson(b, *element, DicomToJsonFormat_Full, |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
492 DicomToJsonFlags_Default, 0, Encoding_Ascii, false, ignoreTagLength); |
2126 | 493 |
494 Json::Value c; | |
495 ServerToolbox::SimplifyTags(c, b, DicomToJsonFormat_Human); | |
496 | |
497 a[1]["PatientName"] = "Hello2"; // To remove the Data URI Scheme encoding | |
498 ASSERT_EQ(0, c["ReferencedStudySequence"].compare(a)); | |
499 } | |
1692 | 500 } |
501 } | |
1690 | 502 } |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
503 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
504 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
505 TEST(ParsedDicomFile, InsertReplaceStrings) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
506 { |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
507 ParsedDicomFile f(true); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
508 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
509 f.Insert(DICOM_TAG_PATIENT_NAME, "World", false, ""); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
510 ASSERT_THROW(f.Insert(DICOM_TAG_PATIENT_ID, "Hello", false, ""), OrthancException); // Already existing tag |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
511 f.ReplacePlainString(DICOM_TAG_SOP_INSTANCE_UID, "Toto"); // (*) |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
512 f.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, "Tata"); // (**) |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
513 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
514 std::string s; |
2209
e3fd5bc429a2
URI to reconstruct the main DICOM tags, the JSON summary and the metadata
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2207
diff
changeset
|
515 ASSERT_FALSE(f.LookupTransferSyntax(s)); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
516 |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
517 ASSERT_THROW(f.Replace(DICOM_TAG_ACCESSION_NUMBER, std::string("Accession"), |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
518 false, DicomReplaceMode_ThrowIfAbsent, ""), OrthancException); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
519 f.Replace(DICOM_TAG_ACCESSION_NUMBER, std::string("Accession"), false, DicomReplaceMode_IgnoreIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
520 ASSERT_FALSE(f.GetTagValue(s, DICOM_TAG_ACCESSION_NUMBER)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
521 f.Replace(DICOM_TAG_ACCESSION_NUMBER, std::string("Accession"), false, DicomReplaceMode_InsertIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
522 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_ACCESSION_NUMBER)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
523 ASSERT_EQ(s, "Accession"); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
524 f.Replace(DICOM_TAG_ACCESSION_NUMBER, std::string("Accession2"), false, DicomReplaceMode_IgnoreIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
525 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_ACCESSION_NUMBER)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
526 ASSERT_EQ(s, "Accession2"); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
527 f.Replace(DICOM_TAG_ACCESSION_NUMBER, std::string("Accession3"), false, DicomReplaceMode_ThrowIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
528 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_ACCESSION_NUMBER)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
529 ASSERT_EQ(s, "Accession3"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
530 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
531 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_PATIENT_NAME)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
532 ASSERT_EQ(s, "World"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
533 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_SOP_INSTANCE_UID)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
534 ASSERT_EQ(s, "Toto"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
535 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_MEDIA_STORAGE_SOP_INSTANCE_UID)); // Implicitly modified by (*) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
536 ASSERT_EQ(s, "Toto"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
537 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_SOP_CLASS_UID)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
538 ASSERT_EQ(s, "Tata"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
539 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_MEDIA_STORAGE_SOP_CLASS_UID)); // Implicitly modified by (**) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
540 ASSERT_EQ(s, "Tata"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
541 } |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
542 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
543 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
544 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
545 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
546 TEST(ParsedDicomFile, InsertReplaceJson) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
547 { |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
548 ParsedDicomFile f(true); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
549 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
550 Json::Value a; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
551 CreateSampleJson(a); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
552 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
553 ASSERT_FALSE(f.HasTag(REFERENCED_STUDY_SEQUENCE)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
554 f.Remove(REFERENCED_STUDY_SEQUENCE); // No effect |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
555 f.Insert(REFERENCED_STUDY_SEQUENCE, a, true, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
556 ASSERT_TRUE(f.HasTag(REFERENCED_STUDY_SEQUENCE)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
557 ASSERT_THROW(f.Insert(REFERENCED_STUDY_SEQUENCE, a, true, ""), OrthancException); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
558 f.Remove(REFERENCED_STUDY_SEQUENCE); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
559 ASSERT_FALSE(f.HasTag(REFERENCED_STUDY_SEQUENCE)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
560 f.Insert(REFERENCED_STUDY_SEQUENCE, a, true, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
561 ASSERT_TRUE(f.HasTag(REFERENCED_STUDY_SEQUENCE)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
562 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
563 ASSERT_FALSE(f.HasTag(REFERENCED_PATIENT_SEQUENCE)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
564 ASSERT_THROW(f.Replace(REFERENCED_PATIENT_SEQUENCE, a, false, DicomReplaceMode_ThrowIfAbsent, ""), OrthancException); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
565 ASSERT_FALSE(f.HasTag(REFERENCED_PATIENT_SEQUENCE)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
566 f.Replace(REFERENCED_PATIENT_SEQUENCE, a, false, DicomReplaceMode_IgnoreIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
567 ASSERT_FALSE(f.HasTag(REFERENCED_PATIENT_SEQUENCE)); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
568 f.Replace(REFERENCED_PATIENT_SEQUENCE, a, false, DicomReplaceMode_InsertIfAbsent, ""); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
569 ASSERT_TRUE(f.HasTag(REFERENCED_PATIENT_SEQUENCE)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
570 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
571 { |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
572 Json::Value b; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
573 f.DatasetToJson(b, DicomToJsonFormat_Full, DicomToJsonFlags_Default, 0); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
574 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
575 Json::Value c; |
2120 | 576 ServerToolbox::SimplifyTags(c, b, DicomToJsonFormat_Human); |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
577 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
578 ASSERT_EQ(0, c["ReferencedPatientSequence"].compare(a)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
579 ASSERT_NE(0, c["ReferencedStudySequence"].compare(a)); // Because Data URI Scheme decoding was enabled |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
580 } |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
581 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
582 a = "data:application/octet-stream;base64,VGF0YQ=="; // echo -n "Tata" | base64 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
583 f.Replace(DICOM_TAG_SOP_INSTANCE_UID, a, false, DicomReplaceMode_InsertIfAbsent, ""); // (*) |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
584 f.Replace(DICOM_TAG_SOP_CLASS_UID, a, true, DicomReplaceMode_InsertIfAbsent, ""); // (**) |
1693
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
585 |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
586 std::string s; |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
587 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_SOP_INSTANCE_UID)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
588 ASSERT_EQ(s, a.asString()); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
589 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_MEDIA_STORAGE_SOP_INSTANCE_UID)); // Implicitly modified by (*) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
590 ASSERT_EQ(s, a.asString()); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
591 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_SOP_CLASS_UID)); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
592 ASSERT_EQ(s, "Tata"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
593 ASSERT_TRUE(f.GetTagValue(s, DICOM_TAG_MEDIA_STORAGE_SOP_CLASS_UID)); // Implicitly modified by (**) |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
594 ASSERT_EQ(s, "Tata"); |
558b25228a23
creation of tag hierarchy from json
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1692
diff
changeset
|
595 } |
1695 | 596 |
597 | |
598 TEST(ParsedDicomFile, JsonEncoding) | |
599 { | |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
600 ParsedDicomFile f(true); |
1695 | 601 |
602 for (unsigned int i = 0; i < testEncodingsCount; i++) | |
603 { | |
604 if (testEncodings[i] != Encoding_Windows1251) | |
605 { | |
606 //std::cout << EnumerationToString(testEncodings[i]) << std::endl; | |
607 f.SetEncoding(testEncodings[i]); | |
608 | |
609 if (testEncodings[i] != Encoding_Ascii) | |
610 { | |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
611 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
612 ASSERT_EQ(testEncodings[i], f.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
613 ASSERT_FALSE(hasCodeExtensions); |
1695 | 614 } |
615 | |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
616 Json::Value s = Toolbox::ConvertToUtf8(testEncodingsEncoded[i], testEncodings[i], false); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
617 f.Replace(DICOM_TAG_PATIENT_NAME, s, false, DicomReplaceMode_InsertIfAbsent, ""); |
1695 | 618 |
619 Json::Value v; | |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
620 f.DatasetToJson(v, DicomToJsonFormat_Human, DicomToJsonFlags_Default, 0); |
1695 | 621 ASSERT_EQ(v["PatientName"].asString(), std::string(testEncodingsExpected[i])); |
622 } | |
623 } | |
624 } | |
1735
a001f6226c7c
primitives for flags in dicom-to-json conversions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1701
diff
changeset
|
625 |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
626 |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
627 TEST(ParsedDicomFile, ToJsonFlags1) |
1735
a001f6226c7c
primitives for flags in dicom-to-json conversions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1701
diff
changeset
|
628 { |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
629 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(0x7053, 0x1000), ValueRepresentation_OtherByte, "MyPrivateTag", 1, 1, "OrthancCreator"); |
2115
a657f7772e69
Handling of private tags/creators in the "Dictionary" configuration option
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2107
diff
changeset
|
630 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(0x7050, 0x1000), ValueRepresentation_PersonName, "Declared public tag", 1, 1, ""); |
1736
b953c6eef28d
ToJson: IncludePrivateTags and IncludeUnknownTags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1735
diff
changeset
|
631 |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
632 ParsedDicomFile f(true); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
633 f.Insert(DicomTag(0x7050, 0x1000), "Some public tag", false, ""); // Even group => public tag |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
634 f.Insert(DicomTag(0x7052, 0x1000), "Some unknown tag", false, ""); // Even group => public, unknown tag |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
635 f.Insert(DicomTag(0x7053, 0x1000), "Some private tag", false, "OrthancCreator"); // Odd group => private tag |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
636 |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
637 Json::Value v; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
638 f.DatasetToJson(v, DicomToJsonFormat_Short, DicomToJsonFlags_None, 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
639 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
640 ASSERT_EQ(6u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
641 ASSERT_FALSE(v.isMember("7052,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
642 ASSERT_FALSE(v.isMember("7053,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
643 ASSERT_TRUE(v.isMember("7050,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
644 ASSERT_EQ(Json::stringValue, v["7050,1000"].type()); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
645 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1735
a001f6226c7c
primitives for flags in dicom-to-json conversions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1701
diff
changeset
|
646 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
647 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePrivateTags | DicomToJsonFlags_IncludeBinary | DicomToJsonFlags_ConvertBinaryToNull), 0); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
648 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
649 ASSERT_EQ(7u, v.getMemberNames().size()); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
650 ASSERT_FALSE(v.isMember("7052,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
651 ASSERT_TRUE(v.isMember("7050,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
652 ASSERT_TRUE(v.isMember("7053,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
653 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
654 ASSERT_EQ(Json::nullValue, v["7053,1000"].type()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
655 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
656 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePrivateTags), 0); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
657 ASSERT_EQ(Json::objectValue, v.type()); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
658 ASSERT_EQ(6u, v.getMemberNames().size()); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
659 ASSERT_FALSE(v.isMember("7052,1000")); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
660 ASSERT_TRUE(v.isMember("7050,1000")); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
661 ASSERT_FALSE(v.isMember("7053,1000")); |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
662 |
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
663 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePrivateTags | DicomToJsonFlags_IncludeBinary), 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
664 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
665 ASSERT_EQ(7u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
666 ASSERT_FALSE(v.isMember("7052,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
667 ASSERT_TRUE(v.isMember("7050,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
668 ASSERT_TRUE(v.isMember("7053,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
669 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
670 std::string mime, content; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
671 ASSERT_EQ(Json::stringValue, v["7053,1000"].type()); |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1971
diff
changeset
|
672 ASSERT_TRUE(Toolbox::DecodeDataUriScheme(mime, content, v["7053,1000"].asString())); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
673 ASSERT_EQ("application/octet-stream", mime); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
674 ASSERT_EQ("Some private tag", content); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
675 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
676 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludeUnknownTags | DicomToJsonFlags_IncludeBinary | DicomToJsonFlags_ConvertBinaryToNull), 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
677 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
678 ASSERT_EQ(7u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
679 ASSERT_TRUE(v.isMember("7050,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
680 ASSERT_TRUE(v.isMember("7052,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
681 ASSERT_FALSE(v.isMember("7053,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
682 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
683 ASSERT_EQ(Json::nullValue, v["7052,1000"].type()); |
1735
a001f6226c7c
primitives for flags in dicom-to-json conversions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1701
diff
changeset
|
684 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
685 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludeUnknownTags | DicomToJsonFlags_IncludeBinary), 0); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
686 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
687 ASSERT_EQ(7u, v.getMemberNames().size()); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
688 ASSERT_TRUE(v.isMember("7050,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
689 ASSERT_TRUE(v.isMember("7052,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
690 ASSERT_FALSE(v.isMember("7053,1000")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
691 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
692 ASSERT_EQ(Json::stringValue, v["7052,1000"].type()); |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1971
diff
changeset
|
693 ASSERT_TRUE(Toolbox::DecodeDataUriScheme(mime, content, v["7052,1000"].asString())); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
694 ASSERT_EQ("application/octet-stream", mime); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
695 ASSERT_EQ("Some unknown tag", content); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
696 |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
697 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludeUnknownTags | DicomToJsonFlags_IncludePrivateTags | DicomToJsonFlags_IncludeBinary | DicomToJsonFlags_ConvertBinaryToNull), 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
698 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
699 ASSERT_EQ(8u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
700 ASSERT_TRUE(v.isMember("7050,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
701 ASSERT_TRUE(v.isMember("7052,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
702 ASSERT_TRUE(v.isMember("7053,1000")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
703 ASSERT_EQ("Some public tag", v["7050,1000"].asString()); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
704 ASSERT_EQ(Json::nullValue, v["7052,1000"].type()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
705 ASSERT_EQ(Json::nullValue, v["7053,1000"].type()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
706 } |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
707 |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
708 |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
709 TEST(ParsedDicomFile, ToJsonFlags2) |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
710 { |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
711 ParsedDicomFile f(true); |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
712 f.Insert(DICOM_TAG_PIXEL_DATA, "Pixels", false, ""); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
713 |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
714 Json::Value v; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
715 f.DatasetToJson(v, DicomToJsonFormat_Short, DicomToJsonFlags_None, 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
716 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
717 ASSERT_EQ(5u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
718 ASSERT_FALSE(v.isMember("7fe0,0010")); |
1736
b953c6eef28d
ToJson: IncludePrivateTags and IncludeUnknownTags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1735
diff
changeset
|
719 |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
720 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePixelData | DicomToJsonFlags_ConvertBinaryToNull), 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
721 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
722 ASSERT_EQ(6u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
723 ASSERT_TRUE(v.isMember("7fe0,0010")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
724 ASSERT_EQ(Json::nullValue, v["7fe0,0010"].type()); |
1736
b953c6eef28d
ToJson: IncludePrivateTags and IncludeUnknownTags
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1735
diff
changeset
|
725 |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
726 f.DatasetToJson(v, DicomToJsonFormat_Short, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePixelData | DicomToJsonFlags_ConvertBinaryToAscii), 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
727 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
728 ASSERT_EQ(6u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
729 ASSERT_TRUE(v.isMember("7fe0,0010")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
730 ASSERT_EQ(Json::stringValue, v["7fe0,0010"].type()); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
731 ASSERT_EQ("Pixels", v["7fe0,0010"].asString()); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
732 |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
733 f.DatasetToJson(v, DicomToJsonFormat_Short, DicomToJsonFlags_IncludePixelData, 0); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
734 ASSERT_EQ(Json::objectValue, v.type()); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
735 ASSERT_EQ(6u, v.getMemberNames().size()); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
736 ASSERT_TRUE(v.isMember("7fe0,0010")); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
737 ASSERT_EQ(Json::stringValue, v["7fe0,0010"].type()); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
738 std::string mime, content; |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1971
diff
changeset
|
739 ASSERT_TRUE(Toolbox::DecodeDataUriScheme(mime, content, v["7fe0,0010"].asString())); |
1739
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
740 ASSERT_EQ("application/octet-stream", mime); |
df331354cea2
include binary in ToJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1736
diff
changeset
|
741 ASSERT_EQ("Pixels", content); |
1735
a001f6226c7c
primitives for flags in dicom-to-json conversions
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1701
diff
changeset
|
742 } |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
743 |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
744 |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
745 TEST(DicomFindAnswers, Basic) |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
746 { |
2059 | 747 DicomFindAnswers a(false); |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
748 |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
749 { |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
750 DicomMap m; |
2007
655489d9165d
DicomMap::ParseDicomMetaInformation()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2006
diff
changeset
|
751 m.SetValue(DICOM_TAG_PATIENT_ID, "hello", false); |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
752 a.Add(m); |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
753 } |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
754 |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
755 { |
1805
f08978b1f45b
c-find scu for modality worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1789
diff
changeset
|
756 ParsedDicomFile d(true); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
757 d.ReplacePlainString(DICOM_TAG_PATIENT_ID, "my"); |
1789 | 758 a.Add(d); |
759 } | |
760 | |
761 { | |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
762 DicomMap m; |
2007
655489d9165d
DicomMap::ParseDicomMetaInformation()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2006
diff
changeset
|
763 m.SetValue(DICOM_TAG_PATIENT_ID, "world", false); |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
764 a.Add(m); |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
765 } |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
766 |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
767 Json::Value j; |
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
768 a.ToJson(j, true); |
1789 | 769 ASSERT_EQ(3u, j.size()); |
770 | |
771 //std::cout << j; | |
1787
1b1d5470233f
refactoring of DicomFindAnswers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1739
diff
changeset
|
772 } |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
773 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
774 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
775 TEST(ParsedDicomFile, FromJson) |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
776 { |
2117 | 777 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(0x7057, 0x1000), ValueRepresentation_OtherByte, "MyPrivateTag2", 1, 1, "ORTHANC"); |
778 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(0x7059, 0x1000), ValueRepresentation_OtherByte, "MyPrivateTag3", 1, 1, ""); | |
779 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(0x7050, 0x1000), ValueRepresentation_PersonName, "Declared public tag2", 1, 1, ""); | |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
780 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
781 Json::Value v; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
782 const std::string sopClassUid = "1.2.840.10008.5.1.4.1.1.1"; // CR Image Storage: |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
783 |
2117 | 784 // Test the private creator |
785 ASSERT_EQ(DcmTag_ERROR_TagName, FromDcmtkBridge::GetTagName(DicomTag(0x7057, 0x1000), "NOPE")); | |
786 ASSERT_EQ("MyPrivateTag2", FromDcmtkBridge::GetTagName(DicomTag(0x7057, 0x1000), "ORTHANC")); | |
787 | |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
788 { |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
789 v["SOPClassUID"] = sopClassUid; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
790 v["SpecificCharacterSet"] = "ISO_IR 148"; // This is latin-5 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
791 v["PatientName"] = "Sébastien"; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
792 v["7050-1000"] = "Some public tag"; // Even group => public tag |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
793 v["7052-1000"] = "Some unknown tag"; // Even group => public, unknown tag |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
794 v["7057-1000"] = "Some private tag"; // Odd group => private tag |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
795 v["7059-1000"] = "Some private tag2"; // Odd group => private tag, with an odd length to test padding |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
796 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
797 std::string s; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
798 Toolbox::EncodeDataUriScheme(s, "application/octet-stream", "Sebastien"); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
799 v["StudyDescription"] = s; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
800 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
801 v["PixelData"] = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=="; // A red dot of 5x5 pixels |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
802 v["0040,0100"] = Json::arrayValue; // ScheduledProcedureStepSequence |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
803 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
804 Json::Value vv; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
805 vv["Modality"] = "MR"; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
806 v["0040,0100"].append(vv); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
807 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
808 vv["Modality"] = "CT"; |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
809 v["0040,0100"].append(vv); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
810 } |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
811 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
812 const DicomToJsonFlags toJsonFlags = static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludeBinary | |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
813 DicomToJsonFlags_IncludePixelData | |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
814 DicomToJsonFlags_IncludePrivateTags | |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
815 DicomToJsonFlags_IncludeUnknownTags | |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
816 DicomToJsonFlags_ConvertBinaryToAscii); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
817 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
818 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
819 { |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
820 std::auto_ptr<ParsedDicomFile> dicom |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
821 (ParsedDicomFile::CreateFromJson(v, static_cast<DicomFromJsonFlags>(DicomFromJsonFlags_GenerateIdentifiers), "")); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
822 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
823 Json::Value vv; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
824 dicom->DatasetToJson(vv, DicomToJsonFormat_Human, toJsonFlags, 0); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
825 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
826 ASSERT_EQ(vv["SOPClassUID"].asString(), sopClassUid); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
827 ASSERT_EQ(vv["MediaStorageSOPClassUID"].asString(), sopClassUid); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
828 ASSERT_TRUE(vv.isMember("SOPInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
829 ASSERT_TRUE(vv.isMember("SeriesInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
830 ASSERT_TRUE(vv.isMember("StudyInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
831 ASSERT_TRUE(vv.isMember("PatientID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
832 } |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
833 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
834 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
835 { |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
836 std::auto_ptr<ParsedDicomFile> dicom |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
837 (ParsedDicomFile::CreateFromJson(v, static_cast<DicomFromJsonFlags>(DicomFromJsonFlags_GenerateIdentifiers), "")); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
838 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
839 Json::Value vv; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
840 dicom->DatasetToJson(vv, DicomToJsonFormat_Human, static_cast<DicomToJsonFlags>(DicomToJsonFlags_IncludePixelData), 0); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
841 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
842 std::string mime, content; |
1981
4b545a8b1f95
return code in Toolbox::DecodeDataUriScheme
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1971
diff
changeset
|
843 ASSERT_TRUE(Toolbox::DecodeDataUriScheme(mime, content, vv["PixelData"].asString())); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
844 ASSERT_EQ("application/octet-stream", mime); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
845 ASSERT_EQ(5u * 5u * 3u /* the red dot is 5x5 pixels in RGB24 */ + 1 /* for padding */, content.size()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
846 } |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
847 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
848 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
849 { |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
850 std::auto_ptr<ParsedDicomFile> dicom |
3691
4922bdd046dd
Fix issue #140 (Modifying private tags with REST API changes VR from LO to UN) - DANGEROUS COMMIT
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
851 (ParsedDicomFile::CreateFromJson(v, static_cast<DicomFromJsonFlags>(DicomFromJsonFlags_DecodeDataUriScheme), "")); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
852 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
853 Json::Value vv; |
2128
9329ba17a069
Possibility to DELETE "dicom-as-json" attachments to reconstruct them
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2126
diff
changeset
|
854 dicom->DatasetToJson(vv, DicomToJsonFormat_Short, toJsonFlags, 0); |
1818
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
855 |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
856 ASSERT_FALSE(vv.isMember("SOPInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
857 ASSERT_FALSE(vv.isMember("SeriesInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
858 ASSERT_FALSE(vv.isMember("StudyInstanceUID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
859 ASSERT_FALSE(vv.isMember("PatientID")); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
860 ASSERT_EQ(2u, vv["0040,0100"].size()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
861 ASSERT_EQ("MR", vv["0040,0100"][0]["0008,0060"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
862 ASSERT_EQ("CT", vv["0040,0100"][1]["0008,0060"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
863 ASSERT_EQ("Some public tag", vv["7050,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
864 ASSERT_EQ("Some unknown tag", vv["7052,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
865 ASSERT_EQ("Some private tag", vv["7057,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
866 ASSERT_EQ("Some private tag2", vv["7059,1000"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
867 ASSERT_EQ("Sébastien", vv["0010,0010"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
868 ASSERT_EQ("Sebastien", vv["0008,1030"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
869 ASSERT_EQ("ISO_IR 148", vv["0008,0005"].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
870 ASSERT_EQ("5", vv[DICOM_TAG_ROWS.Format()].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
871 ASSERT_EQ("5", vv[DICOM_TAG_COLUMNS.Format()].asString()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
872 ASSERT_TRUE(vv[DICOM_TAG_PIXEL_DATA.Format()].asString().empty()); |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
873 } |
1065401501fb
ParsedDicomFile::CreateFromJson
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1805
diff
changeset
|
874 } |
1937 | 875 |
876 | |
877 | |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
878 TEST(TestImages, PatternGrayscale8) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
879 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
880 static const char* PATH = "UnitTestsResults/PatternGrayscale8.dcm"; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
881 |
2107 | 882 Orthanc::Image image(Orthanc::PixelFormat_Grayscale8, 256, 256, false); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
883 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
884 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
885 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
886 uint8_t *p = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
887 for (int x = 0; x < 256; x++, p++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
888 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
889 *p = y; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
890 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
891 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
892 |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
893 Orthanc::ImageAccessor r; |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
894 |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
895 image.GetRegion(r, 32, 32, 64, 192); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
896 Orthanc::ImageProcessing::Set(r, 0); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
897 |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
898 image.GetRegion(r, 160, 32, 64, 192); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
899 Orthanc::ImageProcessing::Set(r, 255); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
900 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
901 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
902 ParsedDicomFile f(true); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
903 f.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.7"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
904 f.ReplacePlainString(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.276.0.7230010.3.1.2.2831176407.321.1458901422.884998"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
905 f.ReplacePlainString(DICOM_TAG_PATIENT_ID, "ORTHANC"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
906 f.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "Orthanc"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
907 f.ReplacePlainString(DICOM_TAG_STUDY_DESCRIPTION, "Patterns"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
908 f.ReplacePlainString(DICOM_TAG_SERIES_DESCRIPTION, "Grayscale8"); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
909 f.EmbedImage(image); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
910 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
911 f.SaveToFile(PATH); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
912 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
913 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
914 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
915 std::string s; |
2140 | 916 Orthanc::SystemToolbox::ReadFile(s, PATH); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
917 Orthanc::ParsedDicomFile f(s); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
918 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
919 std::auto_ptr<Orthanc::ImageAccessor> decoded(Orthanc::DicomImageDecoder::Decode(f, 0)); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
920 ASSERT_EQ(256u, decoded->GetWidth()); |
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
921 ASSERT_EQ(256u, decoded->GetHeight()); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
922 ASSERT_EQ(Orthanc::PixelFormat_Grayscale8, decoded->GetFormat()); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
923 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
924 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
925 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
926 const void* a = image.GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
927 const void* b = decoded->GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
928 ASSERT_EQ(0, memcmp(a, b, 256)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
929 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
930 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
931 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
932 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
933 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
934 TEST(TestImages, PatternRGB) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
935 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
936 static const char* PATH = "UnitTestsResults/PatternRGB24.dcm"; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
937 |
2107 | 938 Orthanc::Image image(Orthanc::PixelFormat_RGB24, 384, 256, false); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
939 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
940 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
941 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
942 uint8_t *p = reinterpret_cast<uint8_t*>(image.GetRow(y)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
943 for (int x = 0; x < 128; x++, p += 3) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
944 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
945 p[0] = y; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
946 p[1] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
947 p[2] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
948 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
949 for (int x = 128; x < 128 * 2; x++, p += 3) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
950 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
951 p[0] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
952 p[1] = 255 - y; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
953 p[2] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
954 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
955 for (int x = 128 * 2; x < 128 * 3; x++, p += 3) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
956 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
957 p[0] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
958 p[1] = 0; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
959 p[2] = y; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
960 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
961 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
962 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
963 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
964 ParsedDicomFile f(true); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
965 f.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.7"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
966 f.ReplacePlainString(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.276.0.7230010.3.1.2.2831176407.321.1458901422.884998"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
967 f.ReplacePlainString(DICOM_TAG_PATIENT_ID, "ORTHANC"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
968 f.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "Orthanc"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
969 f.ReplacePlainString(DICOM_TAG_STUDY_DESCRIPTION, "Patterns"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
970 f.ReplacePlainString(DICOM_TAG_SERIES_DESCRIPTION, "RGB24"); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
971 f.EmbedImage(image); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
972 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
973 f.SaveToFile(PATH); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
974 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
975 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
976 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
977 std::string s; |
2140 | 978 Orthanc::SystemToolbox::ReadFile(s, PATH); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
979 Orthanc::ParsedDicomFile f(s); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
980 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
981 std::auto_ptr<Orthanc::ImageAccessor> decoded(Orthanc::DicomImageDecoder::Decode(f, 0)); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
982 ASSERT_EQ(384u, decoded->GetWidth()); |
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
983 ASSERT_EQ(256u, decoded->GetHeight()); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
984 ASSERT_EQ(Orthanc::PixelFormat_RGB24, decoded->GetFormat()); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
985 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
986 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
987 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
988 const void* a = image.GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
989 const void* b = decoded->GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
990 ASSERT_EQ(0, memcmp(a, b, 3 * 384)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
991 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
992 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
993 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
994 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
995 |
1940 | 996 TEST(TestImages, PatternUint16) |
1937 | 997 { |
1940 | 998 static const char* PATH = "UnitTestsResults/PatternGrayscale16.dcm"; |
999 | |
2107 | 1000 Orthanc::Image image(Orthanc::PixelFormat_Grayscale16, 256, 256, false); |
1937 | 1001 |
1002 uint16_t v = 0; | |
1003 for (int y = 0; y < 256; y++) | |
1004 { | |
1005 uint16_t *p = reinterpret_cast<uint16_t*>(image.GetRow(y)); | |
1006 for (int x = 0; x < 256; x++, v++, p++) | |
1007 { | |
1940 | 1008 *p = htole16(v); // Orthanc uses Little-Endian transfer syntax to encode images |
1937 | 1009 } |
1010 } | |
1011 | |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1012 Orthanc::ImageAccessor r; |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1013 |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1014 image.GetRegion(r, 32, 32, 64, 192); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1015 Orthanc::ImageProcessing::Set(r, 0); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1016 |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1017 image.GetRegion(r, 160, 32, 64, 192); |
1940 | 1018 Orthanc::ImageProcessing::Set(r, 65535); |
1019 | |
1020 { | |
1021 ParsedDicomFile f(true); | |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1022 f.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.7"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1023 f.ReplacePlainString(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.276.0.7230010.3.1.2.2831176407.321.1458901422.884998"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1024 f.ReplacePlainString(DICOM_TAG_PATIENT_ID, "ORTHANC"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1025 f.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "Orthanc"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1026 f.ReplacePlainString(DICOM_TAG_STUDY_DESCRIPTION, "Patterns"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1027 f.ReplacePlainString(DICOM_TAG_SERIES_DESCRIPTION, "Grayscale16"); |
1940 | 1028 f.EmbedImage(image); |
1029 | |
1030 f.SaveToFile(PATH); | |
1031 } | |
1937 | 1032 |
1940 | 1033 { |
1034 std::string s; | |
2140 | 1035 Orthanc::SystemToolbox::ReadFile(s, PATH); |
1940 | 1036 Orthanc::ParsedDicomFile f(s); |
1037 | |
1038 std::auto_ptr<Orthanc::ImageAccessor> decoded(Orthanc::DicomImageDecoder::Decode(f, 0)); | |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
1039 ASSERT_EQ(256u, decoded->GetWidth()); |
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
1040 ASSERT_EQ(256u, decoded->GetHeight()); |
1940 | 1041 ASSERT_EQ(Orthanc::PixelFormat_Grayscale16, decoded->GetFormat()); |
1042 | |
1043 for (int y = 0; y < 256; y++) | |
1044 { | |
1045 const void* a = image.GetConstRow(y); | |
1046 const void* b = decoded->GetConstRow(y); | |
1047 ASSERT_EQ(0, memcmp(a, b, 512)); | |
1048 } | |
1049 } | |
1937 | 1050 } |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1051 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1052 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1053 TEST(TestImages, PatternInt16) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1054 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1055 static const char* PATH = "UnitTestsResults/PatternSignedGrayscale16.dcm"; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1056 |
2107 | 1057 Orthanc::Image image(Orthanc::PixelFormat_SignedGrayscale16, 256, 256, false); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1058 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1059 int16_t v = -32768; |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1060 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1061 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1062 int16_t *p = reinterpret_cast<int16_t*>(image.GetRow(y)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1063 for (int x = 0; x < 256; x++, v++, p++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1064 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1065 *p = htole16(v); // Orthanc uses Little-Endian transfer syntax to encode images |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1066 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1067 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1068 |
2861
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1069 Orthanc::ImageAccessor r; |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1070 image.GetRegion(r, 32, 32, 64, 192); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1071 Orthanc::ImageProcessing::Set(r, -32768); |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1072 |
9b4251721f22
ImageAccessor now non-copyable
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2521
diff
changeset
|
1073 image.GetRegion(r, 160, 32, 64, 192); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1074 Orthanc::ImageProcessing::Set(r, 32767); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1075 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1076 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1077 ParsedDicomFile f(true); |
1982
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1078 f.ReplacePlainString(DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.7"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1079 f.ReplacePlainString(DICOM_TAG_STUDY_INSTANCE_UID, "1.2.276.0.7230010.3.1.2.2831176407.321.1458901422.884998"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1080 f.ReplacePlainString(DICOM_TAG_PATIENT_ID, "ORTHANC"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1081 f.ReplacePlainString(DICOM_TAG_PATIENT_NAME, "Orthanc"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1082 f.ReplacePlainString(DICOM_TAG_STUDY_DESCRIPTION, "Patterns"); |
b5d4f9c156ad
Modification of instances can now replace PixelData
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1981
diff
changeset
|
1083 f.ReplacePlainString(DICOM_TAG_SERIES_DESCRIPTION, "SignedGrayscale16"); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1084 f.EmbedImage(image); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1085 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1086 f.SaveToFile(PATH); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1087 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1088 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1089 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1090 std::string s; |
2140 | 1091 Orthanc::SystemToolbox::ReadFile(s, PATH); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1092 Orthanc::ParsedDicomFile f(s); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1093 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1094 std::auto_ptr<Orthanc::ImageAccessor> decoded(Orthanc::DicomImageDecoder::Decode(f, 0)); |
1971
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
1095 ASSERT_EQ(256u, decoded->GetWidth()); |
869a87c08673
fix for mingw <= 4.2
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1970
diff
changeset
|
1096 ASSERT_EQ(256u, decoded->GetHeight()); |
1941
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1097 ASSERT_EQ(Orthanc::PixelFormat_SignedGrayscale16, decoded->GetFormat()); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1098 |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1099 for (int y = 0; y < 256; y++) |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1100 { |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1101 const void* a = image.GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1102 const void* b = decoded->GetConstRow(y); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1103 ASSERT_EQ(0, memcmp(a, b, 512)); |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1104 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1105 } |
d7b176f7dd1b
test dicom patterns
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1940
diff
changeset
|
1106 } |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1107 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1108 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1109 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1110 static void CheckEncoding(const ParsedDicomFile& dicom, |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1111 Encoding expected) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1112 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1113 const char* value = NULL; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1114 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->findAndGetString(DCM_SpecificCharacterSet, value).good()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1115 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1116 Encoding encoding; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1117 ASSERT_TRUE(GetDicomEncoding(encoding, value)); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1118 ASSERT_EQ(expected, encoding); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1119 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1120 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1121 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1122 TEST(ParsedDicomFile, DicomMapEncodings1) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1123 { |
2381
b8969010b534
uncoupling DCMTK primitives from Orthanc::Configuration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2326
diff
changeset
|
1124 SetDefaultDicomEncoding(Encoding_Ascii); |
b8969010b534
uncoupling DCMTK primitives from Orthanc::Configuration
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2326
diff
changeset
|
1125 ASSERT_EQ(Encoding_Ascii, GetDefaultDicomEncoding()); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1126 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1127 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1128 DicomMap m; |
3342
63f59ad9381a
Fix issue #136 (C-Find request fails when found DICOM file does not have certain tags)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3311
diff
changeset
|
1129 ParsedDicomFile dicom(m, GetDefaultDicomEncoding(), false); |
2411
82d5e305fbd9
fix gcc warnings in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2409
diff
changeset
|
1130 ASSERT_EQ(1u, dicom.GetDcmtkObject().getDataset()->card()); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1131 CheckEncoding(dicom, Encoding_Ascii); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1132 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1133 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1134 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1135 DicomMap m; |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1136 ParsedDicomFile dicom(m, Encoding_Latin4, false); |
2411
82d5e305fbd9
fix gcc warnings in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2409
diff
changeset
|
1137 ASSERT_EQ(1u, dicom.GetDcmtkObject().getDataset()->card()); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1138 CheckEncoding(dicom, Encoding_Latin4); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1139 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1140 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1141 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1142 DicomMap m; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1143 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "ISO_IR 148", false); |
3342
63f59ad9381a
Fix issue #136 (C-Find request fails when found DICOM file does not have certain tags)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3311
diff
changeset
|
1144 ParsedDicomFile dicom(m, GetDefaultDicomEncoding(), false); |
2411
82d5e305fbd9
fix gcc warnings in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2409
diff
changeset
|
1145 ASSERT_EQ(1u, dicom.GetDcmtkObject().getDataset()->card()); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1146 CheckEncoding(dicom, Encoding_Latin5); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1147 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1148 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1149 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1150 DicomMap m; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1151 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "ISO_IR 148", false); |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1152 ParsedDicomFile dicom(m, Encoding_Latin1, false); |
2411
82d5e305fbd9
fix gcc warnings in unit tests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2409
diff
changeset
|
1153 ASSERT_EQ(1u, dicom.GetDcmtkObject().getDataset()->card()); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1154 CheckEncoding(dicom, Encoding_Latin5); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1155 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1156 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1157 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1158 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1159 TEST(ParsedDicomFile, DicomMapEncodings2) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1160 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1161 const char* utf8 = NULL; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1162 for (unsigned int i = 0; i < testEncodingsCount; i++) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1163 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1164 if (testEncodings[i] == Encoding_Utf8) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1165 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1166 utf8 = testEncodingsEncoded[i]; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1167 break; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1168 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1169 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1170 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1171 ASSERT_TRUE(utf8 != NULL); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1172 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1173 for (unsigned int i = 0; i < testEncodingsCount; i++) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1174 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1175 // 1251 codepage is not supported by the core DICOM standard, ignore it |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1176 if (testEncodings[i] != Encoding_Windows1251) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1177 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1178 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1179 // Sanity check to test the proper behavior of "EncodingTests.py" |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1180 std::string encoded = Toolbox::ConvertFromUtf8(testEncodingsExpected[i], testEncodings[i]); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1181 ASSERT_STREQ(testEncodingsEncoded[i], encoded.c_str()); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1182 std::string decoded = Toolbox::ConvertToUtf8(encoded, testEncodings[i], false); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1183 ASSERT_STREQ(testEncodingsExpected[i], decoded.c_str()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1184 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1185 if (testEncodings[i] != Encoding_Chinese) |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1186 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1187 // A specific source string is used in "EncodingTests.py" to |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1188 // test against Chinese, it is normal that it does not correspond to UTF8 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1189 |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1190 std::string encoded = Toolbox::ConvertToUtf8(Toolbox::ConvertFromUtf8(utf8, testEncodings[i]), testEncodings[i], false); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1191 ASSERT_STREQ(testEncodingsExpected[i], encoded.c_str()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1192 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1193 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1194 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1195 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1196 Json::Value v; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1197 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1198 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1199 DicomMap m; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1200 m.SetValue(DICOM_TAG_PATIENT_NAME, testEncodingsExpected[i], false); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1201 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1202 ParsedDicomFile dicom(m, testEncodings[i], false); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1203 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1204 const char* encoded = NULL; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1205 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->findAndGetString(DCM_PatientName, encoded).good()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1206 ASSERT_STREQ(testEncodingsEncoded[i], encoded); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1207 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1208 dicom.DatasetToJson(v, DicomToJsonFormat_Human, DicomToJsonFlags_Default, 0); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1209 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1210 Encoding encoding; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1211 ASSERT_TRUE(GetDicomEncoding(encoding, v["SpecificCharacterSet"].asCString())); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1212 ASSERT_EQ(encoding, testEncodings[i]); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1213 ASSERT_STREQ(testEncodingsExpected[i], v["PatientName"].asCString()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1214 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1215 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1216 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1217 { |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1218 DicomMap m; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1219 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, GetDicomSpecificCharacterSet(testEncodings[i]), false); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1220 m.SetValue(DICOM_TAG_PATIENT_NAME, testEncodingsExpected[i], false); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1221 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1222 ParsedDicomFile dicom(m, testEncodings[i], false); |
2202
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1223 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1224 Json::Value v2; |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1225 dicom.DatasetToJson(v2, DicomToJsonFormat_Human, DicomToJsonFlags_Default, 0); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1226 |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1227 ASSERT_EQ(v2["PatientName"].asString(), v["PatientName"].asString()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1228 ASSERT_EQ(v2["SpecificCharacterSet"].asString(), v["SpecificCharacterSet"].asString()); |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1229 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1230 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1231 } |
9b373b7d6713
Fix handling of encodings in C-FIND requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2142
diff
changeset
|
1232 } |
2207
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1233 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1234 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1235 TEST(ParsedDicomFile, ChangeEncoding) |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1236 { |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1237 for (unsigned int i = 0; i < testEncodingsCount; i++) |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1238 { |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1239 // 1251 codepage is not supported by the core DICOM standard, ignore it |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1240 if (testEncodings[i] != Encoding_Windows1251) |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1241 { |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1242 DicomMap m; |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1243 m.SetValue(DICOM_TAG_PATIENT_NAME, testEncodingsExpected[i], false); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1244 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1245 std::string tag; |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1246 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1247 ParsedDicomFile dicom(m, Encoding_Utf8, false); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1248 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1249 ASSERT_EQ(Encoding_Utf8, dicom.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1250 ASSERT_FALSE(hasCodeExtensions); |
2207
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1251 ASSERT_TRUE(dicom.GetTagValue(tag, DICOM_TAG_PATIENT_NAME)); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1252 ASSERT_EQ(tag, testEncodingsExpected[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1253 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1254 { |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1255 Json::Value v; |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1256 dicom.DatasetToJson(v, DicomToJsonFormat_Human, DicomToJsonFlags_Default, 0); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1257 ASSERT_STREQ(v["SpecificCharacterSet"].asCString(), "ISO_IR 192"); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1258 ASSERT_STREQ(v["PatientName"].asCString(), testEncodingsExpected[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1259 } |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1260 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1261 dicom.ChangeEncoding(testEncodings[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1262 |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1263 ASSERT_EQ(testEncodings[i], dicom.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1264 ASSERT_FALSE(hasCodeExtensions); |
2207
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1265 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1266 const char* c = NULL; |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1267 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->findAndGetString(DCM_PatientName, c).good()); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1268 EXPECT_STREQ(c, testEncodingsEncoded[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1269 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1270 ASSERT_TRUE(dicom.GetTagValue(tag, DICOM_TAG_PATIENT_NAME)); // Decodes to UTF-8 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1271 EXPECT_EQ(tag, testEncodingsExpected[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1272 |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1273 { |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1274 Json::Value v; |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1275 dicom.DatasetToJson(v, DicomToJsonFormat_Human, DicomToJsonFlags_Default, 0); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1276 ASSERT_STREQ(v["SpecificCharacterSet"].asCString(), GetDicomSpecificCharacterSet(testEncodings[i])); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1277 ASSERT_STREQ(v["PatientName"].asCString(), testEncodingsExpected[i]); |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1278 } |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1279 } |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1280 } |
6dc3bdb4088b
Fix handling of encodings in C-FIND for worklists
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2202
diff
changeset
|
1281 } |
2326
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1282 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1283 |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1284 TEST(Toolbox, CaseWithAccents) |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1285 { |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1286 ASSERT_EQ(toUpperResult, Toolbox::ToUpperCaseWithAccents(toUpperSource)); |
423d3b692bb9
Upgrade to Boost 1.64.0, and Toolbox::ToUpperCaseWithAccents
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2309
diff
changeset
|
1287 } |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1288 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1289 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1290 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1291 TEST(ParsedDicomFile, InvalidCharacterSets) |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1292 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1293 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1294 // No encoding provided, fallback to default encoding |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1295 DicomMap m; |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1296 m.SetValue(DICOM_TAG_PATIENT_NAME, "HELLO", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1297 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1298 ParsedDicomFile d(m, Encoding_Latin3 /* default encoding */, false); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1299 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1300 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1301 ASSERT_EQ(Encoding_Latin3, d.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1302 ASSERT_FALSE(hasCodeExtensions); |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1303 } |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1304 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1305 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1306 // Valid encoding, "ISO_IR 13" is Japanese |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1307 DicomMap m; |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1308 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "ISO_IR 13", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1309 m.SetValue(DICOM_TAG_PATIENT_NAME, "HELLO", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1310 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1311 ParsedDicomFile d(m, Encoding_Latin3 /* default encoding */, false); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1312 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1313 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1314 ASSERT_EQ(Encoding_Japanese, d.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1315 ASSERT_FALSE(hasCodeExtensions); |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1316 } |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1317 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1318 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1319 // Invalid value for an encoding ("nope" is not in the DICOM standard) |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1320 DicomMap m; |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1321 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "nope", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1322 m.SetValue(DICOM_TAG_PATIENT_NAME, "HELLO", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1323 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1324 ASSERT_THROW(ParsedDicomFile d(m, Encoding_Latin3, false), OrthancException); |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1325 } |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1326 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1327 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1328 // Invalid encoding, as provided as a binary string |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1329 DicomMap m; |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1330 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "ISO_IR 13", true); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1331 m.SetValue(DICOM_TAG_PATIENT_NAME, "HELLO", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1332 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1333 ASSERT_THROW(ParsedDicomFile d(m, Encoding_Latin3, false), OrthancException); |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1334 } |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1335 |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1336 { |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1337 // Encoding provided as an empty string, fallback to default encoding |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1338 // In Orthanc <= 1.3.1, this test was throwing an exception |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1339 DicomMap m; |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1340 m.SetValue(DICOM_TAG_SPECIFIC_CHARACTER_SET, "", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1341 m.SetValue(DICOM_TAG_PATIENT_NAME, "HELLO", false); |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1342 |
3276
9b0e67161600
More tolerance wrt. invalid DICOM files that must be returned by Orthanc C-FIND SCP
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3229
diff
changeset
|
1343 ParsedDicomFile d(m, Encoding_Latin3 /* default encoding */, false); |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1344 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1345 bool hasCodeExtensions; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1346 ASSERT_EQ(Encoding_Latin3, d.DetectEncoding(hasCodeExtensions)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1347 ASSERT_FALSE(hasCodeExtensions); |
2445
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1348 } |
6e5bc5c6d1a4
Fix to allow creating DICOM instances with empty Specific Character Set (0008,0005)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2411
diff
changeset
|
1349 } |
3217
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1350 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1351 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1352 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1353 TEST(Toolbox, RemoveIso2022EscapeSequences) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1354 { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1355 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1356 // | one-byte control messages | |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1357 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1358 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1359 static const uint8_t iso2022_cstr_oneByteControl[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1360 0x0f, 0x41, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1361 0x0e, 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1362 0x8e, 0x1b, 0x4e, 0x43, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1363 0x8f, 0x1b, 0x4f, 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1364 0x8e, 0x1b, 0x4a, 0x45, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1365 0x8f, 0x1b, 0x4a, 0x46, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1366 0x50, 0x51, 0x52, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1367 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1368 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1369 static const uint8_t iso2022_cstr_oneByteControl_ref[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1370 0x41, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1371 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1372 0x43, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1373 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1374 0x8e, 0x1b, 0x4a, 0x45, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1375 0x8f, 0x1b, 0x4a, 0x46, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1376 0x50, 0x51, 0x52, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1377 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1378 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1379 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1380 // | two-byte control messages | |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1381 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1382 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1383 static const uint8_t iso2022_cstr_twoByteControl[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1384 0x1b, 0x6e, 0x41, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1385 0x1b, 0x6f, 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1386 0x1b, 0x4e, 0x43, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1387 0x1b, 0x4f, 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1388 0x1b, 0x7e, 0x45, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1389 0x1b, 0x7d, 0x46, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1390 0x1b, 0x7c, 0x47, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1391 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1392 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1393 static const uint8_t iso2022_cstr_twoByteControl_ref[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1394 0x41, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1395 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1396 0x43, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1397 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1398 0x45, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1399 0x46, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1400 0x47, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1401 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1402 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1403 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1404 // | various-length escape sequences | |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1405 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1406 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1407 static const uint8_t iso2022_cstr_escapeSequence[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1408 0x1b, 0x40, 0x41, // 1b and 40 should not be removed (invalid esc seq) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1409 0x1b, 0x50, 0x42, // ditto |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1410 0x1b, 0x7f, 0x43, // ditto |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1411 0x1b, 0x21, 0x4a, 0x44, // this will match |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1412 0x1b, 0x20, 0x21, 0x2f, 0x40, 0x45, // this will match |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1413 0x1b, 0x20, 0x21, 0x2f, 0x2f, 0x40, 0x46, // this will match too |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1414 0x1b, 0x20, 0x21, 0x2f, 0x1f, 0x47, 0x48, 0x00 // this will NOT match! |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1415 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1416 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1417 static const uint8_t iso2022_cstr_escapeSequence_ref[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1418 0x1b, 0x40, 0x41, // 1b and 40 should not be removed (invalid esc seq) |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1419 0x1b, 0x50, 0x42, // ditto |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1420 0x1b, 0x7f, 0x43, // ditto |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1421 0x44, // this will match |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1422 0x45, // this will match |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1423 0x46, // this will match too |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1424 0x1b, 0x20, 0x21, 0x2f, 0x1f, 0x47, 0x48, 0x00 // this will NOT match! |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1425 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1426 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1427 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1428 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1429 // | a real-world japanese sample | |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1430 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1431 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1432 static const uint8_t iso2022_cstr_real_ir13[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1433 0xd4, 0xcf, 0xc0, 0xde, 0x5e, 0xc0, 0xdb, 0xb3, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1434 0x3d, 0x1b, 0x24, 0x42, 0x3b, 0x33, 0x45, 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1435 0x1b, 0x28, 0x4a, 0x5e, 0x1b, 0x24, 0x42, 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1436 0x40, 0x4f, 0x3a, 0x1b, 0x28, 0x4a, 0x3d, 0x1b, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1437 0x24, 0x42, 0x24, 0x64, 0x24, 0x5e, 0x24, 0x40, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1438 0x1b, 0x28, 0x4a, 0x5e, 0x1b, 0x24, 0x42, 0x24, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1439 0x3f, 0x24, 0x6d, 0x24, 0x26, 0x1b, 0x28, 0x4a, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1440 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1441 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1442 static const uint8_t iso2022_cstr_real_ir13_ref[] = { |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1443 0xd4, 0xcf, 0xc0, 0xde, 0x5e, 0xc0, 0xdb, 0xb3, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1444 0x3d, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1445 0x3b, 0x33, 0x45, 0x44, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1446 0x5e, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1447 0x42, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1448 0x40, 0x4f, 0x3a, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1449 0x3d, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1450 0x24, 0x64, 0x24, 0x5e, 0x24, 0x40, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1451 0x5e, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1452 0x24, |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1453 0x3f, 0x24, 0x6d, 0x24, 0x26, 0x00 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1454 }; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1455 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1456 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1457 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1458 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1459 // | the actual test | |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1460 // +----------------------------------+ |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1461 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1462 std::string iso2022_str_oneByteControl( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1463 reinterpret_cast<const char*>(iso2022_cstr_oneByteControl)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1464 std::string iso2022_str_oneByteControl_ref( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1465 reinterpret_cast<const char*>(iso2022_cstr_oneByteControl_ref)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1466 std::string iso2022_str_twoByteControl( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1467 reinterpret_cast<const char*>(iso2022_cstr_twoByteControl)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1468 std::string iso2022_str_twoByteControl_ref( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1469 reinterpret_cast<const char*>(iso2022_cstr_twoByteControl_ref)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1470 std::string iso2022_str_escapeSequence( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1471 reinterpret_cast<const char*>(iso2022_cstr_escapeSequence)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1472 std::string iso2022_str_escapeSequence_ref( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1473 reinterpret_cast<const char*>(iso2022_cstr_escapeSequence_ref)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1474 std::string iso2022_str_real_ir13( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1475 reinterpret_cast<const char*>(iso2022_cstr_real_ir13)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1476 std::string iso2022_str_real_ir13_ref( |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1477 reinterpret_cast<const char*>(iso2022_cstr_real_ir13_ref)); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1478 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1479 std::string dest; |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1480 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1481 Toolbox::RemoveIso2022EscapeSequences(dest, iso2022_str_oneByteControl); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1482 ASSERT_EQ(dest, iso2022_str_oneByteControl_ref); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1483 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1484 Toolbox::RemoveIso2022EscapeSequences(dest, iso2022_str_twoByteControl); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1485 ASSERT_EQ(dest, iso2022_str_twoByteControl_ref); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1486 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1487 Toolbox::RemoveIso2022EscapeSequences(dest, iso2022_str_escapeSequence); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1488 ASSERT_EQ(dest, iso2022_str_escapeSequence_ref); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1489 |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1490 Toolbox::RemoveIso2022EscapeSequences(dest, iso2022_str_real_ir13); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1491 ASSERT_EQ(dest, iso2022_str_real_ir13_ref); |
cf8cbeb35f33
preliminary support of Korean character set
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3083
diff
changeset
|
1492 } |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1493 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1494 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1495 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1496 static std::string DecodeFromSpecification(const std::string& s) |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1497 { |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1498 std::vector<std::string> tokens; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1499 Toolbox::TokenizeString(tokens, s, ' '); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1500 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1501 std::string result; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1502 result.resize(tokens.size()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1503 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1504 for (size_t i = 0; i < tokens.size(); i++) |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1505 { |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1506 std::vector<std::string> components; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1507 Toolbox::TokenizeString(components, tokens[i], '/'); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1508 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1509 if (components.size() != 2) |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1510 { |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1511 throw; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1512 } |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1513 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1514 int a = boost::lexical_cast<int>(components[0]); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1515 int b = boost::lexical_cast<int>(components[1]); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1516 if (a < 0 || a > 15 || |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1517 b < 0 || b > 15 || |
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1518 (a == 0 && b == 0)) |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1519 { |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1520 throw; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1521 } |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1522 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1523 result[i] = static_cast<uint8_t>(a * 16 + b); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1524 } |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1525 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1526 return result; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1527 } |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1528 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1529 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1530 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1531 // Compatibility wrapper |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1532 static pugi::xpath_node SelectNode(const pugi::xml_document& doc, |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1533 const char* xpath) |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1534 { |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1535 #if PUGIXML_VERSION <= 140 |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1536 return doc.select_single_node(xpath); // Deprecated in pugixml 1.5 |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1537 #else |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1538 return doc.select_node(xpath); |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1539 #endif |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1540 } |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1541 |
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1542 |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1543 TEST(Toolbox, EncodingsKorean) |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1544 { |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1545 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_I.2.html |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1546 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1547 std::string korean = DecodeFromSpecification( |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1548 "04/08 06/15 06/14 06/07 05/14 04/07 06/09 06/12 06/04 06/15 06/14 06/07 03/13 " |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1549 "01/11 02/04 02/09 04/03 15/11 15/03 05/14 01/11 02/04 02/09 04/03 13/01 12/14 " |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1550 "13/04 13/07 03/13 01/11 02/04 02/09 04/03 12/08 10/11 05/14 01/11 02/04 02/09 " |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1551 "04/03 11/01 14/06 11/05 11/15"); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1552 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1553 // This array can be re-generated using command-line: |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1554 // echo -n "Hong^Gildong=..." | hexdump -v -e '14/1 "0x%02x, "' -e '"\n"' |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1555 static const uint8_t utf8raw[] = { |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1556 0x48, 0x6f, 0x6e, 0x67, 0x5e, 0x47, 0x69, 0x6c, 0x64, 0x6f, 0x6e, 0x67, 0x3d, 0xe6, |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1557 0xb4, 0xaa, 0x5e, 0xe5, 0x90, 0x89, 0xe6, 0xb4, 0x9e, 0x3d, 0xed, 0x99, 0x8d, 0x5e, |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1558 0xea, 0xb8, 0xb8, 0xeb, 0x8f, 0x99 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1559 }; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1560 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1561 std::string utf8(reinterpret_cast<const char*>(utf8raw), sizeof(utf8raw)); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1562 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1563 ParsedDicomFile dicom(false); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1564 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "\\ISO 2022 IR 149"); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1565 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1566 (DCM_PatientName, korean.c_str(), OFBool(true)).good()); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1567 |
3225
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1568 bool hasCodeExtensions; |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1569 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1570 ASSERT_EQ(Encoding_Korean, encoding); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1571 ASSERT_TRUE(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1572 |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1573 std::string value; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1574 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_NAME)); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1575 ASSERT_EQ(utf8, value); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1576 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1577 DicomWebJsonVisitor visitor; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1578 dicom.Apply(visitor); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1579 ASSERT_EQ(utf8.substr(0, 12), visitor.GetResult()["00100010"]["Value"][0]["Alphabetic"].asString()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1580 ASSERT_EQ(utf8.substr(13, 10), visitor.GetResult()["00100010"]["Value"][0]["Ideographic"].asString()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1581 ASSERT_EQ(utf8.substr(24), visitor.GetResult()["00100010"]["Value"][0]["Phonetic"].asString()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1582 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1583 #if ORTHANC_ENABLE_PUGIXML == 1 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1584 // http://dicom.nema.org/medical/dicom/current/output/chtml/part18/sect_F.3.html#table_F.3.1-1 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1585 std::string xml; |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1586 visitor.FormatXml(xml); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1587 |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1588 pugi::xml_document doc; |
3222 | 1589 doc.load_buffer(xml.c_str(), xml.size()); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1590 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1591 pugi::xpath_node node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00080005\"]/Value"); |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3342
diff
changeset
|
1592 ASSERT_STREQ("ISO 2022 IR 149", node.node().text().as_string()); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1593 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1594 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00080005\"]"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1595 ASSERT_STREQ("CS", node.node().attribute("vr").value()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1596 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1597 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1598 ASSERT_STREQ("PN", node.node().attribute("vr").value()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1599 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1600 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Alphabetic/FamilyName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1601 ASSERT_STREQ("Hong", node.node().text().as_string()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1602 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1603 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Alphabetic/GivenName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1604 ASSERT_STREQ("Gildong", node.node().text().as_string()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1605 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1606 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Ideographic/FamilyName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1607 ASSERT_EQ(utf8.substr(13, 3), node.node().text().as_string()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1608 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1609 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Ideographic/GivenName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1610 ASSERT_EQ(utf8.substr(17, 6), node.node().text().as_string()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1611 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1612 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Phonetic/FamilyName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1613 ASSERT_EQ(utf8.substr(24, 3), node.node().text().as_string()); |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1614 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1615 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Phonetic/GivenName"); |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1616 ASSERT_EQ(utf8.substr(28), node.node().text().as_string()); |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1617 #endif |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1618 |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1619 { |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1620 DicomMap m; |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1621 m.FromDicomWeb(visitor.GetResult()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1622 ASSERT_EQ(2u, m.GetSize()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1623 |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1624 std::string s; |
3518
a57c8163d9ae
DicomMap::GetStringValue()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3496
diff
changeset
|
1625 ASSERT_TRUE(m.LookupStringValue(s, DICOM_TAG_SPECIFIC_CHARACTER_SET, false)); |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1626 ASSERT_EQ("ISO 2022 IR 149", s); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1627 |
3518
a57c8163d9ae
DicomMap::GetStringValue()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3496
diff
changeset
|
1628 ASSERT_TRUE(m.LookupStringValue(s, DICOM_TAG_PATIENT_NAME, false)); |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1629 std::vector<std::string> v; |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1630 Toolbox::TokenizeString(v, s, '='); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1631 ASSERT_EQ(3u, v.size()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1632 ASSERT_EQ("Hong^Gildong", v[0]); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1633 ASSERT_EQ(utf8, s); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1634 } |
3221
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1635 } |
4be505c2ac56
Separation of ideographic and phonetic characters in DICOMweb JSON and XML
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3219
diff
changeset
|
1636 |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1637 |
3225
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1638 TEST(Toolbox, EncodingsJapaneseKanji) |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1639 { |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1640 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_H.3.html |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1641 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1642 std::string japanese = DecodeFromSpecification( |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1643 "05/09 06/01 06/13 06/01 06/04 06/01 05/14 05/04 06/01 07/02 06/15 07/05 03/13 " |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1644 "01/11 02/04 04/02 03/11 03/03 04/05 04/04 01/11 02/08 04/02 05/14 01/11 02/04 " |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1645 "04/02 04/02 04/00 04/15 03/10 01/11 02/08 04/02 03/13 01/11 02/04 04/02 02/04 " |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1646 "06/04 02/04 05/14 02/04 04/00 01/11 02/08 04/02 05/14 01/11 02/04 04/02 02/04 " |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1647 "03/15 02/04 06/13 02/04 02/06 01/11 02/08 04/02"); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1648 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1649 // This array can be re-generated using command-line: |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1650 // echo -n "Yamada^Tarou=..." | hexdump -v -e '14/1 "0x%02x, "' -e '"\n"' |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1651 static const uint8_t utf8raw[] = { |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1652 0x59, 0x61, 0x6d, 0x61, 0x64, 0x61, 0x5e, 0x54, 0x61, 0x72, 0x6f, 0x75, 0x3d, 0xe5, |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1653 0xb1, 0xb1, 0xe7, 0x94, 0xb0, 0x5e, 0xe5, 0xa4, 0xaa, 0xe9, 0x83, 0x8e, 0x3d, 0xe3, |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1654 0x82, 0x84, 0xe3, 0x81, 0xbe, 0xe3, 0x81, 0xa0, 0x5e, 0xe3, 0x81, 0x9f, 0xe3, 0x82, |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1655 0x8d, 0xe3, 0x81, 0x86 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1656 }; |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1657 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1658 std::string utf8(reinterpret_cast<const char*>(utf8raw), sizeof(utf8raw)); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1659 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1660 ParsedDicomFile dicom(false); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1661 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "\\ISO 2022 IR 87"); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1662 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1663 (DCM_PatientName, japanese.c_str(), OFBool(true)).good()); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1664 |
3225
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1665 bool hasCodeExtensions; |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1666 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1667 ASSERT_EQ(Encoding_JapaneseKanji, encoding); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1668 ASSERT_TRUE(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1669 |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1670 std::string value; |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1671 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_NAME)); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1672 ASSERT_EQ(utf8, value); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1673 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1674 DicomWebJsonVisitor visitor; |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1675 dicom.Apply(visitor); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1676 ASSERT_EQ(utf8.substr(0, 12), visitor.GetResult()["00100010"]["Value"][0]["Alphabetic"].asString()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1677 ASSERT_EQ(utf8.substr(13, 13), visitor.GetResult()["00100010"]["Value"][0]["Ideographic"].asString()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1678 ASSERT_EQ(utf8.substr(27), visitor.GetResult()["00100010"]["Value"][0]["Phonetic"].asString()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1679 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1680 #if ORTHANC_ENABLE_PUGIXML == 1 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1681 // http://dicom.nema.org/medical/dicom/current/output/chtml/part18/sect_F.3.html#table_F.3.1-1 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1682 std::string xml; |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1683 visitor.FormatXml(xml); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1684 |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1685 pugi::xml_document doc; |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1686 doc.load_buffer(xml.c_str(), xml.size()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1687 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1688 pugi::xpath_node node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00080005\"]/Value"); |
3420
0a0e7eca95ae
fix encoding in DICOMweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3342
diff
changeset
|
1689 ASSERT_STREQ("ISO 2022 IR 87", node.node().text().as_string()); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1690 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1691 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00080005\"]"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1692 ASSERT_STREQ("CS", node.node().attribute("vr").value()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1693 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1694 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1695 ASSERT_STREQ("PN", node.node().attribute("vr").value()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1696 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1697 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Alphabetic/FamilyName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1698 ASSERT_STREQ("Yamada", node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1699 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1700 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Alphabetic/GivenName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1701 ASSERT_STREQ("Tarou", node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1702 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1703 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Ideographic/FamilyName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1704 ASSERT_EQ(utf8.substr(13, 6), node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1705 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1706 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Ideographic/GivenName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1707 ASSERT_EQ(utf8.substr(20, 6), node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1708 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1709 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Phonetic/FamilyName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1710 ASSERT_EQ(utf8.substr(27, 9), node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1711 |
3311
f2f8aa6f78aa
compatibility with pugixml <= 1.4.0
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3298
diff
changeset
|
1712 node = SelectNode(doc, "//NativeDicomModel/DicomAttribute[@tag=\"00100010\"]/PersonName/Phonetic/GivenName"); |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1713 ASSERT_EQ(utf8.substr(37), node.node().text().as_string()); |
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1714 #endif |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1715 |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1716 { |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1717 DicomMap m; |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1718 m.FromDicomWeb(visitor.GetResult()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1719 ASSERT_EQ(2u, m.GetSize()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1720 |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1721 std::string s; |
3518
a57c8163d9ae
DicomMap::GetStringValue()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3496
diff
changeset
|
1722 ASSERT_TRUE(m.LookupStringValue(s, DICOM_TAG_SPECIFIC_CHARACTER_SET, false)); |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1723 ASSERT_EQ("ISO 2022 IR 87", s); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1724 |
3518
a57c8163d9ae
DicomMap::GetStringValue()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3496
diff
changeset
|
1725 ASSERT_TRUE(m.LookupStringValue(s, DICOM_TAG_PATIENT_NAME, false)); |
3496
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1726 std::vector<std::string> v; |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1727 Toolbox::TokenizeString(v, s, '='); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1728 ASSERT_EQ(3u, v.size()); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1729 ASSERT_EQ("Yamada^Tarou", v[0]); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1730 ASSERT_EQ(utf8, s); |
109631ed3564
DicomMap::FromDicomWeb()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3420
diff
changeset
|
1731 } |
3223
c94f23198946
unit testing japanese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3222
diff
changeset
|
1732 } |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1733 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1734 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1735 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1736 TEST(Toolbox, EncodingsChinese3) |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1737 { |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1738 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_J.3.html |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1739 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1740 static const uint8_t chinese[] = { |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1741 0x57, 0x61, 0x6e, 0x67, 0x5e, 0x58, 0x69, 0x61, 0x6f, 0x44, 0x6f, |
3229 | 1742 0x6e, 0x67, 0x3d, 0xcd, 0xf5, 0x5e, 0xd0, 0xa1, 0xb6, 0xab, 0x3d, 0x00 |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1743 }; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1744 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1745 ParsedDicomFile dicom(false); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1746 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "GB18030"); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1747 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1748 (DCM_PatientName, reinterpret_cast<const char*>(chinese), OFBool(true)).good()); |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1749 |
3225
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1750 bool hasCodeExtensions; |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1751 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1752 ASSERT_EQ(Encoding_Chinese, encoding); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1753 ASSERT_FALSE(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1754 |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1755 std::string value; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1756 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_NAME)); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1757 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1758 std::vector<std::string> tokens; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1759 Orthanc::Toolbox::TokenizeString(tokens, value, '='); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1760 ASSERT_EQ(3u, tokens.size()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1761 ASSERT_EQ("Wang^XiaoDong", tokens[0]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1762 ASSERT_TRUE(tokens[2].empty()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1763 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1764 std::vector<std::string> middle; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1765 Orthanc::Toolbox::TokenizeString(middle, tokens[1], '^'); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1766 ASSERT_EQ(2u, middle.size()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1767 ASSERT_EQ(3u, middle[0].size()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1768 ASSERT_EQ(6u, middle[1].size()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1769 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1770 // CDF5 in GB18030 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1771 ASSERT_EQ(static_cast<char>(0xe7), middle[0][0]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1772 ASSERT_EQ(static_cast<char>(0x8e), middle[0][1]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1773 ASSERT_EQ(static_cast<char>(0x8b), middle[0][2]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1774 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1775 // D0A1 in GB18030 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1776 ASSERT_EQ(static_cast<char>(0xe5), middle[1][0]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1777 ASSERT_EQ(static_cast<char>(0xb0), middle[1][1]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1778 ASSERT_EQ(static_cast<char>(0x8f), middle[1][2]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1779 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1780 // B6AB in GB18030 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1781 ASSERT_EQ(static_cast<char>(0xe4), middle[1][3]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1782 ASSERT_EQ(static_cast<char>(0xb8), middle[1][4]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1783 ASSERT_EQ(static_cast<char>(0x9c), middle[1][5]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1784 } |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1785 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1786 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1787 TEST(Toolbox, EncodingsChinese4) |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1788 { |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1789 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_J.4.html |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1790 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1791 static const uint8_t chinese[] = { |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1792 0x54, 0x68, 0x65, 0x20, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20, 0x6c, 0x69, 0x6e, |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1793 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x73, 0xd6, 0xd0, 0xce, |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1794 0xc4, 0x2e, 0x0d, 0x0a, 0x54, 0x68, 0x65, 0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1795 0x64, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1796 0x65, 0x73, 0xd6, 0xd0, 0xce, 0xc4, 0x2c, 0x20, 0x74, 0x6f, 0x6f, 0x2e, 0x0d, |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1797 0x0a, 0x54, 0x68, 0x65, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64, 0x20, 0x6c, 0x69, |
3229 | 1798 0x6e, 0x65, 0x2e, 0x0d, 0x0a, 0x00 |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1799 }; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1800 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1801 static const uint8_t patternRaw[] = { |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1802 0xe4, 0xb8, 0xad, 0xe6, 0x96, 0x87 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1803 }; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1804 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1805 const std::string pattern(reinterpret_cast<const char*>(patternRaw), sizeof(patternRaw)); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1806 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1807 ParsedDicomFile dicom(false); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1808 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "GB18030"); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1809 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1810 (DCM_PatientComments, reinterpret_cast<const char*>(chinese), OFBool(true)).good()); |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1811 |
3225
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1812 bool hasCodeExtensions; |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1813 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1814 ASSERT_EQ(Encoding_Chinese, encoding); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1815 ASSERT_FALSE(hasCodeExtensions); |
c85510b5f21d
unit testing ParsedDicomFile::DetectEncoding()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3224
diff
changeset
|
1816 |
3224
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1817 std::string value; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1818 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_COMMENTS)); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1819 |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1820 std::vector<std::string> lines; |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1821 Orthanc::Toolbox::TokenizeString(lines, value, '\n'); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1822 ASSERT_EQ(4u, lines.size()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1823 ASSERT_TRUE(boost::starts_with(lines[0], "The first line includes")); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1824 ASSERT_TRUE(boost::ends_with(lines[0], ".\r")); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1825 ASSERT_TRUE(lines[0].find(pattern) != std::string::npos); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1826 ASSERT_TRUE(boost::starts_with(lines[1], "The second line includes")); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1827 ASSERT_TRUE(boost::ends_with(lines[1], ", too.\r")); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1828 ASSERT_TRUE(lines[1].find(pattern) != std::string::npos); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1829 ASSERT_EQ("The third line.\r", lines[2]); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1830 ASSERT_FALSE(lines[1].find(pattern) == std::string::npos); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1831 ASSERT_TRUE(lines[3].empty()); |
6399f5f25498
unit testing simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3223
diff
changeset
|
1832 } |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1833 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1834 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1835 TEST(Toolbox, EncodingsSimplifiedChinese2) |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1836 { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1837 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_K.2.html |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1838 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1839 static const uint8_t chinese[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1840 0x5a, 0x68, 0x61, 0x6e, 0x67, 0x5e, 0x58, 0x69, 0x61, 0x6f, 0x44, 0x6f, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1841 0x6e, 0x67, 0x3d, 0x1b, 0x24, 0x29, 0x41, 0xd5, 0xc5, 0x5e, 0x1b, 0x24, |
3229 | 1842 0x29, 0x41, 0xd0, 0xa1, 0xb6, 0xab, 0x3d, 0x20, 0x00 |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1843 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1844 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1845 // echo -n "Zhang^XiaoDong=..." | hexdump -v -e '14/1 "0x%02x, "' -e '"\n"' |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1846 static const uint8_t utf8[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1847 0x5a, 0x68, 0x61, 0x6e, 0x67, 0x5e, 0x58, 0x69, 0x61, 0x6f, 0x44, 0x6f, 0x6e, 0x67, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1848 0x3d, 0xe5, 0xbc, 0xa0, 0x5e, 0xe5, 0xb0, 0x8f, 0xe4, 0xb8, 0x9c, 0x3d |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1849 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1850 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1851 ParsedDicomFile dicom(false); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1852 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "\\ISO 2022 IR 58"); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1853 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1854 (DCM_PatientName, reinterpret_cast<const char*>(chinese), OFBool(true)).good()); |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1855 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1856 bool hasCodeExtensions; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1857 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1858 ASSERT_EQ(Encoding_SimplifiedChinese, encoding); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1859 ASSERT_TRUE(hasCodeExtensions); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1860 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1861 std::string value; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1862 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_NAME)); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1863 ASSERT_EQ(value, std::string(reinterpret_cast<const char*>(utf8), sizeof(utf8))); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1864 } |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1865 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1866 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1867 TEST(Toolbox, EncodingsSimplifiedChinese3) |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1868 { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1869 // http://dicom.nema.org/MEDICAL/dicom/current/output/chtml/part05/sect_K.2.html |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1870 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1871 static const uint8_t chinese[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1872 0x31, 0x2e, 0x1b, 0x24, 0x29, 0x41, 0xb5, 0xda, 0xd2, 0xbb, 0xd0, 0xd0, 0xce, 0xc4, 0xd7, 0xd6, 0xa1, 0xa3, 0x0d, 0x0a, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1873 0x32, 0x2e, 0x1b, 0x24, 0x29, 0x41, 0xb5, 0xda, 0xb6, 0xfe, 0xd0, 0xd0, 0xce, 0xc4, 0xd7, 0xd6, 0xa1, 0xa3, 0x0d, 0x0a, |
3229 | 1874 0x33, 0x2e, 0x1b, 0x24, 0x29, 0x41, 0xb5, 0xda, 0xc8, 0xfd, 0xd0, 0xd0, 0xce, 0xc4, 0xd7, 0xd6, 0xa1, 0xa3, 0x0d, 0x0a, 0x00 |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1875 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1876 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1877 static const uint8_t line1[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1878 0x31, 0x2e, 0xe7, 0xac, 0xac, 0xe4, 0xb8, 0x80, 0xe8, 0xa1, 0x8c, 0xe6, 0x96, 0x87, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1879 0xe5, 0xad, 0x97, 0xe3, 0x80, 0x82, '\r' |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1880 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1881 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1882 static const uint8_t line2[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1883 0x32, 0x2e, 0xe7, 0xac, 0xac, 0xe4, 0xba, 0x8c, 0xe8, 0xa1, 0x8c, 0xe6, 0x96, 0x87, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1884 0xe5, 0xad, 0x97, 0xe3, 0x80, 0x82, '\r' |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1885 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1886 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1887 static const uint8_t line3[] = { |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1888 0x33, 0x2e, 0xe7, 0xac, 0xac, 0xe4, 0xb8, 0x89, 0xe8, 0xa1, 0x8c, 0xe6, 0x96, 0x87, |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1889 0xe5, 0xad, 0x97, 0xe3, 0x80, 0x82, '\r' |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1890 }; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1891 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1892 ParsedDicomFile dicom(false); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1893 dicom.ReplacePlainString(DICOM_TAG_SPECIFIC_CHARACTER_SET, "\\ISO 2022 IR 58"); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1894 ASSERT_TRUE(dicom.GetDcmtkObject().getDataset()->putAndInsertString |
3228
4b9cfd92d1ae
preparing for libicu
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3226
diff
changeset
|
1895 (DCM_PatientName, reinterpret_cast<const char*>(chinese), OFBool(true)).good()); |
3226
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1896 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1897 bool hasCodeExtensions; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1898 Encoding encoding = dicom.DetectEncoding(hasCodeExtensions); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1899 ASSERT_EQ(Encoding_SimplifiedChinese, encoding); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1900 ASSERT_TRUE(hasCodeExtensions); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1901 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1902 std::string value; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1903 ASSERT_TRUE(dicom.GetTagValue(value, DICOM_TAG_PATIENT_NAME)); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1904 |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1905 std::vector<std::string> lines; |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1906 Toolbox::TokenizeString(lines, value, '\n'); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1907 ASSERT_EQ(4u, lines.size()); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1908 ASSERT_EQ(std::string(reinterpret_cast<const char*>(line1), sizeof(line1)), lines[0]); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1909 ASSERT_EQ(std::string(reinterpret_cast<const char*>(line2), sizeof(line2)), lines[1]); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1910 ASSERT_EQ(std::string(reinterpret_cast<const char*>(line3), sizeof(line3)), lines[2]); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1911 ASSERT_TRUE(lines[3].empty()); |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1912 } |
45e1631febbb
support of simplified chinese
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3225
diff
changeset
|
1913 |