Mercurial > hg > orthanc-stone
annotate Framework/Toolbox/DicomStructureSet.cpp @ 113:2eca030792aa wasm
using the Orthanc Framework
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 20 Sep 2017 15:32:32 +0200 |
| parents | 53025eecbc95 |
| children | a4d0b6c82b29 |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 2 * Stone of Orthanc | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
|
40
7207a407bcd8
shared copyright with osimis
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
35
diff
changeset
|
5 * Copyright (C) 2017 Osimis, Belgium |
| 0 | 6 * |
| 7 * This program is free software: you can redistribute it and/or | |
| 47 | 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. | |
| 0 | 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 | |
| 47 | 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 | |
| 0 | 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 19 **/ | |
| 20 | |
| 21 | |
| 22 #include "DicomStructureSet.h" | |
| 23 | |
| 35 | 24 #include "../Toolbox/MessagingToolbox.h" |
| 0 | 25 |
|
113
2eca030792aa
using the Orthanc Framework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
110
diff
changeset
|
26 #include <Core/Logging.h> |
|
2eca030792aa
using the Orthanc Framework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
110
diff
changeset
|
27 #include <Core/OrthancException.h> |
|
2eca030792aa
using the Orthanc Framework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
110
diff
changeset
|
28 #include <Plugins/Samples/Common/FullOrthancDataset.h> |
|
2eca030792aa
using the Orthanc Framework
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
110
diff
changeset
|
29 |
| 0 | 30 #include <stdio.h> |
| 31 #include <boost/lexical_cast.hpp> | |
| 32 | |
| 33 namespace OrthancStone | |
| 34 { | |
| 32 | 35 static const OrthancPlugins::DicomTag DICOM_TAG_CONTOUR_GEOMETRIC_TYPE(0x3006, 0x0042); |
| 36 static const OrthancPlugins::DicomTag DICOM_TAG_CONTOUR_IMAGE_SEQUENCE(0x3006, 0x0016); | |
| 37 static const OrthancPlugins::DicomTag DICOM_TAG_CONTOUR_SEQUENCE(0x3006, 0x0040); | |
| 38 static const OrthancPlugins::DicomTag DICOM_TAG_NUMBER_OF_CONTOUR_POINTS(0x3006, 0x0046); | |
| 39 static const OrthancPlugins::DicomTag DICOM_TAG_REFERENCED_SOP_INSTANCE_UID(0x0008, 0x1155); | |
| 40 static const OrthancPlugins::DicomTag DICOM_TAG_ROI_CONTOUR_SEQUENCE(0x3006, 0x0039); | |
| 41 static const OrthancPlugins::DicomTag DICOM_TAG_ROI_DISPLAY_COLOR(0x3006, 0x002a); | |
| 42 static const OrthancPlugins::DicomTag DICOM_TAG_ROI_NAME(0x3006, 0x0026); | |
| 43 static const OrthancPlugins::DicomTag DICOM_TAG_RT_ROI_INTERPRETED_TYPE(0x3006, 0x00a4); | |
| 44 static const OrthancPlugins::DicomTag DICOM_TAG_RT_ROI_OBSERVATIONS_SEQUENCE(0x3006, 0x0080); | |
| 45 static const OrthancPlugins::DicomTag DICOM_TAG_STRUCTURE_SET_ROI_SEQUENCE(0x3006, 0x0020); | |
| 0 | 46 |
| 47 | |
| 48 static uint8_t ConvertColor(double v) | |
| 49 { | |
| 50 if (v < 0) | |
| 51 { | |
| 52 return 0; | |
| 53 } | |
| 54 else if (v >= 255) | |
| 55 { | |
| 56 return 255; | |
| 57 } | |
| 58 else | |
| 59 { | |
| 60 return static_cast<uint8_t>(v); | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 | |
|
110
53025eecbc95
renamed SliceGeometry as CoordinateSystem3D
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
65 CoordinateSystem3D DicomStructureSet::ExtractSliceGeometry(double& sliceThickness, |
|
31
9aace933cb64
sharing code with the Orthanc core
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
66 OrthancPlugins::IOrthancConnection& orthanc, |
| 32 | 67 const OrthancPlugins::IDicomDataset& tags, |
| 68 size_t contourIndex, | |
| 69 size_t sliceIndex) | |
| 0 | 70 { |
| 32 | 71 using namespace OrthancPlugins; |
| 0 | 72 |
| 32 | 73 size_t size; |
| 74 if (!tags.GetSequenceSize(size, DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, contourIndex, | |
| 75 DICOM_TAG_CONTOUR_SEQUENCE, sliceIndex, | |
| 76 DICOM_TAG_CONTOUR_IMAGE_SEQUENCE)) || | |
| 77 size != 1) | |
| 0 | 78 { |
| 79 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 80 } | |
| 81 | |
| 32 | 82 DicomDatasetReader reader(tags); |
| 83 std::string parentUid = reader.GetMandatoryStringValue(DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, contourIndex, | |
| 84 DICOM_TAG_CONTOUR_SEQUENCE, sliceIndex, | |
| 85 DICOM_TAG_CONTOUR_IMAGE_SEQUENCE, 0, | |
| 86 DICOM_TAG_REFERENCED_SOP_INSTANCE_UID)); | |
| 0 | 87 |
| 34 | 88 Json::Value parentLookup; |
| 89 MessagingToolbox::RestApiPost(parentLookup, orthanc, "/tools/lookup", parentUid); | |
| 0 | 90 |
| 34 | 91 if (parentLookup.type() != Json::arrayValue || |
| 92 parentLookup.size() != 1 || | |
| 93 !parentLookup[0].isMember("Type") || | |
| 94 !parentLookup[0].isMember("Path") || | |
| 95 parentLookup[0]["Type"].type() != Json::stringValue || | |
| 96 parentLookup[0]["ID"].type() != Json::stringValue || | |
| 97 parentLookup[0]["Type"].asString() != "Instance") | |
| 0 | 98 { |
| 99 throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource); | |
| 100 } | |
| 101 | |
| 102 Json::Value parentInstance; | |
| 34 | 103 MessagingToolbox::RestApiGet(parentInstance, orthanc, "/instances/" + parentLookup[0]["ID"].asString()); |
| 0 | 104 |
| 105 if (parentInstance.type() != Json::objectValue || | |
| 106 !parentInstance.isMember("ParentSeries") || | |
| 107 parentInstance["ParentSeries"].type() != Json::stringValue) | |
| 108 { | |
| 109 throw Orthanc::OrthancException(Orthanc::ErrorCode_NetworkProtocol); | |
| 110 } | |
| 111 | |
| 112 std::string parentSeriesId = parentInstance["ParentSeries"].asString(); | |
| 113 bool isFirst = parentSeriesId_.empty(); | |
| 114 | |
| 115 if (isFirst) | |
| 116 { | |
| 117 parentSeriesId_ = parentSeriesId; | |
| 118 } | |
| 119 else if (parentSeriesId_ != parentSeriesId) | |
| 120 { | |
| 121 LOG(ERROR) << "This RT-STRUCT refers to several different series"; | |
| 122 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 123 } | |
| 124 | |
| 34 | 125 FullOrthancDataset parentTags(orthanc, "/instances/" + parentLookup[0]["ID"].asString() + "/tags"); |
|
110
53025eecbc95
renamed SliceGeometry as CoordinateSystem3D
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
126 CoordinateSystem3D slice(parentTags); |
| 0 | 127 |
| 32 | 128 Vector v; |
| 129 if (GeometryToolbox::ParseVector(v, parentTags, DICOM_TAG_SLICE_THICKNESS) && | |
| 130 v.size() > 0) | |
| 0 | 131 { |
| 32 | 132 sliceThickness = v[0]; |
| 133 } | |
| 134 else | |
| 135 { | |
| 136 sliceThickness = 1; // 1 mm by default | |
| 0 | 137 } |
| 138 | |
| 139 if (isFirst) | |
| 140 { | |
| 141 normal_ = slice.GetNormal(); | |
| 142 } | |
| 143 else if (!GeometryToolbox::IsParallel(normal_, slice.GetNormal())) | |
| 144 { | |
| 145 LOG(ERROR) << "Incompatible orientation of slices in this RT-STRUCT"; | |
| 146 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 147 } | |
| 148 | |
| 149 return slice; | |
| 150 } | |
| 151 | |
| 152 | |
| 153 const DicomStructureSet::Structure& DicomStructureSet::GetStructure(size_t index) const | |
| 154 { | |
| 155 if (index >= structures_.size()) | |
| 156 { | |
| 157 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | |
| 158 } | |
| 159 | |
| 160 return structures_[index]; | |
| 161 } | |
| 162 | |
| 163 | |
| 164 bool DicomStructureSet::IsPolygonOnSlice(const Polygon& polygon, | |
|
110
53025eecbc95
renamed SliceGeometry as CoordinateSystem3D
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
165 const CoordinateSystem3D& geometry) const |
| 0 | 166 { |
| 167 double d = boost::numeric::ublas::inner_prod(geometry.GetOrigin(), normal_); | |
| 168 | |
| 169 return (GeometryToolbox::IsNear(d, polygon.projectionAlongNormal_, polygon.sliceThickness_ / 2.0) && | |
| 170 !polygon.points_.empty()); | |
| 171 } | |
| 172 | |
| 173 | |
|
31
9aace933cb64
sharing code with the Orthanc core
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
16
diff
changeset
|
174 DicomStructureSet::DicomStructureSet(OrthancPlugins::IOrthancConnection& orthanc, |
| 0 | 175 const std::string& instanceId) |
| 176 { | |
| 32 | 177 using namespace OrthancPlugins; |
| 0 | 178 |
| 32 | 179 FullOrthancDataset tags(orthanc, "/instances/" + instanceId + "/tags"); |
| 180 DicomDatasetReader reader(tags); | |
| 181 | |
| 182 size_t count, tmp; | |
| 183 if (!tags.GetSequenceSize(count, DICOM_TAG_RT_ROI_OBSERVATIONS_SEQUENCE) || | |
| 184 !tags.GetSequenceSize(tmp, DICOM_TAG_ROI_CONTOUR_SEQUENCE) || | |
| 185 tmp != count || | |
| 186 !tags.GetSequenceSize(tmp, DICOM_TAG_STRUCTURE_SET_ROI_SEQUENCE) || | |
| 187 tmp != count) | |
| 0 | 188 { |
| 189 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 190 } | |
| 191 | |
| 32 | 192 structures_.resize(count); |
| 193 for (size_t i = 0; i < count; i++) | |
| 194 { | |
| 195 structures_[i].interpretation_ = reader.GetStringValue(DicomPath(DICOM_TAG_RT_ROI_OBSERVATIONS_SEQUENCE, i, | |
| 196 DICOM_TAG_RT_ROI_INTERPRETED_TYPE), | |
| 197 "No interpretation"); | |
| 0 | 198 |
| 32 | 199 structures_[i].name_ = reader.GetStringValue(DicomPath(DICOM_TAG_STRUCTURE_SET_ROI_SEQUENCE, i, |
| 200 DICOM_TAG_ROI_NAME), | |
| 201 "No interpretation"); | |
| 0 | 202 |
| 203 Vector color; | |
| 32 | 204 if (GeometryToolbox::ParseVector(color, tags, DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, i, |
| 205 DICOM_TAG_ROI_DISPLAY_COLOR)) && | |
| 206 color.size() == 3) | |
| 0 | 207 { |
| 32 | 208 structures_[i].red_ = ConvertColor(color[0]); |
| 209 structures_[i].green_ = ConvertColor(color[1]); | |
| 210 structures_[i].blue_ = ConvertColor(color[2]); | |
| 211 } | |
| 212 else | |
| 213 { | |
| 214 structures_[i].red_ = 255; | |
| 215 structures_[i].green_ = 0; | |
| 216 structures_[i].blue_ = 0; | |
| 0 | 217 } |
| 218 | |
| 32 | 219 size_t countSlices; |
| 220 if (!tags.GetSequenceSize(countSlices, DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, i, | |
| 221 DICOM_TAG_CONTOUR_SEQUENCE))) | |
| 222 { | |
| 223 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 224 } | |
| 0 | 225 |
| 226 LOG(WARNING) << "New RT structure: \"" << structures_[i].name_ | |
| 227 << "\" with interpretation \"" << structures_[i].interpretation_ | |
| 32 | 228 << "\" containing " << countSlices << " slices (color: " |
| 0 | 229 << static_cast<int>(structures_[i].red_) << "," |
| 230 << static_cast<int>(structures_[i].green_) << "," | |
| 231 << static_cast<int>(structures_[i].blue_) << ")"; | |
| 232 | |
| 32 | 233 for (size_t j = 0; j < countSlices; j++) |
| 0 | 234 { |
| 32 | 235 unsigned int countPoints; |
| 0 | 236 |
| 32 | 237 if (!reader.GetUnsignedIntegerValue(countPoints, DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, i, |
| 238 DICOM_TAG_CONTOUR_SEQUENCE, j, | |
| 239 DICOM_TAG_NUMBER_OF_CONTOUR_POINTS))) | |
| 240 { | |
| 241 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 242 } | |
| 243 | |
| 244 LOG(INFO) << "Parsing slice containing " << countPoints << " vertices"; | |
| 0 | 245 |
| 32 | 246 std::string type = reader.GetMandatoryStringValue(DicomPath(DICOM_TAG_ROI_CONTOUR_SEQUENCE, i, |
| 247 DICOM_TAG_CONTOUR_SEQUENCE, j, | |
| 248 DICOM_TAG_CONTOUR_GEOMETRIC_TYPE)); | |
| 249 if (type != "CLOSED_PLANAR") | |
| 0 | 250 { |
| 32 | 251 LOG(ERROR) << "Cannot handle contour with geometry type: " << type; |
| 0 | 252 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); |
| 253 } | |
| 254 | |
| 32 | 255 // The "CountourData" tag (3006,0050) is too large to be |
| 256 // returned by the "/instances/{id}/tags" URI: Access it using | |
| 257 // the raw "/instances/{id}/content/{...}" endpoint | |
| 0 | 258 std::string slicesData; |
| 259 orthanc.RestApiGet(slicesData, "/instances/" + instanceId + "/content/3006-0039/" + | |
| 260 boost::lexical_cast<std::string>(i) + "/3006-0040/" + | |
| 261 boost::lexical_cast<std::string>(j) + "/3006-0050"); | |
| 262 | |
| 263 Vector points; | |
| 264 if (!GeometryToolbox::ParseVector(points, slicesData) || | |
| 32 | 265 points.size() != 3 * countPoints) |
| 0 | 266 { |
| 267 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 268 } | |
| 269 | |
| 270 Polygon polygon; | |
|
110
53025eecbc95
renamed SliceGeometry as CoordinateSystem3D
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
271 CoordinateSystem3D geometry = ExtractSliceGeometry(polygon.sliceThickness_, orthanc, tags, i, j); |
| 0 | 272 polygon.projectionAlongNormal_ = geometry.ProjectAlongNormal(geometry.GetOrigin()); |
| 273 | |
| 32 | 274 for (size_t k = 0; k < countPoints; k++) |
| 0 | 275 { |
| 276 Vector v(3); | |
| 277 v[0] = points[3 * k]; | |
| 278 v[1] = points[3 * k + 1]; | |
| 279 v[2] = points[3 * k + 2]; | |
| 280 | |
| 281 if (!GeometryToolbox::IsNear(geometry.ProjectAlongNormal(v), | |
| 282 polygon.projectionAlongNormal_, | |
| 283 polygon.sliceThickness_ / 2.0 /* in mm */)) | |
| 284 { | |
| 285 LOG(ERROR) << "This RT-STRUCT contains a point that is off the slice of its instance"; | |
| 286 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 287 } | |
| 288 | |
| 289 polygon.points_.push_back(v); | |
| 290 } | |
| 291 | |
| 292 structures_[i].polygons_.push_back(polygon); | |
| 293 } | |
| 294 } | |
| 295 | |
| 296 if (parentSeriesId_.empty() || | |
| 297 normal_.size() != 3) | |
| 298 { | |
| 299 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadFileFormat); | |
| 300 } | |
| 301 } | |
| 302 | |
| 303 | |
| 304 Vector DicomStructureSet::GetStructureCenter(size_t index) const | |
| 305 { | |
| 306 const Structure& structure = GetStructure(index); | |
| 307 | |
| 308 Vector center; | |
| 309 GeometryToolbox::AssignVector(center, 0, 0, 0); | |
| 310 if (structure.polygons_.empty()) | |
| 311 { | |
| 312 return center; | |
| 313 } | |
| 314 | |
| 315 double n = static_cast<double>(structure.polygons_.size()); | |
| 316 | |
| 317 for (Polygons::const_iterator polygon = structure.polygons_.begin(); | |
| 318 polygon != structure.polygons_.end(); ++polygon) | |
| 319 { | |
| 320 if (!polygon->points_.empty()) | |
| 321 { | |
| 322 center += polygon->points_.front() / n; | |
| 323 } | |
| 324 } | |
| 325 | |
| 326 return center; | |
| 327 } | |
| 328 | |
| 329 | |
| 330 const std::string& DicomStructureSet::GetStructureName(size_t index) const | |
| 331 { | |
| 332 return GetStructure(index).name_; | |
| 333 } | |
| 334 | |
| 335 | |
| 336 const std::string& DicomStructureSet::GetStructureInterpretation(size_t index) const | |
| 337 { | |
| 338 return GetStructure(index).interpretation_; | |
| 339 } | |
| 340 | |
| 341 | |
| 342 void DicomStructureSet::GetStructureColor(uint8_t& red, | |
| 343 uint8_t& green, | |
| 344 uint8_t& blue, | |
| 345 size_t index) const | |
| 346 { | |
| 347 const Structure& s = GetStructure(index); | |
| 348 red = s.red_; | |
| 349 green = s.green_; | |
| 350 blue = s.blue_; | |
| 351 } | |
| 352 | |
| 353 | |
| 354 void DicomStructureSet::Render(CairoContext& context, | |
|
110
53025eecbc95
renamed SliceGeometry as CoordinateSystem3D
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
47
diff
changeset
|
355 const CoordinateSystem3D& slice) const |
| 0 | 356 { |
| 357 cairo_t* cr = context.GetObject(); | |
| 358 | |
| 359 for (Structures::const_iterator structure = structures_.begin(); | |
| 360 structure != structures_.end(); ++structure) | |
| 361 { | |
| 362 for (Polygons::const_iterator polygon = structure->polygons_.begin(); | |
| 363 polygon != structure->polygons_.end(); ++polygon) | |
| 364 { | |
| 365 if (IsPolygonOnSlice(*polygon, slice)) | |
| 366 { | |
| 367 context.SetSourceColor(structure->red_, structure->green_, structure->blue_); | |
| 368 | |
| 369 Points::const_iterator p = polygon->points_.begin(); | |
| 370 | |
| 371 double x, y; | |
| 372 slice.ProjectPoint(x, y, *p); | |
| 373 cairo_move_to(cr, x, y); | |
| 374 ++p; | |
| 375 | |
| 376 while (p != polygon->points_.end()) | |
| 377 { | |
| 378 slice.ProjectPoint(x, y, *p); | |
| 379 cairo_line_to(cr, x, y); | |
| 380 ++p; | |
| 381 } | |
| 382 | |
| 383 slice.ProjectPoint(x, y, *polygon->points_.begin()); | |
| 384 cairo_line_to(cr, x, y); | |
| 385 } | |
| 386 } | |
| 387 } | |
| 388 | |
| 389 cairo_stroke(cr); | |
| 390 } | |
| 391 } |