/*updateNodeProbabilityMatrixs
* Update the size of the matrices when a node or and edge is added/removed
*/
void BNet::updateNodeProbabilityMatrix(int i_nodeNumber, int i_newEdgeFromNodeID){
MatrixXf oldMatrix(listOfNodeConditionalProbabilities[i_nodeNumber]->cols(), listOfNodeConditionalProbabilities[i_nodeNumber]->rows());
oldMatrix = listOfNodeConditionalProbabilities[i_nodeNumber][0];
VectorXd oldVector(listOfNodeInputEdges[i_nodeNumber]->rows());
oldVector = listOfNodeInputEdges[i_nodeNumber][0];
int nbParent = getNumberOfParentsOf(getNodeId(i_nodeNumber));
int nbConditionalProb = 1;
for(int c = 0; c < nbParent; c++){
nbConditionalProb *= getParentNb(getNodeId(i_nodeNumber), c)->getNumberOfStates();
}
//Create a matrix with cols being the number of states of the node and rows all the possibilities for its parent value
listOfNodeConditionalProbabilities[i_nodeNumber] = new MatrixXf(listOfNodes[i_nodeNumber]->getNumberOfStates(), nbConditionalProb);
// cout<<getNodeId(i_nodeNumber)->getName()<<" is size "<<listOfNodes[i_nodeNumber]->getNumberOfStates()<<" x "<<nbConditionalProb<<endl;
for(int cRows = 0; cRows < listOfNodeConditionalProbabilities[i_nodeNumber]->rows(); cRows++){
for(int cCols = 0; cCols < listOfNodeConditionalProbabilities[i_nodeNumber]->cols(); cCols++){
listOfNodeConditionalProbabilities[i_nodeNumber][0](cRows, cCols) = 1/(listOfNodes[i_nodeNumber]->getNumberOfStates());
}
}
//Create a matrix with rows being the number of states of the node and rows all the possibilities for its parent value
listOfNodeInputEdges[i_nodeNumber] = new VectorXd(getNumberOfParentsOf(listOfNodes[i_nodeNumber]));
for(int cRows = 0; cRows < oldVector.rows(); cRows++){
listOfNodeInputEdges[i_nodeNumber][0](cRows) = oldVector(cRows);
}
listOfNodeInputEdges[i_nodeNumber][0]((listOfNodeInputEdges[i_nodeNumber]->rows())-1) = i_newEdgeFromNodeID;
}
bool
RenderingManager
::InitializeViews( const Geometry3D * dataGeometry, RequestType type, bool preserveRoughOrientationInWorldSpace )
{
MITK_DEBUG << "initializing views";
bool boundingBoxInitialized = false;
Geometry3D::ConstPointer geometry = dataGeometry;
if (dataGeometry && preserveRoughOrientationInWorldSpace)
{
// clone the input geometry
Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
assert(modifiedGeometry.IsNotNull());
// construct an affine transform from it
AffineGeometryFrame3D::TransformType::Pointer transform = AffineGeometryFrame3D::TransformType::New();
assert( modifiedGeometry->GetIndexToWorldTransform() );
transform->SetMatrix( modifiedGeometry->GetIndexToWorldTransform()->GetMatrix() );
transform->SetOffset( modifiedGeometry->GetIndexToWorldTransform()->GetOffset() );
// get transform matrix
AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& oldMatrix =
const_cast< AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType& > ( transform->GetMatrix().GetVnlMatrix() );
AffineGeometryFrame3D::TransformType::MatrixType::InternalMatrixType newMatrix(oldMatrix);
// get offset and bound
Vector3D offset = modifiedGeometry->GetIndexToWorldTransform()->GetOffset();
Geometry3D::BoundsArrayType oldBounds = modifiedGeometry->GetBounds();
Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
// get rid of rotation other than pi/2 degree
for ( unsigned int i = 0; i < 3; ++i )
{
// i-th column of the direction matrix
Vector3D currentVector;
currentVector[0] = oldMatrix(0,i);
currentVector[1] = oldMatrix(1,i);
currentVector[2] = oldMatrix(2,i);
// matchingRow will store the row that holds the biggest
// value in the column
unsigned int matchingRow = 0;
// maximum value in the column
float max = std::numeric_limits<float>::min();
// sign of the maximum value (-1 or 1)
int sign = 1;
// iterate through the column vector
for (unsigned int dim = 0; dim < 3; ++dim)
{
if ( fabs(currentVector[dim]) > max )
{
matchingRow = dim;
max = fabs(currentVector[dim]);
if(currentVector[dim]<0)
sign = -1;
else
sign = 1;
}
}
// in case we found a negative maximum,
// we negate the column and adjust the offset
// (in order to run through the dimension in the opposite direction)
if(sign == -1)
{
currentVector *= sign;
offset += modifiedGeometry->GetAxisVector(i);
}
// matchingRow is now used as column index to place currentVector
// correctly in the new matrix
vnl_vector<ScalarType> newMatrixColumn(3);
newMatrixColumn[0] = currentVector[0];
newMatrixColumn[1] = currentVector[1];
newMatrixColumn[2] = currentVector[2];
newMatrix.set_column( matchingRow, newMatrixColumn );
// if a column is moved, we also have to adjust the bounding
// box accordingly, this is done here
newBounds[2*matchingRow ] = oldBounds[2*i ];
newBounds[2*matchingRow+1] = oldBounds[2*i+1];
}
// set the newly calculated bounds array
modifiedGeometry->SetBounds(newBounds);
// set new offset and direction matrix
AffineGeometryFrame3D::TransformType::MatrixType newMatrixITK( newMatrix );
transform->SetMatrix( newMatrixITK );
transform->SetOffset( offset );
modifiedGeometry->SetIndexToWorldTransform( transform );
geometry = modifiedGeometry;
}
int warningLevel = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
if ( (geometry.IsNotNull() ) && (const_cast< mitk::BoundingBox * >(
geometry->GetBoundingBox())->GetDiagonalLength2() > mitk::eps) )
{
boundingBoxInitialized = true;
}
if (geometry.IsNotNull() )
{ // make sure bounding box has an extent bigger than zero in any direction
// clone the input geometry
Geometry3D::Pointer modifiedGeometry = dynamic_cast<Geometry3D*>( dataGeometry->Clone().GetPointer() );
assert(modifiedGeometry.IsNotNull());
Geometry3D::BoundsArrayType newBounds = modifiedGeometry->GetBounds();
for( unsigned int dimension = 0; ( 2 * dimension ) < newBounds.Size() ; dimension++ )
{
//check for equality but for an epsilon
if( Equal( newBounds[ 2 * dimension ], newBounds[ 2 * dimension + 1 ] ) )
{
newBounds[ 2 * dimension + 1 ] += 1;
}
}
// set the newly calculated bounds array
modifiedGeometry->SetBounds(newBounds);
geometry = modifiedGeometry;
}
RenderWindowList::iterator it;
for ( it = m_RenderWindowList.begin(); it != m_RenderWindowList.end(); ++it )
{
mitk::BaseRenderer *baseRenderer =
mitk::BaseRenderer::GetInstance( it->first );
baseRenderer->GetDisplayGeometry()->SetConstrainZoomingAndPanning(m_ConstrainedPaddingZooming);
int id = baseRenderer->GetMapperID();
if ( ((type == REQUEST_UPDATE_ALL)
|| ((type == REQUEST_UPDATE_2DWINDOWS) && (id == 1))
|| ((type == REQUEST_UPDATE_3DWINDOWS) && (id == 2)))
)
{
this->InternalViewInitialization( baseRenderer, geometry,
boundingBoxInitialized, id );
}
}
if ( m_TimeNavigationController != NULL )
{
if ( boundingBoxInitialized )
{
m_TimeNavigationController->SetInputWorldGeometry( geometry );
}
m_TimeNavigationController->Update();
}
this->RequestUpdateAll( type );
vtkObject::SetGlobalWarningDisplay( warningLevel );
// Inform listeners that views have been initialized
this->InvokeEvent( mitk::RenderingManagerViewsInitializedEvent() );
return boundingBoxInitialized;
}
