void ShiftScaleInternal(ImageAccessor& image,
float offset,
float scaling)
{
const float minValue = static_cast<float>(std::numeric_limits<PixelType>::min());
const float maxValue = static_cast<float>(std::numeric_limits<PixelType>::max());
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
{
float v = (static_cast<float>(*p) + offset) * scaling;
if (v > maxValue)
{
*p = std::numeric_limits<PixelType>::max();
}
else if (v < minValue)
{
*p = std::numeric_limits<PixelType>::min();
}
else
{
*p = static_cast<PixelType>(boost::math::iround(v));
}
}
}
}
static void ConvertColorToGrayscale(ImageAccessor& target,
const ImageAccessor& source)
{
assert(source.GetFormat() == PixelFormat_RGB24);
const TargetType minValue = std::numeric_limits<TargetType>::min();
const TargetType maxValue = std::numeric_limits<TargetType>::max();
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y));
const uint8_t* s = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s += 3)
{
// Y = 0.2126 R + 0.7152 G + 0.0722 B
int32_t v = (2126 * static_cast<int32_t>(s[0]) +
7152 * static_cast<int32_t>(s[1]) +
0722 * static_cast<int32_t>(s[2])) / 1000;
if (static_cast<int32_t>(v) < static_cast<int32_t>(minValue))
{
*t = minValue;
}
else if (static_cast<int32_t>(v) > static_cast<int32_t>(maxValue))
{
*t = maxValue;
}
else
{
*t = static_cast<TargetType>(v);
}
}
}
}
static void ConvertInternal(ImageAccessor& target,
const ImageAccessor& source)
{
const TargetType minValue = std::numeric_limits<TargetType>::min();
const TargetType maxValue = std::numeric_limits<TargetType>::max();
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
TargetType* t = reinterpret_cast<TargetType*>(target.GetRow(y));
const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s++)
{
if (static_cast<int32_t>(*s) < static_cast<int32_t>(minValue))
{
*t = minValue;
}
else if (static_cast<int32_t>(*s) > static_cast<int32_t>(maxValue))
{
*t = maxValue;
}
else
{
*t = static_cast<TargetType>(*s);
}
}
}
}
void MultiplyConstantInternal(ImageAccessor& image,
float factor)
{
if (std::abs(factor - 1.0f) <= std::numeric_limits<float>::epsilon())
{
return;
}
const int64_t minValue = std::numeric_limits<PixelType>::min();
const int64_t maxValue = std::numeric_limits<PixelType>::max();
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
{
int64_t v = boost::math::llround(static_cast<float>(*p) * factor);
if (v > maxValue)
{
*p = std::numeric_limits<PixelType>::max();
}
else if (v < minValue)
{
*p = std::numeric_limits<PixelType>::min();
}
else
{
*p = static_cast<PixelType>(v);
}
}
}
}
static void AddConstantInternal(ImageAccessor& image,
int64_t constant)
{
if (constant == 0)
{
return;
}
const int64_t minValue = std::numeric_limits<PixelType>::min();
const int64_t maxValue = std::numeric_limits<PixelType>::max();
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
{
int64_t v = static_cast<int64_t>(*p) + constant;
if (v > maxValue)
{
*p = std::numeric_limits<PixelType>::max();
}
else if (v < minValue)
{
*p = std::numeric_limits<PixelType>::min();
}
else
{
*p = static_cast<PixelType>(v);
}
}
}
}
static void SetInternal(ImageAccessor& image,
int64_t constant)
{
for (unsigned int y = 0; y < image.GetHeight(); y++)
{
PixelType* p = reinterpret_cast<PixelType*>(image.GetRow(y));
for (unsigned int x = 0; x < image.GetWidth(); x++, p++)
{
*p = static_cast<PixelType>(constant);
}
}
}
static void ConvertGrayscaleToFloat(ImageAccessor& target,
const ImageAccessor& source)
{
assert(sizeof(float) == 4);
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
float* t = reinterpret_cast<float*>(target.GetRow(y));
const SourceType* s = reinterpret_cast<const SourceType*>(source.GetConstRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++, t++, s++)
{
*t = static_cast<float>(*s);
}
}
}
void ImageProcessing::Copy(ImageAccessor& target,
const ImageAccessor& source)
{
if (target.GetWidth() != source.GetWidth() ||
target.GetHeight() != source.GetHeight())
{
throw OrthancException(ErrorCode_IncompatibleImageSize);
}
if (target.GetFormat() != source.GetFormat())
{
throw OrthancException(ErrorCode_IncompatibleImageFormat);
}
unsigned int lineSize = GetBytesPerPixel(source.GetFormat()) * source.GetWidth();
assert(source.GetPitch() >= lineSize && target.GetPitch() >= lineSize);
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
memcpy(target.GetRow(y), source.GetConstRow(y), lineSize);
}
}
void ImageProcessing::Convert(ImageAccessor& target,
const ImageAccessor& source)
{
if (target.GetWidth() != source.GetWidth() ||
target.GetHeight() != source.GetHeight())
{
throw OrthancException(ErrorCode_IncompatibleImageSize);
}
if (source.GetFormat() == target.GetFormat())
{
Copy(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale16 &&
source.GetFormat() == PixelFormat_Grayscale8)
{
ConvertInternal<uint16_t, uint8_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
source.GetFormat() == PixelFormat_Grayscale8)
{
ConvertInternal<int16_t, uint8_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale8 &&
source.GetFormat() == PixelFormat_Grayscale16)
{
ConvertInternal<uint8_t, uint16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
source.GetFormat() == PixelFormat_Grayscale16)
{
ConvertInternal<int16_t, uint16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale8 &&
source.GetFormat() == PixelFormat_SignedGrayscale16)
{
ConvertInternal<uint8_t, int16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale16 &&
source.GetFormat() == PixelFormat_SignedGrayscale16)
{
ConvertInternal<uint16_t, int16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale8 &&
source.GetFormat() == PixelFormat_RGB24)
{
ConvertColorToGrayscale<uint8_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale16 &&
source.GetFormat() == PixelFormat_RGB24)
{
ConvertColorToGrayscale<uint16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_SignedGrayscale16 &&
source.GetFormat() == PixelFormat_RGB24)
{
ConvertColorToGrayscale<int16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Float32 &&
source.GetFormat() == PixelFormat_Grayscale8)
{
ConvertGrayscaleToFloat<uint8_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Float32 &&
source.GetFormat() == PixelFormat_Grayscale16)
{
ConvertGrayscaleToFloat<uint16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Float32 &&
source.GetFormat() == PixelFormat_SignedGrayscale16)
{
ConvertGrayscaleToFloat<int16_t>(target, source);
return;
}
if (target.GetFormat() == PixelFormat_Grayscale8 &&
source.GetFormat() == PixelFormat_RGBA32)
{
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++, q++)
{
*q = static_cast<uint8_t>((2126 * static_cast<uint32_t>(p[0]) +
7152 * static_cast<uint32_t>(p[1]) +
0722 * static_cast<uint32_t>(p[2])) / 10000);
p += 4;
}
}
return;
}
if (target.GetFormat() == PixelFormat_RGB24 &&
source.GetFormat() == PixelFormat_RGBA32)
{
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++)
{
q[0] = p[0];
q[1] = p[1];
q[2] = p[2];
p += 4;
q += 3;
}
}
return;
}
if (target.GetFormat() == PixelFormat_RGBA32 &&
source.GetFormat() == PixelFormat_RGB24)
{
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++)
{
q[0] = p[0];
q[1] = p[1];
q[2] = p[2];
q[3] = 255; // Set the alpha channel to full opacity
p += 3;
q += 4;
}
}
return;
}
if (target.GetFormat() == PixelFormat_RGB24 &&
source.GetFormat() == PixelFormat_Grayscale8)
{
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++)
{
q[0] = *p;
q[1] = *p;
q[2] = *p;
p += 1;
q += 3;
}
}
return;
}
if (target.GetFormat() == PixelFormat_RGBA32 &&
source.GetFormat() == PixelFormat_Grayscale8)
{
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
uint8_t* q = reinterpret_cast<uint8_t*>(target.GetRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++)
{
q[0] = *p;
q[1] = *p;
q[2] = *p;
q[3] = 255;
p += 1;
q += 4;
}
}
return;
}
throw OrthancException(ErrorCode_NotImplemented);
}
