# HG changeset patch
# User Sebastien Jodogne <s.jodogne@gmail.com>
# Date 1729605368 -7200
# Node ID 4596ad1b2aa49b7aeaaa8f17c963eb112783a3ea
# Parent  e65fe2e50fde8829c4c9729fba6ac0e5d6329ce2# Parent  239fb2c893c183da0e15dcb8a32d4d4270c57e75
integration mainline->dicom-sr

diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/NEWS
--- a/Applications/StoneWebViewer/NEWS	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/NEWS	Tue Oct 22 15:56:08 2024 +0200
@@ -1,6 +1,12 @@
 Pending changes in the mainline
 ===============================
 
+* Automatically stretch to whole range for images without preset
+* Improved support of the (0028,9132) tag for Philips multiframe images
+* Remember the previous layout when re-opening the viewer.
+* Added a Print button in the PDF viewer toolbar.
+* Added a Download button in the PDF viewer toolbar.
+ 
 
 Version 2.6 (2024-08-31)
 ========================
diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/Plugin/Plugin.cpp
--- a/Applications/StoneWebViewer/Plugin/Plugin.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/Plugin/Plugin.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -61,7 +61,7 @@
       }
 
       std::string version = info["Version"].asString();
-      if (version != "mainline")
+      if (version.find("mainline") != 0)
       {
         std::vector<std::string> tokens;
         Orthanc::Toolbox::TokenizeString(tokens, version, '.');
diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/WebApplication/app.js
--- a/Applications/StoneWebViewer/WebApplication/app.js	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/WebApplication/app.js	Tue Oct 22 15:56:08 2024 +0200
@@ -960,7 +960,7 @@
         this.layoutCountX = 1;
         this.layoutCountY = 2;
       }
-
+      localStorage.setItem('layout', layout);
       this.FitContent();
     },
 
@@ -1369,7 +1369,11 @@
   mounted: function() {
     // Warning: In this function, the "stone" global object is not initialized yet!
     
-    this.SetViewportLayout('1x1');
+    if (localStorage.layout) {
+      this.SetViewportLayout(localStorage.layout);
+    } else {
+      this.SetViewportLayout('1x1');
+    }
 
     if (localStorage.settingNotDiagnostic) {
       this.settingNotDiagnostic = (localStorage.settingNotDiagnostic == '1');
diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/WebApplication/index.html
--- a/Applications/StoneWebViewer/WebApplication/index.html	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/WebApplication/index.html	Tue Oct 22 15:56:08 2024 +0200
@@ -898,6 +898,14 @@
 
         <div class="wv-overlay">
           <div class="wv-overlay-bottomleft wvPrintExclude">
+            <button class="btn btn-primary" @click="Download()"
+                    data-toggle="tooltip" data-title="Download">
+              <i class="fa fa-download"></i>
+            </button>
+            <button class="btn btn-primary" @click="Print()"
+                    data-toggle="tooltip" data-title="Print">
+              <i class="fa fa-print"></i>
+            </button>
             <button class="btn btn-primary" @click="FitWidth()"
                     data-toggle="tooltip" data-title="Fit page width">
               <i class="fas fa-text-width"></i>
diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/WebApplication/pdf-viewer.js
--- a/Applications/StoneWebViewer/WebApplication/pdf-viewer.js	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/WebApplication/pdf-viewer.js	Tue Oct 22 15:56:08 2024 +0200
@@ -92,6 +92,46 @@
     });
   },
   methods: {
+    Download: function() {
+      if (this.pdfDoc !== null) {
+        const blob = new Blob([this.pdf], { type: 'application/pdf'});
+        const blobUrl = URL.createObjectURL(blob);
+
+        const a = document.createElement('a');
+        a.href = blobUrl;
+        a.download = "report.pdf";
+
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+
+        // Revoke the object URL to free up memory
+        URL.revokeObjectURL(blobUrl);
+      }
+    },
+    Print: function() {
+      if (this.pdfDoc !== null) {
+        if (0) { // works on Chrome but with a popup that is blocked by default !
+          const blob = new Blob([this.pdf], { type: 'application/pdf'});
+          const blobUrl = URL.createObjectURL(blob);
+
+          let w = window.open(blobUrl, '_blank');
+          w.print();
+        } else {
+          // Let's open a new window with the pdf
+          // First we need to convert the pdf from a byte array to a binary string and then to b64
+          let binaryStringPdf = '';
+          for (let i = 0; i < this.pdf.length; i++) {
+            binaryStringPdf += String.fromCharCode(this.pdf[i]);
+          }
+
+          const htmlContent = '<html><body style="margin: 0;"><embed width="100%" height="100%" src="data:application/pdf;base64,' + btoa(binaryStringPdf) + '" type="application/pdf" /></body></html>';
+
+          let w = window.open('', '_blank');
+          w.document.write(htmlContent);
+        }
+      }
+    },
     NextPage: function() {
       if (this.pdfDoc !== null &&
           this.currentPage < this.pdfDoc.numPages) {
diff -r e65fe2e50fde -r 4596ad1b2aa4 Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp
--- a/Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/Applications/StoneWebViewer/WebAssembly/StoneWebViewer.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -121,7 +121,8 @@
     ThumbnailType_Pdf,
     ThumbnailType_Video,
     ThumbnailType_Loading,
-    ThumbnailType_Unknown
+    ThumbnailType_Unknown,
+    ThumbnailType_Unavailable
     };
 
 
@@ -211,6 +212,76 @@
 
 
 
+enum WindowingState
+{
+  WindowingState_None = 1,
+  WindowingState_Fallback = 2,
+  WindowingState_GlobalPreset = 3,
+  WindowingState_FramePreset = 4,
+  WindowingState_User = 5
+};
+
+
+class WindowingTracker
+{
+private:
+  WindowingState           state_;
+  OrthancStone::Windowing  windowing_;
+
+public:
+  WindowingTracker() :
+    state_(WindowingState_None)
+  {
+  }
+
+  WindowingState GetState() const
+  {
+    return state_;
+  }
+
+  const OrthancStone::Windowing& GetWindowing() const
+  {
+    return windowing_;
+  }
+
+  void Reset()
+  {
+    state_ = WindowingState_None;
+    windowing_ = OrthancStone::Windowing();
+  }
+
+  // Returns "true" iif. the windowing needed an update
+  bool Update(WindowingState newState,
+              const OrthancStone::Windowing& newWindowing)
+  {
+    if (newState == WindowingState_None)
+    {
+      // "Reset()" should have been called
+      throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+    }
+
+    if (newState >= state_)
+    {
+      state_ = newState;
+
+      if (windowing_.IsNear(newWindowing))
+      {
+        return false;
+      }
+      else
+      {
+        windowing_ = newWindowing;
+        return true;
+      }
+    }
+    else
+    {
+      return false;
+    }
+  }
+};
+
+
 class IFramesCollection : public boost::noncopyable
 {
 public:
@@ -1535,6 +1606,79 @@
 
 
 
+class InstancesCache : public boost::noncopyable
+{
+private:
+  // Maps "SOP Instance UID" to DICOM parameters
+  typedef std::map<std::string, OrthancStone::DicomInstanceParameters*>  Content;
+
+  Content  content_;
+
+  void Clear()
+  {
+    for (Content::iterator it = content_.begin(); it != content_.end(); ++it)
+    {
+      assert(it->second != NULL);
+      delete it->second;
+    }
+
+    content_.clear();
+  }
+
+public:
+  ~InstancesCache()
+  {
+    Clear();
+  }
+
+  void Store(const std::string& sopInstanceUid,
+             const OrthancStone::DicomInstanceParameters& parameters)
+  {
+    Content::iterator found = content_.find(sopInstanceUid);
+    if (found == content_.end())
+    {
+      content_[sopInstanceUid] = parameters.Clone();
+    }
+  }
+
+  class Accessor : public boost::noncopyable
+  {
+  private:
+    std::unique_ptr<OrthancStone::DicomInstanceParameters>  parameters_;
+
+  public:
+    Accessor(InstancesCache& that,
+             const std::string& sopInstanceUid)
+    {
+      Content::iterator found = that.content_.find(sopInstanceUid);
+      if (found != that.content_.end())
+      {
+        assert(found->second != NULL);
+        parameters_.reset(found->second->Clone());
+      }
+    }
+
+    bool IsValid() const
+    {
+      return parameters_.get() != NULL;
+    }
+
+    const OrthancStone::DicomInstanceParameters& GetParameters() const
+    {
+      if (IsValid())
+      {
+        return *parameters_;
+      }
+      else
+      {
+        throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
+      }
+    }
+  };
+};
+
+
+
 class SeriesCursor : public boost::noncopyable
 {
 public:
@@ -2078,8 +2222,7 @@
                                             const OrthancStone::Vector& normal) = 0;
 
     virtual void SignalWindowingUpdated(const ViewerViewport& viewport,
-                                        double windowingCenter,
-                                        double windowingWidth) = 0;
+                                        const OrthancStone::Windowing& windowing) = 0;
 
     virtual void SignalStoneAnnotationsChanged(const ViewerViewport& viewport,
                                                const std::string& sopInstanceUid,
@@ -2189,41 +2332,18 @@
                                                   static_cast<double>(params.GetHeight()));
         }
 
-        GetViewport().windowingPresetCenters_.resize(params.GetWindowingPresetsCount());
-        GetViewport().windowingPresetWidths_.resize(params.GetWindowingPresetsCount());
+        GetViewport().windowingPresets_.resize(params.GetWindowingPresetsCount());
 
         for (size_t i = 0; i < params.GetWindowingPresetsCount(); i++)
         {
           LOG(INFO) << "Preset windowing " << (i + 1) << "/" << params.GetWindowingPresetsCount()
-                    << ": " << params.GetWindowingPresetCenter(i)
-                    << "," << params.GetWindowingPresetWidth(i);
-
-          GetViewport().windowingPresetCenters_[i] = params.GetWindowingPresetCenter(i);
-          GetViewport().windowingPresetWidths_[i] = params.GetWindowingPresetWidth(i);
-        }
-
-        if (params.GetWindowingPresetsCount() == 0)
-        {
-          LOG(INFO) << "No preset windowing";
+                    << ": " << params.GetWindowingPreset(i).GetCenter()
+                    << "," << params.GetWindowingPreset(i).GetWidth();
+
+          GetViewport().windowingPresets_[i] = params.GetWindowingPreset(i);
         }
 
-        uint32_t bitsStored, pixelRepresentation;
-        if (dicom.ParseUnsignedInteger32(bitsStored, Orthanc::DICOM_TAG_BITS_STORED) &&
-            dicom.ParseUnsignedInteger32(pixelRepresentation, Orthanc::DICOM_TAG_PIXEL_REPRESENTATION))
-        {
-          // Added in Stone Web viewer > 2.5
-          const bool isSigned = (pixelRepresentation != 0);
-          const float maximum = powf(2.0, bitsStored);
-          GetViewport().windowingDefaultCenter_ = (isSigned ? 0.0f : maximum / 2.0f);
-          GetViewport().windowingDefaultWidth_ = maximum;
-        }
-        else
-        {
-          GetViewport().windowingDefaultCenter_ = 128;
-          GetViewport().windowingDefaultWidth_ = 256;
-        }
-
-        GetViewport().SetWindowingPreset();
+        GetViewport().SetDefaultWindowing(params);
       }
 
       uint32_t cineRate;
