PlaybackTool::PlaybackTool(ToolPtr base, PlaybackTimePtr time) :
ToolImpl(base->getUid(), "playback "+base->getName()), mBase(base),
mTime(time),
mVisible(false)
{
connect(mTime.get(), SIGNAL(changed()), this, SLOT(timeChangedSlot()));
connect(mBase.get(), SIGNAL(toolProbeSector()), this, SIGNAL(toolProbeSector()));
connect(mBase.get(), SIGNAL(tooltipOffset(double)), this, SIGNAL(tooltipOffset(double)));
}
/**Create and return the structure that would have been read by UsReconstructFileReader,
* if written from this object.
*
*/
USReconstructInputData UsReconstructionFileMaker::getReconstructData(ImageDataContainerPtr imageData,
std::vector<TimeInfo> imageTimestamps,
TimedTransformMap trackerRecordedData,
std::map<double, ToolPositionMetadata> trackerRecordedMetadata,
std::map<double, ToolPositionMetadata> referenceRecordedMetadata,
ToolPtr tool, QString streamUid,
bool writeColor, Transform3D rMpr)
{
if(trackerRecordedData.empty())
reportWarning("No tracking data for writing to reconstruction file.");
USReconstructInputData retval;
retval.mFilename = mSessionDescription; // not saved yet - no filename
retval.mUsRaw = USFrameData::create(mSessionDescription, imageData);
retval.rMpr = rMpr;
retval.mTrackerRecordedMetadata = trackerRecordedMetadata;
retval.mReferenceRecordedMetadata = referenceRecordedMetadata;
for (TimedTransformMap::iterator it = trackerRecordedData.begin(); it != trackerRecordedData.end(); ++it)
{
TimedPosition current;
current.mTime = it->first;
current.mTimeInfo.setAcquisitionTime(it->first);
current.mPos = it->second;
retval.mPositions.push_back(current);
}
std::vector<TimeInfo> fts = imageTimestamps;
for (unsigned i=0; i<fts.size(); ++i)
{
TimedPosition current;
current.mTimeInfo = fts[i];
current.mTime = current.mTimeInfo.getAcquisitionTime();
current.mPos = Transform3D::Identity();
// current.mPos = not written - will be found from track positions during reconstruction.
retval.mFrames.push_back(current);
}
if (tool && tool->getProbe())
{
retval.mProbeDefinition.setData(tool->getProbe()->getProbeDefinition(streamUid));
}
if (tool)
retval.mProbeUid = tool->getUid();
this->fillFramePositions(&retval);
return retval;
}
void ViewWrapper3D::toolsAvailableSlot()
{
std::vector<ToolRep3DPtr> reps = RepContainer::findReps<ToolRep3D>(mView->getReps());
TrackingService::ToolMap tools = mServices->tracking()->getTools();
TrackingService::ToolMap::iterator iter;
for (iter = tools.begin(); iter != tools.end(); ++iter)
{
ToolPtr tool = iter->second;
if (tool->hasType(Tool::TOOL_REFERENCE))
continue;
ToolRep3DPtr toolRep = RepContainer(mView->getReps()).findFirst<ToolRep3D>(tool);
std::vector<ToolRep3DPtr>::iterator oldRep = std::find(reps.begin(), reps.end(), toolRep);
if (oldRep!=reps.end())
reps.erase(oldRep);
if (tool->hasType(Tool::TOOL_MANUAL) && !settings()->value("showManualTool").toBool())
{
if (toolRep)
mView->removeRep(toolRep);
continue;
}
// mManualTool->setVisible(settings()->value("showManualTool").toBool());
if (!toolRep)
{
toolRep = ToolRep3D::New(mServices->spaceProvider(), tool->getUid() + "_rep3d_" + this->mView->getUid());
if (settings()->value("showToolPath").toBool())
toolRep->getTracer()->start();
}
toolRep->setSphereRadius(settings()->value("View3D/sphereRadius").toDouble()); // use fraction of set size
toolRep->setSphereRadiusInNormalizedViewport(true);
toolRep->setTool(tool);
toolRep->setOffsetPointVisibleAtZeroOffset(true);
mView->addRep(toolRep);
}
// remove reps for tools no longer present
for (unsigned i=0; i<reps.size(); ++i)
{
mView->removeRep(reps[i]);
}
}
TreeNodePtr ToolTreeNode::getParent() const
{
if (this->repo()->getMode()=="flat")
return this->repo()->getNodeForGroup("tool");
if (mTool->getUid() == this->getServices()->tracking()->getManualTool()->getUid())
return this->repo()->getNode(CoordinateSystem(csPATIENTREF).toString());
if (mTool->hasType(Tool::TOOL_REFERENCE))
return this->repo()->getNode(CoordinateSystem(csPATIENTREF).toString());
ToolPtr ref = this->getServices()->tracking()->getReferenceTool();
if (ref)
return this->repo()->getNode(ref->getUid());
return this->repo()->getNode(CoordinateSystem(csPATIENTREF).toString());
}
void ViewWrapper3D::showRefToolSlot(bool checked)
{
ToolPtr refTool = mServices->tracking()->getReferenceTool();
if (!refTool)
return;
ToolRep3DPtr refRep = RepContainer(mView->getReps()).findFirst<ToolRep3D>(refTool);
if (!refRep)
{
refRep = ToolRep3D::New(mServices->spaceProvider(), refTool->getUid() + "_rep3d_" + this->mView->getUid());
refRep->setTool(refTool);
}
if (checked) //should show
mView->addRep(refRep);
else
//should not show
mView->removeRep(refRep);
}
void PatientModelImplService::videoSourceAdded(VideoSourcePtr source)
{
ToolPtr tool = this->getProbeTool(source->getUid());
if(!tool)
return;
QString uid = source->getUid() + tool->getUid();
QString name = source->getName() + " - " + tool->getName();
TrackedStreamPtr trackedStream = this->dataService()->getTrackedStream(uid);
if (!trackedStream)
trackedStream = this->createSpecificData<TrackedStream>(uid, name);
trackedStream->setProbeTool(tool);
trackedStream->setVideoSource(source);
trackedStream->setSpaceProvider(mDataService->getSpaceProvider());
//Only load trackedStream, don't save it
this->dataService()->loadData(trackedStream);
emit videoAddedToTrackedStream();
this->reEmitActiveTrackedStream(trackedStream);
}
void TreeRepository::insertToolNode(ToolPtr tool)
{
if (this->getNode(tool->getUid()))
return;
this->appendNode(new ToolTreeNode(mSelf, tool));
}
void ViewWrapper3D::showAxesActionSlot(bool checked)
{
if (mShowAxes == checked)
return;
mShowAxes = checked;
// clear all
for (unsigned i=0; i<mAxis.size(); ++i)
mView->removeRep(mAxis[i]->mRep);
mAxis.clear();
// show all
if (mShowAxes)
{
AxisConnectorPtr axis;
// reference space
axis.reset(new AxisConnector(CoordinateSystem(csREF), mServices->spaceProvider()));
axis->mRep->setAxisLength(0.12);
axis->mRep->setShowAxesLabels(true);
axis->mRep->setCaption("ref", Vector3D(1, 0, 0));
axis->mRep->setFontSize(0.03);
mAxis.push_back(axis);
// data spaces
std::vector<DataPtr> data = mGroupData->getData();
for (unsigned i = 0; i < data.size(); ++i)
{
axis.reset(new AxisConnector(CoordinateSystem(csDATA, data[i]->getUid()), mServices->spaceProvider()));
axis->mRep->setAxisLength(0.08);
axis->mRep->setShowAxesLabels(false);
axis->mRep->setCaption(data[i]->getName(), Vector3D(1, 0, 0));
axis->mRep->setFontSize(0.03);
mAxis.push_back(axis);
}
// tool spaces
TrackingService::ToolMap tools = mServices->tracking()->getTools();
TrackingService::ToolMap::iterator iter;
for (iter = tools.begin(); iter != tools.end(); ++iter)
{
ToolPtr tool = iter->second;
axis.reset(new AxisConnector(CoordinateSystem(csTOOL, tool->getUid()), mServices->spaceProvider()));
axis->mRep->setAxisLength(0.08);
axis->mRep->setShowAxesLabels(false);
axis->mRep->setCaption("t", Vector3D(0.7, 1, 0.7));
axis->mRep->setFontSize(0.03);
axis->connectTo(tool);
SpaceListenerPtr mToolListener = axis->mListener;
mAxis.push_back(axis);
axis.reset(new AxisConnector(CoordinateSystem(csSENSOR, tool->getUid()), mServices->spaceProvider()));
axis->mRep->setAxisLength(0.05);
axis->mRep->setShowAxesLabels(false);
axis->mRep->setCaption("s", Vector3D(1, 1, 0));
axis->mRep->setFontSize(0.03);
axis->connectTo(tool);
axis->mergeWith(mToolListener);
mAxis.push_back(axis);
}
for (unsigned i=0; i<mAxis.size(); ++i)
mView->addRep(mAxis[i]->mRep);
}
}
