Mercurial > hg > orthanc-stone
diff Framework/Loaders/BasicFetchingStrategy.cpp @ 708:51976977d2d3
reorganization
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Mon, 20 May 2019 11:20:01 +0200 |
parents | |
children | 7457b4ee1f29 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Loaders/BasicFetchingStrategy.cpp Mon May 20 11:20:01 2019 +0200 @@ -0,0 +1,146 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2019 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation, either version 3 of + * the License, or (at your option) any later version. + * + * 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 + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + **/ + + +#include "BasicFetchingStrategy.h" + +#include <Core/OrthancException.h> + +namespace OrthancStone +{ + void BasicFetchingStrategy::Schedule(unsigned int item, + unsigned int quality) + { + assert(item < GetItemsCount() && + quality <= maxQuality_); + + if (nextQuality_[item] <= quality) + { + content_.push_back(ContentItem(item, quality)); + } + } + + + BasicFetchingStrategy::BasicFetchingStrategy(IFetchingItemsSorter* sorter, // Takes ownership + unsigned int maxQuality) : + sorter_(sorter), + maxQuality_(maxQuality), + position_(0), + blockSize_(2) + { + if (sorter == NULL) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); + } + + nextQuality_.resize(sorter_->GetItemsCount(), 0), // Does not change along calls to "SetCurrent()" + + SetCurrent(0); + } + + + // WARNING - This parameters is only considered during the next call to SetCurrent(). + void BasicFetchingStrategy::SetBlockSize(unsigned int size) + { + if (size <= 0) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + blockSize_ = size; + } + + + bool BasicFetchingStrategy::GetNext(unsigned int& item, + unsigned int& quality) + { + if (position_ >= content_.size()) + { + return false; + } + else + { + item = content_[position_].GetItem(); + quality = content_[position_].GetQuality(); + + assert(nextQuality_[item] <= quality); + nextQuality_[item] = quality + 1; + + position_ ++; + return true; + } + } + + + void BasicFetchingStrategy::SetCurrent(unsigned int item) + { + // TODO - This function is O(N) complexity where "N" is the + // number of items times the max quality. Could use a LRU index. + + position_ = 0; + + std::vector<unsigned int> v; + sorter_->Sort(v, item); + + assert(v.size() == GetItemsCount()); + + if (v.size() == 0) + { + return; + } + + content_.clear(); + content_.reserve(v.size() * maxQuality_); + + Schedule(v.front(), maxQuality_); + + for (unsigned int q = 0; q <= maxQuality_; q++) + { + unsigned int start = 1 + q * blockSize_; + unsigned int end = start + blockSize_; + + if (q == maxQuality_ || + end > v.size()) + { + end = v.size(); + } + + unsigned int a = 0; + if (maxQuality_ >= q + 1) + { + a = maxQuality_ - q - 1; + } + + for (unsigned int j = a; j <= maxQuality_; j++) + { + for (unsigned int i = start; i < end; i++) + { + Schedule(v[i], j); + } + } + } + } + + + void BasicFetchingStrategy::RecycleFurthest(unsigned int& item) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); + } +}