bool QGLPixmapData::fromFile(const QString &filename, const char *format,
Qt::ImageConversionFlags flags)
{
if (pixelType() == QPixmapData::BitmapType)
return QPixmapData::fromFile(filename, format, flags);
QFile file(filename);
if (!file.open(QIODevice::ReadOnly))
return false;
QByteArray data = file.peek(64);
bool alpha;
if (m_texture.canBindCompressedTexture
(data.constData(), data.size(), format, &alpha)) {
resize(0, 0);
data = file.readAll();
file.close();
QGLShareContextScope ctx(qt_gl_share_widget()->context());
QSize size = m_texture.bindCompressedTexture
(data.constData(), data.size(), format);
if (!size.isEmpty()) {
w = size.width();
h = size.height();
is_null = false;
d = 32;
m_hasAlpha = alpha;
m_source = QImage();
m_dirty = isValid();
return true;
}
return false;
}
fromImage(QImageReader(&file, format).read(), flags);
return !isNull();
}
void QGLPixmapData::resize(int width, int height)
{
if (width == w && height == h)
return;
if (width <= 0 || height <= 0) {
width = 0;
height = 0;
}
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
d = pixelType() == QPixmapData::PixmapType ? 32 : 1;
if (m_texture.id) {
QGLShareContextScope ctx(qt_gl_share_context());
glDeleteTextures(1, &m_texture.id);
m_texture.id = 0;
}
m_source = QImage();
m_dirty = isValid();
setSerialNumber(++qt_gl_pixmap_serial);
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode( Image* original, const std::string& organName, const mitk::Color& color )
{
// we NEED a reference image for size etc.
if (!original) return NULL;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
Image::Pointer segmentation = Image::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = { original->GetDimension(0), original->GetDimension(1), 1 };
segmentation->Initialize(pixelType, 3, dimensions);
}
else
{
segmentation->Initialize(pixelType, original->GetDimension(), original->GetDimensions());
}
unsigned int byteSize = sizeof(DefaultSegmentationDataType);
if(segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation, segmentation->GetVolumeData(0));
memset( writeAccess.GetData(), 0, byteSize );
}
else
{//if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for( unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation, segmentation->GetVolumeData(volumeNumber));
memset( writeAccess.GetData(), 0, byteSize );
}
}
if (original->GetTimeGeometry() )
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry( originalGeometry );
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return NULL;
}
return CreateSegmentationNode( segmentation, organName, color );
}
void QMacPixmapData::resize(int width, int height)
{
setSerialNumber(++qt_pixmap_serial);
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
d = (pixelType() == BitmapType ? 1 : 32);
bool make_null = w <= 0 || h <= 0; // create null pixmap
if (make_null || d == 0) {
w = 0;
h = 0;
is_null = true;
d = 0;
if (!make_null)
qWarning("Qt: QPixmap: Invalid pixmap parameters");
return;
}
if (w < 1 || h < 1)
return;
//create the pixels
bytesPerRow = w * sizeof(quint32); // Minimum bytes per row.
// Quartz2D likes things as a multple of 16 (for now).
bytesPerRow = COMPTUE_BEST_BYTES_PER_ROW(bytesPerRow);
macCreatePixels();
}
void QEglGLPixmapData::fromImage(const QImage &image, Qt::ImageConversionFlags flags)
{
TRACE();
resize(image.width(), image.height());
if (pixelType() == BitmapType) {
m_source = image.convertToFormat(QImage::Format_MonoLSB);
} else {
QImage::Format format = QImage::Format_RGB32;
if (qApp->desktop()->depth() == 16)
format = QImage::Format_RGB16;
if (image.hasAlphaChannel() && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels())
format = QImage::Format_ARGB32_Premultiplied;;
m_source = image.convertToFormat(format);
}
m_dirty = true;
m_hasFillColor = false;
m_hasAlpha = m_source.hasAlphaChannel();
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = m_source.depth();
if (m_texture.id) {
QGLShareContextScope ctx(qt_gl_share_widget()->context());
glDeleteTextures(1, &m_texture.id);
m_texture.id = 0;
}
}
void QGLPixmapData::fromNativeType(void* pixmap, NativeType type)
{
if (type == QPixmapData::SgImage && pixmap) {
#if defined(QT_SYMBIAN_SUPPORTS_SGIMAGE) && !defined(QT_NO_EGL)
RSgImage *sgImage = reinterpret_cast<RSgImage*>(pixmap);
m_sgImage = new RSgImage;
m_sgImage->Open(sgImage->Id());
TSgImageInfo info;
sgImage->GetInfo(info);
w = info.iSizeInPixels.iWidth;
h = info.iSizeInPixels.iHeight;
d = symbianPixeFormatBitsPerPixel((TUidPixelFormat)info.iPixelFormat);
m_source = QVolatileImage();
m_hasAlpha = true;
m_hasFillColor = false;
m_dirty = true;
is_null = (w <= 0 || h <= 0);
#endif
} else if (type == QPixmapData::FbsBitmap && pixmap) {
CFbsBitmap *bitmap = reinterpret_cast<CFbsBitmap *>(pixmap);
QSize size(bitmap->SizeInPixels().iWidth, bitmap->SizeInPixels().iHeight);
if (size.width() == w && size.height() == h)
setSerialNumber(++qt_gl_pixmap_serial);
resize(size.width(), size.height());
m_source = QVolatileImage(bitmap);
if (pixelType() == BitmapType) {
m_source.ensureFormat(QImage::Format_MonoLSB);
} else if (!knownGoodFormat(m_source.format())) {
m_source.beginDataAccess();
QImage::Format format = idealFormat(m_source.imageRef(), Qt::AutoColor);
m_source.endDataAccess(true);
m_source.ensureFormat(format);
}
m_hasAlpha = m_source.hasAlphaChannel();
m_hasFillColor = false;
m_dirty = true;
d = m_source.depth();
} else if (type == QPixmapData::VolatileImage && pixmap) {
// Support QS60Style in more efficient skin graphics retrieval.
QVolatileImage *img = static_cast<QVolatileImage *>(pixmap);
if (img->width() == w && img->height() == h)
setSerialNumber(++qt_gl_pixmap_serial);
resize(img->width(), img->height());
m_source = *img;
m_hasAlpha = m_source.hasAlphaChannel();
m_hasFillColor = false;
m_dirty = true;
d = m_source.depth();
} else if (type == QPixmapData::NativeImageHandleProvider && pixmap) {
destroyTexture();
nativeImageHandleProvider = static_cast<QNativeImageHandleProvider *>(pixmap);
// Cannot defer the retrieval, we need at least the size right away.
createFromNativeImageHandleProvider();
}
}
/**
* Construct a tile handler. This will determine a good chunk size to put
* into the output cube.
*
* @param dataFile The file with cube DN data in it
* @param virtualBandList The mapping from virtual band to physical band, see
* CubeIoHandler's description.
* @param labels The Pvl labels for the cube
* @param alreadyOnDisk True if the cube is allocated on the disk, false
* otherwise
*/
CubeTileHandler::CubeTileHandler(QFile * dataFile,
const QList<int> *virtualBandList, const Pvl &labels, bool alreadyOnDisk)
: CubeIoHandler(dataFile, virtualBandList, labels, alreadyOnDisk) {
const PvlObject &core = labels.findObject("IsisCube").findObject("Core");
if(core.hasKeyword("Format")) {
setChunkSizes(core["TileSamples"], core["TileLines"], 1);
}
else {
// up to 1MB chunks
int sampleChunkSize =
findGoodSize(512 * 4 / SizeOf(pixelType()), sampleCount());
int lineChunkSize =
findGoodSize(512 * 4 / SizeOf(pixelType()), lineCount());
setChunkSizes(sampleChunkSize, lineChunkSize, 1);
}
}
void QRasterPlatformPixmap::resize(int width, int height)
{
QImage::Format format;
if (pixelType() == BitmapType)
format = QImage::Format_MonoLSB;
else
format = QNativeImage::systemFormat();
image = QImage(width, height, format);
w = width;
h = height;
d = image.depth();
is_null = (w <= 0 || h <= 0);
if (pixelType() == BitmapType && !image.isNull()) {
image.setColorCount(2);
image.setColor(0, QColor(Qt::color0).rgba());
image.setColor(1, QColor(Qt::color1).rgba());
}
setSerialNumber(image.cacheKey() >> 32);
}
// Force the pixmap data to be backed by some valid data.
void QGLPixmapData::forceToImage()
{
if (!isValid())
return;
if (m_source.isNull()) {
QImage::Format format = QImage::Format_ARGB32_Premultiplied;
if (pixelType() == BitmapType)
format = QImage::Format_MonoLSB;
m_source = QVolatileImage(w, h, format);
}
m_dirty = true;
}
QPixmap QDirectFBPixmapData::transformed(const QTransform &transform,
Qt::TransformationMode mode) const
{
if (!surface || transform.type() != QTransform::TxScale
|| mode != Qt::FastTransformation)
{
QDirectFBPixmapData *that = const_cast<QDirectFBPixmapData*>(this);
const QImage *image = that->buffer();
if (image) { // avoid deep copy
const QImage transformed = image->transformed(transform, mode);
that->unlockDirectFB();
QDirectFBPixmapData *data = new QDirectFBPixmapData(pixelType());
data->fromImage(transformed, Qt::AutoColor);
return QPixmap(data);
}
return QPixmapData::transformed(transform, mode);
}
int w, h;
surface->GetSize(surface, &w, &h);
const QSize size = transform.mapRect(QRect(0, 0, w, h)).size();
if (size.isEmpty())
return QPixmap();
QDirectFBPixmapData *data = new QDirectFBPixmapData(pixelType());
data->resize(size.width(), size.height());
IDirectFBSurface *dest = data->surface;
dest->SetBlittingFlags(dest, DSBLIT_NOFX);
const DFBRectangle srcRect = { 0, 0, w, h };
const DFBRectangle destRect = { 0, 0, size.width(), size.height() };
dest->StretchBlit(dest, surface, &srcRect, &destRect);
return QPixmap(data);
}
/*!
out-of-place conversion (inPlace == false) will always detach()
*/
void QGLPixmapData::createPixmapForImage(QImage &image, Qt::ImageConversionFlags flags, bool inPlace)
{
if (image.size() == QSize(w, h))
setSerialNumber(++qt_gl_pixmap_serial);
resize(image.width(), image.height());
if (pixelType() == BitmapType) {
m_source = image.convertToFormat(QImage::Format_MonoLSB);
} else {
QImage::Format format = QImage::Format_RGB32;
if (qApp->desktop()->depth() == 16)
format = QImage::Format_RGB16;
if (image.hasAlphaChannel()
&& ((flags & Qt::NoOpaqueDetection)
|| const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels()))
format = QImage::Format_ARGB32_Premultiplied;;
if (inPlace && image.data_ptr()->convertInPlace(format, flags)) {
m_source = image;
} else {
m_source = image.convertToFormat(format);
// convertToFormat won't detach the image if format stays the same.
if (image.format() == format)
m_source.detach();
}
}
m_dirty = true;
m_hasFillColor = false;
m_hasAlpha = m_source.hasAlphaChannel();
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = m_source.depth();
if (m_texture.id) {
QGLShareContextScope ctx(qt_gl_share_context());
glDeleteTextures(1, &m_texture.id);
m_texture.id = 0;
}
}
void QGLPixmapData::createPixmapForImage(QImage &image, Qt::ImageConversionFlags flags, bool inPlace)
{
if (image.size() == QSize(w, h))
setSerialNumber(++qt_gl_pixmap_serial);
resize(image.width(), image.height());
if (pixelType() == BitmapType) {
QImage convertedImage = image.convertToFormat(QImage::Format_MonoLSB);
if (image.format() == QImage::Format_MonoLSB)
convertedImage.detach();
m_source = QVolatileImage(convertedImage);
} else {
QImage::Format format = idealFormat(image, flags);
if (inPlace && image.data_ptr()->convertInPlace(format, flags)) {
m_source = QVolatileImage(image);
} else {
QImage convertedImage = image.convertToFormat(format);
// convertToFormat won't detach the image if format stays the same.
if (image.format() == format)
convertedImage.detach();
m_source = QVolatileImage(convertedImage);
}
}
m_dirty = true;
m_hasFillColor = false;
m_hasAlpha = m_source.hasAlphaChannel();
w = image.width();
h = image.height();
is_null = (w <= 0 || h <= 0);
d = m_source.depth();
destroyTexture();
}
void QGLPixmapData::resize(int width, int height)
{
if (width == w && height == h)
return;
if (width <= 0 || height <= 0) {
width = 0;
height = 0;
}
w = width;
h = height;
is_null = (w <= 0 || h <= 0);
d = pixelType() == QPixmapData::PixmapType ? 32 : 1;
destroyTexture();
m_source = QVolatileImage();
m_dirty = isValid();
setSerialNumber(++qt_gl_pixmap_serial);
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode( Image* original, const std::string& organName, const mitk::Color& color )
{
// we NEED a reference image for size etc.
if (!original) return NULL;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>() );
Image::Pointer segmentation = Image::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = { original->GetDimension(0), original->GetDimension(1), 1 };
segmentation->Initialize(pixelType, 3, dimensions);
}
else
{
segmentation->Initialize(pixelType, original->GetDimension(), original->GetDimensions());
}
unsigned int byteSize = sizeof(DefaultSegmentationDataType);
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
memset( segmentation->GetData(), 0, byteSize );
if (original->GetTimeSlicedGeometry() )
{
AffineGeometryFrame3D::Pointer originalGeometryAGF = original->GetTimeSlicedGeometry()->Clone();
TimeSlicedGeometry::Pointer originalGeometry = dynamic_cast<TimeSlicedGeometry*>( originalGeometryAGF.GetPointer() );
segmentation->SetGeometry( originalGeometry );
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return NULL;
}
return CreateSegmentationNode( segmentation, organName, color );
}
void mitk::CorrectorAlgorithm::ItkCalculateDifferenceImage( itk::Image<TPixel, VImageDimension>* originalImage, Image* modifiedMITKImage )
{
typedef itk::Image<ipMITKSegmentationTYPE, VImageDimension> ModifiedImageType;
typedef itk::Image<short signed int, VImageDimension> DiffImageType;
typedef itk::ImageRegionConstIterator< itk::Image<TPixel,VImageDimension> > OriginalSliceIteratorType;
typedef itk::ImageRegionConstIterator< ModifiedImageType > ModifiedSliceIteratorType;
typedef itk::ImageRegionIterator< DiffImageType > DiffSliceIteratorType;
typename ModifiedImageType::Pointer modifiedImage;
CastToItkImage( modifiedMITKImage, modifiedImage );
// create new image as a copy of the input
// this new image is the output of this filter class
typename DiffImageType::Pointer diffImage;
m_DifferenceImage = Image::New();
PixelType pixelType( typeid(short signed int) );
m_DifferenceImage->Initialize( pixelType, 2, modifiedMITKImage->GetDimensions() );
CastToItkImage( m_DifferenceImage, diffImage );
// iterators over both input images (original and modified) and the output image (diff)
ModifiedSliceIteratorType modifiedIterator( modifiedImage, diffImage->GetLargestPossibleRegion() );
OriginalSliceIteratorType originalIterator( originalImage, diffImage->GetLargestPossibleRegion() );
DiffSliceIteratorType diffIterator( diffImage, diffImage->GetLargestPossibleRegion() );
modifiedIterator.GoToBegin();
originalIterator.GoToBegin();
diffIterator.GoToBegin();
while ( !diffIterator.IsAtEnd() )
{
short signed int difference = static_cast<short signed int>( static_cast<signed int>(modifiedIterator.Get()) -
static_cast<signed int>(originalIterator.Get())); // not good for bigger values ?!
diffIterator.Set( difference );
++modifiedIterator;
++originalIterator;
++diffIterator;
}
}
QImage QGLPixmapData::fillImage(const QColor &color) const
{
QImage img;
if (pixelType() == BitmapType) {
img = QImage(w, h, QImage::Format_MonoLSB);
img.setColorCount(2);
img.setColor(0, QColor(Qt::color0).rgba());
img.setColor(1, QColor(Qt::color1).rgba());
if (color == Qt::color1)
img.fill(1);
else
img.fill(0);
} else {
img = QImage(w, h,
m_hasAlpha
? QImage::Format_ARGB32_Premultiplied
: QImage::Format_RGB32);
img.fill(PREMUL(color.rgba()));
}
return img;
}
void mitk::OverwriteSliceImageFilter::GenerateData()
{
//
// this is the place to implement the major part of undo functionality (bug #491)
// here we have to create undo/do operations
//
// WHO is the operation actor? This object may not be destroyed ever (design of undo stack)!
// -> some singleton method of this filter?
//
// neccessary additional objects:
// - something that executes the operations
// - the operation class (must hold a binary diff or something)
// - observer commands to know when the image is deleted (no further action then, perhaps even remove the operations from the undo stack)
//
Image::ConstPointer input = ImageToImageFilter::GetInput(0);
Image::ConstPointer input3D = input;
Image::ConstPointer slice = m_SliceImage;
if ( input.IsNull() || slice.IsNull() ) return;
switch (m_SliceDimension)
{
default:
case 2:
m_Dimension0 = 0;
m_Dimension1 = 1;
break;
case 1:
m_Dimension0 = 0;
m_Dimension1 = 2;
break;
case 0:
m_Dimension0 = 1;
m_Dimension1 = 2;
break;
}
if ( slice->GetDimension() < 2 || input->GetDimension() > 4 ||
slice->GetDimension(0) != input->GetDimension(m_Dimension0) ||
slice->GetDimension(1) != input->GetDimension(m_Dimension1) ||
m_SliceIndex >= input->GetDimension(m_SliceDimension)
)
{
itkExceptionMacro("Slice and image dimensions differ or slice index is too large. Sorry, cannot work like this.");
return;
}
if ( input->GetDimension() == 4 )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( input );
timeSelector->SetTimeNr( m_TimeStep );
timeSelector->UpdateLargestPossibleRegion();
input3D = timeSelector->GetOutput();
}
if ( m_SliceDifferenceImage.IsNull() ||
m_SliceDifferenceImage->GetDimension(0) != m_SliceImage->GetDimension(0) ||
m_SliceDifferenceImage->GetDimension(1) != m_SliceImage->GetDimension(1) )
{
m_SliceDifferenceImage = mitk::Image::New();
mitk::PixelType pixelType( mitk::MakeScalarPixelType<short signed int>() );
m_SliceDifferenceImage->Initialize( pixelType, 2, m_SliceImage->GetDimensions() );
}
//MITK_INFO << "Overwriting slice " << m_SliceIndex << " in dimension " << m_SliceDimension << " at time step " << m_TimeStep << std::endl;
// this will do a long long if/else to find out both pixel types
AccessFixedDimensionByItk( input3D, ItkImageSwitch, 3 );
SegmentationInterpolationController* interpolator = SegmentationInterpolationController::InterpolatorForImage( input );
if (interpolator)
{
interpolator->BlockModified(true);
interpolator->SetChangedSlice( m_SliceDifferenceImage, m_SliceDimension, m_SliceIndex, m_TimeStep );
}
if ( m_CreateUndoInformation )
{
// create do/undo operations (we don't execute the doOp here, because it has already been executed during calculation of the diff image
ApplyDiffImageOperation* doOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
ApplyDiffImageOperation* undoOp = new ApplyDiffImageOperation( OpTEST, const_cast<Image*>(input.GetPointer()), m_SliceDifferenceImage, m_TimeStep, m_SliceDimension, m_SliceIndex );
undoOp->SetFactor( -1.0 );
OperationEvent* undoStackItem = new OperationEvent( DiffImageApplier::GetInstanceForUndo(), doOp, undoOp, this->EventDescription(m_SliceDimension, m_SliceIndex, m_TimeStep) );
UndoController::GetCurrentUndoModel()->SetOperationEvent( undoStackItem );
}
// this image is modified (good to know for the renderer)
input->Modified();
if (interpolator)
{
interpolator->BlockModified(false);
}
}
void QMacPixmapData::fromImage(const QImage &img,
Qt::ImageConversionFlags flags)
{
setSerialNumber(++qt_pixmap_serial);
// the conversion code only handles format >=
// Format_ARGB32_Premultiplied at the moment..
if (img.format() > QImage::Format_ARGB32_Premultiplied) {
QImage image;
if (img.hasAlphaChannel())
image = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
else
image = img.convertToFormat(QImage::Format_RGB32);
fromImage(image, flags);
return;
}
w = img.width();
h = img.height();
is_null = (w <= 0 || h <= 0);
d = (pixelType() == BitmapType ? 1 : img.depth());
QImage image = img;
int dd = QPixmap::defaultDepth();
bool force_mono = (dd == 1 ||
(flags & Qt::ColorMode_Mask)==Qt::MonoOnly);
if (force_mono) { // must be monochrome
if (d != 1) {
image = image.convertToFormat(QImage::Format_MonoLSB, flags); // dither
d = 1;
}
} else { // can be both
bool conv8 = false;
if(d > 8 && dd <= 8) { // convert to 8 bit
if ((flags & Qt::DitherMode_Mask) == Qt::AutoDither)
flags = (flags & ~Qt::DitherMode_Mask)
| Qt::PreferDither;
conv8 = true;
} else if ((flags & Qt::ColorMode_Mask) == Qt::ColorOnly) {
conv8 = d == 1; // native depth wanted
} else if (d == 1) {
if (image.colorCount() == 2) {
QRgb c0 = image.color(0); // Auto: convert to best
QRgb c1 = image.color(1);
conv8 = qMin(c0,c1) != qRgb(0,0,0) || qMax(c0,c1) != qRgb(255,255,255);
} else {
// eg. 1-color monochrome images (they do exist).
conv8 = true;
}
}
if (conv8) {
image = image.convertToFormat(QImage::Format_Indexed8, flags);
d = 8;
}
}
if (image.depth()==1) {
image.setColor(0, QColor(Qt::color0).rgba());
image.setColor(1, QColor(Qt::color1).rgba());
}
if (d == 16 || d == 24) {
image = image.convertToFormat(QImage::Format_RGB32, flags);
fromImage(image, flags);
return;
}
// different size or depth, make a new pixmap
resize(w, h);
quint32 *dptr = pixels, *drow;
const uint dbpr = bytesPerRow;
const QImage::Format sfmt = image.format();
const unsigned short sbpr = image.bytesPerLine();
// use const_cast to prevent a detach
const uchar *sptr = const_cast<const QImage &>(image).bits(), *srow;
for (int y = 0; y < h; ++y) {
drow = dptr + (y * (dbpr / 4));
srow = sptr + (y * sbpr);
switch(sfmt) {
case QImage::Format_MonoLSB:
case QImage::Format_Mono:{
for (int x = 0; x < w; ++x) {
char one_bit = *(srow + (x / 8));
if (sfmt == QImage::Format_Mono)
one_bit = one_bit >> (7 - (x % 8));
else
one_bit = one_bit >> (x % 8);
if ((one_bit & 0x01))
*(drow+x) = 0xFF000000;
else
*(drow+x) = 0xFFFFFFFF;
}
break;
}
case QImage::Format_Indexed8: {
int numColors = image.numColors();
if (numColors > 0) {
for (int x = 0; x < w; ++x) {
int index = *(srow + x);
*(drow+x) = PREMUL(image.color(qMin(index, numColors)));
}
}
} break;
case QImage::Format_RGB32:
for (int x = 0; x < w; ++x)
*(drow+x) = *(((quint32*)srow) + x) | 0xFF000000;
break;
case QImage::Format_ARGB32:
case QImage::Format_ARGB32_Premultiplied:
for (int x = 0; x < w; ++x) {
if(sfmt == QImage::Format_RGB32)
*(drow+x) = 0xFF000000 | (*(((quint32*)srow) + x) & 0x00FFFFFF);
else if(sfmt == QImage::Format_ARGB32_Premultiplied)
*(drow+x) = *(((quint32*)srow) + x);
else
*(drow+x) = PREMUL(*(((quint32*)srow) + x));
}
break;
default:
qWarning("Qt: internal: Oops: Forgot a format [%d] %s:%d", sfmt,
__FILE__, __LINE__);
break;
}
}
/**
* Handles "PixelType" property.
*/
int MUCamSource::OnPixelType(MM::PropertyBase* pProp, MM::ActionType eAct)
{
if (eAct == MM::AfterSet)
{
string val;
pProp->Get(val);
if (val.compare(g_PixelType_8bit) == 0)
{
MUCam_setBitCount(hCameras_[currentCam_], 8);
bytesPerPixel_ = 1;
bitCnt_ = 8;
}
else if (val.compare(g_PixelType_16bit) == 0)
{
MUCam_setBitCount(hCameras_[currentCam_], 16);
bytesPerPixel_ = 2;
bitCnt_ = 16;
}
else if (val.compare(g_PixelType_32bitRGB) == 0)
{
MUCam_setBitCount(hCameras_[currentCam_], 8);
bytesPerPixel_ = 4;
bitCnt_ = 24;
}
else if (val.compare(g_PixelType_64bitRGB) == 0)
{
MUCam_setBitCount(hCameras_[currentCam_], 16);
bytesPerPixel_ = 8;
bitCnt_ = 48;
}
else
assert(false);
////////////////////////////////
////////////////////////////////////////////////////////////////////////
char buf[MM::MaxStrLength];
GetProperty(MM::g_Keyword_PixelType, buf);
std::string pixelType(buf);
if (pixelType.compare(g_PixelType_8bit) == 0)
{
if(bytesPerPixel_ == 2)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_16bit);
}
else if(bytesPerPixel_ == 4)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_32bitRGB);
}
else if(bytesPerPixel_ == 8)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_64bitRGB);
}
}
else if (pixelType.compare(g_PixelType_16bit) == 0)
{
if(bytesPerPixel_ == 1)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_8bit);
}
else if(bytesPerPixel_ == 4)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_32bitRGB);
}
else if(bytesPerPixel_ == 8)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_64bitRGB);
}
}
else if (pixelType.compare(g_PixelType_32bitRGB) == 0)
{
if(bytesPerPixel_ == 1)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_8bit);
}
else if(bytesPerPixel_ == 2)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_16bit);
}
else if(bytesPerPixel_ == 8)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_64bitRGB);
}
}
else if (pixelType.compare(g_PixelType_64bitRGB) == 0)
{
if(bytesPerPixel_ == 1)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_8bit);
}
else if(bytesPerPixel_ == 2)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_16bit);
}
else if(bytesPerPixel_ == 4)
{
SetProperty(MM::g_Keyword_PixelType, g_PixelType_32bitRGB);
}
}
// save to plist
ResizeImageBuffer();
}
else if (eAct == MM::BeforeGet)
{
if (bytesPerPixel_ == 1)
pProp->Set(g_PixelType_8bit);
else if (bytesPerPixel_ == 2)
pProp->Set(g_PixelType_16bit);
else if (bytesPerPixel_ == 4)
pProp->Set(g_PixelType_32bitRGB);
else if (bytesPerPixel_ == 8)
pProp->Set(g_PixelType_64bitRGB);
else
assert(false); // this should never happen
}
return DEVICE_OK;
}
QPixmapData *QMacPixmapData::createCompatiblePixmapData() const
{
return new QMacPixmapData(pixelType());
}
QPixmapData *QMeeGoLivePixmapData::createCompatiblePixmapData() const
{
qWarning("Create compatible called on live pixmap! Expect fail soon...");
return new QMeeGoRasterPixmapData(pixelType());
}
void mitk::Image::Initialize(vtkImageData* vtkimagedata, int channels, int tDim, int sDim, int pDim)
{
if(vtkimagedata==nullptr) return;
m_Dimension=vtkimagedata->GetDataDimension();
unsigned int i, *tmpDimensions=new unsigned int[m_Dimension>4?m_Dimension:4];
for(i=0;i<m_Dimension;++i) tmpDimensions[i]=vtkimagedata->GetDimensions()[i];
if(m_Dimension<4)
{
unsigned int *p;
for(i=0,p=tmpDimensions+m_Dimension;i<4-m_Dimension;++i, ++p)
*p=1;
}
if(pDim>=0)
{
tmpDimensions[1]=pDim;
if(m_Dimension < 2)
m_Dimension = 2;
}
if(sDim>=0)
{
tmpDimensions[2]=sDim;
if(m_Dimension < 3)
m_Dimension = 3;
}
if(tDim>=0)
{
tmpDimensions[3]=tDim;
if(m_Dimension < 4)
m_Dimension = 4;
}
mitk::PixelType pixelType(MakePixelType(vtkimagedata));
Initialize(pixelType, m_Dimension, tmpDimensions, channels);
const double *spacinglist = vtkimagedata->GetSpacing();
Vector3D spacing;
FillVector3D(spacing, spacinglist[0], 1.0, 1.0);
if(m_Dimension>=2)
spacing[1]=spacinglist[1];
if(m_Dimension>=3)
spacing[2]=spacinglist[2];
// access origin of vtkImage
Point3D origin;
double vtkorigin[3];
vtkimagedata->GetOrigin(vtkorigin);
FillVector3D(origin, vtkorigin[0], 0.0, 0.0);
if(m_Dimension>=2)
origin[1]=vtkorigin[1];
if(m_Dimension>=3)
origin[2]=vtkorigin[2];
SlicedGeometry3D* slicedGeometry = GetSlicedGeometry(0);
// re-initialize PlaneGeometry with origin and direction
PlaneGeometry* planeGeometry = static_cast<PlaneGeometry*>(slicedGeometry->GetPlaneGeometry(0));
planeGeometry->SetOrigin(origin);
// re-initialize SlicedGeometry3D
slicedGeometry->SetOrigin(origin);
slicedGeometry->SetSpacing(spacing);
ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
timeGeometry->Initialize(slicedGeometry, m_Dimensions[3]);
SetTimeGeometry(timeGeometry);
delete [] tmpDimensions;
}
void QRasterPlatformPixmap::createPixmapForImage(QImage &sourceImage, Qt::ImageConversionFlags flags, bool inPlace)
{
QImage::Format format;
if (flags & Qt::NoFormatConversion)
format = sourceImage.format();
else
if (pixelType() == BitmapType) {
format = QImage::Format_MonoLSB;
} else {
if (sourceImage.depth() == 1) {
format = sourceImage.hasAlphaChannel()
? QImage::Format_ARGB32_Premultiplied
: QImage::Format_RGB32;
} else {
QImage::Format opaqueFormat = QNativeImage::systemFormat();
QImage::Format alphaFormat = QImage::Format_ARGB32_Premultiplied;
#if !defined(__ARM_NEON__) && !defined(__SSE2__)
switch (opaqueFormat) {
case QImage::Format_RGB16:
alphaFormat = QImage::Format_ARGB8565_Premultiplied;
break;
default: // We don't care about the others...
break;
}
#endif
if (!sourceImage.hasAlphaChannel()) {
format = opaqueFormat;
} else if ((flags & Qt::NoOpaqueDetection) == 0
&& !const_cast<QImage &>(sourceImage).data_ptr()->checkForAlphaPixels())
{
format = opaqueFormat;
} else {
format = alphaFormat;
}
}
}
// image has alpha format but is really opaque, so try to do a
// more efficient conversion
if (format == QImage::Format_RGB32 && (sourceImage.format() == QImage::Format_ARGB32
|| sourceImage.format() == QImage::Format_ARGB32_Premultiplied))
{
image = sourceImage;
if (!inPlace)
image.detach();
if (image.d)
image.d->format = QImage::Format_RGB32;
} else if (inPlace && sourceImage.d->convertInPlace(format, flags)) {
image = sourceImage;
} else {
image = sourceImage.convertToFormat(format);
}
if (image.d) {
w = image.d->width;
h = image.d->height;
d = image.d->depth;
} else {
w = h = d = 0;
}
is_null = (w <= 0 || h <= 0);
image.d->devicePixelRatio = sourceImage.devicePixelRatio();
//ensure the pixmap and the image resulting from toImage() have the same cacheKey();
setSerialNumber(image.cacheKey() >> 32);
setDetachNumber(image.d->detach_no);
}
QPixmapData *QMeeGoPixmapData::createCompatiblePixmapData() const
{
return new QMeeGoRasterPixmapData(pixelType());
}
QPlatformPixmap *QPlatformPixmap::createCompatiblePlatformPixmap() const
{
QPlatformPixmap *d = QGuiApplicationPrivate::platformIntegration()->createPlatformPixmap(pixelType());
return d;
}
mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(Image *original,
const std::string &organName,
const mitk::Color &color)
{
// we NEED a reference image for size etc.
if (!original)
return nullptr;
// actually create a new empty segmentation
PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
LabelSetImage::Pointer segmentation = LabelSetImage::New();
if (original->GetDimension() == 2)
{
const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
segmentation->Initialize(pixelType, 3, dimensions);
segmentation->AddLayer();
}
else
{
segmentation->Initialize(original);
}
mitk::Label::Pointer label = mitk::Label::New();
label->SetName(organName);
label->SetColor(color);
label->SetValue(1);
segmentation->GetActiveLabelSet()->AddLabel(label);
segmentation->GetActiveLabelSet()->SetActiveLabel(1);
unsigned int byteSize = sizeof(mitk::Label::PixelType);
if (segmentation->GetDimension() < 4)
{
for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
memset(writeAccess.GetData(), 0, byteSize);
}
else
{
// if we have a time-resolved image we need to set memory to 0 for each time step
for (unsigned int dim = 0; dim < 3; ++dim)
{
byteSize *= segmentation->GetDimension(dim);
}
for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
{
mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
memset(writeAccess.GetData(), 0, byteSize);
}
}
if (original->GetTimeGeometry())
{
TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
segmentation->SetTimeGeometry(originalGeometry);
}
else
{
Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
return nullptr;
}
// Add some DICOM Tags as properties to segmentation image
PropertyList::Pointer dicomSegPropertyList = mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentationProperties(original->GetPropertyList());
segmentation->GetPropertyList()->ConcatenatePropertyList(dicomSegPropertyList);
mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentProperties(segmentation->GetActiveLabel(segmentation->GetActiveLayer()));
return CreateSegmentationNode(segmentation, organName, color);
}
/*!
\reimp
*/
void QTransformedScreen::blit(const QImage &image, const QPoint &topLeft,
const QRegion ®ion)
{
const Transformation trans = d_ptr->transformation;
if (trans == None) {
QProxyScreen::blit(image, topLeft, region);
return;
}
const QVector<QRect> rects = region.rects();
const QRect bound = QRect(0, 0, QScreen::w, QScreen::h)
& QRect(topLeft, image.size());
BlitFunc func = 0;
#ifdef QT_QWS_DEPTH_GENERIC
if (d_ptr->doGenericColors && depth() == 16) {
if (image.depth() == 16)
SET_BLIT_FUNC(qrgb_generic16, quint16, trans, func);
else
SET_BLIT_FUNC(qrgb_generic16, quint32, trans, func);
} else
#endif
switch (depth()) {
#ifdef QT_QWS_DEPTH_32
case 32:
#ifdef QT_QWS_DEPTH_16
if (image.depth() == 16)
SET_BLIT_FUNC(quint32, quint16, trans, func);
else
#endif
SET_BLIT_FUNC(quint32, quint32, trans, func);
break;
#endif
#if defined(QT_QWS_DEPTH_24) || defined(QT_QWS_DEPTH18)
case 24:
case 18:
SET_BLIT_FUNC(quint24, quint24, trans, func);
break;
#endif
#if defined(QT_QWS_DEPTH_16) || defined(QT_QWS_DEPTH_15) || defined(QT_QWS_DEPTH_12)
case 16:
#if defined QT_QWS_ROTATE_BGR
if (pixelType() == BGRPixel && image.depth() == 16) {
SET_BLIT_FUNC(qbgr565, quint16, trans, func);
break;
} //fall-through here!!!
#endif
case 15:
#if defined QT_QWS_ROTATE_BGR
if (pixelType() == BGRPixel && image.format() == QImage::Format_RGB555) {
SET_BLIT_FUNC(qbgr555, qrgb555, trans, func);
break;
} //fall-through here!!!
#endif
case 12:
if (image.depth() == 16)
SET_BLIT_FUNC(quint16, quint16, trans, func);
else
SET_BLIT_FUNC(quint16, quint32, trans, func);
break;
#endif
#ifdef QT_QWS_DEPTH_8
case 8:
if (image.format() == QImage::Format_RGB444)
SET_BLIT_FUNC(quint8, qrgb444, trans, func);
else if (image.depth() == 16)
SET_BLIT_FUNC(quint8, quint16, trans, func);
else
SET_BLIT_FUNC(quint8, quint32, trans, func);
break;
#endif
default:
return;
}
if (!func)
return;
QWSDisplay::grab();
for (int i = 0; i < rects.size(); ++i) {
const QRect r = rects.at(i) & bound;
QPoint dst;
switch (trans) {
case Rot90:
dst = mapToDevice(r.topRight(), QSize(w, h));
break;
case Rot180:
dst = mapToDevice(r.bottomRight(), QSize(w, h));
break;
case Rot270:
dst = mapToDevice(r.bottomLeft(), QSize(w, h));
break;
default:
break;
}
func(this, image, r.translated(-topLeft), dst);
}
QWSDisplay::ungrab();
}
QPlatformPixmap *QRasterPlatformPixmap::createCompatiblePlatformPixmap() const
{
return new QRasterPlatformPixmap(pixelType());
}