Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 1625:c17b1142caab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
reorganization
author Sebastien Jodogne <s.jodogne@gmail.com>
date Fri, 18 Sep 2015 12:58:51 +0200
parents 0a2ad4a6858f
children da7854deb662
comparison
equal deleted inserted replaced
1624:0a2ad4a6858f 1625:c17b1142caab
28 * You should have received a copy of the GNU General Public License 28 * You should have received a copy of the GNU General Public License
29 * along with this program. If not, see <http://www.gnu.org/licenses/>. 29 * along with this program. If not, see <http://www.gnu.org/licenses/>.
30 **/ 30 **/
31 31
32 32
33 #include "../../Core/PrecompiledHeaders.h" 33 #include "../../OrthancServer/PrecompiledHeadersServer.h"
34 #include "OrthancPlugins.h" 34 #include "OrthancPlugins.h"
35 35
36 #include "../../Core/ChunkedBuffer.h" 36 #include "../../Core/ChunkedBuffer.h"
37 #include "../../Core/HttpServer/HttpToolbox.h" 37 #include "../../Core/HttpServer/HttpToolbox.h"
38 #include "../../Core/Logging.h" 38 #include "../../Core/Logging.h"
47 #include "../../Core/Images/PngReader.h" 47 #include "../../Core/Images/PngReader.h"
48 #include "../../Core/Images/PngWriter.h" 48 #include "../../Core/Images/PngWriter.h"
49 #include "../../Core/Images/JpegReader.h" 49 #include "../../Core/Images/JpegReader.h"
50 #include "../../Core/Images/JpegWriter.h" 50 #include "../../Core/Images/JpegWriter.h"
51 #include "../../Core/Images/ImageProcessing.h" 51 #include "../../Core/Images/ImageProcessing.h"
52 #include "PluginsEnumerations.h"
52 53
53 #include <boost/regex.hpp> 54 #include <boost/regex.hpp>
54 55
55 namespace Orthanc 56 namespace Orthanc
56 { 57 {
57 static OrthancPluginResourceType Convert(ResourceType type)
58 {
59 switch (type)
60 {
61 case ResourceType_Patient:
62 return OrthancPluginResourceType_Patient;
63
64 case ResourceType_Study:
65 return OrthancPluginResourceType_Study;
66
67 case ResourceType_Series:
68 return OrthancPluginResourceType_Series;
69
70 case ResourceType_Instance:
71 return OrthancPluginResourceType_Instance;
72
73 default:
74 throw OrthancException(ErrorCode_ParameterOutOfRange);
75 }
76 }
77
78
79 static OrthancPluginChangeType Convert(ChangeType type)
80 {
81 switch (type)
82 {
83 case ChangeType_CompletedSeries:
84 return OrthancPluginChangeType_CompletedSeries;
85
86 case ChangeType_Deleted:
87 return OrthancPluginChangeType_Deleted;
88
89 case ChangeType_NewChildInstance:
90 return OrthancPluginChangeType_NewChildInstance;
91
92 case ChangeType_NewInstance:
93 return OrthancPluginChangeType_NewInstance;
94
95 case ChangeType_NewPatient:
96 return OrthancPluginChangeType_NewPatient;
97
98 case ChangeType_NewSeries:
99 return OrthancPluginChangeType_NewSeries;
100
101 case ChangeType_NewStudy:
102 return OrthancPluginChangeType_NewStudy;
103
104 case ChangeType_StablePatient:
105 return OrthancPluginChangeType_StablePatient;
106
107 case ChangeType_StableSeries:
108 return OrthancPluginChangeType_StableSeries;
109
110 case ChangeType_StableStudy:
111 return OrthancPluginChangeType_StableStudy;
112
113 default:
114 throw OrthancException(ErrorCode_ParameterOutOfRange);
115 }
116 }
117
118
119 static OrthancPluginPixelFormat Convert(PixelFormat format)
120 {
121 switch (format)
122 {
123 case PixelFormat_Grayscale16:
124 return OrthancPluginPixelFormat_Grayscale16;
125
126 case PixelFormat_Grayscale8:
127 return OrthancPluginPixelFormat_Grayscale8;
128
129 case PixelFormat_RGB24:
130 return OrthancPluginPixelFormat_RGB24;
131
132 case PixelFormat_RGBA32:
133 return OrthancPluginPixelFormat_RGBA32;
134
135 case PixelFormat_SignedGrayscale16:
136 return OrthancPluginPixelFormat_SignedGrayscale16;
137
138 default:
139 throw OrthancException(ErrorCode_ParameterOutOfRange);
140 }
141 }
142
143
144 static PixelFormat Convert(OrthancPluginPixelFormat format)
145 {
146 switch (format)
147 {
148 case OrthancPluginPixelFormat_Grayscale16:
149 return PixelFormat_Grayscale16;
150
151 case OrthancPluginPixelFormat_Grayscale8:
152 return PixelFormat_Grayscale8;
153
154 case OrthancPluginPixelFormat_RGB24:
155 return PixelFormat_RGB24;
156
157 case OrthancPluginPixelFormat_RGBA32:
158 return PixelFormat_RGBA32;
159
160 case OrthancPluginPixelFormat_SignedGrayscale16:
161 return PixelFormat_SignedGrayscale16;
162
163 default:
164 throw OrthancException(ErrorCode_ParameterOutOfRange);
165 }
166 }
167
168
169 static OrthancPluginContentType Convert(FileContentType type)
170 {
171 switch (type)
172 {
173 case FileContentType_Dicom:
174 return OrthancPluginContentType_Dicom;
175
176 case FileContentType_DicomAsJson:
177 return OrthancPluginContentType_DicomAsJson;
178
179 default:
180 return OrthancPluginContentType_Unknown;
181 }
182 }
183
184
185 static FileContentType Convert(OrthancPluginContentType type)
186 {
187 switch (type)
188 {
189 case OrthancPluginContentType_Dicom:
190 return FileContentType_Dicom;
191
192 case OrthancPluginContentType_DicomAsJson:
193 return FileContentType_DicomAsJson;
194
195 default:
196 return FileContentType_Unknown;
197 }
198 }
199
200
201 struct OrthancPlugins::PImpl 58 struct OrthancPlugins::PImpl
202 { 59 {
203 class RestCallback : public boost::noncopyable 60 class RestCallback : public boost::noncopyable
204 { 61 {
205 private: 62 private:
528 385
529 for (std::list<OrthancPluginOnChangeCallback>::const_iterator 386 for (std::list<OrthancPluginOnChangeCallback>::const_iterator
530 callback = pimpl_->onChangeCallbacks_.begin(); 387 callback = pimpl_->onChangeCallbacks_.begin();
531 callback != pimpl_->onChangeCallbacks_.end(); ++callback) 388 callback != pimpl_->onChangeCallbacks_.end(); ++callback)
532 { 389 {
533 (*callback) (Convert(change.GetChangeType()), 390 (*callback) (Plugins::Convert(change.GetChangeType()),
534 Convert(change.GetResourceType()), 391 Plugins::Convert(change.GetResourceType()),
535 change.GetPublicId().c_str()); 392 change.GetPublicId().c_str());
536 } 393 }
537 } 394 }
538 catch (OrthancException&) 395 catch (OrthancException&)
539 { 396 {
737 *reinterpret_cast<const _OrthancPluginCompressAndAnswerImage*>(parameters); 594 *reinterpret_cast<const _OrthancPluginCompressAndAnswerImage*>(parameters);
738 595
739 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output); 596 HttpOutput* translatedOutput = reinterpret_cast<HttpOutput*>(p.output);
740 597
741 ImageAccessor accessor; 598 ImageAccessor accessor;
742 accessor.AssignReadOnly(Convert(p.pixelFormat), p.width, p.height, p.pitch, p.buffer); 599 accessor.AssignReadOnly(Plugins::Convert(p.pixelFormat), p.width, p.height, p.pitch, p.buffer);
743 600
744 std::string compressed; 601 std::string compressed;
745 602
746 switch (p.imageFormat) 603 switch (p.imageFormat)
747 { 604 {
1133 switch (p.imageFormat) 990 switch (p.imageFormat)
1134 { 991 {
1135 case OrthancPluginImageFormat_Png: 992 case OrthancPluginImageFormat_Png:
1136 { 993 {
1137 PngWriter writer; 994 PngWriter writer;
1138 writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Convert(p.pixelFormat), p.buffer); 995 writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Plugins::Convert(p.pixelFormat), p.buffer);
1139 break; 996 break;
1140 } 997 }
1141 998
1142 case OrthancPluginImageFormat_Jpeg: 999 case OrthancPluginImageFormat_Jpeg:
1143 { 1000 {
1144 JpegWriter writer; 1001 JpegWriter writer;
1145 writer.SetQuality(p.quality); 1002 writer.SetQuality(p.quality);
1146 writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Convert(p.pixelFormat), p.buffer); 1003 writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Plugins::Convert(p.pixelFormat), p.buffer);
1147 break; 1004 break;
1148 } 1005 }
1149 1006
1150 default: 1007 default:
1151 throw OrthancException(ErrorCode_ParameterOutOfRange); 1008 throw OrthancException(ErrorCode_ParameterOutOfRange);
1205 void OrthancPlugins::ConvertPixelFormat(const void* parameters) 1062 void OrthancPlugins::ConvertPixelFormat(const void* parameters)
1206 { 1063 {
1207 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters); 1064 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters);
1208 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source); 1065 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source);
1209 1066
1210 std::auto_ptr<ImageAccessor> target(new Image(Convert(p.targetFormat), source.GetWidth(), source.GetHeight())); 1067 std::auto_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight()));
1211 ImageProcessing::Convert(*target, source); 1068 ImageProcessing::Convert(*target, source);
1212 1069
1213 *(p.target) = reinterpret_cast<OrthancPluginImage*>(target.release()); 1070 *(p.target) = reinterpret_cast<OrthancPluginImage*>(target.release());
1214 } 1071 }
1215 1072
1570 } 1427 }
1571 1428
1572 case _OrthancPluginService_GetImagePixelFormat: 1429 case _OrthancPluginService_GetImagePixelFormat:
1573 { 1430 {
1574 const _OrthancPluginGetImageInfo& p = *reinterpret_cast<const _OrthancPluginGetImageInfo*>(parameters); 1431 const _OrthancPluginGetImageInfo& p = *reinterpret_cast<const _OrthancPluginGetImageInfo*>(parameters);
1575 *(p.resultPixelFormat) = Convert(reinterpret_cast<const ImageAccessor*>(p.image)->GetFormat()); 1432 *(p.resultPixelFormat) = Plugins::Convert(reinterpret_cast<const ImageAccessor*>(p.image)->GetFormat());
1576 return true; 1433 return true;
1577 } 1434 }
1578 1435
1579 case _OrthancPluginService_GetImageWidth: 1436 case _OrthancPluginService_GetImageWidth:
1580 { 1437 {
1653 case _OrthancPluginService_StorageAreaCreate: 1510 case _OrthancPluginService_StorageAreaCreate:
1654 { 1511 {
1655 const _OrthancPluginStorageAreaCreate& p = 1512 const _OrthancPluginStorageAreaCreate& p =
1656 *reinterpret_cast<const _OrthancPluginStorageAreaCreate*>(parameters); 1513 *reinterpret_cast<const _OrthancPluginStorageAreaCreate*>(parameters);
1657 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea); 1514 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
1658 storage.Create(p.uuid, p.content, p.size, Convert(p.type)); 1515 storage.Create(p.uuid, p.content, p.size, Plugins::Convert(p.type));
1659 return true; 1516 return true;
1660 } 1517 }
1661 1518
1662 case _OrthancPluginService_StorageAreaRead: 1519 case _OrthancPluginService_StorageAreaRead:
1663 { 1520 {
1664 const _OrthancPluginStorageAreaRead& p = 1521 const _OrthancPluginStorageAreaRead& p =
1665 *reinterpret_cast<const _OrthancPluginStorageAreaRead*>(parameters); 1522 *reinterpret_cast<const _OrthancPluginStorageAreaRead*>(parameters);
1666 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea); 1523 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
1667 std::string content; 1524 std::string content;
1668 storage.Read(content, p.uuid, Convert(p.type)); 1525 storage.Read(content, p.uuid, Plugins::Convert(p.type));
1669 CopyToMemoryBuffer(*p.target, content); 1526 CopyToMemoryBuffer(*p.target, content);
1670 return true; 1527 return true;
1671 } 1528 }
1672 1529
1673 case _OrthancPluginService_StorageAreaRemove: 1530 case _OrthancPluginService_StorageAreaRemove:
1674 { 1531 {
1675 const _OrthancPluginStorageAreaRemove& p = 1532 const _OrthancPluginStorageAreaRemove& p =
1676 *reinterpret_cast<const _OrthancPluginStorageAreaRemove*>(parameters); 1533 *reinterpret_cast<const _OrthancPluginStorageAreaRemove*>(parameters);
1677 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea); 1534 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
1678 storage.Remove(p.uuid, Convert(p.type)); 1535 storage.Remove(p.uuid, Plugins::Convert(p.type));
1679 return true; 1536 return true;
1680 } 1537 }
1681 1538
1682 default: 1539 default:
1683 { 1540 {
1723 virtual void Create(const std::string& uuid, 1580 virtual void Create(const std::string& uuid,
1724 const void* content, 1581 const void* content,
1725 size_t size, 1582 size_t size,
1726 FileContentType type) 1583 FileContentType type)
1727 { 1584 {
1728 if (params_.create(uuid.c_str(), content, size, Convert(type)) != 0) 1585 if (params_.create(uuid.c_str(), content, size, Plugins::Convert(type)) != 0)
1729 { 1586 {
1730 throw OrthancException(ErrorCode_Plugin); 1587 throw OrthancException(ErrorCode_Plugin);
1731 } 1588 }
1732 } 1589 }
1733 1590
1736 FileContentType type) 1593 FileContentType type)
1737 { 1594 {
1738 void* buffer = NULL; 1595 void* buffer = NULL;
1739 int64_t size = 0; 1596 int64_t size = 0;
1740 1597
1741 if (params_.read(&buffer, &size, uuid.c_str(), Convert(type)) != 0) 1598 if (params_.read(&buffer, &size, uuid.c_str(), Plugins::Convert(type)) != 0)
1742 { 1599 {
1743 throw OrthancException(ErrorCode_Plugin); 1600 throw OrthancException(ErrorCode_Plugin);
1744 } 1601 }
1745 1602
1746 try 1603 try
1762 } 1619 }
1763 1620
1764 virtual void Remove(const std::string& uuid, 1621 virtual void Remove(const std::string& uuid,
1765 FileContentType type) 1622 FileContentType type)
1766 { 1623 {
1767 if (params_.remove(uuid.c_str(), Convert(type)) != 0) 1624 if (params_.remove(uuid.c_str(), Plugins::Convert(type)) != 0)
1768 { 1625 {
1769 throw OrthancException(ErrorCode_Plugin); 1626 throw OrthancException(ErrorCode_Plugin);
1770 } 1627 }
1771 } 1628 }
1772 }; 1629 };