@@ -2257,8 +2377,7 @@
   private:
     std::string   sopInstanceUid_;
     unsigned int  frameNumber_;
-    float         windowCenter_;
-    float         windowWidth_;
+    OrthancStone::Windowing  windowing_;
     bool          isMonochrome1_;
     bool          isPrefetch_;
     
@@ -2266,15 +2385,13 @@
     SetLowQualityFrame(boost::shared_ptr<ViewerViewport> viewport,
                        const std::string& sopInstanceUid,
                        unsigned int frameNumber,
-                       float windowCenter,
-                       float windowWidth,
+                       const OrthancStone::Windowing& windowing,
                        bool isMonochrome1,
                        bool isPrefetch) :
       ICommand(viewport),
       sopInstanceUid_(sopInstanceUid),
       frameNumber_(frameNumber),
-      windowCenter_(windowCenter),
-      windowWidth_(windowWidth),
+      windowing_(windowing),
       isMonochrome1_(isMonochrome1),
       isPrefetch_(isPrefetch)
     {
@@ -2320,9 +2437,11 @@
 
           **/
 
-          const float scaling = windowWidth_ / 255.0f;
+          const float center = static_cast<float>(windowing_.GetCenter());
+          const float width = static_cast<float>(windowing_.GetWidth());
+          const float scaling = width / 255.0f;
           const float offset = (OrthancStone::LinearAlgebra::IsCloseToZero(scaling) ? 0 :
-                                (windowCenter_ - windowWidth_ / 2.0f) / scaling);
+                                (center - width / 2.0f) / scaling);
 
           Orthanc::ImageProcessing::ShiftScale(*converted, offset, scaling, false);
           break;
