// static
KoShapeReorderCommand *KoShapeReorderCommand::createCommand(const QList<KoShape*> &shapes, KoShapeManager *manager, MoveShapeType move, KUndo2Command *parent)
{
QList<int> newIndexes;
QList<KoShape*> changedShapes;
QMap<KoShape*, QList<KoShape*> > newOrder;
QList<KoShape*> sortedShapes(shapes);
qSort(sortedShapes.begin(), sortedShapes.end(), KoShape::compareShapeZIndex);
if (move == BringToFront || move == LowerShape) {
for (int i = 0; i < sortedShapes.size(); ++i) {
prepare(sortedShapes.at(i), newOrder, manager, move);
}
}
else {
for (int i = sortedShapes.size() - 1; i >= 0; --i) {
prepare(sortedShapes.at(i), newOrder, manager, move);
}
}
QMap<KoShape*, QList<KoShape*> >::iterator newIt(newOrder.begin());
for (; newIt!= newOrder.end(); ++newIt) {
QList<KoShape*> order(newIt.value());
order.removeAll(0);
int index = -2^13;
int pos = 0;
for (; pos < order.size(); ++pos) {
if (order[pos]->zIndex() > index) {
index = order[pos]->zIndex();
}
else {
break;
}
}
if (pos == order.size()) {
//nothing needs to be done
continue;
}
else if (pos <= order.size() / 2) {
// new index for the front
int startIndex = order[pos]->zIndex() - pos;
for (int i = 0; i < pos; ++i) {
changedShapes.append(order[i]);
newIndexes.append(startIndex++);
}
}
else {
//new index for the end
for (int i = pos; i < order.size(); ++i) {
changedShapes.append(order[i]);
newIndexes.append(++index);
}
}
}
Q_ASSERT(changedShapes.count() == newIndexes.count());
return changedShapes.isEmpty() ? 0: new KoShapeReorderCommand(changedShapes, newIndexes, parent);
}
void mitk::DiffusionPropertyHelper::AverageRedundantGradients(double precision)
{
mitk::GradientDirectionsProperty* DirectionsProperty = static_cast<mitk::GradientDirectionsProperty*>( m_Image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
GradientDirectionsContainerType::Pointer oldDirs = DirectionsProperty->GetGradientDirectionsContainer();
GradientDirectionsContainerType::Pointer newDirs =
CalcAveragedDirectionSet(precision, oldDirs);
// if sizes equal, we do not need to do anything in this function
if(oldDirs->size() == newDirs->size())
return;
// new image
ImageType::Pointer oldImage = ImageType::New();
mitk::CastToItkImage( m_Image, oldImage);
ImageType::Pointer newITKImage = ImageType::New();
newITKImage->SetSpacing( oldImage->GetSpacing() ); // Set the image spacing
newITKImage->SetOrigin( oldImage->GetOrigin() ); // Set the image origin
newITKImage->SetDirection( oldImage->GetDirection() ); // Set the image direction
newITKImage->SetLargestPossibleRegion( oldImage->GetLargestPossibleRegion() );
newITKImage->SetVectorLength( newDirs->size() );
newITKImage->SetBufferedRegion( oldImage->GetLargestPossibleRegion() );
newITKImage->Allocate();
// average image data that corresponds to identical directions
itk::ImageRegionIterator< ImageType > newIt(newITKImage, newITKImage->GetLargestPossibleRegion());
newIt.GoToBegin();
itk::ImageRegionIterator< ImageType > oldIt(oldImage, oldImage->GetLargestPossibleRegion());
oldIt.GoToBegin();
// initial new value of voxel
ImageType::PixelType newVec;
newVec.SetSize(newDirs->size());
newVec.AllocateElements(newDirs->size());
// find which gradients should be averaged
GradientDirectionsContainerType::Pointer oldDirections = oldDirs;
std::vector<std::vector<int> > dirIndices;
for(GradientDirectionsContainerType::ConstIterator gdcitNew = newDirs->Begin();
gdcitNew != newDirs->End(); ++gdcitNew)
{
dirIndices.push_back(std::vector<int>(0));
for(GradientDirectionsContainerType::ConstIterator gdcitOld = oldDirs->Begin();
gdcitOld != oldDirections->End(); ++gdcitOld)
{
if(AreAlike(gdcitNew.Value(), gdcitOld.Value(), precision))
{
//MITK_INFO << gdcitNew.Value() << " " << gdcitOld.Value();
dirIndices[gdcitNew.Index()].push_back(gdcitOld.Index());
}
}
}
//int ind1 = -1;
while(!newIt.IsAtEnd())
{
// progress
//typename ImageType::IndexType ind = newIt.GetIndex();
//ind1 = ind.m_Index[2];
// init new vector with zeros
newVec.Fill(0.0);
// the old voxel value with duplicates
ImageType::PixelType oldVec = oldIt.Get();
for(unsigned int i=0; i<dirIndices.size(); i++)
{
// do the averaging
const unsigned int numavg = dirIndices[i].size();
unsigned int sum = 0;
for(unsigned int j=0; j<numavg; j++)
{
//MITK_INFO << newVec[i] << " << " << oldVec[dirIndices[i].at(j)];
sum += oldVec[dirIndices[i].at(j)];
}
if(numavg == 0)
{
MITK_ERROR << "VectorImage: Error on averaging. Possibly due to corrupted data";
return;
}
newVec[i] = sum / numavg;
}
newIt.Set(newVec);
++newIt;
++oldIt;
}
mitk::GrabItkImageMemory( newITKImage, m_Image );
m_Image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
m_Image->SetProperty( mitk::DiffusionPropertyHelper::ORIGINALGRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( newDirs ) );
ApplyMeasurementFrame();
UpdateBValueMap();
std::cout << std::endl;
}
