orthanc: OrthancServer/SliceOrdering.cpp comparison

comparison OrthancServer/SliceOrdering.cpp @ 3538:23219b9da4d1

fix ordered-slices route to be closer to 1.5.7 behaviour

author	Alain Mazy <alain@mazy.be>
date	Tue, 15 Oct 2019 09:53:33 +0200
parents	4bced7d1ec20
children	f25e84cc5f87

comparison

equal deleted inserted replaced

-:9cc09f4c0fa9
+:23219b9da4d1
 instances_.reserve(instancesId.size());
 for (std::list<std::string>::const_iterator
 it = instancesId.begin(); it != instancesId.end(); ++it)
 {
-std::auto_ptr<Instance> instance(new Instance(index_, *it));
+instances_.push_back(new Instance(index_, *it));
-if (instance->HasPosition() || instance->HasNormal() || instance->HasIndexInSeries())
-{
-instances_.push_back(instance.release());
-}
 }
 }
 bool SliceOrdering::SortUsingPositions()
 {
 if (instances_.size() <= 1)
 {
 // One single instance: It is sorted by default
+sortedInstances_ = instances_;
 return true;
 }
 if (!hasNormal_)
 {
 return false;
 }
+sortedInstances_.clear();
+// consider only the instances with a position
 for (size_t i = 0; i < instances_.size(); i++)
 {
 assert(instances_[i] != NULL);
-if (!instances_[i]->HasPosition() ||
+if (instances_[i]->HasPosition())
-(instances_[i]->HasNormal() &&
+{
-!IsParallelOrOpposite(instances_[i]->GetNormal(), normal_)))
+sortedInstances_.push_back(instances_[i]);
-{
+}
-return false;
+}
-}
+if (sortedInstances_.size() == 0)
+{
+return false;
 }
 PositionComparator comparator(normal_);
-std::sort(instances_.begin(), instances_.end(), comparator);
+std::sort(sortedInstances_.begin(), sortedInstances_.end(), comparator);
-float a = instances_[0]->ComputeRelativePosition(normal_);
+float a = sortedInstances_[0]->ComputeRelativePosition(normal_);
-for (size_t i = 1; i < instances_.size(); i++)
+for (size_t i = 1; i < sortedInstances_.size(); i++)
 {
-float b = instances_[i]->ComputeRelativePosition(normal_);
+float b = sortedInstances_[i]->ComputeRelativePosition(normal_);
 if (std::fabs(b - a) <= 10.0f * std::numeric_limits<float>::epsilon())
 {
 // Not enough space between two slices along the normal of the volume
 return false;
 bool SliceOrdering::SortUsingIndexInSeries()
 {
 if (instances_.size() <= 1)
 {
 // One single instance: It is sorted by default
+sortedInstances_ = instances_;
 return true;
 }
+sortedInstances_.clear();
+// consider only the instances with an index
 for (size_t i = 0; i < instances_.size(); i++)
 {
 assert(instances_[i] != NULL);
-if (!instances_[i]->HasIndexInSeries())
+if (instances_[i]->HasIndexInSeries())
 {
-return false;
+sortedInstances_.push_back(instances_[i]);
 }
 }
-std::sort(instances_.begin(), instances_.end(), IndexInSeriesComparator);
+if (sortedInstances_.size() == 0) // if we were not able to sort instances because none of them had an index, return all instances in a "random" order
+{
-for (size_t i = 1; i < instances_.size(); i++)
+sortedInstances_ = instances_;
-{
+}
-if (instances_[i - 1]->GetIndexInSeries() == instances_[i]->GetIndexInSeries())
+else
 {
-// The current "IndexInSeries" occurs 2 times: Not a proper ordering
+std::sort(sortedInstances_.begin(), sortedInstances_.end(), IndexInSeriesComparator);
-LOG(WARNING) << "This series contains 2 slices with the same index, trying to display it anyway";
-break;
+for (size_t i = 1; i < sortedInstances_.size(); i++)
+{
+if (sortedInstances_[i - 1]->GetIndexInSeries() == sortedInstances_[i]->GetIndexInSeries())
+{
+// The current "IndexInSeries" occurs 2 times: Not a proper ordering
+LOG(WARNING) << "This series contains 2 slices with the same index, trying to display it anyway";
+break;
+}
 }
 }
 return true;
 }
 }
 }
 }
-const std::string& SliceOrdering::GetInstanceId(size_t index) const
+const std::string& SliceOrdering::GetSortedInstanceId(size_t index) const
 {
-if (index >= instances_.size())
+if (index >= sortedInstances_.size())
 {
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 else
 {
-return instances_[index]->GetIdentifier();
+return sortedInstances_[index]->GetIdentifier();
 }
 }
-unsigned int SliceOrdering::GetFramesCount(size_t index) const
+unsigned int SliceOrdering::GetSortedInstanceFramesCount(size_t index) const
 {
-if (index >= instances_.size())
+if (index >= sortedInstances_.size())
 {
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 else
 {
-return instances_[index]->GetFramesCount();
+return sortedInstances_[index]->GetFramesCount();
 }
 }
 void SliceOrdering::Format(Json::Value& result) const
 {
 result = Json::objectValue;
 result["Type"] = (isVolume_ ? "Volume" : "Sequence");
 Json::Value tmp = Json::arrayValue;
-for (size_t i = 0; i < GetInstancesCount(); i++)
+for (size_t i = 0; i < GetSortedInstancesCount(); i++)
 {
-tmp.append(GetBasePath(ResourceType_Instance, GetInstanceId(i)) + "/file");
+tmp.append(GetBasePath(ResourceType_Instance, GetSortedInstanceId(i)) + "/file");
 }
 result["Dicom"] = tmp;
 Json::Value slicesShort = Json::arrayValue;
 tmp.clear();
-for (size_t i = 0; i < GetInstancesCount(); i++)
+for (size_t i = 0; i < GetSortedInstancesCount(); i++)
 {
-std::string base = GetBasePath(ResourceType_Instance, GetInstanceId(i));
+std::string base = GetBasePath(ResourceType_Instance, GetSortedInstanceId(i));
-for (size_t j = 0; j < GetFramesCount(i); j++)
+for (size_t j = 0; j < GetSortedInstanceFramesCount(i); j++)
 {
 tmp.append(base + "/frames/" + boost::lexical_cast<std::string>(j));
 }
 Json::Value tmp2 = Json::arrayValue;
-tmp2.append(GetInstanceId(i));
+tmp2.append(GetSortedInstanceId(i));
 tmp2.append(0);
-tmp2.append(GetFramesCount(i));
+tmp2.append(GetSortedInstanceFramesCount(i));
 slicesShort.append(tmp2);
 }
 result["Slices"] = tmp;

Mercurial > hg > orthanc

comparison OrthancServer/SliceOrdering.cpp @ 3538:23219b9da4d1