vtkCxxRevisionMacro(vvSlicer, "DummyRevision");
vtkStandardNewMacro(vvSlicer);
-
+static void copyExtent(int* in, int* to){
+ for(int i=0; i<6; ++i) to[i]=in[i];
+}
//------------------------------------------------------------------------------
vvSlicer::vvSlicer()
{
this->UnInstallPipeline();
mImage = NULL;
+ mReducedExtent = new int[6];
mCurrentTSlice = 0;
mUseReducedExtent = false;
//------------------------------------------------------------------------------
void vvSlicer::SetReducedExtent(int * ext)
{
- mReducedExtent = ext;
+ copyExtent(ext, mReducedExtent);
}
//------------------------------------------------------------------------------
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
i!=mSurfaceCutActors.end(); i++)
delete (*i);
+ delete [] mReducedExtent;
}
//------------------------------------------------------------------------------
// Prevent crash when reload -> change slice if outside extent
if (Slice < extent[SliceOrientation*2] || Slice>=extent[SliceOrientation*2+1]) {
- Slice = (extent[SliceOrientation*2+1]-extent[SliceOrientation*2])/2.0;
+ Slice = (extent[SliceOrientation*2+1]+extent[SliceOrientation*2])/2.0;
}
// Make sure that the required part image has been computed
mOverlayActor = vtkSmartPointer<vvBlendImageActor>::New();
mOverlayActor->SetInput(mOverlayMapper->GetOutput());
mOverlayActor->SetPickable(0);
- mOverlayActor->SetVisibility(false);
+ mOverlayActor->SetVisibility(true);
mOverlayActor->SetOpacity(0.5);
}
mFusionActor = vtkSmartPointer<vtkImageActor>::New();
mFusionActor->SetInput(mFusionMapper->GetOutput());
mFusionActor->SetPickable(0);
- mFusionActor->SetVisibility(false);
+ mFusionActor->SetVisibility(true);
mFusionActor->SetOpacity(0.7);
this->GetRenderer()->AddActor(mFusionActor);
}
//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+bool vvSlicer::GetActorVisibility(const std::string& actor_type, int overlay_index)
+{
+ bool vis = false;
+ if (actor_type == "image") {
+ vis = this->ImageActor->GetVisibility();
+ }
+ else if (actor_type == "vector") {
+ vis = this->mVFActor->GetVisibility();
+ }
+ else if (actor_type == "overlay") {
+ vis = this->mOverlayActor->GetVisibility();
+ }
+ else if (actor_type == "fusion") {
+ vis = this->mFusionActor->GetVisibility();
+ }
+ else if (actor_type == "contour")
+ vis = this->mSurfaceCutActors[overlay_index]->GetActor()->GetVisibility();
+
+ return vis;
+}
+//------------------------------------------------------------------------------
+
//------------------------------------------------------------------------------
void vvSlicer::SetActorVisibility(const std::string& actor_type, int overlay_index ,bool vis)
{
- if (actor_type == "vector") {
+ if (actor_type == "image") {
+ this->ImageActor->SetVisibility(vis);
+ }
+ else if (actor_type == "vector") {
this->mVFActor->SetVisibility(vis);
}
- if (actor_type == "overlay") {
+ else if (actor_type == "overlay") {
this->mOverlayActor->SetVisibility(vis);
}
- if (actor_type == "fusion") {
+ else if (actor_type == "fusion") {
this->mFusionActor->SetVisibility(vis);
}
- if (actor_type == "contour")
+ else if (actor_type == "contour")
this->mSurfaceCutActors[overlay_index]->GetActor()->SetVisibility(vis);
UpdateDisplayExtent();
}
//------------------------------------------------------------------------------
-
//------------------------------------------------------------------------------
void vvSlicer::SetVF(vvImage::Pointer vf)
{
//------------------------------------------------------------------------------
//----------------------------------------------------------------------------
-int * vvSlicer::GetExtent()
-{
+int * vvSlicer::GetExtent(){
int *w_ext;
if (mUseReducedExtent) {
w_ext = mReducedExtent;
}
//----------------------------------------------------------------------------
+
//----------------------------------------------------------------------------
void vvSlicer::UpdateDisplayExtent()
{
// Local copy of extent
int w_ext[6];
- for(unsigned int i=0; i<6; i++){
- if (mUseReducedExtent)
- w_ext[i] = mReducedExtent[i];
- else
- w_ext[i] = input->GetWholeExtent()[i];
- }
-
+ copyExtent(GetExtent(), w_ext);
// Set slice value
w_ext[ this->SliceOrientation*2 ] = this->Slice;
w_ext[ this->SliceOrientation*2+1 ] = this->Slice;
// Image actor
this->ImageActor->SetDisplayExtent(w_ext);
- // Position vector
- double position[3] = {0.,0.,0.};
- double positionInc = (Renderer->GetActiveCamera()->GetPosition()[this->SliceOrientation] > this->Slice)?10:-10;
- position[this->SliceOrientation] += positionInc;
-
// Overlay image actor
if (mOverlay && mOverlayActor->GetVisibility()) {
int overExtent[6];
this->ConvertImageToImageDisplayExtent(input, w_ext, mOverlayReslice->GetOutput(), overExtent);
ClipDisplayedExtent(overExtent, mOverlayMapper->GetInput()->GetWholeExtent());
mOverlayActor->SetDisplayExtent( overExtent );
- mOverlayActor->SetPosition(position);
}
- position[this->SliceOrientation] += positionInc;
// Fusion image actor
if (mFusion && mFusionActor->GetVisibility()) {
this->ConvertImageToImageDisplayExtent(input, w_ext, mFusionReslice->GetOutput(), fusExtent);
ClipDisplayedExtent(fusExtent, mFusionMapper->GetInput()->GetWholeExtent());
mFusionActor->SetDisplayExtent(fusExtent);
- mFusionActor->SetPosition(position);
}
- position[this->SliceOrientation] += positionInc;
// Vector field actor
+ double* camera = Renderer->GetActiveCamera()->GetPosition();
+ double* image_bounds = ImageActor->GetBounds();
+ double position[3] = {0, 0, 0};
+ position[this->SliceOrientation] = image_bounds[this->SliceOrientation*2];
+
+ //print_vector<double, 6>("camera", camera);
+ //print_vector<double, 6>("image_bounds", image_bounds);
+ //print_vector<double, 3>("position", position);
+
+ // find where to place the VF actor. to deal with
+ // z-buffer issues, the VF is placed right in front of the image,
+ // subject to a small offset. the position actually depends on the
+ // the location of the camera relative to the image.
+ double offset = 1;
+ if (camera[this->SliceOrientation] < image_bounds[this->SliceOrientation*2])
+ offset = -1;
+
if (mVF && mVFActor->GetVisibility()) {
int vfExtent[6];
mVF->GetVTKImages()[0]->UpdateInformation();
orientation[this->SliceOrientation] = 0;
mGlyphFilter->SetOrientation(orientation[0], orientation[1], orientation[2]);
mVFMapper->Update();
+
+ position[this->SliceOrientation] += offset;
mVFActor->SetPosition(position);
}
- position[this->SliceOrientation] += positionInc;
-
+
// Landmarks actor
if (mLandActor) {
if (mClipBox) {
double bounds [6];
for(unsigned int i=0; i<6; i++)
bounds[i] = ImageActor->GetBounds()[i];
- bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(0.5/this->GetInput()->GetSpacing()[this->SliceOrientation]);
- bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(0.5/this->GetInput()->GetSpacing()[this->SliceOrientation]);
+ bounds[ this->SliceOrientation*2 ] = ImageActor->GetBounds()[ this->SliceOrientation*2 ]-fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
+ bounds[ this->SliceOrientation*2+1 ] = ImageActor->GetBounds()[ this->SliceOrientation*2+1 ]+fabs(this->GetInput()->GetSpacing()[this->SliceOrientation]);
mClipBox->SetBounds(bounds);
UpdateLandmarks();
}
+
+ position[this->SliceOrientation] = offset;
mLandActor->SetPosition(position);
}
}
}
}
+
}
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
void vvSlicer::SetDisplayMode(bool i)
{
- this->GetImageActor()->SetVisibility(i);
- this->GetAnnotation()->SetVisibility(i);
this->GetRenderer()->SetDraw(i);
- if (mLandActor)
- mLandActor->SetVisibility(i);
- pdmA->SetVisibility(i);
if (i)
UpdateDisplayExtent();
}
vtkCamera *cam = this->Renderer ? this->Renderer->GetActiveCamera() : NULL;
if (cam) {
double *position = cam->GetPosition();
- switch (this->SliceOrientation) {
+ double factor[3] = {1, 1, 1};
+ factor[this->SliceOrientation] = -1;
+ cam->SetPosition(factor[0]*position[0],factor[1]*position[1],factor[2]*position[2]);
+
+/* switch (this->SliceOrientation) {
case vtkImageViewer2::SLICE_ORIENTATION_XY:
cam->SetPosition(position[0],position[1],-position[2]);
break;
case vtkImageViewer2::SLICE_ORIENTATION_YZ:
cam->SetPosition(-position[0],position[1],position[2]);
break;
- }
+ }*/
+
this->Renderer->ResetCameraClippingRange();
this->UpdateDisplayExtent();
}
//----------------------------------------------------------------------------
void vvSlicer::UpdateCursorPosition()
{
- if (this->GetImageActor()->GetVisibility()) {
- pdmA->SetVisibility(true);
- mCursor[0] = mCurrent[0];
- mCursor[1] = mCurrent[1];
- mCursor[2] = mCurrent[2];
- mCursor[3] = mCurrentTSlice;
- }
+ pdmA->SetVisibility(true);
+ mCursor[0] = mCurrent[0];
+ mCursor[1] = mCurrent[1];
+ mCursor[2] = mCurrent[2];
+ mCursor[3] = mCurrentTSlice;
}
//----------------------------------------------------------------------------
{
if (mSurfaceCutActors.size() > 0)
for (std::vector<vvMeshActor*>::iterator i=mSurfaceCutActors.begin();
- i!=mSurfaceCutActors.end(); i++)
+ i!=mSurfaceCutActors.end(); i++) {
+
+ (*i)->SetSlicingOrientation(this->SliceOrientation);
(*i)->SetCutSlice((this->Slice)*this->GetImage()->GetSpacing()[this->SliceOrientation]+
this->GetImage()->GetOrigin()[this->SliceOrientation]);
+ }
}
//----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / clitk.git / blobdiff