# HG changeset patch # User Sebastien Jodogne # Date 1527518814 -7200 # Node ID ccc470091ea6bda06b9fcd85f132994dd3cf8f7d # Parent 3ce8863398ab0e586367d47392ff84aea20f6680 reorganization diff -r 3ce8863398ab -r ccc470091ea6 CMakeLists.txt --- a/CMakeLists.txt Mon May 28 16:39:00 2018 +0200 +++ b/CMakeLists.txt Mon May 28 16:46:54 2018 +0200 @@ -93,6 +93,7 @@ OrthancServer/ServerJobs/Operations/SystemCallOperation.cpp OrthancServer/ServerJobs/OrthancJobUnserializer.cpp OrthancServer/ServerJobs/OrthancPeerStoreJob.cpp + OrthancServer/ServerJobs/ResourceModificationJob.cpp OrthancServer/ServerToolbox.cpp OrthancServer/SliceOrdering.cpp ) diff -r 3ce8863398ab -r ccc470091ea6 OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp --- a/OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp Mon May 28 16:39:00 2018 +0200 +++ b/OrthancServer/OrthancRestApi/OrthancRestAnonymizeModify.cpp Mon May 28 16:46:54 2018 +0200 @@ -34,10 +34,10 @@ #include "../PrecompiledHeadersServer.h" #include "OrthancRestApi.h" +#include "../../Core/DicomParsing/FromDcmtkBridge.h" #include "../../Core/Logging.h" -#include "../../Core/DicomParsing/FromDcmtkBridge.h" #include "../ServerContext.h" -#include "../OrthancInitialization.h" +#include "../ServerJobs/ResourceModificationJob.h" #include #include @@ -139,287 +139,6 @@ - class ResourceModificationJob : public SetOfInstancesJob - { - public: - class Output : public boost::noncopyable - { - private: - boost::mutex mutex_; - ResourceType level_; - bool isFirst_; - std::string id_; - std::string patientId_; - - public: - Output(ResourceType level) : - level_(level), - isFirst_(true) - { - if (level_ != ResourceType_Patient && - level_ != ResourceType_Study && - level_ != ResourceType_Series) - { - throw OrthancException(ErrorCode_ParameterOutOfRange); - } - } - - ResourceType GetLevel() const - { - return level_; - } - - void Update(DicomInstanceHasher& hasher) - { - boost::mutex::scoped_lock lock(mutex_); - - if (isFirst_) - { - switch (level_) - { - case ResourceType_Series: - id_ = hasher.HashSeries(); - break; - - case ResourceType_Study: - id_ = hasher.HashStudy(); - break; - - case ResourceType_Patient: - id_ = hasher.HashPatient(); - break; - - default: - throw OrthancException(ErrorCode_InternalError); - } - - patientId_ = hasher.HashPatient(); - isFirst_ = false; - } - } - - bool Format(Json::Value& target) - { - boost::mutex::scoped_lock lock(mutex_); - - if (isFirst_) - { - return false; - } - else - { - target = Json::objectValue; - target["Type"] = EnumerationToString(level_); - target["ID"] = id_; - target["Path"] = GetBasePath(level_, id_); - target["PatientID"] = patientId_; - return true; - } - } - - bool GetIdentifier(std::string& id) - { - boost::mutex::scoped_lock lock(mutex_); - - if (isFirst_) - { - return false; - } - else - { - id = id_; - return true; - } - } - }; - - private: - ServerContext& context_; - std::auto_ptr modification_; - boost::shared_ptr output_; - bool isAnonymization_; - MetadataType metadataType_; - std::string description_; - DicomInstanceOrigin origin_; - - protected: - bool HandleInstance(const std::string& instance) - { - if (modification_.get() == NULL) - { - LOG(ERROR) << "No modification was provided for this job"; - throw OrthancException(ErrorCode_BadSequenceOfCalls); - } - - - LOG(INFO) << "Modifying instance in a job: " << instance; - - std::auto_ptr locker; - - try - { - locker.reset(new ServerContext::DicomCacheLocker(context_, instance)); - } - catch (OrthancException&) - { - LOG(WARNING) << "An instance was removed after the job was issued: " << instance; - return false; - } - - - ParsedDicomFile& original = locker->GetDicom(); - DicomInstanceHasher originalHasher = original.GetHasher(); - - - /** - * Compute the resulting DICOM instance. - **/ - - std::auto_ptr modified(original.Clone(true)); - modification_->Apply(*modified); - - DicomInstanceToStore toStore; - toStore.SetOrigin(origin_); - toStore.SetParsedDicomFile(*modified); - - - /** - * Prepare the metadata information to associate with the - * resulting DICOM instance (AnonymizedFrom/ModifiedFrom). - **/ - - DicomInstanceHasher modifiedHasher = modified->GetHasher(); - - MetadataType metadataType = (isAnonymization_ ? - MetadataType_AnonymizedFrom : - MetadataType_ModifiedFrom); - - if (originalHasher.HashSeries() != modifiedHasher.HashSeries()) - { - toStore.AddMetadata(ResourceType_Series, metadataType, originalHasher.HashSeries()); - } - - if (originalHasher.HashStudy() != modifiedHasher.HashStudy()) - { - toStore.AddMetadata(ResourceType_Study, metadataType, originalHasher.HashStudy()); - } - - if (originalHasher.HashPatient() != modifiedHasher.HashPatient()) - { - toStore.AddMetadata(ResourceType_Patient, metadataType, originalHasher.HashPatient()); - } - - assert(instance == originalHasher.HashInstance()); - toStore.AddMetadata(ResourceType_Instance, metadataType, instance); - - - /** - * Store the resulting DICOM instance into the Orthanc store. - **/ - - std::string modifiedInstance; - if (context_.Store(modifiedInstance, toStore) != StoreStatus_Success) - { - LOG(ERROR) << "Error while storing a modified instance " << instance; - throw OrthancException(ErrorCode_CannotStoreInstance); - } - - // Sanity checks in debug mode - assert(modifiedInstance == modifiedHasher.HashInstance()); - - - if (output_.get() != NULL) - { - output_->Update(modifiedHasher); - } - - return true; - } - - public: - ResourceModificationJob(ServerContext& context) : - context_(context), - isAnonymization_(false) - { - } - - void SetModification(DicomModification* modification, // Takes ownership - bool isAnonymization) - { - if (modification == NULL) - { - throw OrthancException(ErrorCode_NullPointer); - } - else if (IsStarted()) - { - throw OrthancException(ErrorCode_BadSequenceOfCalls); - } - else - { - modification_.reset(modification); - isAnonymization_ = isAnonymization; - } - } - - void SetOutput(boost::shared_ptr& output) - { - if (IsStarted()) - { - throw OrthancException(ErrorCode_BadSequenceOfCalls); - } - else - { - output_ = output; - } - } - - void SetOrigin(const DicomInstanceOrigin& origin) - { - if (IsStarted()) - { - throw OrthancException(ErrorCode_BadSequenceOfCalls); - } - else - { - origin_ = origin; - } - } - - void SetOrigin(const RestApiCall& call) - { - DicomInstanceOrigin tmp; - tmp.SetRestOrigin(call); - SetOrigin(tmp); - } - - virtual void ReleaseResources() - { - } - - virtual void GetJobType(std::string& target) - { - target = "ResourceModification"; - } - - virtual void GetPublicContent(Json::Value& value) - { - SetOfInstancesJob::GetPublicContent(value); - - value["IsAnonymization"] = isAnonymization_; - } - - virtual void GetInternalContent(Json::Value& value) - { - SetOfInstancesJob::GetInternalContent(value); - - Json::Value tmp; - modification_->Serialize(tmp); - value["Modification"] = tmp; - } - }; - - - static void SubmitJob(std::auto_ptr& modification, bool isAnonymization, ResourceType level, diff -r 3ce8863398ab -r ccc470091ea6 OrthancServer/ServerJobs/ResourceModificationJob.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancServer/ServerJobs/ResourceModificationJob.cpp Mon May 28 16:46:54 2018 +0200 @@ -0,0 +1,284 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#include "../PrecompiledHeadersServer.h" +#include "ResourceModificationJob.h" + +#include "../../Core/Logging.h" + +namespace Orthanc +{ + ResourceModificationJob::Output::Output(ResourceType level) : + level_(level), + isFirst_(true) + { + if (level_ != ResourceType_Patient && + level_ != ResourceType_Study && + level_ != ResourceType_Series) + { + throw OrthancException(ErrorCode_ParameterOutOfRange); + } + } + + + void ResourceModificationJob::Output::Update(DicomInstanceHasher& hasher) + { + boost::mutex::scoped_lock lock(mutex_); + + if (isFirst_) + { + switch (level_) + { + case ResourceType_Series: + id_ = hasher.HashSeries(); + break; + + case ResourceType_Study: + id_ = hasher.HashStudy(); + break; + + case ResourceType_Patient: + id_ = hasher.HashPatient(); + break; + + default: + throw OrthancException(ErrorCode_InternalError); + } + + patientId_ = hasher.HashPatient(); + isFirst_ = false; + } + } + + + bool ResourceModificationJob::Output::Format(Json::Value& target) + { + boost::mutex::scoped_lock lock(mutex_); + + if (isFirst_) + { + return false; + } + else + { + target = Json::objectValue; + target["Type"] = EnumerationToString(level_); + target["ID"] = id_; + target["Path"] = GetBasePath(level_, id_); + target["PatientID"] = patientId_; + return true; + } + } + + + bool ResourceModificationJob::Output::GetIdentifier(std::string& id) + { + boost::mutex::scoped_lock lock(mutex_); + + if (isFirst_) + { + return false; + } + else + { + id = id_; + return true; + } + } + + + bool ResourceModificationJob::HandleInstance(const std::string& instance) + { + if (modification_.get() == NULL) + { + LOG(ERROR) << "No modification was provided for this job"; + throw OrthancException(ErrorCode_BadSequenceOfCalls); + } + + + LOG(INFO) << "Modifying instance in a job: " << instance; + + std::auto_ptr locker; + + try + { + locker.reset(new ServerContext::DicomCacheLocker(context_, instance)); + } + catch (OrthancException&) + { + LOG(WARNING) << "An instance was removed after the job was issued: " << instance; + return false; + } + + + ParsedDicomFile& original = locker->GetDicom(); + DicomInstanceHasher originalHasher = original.GetHasher(); + + + /** + * Compute the resulting DICOM instance. + **/ + + std::auto_ptr modified(original.Clone(true)); + modification_->Apply(*modified); + + DicomInstanceToStore toStore; + toStore.SetOrigin(origin_); + toStore.SetParsedDicomFile(*modified); + + + /** + * Prepare the metadata information to associate with the + * resulting DICOM instance (AnonymizedFrom/ModifiedFrom). + **/ + + DicomInstanceHasher modifiedHasher = modified->GetHasher(); + + MetadataType metadataType = (isAnonymization_ ? + MetadataType_AnonymizedFrom : + MetadataType_ModifiedFrom); + + if (originalHasher.HashSeries() != modifiedHasher.HashSeries()) + { + toStore.AddMetadata(ResourceType_Series, metadataType, originalHasher.HashSeries()); + } + + if (originalHasher.HashStudy() != modifiedHasher.HashStudy()) + { + toStore.AddMetadata(ResourceType_Study, metadataType, originalHasher.HashStudy()); + } + + if (originalHasher.HashPatient() != modifiedHasher.HashPatient()) + { + toStore.AddMetadata(ResourceType_Patient, metadataType, originalHasher.HashPatient()); + } + + assert(instance == originalHasher.HashInstance()); + toStore.AddMetadata(ResourceType_Instance, metadataType, instance); + + + /** + * Store the resulting DICOM instance into the Orthanc store. + **/ + + std::string modifiedInstance; + if (context_.Store(modifiedInstance, toStore) != StoreStatus_Success) + { + LOG(ERROR) << "Error while storing a modified instance " << instance; + throw OrthancException(ErrorCode_CannotStoreInstance); + } + + // Sanity checks in debug mode + assert(modifiedInstance == modifiedHasher.HashInstance()); + + + if (output_.get() != NULL) + { + output_->Update(modifiedHasher); + } + + return true; + } + + + + void ResourceModificationJob::SetModification(DicomModification* modification, + bool isAnonymization) + { + if (modification == NULL) + { + throw OrthancException(ErrorCode_NullPointer); + } + else if (IsStarted()) + { + throw OrthancException(ErrorCode_BadSequenceOfCalls); + } + else + { + modification_.reset(modification); + isAnonymization_ = isAnonymization; + } + } + + + void ResourceModificationJob::SetOutput(boost::shared_ptr& output) + { + if (IsStarted()) + { + throw OrthancException(ErrorCode_BadSequenceOfCalls); + } + else + { + output_ = output; + } + } + + + void ResourceModificationJob::SetOrigin(const DicomInstanceOrigin& origin) + { + if (IsStarted()) + { + throw OrthancException(ErrorCode_BadSequenceOfCalls); + } + else + { + origin_ = origin; + } + } + + + void ResourceModificationJob::SetOrigin(const RestApiCall& call) + { + DicomInstanceOrigin tmp; + tmp.SetRestOrigin(call); + SetOrigin(tmp); + } + + + void ResourceModificationJob::GetPublicContent(Json::Value& value) + { + SetOfInstancesJob::GetPublicContent(value); + + value["IsAnonymization"] = isAnonymization_; + } + + + void ResourceModificationJob::GetInternalContent(Json::Value& value) + { + SetOfInstancesJob::GetInternalContent(value); + + Json::Value tmp; + modification_->Serialize(tmp); + value["Modification"] = tmp; + } +} diff -r 3ce8863398ab -r ccc470091ea6 OrthancServer/ServerJobs/ResourceModificationJob.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancServer/ServerJobs/ResourceModificationJob.h Mon May 28 16:46:54 2018 +0200 @@ -0,0 +1,109 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2018 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * In addition, as a special exception, the copyright holders of this + * program give permission to link the code of its release with the + * OpenSSL project's "OpenSSL" library (or with modified versions of it + * that use the same license as the "OpenSSL" library), and distribute + * the linked executables. You must obey the GNU General Public License + * in all respects for all of the code used other than "OpenSSL". If you + * modify file(s) with this exception, you may extend this exception to + * your version of the file(s), but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source files + * in the program, then also delete it here. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "../../Core/JobsEngine/SetOfInstancesJob.h" +#include "../ServerContext.h" + +namespace Orthanc +{ + class ResourceModificationJob : public SetOfInstancesJob + { + public: + class Output : public boost::noncopyable + { + private: + boost::mutex mutex_; + ResourceType level_; + bool isFirst_; + std::string id_; + std::string patientId_; + + public: + Output(ResourceType level); + + ResourceType GetLevel() const + { + return level_; + } + + void Update(DicomInstanceHasher& hasher); + + bool Format(Json::Value& target); + + bool GetIdentifier(std::string& id); + }; + + private: + ServerContext& context_; + std::auto_ptr modification_; + boost::shared_ptr output_; + bool isAnonymization_; + MetadataType metadataType_; + std::string description_; + DicomInstanceOrigin origin_; + + protected: + virtual bool HandleInstance(const std::string& instance); + + public: + ResourceModificationJob(ServerContext& context) : + context_(context), + isAnonymization_(false) + { + } + + void SetModification(DicomModification* modification, // Takes ownership + bool isAnonymization); + + void SetOutput(boost::shared_ptr& output); + + void SetOrigin(const DicomInstanceOrigin& origin); + + void SetOrigin(const RestApiCall& call); + + virtual void ReleaseResources() + { + } + + virtual void GetJobType(std::string& target) + { + target = "ResourceModification"; + } + + virtual void GetPublicContent(Json::Value& value); + + virtual void GetInternalContent(Json::Value& value); + }; +}