Mercurial > hg > orthanc-stone
comparison Samples/Sdl/Loader.cpp @ 802:f38c1fc08655
Merge
author | Benjamin Golinvaux <bgo@osimis.io> |
---|---|
date | Tue, 28 May 2019 14:18:46 +0200 |
parents | 98a89b116b62 d3197e0e321d |
children | d61728752790 61ba4b504e9a |
comparison
equal
deleted
inserted
replaced
801:7efcbae4717e | 802:f38c1fc08655 |
---|---|
530 | 530 |
531 | 531 |
532 | 532 |
533 | 533 |
534 | 534 |
535 // TODO - Refactor using LoaderStateMachine? | |
535 class OrthancSeriesVolumeProgressiveLoader : | 536 class OrthancSeriesVolumeProgressiveLoader : |
536 public IObserver, | 537 public IObserver, |
537 public IObservable, | 538 public IObservable, |
538 public IVolumeSlicer | 539 public IVolumeSlicer |
539 { | 540 { |
1054 T& GetLoader() const | 1055 T& GetLoader() const |
1055 { | 1056 { |
1056 return dynamic_cast<T&>(that_); | 1057 return dynamic_cast<T&>(that_); |
1057 } | 1058 } |
1058 | 1059 |
1059 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const | 1060 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
1060 { | 1061 { |
1061 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | 1062 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); |
1062 } | 1063 } |
1063 | 1064 |
1064 virtual void Handle(const GetOrthancImageCommand::SuccessMessage& message) const | 1065 virtual void Handle(const GetOrthancImageCommand::SuccessMessage& message) |
1065 { | 1066 { |
1066 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | 1067 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); |
1067 } | 1068 } |
1068 | 1069 |
1069 virtual void Handle(const GetOrthancWebViewerJpegCommand::SuccessMessage& message) const | 1070 virtual void Handle(const GetOrthancWebViewerJpegCommand::SuccessMessage& message) |
1070 { | 1071 { |
1071 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); | 1072 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); |
1072 } | 1073 } |
1073 }; | 1074 }; |
1074 | 1075 |
1124 for (PendingCommands::iterator it = pendingCommands_.begin(); | 1125 for (PendingCommands::iterator it = pendingCommands_.begin(); |
1125 it != pendingCommands_.end(); ++it) | 1126 it != pendingCommands_.end(); ++it) |
1126 { | 1127 { |
1127 delete *it; | 1128 delete *it; |
1128 } | 1129 } |
1129 } | 1130 |
1130 | 1131 pendingCommands_.clear(); |
1131 void HandleException(const OracleCommandExceptionMessage& message) | 1132 } |
1133 | |
1134 void HandleExceptionMessage(const OracleCommandExceptionMessage& message) | |
1132 { | 1135 { |
1133 LOG(ERROR) << "Error in the state machine, stopping all processing"; | 1136 LOG(ERROR) << "Error in the state machine, stopping all processing"; |
1134 Clear(); | 1137 Clear(); |
1135 } | 1138 } |
1136 | 1139 |
1137 template <typename T> | 1140 template <typename T> |
1138 void Handle(const T& message) | 1141 void HandleSuccessMessage(const T& message) |
1139 { | 1142 { |
1140 dynamic_cast<const State&>(message.GetOrigin().GetPayload()).Handle(message); | 1143 assert(activeCommands_ > 0); |
1141 activeCommands_--; | 1144 activeCommands_--; |
1142 Step(); | 1145 |
1146 try | |
1147 { | |
1148 dynamic_cast<State&>(message.GetOrigin().GetPayload()).Handle(message); | |
1149 Step(); | |
1150 } | |
1151 catch (Orthanc::OrthancException& e) | |
1152 { | |
1153 LOG(ERROR) << "Error in the state machine, stopping all processing: " << e.What(); | |
1154 Clear(); | |
1155 } | |
1143 } | 1156 } |
1144 | 1157 |
1145 typedef std::list<IOracleCommand*> PendingCommands; | 1158 typedef std::list<IOracleCommand*> PendingCommands; |
1146 | 1159 |
1147 IOracle& oracle_; | 1160 IOracle& oracle_; |
1159 simultaneousDownloads_(4), | 1172 simultaneousDownloads_(4), |
1160 activeCommands_(0) | 1173 activeCommands_(0) |
1161 { | 1174 { |
1162 oracleObservable.RegisterObserverCallback( | 1175 oracleObservable.RegisterObserverCallback( |
1163 new Callable<LoaderStateMachine, OrthancRestApiCommand::SuccessMessage> | 1176 new Callable<LoaderStateMachine, OrthancRestApiCommand::SuccessMessage> |
1164 (*this, &LoaderStateMachine::Handle<OrthancRestApiCommand::SuccessMessage>)); | 1177 (*this, &LoaderStateMachine::HandleSuccessMessage)); |
1165 | 1178 |
1166 oracleObservable.RegisterObserverCallback( | 1179 oracleObservable.RegisterObserverCallback( |
1167 new Callable<LoaderStateMachine, GetOrthancImageCommand::SuccessMessage> | 1180 new Callable<LoaderStateMachine, GetOrthancImageCommand::SuccessMessage> |
1168 (*this, &LoaderStateMachine::Handle<GetOrthancImageCommand::SuccessMessage>)); | 1181 (*this, &LoaderStateMachine::HandleSuccessMessage)); |
1169 | 1182 |
1170 oracleObservable.RegisterObserverCallback( | 1183 oracleObservable.RegisterObserverCallback( |
1171 new Callable<LoaderStateMachine, GetOrthancWebViewerJpegCommand::SuccessMessage> | 1184 new Callable<LoaderStateMachine, GetOrthancWebViewerJpegCommand::SuccessMessage> |
1172 (*this, &LoaderStateMachine::Handle<GetOrthancWebViewerJpegCommand::SuccessMessage>)); | 1185 (*this, &LoaderStateMachine::HandleSuccessMessage)); |
1173 | 1186 |
1174 oracleObservable.RegisterObserverCallback( | 1187 oracleObservable.RegisterObserverCallback( |
1175 new Callable<LoaderStateMachine, OracleCommandExceptionMessage> | 1188 new Callable<LoaderStateMachine, OracleCommandExceptionMessage> |
1176 (*this, &LoaderStateMachine::HandleException)); | 1189 (*this, &LoaderStateMachine::HandleExceptionMessage)); |
1177 } | 1190 } |
1178 | 1191 |
1179 virtual ~LoaderStateMachine() | 1192 virtual ~LoaderStateMachine() |
1180 { | 1193 { |
1181 Clear(); | 1194 Clear(); |
1226 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | 1239 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); |
1227 } | 1240 } |
1228 | 1241 |
1229 } | 1242 } |
1230 | 1243 |
1231 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const | 1244 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
1232 { | 1245 { |
1233 // Complete the DICOM tags with just-received "Grid Frame Offset Vector" | 1246 // Complete the DICOM tags with just-received "Grid Frame Offset Vector" |
1234 std::string s = Orthanc::Toolbox::StripSpaces(message.GetAnswer()); | 1247 std::string s = Orthanc::Toolbox::StripSpaces(message.GetAnswer()); |
1235 dicom_->SetValue(Orthanc::DICOM_TAG_GRID_FRAME_OFFSET_VECTOR, s, false); | 1248 dicom_->SetValue(Orthanc::DICOM_TAG_GRID_FRAME_OFFSET_VECTOR, s, false); |
1236 | 1249 |
1260 LoadGeometry(OrthancMultiframeVolumeLoader& that) : | 1273 LoadGeometry(OrthancMultiframeVolumeLoader& that) : |
1261 State(that) | 1274 State(that) |
1262 { | 1275 { |
1263 } | 1276 } |
1264 | 1277 |
1265 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const | 1278 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
1266 { | 1279 { |
1267 OrthancMultiframeVolumeLoader& loader = GetLoader<OrthancMultiframeVolumeLoader>(); | 1280 OrthancMultiframeVolumeLoader& loader = GetLoader<OrthancMultiframeVolumeLoader>(); |
1268 | 1281 |
1269 Json::Value body; | 1282 Json::Value body; |
1270 message.ParseJsonBody(body); | 1283 message.ParseJsonBody(body); |
1304 LoadTransferSyntax(OrthancMultiframeVolumeLoader& that) : | 1317 LoadTransferSyntax(OrthancMultiframeVolumeLoader& that) : |
1305 State(that) | 1318 State(that) |
1306 { | 1319 { |
1307 } | 1320 } |
1308 | 1321 |
1309 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const | 1322 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
1310 { | 1323 { |
1311 GetLoader<OrthancMultiframeVolumeLoader>().SetTransferSyntax(message.GetAnswer()); | 1324 GetLoader<OrthancMultiframeVolumeLoader>().SetTransferSyntax(message.GetAnswer()); |
1312 } | 1325 } |
1313 }; | 1326 }; |
1314 | 1327 |
1319 LoadUncompressedPixelData(OrthancMultiframeVolumeLoader& that) : | 1332 LoadUncompressedPixelData(OrthancMultiframeVolumeLoader& that) : |
1320 State(that) | 1333 State(that) |
1321 { | 1334 { |
1322 } | 1335 } |
1323 | 1336 |
1324 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) const | 1337 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) |
1325 { | 1338 { |
1326 GetLoader<OrthancMultiframeVolumeLoader>().SetUncompressedPixelData(message.GetAnswer()); | 1339 GetLoader<OrthancMultiframeVolumeLoader>().SetUncompressedPixelData(message.GetAnswer()); |
1327 } | 1340 } |
1328 }; | 1341 }; |
1329 | 1342 |
1546 } | 1559 } |
1547 }; | 1560 }; |
1548 | 1561 |
1549 | 1562 |
1550 | 1563 |
1551 class VolumeImageReslicer : public IVolumeSlicer | 1564 class DicomVolumeImageReslicer : public IVolumeSlicer |
1552 { | 1565 { |
1553 private: | 1566 private: |
1554 class Slice : public IExtractedSlice | 1567 class Slice : public IExtractedSlice |
1555 { | 1568 { |
1556 private: | 1569 private: |
1557 VolumeImageReslicer& that_; | 1570 DicomVolumeImageReslicer& that_; |
1558 CoordinateSystem3D cuttingPlane_; | 1571 CoordinateSystem3D cuttingPlane_; |
1559 | 1572 |
1560 public: | 1573 public: |
1561 Slice(VolumeImageReslicer& that, | 1574 Slice(DicomVolumeImageReslicer& that, |
1562 const CoordinateSystem3D& cuttingPlane) : | 1575 const CoordinateSystem3D& cuttingPlane) : |
1563 that_(that), | 1576 that_(that), |
1564 cuttingPlane_(cuttingPlane) | 1577 cuttingPlane_(cuttingPlane) |
1565 { | 1578 { |
1566 } | 1579 } |
1573 virtual uint64_t GetRevision() | 1586 virtual uint64_t GetRevision() |
1574 { | 1587 { |
1575 return that_.volume_->GetRevision(); | 1588 return that_.volume_->GetRevision(); |
1576 } | 1589 } |
1577 | 1590 |
1578 virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator, // possibly absent | 1591 virtual ISceneLayer* CreateSceneLayer(const ILayerStyleConfigurator* configurator, |
1579 const CoordinateSystem3D& cuttingPlane) | 1592 const CoordinateSystem3D& cuttingPlane) |
1580 { | 1593 { |
1581 VolumeReslicer& reslicer = that_.reslicer_; | 1594 VolumeReslicer& reslicer = that_.reslicer_; |
1582 | 1595 |
1583 if (configurator == NULL) | 1596 if (configurator == NULL) |
1619 | 1632 |
1620 boost::shared_ptr<DicomVolumeImage> volume_; | 1633 boost::shared_ptr<DicomVolumeImage> volume_; |
1621 VolumeReslicer reslicer_; | 1634 VolumeReslicer reslicer_; |
1622 | 1635 |
1623 public: | 1636 public: |
1624 VolumeImageReslicer(const boost::shared_ptr<DicomVolumeImage>& volume) : | 1637 DicomVolumeImageReslicer(const boost::shared_ptr<DicomVolumeImage>& volume) : |
1625 volume_(volume) | 1638 volume_(volume) |
1626 { | 1639 { |
1627 if (volume.get() == NULL) | 1640 if (volume.get() == NULL) |
1628 { | 1641 { |
1629 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | 1642 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); |
1664 }; | 1677 }; |
1665 | 1678 |
1666 | 1679 |
1667 | 1680 |
1668 class DicomStructureSetLoader : | 1681 class DicomStructureSetLoader : |
1669 public IObserver, | 1682 public LoaderStateMachine, |
1670 public IVolumeSlicer | 1683 public IVolumeSlicer |
1671 { | 1684 { |
1672 private: | 1685 private: |
1686 class AddReferencedInstance : public State | |
1687 { | |
1688 private: | |
1689 std::string instanceId_; | |
1690 | |
1691 public: | |
1692 AddReferencedInstance(DicomStructureSetLoader& that, | |
1693 const std::string& instanceId) : | |
1694 State(that), | |
1695 instanceId_(instanceId) | |
1696 { | |
1697 } | |
1698 | |
1699 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) | |
1700 { | |
1701 Json::Value tags; | |
1702 message.ParseJsonBody(tags); | |
1703 | |
1704 Orthanc::DicomMap dicom; | |
1705 dicom.FromDicomAsJson(tags); | |
1706 | |
1707 DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>(); | |
1708 loader.content_->AddReferencedSlice(dicom); | |
1709 | |
1710 loader.countProcessedInstances_ ++; | |
1711 assert(loader.countProcessedInstances_ <= loader.countReferencedInstances_); | |
1712 | |
1713 if (loader.countProcessedInstances_ == loader.countReferencedInstances_) | |
1714 { | |
1715 // All the referenced instances have been loaded, finalize the RT-STRUCT | |
1716 loader.content_->CheckReferencedSlices(); | |
1717 loader.revision_++; | |
1718 } | |
1719 } | |
1720 }; | |
1721 | |
1722 // State that converts a "SOP Instance UID" to an Orthanc identifier | |
1723 class LookupInstance : public State | |
1724 { | |
1725 private: | |
1726 std::string sopInstanceUid_; | |
1727 | |
1728 public: | |
1729 LookupInstance(DicomStructureSetLoader& that, | |
1730 const std::string& sopInstanceUid) : | |
1731 State(that), | |
1732 sopInstanceUid_(sopInstanceUid) | |
1733 { | |
1734 } | |
1735 | |
1736 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) | |
1737 { | |
1738 DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>(); | |
1739 | |
1740 Json::Value lookup; | |
1741 message.ParseJsonBody(lookup); | |
1742 | |
1743 if (lookup.type() != Json::arrayValue || | |
1744 lookup.size() != 1 || | |
1745 !lookup[0].isMember("Type") || | |
1746 !lookup[0].isMember("Path") || | |
1747 lookup[0]["Type"].type() != Json::stringValue || | |
1748 lookup[0]["ID"].type() != Json::stringValue || | |
1749 lookup[0]["Type"].asString() != "Instance") | |
1750 { | |
1751 throw Orthanc::OrthancException(Orthanc::ErrorCode_UnknownResource); | |
1752 } | |
1753 | |
1754 const std::string instanceId = lookup[0]["ID"].asString(); | |
1755 | |
1756 { | |
1757 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand); | |
1758 command->SetHttpHeader("Accept-Encoding", "gzip"); | |
1759 command->SetUri("/instances/" + instanceId + "/tags"); | |
1760 command->SetPayload(new AddReferencedInstance(loader, instanceId)); | |
1761 Schedule(command.release()); | |
1762 } | |
1763 } | |
1764 }; | |
1765 | |
1766 class LoadStructure : public State | |
1767 { | |
1768 public: | |
1769 LoadStructure(DicomStructureSetLoader& that) : | |
1770 State(that) | |
1771 { | |
1772 } | |
1773 | |
1774 virtual void Handle(const OrthancRestApiCommand::SuccessMessage& message) | |
1775 { | |
1776 DicomStructureSetLoader& loader = GetLoader<DicomStructureSetLoader>(); | |
1777 | |
1778 { | |
1779 OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer()); | |
1780 loader.content_.reset(new DicomStructureSet(dicom)); | |
1781 } | |
1782 | |
1783 std::set<std::string> instances; | |
1784 loader.content_->GetReferencedInstances(instances); | |
1785 | |
1786 loader.countReferencedInstances_ = instances.size(); | |
1787 | |
1788 for (std::set<std::string>::const_iterator | |
1789 it = instances.begin(); it != instances.end(); ++it) | |
1790 { | |
1791 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand); | |
1792 command->SetUri("/tools/lookup"); | |
1793 command->SetMethod(Orthanc::HttpMethod_Post); | |
1794 command->SetBody(*it); | |
1795 command->SetPayload(new LookupInstance(loader, *it)); | |
1796 Schedule(command.release()); | |
1797 | |
1798 printf("[%s]\n", it->c_str()); | |
1799 } | |
1800 } | |
1801 }; | |
1802 | |
1803 | |
1804 | |
1673 std::auto_ptr<DicomStructureSet> content_; | 1805 std::auto_ptr<DicomStructureSet> content_; |
1674 IOracle& oracle_; | |
1675 bool active_; | |
1676 uint64_t revision_; | 1806 uint64_t revision_; |
1677 std::string instanceId_; | 1807 std::string instanceId_; |
1678 | 1808 unsigned int countProcessedInstances_; |
1679 void Handle(const OrthancRestApiCommand::SuccessMessage& message) | 1809 unsigned int countReferencedInstances_; |
1680 { | |
1681 assert(active_); | |
1682 | |
1683 { | |
1684 OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer()); | |
1685 content_.reset(new DicomStructureSet(dicom)); | |
1686 } | |
1687 | |
1688 std::set<std::string> instances; | |
1689 content_->GetReferencedInstances(instances); | |
1690 | |
1691 for (std::set<std::string>::const_iterator | |
1692 it = instances.begin(); it != instances.end(); ++it) | |
1693 { | |
1694 printf("[%s]\n", it->c_str()); | |
1695 } | |
1696 } | |
1697 | 1810 |
1698 | 1811 |
1699 class Slice : public IExtractedSlice | 1812 class Slice : public IExtractedSlice |
1700 { | 1813 { |
1701 private: | 1814 private: |
1733 const CoordinateSystem3D& cuttingPlane) | 1846 const CoordinateSystem3D& cuttingPlane) |
1734 { | 1847 { |
1735 assert(isValid_); | 1848 assert(isValid_); |
1736 | 1849 |
1737 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer); | 1850 std::auto_ptr<PolylineSceneLayer> layer(new PolylineSceneLayer); |
1851 layer->SetThickness(2); | |
1738 | 1852 |
1739 for (size_t i = 0; i < content_.GetStructuresCount(); i++) | 1853 for (size_t i = 0; i < content_.GetStructuresCount(); i++) |
1740 { | 1854 { |
1741 std::vector< std::vector<DicomStructureSet::PolygonPoint> > polygons; | 1855 std::vector< std::vector<DicomStructureSet::PolygonPoint> > polygons; |
1742 | 1856 |
1747 for (size_t j = 0; j < polygons.size(); j++) | 1861 for (size_t j = 0; j < polygons.size(); j++) |
1748 { | 1862 { |
1749 PolylineSceneLayer::Chain chain; | 1863 PolylineSceneLayer::Chain chain; |
1750 chain.resize(polygons[j].size()); | 1864 chain.resize(polygons[j].size()); |
1751 | 1865 |
1752 for (size_t k = 0; k < polygons[i].size(); k++) | 1866 for (size_t k = 0; k < polygons[j].size(); k++) |
1753 { | 1867 { |
1754 chain[k] = ScenePoint2D(polygons[j][k].first, polygons[j][k].second); | 1868 chain[k] = ScenePoint2D(polygons[j][k].first, polygons[j][k].second); |
1755 } | 1869 } |
1756 | 1870 |
1757 layer->AddChain(chain, true /* closed */); | 1871 layer->AddChain(chain, true /* closed */); |
1758 } | 1872 } |
1759 } | 1873 } |
1760 } | 1874 } |
1761 | 1875 |
1762 printf("OK\n"); | |
1763 | |
1764 return layer.release(); | 1876 return layer.release(); |
1765 } | 1877 } |
1766 }; | 1878 }; |
1767 | 1879 |
1768 public: | 1880 public: |
1769 DicomStructureSetLoader(IOracle& oracle, | 1881 DicomStructureSetLoader(IOracle& oracle, |
1770 IObservable& oracleObservable) : | 1882 IObservable& oracleObservable) : |
1771 IObserver(oracleObservable.GetBroker()), | 1883 LoaderStateMachine(oracle, oracleObservable), |
1772 oracle_(oracle), | 1884 revision_(0), |
1773 active_(false), | 1885 countProcessedInstances_(0), |
1774 revision_(0) | 1886 countReferencedInstances_(0) |
1775 { | 1887 { |
1776 oracleObservable.RegisterObserverCallback( | |
1777 new Callable<DicomStructureSetLoader, OrthancRestApiCommand::SuccessMessage> | |
1778 (*this, &DicomStructureSetLoader::Handle)); | |
1779 } | 1888 } |
1780 | 1889 |
1781 | 1890 |
1782 void LoadInstance(const std::string& instanceId) | 1891 void LoadInstance(const std::string& instanceId) |
1783 { | 1892 { |
1784 if (active_) | 1893 Start(); |
1785 { | 1894 |
1786 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | 1895 instanceId_ = instanceId; |
1787 } | 1896 |
1788 else | 1897 { |
1789 { | 1898 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand); |
1790 active_ = true; | 1899 command->SetHttpHeader("Accept-Encoding", "gzip"); |
1791 instanceId_ = instanceId; | 1900 command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3006-0050"); |
1792 | 1901 command->SetPayload(new LoadStructure(*this)); |
1793 { | 1902 Schedule(command.release()); |
1794 std::auto_ptr<OrthancRestApiCommand> command(new OrthancRestApiCommand); | |
1795 command->SetHttpHeader("Accept-Encoding", "gzip"); | |
1796 command->SetUri("/instances/" + instanceId + "/tags?ignore-length=3006-0050"); | |
1797 oracle_.Schedule(*this, command.release()); | |
1798 } | |
1799 } | 1903 } |
1800 } | 1904 } |
1801 | 1905 |
1802 virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) | 1906 virtual IExtractedSlice* ExtractSlice(const CoordinateSystem3D& cuttingPlane) |
1803 { | 1907 { |
2236 | 2340 |
2237 #if 1 | 2341 #if 1 |
2238 toto->SetVolume1(0, ctLoader, new OrthancStone::GrayscaleStyleConfigurator); | 2342 toto->SetVolume1(0, ctLoader, new OrthancStone::GrayscaleStyleConfigurator); |
2239 #else | 2343 #else |
2240 { | 2344 { |
2241 boost::shared_ptr<OrthancStone::IVolumeSlicer> reslicer(new OrthancStone::VolumeImageReslicer(ct)); | 2345 boost::shared_ptr<OrthancStone::IVolumeSlicer> reslicer(new OrthancStone::DicomVolumeImageReslicer(ct)); |
2242 toto->SetVolume1(0, reslicer, new OrthancStone::GrayscaleStyleConfigurator); | 2346 toto->SetVolume1(0, reslicer, new OrthancStone::GrayscaleStyleConfigurator); |
2243 } | 2347 } |
2244 #endif | 2348 #endif |
2245 | 2349 |
2246 | 2350 |
2338 ctLoader->LoadSeries("a04ecf01-79b2fc33-58239f7e-ad9db983-28e81afa"); // CT | 2442 ctLoader->LoadSeries("a04ecf01-79b2fc33-58239f7e-ad9db983-28e81afa"); // CT |
2339 doseLoader->LoadInstance("830a69ff-8e4b5ee3-b7f966c8-bccc20fb-d322dceb"); // RT-DOSE | 2443 doseLoader->LoadInstance("830a69ff-8e4b5ee3-b7f966c8-bccc20fb-d322dceb"); // RT-DOSE |
2340 //rtstructLoader->LoadInstance("54460695-ba3885ee-ddf61ac0-f028e31d-a6e474d9"); // RT-STRUCT | 2444 //rtstructLoader->LoadInstance("54460695-ba3885ee-ddf61ac0-f028e31d-a6e474d9"); // RT-STRUCT |
2341 #else | 2445 #else |
2342 //ctLoader->LoadSeries("cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618"); // CT | 2446 //ctLoader->LoadSeries("cb3ea4d1-d08f3856-ad7b6314-74d88d77-60b05618"); // CT |
2343 doseLoader->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6"); // RT-DOSE | 2447 //doseLoader->LoadInstance("41029085-71718346-811efac4-420e2c15-d39f99b6"); // RT-DOSE |
2344 //rtstructLoader->LoadInstance("83d9c0c3-913a7fee-610097d7-cbf0522d-fd75bee6"); // RT-STRUCT | 2448 //rtstructLoader->LoadInstance("83d9c0c3-913a7fee-610097d7-cbf0522d-fd75bee6"); // RT-STRUCT |
2449 | |
2450 // 2017-05-16 | |
2451 ctLoader->LoadSeries("a04ecf01-79b2fc33-58239f7e-ad9db983-28e81afa"); // CT | |
2452 doseLoader->LoadInstance("eac822ef-a395f94e-e8121fe0-8411fef8-1f7bffad"); // RT-DOSE | |
2453 rtstructLoader->LoadInstance("54460695-ba3885ee-ddf61ac0-f028e31d-a6e474d9"); // RT-STRUCT | |
2345 #endif | 2454 #endif |
2346 // 2015-01-28-Multiframe | 2455 // 2015-01-28-Multiframe |
2347 //doseLoader->LoadInstance("88f71e2a-5fad1c61-96ed14d6-5b3d3cf7-a5825279"); // Multiframe CT | 2456 //doseLoader->LoadInstance("88f71e2a-5fad1c61-96ed14d6-5b3d3cf7-a5825279"); // Multiframe CT |
2348 | 2457 |
2349 // Delphine | 2458 // Delphine |