Mercurial > hg > orthanc-stone

comparison Framework/Loaders/LoaderCache.cpp @ 1337:b1396be5aa27 broker

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Moved the fixed loaders back from the dead
author Benjamin Golinvaux <bgo@osimis.io>
date Fri, 03 Apr 2020 16:13:06 +0200
parents Framework/Deprecated/Loaders/LoaderCache.cpp@4f8db2d202c8
children 556b4bc19118
comparison
equal deleted inserted replaced
1334:04055b6b9e2c 1337:b1396be5aa27
1 /**
2 * Stone of Orthanc
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium
6 *
7 * This program is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU Affero General Public License
9 * as published by the Free Software Foundation, either version 3 of
10 * the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Affero General Public License for more details.
16 *
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/
20
21 #include "LoaderCache.h"
22
23 #include "../../StoneException.h"
24 #include "OrthancSeriesVolumeProgressiveLoader.h"
25 #include "OrthancMultiframeVolumeLoader.h"
26 #include "DicomStructureSetLoader.h"
27
28 #include "../../Loaders/ILoadersContext.h"
29
30
31 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
32 #include "DicomStructureSetLoader2.h"
33 #endif
34 //BGO_ENABLE_DICOMSTRUCTURESETLOADER2
35
36
37 #if ORTHANC_ENABLE_WASM == 1
38 # include <unistd.h>
39 # include "../../Oracle/WebAssemblyOracle.h"
40 #else
41 # include "../../Oracle/ThreadedOracle.h"
42 #endif
43
44 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
45 #include "../../Toolbox/DicomStructureSet2.h"
46 #endif
47 //BGO_ENABLE_DICOMSTRUCTURESETLOADER2
48
49 #include "../../Volumes/DicomVolumeImage.h"
50 #include "../../Volumes/DicomVolumeImageMPRSlicer.h"
51
52 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
53 #include "../../Volumes/DicomStructureSetSlicer2.h"
54 #endif
55 //BGO_ENABLE_DICOMSTRUCTURESETLOADER2
56
57 #include <Core/OrthancException.h>
58 #include <Core/Toolbox.h>
59
60 namespace OrthancStone
61 {
62 LoaderCache::LoaderCache(OrthancStone::ILoadersContext& loadersContext)
63 : loadersContext_(loadersContext)
64 {
65
66 }
67
68 boost::shared_ptr<OrthancSeriesVolumeProgressiveLoader>
69 LoaderCache::GetSeriesVolumeProgressiveLoader(std::string seriesUuid)
70 {
71 try
72 {
73
74 // normalize keys a little
75 seriesUuid = Orthanc::Toolbox::StripSpaces(seriesUuid);
76 Orthanc::Toolbox::ToLowerCase(seriesUuid);
77
78 // find in cache
79 if (seriesVolumeProgressiveLoaders_.find(seriesUuid) == seriesVolumeProgressiveLoaders_.end())
80 {
81 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(loadersContext_.Lock());
82
83 boost::shared_ptr<OrthancStone::DicomVolumeImage> volumeImage(new OrthancStone::DicomVolumeImage);
84 boost::shared_ptr<OrthancSeriesVolumeProgressiveLoader> loader;
85
86 // true means "use progressive quality"
87 // false means "load high quality slices only"
88 loader = OrthancSeriesVolumeProgressiveLoader::Create(loadersContext_, volumeImage, false);
89 loader->LoadSeries(seriesUuid);
90 seriesVolumeProgressiveLoaders_[seriesUuid] = loader;
91 }
92 else
93 {
94 // LOG(TRACE) << "LoaderCache::GetSeriesVolumeProgressiveLoader : returning cached loader for seriesUUid = " << seriesUuid;
95 }
96 return seriesVolumeProgressiveLoaders_[seriesUuid];
97 }
98 catch (const Orthanc::OrthancException& e)
99 {
100 if (e.HasDetails())
101 {
102 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What() << " Details: " << e.GetDetails();
103 }
104 else
105 {
106 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What();
107 }
108 throw;
109 }
110 catch (const std::exception& e)
111 {
112 LOG(ERROR) << "std::exception in LoaderCache: " << e.what();
113 throw;
114 }
115 catch (...)
116 {
117 LOG(ERROR) << "Unknown exception in LoaderCache";
118 throw;
119 }
120 }
121
122 boost::shared_ptr<OrthancMultiframeVolumeLoader> LoaderCache::GetMultiframeVolumeLoader(std::string instanceUuid)
123 {
124 // if the loader is not available, let's trigger its creation
125 if(multiframeVolumeLoaders_.find(instanceUuid) == multiframeVolumeLoaders_.end())
126 {
127 GetMultiframeDicomVolumeImageMPRSlicer(instanceUuid);
128 }
129 ORTHANC_ASSERT(multiframeVolumeLoaders_.find(instanceUuid) != multiframeVolumeLoaders_.end());
130
131 return multiframeVolumeLoaders_[instanceUuid];
132 }
133
134 boost::shared_ptr<OrthancStone::DicomVolumeImageMPRSlicer> LoaderCache::GetMultiframeDicomVolumeImageMPRSlicer(std::string instanceUuid)
135 {
136 try
137 {
138 // normalize keys a little
139 instanceUuid = Orthanc::Toolbox::StripSpaces(instanceUuid);
140 Orthanc::Toolbox::ToLowerCase(instanceUuid);
141
142 // find in cache
143 if (dicomVolumeImageMPRSlicers_.find(instanceUuid) == dicomVolumeImageMPRSlicers_.end())
144 {
145 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(loadersContext_.Lock());
146 boost::shared_ptr<OrthancStone::DicomVolumeImage> volumeImage(new OrthancStone::DicomVolumeImage);
147 boost::shared_ptr<OrthancMultiframeVolumeLoader> loader;
148 {
149 loader = OrthancMultiframeVolumeLoader::Create(loadersContext_, volumeImage);
150 loader->LoadInstance(instanceUuid);
151 }
152 multiframeVolumeLoaders_[instanceUuid] = loader;
153 boost::shared_ptr<OrthancStone::DicomVolumeImageMPRSlicer> mprSlicer(new OrthancStone::DicomVolumeImageMPRSlicer(volumeImage));
154 dicomVolumeImageMPRSlicers_[instanceUuid] = mprSlicer;
155 }
156 return dicomVolumeImageMPRSlicers_[instanceUuid];
157 }
158 catch (const Orthanc::OrthancException& e)
159 {
160 if (e.HasDetails())
161 {
162 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What() << " Details: " << e.GetDetails();
163 }
164 else
165 {
166 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What();
167 }
168 throw;
169 }
170 catch (const std::exception& e)
171 {
172 LOG(ERROR) << "std::exception in LoaderCache: " << e.what();
173 throw;
174 }
175 catch (...)
176 {
177 LOG(ERROR) << "Unknown exception in LoaderCache";
178 throw;
179 }
180 }
181
182 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
183
184 boost::shared_ptr<DicomStructureSetSlicer2> LoaderCache::GetDicomStructureSetSlicer2(std::string instanceUuid)
185 {
186 // if the loader is not available, let's trigger its creation
187 if (dicomStructureSetSlicers2_.find(instanceUuid) == dicomStructureSetSlicers2_.end())
188 {
189 GetDicomStructureSetLoader2(instanceUuid);
190 }
191 ORTHANC_ASSERT(dicomStructureSetSlicers2_.find(instanceUuid) != dicomStructureSetSlicers2_.end());
192
193 return dicomStructureSetSlicers2_[instanceUuid];
194 }
195 #endif
196 //BGO_ENABLE_DICOMSTRUCTURESETLOADER2
197
198
199 /**
200 This method allows to convert a list of string into a string by
201 sorting the strings then joining them
202 */
203 static std::string SortAndJoin(const std::vector<std::string>& stringList)
204 {
205 if (stringList.size() == 0)
206 {
207 return "";
208 }
209 else
210 {
211 std::vector<std::string> sortedStringList = stringList;
212 std::sort(sortedStringList.begin(), sortedStringList.end());
213 std::stringstream s;
214 s << sortedStringList[0];
215 for (size_t i = 1; i < sortedStringList.size(); ++i)
216 {
217 s << "-" << sortedStringList[i];
218 }
219 return s.str();
220 }
221 }
222
223 boost::shared_ptr<DicomStructureSetLoader>
224 LoaderCache::GetDicomStructureSetLoader(
225 std::string inInstanceUuid,
226 const std::vector<std::string>& initiallyVisibleStructures)
227 {
228 try
229 {
230 // normalize keys a little
231 inInstanceUuid = Orthanc::Toolbox::StripSpaces(inInstanceUuid);
232 Orthanc::Toolbox::ToLowerCase(inInstanceUuid);
233
234 std::string initiallyVisibleStructuresKey =
235 SortAndJoin(initiallyVisibleStructures);
236
237 std::string entryKey = inInstanceUuid + "_" + initiallyVisibleStructuresKey;
238
239 // find in cache
240 if (dicomStructureSetLoaders_.find(entryKey) == dicomStructureSetLoaders_.end())
241 {
242 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(loadersContext_.Lock());
243
244 boost::shared_ptr<DicomStructureSetLoader> loader;
245 {
246 loader = DicomStructureSetLoader::Create(loadersContext_);
247 loader->LoadInstance(inInstanceUuid, initiallyVisibleStructures);
248 }
249 dicomStructureSetLoaders_[entryKey] = loader;
250 }
251 return dicomStructureSetLoaders_[entryKey];
252 }
253 catch (const Orthanc::OrthancException& e)
254 {
255 if (e.HasDetails())
256 {
257 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What() << " Details: " << e.GetDetails();
258 }
259 else
260 {
261 LOG(ERROR) << "OrthancException in LoaderCache: " << e.What();
262 }
263 throw;
264 }
265 catch (const std::exception& e)
266 {
267 LOG(ERROR) << "std::exception in LoaderCache: " << e.what();
268 throw;
269 }
270 catch (...)
271 {
272 LOG(ERROR) << "Unknown exception in LoaderCache";
273 throw;
274 }
275 }
276
277 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
278
279 boost::shared_ptr<DicomStructureSetLoader2> LoaderCache::GetDicomStructureSetLoader2(std::string instanceUuid)
280 {
281 try
282 {
283 // normalize keys a little
284 instanceUuid = Orthanc::Toolbox::StripSpaces(instanceUuid);
285 Orthanc::Toolbox::ToLowerCase(instanceUuid);
286
287 // find in cache
288 if (dicomStructureSetLoaders2_.find(instanceUuid) == dicomStructureSetLoaders2_.end())
289 {
290 boost::shared_ptr<DicomStructureSetLoader2> loader;
291 boost::shared_ptr<DicomStructureSet2> structureSet(new DicomStructureSet2());
292 boost::shared_ptr<DicomStructureSetSlicer2> rtSlicer(new DicomStructureSetSlicer2(structureSet));
293 dicomStructureSetSlicers2_[instanceUuid] = rtSlicer;
294 dicomStructureSets2_[instanceUuid] = structureSet; // to prevent it from being deleted
295 {
296 #if ORTHANC_ENABLE_WASM == 1
297 loader.reset(new DicomStructureSetLoader2(*(structureSet.get()), oracle_, oracle_));
298 #else
299 LockingEmitter::WriterLock lock(lockingEmitter_);
300 // TODO: clarify lifetimes... this is DANGEROUS!
301 loader.reset(new DicomStructureSetLoader2(*(structureSet.get()), oracle_, lock.GetOracleObservable()));
302 #endif
303 loader->LoadInstance(instanceUuid);
304 }
305 dicomStructureSetLoaders2_[instanceUuid] = loader;
306 }
307 return dicomStructureSetLoaders2_[instanceUuid];
308 }
309 catch (const Orthanc::OrthancException& e)
310 {
311 if (e.HasDetails())
312 {
313 LOG(ERROR) << "OrthancException in GetDicomStructureSetLoader2: " << e.What() << " Details: " << e.GetDetails();
314 }
315 else
316 {
317 LOG(ERROR) << "OrthancException in GetDicomStructureSetLoader2: " << e.What();
318 }
319 throw;
320 }
321 catch (const std::exception& e)
322 {
323 LOG(ERROR) << "std::exception in GetDicomStructureSetLoader2: " << e.what();
324 throw;
325 }
326 catch (...)
327 {
328 LOG(ERROR) << "Unknown exception in GetDicomStructureSetLoader2";
329 throw;
330 }
331 }
332
333 #endif
334 // BGO_ENABLE_DICOMSTRUCTURESETLOADER2
335
336
337 void LoaderCache::ClearCache()
338 {
339 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(loadersContext_.Lock());
340
341 #ifndef NDEBUG
342 // ISO way of checking for debug builds
343 DebugDisplayObjRefCounts();
344 #endif
345 seriesVolumeProgressiveLoaders_.clear();
346 multiframeVolumeLoaders_.clear();
347 dicomVolumeImageMPRSlicers_.clear();
348 dicomStructureSetLoaders_.clear();
349
350 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
351 // order is important!
352 dicomStructureSetLoaders2_.clear();
353 dicomStructureSetSlicers2_.clear();
354 dicomStructureSets2_.clear();
355 #endif
356 // BGO_ENABLE_DICOMSTRUCTURESETLOADER2
357 }
358
359 template<typename T> void DebugDisplayObjRefCountsInMap(
360 const std::string& name, const std::map<std::string, boost::shared_ptr<T> >& myMap)
361 {
362 LOG(TRACE) << "Map \"" << name << "\" ref counts:";
363 size_t i = 0;
364 for (typename std::map<std::string, boost::shared_ptr<T> >::const_iterator
365 it = myMap.begin(); it != myMap.end(); ++it)
366 {
367 LOG(TRACE) << " element #" << i << ": ref count = " << it->second.use_count();
368 i++;
369 }
370 }
371
372 void LoaderCache::DebugDisplayObjRefCounts()
373 {
374 DebugDisplayObjRefCountsInMap("seriesVolumeProgressiveLoaders_", seriesVolumeProgressiveLoaders_);
375 DebugDisplayObjRefCountsInMap("multiframeVolumeLoaders_", multiframeVolumeLoaders_);
376 DebugDisplayObjRefCountsInMap("dicomVolumeImageMPRSlicers_", dicomVolumeImageMPRSlicers_);
377 DebugDisplayObjRefCountsInMap("dicomStructureSetLoaders_", dicomStructureSetLoaders_);
378 #ifdef BGO_ENABLE_DICOMSTRUCTURESETLOADER2
379 DebugDisplayObjRefCountsInMap("dicomStructureSetLoaders2_", dicomStructureSetLoaders2_);
380 DebugDisplayObjRefCountsInMap("dicomStructureSetSlicers2_", dicomStructureSetSlicers2_);
381 #endif
382 //BGO_ENABLE_DICOMSTRUCTURESETLOADER2
383 }
384 }