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

comparison Applications/Samples/SingleFrameEditorApplication.h @ 384:d20d75f20c5d

better following of the MVC design pattern

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 07 Nov 2018 16:17:02 +0100
parents	8eb4fe74000f
children	d87fe075d31b

comparison

equal deleted inserted replaced

-:939f626eb6d7
+:d20d75f20c5d
 ApplyTransform(x, y, transform_);
 }
 public:
-Bitmap(size_t index) :
+Bitmap() :
-index_(index),
+index_(0),
 hasSize_(false),
 width_(0),
 height_(0),
 hasCrop_(false),
 pixelSpacingX_(1),
 virtual ~Bitmap()
 {
 }
+void SetIndex(size_t index)
+{
+index_ = index;
+}
 size_t GetIndex() const
 {
 return index_;
 }
 std::auto_ptr<Orthanc::ImageAccessor>  alpha_;      // Grayscale8
 bool                                   useWindowing_;
 float                                  foreground_;
 public:
-AlphaBitmap(size_t index,
+AlphaBitmap(const BitmapStack& stack) :
-const BitmapStack& stack) :
-Bitmap(index),
 stack_(stack),
 useWindowing_(true),
 foreground_(0)
 {
 }
 virtual void Render(Orthanc::ImageAccessor& buffer,
 const Matrix& viewTransform,
 ImageInterpolation interpolation) const
 {
+if (alpha_.get() == NULL)
+{
+return;
+}
 if (buffer.GetFormat() != Orthanc::PixelFormat_Float32)
 {
 throw Orthanc::OrthancException(Orthanc::ErrorCode_IncompatibleImageFormat);
 }
 converted_.reset(converter_->ConvertFrame(*source_));
 }
 }
 public:
-DicomBitmap(size_t index) :
-Bitmap(index)
-{
-}
 void SetDicomTags(const OrthancPlugins::FullOrthancDataset& dataset)
 {
 converter_.reset(new DicomFrameConverter);
 converter_->ReadParameters(dataset);
 ApplyConverter();
 size_t             countBitmaps_;
 bool               hasWindowing_;
 float              windowingCenter_;
 float              windowingWidth_;
 Bitmaps            bitmaps_;
-bool               hasSelection_;
-size_t             selectedBitmap_;
 public:
 BitmapStack(MessageBroker& broker,
 OrthancApiClient& orthanc) :
 IObserver(broker),
 IObservable(broker),
 orthanc_(orthanc),
 countBitmaps_(0),
 hasWindowing_(false),
 windowingCenter_(0),  // Dummy initialization
-windowingWidth_(0),   // Dummy initialization
+windowingWidth_(0)    // Dummy initialization
-hasSelection_(false),
+{
-selectedBitmap_(0)    // Dummy initialization
+}
-{
-}
-void Unselect()
-{
-hasSelection_ = false;
-}
-void Select(size_t bitmap)
-{
-hasSelection_ = true;
-selectedBitmap_ = bitmap;
-}
-bool GetSelectedBitmap(size_t& bitmap) const
-{
-if (hasSelection_)
-{
-bitmap = selectedBitmap_;
-return true;
-}
-else
-{
-return false;
-}
-}
 virtual ~BitmapStack()
 {
 for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); it++)
 {
 assert(it->second != NULL);
 {
 hasWindowing_ = true;
 windowingCenter_ = center;
 windowingWidth_ = width;
+}
-//EmitMessage(ContentChangedMessage(*this));
+Bitmap& RegisterBitmap(Bitmap* bitmap)
+{
+if (bitmap == NULL)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer);
+}
+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;
 }
 Bitmap& LoadText(const Orthanc::Font& font,
 const std::string& utf8)
 {
-size_t bitmap = countBitmaps_++;
+std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(*this));
-std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(bitmap, *this));
 alpha->LoadText(font, utf8);
-AlphaBitmap* ptr = alpha.get();
+return RegisterBitmap(alpha.release());
-bitmaps_[bitmap] = alpha.release();
-return *ptr;
 }
 Bitmap& LoadTestBlock(unsigned int width,
 unsigned int height)
 {
-size_t bitmap = countBitmaps_++;
-std::auto_ptr<AlphaBitmap>  alpha(new AlphaBitmap(bitmap, *this));
 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);
 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));
 alpha->SetAlpha(block.release());
