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); }