double ManualImage2ImageRegistrationWidget::getAccuracy(QString uid)
{
DataPtr fixedData = mServices->registration()->getFixedData();
if (!fixedData)
return 1000.0;
DataPtr movingData = mServices->registration()->getMovingData();
if (!movingData)
return 1000.0;
Landmark masterLandmark = fixedData->getLandmarks()->getLandmarks()[uid];
Landmark targetLandmark = movingData->getLandmarks()->getLandmarks()[uid];
if (masterLandmark.getUid().isEmpty() || targetLandmark.getUid().isEmpty())
return 1000.0;
Vector3D p_master_master = masterLandmark.getCoord();
Vector3D p_target_target = targetLandmark.getCoord();
Transform3D rMmaster = fixedData->get_rMd();
Transform3D rMtarget = movingData->get_rMd();
Vector3D p_target_r = rMtarget.coord(p_target_target);
Vector3D p_master_r = rMmaster.coord(p_master_master);
double targetPoint[3];
double masterPoint[3];
targetPoint[0] = p_target_r[0];
targetPoint[1] = p_target_r[1];
targetPoint[2] = p_target_r[2];
masterPoint[0] = p_master_r[0];
masterPoint[1] = p_master_r[1];
masterPoint[2] = p_master_r[2];
return (vtkMath::Distance2BetweenPoints(targetPoint, masterPoint));
}
void CustomMetric::updateTexture(MeshPtr model, Transform3D rMrr)
{
if (!model)
return;
if (!this->getTextureFollowTool() || !model->hasTexture())
return;
// special case:
// Project tool position down to the model, then set that position as
// the texture x pos.
Transform3D rMt = mSpaceProvider->getActiveToolTipTransform(CoordinateSystem::reference());
Transform3D rMd = rMrr * model->get_rMd();
Vector3D t_r = rMt.coord(Vector3D::Zero());
Vector3D td_r = rMt.vector(Vector3D::UnitZ());
DoubleBoundingBox3D bb_d = model->boundingBox();
Vector3D bl = bb_d.bottomLeft();
Vector3D tr = bb_d.topRight();
Vector3D c = (bl+tr)/2;
Vector3D x_min_r(c[0], bl[1], c[2]);
Vector3D x_max_r(c[0], tr[1], c[2]);
x_min_r = rMd.coord(x_min_r);
x_max_r = rMd.coord(x_max_r);
double t_x = dot(t_r, td_r);
double bbmin_x = dot(x_min_r, td_r);
double bbmax_x = dot(x_max_r, td_r);
double range = bbmax_x-bbmin_x;
if (similar(range, 0.0))
range = 1.0E-6;
double s = (t_x-bbmin_x)/range;
model->getTextureData().getPositionY()->setValue(s);
}
void Rect3D::updatePosition(const DoubleBoundingBox3D bb, const Transform3D& M)
{
mPoints = vtkPointsPtr::New();
mPoints->InsertPoint(0, M.coord(bb.corner(0,0,0)).begin());
mPoints->InsertPoint(1, M.coord(bb.corner(0,1,0)).begin());
mPoints->InsertPoint(2, M.coord(bb.corner(1,1,0)).begin());
mPoints->InsertPoint(3, M.coord(bb.corner(1,0,0)).begin());
mPolyData->SetPoints(mPoints);
}
void EraserWidget::eraseVolume(TYPE* volumePointer)
{
ImagePtr image = mPatientModelService->getActiveImage();
vtkImageDataPtr img = image->getBaseVtkImageData();
Eigen::Array3i dim(img->GetDimensions());
Vector3D spacing(img->GetSpacing());
Transform3D rMd = mVisualizationService->getGroup(0)->getOptions().mPickerGlyph->get_rMd();
Vector3D c(mSphere->GetCenter());
c = rMd.coord(c);
double r = mSphere->GetRadius();
mPreviousCenter = c;
mPreviousRadius = r;
DoubleBoundingBox3D bb_r(c[0]-r, c[0]+r, c[1]-r, c[1]+r, c[2]-r, c[2]+r);
Transform3D dMr = image->get_rMd().inv();
Transform3D rawMd = createTransformScale(spacing).inv();
Transform3D rawMr = rawMd * dMr;
Vector3D c_d = dMr.coord(c);
double r_d = dMr.vector(r * Vector3D::UnitX()).length();
c = rawMr.coord(c);
r = rawMr.vector(r * Vector3D::UnitX()).length();
DoubleBoundingBox3D bb0_raw = transform(rawMr, bb_r);
IntBoundingBox3D bb1_raw(0, dim[0], 0, dim[1], 0, dim[2]);
// std::cout << " sphere: " << bb0_raw << std::endl;
// std::cout << " raw: " << bb1_raw << std::endl;
for (int i=0; i<3; ++i)
{
bb1_raw[2*i] = std::max<double>(bb1_raw[2*i], bb0_raw[2*i]);
bb1_raw[2*i+1] = std::min<double>(bb1_raw[2*i+1], bb0_raw[2*i+1]);
}
int replaceVal = mEraseValueAdapter->getValue();
for (int x = bb1_raw[0]; x < bb1_raw[1]; ++x)
for (int y = bb1_raw[2]; y < bb1_raw[3]; ++y)
for (int z = bb1_raw[4]; z < bb1_raw[5]; ++z)
{
int index = x + y * dim[0] + z * dim[0] * dim[1];
if ((Vector3D(x*spacing[0], y*spacing[1], z*spacing[2]) - c_d).length() < r_d)
volumePointer[index] = replaceVal;
}
}
vtkPolyDataPtr polydataFromTransforms(TimedTransformMap transformMap_prMt, Transform3D rMpr)
{
vtkPolyDataPtr retval = vtkPolyDataPtr::New();
vtkPointsPtr points = vtkPointsPtr::New();
vtkCellArrayPtr lines = vtkCellArrayPtr::New();
points->Allocate(transformMap_prMt.size());
TimedTransformMap::iterator mapIter = transformMap_prMt.begin();
while(mapIter != transformMap_prMt.end())
{
Vector3D point_t = Vector3D(0,0,0);
Transform3D prMt = mapIter->second;
Transform3D rMt = rMpr * prMt;
Vector3D p = rMt.coord(point_t);
points->InsertNextPoint(p.begin());
++mapIter;
}
lines->Initialize();
std::vector<vtkIdType> ids(points->GetNumberOfPoints());
for (unsigned i=0; i<ids.size(); ++i)
ids[i] = i;
lines->InsertNextCell(ids.size(), &(*ids.begin()));
retval->SetPoints(points);
retval->SetLines(lines);
return retval;
}
std::vector<Vector3D> CustomMetric::getPointCloud() const
{
std::vector<Vector3D> retval;
DataPtr model = this->getModel();
std::vector<Transform3D> pos = this->calculateOrientations();
std::vector<Vector3D> cloud;
Transform3D rrMd;
if (model)
{
rrMd = model->get_rMd();
cloud = model->getPointCloud();
}
else
{
cloud.push_back(Vector3D::Zero());
rrMd = Transform3D::Identity();
}
for (unsigned i=0; i<pos.size(); ++i)
{
Transform3D rMd = pos[i] * rrMd;
for (unsigned j=0; j<cloud.size(); ++j)
{
Vector3D p_r = rMd.coord(cloud[j]);
retval.push_back(p_r);
}
}
return retval;
}
Vector3D ViewFollower::findCenter_r_fromShift_s(Vector3D shift_s)
{
Transform3D sMr = mSliceProxy->get_sMr();
Vector3D c_s = sMr.coord(mDataManager->getCenter());
Vector3D newcenter_s = c_s + shift_s;
Vector3D newcenter_r = sMr.inv().coord(newcenter_s);
return newcenter_r;
}
Vector3D ViewFollower::findVirtualTooltip_s()
{
ToolPtr tool = mSliceProxy->getTool();
Transform3D sMr = mSliceProxy->get_sMr();
Transform3D rMpr = mDataManager->get_rMpr();
Transform3D prMt = tool->get_prMt();
Vector3D pt_s = sMr * rMpr * prMt.coord(Vector3D(0,0,tool->getTooltipOffset()));
pt_s[2] = 0; // project into plane
return pt_s;
}
Vector3D ToolTipCalibrationCalculator::get_sampledPoint_ref()
{
CoordinateSystem csT = mSpaces->getT(mTool); //from
CoordinateSystem csRef = mSpaces->getT(mRef); //to
Transform3D refMt = mSpaces->get_toMfrom(csT, csRef);
Vector3D P_ref = refMt.coord(mP_t);
return P_ref;
}
double LandmarkRegistrationWidget::getAccuracy(QString uid)
{
DataPtr fixedData = mServices->registration()->getFixedData();
if (!fixedData)
return 1000.0;
Landmark masterLandmark = fixedData->getLandmarks()->getLandmarks()[uid];
Landmark targetLandmark = this->getTargetLandmarks()[uid];
if (masterLandmark.getUid().isEmpty() || targetLandmark.getUid().isEmpty())
return 1000.0;
Vector3D p_master_master = masterLandmark.getCoord();
Vector3D p_target_target = targetLandmark.getCoord();
Transform3D rMmaster = fixedData->get_rMd();
Transform3D rMtarget = this->getTargetTransform();
Vector3D p_target_r = rMtarget.coord(p_target_target);
Vector3D p_master_r = rMmaster.coord(p_master_master);
return (p_target_r - p_master_r).length();
}
std::vector<Vector3D> RegistrationImplService::convertAndTransformToPoints(const std::vector<QString>& uids, const LandmarkMap& data, Transform3D M)
{
std::vector<Vector3D> retval;
for (unsigned i=0; i<uids.size(); ++i)
{
QString uid = uids[i];
Vector3D p = M.coord(data.find(uid)->second.getCoord());
retval.push_back(p);
}
return retval;
}
/**Convert the landmarks given by uids to vtk points.
* The coordinates are given by the input data,
* and should be transformed by M.
*
* Prerequisite: all uids exist in data.
*/
vtkPointsPtr RegistrationImplService::convertTovtkPoints(const std::vector<QString>& uids, const LandmarkMap& data, Transform3D M)
{
vtkPointsPtr retval = vtkPointsPtr::New();
for (unsigned i=0; i<uids.size(); ++i)
{
QString uid = uids[i];
Vector3D p = M.coord(data.find(uid)->second.getCoord());
retval->InsertNextPoint(p.begin());
}
return retval;
}
void PickerRep::toolHasChanged()
{
if (!mTool)
return;
Transform3D prMt = mTool->get_prMt();
Transform3D rMpr = mDataManager->get_rMpr();
Transform3D rMt = rMpr * prMt;
Vector3D p_r = rMt.coord(Vector3D(0, 0, mTool->getTooltipOffset()));
mPickedPoint = p_r;
if (mGraphicalPoint)
mGraphicalPoint->setValue(mPickedPoint);
this->setGlyphCenter(mPickedPoint);
}
void SlicePlaneClipper::updateClipPlane()
{
if (!mSlicer)
return;
if (!mClipPlane)
mClipPlane = vtkPlanePtr::New();
Transform3D rMs = mSlicer->get_sMr().inv();
Vector3D n = rMs.vector(this->getUnitNormal());
Vector3D p = rMs.coord(Vector3D(0,0,0));
mClipPlane->SetNormal(n.begin());
mClipPlane->SetOrigin(p.begin());
}
void EraserWidget::continousRemoveSlot()
{
Transform3D rMd = mVisualizationService->getGroup(0)->getOptions().mPickerGlyph->get_rMd();
//Transform3D rMd = mVisualizationService->getViewGroupDatas().front()->getData()->getOptions().mPickerGlyph->get_rMd();
Vector3D c(mSphere->GetCenter());
c = rMd.coord(c);
double r = mSphere->GetRadius();
// optimization: dont remove if idle
if (similar(mPreviousCenter, c) && similar(mPreviousRadius, r))
return;
this->removeSlot();
}
void LandmarkRegistrationWidget::setManualToolPosition(Vector3D p_r)
{
Transform3D rMpr = mServices->patient()->get_rMpr();
Vector3D p_pr = rMpr.inv().coord(p_r);
// set the picked point as offset tip
ToolPtr tool = mServices->tracking()->getManualTool();
Vector3D offset = tool->get_prMt().vector(Vector3D(0, 0, tool->getTooltipOffset()));
p_pr -= offset;
p_r = rMpr.coord(p_pr);
// TODO set center here will not do: must handle
mServices->patient()->setCenter(p_r);
Vector3D p0_pr = tool->get_prMt().coord(Vector3D(0, 0, 0));
tool->set_prMt(createTransformTranslate(p_pr - p0_pr) * tool->get_prMt());
}
void GraphicalAxes3D::rescale()
{
if (!mViewportListener->isListening())
return;
double size = mViewportListener->getVpnZoom();
double axisSize = mSize/size;
double scale = axisSize / m_vtkAxisLength;
// NOTE: vtkAxesActor dislikes small values for SetTotalLength, thus we
// keep that value constant at m_vtkAxisLength and instead scale the transform.
Transform3D rMq = m_rMt * createTransformScale(Vector3D(scale,scale,scale));
mActor->SetUserMatrix(rMq.getVtkMatrix());
for (unsigned i=0; i<mCaption.size(); ++i)
{
Vector3D pos = rMq.coord(axisSize*mCaptionPos[i]);
mCaption[i]->SetAttachmentPoint(pos.begin());
}
}
std::vector<double> TemporalCalibration::computeTrackingMovement()
{
std::vector<double> retval;
Vector3D e_z(0,0,1);
Vector3D origin(0,0,0);
double zero = 0;
Transform3D prM0t = mFileData.mPositions[0].mPos;
Vector3D ez_pr = prM0t.vector(e_z);
for (unsigned i=0; i<mFileData.mPositions.size(); ++i)
{
Transform3D prMt = mFileData.mPositions[i].mPos;
Vector3D p_pr = prMt.coord(origin);
double val = dot(ez_pr, p_pr);
if (retval.empty())
zero = val;
retval.push_back(val-zero);
}
if (mAddRawToDebug)
{
mDebugStream << "=======================================" << std::endl;
mDebugStream << "tracking raw data:" << std::endl;
mDebugStream << std::endl;
mDebugStream << "timestamp" << "\t" << "pos" << std::endl;
for (unsigned x = 0; x < mFileData.mPositions.size(); ++x)
{
mDebugStream << mFileData.mPositions[x].mTime << "\t" << retval[x] << std::endl;
}
mDebugStream << std::endl;
mDebugStream << "=======================================" << std::endl;
}
return retval;
}
/**Transform bb using the transform m.
* Only the two defining corners are actually transformed.
*/
DoubleBoundingBox3D transform(const Transform3D& m, const DoubleBoundingBox3D& bb)
{
Vector3D a = m.coord(bb.bottomLeft());
Vector3D b = m.coord(bb.topRight());
return DoubleBoundingBox3D(a, b);
}
void LandmarkRegistrationWidget::prePaintEvent()
{
mLandmarkTableWidget->blockSignals(true);
mLandmarkTableWidget->clear();
QString fixedName;
DataPtr fixedData = boost::dynamic_pointer_cast<Data>(mServices->registration()->getFixedData());
if (fixedData)
fixedName = fixedData->getName();
std::vector<Landmark> landmarks = this->getAllLandmarks();
LandmarkMap targetData = this->getTargetLandmarks();
Transform3D rMtarget = this->getTargetTransform();
//ready the table widget
mLandmarkTableWidget->setRowCount((int)landmarks.size());
mLandmarkTableWidget->setColumnCount(4);
QStringList headerItems(QStringList() << "Name" << "Status" << "Coordinates" << "Accuracy (mm)");
mLandmarkTableWidget->setHorizontalHeaderLabels(headerItems);
mLandmarkTableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
mLandmarkTableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
for (unsigned i = 0; i < landmarks.size(); ++i)
{
std::vector<QTableWidgetItem*> items(4); // name, status, coordinates, accuracy
LandmarkProperty prop = mServices->patient()->getLandmarkProperties()[landmarks[i].getUid()];
Vector3D coord = landmarks[i].getCoord();
coord = rMtarget.coord(coord); // display coordinates in space r (in principle, this means all coords should be equal)
items[0] = new QTableWidgetItem(qstring_cast(prop.getName()));
items[0]->setToolTip(QString("Landmark name. Double-click to rename."));
items[1] = new QTableWidgetItem;
if (prop.getActive())
items[1]->setCheckState(Qt::Checked);
else
items[1]->setCheckState(Qt::Unchecked);
items[1]->setToolTip(QString("Check to use landmark in current registration."));
QString coordText = "Not sampled";
if (targetData.count(prop.getUid()))
{
int width = 5;
int prec = 1;
coordText = tr("(%1, %2, %3)").arg(coord[0], width, 'f', prec).arg(coord[1], width, 'f', prec).arg(
coord[2], width, 'f', prec);
}
items[2] = new QTableWidgetItem(coordText);
items[2]->setToolTip(QString("Landmark coordinates of target [%1] in reference space.").arg(this->getTargetName()));
items[3] = new QTableWidgetItem(tr("%1").arg(this->getAccuracy(landmarks[i].getUid())));
items[3]->setToolTip(QString("Distance from target [%1] to fixed [%2].").arg(this->getTargetName()).arg(fixedName));
for (unsigned j = 0; j < items.size(); ++j)
{
items[j]->setData(Qt::UserRole, qstring_cast(prop.getUid()));
mLandmarkTableWidget->setItem(i, j, items[j]);
}
//highlight selected row
if (prop.getUid() == mActiveLandmark)
{
mLandmarkTableWidget->setCurrentItem(items[2]);
}
}
this->updateAverageAccuracyLabel();
mLandmarkTableWidget->blockSignals(false);
}