-AlphaBitmap* ptr = alpha.get();
+return RegisterBitmap(alpha.release());
-bitmaps_[bitmap] = alpha.release();
-return *ptr;
 }
 Bitmap& LoadFrame(const std::string& instance,
 unsigned int frame,
 bool httpCompression)
 {
-size_t bitmap = countBitmaps_++;
+Bitmap& bitmap = RegisterBitmap(new DicomBitmap);
-bitmaps_[bitmap] = new DicomBitmap(bitmap);
 {
 IWebService::Headers headers;
 std::string uri = "/instances/" + instance + "/tags";
 orthanc_.GetBinaryAsync(uri, headers,
 new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage>
 (*this, &BitmapStack::OnTagsReceived), NULL,
-new Orthanc::SingleValueObject<size_t>(bitmap));
+new Orthanc::SingleValueObject<size_t>(bitmap.GetIndex()));
 }
 {
 IWebService::Headers headers;
 headers["Accept"] = "image/x-portable-arbitrarymap";
 std::string uri = "/instances/" + instance + "/frames/" + boost::lexical_cast<std::string>(frame) + "/image-uint16";
 orthanc_.GetBinaryAsync(uri, headers,
 new Callable<BitmapStack, OrthancApiClient::BinaryResponseReadyMessage>
 (*this, &BitmapStack::OnFrameReceived), NULL,
-new Orthanc::SingleValueObject<size_t>(bitmap));
+new Orthanc::SingleValueObject<size_t>(bitmap.GetIndex()));
 }
-return *bitmaps_[bitmap];
+return bitmap;
 }
 void OnTagsReceived(const OrthancApiClient::BinaryResponseReadyMessage& message)
 {
 }
 return false;
 }
-void DrawControls(CairoContext& context,
-double zoom)
+void DrawBorder(CairoContext& context,
-{
+unsigned int bitmap,
-if (hasSelection_)
+double zoom)
 {
-Bitmaps::const_iterator bitmap = bitmaps_.find(selectedBitmap_);
+Bitmaps::const_iterator found = bitmaps_.find(bitmap);
-if (bitmap != bitmaps_.end())
+if (found != bitmaps_.end())
 {
 context.SetSourceColor(255, 0, 0);
-//view.ApplyTransform(context);
+found->second->DrawBorders(context, zoom);
-bitmap->second->DrawBorders(context, zoom);
-}
 }
 }
 void GetRange(float& minValue,
 if (first)
 {
 minValue = 0;
 maxValue = 0;
 }
+}
+void Export(const Orthanc::DicomMap& dicom,
+double pixelSpacingX,
+double pixelSpacingY,
+bool invert,
+ImageInterpolation interpolation)
+{
+if (pixelSpacingX <= 0 ||
+pixelSpacingY <= 0)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
+}
+LOG(WARNING) << "Exporting DICOM";
+Extent2D extent = GetSceneExtent();
+int w = std::ceil(extent.GetWidth() / pixelSpacingX);
+int h = std::ceil(extent.GetHeight() / pixelSpacingY);
+if (w < 0 || h < 0)
+{
+throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
+}
+Orthanc::Image layers(Orthanc::PixelFormat_Float32,
+static_cast<unsigned int>(w),
+static_cast<unsigned int>(h), false);
+Matrix view = LinearAlgebra::Product(
+CreateScalingMatrix(1.0 / pixelSpacingX, 1.0 / pixelSpacingY),
+CreateOffsetMatrix(-extent.GetX1(), -extent.GetY1()));
+Render(layers, view, interpolation);
+Orthanc::Image rendered(Orthanc::PixelFormat_Grayscale16,
+layers.GetWidth(), layers.GetHeight(), false);
+Orthanc::ImageProcessing::Convert(rendered, layers);
+std::string base64;
+{
+std::string content;
+#if EXPORT_USING_PAM == 1
+{
+Orthanc::PamWriter writer;
+writer.WriteToMemory(content, rendered);
+}
+#else
+{
+Orthanc::PngWriter writer;
+writer.WriteToMemory(content, rendered);
+}
+#endif
+Orthanc::Toolbox::EncodeBase64(base64, content);
+}
+std::set<Orthanc::DicomTag> tags;
+dicom.GetTags(tags);
+Json::Value json = Json::objectValue;
+json["Tags"] = Json::objectValue;
+for (std::set<Orthanc::DicomTag>::const_iterator
+tag = tags.begin(); tag != tags.end(); ++tag)
+{
+const Orthanc::DicomValue& value = dicom.GetValue(*tag);
+if (!value.IsNull() &&
+!value.IsBinary())
+{
+json["Tags"][tag->Format()] = value.GetContent();
+}
+}
+json["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] =
+(invert ? "MONOCHROME1" : "MONOCHROME2");
+// WARNING: The order of PixelSpacing is Y/X
+char buf[32];
+sprintf(buf, "%0.8f\\%0.8f", pixelSpacingY, pixelSpacingX);
+json["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf;
+float center, width;
+if (GetWindowing(center, width))
+{
+json["Tags"][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()] =
+boost::lexical_cast<std::string>(boost::math::iround(center));
+json["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] =
+boost::lexical_cast<std::string>(boost::math::iround(width));
+}
+#if EXPORT_USING_PAM == 1
+json["Content"] = "data:" + std::string(Orthanc::MIME_PAM) + ";base64," + base64;
+#else
+json["Content"] = "data:" + std::string(Orthanc::MIME_PNG) + ";base64," + base64;
+#endif
+orthanc_.PostJsonAsyncExpectJson(
+"/tools/create-dicom", json,
+new Callable<BitmapStack, OrthancApiClient::JsonResponseReadyMessage>
+(*this, &BitmapStack::OnDicomExported),
+NULL, NULL);
+}
+void OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message)
+{
+LOG(WARNING) << "DICOM export was successful:"
+<< message.GetJson().toStyledString();
 }
 };
 class UndoRedoStack : public boost::noncopyable
 };
 class BitmapStackWidget :
 public WorldSceneWidget,