@@ -2408,17 +2527,6 @@
       }
       else
       {
-        if (GetViewport().windowingPresetCenters_.empty())
-        {
-          // New in Stone Web viewer 2.2: Deal with Philips multiframe
-          // (cf. mail from Tomas Kenda on 2021-08-17)
-          double windowingCenter, windowingWidth;
-          message.GetDicom().GetDefaultWindowing(windowingCenter, windowingWidth, frameNumber_);
-          GetViewport().windowingPresetCenters_.push_back(windowingCenter);
-          GetViewport().windowingPresetWidths_.push_back(windowingWidth);
-          GetViewport().SetWindowingPreset();
-        }
-
         Apply(GetViewport(), message.GetDicom(), frame.release(), sopInstanceUid_, frameNumber_);
 
         if (isPrefetch_)
@@ -2440,6 +2548,7 @@
       dicom.ExtractDicomSummary(tags, ORTHANC_STONE_MAX_TAG_LENGTH);
 
       OrthancStone::DicomInstanceParameters parameters(tags);
+      viewport.instancesCache_->Store(sopInstanceUid, parameters);
 
       std::unique_ptr<Orthanc::ImageAccessor> converted;
       
@@ -2509,15 +2618,12 @@
   boost::shared_ptr<OrthancStone::WebAssemblyViewport>   viewport_;
   boost::shared_ptr<OrthancStone::DicomResourcesLoader> loader_;
   OrthancStone::DicomSource                    source_;
-  boost::shared_ptr<FramesCache>               framesCache_;  
+  boost::shared_ptr<FramesCache>               framesCache_;
+  boost::shared_ptr<InstancesCache>            instancesCache_;
   std::unique_ptr<IFramesCollection>           frames_;
   std::unique_ptr<SeriesCursor>                cursor_;
-  float                                        windowingCenter_;
-  float                                        windowingWidth_;
-  std::vector<float>                           windowingPresetCenters_;
-  std::vector<float>                           windowingPresetWidths_;
-  float                                        windowingDefaultCenter_;
-  float                                        windowingDefaultWidth_;
+  WindowingTracker                             windowingTracker_;
+  std::vector<OrthancStone::Windowing>         windowingPresets_;
   unsigned int                                 cineRate_;
   bool                                         inverted_;
   bool                                         fitNextContent_;
@@ -2546,6 +2652,37 @@
   std::string pendingSeriesInstanceUid_;
 
 
+  void UpdateWindowing(WindowingState state,
+                       const OrthancStone::Windowing& windowing)
+  {
+    if (windowingTracker_.Update(state, windowing))
+    {
+      UpdateCurrentTextureParameters();
+
+      if (observer_.get() != NULL)
+      {
+        observer_->SignalWindowingUpdated(*this, windowingTracker_.GetWindowing());
+      }
+    }
+  }
+
+
+  void SetDefaultWindowing(const OrthancStone::DicomInstanceParameters& instance)
+  {
+    windowingTracker_.Reset();
+
+    if (instance.GetWindowingPresetsCount() == 0)
+    {
+      LOG(INFO) << "No preset windowing";
+      UpdateWindowing(WindowingState_Fallback, instance.GetFallbackWindowing());
+    }
+    else
+    {
+      UpdateWindowing(WindowingState_GlobalPreset, instance.GetWindowingPreset(0));
+    }
+  }
+
+
   void ScheduleNextPrefetch()
   {
     while (!prefetchQueue_.empty())
@@ -2668,9 +2805,41 @@
 
       case Orthanc::PixelFormat_Float32:
       {
+        {
+          // New in Stone Web viewer 2.2: Deal with Philips multiframe
+          // (cf. mail from Tomas Kenda on 2021-08-17)
+          InstancesCache::Accessor accessor(*instancesCache_, instance.GetSopInstanceUid());
+          OrthancStone::Windowing windowing;
+          if (accessor.IsValid() &&
+              accessor.GetParameters().LookupPerFrameWindowing(windowing, frameIndex))
+          {
+            UpdateWindowing(WindowingState_FramePreset, windowing);
+          }
+        }
+
         std::unique_ptr<OrthancStone::FloatTextureSceneLayer> tmp(
           new OrthancStone::FloatTextureSceneLayer(frame));
-        tmp->SetCustomWindowing(windowingCenter_, windowingWidth_);
+
+        if (windowingTracker_.GetState() == WindowingState_None ||
+            windowingTracker_.GetState() == WindowingState_Fallback)
+        {
+          const Orthanc::ImageAccessor& texture = tmp->GetTexture();
+          if (texture.GetFormat() != Orthanc::PixelFormat_Float32)
+          {
+            throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+          }
+          else
+          {
+            float minValue, maxValue;
+            Orthanc::ImageProcessing::GetMinMaxFloatValue(minValue, maxValue, texture);
+
+            const float center = (minValue + maxValue) / 2.0f;
+            const float width = maxValue - minValue;
+            UpdateWindowing(WindowingState_Fallback, OrthancStone::Windowing(center, width));
+          }
+        }
+
+        tmp->SetCustomWindowing(windowingTracker_.GetWindowing().GetCenter(), windowingTracker_.GetWindowing().GetWidth());
         tmp->SetInverted(inverted_ ^ isMonochrome1);
         layer.reset(tmp.release());
         break;
@@ -3024,14 +3193,14 @@
       std::map<std::string, std::string> headers, arguments;
       // arguments["quality"] = "10";   // Low-level quality for test purpose
       arguments["window"] = (
-        boost::lexical_cast<std::string>(windowingCenter_) + ","  +
-        boost::lexical_cast<std::string>(windowingWidth_) + ",linear");
+        boost::lexical_cast<std::string>(windowingTracker_.GetWindowing().GetCenter()) + ","  +
+        boost::lexical_cast<std::string>(windowingTracker_.GetWindowing().GetWidth()) + ",linear");
 
       std::unique_ptr<OrthancStone::IOracleCommand> command(
         source_.CreateDicomWebCommand(
           uri, arguments, headers, new SetLowQualityFrame(
             GetSharedObserver(), instance.GetSopInstanceUid(), frameNumber,
-            windowingCenter_, windowingWidth_, isMonochrome1, isPrefetch)));
+            windowingTracker_.GetWindowing(), isMonochrome1, isPrefetch)));
 
       {
         std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context_.Lock());
@@ -3051,7 +3220,7 @@
       {
         dynamic_cast<OrthancStone::FloatTextureSceneLayer&>(
           lock->GetController().GetScene().GetLayer(LAYER_TEXTURE)).
-          SetCustomWindowing(windowingCenter_, windowingWidth_);
+          SetCustomWindowing(windowingTracker_.GetWindowing().GetCenter(), windowingTracker_.GetWindowing().GetWidth());
       }
         
       lock->Invalidate();
@@ -3062,13 +3231,13 @@
                  const OrthancStone::DicomSource& source,
                  const std::string& canvas,
                  boost::shared_ptr<FramesCache> cache,
+                 boost::shared_ptr<InstancesCache> instancesCache,
                  bool softwareRendering,
                  bool linearInterpolation) :
     context_(context),
     source_(source),
     framesCache_(cache),
-    windowingDefaultCenter_(128),
-    windowingDefaultWidth_(256),
+    instancesCache_(instancesCache),
     fitNextContent_(true),
     hasFocusOnInstance_(false),
     focusFrameNumber_(0),
@@ -3105,8 +3274,6 @@
     
     emscripten_set_wheel_callback(viewport_->GetCanvasCssSelector().c_str(), this, true, OnWheel);
 
