void QmitkTbssRoiAnalysisWidget::DoPlotFiberBundles(mitk::FiberBundle *fib, mitk::Image* img,
mitk::DataNode* startRoi, mitk::DataNode* endRoi, bool avg, int number)
{
TractContainerType tracts = CreateTracts(fib, startRoi, endRoi);
TractContainerType resampledTracts = ParameterizeTracts(tracts, number);
// Now we have the resampled tracts. Next we should use these points to read out the values
mitkPixelTypeMultiplex3(PlotFiberBundles,img->GetImageDescriptor()->GetChannelTypeById(0),resampledTracts, img, avg);
m_CurrentTracts = resampledTracts;
}
double mitk::Image::GetPixelValueByIndex(const mitk::Index3D &position, unsigned int timestep)
{
double value = 0;
if (this->GetTimeSteps() < timestep)
{
timestep = this->GetTimeSteps();
}
value = 0.0;
const unsigned int* imageDims = this->m_ImageDescriptor->GetDimensions();
const mitk::PixelType ptype = this->m_ImageDescriptor->GetChannelTypeById(0);
// Comparison ?>=0 not needed since all position[i] and timestep are unsigned int
// (position[0]>=0 && position[1] >=0 && position[2]>=0 && timestep>=0)
// bug-11978 : we still need to catch index with negative values
if ( position[0] < 0 ||
position[1] < 0 ||
position[2] < 0 )
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
// check if the given position is inside the index range of the image, the 3rd dimension needs to be compared only if the dimension is not 0
else if ( (unsigned int)position[0] >= imageDims[0] ||
(unsigned int)position[1] >= imageDims[1] ||
( imageDims[2] && (unsigned int)position[2] >= imageDims[2] ))
{
MITK_WARN << "Given position ("<< position << ") is out of image range, returning 0." ;
}
else
{
const unsigned int offset = position[0] + position[1]*imageDims[0] + position[2]*imageDims[0]*imageDims[1] + timestep*imageDims[0]*imageDims[1]*imageDims[2];
mitkPixelTypeMultiplex3( AccessPixel, ptype, this->GetData(), offset, value );
}
return value;
}
void QmitkAdaptiveRegionGrowingToolGUI::OnPointAdded()
{
if (m_RegionGrow3DTool.IsNull())
return;
mitk::DataNode* node = m_RegionGrow3DTool->GetPointSetNode();
if (node != NULL)
{
mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
if (pointSet.IsNull())
{
QMessageBox::critical(NULL, "QmitkAdaptiveRegionGrowingToolGUI", "PointSetNode does not contain a pointset");
return;
}
m_Controls.m_lblSetSeedpoint->setText("");
mitk::Image* image = dynamic_cast<mitk::Image*>(m_InputImageNode->GetData());
mitk::Point3D seedPoint = pointSet->GetPointSet(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1") )->GetTimeStep())->GetPoints()->ElementAt(0);
mitkPixelTypeMultiplex3(AccessPixel,image->GetChannelDescriptor().GetPixelType(),image,seedPoint,m_SeedpointValue);
/* In this case the seedpoint is placed e.g. in the lung or bronchialtree
* The lowerFactor sets the windowsize depending on the regiongrowing direction
*/
m_CurrentRGDirectionIsUpwards = true;
if (m_SeedpointValue < -500)
{
m_CurrentRGDirectionIsUpwards = false;
}
// Initializing the region by the area around the seedpoint
m_SeedPointValueMean = 0;
itk::Index<3> currentIndex, runningIndex;
mitk::ScalarType pixelValues[125];
unsigned int pos (0);
image->GetGeometry(0)->WorldToIndex(seedPoint, currentIndex);
runningIndex = currentIndex;
for(int i = runningIndex[0]-2; i <= runningIndex[0]+2; i++)
{
for(int j = runningIndex[1]-2; j <= runningIndex[1]+2; j++)
{
for(int k = runningIndex[2]-2; k <= runningIndex[2]+2; k++)
{
currentIndex[0] = i;
currentIndex[1] = j;
currentIndex[2] = k;
if(image->GetGeometry()->IsIndexInside(currentIndex))
{
pixelValues[pos] = image->GetPixelValueByIndex(currentIndex);
pos++;
}
else
{
pixelValues[pos] = -10000000;
pos++;
}
}
}
}
//Now calculation mean of the pixelValues
unsigned int numberOfValues(0);
for (unsigned int i = 0; i < 125; i++)
{
if(pixelValues[i] > -10000000)
{
m_SeedPointValueMean += pixelValues[i];
numberOfValues++;
}
}
m_SeedPointValueMean = m_SeedPointValueMean/numberOfValues;
/*
* Here the upper- and lower threshold is calculated:
* The windowSize is 20% of the maximum range of the intensity values existing in the current image
* If the RG direction is upwards the lower TH is meanSeedValue-0.15*windowSize and upper TH is meanSeedValue+0.85*windowsSize
* if the RG direction is downwards the lower TH is meanSeedValue-0.85*windowSize and upper TH is meanSeedValue+0.15*windowsSize
*/
mitk::ScalarType min = image->GetStatistics()->GetScalarValueMin();
mitk::ScalarType max = image->GetStatistics()->GetScalarValueMax();
mitk::ScalarType windowSize = max - min;
windowSize = 0.15*windowSize;
if (m_CurrentRGDirectionIsUpwards)
{
m_LOWERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue < m_SeedPointValueMean)
m_LOWERTHRESHOLD = m_SeedpointValue;
m_UPPERTHRESHOLD = m_SeedpointValue + windowSize;
if (m_UPPERTHRESHOLD > max)
m_UPPERTHRESHOLD = max;
m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
}
else
{
m_UPPERTHRESHOLD = m_SeedPointValueMean;
if (m_SeedpointValue > m_SeedPointValueMean)
m_UPPERTHRESHOLD = m_SeedpointValue;
m_LOWERTHRESHOLD = m_SeedpointValue - windowSize;
if (m_LOWERTHRESHOLD < min)
m_LOWERTHRESHOLD = min;
m_Controls.m_ThresholdSlider->setMinimumValue(m_LOWERTHRESHOLD);
m_Controls.m_ThresholdSlider->setMaximumValue(m_UPPERTHRESHOLD);
}
}
}
void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep)
{
this->ClearData();
m_ParametricPath->Initialize();
if (m_PlanarFigure.IsNull())
{
mitkThrow() << "PlanarFigure not set!";
}
if (m_Image.IsNull())
{
mitkThrow() << "Image not set!";
}
// Get 2D geometry frame of PlanarFigure
mitk::Geometry2D* planarFigureGeometry2D = dynamic_cast<mitk::Geometry2D*>(m_PlanarFigure->GetGeometry(0));
if (planarFigureGeometry2D == NULL)
{
mitkThrow() << "PlanarFigure has no valid geometry!";
}
// Get 3D geometry from Image (needed for conversion of point to index)
mitk::Geometry3D* imageGeometry = m_Image->GetGeometry(0);
if (imageGeometry == NULL)
{
mitkThrow() << "Image has no valid geometry!";
}
// Get first poly-line of PlanarFigure (other possible poly-lines in PlanarFigure
// are not supported)
const VertexContainerType vertexContainer = m_PlanarFigure->GetPolyLine(0);
VertexContainerType::const_iterator it;
for (it = vertexContainer.begin(); it != vertexContainer.end(); ++it)
{
// Map PlanarFigure 2D point to 3D point
mitk::Point3D point3D;
planarFigureGeometry2D->Map(it->Point, point3D);
// Convert world to index coordinates
mitk::Point3D indexPoint3D;
imageGeometry->WorldToIndex(point3D, indexPoint3D);
ParametricPathType::OutputType index;
index[0] = indexPoint3D[0];
index[1] = indexPoint3D[1];
index[2] = indexPoint3D[2];
// Add index to parametric path
m_ParametricPath->AddVertex(index);
}
m_DerivedPath = m_ParametricPath;
if (m_DerivedPath.IsNull())
{
mitkThrow() << "No path set!";
}
// Fill item model with line profile data
double distance = 0.0;
mitk::Point3D currentWorldPoint;
double t;
unsigned int i = 0;
for (i = 0, t = m_DerivedPath->StartOfInput(); ;++i)
{
const PathType::OutputType &continousIndex = m_DerivedPath->Evaluate(t);
mitk::Point3D worldPoint;
imageGeometry->IndexToWorld(continousIndex, worldPoint);
if (i == 0)
{
currentWorldPoint = worldPoint;
}
distance += currentWorldPoint.EuclideanDistanceTo(worldPoint);
mitk::Index3D indexPoint;
imageGeometry->WorldToIndex(worldPoint, indexPoint);
const mitk::PixelType ptype = m_Image->GetPixelType();
double intensity = 0.0;
if (m_Image->GetDimension() == 4)
{
mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
timeSelector->SetInput(m_Image);
timeSelector->SetTimeNr(timeStep);
timeSelector->Update();
mitk::Image::Pointer image = timeSelector->GetOutput();
mitkPixelTypeMultiplex3( ReadPixel, ptype, image, indexPoint, intensity);
}
else
{
mitkPixelTypeMultiplex3( ReadPixel, ptype, m_Image, indexPoint, intensity);
}
m_Measurement.insert(i, distance);
m_Frequency.insert(i, intensity);
// Go to next index; when iteration offset reaches zero, iteration is finished
PathType::OffsetType offset = m_DerivedPath->IncrementInput(t);
if (!(offset[0] || offset[1] || offset[2]))
{
break;
}
currentWorldPoint = worldPoint;
}
m_IntensityProfile = true;
m_UseLineGraph = true;
this->SignalDataChanged();
}