-public IObservable,
 public IObserver
 {
 private:
 BitmapStack&                   stack_;
 std::auto_ptr<Orthanc::Image>  floatBuffer_;
 std::auto_ptr<CairoSurface>    cairoBuffer_;
 bool                           invert_;
 ImageInterpolation             interpolation_;
+bool                           hasSelection_;
+size_t                         selectedBitmap_;
 virtual bool RenderInternal(unsigned int width,
 unsigned int height,
 ImageInterpolation interpolation)
 {
 return true;
 }
 }
 protected:
 virtual Extent2D GetSceneExtent()
 {
 return stack_.GetSceneExtent();
 }
 // https://www.cairographics.org/FAQ/#clear_a_surface
 context.SetSourceColor(0, 0, 0);
 cairo_paint(cr);
 }
-stack_.DrawControls(context, view.GetZoom());
+if (hasSelection_)
+{
+stack_.DrawBorder(context, selectedBitmap_, view.GetZoom());
+}
 return true;
 }
 public:
 BitmapStackWidget(MessageBroker& broker,
 BitmapStack& stack,
 const std::string& name) :
 WorldSceneWidget(name),
-IObservable(broker),
 IObserver(broker),
 stack_(stack),
 invert_(false),
-interpolation_(ImageInterpolation_Nearest)
+interpolation_(ImageInterpolation_Nearest),
+hasSelection_(false),
+selectedBitmap_(0)    // Dummy initialization
 {
 stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::GeometryChangedMessage>(*this, &BitmapStackWidget::OnGeometryChanged));
 stack.RegisterObserverCallback(new Callable<BitmapStackWidget, BitmapStack::ContentChangedMessage>(*this, &BitmapStackWidget::OnContentChanged));
 }
 BitmapStack& GetStack() const
 {
 return stack_;
 }