-    SetWindowingPreset();
-
     stoneAnnotations_.reset(new OrthancStone::AnnotationsSceneLayer(LAYER_ANNOTATIONS_STONE));
     stoneAnnotations_->SetProbedLayer(LAYER_TEXTURE);
   }
@@ -3115,13 +3282,7 @@
   void Handle(const OrthancStone::ViewportController::GrayscaleWindowingChanged& message)
   {
     // This event is triggered by the windowing mouse action, from class "GrayscaleWindowingSceneTracker"
-    windowingCenter_ = message.GetWindowingCenter();
-    windowingWidth_ = message.GetWindowingWidth();
-
-    if (observer_.get() != NULL)
-    {
-      observer_->SignalWindowingUpdated(*this, message.GetWindowingCenter(), message.GetWindowingWidth());
-    }
+    UpdateWindowing(WindowingState_User, message.GetWindowing());
   }
 
   
@@ -3264,12 +3425,13 @@
   static boost::shared_ptr<ViewerViewport> Create(OrthancStone::WebAssemblyLoadersContext& context,
                                                   const OrthancStone::DicomSource& source,
                                                   const std::string& canvas,
-                                                  boost::shared_ptr<FramesCache> cache,
+                                                  boost::shared_ptr<FramesCache> framesCache,
+                                                  boost::shared_ptr<InstancesCache> instancesCache,
                                                   bool softwareRendering,
                                                   bool linearInterpolation)
   {
     boost::shared_ptr<ViewerViewport> viewport(
-      new ViewerViewport(context, source, canvas, cache, softwareRendering, linearInterpolation));
+      new ViewerViewport(context, source, canvas, framesCache, instancesCache, softwareRendering, linearInterpolation));
 
     {
       std::unique_ptr<OrthancStone::ILoadersContext::ILock> lock(context.Lock());
@@ -3321,7 +3483,7 @@
 
     frames_.reset(frames);
     cursor_.reset(new SeriesCursor(frames_->GetFramesCount(), false));
-    
+
     if (frames_->GetFramesCount() != 0)
     {
       const OrthancStone::DicomInstanceParameters& firstInstance = frames_->GetInstanceOfFrame(0);
@@ -3341,11 +3503,16 @@
           cursor_.reset(new SeriesCursor(frames_->GetFramesCount(), true));
         }
       }
+
+      SetDefaultWindowing(firstInstance);
+    }
+    else
+    {
+      windowingTracker_.Reset();
     }
 
     LOG(INFO) << "Number of frames in series: " << frames_->GetFramesCount();
 
-    SetWindowingPreset();
     ClearViewport();
     prefetchQueue_.clear();
 
@@ -3615,33 +3782,6 @@
   }
 
 
-  void SetWindowingPreset()
-  {
-    assert(windowingPresetCenters_.size() == windowingPresetWidths_.size());
-
-    if (windowingPresetCenters_.empty())
-    {
-      SetWindowing(windowingDefaultCenter_, windowingDefaultWidth_);
-    }
-    else
-    {
-      SetWindowing(windowingPresetCenters_[0], windowingPresetWidths_[0]);
-    }
-  }
-
-  void SetWindowing(float windowingCenter,
-                    float windowingWidth)
-  {
-    windowingCenter_ = windowingCenter;
-    windowingWidth_ = windowingWidth;
-    UpdateCurrentTextureParameters();
-
-    if (observer_.get() != NULL)
-    {
-      observer_->SignalWindowingUpdated(*this, windowingCenter, windowingWidth);
-    }
-  }
-
   void StretchWindowing()
   {
     float minValue, maxValue;
@@ -3667,7 +3807,9 @@
       Orthanc::ImageProcessing::GetMinMaxFloatValue(minValue, maxValue, texture);
     }
 
-    SetWindowing((minValue + maxValue) / 2.0f, maxValue - minValue);
+    const float center = (minValue + maxValue) / 2.0f;
+    const float width = maxValue - minValue;
+    UpdateWindowing(WindowingState_User, OrthancStone::Windowing(center, width));
   }
 
   void FlipX()
@@ -3959,17 +4101,15 @@
 
   void FormatWindowingPresets(Json::Value& target) const
   {
-    assert(windowingPresetCenters_.size() == windowingPresetWidths_.size());
-
     target = Json::arrayValue;
 
-    for (size_t i = 0; i < windowingPresetCenters_.size(); i++)
-    {
-      const float c = windowingPresetCenters_[i];
-      const float w = windowingPresetWidths_[i];
+    for (size_t i = 0; i < windowingPresets_.size(); i++)
+    {
+      const double c = windowingPresets_[i].GetCenter();
+      const double w = windowingPresets_[i].GetWidth();
       
       std::string name = "Preset";
-      if (windowingPresetCenters_.size() > 1)
+      if (windowingPresets_.size() > 1)
       {
         name += " " + boost::lexical_cast<std::string>(i + 1);
       }
@@ -4052,6 +4192,12 @@
   }
 
 
+  void SetUserWindowing(const OrthancStone::Windowing& windowing)
+  {
+    UpdateWindowing(WindowingState_User, windowing);
+  }
+
+
   void SetPendingSeriesInstanceUid(const std::string& seriesInstanceUid)
   {
     pendingSeriesInstanceUid_ = seriesInstanceUid;
@@ -4274,8 +4420,7 @@
   }
 
   virtual void SignalWindowingUpdated(const ViewerViewport& viewport,
-                                      double windowingCenter,
-                                      double windowingWidth) ORTHANC_OVERRIDE
+                                      const OrthancStone::Windowing& windowing) ORTHANC_OVERRIDE
   {
     EM_ASM({
         const customEvent = document.createEvent("CustomEvent");
@@ -4286,8 +4431,8 @@
         window.dispatchEvent(customEvent);
       },
       viewport.GetCanvasId().c_str(),
-      static_cast<int>(boost::math::iround<double>(windowingCenter)),
-      static_cast<int>(boost::math::iround<double>(windowingWidth)));
+      static_cast<int>(boost::math::iround<double>(windowing.GetCenter())),
+      static_cast<int>(boost::math::iround<double>(windowing.GetWidth())));
 
     UpdateReferenceLines();
   }
@@ -4359,6 +4504,7 @@
 
 static OrthancStone::DicomSource source_;
 static boost::shared_ptr<FramesCache> framesCache_;
+static boost::shared_ptr<InstancesCache> instancesCache_;
 static boost::shared_ptr<OrthancStone::WebAssemblyLoadersContext> context_;
 static std::string stringBuffer_;
 static bool softwareRendering_ = false;
