/**Do the following operations on mBaseVtkImageData:
* * Reset the origin to zero.
* * Reset the extent to have its lower-left corner in zero.
* The shift introduced by these two operations are inserted
* as a translation into the matrix rMd.
*
* This operation is needed because Image dont support vtkImageData
* with a nonzero origin or nonzero extent. These must be removed during creation.
*
* Use this method only when you, by using some vtk algorithm, have created a vtkImageData
* that in nonconform with the Image spec.
*/
void Image::mergevtkSettingsIntosscTransform()
{
// the internal CustusX format does not handle extents starting at non-zero.
// Move extent to zero and change rMd.
Vector3D origin(mBaseImageData->GetOrigin());
Vector3D spacing(mBaseImageData->GetSpacing());
IntBoundingBox3D extent(mBaseImageData->GetExtent());
Vector3D extentShift = multiply_elems(extent.corner(0, 0, 0).cast<double>(), spacing);
vtkImageChangeInformationPtr info = vtkImageChangeInformationPtr::New();
info->SetInputData(mBaseImageData);
info->SetOutputExtentStart(0, 0, 0);
info->SetOutputOrigin(0, 0, 0);
info->Update();
info->UpdateInformation();
mBaseImageData = info->GetOutput();
mBaseImageData->ComputeBounds();
// mBaseImageData->Update();
// mBaseImageData->UpdateInformation();
this->get_rMd_History()->setRegistration(this->get_rMd() * createTransformTranslate(origin + extentShift));
emit vtkImageDataChanged();
emit clipPlanesChanged();
emit cropBoxChanged();
}
void PickerRep::setGlyphCenter(Vector3D pos)
{
if (mGlyph)
{
mGlyph->get_rMd_History()->setRegistration(createTransformTranslate(pos));
}
}
/**Move the tool pos / axis pos to a new position given
* by the input click position in vp space.
*/
void ViewWrapper2D::setAxisPos(Vector3D click_vp)
{
ToolPtr tool = mServices->getToolManager()->getManualTool();
Transform3D sMr = mSliceProxy->get_sMr();
Transform3D rMpr = mServices->getPatientService()->get_rMpr();
Transform3D prMt = tool->get_prMt();
// find tool position in s
Vector3D tool_t(0, 0, tool->getTooltipOffset());
Vector3D tool_s = (sMr * rMpr * prMt).coord(tool_t);
// find click position in s.
Transform3D vpMs = mView->get_vpMs();
Vector3D click_s = vpMs.inv().coord(click_vp);
// compute the new tool position in slice space as a synthesis of the plane part of click and the z part of original.
Vector3D cross_s(click_s[0], click_s[1], tool_s[2]);
// compute the position change and transform to patient.
Vector3D delta_s = cross_s - tool_s;
Vector3D delta_pr = (rMpr.inv() * sMr.inv()).vector(delta_s);
// MD is the actual tool movement in patient space, matrix form
Transform3D MD = createTransformTranslate(delta_pr);
// set new tool position to old modified by MD:
tool->set_prMt(MD * prMt);
}
QSize sizeHint() const
{
Transform3D M = createTransformRotateX(M_PI_4) *
createTransformRotateZ(M_PI_4) *
createTransformTranslate(Vector3D(1,2,M_PI));
QString text = qstring_cast(M).split("\n")[0];
QRect rect = QFontMetrics(this->font()).boundingRect(text);
QSize s(rect.width()*1.0+5, 4*rect.height()*1.2+5);
return s;
}
/**
* Based on a position+direction, view up and scale,
* calculate an orientation matrix combining these.
*/
Transform3D CustomMetric::calculateOrientation(Vector3D pos, Vector3D dir, Vector3D vup, Vector3D scale) const
{
Transform3D R = this->calculateRotation(dir, vup);
Transform3D center2DImage = this->calculateTransformTo2DImageCenter();
Transform3D S = createTransformScale(scale);
Transform3D T = createTransformTranslate(pos);
Transform3D M = T*R*S*center2DImage;
return M;
}
/**Normalize volume defined by in to volume defined by out.
*
* This is intended for creating transforms from one viewport to another, i.e.
* the two boxes should be aligned and differ only in translation + scaling.
*/
Transform3D createTransformNormalize(const DoubleBoundingBox3D& in, const DoubleBoundingBox3D& out)
{
// translate input bottomleft to origin, scale, translate back to output bottomleft.
Transform3D T0 = createTransformTranslate(-in.bottomLeft());
Vector3D inrange = in.range();
Vector3D outrange = out.range();
Vector3D scale;
// check for zero input dimensions
for (unsigned i = 0; i < scale.size(); ++i)
{
if (fabs(inrange[i]) < 1.0E-5)
scale[i] = 0;
else
scale[i] = outrange[i] / inrange[i];
}
Transform3D S = createTransformScale(scale);
Transform3D T1 = createTransformTranslate(out.bottomLeft());
Transform3D M = T1 * S * T0;
return M;
}
Transform3D ToolTipCalibrationCalculator::get_sMt_new()
{
Transform3D sMt_old = mTool->getCalibration_sMt();
CoordinateSystem csT = mSpaces->getT(mTool); //to
CoordinateSystem csRef = mSpaces->getT(mRef); //from
Transform3D tMref = mSpaces->get_toMfrom(csRef, csT);
Vector3D delta_t = tMref.vector(this->get_delta_ref());
Transform3D T_delta_t = createTransformTranslate(delta_t);
return sMt_old * T_delta_t;
}
Transform3D TrackedStream::get_tMu()
{
//Made tMu by copying and modifying code from ProbeSector::get_tMu()
ProbeDefinition probeDefinition = mProbeTool->getProbe()->getProbeData();
Vector3D origin_p = probeDefinition.getOrigin_p();
Vector3D spacing = probeDefinition.getSpacing();
Vector3D origin_u(origin_p[0]*spacing[0], origin_p[1]*spacing[1], origin_p[2]*spacing[2]);
Transform3D Rx = createTransformRotateX(M_PI / 2.0);
Transform3D Ry = createTransformRotateY(-M_PI / 2.0);
Transform3D R = (Rx * Ry);
Transform3D T = createTransformTranslate(-origin_u);
Transform3D tMu = R * T;
return tMu;
}
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());
}
Transform3D CustomMetric::calculateTransformTo2DImageCenter() const
{
Transform3D position2DImage = Transform3D::Identity();
if(this->modelIsImage())
{
DataPtr model = this->getModel();
ImagePtr imageModel = boost::dynamic_pointer_cast<Image>(model);
vtkImageDataPtr vtkImage = imageModel->getBaseVtkImageData();
int xSize = vtkImage->GetExtent()[1] - vtkImage->GetExtent()[0];
int ySize = vtkImage->GetExtent()[3] - vtkImage->GetExtent()[2];
Eigen::Array3d spacing(vtkImage->GetSpacing());
position2DImage = createTransformTranslate(Vector3D(-xSize*spacing[0]/2.0, -ySize*spacing[1]/2.0, 0));
}
return position2DImage;
}
/**Move the tool pos / axis pos to a new position given
* by delta movement in vp space.
*/
void ViewWrapper2D::shiftAxisPos(Vector3D delta_vp)
{
delta_vp = -delta_vp;
ToolPtr tool = mServices->getToolManager()->getManualTool();
Transform3D sMr = mSliceProxy->get_sMr();
Transform3D rMpr = mServices->getPatientService()->get_rMpr();
Transform3D prMt = tool->get_prMt();
Transform3D vpMs = mView->get_vpMs();
Vector3D delta_s = vpMs.inv().vector(delta_vp);
Vector3D delta_pr = (rMpr.inv() * sMr.inv()).vector(delta_s);
// MD is the actual tool movement in patient space, matrix form
Transform3D MD = createTransformTranslate(delta_pr);
// set new tool position to old modified by MD:
tool->set_prMt(MD * prMt);
}
std::vector<Transform3D> CustomMetric::calculateOrientations() const
{
std::vector<Vector3D> pos = this->getPositions();
Vector3D dir = this->getDirection();
Vector3D vup = this->getVectorUp();
Vector3D scale = this->getScale();
std::vector<Transform3D> retval(pos.size());
for (unsigned i=0; i<retval.size(); ++i)
{
if (mTranslationOnly)
{
retval[i] = createTransformTranslate(pos[i]);
}
else
{
retval[i] = this->calculateOrientation(pos[i], dir, vup, scale);
}
}
return retval;
}
/**Provide a nice default transform for displays without a tool.
*/
Transform3D SliceProxy::getSyntheticToolPos(const Vector3D& center) const
{
Transform3D R_tq = createTransformRotateY(M_PI) * createTransformRotateZ(M_PI_2);
Transform3D T_c = createTransformTranslate(center);
return T_c * R_tq;
}
Transform3D Frame3D::transform() const
{
return createTransformTranslate(mPos) * mAngleAxis;
}
Transform3D DecomposedTransform3D::getMatrix() const
{
return createTransformTranslate(mPos) * m_R;
}
