PM/DYT
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d1aa2ed6e7
DYT/Tool/3rdParty_x64/include/dcmtk/dcmimgle/discalet.h

1240 lines
54 KiB
C
Raw Normal View History

添加tool
2024-11-22 15:19:31 +00:00
/*
*
* Copyright (C) 1996-2016, OFFIS e.V.
* All rights reserved. See COPYRIGHT file for details.
*
* This software and supporting documentation were developed by
*
* OFFIS e.V.
* R&D Division Health
* Escherweg 2
* D-26121 Oldenburg, Germany
*
*
* Module: dcmimgle
*
* Author: Joerg Riesmeier
*
* Purpose: DicomScaleTemplates (Header)
*
*/
#ifndef DISCALET_H
#define DISCALET_H
#include "dcmtk/config/osconfig.h"
#include "dcmtk/ofstd/ofcast.h"
#include "dcmtk/dcmimgle/ditranst.h"
#include "dcmtk/dcmimgle/dipxrept.h"
/*---------------------*
* macro definitions *
*---------------------*/
#define SCALE_FACTOR 4096
#define HALFSCALE_FACTOR 2048
/*--------------------*
* helper functions *
*--------------------*/
// help function to set scaling values
static inline void setScaleValues(Uint16 data[],
const Uint16 min,
const Uint16 max)
{
Uint16 remainder = max % min;
Uint16 step0 = max / min;
Uint16 step1 = max / min;
if (remainder > OFstatic_cast(Uint16, min / 2))
{
remainder = min - remainder;
++step0;
} else
++step1;
const double count = OFstatic_cast(double, min) / (OFstatic_cast(double, remainder) + 1);
Uint16 i;
double c = count;
for (i = 0; i < min; ++i)
{
if ((i >= OFstatic_cast(Uint16, c)) && (remainder > 0))
{
--remainder;
c += count;
data[i] = step1;
}
else
data[i] = step0;
}
}
// cubic value interpolation using Catmull-Rom formula.
// the interpolated pixel lies between the second and the third original pixels
static inline double cubicValue(const double v1,
const double v2,
const double v3,
const double v4,
const double dD,
const double minVal,
const double maxVal)
{
double dVal = 0.5 * ((((-v1 + 3 * v2 - 3 * v3 + v4) * dD + (2 * v1 - 5 * v2 + 4 * v3 - v4)) * dD + (-v1 + v3)) * dD + (v2 + v2));
return (dVal < minVal) ? minVal : ((dVal > maxVal) ? maxVal : dVal);
}
/*---------------------*
* class declaration *
*---------------------*/
/** Template class to scale images (on pixel data level).
* with and without interpolation
*/
template<class T>
class DiScaleTemplate
: public DiTransTemplate<T>
{
public:
/** constructor, scale clipping area.
*
** @param planes number of planes (1 or 3)
* @param columns width of source image
* @param rows height of source image
* @param left_pos left coordinate of clipping area
* @param top_pos top coordinate of clipping area
* @param src_cols width of clipping area
* @param src_rows height of clipping area
* @param dest_cols width of destination image (scaled image)
* @param dest_rows height of destination image
* @param frames number of frames
* @param bits number of bits per plane/pixel
*/
DiScaleTemplate(const int planes,
const Uint16 columns, /* resolution of source image */
const Uint16 rows,
const signed long left_pos, /* origin of clipping area */
const signed long top_pos,
const Uint16 src_cols, /* extension of clipping area */
const Uint16 src_rows,
const Uint16 dest_cols, /* extension of destination image */
const Uint16 dest_rows,
const Uint32 frames, /* number of frames */
const int bits = 0)
: DiTransTemplate<T>(planes, src_cols, src_rows, dest_cols, dest_rows, frames, bits),
Left(left_pos),
Top(top_pos),
Columns(columns),
Rows(rows)
{
}
/** constructor, scale whole image.
*
** @param planes number of planes (1 or 3)
* @param src_cols width of source image
* @param src_rows height of source image
* @param dest_cols width of destination image (scaled image)
* @param dest_rows height of destination image
* @param frames number of frames
* @param bits number of bits per plane/pixel
*/
DiScaleTemplate(const int planes,
const Uint16 src_cols, /* resolution of source image */
const Uint16 src_rows,
const Uint16 dest_cols, /* resolution of destination image */
const Uint16 dest_rows,
const Uint32 frames, /* number of frames */
const int bits = 0)
: DiTransTemplate<T>(planes, src_cols, src_rows, dest_cols, dest_rows, frames, bits),
Left(0),
Top(0),
Columns(src_cols),
Rows(src_rows)
{
}
/** destructor
*/
virtual ~DiScaleTemplate()
{
}
/** check whether template type T is signed or not
*
** @return true if signed, false otherwise
*/
inline int isSigned() const
{
const DiPixelRepresentationTemplate<T> rep;
return rep.isSigned();
}
/** choose scaling/clipping algorithm depending on specified parameters.
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
* @param interpolate preferred interpolation algorithm (0 = no interpolation, 1 = pbmplus algorithm,
* 2 = c't algorithm, 3 = bilinear magnification, 4 = bicubic magnification)
* @param value value to be set outside the image boundaries (used for clipping, default: 0)
*/
void scaleData(const T *src[],
T *dest[],
const int interpolate,
const T value = 0)
{
if ((src != NULL) && (dest != NULL))
{
DCMIMGLE_TRACE("Col/Rows: " << Columns << " " << Rows << OFendl
<< "Left/Top: " << Left << " " << Top << OFendl
<< "Src X/Y: " << this->Src_X << " " << this->Src_Y << OFendl
<< "Dest X/Y: " << this->Dest_X << " " << this->Dest_Y);
if ((Left + OFstatic_cast(signed long, this->Src_X) <= 0) || (Top + OFstatic_cast(signed long, this->Src_Y) <= 0) ||
(Left >= OFstatic_cast(signed long, Columns)) || (Top >= OFstatic_cast(signed long, Rows)))
{ // no image to be displayed
DCMIMGLE_DEBUG("clipping area is fully outside the image boundaries");
this->fillPixel(dest, value); // ... fill bitmap
}
else if ((this->Src_X == this->Dest_X) && (this->Src_Y == this->Dest_Y)) // no scaling
{
if ((Left == 0) && (Top == 0) && (Columns == this->Src_X) && (Rows == this->Src_Y))
this->copyPixel(src, dest); // copying
else if ((Left >= 0) && (OFstatic_cast(Uint16, Left + this->Src_X) <= Columns) &&
(Top >= 0) && (OFstatic_cast(Uint16, Top + this->Src_Y) <= Rows))
clipPixel(src, dest); // clipping
else
clipBorderPixel(src, dest, value); // clipping (with border)
}
else if ((interpolate == 1) && (this->Bits <= MAX_INTERPOLATION_BITS))
interpolatePixel(src, dest); // interpolation (pbmplus)
else if ((interpolate == 4) && (this->Dest_X >= this->Src_X) && (this->Dest_Y >= this->Src_Y) &&
(this->Src_X >= 3) && (this->Src_Y >= 3))
bicubicPixel(src, dest); // bicubic magnification
else if ((interpolate >= 3) && (this->Dest_X >= this->Src_X) && (this->Dest_Y >= this->Src_Y) &&
(this->Src_X >= 2) && (this->Src_Y >= 2))
bilinearPixel(src, dest); // bilinear magnification
else if ((interpolate >= 1) && (this->Dest_X >= this->Src_X) && (this->Dest_Y >= this->Src_Y))
expandPixel(src, dest); // interpolated expansion (c't)
else if ((interpolate >= 1) && (this->Src_X >= this->Dest_X) && (this->Src_Y >= this->Dest_Y))
reducePixel(src, dest); // interpolated reduction (c't)
else if ((interpolate >= 1) && (this->Bits <= MAX_INTERPOLATION_BITS))
interpolatePixel(src, dest); // interpolation (pbmplus), fallback
else if ((this->Dest_X % this->Src_X == 0) && (this->Dest_Y % this->Src_Y == 0))
replicatePixel(src, dest); // replication
else if ((this->Src_X % this->Dest_X == 0) && (this->Src_Y % this->Dest_Y == 0))
suppressPixel(src, dest); // suppression
else
scalePixel(src, dest); // general scaling
}
}
protected:
/// left coordinate of clipping area
const signed long Left;
/// top coordinate of clipping area
const signed long Top;
/// width of source image
const Uint16 Columns;
/// height of source image
const Uint16 Rows;
private:
/** clip image to specified area (only inside image boundaries).
* This is an optimization of the more general method clipBorderPixel().
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void clipPixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using clip image to specified area algorithm");
const unsigned long x_feed = Columns - this->Src_X;
const unsigned long y_feed = OFstatic_cast(unsigned long, Rows - this->Src_Y) * OFstatic_cast(unsigned long, Columns);
Uint16 x;
Uint16 y;
const T *p;
T *q;
for (int j = 0; j < this->Planes; ++j)
{
p = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
for (y = this->Dest_Y; y != 0; --y)
{
for (x = this->Dest_X; x != 0; --x)
*(q++) = *(p++);
p += x_feed;
}
p += y_feed;
}
}
}
/** clip image to specified area and add a border if necessary
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
* @param value value to be set outside the image boundaries
*/
void clipBorderPixel(const T *src[],
T *dest[],
const T value)
{
DCMIMGLE_DEBUG("using clip image to specified area and add border algorithm");
const Uint16 s_left = (Left > 0) ? OFstatic_cast(Uint16, Left) : 0;
const Uint16 s_top = (Top > 0) ? OFstatic_cast(Uint16, Top) : 0;
const Uint16 d_left = (Left < 0 ? OFstatic_cast(Uint16, -Left) : 0);
const Uint16 d_top = (Top < 0) ? OFstatic_cast(Uint16, -Top) : 0;
const Uint16 d_right = (OFstatic_cast(unsigned long, this->Src_X) + OFstatic_cast(unsigned long, s_left) <
OFstatic_cast(unsigned long, Columns) + OFstatic_cast(unsigned long, d_left)) ?
(this->Src_X - 1) : (Columns + d_left - s_left - 1);
const Uint16 d_bottom = (OFstatic_cast(unsigned long, this->Src_Y) + OFstatic_cast(unsigned long, s_top) <
OFstatic_cast(unsigned long, Rows) + OFstatic_cast(unsigned long, d_top)) ?
(this->Src_Y - 1) : (Rows + d_top - s_top - 1);
const Uint16 x_count = d_right - d_left + 1;
const Uint16 y_count = d_bottom - d_top + 1;
const unsigned long s_start = OFstatic_cast(unsigned long, s_top) * OFstatic_cast(unsigned long, Columns) + s_left;
const unsigned long x_feed = Columns - x_count;
const unsigned long y_feed = OFstatic_cast(unsigned long, Rows - y_count) * Columns;
const unsigned long t_feed = OFstatic_cast(unsigned long, d_top) * OFstatic_cast(unsigned long, this->Src_X);
const unsigned long b_feed = OFstatic_cast(unsigned long, this->Src_Y - d_bottom - 1) * OFstatic_cast(unsigned long, this->Src_X);
/*
* The approach is to divide the destination image in up to four areas outside the source image
* plus one area for the source image. The for and while loops are scanning linearly over the
* destination image and setting the appropriate value depending on the current area. This is
* different from most of the other algorithms in this toolkit where the source image is scanned
* linearly.
*/
Uint16 x;
Uint16 y;
unsigned long i;
const T *p;
T *q;
for (int j = 0; j < this->Planes; ++j)
{
p = src[j] + s_start;
q = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
for (i = t_feed; i != 0; --i) // top
*(q++) = value;
for (y = y_count; y != 0; --y) // middle part:
{
x = 0;
while (x < d_left) // - left
{
*(q++) = value;
++x;
}
while (x <= d_right) // - middle
{
*(q++) = *(p++);
++x;
}
while (x < this->Src_X) // - right
{
*(q++) = value;
++x;
}
p += x_feed;
}
for (i = b_feed; i != 0; --i) // bottom
*(q++) = value;
p += y_feed;
}
}
}
/** enlarge image by an integer factor.
* Pixels are replicated independently in both directions.
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void replicatePixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using replicate pixel scaling algorithm without interpolation");
const Uint16 x_factor = this->Dest_X / this->Src_X;
const Uint16 y_factor = this->Dest_Y / this->Src_Y;
const unsigned long x_feed = Columns;
const unsigned long y_feed = OFstatic_cast(unsigned long, Rows - this->Src_Y) * OFstatic_cast(unsigned long, Columns);
const T *sp;
Uint16 x;
Uint16 y;
Uint16 dx;
Uint16 dy;
const T *p;
T *q;
T value;
for (int j = 0; j < this->Planes; ++j)
{
sp = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
for (y = this->Src_Y; y != 0; --y)
{
for (dy = y_factor; dy != 0; --dy)
{
for (x = this->Src_X, p = sp; x != 0; --x)
{
value = *(p++);
for (dx = x_factor; dx != 0; --dx)
*(q++) = value;
}
}
sp += x_feed;
}
sp += y_feed;
}
}
}
/** shrink image by an integer divisor.
* Pixels are suppressed independently in both directions.
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void suppressPixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using suppress pixel scaling algorithm without interpolation");
const unsigned int x_divisor = this->Src_X / this->Dest_X;
const unsigned long x_feed = OFstatic_cast(unsigned long, this->Src_Y / this->Dest_Y) * OFstatic_cast(unsigned long, Columns) - this->Src_X;
const unsigned long y_feed = OFstatic_cast(unsigned long, Rows - this->Src_Y) * OFstatic_cast(unsigned long, Columns);
Uint16 x;
Uint16 y;
const T *p;
T *q;
for (int j = 0; j < this->Planes; ++j)
{
p = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
for (y = this->Dest_Y; y != 0; --y)
{
for (x = this->Dest_X; x != 0; --x)
{
*(q++) = *p;
p += x_divisor;
}
p += x_feed;
}
p += y_feed;
}
}
}
/** free scaling method without interpolation.
* This algorithm is necessary for overlays (1 bpp).
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void scalePixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using free scaling algorithm without interpolation");
const Uint16 xmin = (this->Dest_X < this->Src_X) ? this->Dest_X : this->Src_X; // minimum width
const Uint16 ymin = (this->Dest_Y < this->Src_Y) ? this->Dest_Y : this->Src_Y; // minimum height
Uint16 *x_step = new Uint16[xmin];
Uint16 *y_step = new Uint16[ymin];
Uint16 *x_fact = new Uint16[xmin];
Uint16 *y_fact = new Uint16[ymin];
/*
* Approach: If one pixel line has to be added or removed it is taken from the middle of the image (1/2).
* For two lines it is at 1/3 and 2/3 of the image and so on. It sounds easy but it was a hard job ;-)
*/
if ((x_step != NULL) && (y_step != NULL) && (x_fact != NULL) && (y_fact != NULL))
{
Uint16 x;
Uint16 y;
if (this->Dest_X < this->Src_X)
setScaleValues(x_step, this->Dest_X, this->Src_X);
else if (this->Dest_X > this->Src_X)
setScaleValues(x_fact, this->Src_X, this->Dest_X);
if (this->Dest_X <= this->Src_X)
OFBitmanipTemplate<Uint16>::setMem(x_fact, 1, xmin); // initialize with default values
if (this->Dest_X >= this->Src_X)
OFBitmanipTemplate<Uint16>::setMem(x_step, 1, xmin); // initialize with default values
x_step[xmin - 1] += Columns - this->Src_X; // skip to next line
if (this->Dest_Y < this->Src_Y)
setScaleValues(y_step, this->Dest_Y, this->Src_Y);
else if (this->Dest_Y > this->Src_Y)
setScaleValues(y_fact, this->Src_Y, this->Dest_Y);
if (this->Dest_Y <= this->Src_Y)
OFBitmanipTemplate<Uint16>::setMem(y_fact, 1, ymin); // initialize with default values
if (this->Dest_Y >= this->Src_Y)
OFBitmanipTemplate<Uint16>::setMem(y_step, 1, ymin); // initialize with default values
y_step[ymin - 1] += Rows - this->Src_Y; // skip to next frame
const T *sp;
Uint16 dx;
Uint16 dy;
const T *p;
T *q;
T value;
for (int j = 0; j < this->Planes; ++j)
{
sp = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = 0; f < this->Frames; ++f)
{
for (y = 0; y < ymin; ++y)
{
for (dy = 0; dy < y_fact[y]; ++dy)
{
for (x = 0, p = sp; x < xmin; ++x)
{
value = *p;
for (dx = 0; dx < x_fact[x]; ++dx)
*(q++) = value;
p += x_step[x];
}
}
sp += OFstatic_cast(unsigned long, y_step[y]) * OFstatic_cast(unsigned long, Columns);
}
}
}
}
delete[] x_step;
delete[] y_step;
delete[] x_fact;
delete[] y_fact;
}
/** free scaling method with interpolation
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void interpolatePixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using scaling algorithm with interpolation from pbmplus toolkit");
if ((this->Src_X != Columns) || (this->Src_Y != Rows))
{
DCMIMGLE_ERROR("interpolated scaling and clipping at the same time not implemented ... ignoring clipping region");
this->Src_X = Columns; // temporarily removed 'const' for 'Src_X' in class 'DiTransTemplate'
this->Src_Y = Rows; // ... 'Src_Y' ...
}
/*
* based on scaling algorithm from "Extended Portable Bitmap Toolkit" (pbmplus10dec91)
* (adapted to be used with signed pixel representation, inverse images - mono1,
* various bit depths, multi-frame and multi-plane/color images)
*/
Uint16 x;
Uint16 y;
const T *p;
T *q;
const T *sp = NULL; // initialization avoids compiler warning
const T *fp;
T *sq;
const unsigned long sxscale = OFstatic_cast(unsigned long, (OFstatic_cast(double, this->Dest_X) / OFstatic_cast(double, this->Src_X)) * SCALE_FACTOR);
const unsigned long syscale = OFstatic_cast(unsigned long, (OFstatic_cast(double, this->Dest_Y) / OFstatic_cast(double, this->Src_Y)) * SCALE_FACTOR);
const signed long maxvalue = DicomImageClass::maxval(this->Bits - isSigned());
T *xtemp = new T[this->Src_X];
signed long *xvalue = new signed long[this->Src_X];
if ((xtemp == NULL) || (xvalue == NULL))
{
DCMIMGLE_ERROR("can't allocate temporary buffers for interpolation scaling");
this->clearPixel(dest);
} else {
for (int j = 0; j < this->Planes; ++j)
{
fp = src[j];
sq = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
for (x = 0; x < this->Src_X; ++x)
xvalue[x] = HALFSCALE_FACTOR;
unsigned long yfill = SCALE_FACTOR;
unsigned long yleft = syscale;
int yneed = 1;
int ysrc = 0;
for (y = 0; y < this->Dest_Y; ++y)
{
if (this->Src_Y == this->Dest_Y)
{
sp = fp;
for (x = this->Src_X, p = sp, q = xtemp; x != 0; --x)
*(q++) = *(p++);
fp += this->Src_X;
}
else
{
while (yleft < yfill)
{
if (yneed && (ysrc < OFstatic_cast(int, this->Src_Y)))
{
sp = fp;
fp += this->Src_X;
++ysrc;
}
for (x = 0, p = sp; x < this->Src_X; ++x)
xvalue[x] += yleft * OFstatic_cast(signed long, *(p++));
yfill -= yleft;
yleft = syscale;
yneed = 1;
}
if (yneed && (ysrc < OFstatic_cast(int, this->Src_Y)))
{
sp = fp;
fp += this->Src_X;
++ysrc;
yneed = 0;
}
signed long v;
for (x = 0, p = sp, q = xtemp; x < this->Src_X; ++x)
{
v = xvalue[x] + yfill * OFstatic_cast(signed long, *(p++));
v /= SCALE_FACTOR;
*(q++) = OFstatic_cast(T, (v > maxvalue) ? maxvalue : v);
xvalue[x] = HALFSCALE_FACTOR;
}
yleft -= yfill;
if (yleft == 0)
{
yleft = syscale;
yneed = 1;
}
yfill = SCALE_FACTOR;
}
if (this->Src_X == this->Dest_X)
{
for (x = this->Dest_X, p = xtemp, q = sq; x != 0; --x)
*(q++) = *(p++);
sq += this->Dest_X;
}
else
{
signed long v = HALFSCALE_FACTOR;
unsigned long xfill = SCALE_FACTOR;
unsigned long xleft;
int xneed = 0;
q = sq;
for (x = 0, p = xtemp; x < this->Src_X; ++x, ++p)
{
xleft = sxscale;
while (xleft >= xfill)
{
if (xneed)
{
++q;
v = HALFSCALE_FACTOR;
}
v += xfill * OFstatic_cast(signed long, *p);
v /= SCALE_FACTOR;
*q = OFstatic_cast(T, (v > maxvalue) ? maxvalue : v);
xleft -= xfill;
xfill = SCALE_FACTOR;
xneed = 1;
}
if (xleft > 0)
{
if (xneed)
{
++q;
v = HALFSCALE_FACTOR;
xneed = 0;
}
v += xleft * OFstatic_cast(signed long, *p);
xfill -= xleft;
}
}
if (xfill > 0)
v += xfill * OFstatic_cast(signed long, *(--p));
if (!xneed)
{
v /= SCALE_FACTOR;
*q = OFstatic_cast(T, (v > maxvalue) ? maxvalue : v);
}
sq += this->Dest_X;
}
}
}
}
}
delete[] xtemp;
delete[] xvalue;
}
/** free scaling method with interpolation (only for magnification)
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void expandPixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using expand pixel scaling algorithm with interpolation from c't magazine");
const double x_factor = OFstatic_cast(double, this->Src_X) / OFstatic_cast(double, this->Dest_X);
const double y_factor = OFstatic_cast(double, this->Src_Y) / OFstatic_cast(double, this->Dest_Y);
const unsigned long f_size = OFstatic_cast(unsigned long, Rows) * OFstatic_cast(unsigned long, Columns);
const T *sp;
double bx, ex;
double by, ey;
int bxi, exi;
int byi, eyi;
unsigned long offset;
double value, sum;
double x_part, y_part;
double l_factor, r_factor;
double t_factor, b_factor;
int xi;
int yi;
Uint16 x;
Uint16 y;
const T *p;
T *q;
/*
* based on scaling algorithm from "c't - Magazin fuer Computertechnik" (c't 11/94)
* (adapted to be used with signed pixel representation, inverse images - mono1,
* various bit depths, multi-frame and multi-plane/color images, combined clipping/scaling)
*/
for (int j = 0; j < this->Planes; ++j)
{
sp = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = 0; f < this->Frames; ++f)
{
for (y = 0; y < this->Dest_Y; ++y)
{
by = y_factor * OFstatic_cast(double, y);
ey = y_factor * (OFstatic_cast(double, y) + 1.0);
if (ey > this->Src_Y)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" limiting value of 'ey' to 'Src_Y': " << ey << " -> " << this->Src_Y);
#endif
// see reducePixel()
ey = this->Src_Y;
}
byi = OFstatic_cast(int, by);
eyi = OFstatic_cast(int, ey);
if (OFstatic_cast(double, eyi) == ey)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" decreasing value of 'eyi' by 1: " << eyi << " -> " << (eyi - 1));
#endif
--eyi;
}
y_part = OFstatic_cast(double, eyi) / y_factor;
b_factor = y_part - OFstatic_cast(double, y);
t_factor = (OFstatic_cast(double, y) + 1.0) - y_part;
for (x = 0; x < this->Dest_X; ++x)
{
value = 0;
bx = x_factor * OFstatic_cast(double, x);
ex = x_factor * (OFstatic_cast(double, x) + 1.0);
if (ex > this->Src_X)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" limiting value of 'ex' to 'Src_X': " << ex << " -> " << this->Src_X);
#endif
// see reducePixel()
ex = this->Src_X;
}
bxi = OFstatic_cast(int, bx);
exi = OFstatic_cast(int, ex);
if (OFstatic_cast(double, exi) == ex)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" decreasing value of 'exi' by 1: " << exi << " -> " << (exi - 1));
#endif
--exi;
}
x_part = OFstatic_cast(double, exi) / x_factor;
l_factor = x_part - OFstatic_cast(double, x);
r_factor = (OFstatic_cast(double, x) + 1.0) - x_part;
offset = OFstatic_cast(unsigned long, byi) * OFstatic_cast(unsigned long, Columns);
for (yi = byi; yi <= eyi; ++yi)
{
p = sp + offset + bxi;
for (xi = bxi; xi <= exi; ++xi)
{
sum = OFstatic_cast(double, *(p++));
if (bxi != exi)
{
if (xi == bxi)
sum *= l_factor;
else
sum *= r_factor;
}
if (byi != eyi)
{
if (yi == byi)
sum *= b_factor;
else
sum *= t_factor;
}
value += sum;
}
offset += Columns;
}
*(q++) = OFstatic_cast(T, value + 0.5);
}
}
sp += f_size;
}
}
}
/** free scaling method with interpolation (only for reduction)
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void reducePixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using reduce pixel scaling algorithm with interpolation from c't magazine");
const double x_factor = OFstatic_cast(double, this->Src_X) / OFstatic_cast(double, this->Dest_X);
const double y_factor = OFstatic_cast(double, this->Src_Y) / OFstatic_cast(double, this->Dest_Y);
const double xy_factor = x_factor * y_factor;
const unsigned long f_size = OFstatic_cast(unsigned long, Rows) * OFstatic_cast(unsigned long, Columns);
const T *sp;
double bx, ex;
double by, ey;
int bxi, exi;
int byi, eyi;
unsigned long offset;
double value, sum;
double l_factor, r_factor;
double t_factor, b_factor;
int xi;
int yi;
Uint16 x;
Uint16 y;
const T *p;
T *q;
/*
* based on scaling algorithm from "c't - Magazin fuer Computertechnik" (c't 11/94)
* (adapted to be used with signed pixel representation, inverse images - mono1,
* various bit depths, multi-frame and multi-plane/color images, combined clipping/scaling)
*/
for (int j = 0; j < this->Planes; ++j)
{
sp = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
q = dest[j];
for (unsigned long f = 0; f < this->Frames; ++f)
{
for (y = 0; y < this->Dest_Y; ++y)
{
by = y_factor * OFstatic_cast(double, y);
ey = y_factor * (OFstatic_cast(double, y) + 1.0);
if (ey > this->Src_Y)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" limiting value of 'ey' to 'Src_Y': " << ey << " -> " << this->Src_Y);
#endif
// yes, this can happen due to rounding, e.g. double(943) / double(471) * double(471)
// is something like 943.00000000000011368683772161602974 and then, the eyi == ey check
// fails to bring eyi back into range!
ey = this->Src_Y;
}
byi = OFstatic_cast(int, by);
eyi = OFstatic_cast(int, ey);
if (OFstatic_cast(double, eyi) == ey)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" decreasing value of 'eyi' by 1: " << eyi << " -> " << (eyi - 1));
#endif
--eyi;
}
b_factor = 1 + OFstatic_cast(double, byi) - by;
t_factor = ey - OFstatic_cast(double, eyi);
for (x = 0; x < this->Dest_X; ++x)
{
value = 0;
bx = x_factor * OFstatic_cast(double, x);
ex = x_factor * (OFstatic_cast(double, x) + 1.0);
if (ex > this->Src_X)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" limiting value of 'ex' to 'Src_X': " << ex << " -> " << this->Src_X);
#endif
// see above comment
ex = this->Src_X;
}
bxi = OFstatic_cast(int, bx);
exi = OFstatic_cast(int, ex);
if (OFstatic_cast(double, exi) == ex)
{
#ifdef DEBUG // this output is only useful for debugging purposes
DCMIMGLE_TRACE(" decreasing value of 'exi' by 1: " << exi << " -> " << (exi - 1));
#endif
--exi;
}
l_factor = 1 + OFstatic_cast(double, bxi) - bx;
r_factor = ex - OFstatic_cast(double, exi);
offset = OFstatic_cast(unsigned long, byi) * OFstatic_cast(unsigned long, Columns);
for (yi = byi; yi <= eyi; ++yi)
{
p = sp + offset + bxi;
for (xi = bxi; xi <= exi; ++xi)
{
sum = OFstatic_cast(double, *(p++)) / xy_factor;
if (xi == bxi)
sum *= l_factor;
else if (xi == exi)
sum *= r_factor;
if (yi == byi)
sum *= b_factor;
else if (yi == eyi)
sum *= t_factor;
value += sum;
}
offset += Columns;
}
*(q++) = OFstatic_cast(T, value + 0.5);
}
}
sp += f_size;
}
}
}
/** bilinear interpolation method (only for magnification)
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void bilinearPixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using magnification algorithm with bilinear interpolation contributed by Eduard Stanescu");
const double x_factor = OFstatic_cast(double, this->Src_X) / OFstatic_cast(double, this->Dest_X);
const double y_factor = OFstatic_cast(double, this->Src_Y) / OFstatic_cast(double, this->Dest_Y);
const unsigned long f_size = OFstatic_cast(unsigned long, Rows) * OFstatic_cast(unsigned long, Columns);
const unsigned long l_offset = OFstatic_cast(unsigned long, this->Src_Y - 1) * OFstatic_cast(unsigned long, this->Dest_X);
Uint16 x;
Uint16 y;
T *pD;
T *pCurrTemp;
const T *pCurrSrc;
Uint16 nSrcIndex;
double dOff;
T *pT;
const T *pS;
const T *pF;
// buffer used for storing temporarily the interpolated lines
T *pTemp = new T[OFstatic_cast(unsigned long, this->Src_Y) * OFstatic_cast(unsigned long, this->Dest_X)];
if (pTemp == NULL)
{
DCMIMGLE_ERROR("can't allocate temporary buffer for interpolation scaling");
this->clearPixel(dest);
} else {
/*
* based on scaling algorithm contributed by Eduard Stanescu
* (adapted to be used with signed pixel representation, inverse images - mono1,
* various bit depths, multi-frame multi-plane/color images, combined clipping/scaling)
*/
for (int j = 0; j < this->Planes; ++j)
{
pF = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
pD = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
pT = pCurrTemp = pTemp;
pS = pCurrSrc = pF;
// first, interpolate the columns:
// column 0, just copy the source data column 0
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = *(pCurrSrc);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
pCurrSrc = pS;
nSrcIndex = 0;
// column 1 to column Dest_X - 1
for (x = 1; x < this->Dest_X - 1; ++x)
{
pCurrTemp = ++pT;
dOff = x * x_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (y = 0; y < this->Src_Y; ++y)
{
// use floating points in order to avoid possible integer overflow
const double v1 = OFstatic_cast(double, *(pCurrSrc));
const double v2 = OFstatic_cast(double, *(pCurrSrc + 1));
*(pCurrTemp) = OFstatic_cast(T, v1 + (v2 - v1) * dOff);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
// don't go beyond the source data
if ((nSrcIndex < this->Src_X - 2) && (x * x_factor >= nSrcIndex + 1))
{
pS++;
nSrcIndex++;
}
pCurrSrc = pS;
}
pCurrTemp = ++pT;
// last column, just copy the source data column Src_X
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = *(pCurrSrc);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
// now the columns are interpolated in temp buffer, so interpolate the lines
pT = pCurrTemp = pTemp;
// line 0, just copy the temp buffer line 0
for (x = this->Dest_X; x != 0; --x)
*(pD++) = *(pCurrTemp++);
nSrcIndex = 0;
pCurrTemp = pTemp;
for (y = 1; y < this->Dest_Y - 1; ++y)
{
dOff = y * y_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (x = this->Dest_X; x != 0; --x)
{
// use floating points in order to avoid possible integer overflow
const double v1 = OFstatic_cast(double, *(pCurrTemp));
const double v2 = OFstatic_cast(double, *(pCurrTemp + this->Dest_X));
*(pD++) = OFstatic_cast(T, v1 + (v2 - v1) * dOff);
pCurrTemp++;
}
// don't go beyond the source data
if ((nSrcIndex < this->Src_Y - 2) && (y * y_factor >= nSrcIndex + 1))
{
pT += this->Dest_X;
nSrcIndex++;
}
pCurrTemp = pT;
}
// the last line, just copy the temp buffer line Src_X
pCurrTemp = pTemp + l_offset;
for (x = this->Dest_X; x != 0; --x)
*(pD++) = *(pCurrTemp++);
// skip to next frame
pF += f_size;
}
}
}
delete[] pTemp;
}
/** bicubic interpolation method (only for magnification)
*
** @param src array of pointers to source image pixels
* @param dest array of pointers to destination image pixels
*/
void bicubicPixel(const T *src[],
T *dest[])
{
DCMIMGLE_DEBUG("using magnification algorithm with bicubic interpolation contributed by Eduard Stanescu");
const double minVal = (isSigned()) ? -OFstatic_cast(double, DicomImageClass::maxval(this->Bits - 1, 0)) : 0.0;
const double maxVal = OFstatic_cast(double, DicomImageClass::maxval(this->Bits - isSigned()));
const double x_factor = OFstatic_cast(double, this->Src_X) / OFstatic_cast(double, this->Dest_X);
const double y_factor = OFstatic_cast(double, this->Src_Y) / OFstatic_cast(double, this->Dest_Y);
const Uint16 xDelta = OFstatic_cast(Uint16, 1 / x_factor);
const Uint16 yDelta = OFstatic_cast(Uint16, 1 / y_factor);
const unsigned long f_size = OFstatic_cast(unsigned long, Rows) * OFstatic_cast(unsigned long, Columns);
const unsigned long l_offset = OFstatic_cast(unsigned long, this->Src_Y - 1) * OFstatic_cast(unsigned long, this->Dest_X);
Uint16 x;
Uint16 y;
T *pD;
T *pCurrTemp;
const T *pCurrSrc;
Uint16 nSrcIndex;
double dOff;
T *pT;
const T *pS;
const T *pF;
// buffer used for storing temporarily the interpolated lines
T *pTemp = pT = pCurrTemp = new T[OFstatic_cast(unsigned long, this->Src_Y) * OFstatic_cast(unsigned long, this->Dest_X)];
if (pTemp == NULL)
{
DCMIMGLE_ERROR("can't allocate temporary buffer for interpolation scaling");
this->clearPixel(dest);
} else {
/*
* based on scaling algorithm contributed by Eduard Stanescu
* (adapted to be used with signed pixel representation, inverse images - mono1,
* various bit depths, multi-frame multi-plane/color images, combined clipping/scaling)
*/
for (int j = 0; j < this->Planes; ++j)
{
pF = src[j] + OFstatic_cast(unsigned long, Top) * OFstatic_cast(unsigned long, Columns) + Left;
pD = dest[j];
for (unsigned long f = this->Frames; f != 0; --f)
{
pT = pCurrTemp = pTemp;
pS = pCurrSrc = pF;
// first, interpolate the columns:
// column 0, just copy the source data column 0
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = *(pCurrSrc);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
pCurrSrc = pS;
// for the next few columns, linear interpolation
for (x = 1; x < xDelta + 1; ++x)
{
pCurrSrc = pS;
pCurrTemp = ++pT;
dOff = x * x_factor;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = OFstatic_cast(T, *(pCurrSrc) + (*(pCurrSrc + 1) - *(pCurrSrc)) * dOff);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
}
nSrcIndex = 1;
pCurrSrc = ++pS;
// the majority of the columns
for (x = xDelta + 1; x < this->Dest_X - 2 * xDelta; ++x)
{
pCurrTemp = ++pT;
dOff = x * x_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = OFstatic_cast(T, cubicValue(*(pCurrSrc - 1), *(pCurrSrc), *(pCurrSrc + 1), *(pCurrSrc + 2), dOff, minVal, maxVal));
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
// don't go beyond the source data
if ((nSrcIndex < this->Src_X - 3) && (x * x_factor >= nSrcIndex + 1))
{
pS++;
nSrcIndex++;
}
pCurrSrc = pS;
}
// last few columns except the very last one, linear interpolation
for (x = this->Dest_X - 2 * xDelta; x < this->Dest_X - 1; ++x)
{
pCurrTemp = ++pT;
dOff = x * x_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = OFstatic_cast(T, *(pCurrSrc) + (*(pCurrSrc + 1) - *(pCurrSrc)) * dOff);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
// don't go beyond the source data
if ((nSrcIndex < this->Src_X - 2) && (x * x_factor >= nSrcIndex + 1))
{
pS++;
nSrcIndex++;
}
pCurrSrc = pS;
}
// last column, just copy the source data column Src_X
pCurrTemp = pTemp + this->Dest_X - 1;
pCurrSrc = pF + this->Src_X - 1;
for (y = this->Src_Y; y != 0; --y)
{
*(pCurrTemp) = *(pCurrSrc);
pCurrSrc += Columns;
pCurrTemp += this->Dest_X;
}
// now the columns are interpolated in temp buffer, so interpolate the lines
pT = pCurrTemp = pTemp;
// line 0, just copy the temp buffer line 0
for (x = this->Dest_X; x != 0; --x)
*(pD++) = *(pCurrTemp++);
// for the next few lines, linear interpolation between line 0 and 1 of the temp buffer
for (y = 1; y < yDelta + 1; ++y)
{
pCurrTemp = pTemp;
dOff = y * y_factor;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (x = this->Dest_X; x != 0; --x)
{
*(pD++) = OFstatic_cast(T, *(pCurrTemp) + (*(pCurrTemp + this->Dest_X) - *(pCurrTemp)) * dOff);
pCurrTemp++;
}
}
nSrcIndex = 1;
pCurrTemp = pT = pTemp + this->Dest_X;
for (y = yDelta + 1; y < this->Dest_Y - yDelta - 1; ++y)
{
dOff = y * y_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (x = this->Dest_X; x != 0; --x)
{
*(pD++) = OFstatic_cast(T, cubicValue(*(pCurrTemp - this->Dest_X),*(pCurrTemp), *(pCurrTemp + this->Dest_X),
*(pCurrTemp + this->Dest_X + this->Dest_X), dOff, minVal, maxVal));
pCurrTemp++;
}
// don't go beyond the source data
if ((nSrcIndex < this->Src_Y - 3) && (y * y_factor >= nSrcIndex + 1))
{
pT += this->Dest_X;
nSrcIndex++;
}
pCurrTemp = pT;
}
// the last few lines except the very last one, linear interpolation in between the second last and the last lines
pCurrTemp = pT = pTemp + OFstatic_cast(unsigned long, this->Src_Y - 2) * OFstatic_cast(unsigned long, this->Dest_X);
for (y = this->Dest_Y - yDelta - 1; y < this->Dest_Y - 1; ++y)
{
dOff = y * y_factor - nSrcIndex;
dOff = (1.0 < dOff) ? 1.0 : dOff;
for (x = this->Dest_X; x != 0; --x)
{
*(pD++) = OFstatic_cast(T, *(pCurrTemp) + (*(pCurrTemp + this->Dest_X) - *(pCurrTemp)) * dOff);
pCurrTemp++;
}
pCurrTemp = pT;
}
// the the last line, just copy the temp buffer line Src_X
pCurrTemp = pTemp + l_offset;
for (x = this->Dest_X; x != 0; --x)
*(pD++) = *(pCurrTemp++);
// skip to next frame
pF += f_size;
}
}
}
delete[] pTemp;
}
};
#endif
Reference in New Issue Copy Permalink