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);
}
}
}
}
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 ToMatlabStringInternal(ChunkedBuffer& target,
const ImageAccessor& source)
{
target.AddChunk("double([ ");
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const PixelType* p = reinterpret_cast<const PixelType*>(source.GetConstRow(y));
std::string s;
if (y > 0)
{
s = "; ";
}
s.reserve(source.GetWidth() * 8);
for (unsigned int x = 0; x < source.GetWidth(); x++, p++)
{
s += boost::lexical_cast<std::string>(static_cast<double>(*p)) + " ";
}
target.AddChunk(s);
}
target.AddChunk("])");
}
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);
}
}
}
}
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);
}
}
}
}
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 GetMinMaxValueInternal(PixelType& minValue,
PixelType& maxValue,
const ImageAccessor& source)
{
// Deal with the special case of empty image
if (source.GetWidth() == 0 ||
source.GetHeight() == 0)
{
minValue = 0;
maxValue = 0;
return;
}
minValue = std::numeric_limits<PixelType>::max();
maxValue = std::numeric_limits<PixelType>::min();
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const PixelType* p = reinterpret_cast<const PixelType*>(source.GetConstRow(y));
for (unsigned int x = 0; x < source.GetWidth(); x++, p++)
{
if (*p < minValue)
{
minValue = *p;
}
if (*p > maxValue)
{
maxValue = *p;
}
}
}
}
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);
}
}
}
void ImageProcessing::ShiftRight(ImageAccessor& image,
unsigned int shift)
{
if (image.GetWidth() == 0 ||
image.GetHeight() == 0 ||
shift == 0)
{
// Nothing to do
return;
}
throw OrthancException(ErrorCode_NotImplemented);
}
void operator()(const Mat& mat, char* data) {
ImageAccessor<RGBPixel> acc;
typename Mat::const_row_iterator row = mat.row_begin();
typename Mat::const_col_iterator col;
char* i = data;
for (; row != mat.row_end(); ++row) {
for (col = row.begin(); col != row.end(); ++col) {
RGBPixel tmp = acc.get(col);
*(i++) = (unsigned char)tmp.red();
*(i++) = (unsigned char)tmp.green();
*(i++) = (unsigned char)tmp.blue();
}
}
}
void ImageProcessing::Set(ImageAccessor& image,
int64_t value)
{
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
SetInternal<uint8_t>(image, value);
return;
case PixelFormat_Grayscale16:
SetInternal<uint16_t>(image, value);
return;
case PixelFormat_SignedGrayscale16:
SetInternal<int16_t>(image, value);
return;
case PixelFormat_Float32:
assert(sizeof(float) == 4);
SetInternal<float>(image, value);
return;
default:
throw OrthancException(ErrorCode_NotImplemented);
}
}
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 operator()(const Mat& mat, char* data) {
char* i = data;
ImageAccessor<T> acc;
typename Mat::const_row_iterator row = mat.row_begin();
typename Mat::const_col_iterator col;
T tmp;
for (; row != mat.row_end(); ++row) {
for (col = row.begin(); col != row.end(); ++col) {
tmp = acc.get(col);
if (tmp > 255)
tmp = 255;
*(i++) = (char)tmp;
*(i++) = (char)tmp;
*(i++) = (char)tmp;
}
}
}
static void RGB24ToMatlabString(ChunkedBuffer& target,
const ImageAccessor& source)
{
assert(source.GetFormat() == PixelFormat_RGB24);
target.AddChunk("double(permute(reshape([ ");
for (unsigned int y = 0; y < source.GetHeight(); y++)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(source.GetConstRow(y));
std::string s;
s.reserve(source.GetWidth() * 3 * 8);
for (unsigned int x = 0; x < 3 * source.GetWidth(); x++, p++)
{
s += boost::lexical_cast<std::string>(static_cast<int>(*p)) + " ";
}
target.AddChunk(s);
}
target.AddChunk("], [ 3 " + boost::lexical_cast<std::string>(source.GetHeight()) +
" " + boost::lexical_cast<std::string>(source.GetWidth()) + " ]), [ 3 2 1 ]))");
}
void operator()(const Mat& mat, char* data) {
ImageAccessor<Grey16Pixel> acc;
typename Mat::const_row_iterator row = mat.row_begin();
typename Mat::const_col_iterator col;
char tmp;
char* i = data;
for (; row != mat.row_end(); ++row) {
for (col = row.begin(); col != row.end(); ++col) {
/*
This should correctly map the 16 bit grey values onto
the rgb color space. KWM
*/
tmp = char(acc.get(col));
*(i++) = tmp;
*(i++) = tmp;
*(i++) = tmp;
}
}
}
FloatVector* histogram_real_values(const T& image) {
// The histogram is the size of all of the possible values of
// the pixel type.
size_t l = std::numeric_limits<typename T::value_type>::max() + 1;
FloatVector* values = new FloatVector(l);
// set the list to 0
std::fill(values->begin(), values->end(), 0);
typename T::const_row_iterator row = image.row_begin();
typename T::const_col_iterator col;
ImageAccessor<typename T::value_type> acc;
// create the histogram
for (; row != image.row_end(); ++row)
for (col = row.begin(); col != row.end(); ++col)
(*values)[acc.get(col)]++;
return values;
}
ImageAccessor ImageAccessor::GetRegion(unsigned int x,
unsigned int y,
unsigned int width,
unsigned int height) const
{
if (x + width > width_ ||
y + height > height_)
{
throw OrthancException(ErrorCode_ParameterOutOfRange);
}
ImageAccessor result;
if (width == 0 ||
height == 0)
{
result.AssignWritable(format_, 0, 0, 0, NULL);
}
else
{
uint8_t* p = (buffer_ +
y * pitch_ +
x * GetBytesPerPixel());
if (readOnly_)
{
result.AssignReadOnly(format_, width, height, pitch_, p);
}
else
{
result.AssignWritable(format_, width, height, pitch_, p);
}
}
return result;
}
void ImageProcessing::AddConstant(ImageAccessor& image,
int64_t value)
{
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
AddConstantInternal<uint8_t>(image, value);
return;
case PixelFormat_Grayscale16:
AddConstantInternal<uint16_t>(image, value);
return;
case PixelFormat_SignedGrayscale16:
AddConstantInternal<int16_t>(image, value);
return;
default:
throw OrthancException(ErrorCode_NotImplemented);
}
}
void ImageProcessing::MultiplyConstant(ImageAccessor& image,
float factor)
{
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
MultiplyConstantInternal<uint8_t>(image, factor);
return;
case PixelFormat_Grayscale16:
MultiplyConstantInternal<uint16_t>(image, factor);
return;
case PixelFormat_SignedGrayscale16:
MultiplyConstantInternal<int16_t>(image, factor);
return;
default:
throw OrthancException(ErrorCode_NotImplemented);
}
}
void ImageProcessing::ShiftScale(ImageAccessor& image,
float offset,
float scaling)
{
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
ShiftScaleInternal<uint8_t>(image, offset, scaling);
return;
case PixelFormat_Grayscale16:
ShiftScaleInternal<uint16_t>(image, offset, scaling);
return;
case PixelFormat_SignedGrayscale16:
ShiftScaleInternal<int16_t>(image, offset, scaling);
return;
default:
throw OrthancException(ErrorCode_NotImplemented);
}
}
void ImageProcessing::GetMinMaxValue(int64_t& minValue,
int64_t& maxValue,
const ImageAccessor& image)
{
switch (image.GetFormat())
{
case PixelFormat_Grayscale8:
{
uint8_t a, b;
GetMinMaxValueInternal<uint8_t>(a, b, image);
minValue = a;
maxValue = b;
break;
}
case PixelFormat_Grayscale16:
{
uint16_t a, b;
GetMinMaxValueInternal<uint16_t>(a, b, image);
minValue = a;
maxValue = b;
break;
}
case PixelFormat_SignedGrayscale16:
{
int16_t a, b;
GetMinMaxValueInternal<int16_t>(a, b, image);
minValue = a;
maxValue = b;
break;
}
default:
throw OrthancException(ErrorCode_NotImplemented);
}
}
void Pixel::operator=(const ImageAccessor accessor)
{
(*this) = accessor.read();
}
Pixel::Pixel(const ImageAccessor accessor)
{
(*this) = accessor.read();
}
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);
}
