Mercurial > hg > orthanc-wsi

comparison ViewerPlugin/IIIF.cpp @ 261:c72fbdecdc38 iiif

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 Mon, 10 Jul 2023 08:59:40 +0200
parents
children 75d933374805
comparison
equal deleted inserted replaced
260:35c241231af2 261:c72fbdecdc38
1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
4 * Department, University Hospital of Liege, Belgium
5 * Copyright (C) 2017-2023 Osimis S.A., Belgium
6 * Copyright (C) 2021-2023 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
7 *
8 * This program is free software: you can redistribute it and/or
9 * modify it under the terms of the GNU Affero General Public License
10 * as published by the Free Software Foundation, either version 3 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Affero General Public License for more details.
17 *
18 * You should have received a copy of the GNU Affero General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 **/
21
22
23 #include "../Framework/PrecompiledHeadersWSI.h"
24 #include "IIIF.h"
25
26 #include "DicomPyramidCache.h"
27 #include "RawTile.h"
28 #include "../Resources/Orthanc/Plugins/OrthancPluginCppWrapper.h"
29
30 #include <Images/Image.h>
31 #include <Images/ImageProcessing.h>
32 #include <Logging.h>
33
34 #include <boost/regex.hpp>
35 #include <boost/math/special_functions/round.hpp>
36
37
38 static std::string iiifPublicUrl_;
39
40
41 static void ServeIIIFImageInfo(OrthancPluginRestOutput* output,
42 const char* url,
43 const OrthancPluginHttpRequest* request)
44 {
45 std::string seriesId(request->groups[0]);
46
47 LOG(INFO) << "IIIF: Image API call to whole-slide pyramid of series " << seriesId;
48
49 OrthancWSI::DicomPyramidCache::Locker locker(seriesId);
50
51 if (locker.GetPyramid().GetLevelCount() == 0)
52 {
53 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
54 }
55
56 if (locker.GetPyramid().GetTileWidth(0) != locker.GetPyramid().GetTileHeight(0))
57 {
58 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat,
59 "IIIF doesn't support non-isotropic tile sizes");
60 }
61
62 for (unsigned int i = 1; i < locker.GetPyramid().GetLevelCount(); i++)
63 {
64 if (locker.GetPyramid().GetTileWidth(i) != locker.GetPyramid().GetTileWidth(0) ||
65 locker.GetPyramid().GetTileHeight(i) != locker.GetPyramid().GetTileHeight(0))
66 {
67 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat,
68 "IIIF doesn't support levels with varying tile sizes");
69 }
70 }
71
72 Json::Value sizes = Json::arrayValue;
73 Json::Value scaleFactors = Json::arrayValue;
74
75 for (unsigned int i = locker.GetPyramid().GetLevelCount(); i > 0; i--)
76 {
77 /**
78 * Openseadragon seems to have difficulties in rendering
79 * non-integer scale factors. Consequently, we only keep the
80 * levels with an integer scale factor.
81 **/
82 if (locker.GetPyramid().GetLevelWidth(0) % locker.GetPyramid().GetLevelWidth(i - 1) == 0 &&
83 locker.GetPyramid().GetLevelHeight(0) % locker.GetPyramid().GetLevelHeight(i - 1) == 0)
84 {
85 Json::Value level;
86 level["width"] = locker.GetPyramid().GetLevelWidth(i - 1);
87 level["height"] = locker.GetPyramid().GetLevelHeight(i - 1);
88 sizes.append(level);
89
90 scaleFactors.append(static_cast<float>(locker.GetPyramid().GetLevelWidth(0)) /
91 static_cast<float>(locker.GetPyramid().GetLevelWidth(i - 1)));
92 }
93 }
94
95 Json::Value tiles;
96 tiles["width"] = locker.GetPyramid().GetTileWidth(0);
97 tiles["height"] = locker.GetPyramid().GetTileHeight(0);
98 tiles["scaleFactors"] = scaleFactors;
99
100 Json::Value result;
101 result["@context"] = "http://iiif.io/api/image/2/context.json";
102 result["@id"] = iiifPublicUrl_ + seriesId;
103 result["profile"] = "http://iiif.io/api/image/2/level0.json";
104 result["protocol"] = "http://iiif.io/api/image";
105 result["width"] = locker.GetPyramid().GetLevelWidth(0);
106 result["height"] = locker.GetPyramid().GetLevelHeight(0);
107 result["sizes"] = sizes;
108
109 result["tiles"] = Json::arrayValue;
110 result["tiles"].append(tiles);
111
112 std::string s = result.toStyledString();
113 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json");
114 }
115
116
117 static unsigned int GetPhysicalTileWidth(const OrthancWSI::ITiledPyramid& pyramid,
118 unsigned int level)
119 {
120 return static_cast<unsigned int>(boost::math::iround(
121 static_cast<float>(pyramid.GetTileWidth(level)) *
122 static_cast<float>(pyramid.GetLevelWidth(0)) /
123 static_cast<float>(pyramid.GetLevelWidth(level))));
124 }
125
126
127 static unsigned int GetPhysicalTileHeight(const OrthancWSI::ITiledPyramid& pyramid,
128 unsigned int level)
129 {
130 return static_cast<unsigned int>(boost::math::iround(
131 static_cast<float>(pyramid.GetTileHeight(level)) *
132 static_cast<float>(pyramid.GetLevelHeight(0)) /
133 static_cast<float>(pyramid.GetLevelHeight(level))));
134 }
135
136
137 static void ServeIIIFImageTile(OrthancPluginRestOutput* output,
138 const char* url,
139 const OrthancPluginHttpRequest* request)
140 {
141 std::string seriesId(request->groups[0]);
142 std::string region(request->groups[1]);
143 std::string size(request->groups[2]);
144 std::string rotation(request->groups[3]);
145 std::string quality(request->groups[4]);
146 std::string format(request->groups[5]);
147
148 LOG(INFO) << "IIIF: Image API call to tile of series " << seriesId << ": "
149 << "region=" << region << "; size=" << size << "; rotation="
150 << rotation << "; quality=" << quality << "; format=" << format;
151
152 if (rotation != "0")
153 {
154 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented, "IIIF - Unsupported rotation: " + rotation);
155 }
156
157 if (quality != "default")
158 {
159 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented, "IIIF - Unsupported quality: " + quality);
160 }
161
162 if (format != "jpg")
163 {
164 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented, "IIIF - Unsupported format: " + format);
165 }
166
167 if (region == "full")
168 {
169 OrthancWSI::DicomPyramidCache::Locker locker(seriesId);
170
171 OrthancWSI::ITiledPyramid& pyramid = locker.GetPyramid();
172 const unsigned int level = pyramid.GetLevelCount() - 1;
173
174 Orthanc::Image full(Orthanc::PixelFormat_RGB24, pyramid.GetLevelWidth(level), pyramid.GetLevelHeight(level), false);
175 Orthanc::ImageProcessing::Set(full, 255, 255, 255, 0);
176
177 const unsigned int nx = OrthancWSI::CeilingDivision(pyramid.GetLevelWidth(level), pyramid.GetTileWidth(level));
178 const unsigned int ny = OrthancWSI::CeilingDivision(pyramid.GetLevelHeight(level), pyramid.GetTileHeight(level));
179 for (unsigned int ty = 0; ty < ny; ty++)
180 {
181 const unsigned int y = ty * pyramid.GetTileHeight(level);
182 const unsigned int height = std::min(pyramid.GetTileHeight(level), full.GetHeight() - y);
183
184 for (unsigned int tx = 0; tx < nx; tx++)
185 {
186 const unsigned int x = tx * pyramid.GetTileWidth(level);
187 std::unique_ptr<Orthanc::ImageAccessor> tile(pyramid.DecodeTile(level, tx, ty));
188
189 const unsigned int width = std::min(pyramid.GetTileWidth(level), full.GetWidth() - x);
190
191 Orthanc::ImageAccessor source, target;
192 tile->GetRegion(source, 0, 0, width, height);
193 full.GetRegion(target, x, y, width, height);
194
195 Orthanc::ImageProcessing::Copy(target, source);
196 }
197 }
198
199 std::string encoded;
200 OrthancWSI::RawTile::Encode(encoded, full, Orthanc::MimeType_Jpeg);
201
202 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, encoded.c_str(),
203 encoded.size(), Orthanc::EnumerationToString(Orthanc::MimeType_Jpeg));
204 }
205 else
206 {
207 int regionX, regionY, regionWidth, regionHeight;
208
209 bool ok = false;
210 boost::regex regionPattern("([0-9]+),([0-9]+),([0-9]+),([0-9]+)");
211 boost::cmatch regionWhat;
212 if (regex_match(region.c_str(), regionWhat, regionPattern))
213 {
214 try
215 {
216 regionX = boost::lexical_cast<int>(regionWhat[1]);
217 regionY = boost::lexical_cast<int>(regionWhat[2]);
218 regionWidth = boost::lexical_cast<int>(regionWhat[3]);
219 regionHeight = boost::lexical_cast<int>(regionWhat[4]);
220 ok = (regionX >= 0 &&
221 regionY >= 0 &&
222 regionWidth > 0 &&
223 regionHeight > 0);
224 }
225 catch (boost::bad_lexical_cast&)
226 {
227 }
228 }
229
230 if (!ok)
231 {
232 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented, "IIIF - Not a (x,y,width,height) region: " + region);
233 }
234
235 int cropWidth;
236 boost::regex sizePattern("([0-9]+),");
237 boost::cmatch sizeWhat;
238 if (regex_match(size.c_str(), sizeWhat, sizePattern))
239 {
240 try
241 {
242 cropWidth = boost::lexical_cast<int>(sizeWhat[1]);
243 ok = (cropWidth > 0);
244 }
245 catch (boost::bad_lexical_cast&)
246 {
247 }
248 }
249
250 if (!ok)
251 {
252 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented, "IIIF - Not a (width,) size: " + size);
253 }
254
255 std::unique_ptr<OrthancWSI::RawTile> rawTile;
256 std::unique_ptr<Orthanc::ImageAccessor> toCrop;
257
258 {
259 OrthancWSI::DicomPyramidCache::Locker locker(seriesId);
260
261 OrthancWSI::ITiledPyramid& pyramid = locker.GetPyramid();
262
263 unsigned int level;
264 for (level = 0; level < pyramid.GetLevelCount(); level++)
265 {
266 const unsigned int physicalTileWidth = GetPhysicalTileWidth(pyramid, level);
267 const unsigned int physicalTileHeight = GetPhysicalTileHeight(pyramid, level);
268
269 if (regionX % physicalTileWidth == 0 &&
270 regionY % physicalTileHeight == 0 &&
271 regionWidth <= physicalTileWidth &&
272 regionHeight <= physicalTileHeight &&
273 regionX + regionWidth <= pyramid.GetLevelWidth(0) &&
274 regionY + regionHeight <= pyramid.GetLevelHeight(0))
275 {
276 break;
277 }
278 }
279
280 if (level == pyramid.GetLevelCount())
281 {
282 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadRequest, "IIIF - Cannot locate the level of interest");
283 }
284 else if (cropWidth > pyramid.GetTileWidth(level))
285 {
286 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadRequest, "IIIF - Request for a cropping that is too large for the tile size");
287 }
288 else
289 {
290 rawTile.reset(new OrthancWSI::RawTile(locker.GetPyramid(), level,
291 regionX / GetPhysicalTileWidth(pyramid, level),
292 regionY / GetPhysicalTileHeight(pyramid, level)));
293
294 if (cropWidth < pyramid.GetTileWidth(level))
295 {
296 toCrop.reset(rawTile->Decode());
297 rawTile.reset(NULL);
298 }
299 }
300 }
301
302 if (rawTile.get() != NULL)
303 {
304 assert(toCrop.get() == NULL);
305
306 // Level 0 Compliance of IIIF expects JPEG files
307 rawTile->Answer(output, Orthanc::MimeType_Jpeg);
308 }
309 else if (toCrop.get() != NULL)
310 {
311 assert(rawTile.get() == NULL);
312 assert(cropWidth < toCrop->GetWidth());
313
314 Orthanc::ImageAccessor cropped;
315 toCrop->GetRegion(cropped, 0, 0, cropWidth, toCrop->GetHeight());
316
317 std::string encoded;
318 OrthancWSI::RawTile::Encode(encoded, cropped, Orthanc::MimeType_Jpeg);
319
320 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, encoded.c_str(),
321 encoded.size(), Orthanc::EnumerationToString(Orthanc::MimeType_Jpeg));
322 }
323 else
324 {
325 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
326 }
327 }
328 }
329
330
331 static void ServeIIIFManifest(OrthancPluginRestOutput* output,
332 const char* url,
333 const OrthancPluginHttpRequest* request)
334 {
335 /**
336 * This is based on IIIF cookbook: "Support Deep Viewing with Basic
337 * Use of a IIIF Image Service."
338 * https://iiif.io/api/cookbook/recipe/0005-image-service/
339 **/
340
341 std::string seriesId(request->groups[0]);
342
343 LOG(INFO) << "IIIF: Presentation API call to whole-slide pyramid of series " << seriesId;
344
345 Json::Value study, series;
346 if (!OrthancPlugins::RestApiGet(series, "/series/" + seriesId, false) ||
347 !OrthancPlugins::RestApiGet(study, "/series/" + seriesId + "/study", false))
348 {
349 throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource);
350 }
351
352 unsigned int width, height;
353
354 {
355 OrthancWSI::DicomPyramidCache::Locker locker(seriesId);
356 width = locker.GetPyramid().GetLevelWidth(0);
357 height = locker.GetPyramid().GetLevelHeight(0);
358 }
359
360 const std::string base = iiifPublicUrl_ + seriesId;
361
362 Json::Value service;
363 service["id"] = base;
364 service["profile"] = "level0";
365 service["type"] = "ImageService3";
366
367 Json::Value body;
368 body["id"] = base + "/full/max/0/default.jpg";
369 body["type"] = "Image";
370 body["format"] = Orthanc::EnumerationToString(Orthanc::MimeType_Jpeg);
371 body["height"] = height;
372 body["width"] = width;
373 body["service"].append(service);
374
375 Json::Value annotation;
376 annotation["id"] = base + "/annotation/p0001-image";
377 annotation["type"] = "Annotation";
378 annotation["motivation"] = "painting";
379 annotation["body"] = body;
380 annotation["target"] = base + "/canvas/p1";
381
382 Json::Value annotationPage;
383 annotationPage["id"] = base + "/page/p1/1";
384 annotationPage["type"] = "AnnotationPage";
385 annotationPage["items"].append(annotation);
386
387 Json::Value canvas;
388 canvas["id"] = annotation["target"];
389 canvas["type"] = "Canvas";
390 canvas["width"] = width;
391 canvas["height"] = height;
392
393 Json::Value labels = Json::arrayValue;
394 labels.append(series["MainDicomTags"]["SeriesDate"].asString() + " - " +
395 series["MainDicomTags"]["SeriesDescription"].asString());
396 canvas["label"]["en"] = labels;
397
398 canvas["items"].append(annotationPage);
399
400 Json::Value manifest;
401 manifest["@context"] = "http://iiif.io/api/presentation/3/context.json";
402 manifest["id"] = base + "/manifest.json";
403 manifest["type"] = "Manifest";
404
405 labels = Json::arrayValue;
406 labels.append(study["MainDicomTags"]["StudyDate"].asString() + " - " +
407 study["MainDicomTags"]["StudyDescription"].asString());
408 manifest["label"]["en"] = labels;
409
410 manifest["items"].append(canvas);
411
412 std::string s = manifest.toStyledString();
413 OrthancPluginAnswerBuffer(OrthancPlugins::GetGlobalContext(), output, s.c_str(), s.size(), "application/json");
414 }
415
416
417 void InitializeIIIF(const std::string& iiifPublicUrl)
418 {
419 iiifPublicUrl_ = iiifPublicUrl;
420
421 OrthancPlugins::RegisterRestCallback<ServeIIIFImageInfo>("/wsi/iiif/([0-9a-f-]+)/info.json", true);
422 OrthancPlugins::RegisterRestCallback<ServeIIIFImageTile>("/wsi/iiif/([0-9a-f-]+)/([0-9a-z,:]+)/([0-9a-z,!:]+)/([0-9,!]+)/([a-z]+)\\.([a-z]+)", true);
423 OrthancPlugins::RegisterRestCallback<ServeIIIFManifest>("/wsi/iiif/([0-9a-f-]+)/manifest.json", true);
424 }