orthanc-stone: Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp comparison

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1600:b253b79906fa

clarifying variable names: frameIndex vs numberIndex

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 28 Oct 2020 15:23:26 +0100
parents	4fb8fdf03314
children	595c0952ef7e

comparison

equal deleted inserted replaced

-:73cd85d7da6a
+:b253b79906fa
 }
 };
 static std::string GetKey(const std::string& sopInstanceUid,
-size_t frameIndex)
+size_t frameNumber)
 {
-return sopInstanceUid + "|" + boost::lexical_cast<std::string>(frameIndex);
+return sopInstanceUid + "|" + boost::lexical_cast<std::string>(frameNumber);
 }
 Orthanc::MemoryObjectCache  cache_;
 /**
 * Returns "true" iff the provided image has better quality than the
 * previously cached one, or if no cache was previously available.
 **/
 bool Acquire(const std::string& sopInstanceUid,
-size_t frameIndex,
+size_t frameNumber,
 Orthanc::ImageAccessor* image /* transfer ownership */,
 unsigned int quality)
 {
 std::unique_ptr<Orthanc::ImageAccessor> protection(image);
 image->GetFormat() != Orthanc::PixelFormat_RGB24)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
 }
-const std::string& key = GetKey(sopInstanceUid, frameIndex);
+const std::string& key = GetKey(sopInstanceUid, frameNumber);
 bool invalidate = false;
 {
 /**
 }
 public:
 Accessor(FramesCache& that,
 const std::string& sopInstanceUid,
-size_t frameIndex) :
+size_t frameNumber) :
-accessor_(that.cache_, GetKey(sopInstanceUid, frameIndex), false /* shared lock */)
+accessor_(that.cache_, GetKey(sopInstanceUid, frameNumber), false /* shared lock */)
 {
 }
 bool IsValid() const
 {
 class SetLowQualityFrame : public ICommand
 {
 private:
 std::string   sopInstanceUid_;
-unsigned int  frameIndex_;
+unsigned int  frameNumber_;
 float         windowCenter_;
 float         windowWidth_;
 bool          isMonochrome1_;
 bool          isPrefetch_;
 public:
 SetLowQualityFrame(boost::shared_ptr<ViewerViewport> viewport,
 const std::string& sopInstanceUid,
-unsigned int frameIndex,
+unsigned int frameNumber,
 float windowCenter,
 float windowWidth,
 bool isMonochrome1,
 bool isPrefetch) :
 ICommand(viewport),
 sopInstanceUid_(sopInstanceUid),
-frameIndex_(frameIndex),
+frameNumber_(frameNumber),
 windowCenter_(windowCenter),
 windowWidth_(windowWidth),
 isMonochrome1_(isMonochrome1),
 isPrefetch_(isPrefetch)
 {
 switch (jpeg->GetFormat())
 {
 case Orthanc::PixelFormat_RGB24:
 updatedCache = GetViewport().cache_->Acquire(
-sopInstanceUid_, frameIndex_, jpeg.release(), QUALITY_JPEG);
+sopInstanceUid_, frameNumber_, jpeg.release(), QUALITY_JPEG);
 break;
 case Orthanc::PixelFormat_Grayscale8:
 {
 if (isMonochrome1_)
 const float offset = (OrthancStone::LinearAlgebra::IsCloseToZero(scaling) ? 0 :
 (windowCenter_ - windowWidth_ / 2.0f) / scaling);
 Orthanc::ImageProcessing::ShiftScale(*converted, offset, scaling, false);
 updatedCache = GetViewport().cache_->Acquire(
-sopInstanceUid_, frameIndex_, converted.release(), QUALITY_JPEG);
+sopInstanceUid_, frameNumber_, converted.release(), QUALITY_JPEG);
 break;
 }
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented);
 }
 if (updatedCache)
 {
-GetViewport().SignalUpdatedFrame(sopInstanceUid_, frameIndex_);
+GetViewport().SignalUpdatedFrame(sopInstanceUid_, frameNumber_);
 }
 if (isPrefetch_)
 {
 GetViewport().ScheduleNextPrefetch();
 class SetFullDicomFrame : public ICommand
 {
 private:
 std::string   sopInstanceUid_;
-unsigned int  frameIndex_;
+unsigned int  frameNumber_;
 bool          isPrefetch_;
 public:
 SetFullDicomFrame(boost::shared_ptr<ViewerViewport> viewport,
 const std::string& sopInstanceUid,
-unsigned int frameIndex,
+unsigned int frameNumber,
 bool isPrefetch) :
 ICommand(viewport),
 sopInstanceUid_(sopInstanceUid),
-frameIndex_(frameIndex),
+frameNumber_(frameNumber),
 isPrefetch_(isPrefetch)
 {
 }
 virtual void Handle(const OrthancStone::ParseDicomSuccessMessage& message) const ORTHANC_OVERRIDE
 {
 // Safety check
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
-std::unique_ptr<Orthanc::ImageAccessor> frame(message.GetDicom().DecodeFrame(frameIndex_));
+std::unique_ptr<Orthanc::ImageAccessor> frame(message.GetDicom().DecodeFrame(frameNumber_));
 if (frame.get() == NULL)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 bool updatedCache;
 if (frame->GetFormat() == Orthanc::PixelFormat_RGB24)
 {
 updatedCache = GetViewport().cache_->Acquire(
-sopInstanceUid_, frameIndex_, frame.release(), QUALITY_FULL);
+sopInstanceUid_, frameNumber_, frame.release(), QUALITY_FULL);
 }
 else
 {
 double a = 1;
 double b = 0;
 new Orthanc::Image(Orthanc::PixelFormat_Float32, frame->GetWidth(), frame->GetHeight(), false));
 Orthanc::ImageProcessing::Convert(*converted, *frame);
 Orthanc::ImageProcessing::ShiftScale2(*converted, b, a, false);
 updatedCache = GetViewport().cache_->Acquire(
-sopInstanceUid_, frameIndex_, converted.release(), QUALITY_FULL);
+sopInstanceUid_, frameNumber_, converted.release(), QUALITY_FULL);
 }
 if (updatedCache)
 {
-GetViewport().SignalUpdatedFrame(sopInstanceUid_, frameIndex_);
+GetViewport().SignalUpdatedFrame(sopInstanceUid_, frameNumber_);
 }
 if (isPrefetch_)
 {
 GetViewport().ScheduleNextPrefetch();
 return isFull_;
 }
 };
