void mitk::ExtrudePlanarFigureFilter::GenerateData()
{
typedef PlanarFigure::PolyLineType PolyLine;
typedef PolyLine::const_iterator PolyLineConstIter;
if (m_Length <= 0)
mitkThrow() << "Length is not positive!";
if (m_NumberOfSegments == 0)
mitkThrow() << "Number of segments is zero!";
if (m_BendAngle != 0 && m_BendDirection[0] == 0 && m_BendDirection[1] == 0)
mitkThrow() << "Bend direction is zero-length vector!";
PlanarFigure* input = dynamic_cast<PlanarFigure*>(this->GetPrimaryInput());
if (input == NULL)
mitkThrow() << "Primary input is not a planar figure!";
size_t numPolyLines = input->GetPolyLinesSize();
if (numPolyLines == 0)
mitkThrow() << "Primary input does not contain any poly lines!";
const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(input->GetPlaneGeometry());
if (planeGeometry == NULL)
mitkThrow() << "Could not get plane geometry from primary input!";
Vector3D planeNormal = planeGeometry->GetNormal();
planeNormal.Normalize();
Point2D centerPoint2d = GetCenterPoint(input);
Point3D centerPoint3d;
planeGeometry->Map(centerPoint2d, centerPoint3d);
Vector3D bendDirection3d = m_BendAngle != 0
? ::GetBendDirection(planeGeometry, centerPoint2d, m_BendDirection)
: Vector3D();
ScalarType radius = m_Length * (360 / m_BendAngle) / (2 * vnl_math::pi);
Vector3D scaledBendDirection3d = bendDirection3d * radius;
Vector3D bendAxis = itk::CrossProduct(planeNormal, bendDirection3d);
bendAxis.Normalize();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkIdType baseIndex = 0;
for (size_t i = 0; i < numPolyLines; ++i)
{
PolyLine polyLine = input->GetPolyLine(i);
size_t numPoints = polyLine.size();
if (numPoints < 2)
mitkThrow() << "Poly line " << i << " of primary input consists of less than two points!";
std::vector<mitk::Point3D> crossSection;
PolyLineConstIter polyLineEnd = polyLine.end();
for (PolyLineConstIter polyLineIter = polyLine.begin(); polyLineIter != polyLineEnd; ++polyLineIter)
{
Point3D point;
planeGeometry->Map(*polyLineIter, point);
crossSection.push_back(point);
}
ScalarType segmentLength = m_Length / m_NumberOfSegments;
Vector3D translation = planeNormal * segmentLength;
bool bend = std::abs(m_BendAngle) > mitk::eps;
bool twist = std::abs(m_TwistAngle) > mitk::eps;
ScalarType twistAngle = twist
? m_TwistAngle / m_NumberOfSegments * vnl_math::pi / 180
: 0;
ScalarType bendAngle = bend
? m_BendAngle / m_NumberOfSegments * vnl_math::pi / 180
: 0;
if (m_FlipDirection)
{
translation *= -1;
bendAngle *= -1;
}
for (size_t k = 0; k < numPoints; ++k)
points->InsertNextPoint(crossSection[k].GetDataPointer());
for (size_t j = 1; j <= m_NumberOfSegments; ++j)
{
mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
if (bend || twist)
transform->Translate(centerPoint3d.GetVectorFromOrigin(), true);
if (bend)
{
transform->Translate(scaledBendDirection3d, true);
transform->Rotate3D(bendAxis, bendAngle * j, true);
transform->Translate(-scaledBendDirection3d, true);
}
else
{
transform->Translate(translation * j, true);
}
if (twist)
transform->Rotate3D(planeNormal, twistAngle * j, true);
if (bend || twist)
transform->Translate(-centerPoint3d.GetVectorFromOrigin(), true);
for (size_t k = 0; k < numPoints; ++k)
{
mitk::Point3D transformedPoint = transform->TransformPoint(crossSection[k]);
points->InsertNextPoint(transformedPoint.GetDataPointer());
}
}
for (size_t j = 0; j < m_NumberOfSegments; ++j)
{
for (size_t k = 1; k < numPoints; ++k)
{
vtkIdType cell[3];
cell[0] = baseIndex + j * numPoints + (k - 1);
cell[1] = baseIndex + (j + 1) * numPoints + (k - 1);
cell[2] = baseIndex + j * numPoints + k;
cells->InsertNextCell(3, cell);
cell[0] = cell[1];
cell[1] = baseIndex + (j + 1) * numPoints + k;
cells->InsertNextCell(3, cell);
}
if (input->IsClosed() && numPoints > 2)
{
vtkIdType cell[3];
cell[0] = baseIndex + j * numPoints + (numPoints - 1);
cell[1] = baseIndex + (j + 1) * numPoints + (numPoints - 1);
cell[2] = baseIndex + j * numPoints;
cells->InsertNextCell(3, cell);
cell[0] = cell[1];
cell[1] = baseIndex + (j + 1) * numPoints;
cells->InsertNextCell(3, cell);
}
}
baseIndex += points->GetNumberOfPoints();
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->SetPolys(cells);
vtkSmartPointer<vtkPolyDataNormals> polyDataNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
polyDataNormals->SetFlipNormals(m_FlipNormals);
polyDataNormals->SetInputData(polyData);
polyDataNormals->SplittingOff();
polyDataNormals->Update();
Surface* output = static_cast<Surface*>(this->GetPrimaryOutput());
output->SetVtkPolyData(polyDataNormals->GetOutput());
}
void mitk::PlanarFigureVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
{
typedef PlanarFigure::PolyLineType PolyLine;
DataNode* node = this->GetDataNode();
if (node == NULL)
return;
PlanarFigure* planarFigure = dynamic_cast<PlanarFigure*>(node->GetData());
if (planarFigure == NULL || !planarFigure->IsPlaced())
return;
LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
unsigned long mTime = planarFigure->GetMTime();
if (mTime > localStorage->m_LastMTime)
{
localStorage->m_LastMTime = mTime;
const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(planarFigure->GetPlaneGeometry());
const AbstractTransformGeometry* abstractTransformGeometry = dynamic_cast<const AbstractTransformGeometry*>(planarFigure->GetPlaneGeometry());
if (planeGeometry == NULL && abstractTransformGeometry == NULL)
return;
size_t numPolyLines = planarFigure->GetPolyLinesSize();
if (numPolyLines == 0)
return;
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
vtkIdType baseIndex = 0;
for (size_t i = 0; i < numPolyLines; ++i)
{
PolyLine polyLine = planarFigure->GetPolyLine(i);
vtkIdType numPoints = polyLine.size();
if (numPoints < 2)
continue;
PolyLine::const_iterator polyLineEnd = polyLine.end();
for (PolyLine::const_iterator polyLineIt = polyLine.begin(); polyLineIt != polyLineEnd; ++polyLineIt)
{
Point3D point;
planeGeometry->Map(*polyLineIt, point);
points->InsertNextPoint(point.GetDataPointer());
}
vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
vtkIdList* pointIds = line->GetPointIds();
if (planarFigure->IsClosed() && numPoints > 2)
{
pointIds->SetNumberOfIds(numPoints + 1);
pointIds->SetId(numPoints, baseIndex);
}
else
{
pointIds->SetNumberOfIds(numPoints);
}
for (vtkIdType j = 0; j < numPoints; ++j)
pointIds->SetId(j, baseIndex + j);
cells->InsertNextCell(line);
baseIndex += points->GetNumberOfPoints();
}
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints(points);
polyData->SetLines(cells);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputData(polyData);
localStorage->m_Actor->SetMapper(mapper);
}
this->ApplyColorAndOpacityProperties(renderer, localStorage->m_Actor);
this->ApplyPlanarFigureProperties(renderer, localStorage->m_Actor);
}
// Render
void KinectApp::draw()
{
// Clear window
gl::setViewport( getWindowBounds() );
gl::clear( Colorf( 0.1f, 0.1f, 0.1f ) );
// We're capturing
if ( mKinect->isCapturing() ) {
// Set up camera for 3D
gl::setMatrices( mCamera );
// Move skeletons down below the rest of the interface
gl::pushMatrices();
gl::translate( 0.0f, -0.62f, 0.0f );
// Iterate through skeletons
uint32_t i = 0;
for ( vector<Skeleton>::const_iterator skeletonIt = mSkeletons.cbegin(); skeletonIt != mSkeletons.cend(); ++skeletonIt, i++ ) {
// Skeleton is valid when all joints are present
if ( skeletonIt->size() == JointName::NUI_SKELETON_POSITION_COUNT ) {
// Set color
gl::color( mKinect->getUserColor( i ) );
// Draw joints
for ( Skeleton::const_iterator jointIt = skeletonIt->cbegin(); jointIt != skeletonIt->cend(); ++jointIt ) {
gl::drawSphere( jointIt->second * Vec3f( -1.0f, 1.0f, 1.0f ), 0.025f, 16 );
}
// Draw body
for ( vector<vector<JointName> >::const_iterator segmentIt = mSegments.cbegin(); segmentIt != mSegments.cend(); ++segmentIt ) {
drawSegment( * skeletonIt, * segmentIt );
}
}
}
// Switch to 2D
gl::popMatrices();
gl::setMatricesWindow( getWindowSize(), true );
// Draw depth and video textures
gl::color( Colorf::white() );
if ( mDepthSurface ) {
Area srcArea( 0, 0, mDepthSurface.getWidth(), mDepthSurface.getHeight() );
Rectf destRect( 265.0f, 15.0f, 505.0f, 195.0f );
gl::draw( gl::Texture( mDepthSurface ), srcArea, destRect );
}
if ( mVideoSurface ) {
Area srcArea( 0, 0, mVideoSurface.getWidth(), mVideoSurface.getHeight() );
Rectf destRect( 508.0f, 15.0f, 748.0f, 195.0f );
gl::draw( gl::Texture( mVideoSurface ), srcArea, destRect);
}
}
// Check audio data
if ( mData != 0 ) {
// Get dimensions
int32_t dataSize = mInput->getDataSize();
float scale = 240.0f / (float)dataSize;
float height = 180.0f;
Vec2f position( 751.0f, 15.0f );
// Draw background
gl::color( ColorAf::black() );
Rectf background( position.x, position.y, position.x + 240.0f, position.y + 180.0f );
gl::drawSolidRect( background );
// Draw audio input
gl::color( ColorAf::white() );
PolyLine<Vec2f> mLine;
for ( int32_t i = 0; i < dataSize; i++ ) {
mLine.push_back( position + Vec2f( i * scale, math<float>::clamp( mData[ i ], -1.0f, 1.0f ) * height * 0.5f + height * 0.5f ) );
}
if ( mLine.size() > 0 ) {
gl::draw( mLine );
}
}
// Draw the interface
params::InterfaceGl::draw();
}