void mitk::ContourUtils::ItkCopyFilledContourToSlice( itk::Image<TPixel,VImageDimension>* originalSlice, const Image* filledContourSlice, int overwritevalue )
{
typedef itk::Image<TPixel,VImageDimension> SliceType;
typename SliceType::Pointer filledContourSliceITK;
CastToItkImage( filledContourSlice, filledContourSliceITK );
// now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels that are non-zero
typedef itk::ImageRegionIterator< SliceType > OutputIteratorType;
typedef itk::ImageRegionConstIterator< SliceType > InputIteratorType;
InputIteratorType inputIterator( filledContourSliceITK, filledContourSliceITK->GetLargestPossibleRegion() );
OutputIteratorType outputIterator( originalSlice, originalSlice->GetLargestPossibleRegion() );
outputIterator.GoToBegin();
inputIterator.GoToBegin();
while ( !outputIterator.IsAtEnd() )
{
if ( inputIterator.Get() != 0 )
{
outputIterator.Set( overwritevalue );
}
++outputIterator;
++inputIterator;
}
}
void mitk::OverwriteSliceImageFilter::ItkImageProcessing(const itk::Image<TPixel1, VImageDimension1> *inputImage,
itk::Image<TPixel2, VImageDimension2> *outputImage)
{
typedef itk::Image<TPixel1, VImageDimension1> SliceImageType;
typedef itk::Image<short signed int, VImageDimension1> DiffImageType;
typedef itk::Image<TPixel2, VImageDimension2> VolumeImageType;
typedef itk::ImageSliceIteratorWithIndex<VolumeImageType> OutputSliceIteratorType;
typedef itk::ImageRegionConstIterator<SliceImageType> InputSliceIteratorType;
typedef itk::ImageRegionIterator<DiffImageType> DiffSliceIteratorType;
typename VolumeImageType::RegionType sliceInVolumeRegion;
sliceInVolumeRegion = outputImage->GetLargestPossibleRegion();
sliceInVolumeRegion.SetSize(m_SliceDimension, 1); // just one slice
sliceInVolumeRegion.SetIndex(m_SliceDimension, m_SliceIndex); // exactly this slice, please
OutputSliceIteratorType outputIterator(outputImage, sliceInVolumeRegion);
outputIterator.SetFirstDirection(m_Dimension0);
outputIterator.SetSecondDirection(m_Dimension1);
InputSliceIteratorType inputIterator(inputImage, inputImage->GetLargestPossibleRegion());
typename DiffImageType::Pointer diffImage;
CastToItkImage(m_SliceDifferenceImage, diffImage);
DiffSliceIteratorType diffIterator(diffImage, diffImage->GetLargestPossibleRegion());
// iterate over output slice (and over input slice simultaneously)
outputIterator.GoToBegin();
inputIterator.GoToBegin();
diffIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
while (!outputIterator.IsAtEndOfSlice())
{
while (!outputIterator.IsAtEndOfLine())
{
diffIterator.Set(static_cast<short signed int>(inputIterator.Get() -
outputIterator.Get())); // oh oh, not good for bigger values
outputIterator.Set((TPixel2)inputIterator.Get());
++outputIterator;
++inputIterator;
++diffIterator;
}
outputIterator.NextLine();
}
outputIterator.NextSlice();
}
}
void DeepCopyScalarImage(const TImage* const input, TImage* const output)
{
output->SetRegions(input->GetLargestPossibleRegion());
output->Allocate();
itk::ImageRegionConstIterator<TImage> inputIterator(input, input->GetLargestPossibleRegion());
itk::ImageRegionIterator<TImage> outputIterator(output, output->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
outputIterator.Set(inputIterator.Get());
++inputIterator;
++outputIterator;
}
}
void Mask::CopyHolesFrom(const Mask* const inputMask)
{
itk::ImageRegionConstIterator<Mask> inputIterator(inputMask, inputMask->GetLargestPossibleRegion());
itk::ImageRegionIterator<Mask> thisIterator(this, this->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
if(inputMask->IsHole(inputIterator.GetIndex()))
{
thisIterator.Set(HoleMaskPixelTypeEnum::HOLE);
}
++inputIterator;
++thisIterator;
}
}
void Mask::DeepCopyFrom(const Mask* inputMask)
{
this->SetRegions(inputMask->GetLargestPossibleRegion());
this->Allocate();
itk::ImageRegionConstIterator<Mask> inputIterator(inputMask, inputMask->GetLargestPossibleRegion());
itk::ImageRegionIterator<Mask> thisIterator(this, this->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
thisIterator.Set(inputIterator.Get());
++inputIterator;
++thisIterator;
}
this->SetHoleValue(inputMask->GetHoleValue());
this->SetValidValue(inputMask->GetValidValue());
}
void Mask::CreateValidPixelsFromValue(const TImage* const inputImage,
const typename TImage::PixelType value)
{
assert(inputImage->GetLargestPossibleRegion() == this->GetLargestPossibleRegion());
itk::ImageRegionConstIterator<TImage> inputIterator(inputImage, inputImage->GetLargestPossibleRegion());
itk::ImageRegionIterator<Mask> thisIterator(this, this->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
if(inputIterator.Get() == value)
{
thisIterator.Set(HoleMaskPixelTypeEnum::VALID);
}
++inputIterator;
++thisIterator;
}
}
void VectorImageToRGBImage(const FloatVectorImageType* const image, RGBImageType* const rgbImage)
{
// Only the first 3 components are used (assumed to be RGB)
rgbImage->SetRegions(image->GetLargestPossibleRegion());
rgbImage->Allocate();
itk::ImageRegionConstIteratorWithIndex<FloatVectorImageType> inputIterator(image, image->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
FloatVectorImageType::PixelType inputPixel = inputIterator.Get();
RGBImageType::PixelType outputPixel;
outputPixel.SetRed(inputPixel[0]);
outputPixel.SetGreen(inputPixel[1]);
outputPixel.SetBlue(inputPixel[2]);
rgbImage->SetPixel(inputIterator.GetIndex(), outputPixel);
++inputIterator;
}
}
void mitk::PixelManipulationTool::ITKPixelManipulation( itk::Image<TPixel, VImageDimension>* originalImage, Image* maskImage, Image* newImage, int newValue)
{
typedef itk::Image< TPixel, VImageDimension> itkImageType;
typedef itk::Image< unsigned char, 3> itkMaskType;
typename itkImageType::Pointer itkImage;
typename itkMaskType::Pointer itkMask;
CastToItkImage( newImage, itkImage);
CastToItkImage( maskImage, itkMask);
typedef itk::ImageRegionConstIterator< itkImageType > InputIteratorType;
typedef itk::ImageRegionIterator< itkImageType > OutputIteratorType;
typedef itk::ImageRegionConstIterator< itkMaskType > MaskIteratorType;
MaskIteratorType maskIterator ( itkMask, itkMask->GetLargestPossibleRegion() );
InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
OutputIteratorType outputIterator( itkImage, itkImage->GetLargestPossibleRegion() );
inputIterator.GoToBegin();
outputIterator.GoToBegin();
maskIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
if (maskIterator.Get())
{
if (m_FixedValue)
outputIterator.Set(newValue);
else
outputIterator.Set( inputIterator.Get()+ newValue);
}
else
outputIterator.Set( inputIterator.Get());
++inputIterator;
++outputIterator;
++maskIterator;
}
}
Data::Data() {
namChart = new QNetworkAccessManager(this);
QObject::connect(namChart, SIGNAL(finished(QNetworkReply*)),
this, SLOT(finishedSlotChart(QNetworkReply*)));
QFile filer("goldapp.txt");
filer.deleteLater();
filer.open(QIODevice::ReadOnly | QIODevice::Text);
QTextStream stream(&filer);
QString line = stream.readLine();
filer.close(); // optional, as QFile destructor will already do it
if(!line.trimmed().isEmpty()) {
QStringListIterator inputIterator(line.split("/"));
cstyle = Constants::getStyleIndexByKey(inputIterator.next());
cmetal = Constants::getMetalIndexByKey(inputIterator.next());
ccurrency = Constants::getCurrencyIndexByKey(inputIterator.next());
cdateRange = Constants::getDateRangeIndexByKey(inputIterator.next());
urlChart->setUrl("http://www.galmarley.com/prices/"+line);
} else {
urlChart->setUrl("http://www.galmarley.com/prices/CHART_BAR_HLC/AUX/USD/172800/Full");
}
}
void mitk::BinaryThresholdULTool::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, Image* segmentation, unsigned int timeStep )
{
ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
timeSelector->SetInput( segmentation );
timeSelector->SetTimeNr( timeStep );
timeSelector->UpdateLargestPossibleRegion();
Image::Pointer segmentation3D = timeSelector->GetOutput();
typedef itk::Image< Tool::DefaultSegmentationDataType, 3> SegmentationType; // this is sure for new segmentations
SegmentationType::Pointer itkSegmentation;
CastToItkImage( segmentation3D, itkSegmentation );
// iterate over original and segmentation
typedef itk::ImageRegionConstIterator< itk::Image<TPixel, VImageDimension> > InputIteratorType;
typedef itk::ImageRegionIterator< SegmentationType > SegmentationIteratorType;
InputIteratorType inputIterator( originalImage, originalImage->GetLargestPossibleRegion() );
SegmentationIteratorType outputIterator( itkSegmentation, itkSegmentation->GetLargestPossibleRegion() );
inputIterator.GoToBegin();
outputIterator.GoToBegin();
while (!outputIterator.IsAtEnd())
{
if ( (signed)inputIterator.Get() >= m_CurrentLowerThresholdValue && (signed)inputIterator.Get() <= m_CurrentUpperThresholdValue )
{
outputIterator.Set( 1 );
}
else
{
outputIterator.Set( 0 );
}
++inputIterator;
++outputIterator;
}
}
bool AppITKImage::LoadAndValidate(const std::string& imagePath)
{
typedef itk::ImageFileReader<AppImageITKType> ReaderType;
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName(imagePath);
reader->Update();
if(!m_image)
{
m_image = AppImageITKType::New();
}
// Deep copy
m_image->SetRegions(reader->GetOutput()->GetLargestPossibleRegion());
m_image->SetNumberOfComponentsPerPixel(LfnIc::Image::Pixel::NUM_CHANNELS);
m_image->Allocate();
itk::ImageRegionConstIterator<AppImageITKType> inputIterator(reader->GetOutput(), reader->GetOutput()->GetLargestPossibleRegion());
itk::ImageRegionIterator<AppImageITKType> outputIterator(m_image, m_image->GetLargestPossibleRegion());
while(!inputIterator.IsAtEnd())
{
outputIterator.Set(inputIterator.Get());
++inputIterator;
++outputIterator;
}
#if USE_CHANNEL_WEIGHTING
// Setup channel weights - Uniform weighting - set the weight of each channel so it has the perceived range of 255
// If a channel already has the range 255, the weight is set to 1. If a channel has a range smaller
// than 255, its weight will be > 1. If a channel has a weight larger than 255, its weight will be set to < 1.
// A weight should never be negative. There is no magic to scaling to 255, it is just that usually there will be some
// RGB type channels so 255 should make several of the weights close to 1.
std::cout << "Weights: ";
for (int c = 0; c < LfnIc::Image::Pixel::NUM_CHANNELS; c++)
{
typedef itk::Image<LfnIc::Image::Pixel::ChannelType, 2> ScalarImageType;
typedef itk::VectorIndexSelectionCastImageFilter<AppImageITKType, ScalarImageType> IndexSelectionType;
IndexSelectionType::Pointer indexSelectionFilter = IndexSelectionType::New();
indexSelectionFilter->SetIndex(c);
indexSelectionFilter->SetInput(m_image);
indexSelectionFilter->Update();
typedef itk::MinimumMaximumImageCalculator <ScalarImageType> ImageCalculatorFilterType;
ImageCalculatorFilterType::Pointer imageCalculatorFilter = ImageCalculatorFilterType::New();
imageCalculatorFilter->SetImage(indexSelectionFilter->GetOutput());
imageCalculatorFilter->Compute();
// If there is no variation in a channel (take an image with only red (255,0,0) and blue (0,0,255) pixels for example),
// then computing the weight doesn't make sense (and causes a divide by zero).
if( (imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum()) <= 0)
{
m_channelWeights[c] = 1.0f;
}
else
{
m_channelWeights[c] = 255.0f / (imageCalculatorFilter->GetMaximum() - imageCalculatorFilter->GetMinimum());
}
std::cout << m_channelWeights[c] << " ";
}
std::cout << std::endl;
// Now that the weights have been calculated, apply them directly to the image data.
LfnIc::Image::Pixel* pixelPtr = AppITKImage::GetData();
for (int i = 0, n = GetWidth() * GetHeight(); i < n; ++i, ++pixelPtr)
{
LfnIc::Image::Pixel& pixel = *pixelPtr;
for (int c = 0; c < LfnIc::Image::Pixel::NUM_CHANNELS; ++c)
{
pixel.channel[c] *= m_channelWeights[c];
}
}
#endif // USE_CHANNEL_WEIGHTING
return true;
}
bool DeleteExecutor::p_execute(const NValueArray ¶ms, ReadWriteTracker *tracker) {
assert(m_targetTable);
if (m_truncate) {
VOLT_TRACE("truncating table %s...", m_targetTable->name().c_str());
// count the truncated tuples as deleted
m_engine->m_tuplesModified += m_inputTable->activeTupleCount();
#ifdef ARIES
if(m_engine->isARIESEnabled()){
// no need of persistency check, m_targetTable is
// always persistent for deletes
LogRecord *logrecord = new LogRecord(computeTimeStamp(),
LogRecord::T_TRUNCATE,// this is a truncate record
LogRecord::T_FORWARD,// the system is running normally
-1,// XXX: prevLSN must be fetched from table!
m_engine->getExecutorContext()->currentTxnId() ,// txn id
m_engine->getSiteId(),// which execution site
m_targetTable->name(),// the table affected
NULL,// primary key irrelevant
-1,// irrelevant numCols
NULL,// list of modified cols irrelevant
NULL,// before image irrelevant
NULL// after image irrelevant
);
size_t logrecordLength = logrecord->getEstimatedLength();
char *logrecordBuffer = new char[logrecordLength];
FallbackSerializeOutput output;
output.initializeWithPosition(logrecordBuffer, logrecordLength, 0);
logrecord->serializeTo(output);
LogManager* m_logManager = this->m_engine->getLogManager();
Logger m_ariesLogger = m_logManager->getAriesLogger();
//VOLT_WARN("m_logManager : %p AriesLogger : %p",&m_logManager, &m_ariesLogger);
const Logger *logger = m_logManager->getThreadLogger(LOGGERID_MM_ARIES);
logger->log(LOGLEVEL_INFO, output.data(), output.position());
delete[] logrecordBuffer;
logrecordBuffer = NULL;
delete logrecord;
logrecord = NULL;
}
#endif
//m_engine->context().incrementTuples(m_targetTable->activeTupleCount());
// actually delete all the tuples
m_targetTable->deleteAllTuples(true);
return true;
}
// XXX : ARIES : Not sure if else is needed ?
assert(m_inputTable);
assert(m_inputTuple.sizeInValues() == m_inputTable->columnCount());
assert(m_targetTuple.sizeInValues() == m_targetTable->columnCount());
TableIterator inputIterator(m_inputTable);
while (inputIterator.next(m_inputTuple)) {
//
// OPTIMIZATION: Single-Sited Query Plans
// If our beloved DeletePlanNode is apart of a single-site query plan,
// then the first column in the input table will be the address of a
// tuple on the target table that we will want to blow away. This saves
// us the trouble of having to do an index lookup
//
void *targetAddress = m_inputTuple.getNValue(0).castAsAddress();
m_targetTuple.move(targetAddress);
// Read/Write Set Tracking
if (tracker != NULL) {
tracker->markTupleWritten(m_targetTable, &m_targetTuple);
}
#ifdef ARIES
if(m_engine->isARIESEnabled()){
// no need of persistency check, m_targetTable is
// always persistent for deletes
// before image -- target is tuple to be deleted.
TableTuple *beforeImage = &m_targetTuple;
TableTuple *keyTuple = NULL;
char *keydata = NULL;
// See if we use an index instead
TableIndex *index = m_targetTable->primaryKeyIndex();
if (index != NULL) {
// First construct tuple for primary key
keydata = new char[index->getKeySchema()->tupleLength()];
keyTuple = new TableTuple(keydata, index->getKeySchema());
for (int i = 0; i < index->getKeySchema()->columnCount(); i++) {
keyTuple->setNValue(i, beforeImage->getNValue(index->getColumnIndices()[i]));
}
// no before image need be recorded, just the primary key
beforeImage = NULL;
}
LogRecord *logrecord = new LogRecord(computeTimeStamp(),
LogRecord::T_DELETE,// this is a delete record
LogRecord::T_FORWARD,// the system is running normally
-1,// XXX: prevLSN must be fetched from table!
m_engine->getExecutorContext()->currentTxnId() ,// txn id
m_engine->getSiteId(),// which execution site
m_targetTable->name(),// the table affected
keyTuple,// primary key
-1,// must delete all columns
NULL,// no list of modified cols
beforeImage,
NULL// no after image
);
size_t logrecordLength = logrecord->getEstimatedLength();
char *logrecordBuffer = new char[logrecordLength];
FallbackSerializeOutput output;
output.initializeWithPosition(logrecordBuffer, logrecordLength, 0);
logrecord->serializeTo(output);
LogManager* m_logManager = this->m_engine->getLogManager();
Logger m_ariesLogger = m_logManager->getAriesLogger();
//VOLT_WARN("m_logManager : %p AriesLogger : %p",&m_logManager, &m_ariesLogger);
const Logger *logger = m_logManager->getThreadLogger(LOGGERID_MM_ARIES);
logger->log(LOGLEVEL_INFO, output.data(), output.position());
delete[] logrecordBuffer;
logrecordBuffer = NULL;
delete logrecord;
logrecord = NULL;
if (keydata != NULL) {
delete[] keydata;
keydata = NULL;
}
if (keyTuple != NULL) {
delete keyTuple;
keyTuple = NULL;
}
}
#endif
// Delete from target table
if (!m_targetTable->deleteTuple(m_targetTuple, true)) {
VOLT_ERROR("Failed to delete tuple from table '%s'",
m_targetTable->name().c_str());
return false;
}
}
// add to the planfragments count of modified tuples
m_engine->m_tuplesModified += m_inputTable->activeTupleCount();
//m_engine->context().incrementTuples(m_inputTable->activeTupleCount());
return true;
}
void InternalWritePreviewOnWorkingImage(itk::Image<TPixel, VImageDimension> *targetSlice,
const mitk::Image *sourceSlice,
mitk::Image *originalImage,
int overwritevalue)
{
typedef itk::Image<TPixel, VImageDimension> SliceType;
typename SliceType::Pointer sourceSliceITK;
CastToItkImage(sourceSlice, sourceSliceITK);
// now the original slice and the ipSegmentation-painted slice are in the same format, and we can just copy all pixels
// that are non-zero
typedef itk::ImageRegionIterator<SliceType> OutputIteratorType;
typedef itk::ImageRegionConstIterator<SliceType> InputIteratorType;
InputIteratorType inputIterator(sourceSliceITK, sourceSliceITK->GetLargestPossibleRegion());
OutputIteratorType outputIterator(targetSlice, targetSlice->GetLargestPossibleRegion());
outputIterator.GoToBegin();
inputIterator.GoToBegin();
mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(originalImage);
assert(workingImage);
int activePixelValue = workingImage->GetActiveLabel()->GetValue();
if (activePixelValue == 0) // if exterior is the active label
{
while (!outputIterator.IsAtEnd())
{
if (inputIterator.Get() != 0)
{
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
else if (overwritevalue != 0) // if we are not erasing
{
while (!outputIterator.IsAtEnd())
{
int targetValue = static_cast<int>(outputIterator.Get());
if (inputIterator.Get() != 0)
{
if (!workingImage->GetLabel(targetValue)->GetLocked())
{
outputIterator.Set(overwritevalue);
}
}
if (targetValue == overwritevalue)
{
outputIterator.Set(inputIterator.Get());
}
++outputIterator;
++inputIterator;
}
}
else // if we are erasing
{
while (!outputIterator.IsAtEnd())
{
const int targetValue = outputIterator.Get();
if (inputIterator.Get() != 0)
{
if (targetValue == activePixelValue)
outputIterator.Set(overwritevalue);
}
++outputIterator;
++inputIterator;
}
}
}
