# HG changeset patch # User Sebastien Jodogne # Date 1558634673 -7200 # Node ID 55411e7da2f779db1eaf66f336a62b6cc86048b6 # Parent dce5b067d040167f2e9e02bab6d0e2a46a3d6e2f LookupTableTextureSceneLayer diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/CairoCompositor.cpp --- a/Framework/Scene2D/CairoCompositor.cpp Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/CairoCompositor.cpp Thu May 23 20:04:33 2019 +0200 @@ -24,6 +24,7 @@ #include "Internals/CairoColorTextureRenderer.h" #include "Internals/CairoFloatTextureRenderer.h" #include "Internals/CairoInfoPanelRenderer.h" +#include "Internals/CairoLookupTableTextureRenderer.h" #include "Internals/CairoPolylineRenderer.h" #include "Internals/CairoTextRenderer.h" @@ -60,6 +61,9 @@ case ISceneLayer::Type_FloatTexture: return new Internals::CairoFloatTextureRenderer(*this, layer); + case ISceneLayer::Type_LookupTableTexture: + return new Internals::CairoLookupTableTextureRenderer(*this, layer); + case ISceneLayer::Type_Text: { const TextSceneLayer& l = dynamic_cast(layer); diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/ColorTextureSceneLayer.h --- a/Framework/Scene2D/ColorTextureSceneLayer.h Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/ColorTextureSceneLayer.h Thu May 23 20:04:33 2019 +0200 @@ -28,6 +28,7 @@ class ColorTextureSceneLayer : public TextureBaseSceneLayer { public: + // If using RGBA32, premultiplied alpha is assumed ColorTextureSceneLayer(const Orthanc::ImageAccessor& texture); virtual ISceneLayer* Clone() const; diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/ISceneLayer.h --- a/Framework/Scene2D/ISceneLayer.h Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/ISceneLayer.h Thu May 23 20:04:33 2019 +0200 @@ -37,7 +37,8 @@ Type_ColorTexture, Type_Polyline, Type_Text, - Type_FloatTexture + Type_FloatTexture, + Type_LookupTableTexture }; virtual ~ISceneLayer() diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/Internals/CairoColorTextureRenderer.cpp --- a/Framework/Scene2D/Internals/CairoColorTextureRenderer.cpp Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/Internals/CairoColorTextureRenderer.cpp Thu May 23 20:04:33 2019 +0200 @@ -44,13 +44,17 @@ isLinearInterpolation_ = l.IsLinearInterpolation(); } - - void CairoColorTextureRenderer::Render(const AffineTransform2D& transform) + + void CairoColorTextureRenderer::RenderColorTexture(ICairoContextProvider& target, + const AffineTransform2D& transform, + CairoSurface& texture, + const AffineTransform2D& textureTransform, + bool isLinearInterpolation) { - cairo_t* cr = target_.GetCairoContext(); + cairo_t* cr = target.GetCairoContext(); AffineTransform2D t = - AffineTransform2D::Combine(transform, textureTransform_); + AffineTransform2D::Combine(transform, textureTransform); Matrix h = t.GetHomogeneousMatrix(); cairo_save(cr); @@ -60,9 +64,9 @@ cairo_transform(cr, &m); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); - cairo_set_source_surface(cr, texture_.GetObject(), 0, 0); + cairo_set_source_surface(cr, texture.GetObject(), 0, 0); - if (isLinearInterpolation_) + if (isLinearInterpolation) { cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_BILINEAR); } diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/Internals/CairoColorTextureRenderer.h --- a/Framework/Scene2D/Internals/CairoColorTextureRenderer.h Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/Internals/CairoColorTextureRenderer.h Thu May 23 20:04:33 2019 +0200 @@ -43,7 +43,17 @@ virtual void Update(const ISceneLayer& layer); - virtual void Render(const AffineTransform2D& transform); + virtual void Render(const AffineTransform2D& transform) + { + RenderColorTexture(target_, transform, texture_, + textureTransform_, isLinearInterpolation_); + } + + static void RenderColorTexture(ICairoContextProvider& target, + const AffineTransform2D& transform, + CairoSurface& texture, + const AffineTransform2D& textureTransform, + bool isLinearInterpolation); }; } } diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/Internals/CairoFloatTextureRenderer.cpp --- a/Framework/Scene2D/Internals/CairoFloatTextureRenderer.cpp Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Scene2D/Internals/CairoFloatTextureRenderer.cpp Thu May 23 20:04:33 2019 +0200 @@ -21,6 +21,7 @@ #include "CairoFloatTextureRenderer.h" +#include "CairoColorTextureRenderer.h" #include "../FloatTextureSceneLayer.h" namespace OrthancStone @@ -84,33 +85,8 @@ void CairoFloatTextureRenderer::Render(const AffineTransform2D& transform) { - cairo_t* cr = target_.GetCairoContext(); - - AffineTransform2D t = - AffineTransform2D::Combine(transform, textureTransform_); - Matrix h = t.GetHomogeneousMatrix(); - - cairo_save(cr); - - cairo_matrix_t m; - cairo_matrix_init(&m, h(0, 0), h(1, 0), h(0, 1), h(1, 1), h(0, 2), h(1, 2)); - cairo_transform(cr, &m); - - cairo_set_operator(cr, CAIRO_OPERATOR_OVER); - cairo_set_source_surface(cr, texture_.GetObject(), 0, 0); - - if (isLinearInterpolation_) - { - cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_BILINEAR); - } - else - { - cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST); - } - - cairo_paint(cr); - - cairo_restore(cr); + CairoColorTextureRenderer::RenderColorTexture(target_, transform, texture_, + textureTransform_, isLinearInterpolation_); } } } diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/Internals/CairoLookupTableTextureRenderer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2D/Internals/CairoLookupTableTextureRenderer.cpp Thu May 23 20:04:33 2019 +0200 @@ -0,0 +1,108 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2019 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero 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 + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + **/ + + +#include "CairoLookupTableTextureRenderer.h" + +#include "CairoColorTextureRenderer.h" +#include "../LookupTableTextureSceneLayer.h" + +#include + +namespace OrthancStone +{ + namespace Internals + { + void CairoLookupTableTextureRenderer::Update(const ISceneLayer& layer) + { + const LookupTableTextureSceneLayer& l = dynamic_cast(layer); + + textureTransform_ = l.GetTransform(); + isLinearInterpolation_ = l.IsLinearInterpolation(); + + const float a = l.GetMinValue(); + float slope; + + if (l.GetMinValue() >= l.GetMaxValue()) + { + slope = 0; + } + else + { + slope = 256.0f / (l.GetMaxValue() - l.GetMinValue()); + } + + const Orthanc::ImageAccessor& source = l.GetTexture(); + const unsigned int width = source.GetWidth(); + const unsigned int height = source.GetHeight(); + texture_.SetSize(width, height, true /* alpha channel is enabled */); + + Orthanc::ImageAccessor target; + texture_.GetWriteableAccessor(target); + + const std::vector& lut = l.GetLookupTable(); + if (lut.size() != 4 * 256) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); + } + + assert(source.GetFormat() == Orthanc::PixelFormat_Float32 && + target.GetFormat() == Orthanc::PixelFormat_BGRA32 && + sizeof(float) == 4); + + for (unsigned int y = 0; y < height; y++) + { + const float* p = reinterpret_cast(source.GetConstRow(y)); + uint8_t* q = reinterpret_cast(target.GetRow(y)); + + for (unsigned int x = 0; x < width; x++) + { + float v = (*p - a) * slope; + if (v <= 0) + { + v = 0; + } + else if (v >= 255) + { + v = 255; + } + + uint8_t vv = static_cast(v); + + q[0] = lut[4 * vv + 2]; // B + q[1] = lut[4 * vv + 1]; // G + q[2] = lut[4 * vv + 0]; // R + q[3] = lut[4 * vv + 3]; // A + + p++; + q += 4; + } + } + + cairo_surface_mark_dirty(texture_.GetObject()); + } + + void CairoLookupTableTextureRenderer::Render(const AffineTransform2D& transform) + { + CairoColorTextureRenderer::RenderColorTexture(target_, transform, texture_, + textureTransform_, isLinearInterpolation_); + } + } +} diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/Internals/CairoLookupTableTextureRenderer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2D/Internals/CairoLookupTableTextureRenderer.h Thu May 23 20:04:33 2019 +0200 @@ -0,0 +1,53 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2019 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero 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 + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "../../Viewport/CairoSurface.h" +#include "CompositorHelper.h" +#include "ICairoContextProvider.h" + +namespace OrthancStone +{ + namespace Internals + { + class CairoLookupTableTextureRenderer : public CompositorHelper::ILayerRenderer + { + private: + ICairoContextProvider& target_; + CairoSurface texture_; + AffineTransform2D textureTransform_; + bool isLinearInterpolation_; + + public: + CairoLookupTableTextureRenderer(ICairoContextProvider& target, + const ISceneLayer& layer) : + target_(target) + { + Update(layer); + } + + virtual void Update(const ISceneLayer& layer); + + virtual void Render(const AffineTransform2D& transform); + }; + } +} diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/LookupTableTextureSceneLayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2D/LookupTableTextureSceneLayer.cpp Thu May 23 20:04:33 2019 +0200 @@ -0,0 +1,183 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2019 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero 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 + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + **/ + + +#include "LookupTableTextureSceneLayer.h" + +#include +#include +#include + +namespace OrthancStone +{ + static void StringToVector(std::vector& target, + const std::string& source) + { + target.resize(source.size()); + + for (size_t i = 0; i < source.size(); i++) + { + target[i] = source[i]; + } + } + + + LookupTableTextureSceneLayer::LookupTableTextureSceneLayer(const Orthanc::ImageAccessor& texture) + { + { + std::auto_ptr t( + new Orthanc::Image(Orthanc::PixelFormat_Float32, + texture.GetWidth(), + texture.GetHeight(), + false)); + + Orthanc::ImageProcessing::Convert(*t, texture); + SetTexture(t.release()); + } + + SetLookupTableGrayscale(1); + SetRange(0, 1); + } + + + void LookupTableTextureSceneLayer::SetLookupTableGrayscale(float alpha) + { + std::vector rgb(3 * 256); + + for (size_t i = 0; i < 256; i++) + { + rgb[3 * i] = i; + rgb[3 * i + 1] = i; + rgb[3 * i + 2] = i; + } + + SetLookupTableRgb(rgb, alpha); + } + + + void LookupTableTextureSceneLayer::SetLookupTableRgb(const std::vector& lut, + float alpha) + { + if (lut.size() != 3 * 256 || + alpha < 0 || + alpha > 1) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + lut_.resize(4 * 256); + + for (size_t i = 0; i < 256; i++) + { + // Premultiplied alpha + + if (i == 0) + { + // Make zero transparent + lut_[4 * i] = 0; // R + lut_[4 * i + 1] = 0; // G + lut_[4 * i + 2] = 0; // B + lut_[4 * i + 3] = 0; // A + } + else + { + float r = static_cast(lut[3 * i]) * alpha; + float g = static_cast(lut[3 * i + 1]) * alpha; + float b = static_cast(lut[3 * i + 2]) * alpha; + + lut_[4 * i] = static_cast(std::floor(r)); + lut_[4 * i + 1] = static_cast(std::floor(g)); + lut_[4 * i + 2] = static_cast(std::floor(b)); + lut_[4 * i + 3] = static_cast(std::floor(alpha * 255.0f)); + } + } + + IncrementRevision(); + } + + + void LookupTableTextureSceneLayer::SetLookupTableRgb(const std::string& lut, + float alpha) + { + std::vector tmp; + StringToVector(tmp, lut); + SetLookupTableRgb(tmp, alpha); + } + + + void LookupTableTextureSceneLayer::SetLookupTable(const std::vector& lut) + { + if (lut.size() != 4 * 256) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + + lut_ = lut; + + IncrementRevision(); + } + + + void LookupTableTextureSceneLayer::SetLookupTable(const std::string& lut) + { + std::vector tmp; + StringToVector(tmp, lut); + SetLookupTable(tmp); + } + + + void LookupTableTextureSceneLayer::SetRange(float minValue, + float maxValue) + { + if (minValue > maxValue) + { + throw Orthanc::OrthancException(Orthanc::ErrorCode_ParameterOutOfRange); + } + else + { + minValue_ = minValue; + maxValue_ = maxValue; + IncrementRevision(); + } + } + + + void LookupTableTextureSceneLayer::FitRange() + { + Orthanc::ImageProcessing::GetMinMaxFloatValue(minValue_, maxValue_, GetTexture()); + assert(minValue_ <= maxValue_); + + IncrementRevision(); + } + + + ISceneLayer* LookupTableTextureSceneLayer::Clone() const + { + std::auto_ptr cloned + (new LookupTableTextureSceneLayer(GetTexture())); + + cloned->CopyParameters(*this); + cloned->minValue_ = minValue_; + cloned->maxValue_ = maxValue_; + cloned->lut_ = lut_; + + return cloned.release(); + } +} diff -r dce5b067d040 -r 55411e7da2f7 Framework/Scene2D/LookupTableTextureSceneLayer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Framework/Scene2D/LookupTableTextureSceneLayer.h Thu May 23 20:04:33 2019 +0200 @@ -0,0 +1,79 @@ +/** + * Stone of Orthanc + * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics + * Department, University Hospital of Liege, Belgium + * Copyright (C) 2017-2019 Osimis S.A., Belgium + * + * This program is free software: you can redistribute it and/or + * modify it under the terms of the GNU Affero 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 + * Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + **/ + + +#pragma once + +#include "TextureBaseSceneLayer.h" + +namespace OrthancStone +{ + class LookupTableTextureSceneLayer : public TextureBaseSceneLayer + { + private: + ImageWindowing windowing_; + float minValue_; + float maxValue_; + std::vector lut_; + + public: + // The pixel format must be "Flot32" + LookupTableTextureSceneLayer(const Orthanc::ImageAccessor& texture); + + void SetLookupTableGrayscale(float alpha); + + void SetLookupTableRgb(const std::vector& lut, + float alpha); + + void SetLookupTableRgb(const std::string& lut, + float alpha); + + void SetLookupTable(const std::vector& lut); + + void SetLookupTable(const std::string& lut); + + void SetRange(float minValue, + float maxValue); + + void FitRange(); + + float GetMinValue() const + { + return minValue_; + } + + float GetMaxValue() const + { + return maxValue_; + } + + const std::vector& GetLookupTable() const + { + return lut_; + } + + virtual ISceneLayer* Clone() const; + + virtual Type GetType() const + { + return Type_LookupTableTexture; + } + }; +} diff -r dce5b067d040 -r 55411e7da2f7 Framework/Toolbox/DicomInstanceParameters.cpp --- a/Framework/Toolbox/DicomInstanceParameters.cpp Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Toolbox/DicomInstanceParameters.cpp Thu May 23 20:04:33 2019 +0200 @@ -320,7 +320,24 @@ } - TextureBaseSceneLayer* DicomInstanceParameters::CreateTexture(const Orthanc::ImageAccessor& pixelData) const + Orthanc::ImageAccessor* DicomInstanceParameters::ConvertToFloat(const Orthanc::ImageAccessor& pixelData) const + { + std::auto_ptr converted(new Orthanc::Image(Orthanc::PixelFormat_Float32, + pixelData.GetWidth(), + pixelData.GetHeight(), + false)); + Orthanc::ImageProcessing::Convert(*converted, pixelData); + + // Correct rescale slope/intercept if need be + data_.ApplyRescale(*converted, (pixelData.GetFormat() == Orthanc::PixelFormat_Grayscale32)); + + return converted.release(); + } + + + + TextureBaseSceneLayer* DicomInstanceParameters::CreateTexture + (const Orthanc::ImageAccessor& pixelData) const { assert(sizeof(float) == 4); @@ -338,26 +355,16 @@ } else { - if (sourceFormat != Orthanc::PixelFormat_Grayscale16 && - sourceFormat != Orthanc::PixelFormat_Grayscale32 && - sourceFormat != Orthanc::PixelFormat_SignedGrayscale16) - { - throw Orthanc::OrthancException(Orthanc::ErrorCode_NotImplemented); - } + // This is the case of a grayscale frame. Convert it to Float32. + std::auto_ptr texture; - std::auto_ptr texture; - + if (pixelData.GetFormat() == Orthanc::PixelFormat_Float32) { - // This is the case of a grayscale frame. Convert it to Float32. - std::auto_ptr converted(new Orthanc::Image(Orthanc::PixelFormat_Float32, - pixelData.GetWidth(), - pixelData.GetHeight(), - false)); - Orthanc::ImageProcessing::Convert(*converted, pixelData); - - // Correct rescale slope/intercept if need be - data_.ApplyRescale(*converted, (sourceFormat == Orthanc::PixelFormat_Grayscale32)); - + texture.reset(new FloatTextureSceneLayer(pixelData)); + } + else + { + std::auto_ptr converted(ConvertToFloat(pixelData)); texture.reset(new FloatTextureSceneLayer(*converted)); } @@ -370,4 +377,21 @@ return texture.release(); } } + + + LookupTableTextureSceneLayer* DicomInstanceParameters::CreateLookupTableTexture + (const Orthanc::ImageAccessor& pixelData) const + { + std::auto_ptr texture; + + if (pixelData.GetFormat() == Orthanc::PixelFormat_Float32) + { + return new LookupTableTextureSceneLayer(pixelData); + } + else + { + std::auto_ptr converted(ConvertToFloat(pixelData)); + return new LookupTableTextureSceneLayer(*converted); + } + } } diff -r dce5b067d040 -r 55411e7da2f7 Framework/Toolbox/DicomInstanceParameters.h --- a/Framework/Toolbox/DicomInstanceParameters.h Thu May 23 16:57:33 2019 +0200 +++ b/Framework/Toolbox/DicomInstanceParameters.h Thu May 23 20:04:33 2019 +0200 @@ -22,7 +22,7 @@ #pragma once #include "../StoneEnumerations.h" -#include "../Scene2D/TextureBaseSceneLayer.h" +#include "../Scene2D/LookupTableTextureSceneLayer.h" #include "../Toolbox/CoordinateSystem3D.h" #include @@ -72,6 +72,9 @@ }; + Orthanc::ImageAccessor* ConvertToFloat(const Orthanc::ImageAccessor& pixelData) const; + + Data data_; @@ -181,5 +184,7 @@ } TextureBaseSceneLayer* CreateTexture(const Orthanc::ImageAccessor& pixelData) const; + + LookupTableTextureSceneLayer* CreateLookupTableTexture(const Orthanc::ImageAccessor& pixelData) const; }; } diff -r dce5b067d040 -r 55411e7da2f7 Resources/CMake/OrthancStoneConfiguration.cmake --- a/Resources/CMake/OrthancStoneConfiguration.cmake Thu May 23 16:57:33 2019 +0200 +++ b/Resources/CMake/OrthancStoneConfiguration.cmake Thu May 23 20:04:33 2019 +0200 @@ -380,10 +380,12 @@ ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoColorTextureRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoFloatTextureRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoInfoPanelRenderer.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoLookupTableTextureRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoPolylineRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CairoTextRenderer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/CompositorHelper.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/Internals/FixedPointAligner.cpp + ${ORTHANC_STONE_ROOT}/Framework/Scene2D/LookupTableTextureSceneLayer.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/PanSceneTracker.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/PointerEvent.cpp ${ORTHANC_STONE_ROOT}/Framework/Scene2D/PolylineSceneLayer.cpp diff -r dce5b067d040 -r 55411e7da2f7 Samples/Sdl/Loader.cpp --- a/Samples/Sdl/Loader.cpp Thu May 23 16:57:33 2019 +0200 +++ b/Samples/Sdl/Loader.cpp Thu May 23 20:04:33 2019 +0200 @@ -33,6 +33,7 @@ #include "../../Framework/Scene2D/CairoCompositor.h" #include "../../Framework/Scene2D/Scene2D.h" #include "../../Framework/Scene2D/PolylineSceneLayer.h" +#include "../../Framework/Scene2D/LookupTableTextureSceneLayer.h" #include "../../Framework/StoneInitialization.h" #include "../../Framework/Toolbox/GeometryToolbox.h" #include "../../Framework/Toolbox/SlicesSorter.h" @@ -50,6 +51,9 @@ #include +#include + + namespace OrthancStone { class IVolumeSlicer : public boost::noncopyable @@ -174,7 +178,25 @@ { const DicomInstanceParameters& parameters = GetDicomParameters(projection_, sliceIndex_); ImageBuffer3D::SliceReader reader(image_, projection_, sliceIndex_); - texture.reset(parameters.CreateTexture(reader.GetAccessor())); + + static unsigned int i = 1; + + if (i % 2) + { + texture.reset(parameters.CreateTexture(reader.GetAccessor())); + } + else + { + std::string lut; + Orthanc::EmbeddedResources::GetFileResource(lut, Orthanc::EmbeddedResources::COLORMAP_HOT); + + std::auto_ptr tmp(parameters.CreateLookupTableTexture(reader.GetAccessor())); + tmp->FitRange(); + tmp->SetLookupTableRgb(lut, 1); + texture.reset(tmp.release()); + } + + i++; } const CoordinateSystem3D& system = geometry_.GetProjectionGeometry(projection_);