-std::unique_ptr<IObserver>                    observer_;
+std::unique_ptr<IObserver>                   observer_;
 OrthancStone::ILoadersContext&               context_;
 boost::shared_ptr<OrthancStone::WebAssemblyViewport>   viewport_;
 boost::shared_ptr<OrthancStone::DicomResourcesLoader> loader_;
 OrthancStone::DicomSource                    source_;
 boost::shared_ptr<FramesCache>               cache_;
 bool                                         fitNextContent_;
 bool                                         isCtrlDown_;
 FrameGeometry                                currentFrameGeometry_;
 std::list<PrefetchItem>                      prefetchQueue_;
-boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations>  annotations_;
+bool         hasFocusOnInstance_;
+std::string  focusSopInstanceUid_;
+boost::shared_ptr<OrthancStone::OsiriX::CollectionOfAnnotations>  annotations_;
 void ScheduleNextPrefetch()
 {
 while (!prefetchQueue_.empty())
 {
 size_t index = prefetchQueue_.front().GetFrameIndex();
 bool isFull = prefetchQueue_.front().IsFull();
 prefetchQueue_.pop_front();
 const std::string sopInstanceUid = frames_->GetFrameSopInstanceUid(index);
-unsigned int frame = frames_->GetFrameIndex(index);
+unsigned int frameNumber = frames_->GetFrameNumberInInstance(index);
 {
-FramesCache::Accessor accessor(*cache_, sopInstanceUid, frame);
+FramesCache::Accessor accessor(*cache_, sopInstanceUid, frameNumber);
 if (!accessor.IsValid() ||
 (isFull && accessor.GetQuality() == 0))
 {
 if (isFull)
 {
 inverted_ = false;
 }
 void SignalUpdatedFrame(const std::string& sopInstanceUid,
-unsigned int frameIndex)
+unsigned int frameNumber)
 {
 if (cursor_.get() != NULL &&
 frames_.get() != NULL)
 {
 size_t index = cursor_->GetCurrentIndex();
 if (frames_->GetFrameSopInstanceUid(index) == sopInstanceUid &&
-frames_->GetFrameIndex(index) == frameIndex)
+frames_->GetFrameNumberInInstance(index) == frameNumber)
 {
 DisplayCurrentFrame();
 }
 }
 }
 {
 return false;
 }
 const std::string sopInstanceUid = frames_->GetFrameSopInstanceUid(index);
-unsigned int frame = frames_->GetFrameIndex(index);
+size_t frameNumber = frames_->GetFrameNumberInInstance(index);
-FramesCache::Accessor accessor(*cache_, sopInstanceUid, frame);
+FramesCache::Accessor accessor(*cache_, sopInstanceUid, frameNumber);
 if (accessor.IsValid())
 {
 SaveCurrentWindowing();
 quality = accessor.GetQuality();
 bool isPrefetch)
 {
 if (frames_.get() != NULL)
 {
 std::string sopInstanceUid = frames_->GetFrameSopInstanceUid(index);
-unsigned int frame = frames_->GetFrameIndex(index);
+unsigned int frameNumber = frames_->GetFrameNumberInInstance(index);
 {
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_.Lock());
 lock->Schedule(
 GetSharedObserver(), priority, OrthancStone::ParseDicomFromWadoCommand::Create(
 source_, frames_->GetStudyInstanceUid(), frames_->GetSeriesInstanceUid(),
 sopInstanceUid, false /* transcoding (TODO) */,
 Orthanc::DicomTransferSyntax_LittleEndianExplicit /* TODO */,
-new SetFullDicomFrame(GetSharedObserver(), sopInstanceUid, frame, isPrefetch)));
+new SetFullDicomFrame(GetSharedObserver(), sopInstanceUid, frameNumber, isPrefetch)));
 }
 }
 }
 void ScheduleLoadRenderedFrame(size_t index,
 ScheduleLoadFullDicomFrame(index, priority, isPrefetch);
 }
 else if (frames_.get() != NULL)
 {
 std::string sopInstanceUid = frames_->GetFrameSopInstanceUid(index);
-unsigned int frame = frames_->GetFrameIndex(index);
+unsigned int frameNumber = frames_->GetFrameNumberInInstance(index);
 bool isMonochrome1 = frames_->IsFrameMonochrome1(index);
 const std::string uri = ("studies/" + frames_->GetStudyInstanceUid() +
 "/series/" + frames_->GetSeriesInstanceUid() +
 "/instances/" + sopInstanceUid +
-"/frames/" + boost::lexical_cast<std::string>(frame + 1) + "/rendered");
+"/frames/" + boost::lexical_cast<std::string>(frameNumber + 1) + "/rendered");
 std::map<std::string, std::string> headers, arguments;
 arguments["window"] = (
 boost::lexical_cast<std::string>(windowingCenter_) + ","  +
 boost::lexical_cast<std::string>(windowingWidth_) + ",linear");
 std::unique_ptr<OrthancStone::IOracleCommand> command(
 source_.CreateDicomWebCommand(
 uri, arguments, headers, new SetLowQualityFrame(
-GetSharedObserver(), sopInstanceUid, frame,
+GetSharedObserver(), sopInstanceUid, frameNumber,
 windowingCenter_, windowingWidth_, isMonochrome1, isPrefetch)));
 {
 std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_.Lock());
 lock->Schedule(GetSharedObserver(), priority, command.release());
 source_(source),
 cache_(cache),
 fitNextContent_(true),
 isCtrlDown_(false),
 flipX_(false),
-flipY_(false)
+flipY_(false),
+hasFocusOnInstance_(false)
 {
 if (!cache_)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
 }
 void Handle(const OrthancStone::ParseDicomSuccessMessage& message)
 {
 dynamic_cast<const ICommand&>(message.GetOrigin().GetPayload()).Handle(message);
 }
+void ApplyScheduledFocus()
+{
+size_t instanceIndex;
+if (hasFocusOnInstance_ &&
+frames_.get() != NULL &&
+frames_->LookupSopInstanceUid(instanceIndex, focusSopInstanceUid_))
+{
+// TODO
+hasFocusOnInstance_ = false;
+}
+}
 public:
 static boost::shared_ptr<ViewerViewport> Create(OrthancStone::ILoadersContext::ILock& lock,
 const OrthancStone::DicomSource& source,
 const std::string& canvas,

Mercurial > hg > orthanc-stone

comparison Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp @ 1600:b253b79906fa