void PlaneGeometry::EnsurePerpendicularNormal( mitk::AffineTransform3D *transform )
{
/** \brief ensure column(2) of indexToWorldTransform-matrix to be perpendicular to plane, keep length and handedness. */
VnlVector normal = vnl_cross_3d( transform->GetMatrix().GetVnlMatrix().get_column(0),
transform->GetMatrix().GetVnlMatrix().get_column(1) );
normal.normalize(); // Now normal is a righthand normal unit vector, perpendicular to the plane.
ScalarType len = transform->GetMatrix().GetVnlMatrix().get_column(2).two_norm();
if (len==0) { len = 1; }
normal *= len;
// Get the existing normal vector zed:
vnl_vector_fixed<double, 3> zed = transform->GetMatrix().GetVnlMatrix().get_column(2);
/** If det(matrix)<0, multiply normal vector by (-1) to keep geometry lefthanded. */
if( vnl_determinant( transform->GetMatrix().GetVnlMatrix()) < 0 )
{
MITK_DEBUG << "EnsurePerpendicularNormal(): Lefthanded geometry preserved, rh-normal: [ " << normal << " ],";
normal *= (-1.0);
MITK_DEBUG << "lh-normal: [ " << normal << " ], original vector zed is: [ " << zed << " ]";
}
// Now lets compare and only replace if necessary and only then warn the user:
// float epsilon is precise enough here, but we need to respect numerical condition:
// Higham, N., 2002, Accuracy and Stability of Numerical Algorithms,
// SIAM, page 37, 2nd edition:
double feps = std::numeric_limits<float>::epsilon();
double zedsMagnitude = zed.two_norm();
feps = feps * zedsMagnitude * 2;
/** Check if normal (3. column) was perpendicular: If not, replace with calculated normal vector: */
if( normal != zed )
{
vnl_vector_fixed<double, 3> parallel;
for ( unsigned int i = 0; i<3 ; ++i )
{
parallel[i] = normal[i] / zed[i]; // Remember linear algebra: checking for parallelity.
}
// Checking if really not paralell i.e. non-colinear vectors by comparing these floating point numbers:
if( (parallel[0]+feps < parallel[1] || feps+parallel[1] < parallel[0])
&& (parallel[0]+feps < parallel[2] || feps+parallel[2] < parallel[0]) )
{
MITK_WARN << "EnsurePerpendicularNormal(): Plane geometry was _/askew/_, so here it gets rectified by substituting"
<< " the 3rd column of the indexToWorldMatrix with an appropriate normal vector: [ " << normal
<< " ], original vector zed was: [ " << zed << " ].";
Matrix3D matrix = transform->GetMatrix();
matrix.GetVnlMatrix().set_column( 2, normal );
transform->SetMatrix( matrix );
}
}
else
{
// Nothing to do, 3rd column of indexToWorldTransformMatrix already was perfectly perpendicular.
}
}
bool PivotCalibration2::ComputeSpinCalibration(bool snapRotation)
{
if (this->ToolToReferenceMatrices.size() < 10)
{
this->ErrorText = "Not enough input transforms are available";
return false;
}
if (this->GetMaximumToolOrientationDifferenceDeg() < this->MinimumOrientationDifferenceDeg)
{
this->ErrorText = "Not enough variation in the input transforms";
return false;
}
// Setup our system to find the axis of rotation
unsigned int rows = 3, columns = 3;
vnl_matrix<double> A(rows, columns, 0);
vnl_matrix<double> I(3, 3, 0);
I.set_identity();
vnl_matrix<double> RI(rows, columns);
// this will store the maximum difference in orientation between the first transform and all the other transforms
double maximumOrientationDifferenceDeg = 0;
std::vector< vtkSmartPointer<vtkMatrix4x4> >::const_iterator previt = this->ToolToReferenceMatrices.end();
for (std::vector< vtkSmartPointer<vtkMatrix4x4> >::const_iterator it = this->ToolToReferenceMatrices.begin(); it != this->ToolToReferenceMatrices.end(); it++)
{
if (previt == this->ToolToReferenceMatrices.end())
{
previt = it;
continue; // No comparison to make for the first matrix
}
vtkSmartPointer< vtkMatrix4x4 > itinverse = vtkSmartPointer< vtkMatrix4x4 >::New();
vtkMatrix4x4::Invert((*it), itinverse);
vtkSmartPointer< vtkMatrix4x4 > instRotation = vtkSmartPointer< vtkMatrix4x4 >::New();
vtkMatrix4x4::Multiply4x4(itinverse, (*previt), instRotation);
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
RI(i, j) = instRotation->GetElement(i, j);
}
}
RI = RI - I;
A = A + RI.transpose() * RI;
previt = it;
}
// Note: If the needle orientation protocol changes, only the definitions of shaftAxis and secondaryAxes need to be changed
// Define the shaft axis and the secondary shaft axis
// Current needle orientation protocol dictates: shaft axis -z, orthogonal axis +x
// If StylusX is parallel to ShaftAxis then: shaft axis -z, orthogonal axis +y
vnl_vector<double> shaftAxis_Shaft(columns, 0); shaftAxis_Shaft(0) = 0; shaftAxis_Shaft(1) = 0; shaftAxis_Shaft(2) = -1;
vnl_vector<double> orthogonalAxis_Shaft(columns, 0); orthogonalAxis_Shaft(0) = 1; orthogonalAxis_Shaft(1) = 0; orthogonalAxis_Shaft(2) = 0;
vnl_vector<double> backupAxis_Shaft(columns, 0); backupAxis_Shaft(0) = 0; backupAxis_Shaft(1) = 1; backupAxis_Shaft(2) = 0;
// Find the eigenvector associated with the smallest eigenvalue
// This is the best axis of rotation over all instantaneous rotations
vnl_matrix<double> eigenvectors(columns, columns, 0);
vnl_vector<double> eigenvalues(columns, 0);
vnl_symmetric_eigensystem_compute(A, eigenvectors, eigenvalues);
// Note: eigenvectors are ordered in increasing eigenvalue ( 0 = smallest, end = biggest )
vnl_vector<double> shaftAxis_ToolTip(columns, 0);
shaftAxis_ToolTip(0) = eigenvectors(0, 0);
shaftAxis_ToolTip(1) = eigenvectors(1, 0);
shaftAxis_ToolTip(2) = eigenvectors(2, 0);
shaftAxis_ToolTip.normalize();
// Snap the direction vector to be exactly aligned with one of the coordinate axes
// This is if the sensor is known to be parallel to one of the axis, just not which one
if (snapRotation)
{
int closestCoordinateAxis = element_product(shaftAxis_ToolTip, shaftAxis_ToolTip).arg_max();
shaftAxis_ToolTip.fill(0);
shaftAxis_ToolTip.put(closestCoordinateAxis, 1); // Doesn't matter the direction, will be sorted out in the next step
}
// Make sure it is in the correct direction (opposite the StylusTipToStylus translation)
vnl_vector<double> toolTipToToolTranslation(3);
toolTipToToolTranslation(0) = this->ToolTipToToolMatrix->GetElement(0, 3);
toolTipToToolTranslation(1) = this->ToolTipToToolMatrix->GetElement(1, 3);
toolTipToToolTranslation(2) = this->ToolTipToToolMatrix->GetElement(2, 3);
if (dot_product(shaftAxis_ToolTip, toolTipToToolTranslation) > 0)
{
shaftAxis_ToolTip = shaftAxis_ToolTip * (-1);
}
//set the RMSE
this->SpinRMSE = (A * shaftAxis_ToolTip).rms();
// If the secondary axis 1 is parallel to the shaft axis in the tooltip frame, then use secondary axis 2
vnl_vector<double> orthogonalAxis_ToolTip;
double angle = acos(dot_product(shaftAxis_ToolTip, orthogonalAxis_Shaft));
// Force angle to be between -pi/2 and +pi/2
if (angle > vtkMath::Pi() / 2)
{
angle -= vtkMath::Pi();
}
if (angle < -vtkMath::Pi() / 2)
{
angle += vtkMath::Pi();
}
if (fabs(angle) > vtkMath::RadiansFromDegrees(PARALLEL_ANGLE_THRESHOLD_DEGREES)) // If shaft axis and orthogonal axis are not parallel
{
orthogonalAxis_ToolTip = orthogonalAxis_Shaft;
}
else
{
orthogonalAxis_ToolTip = backupAxis_Shaft;
}
// Do the registration find the appropriate rotation
orthogonalAxis_ToolTip = orthogonalAxis_ToolTip - dot_product(orthogonalAxis_ToolTip, shaftAxis_ToolTip) * shaftAxis_ToolTip;
orthogonalAxis_ToolTip.normalize();
// Register X,Y,O points in the two coordinate frames (only spherical registration - since pure rotation)
vnl_matrix<double> ToolTipPoints(3, 3, 0.0);
vnl_matrix<double> ShaftPoints(3, 3, 0.0);
ToolTipPoints.put(0, 0, shaftAxis_ToolTip(0));
ToolTipPoints.put(0, 1, shaftAxis_ToolTip(1));
ToolTipPoints.put(0, 2, shaftAxis_ToolTip(2));
ToolTipPoints.put(1, 0, orthogonalAxis_ToolTip(0));
ToolTipPoints.put(1, 1, orthogonalAxis_ToolTip(1));
ToolTipPoints.put(1, 2, orthogonalAxis_ToolTip(2));
ToolTipPoints.put(2, 0, 0);
ToolTipPoints.put(2, 1, 0);
ToolTipPoints.put(2, 2, 0);
ShaftPoints.put(0, 0, shaftAxis_Shaft(0));
ShaftPoints.put(0, 1, shaftAxis_Shaft(1));
ShaftPoints.put(0, 2, shaftAxis_Shaft(2));
ShaftPoints.put(1, 0, orthogonalAxis_Shaft(0));
ShaftPoints.put(1, 1, orthogonalAxis_Shaft(1));
ShaftPoints.put(1, 2, orthogonalAxis_Shaft(2));
ShaftPoints.put(2, 0, 0);
ShaftPoints.put(2, 1, 0);
ShaftPoints.put(2, 2, 0);
vnl_svd<double> ShaftToToolTipRegistrator(ShaftPoints.transpose() * ToolTipPoints);
vnl_matrix<double> V = ShaftToToolTipRegistrator.V();
vnl_matrix<double> U = ShaftToToolTipRegistrator.U();
vnl_matrix<double> Rotation = V * U.transpose();
// Make sure the determinant is positve (i.e. +1)
double determinant = vnl_determinant(Rotation);
if (determinant < 0)
{
// Switch the sign of the third column of V if the determinant is not +1
// This is the recommended approach from Huang et al. 1987
V.put(0, 2, -V.get(0, 2));
V.put(1, 2, -V.get(1, 2));
V.put(2, 2, -V.get(2, 2));
Rotation = V * U.transpose();
}
// Set the elements of the output matrix
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
this->ToolTipToToolMatrix->SetElement(i, j, Rotation[i][j]);
}
}
this->ErrorText.empty();
return true;
}
int MCLR_SM::Active_Query()
{
stop_training = false;
// The max_info value and hence the algo converges if the user successively selects
//"I am not sure option" .. so whenever the user selects the "I am not sure option
// delete that info value from max_info;
if(current_label==0)
max_info_vector.erase(max_info_vector.begin()+max_info_vector.size()-1);
max_info = -1e9;
int active_query = 0;
//vnl_vector<double> diff_info_3_it(3,0);//difference in g vals for last 3 iterations
//vnl_vector<double> g_3_it(3,0); // g vals for the last three
vnl_matrix<double> test_data_just_features = test_data.transpose();
//test_data_just_features = test_data_just_features.get_n_rows(0,test_data_just_features.rows()-1);
vnl_matrix<double> prob = Test_Current_Model(test_data_just_features);
vnl_matrix<double> test_data_bias = Add_Bias(test_data_just_features);
vnl_vector<double> info_vector(test_data_just_features.cols());
//Compute Information gain
for(int i =0; i< test_data_just_features.cols();++i )
{
vnl_vector<double> temp_col_prob = prob.get_column(i);
vnl_vector<double> temp_col_data = test_data_bias.get_column(i);
vnl_matrix<double> q = Kron(temp_col_prob,temp_col_data);//Kronecker Product
vnl_diag_matrix<double> identity_matrix(no_of_classes,1); // Identity Matrix;
double infoval = (q.transpose() * m.CRB.transpose() * q).get(0,0);
vnl_matrix<double> info_matrix(no_of_classes,no_of_classes,infoval);
info_matrix = identity_matrix + info_matrix ;
info_vector(i) = log(vnl_determinant(info_matrix));
if(info_vector(i)>max_info)
{
active_query = i;
max_info = info_vector(i);
}
}
max_info_vector.push_back(max_info);
// std::cout<<max_info_vector.size() << "--" << max_info <<std::endl;
if(max_info_vector.size()>1)
diff_info_3_it((max_info_vector.size()-1)%3) = max_info_vector.at((max_info_vector.size()-1)) - max_info_vector.at((max_info_vector.size()-2));
info_3_it((max_info_vector.size()-1)%3) = max_info;
if (max_info_vector.size()>3)
{
int sum = 0;
for(int iter =0; iter < 3; iter++)
{
//std::cout<<fabs(diff_info_3_it(iter))/fabs(info_3_it(iter))<<std::endl;
if(fabs(diff_info_3_it(iter))/fabs(info_3_it(iter)) < stop_cond(1))
{
sum = sum + 1;
}
}
// The algorithm is now confident about the problem
// Training can be stopped
if(sum==3)
stop_training = true;
}
return active_query;
}
SEXP invariantSimilarityHelper(
typename itk::Image< float , ImageDimension >::Pointer image1,
typename itk::Image< float , ImageDimension >::Pointer image2,
SEXP r_thetas, SEXP r_lsits, SEXP r_WM, SEXP r_scale,
SEXP r_doreflection, SEXP r_txfn )
{
unsigned int mibins = 20;
unsigned int localSearchIterations =
Rcpp::as< unsigned int >( r_lsits ) ;
std::string whichMetric = Rcpp::as< std::string >( r_WM );
std::string txfn = Rcpp::as< std::string >( r_txfn );
bool useprincaxis = true;
typedef typename itk::ImageMaskSpatialObject<ImageDimension>::ImageType
maskimagetype;
typename maskimagetype::Pointer mask = ITK_NULLPTR;
Rcpp::NumericVector thetas( r_thetas );
Rcpp::NumericVector vector_r( r_thetas ) ;
Rcpp::IntegerVector dims( 1 );
Rcpp::IntegerVector doReflection( r_doreflection );
unsigned int vecsize = thetas.size();
dims[0]=0;
typedef float PixelType;
typedef double RealType;
RealType bestscale = Rcpp::as< RealType >( r_scale ) ;
typedef itk::Image< PixelType , ImageDimension > ImageType;
if( image1.IsNotNull() & image2.IsNotNull() )
{
typedef typename itk::ImageMomentsCalculator<ImageType> ImageCalculatorType;
typedef itk::AffineTransform<RealType, ImageDimension> AffineType0;
typedef itk::AffineTransform<RealType, ImageDimension> AffineType;
typedef typename ImageCalculatorType::MatrixType MatrixType;
typedef itk::Vector<float, ImageDimension> VectorType;
VectorType ccg1;
VectorType cpm1;
MatrixType cpa1;
VectorType ccg2;
VectorType cpm2;
MatrixType cpa2;
typename ImageCalculatorType::Pointer calculator1 =
ImageCalculatorType::New();
typename ImageCalculatorType::Pointer calculator2 =
ImageCalculatorType::New();
calculator1->SetImage( image1 );
calculator2->SetImage( image2 );
typename ImageCalculatorType::VectorType fixed_center;
fixed_center.Fill(0);
typename ImageCalculatorType::VectorType moving_center;
moving_center.Fill(0);
try
{
calculator1->Compute();
fixed_center = calculator1->GetCenterOfGravity();
ccg1 = calculator1->GetCenterOfGravity();
cpm1 = calculator1->GetPrincipalMoments();
cpa1 = calculator1->GetPrincipalAxes();
try
{
calculator2->Compute();
moving_center = calculator2->GetCenterOfGravity();
ccg2 = calculator2->GetCenterOfGravity();
cpm2 = calculator2->GetPrincipalMoments();
cpa2 = calculator2->GetPrincipalAxes();
}
catch( ... )
{
fixed_center.Fill(0);
}
}
catch( ... )
{
// Rcpp::Rcerr << " zero image1 error ";
}
if ( vnl_math_abs( bestscale - 1.0 ) < 1.e-6 )
{
RealType volelt1 = 1;
RealType volelt2 = 1;
for ( unsigned int d=0; d<ImageDimension; d++)
{
volelt1 *= image1->GetSpacing()[d];
volelt2 *= image2->GetSpacing()[d];
}
bestscale =
( calculator2->GetTotalMass() * volelt2 )/
( calculator1->GetTotalMass() * volelt1 );
RealType powlev = 1.0 / static_cast<RealType>(ImageDimension);
bestscale = vcl_pow( bestscale , powlev );
}
unsigned int eigind1 = 1;
unsigned int eigind2 = 1;
if( ImageDimension == 3 )
{
eigind1 = 2;
}
typedef vnl_vector<RealType> EVectorType;
typedef vnl_matrix<RealType> EMatrixType;
EVectorType evec1_2ndary = cpa1.GetVnlMatrix().get_row( eigind2 );
EVectorType evec1_primary = cpa1.GetVnlMatrix().get_row( eigind1 );
EVectorType evec2_2ndary = cpa2.GetVnlMatrix().get_row( eigind2 );
EVectorType evec2_primary = cpa2.GetVnlMatrix().get_row( eigind1 );
/** Solve Wahba's problem http://en.wikipedia.org/wiki/Wahba%27s_problem */
EMatrixType B = outer_product( evec2_primary, evec1_primary );
if( ImageDimension == 3 )
{
B = outer_product( evec2_2ndary, evec1_2ndary )
+ outer_product( evec2_primary, evec1_primary );
}
vnl_svd<RealType> wahba( B );
vnl_matrix<RealType> A_solution = wahba.V() * wahba.U().transpose();
A_solution = vnl_inverse( A_solution );
RealType det = vnl_determinant( A_solution );
if( ( det < 0 ) )
{
vnl_matrix<RealType> id( A_solution );
id.set_identity();
for( unsigned int i = 0; i < ImageDimension; i++ )
{
if( A_solution( i, i ) < 0 )
{
id( i, i ) = -1.0;
}
}
A_solution = A_solution * id.transpose();
}
if ( doReflection[0] == 1 || doReflection[0] == 3 )
{
vnl_matrix<RealType> id( A_solution );
id.set_identity();
id = id - 2.0 * outer_product( evec2_primary , evec2_primary );
A_solution = A_solution * id;
}
if ( doReflection[0] > 1 )
{
vnl_matrix<RealType> id( A_solution );
id.set_identity();
id = id - 2.0 * outer_product( evec1_primary , evec1_primary );
A_solution = A_solution * id;
}
typename AffineType::Pointer affine1 = AffineType::New();
typename AffineType::OffsetType trans = affine1->GetOffset();
itk::Point<RealType, ImageDimension> trans2;
for( unsigned int i = 0; i < ImageDimension; i++ )
{
trans[i] = moving_center[i] - fixed_center[i];
trans2[i] = fixed_center[i] * ( 1 );
}
affine1->SetIdentity();
affine1->SetOffset( trans );
if( useprincaxis )
{
affine1->SetMatrix( A_solution );
}
affine1->SetCenter( trans2 );
if( ImageDimension > 3 )
{
return EXIT_SUCCESS;
}
vnl_vector<RealType> evec_tert;
if( ImageDimension == 3 )
{ // try to rotate around tertiary and secondary axis
evec_tert = vnl_cross_3d( evec1_primary, evec1_2ndary );
}
if( ImageDimension == 2 )
{ // try to rotate around tertiary and secondary axis
evec_tert = evec1_2ndary;
evec1_2ndary = evec1_primary;
}
itk::Vector<RealType, ImageDimension> axis2;
itk::Vector<RealType, ImageDimension> axis1;
for( unsigned int d = 0; d < ImageDimension; d++ )
{
axis1[d] = evec_tert[d];
axis2[d] = evec1_2ndary[d];
}
typename AffineType::Pointer simmer = AffineType::New();
simmer->SetIdentity();
simmer->SetCenter( trans2 );
simmer->SetOffset( trans );
typename AffineType0::Pointer affinesearch = AffineType0::New();
affinesearch->SetIdentity();
affinesearch->SetCenter( trans2 );
typedef itk::MultiStartOptimizerv4 OptimizerType;
typename OptimizerType::MetricValuesListType metricvalues;
typename OptimizerType::Pointer mstartOptimizer = OptimizerType::New();
typedef itk::CorrelationImageToImageMetricv4
<ImageType, ImageType, ImageType> GCMetricType;
typedef itk::MattesMutualInformationImageToImageMetricv4
<ImageType, ImageType, ImageType> MetricType;
typename MetricType::ParametersType newparams( affine1->GetParameters() );
typename GCMetricType::Pointer gcmetric = GCMetricType::New();
gcmetric->SetFixedImage( image1 );
gcmetric->SetVirtualDomainFromImage( image1 );
gcmetric->SetMovingImage( image2 );
gcmetric->SetMovingTransform( simmer );
gcmetric->SetParameters( newparams );
typename MetricType::Pointer mimetric = MetricType::New();
mimetric->SetNumberOfHistogramBins( mibins );
mimetric->SetFixedImage( image1 );
mimetric->SetMovingImage( image2 );
mimetric->SetMovingTransform( simmer );
mimetric->SetParameters( newparams );
if( mask.IsNotNull() )
{
typename itk::ImageMaskSpatialObject<ImageDimension>::Pointer so =
itk::ImageMaskSpatialObject<ImageDimension>::New();
so->SetImage( const_cast<maskimagetype *>( mask.GetPointer() ) );
mimetric->SetFixedImageMask( so );
gcmetric->SetFixedImageMask( so );
}
typedef itk::ConjugateGradientLineSearchOptimizerv4 LocalOptimizerType;
typename LocalOptimizerType::Pointer localoptimizer =
LocalOptimizerType::New();
RealType localoptimizerlearningrate = 0.1;
localoptimizer->SetLearningRate( localoptimizerlearningrate );
localoptimizer->SetMaximumStepSizeInPhysicalUnits(
localoptimizerlearningrate );
localoptimizer->SetNumberOfIterations( localSearchIterations );
localoptimizer->SetLowerLimit( 0 );
localoptimizer->SetUpperLimit( 2 );
localoptimizer->SetEpsilon( 0.1 );
localoptimizer->SetMaximumLineSearchIterations( 50 );
localoptimizer->SetDoEstimateLearningRateOnce( true );
localoptimizer->SetMinimumConvergenceValue( 1.e-6 );
localoptimizer->SetConvergenceWindowSize( 5 );
if( true )
{
typedef typename MetricType::FixedSampledPointSetType PointSetType;
typedef typename PointSetType::PointType PointType;
typename PointSetType::Pointer pset(PointSetType::New());
unsigned int ind=0;
unsigned int ct=0;
itk::ImageRegionIteratorWithIndex<ImageType> It(image1,
image1->GetLargestPossibleRegion() );
for( It.GoToBegin(); !It.IsAtEnd(); ++It )
{
// take every N^th point
if ( ct % 10 == 0 )
{
PointType pt;
image1->TransformIndexToPhysicalPoint( It.GetIndex(), pt);
pset->SetPoint(ind, pt);
ind++;
}
ct++;
}
mimetric->SetFixedSampledPointSet( pset );
mimetric->SetUseFixedSampledPointSet( true );
gcmetric->SetFixedSampledPointSet( pset );
gcmetric->SetUseFixedSampledPointSet( true );
}
if ( whichMetric.compare("MI") == 0 ) {
mimetric->Initialize();
typedef itk::RegistrationParameterScalesFromPhysicalShift<MetricType>
RegistrationParameterScalesFromPhysicalShiftType;
typename RegistrationParameterScalesFromPhysicalShiftType::Pointer
shiftScaleEstimator =
RegistrationParameterScalesFromPhysicalShiftType::New();
shiftScaleEstimator->SetMetric( mimetric );
shiftScaleEstimator->SetTransformForward( true );
typename RegistrationParameterScalesFromPhysicalShiftType::ScalesType
movingScales( simmer->GetNumberOfParameters() );
shiftScaleEstimator->EstimateScales( movingScales );
mstartOptimizer->SetScales( movingScales );
mstartOptimizer->SetMetric( mimetric );
localoptimizer->SetMetric( mimetric );
localoptimizer->SetScales( movingScales );
}
if ( whichMetric.compare("MI") != 0 ) {
gcmetric->Initialize();
typedef itk::RegistrationParameterScalesFromPhysicalShift<GCMetricType>
RegistrationParameterScalesFromPhysicalShiftType;
typename RegistrationParameterScalesFromPhysicalShiftType::Pointer
shiftScaleEstimator =
RegistrationParameterScalesFromPhysicalShiftType::New();
shiftScaleEstimator->SetMetric( gcmetric );
shiftScaleEstimator->SetTransformForward( true );
typename RegistrationParameterScalesFromPhysicalShiftType::ScalesType
movingScales( simmer->GetNumberOfParameters() );
shiftScaleEstimator->EstimateScales( movingScales );
mstartOptimizer->SetScales( movingScales );
mstartOptimizer->SetMetric( gcmetric );
localoptimizer->SetMetric( gcmetric );
localoptimizer->SetScales( movingScales );
}
typename OptimizerType::ParametersListType parametersList =
mstartOptimizer->GetParametersList();
affinesearch->SetIdentity();
affinesearch->SetCenter( trans2 );
affinesearch->SetOffset( trans );
for ( unsigned int i = 0; i < vecsize; i++ )
{
RealType ang1 = thetas[i];
RealType ang2 = 0; // FIXME should be psi
vector_r[ i ]=0;
if( ImageDimension == 3 )
{
for ( unsigned int jj = 0; jj < vecsize; jj++ )
{
ang2=thetas[jj];
affinesearch->SetIdentity();
affinesearch->SetCenter( trans2 );
affinesearch->SetOffset( trans );
if( useprincaxis )
{
affinesearch->SetMatrix( A_solution );
}
affinesearch->Rotate3D(axis1, ang1, 1);
affinesearch->Rotate3D(axis2, ang2, 1);
affinesearch->Scale( bestscale );
simmer->SetMatrix( affinesearch->GetMatrix() );
parametersList.push_back( simmer->GetParameters() );
}
}
if( ImageDimension == 2 )
{
affinesearch->SetIdentity();
affinesearch->SetCenter( trans2 );
affinesearch->SetOffset( trans );
if( useprincaxis )
{
affinesearch->SetMatrix( A_solution );
}
affinesearch->Rotate2D( ang1, 1);
affinesearch->Scale( bestscale );
simmer->SetMatrix( affinesearch->GetMatrix() );
typename AffineType::ParametersType pp =
simmer->GetParameters();
//pp[1]=ang1;
//pp[0]=bestscale;
parametersList.push_back( simmer->GetParameters() );
}
}
mstartOptimizer->SetParametersList( parametersList );
if( localSearchIterations > 0 )
{
mstartOptimizer->SetLocalOptimizer( localoptimizer );
}
mstartOptimizer->StartOptimization();
typename AffineType::Pointer bestaffine = AffineType::New();
bestaffine->SetCenter( trans2 );
bestaffine->SetParameters( mstartOptimizer->GetBestParameters() );
if ( txfn.length() > 3 )
{
typename AffineType::Pointer bestaffine = AffineType::New();
bestaffine->SetCenter( trans2 );
bestaffine->SetParameters( mstartOptimizer->GetBestParameters() );
typedef itk::TransformFileWriter TransformWriterType;
typename TransformWriterType::Pointer transformWriter =
TransformWriterType::New();
transformWriter->SetInput( bestaffine );
transformWriter->SetFileName( txfn.c_str() );
transformWriter->Update();
}
metricvalues = mstartOptimizer->GetMetricValuesList();
for ( unsigned int k = 0; k < metricvalues.size(); k++ )
{
vector_r[k] = metricvalues[k];
}
dims[0] = vecsize;
vector_r.attr( "dim" ) = vecsize;
return Rcpp::wrap( vector_r );
}
else
{
return Rcpp::wrap( vector_r );
}
}
int main(int argc , char** argv)
{
MCLR *mclr = new MCLR();
vnl_matrix<double> data;
vnl_vector<double> classes;
double sparsity = 1;
int active_query = 1;
double max_info = -1e9;
int max_label_examples = atoi(argv[1]);
//Get the training data with the classes
vnl_matrix<double> Feats = Read_From_File("C:\\ActiveLearning\\spMCLogit_active_updated_06_02_11\\alltrain_gt2.txt");
mclr->Initialize(Feats,sparsity,"ground_truth");
mclr->Get_Training_Model();
vnl_vector<double> diff_g_3_it(3,0);//difference in g vals for last 3 iterations
vnl_vector<double> g_3_it(3,0); // g vals for the last three
for(int iteration = 0 ; iteration< max_label_examples ; ++ iteration)
{
vnl_matrix<double> test_data_just_features = mclr->test_data.transpose();
if(mclr->validation == "ground_truth")
test_data_just_features = test_data_just_features.get_n_rows(0,test_data_just_features.rows()-3);
else
test_data_just_features = test_data_just_features.get_n_rows(0,test_data_just_features.rows()-2);
vnl_matrix<double> prob = mclr->Test_Current_Model(test_data_just_features);
vnl_matrix<double> test_data_bias = mclr->Add_Bias(test_data_just_features);
vnl_vector<double> info_vector(test_data_just_features.cols());
//Compute Information gain
for(int i =0; i< test_data_just_features.cols();++i )
{
vnl_vector<double> temp_col_prob = prob.get_column(i);
vnl_vector<double> temp_col_data = test_data_bias.get_column(i);
vnl_matrix<double> q = mclr->Kron(temp_col_prob,temp_col_data);//Kronecker Product
vnl_diag_matrix<double> identity_matrix(mclr->no_of_classes,1); // Identity Matrix;
double infoval = (q.transpose() * mclr->m.CRB.transpose() * q).get(0,0);
vnl_matrix<double> info_matrix(mclr->no_of_classes,mclr->no_of_classes,infoval);
info_matrix = identity_matrix + info_matrix ;
info_vector(i) = log(vnl_determinant(info_matrix));
if(info_vector(i)>max_info)
{
active_query = i;
max_info = info_vector(i);
}
}
mclr->Update_Train_Data(active_query);
mclr->Get_Training_Model();
std::cout<< max_info <<std::endl;
//reset the max_info for next iteration
max_info = -1e9;
}
vnl_matrix<double> test_data_just_features = mclr->test_data.transpose();
if(mclr->validation == "ground_truth")
test_data_just_features = test_data_just_features.get_n_rows(0,test_data_just_features.rows()-3);
else
test_data_just_features = test_data_just_features.get_n_rows(0,test_data_just_features.rows()-2);
vnl_matrix<double> currprob = mclr->Test_Current_Model(test_data_just_features);
vnl_vector<double> gt = mclr->y_ground_truth;
double accuracy = 0;
for(int i = 0; i< currprob.cols() ; ++i)
{
vnl_vector<double> curr_col = currprob.get_column(i);
if(curr_col.arg_max()+1 == gt(i))
accuracy++;
}
double p = gt.size();
std::cout<< accuracy/p <<std::endl;
}
void
PlaneGeometry::InitializeStandardPlane( mitk::ScalarType width, mitk::ScalarType height,
const AffineTransform3D* transform /* = nullptr */,
PlaneGeometry::PlaneOrientation planeorientation /* = Axial */,
mitk::ScalarType zPosition /* = 0 */,
bool frontside /* = true */,
bool rotated /* = false */ )
{
Superclass::Initialize();
/// construct standard view.
// We define at the moment "frontside" as: axial from above,
// coronal from front (nose), saggital from right.
// TODO: Double check with medicals doctors or radiologists [ ].
// We define the orientation in patient's view, e.g. LAI is in a axial cut
// (parallel to the triangle ear-ear-nose):
// first axis: To the left ear of the patient
// seecond axis: To the nose of the patient
// third axis: To the legs of the patient.
// Options are: L/R left/right; A/P anterior/posterior; I/S inferior/superior
// (AKA caudal/cranial).
// We note on all cases in the following switch block r.h. for right handed
// or l.h. for left handed to describe the different cases.
// However, which system is chosen is defined at the end of the switch block.
// CAVE / be careful: the vectors right and bottom are relative to the plane
// and do NOT describe e.g. the right side of the patient.
Point3D origin;
/** Bottom means downwards, DV means Direction Vector. Both relative to the image! */
VnlVector rightDV(3), bottomDV(3);
/** Origin of this plane is by default a zero vector and implicitly in the top-left corner: */
origin.Fill(0);
/** This is different to all definitions in MITK, except the QT mouse clicks.
* But it is like this here and we don't want to change a running system.
* Just be aware, that IN THIS FUNCTION we define the origin at the top left (e.g. your screen). */
/** NormalDirection defines which axis (i.e. column index in the transform matrix)
* is perpendicular to the plane: */
int normalDirection;
switch(planeorientation) // Switch through our limited choice of standard planes:
{
case None:
/** Orientation 'None' shall be done like the axial plane orientation,
* for whatever reasons. */
case Axial:
if(frontside) // Radiologist's view from below. A cut along the triangle ear-ear-nose.
{
if(rotated==false)
/** Origin in the top-left corner, x=[1; 0; 0], y=[0; 1; 0], z=[0; 0; 1],
* origin=[0,0,zpos]: LAI (r.h.)
*
* 0---rightDV----> |
* | |
* | Picture of a finite, rectangular plane |
* | ( insert LOLCAT-scan here ^_^ ) |
* | |
* v _________________________________________|
*
*/
{
FillVector3D(origin, 0, 0, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else // Origin rotated to the bottom-right corner, x=[-1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
// origin=[w,h,zpos]: RPI (r.h.)
{ // Caveat emptor: Still using top-left as origin of index coordinate system!
FillVector3D(origin, width, height, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
else // 'Backside, not frontside.' Neuro-Surgeons's view from above patient.
{
if(rotated==false) // x=[-1; 0; 0], y=[0; 1; 0], z=[0; 0; 1], origin=[w,0,zpos]: RAS (r.h.)
{
FillVector3D(origin, width, 0, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else // Origin in the bottom-left corner, x=[1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
// origin=[0,h,zpos]: LPS (r.h.)
{
FillVector3D(origin, 0, height, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
normalDirection = 2; // That is S=Superior=z=third_axis=middlefinger in righthanded LPS-system.
break;
// Frontal is known as Coronal in mitk. Plane cuts through patient's ear-ear-heel-heel:
case Frontal:
if(frontside)
{
if(rotated==false) // x=[1; 0; 0], y=[0; 0; 1], z=[0; 1; 0], origin=[0,zpos,0]: LAI (r.h.)
{
FillVector3D(origin, 0, zPosition, 0);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[-1;0;0], y=[0;0;-1], z=[0;1;0], origin=[w,zpos,h]: RAS (r.h.)
{
FillVector3D(origin, width, zPosition, height);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false) // x=[-1;0;0], y=[0;0;1], z=[0;1;0], origin=[w,zpos,0]: RPI (r.h.)
{
FillVector3D(origin, width, zPosition, 0);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[1;0;0], y=[0;1;0], z=[0;0;-1], origin=[0,zpos,h]: LPS (r.h.)
{
FillVector3D(origin, 0, zPosition, height);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 1; // Normal vector = posterior direction.
break;
case Sagittal: // Sagittal=Medial plane, the symmetry-plane mirroring your face.
if(frontside)
{
if(rotated==false) // x=[0;1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,0,0]: LAI (r.h.)
{
FillVector3D(origin, zPosition, 0, 0);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[0;-1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,w,h]: LPS (r.h.)
{
FillVector3D(origin, zPosition, width, height);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if(rotated==false) // x=[0;-1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,w,0]: RPI (r.h.)
{
FillVector3D(origin, zPosition, width, 0);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[0;1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,0,h]: RAS (r.h.)
{
FillVector3D(origin, zPosition, 0, height);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 0; // Normal vector = Lateral direction: Left in a LPS-system.
break;
default:
itkExceptionMacro("unknown PlaneOrientation");
}
/// Checking if lefthanded or righthanded:
mitk::ScalarType lhOrRhSign=(+1);
if ( transform != nullptr )
{
lhOrRhSign = ( (0 < vnl_determinant( transform->GetMatrix().GetVnlMatrix() )) ? (+1) : (-1) );
MITK_DEBUG << "mitk::PlaneGeometry::InitializeStandardPlane(): lhOrRhSign, normalDirection, NameOfClass, ObjectName = "
<< lhOrRhSign << ", " << normalDirection << ", " << transform->GetNameOfClass()
<< ", " << transform->GetObjectName() << ".";
origin = transform->TransformPoint( origin );
rightDV = transform->TransformVector( rightDV );
bottomDV = transform->TransformVector( bottomDV );
/// Signing normal vector according to l.h./r.h. coordinate system:
this->SetMatrixByVectors( rightDV,
bottomDV,
transform->GetMatrix().GetVnlMatrix().get_column(normalDirection).two_norm() * lhOrRhSign );
}
else if ( transform == nullptr )
{
this->SetMatrixByVectors( rightDV, bottomDV );
}
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
this->SetOrigin( origin );
}