+void Unselect()
+{
+hasSelection_ = false;
+}
+void Select(size_t bitmap)
+{
+hasSelection_ = true;
+selectedBitmap_ = bitmap;
+}
+bool LookupSelectedBitmap(size_t& bitmap)
+{
+if (hasSelection_)
+{
+bitmap = selectedBitmap_;
+return true;
+}
+else
+{
+return false;
+}
+}
 void OnGeometryChanged(const BitmapStack::GeometryChangedMessage& message)
 {
 LOG(INFO) << "Geometry has changed";
 FitContent();
 }
 {
 invert_ = !invert_;
 NotifyContentChanged();
 }
-bool IsInvert() const
+bool IsInverted() const
 {
 return invert_;
 }
 void SetInterpolation(ImageInterpolation interpolation)
 };
 UndoRedoStack      undoRedoStack_;
 Tool               tool_;
-OrthancApiClient  *orthanc_;
 static double GetHandleSize()
 {
 return 10.0;
 }
-static BitmapStackWidget& GetWidget(WorldSceneWidget& widget)
-{
-return dynamic_cast<BitmapStackWidget&>(widget);
-}
-static BitmapStack& GetStack(WorldSceneWidget& widget)
-{
-return GetWidget(widget).GetStack();
-}
 public:
 BitmapStackInteractor(MessageBroker& broker) :
 IObserver(broker),
-tool_(Tool_Move),
+tool_(Tool_Move)
-orthanc_(NULL)
 {
 }
