# HG changeset patch # User Sebastien Jodogne # Date 1445863670 -3600 # Node ID 38dda23c7d7de505601377a074adaec93c6c64ae # Parent b3de74dec2d55b9ad88fe61c7721ed0c79b2edf5 LookupIdentifierQuery diff -r b3de74dec2d5 -r 38dda23c7d7d CMakeLists.txt --- a/CMakeLists.txt Mon Oct 26 12:30:34 2015 +0100 +++ b/CMakeLists.txt Mon Oct 26 13:47:50 2015 +0100 @@ -164,6 +164,7 @@ OrthancServer/Internals/FindScp.cpp OrthancServer/Internals/MoveScp.cpp OrthancServer/Internals/StoreScp.cpp + OrthancServer/LookupIdentifierQuery.cpp OrthancServer/LuaScripting.cpp OrthancServer/OrthancFindRequestHandler.cpp OrthancServer/OrthancHttpHandler.cpp diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/DatabaseWrapper.h --- a/OrthancServer/DatabaseWrapper.h Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/DatabaseWrapper.h Mon Oct 26 13:47:50 2015 +0100 @@ -323,11 +323,9 @@ base_.LookupIdentifierExact(target, level, tag, value); } - virtual void LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value) + virtual void LookupIdentifier(const LookupIdentifierQuery& query) { - base_.LookupIdentifierWildcard(target, tag, value); + base_.LookupIdentifier(query); } virtual void GetAllMetadata(std::map& target, diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/DatabaseWrapperBase.cpp --- a/OrthancServer/DatabaseWrapperBase.cpp Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/DatabaseWrapperBase.cpp Mon Oct 26 13:47:50 2015 +0100 @@ -694,9 +694,8 @@ } - void DatabaseWrapperBase::LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value) + + void DatabaseWrapperBase::LookupIdentifier(const LookupIdentifierQuery& query) { // TODO throw OrthancException(ErrorCode_NotImplemented); diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/DatabaseWrapperBase.h --- a/OrthancServer/DatabaseWrapperBase.h Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/DatabaseWrapperBase.h Mon Oct 26 13:47:50 2015 +0100 @@ -39,6 +39,7 @@ #include "../Core/SQLite/Connection.h" #include "../OrthancServer/ExportedResource.h" #include "../OrthancServer/ServerIndexChange.h" +#include "LookupIdentifierQuery.h" #include "ServerEnumerations.h" #include @@ -195,9 +196,7 @@ const DicomTag& tag, const std::string& value); - void LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value); + void LookupIdentifier(const LookupIdentifierQuery& query); }; } diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/IDatabaseWrapper.h --- a/OrthancServer/IDatabaseWrapper.h Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/IDatabaseWrapper.h Mon Oct 26 13:47:50 2015 +0100 @@ -44,6 +44,8 @@ namespace Orthanc { + class LookupIdentifierQuery; + class IDatabaseWrapper : public boost::noncopyable { public: @@ -151,28 +153,7 @@ const DicomTag& tag, const std::string& value) = 0; - /** - * Primitive for wildcard matching, as defined in DICOM: - * http://dicom.nema.org/dicom/2013/output/chtml/part04/sect_C.2.html#sect_C.2.2.2.4 - * - * "Any occurrence of an "*" or a "?", then "*" shall match any - * sequence of characters (including a zero length value) and "?" - * shall match any single character. This matching is case - * sensitive, except for Attributes with an PN Value - * Representation (e.g., Patient Name (0010,0010))." - * - * Pay attention to the fact that "*" (resp. "?") generally - * corresponds to "%" (resp. "_") in primitive LIKE of SQL. The - * values "%", "_", "\" should in the user request should - * respectively be escaped as "\%", "\_" and "\\". - * - * This matching must be case sensitive: The special case of PN VR - * is taken into consideration by normalizing the query string in - * method "ServerIndex::LookupIdentifierWildcard()". - **/ - virtual void LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value) = 0; + virtual void LookupIdentifier(const LookupIdentifierQuery& query) = 0; virtual bool LookupMetadata(std::string& target, int64_t id, diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/LookupIdentifierQuery.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancServer/LookupIdentifierQuery.cpp Mon Oct 26 13:47:50 2015 +0100 @@ -0,0 +1,205 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, 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 "LookupIdentifierQuery.h" + +#include "../Core/OrthancException.h" + + +#include + + + +namespace Orthanc +{ + static const DicomTag patientIdentifiers[] = + { + DICOM_TAG_PATIENT_ID, + DICOM_TAG_PATIENT_NAME, + DICOM_TAG_PATIENT_BIRTH_DATE + }; + + static const DicomTag studyIdentifiers[] = + { + DICOM_TAG_PATIENT_ID, + DICOM_TAG_PATIENT_NAME, + DICOM_TAG_PATIENT_BIRTH_DATE, + DICOM_TAG_STUDY_INSTANCE_UID, + DICOM_TAG_ACCESSION_NUMBER, + DICOM_TAG_STUDY_DESCRIPTION, + DICOM_TAG_STUDY_DATE + }; + + static const DicomTag seriesIdentifiers[] = + { + DICOM_TAG_SERIES_INSTANCE_UID + }; + + static const DicomTag instanceIdentifiers[] = + { + DICOM_TAG_SOP_INSTANCE_UID + }; + + + LookupIdentifierQuery::~LookupIdentifierQuery() + { + for (Constraints::iterator it = constraints_.begin(); + it != constraints_.end(); ++it) + { + delete *it; + } + } + + + + void LookupIdentifierQuery::CheckIndex(size_t index) const + { + if (index >= constraints_.size()) + { + throw OrthancException(ErrorCode_ParameterOutOfRange); + } + } + + + static void LoadIdentifiers(const DicomTag*& tags, + size_t& size, + ResourceType level) + { + switch (level) + { + case ResourceType_Patient: + tags = patientIdentifiers; + size = sizeof(patientIdentifiers) / sizeof(DicomTag); + break; + + case ResourceType_Study: + tags = studyIdentifiers; + size = sizeof(studyIdentifiers) / sizeof(DicomTag); + break; + + case ResourceType_Series: + tags = seriesIdentifiers; + size = sizeof(seriesIdentifiers) / sizeof(DicomTag); + break; + + case ResourceType_Instance: + tags = instanceIdentifiers; + size = sizeof(instanceIdentifiers) / sizeof(DicomTag); + break; + + default: + throw OrthancException(ErrorCode_ParameterOutOfRange); + } + } + + + bool LookupIdentifierQuery::IsIdentifier(const DicomTag& tag) const + { + const DicomTag* tags; + size_t size; + + LoadIdentifiers(tags, size, level_); + + for (size_t i = 0; i < size; i++) + { + if (tag == tags[i]) + { + return true; + } + } + + return false; + } + + + void LookupIdentifierQuery::AddConstraint(DicomTag tag, + IdentifierConstraintType type, + const std::string& value) + { + assert(IsIdentifier(tag)); + constraints_.push_back(new Constraint(tag, type, NormalizeIdentifier(value))); + } + + + const DicomTag& LookupIdentifierQuery::GetTag(size_t index) const + { + CheckIndex(index); + return constraints_[index]->tag_; + } + + + IdentifierConstraintType LookupIdentifierQuery::GetType(size_t index) const + { + CheckIndex(index); + return constraints_[index]->type_; + } + + + const std::string& LookupIdentifierQuery::GetValue(size_t index) const + { + CheckIndex(index); + return constraints_[index]->value_; + } + + + std::string LookupIdentifierQuery::NormalizeIdentifier(const std::string& value) + { + std::string s = Toolbox::ConvertToAscii(Toolbox::StripSpaces(value)); + Toolbox::ToUpperCase(s); + return s; + } + + + void LookupIdentifierQuery::StoreIdentifiers(IDatabaseWrapper& database, + int64_t resource, + ResourceType level, + const DicomMap& map) + { + const DicomTag* tags; + size_t size; + + LoadIdentifiers(tags, size, level); + + for (size_t i = 0; i < size; i++) + { + const DicomValue* value = map.TestAndGetValue(tags[i]); + if (value != NULL && + !value->IsNull() && + !value->IsBinary()) + { + std::string s = NormalizeIdentifier(value->GetContent()); + database.SetIdentifierTag(resource, tags[i], s); + } + } + } +} diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/LookupIdentifierQuery.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/OrthancServer/LookupIdentifierQuery.h Mon Oct 26 13:47:50 2015 +0100 @@ -0,0 +1,123 @@ +/** + * Orthanc - A Lightweight, RESTful DICOM Store + * Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, 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 "ServerEnumerations.h" +#include "IDatabaseWrapper.h" + +#include +#include + +namespace Orthanc +{ + /** + * Primitive for wildcard matching, as defined in DICOM: + * http://dicom.nema.org/dicom/2013/output/chtml/part04/sect_C.2.html#sect_C.2.2.2.4 + * + * "Any occurrence of an "*" or a "?", then "*" shall match any + * sequence of characters (including a zero length value) and "?" + * shall match any single character. This matching is case + * sensitive, except for Attributes with an PN Value + * Representation (e.g., Patient Name (0010,0010))." + * + * Pay attention to the fact that "*" (resp. "?") generally + * corresponds to "%" (resp. "_") in primitive LIKE of SQL. The + * values "%", "_", "\" should in the user request should + * respectively be escaped as "\%", "\_" and "\\". + * + * This matching must be case sensitive: The special case of PN VR + * is taken into consideration by normalizing the query string in + * method "NormalizeIdentifier()". + **/ + + + + class LookupIdentifierQuery : public boost::noncopyable + { + private: + struct Constraint + { + DicomTag tag_; + IdentifierConstraintType type_; + std::string value_; + + Constraint(const DicomTag& tag, + IdentifierConstraintType type, + const std::string& value) : + tag_(tag), + type_(type), + value_(value) + { + } + }; + + typedef std::vector Constraints; + + ResourceType level_; + Constraints constraints_; + + void CheckIndex(size_t index) const; + + static std::string NormalizeIdentifier(const std::string& value); + + public: + LookupIdentifierQuery(ResourceType level) : level_(level) + { + } + + ~LookupIdentifierQuery(); + + bool IsIdentifier(const DicomTag& tag) const; + + void AddConstraint(DicomTag tag, + IdentifierConstraintType type, + const std::string& value); + + size_t GetSize() + { + return constraints_.size(); + } + + const DicomTag& GetTag(size_t index) const; + + IdentifierConstraintType GetType(size_t index) const; + + const std::string& GetValue(size_t index) const; + + static void StoreIdentifiers(IDatabaseWrapper& database, + int64_t resource, + ResourceType level, + const DicomMap& map); + + }; +} diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/ServerEnumerations.h --- a/OrthancServer/ServerEnumerations.h Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/ServerEnumerations.h Mon Oct 26 13:47:50 2015 +0100 @@ -125,6 +125,14 @@ DicomToJsonFlags_ConvertBinaryToNull) }; + enum IdentifierConstraintType + { + IdentifierConstraintType_Equal, + IdentifierConstraintType_LessOrEqual, + IdentifierConstraintType_GeaterOrEqual, + IdentifierConstraintType_Wildcard /* "*" or "?" are the only allowed wildcards */ + }; + /** * WARNING: Do not change the explicit values in the enumerations diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/ServerToolbox.cpp --- a/OrthancServer/ServerToolbox.cpp Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/ServerToolbox.cpp Mon Oct 26 13:47:50 2015 +0100 @@ -38,6 +38,7 @@ #include "../Core/Logging.h" #include "../Core/OrthancException.h" #include "ParsedDicomFile.h" +#include "LookupIdentifierQuery.h" #include @@ -193,45 +194,6 @@ } - static void SetIdentifierTagInternal(IDatabaseWrapper& database, - int64_t resource, - const DicomMap& tags, - const DicomTag& tag) - { - const DicomValue* value = tags.TestAndGetValue(tag); - if (value != NULL && - !value->IsNull() && - !value->IsBinary()) - { - std::string s = value->GetContent(); - - if (tag != DICOM_TAG_PATIENT_ID && - tag != DICOM_TAG_STUDY_INSTANCE_UID && - tag != DICOM_TAG_SERIES_INSTANCE_UID && - tag != DICOM_TAG_SOP_INSTANCE_UID && - tag != DICOM_TAG_ACCESSION_NUMBER) - { - s = NormalizeTagForWildcard(s); - } - - database.SetIdentifierTag(resource, tag, s); - } - } - - - static void AttachPatientInformation(IDatabaseWrapper& database, - int64_t resource, - const DicomMap& dicomSummary) - { - DicomMap tags; - dicomSummary.ExtractPatientInformation(tags); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_PATIENT_ID); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_PATIENT_NAME); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_PATIENT_BIRTH_DATE); - SetMainDicomTagsInternal(database, resource, tags); - } - - void SetMainDicomTags(IDatabaseWrapper& database, int64_t resource, ResourceType level, @@ -239,33 +201,30 @@ { // WARNING: The database should be locked with a transaction! + LookupIdentifierQuery::StoreIdentifiers(database, resource, level, dicomSummary); + DicomMap tags; switch (level) { case ResourceType_Patient: - AttachPatientInformation(database, resource, dicomSummary); + dicomSummary.ExtractPatientInformation(tags); break; case ResourceType_Study: // Duplicate the patient tags at the study level (new in Orthanc 0.9.5 - db v6) - AttachPatientInformation(database, resource, dicomSummary); + dicomSummary.ExtractPatientInformation(tags); + SetMainDicomTagsInternal(database, resource, tags); dicomSummary.ExtractStudyInformation(tags); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_STUDY_INSTANCE_UID); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_ACCESSION_NUMBER); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_STUDY_DESCRIPTION); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_STUDY_DATE); break; case ResourceType_Series: dicomSummary.ExtractSeriesInformation(tags); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_SERIES_INSTANCE_UID); break; case ResourceType_Instance: dicomSummary.ExtractInstanceInformation(tags); - SetIdentifierTagInternal(database, resource, tags, DICOM_TAG_SOP_INSTANCE_UID); break; default: @@ -374,13 +333,5 @@ Toolbox::SetMainDicomTags(database, resource, level, dicomSummary); } } - - - std::string NormalizeTagForWildcard(const std::string& value) - { - std::string s = Toolbox::ConvertToAscii(Toolbox::StripSpaces(value)); - Toolbox::ToUpperCase(s); - return s; - } } } diff -r b3de74dec2d5 -r 38dda23c7d7d OrthancServer/ServerToolbox.h --- a/OrthancServer/ServerToolbox.h Mon Oct 26 12:30:34 2015 +0100 +++ b/OrthancServer/ServerToolbox.h Mon Oct 26 13:47:50 2015 +0100 @@ -59,7 +59,5 @@ void ReconstructMainDicomTags(IDatabaseWrapper& database, IStorageArea& storageArea, ResourceType level); - - std::string NormalizeTagForWildcard(const std::string& value); } } diff -r b3de74dec2d5 -r 38dda23c7d7d Plugins/Engine/OrthancPluginDatabase.cpp --- a/Plugins/Engine/OrthancPluginDatabase.cpp Mon Oct 26 12:30:34 2015 +0100 +++ b/Plugins/Engine/OrthancPluginDatabase.cpp Mon Oct 26 13:47:50 2015 +0100 @@ -646,9 +646,7 @@ } - void OrthancPluginDatabase::LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value) + void OrthancPluginDatabase::LookupIdentifier(const LookupIdentifierQuery& query) { // TODO throw OrthancException(ErrorCode_NotImplemented); diff -r b3de74dec2d5 -r 38dda23c7d7d Plugins/Engine/OrthancPluginDatabase.h --- a/Plugins/Engine/OrthancPluginDatabase.h Mon Oct 26 12:30:34 2015 +0100 +++ b/Plugins/Engine/OrthancPluginDatabase.h Mon Oct 26 13:47:50 2015 +0100 @@ -208,9 +208,7 @@ const DicomTag& tag, const std::string& value); - virtual void LookupIdentifierWildcard(std::list& target, - const DicomTag& tag, - const std::string& value); + virtual void LookupIdentifier(const LookupIdentifierQuery& query); virtual bool LookupMetadata(std::string& target, int64_t id,