@@ -4409,7 +4555,7 @@
   if (found == allViewports_.end())
   {
     boost::shared_ptr<ViewerViewport> viewport(
-      ViewerViewport::Create(*context_, source_, canvas, framesCache_, softwareRendering_, linearInterpolation_));
+      ViewerViewport::Create(*context_, source_, canvas, framesCache_, instancesCache_, softwareRendering_, linearInterpolation_));
     viewport->SetMouseButtonActions(leftButtonAction_, middleButtonAction_, rightButtonAction_);
     viewport->AcquireObserver(new WebAssemblyObserver);
     viewport->SetOsiriXAnnotations(osiriXAnnotations_);
@@ -4460,6 +4606,7 @@
     context_->SetDicomCacheSize(128 * 1024 * 1024);  // 128MB
     
     framesCache_.reset(new FramesCache);
+    instancesCache_.reset(new InstancesCache);
     osiriXAnnotations_.reset(new OrthancStone::OsiriX::CollectionOfAnnotations);
 
     DISPATCH_JAVASCRIPT_EVENT("StoneInitialized");
@@ -4891,7 +5038,7 @@
   {
     try
     {
-      GetViewport(canvas)->SetWindowing(center, width);
+      GetViewport(canvas)->SetUserWindowing(OrthancStone::Windowing(center, width));
     }
     EXTERN_CATCH_EXCEPTIONS;
   }  
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake
--- a/OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Resources/CMake/OrthancStoneConfiguration.cmake	Tue Oct 22 15:56:08 2024 +0200
@@ -451,6 +451,8 @@
   ${ORTHANC_STONE_ROOT}/Toolbox/UndoRedoStack.h
   ${ORTHANC_STONE_ROOT}/Toolbox/UnionOfRectangles.cpp
   ${ORTHANC_STONE_ROOT}/Toolbox/UnionOfRectangles.h
+  ${ORTHANC_STONE_ROOT}/Toolbox/Windowing.cpp
+  ${ORTHANC_STONE_ROOT}/Toolbox/Windowing.h
   
   ${ORTHANC_STONE_ROOT}/Viewport/DefaultViewportInteractor.cpp
   ${ORTHANC_STONE_ROOT}/Viewport/IViewport.h
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Loaders/SeriesFramesLoader.cpp
--- a/OrthancStone/Sources/Loaders/SeriesFramesLoader.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Loaders/SeriesFramesLoader.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -47,8 +47,7 @@
     std::string   sopInstanceUid_;  // Only used for debug purpose
     unsigned int  quality_;
     bool          hasWindowing_;
-    float         windowingCenter_;
-    float         windowingWidth_;
+    Windowing     windowing_;
     std::unique_ptr<Orthanc::IDynamicObject>  userPayload_;
 
   public:
@@ -62,8 +61,6 @@
       sopInstanceUid_(sopInstanceUid),
       quality_(quality),
       hasWindowing_(false),
-      windowingCenter_(0),
-      windowingWidth_(0),
       userPayload_(userPayload)
     {
     }
@@ -83,12 +80,10 @@
       return quality_;
     }
 
-    void SetWindowing(float center,
-                      float width)
+    void SetWindowing(const Windowing& windowing)
     {
       hasWindowing_ = true;
-      windowingCenter_ = center;
-      windowingWidth_ = width;
+      windowing_ = windowing;
     }
 
     bool HasWindowing() const
@@ -96,23 +91,11 @@
       return hasWindowing_;
     }
 
-    float GetWindowingCenter() const
+    const Windowing& GetWindowing() const
     {
       if (hasWindowing_)
       {
-        return windowingCenter_;
-      }
-      else
-      {
-        throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
-      }
-    }
-
-    float GetWindowingWidth() const
-    {
-      if (hasWindowing_)
-      {
-        return windowingWidth_;
+        return windowing_;
       }
       else
       {
@@ -227,13 +210,13 @@
         Orthanc::Image scaled(parameters.GetExpectedPixelFormat(), reader.GetWidth(), reader.GetHeight(), false);
         Orthanc::ImageProcessing::Convert(scaled, reader);
           
-        float w = payload.GetWindowingWidth();
+        float w = static_cast<float>(payload.GetWindowing().GetWidth());
         if (w <= 0.01f)
         {
           w = 0.01f;  // Prevent division by zero
         }
 
-        const float c = payload.GetWindowingCenter();
+        const float c = static_cast<float>(payload.GetWindowing().GetCenter());
         const float scaling = w / 255.0f;
         const float offset = (c - w / 2.0f) / scaling;
 
@@ -417,16 +400,15 @@
       {
         const DicomInstanceParameters& parameters = frames_.GetInstanceParameters(index);
 
-        float c, w;
-        parameters.GetWindowingPresetsUnion(c, w);
+        Windowing windowing = parameters.GetWindowingPresetsUnion();
 
         std::map<std::string, std::string> arguments, headers;
-        arguments["window"] = (boost::lexical_cast<std::string>(c) + "," +
-                               boost::lexical_cast<std::string>(w) + ",linear");
+        arguments["window"] = (boost::lexical_cast<std::string>(windowing.GetCenter()) + "," +
+                               boost::lexical_cast<std::string>(windowing.GetWidth()) + ",linear");
         headers["Accept"] = "image/jpeg";
 
         std::unique_ptr<Payload> payload(new Payload(source, index, sopInstanceUid, quality, protection.release()));
-        payload->SetWindowing(c, w);
+        payload->SetWindowing(windowing);
 
         {
           std::unique_ptr<ILoadersContext::ILock> lock(context_.Lock());
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Scene2D/GrayscaleWindowingSceneTracker.cpp
--- a/OrthancStone/Sources/Scene2D/GrayscaleWindowingSceneTracker.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Scene2D/GrayscaleWindowingSceneTracker.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -89,7 +89,7 @@
       {
         if (lock_.get() != NULL)
         {
-          lock_->GetController().BroadcastGrayscaleWindowingChanged(center, width);
+          lock_->GetController().BroadcastGrayscaleWindowingChanged(Windowing(center, width));
         }
       }        
     };
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Scene2DViewport/ViewportController.cpp
--- a/OrthancStone/Sources/Scene2DViewport/ViewportController.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Scene2DViewport/ViewportController.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -151,10 +151,9 @@
     BroadcastMessage(SceneTransformChanged(*this));
   }
 
-  void ViewportController::BroadcastGrayscaleWindowingChanged(double windowingCenter,
-                                                              double windowingWidth)
+  void ViewportController::BroadcastGrayscaleWindowingChanged(const Windowing& windowing)
   {
-    BroadcastMessage(GrayscaleWindowingChanged(*this, windowingCenter, windowingWidth));
+    BroadcastMessage(GrayscaleWindowingChanged(*this, windowing));
   }
 
   void ViewportController::FitContent(unsigned int viewportWidth,
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Scene2DViewport/ViewportController.h
--- a/OrthancStone/Sources/Scene2DViewport/ViewportController.h	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Scene2DViewport/ViewportController.h	Tue Oct 22 15:56:08 2024 +0200
@@ -27,6 +27,7 @@
 #include "../Messages/IObservable.h"
 #include "../Scene2D/Scene2D.h"
 #include "../Scene2DViewport/IFlexiblePointerTracker.h"
+#include "../Toolbox/Windowing.h"
 #include "../Viewport/IViewportInteractor.h"
 
 #include <Compatibility.h>
@@ -94,27 +95,19 @@
       ORTHANC_STONE_MESSAGE(__FILE__, __LINE__);
       
     private:
-      double  windowingCenter_;
-      double  windowingWidth_;
+      Windowing windowing_;
       
     public:
       GrayscaleWindowingChanged(const ViewportController& origin,
-                                double windowingCenter,
-                                double windowingWidth) :
+                                const Windowing& windowing) :
         OriginMessage(origin),
-        windowingCenter_(windowingCenter),
-        windowingWidth_(windowingWidth)        
+        windowing_(windowing)
       {
       }
 
-      double GetWindowingCenter() const
+      const Windowing& GetWindowing() const
       {
-        return windowingCenter_;
-      }
-
-      double GetWindowingWidth() const
-      {
-        return windowingWidth_;
+        return windowing_;
       }
     };
 
@@ -155,8 +148,7 @@
     void SetSceneToCanvasTransform(const AffineTransform2D& transform);
 
     /** Info broadcasted to the observers */
-    void BroadcastGrayscaleWindowingChanged(double windowingCenter,
-                                            double windowingWidth);
+    void BroadcastGrayscaleWindowingChanged(const Windowing& windowing);
 
     /** Forwarded to the underlying scene, and broadcasted to the observers */
     void FitContent(unsigned int viewportWidth,
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Toolbox/DebugDrawing2D.cpp
--- a/OrthancStone/Sources/Toolbox/DebugDrawing2D.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Toolbox/DebugDrawing2D.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -23,6 +23,8 @@
 
 #include "DebugDrawing2D.h"
 
+#include <stdio.h>
+
 
 namespace OrthancStone
 {
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp
--- a/OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Toolbox/DicomInstanceParameters.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -32,6 +32,7 @@
 #include <Images/ImageProcessing.h>
 #include <Logging.h>
 #include <OrthancException.h>
+#include <SerializationToolbox.h>
 #include <Toolbox.h>
 
 
@@ -190,29 +191,29 @@
       }
     }
 
-    bool ok = false;
+
+    windowingPresets_.clear();
+
+    Vector centers, widths;
     
-    if (LinearAlgebra::ParseVector(windowingPresetCenters_, dicom, Orthanc::DICOM_TAG_WINDOW_CENTER) &&
-        LinearAlgebra::ParseVector(windowingPresetWidths_, dicom, Orthanc::DICOM_TAG_WINDOW_WIDTH))
+    if (LinearAlgebra::ParseVector(centers, dicom, Orthanc::DICOM_TAG_WINDOW_CENTER) &&
+        LinearAlgebra::ParseVector(widths, dicom, Orthanc::DICOM_TAG_WINDOW_WIDTH))
     {
-      if (windowingPresetCenters_.size() == windowingPresetWidths_.size())
+      if (centers.size() == widths.size())
       {
-        ok = true;
+        windowingPresets_.resize(centers.size());
+
+        for (size_t i = 0; i < centers.size(); i++)
+        {
+          windowingPresets_[i] = Windowing(centers[i], widths[i]);
+        }
       }
       else
       {
         LOG(ERROR) << "Mismatch in the number of preset windowing widths/centers, ignoring this";
-        ok = false;
       }
     }
 
-    if (!ok)
-    {
-      // Don't use "Vector::clear()", as it has not the same meaning as "std::vector::clear()"
-      windowingPresetCenters_.resize(0);
-      windowingPresetWidths_.resize(0);
-    }      
-
     // This computes the "IndexInSeries" metadata from Orthanc (check
     // out "Orthanc::ServerIndex::Store()")
     hasIndexInSeries_ = (
@@ -230,6 +231,65 @@
     {
       instanceNumber_ = 0;
     }
+
+
+    static const Orthanc::DicomTag DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE(0x5200, 0x9230);
+    static const Orthanc::DicomTag DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE(0x0028, 0x9132);
+
+    const Orthanc::DicomValue* frames = dicom.TestAndGetValue(DICOM_TAG_PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE);
+    if (frames != NULL &&
+        hasNumberOfFrames_ &&
+        frames->IsSequence())
+    {
+      /**
+       * New in Stone Web viewer 2.2: Deal with Philips multiframe
+       * (cf. mail from Tomas Kenda on 2021-08-17). This cannot be done
+       * in LoadSeriesDetailsFromInstance, as the "Per Frame Functional Groups Sequence"
+       * is not available at that point.
+       **/
+
+      const Json::Value& sequence = frames->GetSequenceContent();
+
+      perFrameWindowing_.resize(numberOfFrames_);
+
+      // This corresponds to "ParsedDicomFile::GetDefaultWindowing()"
+      for (Json::ArrayIndex i = 0; i < sequence.size(); i++)
+      {
+        if (i < numberOfFrames_ &&
+            sequence[i].isMember(DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE.Format()))
+        {
+          const Json::Value& v = sequence[i][DICOM_TAG_FRAME_VOI_LUT_SEQUENCE_ATTRIBUTE.Format()];
+
+          static const char* KEY_VALUE = "Value";
+
+          if (v.isMember(KEY_VALUE) &&
+              v[KEY_VALUE].type() == Json::arrayValue &&
+              v[KEY_VALUE].size() >= 1 &&
+              v[KEY_VALUE][0].isMember(Orthanc::DICOM_TAG_WINDOW_CENTER.Format()) &&
+              v[KEY_VALUE][0].isMember(Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()) &&
+              v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()].isMember(KEY_VALUE) &&
+              v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()].isMember(KEY_VALUE))
+          {
+            const Json::Value& scenter = v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()][KEY_VALUE];
+            const Json::Value& swidth = v[KEY_VALUE][0][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()][KEY_VALUE];
+
+            double center, width;
+            if (scenter.isString() &&
+                swidth.isString() &&
+                Orthanc::SerializationToolbox::ParseDouble(center, scenter.asString()) &&
+                Orthanc::SerializationToolbox::ParseDouble(width, swidth.asString()))
+            {
+              perFrameWindowing_[i] = Windowing(center, width);
+            }
+            else if (scenter.isNumeric() &&
+                     swidth.isNumeric())
+            {
+              perFrameWindowing_[i] = Windowing(scenter.asDouble(), swidth.asDouble());
+            }
+          }
+        }
+      }
+    }
   }
 
 
@@ -399,18 +459,45 @@
   }
 
 
