void QmitkColorPropertyView::DisplayColor()
{
const mitk::Color& tmp_col(m_ColorProperty->GetColor());
QColor color( ROUND_P(tmp_col[0] * 255.0), ROUND_P(tmp_col[1] * 255.0) , ROUND_P(tmp_col[2] * 255.0) );
//m_SelfCall = true;
//QWidget::setPaletteBackgroundColor( color );
//m_SelfCall = false;
m_WidgetPalette.setColor(QPalette::Background, color);
}
void mitk::ClippedSurfaceBoundsCalculator::CalculateIntersectionPoints( PointListType pointList )
{
PointListType::iterator pointIterator;
mitk::SlicedGeometry3D::Pointer imageGeometry = m_Image->GetSlicedGeometry();
for ( pointIterator = pointList.begin(); pointIterator != pointList.end(); pointIterator++ )
{
mitk::Point3D pntInIndexCoordinates;
imageGeometry->WorldToIndex( (*pointIterator), pntInIndexCoordinates );
m_MinMaxOutput[0].first = pntInIndexCoordinates[0] < m_MinMaxOutput[0].first ? ROUND_P(pntInIndexCoordinates[0]) : m_MinMaxOutput[0].first;
m_MinMaxOutput[0].second = pntInIndexCoordinates[0] > m_MinMaxOutput[0].second ? ROUND_P(pntInIndexCoordinates[0]) : m_MinMaxOutput[0].second;
m_MinMaxOutput[1].first = pntInIndexCoordinates[1] < m_MinMaxOutput[1].first ? ROUND_P(pntInIndexCoordinates[1]) : m_MinMaxOutput[1].first;
m_MinMaxOutput[1].second = pntInIndexCoordinates[1] > m_MinMaxOutput[1].second ? ROUND_P(pntInIndexCoordinates[1]) : m_MinMaxOutput[1].second;
m_MinMaxOutput[2].first = pntInIndexCoordinates[2] < m_MinMaxOutput[2].first ? ROUND_P(pntInIndexCoordinates[2]) : m_MinMaxOutput[2].first;
m_MinMaxOutput[2].second = pntInIndexCoordinates[2] > m_MinMaxOutput[2].second ? ROUND_P(pntInIndexCoordinates[2]) : m_MinMaxOutput[2].second;
}
this->EnforceImageBounds();
}
void mitk::ClippedSurfaceBoundsCalculator::CalculateIntersectionPoints(const mitk::PlaneGeometry* geometry)
{
// SEE HEADER DOCUMENTATION for explanation
const mitk::BaseGeometry::Pointer imageGeometry = m_Image->GetGeometry()->Clone();
// the cornerpoint(0) is the corner based Origin, which is original center based
Point3D origin = imageGeometry->GetCornerPoint(0); //Left, bottom, front
//Get axis vector for the spatial directions
const Vector3D xDirection = imageGeometry->GetAxisVector(0);
const Vector3D yDirection = imageGeometry->GetAxisVector(1);
const Vector3D zDirection = imageGeometry->GetAxisVector(2);
const Point3D leftBottomFront = origin;
const Point3D leftTopFront = origin + yDirection;
const Point3D leftBottomBack = origin + zDirection;
const Point3D leftTopBack = origin + yDirection + zDirection;
const Point3D rightBottomFront = origin + xDirection;
const Point3D rightTopFront = origin + xDirection + yDirection;
const Point3D rightBottomBack = origin + xDirection + zDirection;
const Point3D rightTopBack = origin + xDirection + yDirection + zDirection;
typedef std::vector< std::pair<mitk::Point3D, mitk::Point3D> > EdgesVector;
EdgesVector edgesOf3DBox;
edgesOf3DBox.reserve(12);
edgesOf3DBox.push_back(std::make_pair(leftBottomFront, // x = left=xfront, y=bottom=yfront, z=front=zfront
leftTopFront)); // left, top, front
edgesOf3DBox.push_back(std::make_pair(leftBottomFront, // left, bottom, front
leftBottomBack)); // left, bottom, back
edgesOf3DBox.push_back(std::make_pair(leftBottomFront, // left, bottom, front
rightBottomFront)); // right, bottom, front
edgesOf3DBox.push_back(std::make_pair(leftTopFront, // left, top, front
rightTopFront)); // right, top, front
edgesOf3DBox.push_back(std::make_pair(leftTopFront, // left, top, front
leftTopBack)); // left, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopFront, // right, top, front
rightTopBack)); // right, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopFront, // right, top, front
rightBottomFront)); // right, bottom, front
edgesOf3DBox.push_back(std::make_pair(rightBottomFront, // right, bottom, front
rightBottomBack)); // right, bottom, back
edgesOf3DBox.push_back(std::make_pair(rightBottomBack, // right, bottom, back
leftBottomBack)); // left, bottom, back
edgesOf3DBox.push_back(std::make_pair(rightBottomBack, // right, bottom, back
rightTopBack)); // right, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopBack, // right, top, back
leftTopBack)); // left, top, back
edgesOf3DBox.push_back(std::make_pair(leftTopBack, // left, top, back
leftBottomBack)); // left, bottom, back
for ( auto iterator = edgesOf3DBox.cbegin(); iterator != edgesOf3DBox.cend(); ++iterator )
{
const Point3D startPoint = (*iterator).first; // start point of the line
const Point3D endPoint = (*iterator).second; // end point of the line
const Vector3D lineDirection = endPoint - startPoint;
const mitk::Line3D line(startPoint, lineDirection);
// Get intersection point of line and plane geometry
Point3D intersectionWorldPoint(std::numeric_limits<int>::min());
double t = -1.0;
bool doesLineIntersectWithPlane(false);
const double norm = line.GetDirection().GetNorm();
const double dist = geometry->Distance(line.GetPoint1());
if( norm < mitk::eps && dist < mitk::sqrteps)
{
t = 1.0;
doesLineIntersectWithPlane = true;
intersectionWorldPoint = line.GetPoint1();
}
else
{
geometry->IntersectionPoint(line, intersectionWorldPoint);
doesLineIntersectWithPlane = geometry->IntersectionPointParam(line, t);
}
//Get index point
mitk::Point3D intersectionIndexPoint;
imageGeometry->WorldToIndex(intersectionWorldPoint, intersectionIndexPoint);
const bool lowerBoundGood = (0-mitk::sqrteps) <= t;
const bool upperBoundGood = t <= 1.0 + mitk::sqrteps;
if ( doesLineIntersectWithPlane && lowerBoundGood && upperBoundGood )
{
for( int dim = 0; dim < 3; ++dim )
{
m_MinMaxOutput[dim].first = std::min( m_MinMaxOutput[dim].first, ROUND_P(intersectionIndexPoint[dim]) );
m_MinMaxOutput[dim].second = std::max( m_MinMaxOutput[dim].second, ROUND_P(intersectionIndexPoint[dim]) );
}
this->EnforceImageBounds();
}
}
}
void mitk::ClippedSurfaceBoundsCalculator::CalculateIntersectionPoints(const mitk::PlaneGeometry* geometry)
{
// SEE HEADER DOCUMENTATION for explanation
typedef std::vector< std::pair<mitk::Point3D, mitk::Point3D> > EdgesVector;
Point3D origin;
Vector3D xDirection, yDirection, zDirection;
const Vector3D spacing = m_Image->GetGeometry()->GetSpacing();
origin = m_Image->GetGeometry()->GetOrigin(); //Left, bottom, front
//Get axis vector for the spatial directions
xDirection = m_Image->GetGeometry()->GetAxisVector(1);
yDirection = m_Image->GetGeometry()->GetAxisVector(0);
zDirection = m_Image->GetGeometry()->GetAxisVector(2);
/*
* For the calculation of the intersection points we need as corner points the center-based image coordinates.
* With the method GetCornerPoint() of the class Geometry3D we only get the corner-based coordinates.
* Therefore we need to calculate the center-based corner points here. For that we add/substract the corner-
* based coordinates with the spacing of the geometry3D.
*/
for( int i = 0; i < 3; i++ )
{
if(xDirection[i] < 0)
{
xDirection[i] += spacing[i];
}
else if( xDirection[i] > 0 )
{
xDirection[i] -= spacing[i];
}
if(yDirection[i] < 0)
{
yDirection[i] += spacing[i];
}
else if( yDirection[i] > 0 )
{
yDirection[i] -= spacing[i];
}
if(zDirection[i] < 0)
{
zDirection[i] += spacing[i];
}
else if( zDirection[i] > 0 )
{
zDirection[i] -= spacing[i];
}
}
Point3D leftBottomFront, leftTopFront, leftBottomBack, leftTopBack;
Point3D rightBottomFront, rightTopFront, rightBottomBack, rightTopBack;
leftBottomFront = origin;
leftTopFront = origin + yDirection;
leftBottomBack = origin + zDirection;
leftTopBack = origin + yDirection + zDirection;
rightBottomFront = origin + xDirection;
rightTopFront = origin + xDirection + yDirection;
rightBottomBack = origin + xDirection + zDirection;
rightTopBack = origin + xDirection + yDirection + zDirection;
EdgesVector edgesOf3DBox;
edgesOf3DBox.push_back(std::make_pair(leftBottomBack, // x = left=xfront, y=bottom=yfront, z=front=zfront
leftTopFront)); // left, top, front
edgesOf3DBox.push_back(std::make_pair(leftBottomFront, // left, bottom, front
leftBottomBack)); // left, bottom, back
edgesOf3DBox.push_back(std::make_pair(leftBottomFront, // left, bottom, front
rightBottomFront)); // right, bottom, front
edgesOf3DBox.push_back(std::make_pair(leftTopFront, // left, top, front
rightTopFront)); // right, top, front
edgesOf3DBox.push_back(std::make_pair(leftTopFront, // left, top, front
leftTopBack)); // left, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopFront, // right, top, front
rightTopBack)); // right, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopFront, // right, top, front
rightBottomFront)); // right, bottom, front
edgesOf3DBox.push_back(std::make_pair(rightBottomFront, // right, bottom, front
rightBottomBack)); // right, bottom, back
edgesOf3DBox.push_back(std::make_pair(rightBottomBack, // right, bottom, back
leftBottomBack)); // left, bottom, back
edgesOf3DBox.push_back(std::make_pair(rightBottomBack, // right, bottom, back
rightTopBack)); // right, top, back
edgesOf3DBox.push_back(std::make_pair(rightTopBack, // right, top, back
leftTopBack)); // left, top, back
edgesOf3DBox.push_back(std::make_pair(leftTopBack, // left, top, back
leftBottomBack)); // left, bottom, back
for (EdgesVector::iterator iterator = edgesOf3DBox.begin(); iterator != edgesOf3DBox.end();iterator++)
{
Point3D startPoint = (*iterator).first; // start point of the line
Point3D endPoint = (*iterator).second; // end point of the line
Vector3D lineDirection = endPoint - startPoint;
mitk::Line3D line(startPoint, lineDirection);
Point3D intersectionWorldPoint;
intersectionWorldPoint.Fill(std::numeric_limits<int>::min());
// Get intersection point of line and plane geometry
geometry->IntersectionPoint(line, intersectionWorldPoint);
double t = -1.0;
bool doesLineIntersectWithPlane(false);
if(line.GetDirection().GetNorm() < mitk::eps && geometry->Distance(line.GetPoint1()) < mitk::sqrteps)
{
t = 1.0;
doesLineIntersectWithPlane = true;
intersectionWorldPoint = line.GetPoint1();
}
else
{
geometry->IntersectionPoint(line, intersectionWorldPoint);
doesLineIntersectWithPlane = geometry->IntersectionPointParam(line, t);
}
mitk::Point3D intersectionIndexPoint;
//Get index point
m_Image->GetGeometry()->WorldToIndex(intersectionWorldPoint, intersectionIndexPoint);
if ( doesLineIntersectWithPlane && -mitk::sqrteps <= t && t <= 1.0 + mitk::sqrteps )
{
for(int dim = 0; dim < 3; dim++)
{
// minimum
//If new point value is lower than old
if( this->m_MinMaxOutput[dim].first > ROUND_P(intersectionIndexPoint[dim]) )
{
this->m_MinMaxOutput[dim].first = ROUND_P(intersectionIndexPoint[dim]); //set new value
}
// maximum
//If new point value is higher than old
if( this->m_MinMaxOutput[dim].second < ROUND_P(intersectionIndexPoint[dim]) )
{
this->m_MinMaxOutput[dim].second = ROUND_P(intersectionIndexPoint[dim]); //set new value
}
}
this->EnforceImageBounds();
}
}
}
