}
//------------------------------------------------------------------------------
vvSlicer::vvSlicer()
-{ //out << __func__ << endl;
+{
mFusionSequenceCode = -1;
this->UnInstallPipeline();
mImage = NULL;
//------------------------------------------------------------------------------
vtkImageMapToWindowLevelColors* vvSlicer::GetOverlayMapper()
-{ //out << __func__ << endl;
+{
return mOverlayMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvBlendImageActor* vvSlicer::GetOverlayActor()
-{ //out << __func__ << endl;
+{
return mOverlayActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageMapToColors* vvSlicer::GetFusionMapper()
-{ //out << __func__ << endl;
+{
return mFusionMapper.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkImageActor* vvSlicer::GetFusionActor()
-{ //out << __func__ << endl;
+{
return mFusionActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkActor* vvSlicer::GetVFActor()
-{ //out << __func__ << endl;
+{
return mVFActor.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vtkCornerAnnotation* vvSlicer::GetAnnotation()
-{ //out << __func__ << endl;
+{
return ca.GetPointer();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::EnableReducedExtent(bool b)
-{ //out << __func__ << endl;
+{
mUseReducedExtent = b;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetReducedExtent(int * ext)
-{ //out << __func__ << endl;
+{
copyExtent(ext, mReducedExtent);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::AddContour(vvMesh::Pointer contour,bool propagate)
-{ //out << __func__ << endl;
+{
mSurfaceCutActors.push_back(new vvMeshActor());
if (propagate)
//------------------------------------------------------------------------------
void vvSlicer::ToggleContourSuperposition()
-{ //out << __func__ << endl;
+{
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
(*i)->ToggleSuperposition();
//------------------------------------------------------------------------------
void vvSlicer::SetCursorColor(int r,int g, int b)
-{ //out << __func__ << endl;
+{
pdmA->GetProperty()->SetColor(r,g,b);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCursorVisibility(bool s)
-{ //out << __func__ << endl;
+{
pdmA->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCursorVisibility()
-{ //out << __func__ << endl;
+{
return pdmA->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCornerAnnotationVisibility(bool s)
-{ //out << __func__ << endl;
+{
ca->SetVisibility(s);
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
bool vvSlicer::GetCornerAnnotationVisibility()
-{ //out << __func__ << endl;
+{
return ca->GetVisibility();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
vvSlicer::~vvSlicer()
-{ //out << __func__ << endl;
+{
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
delete (*i);
//------------------------------------------------------------------------------
double* vvSlicer::GetCurrentPosition()
-{ //out << __func__ << endl;
+{
return mCurrentBeforeSlicingTransform;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetCurrentPosition(double x, double y, double z, int t)
-{ //out << __func__ << endl;
+{
mCurrentBeforeSlicingTransform[0]=x;
mCurrentBeforeSlicingTransform[1]=y;
mCurrentBeforeSlicingTransform[2]=z;
//------------------------------------------------------------------------------
void vvSlicer::SetImage(vvImage::Pointer image)
-{ //out << __func__ << endl;
+{
if (image->GetVTKImages().size()) {
mImage = image;
//------------------------------------------------------------------------------
void vvSlicer::SetOverlay(vvImage::Pointer overlay)
-{ //out << __func__ << endl;
+{
if (overlay->GetVTKImages().size()) {
mOverlay = overlay;
mOverlayVisibility = true;
//------------------------------------------------------------------------------
void vvSlicer::SetFusion(vvImage::Pointer fusion, int fusionSequenceCode)
-{ //out << __func__ << endl;
+{
mFusionSequenceCode = fusionSequenceCode;
if (fusion->GetVTKImages().size()) {
mFusion = fusion;
//------------------------------------------------------------------------------
bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
-{ //out << __func__ << endl;
+{
bool vis = false;
if (actor_type == "image")
vis = mImageVisibility;
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
-{ //out << __func__ << endl;
+{
if (actor_type == "image")
mImageVisibility = vis;
else if (actor_type == "vector")
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
-{ //out << __func__ << endl;
+{
if (vf->GetVTKImages().size()) {
mVF = vf;
mVFVisibility = true;
//------------------------------------------------------------------------------
void vvSlicer::SetLandmarks(vvLandmarks* landmarks)
-{ //out << __func__ << endl;
+{
mLandmarks = landmarks;
if (landmarks) {
//------------------------------------------------------------------------------
//FIXME: this function leaks memory, we should fix it someday :)
void vvSlicer::RemoveActor(const std::string& actor_type, int overlay_index)
-{ //out << __func__ << endl;
+{
if (actor_type == "vector") {
Renderer->RemoveActor(mVFActor);
mGlyphFilter=NULL;
//------------------------------------------------------------------------------
void vvSlicer::SetVFSubSampling(int sub)
-{ //out << __func__ << endl;
+{
if (mVOIFilter) {
mVOIFilter->SetSampleRate(mSubSampling,mSubSampling,mSubSampling);
mSubSampling = sub;
//------------------------------------------------------------------------------
void vvSlicer::SetVFScale(int scale)
-{ //out << __func__ << endl;
+{
mScale = scale;
if (mArrow)
mArrow->SetScale(mScale);
//------------------------------------------------------------------------------
void vvSlicer::SetVFWidth(int width)
-{ //out << __func__ << endl;
+{
mVFWidth = width;
if (mVFActor)
mVFActor->GetProperty()->SetLineWidth(mVFWidth);
//------------------------------------------------------------------------------
void vvSlicer::SetVFLog(int log)
-{ //out << __func__ << endl;
+{
mVFLog = log;
if (mGlyphFilter) {
mGlyphFilter->SetUseLog(mVFLog);
//------------------------------------------------------------------------------
void vvSlicer::SetTSlice(int t, bool updateLinkedImages)
-{ //out << __func__ << endl;
+{
if (!updateLinkedImages) {
mCurrentTSlice = t;
#if VTK_MAJOR_VERSION <= 5
//------------------------------------------------------------------------------
void vvSlicer::SetFusionSequenceTSlice(int t)
-{ //out << __func__ << endl;
+{
if (mFusion && mFusionActor->GetVisibility() && (mFusionSequenceCode>=0)) {
if (mFusion->GetVTKImages().size() > (unsigned int)t) {
mCurrentFusionTSlice = t;
//------------------------------------------------------------------------------
int vvSlicer::GetTSlice()
-{ //out << __func__ << endl;
+{
return mCurrentTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetMaxCurrentTSlice()
-{ //out << __func__ << endl;
+{
int t = mCurrentTSlice;
if(mOverlay)
t = std::max(t, mCurrentOverlayTSlice);
//------------------------------------------------------------------------------
int vvSlicer::GetFusionTSlice()
-{ //out << __func__ << endl;
+{
return mCurrentFusionTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int vvSlicer::GetOverlayTSlice()
-{ //out << __func__ << endl;
+{
return mCurrentOverlayTSlice;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void vvSlicer::SetSliceOrientation(int orientation)
-{ //out << __func__ << endl;
+{
//if 2D image, force to watch in Axial View
int extent[6];
#if VTK_MAJOR_VERSION <= 5
// In other words, we change the grid of the reslice in the same way as the grid
// of the displayed image in the slicing direction.
void vvSlicer::AdjustResliceToSliceOrientation(vtkImageReslice *reslice)
-{ //out << __func__ << endl;
+{
// Reset autocrop and update output information
reslice->SetOutputOriginToDefault();
reslice->SetOutputSpacingToDefault();
//----------------------------------------------------------------------------
int * vvSlicer::GetExtent()
-{ //out << __func__ << endl;
+{
int *w_ext;
if (mUseReducedExtent) {
w_ext = mReducedExtent;
//----------------------------------------------------------------------------
int vvSlicer::GetOrientation()
-{ //out << __func__ << endl;
+{
return this->SliceOrientation;
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::UpdateDisplayExtent()
-{ //out << __func__ << endl;
-
+{
vtkImageData *input = this->GetInput();
if (!input || !this->ImageActor) {
return;
if (mUseReducedExtent) {
copyExtent(mReducedExtent, w_ext);
}
-
+ cout << mUseReducedExtent<< " " << w_ext[0] << " " << w_ext[1] << " " << w_ext[2] << " " << w_ext[3] << " " << w_ext[4] << " " << w_ext[5] << endl;
// Set slice value
w_ext[ this->SliceOrientation*2 ] = this->Slice;
//----------------------------------------------------------------------------
void vvSlicer::ConvertImageToImageDisplayExtent(vtkInformation *sourceImage, const int sourceExtent[6],
vtkImageData *targetImage, int targetExtent[6])
-{ //out << __func__ << endl;
+{
double dExtents[6];
double *origin, *spacing;
origin = sourceImage->Get(vtkDataObject::ORIGIN());
//----------------------------------------------------------------------------
bool vvSlicer::ClipDisplayedExtent(int extent[6], int refExtent[6])
-{ //out << __func__ << endl;
+{
bool out = false;
int maxBound = 6;
//----------------------------------------------------------------------------
void vvSlicer::UpdateOrientation()
-{ //out << __func__ << endl;
+{
// Set the camera position
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
//----------------------------------------------------------------------------
void vvSlicer::SetOpacity(double s)
-{ //out << __func__ << endl;
+{
this->GetImageActor()->SetOpacity(s);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetRenderWindow(int orientation, vtkRenderWindow * rw)
-{ //out << __func__ << endl;
+{
this->Superclass::SetRenderWindow(rw);
this->SetupInteractor(rw->GetInteractor());
ca->SetImageActor(this->GetImageActor());
//----------------------------------------------------------------------------
void vvSlicer::ResetCamera()
-{ //out << __func__ << endl;
+{
this->GetRenderer()->ResetCamera();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
-{ //out << __func__ << endl;
+{
this->GetRenderer()->SetDraw(i);
if (i) UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
void vvSlicer::FlipHorizontalView()
-{ //out << __func__ << endl;
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
//----------------------------------------------------------------------------
void vvSlicer::FlipVerticalView()
-{ //out << __func__ << endl;
+{
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
FlipHorizontalView();
//----------------------------------------------------------------------------
void vvSlicer::SetColorWindow(double window)
-{ //out << __func__ << endl;
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double level = this->GetWindowLevel()->GetLevel();
//----------------------------------------------------------------------------
void vvSlicer::SetColorLevel(double level)
-{ //out << __func__ << endl;
+{
vtkLookupTable* LUT = static_cast<vtkLookupTable*>(this->GetWindowLevel()->GetLookupTable());
if ( LUT ) {
double window = this->GetWindowLevel()->GetWindow();
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorWindow()
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
return mOverlayMapper->GetWindow();
else
//----------------------------------------------------------------------------
double vvSlicer::GetOverlayColorLevel()
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
return mOverlayMapper->GetLevel();
else
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorWindow(double window)
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
mOverlayMapper->SetWindow(window);
}
//----------------------------------------------------------------------------
void vvSlicer::SetOverlayColorLevel(double level)
-{ //out << __func__ << endl;
+{
if(mOverlayMapper)
mOverlayMapper->SetLevel(level);
}
//----------------------------------------------------------------------------
// Returns the min an the max value in a 20%x20% region around the mouse pointer
void vvSlicer::GetExtremasAroundMousePointer(double & min, double & max, vtkImageData *image, vtkTransform *transform)
-{ //out << __func__ << endl;
+{
//Get mouse pointer position in view coordinates
double corner1[3];
double corner2[3];
//----------------------------------------------------------------------------
double vvSlicer::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int &ix, int &iy, int &iz, int component)
-{ //out << __func__ << endl;
+{
ix = lrint(X);
iy = lrint(Y);
iz = lrint(Z);
//----------------------------------------------------------------------------
void vvSlicer::Render()
-{ //out << __func__ << endl;
+{
if (this->mFusion && mFusionActor->GetVisibility() && showFusionLegend) {
legend->SetLookupTable(this->GetFusionMapper()->GetLookupTable());
legend->UseOpacityOn();
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
-{ //out << __func__ << endl;
+{
pdmA->SetVisibility(true);
mCursor[0] = mCurrent[0];
mCursor[1] = mCurrent[1];
//----------------------------------------------------------------------------
void vvSlicer::UpdateLandmarks()
-{ //out << __func__ << endl;
+{
vtkPolyData *pd = static_cast<vtkPolyData*>(mLandClipper->GetInput());
if (pd->GetPoints()) {
//mLandGlyph->SetRange(0,1);
//----------------------------------------------------------------------------
void vvSlicer::SetSlice(int slice)
-{ //out << __func__ << endl;
+{
int *range = this->GetSliceRange();
if (range) {
if (slice < range[0]) {
//----------------------------------------------------------------------------
int vvSlicer::GetTMax()
-{ //out << __func__ << endl;
+{
int tmax = (int)mImage->GetVTKImages().size() - 1;
if(mOverlay)
tmax = std::max(tmax, (int)mOverlay->GetVTKImages().size()-1);
//----------------------------------------------------------------------------
void vvSlicer::SetContourSlice()
-{ //out << __func__ << endl;
+{
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++) {
//----------------------------------------------------------------------------
void vvSlicer::ForceUpdateDisplayExtent()
-{ //out << __func__ << endl;
+{
this->UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
int* vvSlicer::GetDisplayExtent()
-{ //out << __func__ << endl;
+{
return this->GetImageActor()->GetDisplayExtent();
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::PrintSelf(ostream& os, vtkIndent indent)
-{ //out << __func__ << endl;
+{
this->Superclass::PrintSelf(os, indent);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetVFColor(double r, double g, double b)
-{ //out << __func__ << endl;
+{
double mVFColorHSV[3];
mVFColor[0] = r;
mVFColor[1] = g;
//----------------------------------------------------------------------------
void vvSlicer::SetRegisterExtent(int ext[6])
-{ //out << __func__ << endl;
+{
copyExtent(ext, mRegisterExtent);
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::GetRegisterExtent(int ext[6])
-{ //out << __func__ << endl;
+{
copyExtent(mRegisterExtent, ext);
}
//----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff