orthanc-stone: Applications/Samples/SingleFrameEditorApplication.h comparison

comparison Applications/Samples/SingleFrameEditorApplication.h @ 407:842a3c7cfdc0

renames

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Mon, 12 Nov 2018 11:44:20 +0100
parents	99e31898910e
children	6834c236b36d

comparison

equal deleted inserted replaced

-:5d359b115b29
+:842a3c7cfdc0
 #include <Core/OrthancException.h>
 #include <Core/Toolbox.h>
 #include <Plugins/Samples/Common/DicomDatasetReader.h>
 #include <Plugins/Samples/Common/FullOrthancDataset.h>
+// Export using PAM is faster than using PNG, but requires Orthanc
+// core >= 1.4.3
 #define EXPORT_USING_PAM  1
 #include <boost/math/constants/constants.hpp>
 #include <boost/math/special_functions/round.hpp>
 namespace OrthancStone
 {
-class BitmapStack :
+class RadiologyScene :
 public IObserver,
 public IObservable
 {
 public:
-typedef OriginMessage<MessageType_Widget_GeometryChanged, BitmapStack> GeometryChangedMessage;
+typedef OriginMessage<MessageType_Widget_GeometryChanged, RadiologyScene> GeometryChangedMessage;
-typedef OriginMessage<MessageType_Widget_ContentChanged, BitmapStack> ContentChangedMessage;
+typedef OriginMessage<MessageType_Widget_ContentChanged, RadiologyScene> ContentChangedMessage;
 enum Corner
 {
 Corner_TopLeft,
 Corner_BottomRight
 };
-class Bitmap : public boost::noncopyable
+class Layer : public boost::noncopyable
 {
+friend class RadiologyScene;
 private:
 size_t        index_;
 bool          hasSize_;
 unsigned int  width_;
 unsigned int  height_;
 ApplyTransform(x, y, transform_);
 }
+void SetIndex(size_t index)
+{
+index_ = index;
+}
+bool Contains(double x,
+double y) const
+{
+ApplyTransform(x, y, transformInverse_);
+unsigned int cropX, cropY, cropWidth, cropHeight;
+GetCrop(cropX, cropY, cropWidth, cropHeight);
+return (x >= cropX && x <= cropX + cropWidth &&
+y >= cropY && y <= cropY + cropHeight);
+}
+void DrawBorders(CairoContext& context,
+double zoom)
+{
+unsigned int cx, cy, width, height;
+GetCrop(cx, cy, width, height);
+double dx = static_cast<double>(cx);
+double dy = static_cast<double>(cy);
+double dwidth = static_cast<double>(width);
+double dheight = static_cast<double>(height);
+cairo_t* cr = context.GetObject();
+cairo_set_line_width(cr, 2.0 / zoom);
+double x, y;
+x = dx;
+y = dy;
+ApplyTransform(x, y, transform_);
+cairo_move_to(cr, x, y);
+x = dx + dwidth;
+y = dy;
+ApplyTransform(x, y, transform_);
+cairo_line_to(cr, x, y);
+x = dx + dwidth;
+y = dy + dheight;
+ApplyTransform(x, y, transform_);
+cairo_line_to(cr, x, y);
+x = dx;
+y = dy + dheight;
+ApplyTransform(x, y, transform_);
+cairo_line_to(cr, x, y);
+x = dx;
+y = dy;
+ApplyTransform(x, y, transform_);
+cairo_line_to(cr, x, y);
+cairo_stroke(cr);
+}
+static double Square(double x)
+{
+return x * x;
+}
 public:
-Bitmap() :
+Layer() :
 index_(0),
 hasSize_(false),
 width_(0),
 height_(0),
 hasCrop_(false),
 resizeable_(false)
 {
 UpdateTransform();
 }
-virtual ~Bitmap()
+virtual ~Layer()
 {
-}
-void SetIndex(size_t index)
-{
-index_ = index;
 }
 size_t GetIndex() const
 {
 return index_;
 {
 return height_;
 }
-void CheckSize(unsigned int width,
-unsigned int height)
-{
-if (hasSize_ &&
-(width != width_ ||
-height != height_))
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageSize);
-}
-}
 Extent2D GetExtent() const
 {
 Extent2D extent;
 unsigned int x, y, width, height;
 return extent;
 }
-bool Contains(double x,
-double y) const
-{
-ApplyTransform(x, y, transformInverse_);
-unsigned int cropX, cropY, cropWidth, cropHeight;
-GetCrop(cropX, cropY, cropWidth, cropHeight);
-return (x >= cropX && x <= cropX + cropWidth &&
-y >= cropY && y <= cropY + cropHeight);
-}
 bool GetPixel(unsigned int& imageX,
 unsigned int& imageY,
 double sceneX,
 double sceneY) const
 {
 double& centerY) const
 {
 centerX = static_cast<double>(width_) / 2.0;
 centerY = static_cast<double>(height_) / 2.0;
 ApplyTransform(centerX, centerY, transform_);
-}
-void DrawBorders(CairoContext& context,
-double zoom)
-{
-unsigned int cx, cy, width, height;
-GetCrop(cx, cy, width, height);
-double dx = static_cast<double>(cx);
-double dy = static_cast<double>(cy);
-double dwidth = static_cast<double>(width);
-double dheight = static_cast<double>(height);
-cairo_t* cr = context.GetObject();
-cairo_set_line_width(cr, 2.0 / zoom);
-double x, y;
-x = dx;
-y = dy;
-ApplyTransform(x, y, transform_);
-cairo_move_to(cr, x, y);
-x = dx + dwidth;
-y = dy;
-ApplyTransform(x, y, transform_);
-cairo_line_to(cr, x, y);
-x = dx + dwidth;
-y = dy + dheight;
-ApplyTransform(x, y, transform_);
-cairo_line_to(cr, x, y);
-x = dx;
-y = dy + dheight;
-ApplyTransform(x, y, transform_);
-cairo_line_to(cr, x, y);
-x = dx;
-y = dy;
-ApplyTransform(x, y, transform_);
-cairo_line_to(cr, x, y);
-cairo_stroke(cr);
-}
-static double Square(double x)
-{
-return x * x;
 }
 void GetCorner(double& x /* out */,
 double& y /* out */,
 {
 resizeable_ = resizeable;
 }
 virtual bool GetDefaultWindowing(float& center,
-float& width) const
+float& width) const = 0;
-{
-return false;
-}
 virtual void Render(Orthanc::ImageAccessor& buffer,
 const Matrix& viewTransform,
 ImageInterpolation interpolation) const = 0;
 virtual bool GetRange(float& minValue,
 float& maxValue) const = 0;
 };
-class BitmapAccessor : public boost::noncopyable
+class LayerAccessor : public boost::noncopyable
 {
 private:
-BitmapStack&  stack_;
+RadiologyScene&  scene_;
-size_t        index_;
+size_t           index_;
-Bitmap*       bitmap_;
+Layer*           layer_;
 public:
-BitmapAccessor(BitmapStack& stack,
+LayerAccessor(RadiologyScene& scene,
 size_t index) :
-stack_(stack),
+scene_(scene),
 index_(index)
 {
-Bitmaps::iterator bitmap = stack.bitmaps_.find(index);
+Layers::iterator layer = scene.layers_.find(index);
-if (bitmap == stack.bitmaps_.end())
+if (layer == scene.layers_.end())
 {
-bitmap_ = NULL;
+layer_ = NULL;
 }
 else
 {
-assert(bitmap->second != NULL);
+assert(layer->second != NULL);
-bitmap_ = bitmap->second;
+layer_ = layer->second;
 }
 }
-BitmapAccessor(BitmapStack& stack,
+LayerAccessor(RadiologyScene& scene,
 double x,
 double y) :
-stack_(stack),
+scene_(scene),
 index_(0)  // Dummy initialization
 {
-if (stack.LookupBitmap(index_, x, y))
+if (scene.LookupLayer(index_, x, y))
 {
-Bitmaps::iterator bitmap = stack.bitmaps_.find(index_);
+Layers::iterator layer = scene.layers_.find(index_);
-if (bitmap == stack.bitmaps_.end())
+if (layer == scene.layers_.end())
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 else
 {
-assert(bitmap->second != NULL);
+assert(layer->second != NULL);
-bitmap_ = bitmap->second;
+layer_ = layer->second;
 }
 }
 else
 {
-bitmap_ = NULL;
+layer_ = NULL;
 }
 }
 void Invalidate()
 {
-bitmap_ = NULL;
+layer_ = NULL;
 }
 bool IsValid() const
 {
-return bitmap_ != NULL;
+return layer_ != NULL;
 }
-BitmapStack& GetStack() const
+RadiologyScene& GetScene() const
 {
 if (IsValid())
 {
-return stack_;
+return scene_;
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
-Bitmap& GetBitmap() const
+Layer& GetLayer() const
 {
 if (IsValid())
 {
-return *bitmap_;
+return *layer_;
 }
 else
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls);
 }
 }
 };
-class AlphaBitmap : public Bitmap
+private:
+class AlphaLayer : public Layer
 {
 private:
-const BitmapStack&                     stack_;
+const RadiologyScene&                  scene_;
 std::auto_ptr<Orthanc::ImageAccessor>  alpha_;      // Grayscale8
 bool                                   useWindowing_;
 float                                  foreground_;
 public:
-AlphaBitmap(const BitmapStack& stack) :
+AlphaLayer(const RadiologyScene& scene) :
-stack_(stack),
+scene_(scene),
 useWindowing_(true),
 foreground_(0)
 {
 }
 const std::string& utf8)
 {
 SetAlpha(font.RenderAlpha(utf8));
 }
+virtual bool GetDefaultWindowing(float& center,
+float& width) const
+{
+return false;
+}
 virtual void Render(Orthanc::ImageAccessor& buffer,
 const Matrix& viewTransform,
 ImageInterpolation interpolation) const
 {
 float value = foreground_;
 if (useWindowing_)
 {
 float center, width;
-if (stack_.GetWindowing(center, width))
+if (scene_.GetWindowing(center, width))
 {
 value = center + width / 2.0f;
 }
 }
 *q = (a * value + (1.0f - a) * (*q));
 }
 }
 }
 virtual bool GetRange(float& minValue,
 float& maxValue) const
 {
 if (useWindowing_)
 {
 LinearAlgebra::FillMatrix(m, 3, 3, v);
 return m;
 }
-class DicomBitmap : public Bitmap
+class DicomLayer : public Layer
 {
 private:
 std::auto_ptr<Orthanc::ImageAccessor>  source_;  // Content of PixelData
 std::auto_ptr<DicomFrameConverter>     converter_;
 std::auto_ptr<Orthanc::ImageAccessor>  converted_;  // Float32
 };
-typedef std::map<size_t, Bitmap*>  Bitmaps;
+typedef std::map<size_t, Layer*>  Layers;
 OrthancApiClient&  orthanc_;
-size_t             countBitmaps_;
+size_t             countLayers_;
 bool               hasWindowing_;
 float              windowingCenter_;
 float              windowingWidth_;
-Bitmaps            bitmaps_;
+Layers             layers_;
+Layer& RegisterLayer(Layer* layer)
+{
+if (layer == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+std::auto_ptr<Layer> raii(layer);
+size_t index = countLayers_++;
+raii->SetIndex(index);
+layers_[index] = raii.release();
+EmitMessage(GeometryChangedMessage(*this));
+EmitMessage(ContentChangedMessage(*this));
+return *layer;
+}
 public:
-BitmapStack(MessageBroker& broker,
+RadiologyScene(MessageBroker& broker,
 OrthancApiClient& orthanc) :
 IObserver(broker),
 IObservable(broker),
 orthanc_(orthanc),
-countBitmaps_(0),
+countLayers_(0),
 hasWindowing_(false),
 windowingCenter_(0),  // Dummy initialization
 windowingWidth_(0)    // Dummy initialization
 {
 }
-virtual ~BitmapStack()
+virtual ~RadiologyScene()
 {
-for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); it++)
+for (Layers::iterator it = layers_.begin(); it != layers_.end(); it++)
 {
 assert(it->second != NULL);
 delete it->second;
 }
 }
 windowingCenter_ = center;
 windowingWidth_ = width;
 }
-Bitmap& RegisterBitmap(Bitmap* bitmap)
+Layer& LoadText(const Orthanc::Font& font,
-{
+const std::string& utf8)
-if (bitmap == NULL)
+{
-{
+std::auto_ptr<AlphaLayer>  alpha(new AlphaLayer(*this));
-throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+alpha->LoadText(font, utf8);
-}
+return RegisterLayer(alpha.release());
-std::auto_ptr<Bitmap> raii(bitmap);
+}
-size_t index = countBitmaps_++;
-raii->SetIndex(index);
-bitmaps_[index] = raii.release();
-EmitMessage(GeometryChangedMessage(*this));
-EmitMessage(ContentChangedMessage(*this));
-return *bitmap;
-}
+Layer& LoadTestBlock(unsigned int width,
-Bitmap& LoadText(const Orthanc::Font& font,
+unsigned int height)
-const std::string& utf8)
-{
-std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(*this));
-alpha->LoadText(font, utf8);
-return RegisterBitmap(alpha.release());
-}
-Bitmap& LoadTestBlock(unsigned int width,
-unsigned int height)
 {
 std::auto_ptr<Orthanc::Image>  block(new Orthanc::Image(Orthanc::PixelFormat_Grayscale8, width, height, false));
 for (unsigned int padding = 0;
 (width > 2 * padding) && (height > 2 * padding);
 Orthanc::ImageAccessor region;
 block->GetRegion(region, padding, padding, width - 2 * padding, height - 2 * padding);
 Orthanc::ImageProcessing::Set(region, color);
 }
-std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(*this));
+std::auto_ptr<AlphaLayer>  alpha(new AlphaLayer(*this));
 alpha->SetAlpha(block.release());
-return RegisterBitmap(alpha.release());
+return RegisterLayer(alpha.release());
 }
-Bitmap& LoadFrame(const std::string& instance,
+Layer& LoadDicomFrame(const std::string& instance,
 unsigned int frame,
 bool httpCompression)
 {
-Bitmap& bitmap = RegisterBitmap(new DicomBitmap);
+Layer& layer = RegisterLayer(new DicomLayer);
 {
 IWebService::Headers headers;
 std::string uri = "/instances/" + instance + "/tags";
 orthanc_.GetBinaryAsync(uri, headers,
-new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage>
+new Callable<RadiologyScene, OrthancApiClient::BinaryResponseReadyMessage>
-(*this, &BitmapStack::OnTagsReceived), NULL,
+(*this, &RadiologyScene::OnTagsReceived), NULL,
-new Orthanc::SingleValueObject<size_t>(bitmap.GetIndex()));
+new Orthanc::SingleValueObject<size_t>(layer.GetIndex()));
 }
 {
 IWebService::Headers headers;
 headers["Accept"] = "image/x-portable-arbitrarymap";
 headers["Accept-Encoding"] = "gzip";
 }
 std::string uri = "/instances/" + instance + "/frames/" + boost::lexical_cast<std::string>(frame) + "/image-uint16";
 orthanc_.GetBinaryAsync(uri, headers,
-new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage>
+new Callable<RadiologyScene, OrthancApiClient::BinaryResponseReadyMessage>
-(*this, &BitmapStack::OnFrameReceived), NULL,
+(*this, &RadiologyScene::OnFrameReceived), NULL,
-new Orthanc::SingleValueObject<size_t>(bitmap.GetIndex()));
+new Orthanc::SingleValueObject<size_t>(layer.GetIndex()));
 }
-return bitmap;
+return layer;
 }
 void OnTagsReceived(const OrthancApiClient::BinaryResponseReadyMessage& message)
 {
 size_t index = dynamic_cast<const Orthanc::SingleValueObject<size_t>&>(message.GetPayload()).GetValue();
 LOG(INFO) << "JSON received: " << message.GetUri().c_str()
-<< " (" << message.GetAnswerSize() << " bytes) for bitmap " << index;
+<< " (" << message.GetAnswerSize() << " bytes) for layer " << index;
-Bitmaps::iterator bitmap = bitmaps_.find(index);
+Layers::iterator layer = layers_.find(index);
-if (bitmap != bitmaps_.end())
+if (layer != layers_.end())
 {
-assert(bitmap->second != NULL);
+assert(layer->second != NULL);
 OrthancPlugins::FullOrthancDataset dicom(message.GetAnswer(), message.GetAnswerSize());
-dynamic_cast<DicomBitmap*>(bitmap->second)->SetDicomTags(dicom);
+dynamic_cast<DicomLayer*>(layer->second)->SetDicomTags(dicom);
 float c, w;
 if (!hasWindowing_ &&
-bitmap->second->GetDefaultWindowing(c, w))
+layer->second->GetDefaultWindowing(c, w))
 {
 hasWindowing_ = true;
 windowingCenter_ = c;
 windowingWidth_ = w;
 }
 void OnFrameReceived(const OrthancApiClient::BinaryResponseReadyMessage& message)
 {
 size_t index = dynamic_cast<const Orthanc::SingleValueObject<size_t>&>(message.GetPayload()).GetValue();
 LOG(INFO) << "DICOM frame received: " << message.GetUri().c_str()
-<< " (" << message.GetAnswerSize() << " bytes) for bitmap " << index;
+<< " (" << message.GetAnswerSize() << " bytes) for layer " << index;
-Bitmaps::iterator bitmap = bitmaps_.find(index);
+Layers::iterator layer = layers_.find(index);
-if (bitmap != bitmaps_.end())
+if (layer != layers_.end())
 {
-assert(bitmap->second != NULL);
+assert(layer->second != NULL);
 std::string content;
 if (message.GetAnswerSize() > 0)
 {
 content.assign(reinterpret_cast<const char*>(message.GetAnswer()), message.GetAnswerSize());
 }
 std::auto_ptr<Orthanc::PamReader> reader(new Orthanc::PamReader);
 reader->ReadFromMemory(content);
-dynamic_cast<DicomBitmap*>(bitmap->second)->SetSourceImage(reader.release());
+dynamic_cast<DicomLayer*>(layer->second)->SetSourceImage(reader.release());
 EmitMessage(ContentChangedMessage(*this));
 }
 }
 Extent2D GetSceneExtent() const
 {
 Extent2D extent;
-for (Bitmaps::const_iterator it = bitmaps_.begin();
+for (Layers::const_iterator it = layers_.begin();
-it != bitmaps_.end(); ++it)
+it != layers_.end(); ++it)
 {
 assert(it->second != NULL);
 extent.Union(it->second->GetExtent());
 }
 ImageInterpolation interpolation) const
 {
 Orthanc::ImageProcessing::Set(buffer, 0);
 // Render layers in the background-to-foreground order
-for (size_t index = 0; index < countBitmaps_; index++)
+for (size_t index = 0; index < countLayers_; index++)
 {
-Bitmaps::const_iterator it = bitmaps_.find(index);
+Layers::const_iterator it = layers_.find(index);
-if (it != bitmaps_.end())
+if (it != layers_.end())
 {
 assert(it->second != NULL);
 it->second->Render(buffer, viewTransform, interpolation);
 }
 }
 }
-bool LookupBitmap(size_t& index /* out */,
+bool LookupLayer(size_t& index /* out */,
 double x,
 double y) const
 {
 // Render layers in the foreground-to-background order
-for (size_t i = countBitmaps_; i > 0; i--)
+for (size_t i = countLayers_; i > 0; i--)
 {
 index = i - 1;
-Bitmaps::const_iterator it = bitmaps_.find(index);
+Layers::const_iterator it = layers_.find(index);
-if (it != bitmaps_.end())
+if (it != layers_.end())
 {
 assert(it->second != NULL);
 if (it->second->Contains(x, y))
 {
 return true;
 return false;
 }
 void DrawBorder(CairoContext& context,
-unsigned int bitmap,
+unsigned int layer,
 double zoom)
 {
-Bitmaps::const_iterator found = bitmaps_.find(bitmap);
+Layers::const_iterator found = layers_.find(layer);
-if (found != bitmaps_.end())
+if (found != layers_.end())
 {
 context.SetSourceColor(255, 0, 0);
 found->second->DrawBorders(context, zoom);
 }
 }
 void GetRange(float& minValue,
 float& maxValue) const
 {
 bool first = true;
-for (Bitmaps::const_iterator it = bitmaps_.begin();
+for (Layers::const_iterator it = layers_.begin();
-it != bitmaps_.end(); it++)
+it != layers_.end(); it++)
 {
 assert(it->second != NULL);
 float a, b;
 if (it->second->GetRange(a, b))
 maxValue = 0;
 }
 }
+// Export using PAM is faster than using PNG, but requires Orthanc
+// core >= 1.4.3
 void Export(const Orthanc::DicomMap& dicom,
 double pixelSpacingX,
 double pixelSpacingY,
 bool invert,
-ImageInterpolation interpolation)
+ImageInterpolation interpolation,
+bool usePam)
 {
 if (pixelSpacingX <= 0 ||
 pixelSpacingY <= 0)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
-LOG(WARNING) << "Exporting DICOM";
+LOG(INFO) << "Exporting DICOM";
 Extent2D extent = GetSceneExtent();
 int w = std::ceil(extent.GetWidth() / pixelSpacingX);
 int h = std::ceil(extent.GetHeight() / pixelSpacingY);
 std::string base64;
 {
 std::string content;
-#if EXPORT_USING_PAM == 1
+if (usePam)
 {
 Orthanc::PamWriter writer;
 writer.WriteToMemory(content, rendered);
 }
-#else
+else
 {
 Orthanc::PngWriter writer;
 writer.WriteToMemory(content, rendered);
 }
-#endif
 Orthanc::Toolbox::EncodeBase64(base64, content);
 }
 std::set<Orthanc::DicomTag> tags;
 }
 json["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] =
 (invert ? "MONOCHROME1" : "MONOCHROME2");
-// WARNING: The order of PixelSpacing is Y/X
+// WARNING: The order of PixelSpacing is Y/X. We use "%0.8f" to
+// avoid floating-point numbers to grow over 16 characters,
+// which would be invalid according to DICOM standard
+// ("dciodvfy" would complain).
 char buf[32];
 sprintf(buf, "%0.8f\\%0.8f", pixelSpacingY, pixelSpacingX);
 json["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf;
 json["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] =
 boost::lexical_cast<std::string>(boost::math::iround(width));
 }
-#if EXPORT_USING_PAM == 1
+// This is Data URI scheme: https://en.wikipedia.org/wiki/Data_URI_scheme
-json["Content"] = "data:" + std::string(Orthanc::MIME_PAM) + ";base64," + base64;
+json["Content"] = ("data:" +
-#else
+std::string(usePam ? Orthanc::MIME_PAM : Orthanc::MIME_PNG) +
-json["Content"] = "data:" + std::string(Orthanc::MIME_PNG) + ";base64," + base64;
+";base64," + base64);
-#endif
 orthanc_.PostJsonAsyncExpectJson(
 "/tools/create-dicom", json,
-new Callable<BitmapStack, OrthancApiClient::JsonResponseReadyMessage>
+new Callable<RadiologyScene, OrthancApiClient::JsonResponseReadyMessage>
-(*this, &BitmapStack::OnDicomExported),
+(*this, &RadiologyScene::OnDicomExported),
 NULL, NULL);
 }
 void OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message)
 {
-LOG(WARNING) << "DICOM export was successful:"
+LOG(INFO) << "DICOM export was successful:"
 << message.GetJson().toStyledString();
 }
 };
 class UndoRedoStack : public boost::noncopyable
 }
 }
 };
-class BitmapCommandBase : public UndoRedoStack::ICommand
+class RadiologyLayerCommand : public UndoRedoStack::ICommand
 {
 private:
-BitmapStack&  stack_;
+RadiologyScene&  scene_;
-size_t        bitmap_;
+size_t           layer_;
 protected:
-virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const = 0;
+virtual void UndoInternal(RadiologyScene::Layer& layer) const = 0;
-virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const = 0;
+virtual void RedoInternal(RadiologyScene::Layer& layer) const = 0;
 public:
-BitmapCommandBase(BitmapStack& stack,
+RadiologyLayerCommand(RadiologyScene& scene,
-size_t bitmap) :
+size_t layer) :
-stack_(stack),
+scene_(scene),
-bitmap_(bitmap)
+layer_(layer)
 {
 }
-BitmapCommandBase(const BitmapStack::BitmapAccessor& accessor) :
+RadiologyLayerCommand(const RadiologyScene::LayerAccessor& accessor) :
-stack_(accessor.GetStack()),
+scene_(accessor.GetScene()),
-bitmap_(accessor.GetIndex())
+layer_(accessor.GetIndex())
 {
 }
 virtual void Undo() const
 {
-BitmapStack::BitmapAccessor accessor(stack_, bitmap_);
+RadiologyScene::LayerAccessor accessor(scene_, layer_);
 if (accessor.IsValid())
 {
-UndoInternal(accessor.GetBitmap());
+UndoInternal(accessor.GetLayer());
 }
 }
 virtual void Redo() const
 {
-BitmapStack::BitmapAccessor accessor(stack_, bitmap_);
+RadiologyScene::LayerAccessor accessor(scene_, layer_);
 if (accessor.IsValid())
 {
-RedoInternal(accessor.GetBitmap());
+RedoInternal(accessor.GetLayer());
 }
 }
 };
-class RotateBitmapTracker : public IWorldSceneMouseTracker
+class RadiologyLayerRotateTracker : public IWorldSceneMouseTracker
 {
 private:
-UndoRedoStack&               undoRedoStack_;
+UndoRedoStack&                 undoRedoStack_;
-BitmapStack::BitmapAccessor  accessor_;
+RadiologyScene::LayerAccessor  accessor_;
-double                       centerX_;
+double                         centerX_;
-double                       centerY_;
+double                         centerY_;
-double                       originalAngle_;
+double                         originalAngle_;
-double                       clickAngle_;
+double                         clickAngle_;
-bool                         roundAngles_;
+bool                           roundAngles_;
 bool ComputeAngle(double& angle /* out */,
 double sceneX,
 double sceneY) const
 {
 return false;
 }
 }
-class UndoRedoCommand : public BitmapCommandBase
+class UndoRedoCommand : public RadiologyLayerCommand
 {
 private:
 double  sourceAngle_;
 double  targetAngle_;
 {
 return boost::math::iround(angle * 180.0 / boost::math::constants::pi<double>());
 }
 protected:
-virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void UndoInternal(RadiologyScene::Layer& layer) const
 {
 LOG(INFO) << "Undo - Set angle to " << ToDegrees(sourceAngle_) << " degrees";
-bitmap.SetAngle(sourceAngle_);
+layer.SetAngle(sourceAngle_);
 }
-virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void RedoInternal(RadiologyScene::Layer& layer) const
 {
 LOG(INFO) << "Redo - Set angle to " << ToDegrees(sourceAngle_) << " degrees";
-bitmap.SetAngle(targetAngle_);
+layer.SetAngle(targetAngle_);
 }
 public:
-UndoRedoCommand(const RotateBitmapTracker& tracker) :
+UndoRedoCommand(const RadiologyLayerRotateTracker& tracker) :
-BitmapCommandBase(tracker.accessor_),
+RadiologyLayerCommand(tracker.accessor_),
 sourceAngle_(tracker.originalAngle_),
-targetAngle_(tracker.accessor_.GetBitmap().GetAngle())
+targetAngle_(tracker.accessor_.GetLayer().GetAngle())
 {
 }
 };
 public:
-RotateBitmapTracker(UndoRedoStack& undoRedoStack,
+RadiologyLayerRotateTracker(UndoRedoStack& undoRedoStack,
-BitmapStack& stack,
+RadiologyScene& scene,
 const ViewportGeometry& view,
-size_t bitmap,
+size_t layer,
 double x,
 double y,
 bool roundAngles) :
 undoRedoStack_(undoRedoStack),
-accessor_(stack, bitmap),
+accessor_(scene, layer),
 roundAngles_(roundAngles)
 {
 if (accessor_.IsValid())
 {
-accessor_.GetBitmap().GetCenter(centerX_, centerY_);
+accessor_.GetLayer().GetCenter(centerX_, centerY_);
-originalAngle_ = accessor_.GetBitmap().GetAngle();
+originalAngle_ = accessor_.GetLayer().GetAngle();
 double sceneX, sceneY;
 view.MapDisplayToScene(sceneX, sceneY, x, y);
 if (!ComputeAngle(clickAngle_, x, y))
 if (roundAngles_)
 {
 angle = boost::math::round<double>((angle / ROUND_ANGLE) * ROUND_ANGLE);
 }
-accessor_.GetBitmap().SetAngle(angle);
+accessor_.GetLayer().SetAngle(angle);
 }
 }
 };
-class MoveBitmapTracker : public IWorldSceneMouseTracker
+class RadiologyLayerMoveTracker : public IWorldSceneMouseTracker
 {
 private:
-UndoRedoStack&               undoRedoStack_;
+UndoRedoStack&                 undoRedoStack_;
-BitmapStack::BitmapAccessor  accessor_;
+RadiologyScene::LayerAccessor  accessor_;
-double                       clickX_;
+double                         clickX_;
-double                       clickY_;
+double                         clickY_;
-double                       panX_;
+double                         panX_;
-double                       panY_;
+double                         panY_;
-bool                         oneAxis_;
+bool                           oneAxis_;
-class UndoRedoCommand : public BitmapCommandBase
+class UndoRedoCommand : public RadiologyLayerCommand
 {
 private:
 double  sourceX_;
 double  sourceY_;
 double  targetX_;
 double  targetY_;
 protected:
-virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void UndoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetPan(sourceX_, sourceY_);
+layer.SetPan(sourceX_, sourceY_);
 }
-virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void RedoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetPan(targetX_, targetY_);
+layer.SetPan(targetX_, targetY_);
 }
 public:
-UndoRedoCommand(const MoveBitmapTracker& tracker) :
+UndoRedoCommand(const RadiologyLayerMoveTracker& tracker) :
-BitmapCommandBase(tracker.accessor_),
+RadiologyLayerCommand(tracker.accessor_),
 sourceX_(tracker.panX_),
 sourceY_(tracker.panY_),
-targetX_(tracker.accessor_.GetBitmap().GetPanX()),
+targetX_(tracker.accessor_.GetLayer().GetPanX()),
-targetY_(tracker.accessor_.GetBitmap().GetPanY())
+targetY_(tracker.accessor_.GetLayer().GetPanY())
 {
 }
 };
 public:
-MoveBitmapTracker(UndoRedoStack& undoRedoStack,
+RadiologyLayerMoveTracker(UndoRedoStack& undoRedoStack,
-BitmapStack& stack,
+RadiologyScene& scene,
-size_t bitmap,
+size_t layer,
 double x,
 double y,
 bool oneAxis) :
 undoRedoStack_(undoRedoStack),
-accessor_(stack, bitmap),
+accessor_(scene, layer),
 clickX_(x),
 clickY_(y),
 oneAxis_(oneAxis)
 {
 if (accessor_.IsValid())
 {
-panX_ = accessor_.GetBitmap().GetPanX();
+panX_ = accessor_.GetLayer().GetPanX();
-panY_ = accessor_.GetBitmap().GetPanY();
+panY_ = accessor_.GetLayer().GetPanY();
 }
 }
 virtual bool HasRender() const
 {
 if (oneAxis_)
 {
 if (fabs(dx) > fabs(dy))
 {
-accessor_.GetBitmap().SetPan(dx + panX_, panY_);
+accessor_.GetLayer().SetPan(dx + panX_, panY_);
 }
 else
 {
-accessor_.GetBitmap().SetPan(panX_, dy + panY_);
+accessor_.GetLayer().SetPan(panX_, dy + panY_);
 }
 }
 else
 {
-accessor_.GetBitmap().SetPan(dx + panX_, dy + panY_);
+accessor_.GetLayer().SetPan(dx + panX_, dy + panY_);
 }
 }
 }
 };
-class CropBitmapTracker : public IWorldSceneMouseTracker
+class RadiologyLayerCropTracker : public IWorldSceneMouseTracker
 {
 private:
-UndoRedoStack&               undoRedoStack_;
+UndoRedoStack&                 undoRedoStack_;
-BitmapStack::BitmapAccessor  accessor_;
+RadiologyScene::LayerAccessor  accessor_;
-BitmapStack::Corner          corner_;
+RadiologyScene::Corner         corner_;
-unsigned int                 cropX_;
+unsigned int                   cropX_;
-unsigned int                 cropY_;
+unsigned int                   cropY_;
-unsigned int                 cropWidth_;
+unsigned int                   cropWidth_;
-unsigned int                 cropHeight_;
+unsigned int                   cropHeight_;
-class UndoRedoCommand : public BitmapCommandBase
+class UndoRedoCommand : public RadiologyLayerCommand
 {
 private:
 unsigned int  sourceCropX_;
 unsigned int  sourceCropY_;
 unsigned int  sourceCropWidth_;
 unsigned int  targetCropY_;
 unsigned int  targetCropWidth_;
 unsigned int  targetCropHeight_;
 protected:
-virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void UndoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetCrop(sourceCropX_, sourceCropY_, sourceCropWidth_, sourceCropHeight_);
+layer.SetCrop(sourceCropX_, sourceCropY_, sourceCropWidth_, sourceCropHeight_);
 }
-virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void RedoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetCrop(targetCropX_, targetCropY_, targetCropWidth_, targetCropHeight_);
+layer.SetCrop(targetCropX_, targetCropY_, targetCropWidth_, targetCropHeight_);
 }
 public:
-UndoRedoCommand(const CropBitmapTracker& tracker) :
+UndoRedoCommand(const RadiologyLayerCropTracker& tracker) :
-BitmapCommandBase(tracker.accessor_),
+RadiologyLayerCommand(tracker.accessor_),
 sourceCropX_(tracker.cropX_),
 sourceCropY_(tracker.cropY_),
 sourceCropWidth_(tracker.cropWidth_),
 sourceCropHeight_(tracker.cropHeight_)
 {
-tracker.accessor_.GetBitmap().GetCrop(targetCropX_, targetCropY_,
+tracker.accessor_.GetLayer().GetCrop(targetCropX_, targetCropY_,
 targetCropWidth_, targetCropHeight_);
 }
 };
 public:
-CropBitmapTracker(UndoRedoStack& undoRedoStack,
+RadiologyLayerCropTracker(UndoRedoStack& undoRedoStack,
-BitmapStack& stack,
+RadiologyScene& scene,
 const ViewportGeometry& view,
-size_t bitmap,
+size_t layer,
 double x,
 double y,
-BitmapStack::Corner corner) :
+RadiologyScene::Corner corner) :
 undoRedoStack_(undoRedoStack),
-accessor_(stack, bitmap),
+accessor_(scene, layer),
 corner_(corner)
 {
 if (accessor_.IsValid())
 {
-accessor_.GetBitmap().GetCrop(cropX_, cropY_, cropWidth_, cropHeight_);
+accessor_.GetLayer().GetCrop(cropX_, cropY_, cropWidth_, cropHeight_);
 }
 }
 virtual bool HasRender() const
 {
 {
 if (accessor_.IsValid())
 {
 unsigned int x, y;
-BitmapStack::Bitmap& bitmap = accessor_.GetBitmap();
+RadiologyScene::Layer& layer = accessor_.GetLayer();
-if (bitmap.GetPixel(x, y, sceneX, sceneY))
+if (layer.GetPixel(x, y, sceneX, sceneY))
 {
 unsigned int targetX, targetWidth;
-if (corner_ == BitmapStack::Corner_TopLeft ||
+if (corner_ == RadiologyScene::Corner_TopLeft ||
-corner_ == BitmapStack::Corner_BottomLeft)
+corner_ == RadiologyScene::Corner_BottomLeft)
 {
 targetX = std::min(x, cropX_ + cropWidth_);
 targetWidth = cropX_ + cropWidth_ - targetX;
 }
 else
 targetWidth = std::max(x, cropX_) - cropX_;
 }
 unsigned int targetY, targetHeight;
-if (corner_ == BitmapStack::Corner_TopLeft ||
+if (corner_ == RadiologyScene::Corner_TopLeft ||
-corner_ == BitmapStack::Corner_TopRight)
+corner_ == RadiologyScene::Corner_TopRight)
 {
 targetY = std::min(y, cropY_ + cropHeight_);
 targetHeight = cropY_ + cropHeight_ - targetY;
 }
 else
 {
 targetY = cropY_;
 targetHeight = std::max(y, cropY_) - cropY_;
 }
-bitmap.SetCrop(targetX, targetY, targetWidth, targetHeight);
+layer.SetCrop(targetX, targetY, targetWidth, targetHeight);
 }
 }
 }
 };
-class ResizeBitmapTracker : public IWorldSceneMouseTracker
+class RadiologyLayerResizeTracker : public IWorldSceneMouseTracker
 {
 private:
-UndoRedoStack&               undoRedoStack_;
+UndoRedoStack&                 undoRedoStack_;
-BitmapStack::BitmapAccessor  accessor_;
+RadiologyScene::LayerAccessor  accessor_;
-bool                         roundScaling_;
+bool                           roundScaling_;
-double                       originalSpacingX_;
+double                         originalSpacingX_;
-double                       originalSpacingY_;
+double                         originalSpacingY_;
-double                       originalPanX_;
+double                         originalPanX_;
-double                       originalPanY_;
+double                         originalPanY_;
-BitmapStack::Corner          oppositeCorner_;
+RadiologyScene::Corner         oppositeCorner_;
-double                       oppositeX_;
+double                         oppositeX_;
-double                       oppositeY_;
+double                         oppositeY_;
-double                       baseScaling_;
+double                         baseScaling_;
 static double ComputeDistance(double x1,
 double y1,
 double x2,
 double y2)
 double dx = x1 - x2;
 double dy = y1 - y2;
 return sqrt(dx * dx + dy * dy);
 }
-class UndoRedoCommand : public BitmapCommandBase
+class UndoRedoCommand : public RadiologyLayerCommand
 {
 private:
 double   sourceSpacingX_;
 double   sourceSpacingY_;
 double   sourcePanX_;
 double   targetSpacingY_;
 double   targetPanX_;
 double   targetPanY_;
 protected:
-virtual void UndoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void UndoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetPixelSpacing(sourceSpacingX_, sourceSpacingY_);
+layer.SetPixelSpacing(sourceSpacingX_, sourceSpacingY_);
-bitmap.SetPan(sourcePanX_, sourcePanY_);
+layer.SetPan(sourcePanX_, sourcePanY_);
 }
-virtual void RedoInternal(BitmapStack::Bitmap& bitmap) const
+virtual void RedoInternal(RadiologyScene::Layer& layer) const
 {
-bitmap.SetPixelSpacing(targetSpacingX_, targetSpacingY_);
+layer.SetPixelSpacing(targetSpacingX_, targetSpacingY_);
-bitmap.SetPan(targetPanX_, targetPanY_);
+layer.SetPan(targetPanX_, targetPanY_);
 }
 public:
-UndoRedoCommand(const ResizeBitmapTracker& tracker) :
+UndoRedoCommand(const RadiologyLayerResizeTracker& tracker) :
-BitmapCommandBase(tracker.accessor_),
+RadiologyLayerCommand(tracker.accessor_),
 sourceSpacingX_(tracker.originalSpacingX_),
 sourceSpacingY_(tracker.originalSpacingY_),
 sourcePanX_(tracker.originalPanX_),
 sourcePanY_(tracker.originalPanY_),
-targetSpacingX_(tracker.accessor_.GetBitmap().GetPixelSpacingX()),
+targetSpacingX_(tracker.accessor_.GetLayer().GetPixelSpacingX()),
-targetSpacingY_(tracker.accessor_.GetBitmap().GetPixelSpacingY()),
+targetSpacingY_(tracker.accessor_.GetLayer().GetPixelSpacingY()),
-targetPanX_(tracker.accessor_.GetBitmap().GetPanX()),
+targetPanX_(tracker.accessor_.GetLayer().GetPanX()),
-targetPanY_(tracker.accessor_.GetBitmap().GetPanY())
+targetPanY_(tracker.accessor_.GetLayer().GetPanY())
 {
 }
 };
 public:
-ResizeBitmapTracker(UndoRedoStack& undoRedoStack,
+RadiologyLayerResizeTracker(UndoRedoStack& undoRedoStack,
-BitmapStack& stack,
+RadiologyScene& scene,
-size_t bitmap,
+size_t layer,
 double x,
 double y,
-BitmapStack::Corner corner,
+RadiologyScene::Corner corner,
 bool roundScaling) :
 undoRedoStack_(undoRedoStack),
-accessor_(stack, bitmap),
+accessor_(scene, layer),
 roundScaling_(roundScaling)
 {
 if (accessor_.IsValid() &&
-accessor_.GetBitmap().IsResizeable())
+accessor_.GetLayer().IsResizeable())
 {
-originalSpacingX_ = accessor_.GetBitmap().GetPixelSpacingX();
+originalSpacingX_ = accessor_.GetLayer().GetPixelSpacingX();
-originalSpacingY_ = accessor_.GetBitmap().GetPixelSpacingY();
+originalSpacingY_ = accessor_.GetLayer().GetPixelSpacingY();
-originalPanX_ = accessor_.GetBitmap().GetPanX();
+originalPanX_ = accessor_.GetLayer().GetPanX();
-originalPanY_ = accessor_.GetBitmap().GetPanY();
+originalPanY_ = accessor_.GetLayer().GetPanY();
 switch (corner)
 {
-case BitmapStack::Corner_TopLeft:
+case RadiologyScene::Corner_TopLeft:
-oppositeCorner_ = BitmapStack::Corner_BottomRight;
+oppositeCorner_ = RadiologyScene::Corner_BottomRight;
 break;
-case BitmapStack::Corner_TopRight:
+case RadiologyScene::Corner_TopRight:
-oppositeCorner_ = BitmapStack::Corner_BottomLeft;
+oppositeCorner_ = RadiologyScene::Corner_BottomLeft;
 break;
-case BitmapStack::Corner_BottomLeft:
+case RadiologyScene::Corner_BottomLeft:
-oppositeCorner_ = BitmapStack::Corner_TopRight;
+oppositeCorner_ = RadiologyScene::Corner_TopRight;
 break;
-case BitmapStack::Corner_BottomRight:
+case RadiologyScene::Corner_BottomRight:
-oppositeCorner_ = BitmapStack::Corner_TopLeft;
+oppositeCorner_ = RadiologyScene::Corner_TopLeft;
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
-accessor_.GetBitmap().GetCorner(oppositeX_, oppositeY_, oppositeCorner_);
+accessor_.GetLayer().GetCorner(oppositeX_, oppositeY_, oppositeCorner_);
 double d = ComputeDistance(x, y, oppositeX_, oppositeY_);
 if (d >= std::numeric_limits<float>::epsilon())
 {
 baseScaling_ = 1.0 / d;
 }
 virtual void MouseUp()
 {
 if (accessor_.IsValid() &&
-accessor_.GetBitmap().IsResizeable())
+accessor_.GetLayer().IsResizeable())
 {
 undoRedoStack_.Add(new UndoRedoCommand(*this));
 }
 }
 double sceneY)
 {
 static const double ROUND_SCALING = 0.1;
 if (accessor_.IsValid() &&
-accessor_.GetBitmap().IsResizeable())
+accessor_.GetLayer().IsResizeable())
 {
 double scaling = ComputeDistance(oppositeX_, oppositeY_, sceneX, sceneY) * baseScaling_;
 if (roundScaling_)
 {
 scaling = boost::math::round<double>((scaling / ROUND_SCALING) * ROUND_SCALING);
 }
-BitmapStack::Bitmap& bitmap = accessor_.GetBitmap();
+RadiologyScene::Layer& layer = accessor_.GetLayer();
-bitmap.SetPixelSpacing(scaling * originalSpacingX_,
+layer.SetPixelSpacing(scaling * originalSpacingX_,
 scaling * originalSpacingY_);
 // Keep the opposite corner at a fixed location
 double ox, oy;
-bitmap.GetCorner(ox, oy, oppositeCorner_);
+layer.GetCorner(ox, oy, oppositeCorner_);
-bitmap.SetPan(bitmap.GetPanX() + oppositeX_ - ox,
+layer.SetPan(layer.GetPanX() + oppositeX_ - ox,
-bitmap.GetPanY() + oppositeY_ - oy);
+layer.GetPanY() + oppositeY_ - oy);
 }
 }
 };
-class WindowingTracker : public IWorldSceneMouseTracker
+class RadiologyWindowingTracker : public IWorldSceneMouseTracker
 {
 public:
 enum Action
 {
 Action_IncreaseWidth,
 Action_IncreaseCenter,
 Action_DecreaseCenter
 };
 private:
-UndoRedoStack&  undoRedoStack_;
+UndoRedoStack&    undoRedoStack_;
-BitmapStack&    stack_;
+RadiologyScene&   scene_;
-int             clickX_;
+int               clickX_;
-int             clickY_;
+int               clickY_;
-Action          leftAction_;
+Action            leftAction_;
-Action          rightAction_;
+Action            rightAction_;
-Action          upAction_;
+Action            upAction_;
-Action          downAction_;
+Action            downAction_;
-float           strength_;
+float             strength_;
-float           sourceCenter_;
+float             sourceCenter_;
-float           sourceWidth_;
+float             sourceWidth_;
 static void ComputeAxisEffect(int& deltaCenter,
 int& deltaWidth,
 int delta,
 Action actionNegative,
 class UndoRedoCommand : public UndoRedoStack::ICommand
 {
 private:
-BitmapStack&  stack_;
+RadiologyScene&  scene_;
-float         sourceCenter_;
+float            sourceCenter_;
-float         sourceWidth_;
+float            sourceWidth_;
-float         targetCenter_;
+float            targetCenter_;
-float         targetWidth_;
+float            targetWidth_;
 public:
-UndoRedoCommand(const WindowingTracker& tracker) :
+UndoRedoCommand(const RadiologyWindowingTracker& tracker) :
-stack_(tracker.stack_),
+scene_(tracker.scene_),
 sourceCenter_(tracker.sourceCenter_),
 sourceWidth_(tracker.sourceWidth_)
 {
-stack_.GetWindowingWithDefault(targetCenter_, targetWidth_);
+scene_.GetWindowingWithDefault(targetCenter_, targetWidth_);
 }
 virtual void Undo() const
 {
-stack_.SetWindowing(sourceCenter_, sourceWidth_);
+scene_.SetWindowing(sourceCenter_, sourceWidth_);
 }
 virtual void Redo() const
 {
-stack_.SetWindowing(targetCenter_, targetWidth_);
+scene_.SetWindowing(targetCenter_, targetWidth_);
 }
 };
 public:
-WindowingTracker(UndoRedoStack& undoRedoStack,
+RadiologyWindowingTracker(UndoRedoStack& undoRedoStack,
-BitmapStack& stack,
+RadiologyScene& scene,
 int x,
 int y,
 Action leftAction,
 Action rightAction,
 Action upAction,
 Action downAction) :
 undoRedoStack_(undoRedoStack),
-stack_(stack),
+scene_(scene),
 clickX_(x),
 clickY_(y),
 leftAction_(leftAction),
 rightAction_(rightAction),
 upAction_(upAction),
 downAction_(downAction)
 {
-stack_.GetWindowingWithDefault(sourceCenter_, sourceWidth_);
+scene_.GetWindowingWithDefault(sourceCenter_, sourceWidth_);
 float minValue, maxValue;
-stack.GetRange(minValue, maxValue);
+scene.GetRange(minValue, maxValue);
 assert(minValue <= maxValue);
 float tmp;
 ComputeAxisEffect(deltaCenter, deltaWidth, displayX - clickX_, leftAction_, rightAction_);
 ComputeAxisEffect(deltaCenter, deltaWidth, displayY - clickY_, upAction_, downAction_);
 float newCenter = sourceCenter_ + (deltaCenter / SCALE * strength_);
 float newWidth = sourceWidth_ + (deltaWidth / SCALE * strength_);
-stack_.SetWindowing(newCenter, newWidth);
+scene_.SetWindowing(newCenter, newWidth);
 }
 };
-class BitmapStackWidget :
+class RadiologyWidget :
 public WorldSceneWidget,
 public IObserver
 {
 private:
-BitmapStack&                   stack_;
+RadiologyScene&                scene_;
 std::auto_ptr<Orthanc::Image>  floatBuffer_;
 std::auto_ptr<CairoSurface>    cairoBuffer_;
 bool                           invert_;
 ImageInterpolation             interpolation_;
 bool                           hasSelection_;
-size_t                         selectedBitmap_;
+size_t                         selectedLayer_;
 virtual bool RenderInternal(unsigned int width,
 unsigned int height,
 ImageInterpolation interpolation)
 {
 float windowCenter, windowWidth;
-stack_.GetWindowingWithDefault(windowCenter, windowWidth);
+scene_.GetWindowingWithDefault(windowCenter, windowWidth);
 float x0 = windowCenter - windowWidth / 2.0f;
 float x1 = windowCenter + windowWidth / 2.0f;
 if (windowWidth <= 0.001f)  // Avoid division by zero at (*)
 cairoBuffer_->GetHeight() != height)
 {
 cairoBuffer_.reset(new CairoSurface(width, height));
 }
-stack_.Render(*floatBuffer_, GetView().GetMatrix(), interpolation);
+scene_.Render(*floatBuffer_, GetView().GetMatrix(), interpolation);
 // Conversion from Float32 to BGRA32 (cairo). Very similar to
 // GrayscaleFrameRenderer => TODO MERGE?
 Orthanc::ImageAccessor target;
 }
 protected:
 virtual Extent2D GetSceneExtent()
 {
-return stack_.GetSceneExtent();
+return scene_.GetSceneExtent();
 }
 virtual bool RenderScene(CairoContext& context,
 const ViewportGeometry& view)
 {
 cairo_paint(cr);
 }
 if (hasSelection_)
 {
-stack_.DrawBorder(context, selectedBitmap_, view.GetZoom());
+scene_.DrawBorder(context, selectedLayer_, view.GetZoom());
 }
 return true;
 }
 public:
-BitmapStackWidget(MessageBroker& broker,
+RadiologyWidget(MessageBroker& broker,
-BitmapStack& stack,
+RadiologyScene& scene,
 const std::string& name) :
 WorldSceneWidget(name),
 IObserver(broker),
-stack_(stack),
+scene_(scene),
 invert_(false),
 interpolation_(ImageInterpolation_Nearest),
 hasSelection_(false),
-selectedBitmap_(0)    // Dummy initialization
+selectedLayer_(0)    // Dummy initialization
 {
-stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::GeometryChangedMessage>(*this, &BitmapStackWidget::OnGeometryChanged));
+scene.RegisterObserverCallback(
-stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::ContentChangedMessage>(*this, &BitmapStackWidget::OnContentChanged));
+new Callable<RadiologyWidget, RadiologyScene::GeometryChangedMessage>
-}
+(*this, &RadiologyWidget::OnGeometryChanged));
-BitmapStack& GetStack() const
+scene.RegisterObserverCallback(
-{
+new Callable<RadiologyWidget, RadiologyScene::ContentChangedMessage>
-return stack_;
+(*this, &RadiologyWidget::OnContentChanged));
+}
+RadiologyScene& GetScene() const
+{
+return scene_;
 }
 void Unselect()
 {
 hasSelection_ = false;
 }
-void Select(size_t bitmap)
+void Select(size_t layer)
 {
 hasSelection_ = true;
-selectedBitmap_ = bitmap;
+selectedLayer_ = layer;
 }
-bool LookupSelectedBitmap(size_t& bitmap)
+bool LookupSelectedLayer(size_t& layer)
 {
 if (hasSelection_)
 {
-bitmap = selectedBitmap_;
+layer = selectedLayer_;
 return true;
 }
 else
 {
 return false;
 }
 }
-void OnGeometryChanged(const BitmapStack::GeometryChangedMessage& message)
+void OnGeometryChanged(const RadiologyScene::GeometryChangedMessage& message)
 {
 LOG(INFO) << "Geometry has changed";
 FitContent();
 }
-void OnContentChanged(const BitmapStack::ContentChangedMessage& message)
+void OnContentChanged(const RadiologyScene::ContentChangedMessage& message)
 {
 LOG(INFO) << "Content has changed";
 NotifyContentChanged();
 }
 return interpolation_;
 }
 };
-class BitmapStackInteractor :
+namespace Samples
-public IWorldSceneInteractor,
-public IObserver
 {
-private:
+class RadiologyEditorInteractor :
-enum Tool
+public IWorldSceneInteractor,
-{
+public IObserver
-Tool_Move,
+{
-Tool_Rotate,
+private:
-Tool_Crop,
+enum Tool
-Tool_Resize,
+{
-Tool_Windowing
+Tool_Move,
-};
+Tool_Rotate,
+Tool_Crop,
+Tool_Resize,
-UndoRedoStack      undoRedoStack_;
+Tool_Windowing
-Tool               tool_;
+};
-static double GetHandleSize()
+UndoRedoStack      undoRedoStack_;
-{
+Tool               tool_;
-return 10.0;
-}
+static double GetHandleSize()
+{
+return 10.0;
+}
 public:
-BitmapStackInteractor(MessageBroker& broker) :
+RadiologyEditorInteractor(MessageBroker& broker) :
 IObserver(broker),
 tool_(Tool_Move)
 {
 }
 virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& worldWidget,
 const ViewportGeometry& view,
 MouseButton button,
 KeyboardModifiers modifiers,
 int viewportX,
 int viewportY,
 double x,
 double y,
 IStatusBar* statusBar)
 {
-BitmapStackWidget& widget = dynamic_cast<BitmapStackWidget&>(worldWidget);
+RadiologyWidget& widget = dynamic_cast<RadiologyWidget&>(worldWidget);
 if (button == MouseButton_Left)
 {
 size_t selected;
 if (tool_ == Tool_Windowing)
 {
-return new WindowingTracker(undoRedoStack_, widget.GetStack(),
+return new RadiologyWindowingTracker(undoRedoStack_, widget.GetScene(),
 viewportX, viewportY,
-WindowingTracker::Action_DecreaseWidth,
+RadiologyWindowingTracker::Action_DecreaseWidth,
-WindowingTracker::Action_IncreaseWidth,
+RadiologyWindowingTracker::Action_IncreaseWidth,
-WindowingTracker::Action_DecreaseCenter,
+RadiologyWindowingTracker::Action_DecreaseCenter,
-WindowingTracker::Action_IncreaseCenter);
+RadiologyWindowingTracker::Action_IncreaseCenter);
 }
-else if (!widget.LookupSelectedBitmap(selected))
+else if (!widget.LookupSelectedLayer(selected))
 {
-// No bitmap is currently selected
+// No layer is currently selected
-size_t bitmap;
+size_t layer;
-if (widget.GetStack().LookupBitmap(bitmap, x, y))
+if (widget.GetScene().LookupLayer(layer, x, y))
-{
-widget.Select(bitmap);
-}
-return NULL;
-}
-else if (tool_ == Tool_Crop ||
-tool_ == Tool_Resize)
-{
-BitmapStack::BitmapAccessor accessor(widget.GetStack(), selected);
-BitmapStack::Corner corner;
-if (accessor.GetBitmap().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize()))
-{
-switch (tool_)
 {
-case Tool_Crop:
+widget.Select(layer);
-return new CropBitmapTracker(undoRedoStack_, widget.GetStack(), view, selected, x, y, corner);
-case Tool_Resize:
-return new ResizeBitmapTracker(undoRedoStack_, widget.GetStack(), selected, x, y, corner,
-(modifiers & KeyboardModifiers_Shift));
-default:
-throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
+return NULL;
+}
+else if (tool_ == Tool_Crop ||
+tool_ == Tool_Resize)
+{
+RadiologyScene::LayerAccessor accessor(widget.GetScene(), selected);
+RadiologyScene::Corner corner;
+if (accessor.GetLayer().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize()))
+{
+switch (tool_)
+{
+case Tool_Crop:
+return new RadiologyLayerCropTracker(undoRedoStack_, widget.GetScene(), view, selected, x, y, corner);
+case Tool_Resize:
+return new RadiologyLayerResizeTracker(undoRedoStack_, widget.GetScene(), selected, x, y, corner,
+(modifiers & KeyboardModifiers_Shift));
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+}
+else
+{
+size_t layer;
+if (widget.GetScene().LookupLayer(layer, x, y))
+{
+widget.Select(layer);
+}
+else
+{
+widget.Unselect();
+}
+return NULL;
+}
 }
 else
 {
-size_t bitmap;
+size_t layer;
-if (widget.GetStack().LookupBitmap(bitmap, x, y))
+if (widget.GetScene().LookupLayer(layer, x, y))
 {
-widget.Select(bitmap);
+if (layer == selected)
+{
+switch (tool_)
+{
+case Tool_Move:
+return new RadiologyLayerMoveTracker(undoRedoStack_, widget.GetScene(), layer, x, y,
+(modifiers & KeyboardModifiers_Shift));
+case Tool_Rotate:
+return new RadiologyLayerRotateTracker(undoRedoStack_, widget.GetScene(), view, layer, x, y,
+(modifiers & KeyboardModifiers_Shift));
+default:
+break;
+}
+return NULL;
+}
+else
+{
+widget.Select(layer);
+return NULL;
+}
 }
 else
 {
 widget.Unselect();
-}
-return NULL;
-}
-}
-else
-{
-size_t bitmap;
-if (widget.GetStack().LookupBitmap(bitmap, x, y))
-{
-if (bitmap == selected)
-{
-switch (tool_)
-{
-case Tool_Move:
-return new MoveBitmapTracker(undoRedoStack_, widget.GetStack(), bitmap, x, y,
-(modifiers & KeyboardModifiers_Shift));
-case Tool_Rotate:
-return new RotateBitmapTracker(undoRedoStack_, widget.GetStack(), view, bitmap, x, y,
-(modifiers & KeyboardModifiers_Shift));
-default:
-break;
-}
 return NULL;
 }
-else
+}
+}
+else
+{
+return NULL;
+}
+}
+virtual void MouseOver(CairoContext& context,
+WorldSceneWidget& worldWidget,
+const ViewportGeometry& view,
+double x,
+double y,
+IStatusBar* statusBar)
+{
+RadiologyWidget& widget = dynamic_cast<RadiologyWidget&>(worldWidget);
+#if 0
+if (statusBar != NULL)
+{
+char buf[64];
+sprintf(buf, "X = %.02f Y = %.02f (in cm)", x / 10.0, y / 10.0);
+statusBar->SetMessage(buf);
+}
+#endif
+size_t selected;
+if (widget.LookupSelectedLayer(selected) &&
+(tool_ == Tool_Crop ||
+tool_ == Tool_Resize))
+{
+RadiologyScene::LayerAccessor accessor(widget.GetScene(), selected);
+RadiologyScene::Corner corner;
+if (accessor.GetLayer().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize()))
+{
+accessor.GetLayer().GetCorner(x, y, corner);
+double z = 1.0 / view.GetZoom();
+context.SetSourceColor(255, 0, 0);
+cairo_t* cr = context.GetObject();
+cairo_set_line_width(cr, 2.0 * z);
+cairo_move_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z);
+cairo_line_to(cr, x + GetHandleSize() * z, y - GetHandleSize() * z);
+cairo_line_to(cr, x + GetHandleSize() * z, y + GetHandleSize() * z);
+cairo_line_to(cr, x - GetHandleSize() * z, y + GetHandleSize() * z);
+cairo_line_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z);
+cairo_stroke(cr);
+}
+}
+}
+virtual void MouseWheel(WorldSceneWidget& widget,
+MouseWheelDirection direction,
+KeyboardModifiers modifiers,
+IStatusBar* statusBar)
+{
+}
+virtual void KeyPressed(WorldSceneWidget& worldWidget,
+KeyboardKeys key,
+char keyChar,
+KeyboardModifiers modifiers,
+IStatusBar* statusBar)
+{
+RadiologyWidget& widget = dynamic_cast<RadiologyWidget&>(worldWidget);
+switch (keyChar)
+{
+case 'a':
+widget.FitContent();
+break;
+case 'c':
+tool_ = Tool_Crop;
+break;
+case 'e':
+{
+Orthanc::DicomMap tags;
+// Minimal set of tags to generate a valid CR image
+tags.SetValue(Orthanc::DICOM_TAG_ACCESSION_NUMBER, "NOPE", false);
+tags.SetValue(Orthanc::DICOM_TAG_BODY_PART_EXAMINED, "PELVIS", false);
+tags.SetValue(Orthanc::DICOM_TAG_INSTANCE_NUMBER, "1", false);
+//tags.SetValue(Orthanc::DICOM_TAG_LATERALITY, "", false);
+tags.SetValue(Orthanc::DICOM_TAG_MANUFACTURER, "OSIMIS", false);
+tags.SetValue(Orthanc::DICOM_TAG_MODALITY, "CR", false);
+tags.SetValue(Orthanc::DICOM_TAG_PATIENT_BIRTH_DATE, "20000101", false);
+tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ID, "hello", false);
+tags.SetValue(Orthanc::DICOM_TAG_PATIENT_NAME, "HELLO^WORLD", false);
+tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ORIENTATION, "", false);
+tags.SetValue(Orthanc::DICOM_TAG_PATIENT_SEX, "M", false);
+tags.SetValue(Orthanc::DICOM_TAG_REFERRING_PHYSICIAN_NAME, "HOUSE^MD", false);
+tags.SetValue(Orthanc::DICOM_TAG_SERIES_NUMBER, "1", false);
+tags.SetValue(Orthanc::DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.1", false);
+tags.SetValue(Orthanc::DICOM_TAG_STUDY_ID, "STUDY", false);
+tags.SetValue(Orthanc::DICOM_TAG_VIEW_POSITION, "", false);
+widget.GetScene().Export(tags, 0.1, 0.1, widget.IsInverted(),
+widget.GetInterpolation(), EXPORT_USING_PAM);
+break;
+}
+case 'i':
+widget.SwitchInvert();
+break;
+case 'm':
+tool_ = Tool_Move;
+break;
+case 'n':
+{
+switch (widget.GetInterpolation())
 {
-widget.Select(bitmap);
+case ImageInterpolation_Nearest:
-return NULL;
+LOG(INFO) << "Switching to bilinear interpolation";
+widget.SetInterpolation(ImageInterpolation_Bilinear);
+break;
+case ImageInterpolation_Bilinear:
+LOG(INFO) << "Switching to nearest neighbor interpolation";
+widget.SetInterpolation(ImageInterpolation_Nearest);
+break;
+default:
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
-}
-else
-{
-widget.Unselect();
-return NULL;
-}
-}
-}
-else
-{
-return NULL;
-}
-}
-virtual void MouseOver(CairoContext& context,
-WorldSceneWidget& worldWidget,
-const ViewportGeometry& view,
-double x,
-double y,
-IStatusBar* statusBar)
-{
-BitmapStackWidget& widget = dynamic_cast<BitmapStackWidget&>(worldWidget);
-#if 0
-if (statusBar != NULL)
-{
-char buf[64];
-sprintf(buf, "X = %.02f Y = %.02f (in cm)", x / 10.0, y / 10.0);
-statusBar->SetMessage(buf);
-}
-#endif
-size_t selected;
-if (widget.LookupSelectedBitmap(selected) &&
-(tool_ == Tool_Crop ||
-tool_ == Tool_Resize))
-{
-BitmapStack::BitmapAccessor accessor(widget.GetStack(), selected);
-BitmapStack::Corner corner;
-if (accessor.GetBitmap().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize()))
-{
-accessor.GetBitmap().GetCorner(x, y, corner);
-double z = 1.0 / view.GetZoom();
+break;
+}
-context.SetSourceColor(255, 0, 0);
-cairo_t* cr = context.GetObject();
+case 'r':
-cairo_set_line_width(cr, 2.0 * z);
+tool_ = Tool_Rotate;
-cairo_move_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z);
+break;
-cairo_line_to(cr, x + GetHandleSize() * z, y - GetHandleSize() * z);
-cairo_line_to(cr, x + GetHandleSize() * z, y + GetHandleSize() * z);
+case 's':
-cairo_line_to(cr, x - GetHandleSize() * z, y + GetHandleSize() * z);
+tool_ = Tool_Resize;
-cairo_line_to(cr, x - GetHandleSize() * z, y - GetHandleSize() * z);
+break;
-cairo_stroke(cr);
-}
+case 'w':
-}
+tool_ = Tool_Windowing;
-}
+break;
-virtual void MouseWheel(WorldSceneWidget& widget,
+case 'y':
-MouseWheelDirection direction,
+if (modifiers & KeyboardModifiers_Control)
-KeyboardModifiers modifiers,
+{
-IStatusBar* statusBar)
+undoRedoStack_.Redo();
-{
+widget.NotifyContentChanged();
 }
+break;
-virtual void KeyPressed(WorldSceneWidget& worldWidget,
-KeyboardKeys key,
+case 'z':
-char keyChar,
+if (modifiers & KeyboardModifiers_Control)
-KeyboardModifiers modifiers,
+{
-IStatusBar* statusBar)
+undoRedoStack_.Undo();
-{
+widget.NotifyContentChanged();
-BitmapStackWidget& widget = dynamic_cast<BitmapStackWidget&>(worldWidget);
+}
+break;
-switch (keyChar)
-{
+default:
-case 'a':
+break;
-widget.FitContent();
+}
-break;
+}
+};
-case 'c':
-tool_ = Tool_Crop;
-break;
-case 'e':
-{
-Orthanc::DicomMap tags;
-// Minimal set of tags to generate a valid CR image
-tags.SetValue(Orthanc::DICOM_TAG_ACCESSION_NUMBER, "NOPE", false);
-tags.SetValue(Orthanc::DICOM_TAG_BODY_PART_EXAMINED, "PELVIS", false);
-tags.SetValue(Orthanc::DICOM_TAG_INSTANCE_NUMBER, "1", false);
-//tags.SetValue(Orthanc::DICOM_TAG_LATERALITY, "", false);
-tags.SetValue(Orthanc::DICOM_TAG_MANUFACTURER, "OSIMIS", false);
-tags.SetValue(Orthanc::DICOM_TAG_MODALITY, "CR", false);
-tags.SetValue(Orthanc::DICOM_TAG_PATIENT_BIRTH_DATE, "20000101", false);
-tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ID, "hello", false);
-tags.SetValue(Orthanc::DICOM_TAG_PATIENT_NAME, "HELLO^WORLD", false);
-tags.SetValue(Orthanc::DICOM_TAG_PATIENT_ORIENTATION, "", false);
-tags.SetValue(Orthanc::DICOM_TAG_PATIENT_SEX, "M", false);
-tags.SetValue(Orthanc::DICOM_TAG_REFERRING_PHYSICIAN_NAME, "HOUSE^MD", false);
-tags.SetValue(Orthanc::DICOM_TAG_SERIES_NUMBER, "1", false);
-tags.SetValue(Orthanc::DICOM_TAG_SOP_CLASS_UID, "1.2.840.10008.5.1.4.1.1.1", false);
-tags.SetValue(Orthanc::DICOM_TAG_STUDY_ID, "STUDY", false);
-tags.SetValue(Orthanc::DICOM_TAG_VIEW_POSITION, "", false);
-widget.GetStack().Export(tags, 0.1, 0.1, widget.IsInverted(), widget.GetInterpolation());
-break;
-}
-case 'i':
-widget.SwitchInvert();
-break;
-case 'm':
-tool_ = Tool_Move;
-break;
-case 'n':
-{
-switch (widget.GetInterpolation())
-{
-case ImageInterpolation_Nearest:
-LOG(INFO) << "Switching to bilinear interpolation";
-widget.SetInterpolation(ImageInterpolation_Bilinear);
-break;
-case ImageInterpolation_Bilinear:
-LOG(INFO) << "Switching to nearest neighbor interpolation";
-widget.SetInterpolation(ImageInterpolation_Nearest);
-break;
-default:
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
-}
-break;
-}
-case 'r':
-tool_ = Tool_Rotate;
-break;
-case 's':
-tool_ = Tool_Resize;
-break;
-case 'w':
-tool_ = Tool_Windowing;
-break;
-case 'y':
-if (modifiers & KeyboardModifiers_Control)
-{
-undoRedoStack_.Redo();
-widget.NotifyContentChanged();
-}
-break;
-case 'z':
-if (modifiers & KeyboardModifiers_Control)
-{
-undoRedoStack_.Undo();
-widget.NotifyContentChanged();
-}
-break;
-default:
-break;
-}
-}
-};
-namespace Samples
-{
 class SingleFrameEditorApplication :
 public SampleSingleCanvasApplicationBase,
 public IObserver
 {
 private:
 std::auto_ptr<OrthancApiClient>  orthancApiClient_;
-std::auto_ptr<BitmapStack>       stack_;
+std::auto_ptr<RadiologyScene>    scene_;
-BitmapStackInteractor            interactor_;
+RadiologyEditorInteractor        interactor_;
 public:
 SingleFrameEditorApplication(MessageBroker& broker) :
 IObserver(broker),
 interactor_(broker)
 statusBar.SetMessage("Use the key \"f\" to switch full screen");
 statusBar.SetMessage("Use the key \"i\" to invert contrast");
 statusBar.SetMessage("Use the key \"m\" to move objects");
 statusBar.SetMessage("Use the key \"n\" to switch between nearest neighbor and bilinear interpolation");
 statusBar.SetMessage("Use the key \"r\" to rotate objects");
-statusBar.SetMessage("Use the key \"s\" to resize objects (not applicable to DICOM bitmaps)");
+statusBar.SetMessage("Use the key \"s\" to resize objects (not applicable to DICOM layers)");
 statusBar.SetMessage("Use the key \"w\" to change windowing");
 statusBar.SetMessage("Use the key \"ctrl-z\" to undo action");
 statusBar.SetMessage("Use the key \"ctrl-y\" to redo action");
 orthancApiClient_.reset(new OrthancApiClient(GetBroker(), context_->GetWebService()));
 Orthanc::FontRegistry fonts;
 fonts.AddFromResource(Orthanc::EmbeddedResources::FONT_UBUNTU_MONO_BOLD_16);
-stack_.reset(new BitmapStack(GetBroker(), *orthancApiClient_));
+scene_.reset(new RadiologyScene(GetBroker(), *orthancApiClient_));
-stack_->LoadFrame(instance, frame, false); //.SetPan(200, 0);
+scene_->LoadDicomFrame(instance, frame, false); //.SetPan(200, 0);
-//stack_->LoadFrame("61f3143e-96f34791-ad6bbb8d-62559e75-45943e1b", 0, false);
+//scene_->LoadDicomFrame("61f3143e-96f34791-ad6bbb8d-62559e75-45943e1b", 0, false);
 {
-BitmapStack::Bitmap& bitmap = stack_->LoadText(fonts.GetFont(0), "Hello\nworld");
+RadiologyScene::Layer& layer = scene_->LoadText(fonts.GetFont(0), "Hello\nworld");
-//dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetForegroundValue(256);
+//dynamic_cast<RadiologyScene::Layer&>(layer).SetForegroundValue(256);
-dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetResizeable(true);
+dynamic_cast<RadiologyScene::Layer&>(layer).SetResizeable(true);
 }
 {
-BitmapStack::Bitmap& bitmap = stack_->LoadTestBlock(100, 50);
+RadiologyScene::Layer& layer = scene_->LoadTestBlock(100, 50);
-//dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetForegroundValue(256);
+//dynamic_cast<RadiologyScene::Layer&>(layer).SetForegroundValue(256);
-dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetResizeable(true);
+dynamic_cast<RadiologyScene::Layer&>(layer).SetResizeable(true);
-dynamic_cast<BitmapStack::AlphaBitmap&>(bitmap).SetPan(0, 200);
+dynamic_cast<RadiologyScene::Layer&>(layer).SetPan(0, 200);
 }
-mainWidget_ = new BitmapStackWidget(GetBroker(), *stack_, "main-widget");
+mainWidget_ = new RadiologyWidget(GetBroker(), *scene_, "main-widget");
 mainWidget_->SetTransmitMouseOver(true);
 mainWidget_->SetInteractor(interactor_);
-//stack_->SetWindowing(128, 256);
+//scene_->SetWindowing(128, 256);
 }
 };
 }
 }

Mercurial > hg > orthanc-stone

comparison Applications/Samples/SingleFrameEditorApplication.h @ 407:842a3c7cfdc0