+  Windowing DicomInstanceParameters::GetFallbackWindowing() const
+  {
+    double a, b;
+    if (tags_->ParseDouble(a, Orthanc::DICOM_TAG_SMALLEST_IMAGE_PIXEL_VALUE) &&
+        tags_->ParseDouble(b, Orthanc::DICOM_TAG_LARGEST_IMAGE_PIXEL_VALUE))
+    {
+      const double center = (a + b) / 2.0f;
+      const double width = (b - a);
+      return Windowing(center, width);
+    }
+
+    // Added in Stone Web viewer > 2.5
+    uint32_t bitsStored, pixelRepresentation;
+    if (tags_->ParseUnsignedInteger32(bitsStored, Orthanc::DICOM_TAG_BITS_STORED) &&
+        tags_->ParseUnsignedInteger32(pixelRepresentation, Orthanc::DICOM_TAG_PIXEL_REPRESENTATION))
+    {
+      const bool isSigned = (pixelRepresentation != 0);
+      const float maximum = powf(2.0, bitsStored);
+      return Windowing(isSigned ? 0.0f : maximum / 2.0f, maximum);
+    }
+    else
+    {
+      // Cannot infer a suitable windowing from the available tags
+      return Windowing();
+    }
+  }
+
+
   size_t DicomInstanceParameters::GetWindowingPresetsCount() const
   {
-    assert(data_.windowingPresetCenters_.size() == data_.windowingPresetWidths_.size());
-    return data_.windowingPresetCenters_.size();
+    return data_.windowingPresets_.size();
   }
   
 
-  float DicomInstanceParameters::GetWindowingPresetCenter(size_t i) const
+  Windowing DicomInstanceParameters::GetWindowingPreset(size_t i) const
   {
     if (i < GetWindowingPresetsCount())
     {
-      return static_cast<float>(data_.windowingPresetCenters_[i]);
+      return data_.windowingPresets_[i];
     }
     else
     {
@@ -418,32 +505,8 @@
     }
   }
 
-
-  float DicomInstanceParameters::GetWindowingPresetWidth(size_t i) const
-  {
-    if (i < GetWindowingPresetsCount())
-    {
-      return static_cast<float>(data_.windowingPresetWidths_[i]);
-    }
-    else
-    {
-      throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
-    }
-  }
-
-
-  static void GetWindowingBounds(float& low,
-                                 float& high,
-                                 double center,  // in
-                                 double width)   // in
-  {
-    low = static_cast<float>(center - width / 2.0);
-    high = static_cast<float>(center + width / 2.0);
-  }
-
   
-  void DicomInstanceParameters::GetWindowingPresetsUnion(float& center,
-                                                         float& width) const
+  Windowing DicomInstanceParameters::GetWindowingPresetsUnion() const
   {
     assert(tags_.get() != NULL);
     size_t s = GetWindowingPresetsCount();
@@ -452,48 +515,29 @@
     {
       // Use the largest windowing given all the preset windowings
       // that are available in the DICOM tags
-      float low, high;
-      GetWindowingBounds(low, high, GetWindowingPresetCenter(0), GetWindowingPresetWidth(0));
+      double low, high;
+      GetWindowingPreset(0).GetBounds(low, high);
 
       for (size_t i = 1; i < s; i++)
       {
-        float a, b;
-        GetWindowingBounds(a, b, GetWindowingPresetCenter(i), GetWindowingPresetWidth(i));
+        double a, b;
+        GetWindowingPreset(i).GetBounds(a, b);
         low = std::min(low, a);
         high = std::max(high, b);
       }
 
       assert(low <= high);
 
-      if (LinearAlgebra::IsNear(low, high))
+      if (!LinearAlgebra::IsNear(low, high))
       {
-        // Cannot infer a suitable windowing from the available tags
-        center = 128.0f;
-        width = 256.0f;
-      }
-      else
-      {
-        center = (low + high) / 2.0f;
-        width = (high - low);
+        const double center = (low + high) / 2.0f;
+        const double width = (high - low);
+        return Windowing(center, width);
       }
     }
-    else
-    {
-      float a, b;
-      if (tags_->ParseFloat(a, Orthanc::DICOM_TAG_SMALLEST_IMAGE_PIXEL_VALUE) &&
-          tags_->ParseFloat(b, Orthanc::DICOM_TAG_LARGEST_IMAGE_PIXEL_VALUE) &&
-          a < b)
-      {
-        center = (a + b) / 2.0f;
-        width = (b - a);
-      }
-      else
-      {
-        // Cannot infer a suitable windowing from the available tags
-        center = 128.0f;
-        width = 256.0f;
-      }
-    }
+
+    // No preset, or presets with an empty range
+    return GetFallbackWindowing();
   }
 
 
@@ -565,7 +609,8 @@
 
       if (GetWindowingPresetsCount() > 0)
       {
-        floatTexture.SetCustomWindowing(GetWindowingPresetCenter(0), GetWindowingPresetWidth(0));
+        Windowing preset = GetWindowingPreset(0);
+        floatTexture.SetCustomWindowing(preset.GetCenter(), preset.GetWidth());
       }
       
       switch (GetImageInformation().GetPhotometricInterpretation())
@@ -839,4 +884,19 @@
       return (data_.frameOffsets_[0] > data_.frameOffsets_[1]);
     }
   }
+
+
+  bool DicomInstanceParameters::LookupPerFrameWindowing(Windowing& windowing,
+                                                        unsigned int frame) const
+  {
+    if (frame < data_.perFrameWindowing_.size())
+    {
+      windowing = data_.perFrameWindowing_[frame];
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
 }
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Toolbox/DicomInstanceParameters.h
--- a/OrthancStone/Sources/Toolbox/DicomInstanceParameters.h	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/Sources/Toolbox/DicomInstanceParameters.h	Tue Oct 22 15:56:08 2024 +0200
@@ -26,6 +26,7 @@
 #include "../Scene2D/LookupTableTextureSceneLayer.h"
 #include "../StoneEnumerations.h"
 #include "../Toolbox/CoordinateSystem3D.h"
+#include "Windowing.h"
 
 #include <IDynamicObject.h>
 #include <DicomFormat/DicomImageInformation.h>
@@ -57,8 +58,7 @@
       bool                hasRescale_;
       double              rescaleIntercept_;
       double              rescaleSlope_;
-      Vector              windowingPresetCenters_;
-      Vector              windowingPresetWidths_;
+      std::vector<Windowing>  windowingPresets_;
       bool                hasIndexInSeries_;
       unsigned int        indexInSeries_;
       std::string         doseUnits_;
@@ -67,6 +67,7 @@
       bool                hasPixelSpacing_;
       bool                hasNumberOfFrames_;
       int32_t             instanceNumber_;
+      std::vector<Windowing>  perFrameWindowing_;
 
       explicit Data(const Orthanc::DicomMap& dicom);
     };
@@ -185,14 +186,13 @@
 
     double GetRescaleSlope() const;
 
+    Windowing GetFallbackWindowing() const;
+
     size_t GetWindowingPresetsCount() const;
 
-    float GetWindowingPresetCenter(size_t i) const;
+    Windowing GetWindowingPreset(size_t i) const;
 