-virtual IWorldSceneMouseTracker* CreateMouseTracker(WorldSceneWidget& widget,
+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);
 if (button == MouseButton_Left)
 {
 size_t selected;
 if (tool_ == Tool_Windowing)
 {
-return new WindowingTracker(undoRedoStack_, GetStack(widget),
+return new WindowingTracker(undoRedoStack_, widget.GetStack(),
 viewportX, viewportY,
 WindowingTracker::Action_DecreaseWidth,
 WindowingTracker::Action_IncreaseWidth,
 WindowingTracker::Action_DecreaseCenter,
 WindowingTracker::Action_IncreaseCenter);
 }
-else if (!GetStack(widget).GetSelectedBitmap(selected))
+else if (!widget.LookupSelectedBitmap(selected))
 {
+// No bitmap is currently selected
 size_t bitmap;
-if (GetStack(widget).LookupBitmap(bitmap, x, y))
+if (widget.GetStack().LookupBitmap(bitmap, x, y))
 {
-LOG(INFO) << "Click on bitmap " << bitmap;
+widget.Select(bitmap);
-GetStack(widget).Select(bitmap);
 }
 return NULL;
 }
 else if (tool_ == Tool_Crop ||
 tool_ == Tool_Resize)
 {
-BitmapStack::BitmapAccessor accessor(GetStack(widget), selected);
+BitmapStack::BitmapAccessor accessor(widget.GetStack(), selected);
 BitmapStack::Corner corner;
 if (accessor.GetBitmap().LookupCorner(corner, x, y, view.GetZoom(), GetHandleSize()))
 {
 switch (tool_)
 {
 case Tool_Crop:
-return new CropBitmapTracker(undoRedoStack_, GetStack(widget), view, selected, x, y, corner);
+return new CropBitmapTracker(undoRedoStack_, widget.GetStack(), view, selected, x, y, corner);
 case Tool_Resize:
-return new ResizeBitmapTracker(undoRedoStack_, GetStack(widget), selected, x, y, corner,
+return new ResizeBitmapTracker(undoRedoStack_, widget.GetStack(), selected, x, y, corner,
 (modifiers & KeyboardModifiers_Shift));
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
 }
 }
 else
 {
 size_t bitmap;
-if (!GetStack(widget).LookupBitmap(bitmap, x, y) ||
+if (widget.GetStack().LookupBitmap(bitmap, x, y))
-bitmap != selected)
 {
-GetStack(widget).Unselect();
+widget.Select(bitmap);
+}
+else
+{
+widget.Unselect();
 }
 return NULL;
 }
 }
 else
 {
 size_t bitmap;
-if (GetStack(widget).LookupBitmap(bitmap, x, y) &&
+if (widget.GetStack().LookupBitmap(bitmap, x, y))
-bitmap == selected)
+{
-{
+if (bitmap == selected)
-switch (tool_)
 {
-case Tool_Move:
+switch (tool_)
-return new MoveBitmapTracker(undoRedoStack_, GetStack(widget), bitmap, x, y,
+{
-(modifiers & KeyboardModifiers_Shift));
+case Tool_Move:
+return new MoveBitmapTracker(undoRedoStack_, widget.GetStack(), bitmap, x, y,
-case Tool_Rotate:
-return new RotateBitmapTracker(undoRedoStack_, GetStack(widget), view, 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
+{
+widget.Select(bitmap);
+return NULL;
+}
+}
+else
+{
+widget.Unselect();
 return NULL;
 }
-else
-{
-LOG(INFO) << "Click out of any bitmap";
-GetStack(widget).Unselect();
-return NULL;
-}
 }
 }
 else
 {
 return NULL;
 }
 }
 virtual void MouseOver(CairoContext& context,
-WorldSceneWidget& widget,
+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 (GetStack(widget).GetSelectedBitmap(selected) &&
+if (widget.LookupSelectedBitmap(selected) &&
 (tool_ == Tool_Crop ||
 tool_ == Tool_Resize))
 {
-BitmapStack::BitmapAccessor accessor(GetStack(widget), selected);
+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);
 KeyboardModifiers modifiers,
 IStatusBar* statusBar)
 {
 }
-virtual void KeyPressed(WorldSceneWidget& widget,
+virtual void KeyPressed(WorldSceneWidget& worldWidget,
 KeyboardKeys key,
 char keyChar,
 KeyboardModifiers modifiers,
 IStatusBar* statusBar)
 {
+BitmapStackWidget& widget = dynamic_cast<BitmapStackWidget&>(worldWidget);
 switch (keyChar)
 {
 case 'a':
 widget.FitContent();
 break;
 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);
-Export(GetWidget(widget), 0.1, 0.1, tags);
+widget.GetStack().Export(tags, 0.1, 0.1, widget.IsInverted(), widget.GetInterpolation());
 break;
 }
 case 'i':
-GetWidget(widget).SwitchInvert();
+widget.SwitchInvert();
 break;
 case 'm':
 tool_ = Tool_Move;
 break;
 case 'n':
 {
-switch (GetWidget(widget).GetInterpolation())
+switch (widget.GetInterpolation())
 {
 case ImageInterpolation_Nearest:
 LOG(INFO) << "Switching to bilinear interpolation";
-GetWidget(widget).SetInterpolation(ImageInterpolation_Bilinear);
+widget.SetInterpolation(ImageInterpolation_Bilinear);
 break;
 case ImageInterpolation_Bilinear:
 LOG(INFO) << "Switching to nearest neighbor interpolation";
-GetWidget(widget).SetInterpolation(ImageInterpolation_Nearest);
+widget.SetInterpolation(ImageInterpolation_Nearest);
 break;
 default:
 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
 }
 break;
 default:
 break;
 }
-}
-void SetOrthanc(OrthancApiClient& orthanc)
-{
-orthanc_ = &orthanc;
-}
-void Export(const BitmapStackWidget& widget,
-double pixelSpacingX,
-double pixelSpacingY,
-const Orthanc::DicomMap& dicom)
-{
-if (pixelSpacingX <= 0 ||
-pixelSpacingY <= 0)
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange);
-}
-if (orthanc_ == NULL)
-{
-return;
-}
-LOG(WARNING) << "Exporting DICOM";
-Extent2D extent = widget.GetStack().GetSceneExtent();
-int w = std::ceil(extent.GetWidth() / pixelSpacingX);
-int h = std::ceil(extent.GetHeight() / pixelSpacingY);
-if (w < 0 || h < 0)
-{
-throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError);
-}
-Orthanc::Image layers(Orthanc::PixelFormat_Float32,
-static_cast<unsigned int>(w),
-static_cast<unsigned int>(h), false);
-Matrix view = LinearAlgebra::Product(
-CreateScalingMatrix(1.0 / pixelSpacingX, 1.0 / pixelSpacingY),
-CreateOffsetMatrix(-extent.GetX1(), -extent.GetY1()));
-widget.GetStack().Render(layers, view, widget.GetInterpolation());
-Orthanc::Image rendered(Orthanc::PixelFormat_Grayscale16,
-layers.GetWidth(), layers.GetHeight(), false);
-Orthanc::ImageProcessing::Convert(rendered, layers);
-std::string base64;
-{
-std::string content;
-#if EXPORT_USING_PAM == 1
-{
-Orthanc::PamWriter writer;
-writer.WriteToMemory(content, rendered);
-}
-#else
-{
-Orthanc::PngWriter writer;
-writer.WriteToMemory(content, rendered);
-}
-#endif
-Orthanc::Toolbox::EncodeBase64(base64, content);
-}
-std::set<Orthanc::DicomTag> tags;
-dicom.GetTags(tags);
-Json::Value json = Json::objectValue;
-json["Tags"] = Json::objectValue;
-for (std::set<Orthanc::DicomTag>::const_iterator
-tag = tags.begin(); tag != tags.end(); ++tag)
-{
-const Orthanc::DicomValue& value = dicom.GetValue(*tag);
-if (!value.IsNull() &&
-!value.IsBinary())
-{
-json["Tags"][tag->Format()] = value.GetContent();
-}
-}
-json["Tags"][Orthanc::DICOM_TAG_PHOTOMETRIC_INTERPRETATION.Format()] =
-(widget.IsInvert() ? "MONOCHROME1" : "MONOCHROME2");
-// WARNING: The order of PixelSpacing is Y/X
-char buf[32];
-sprintf(buf, "%0.8f\\%0.8f", pixelSpacingY, pixelSpacingX);
-json["Tags"][Orthanc::DICOM_TAG_PIXEL_SPACING.Format()] = buf;
-float center, width;
-if (widget.GetStack().GetWindowing(center, width))
-{
-json["Tags"][Orthanc::DICOM_TAG_WINDOW_CENTER.Format()] =
-boost::lexical_cast<std::string>(boost::math::iround(center));
-json["Tags"][Orthanc::DICOM_TAG_WINDOW_WIDTH.Format()] =
-boost::lexical_cast<std::string>(boost::math::iround(width));
-}
-#if EXPORT_USING_PAM == 1
-json["Content"] = "data:" + std::string(Orthanc::MIME_PAM) + ";base64," + base64;
-#else
-json["Content"] = "data:" + std::string(Orthanc::MIME_PNG) + ";base64," + base64;
-#endif
-orthanc_->PostJsonAsyncExpectJson(
-"/tools/create-dicom", json,
-new Callable<BitmapStackInteractor, OrthancApiClient::JsonResponseReadyMessage>
-(*this, &BitmapStackInteractor::OnDicomExported),
-NULL, NULL);
-}
-void OnDicomExported(const OrthancApiClient::JsonResponseReadyMessage& message)
-{
-LOG(WARNING) << "DICOM export was successful:"
-<< message.GetJson().toStyledString();
 }
 };
 public:
 SingleFrameEditorApplication(MessageBroker& broker) :
 IObserver(broker),
 interactor_(broker)
 {
+}
+virtual ~SingleFrameEditorApplication()
+{
+LOG(WARNING) << "Destroying the application";
 }
 virtual void DeclareStartupOptions(boost::program_options::options_description& options)
 {
 boost::program_options::options_description generic("Sample options");
 std::string instance = parameters["instance"].as<std::string>();
 int frame = parameters["frame"].as<unsigned int>();
 orthancApiClient_.reset(new OrthancApiClient(IObserver::broker_, context_->GetWebService()));
-interactor_.SetOrthanc(*orthancApiClient_);
 Orthanc::FontRegistry fonts;
 fonts.AddFromResource(Orthanc::EmbeddedResources::FONT_UBUNTU_MONO_BOLD_16);
 stack_.reset(new BitmapStack(IObserver::broker_, *orthancApiClient_));

Mercurial > hg > orthanc-stone

comparison Applications/Samples/SingleFrameEditorApplication.h @ 384:d20d75f20c5d