-    float GetWindowingPresetWidth(size_t i) const;
-
-    void GetWindowingPresetsUnion(float& center,
-                                  float& width) const;
+    Windowing GetWindowingPresetsUnion() const;
 
     Orthanc::PixelFormat GetExpectedPixelFormat() const;
 
@@ -267,5 +267,8 @@
     CoordinateSystem3D GetMultiFrameGeometry() const;
 
     bool IsReversedFrameOffsets() const;
+
+    bool LookupPerFrameWindowing(Windowing& windowing,
+                                 unsigned int frame) const;
   };
 }
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Toolbox/Windowing.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OrthancStone/Sources/Toolbox/Windowing.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -0,0 +1,52 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2023 Osimis S.A., Belgium
+ * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see
+ * <http://www.gnu.org/licenses/>.
+ **/
+
+
+#include "Windowing.h"
+
+#include "LinearAlgebra.h"
+
+
+namespace OrthancStone
+{
+  Windowing::Windowing(double center,
+                       double width)
+  {
+    center_ = center;
+    width_ = std::abs(width);
+  }
+
+
+  void Windowing::GetBounds(double& low,
+                            double& high) const
+  {
+    low = center_ - width_ / 2.0;
+    high = center_ + width_ / 2.0;
+  }
+
+
+  bool Windowing::IsNear(const Windowing& other) const
+  {
+    return (LinearAlgebra::IsNear(center_, other.center_) &&
+            LinearAlgebra::IsNear(width_, other.width_));
+  }
+}
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/Sources/Toolbox/Windowing.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OrthancStone/Sources/Toolbox/Windowing.h	Tue Oct 22 15:56:08 2024 +0200
@@ -0,0 +1,59 @@
+/**
+ * Stone of Orthanc
+ * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
+ * Department, University Hospital of Liege, Belgium
+ * Copyright (C) 2017-2023 Osimis S.A., Belgium
+ * Copyright (C) 2021-2024 Sebastien Jodogne, ICTEAM UCLouvain, Belgium
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program. If not, see
+ * <http://www.gnu.org/licenses/>.
+ **/
+
+
+#pragma once
+
+namespace OrthancStone
+{
+  class Windowing
+  {
+  private:
+    double  center_;
+    double  width_;
+
+  public:
+    Windowing() :
+      center_(128),
+      width_(256)
+    {
+    }
+
+    Windowing(double center,
+              double width);
+
+    double GetCenter() const
+    {
+      return center_;
+    }
+
+    double GetWidth() const
+    {
+      return width_;
+    }
+
+    void GetBounds(double& low,
+                   double& high) const;
+
+    bool IsNear(const Windowing& other) const;
+  };
+}
diff -r e65fe2e50fde -r 4596ad1b2aa4 OrthancStone/UnitTestsSources/DicomTests.cpp
--- a/OrthancStone/UnitTestsSources/DicomTests.cpp	Fri Sep 27 22:34:17 2024 +0200
+++ b/OrthancStone/UnitTestsSources/DicomTests.cpp	Tue Oct 22 15:56:08 2024 +0200
@@ -66,13 +66,11 @@
   ASSERT_THROW(p->GetRescaleIntercept(), Orthanc::OrthancException);
   ASSERT_THROW(p->GetRescaleSlope(), Orthanc::OrthancException);
   ASSERT_EQ(0u, p->GetWindowingPresetsCount());
-  ASSERT_THROW(p->GetWindowingPresetCenter(0), Orthanc::OrthancException);
-  ASSERT_THROW(p->GetWindowingPresetWidth(0), Orthanc::OrthancException);
+  ASSERT_THROW(p->GetWindowingPreset(0), Orthanc::OrthancException);
 
-  float c, w;
-  p->GetWindowingPresetsUnion(c, w);
-  ASSERT_FLOAT_EQ(128.0f, c);
-  ASSERT_FLOAT_EQ(256.0f, w);
+  OrthancStone::Windowing w = p->GetWindowingPresetsUnion();
+  ASSERT_FLOAT_EQ(128.0f, w.GetCenter());
+  ASSERT_FLOAT_EQ(256.0f, w.GetWidth());
 
   ASSERT_THROW(p->GetExpectedPixelFormat(), Orthanc::OrthancException);
   ASSERT_FALSE(p->HasIndexInSeries());
@@ -96,20 +94,19 @@
 
   OrthancStone::DicomInstanceParameters p(m);
   ASSERT_EQ(3u, p.GetWindowingPresetsCount());
-  ASSERT_FLOAT_EQ(10, p.GetWindowingPresetCenter(0));
-  ASSERT_FLOAT_EQ(100, p.GetWindowingPresetCenter(1));
-  ASSERT_FLOAT_EQ(1000, p.GetWindowingPresetCenter(2));
-  ASSERT_FLOAT_EQ(50, p.GetWindowingPresetWidth(0));
-  ASSERT_FLOAT_EQ(60, p.GetWindowingPresetWidth(1));
-  ASSERT_FLOAT_EQ(70, p.GetWindowingPresetWidth(2));
+  ASSERT_FLOAT_EQ(10, p.GetWindowingPreset(0).GetCenter());
+  ASSERT_FLOAT_EQ(100, p.GetWindowingPreset(1).GetCenter());
+  ASSERT_FLOAT_EQ(1000, p.GetWindowingPreset(2).GetCenter());
+  ASSERT_FLOAT_EQ(50, p.GetWindowingPreset(0).GetWidth());
+  ASSERT_FLOAT_EQ(60, p.GetWindowingPreset(1).GetWidth());
+  ASSERT_FLOAT_EQ(70, p.GetWindowingPreset(2).GetWidth());
 
   const float a = 10.0f - 50.0f / 2.0f;
   const float b = 1000.0f + 70.0f / 2.0f;
   
-  float c, w;
-  p.GetWindowingPresetsUnion(c, w);
-  ASSERT_FLOAT_EQ((a + b) / 2.0f, c);
-  ASSERT_FLOAT_EQ(b - a, w);
+  OrthancStone::Windowing w = p.GetWindowingPresetsUnion();
+  ASSERT_FLOAT_EQ((a + b) / 2.0f, w.GetCenter());
+  ASSERT_FLOAT_EQ(b - a, w.GetWidth());
 }
 
 
diff -r e65fe2e50fde -r 4596ad1b2aa4 TODO
--- a/TODO	Fri Sep 27 22:34:17 2024 +0200
+++ b/TODO	Tue Oct 22 15:56:08 2024 +0200
@@ -45,9 +45,6 @@
 * Order the studies in the left column according to their Instance
   Number (0020,0013). Suggestion by Joseph Maratt.
 
-* Add a button to download PDF:
-  https://discourse.orthanc-server.org/t/printing-pdf-reports-in-stone-of-orthanc/4731
-
 * Open using Orthanc parent/study/series identifier, or using DICOM
   accession number:
   https://discourse.orthanc-server.org/t/stone-web-viewer-what-is-the-link-to-use-through-the-access-number/4808