+/*=========================================================================
+
+ Program: wxMaracas
+ Module: $RCSfile: wxMPRWidget.cxx,v $
+ Language: C++
+ Date: $Date: 2008/10/31 16:32:42 $
+ Version: $Revision: 1.1 $
+
+ Copyright: (c) 2002, 2003
+ License:
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notice for more information.
+
+=========================================================================*/
+
+
+#include <vtkObjectFactory.h>
+#include <vtkInteractorStyleSwitch.h>
+#include <vtkCamera.h>
+#include <vtkImageActor.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkRenderWindow.h>
+
+#include <vtkRenderer.h>
+#include <vtkImageViewer2.h>
+#include <vtkInteractorStyleImage.h>
+
+#include <vtkProperty.h>
+#include <vtkPolyData.h>
+#include <vtkDataSet.h>
+#include <vtkStripper.h>
+#include <vtkCellArray.h>
+#include <vtkPointData.h>
+#include <vtkInteractorStyleTrackballCamera.h>
+
+#include <vtkPlanes.h>
+#include <vtkProbeFilter.h>
+#include <vtkPlane.h>
+#include <vtkPointPicker.h>
+
+
+#include "vtkClosePolyData.h"
+#include <vtkTriangleFilter.h>
+#include <vtkSTLWriter.h>
+#include <vtkPolyDataConnectivityFilter.h>
+
+// EED 25 Janvier 2007 - TestLoic
+#include <vtkCutter.h>
+#include <vtkWindowLevelLookupTable.h>
+#include <vtkLookupTable.h>
+#include <vtkMetaImageWriter.h>
+
+
+
+#include "wxMPRWidget.h"
+#include "wxVTKRenderWindowInteractor.h"
+#include "UtilVtk3DGeometriSelection.h"
+#include "../kernel/marDicomBase.h"
+
+
+#include <wx/wx.h>
+#include <wx/notebook.h>
+#include <wx/colordlg.h>
+
+#include "matrix.h"
+#include <string>
+
+
+#include "pPlotter/HistogramDialog.h"
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+idAlBeRa::idAlBeRa(int id, double radio,int deltavoxel)
+{
+ _id = id;
+ _radio = radio;
+ _deltavoxel = deltavoxel;
+}
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+vtkInteractorStyleSphere::vtkInteractorStyleSphere()
+{
+ _stateRadio = false;
+ _stateRotate = false;
+}
+
+//---------------------------------------------------------------------------
+
+vtkInteractorStyleSphere::~vtkInteractorStyleSphere()
+{
+}
+
+
+//---------------------------------------------------------------------------
+
+bool vtkInteractorStyleSphere::OnRightButtonDown()
+{
+ if ((_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==0) && (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==0) )
+ {
+ _stateRadio = true;
+ //_fordwareX = this->Interactor->GetEventPosition()[0];
+ _fordwareY = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+
+ wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+
+ _radio = wxsphereview->GetRadio();
+ }
+
+ return true;
+}
+
+//---------------------------------------------------------------------------
+
+bool vtkInteractorStyleSphere::OnRightButtonUp()
+{
+ if (_stateRadio==true)
+ {
+ wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ wxsphereview->SetDeltaVoxel(1);
+ double radio=wxsphereview->GetRadio();
+ wxsphereview->GetIdOfImage(radio+0.1);
+ wxsphereview->GetIdOfImage(radio+0.2);
+ wxsphereview->GetIdOfImage(radio-0.1);
+ wxsphereview->GetIdOfImage(radio-0.2);
+
+ wxsphereview->RefreshView();
+ _stateRadio = false;
+ }
+
+ return true;
+}
+//---------------------------------------------------------------------------
+
+bool vtkInteractorStyleSphere::OnLeftButtonDown()
+{
+ _stateRotate = true;
+ _fordwareX = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ _fordwareY = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ return true;
+}
+
+
+//---------------------------------------------------------------------------
+
+bool vtkInteractorStyleSphere::OnLeftButtonUp()
+{
+ wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ if (_stateRotate==true){
+ int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+
+ if ((_fordwareX==fx)&&(_fordwareY==fy)){
+ double x=fx,y=fy,z=1;
+ _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
+ wxsphereview->SetXYZtoParent(x,y);
+ wxCommandEvent newevent(wxEVT_COMMAND_MENU_SELECTED,12121);
+ wxsphereview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent);
+ } else {
+ wxsphereview->RotationEnd();
+ }
+ wxsphereview->RefreshView();
+ _stateRotate = false;
+ }
+
+ return true;
+}
+
+
+//---------------------------------------------------------------------------
+
+bool vtkInteractorStyleSphere::OnMouseMove ()
+{
+ wxSphereView *wxsphereview = (wxSphereView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ if (_stateRotate==true)
+ {
+ bool ok_v, ok_ang;
+ ok_v=false;
+ ok_ang=false;
+ if (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==1)
+ {
+ ok_v = true;
+ }
+ if (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==1)
+ {
+ ok_ang = true;
+ }
+ int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ wxsphereview->RotationStart( fx - _fordwareX , -(fy - _fordwareY) , ok_v, ok_ang);
+ wxsphereview->RefreshView();
+ }
+ if (_stateRadio==true)
+ {
+ //int fx = this->Interactor->GetEventPosition()[0];
+ int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ double dif=(fy-_fordwareY) / 10.0;
+ wxsphereview->SetRadio( _radio + dif );
+ wxsphereview->SetDeltaVoxel(3);
+ wxsphereview->RefreshView();
+ }
+
+ return true;
+}
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxSphereView::wxSphereView( wxWindow *parent, vtkMPRBaseData *vtkmprbasedata, vtkImageData *imageData )
+: wxVtk2DBaseView(parent)
+{
+ _delta = 1;
+ _vtkmprbasedata = vtkmprbasedata;
+ _imageDataOriginal = imageData;
+
+ _imageSphere = vtkImageData::New();
+ _imageSphere->SetDimensions (150,150,500);
+ _imageSphere->SetScalarTypeToUnsignedShort();
+ _imageSphere->AllocateScalars();
+ _imageSphere->Update();
+
+
+ vtkBaseData *vtkbasedata = new vtkBaseData();
+ vtkbasedata->SetMarImageData( new marImageData(_imageSphere) );
+ this->SetVtkBaseData(vtkbasedata);
+
+ _transform = vtkTransform::New();
+ _transform1 = vtkTransform::New();
+ _transform2 = vtkTransform::New();
+ _transform ->Identity();
+ _transform1->Identity();
+ _transform2->Identity();
+
+ _radio=25;
+}
+
+//-------------------------------------------------------------------
+
+wxSphereView::~wxSphereView()
+{
+ _transform -> Delete();
+ _transform1 -> Delete();
+ _transform2 -> Delete();
+ ResetlstId();
+}
+
+//----------------------------------------------------------------------------
+
+double wxSphereView::GetRadio()
+{
+ return _radio;
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::SetRadio(double radio)
+{
+ if (radio<0)
+ {
+ radio=0;
+ }
+ _radio=radio;
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::Configure()
+{
+ wxVtk2DBaseView::Configure();
+
+ _vtkinteractorstylesphere = new vtkInteractorStyleSphere();
+ GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _vtkinteractorstylesphere );
+ double points[4][3];
+
+// EED purify 12/sep/2006
+ int i,j;
+ for (i=0;i<4;i++)
+ {
+ for (j=0;j<3;j++)
+ {
+ points[i][j]=0;
+ }
+ }
+
+ InitSphere(points);
+ DefineImageSphere();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::RefreshPoint()
+{
+ double x = _vtkmprbasedata->GetX() - _centerX;
+ double y = _vtkmprbasedata->GetY() - _centerY;
+ double z = _vtkmprbasedata->GetZ() - _centerZ;
+ double alpha= atan2(x,z);
+ double beta = atan2( y , sqrt(z*z+x*x) );
+
+ alpha = alpha*180/3.1416;
+ beta = beta*180/3.1416;
+
+ _transform1->Identity();
+ _transform1->RotateY(alpha);
+ _transform1->RotateX(-beta);
+
+ _radio= sqrt(x*x + y*y +z*z);
+
+ RefreshView();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::RefreshView()
+{
+ DefineImageSphere();
+ wxVtk2DBaseView::Refresh();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::RotationEnd()
+{
+ _transform1->RotateWXYZ(_ang,_vxb,_vyb,0);
+ _transform2->Identity();
+ SetDeltaVoxel(1);
+ ResetlstId();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::RotationStart(double vx, double vy, bool ok_v, bool ok_ang)
+{
+ if (ok_ang==false)
+ {
+ _ang = -sqrt( vx*vx + vy*vy ) / 1.0;
+ }
+
+ if (ok_v==false){
+ _vxb=-vy;
+ _vyb=vx;
+ }
+
+ _transform2->Identity();
+ _transform2->RotateWXYZ(_ang,_vxb,_vyb,0);
+ SetDeltaVoxel(3);
+ ResetlstId();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::GetPointSphere(double p[3],double r1,double angA,double angB)
+{
+ double in[3],out[3];
+ in[0]=0;
+ in[1]=r1;
+ in[2]=0;
+ vtkTransform *transform = vtkTransform::New();
+ transform->Identity();
+ transform->RotateX(angB);
+ transform->RotateZ(angA);
+ transform->TransformPoint(in,out);
+ p[0]=out[0];
+ p[1]=out[1];
+ p[2]=out[2];
+ transform->Delete();
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::RotatePointOverTheSphere( double pp[3], double p[3],double cc[3])
+{
+
+ double out[3];
+ _transform->TransformPoint(p,out);
+ pp[0] = out[0] + cc[0];
+ pp[1] = out[1] + cc[1];
+ pp[2] = out[2] + cc[2];
+
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::TransferePoints(double pp1[3],double pp2[3],double AngX,double AngY,vtkImageData *image)
+{
+ double t;
+ double difX = pp2[0]-pp1[0];
+ double difY = pp2[1]-pp1[1];
+ double difZ = pp2[2]-pp1[2];
+
+ double max = 200;
+
+ int dimOrg[3];
+ int dimRes[3];
+ int z;
+ _imageDataOriginal->GetDimensions(dimOrg);
+ image->GetDimensions(dimRes);
+
+ int i;
+ double x1=pp1[0];
+ double y1=pp1[1];
+ double z1=pp1[2];
+ int xx=-1,yy=-1,zz=-1;
+
+ for (i=0;i<max;i++)
+ {
+ t = i/max;
+ xx = (int) (x1+t*difX);
+ yy = (int) (y1+t*difY);
+ zz = (int) (z1+t*difZ);
+
+ z=i;
+ if ((xx>=0) && (xx<dimOrg[0]) && (yy>=0) && (yy<dimOrg[1]) && (zz>=0) && (zz<dimOrg[2]) &&
+ (AngX>=0) && (AngX<dimRes[0]) && (AngY>=0) && (AngY<dimRes[1]) && (z>=0) && (z<dimRes[2]) )
+ {
+ unsigned short *pOrg=(unsigned short*)_imageDataOriginal->GetScalarPointer (xx,yy,zz);
+ unsigned short *pRes=(unsigned short*)image->GetScalarPointer( (int)AngX , (int)AngY , z );
+ *pRes=*pOrg;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::ResetlstId()
+{
+ int i,size=_lstId.size();
+ for (i=size-1;i>=0;i--)
+ {
+ delete _lstId[i];
+ }
+ _lstId.clear();
+}
+
+//----------------------------------------------------------------------------
+
+int wxSphereView::GetIdOfImage(double radio)
+{
+ int id=0;
+ int dim[3];
+ _imageSphere->GetDimensions(dim);
+ int sizeMaxList = dim[2];
+ // Search in list >> alpha beta radio
+ int i,size=_lstId.size();
+ for (i=0; i<size;i++)
+ {
+ idAlBeRa *tmp=_lstId[i];
+ if ((_lstId[i]->_radio==radio) && (_lstId[i]->_deltavoxel==_delta))
+ {
+ return _lstId[i]->_id;
+ }
+ }
+ if (size>sizeMaxList)
+ {
+ delete _lstId[size-1];
+ _lstId.pop_back();
+ }
+ if (size!=0){
+ id=_lstId[0]->_id+1;
+ id = id % sizeMaxList;
+ } else {
+ id = 0;
+ }
+
+ FiltreImage(id,radio);
+ _lstId.insert(_lstId.begin(),1,new idAlBeRa(id,radio,_delta) );
+
+ return id;
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::DefineImageSphere()
+{
+ int id;
+ id=GetIdOfImage( _radio );
+ GetVtkBaseData()->SetZ( id );
+}
+
+
+//----------------------------------------------------------------------------
+void wxSphereView::SetDeltaVoxel(int delta)
+{
+ _delta=delta;
+}
+
+//----------------------------------------------------------------------------
+void wxSphereView::SetVoxel(double i, double j, int delta,double id, unsigned short gris)
+{
+ int ii,jj,delta2;
+ unsigned short *pRes;
+ int dimRes[3];
+ _imageSphere->GetDimensions(dimRes);
+
+ delta2=delta-1;
+ for ( ii=(int)(i-delta2) ; ii<=(int)(i+delta2) ; ii++ )
+ {
+ for ( jj=(int)(j-delta2) ; jj<=(int)(j+delta2) ; jj++ )
+ {
+ if ( (ii>=0)&&(ii<dimRes[0]) &&
+ (jj>=0)&&(jj<dimRes[1]) )
+ {
+ pRes = (unsigned short*)_imageSphere->GetScalarPointer( ii , jj , (int)id );
+ *pRes=gris;
+ }
+ }
+ }
+
+}
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::SetXYZtoParent(double i, double j)
+{
+
+ double factor = 0.75;
+ double radio2 = _radio*_radio;
+ double pxx,pyy,d2x,d2y;
+ double cc[3],p[3],pp[3];
+ cc[0]=_centerX;
+ cc[1]=_centerY;
+ cc[2]=_centerZ;
+ double aa;
+ int dimRes[3],dimOrig[3];
+ _imageSphere->GetDimensions(dimRes);
+ d2x=dimRes[0]/2;
+ d2y=dimRes[1]/2;
+ _imageDataOriginal->GetDimensions(dimOrig);
+
+ p[0] = (i - d2x)*factor;
+ pxx=p[0]*p[0];
+ p[1] = (j - d2y)*factor;
+ pyy=p[1]*p[1];
+ aa = pxx + pyy;
+ if (radio2>aa){
+ aa=radio2-aa;
+ p[2] = sqrt(aa);
+ RotatePointOverTheSphere( pp, p,cc);
+ if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
+ (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
+ (pp[2]>=0) && (pp[2]<dimOrig[2]) )
+ {
+ if (_vtkmprbasedata){
+ _vtkmprbasedata->SetX(pp[0]);
+ _vtkmprbasedata->SetY(pp[1]);
+ _vtkmprbasedata->SetZ(pp[2]);
+ }
+ }
+ }
+}
+
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::FiltreImageB(int id, double radio, bool ok,int deltaTMP)
+{
+ double factor = 0.75;
+ double radioB = radio/3;
+ double radio2 = radio*radio;
+ double pxx,pyy,d2x,d2y;
+ double cc[3],p[3],pp[3];
+ cc[0]=_centerX;
+ cc[1]=_centerY;
+ cc[2]=_centerZ;
+ double aa;
+ unsigned short *pOrig;
+ int dimRes[3],dimOrig[3];
+ double i,j;
+ _imageSphere->GetDimensions(dimRes);
+ _imageSphere->SetExtent(0,dimRes[0]-1,0,dimRes[1]-1,0,dimRes[2]-1);
+ d2x=dimRes[0]/2;
+ d2y=dimRes[1]/2;
+// double deltaTMP=_delta;
+ _imageDataOriginal->GetDimensions(dimOrig);
+
+ int start,end;
+ int limitA,limitB;
+ limitA = (int) ( (-radioB/factor)+d2x );
+ limitB = (int) ( (radioB/factor)+d2x );
+ if (ok==true){
+ start = limitA;
+ end = limitB;
+ } else {
+ start=0;
+ end=dimRes[0];
+ }
+
+ for ( i=start ; i<end ; i=i+deltaTMP )
+ {
+ p[0] = (i - d2x)*factor;
+ pxx=p[0]*p[0];
+ for (j=start;j<end;j=j+deltaTMP)
+ {
+ p[1] = (j - d2y)*factor;
+ pyy=p[1]*p[1];
+ aa = pxx + pyy;
+
+ if (( ((ok==false) && (!((i>limitA) && (i<limitB) && (j>limitA) && (j<limitB)))) )
+ ||
+ (ok==true))
+ {
+ if (radio2>aa){
+ aa=radio2-aa;
+ p[2] = sqrt(aa);
+ RotatePointOverTheSphere( pp, p,cc);
+ if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
+ (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
+ (pp[2]>=0) && (pp[2]<dimOrig[2]) )
+ {
+ pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( (int)(pp[0]) , (int)(pp[1]) , (int)(pp[2]) );
+ SetVoxel(i,j,deltaTMP,id,*pOrig);
+ } else {
+ SetVoxel(i,j,deltaTMP,id,2000);
+ }
+ } else {
+ SetVoxel(i,j,deltaTMP,id,0);
+ }
+ }
+ }
+ }
+
+ _imageSphere->Modified();
+ _imageSphere->Update();
+}
+
+
+
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::FiltreImage(int id, double radio)
+{
+
+ _transform -> Identity();
+ _transform -> Concatenate(_transform1);
+ _transform -> Concatenate(_transform2);
+
+ FiltreImageB(id,radio,false, _delta);
+ FiltreImageB(id,radio,true, 1);
+}
+
+
+//----------------------------------------------------------------------------
+
+/*
+void wxSphereView::FiltreImage(int id, double radio)
+{
+ double radio2 = radio*radio;
+ double radio2TMP= (radio/2)*(radio/2);
+ double pxx,pyy,d2x,d2y;
+ double cc[3],p[3],pp[3];
+ cc[0]=_centerX;
+ cc[1]=_centerY;
+ cc[2]=_centerZ;
+ double aa;
+ unsigned short *pOrig;
+ int dimRes[3],dimOrig[3];
+ double i,j;
+ _imageSphere->GetDimensions(dimRes);
+ _imageSphere->SetExtent(0,dimRes[0]-1,0,dimRes[1]-1,0,dimRes[2]-1);
+ d2x=dimRes[0]/2;
+ d2y=dimRes[1]/2;
+ double deltaTMP=_delta;
+ _imageDataOriginal->GetDimensions(dimOrig);
+
+ for ( i=0 ; i<dimRes[0] ; i=i+deltaTMP )
+ {
+ p[0] = (i - d2x)*0.75;
+ pxx=p[0]*p[0];
+ for (j=0;j<dimRes[1];j=j+deltaTMP)
+ {
+ p[1] = (j - d2y)*0.75;
+ pyy=p[1]*p[1];
+ aa = pxx + pyy;
+
+ if (aa>radio2TMP)
+ {
+ if (radio2>aa){
+ aa=radio2-aa;
+ p[2] = sqrt(aa);
+ RotatePointOverTheSphere( pp, p,cc);
+ if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
+ (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
+ (pp[2]>=0) && (pp[2]<dimOrig[2]) )
+ {
+ pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( pp[0] , pp[1] , pp[2] );
+ SetVoxel(i,j,deltaTMP,id,*pOrig);
+ } else {
+ SetVoxel(i,j,deltaTMP,id,2000);
+ }
+ } else {
+ SetVoxel(i,j,deltaTMP,id,0);
+ }
+ }
+ }
+ }
+
+
+ deltaTMP=1;
+ for ( i=0 ; i<dimRes[0] ; i=i+deltaTMP )
+ {
+ p[0] = (i - d2x)*0.75;
+ pxx=p[0]*p[0];
+ for (j=0;j<dimRes[1];j=j+deltaTMP)
+ {
+ p[1] = (j - d2y)*0.75;
+ pyy=p[1]*p[1];
+ aa = pxx + pyy;
+ if (aa<=radio2TMP)
+ {
+ if (radio2>aa){
+ aa=radio2-aa;
+ p[2] = sqrt(aa);
+ RotatePointOverTheSphere( pp, p,cc);
+ if ( (pp[0]>=0) && (pp[0]<dimOrig[0]) &&
+ (pp[1]>=0) && (pp[1]<dimOrig[1]) &&
+ (pp[2]>=0) && (pp[2]<dimOrig[2]) )
+ {
+ pOrig=(unsigned short*)_imageDataOriginal->GetScalarPointer( pp[0] , pp[1] , pp[2] );
+ SetVoxel(i,j,deltaTMP,id,*pOrig);
+ } else {
+ SetVoxel(i,j,deltaTMP,id,2000);
+ }
+ } else {
+ SetVoxel(i,j,deltaTMP,id,0);
+ }
+ }
+ }
+ }
+
+ _imageSphere->Modified();
+ _imageSphere->Update();
+}
+*/
+/*
+void wxSphereView::FiltreImage(vtkImageData *imageSphere)
+{
+ int dim[3],i,j,k;
+ imageSphere->GetDimensions(dim);
+ for (i=0;i<dim[0];i++)
+ {
+ for (j=0;j<dim[1];j++)
+ {
+ for (k=0;k<dim[2];k++)
+ {
+ unsigned short *pRes=(unsigned short*)imageSphere->GetScalarPointer (i,j,k);
+ *pRes=0;
+ }
+ }
+ }
+
+ double deltaA=90;
+ double cc[3],p1[3],p2[3],pp1[3],pp2[3];
+ cc[0]=_centerX;
+ cc[1]=_centerY;
+ cc[2]=_centerZ;
+ double r1 = _sl_radio->GetValue() - _sl_thickness->GetValue()/2;
+ double r2 = _sl_radio->GetValue() + _sl_thickness->GetValue()/2;
+ if (r1<10)
+ {
+ r1=10;
+ }
+ double alpha= _sl_alpha->GetValue();
+ double beta = _sl_beta->GetValue();
+
+ double angA,angB;
+ for (angA=-deltaA;angA<deltaA;angA++)
+ {
+ for (angB=-deltaA;angB<deltaA;angB++)
+ {
+ GetPointSphere(p1,r1,angA,angB);
+ GetPointSphere(p2,r2,angA,angB);
+ RotatePointOverTheSphere( pp1, alpha, beta, p1 ,cc );
+ RotatePointOverTheSphere( pp2, alpha, beta, p2 ,cc );
+ TransferePoints(pp1,pp2,angA+alpha+180,angB+beta+90,imageSphere);
+ }
+ }
+}
+*/
+
+
+//----------------------------------------------------------------------------
+
+void wxSphereView::InitSphere(double points[4][3])
+{
+ double cc[3];
+ double r = SphereFindCenter(points,cc); // 4-points , center
+ if (r > 0)
+ {
+ _centerX = (int)(cc[0]);
+ _centerY = (int)(cc[1]);
+ _centerZ = (int)(cc[2]);
+ } else {
+ int dim[3];
+ _imageDataOriginal->GetDimensions(dim);
+ _centerX = (int)(dim[0]/2);
+ _centerY = (int)(dim[1]/2);
+ _centerZ = (int)(dim[2]/2);
+ }
+}
+
+//----------------------------------------------------------------------------
+
+// Calculate center and radius of sphere given four points
+// http://home.att.net/~srschmitt/script_sphere_solver.html
+// source code HTML <script language=JavaScript>
+double wxSphereView::SphereFindCenter(double P[4][3], double cc[3])
+{
+ int i;
+ double r, m11, m12, m13, m14, m15;
+ double a[4][4];
+
+ for (i = 0; i < 4; i++) // find minor 11
+ {
+ a[i][0] = P[i][0];
+ a[i][1] = P[i][1];
+ a[i][2] = P[i][2];
+ a[i][3] = 1;
+ }
+ m11 = determinant( a, 4 );
+
+ for (i = 0; i < 4; i++) // find minor 12
+ {
+ a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
+ a[i][1] = P[i][1];
+ a[i][2] = P[i][2];
+ a[i][3] = 1;
+ }
+ m12 = determinant( a, 4 );
+
+ for (i = 0; i < 4; i++) // find minor 13
+ {
+ a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
+ a[i][1] = P[i][0];
+ a[i][2] = P[i][2];
+ a[i][3] = 1;
+ }
+ m13 = determinant( a, 4 );
+
+ for (i = 0; i < 4; i++) // find minor 14
+ {
+ a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
+ a[i][1] = P[i][0];
+ a[i][2] = P[i][1];
+ a[i][3] = 1;
+ }
+ m14 = determinant( a, 4 );
+
+
+ for (i = 0; i < 4; i++) // find minor 15
+ {
+ a[i][0] = P[i][0]*P[i][0] + P[i][1]*P[i][1] + P[i][2]*P[i][2];
+ a[i][1] = P[i][0];
+ a[i][2] = P[i][1];
+ a[i][3] = P[i][2];
+ }
+ m15 = determinant( a, 4 );
+
+ if (m11 == 0)
+ {
+ r = 0;
+ }
+ else
+ {
+ // center of sphere
+ cc[0] = 0.5*m12/m11; //cx
+ cc[1] = -0.5*m13/m11; //cy
+ cc[2] = 0.5*m14/m11; //cz
+ // Sphere radio
+ r = sqrt( cc[0]*cc[0] + cc[1]*cc[1] + cc[2]*cc[2] - m15/m11 );
+ }
+
+ return r; // the radius
+}
+//----------------------------------------------------------------------------
+
+// Recursive definition of determinate using expansion by minors.
+double wxSphereView::determinant(double a[4][4], int n)
+{
+ int i, j, j1, j2;
+ double d;
+ double m[4][4];
+
+ for (i=0;i<4;i++)
+ {
+ for (j=0;j<4;j++)
+ {
+ m[i][j]=0;
+ }
+ }
+
+ if (n == 2) // terminate recursion
+ {
+ d = a[0][0]*a[1][1] - a[1][0]*a[0][1];
+ }
+ else
+ {
+ d = 0;
+ for (j1 = 0; j1 < n; j1++ ) // do each column
+ {
+ for (i = 1; i < n; i++) // create minor
+ {
+ j2 = 0;
+ for (j = 0; j < n; j++)
+ {
+ if (j == j1) continue;
+ m[i-1][j2] = a[i][j];
+ j2++;
+ }
+ }
+
+ // sum (+/-)cofactor * minor
+ d = d + pow(-1.0, j1)*a[0][j1]*determinant( m, n-1 );
+ }
+ }
+
+ return d;
+}
+
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+vtkInteractorStylePlane2D::vtkInteractorStylePlane2D()
+{
+ _stateRotate=false;
+}
+//---------------------------------------------------------------------------
+vtkInteractorStylePlane2D::~vtkInteractorStylePlane2D()
+{
+}
+
+//---------------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::GetStateRotate()
+{
+ return _stateRotate;
+}
+
+//---------------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::OnLeftButtonDown() // vitual
+{
+ _stateRotate = true;
+ _fordwareX = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ _fordwareY = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ vtkplane2Dview->RotationStart();
+
+ return true;
+}
+
+//---------------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::OnLeftButtonUp() // virtual
+{
+ if (_stateRotate==true)
+ {
+ _stateRotate = false;
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ vtkplane2Dview->ResetBack();
+// this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
+ }
+
+ return true;
+}
+
+//---------------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::OnRightButtonUp() // virtual
+{
+ if (_stateRotate==true){
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+
+// EED Borrame
+// vtkplane2Dview->RotationEnd();
+
+ _stateRotate = false;
+ }
+
+ return true;
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::OnMouseMove () // virtual
+{
+ bool ok_v, ok_ang;
+ if (_stateRotate==true){
+ ok_v=false;
+ ok_ang=false;
+ if (_vtkInteractorStyleBaseView->GetInteractor()->GetControlKey()==1)
+ {
+ ok_v=true;
+ }
+ if (_vtkInteractorStyleBaseView->GetInteractor()->GetShiftKey()==1)
+ {
+ ok_ang=true;
+ }
+ int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ vtkplane2Dview->RotationDrag( fx - _fordwareX , fy - _fordwareY , ok_v , ok_ang);
+ this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
+ }
+ return true;
+}
+//-------------------------------------------------------------------
+bool vtkInteractorStylePlane2D::OnLeftDClick() // virtual
+{
+ int fx = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ int fy = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ double xx=fx;
+ double yy=fy;
+ double zz=0;
+
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ vtkMPRBaseData *vtkmprbasedata = vtkplane2Dview->GetVtkmprbasedata();
+
+ vtkplane2Dview->TransfromeCoordViewWorld2(xx,yy,zz);
+
+ vtkmprbasedata->SetX( xx );
+ vtkmprbasedata->SetY( yy );
+ vtkmprbasedata->SetZ( zz );
+ this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
+
+ return true;
+}
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+vtkPlane2DView::vtkPlane2DView( wxWindow *parent)
+: wxVtk2DBaseView(parent)
+{
+
+ _backX = -99999;
+ _backY = -99999;
+ _backZ = -99999;
+
+ _backOrient[0] = -99999;
+ _backOrient[1] = -99999;
+ _backOrient[2] = -99999;
+ _backOrient[3] = -99999;
+
+ _active = true;
+ _mip_visualization = true;
+ _mip_width = 2;
+
+ _transform1 = vtkTransform::New();
+ _transform2 = vtkTransform::New();
+ _transform1->Identity();
+ _transform2->Identity();
+
+ _sizeIma = 200;
+
+ _pSource = NULL;
+ _3Dslices = NULL;
+ _stPoints = NULL;
+ _change = NULL;
+ _imageResult = NULL;
+
+ // line horizontal
+ _pts = NULL;
+ _lineActor = NULL;
+ _lineMapper = NULL;
+ _pd = NULL;
+
+ _interactorstyleplane2D = false;
+}
+//-------------------------------------------------------------------
+vtkPlane2DView::~vtkPlane2DView()
+{
+ ResetPlane();
+
+ // Horizontal Line
+ if (_pts != NULL) { _pts -> Delete(); }
+ if (_lineActor != NULL) { _lineActor -> Delete(); }
+ if (_lineMapper != NULL) { _lineMapper -> Delete(); }
+ if (_pd != NULL) { _pd -> Delete(); }
+
+ _transform1 -> Delete();
+ _transform2 -> Delete();
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::ResetBack()
+{
+ _backX=-1;
+ _backY=-1;
+ _backZ=-1;
+ _backOrient[0]=-1;
+ _backOrient[1]=-1;
+ _backOrient[2]=-1;
+ _backOrient[3]=-1;
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::ResetPlane(){
+ if (_pSource !=NULL) { _pSource -> Delete(); }
+ if (_3Dslices !=NULL) { _3Dslices -> Delete(); }
+ if (_stPoints !=NULL) { _stPoints -> Delete(); }
+ if (_change !=NULL) { _change -> Delete(); }
+}
+//-------------------------------------------------------------------
+vtkMPRBaseData *vtkPlane2DView::GetVtkmprbasedata()
+{
+ return (vtkMPRBaseData*)GetVtkBaseData();
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::SetPSource(int sizeIma){
+ int dimIma = sizeIma;
+
+ double x = GetVtkmprbasedata()->GetX();
+ double y = GetVtkmprbasedata()->GetY();
+ double z = GetVtkmprbasedata()->GetZ();
+
+ double spc[3];
+ vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
+ imagedata->GetSpacing(spc);
+ x=x*spc[0];
+ y=y*spc[1];
+ z=z*spc[2];
+
+
+ vtkMPRBaseData *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
+ vtkTransform *transform = mprbasedata->GetTransformOrientation();
+
+ double in[3]; // temp
+ double pA[3];
+ double pB[3];
+ in[0]=1; in[1]=0; in[2]=0;
+ transform->TransformPoint(in,_n);
+
+ in[0]=0; in[1]=dimIma-1; in[2] = 0;
+ transform->TransformPoint(in,pA);
+
+ in[0]=0; in[1]=0; in[2]=dimIma-1;
+ transform->TransformPoint(in,pB);
+
+ _pSource -> SetPoint1( pA );
+ _pSource -> SetPoint2( pB );
+
+ _pSource -> SetOrigin( 0 , 0 , 0 );
+ _pSource -> SetResolution( sizeIma-1 , sizeIma -1 );
+ _pSource -> Update();
+ _pSource -> SetCenter( x, y, z );
+ _pSource -> SetNormal( _n );
+ _pSource -> Update( );
+
+// EED Borrame
+// transform->Delete();
+
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::ExtractPlane()
+{
+
+ double x = GetVtkmprbasedata()->GetX();
+ double y = GetVtkmprbasedata()->GetY();
+ double z = GetVtkmprbasedata()->GetZ();
+
+ double spc[3];
+ vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
+ imagedata->GetSpacing(spc);
+ x=x*spc[0];
+ y=y*spc[1];
+ z=z*spc[2];
+
+ vtkTransform *transform = GetVtkmprbasedata()->GetTransformOrientation();
+ double orientation[4];
+ transform->GetOrientationWXYZ(orientation);
+
+ bool okOrientation=true;
+ if ((orientation[0]!=_backOrient[0]) || (orientation[1]!=_backOrient[1]) ||
+ (orientation[2]!=_backOrient[2]) || (orientation[3]!=_backOrient[3]))
+ {
+ okOrientation=false;
+ }
+
+ bool okPosicion=true;
+ if ( (x!=_backX) || (y!=_backY) || (z!=_backZ) )
+ {
+ okPosicion=false;
+ }
+
+ if ((okPosicion==false) || (okOrientation==false) ) {
+ if (_active==true){
+
+ bool ok = false;
+
+ if ( _mip_visualization==true )
+ {
+ if (_interactorstyleplane2D!=NULL)
+ {
+ if (_interactorstyleplane2D->GetStateRotate()==false )
+ {
+ ok=true;
+ }
+ }
+ }
+// ok=true;
+
+ if (ok==true)
+ {
+ Extract_MIP_PlaneVTK();
+ } else {
+ Extract_One_PlaneVTK();
+ } // ok
+
+ } // active
+ _backX=x;
+ _backY=y;
+ _backZ=z;
+ _backOrient[0]=orientation[0];
+ _backOrient[1]=orientation[1];
+ _backOrient[2]=orientation[2];
+ _backOrient[3]=orientation[3];
+ } //okPosition okOrientation
+}
+
+//-------------------------------------------------------------------
+
+void vtkPlane2DView::Extract_One_PlaneVTK()
+{
+ vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
+ SetPSource(_sizeIma);
+ _3Dslices -> SetInput( ( vtkDataSet* )_pSource->GetOutput( ) );
+ _3Dslices -> SetSource( imagedata );
+ _3Dslices -> Update( );
+ _stPoints -> GetPointData( )->SetScalars( _3Dslices->GetOutput()->GetPointData()->GetScalars() );
+ _stPoints -> SetDimensions( _sizeIma, _sizeIma, 1 );
+ _stPoints -> SetScalarType( imagedata->GetScalarType() );
+ _stPoints -> SetScalarTypeToShort();
+ _stPoints -> Update();
+// _change -> SetInput( _stPoints );
+// _change -> Update(); //important
+ _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _stPoints );
+// _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _change->GetOutput() );
+ // vtkImageActor *imageActor = _imageViewer2XYZ->GetVtkImageViewer2()->GetImageActor();
+}
+
+//-------------------------------------------------------------------
+
+void vtkPlane2DView::Extract_MIP_PlaneVTK( /*double heightDefinition*/ )
+{
+
+ int mipWidth;
+ double sp;
+ int sizeWidth = (_mip_width*2)+1 ;
+ int deltaPixel;
+ int iWidth,itmp,tmpSizeWith;
+
+ double spc[3];
+ vtkImageData *imagedata = GetVtkmprbasedata()->GetImageData();
+ SetPSource(_sizeIma);
+ imagedata->GetSpacing(spc);
+
+ bool heightDefinition=false;
+ if (_mip_width<3)
+ {
+ heightDefinition=true;
+ }
+
+ if (heightDefinition==true)
+ {
+ mipWidth = _mip_width;
+ sp = spc[0];
+ deltaPixel = 1;
+ } else {
+ mipWidth = 2;
+ tmpSizeWith = (mipWidth*2) + 1;
+ sp = (spc[0]*sizeWidth)/tmpSizeWith;
+ sizeWidth = tmpSizeWith;
+ deltaPixel = 4;
+ }
+
+
+
+ std::vector< vtkProbeFilter* > slicesLST;
+
+ _pSource->Push( -mipWidth * sp );
+ _pSource->Update();
+
+ for ( iWidth=0 ; iWidth<sizeWidth ; iWidth++ )
+ {
+ vtkProbeFilter *slice = vtkProbeFilter::New();
+ slice -> SetInput( ( vtkDataSet* )_pSource->GetOutput( ) );
+ slice -> SetSource( imagedata );
+ slice -> Update( );
+ slicesLST.push_back( slice );
+ _pSource->Push( sp );
+ }
+
+ if (_imageResult ==NULL)
+ {
+ _imageResult = vtkImageData::New();
+ _imageResult -> SetDimensions(_sizeIma,_sizeIma,1);
+ _imageResult -> SetSpacing(1,1,1);
+ _imageResult -> SetScalarType( imagedata->GetScalarType() );
+ _imageResult -> SetExtent(0,_sizeIma-1,0,_sizeIma-1,0,0);
+ _imageResult -> SetWholeExtent(0,_sizeIma-1,0,_sizeIma-1,0,0);
+ _imageResult -> AllocateScalars();
+ _imageResult -> Update();
+ }
+
+ unsigned short *pTemp;
+ unsigned short *pResult;
+ pResult = (unsigned short*)_imageResult->GetScalarPointer( 0 , 0 , 0 );
+
+ int iPixels , sizePixels = _sizeIma*_sizeIma;
+ for(iPixels=0 ; iPixels<sizePixels ; iPixels=iPixels+deltaPixel)
+ {
+
+ pTemp = (unsigned short*)slicesLST[0]->GetOutput()->GetPointData()->GetScalars()->GetVoidPointer(0);
+
+ pResult = (unsigned short*)_imageResult->GetScalarPointer( 0 , 0 , 0 );
+ pResult[iPixels] = pTemp[iPixels];
+
+ for (iWidth=1;iWidth<sizeWidth;iWidth++)
+ {
+ pTemp = (unsigned short*)slicesLST[iWidth]->GetOutput()->GetPointData()->GetScalars()->GetVoidPointer(0);
+
+ if (pResult[iPixels]< pTemp[iPixels])
+ {
+ pResult[iPixels] = pTemp[iPixels];
+ }
+ }
+
+ if (deltaPixel!=1)
+ {
+ for (itmp=1;itmp<deltaPixel;itmp++)
+ {
+ pResult[iPixels+itmp] = pResult[iPixels];
+ }
+ }
+
+ }
+
+ for (iWidth=0;iWidth<sizeWidth;iWidth++)
+ {
+ slicesLST[iWidth]->Delete();
+ }
+
+ _imageResult->Modified();
+ _imageViewer2XYZ->GetVtkImageViewer2()->SetInput ( _imageResult );
+
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::Configure( )
+{
+ wxVtk2DBaseView::Configure(false);
+
+ HorizontalLine();
+// Borrame
+// CircleLine();
+
+ _pSource = vtkPlaneSource::New( );
+ _3Dslices = vtkProbeFilter::New( ) ;
+ _stPoints = vtkStructuredPoints::New( );
+ _change = vtkImageChangeInformation::New();
+
+ wxVTKRenderWindowInteractor *iren = GetWxVTKRenderWindowInteractor();
+ ExtractPlane();
+// SetActive(false);
+ _imageViewer2XYZ -> GetVtkImageViewer2() -> SetupInteractor ( iren );
+
+ SetInteractorStyleImage( vtkInteractorStyleBaseView2D::New() );
+
+ _interactorstyleplane2D = new vtkInteractorStylePlane2D();
+ GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _interactorstyleplane2D );
+
+ vtkCamera *camera =_imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->GetActiveCamera();
+ camera->SetViewUp ( 0 , 1 , 0 );
+ camera->SetFocalPoint ((0+_sizeIma)/2 , (0+_sizeIma)/2 , 0 );
+ camera->SetPosition ((0+_sizeIma)/2 , (0+_sizeIma)/2 , 10000 );
+ camera->SetClippingRange(0.01, 100000);
+ camera->ComputeViewPlaneNormal();
+ camera->SetParallelScale( _sizeIma/3.0 );
+
+ // text information over the graphic window
+ _vtkInfoTextImage = new vtkInfoTextImage();
+ _vtkInfoTextImageInteractorPlane2D = new vtkInfoTextImageInteractorPlane2D();
+ _vtkInfoTextImage->SetWxVtk2DBaseView(this);
+ _vtkInfoTextImage->SetMarImageData( GetVtkmprbasedata()->GetMarImageData() );
+ _vtkInfoTextImageInteractorPlane2D->SetModelVtkInfoTextImage(_vtkInfoTextImage);
+ _vtkInfoTextImage->Configure();
+ this->GetInteractorStyleBaseView()->AddInteractorStyleMaracas(_vtkInfoTextImageInteractorPlane2D);
+
+
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::HorizontalLine()
+{
+// Axe Horizontal
+ _pts = vtkPoints::New();
+ _pts->SetNumberOfPoints(2);
+ _pts->SetPoint(0, -1000 , -1000 , -1000 );
+ _pts->SetPoint(1, 1000 , 1000 , 1000 );
+ vtkCellArray *lines = vtkCellArray::New();
+ lines->InsertNextCell(2);
+ lines->InsertCellPoint(0);
+ lines->InsertCellPoint(1);
+ _pd = vtkPolyData::New();
+ _pd->SetPoints( _pts );
+ _pd->SetLines( lines );
+ lines->Delete(); //do not delete lines ??
+ _lineActor = vtkActor::New();
+ _lineMapper = vtkPolyDataMapper::New();
+ _lineMapper->SetInput(_pd);
+ _lineMapper->ImmediateModeRenderingOn();
+ _lineActor->SetMapper(_lineMapper);
+ _lineActor->GetProperty()->BackfaceCullingOn();
+ _lineActor->GetProperty()->SetDiffuseColor(0,0,1);
+ _lineActor->GetProperty()->SetLineWidth(2);
+ _lineActor->GetProperty()->SetOpacity(0);
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineActor );
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::RotationStart()
+{
+ vtkMPRBaseData *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
+ vtkTransform *transform = mprbasedata->GetTransformOrientation();
+ _transform1->SetMatrix( transform->GetMatrix() );
+}
+//-------------------------------------------------------------------
+void vtkPlane2DView::RotationDrag(double vx, double vy, bool ok_v, bool ok_ang)
+{
+ if (ok_ang==false)
+ {
+ _ang =sqrt( vx*vx + vy*vy ) / 1.5;
+ }
+
+ if (ok_v==false){
+ _vxb=-vy;
+ _vyb=vx;
+ }
+ _transform2->Identity();
+ _transform2->RotateWXYZ(_ang,0,_vxb,_vyb);
+
+ vtkMPRBaseData *mprbasedata = (vtkMPRBaseData*)this->GetVtkBaseData();
+ vtkTransform *transform = vtkTransform::New();
+ transform->Identity();
+ transform->Concatenate(_transform1);
+ transform->Concatenate(_transform2);
+ mprbasedata->InitTransformOrientation(transform);
+ transform->Delete();
+
+ // Refresh Horizontal Line
+ _pts->SetPoint( 0 , (_sizeIma/2) - _vxb*2 , (_sizeIma/2) - _vyb*2 , 1 );
+ _pts->SetPoint( 1 , (_sizeIma/2) + _vxb*2 , (_sizeIma/2) + _vyb*2 , 1 );
+// RefreshCircleLine();
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::Refresh( )
+{
+ ExtractPlane();
+ wxVtkBaseView::Refresh();
+}
+//-------------------------------------------------------------------
+void vtkPlane2DView::SetImgSize( int imgSize )
+{
+ _sizeIma = imgSize;
+}
+//-------------------------------------------------------------------
+int vtkPlane2DView::GetImgSize()
+{
+ return _sizeIma;
+}
+//-------------------------------------------------------------------
+int vtkPlane2DView::GetActualSlice() // virtual
+{
+ _cx = GetVtkmprbasedata()->GetX();
+ _cy = GetVtkmprbasedata()->GetY();
+ _cz = GetVtkmprbasedata()->GetZ();
+ return 0;
+}
+
+//-------------------------------------------------------------------
+
+bool vtkPlane2DView::GetMipVisualization()
+{
+ return _mip_visualization;
+}
+
+//-------------------------------------------------------------------
+int vtkPlane2DView::GetMipWidth()
+{
+ return _mip_width;
+}
+
+//-------------------------------------------------------------------
+void vtkPlane2DView::SetActualSlice(int slice) // Virtual
+{
+ double dir=(double)slice/3.0;
+ GetVtkmprbasedata()->SetX( _cx + (_n[0]*dir) );
+ GetVtkmprbasedata()->SetY( _cy + (_n[1]*dir) );
+ GetVtkmprbasedata()->SetZ( _cz + (_n[2]*dir) );
+}
+//---------------------------------------------------------------------------
+vtkInteractorStylePlane2D *vtkPlane2DView::GetInteractorstyleplane2D()
+{
+ return this->_interactorstyleplane2D;
+}
+//---------------------------------------------------------------------------
+void vtkPlane2DView::SetActive(bool active)
+{
+ _active = active;
+}
+
+//---------------------------------------------------------------------------
+
+void vtkPlane2DView::SetMipVisualization(bool ok)
+{
+ _mip_visualization=ok;
+}
+
+//---------------------------------------------------------------------------
+
+void vtkPlane2DView::SetMipWidth(int value)
+{
+ _mip_width=value;
+}
+
+//---------------------------------------------------------------------------
+void vtkPlane2DView::SetVisibleLine(bool ok)
+{
+ double opacity;
+ if (ok==true)
+ {
+ opacity=1;
+ } else {
+ opacity=0;
+ }
+ _lineActor->GetProperty()->SetOpacity(opacity);
+}
+// ----------------------------------------------------------------------------
+void vtkPlane2DView::TransfromeCoordViewWorld2(double &X, double &Y, double &Z)
+{
+ double spc[3];
+ GetVtkmprbasedata()->GetImageData()->GetSpacing(spc);
+
+ double xx = X;
+ double yy = Y;
+ double zz = 0;
+
+ TransfromeCoordScreenToWorld(xx,yy,zz);
+
+
+ vtkTransform *transf1 = vtkTransform::New();
+ transf1->Identity();
+ vtkTransform *transf2 = GetVtkmprbasedata()->GetTransformOrientation();
+ transf1->Concatenate(transf2->GetMatrix());
+ double in[4], out[4];
+ double center = GetImgSize() / 2;
+ in[0] = 0;
+ in[1] = xx - center;
+ in[2] = yy - center;
+ in[3] = 0;
+
+ transf1->MultiplyPoint(in,out);
+ transf1->Delete();
+
+ X = out[0] + GetVtkmprbasedata()->GetX() ;
+ Y = out[1] + GetVtkmprbasedata()->GetY() ;
+ Z = out[2] + GetVtkmprbasedata()->GetZ() ;
+
+}
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+vtkInfoTextImageInteractorPlane2D::vtkInfoTextImageInteractorPlane2D()
+{
+}
+//-------------------------------------------------------------------
+vtkInfoTextImageInteractorPlane2D::~vtkInfoTextImageInteractorPlane2D()
+{
+}
+//-------------------------------------------------------------------
+bool vtkInfoTextImageInteractorPlane2D::OnMouseMove()
+{
+ int X,Y;
+ wxVTKRenderWindowInteractor *wxVTKiren;
+ wxVTKiren = _vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetWxVTKRenderWindowInteractor();
+ wxVTKiren->GetEventPosition(X,Y);
+
+ int z = (int) (_vtkInteractorStyleBaseView->GetWxVtk2DBaseView()->GetVtkBaseData()->GetZ());
+ double xx=X,yy=Y,zz=z;
+
+// --> dif
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_vtkInteractorStyleBaseView->GetWxVtk2DBaseView();
+ vtkplane2Dview->TransfromeCoordViewWorld2(xx,yy,zz);
+
+ GetVtkInfoTextImage()->PutWindowLevel();
+ GetVtkInfoTextImage()->PutColorLevel();
+ GetVtkInfoTextImage()->PutPosition( (int)xx , (int)yy , (int)zz );
+ GetVtkInfoTextImage()->PutPixelIntensity( (int)xx , (int)yy , (int)zz );
+
+ this->_vtkInteractorStyleBaseView->SetRefresh_waiting();
+ return true;
+}
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+manualViewPerpPlaneContour::manualViewPerpPlaneContour()
+{
+}
+// ----------------------------------------------------------------------------
+manualViewPerpPlaneContour::~manualViewPerpPlaneContour()
+{
+}
+
+
+// ----------------------------------------------------------------------------
+manualViewPerpPlaneContour * manualViewPerpPlaneContour :: Clone()
+{
+ manualViewPerpPlaneContour * clone = new manualViewPerpPlaneContour();
+ CopyAttributesTo(clone);
+ return clone;
+}
+
+// ---------------------------------------------------------------------------
+
+void manualViewPerpPlaneContour::CopyAttributesTo( manualViewPerpPlaneContour * cloneObject)
+{
+ // Fathers object
+ manualViewContour::CopyAttributesTo(cloneObject);
+}
+
+
+
+
+// ----------------------------------------------------------------------------
+void manualViewPerpPlaneContour::UpdateViewPoint(int id)
+{ // virtual
+ double x,y,z;
+ manualPoint *mp = _manContModel->GetManualPoint(id);
+ x = mp->GetX();
+ y = mp->GetY();
+ z = mp->GetZ();
+ FilterCordinateXYZ(x,y,z);
+
+ _lstViewPoints[id]->SetPositionXY( x , y ,GetRange(), z );
+ if ((z>=-1) && (z<=1))
+ {
+ _lstViewPoints[id]->GetVtkActor()->VisibilityOn();
+ } else {
+ _lstViewPoints[id]->GetVtkActor()->VisibilityOff();
+ }
+}
+// ----------------------------------------------------------------------------
+void manualViewPerpPlaneContour::FilterCordinateXYZ (double &x, double &y, double &z)
+{
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
+ vtkMPRBaseData *vtkmprbasedata = vtkplane2Dview->GetVtkmprbasedata();
+ vtkTransform *transf1 = vtkTransform::New();
+ vtkTransform *transf2 = vtkmprbasedata->GetTransformOrientation();
+ transf1->SetMatrix( transf2->GetMatrix() );
+ transf1->Inverse();
+
+ double in[4], out[4];
+ double center = vtkplane2Dview->GetImgSize() / 2;
+
+ in[0] = x - vtkmprbasedata->GetX();
+ in[1] = y - vtkmprbasedata->GetY();
+ in[2] = z - vtkmprbasedata->GetZ();
+ in[3] = 0;
+
+ transf1->MultiplyPoint(in,out);
+ z = out[0];
+ x = out[1]+center;
+ y = out[2]+center;
+
+ double spc[3];
+ this->GetWxVtkBaseView()->GetSpacing(spc);
+ x = x / spc[0];
+ y = y / spc[1];
+ z = z / spc[2];
+
+ transf1->Delete();
+}
+
+// ----------------------------------------------------------------------------
+void manualViewPerpPlaneContour::TransfromeCoordViewWorld( double &X,double &Y,double &Z,int type )
+{
+ Z = 0;
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
+ vtkplane2Dview->TransfromeCoordViewWorld2(X,Y,Z);
+}
+
+
+// ----------------------------------------------------------------------------
+void manualViewPerpPlaneContour::RefreshContour() // virtual
+{
+// manualViewContour::RefreshContour();
+
+ double pp1[3];
+ double pp2[3];
+ double u;
+
+// JSTG 25-02-08 ----------------------------------------------------------
+// tt;
+//--------------------------------------------------------
+
+ double pp[3];
+ double ppB[3];
+ double ppC[3];
+ ppB[0] = 999999;
+ double dist,distMin = 99999999;
+
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
+ double center = vtkplane2Dview->GetImgSize() / 2;
+
+ int i,np,nps;
+ np = GetNumberOfPoints( );
+
+//JSTG 25-02-08 ------------------------------------------
+ //double t,delta;
+ //nps = GetNumberOfPointsSpline();
+ nps = _manContModel->GetNumberOfPointsSpline();
+ //delta = ( double ) ( np ) / ( double ) ( nps-1 );
+ _manContModel->UpdateSpline();
+//--------------------------------------------------------
+
+ if ( np >= 2 )
+ {
+ for( i = 0; i < nps; i++ )
+ {
+// JSTG 25-02-08 ----------------------------------------------------------
+ //t = delta * (double)i ;
+ //tt = delta * (double)(i+1) ;
+ //_manContModel->GetSplinePoint(t ,pp1[0],pp1[1],pp1[2]);
+ //_manContModel->GetSplinePoint(tt,pp2[0],pp2[1],pp2[2]);
+ _manContModel->GetSpline_i_Point(i ,&pp1[0],&pp1[1],&pp1[2]);
+ _manContModel->GetSpline_i_Point(i+1,&pp2[0],&pp2[1],&pp2[2]);
+//--------------------------------------------------------------------------
+ FilterCordinateXYZ(pp1[0],pp1[1],pp1[2]);
+ FilterCordinateXYZ(pp2[0],pp2[1],pp2[2]);
+ if (pp2[2]*pp1[2]<=0)
+ {
+ if (pp1[2]-pp2[2]!=0) {
+ u = -pp2[2] / (pp1[2]-pp2[2]);
+ } else {
+ u=9999999;
+ }
+ pp[0] = ( pp1[0]-pp2[0] )*u + pp2[0];
+ pp[1] = ( pp1[1]-pp2[1] )*u + pp2[1];
+ pp[2] = ( pp1[2]-pp2[2] )*u + pp2[2];
+ ppC[0] = pp[0] - center;
+ ppC[1] = pp[1] - center;
+ ppC[2] = pp[2] ;
+ dist = sqrt( ppC[0]*ppC[0] + ppC[1]*ppC[1] + ppC[2]*ppC[2] );
+ if (dist<distMin)
+ {
+ distMin=dist;
+ ppB[0] = pp[0];
+ ppB[1] = pp[1];
+ ppB[2] = pp[2];
+ }
+ }
+
+ }// for
+ } else {
+ _pts->SetPoint(0, 0 , 0 , 0);
+ _pts->SetPoint(1, 0 , 0 , 0);
+ } // if
+
+//EED 27 sep 2006
+ ppB[0]=ppB[0]*_spc[0];
+ ppB[1]=ppB[1]*_spc[1];
+
+ _pts->SetPoint( 0, ppB[0] , ppB[1]+1 , 1 );
+ _pts->SetPoint( 1, ppB[0] , ppB[1]-1 , 1 );
+ _pts->SetPoint( 2, ppB[0] , ppB[1] , 1 );
+ _pts->SetPoint( 3, ppB[0]-1 , ppB[1] , 1 );
+ _pts->SetPoint( 4, ppB[0]+1 , ppB[1] , 1 );
+
+
+ for( i = 5; i < nps; i++ )
+ {
+ _pts->SetPoint( i, ppB[0] , ppB[1] , 1 );
+ }
+
+}
+
+//---------------------------------------------------------------------------
+bool manualViewPerpPlaneContour::ifTouchContour( int x, int y, int z)
+{
+ bool ok=false;
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)( this->GetWxVtkBaseView() );
+ double X=x;
+ double Y=y;
+ double Z=z;
+ vtkplane2Dview->TransfromeCoordScreenToWorld(X,Y,Z);
+ double ppA[3];
+ _pts->GetPoint(0, ppA);
+ if (sqrt( (ppA[0]-X)*(ppA[0]-X) + (ppA[1]-Y)*(ppA[1]-Y) ) <=2)
+ {
+ ok = true;
+ }
+ return ok;
+}
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+vtkInteractorStyleMPRView::vtkInteractorStyleMPRView()
+{
+ _stateMoveAxisX = false;
+ _stateMoveAxisY = false;
+ _stateMoveAxisZ = false;
+}
+//---------------------------------------------------------------------------
+vtkInteractorStyleMPRView::~vtkInteractorStyleMPRView()
+{
+}
+
+
+//---------------------------------------------------------------------------
+bool vtkInteractorStyleMPRView::OnLeftDClick () // virtual
+{
+ wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ double x = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ double y = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ double z = 1;
+ _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
+ wxvtkmpr2Dview->MoveX(x,y,z);
+ wxvtkmpr2Dview->MoveY(x,y,z);
+ wxvtkmpr2Dview->MoveZ(x,y,z);
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ wxCommandEvent newevent2(wxEVT_COMMAND_MENU_SELECTED,12122); // Doble click
+ wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent2);
+
+ return true;
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStyleMPRView::OnLeftButtonDown ()
+{
+ wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+ double x = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ double y = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ double z = 1;
+ double xx = x;
+ double yy = y;
+ _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
+
+/*EED Borrame
+ if ((_xBack==xx) && (_yBack==yy))
+ {
+ wxvtkmpr2Dview->MoveX(x,y,z);
+ wxvtkmpr2Dview->MoveY(x,y,z);
+ wxvtkmpr2Dview->MoveZ(x,y,z);
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ wxCommandEvent newevent2(wxEVT_COMMAND_MENU_SELECTED,12122); // Doble click
+ wxvtkmpr2Dview->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent2);
+ }
+
+ _xBack=xx;
+ _yBack=yy;
+*/
+
+ _stateMoveAxisX = wxvtkmpr2Dview->IfMouseTouchX(x,y,z);
+ _stateMoveAxisY = wxvtkmpr2Dview->IfMouseTouchY(x,y,z);
+ _stateMoveAxisZ = wxvtkmpr2Dview->IfMouseTouchZ(x,y,z);
+
+ return true;
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStyleMPRView::OnLeftButtonUp ()
+{
+ if (_stateMoveAxisX==true)
+ {
+ _stateMoveAxisX=false;
+ }
+ if (_stateMoveAxisY==true)
+ {
+ _stateMoveAxisY=false;
+ }
+ if (_stateMoveAxisZ==true)
+ {
+ _stateMoveAxisZ=false;
+ }
+ return true;
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStyleMPRView::OnMouseMove ()
+{
+ double x = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ double y = _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+
+ double z=1;
+ _vtkInteractorStyleBaseView->TransformCoordinate(x,y,z);
+ wxVtkMPR2DView *wxvtkmpr2Dview = (wxVtkMPR2DView*)(_vtkInteractorStyleBaseView->GetWxVtk2DBaseView());
+// wxvtkmpr2Dview->TransfromeCoordViewWorld(x,y,z);
+
+ wxvtkmpr2Dview->ChangeAxisColor(x,y,z);
+
+ if ((_stateMoveAxisX==true) || (_stateMoveAxisY==true) || (_stateMoveAxisZ==true) )
+ {
+ if (_stateMoveAxisX==true)
+ {
+ wxvtkmpr2Dview-> MoveX(x,y,z);
+ }
+ if (_stateMoveAxisY==true)
+ {
+ wxvtkmpr2Dview->MoveY(x,y,z);
+ }
+ if (_stateMoveAxisZ==true)
+ {
+ wxvtkmpr2Dview->MoveZ(x,y,z);
+ }
+
+ this->_vtkInteractorStyleBaseView->SetParent_refresh_waiting();
+ }
+ return true;
+}
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+wxVtkMPR2DView::wxVtkMPR2DView( wxWindow *parent, int direction)
+ :wxVtk2DBaseView(parent)
+{
+ _backX = -99999;
+ _backY = -99999;
+ _backZ = -99999;
+ _direction = direction;
+ _ptsA = NULL;
+ _lineAActor = NULL;
+ _lineAMapper = NULL;
+ _pdA = NULL;
+ _ptsB = NULL;
+ _lineBActor = NULL;
+ _lineBMapper = NULL;
+ _pdB = NULL;
+}
+
+//-------------------------------------------------------------------
+wxVtkMPR2DView::~wxVtkMPR2DView()
+{
+ if (_ptsA!=NULL) { _ptsA -> Delete(); }
+ if (_lineAActor!=NULL) { _lineAActor -> Delete(); }
+ if (_lineAMapper!=NULL) { _lineAMapper -> Delete(); }
+ if (_pdA!=NULL) { _pdA -> Delete(); }
+ if (_ptsB!=NULL) { _ptsB -> Delete(); }
+ if (_lineBActor!=NULL) { _lineBActor -> Delete(); }
+ if (_lineBMapper!=NULL) { _lineBMapper -> Delete(); }
+ if (_pdB!=NULL) { _pdB -> Delete(); }
+}
+//-------------------------------------------------------------------
+vtkMPRBaseData *wxVtkMPR2DView::GetVtkmprbasedata()
+{
+ return (vtkMPRBaseData*)GetVtkBaseData();
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::Configure(){
+ wxVtk2DBaseView::Configure();
+
+
+ _interactorstylemprview = new vtkInteractorStyleMPRView();
+ GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _interactorstylemprview );
+
+ int x1,x2,y1,y2,z1,z2;
+ GetVtkmprbasedata() -> GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
+
+ double spc[3];
+ GetVtkmprbasedata()->GetImageData()->GetSpacing(spc);
+ x1 = (int)(x1*spc[0]);
+ y1 = (int)(y1*spc[1]);
+ z1 = (int)(z1*spc[2]);
+
+ x2 = (int)(x2*spc[0]);
+ y2 = (int)(y2*spc[1]);
+ z2 = (int)(z2*spc[2]);
+
+ _visibleAxis = true;
+
+// Axe A
+ _ptsA = vtkPoints::New();
+ _ptsA->SetNumberOfPoints(2);
+ _ptsA->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsA->SetPoint(1, 1000 , 1000 , 1000 );
+ vtkCellArray *linesA;
+ linesA = vtkCellArray::New();
+ linesA->InsertNextCell(2);
+ linesA->InsertCellPoint(0);
+ linesA->InsertCellPoint(1);
+ _pdA = vtkPolyData::New();
+ _pdA->SetPoints( _ptsA );
+ _pdA->SetLines( linesA );
+ linesA->Delete(); //do not delete lines ??
+ _lineAActor = vtkActor::New();
+ _lineAMapper = vtkPolyDataMapper::New();
+ _lineAMapper->SetInput(_pdA);
+ _lineAMapper->ImmediateModeRenderingOn();
+ _lineAActor->SetMapper(_lineAMapper);
+ _lineAActor->GetProperty()->BackfaceCullingOn();
+ _lineAActor->GetProperty()->SetDiffuseColor(1,0,0);
+ _lineAActor->GetProperty()->SetLineWidth(2);
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineAActor );
+
+// Axe B
+ _ptsB = vtkPoints::New();
+ _ptsB->SetNumberOfPoints(2);
+ _ptsB->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsB->SetPoint(1, 1000 , 1000 , 1000 );
+ vtkCellArray *linesB;
+ linesB = vtkCellArray::New();
+ linesB->InsertNextCell(2);
+ linesB->InsertCellPoint(0);
+ linesB->InsertCellPoint(1);
+ _pdB = vtkPolyData::New();
+ _pdB->SetPoints( _ptsB );
+ _pdB->SetLines( linesB );
+ linesB->Delete(); //do not delete lines ??
+ _lineBActor = vtkActor::New();
+ _lineBMapper = vtkPolyDataMapper::New();
+ _lineBMapper->SetInput(_pdB);
+ _lineBMapper->ImmediateModeRenderingOn();
+ _lineBActor->SetMapper(_lineBMapper);
+ _lineBActor->GetProperty()->BackfaceCullingOn();
+ _lineBActor->GetProperty()->SetDiffuseColor(1,0,0);
+ _lineBActor->GetProperty()->SetLineWidth(2);
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineBActor );
+
+ vtkCamera *camera =_imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->GetActiveCamera();
+ if (_direction==0) {
+ camera->SetViewUp ( 0 , -1 , 0 );
+ camera->SetPosition ( -10000,(y1+y2)/2 , (z1+z2)/2 );
+ camera->SetFocalPoint ( 0 , (y1+y2)/2 , (z1+z2)/2 );
+ camera->SetParallelScale( (z2-z1)/3.0 );
+ }
+
+ if (_direction==1) {
+ camera->SetViewUp ( 0 , 0 , -1 );
+ camera->SetPosition ((x1+x2)/2 , 10000 , (z1+z2)/2 );
+ camera->SetFocalPoint ((x1+x2)/2 , 0 , (z1+z2)/2 );
+ camera->SetParallelScale( (x2-x1)/3.0 );
+ }
+
+ if (_direction==2) {
+ camera->SetViewUp ( 0 , -1 , 0 );
+ camera->SetPosition ((x1+x2)/2 , (y1+y2)/2 , -10000);
+ camera->SetFocalPoint ((x1+x2)/2 , (y1+y2)/2 , 0 );
+ camera->SetParallelScale( (x2-x1)/3.0 );
+ }
+
+
+
+// _imageViewer2XYZ->GetVtkImageViewer2()->SetColorWindow (160);
+// _imageViewer2XYZ->GetVtkImageViewer2()->SetColorLevel (800);
+
+}
+
+void wxVtkMPR2DView::SetVisibleAxis(bool ok)
+{
+ if (ok!=_visibleAxis)
+ {
+ _visibleAxis=ok;
+ if (_visibleAxis==true)
+ {
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineAActor );
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineBActor );
+ }
+ if (_visibleAxis==false)
+ {
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->RemoveActor( _lineAActor );
+ _imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->RemoveActor( _lineBActor );
+ }
+
+ }
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::Refresh()
+{
+ //wxVtk2DBaseView::Refresh();
+
+
+ vtkImageViewer2 *IV2=_imageViewer2XYZ->GetVtkImageViewer2();
+ vtkCamera *camera = IV2->GetRenderer()->GetActiveCamera();
+
+
+
+ int x1,x2,y1,y2,z1,z2;
+ GetVtkmprbasedata()->GetDimensionExtention(&x1,&x2,&y1,&y2,&z1,&z2);
+ double spc[3];
+ GetVtkmprbasedata()->GetImageData()->GetSpacing(spc);
+ x1 = (int)(x1*spc[0]);
+ y1 = (int)(y1*spc[1]);
+ z1 = (int)(z1*spc[2]);
+
+ x2 = (int)(x2*spc[0]);
+ y2 = (int)(y2*spc[1]);
+ z2 = (int)(z2*spc[2]);
+
+ int x = (int)(GetVtkmprbasedata()->GetX());
+ int y = (int)(GetVtkmprbasedata()->GetY());
+ int z = (int)(GetVtkmprbasedata()->GetZ());
+
+ x = (int)(x*spc[0]);
+ y = (int)(y*spc[1]);
+ z = (int)(z*spc[2]);
+
+
+
+ if ((x!=_backX) || (y!=_backY) || (z!=_backZ)) {
+
+ if (_direction==0) {
+ _imageViewer2XYZ->SetXSlice( (int)(GetVtkmprbasedata()->GetX()) );
+ _ptsA->SetPoint(0, -x2, y1 , z );
+ _ptsA->SetPoint(1, -x2, y2 , z );
+ _ptsB->SetPoint(0, -x2, y , z1);
+ _ptsB->SetPoint(1, -x2, y , z2);
+ }
+ if (_direction==1) {
+ _imageViewer2XYZ->SetYSlice( (int)(GetVtkmprbasedata()->GetY()) );
+ _ptsA->SetPoint(0, x1 , y2 , z );
+ _ptsA->SetPoint(1, x2 , y2 , z );
+ _ptsB->SetPoint(0, x , y2 , z1);
+ _ptsB->SetPoint(1, x , y2 , z2);
+ }
+ if (_direction==2) {
+ _imageViewer2XYZ->SetZSlice( (int)(GetVtkmprbasedata()->GetZ()) );
+ _ptsA->SetPoint(0, x1 , y , -z2 );
+ _ptsA->SetPoint(1, x2 , y , -z2 );
+ _ptsB->SetPoint(0, x , y1, -z2 );
+ _ptsB->SetPoint(1, x , y2, -z2 );
+ }
+ _backX=x;
+ _backY=y;
+ _backZ=z;
+ }
+ wxVtkBaseView::Refresh();
+}
+//-------------------------------------------------------------------
+int wxVtkMPR2DView::GetActualSlice() // virtual
+{
+ int result;
+ if (_direction==0)
+ {
+ result = (int)(GetVtkmprbasedata()->GetX());
+ }
+ if (_direction==1)
+ {
+ result = (int)(GetVtkmprbasedata()->GetY());
+ }
+ if (_direction==2)
+ {
+ result = (int)(GetVtkmprbasedata()->GetZ());
+ }
+ return result;
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::SetActualSlice(int slice) // virtual
+{
+ if (_direction==0)
+ {
+ GetVtkmprbasedata()->SetX(slice);
+ }
+ if (_direction==1)
+ {
+ GetVtkmprbasedata()->SetY(slice);
+ }
+ if (_direction==2)
+ {
+ GetVtkmprbasedata()->SetZ(slice);
+ }
+}
+//-------------------------------------------------------------------
+bool wxVtkMPR2DView::IfMouseTouchX(double x, double y, double z)
+{
+ double delta=5;
+ bool result=false;
+ if (_direction==0)
+ {
+ }
+ if (_direction==1)
+ {
+ if (( x<GetVtkmprbasedata()->GetX()+delta ) && ( x>GetVtkmprbasedata()->GetX()-delta ))
+ {
+ result = true;
+ }
+ }
+ if (_direction==2)
+ {
+ if (( x<GetVtkmprbasedata()->GetX()+delta ) && ( x>GetVtkmprbasedata()->GetX()-delta ))
+ {
+ result = true;
+ }
+ }
+ return result;
+}
+//-------------------------------------------------------------------
+bool wxVtkMPR2DView::IfMouseTouchY(double x, double y, double z)
+{
+ double delta=5;
+ bool result=false;
+ if (_direction==0)
+ {
+ if (( y<GetVtkmprbasedata()->GetY()+delta ) && ( y>GetVtkmprbasedata()->GetY()-delta ))
+ {
+ result = true;
+ }
+ }
+ if (_direction==1)
+ {
+ }
+ if (_direction==2)
+ {
+ if (( y<GetVtkmprbasedata()->GetY()+delta ) && ( y>GetVtkmprbasedata()->GetY()-delta ))
+ {
+ result = true;
+ }
+ }
+ return result;
+}
+//-------------------------------------------------------------------
+bool wxVtkMPR2DView::IfMouseTouchZ(double x, double y, double z)
+{
+ double delta=5;
+ bool result=false;
+ if (_direction==0)
+ {
+ if (( z<GetVtkmprbasedata()->GetZ()+delta ) && ( z>GetVtkmprbasedata()->GetZ()-delta ))
+ {
+ result = true;
+ }
+ }
+ if (_direction==1)
+ {
+ if (( z<GetVtkmprbasedata()->GetZ()+delta ) && ( z>GetVtkmprbasedata()->GetZ()-delta ))
+ {
+ result = true;
+ }
+ }
+ if (_direction==2)
+ {
+ }
+ return result;
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::MoveX(double x, double y, double z)
+{
+ if (_direction==0)
+ {
+ }
+ if (_direction==1)
+ {
+ GetVtkmprbasedata()->SetX(x);
+ }
+ if (_direction==2)
+ {
+ GetVtkmprbasedata()->SetX(x);
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::MoveY(double x, double y, double z)
+{
+ if (_direction==0)
+ {
+ GetVtkmprbasedata()->SetY(y);
+ }
+ if (_direction==1)
+ {
+ }
+ if (_direction==2)
+ {
+ GetVtkmprbasedata()->SetY(y);
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::MoveZ(double x, double y, double z)
+{
+ if (_direction==0)
+ {
+ GetVtkmprbasedata()->SetZ(z);
+ }
+ if (_direction==1)
+ {
+ GetVtkmprbasedata()->SetZ(z);
+ }
+ if (_direction==2)
+ {
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::ChangeAxisColor(double x, double y, double z)
+{
+ double c1r=1,c1g=1,c1b=0;
+ double c2r=1,c2g=0,c2b=0;
+
+ if (_direction==0)
+ {
+ if (IfMouseTouchY(x,y,z)==true)
+ {
+ _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ if (IfMouseTouchZ(x,y,z)==true)
+ {
+ _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ }
+
+ if (_direction==1)
+ {
+ if (IfMouseTouchX(x,y,z)==true)
+ {
+ _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ if (IfMouseTouchZ(x,y,z)==true)
+ {
+ _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ }
+
+ if (_direction==2)
+ {
+ if (IfMouseTouchX(x,y,z)==true)
+ {
+ _lineBActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineBActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ if (IfMouseTouchY(x,y,z)==true)
+ {
+ _lineAActor->GetProperty()->SetDiffuseColor(c1r,c1g,c1b);
+ } else {
+ _lineAActor->GetProperty()->SetDiffuseColor(c2r,c2g,c2b);
+ }
+ }
+ Refresh();
+}
+//-------------------------------------------------------------------
+void wxVtkMPR2DView::TransfromeCoordViewWorld(double &X, double &Y, double &Z, int type) // virtual
+{
+ wxVtkBaseView::TransfromeCoordScreenToWorld(X,Y,Z,_direction);
+
+ if (_direction==0)
+ {
+ X = ((vtkMPRBaseData*)GetVtkBaseData())->GetX();
+ }
+ if (_direction==1)
+ {
+ Y = ((vtkMPRBaseData*)GetVtkBaseData())->GetY();
+ }
+ if (_direction==2)
+ {
+ Z = ((vtkMPRBaseData*)GetVtkBaseData())->GetZ();
+ }
+}
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//void boxVolumeObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) { // virtual
+// if (eventId==vtkCommand::StartInteractionEvent){
+// _renWin->SetDesiredUpdateRate(10);
+// }
+// if (eventId==vtkCommand::InteractionEvent){
+// _renWin->SetDesiredUpdateRate(0.001);
+// }
+// if (eventId==vtkCommand::EndInteractionEvent){
+// vtkPlanes *planes = vtkPlanes::New();
+// vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
+// boxwidget->GetPlanes(planes);
+// _volumeMapper->SetClippingPlanes(planes);
+// planes -> Delete();
+// }
+//}
+
+//-------------------------------------------------------------------
+//void boxVolumeObserver::SetRenWin( vtkRenderWindow *renWin ){
+// _renWin = renWin;
+//}
+//-------------------------------------------------------------------
+//void boxVolumeObserver::SetVolumeMapper(vtkVolumeRayCastMapper *volumeMapper){
+// _volumeMapper = volumeMapper;
+//}
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+// EED 9 fev 2007
+void boxSurfaceObserver::Execute(vtkObject *wdg, unsigned long eventId, void* calldata) { // virtual
+ vtkBoxWidget *boxwidget = reinterpret_cast<vtkBoxWidget*>(wdg);
+ boxwidget->GetPlanes(_planes);
+
+ if ( _vtkVolumeRayCastMapper != NULL )
+ {
+ _vtkVolumeRayCastMapper->RemoveAllClippingPlanes();
+// vtkPlanes *planes = vtkPlanes::New();
+// boxwidget->GetPlanes(planes);
+// _vtkVolumeRayCastMapper->SetClippingPlanes(planes);
+ _vtkVolumeRayCastMapper->SetClippingPlanes(_planes);
+ }
+
+// _actor->VisibilityOn();
+
+}
+//-------------------------------------------------------------------
+void boxSurfaceObserver::SetPlanes(vtkPlanes *planes){
+ _planes = planes;
+}
+//-------------------------------------------------------------------
+void boxSurfaceObserver::SetActor(vtkProp *actor){
+ _actor = actor;
+}
+
+//-------------------------------------------------------------------
+void boxSurfaceObserver::SetvtkVolumeRayCastMapper(vtkVolumeRayCastMapper *vtkvolumeraycastmapper)
+{
+ _vtkVolumeRayCastMapper = vtkvolumeraycastmapper;
+}
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxVtkMPR3DViewCntrlPanel::wxVtkMPR3DViewCntrlPanel(wxWindow *parent, wxVtkMPR3DView *wxvtkmpr3Dview )
+: wxPanel(parent, -1)
+{
+
+ wxPanel *panel = this;
+ _wxvtkmpr3Dview = wxvtkmpr3Dview;
+
+ int maxX = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionX();
+ int maxY = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionY();
+ int maxZ = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionZ();
+ wxCheckBox *ckBoxX = new wxCheckBox(panel,-1,_T("X "));
+ _positionX = new wxSlider(panel,-1,maxX/2,0,maxX, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
+ wxCheckBox *ckBoxY = new wxCheckBox(panel,-1,_T("Y "));
+ _positionY = new wxSlider(panel,-1,maxY/2,0,maxY, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
+ wxCheckBox *ckBoxZ = new wxCheckBox(panel,-1,_T("Z "));
+ _positionZ = new wxSlider(panel,-1,maxZ/2,0,maxZ, wxDefaultPosition, wxSize(150,40), wxSL_HORIZONTAL | wxSL_LABELS);
+ wxButton *btnColorTable = new wxButton (panel, -1, _T("Edit Color Table") );
+
+ _ckBoxXYZ = new wxCheckBox(panel,-1,_T("XYZ "));
+ _ckBoxPlane = new wxCheckBox(panel,-1,_T("Plane"));
+
+ ckBoxX->SetValue(false);
+ ckBoxY->SetValue(false);
+ ckBoxZ->SetValue(false);
+ _ckBoxXYZ->SetValue(true);
+ _ckBoxPlane->SetValue(false);
+
+ _positionX->SetSize(400,20);
+ _positionY->SetSize(400,20);
+ _positionZ->SetSize(400,20);
+
+ Connect(ckBoxX->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX );
+ Connect(_positionX->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionX );
+ Connect(ckBoxY->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY );
+ Connect(_positionY->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionY );
+ Connect(ckBoxZ->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ );
+ Connect(_positionZ->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionZ );
+ Connect(btnColorTable->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnEditColorTable );
+
+ Connect(_ckBoxXYZ->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisXYZ );
+ Connect(_ckBoxPlane->GetId(), wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisiblePlane );
+
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
+// wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
+
+// wxBoxSizer *sizerH4 = new wxBoxSizer(wxHORIZONTAL);
+ wxFlexGridSizer *sizerH4 = new wxFlexGridSizer(10);
+ wxFlexGridSizer *sizerH5 = new wxFlexGridSizer(10);
+
+
+
+//EED 28 sep 2006
+// wxFlexGridSizer *sizerH6 = new wxFlexGridSizer(10);
+// wxFlexGridSizer *sizerH7 = new wxFlexGridSizer(10);
+
+// sizerH4->Add( ckBoxX , 1, wxALL|wxEXPAND, 0);
+// sizerH4->Add( new wxStaticText(panel, -1," ") , 1, wxALL|wxEXPAND, 0);
+// sizerH4->Add( _positionX , 1, wxALL|wxEXPAND, 0);
+
+// sizerH5->Add( ckBoxY , 1, wxALL|wxEXPAND, 0);
+// sizerH5->Add( new wxStaticText(panel, -1," ") , 1, wxALL|wxEXPAND, 0);
+// sizerH5->Add( _positionY , 1, wxALL|wxEXPAND, 0);
+
+// sizerH6->Add( ckBoxZ , 1, wxALL|wxEXPAND, 0);
+// sizerH6->Add( new wxStaticText(panel, -1," ") , 1, wxALL|wxEXPAND, 0);
+// sizerH6->Add( _positionZ , 1, wxALL|wxEXPAND, 0);
+
+// sizerH7->Add( _ckBoxXYZ , 1, wxALL|wxEXPAND, 0);
+// sizerH7->Add( _ckBoxPlane , 1, wxALL|wxEXPAND, 0);
+
+// sizer->Add( sizerH4 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH5 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH6 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH7 , 1, wxALL|wxEXPAND, 2);
+
+ sizerH4->Add( _positionX ,1,wxGROW , 0 );
+ sizerH4->Add( ckBoxX ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED , 0 );
+ sizerH4->Add( _positionY ,1,wxGROW , 0 );
+ sizerH4->Add( ckBoxY ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED , 0 );
+ sizerH4->Add( _positionZ ,1,wxGROW , 0 );
+ sizerH4->Add( ckBoxZ ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED , 0 );
+ sizerH4->Add( btnColorTable ,0,wxALIGN_CENTER_VERTICAL|wxSHAPED , 0 );
+
+ sizerH5->Add( _ckBoxXYZ , 1, wxALL|wxEXPAND, 0);
+ sizerH5->Add( _ckBoxPlane , 1, wxALL|wxEXPAND, 0);
+ sizerH5->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+// sizerH5->Add( ckBoxX , 1, wxALL|wxEXPAND, 0);
+// sizerH5->Add( ckBoxY , 1, wxALL|wxEXPAND, 0);
+// sizerH5->Add( ckBoxZ , 1, wxALL|wxEXPAND, 0);
+
+ sizer->Add( sizerH4 , 1, wxALL|wxGROW, 2);
+ sizer->Add( sizerH5 , 1, wxALL|wxEXPAND, 2);
+
+
+ panel->SetSize(400,50);
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->Layout();
+
+ panel->SetEventHandler((wxEvtHandler*)this);
+
+}
+//-------------------------------------------------------------------
+wxVtkMPR3DViewCntrlPanel::~wxVtkMPR3DViewCntrlPanel()
+{
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::Refresh()
+{
+// wxPanel::Refresh();
+ _positionX->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetX( )) );
+ _positionY->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetY( )) );
+ _positionZ->SetValue( (int)(_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetZ( )) );
+}
+/*
+//-------------------------------------------------------------------
+int wxVtkMPR3DViewCntrlPanel::GetIdTissue()
+{
+ int idTissue=-1;
+ if (_surfA->GetValue()==true)
+ {
+ idTissue=0;
+ }
+ if (_surfB->GetValue()==true)
+ {
+ idTissue=1;
+ }
+ if (_surfC->GetValue()==true)
+ {
+ idTissue=2;
+ }
+ if (_surfD->GetValue()==true)
+ {
+ idTissue=3;
+ }
+
+ return idTissue;
+}
+*/
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnEditColorTable(wxCommandEvent& event)
+{
+
+ vtkColorTransferFunction *ctfun = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetvtkColorTransferFunction();
+ std::vector<double> *ctfunVectorPoint = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorPoint();
+ std::vector<double> *ctfunVectorRed = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorRed();
+ std::vector<double> *ctfunVectorGreen = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorGreen();
+ std::vector<double> *ctfunVectorBlue = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetctFunVectorBlue();
+
+ void *p=this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer();
+
+
+ int i=0,xi,r,g,b;
+
+ vtkImageData *imagedata = this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+
+ HistogramDialog* hDlg=new HistogramDialog(NULL,_T("Color table"),imagedata,2);
+
+
+ hDlg->erasePointsTransferenceFunction();
+ int ctfSize=ctfunVectorRed->size();
+ if(ctfSize>0)
+ {
+// MACHETE OJO Eduardo
+ int i=0;
+ while(i<ctfSize)
+ {
+ double gr = (*ctfunVectorPoint)[i];
+ double r = (*ctfunVectorRed)[i];
+ double g = (*ctfunVectorGreen)[i];
+ double b = (*ctfunVectorBlue)[i];
+ hDlg->addColorPoint(gr,r*255,g*255,b*255);
+ i++;
+ }
+ }
+
+ //
+ // when the user had changed the transference Function
+ //
+
+ //setting variables if the user wants to do refresh
+
+ hDlg->setCTF(ctfun);
+ hDlg->setMPR3Dview(_wxvtkmpr3Dview);
+
+ if(hDlg->ShowModal()== wxID_OK )
+ {
+
+ // -- vtkColorTransferFunction --
+ ctfun->RemoveAllPoints ();
+ //clean colors
+ ctfunVectorPoint->clear();
+ ctfunVectorRed->clear();
+ ctfunVectorGreen->clear();
+ ctfunVectorBlue->clear();
+
+ int nCTFpoints=hDlg->getSizeBarColor();
+// Machete .. Ojo Eduardo
+ i=0;
+ while(i<nCTFpoints)
+ {
+ hDlg->getDataBarColorPoint(i,xi,r,g,b);
+ /*
+ if (i==0)
+ {
+ hDlg->getDataBarColorPoint(1,xi,r,g,b);
+ }
+ if (i==nCTFpoints)
+ {
+ hDlg->getDataBarColorPoint(i-1,xi,r,g,b);
+ }
+ */
+ ctfun->AddRGBPoint(xi,r/255.0,g/255.0,b/255.0 );
+ ctfunVectorPoint->push_back(xi);
+ ctfunVectorRed->push_back(r/255.0);
+ ctfunVectorGreen->push_back(g/255.0);
+ ctfunVectorBlue->push_back(b/255.0);
+ i++;
+
+ }
+
+ }
+
+ else
+ {
+
+ if(hDlg->getRefreshed())
+ {
+ // -- vtkColorTransferFunction --
+ ctfun->RemoveAllPoints ();
+
+ int i=0;
+ int size=ctfunVectorPoint->size();
+
+ for(i=0;i<size;i++)
+ {
+ double grey2=(*ctfunVectorPoint)[i];
+ double red =(*ctfunVectorRed)[i];
+ double green =(*ctfunVectorGreen)[i];
+ double blue = (*ctfunVectorBlue)[i];
+ ctfun->AddRGBPoint(grey2,red,green,blue);
+ }
+ }
+
+ }
+
+ hDlg->Destroy();
+}
+
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX(wxCommandEvent& event)
+{
+ _wxvtkmpr3Dview->VisibleImageActor(0, event.IsChecked() );
+ _wxvtkmpr3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY(wxCommandEvent& event)
+{
+ _wxvtkmpr3Dview->VisibleImageActor(1, event.IsChecked() );
+ _wxvtkmpr3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ(wxCommandEvent& event)
+{
+ _wxvtkmpr3Dview->VisibleImageActor(2, event.IsChecked() );
+ _wxvtkmpr3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnVisibleAxisXYZ(wxCommandEvent& event)
+{
+ _wxvtkmpr3Dview->VisiblePointWidget(event.IsChecked());
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnVisiblePlane(wxCommandEvent& event)
+{
+ _wxvtkmpr3Dview->VisiblePlaneWidget(event.IsChecked());
+}
+
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnPositionX(wxScrollEvent& event)
+{
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX( _positionX->GetValue() );
+ _wxvtkmpr3Dview->RefreshView();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnPositionY(wxScrollEvent& event)
+{
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY( _positionY->GetValue() );
+ _wxvtkmpr3Dview->RefreshView();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DViewCntrlPanel::OnPositionZ(wxScrollEvent& event)
+{
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ( _positionZ->GetValue() );
+ _wxvtkmpr3Dview->RefreshView();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxVtkClipping3DViewCntrlPanel::wxVtkClipping3DViewCntrlPanel(wxWindow *parent, wxVtkClipping3DView *wxvtkclipping3Dview )
+: wxPanel(parent, -1)
+{
+ wxPanel *panel = this;
+ _wxvtkclipping3Dview = wxvtkclipping3Dview;
+
+//EEDx2.6
+// wxStaticText *text1 = new wxStaticText(panel, -1,_T(" "));
+// wxStaticText *text2 = new wxStaticText(panel, -1,_T(" "));
+
+ _surfA = new wxRadioButton(panel,-1,_T("A"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
+ _surfB = new wxRadioButton(panel,-1,_T("B"));
+ _surfC = new wxRadioButton(panel,-1,_T("C"));
+ _surfD = new wxRadioButton(panel,-1,_T("D"));
+
+ wxCheckBox *ckVolum = new wxCheckBox(panel,-1,_T("Vol"));
+ wxCheckBox *ckBoxSurface = new wxCheckBox(panel,-1,_T("Surface Box"));
+ wxCheckBox *ckBoxVolume = new wxCheckBox(panel,-1,_T("Volume Box"));
+
+ _color = new wxButton(panel,-1,_T(""));
+ _visible = new wxCheckBox(panel,-1,_T("Vis"));
+ _opacity = new wxSlider(panel,-1,50,0,100, wxDefaultPosition, wxSize(800,40), wxSL_HORIZONTAL | wxSL_LABELS);
+
+ wxStaticText *isoValueTitle = new wxStaticText(panel,-1,_T("isoValue"));
+ _isoValue = new wxSlider(panel,-1,2000,110,2000, wxDefaultPosition, wxSize(800,40), wxSL_HORIZONTAL | wxSL_AUTOTICKS | wxSL_LABELS);
+
+
+ _wireFrameRep = new wxRadioButton(panel,-1,_T("WireFrame"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
+ _surfaceRep = new wxRadioButton(panel,-1,_T("Surface"));
+
+
+ double range[2];
+ vtkImageData *vtkimagedata = wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+ vtkimagedata->GetScalarRange( range );
+ _isoValue->SetRange( (int)(range[1]*0.1) , (int)(range[1]) );
+ _isoValue->SetValue( (int)(wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIsovalue(0)) );
+
+
+ _isoValue->SetTickFreq(25,0);
+
+ _isoValueSpin = new wxSlider(panel , -1,5,1,10,wxDefaultPosition , wxSize(25,45), wxSL_VERTICAL | wxSL_AUTOTICKS |wxSL_LEFT );
+ _isoValueSpin->SetRange(1,8);
+ _isoValueSpin->SetValue(5);
+ Connect(_isoValueSpin->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValueSpin );
+
+ wxButton *btnSTL = new wxButton(panel,-1,_T("Create STL File"));
+ wxButton *btnSaveRaw = new wxButton(panel,-1,_T("Save Raw Volume"));
+
+ wxButton *btnVolumeFunctions = new wxButton(panel,-1,_T("Read Volume Functions"));
+
+
+ Connect(btnSTL->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnCreateFileSTL );
+ Connect(btnSaveRaw->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnSaveRawVolume );
+ Connect(btnVolumeFunctions->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnVolumeFunctions );
+
+
+ wxButton *btnMeshVTKLoad = new wxButton(panel,-1,_T("Load Mesh"));
+ Connect(btnMeshVTKLoad->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnBtnMeshVTKLoad );
+
+
+/*
+ int maxX = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionX();
+ int maxY = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionY();
+ int maxZ = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetMaxPositionZ();
+ wxCheckBox *ckBoxX = new wxCheckBox(panel,-1,"X");
+ _positionX = new wxSlider(panel,-1,maxX/2,0,maxX, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
+ wxCheckBox *ckBoxY = new wxCheckBox(panel,-1,"Y");
+ _positionY = new wxSlider(panel,-1,maxY/2,0,maxY, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
+ wxCheckBox *ckBoxZ = new wxCheckBox(panel,-1,"Z");
+ _positionZ = new wxSlider(panel,-1,maxZ/2,0,maxZ, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL | wxSL_LABELS);
+*/
+
+// ckVolum->Enable(false);
+ ckBoxSurface->SetValue(false);
+ ckBoxVolume->SetValue(false);
+ _color->SetSize(40,20);
+ _opacity->SetSize(370,20);
+// ckBoxX->SetValue(true);
+// ckBoxY->SetValue(true);
+// ckBoxZ->SetValue(true);
+ _surfA->SetValue(true);
+ _wireFrameRep->SetValue(false);
+ _surfaceRep->SetValue(true);
+ _visible->SetValue(false);
+// _positionX->SetSize(400,20);
+// _positionY->SetSize(400,20);
+// _positionZ->SetSize(400,20);
+
+ Connect(ckVolum->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleVolume );
+ Connect(ckBoxVolume->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleBoxVolume );
+
+ Connect(_surfA->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface );
+ Connect(_surfB->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface );
+ Connect(_surfC->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface );
+ Connect(_surfD->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnSurface );
+ Connect(ckBoxSurface->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleBoxSurface );
+
+ Connect(_wireFrameRep->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame );
+ Connect(_surfaceRep->GetId() , wxEVT_COMMAND_RADIOBUTTON_SELECTED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame );
+
+ Connect(_color->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnColor );
+ Connect(_visible->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnVisibleSurface );
+ Connect(_opacity->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnOpacity );
+
+//EED 27Dic2007
+// Connect(_isoValue->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValue );
+ Connect(_isoValue->GetId() , wxEVT_SCROLL_THUMBRELEASE , (wxObjectEventFunction) &wxVtkClipping3DViewCntrlPanel::OnIsoValue );
+
+/*
+ Connect(ckBoxX->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisX );
+ Connect(_positionX->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionX );
+ Connect(ckBoxY->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisY );
+ Connect(_positionY->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionY );
+ Connect(ckBoxZ->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnVisibleAxisZ );
+ Connect(_positionZ->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxVtkMPR3DViewCntrlPanel::OnPositionZ );
+*/
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
+ wxFlexGridSizer *sizerH0 = new wxFlexGridSizer(20);
+ wxFlexGridSizer *sizerH1 = new wxFlexGridSizer(20);
+ wxFlexGridSizer *sizerH2 = new wxFlexGridSizer(10);
+ wxFlexGridSizer *sizerH3 = new wxFlexGridSizer(10);
+ wxFlexGridSizer *sizerH4 = new wxFlexGridSizer(10);
+ wxFlexGridSizer *sizerH5 = new wxFlexGridSizer(10);
+ wxFlexGridSizer *sizerH6 = new wxFlexGridSizer(10);
+
+ sizerH0->Add( ckVolum , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( ckBoxVolume , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( btnVolumeFunctions , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH0->Add( btnMeshVTKLoad , 1, wxALL|wxEXPAND, 0);
+
+
+ sizerH1->Add( _surfA , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( _surfB , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( _surfC , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( _surfD , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( ckBoxSurface , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( btnSTL , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH1->Add( btnSaveRaw , 1, wxALL|wxEXPAND, 0);
+
+
+// sizerH2->Add( new wxStaticText(panel, -1,_T(" ") , 1, wxALL|wxEXPAND, 0);
+ sizerH2->Add( _color , 1, wxALL|wxEXPAND, 0);
+ sizerH2->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH2->Add( _visible , 1, wxALL|wxEXPAND, 0);
+ sizerH2->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+
+
+ sizerH2->Add( _wireFrameRep , 1,wxSHAPED | wxALIGN_CENTER_VERTICAL , 0);
+ sizerH2->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+ sizerH2->Add( _surfaceRep , 1,wxSHAPED | wxALIGN_CENTER_VERTICAL , 0);
+ sizerH2->Add( new wxStaticText(panel, -1,_T(" ")) , 1, wxALL|wxEXPAND, 0);
+
+ sizerH2->Add( _opacity , 1, wxALL|wxEXPAND, 0);
+
+
+ sizerH3->Add( isoValueTitle , 1, wxALL|wxEXPAND, 0);
+ sizerH3->Add( _isoValueSpin , 1, wxALL|wxEXPAND, 0);
+ sizerH3->Add( _isoValue , 1, wxALL|wxEXPAND, 0);
+
+/*
+ sizerH4->Add( ckBoxX , 1, wxALL|wxEXPAND, 0);
+ sizerH4->Add( text2 , 1, wxALL|wxEXPAND, 0);
+ sizerH4->Add( _positionX , 1, wxALL|wxEXPAND, 0);
+
+ sizerH5->Add( ckBoxY , 1, wxALL|wxEXPAND, 0);
+ sizerH5->Add( text2 , 1, wxALL|wxEXPAND, 0);
+ sizerH5->Add( _positionY , 1, wxALL|wxEXPAND, 0);
+
+ sizerH6->Add( ckBoxZ , 1, wxALL|wxEXPAND, 0);
+ sizerH6->Add( text2 , 1, wxALL|wxEXPAND, 0);
+ sizerH6->Add( _positionZ , 1, wxALL|wxEXPAND, 0);
+*/
+ sizer->Add( sizerH0 , 1, wxALL|wxEXPAND, 2);
+ sizer->Add( sizerH1 , 1, wxALL|wxEXPAND, 2);
+ sizer->Add( sizerH2 , 1, wxALL|wxEXPAND, 2);
+ sizer->Add( sizerH3 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH4 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH5 , 1, wxALL|wxEXPAND, 2);
+// sizer->Add( sizerH6 , 1, wxALL|wxEXPAND, 2);
+
+ panel->SetSize(300,60);
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->Layout();
+
+ panel->SetEventHandler((wxEvtHandler*)this);
+
+}
+//-------------------------------------------------------------------
+wxVtkClipping3DViewCntrlPanel::~wxVtkClipping3DViewCntrlPanel()
+{
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::Refresh()
+{
+// wxPanel::Refresh();
+/*
+ _positionX->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetX( ) );
+ _positionY->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetY( ) );
+ _positionZ->SetValue( _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetZ( ) );
+*/
+}
+//-------------------------------------------------------------------
+int wxVtkClipping3DViewCntrlPanel::GetIdTissue()
+{
+ int idTissue=-1;
+ if (_surfA->GetValue()==true)
+ {
+ idTissue=0;
+ }
+ if (_surfB->GetValue()==true)
+ {
+ idTissue=1;
+ }
+ if (_surfC->GetValue()==true)
+ {
+ idTissue=2;
+ }
+ if (_surfD->GetValue()==true)
+ {
+ idTissue=3;
+ }
+
+ return idTissue;
+}
+/*
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisX(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->VisibleImageActor(0, event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisY(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->VisibleImageActor(1, event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleAxisZ(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->VisibleImageActor(2, event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+}
+*/
+
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnSurface(wxCommandEvent& event)
+{
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+ // Color
+ vtkActor *tmpActor;
+ tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
+ double rgb[3];
+ tmpActor->GetProperty()->GetColor( rgb );
+ wxColour colour( (int)(rgb[0]*255) , (int)(rgb[1]*255) , (int)(rgb[2]*255) );
+ _color->SetBackgroundColour(colour);
+
+ // Visible
+ _visible->SetValue(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVisibleTissue(idTissue));
+
+ // Opacity
+ _opacity->SetValue( (int)(tmpActor->GetProperty()->GetOpacity()*100) );
+
+ // Representation Type WireFrame / Surface
+ _surfaceRep->SetValue(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRepresentationType(idTissue));
+ _wireFrameRep->SetValue(!_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRepresentationType(idTissue));
+
+ // isoValue
+ int isoValue= (int)(_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIsovalue(idTissue));
+ _isoValue->SetValue(isoValue);
+ }
+}
+
+
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnRepresentationSurfaceWireFrame(wxCommandEvent& event)
+{
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+ _wxvtkclipping3Dview->SetRepSurfaceWireFrame(idTissue , _surfaceRep->GetValue() );
+
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+
+ }
+}
+
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleVolume(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->VisibleVolumeActor( event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleBoxSurface(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->SetVisibleBoxSurface(event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleBoxVolume(wxCommandEvent& event)
+{
+ _wxvtkclipping3Dview->SetVisibleBoxVolume(event.IsChecked() );
+ _wxvtkclipping3Dview->Refresh();
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnColor(wxCommandEvent& event)
+{
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+// EED 17 Janvier 2007
+ wxColourDialog dlgColour(this);
+// dlgColour.ShowModal();
+ if( dlgColour.ShowModal( ) == wxID_OK )
+ {
+ vtkActor *tmpActor;
+ tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
+ float r=dlgColour.GetColourData().GetColour().Red()/255;
+ float g=dlgColour.GetColourData().GetColour().Green()/255;
+ float b=dlgColour.GetColourData().GetColour().Blue()/255;
+ tmpActor->GetProperty()->SetColor( r , g , b );
+ _color->SetBackgroundColour(dlgColour.GetColourData().GetColour());
+
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ }
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnVisibleSurface(wxCommandEvent& event)
+{
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+ _wxvtkclipping3Dview->VisibleActor(idTissue, _visible->GetValue());
+
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnOpacity(wxScrollEvent& event)
+{
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+ vtkActor *tmpActor;
+ tmpActor = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
+ float opacity=_opacity->GetValue();
+ tmpActor->GetProperty()->SetOpacity( opacity/100 );
+
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ }
+}
+
+//----------------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnIsoValueSpin(wxScrollEvent& event)
+{
+ int value = _isoValue->GetValue();
+ int delta= (int)pow( 4 , _isoValueSpin->GetValue() );
+ int min=value - delta/2;
+ int max=value + delta/2;
+ if (min<0)
+ {
+ min=0;
+ max=delta;
+ }
+ _isoValue->SetRange(min,max);
+}
+
+
+//------------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnIsoValue(wxScrollEvent& event)
+{
+ wxBusyCursor wait;
+
+ int idTissue=GetIdTissue();
+ if (idTissue!=-1)
+ {
+ int isoValue=_isoValue->GetValue();
+ _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->SetIsovalue(idTissue,isoValue);
+// wxString tmpStr;
+// tmpStr.Printf("%d",isoValue);
+
+ _wxvtkclipping3Dview->Refresh();
+
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ }
+
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnBtnCreateFileSTL(wxCommandEvent& event)
+{
+
+ int idTissue=GetIdTissue();
+ if (idTissue==-1)
+ {
+ idTissue=0;
+ }
+
+
+ wxString dirSTL = wxGetHomeDir( ) ;
+ wxFileDialog dialog( this, _T("Choose a directory..."), dirSTL , _T(""), _T("*.*"), wxSAVE );
+
+ if( dialog.ShowModal( ) == wxID_OK )
+ {
+
+
+ // ------------------------------------------------------------------------
+ // 1. GENERATE STL FILES
+ // ------------------------------------------------------------------------
+// const char* fileprefix = "c:\\Creatis\\";
+ std::string prefix = (const char*) (dialog.GetPath().mb_str() );
+ std::string filename;
+
+ // 1.1. Se hace un filtro triangular puesto que el stl writer solo recibe poligonos triangulares.
+
+ vtkTriangleFilter *filtro = vtkTriangleFilter::New();
+
+
+ filtro->SetInput( this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTissueClipper(idTissue)->GetOutput() );
+ vtkPolyDataConnectivityFilter *pdcf = vtkPolyDataConnectivityFilter::New();
+ pdcf->SetInput( filtro->GetOutput() );
+ vtkClosePolyData *cpd = vtkClosePolyData::New();
+ cpd->SetInput( pdcf->GetOutput() );
+
+ // 1.2 se escribe a disco el archivo stl de la superficie interna
+ cpd->Update();
+ vtkSTLWriter *writer = vtkSTLWriter::New();
+ writer->SetInput( cpd->GetOutput() );
+ filename =prefix;
+ writer->SetFileName(filename.c_str());
+ writer->SetFileTypeToASCII();
+ writer->Write();
+ writer->Delete();
+
+
+ filtro->Delete();
+ cpd->Delete();
+ pdcf->Delete();
+ }
+
+}
+
+//EED 30 Janvier 2007
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnBtnSaveRawVolume(wxCommandEvent& event)
+{
+ wxFileDialog dialog(this, _T("Choose a file"), _T(""), _T(""), _T("*.maracas"), wxSAVE );
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ std::string directory = (const char*) (dialog.GetDirectory().mb_str() );
+ std::string filename = (const char*) (dialog.GetFilename().mb_str() );
+ float rescalaSlope = 1;
+ float rescalaIntercept = 0;
+ vtkMPRBaseData *vtkmprbasedata = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData();
+ vtkImageData *vtkimagedata = vtkmprbasedata->GetImageData();
+ int dim[3];
+ vtkimagedata->GetDimensions(dim);
+ int voi[6];
+ voi[0]=0;
+ voi[1]=dim[0];
+ voi[2]=0;
+ voi[3]=dim[1];
+ voi[4]=0;
+ voi[5]=dim[2];
+//EED 10 oct 2007 MaracasVisu pour bbMaracasvisu
+ marRAW2Files marraw2;
+ marraw2.saveVolume(directory,filename,vtkimagedata,voi,rescalaSlope,rescalaIntercept);
+ }
+}
+
+//EED 22 Fevrier 2007
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnBtnVolumeFunctions(wxCommandEvent& event)
+{
+
+ int i=0,xi,yi,r,g,b;
+ vtkColorTransferFunction* ctfun = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetColorTransferenceFunction();
+ vtkPiecewiseFunction* tfun = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetTransferencefunction();
+ std::vector<double>* gtf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreyValuesTransferenceFVector();
+ std::vector<double>* itf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetIntensityValuesTransferenceFVector();
+ std::vector<double>* greyctf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreyValueColorsOfColorTransferenceFVector();
+ std::vector<double>* rctf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetRedColorsOfColorTransferenceFVector();
+ std::vector<double>* gctf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetGreenColorsOfColorTransferenceFVector();
+ std::vector<double>* bctf = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetBlueColorsOfColorTransferenceFVector();
+ vtkImageData *imagedata = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+
+ //use for update in the refresh
+ /*
+ vtkVolumeRayCastMapper* volumeMapper = this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVolumeMapper();
+ vtkVolume* newvol =this->_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetVolumeActor();
+ */
+
+ /*
+ MMLR BORRAME
+ wxFileDialog dialog(this, _T("Choose a file"), _T("c:/Maracas_configuration"),_T(""), _T("*.MarVolConf"), wxOPEN);
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions( (char *)dialog.GetPath().c_str() );
+
+
+ }
+ */
+
+ HistogramDialog* hDlg=new HistogramDialog(NULL,_T("Histogram Dialog"),imagedata,1);
+ //
+ // put in a method
+ //
+ int tfSize=gtf->size();
+ if(tfSize>0)
+ {
+ int i=0;
+ hDlg->erasePointsTransferenceFunction();
+ while(i<tfSize)
+ {
+ double g=(*gtf)[i];
+ double in=(*itf)[i];
+ hDlg->addPointToTransferenceFunction(g,in*100);
+ i++;
+ }
+
+ }
+
+ int ctfSize=rctf->size();
+ if(ctfSize>0)
+ {
+ int i=0;
+ while(i<ctfSize)
+ {
+ double gr=(*greyctf)[i];
+ double r=(*rctf)[i];
+ double g=(*gctf)[i];
+ double b=(*bctf)[i];
+ hDlg->addColorPoint(gr,r*255,g*255,b*255);
+ i++;
+ }
+ }
+ //setting variables if the user wants to do refresh
+ hDlg->setCTF(ctfun);
+ hDlg->setTF(tfun);
+ hDlg->setClipping3DView(_wxvtkclipping3Dview);
+ /*
+ hDlg->setVolume(newvol);
+ hDlg->setVolumeMapper(volumeMapper);
+ */
+ //
+ // when the user had changed the transference Function
+ //
+ if(hDlg->ShowModal()== wxID_OK )
+ {
+ // -- vtkPiecewiseFunction --
+ tfun->RemoveAllPoints();
+ gtf->clear();
+ itf->clear();
+
+ int nTFPoints=hDlg->getSizeTransferenceFunction();
+ int i=0;
+ while(i<nTFPoints)
+ {
+ hDlg->getTransferenceFunctionPoint(i,xi,yi);
+ tfun->AddPoint( xi , yi/100.0 );
+ gtf->push_back(xi);
+ itf->push_back(yi/100.0);
+ i++;
+ }
+ // -- vtkColorTransferFunction --
+ ctfun->RemoveAllPoints ();
+ //clean colors
+ rctf->clear();
+ gctf->clear();
+ bctf->clear();
+ greyctf->clear();
+
+ int nCTFpoints=hDlg->getSizeBarColor();
+ i=0;
+ while(i<nCTFpoints)
+ {
+ hDlg->getDataBarColorPoint(i,xi,r,g,b);
+ ctfun->AddRGBPoint(xi,r/255.0,g/255.0,b/255.0 );
+ rctf->push_back(r/255.0);
+ gctf->push_back(g/255.0);
+ bctf->push_back(b/255.0);
+ greyctf->push_back(xi);
+ i++;
+ }
+ //---------------------------------
+ // Refreshing and sending the event
+ //---------------------------------
+ //_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions();
+ _wxvtkclipping3Dview->Refresh();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+
+ /*
+ volumeMapper->Update();
+ newvol->Update();
+ */
+ }
+
+ else
+ {
+
+ if(hDlg->getRefreshed())
+ {
+ int i=0,size;
+ //--Transference Function----
+ tfun->RemoveAllPoints();
+ i=0;
+ size=gtf->size();
+ for(i=0;i<size;i++)
+ {
+ double grey1=(*gtf)[i];
+ double in2=(*itf)[i];
+ tfun->AddPoint( grey1 , in2 );
+ }
+
+ // -- vtkColorTransferFunction --
+ ctfun->RemoveAllPoints ();
+
+ i=0;
+ size=greyctf->size();
+ for(i=0;i<size;i++)
+ {
+ double grey2=(*greyctf)[i];
+ double red =(*rctf)[i];
+ double green =(*gctf)[i];
+ double blue = (*bctf)[i];
+ ctfun->AddRGBPoint(grey2,red,green,blue);
+ }
+
+ //---------------------------------
+ // Refreshing and sending the event
+ //---------------------------------
+ //_wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadVolumeFunctions();
+ _wxvtkclipping3Dview->Refresh();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+
+ /*
+ volumeMapper->Update();
+ newvol->Update();
+ */
+ }
+
+ }
+ //destroy the dialog
+ hDlg->Destroy();
+}
+
+//EED 23 Mai 2007
+//-------------------------------------------------------------------
+void wxVtkClipping3DViewCntrlPanel::OnBtnMeshVTKLoad(wxCommandEvent& event)
+{
+ wxFileDialog dialog(this, _T("Choose a file"), _T("c:/Maracas_configuration"),_T(""), _T("*.vtk"), wxOPEN);
+ if (dialog.ShowModal() == wxID_OK)
+ {
+ _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->ReadMeshVTK( (char *)dialog.GetPath().c_str() );
+ _wxvtkclipping3Dview->Refresh();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkclipping3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ }
+}
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+
+wxVtkMPR3DView::wxVtkMPR3DView( wxVtk3DBaseView *wxvtk3Dbaseview )
+{
+ _wxvtk3Dbaseview = wxvtk3Dbaseview;
+ _vtkmpr3Ddataviewer = NULL;
+ _wxvtkmpr3DviewCntrlPanel = NULL;
+}
+
+//-------------------------------------------------------------------
+wxVtkMPR3DView::~wxVtkMPR3DView()
+{
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::Refresh() // virtual
+{
+ _vtkmpr3Ddataviewer -> Refresh();
+ if (_wxvtkmpr3DviewCntrlPanel!=NULL)
+ {
+ _wxvtkmpr3DviewCntrlPanel->Refresh();
+ }
+
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::RefreshView() // virtual
+{
+ double spc[3];
+ this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetSpacing(spc);
+
+ double nx=1,ny=0,nz=0;
+ Refresh();
+ double x=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetX();
+ double y=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetY();
+ double z=GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetZ();
+
+ x=x*spc[0];
+ y=y*spc[1];
+ z=z*spc[2];
+
+ _pointWidget->SetPosition( x,y,z );
+
+
+ double in[3];
+ double normal[3];
+ vtkTransform *transform = GetVtkMPR3DDataViewer ()->GetVtkMPRBaseData()->GetTransformOrientation();
+ in[0]=1; in[1]=0; in[2]=0;
+ transform->TransformPoint(in,normal);
+ _planeWidget->SetNormal( normal[0],normal[1],normal[2] );
+
+
+ _planeWidget->SetCenter( x,y,z );
+ _planeWidget->UpdatePlacement();
+ _planeWidget->GetPolyData(_vtkplane);
+}
+//-------------------------------------------------------------------
+wxPanel* wxVtkMPR3DView::CreateControlPanel(wxWindow *parent)
+{
+ _wxvtkmpr3DviewCntrlPanel = new wxVtkMPR3DViewCntrlPanel(parent,this);
+ return _wxvtkmpr3DviewCntrlPanel;
+}
+//-------------------------------------------------------------------
+vtkMPR3DDataViewer* wxVtkMPR3DView::GetVtkMPR3DDataViewer()
+{
+ return _vtkmpr3Ddataviewer;
+}
+//-------------------------------------------------------------------
+wxVtk3DBaseView* wxVtkMPR3DView::GetWxvtk3Dbaseview()
+{
+ return _wxvtk3Dbaseview;
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::Configure(){
+ _wxvtk3Dbaseview->Configure();
+
+ // Actors are added to the renderer.
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetOutlineActor() );
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(0) ); // _saggital
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(1) ); // _axial
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(2) ); // _coronal
+
+
+ // An initial camera view is created. The Dolly() method moves
+ // the camera towards the FocalPoint, thereby enlarging the image.
+ _wxvtk3Dbaseview->GetRenderer()->SetActiveCamera(_wxvtk3Dbaseview->GetCamera());
+ _wxvtk3Dbaseview->GetRenderer()->ResetCamera ();
+ _wxvtk3Dbaseview->GetCamera()->Dolly(1.5);
+
+ // Set a background color for the renderer and set the size of the
+ // render window (expressed in pixels).
+ _wxvtk3Dbaseview->GetRenderer()->SetBackground( 0.36 , 0.36 , 0.36 );
+ _wxvtk3Dbaseview->GetRenWin()->SetSize(400, 400);
+
+ // Note that when camera movement occurs (as it does in the Dolly()
+ // method), the clipping planes often need adjusting. Clipping planes
+ // consist of two planes: near and far along the view direction. The
+ // near plane clips out objects in front of the plane; the far plane
+ // clips out objects behind the plane. This way only what is drawn
+ // between the planes is actually rendered.
+ _wxvtk3Dbaseview->GetRenderer()->ResetCameraClippingRange();
+
+
+
+ // vtkPointWidget
+ _myCallback = vtkmyPWCallback_3DPointWidget::New();
+ _myCallback->SetWxVtkMPR3DView(this);
+
+ _pointWidget = vtkPointWidget::New();
+ _myCallback->SetVtkPointWidget(_pointWidget);
+ _pointWidget->SetInteractor( GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor() );
+ _pointWidget->SetInput( GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
+ _pointWidget->AllOff();
+ _pointWidget->PlaceWidget();
+// _pointWidget->SetPosition( x,y,z );
+ _pointWidget->On();
+ _pointWidget->AddObserver(vtkCommand::InteractionEvent,_myCallback);
+
+
+// PlaneWidget
+ _planeWidget = vtkPlaneWidget::New();
+ _myCallback->SetVtkPlaneWidget(_planeWidget);
+ _planeWidget->SetInput( GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
+ _planeWidget->NormalToXAxisOn();
+ _planeWidget->SetResolution(50);
+ _planeWidget->SetRepresentationToOutline();
+ int dim[3];
+ GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetDimensions(dim);
+ int px=(dim[0]/2);
+ int py=(dim[1]/2);
+ int pz=(dim[2]/2);
+ int dd=20;
+ _planeWidget->PlaceWidget( px-dd , px+dd , py-dd , py+dd , pz-dd , pz+dd );
+ _vtkplane = vtkPolyData::New();
+ _planeWidget->GetPolyData(_vtkplane);
+
+ vtkProbeFilter *probe = vtkProbeFilter::New();
+ probe->SetInput(_vtkplane);
+ vtkImageData *imageData = GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+ probe->SetSource( imageData );
+
+ vtkPolyDataMapper *contourMapper = vtkPolyDataMapper::New();
+
+ contourMapper->SetInput( probe->GetPolyDataOutput() );
+
+ contourMapper->SetScalarRange( imageData->GetScalarRange() );
+ _contourPlaneActor = vtkActor::New();
+ _contourPlaneActor->SetMapper(contourMapper);
+ _contourPlaneActor->VisibilityOff();
+
+ _planeWidget->SetInteractor( GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor() );
+ _planeWidget->AddObserver(vtkCommand::InteractionEvent,_myCallback);
+ _planeWidget->Off();
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _contourPlaneActor );
+}
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::VisibleImageActor(int idPosition, bool visible){
+ if (visible!=_vtkmpr3Ddataviewer->GetVisiblePosition(idPosition)){
+ if (visible==false){
+ _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkmpr3Ddataviewer->GetImageActor(idPosition) );
+ } else {
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkmpr3Ddataviewer->GetImageActor(idPosition) );
+ }
+ _vtkmpr3Ddataviewer->SetVisiblePosition(idPosition,visible);
+ }
+}
+
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::VisiblePointWidget( bool visible )
+{
+ if (visible==true)
+ {
+ _pointWidget->On();
+ } else {
+ _pointWidget->Off();
+ }
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::VisiblePlaneWidget( bool visible )
+{
+ if (visible==true)
+ {
+ _planeWidget->On();
+ _contourPlaneActor->VisibilityOn();
+
+ } else {
+ _planeWidget->Off();
+ _contourPlaneActor->VisibilityOff();
+ }
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::SetVtkMPR3DDataViewer(vtkMPR3DDataViewer *vtkmpr3Ddataviewer)
+{
+ _vtkmpr3Ddataviewer = vtkmpr3Ddataviewer;
+}
+
+//-------------------------------------------------------------------
+void wxVtkMPR3DView::InitOrientationPointWidget()
+{
+ this->_planeWidget->SetNormal(1,0,0);
+}
+
+
+
+
+//-------------------------------------------------------------------
+// EED 25 Janvier 2007 testLoic
+void wxVtkMPR3DView::TestLoic1()
+{
+
+ int sizeIma = 128;
+ double dimIma = sizeIma*2;
+
+ vtkImageData *vtkimagedata = this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+
+ double spc[3];
+ vtkimagedata->GetSpacing(spc);
+
+ vtkimagedata->Update();
+
+
+ double p[3], n[3];
+ this->_planeWidget->GetOrigin(p);
+ this->_planeWidget->GetNormal(n);
+
+
+
+ vtkPlaneSource* pSource = vtkPlaneSource::New( );
+ pSource->SetResolution( sizeIma - 1, sizeIma - 1 );
+ pSource->SetOrigin( p[ 0 ], p[ 1 ], p[ 2 ] );
+ pSource->SetPoint1( p[ 0 ] + dimIma - 1.0, p[ 1 ], p[ 2 ] );
+ pSource->SetPoint2( p[ 0 ], p[ 1 ]+ dimIma - 1.0 , p[ 2 ] );
+ pSource->Update( );
+ pSource->SetCenter( p[ 0 ], p[ 1 ], p[ 2 ] );
+ pSource->SetNormal( n[ 0 ], n[ 1 ], n[ 2 ] );
+ pSource->Update( );
+
+ vtkProbeFilter* slices = vtkProbeFilter::New();
+ slices->SetInput( ( vtkDataSet* )pSource->GetOutput( ) );
+ slices->SetSource( vtkimagedata );
+ slices->Update( );
+ pSource->Delete( );
+
+ vtkStructuredPoints *stPoints = vtkStructuredPoints::New();
+ stPoints -> GetPointData( )->SetScalars( slices->GetOutput()->GetPointData()->GetScalars() );
+ stPoints -> SetDimensions( sizeIma, sizeIma, 1 );
+ stPoints -> SetScalarType( vtkimagedata->GetScalarType() );
+ stPoints -> SetScalarTypeToShort();
+ stPoints -> Update();
+
+ vtkImageChangeInformation *change = vtkImageChangeInformation ::New();
+ change -> SetInput( stPoints );
+ change -> Update(); //important
+
+ double _range[2];
+ vtkimagedata->GetScalarRange(_range);
+ vtkWindowLevelLookupTable *_bwlookup = vtkWindowLevelLookupTable::New( );
+ _bwlookup->SetHueRange( 0 , 1 );
+ _bwlookup->SetNumberOfColors( (int)(_range[1] - _range[0] + 1) );
+ _bwlookup->SetTableRange( _range[0] , _range[1] );
+ _bwlookup->SetSaturationRange( 0 , 0 );
+ _bwlookup->SetValueRange( 0 , 1 );
+ _bwlookup->SetAlphaRange( 1 , 1 );
+ _bwlookup->Build( );
+
+ vtkLookupTable * _collookup = vtkLookupTable::New( );
+ _collookup->SetNumberOfColors( 256 );
+ _collookup->SetTableRange( 0 , 255 );
+ _collookup->Build( );
+ _collookup->SetTableValue( 0 , 1 , 0 , 0 , 1 );
+ _collookup->SetTableValue(128 , 0 , 0 , 1 , 1 );
+ _collookup->SetTableValue(255 , 0 , 1 , 0 , 1 );
+
+
+ vtkMetaImageWriter *writer = vtkMetaImageWriter::New( );
+ writer->SetInput( stPoints );
+ writer->SetFileName( "C:/Users/Images/temp_EED/image.mhd" );
+ writer->SetFileDimensionality( 2 );
+ writer->Write( );
+
+
+
+ vtkDataSetMapper *_3DSliceMapper = vtkDataSetMapper::New( );
+ _3DSliceMapper->SetInput(change->GetOutput( ) );
+ _3DSliceMapper->SetLookupTable( _bwlookup );
+ _3DSliceMapper->SetScalarRange( _range );
+ _3DSliceMapper->ImmediateModeRenderingOn( );
+
+ vtkActor *_3DSliceActor = vtkActor::New( );
+ _3DSliceActor->SetMapper( _3DSliceMapper );
+
+ // The usual rendering stuff.
+ vtkCamera *camera = vtkCamera::New();
+ camera->SetPosition(1,1,1);
+ camera->SetFocalPoint(0,0,0);
+
+ vtkRenderer *renderer = vtkRenderer::New();
+ vtkRenderWindow *renWin = vtkRenderWindow::New();
+ renWin->AddRenderer(renderer);
+
+ vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+ iren->SetRenderWindow(renWin);
+
+ renderer->AddActor( _3DSliceActor );
+ renderer->SetActiveCamera(camera);
+ renderer->ResetCamera();
+ renderer->SetBackground(1,1,1);
+
+ renWin->SetSize(300,300);
+
+ // interact with data
+ renWin->Render();
+ iren->Start();
+
+
+
+
+
+}
+
+//-------------------------------------------------------------------
+// EED 25 Janvier 2007 testLoic
+void wxVtkMPR3DView::TestLoic2()
+{
+/*
+ vtkVectorNorm *vecMagnitude = vtkVectorNorm::New();
+ vecMagnitude->SetInput(VtkMainGrid);
+ vecMagnitude->NormalizeOff();
+ vecMagnitude->Update();
+*/
+
+ vtkPlane *slicePlane = vtkPlane::New();
+ this->_planeWidget->GetPlane( slicePlane );
+
+
+ vtkCutter* sliceCutter = vtkCutter::New();
+ vtkImageData *vtkimagedata = this->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+ sliceCutter->SetInput( vtkimagedata );
+ sliceCutter->SetCutFunction( slicePlane );
+
+//EED
+// vtkLookupTable *lut = BuildHueWeightBaseMap();
+
+
+ vtkPolyDataMapper *slice = vtkPolyDataMapper::New();
+ slice->SetInput( sliceCutter->GetOutput() );
+ double range[2];
+// EED
+// slice->Update();
+ vtkimagedata->GetScalarRange(range);
+// vecMagnitude->GetOutput()->GetScalarRange( range );
+// range[1] *= 0.7; // reduce the upper range by 30%
+// slice->SetScalarRange( range );
+// slice->SetLookupTable( lut );
+
+// vtkActor *sliceActor = vtkActor::New();
+// sliceActor->SetMapper( slice );
+
+ vtkPolyDataMapper *contourMapper = vtkPolyDataMapper::New();
+ contourMapper->SetInput( sliceCutter->GetOutput() );
+ contourMapper->SetScalarRange( range );
+ // contourMapper->SetLookupTable( lut );
+
+
+ vtkActor *contourActor = vtkActor::New();
+ contourActor->SetMapper( contourMapper );
+
+
+
+ // The usual rendering stuff.
+ vtkCamera *camera = vtkCamera::New();
+ camera->SetPosition(1,1,1);
+ camera->SetFocalPoint(0,0,0);
+
+ vtkRenderer *renderer = vtkRenderer::New();
+ vtkRenderWindow *renWin = vtkRenderWindow::New();
+ renWin->AddRenderer(renderer);
+
+ vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+ iren->SetRenderWindow(renWin);
+
+ renderer->AddActor( contourActor );
+// renderer->AddActor(cubeActor);
+ renderer->SetActiveCamera(camera);
+ renderer->ResetCamera();
+ renderer->SetBackground(1,1,1);
+
+ renWin->SetSize(300,300);
+
+ // interact with data
+ renWin->Render();
+ iren->Start();
+
+
+}
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxVtkClipping3DView::wxVtkClipping3DView(wxVtk3DBaseView* wxvtk3Dbaseview)
+{
+ _wxvtk3Dbaseview = wxvtk3Dbaseview;
+ _vtkclipping3Ddataviewer = NULL;
+ _wxvtkclipping3DviewCntrlPanel = NULL;
+
+ _boxWidgetVolume = NULL;
+ _boxWidgetS1 = NULL;
+}
+
+//-------------------------------------------------------------------
+wxVtkClipping3DView::~wxVtkClipping3DView(){
+ if (_boxWidgetVolume!=NULL) { _boxWidgetVolume -> Delete(); }
+ if (_boxWidgetS1!=NULL) { _boxWidgetS1 -> Delete(); }
+ if (_vtkclipping3Ddataviewer!=NULL) { delete _vtkclipping3Ddataviewer; }
+ if (_wxvtkclipping3DviewCntrlPanel!=NULL){ delete _wxvtkclipping3DviewCntrlPanel; }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::SetVisibleBoxSurface(bool visible)
+{
+ if (visible==true){
+ _boxWidgetS1->On();
+ } else {
+ _boxWidgetS1->Off();
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::SetVisibleBoxVolume(bool visible)
+{
+ if (_boxWidgetVolume!=NULL){
+ if (visible==true){
+ _boxWidgetVolume->On();
+ } else {
+ _boxWidgetVolume->Off();
+ }
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::Refresh()
+{
+ _vtkclipping3Ddataviewer->Refresh();
+ if (_wxvtkclipping3DviewCntrlPanel!=NULL)
+ {
+ _wxvtkclipping3DviewCntrlPanel->Refresh();
+ }
+}
+//-------------------------------------------------------------------
+wxPanel* wxVtkClipping3DView::CreateControlPanel(wxWindow *parent)
+{
+ _wxvtkclipping3DviewCntrlPanel = new wxVtkClipping3DViewCntrlPanel(parent,this);
+ return _wxvtkclipping3DviewCntrlPanel;
+}
+//-------------------------------------------------------------------
+vtkClipping3DDataViewer* wxVtkClipping3DView::GetVtkClipping3DDataViewer()
+{
+ return _vtkclipping3Ddataviewer;
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::VisibleActor(int idTissue, bool visTissue){
+ if (visTissue!=_vtkclipping3Ddataviewer->GetVisibleTissue(idTissue)){
+ if (visTissue==false){
+ _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkclipping3Ddataviewer->GetTissueActor(idTissue) );
+ } else {
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(idTissue) );
+// _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(idTissue) );
+// _actor->VisibilityOn();
+ }
+ _vtkclipping3Ddataviewer->SetVisibleTissue(idTissue,visTissue);
+ }
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::SetRepSurfaceWireFrame(int idTissue , bool representationType )
+{
+ vtkActor *tmpActor;
+ tmpActor = GetVtkClipping3DDataViewer()->GetTissueActor(idTissue);
+
+ if (representationType==false){
+ tmpActor->GetProperty()->SetRepresentationToWireframe();
+ } else {
+ tmpActor->GetProperty()->SetRepresentationToSurface();
+ }
+
+ _vtkclipping3Ddataviewer->SetRepresentationType(idTissue,representationType);
+}
+
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::VisibleVolumeActor( bool visVolume){
+ if (visVolume!=_vtkclipping3Ddataviewer->GetVisibleVolume() ){
+ if (visVolume==false){
+//EED 31/03/2008
+// _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _vtkclipping3Ddataviewer->GetVolumeActor() );
+ _wxvtk3Dbaseview->GetRenderer()->RemoveVolume( _vtkclipping3Ddataviewer->GetVolumeActor() );
+ } else {
+//EED 31/03/2008
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetVolumeActor() );
+ _wxvtk3Dbaseview->GetRenderer()->AddVolume( _vtkclipping3Ddataviewer->GetVolumeActor() );
+ }
+ _vtkclipping3Ddataviewer->SetVisibleVolume(visVolume);
+ }
+}
+//-------------------------------------------------------------------
+wxVtk3DBaseView* wxVtkClipping3DView::GetWxvtk3Dbaseview()
+{
+ return _wxvtk3Dbaseview;
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::Configure(){
+ _wxvtk3Dbaseview->Configure();
+
+ // Actors are added to the renderer.
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetOutlineActor() );
+
+ _boxWidgetS1 = vtkBoxWidget::New();
+ _boxWidgetS1->SetInteractor( _wxvtk3Dbaseview->GetWxVTKRenderWindowInteractor() );
+ _boxWidgetS1->SetPlaceFactor(1.25);
+
+
+
+ vtkStripper *stripper=_vtkclipping3Ddataviewer->GetTissueStripper(0);
+ vtkPolyData *polydata= stripper->GetOutput();
+
+
+ _boxWidgetS1->SetInput( polydata );
+ _boxWidgetS1->PlaceWidget();
+
+ int i;
+ for (i=0; i< VTKMPRDATA_MAXTISSUE ; i++)
+ {
+ _boxWidgetS1->AddObserver( vtkCommand::InteractionEvent , _vtkclipping3Ddataviewer->GetObserverS(i) );
+ }
+
+
+
+
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(0) );
+// _wxvtk3Dbaseview->GetRenderer()->AddActor( _vtkclipping3Ddataviewer->GetTissueActor(3));
+
+ VisibleActor(0, false );
+ VisibleActor(1, false );
+ VisibleActor(2, false );
+ VisibleActor(3, false );
+
+ _boxWidgetS1->HandlesOn ();
+ _boxWidgetS1->On();
+ _boxWidgetS1->Off();
+
+ _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(0) );
+ _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(1) );
+ _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(2) );
+ _boxWidgetS1->GetPlanes( this->GetVtkClipping3DDataViewer()->GetTissuePlanes(3) );
+
+// EED 9 fev 2007
+// box Volume
+ _boxWidgetVolume = vtkBoxWidget::New();
+ _boxWidgetVolume->SetInteractor( _wxvtk3Dbaseview->GetWxVTKRenderWindowInteractor() );
+ _boxWidgetVolume->SetPlaceFactor(1.25);
+
+ _boxWidgetVolume->SetInput( this->GetVtkClipping3DDataViewer()->GetVtkMPRBaseData()->GetImageData() );
+ _boxWidgetVolume->PlaceWidget();
+
+ _boxWidgetVolume->AddObserver( vtkCommand::InteractionEvent , _vtkclipping3Ddataviewer->GetObserverV() );
+
+ _boxWidgetVolume->HandlesOn ();
+ _boxWidgetVolume->On();
+ _boxWidgetVolume->Off();
+
+
+// vtkPlanes *vtkplanes=this->GetVtkClipping3DDataViewer()->GetVolumePlanes();
+// _boxWidgetVolume->GetPlanes( vtkplanes );
+
+
+ // An initial camera view is created. The Dolly() method moves
+ // the camera towards the FocalPoint, thereby enlarging the image.
+ _wxvtk3Dbaseview->GetRenderer()->SetActiveCamera(_wxvtk3Dbaseview->GetCamera());
+ _wxvtk3Dbaseview->GetRenderer()->ResetCamera ();
+ _wxvtk3Dbaseview->GetCamera()->Dolly(1.5);
+
+ // Set a background color for the renderer and set the size of the
+ // render window (expressed in pixels).
+ _wxvtk3Dbaseview->GetRenderer()->SetBackground( 0.36 , 0.36 , 0.36 );
+ _wxvtk3Dbaseview->GetRenWin()->SetSize(400, 400);
+
+ // Note that when camera movement occurs (as it does in the Dolly()
+ // method), the clipping planes often need adjusting. Clipping planes
+ // consist of two planes: near and far along the view direction. The
+ // near plane clips out objects in front of the plane; the far plane
+ // clips out objects behind the plane. This way only what is drawn
+ // between the planes is actually rendered.
+ _wxvtk3Dbaseview->GetRenderer()->ResetCameraClippingRange();
+}
+//-------------------------------------------------------------------
+void wxVtkClipping3DView::SetVtkClipping3DDataViewer(vtkClipping3DDataViewer *vtkclipping3Ddataviewer)
+{
+ _vtkclipping3Ddataviewer = vtkclipping3Ddataviewer;
+}
+
+
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
+vtkInteractorStyle3DView::vtkInteractorStyle3DView()
+{
+}
+//---------------------------------------------------------------------------
+vtkInteractorStyle3DView::~vtkInteractorStyle3DView()
+{
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStyle3DView::OnLeftDClick()
+{
+ SelectMarchibCubePoint();
+ return true;
+}
+//---------------------------------------------------------------------------
+bool vtkInteractorStyle3DView::SelectMarchibCubePoint()
+{
+ bool ok=false;
+ gtm::TVector< double > pO( 3 ), pF( 3 ), pp( 3 ), cp( 3 );
+ gtm::TVector< double > xc( 3 );
+ gtm::TVector< double > x1( 3 ), n1( 3 );
+ gtm::TVector< double > x2( 3 ), n2( 3 );
+
+ double pickPoint[ 3 ], cameraPos[ 3 ];
+ int eventrwi[2];
+ vtkPointPicker* picker = vtkPointPicker::New( );
+ eventrwi[0]= _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[0];
+ eventrwi[1]= _vtkInteractorStyleBaseView->GetInteractor()->GetEventPosition()[1];
+ vtkRenderer *pRenderer = _vtkInteractorStyleBaseView->GetWxVtk3DBaseView()->GetRenderer();
+ picker->Pick( eventrwi[0], eventrwi[1], 0.0, pRenderer );
+ pRenderer->GetActiveCamera( )->GetPosition( cameraPos );
+ picker->GetPickPosition( pickPoint );
+ picker->Delete( );
+
+ pp( 0 ) = pickPoint[ 0 ]; pp( 1 ) = pickPoint[ 1 ]; pp( 2 ) = pickPoint[ 2 ];
+ cp( 0 ) = cameraPos[ 0 ]; cp( 1 ) = cameraPos[ 1 ]; cp( 2 ) = cameraPos[ 2 ];
+
+
+//EED 27 sep 2006 (1/2)
+// wxVtkMPR3DView *wxvtkmpr3Dview = (wxVtkMPR3DView *)_vtkInteractorStyleBaseView->GetWxVtk3DBaseView();
+// double spc[3];
+// wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetSpacing(spc);
+
+
+ vtkImageData *imageData = GetWxVtkMPR3DView()->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData();
+ int dim[3];
+ double spc[3];
+ imageData->GetDimensions(dim);
+ imageData->GetSpacing(spc);
+
+
+ vtkMarchingCubes *mcubes = _wxvtkclipping3Dview->GetVtkClipping3DDataViewer()->GetMCubes(0);
+
+
+ UtilVtk3DGeometriSelection utilVtk3DGeometriSelection;
+ utilVtk3DGeometriSelection.SetDimentions(dim[0],dim[1],dim[2]);
+
+ utilVtk3DGeometriSelection.SetMarchingCube(mcubes);
+
+ double fac;
+ fac = GTM_MAX( dim[0], dim[2] );
+
+
+ if( utilVtk3DGeometriSelection.FindCubePointsFromPoints(
+ pO.GetAnsiRef( ), pF.GetAnsiRef( ),
+ pp.GetAnsiRef( ), cp.GetAnsiRef( ) ) )
+ {
+
+ if( utilVtk3DGeometriSelection.GetPointAndNormalIntersection(
+ x1.GetAnsiRef( ), n1.GetAnsiRef( ),
+ pO.GetAnsiRef( ), pF.GetAnsiRef( ) ) )
+ {
+ if( utilVtk3DGeometriSelection.GetPointAndNormalIntersection(
+ x2.GetAnsiRef( ), n2.GetAnsiRef( ),
+ ( x1 - n1 ).GetAnsiRef( ), ( x1 - ( n1 * fac ) ).GetAnsiRef( ) ) )
+ {
+ xc = ( x2 + x1 ) * 0.5;
+//EED 27 sep 2006 (2/2)
+ this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX(xc(0)/spc[0]);
+ this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY(xc(1)/spc[1]);
+ this->_wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ(xc(2)/spc[2]);
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ this->_wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+ ok=true;
+ }
+ }
+ }
+
+
+ return ok;
+}
+//-------------------------------------------------------------------
+void vtkInteractorStyle3DView::SetWxVtkMPR3DView( wxVtkMPR3DView *wxvtkmpr3Dview )
+{
+ _wxvtkmpr3Dview = wxvtkmpr3Dview;
+}
+//-------------------------------------------------------------------
+wxVtkMPR3DView *vtkInteractorStyle3DView::GetWxVtkMPR3DView()
+{
+ return _wxvtkmpr3Dview;
+}
+//-------------------------------------------------------------------
+wxVtkClipping3DView *vtkInteractorStyle3DView::GetWxVtkClipping3DView()
+{
+ return _wxvtkclipping3Dview;
+}
+//-------------------------------------------------------------------
+void vtkInteractorStyle3DView::SetWxVtkClipping3DView( wxVtkClipping3DView *wxvtkclipping3Dview)
+{
+ _wxvtkclipping3Dview = wxvtkclipping3Dview;
+}
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+void vtkmyPWCallback_3DPointWidget::Execute(vtkObject *caller, unsigned long, void*)
+{
+ double n[3];
+ double p[3];
+ double delta = 0.000000001;
+
+ vtkInteractorStyleBaseView *isbv = _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetInteractorStyleBaseView();
+
+ if (caller==_pointWidget)
+ {
+ _pointWidget->GetPosition(p);
+ }
+ if (caller==_planeWidget)
+ {
+ _planeWidget->GetCenter(p);
+ _planeWidget->GetNormal(n);
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetNormal(n[0],n[1],n[2]);
+ }
+
+ double spc[3];
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetImageData()->GetSpacing(spc);
+ p[0]=p[0]/spc[0];
+ p[1]=p[1]/spc[1];
+ p[2]=p[2]/spc[2];
+
+ // Orientation change
+ if ( (fabs(n[0]-_backNormal[0])>delta) || (fabs(n[1]-_backNormal[1])>delta) || (fabs(n[2]-_backNormal[2])>delta) )
+ {
+ _backNormal[0] = n[0];
+ _backNormal[1] = n[1];
+ _backNormal[2] = n[2];
+ isbv->SetParent_refresh_waiting();
+ }
+
+ // ----------
+
+ double tx = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetX();
+ double ty = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetY();
+ double tz = _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->GetZ();
+
+ // Position Change
+ if ( (fabs(tx-p[0])>delta) || (fabs(ty-p[1])>delta) || (fabs(tz-p[2])>delta) )
+ {
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetX( p[0] );
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetY( p[1] );
+ _wxvtkmpr3Dview->GetVtkMPR3DDataViewer()->GetVtkMPRBaseData()->SetZ( p[2] );
+ vtkInteractorStyleBaseView *isbv = _wxvtkmpr3Dview->GetWxvtk3Dbaseview()->GetInteractorStyleBaseView();
+ isbv->BlockRefresh();
+ isbv->vtkInteractorStyleBaseView::OnLeftButtonDown();
+ isbv->SetParent_refresh_waiting();
+ isbv->vtkInteractorStyleBaseView::OnMouseMove();
+ isbv->UnBlockRefresh();
+ }
+ isbv->EvaluateToRefresh();
+}
+//-------------------------------------------------------------------
+void vtkmyPWCallback_3DPointWidget::SetWxVtkMPR3DView( wxVtkMPR3DView *wxvtkmpr3Dview )
+{
+ _wxvtkmpr3Dview=wxvtkmpr3Dview;
+}
+//-------------------------------------------------------------------
+void vtkmyPWCallback_3DPointWidget::SetVtkPointWidget( vtkPointWidget *pointWidget )
+{
+ _pointWidget=pointWidget;
+}
+//-------------------------------------------------------------------
+void vtkmyPWCallback_3DPointWidget::SetVtkPlaneWidget( vtkPlaneWidget *planeWidget )
+{
+ _planeWidget=planeWidget;
+}
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxPanelCuttingImageData::wxPanelCuttingImageData (wxWindow *parent)
+: wxPanel( parent, -1)
+{
+ _imageData=NULL;
+ _histogrammeVector=NULL;
+ CreateInterface();
+ CreateModel();
+ Create3DViewObjects();
+}
+
+//-------------------------------------------------------------------
+wxPanelCuttingImageData::~wxPanelCuttingImageData()
+{
+
+ delete _modelCube;
+ delete _modelSphere;
+ delete _modelCylinder;
+
+ _vtkcube -> Delete();
+ _vtksphere -> Delete();
+ _vtkcylinder -> Delete();
+ _cubeMapper -> Delete();
+ _sphereMapper -> Delete();
+ _cylinderMapper -> Delete();
+ _cubeActor -> Delete();
+ _sphereActor -> Delete();
+ _cylinderActor -> Delete();
+// _xyplot->RemoveAllInputs();
+ _xyplot -> Delete();
+ _histogrammeVector->Delete();
+
+ delete _wxvtkbaseView;
+
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::RemoveActors()
+{
+ _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _actualActor );
+}
+
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::SetWxVtk3DBaseView( wxVtk3DBaseView * wxvtk3Dbaseview )
+{
+ _wxvtk3Dbaseview=wxvtk3Dbaseview;
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::SetVtkClipping3DDataViewer( vtkClipping3DDataViewer *vtkclipping3Ddataviewer )
+{
+ this->_vtkclipping3Ddataviewer = vtkclipping3Ddataviewer;
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::Create3DViewObjects()
+{
+ // Sphere
+ _vtksphere = vtkSphereSource::New();
+ _vtksphere->SetThetaResolution (20);
+ _vtksphere->SetPhiResolution (20);
+ _sphereMapper = vtkPolyDataMapper::New();
+ _sphereMapper->SetInput( _vtksphere->GetOutput() );
+ _sphereActor = vtkActor::New();
+ _sphereActor->SetMapper(_sphereMapper);
+ _sphereActor->SetOrigin(0, 0, 0);
+ _sphereActor->SetPosition(0, 0, 0);
+ _sphereActor->GetProperty()->SetColor(1, 0, 0);
+ _sphereActor->SetUserTransform( _modelSphere->GetVtkTransform() );
+
+ // cube
+ _vtkcube = vtkCubeSource::New();
+ _vtkcube->SetXLength (1);
+ _vtkcube->SetYLength (1);
+ _vtkcube->SetZLength (1);
+ _cubeMapper = vtkPolyDataMapper::New();
+ _cubeMapper->SetInput( _vtkcube->GetOutput() );
+ _cubeActor = vtkActor::New();
+ _cubeActor->SetMapper(_cubeMapper);
+ _cubeActor->SetOrigin(0, 0, 0);
+ _cubeActor->SetPosition(0, 0, 0);
+ _cubeActor->GetProperty()->SetColor(1, 0, 0);
+ _cubeActor->SetUserTransform( _modelCube->GetVtkTransform() );
+
+ // cylinder
+ _vtkcylinder = vtkCylinderSource::New();
+ _vtkcylinder->SetResolution(20);
+ _cylinderMapper = vtkPolyDataMapper::New();
+ _cylinderMapper->SetInput( _vtkcylinder->GetOutput() );
+ _cylinderActor = vtkActor::New();
+ _cylinderActor->SetMapper(_cylinderMapper);
+ _cylinderActor->SetOrigin(0, 0, 0);
+ _cylinderActor->SetPosition(0, 0, 0);
+ _cylinderActor->GetProperty()->SetColor(1, 0, 0);
+ _cylinderActor->SetUserTransform( _modelCylinder->GetVtkTransform() );
+
+
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::CreateModel()
+{
+ _modelCube = new figureCuttingCubeModel();
+ _modelSphere = new figureCuttingSphereModel();
+ _modelCylinder = new figureCuttingCylinderModel();
+
+// _modelCube->SetVtkTransform( _modelCube->GetVtkTransform() );
+// _modelSphere->SetVtkTransform( _modelSphere->GetVtkTransform() );
+// _modelCylinder->SetVtkTransform( _modelCylinder->GetVtkTransform() );
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::InitHistogramme()
+{
+ double rangeA[2];
+ if (_imageData==NULL)
+ {
+ rangeA[1]=1;
+ } else {
+ _imageData->GetScalarRange(rangeA);
+ }
+ _xyplot->RemoveAllInputs();
+/*
+ if ( _histogrammeVector!=NULL )
+ {
+ _histogrammeVector -> Delete();
+ }
+*/
+ _histogrammeVector = vtkImageData::New();
+ _histogrammeVector -> SetDimensions ( (int)(rangeA[1]),1,1 );
+ _histogrammeVector -> SetScalarTypeToUnsignedShort();
+ _histogrammeVector -> AllocateScalars();
+ _histogrammeVector -> Update();
+
+ unsigned short *p_vol = (unsigned short*)_histogrammeVector->GetScalarPointer(0,0,0);
+ int i,size = (int) (rangeA[1]);
+ for (i=0; i < size; i++)
+ {
+ *p_vol=0;
+ p_vol++;
+ }
+ _xyplot->SetXRange(0, rangeA[1]);
+ _xyplot->SetYRange(0, 10);
+ _xyplot->AddInput( _histogrammeVector );
+}
+
+//-------------------------------------------------------------------
+wxWindow *wxPanelCuttingImageData::CreatePlotHistogrammeInterface()
+{
+ _xyplot = vtkXYPlotActor::New();
+ InitHistogramme();
+ _xyplot->GetPositionCoordinate()->SetValue(0.00, 0.00, 0);
+ _xyplot->GetPosition2Coordinate()->SetValue(1.0, 1.00, 0); //relative to Position
+ _xyplot->SetXValuesToArcLength();
+ _xyplot->SetNumberOfXLabels(6);
+
+ _xyplot->SetTitle("Histogramme");
+ _xyplot->SetXTitle("Gray level");
+ _xyplot->SetYTitle("Occurrences ");
+ _xyplot->GetProperty()->SetColor(1, 0, 0);
+ _xyplot->GetProperty()->SetPointSize(2);
+ vtkTextProperty *tprop = _xyplot->GetTitleTextProperty();
+ tprop->SetColor( 1,0,1 );
+ tprop->BoldOff ();
+ _xyplot->SetAxisTitleTextProperty(tprop);
+ _xyplot->SetAxisLabelTextProperty(tprop);
+ _xyplot->PlotPointsOn();
+ _xyplot->GetProperty()->SetPointSize(3);
+
+ _wxvtkbaseView = new wxVtkBaseView(this);
+ _wxvtkbaseView->Configure();
+
+ vtkRenderer *ren = vtkRenderer::New();
+ vtkRenderWindow *renWin = _wxvtkbaseView->GetRenWin();
+ renWin->AddRenderer( ren );
+ ren->AddActor2D( _xyplot );
+
+ return _wxvtkbaseView->GetWxVTKRenderWindowInteractor();
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::CreateInterface()
+{
+ SetSize(300,500);
+ wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL); // Principal sizer
+
+ wxBoxSizer *sizerH0 = new wxBoxSizer(wxHORIZONTAL ); // type of segmentation figure
+ wxBoxSizer *sizerH2 = new wxBoxSizer(wxHORIZONTAL ); // scale
+ wxBoxSizer *sizerH3 = new wxBoxSizer(wxHORIZONTAL ); // rotation
+ wxBoxSizer *sizerH4 = new wxBoxSizer(wxHORIZONTAL ); // intern extern
+ wxBoxSizer *sizerH5 = new wxBoxSizer(wxHORIZONTAL ); // Isovalue
+ wxBoxSizer *sizerH6 = new wxBoxSizer(wxHORIZONTAL ); // Buttons
+ wxFlexGridSizer *sizerH7 = new wxFlexGridSizer(2 ); // Volumic information
+
+
+ _typeFig = new wxChoice(this,-1);
+ _opacityFig = new wxSlider(this,-1,100,0,100, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+
+ _scaleX = new wxSlider(this,-1,6,0,500 , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _scaleY = new wxSlider(this,-1,20,0,500 , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _scaleZ = new wxSlider(this,-1,7,0,500 , wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+
+ _rotationX = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _rotationY = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _rotationZ = new wxSlider(this,-1,0,-360,360, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+
+ _volIntern = new wxRadioButton(this,-1, _T("Volume intern " ));
+ _volExtern = new wxRadioButton(this,-1, _T("Volume extern " ));
+
+ _histogrammeAccumulated = new wxCheckBox(this,-1,_T("Histogramme accumulated"));
+
+ _isoValue = new wxSlider(this,-1, 200, 0,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _valueBeforeIsoValue = new wxSlider(this,-1,-1,-1,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+ _valueAfterIsoValue = new wxSlider(this,-1,-1,-1,2000, wxDefaultPosition, wxSize(200,45), wxSL_HORIZONTAL | wxSL_LABELS);
+
+ wxButton *btnExtract = new wxButton(this, -1,_T("Extract"));
+
+ _infoToVo = new wxStaticText(this,-1,_T("########################"));
+ _infoSuVoA = new wxStaticText(this,-1,_T("############"));
+ _infoSuVo = new wxStaticText(this,-1,_T("############"));
+ _infoPixLe = new wxStaticText(this,-1,_T("############"));
+ _infoPixHi = new wxStaticText(this,-1,_T("############"));
+
+
+ wxWindow *panelPlotHistogramme = CreatePlotHistogrammeInterface();
+
+ _typeFig->Append(_T("Cylindre"));
+ _typeFig->Append(_T("Cube"));
+ _typeFig->Append(_T("Sphere"));
+ _typeFig->SetSelection(0);
+ _volIntern->SetValue(true);
+
+ Connect(_typeFig->GetId() , wxEVT_COMMAND_CHOICE_SELECTED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTypeFig );
+
+ Connect(_opacityFig->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnOpacityFig );
+ Connect(_rotationX->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(_rotationY->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(_rotationZ->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(_scaleX->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(_scaleY->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(_scaleZ->GetId() , wxEVT_COMMAND_SLIDER_UPDATED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnTransform );
+ Connect(btnExtract->GetId() , wxEVT_COMMAND_BUTTON_CLICKED , (wxObjectEventFunction) &wxPanelCuttingImageData::OnExtract );
+
+
+// wxStaticText *text=new wxStaticText(this,-1, " ");
+
+ sizerH0 -> Add( new wxStaticText(this,-1, _T("Fig. Type: "),wxDefaultPosition, wxSize(50,20)) ,1,wxALL ,0);
+ sizerH0 -> Add( _typeFig ,1,wxALL ,0);
+ sizerH0 -> Add( _opacityFig ,1,wxALL|wxEXPAND ,0);
+
+ sizerH2 -> Add( new wxStaticText(this,-1,_T("Scale : ")) ,1,wxALL ,0);
+ sizerH2 -> Add( _scaleX ,1,wxALL | wxEXPAND ,0 );
+ sizerH2 -> Add( _scaleY ,1,wxALL | wxEXPAND ,0 );
+ sizerH2 -> Add( _scaleZ ,1,wxALL | wxEXPAND ,0 );
+
+ sizerH3 -> Add( new wxStaticText(this,-1,_T("Rotation : ")) ,1,wxALL ,0);
+ sizerH3 -> Add( _rotationX ,1,wxALL | wxEXPAND ,0 );
+ sizerH3 -> Add( _rotationY ,1,wxALL | wxEXPAND ,0 );
+ sizerH3 -> Add( _rotationZ ,1,wxALL | wxEXPAND ,0 );
+
+
+ sizerH4 -> Add( new wxStaticText(this,-1,_T("Intern / Extern : ")) ,1,wxALL ,0);
+ sizerH4 -> Add( _volIntern ,1,wxALL ,0);
+ sizerH4 -> Add( new wxStaticText(this,-1, _T(" ")) ,1,wxALL ,0);
+ sizerH4 -> Add( _volExtern ,1,wxALL ,0);
+
+ sizerH5 -> Add( new wxStaticText(this,-1,_T("Isovalue ")) ,1,wxALL ,0);
+ sizerH5 -> Add( _isoValue ,1,wxALL | wxEXPAND ,0 );
+ sizerH5 -> Add( _valueBeforeIsoValue ,1,wxALL | wxEXPAND ,0 );
+ sizerH5 -> Add( _valueAfterIsoValue ,1,wxALL | wxEXPAND ,0 );
+
+ sizerH6 -> Add( new wxStaticText(this,-1, _T(" ")) ,1,wxALL ,0);
+ sizerH6 -> Add( btnExtract ,1,wxALL ,0);
+
+ sizerH7 -> Add( new wxStaticText(this,-1,_T("Total Volume: "), wxDefaultPosition, wxSize(200,12)) , 1 , wxALL ,0);
+ sizerH7 -> Add( _infoToVo , 1 , wxALL ,0);
+ sizerH7 -> Add( new wxStaticText(this,-1,_T("SubVolume: "), wxDefaultPosition, wxSize(200,12) ) , 1 , wxALL ,0);
+ sizerH7 -> Add( _infoSuVo , 1 , wxALL ,0);
+ sizerH7 -> Add( new wxStaticText(this,-1,_T("SubVolume (ana.): "), wxDefaultPosition, wxSize(200,12)) , 1 , wxALL ,0);
+ sizerH7 -> Add( _infoSuVoA , 1 , wxALL ,0);
+ sizerH7 -> Add( new wxStaticText(this,-1,_T("Pix < isovalue: ") , wxDefaultPosition, wxSize(200,12)) , 1 , wxALL ,0);
+ sizerH7 -> Add( _infoPixLe , 1 , wxALL ,0);
+ sizerH7 -> Add( new wxStaticText(this,-1,_T("Pix > isovalue: "), wxDefaultPosition, wxSize(200,12)) , 1 , wxALL ,0);
+ sizerH7 -> Add( _infoPixHi , 1 , wxALL ,0);
+// sizerH7 -> SetMinSize(300, 120);
+
+ // Figure type
+ topsizer -> Add( sizerH0 ,1,wxALL|wxEXPAND ,0);
+
+ // Scale
+ topsizer -> Add( sizerH2 ,1,wxALL|wxEXPAND ,0);
+
+ // Rotation
+ topsizer -> Add( sizerH3 ,1,wxALL|wxEXPAND ,0);
+
+ // Intern / Extern
+ topsizer -> Add( sizerH4 ,1,wxALL ,0);
+
+
+ // Isovalue limite
+ topsizer -> Add( sizerH5 ,1,wxALL |wxEXPAND ,0);
+
+ // btn Extraction
+ topsizer -> Add( sizerH6 , 1 , wxALL ,0);
+
+ // Histograme
+ topsizer -> Add( _histogrammeAccumulated ,1, wxALL ,0);
+
+ // Volumic information
+ topsizer -> Add( sizerH7 , 1 , wxALL|wxEXPAND ,0);
+
+
+
+// wxBoxSizer *sizerHor = new wxBoxSizer(wxHORIZONTAL);
+ wxBoxSizer *sizerHor = new wxBoxSizer(wxVERTICAL);
+ sizerHor -> Add( topsizer , 1 , wxALL | wxEXPAND ,0);
+ sizerHor -> Add( panelPlotHistogramme , 1 , wxGROW ,0);
+
+
+ this->SetAutoLayout(true);
+ this->SetSizer( sizerHor );
+ this->Layout();
+//EEDxx2.4
+// this->FitInside();
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::OnExtract(wxCommandEvent& event)
+{
+ wxBusyCursor wait;
+
+ bool inside;
+ bool volInt, volExt;
+ int xx,yy,zz;
+ unsigned short *pOrg;
+ unsigned short *p_histogramme;
+ int dim[3];
+ double spc[3];
+ long int contAfter = 0;
+ long int contBefor = 0;
+
+ double min=999999999;
+ double max=-999999999;
+
+ volExt=_volExtern->GetValue();
+ volInt=_volIntern->GetValue();
+ int isoValue = _isoValue->GetValue();
+ int valueBeforeIsoValue = _valueBeforeIsoValue->GetValue();
+ int valueAfterIsoValue = _valueAfterIsoValue ->GetValue();
+
+ InitHistogramme();
+ p_histogramme = (unsigned short*)_histogrammeVector->GetScalarPointer(0,0,0);
+
+ _imageData->GetDimensions(dim);
+ _imageData->GetSpacing(spc);
+ _actualCuttingModel->CalculeInversMatrix();
+
+ for (xx=0;xx<dim[0]; xx++)
+ {
+ for (yy=0;yy<dim[1]; yy++)
+ {
+ for (zz=0;zz<dim[2];zz++)
+ {
+ inside=_actualCuttingModel->IfPointInside(xx,yy,zz);
+ if ( ((inside==true)&&(volInt==true)) || ((!inside==true)&&(volExt==true)) )
+ {
+ pOrg=(unsigned short*)_imageData->GetScalarPointer (xx,yy,zz);
+
+ if ((*pOrg)<isoValue)
+ {
+ contBefor++;
+ if (valueBeforeIsoValue!=-1)
+ {
+ *pOrg=valueBeforeIsoValue;
+ }
+ } else {
+ contAfter++;
+ if (valueAfterIsoValue!=-1)
+ {
+ *pOrg=valueAfterIsoValue;
+ } // if
+ } // if isovalue
+
+ p_histogramme[*pOrg]++;
+ if (*pOrg<min) min=*pOrg;
+ if (*pOrg>max) max=*pOrg;
+ } // if inside
+ } // for zz
+ } // for yy
+ } // for xx
+
+
+ // Information
+ wxString infoToVo;
+ wxString infoSuVo;
+ wxString infoSuVoA;
+ wxString infoPixLe;
+ wxString infoPixHi;
+
+ double volumeUnit = spc[0]*spc[1]*spc[2];
+ long int totalSubVolume = contBefor + contAfter;
+ double contBeforPorc = 100*(double)contBefor/(double)totalSubVolume;
+ double contAfterPorc = 100*(double)contAfter/(double)totalSubVolume;
+ infoToVo.Printf(_T("%dx%dx%d = %d"),dim[0],dim[1],dim[2], dim[0]*dim[1]*dim[2] );
+ infoSuVo.Printf(_T("%d") , totalSubVolume);
+ infoSuVoA.Printf(_T("%.2f"), _actualCuttingModel->GetTheoricVolume() );
+ infoPixLe.Printf(_T("%d pix. (%.2f %s) - %.2f mm^3"),contBefor, contBeforPorc ,_T("%"),contBefor*volumeUnit);
+ infoPixHi.Printf(_T("%d pix. (%.2f %s) - %.2f mm^3"),contAfter, contAfterPorc ,_T("%"),contAfter*volumeUnit);
+
+ _infoToVo->SetLabel(infoToVo);
+ _infoSuVo->SetLabel(infoSuVo);
+ _infoSuVoA->SetLabel(infoSuVoA);
+ _infoPixLe->SetLabel(infoPixLe);
+ _infoPixHi->SetLabel(infoPixHi);
+
+ // Histogram
+ if ( _histogrammeAccumulated->GetValue()==true )
+ {
+ int dimHist[3];
+ _histogrammeVector -> GetDimensions ( dimHist );
+
+ int i,size=dimHist[0];
+ for (i=1; i<=size; i++)
+ {
+ p_histogramme[i] = p_histogramme[i] + p_histogramme[i-1];
+ }
+ }
+ double range[2];
+ _histogrammeVector->Update();
+ _histogrammeVector->GetScalarRange(range);
+ _xyplot->SetYRange( 0 , range[1] );
+ _xyplot->SetXRange( min , max );
+
+ _vtkclipping3Ddataviewer->RefreshSurface();
+ _wxvtkbaseView->Refresh();
+
+// _wxvtkbaseView->RefreshView();
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ _wxvtkbaseView->GetWxVTKRenderWindowInteractor()->GetParent()->ProcessEvent(newevent1);
+}
+
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::OnTypeFig(wxCommandEvent& event)
+{
+ _wxvtk3Dbaseview->GetRenderer()->RemoveActor( _actualActor );
+
+ if (_typeFig->GetSelection()==0){
+ _actualCuttingModel=_modelCylinder;
+ _actualActor=_cylinderActor;
+ }
+ if (_typeFig->GetSelection()==1){
+ _actualCuttingModel=_modelCube;
+ _actualActor=_cubeActor;
+ }
+ if (_typeFig->GetSelection()==2){
+ _actualCuttingModel=_modelSphere;
+ _actualActor=_sphereActor;
+ }
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _actualActor );
+ RefreshOpacity();
+ RefreshView();
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::RefreshOpacity()
+{
+ double op= _opacityFig->GetValue()/100.0;
+ _actualActor->GetProperty()->SetOpacity( op );
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::OnOpacityFig(wxScrollEvent& event)
+{
+ RefreshOpacity();
+ Refresh();
+}
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::RefreshView()
+{
+ SetParamsOfTransformation( );
+ Refresh();
+}
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::Refresh()
+{
+ _wxvtk3Dbaseview->Refresh();
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::SetParamsOfTransformation( )
+{
+ double spc[3];
+ vtkImageData *vtkimagedata = _vtkmprbasedata->GetImageData();
+ vtkimagedata->GetSpacing(spc);
+ int px = (int) (_vtkmprbasedata->GetX() );
+ int py = (int) (_vtkmprbasedata->GetY() );
+ int pz = (int) (_vtkmprbasedata->GetZ() );
+ int sx = (int) (_scaleX->GetValue() * spc[0] );
+ int sy = (int) (_scaleY->GetValue() * spc[1] );
+ int sz = (int) (_scaleZ->GetValue() * spc[2] );
+ _actualCuttingModel -> SetScale ( sx , sy , sz );
+ _actualCuttingModel -> SetPosition ( px , py , pz );
+ _actualCuttingModel -> SetRotation ( _rotationX->GetValue() , _rotationY->GetValue() , _rotationZ->GetValue() );
+ _actualCuttingModel -> SetSpacing ( spc[0] , spc[1] , spc[2] );
+ _actualCuttingModel -> CalculeMatrix();
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::OnTransform(wxScrollEvent& event)
+{
+ RefreshView();
+}
+
+//-------------------------------------------------------------------
+void wxPanelCuttingImageData::SetVtkMPRBaseData( vtkMPRBaseData *vtkmprbasedata )
+{
+ _vtkmprbasedata = vtkmprbasedata;
+ _imageData = _vtkmprbasedata->GetImageData();
+}
+
+//-------------------------------------------------------------------
+
+void wxPanelCuttingImageData::Configure()
+{
+ _actualCuttingModel=_modelCylinder;
+ _actualActor=_cylinderActor;
+ _wxvtk3Dbaseview->GetRenderer()->AddActor( _actualActor );
+ SetParamsOfTransformation();
+ RefreshView();
+}
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+/*
+BEGIN_EVENT_TABLE( wxWidgetMesure2D , wxSplitterWindow )
+ EVT_MENU( 12121, wxWidgetMesure2D::OnRefreshView )
+END_EVENT_TABLE( );
+*/
+//-------------------------------------------------------------------
+
+wxWidgetMesure2D::wxWidgetMesure2D( wxWindow *parent )
+: wxSplitterWindow( parent , -1)
+{
+// EED 27 oct 2007
+ this->SplitHorizontally( new wxPanel(this,-1) , new wxPanel(this,-1), 2 );
+ this->SetMinimumPaneSize(50);
+}
+//-------------------------------------------------------------------
+wxWidgetMesure2D::~wxWidgetMesure2D()
+{
+}
+//-------------------------------------------------------------------
+wxWindow *wxWidgetMesure2D::CreateWin1a(wxWindow *parent) // virtual
+{
+ wxPanel *panel = new wxPanel(parent,-1);
+
+ _cb_messuretool = new wxCheckBox(panel,-1,_T("Active messure tool "));
+ _cb_mt_visible = new wxCheckBox(panel,-1,_T("Visibles "));
+ _cb_closeContour = new wxCheckBox(panel,-1,_T("Close/Open "));
+ _cb_visibleText = new wxCheckBox(panel,-1,_T("Information "));
+
+ _cb_mt_visible->SetValue(true);
+ _cb_closeContour->SetValue(true);
+ _cb_visibleText->SetValue(true);
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(4);
+
+ sizer->Add(_cb_messuretool);
+ sizer->Add(_cb_mt_visible);
+ sizer->Add(_cb_closeContour);
+ sizer->Add(_cb_visibleText);
+
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->SetSize(400,30);
+ panel->Layout();
+//EEDxx2.4
+// panel->FitInside();
+
+ Connect(_cb_messuretool->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D::OnActiveMessureTool );
+ Connect(_cb_mt_visible->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D::OnVisibleMessureTool );
+ Connect(_cb_closeContour->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D::OnCloseContour );
+ Connect(_cb_visibleText->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D::OnVisibleInformation );
+
+ return panel;
+}
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::ConfigureA(wxVtk2DBaseView *wxvtk2Dbaseview) // virtual
+{
+ _wxvtk2Dbaseview = wxvtk2Dbaseview;
+
+ // Contorno 1
+ _manContourControl_1 = new manualContourControler();
+ _mContourModel_1 = new manualContourModel();
+ _mViewContour_1 = new manualViewContour();
+ _mViewContour_1->SetModel( _mContourModel_1 );
+ _mViewContour_1->SetWxVtkBaseView( _wxvtk2Dbaseview );
+ _mViewContour_1->SetRange( 1 );
+
+// EED 3 oct 2006
+// double spc[3];
+// _wxvtk2Dbaseview->GetSpacing( spc );
+// _mViewContour_1->SetSpacing( spc );
+
+
+
+ _manContourControl_1->SetZ( 1000 );
+ _manContourControl_1->SetModelView( _mContourModel_1 , _mViewContour_1 );
+ _wxvtk2Dbaseview->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( _manContourControl_1 );
+ _manContourControl_1->CreateNewManualContour();
+ _manContourControl_1->SetActive( false );
+ _mViewContour_1->RefreshContour();
+
+//EED 27 Oct 2007
+
+// this->ReplaceWindow( this->GetWindow1() , CreateWin1a(this) );
+// this->ReplaceWindow( this->GetWindow2() , _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor() );
+// CreateWin1a(this->GetWindow1() );
+
+ wxBoxSizer *sizerA = new wxBoxSizer(wxHORIZONTAL);
+ sizerA->Add( CreateWin1a( this->GetWindow1()) ,1, wxGROW );
+ this->GetWindow1()->SetSizer(sizerA);
+ this->SetAutoLayout(true);
+ this->Layout();
+
+ wxBoxSizer *sizerB = new wxBoxSizer(wxHORIZONTAL);
+ sizerB->Add( _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor() ,1, wxGROW );
+ this->GetWindow2()->SetSizer(sizerB);
+ this->SetAutoLayout(true);
+ this->Layout();
+
+
+// this->SplitHorizontally( CreateWin1a(this) , _wxvtk2Dbaseview->GetWxVTKRenderWindowInteractor() , 2 );
+
+
+//EEDxx2.4
+// this->FitInside();
+}
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::ActiveMessureTool(bool ok)
+{
+ _wxvtk2Dbaseview->GetInteractorStyleBaseView()->SetActiveAllInteractors(!ok);
+ _manContourControl_1->SetActive( ok );
+}
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::OnActiveMessureTool(wxCommandEvent& event)
+{
+ ActiveMessureTool( _cb_messuretool->GetValue() );
+ if ( _cb_messuretool->GetValue() == true )
+ {
+ _cb_mt_visible->SetValue(true);
+ _mViewContour_1->SetVisible( _cb_mt_visible->GetValue() );
+ _cb_closeContour->Enable(true);
+ _cb_visibleText->Enable(true);
+ } else{
+ _cb_closeContour->Enable(false);
+ _cb_visibleText->Enable(false);
+ }
+ _wxvtk2Dbaseview->Refresh();
+ _wxvtk2Dbaseview->RefreshView();
+}
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::OnVisibleMessureTool(wxCommandEvent& event)
+{
+ _cb_messuretool->SetValue( _cb_mt_visible->GetValue() );
+ if (_cb_messuretool->GetValue()==true)
+ {
+ _cb_closeContour->Enable(true);
+ _cb_visibleText->Enable(true);
+ }
+ ActiveMessureTool( _cb_messuretool->GetValue() );
+ _mViewContour_1->SetVisible( _cb_mt_visible->GetValue() );
+ _mViewContour_1->Refresh();
+ _wxvtk2Dbaseview->Refresh();
+ _wxvtk2Dbaseview->RefreshView();
+}
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::OnCloseContour(wxCommandEvent& event)
+{
+ _mContourModel_1->SetCloseContour( _cb_closeContour->GetValue() );
+ _mViewContour_1->Refresh();
+ _wxvtk2Dbaseview->Refresh();
+ _wxvtk2Dbaseview->RefreshView();
+
+}
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::OnVisibleInformation(wxCommandEvent& event)
+{
+ _mViewContour_1->SetShowText( _cb_visibleText->GetValue() );
+ _mViewContour_1->Refresh();
+ _wxvtk2Dbaseview->Refresh();
+ _wxvtk2Dbaseview->RefreshView();
+}
+//-------------------------------------------------------------------
+void wxWidgetMesure2D::SetMesureScale(double mesureScale)
+{
+ _mViewContour_1->SetMesureScale(mesureScale);
+}
+//-------------------------------------------------------------------
+manualContourModel* wxWidgetMesure2D::GetManualContourModel()
+{
+ return _mContourModel_1;
+}
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxWidgetMesure2D_Plane::wxWidgetMesure2D_Plane(wxWindow *parent)
+: wxWidgetMesure2D(parent)
+{
+ // Circle 1
+ _ptsCircle1 = NULL;
+ _circle1Actor = NULL;
+ _circle1Mapper = NULL;
+ _pdCircle1 = NULL;
+ // Circle 2
+ _ptsCircle2 = NULL;
+ _circle2Actor = NULL;
+ _circle2Mapper = NULL;
+ _pdCircle2 = NULL;
+ // line reference 1
+ _ptsLineRef1 = NULL;
+ _lineRef1Actor = NULL;
+ _lineRef1Mapper = NULL;
+ _pdLineRef1 = NULL;
+ // line reference 2
+ _ptsLineRef2 = NULL;
+ _lineRef2Actor = NULL;
+ _lineRef2Mapper = NULL;
+ _pdLineRef2 = NULL;
+
+}
+
+//-------------------------------------------------------------------
+
+wxWidgetMesure2D_Plane::~wxWidgetMesure2D_Plane()
+{
+ // Circle 1
+ if ( _ptsCircle1 != NULL){ _ptsCircle1 -> Delete(); }
+ if ( _circle1Actor != NULL){ _circle1Actor -> Delete(); }
+ if ( _circle1Mapper != NULL){ _circle1Mapper -> Delete(); }
+ if ( _pdCircle1 != NULL){ _pdCircle1 -> Delete(); }
+ // Circle 2
+ if ( _ptsCircle2 != NULL){ _ptsCircle2 -> Delete(); }
+ if ( _circle2Actor != NULL){ _circle2Actor -> Delete(); }
+ if ( _circle2Mapper != NULL){ _circle2Mapper -> Delete(); }
+ if ( _pdCircle2 != NULL){ _pdCircle2 -> Delete(); }
+ // line reference 1
+ if ( _ptsLineRef1 != NULL){ _ptsLineRef1 -> Delete(); }
+ if ( _lineRef1Actor != NULL){ _lineRef1Actor -> Delete(); }
+ if ( _lineRef1Mapper != NULL){ _lineRef1Mapper -> Delete(); }
+ if ( _pdLineRef1 != NULL){ _pdLineRef1 -> Delete(); }
+ // line reference 2
+ if ( _ptsLineRef2 != NULL){ _ptsLineRef2 -> Delete(); }
+ if ( _lineRef2Actor != NULL){ _lineRef2Actor -> Delete(); }
+ if ( _lineRef2Mapper != NULL){ _lineRef2Mapper -> Delete(); }
+ if ( _pdLineRef2 != NULL){ _pdLineRef2 -> Delete(); }
+}
+
+//-------------------------------------------------------------------
+
+wxWindow *wxWidgetMesure2D_Plane::CreateWin1a(wxWindow *parent) // virtual
+{
+ wxPanel *panel = new wxPanel(parent,-1);
+
+ _cb_circle = new wxCheckBox(panel,-1,_T("Circle "));
+ _cb_line = new wxCheckBox(panel,-1,_T("Rotation Axe "));
+
+
+ wxBoxSizer *sizerA = new wxBoxSizer(wxHORIZONTAL);
+ sizerA->Add(_cb_circle);
+ sizerA->Add(_cb_line);
+
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
+ sizer->Add( sizerA );
+ sizer->Add( wxWidgetMesure2D::CreateWin1a(panel) );
+
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->SetSize(400,30);
+ panel->Layout();
+//EEDxx2.4
+// panel->FitInside();
+
+ Connect(_cb_line->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D_Plane::OnActiveLine );
+ Connect(_cb_circle->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxWidgetMesure2D_Plane::OnActiveCirlcle );
+
+ return panel;
+}
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::OnActiveCirlcle(wxCommandEvent& event)
+{
+ SetVisibleCircle( _cb_circle->GetValue() );
+ _wxvtk2Dbaseview->RefreshView();
+}
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::SetVisibleCircle( bool ok )
+{
+ double opacity;
+ if (ok==true)
+ {
+ opacity=1;
+ } else {
+ opacity=0;
+ }
+ _lineRef1Actor->GetProperty()->SetOpacity( opacity );
+ _lineRef2Actor->GetProperty()->SetOpacity( opacity );
+ _circle1Actor->GetProperty()->SetOpacity( opacity );
+ _circle2Actor->GetProperty()->SetOpacity( opacity );
+}
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::OnActiveLine(wxCommandEvent& event)
+{
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_wxvtk2Dbaseview;
+ vtkplane2Dview->SetVisibleLine( _cb_line->GetValue() );
+ _wxvtk2Dbaseview->RefreshView();
+}
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::ConfigureA(wxVtk2DBaseView *wxvtk2Dbaseview) // virtual
+{
+ wxWidgetMesure2D::ConfigureA(wxvtk2Dbaseview);
+ CircleLine();
+ ConfigureCircleLine();
+ SetVisibleCircle(false);
+}
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::ConfigureCircleLine()
+{
+ double ang;
+
+ vtkPlane2DView *vtkplane2Dview = (vtkPlane2DView*)_wxvtk2Dbaseview;
+ int sizeIma = vtkplane2Dview->GetImgSize();
+
+ double i,maxPts=20;
+ double k=(360/(maxPts-1)) * (3.1416/180);
+ double x,y,r1=5,r2=10,r3=15;
+ for (i=0;i<maxPts;i++)
+ {
+ x=cos( k*i ) ;
+ y=sin( k*i ) ;
+ _ptsCircle1->SetPoint( (int)i , (sizeIma/2) + x*r1 , (sizeIma/2) + y*r1 , 1 );
+ _ptsCircle2->SetPoint( (int)i , (sizeIma/2) + x*r2 , (sizeIma/2) + y*r2 , 1 );
+ }
+
+ //
+ ang=(45) * (3.1416/180);
+ x=cos( ang ) ;
+ y=sin( ang ) ;
+ _ptsLineRef1->SetPoint( 0 , (sizeIma/2) + x*r3 , (sizeIma/2) + y*r3 , 1 );
+
+ ang=(45+180) * (3.1416/180);
+ x=cos( ang ) ;
+ y=sin( ang ) ;
+ _ptsLineRef1->SetPoint( 1 , (sizeIma/2) + x*r3 , (sizeIma/2) + y*r3 , 1 );
+
+ //
+ ang=(135) * (3.1416/180);
+ x=cos( ang ) ;
+ y=sin( ang ) ;
+ _ptsLineRef2->SetPoint( 0 , (sizeIma/2) + x*r3 , (sizeIma/2) + y*r3 , 1 );
+
+ ang=(135+180) * (3.1416/180);
+ x=cos( ang ) ;
+ y=sin( ang ) ;
+ _ptsLineRef2->SetPoint( 1 , (sizeIma/2) + x*r3 , (sizeIma/2) + y*r3 , 1 );
+}
+
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane::CircleLine()
+{
+ int i,maxPts=20;
+ vtkCellArray *lines;
+
+ vtkImageViewer2_XYZ *imageViewer2XYZ = _wxvtk2Dbaseview->_imageViewer2XYZ;
+
+
+// Circle 1 Horizontal
+ _ptsCircle1 = vtkPoints::New();
+ _ptsCircle1->SetNumberOfPoints(maxPts);
+ lines = vtkCellArray::New();
+ lines->InsertNextCell(maxPts);
+ for (i=0;i<maxPts;i++)
+ {
+ lines->InsertCellPoint(i);
+ _ptsCircle1->SetPoint(i, 0 , 0 , 0 );
+ }
+ lines->InsertCellPoint(0);
+ _ptsCircle1->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsCircle1->SetPoint(1, 1000 , 1000 , 1000 );
+
+ _pdCircle1 = vtkPolyData::New();
+ _pdCircle1->SetPoints( _ptsCircle1 );
+ _pdCircle1->SetLines( lines );
+ lines->Delete(); //do not delete lines ??
+ _circle1Actor = vtkActor::New();
+ _circle1Mapper = vtkPolyDataMapper::New();
+ _circle1Mapper->SetInput(_pdCircle1);
+ _circle1Mapper->ImmediateModeRenderingOn();
+ _circle1Actor->SetMapper(_circle1Mapper);
+ _circle1Actor->GetProperty()->BackfaceCullingOn();
+ _circle1Actor->GetProperty()->SetDiffuseColor(0,0,1);
+ _circle1Actor->GetProperty()->SetLineWidth(2);
+ imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _circle1Actor );
+
+// Circle 2 Horizontal
+ _ptsCircle2 = vtkPoints::New();
+ _ptsCircle2->SetNumberOfPoints(maxPts);
+ lines = vtkCellArray::New();
+ lines->InsertNextCell(maxPts);
+ for (i=0;i<maxPts;i++)
+ {
+ lines->InsertCellPoint(i);
+ _ptsCircle2->SetPoint(i, 0 , 0 , 0 );
+ }
+ _ptsCircle2->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsCircle2->SetPoint(1, 1000 , 1000 , 1000 );
+
+ _pdCircle2 = vtkPolyData::New();
+ _pdCircle2->SetPoints( _ptsCircle2 );
+ _pdCircle2->SetLines( lines );
+ lines->Delete(); //do not delete lines ??
+ _circle2Actor = vtkActor::New();
+ _circle2Mapper = vtkPolyDataMapper::New();
+ _circle2Mapper->SetInput(_pdCircle2);
+ _circle2Mapper->ImmediateModeRenderingOn();
+ _circle2Actor->SetMapper(_circle2Mapper);
+ _circle2Actor->GetProperty()->BackfaceCullingOn();
+ _circle2Actor->GetProperty()->SetDiffuseColor(0,0,1);
+ _circle2Actor->GetProperty()->SetLineWidth(2);
+ imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _circle2Actor );
+
+// Line Referance 1
+ _ptsLineRef1 = vtkPoints::New();
+ _ptsLineRef1->SetNumberOfPoints(2);
+ _ptsLineRef1->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsLineRef1->SetPoint(1, 1000 , 1000 , 1000 );
+ lines = vtkCellArray::New();
+ lines->InsertNextCell(2);
+ lines->InsertCellPoint(0);
+ lines->InsertCellPoint(1);
+
+ _pdLineRef1 = vtkPolyData::New();
+ _pdLineRef1->SetPoints( _ptsLineRef1 );
+ _pdLineRef1->SetLines( lines );
+ lines->Delete(); //do not delete lines ??
+ _lineRef1Actor = vtkActor::New();
+ _lineRef1Mapper = vtkPolyDataMapper::New();
+ _lineRef1Mapper->SetInput(_pdLineRef1);
+ _lineRef1Mapper->ImmediateModeRenderingOn();
+ _lineRef1Actor->SetMapper(_lineRef1Mapper);
+ _lineRef1Actor->GetProperty()->BackfaceCullingOn();
+ _lineRef1Actor->GetProperty()->SetDiffuseColor(0,0,1);
+ _lineRef1Actor->GetProperty()->SetLineWidth(2);
+ imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineRef1Actor );
+
+// Line Referance 2
+ _ptsLineRef2 = vtkPoints::New();
+ _ptsLineRef2->SetNumberOfPoints(2);
+ _ptsLineRef2->SetPoint(0, -1000 , -1000 , -1000 );
+ _ptsLineRef2->SetPoint(1, 1000 , 1000 , 1000 );
+ lines = vtkCellArray::New();
+ lines->InsertNextCell(2);
+ lines->InsertCellPoint(0);
+ lines->InsertCellPoint(1);
+
+ _pdLineRef2 = vtkPolyData::New();
+ _pdLineRef2->SetPoints( _ptsLineRef2 );
+ _pdLineRef2->SetLines( lines );
+ lines->Delete(); //do not delete lines ??
+ _lineRef2Actor = vtkActor::New();
+ _lineRef2Mapper = vtkPolyDataMapper::New();
+ _lineRef2Mapper->SetInput(_pdLineRef2);
+ _lineRef2Mapper->ImmediateModeRenderingOn();
+ _lineRef2Actor->SetMapper(_lineRef2Mapper);
+ _lineRef2Actor->GetProperty()->BackfaceCullingOn();
+ _lineRef2Actor->GetProperty()->SetDiffuseColor(0,0,1);
+ _lineRef2Actor->GetProperty()->SetLineWidth(2);
+ imageViewer2XYZ->GetVtkImageViewer2()->GetRenderer()->AddActor( _lineRef2Actor );
+
+
+}
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+wxWidgetMesure2D_Plane_in_MPR::wxWidgetMesure2D_Plane_in_MPR(wxWindow *parent)
+:wxWidgetMesure2D_Plane(parent)
+{
+ _vtkplane2Dview=NULL;
+}
+
+//-------------------------------------------------------------------
+
+wxWidgetMesure2D_Plane_in_MPR::~wxWidgetMesure2D_Plane_in_MPR()
+{
+}
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane_in_MPR::OnActiveLink(wxCommandEvent& event)
+{
+ if (_vtkplane2Dview!=NULL)
+ {
+ _vtkplane2Dview->SetActive( _cb_link->GetValue() );
+ _vtkplane2Dview->Refresh();
+ _vtkplane2Dview->RefreshView();
+ }
+}
+
+
+//-------------------------------------------------------------------
+void wxWidgetMesure2D_Plane_in_MPR::SetActiveLink(bool ok)
+{
+ _cb_link->SetValue(ok);
+ if (_vtkplane2Dview!=NULL)
+ {
+ _vtkplane2Dview->SetActive( _cb_link->GetValue() );
+ }
+}
+//-------------------------------------------------------------------
+
+void wxWidgetMesure2D_Plane_in_MPR::SetVtkPlane2DView(vtkPlane2DView *vtkplane2Dview)
+{
+ _vtkplane2Dview = vtkplane2Dview;
+}
+
+//-------------------------------------------------------------------
+
+wxWindow *wxWidgetMesure2D_Plane_in_MPR::CreateWin1a(wxWindow *parent) // virtual
+{
+ wxPanel *panel = new wxPanel(parent,-1);
+
+ _cb_link = new wxCheckBox(panel,-1,_T("LINK "));
+ _cb_link->SetValue(true);
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
+
+ sizer->Add(_cb_link);
+
+ sizer->Add( wxWidgetMesure2D_Plane::CreateWin1a(panel) );
+
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->SetSize(400,30);
+ panel->Layout();
+
+//EEDxx2.4
+// panel->FitInside();
+
+ Connect(_cb_link->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED, (wxObjectEventFunction) &wxWidgetMesure2D_Plane_in_MPR::OnActiveLink );
+
+ return panel;
+}
+
+
+
+
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+//-------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE( wxMPRWidget, wxPanel )
+ EVT_MENU( 12121, wxMPRWidget::OnRefreshView )
+ EVT_MENU( 12122, wxMPRWidget::OnDClickLeft )
+END_EVENT_TABLE( );
+
+
+
+wxMPRWidget::wxMPRWidget( wxWindow* parent,
+ marImageData *marimageData , double voxelSize)
+: wxPanel( parent, -1, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL)
+{
+
+ _vtkmpr2Dview[0] = NULL;
+ _vtkmpr2Dview[1] = NULL;
+ _vtkmpr2Dview[2] = NULL;
+ _vtkplane2Dview = NULL;
+ _widgetMesure = NULL;
+ _wxsphereview = NULL;
+ _wxvtk3Dbaseview_MPRClipping3D = NULL;
+ _wxvtkmpr3Dview = NULL;
+ _wxvtkclipping3Dview = NULL;
+ _vtkplane2Dview_B = NULL;
+ _widgetMesure_B = NULL;
+
+ _vtkmpr2Dview_B[0] = NULL;
+ _vtkmpr2Dview_B[1] = NULL;
+ _vtkmpr2Dview_B[2] = NULL;
+ _vtkplane2Dview_B = NULL;
+ _widgetMesure_B = NULL;
+ _wxsphereview_B = NULL;
+ _wxvtk3Dbaseview_MPR3D_B = NULL;
+ _wxvtkmpr3Dview_B = NULL;
+ _wxvtk3Dbaseview_Clipping3D_BB = NULL;
+ _wxvtkmpr3Dview_BB = NULL;
+ _wxvtkclipping3Dview_BB = NULL;
+
+ _vtkmprbasedata = NULL;
+
+
+ _voxelSize = voxelSize;
+ _framePanelCutting = NULL;
+ _panelCutting = NULL;
+ _marImageData = marimageData;
+
+ _vtkmprbasedata = new vtkMPRBaseData();
+ _vtkmprbasedata->SetMarImageData(_marImageData);
+
+ wxSplitterWindow *pnlSplitter = new wxSplitterWindow( this , -1);
+
+ wxPanel *MPRPanel = CreateMPRPanel(pnlSplitter,_vtkmprbasedata);
+ wxPanel *controlPanel = CreateControlPanel(pnlSplitter);
+ wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL );
+ sizer -> Add( pnlSplitter ,1,wxGROW ,0);
+
+ int ww,hh;
+ wxWindow *pp=this;
+ while (pp->GetParent()!=NULL) pp=pp->GetParent();
+ pp->GetSize(&ww,&hh);
+
+ pnlSplitter -> SetMinimumPaneSize( 2 );
+
+ pnlSplitter -> SplitVertically( MPRPanel, controlPanel, 550 );
+ this -> SetAutoLayout( true );
+ this -> SetSizer(sizer);
+// sizer -> Fit( this );
+
+ _refreshAPage=0;
+ _refreshBPage=0;
+
+}
+
+//----------------------------------------------------------------------------
+
+wxMPRWidget::~wxMPRWidget( )
+{
+//EEDxx2.4 DELETE
+ if (_framePanelCutting!=NULL)
+ {
+ _framePanelCutting->Close();
+ }
+
+ if (_vtkmpr2Dview[0]!=NULL) { delete _vtkmpr2Dview[0]; }
+ if (_vtkmpr2Dview[1]!=NULL) { delete _vtkmpr2Dview[1]; }
+ if (_vtkmpr2Dview[2]!=NULL) { delete _vtkmpr2Dview[2]; }
+
+ if (_vtkmpr2Dview_B[0]!=NULL) { delete _vtkmpr2Dview_B[0]; }
+
+ if (_vtkmpr2Dview_B[1]!=NULL) { delete _vtkmpr2Dview_B[1]; }
+ if (_vtkmpr2Dview_B[2]!=NULL) { delete _vtkmpr2Dview_B[2]; }
+
+ if (_vtkmprbasedata!=NULL) { delete _vtkmprbasedata; }
+ if (_vtkplane2Dview!=NULL) { delete _vtkplane2Dview; }
+ if (_wxsphereview!=NULL) { delete _wxsphereview; }
+ if (_wxvtk3Dbaseview_MPRClipping3D!=NULL) { delete _wxvtk3Dbaseview_MPRClipping3D; }
+ if (_wxvtkmpr3Dview!=NULL) { delete _wxvtkmpr3Dview; }
+ if (_wxvtkclipping3Dview!=NULL) { delete _wxvtkclipping3Dview; }
+
+ if (_vtkplane2Dview_B!=NULL) { delete _vtkplane2Dview_B; }
+ if (_wxsphereview_B!=NULL) { delete _wxsphereview_B; }
+
+ if (_wxvtk3Dbaseview_MPR3D_B!=NULL) { delete _wxvtk3Dbaseview_MPR3D_B; }
+ if (_wxvtkmpr3Dview_B!=NULL) { delete _wxvtkmpr3Dview_B; }
+
+ if (_wxvtk3Dbaseview_Clipping3D_BB!=NULL) { delete _wxvtk3Dbaseview_Clipping3D_BB; }
+ if (_wxvtkmpr3Dview_BB!=NULL) { delete _wxvtkmpr3Dview_BB; }
+ if (_wxvtkclipping3Dview_BB!=NULL) { delete _wxvtkclipping3Dview_BB; }
+}
+
+//----------------------------------------------------------------------------
+
+wxPanel* wxMPRWidget::CreateControlPanel(wxWindow *parent)
+{
+
+ wxPanel *panel=new wxPanel(parent,-1);
+
+//EEDxx2.4
+// wxStaticText *tmpText = new wxStaticText(panel,-1,"");
+
+ wxStaticText *help0Text = new wxStaticText(panel,-1,_T("General: \n middle click : contrast\n ctrl + middle click : rotate image\n shift + middle click: translate image\n ctrl + right click: zoom"));
+
+ wxStaticText *help1Text = new wxStaticText(panel,-1,_T("mpr2D: \n double click : choose a point\n mouse right : change perpendicular slice\n drag axis: change slice"));
+
+ wxStaticText *help2Text = new wxStaticText(panel,-1,_T("Plane: \n drag mouse: rotate\n ctrl + drag mouse : fix axis rotation\n \n mouse right: change perpendicular slice \n see split control \n - Active/Desactivet plane tool\n - Center market\n - Rotation axis market\n - 2D messure tool (open/close contour)"));
+
+ wxStaticText *help3Text = new wxStaticText(panel,-1,
+_T("Sphere: \n drag mouse: rotation\n mouse right: change radio \n click: 3D point selection in MPR 2D \n double clicks in MPR: show surface sphere"));
+
+ wxStaticText *help4Text = new wxStaticText(panel,-1,_T("MPR3D:\n see split control"));
+
+ wxString text=_T("");
+ text=text+_T("Clipping: \n");
+ text=text+_T(" see split control \n");
+ text=text+_T(" 4 MarchingCubes: \n");
+ text=text+_T(" color, isovalue, opacity \n");
+ text=text+_T(" Box:\n");
+ text=text+_T(" mouse left drag (box): rotation\n");
+ text=text+_T(" mouse left drag (sphere): size,position\n");
+ text=text+_T(" mouse right drag (box): box size");
+ text=text+_T(" Axis: 3D\n");
+ text=text+_T(" mouse drag: translate\n");
+ text=text+_T(" shift + mouse drag: translate 2 axis\n");
+ text=text+_T(" mouse right: scale\n");
+ text=text+_T(" Plane 3D:\n");
+ text=text+_T(" mouse drag perpendicular axis: rotate plane\n");
+ text=text+_T(" mouse drag spheres: size plane\n");
+ text=text+_T(" ctrl +mouse right over the plane: size plane\n");
+ text=text+_T(" mouse drag plane: translate\n");
+ text=text+_T(" middle click perpendicular axis: translate\n");
+ wxStaticText *help5Text = new wxStaticText(panel,-1, text );
+
+
+ wxFlexGridSizer *sizer = new wxFlexGridSizer(1);
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help0Text );
+
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help1Text );
+
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help2Text );
+
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help3Text );
+
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help4Text );
+
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( new wxStaticText(panel,-1,_T("")) );
+ sizer->Add( help5Text );
+
+ panel->SetSizer(sizer);
+ panel->SetAutoLayout(true);
+ panel->SetSize(350,500);
+
+ return panel;
+}
+
+//----------------------------------------------------------------------------
+
+void wxMPRWidget::OnPageAChanged(wxNotebookEvent & event)
+{
+ _refreshAPage=event.GetSelection();
+ Refresh();
+ RefreshView(true);
+}
+
+//----------------------------------------------------------------------------
+
+void wxMPRWidget::OnPageBChanged(wxNotebookEvent & event)
+{
+ _refreshBPage=event.GetSelection();
+// Refresh(false);
+// RefreshView();
+}
+
+
+//----------------------------------------------------------------------------
+
+wxPanel* wxMPRWidget::CreateView(int type,wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
+{
+ wxWindow *wxwindow;
+ wxPanel *panel=new wxPanel(parent,-1);
+
+ if (type==0)
+ {
+ _vtkmpr2Dview_B[0] = new wxVtkMPR2DView(panel,0);
+ _vtkmpr2Dview_B[0]->SetVtkBaseData(vtkmprbasedata);
+ wxwindow=_vtkmpr2Dview_B[0]->GetWxVTKRenderWindowInteractor();
+ }
+ if (type==1)
+ {
+ _vtkmpr2Dview_B[1] = new wxVtkMPR2DView(panel,1);
+ _vtkmpr2Dview_B[1]->SetVtkBaseData(vtkmprbasedata);
+ wxwindow=_vtkmpr2Dview_B[1]->GetWxVTKRenderWindowInteractor();
+ }
+ if (type==2)
+ {
+ _vtkmpr2Dview_B[2] = new wxVtkMPR2DView(panel,2);
+ _vtkmpr2Dview_B[2]->SetVtkBaseData(vtkmprbasedata);
+ wxwindow=_vtkmpr2Dview_B[2]->GetWxVTKRenderWindowInteractor();
+ }
+ if (type==3)
+ {
+ _widgetMesure_B = new wxWidgetMesure2D_Plane_in_MPR(panel);
+ _vtkplane2Dview_B = new vtkPlane2DView( _widgetMesure_B->GetWindow2());
+ _widgetMesure_B->SetVtkPlane2DView( _vtkplane2Dview_B );
+ _vtkplane2Dview_B->SetImgSize( 200 );
+ _vtkplane2Dview_B->SetVtkBaseData(vtkmprbasedata);
+ wxwindow = _widgetMesure_B;
+ }
+ if (type==4)
+ {
+ _wxsphereview_B = new wxSphereView( panel , vtkmprbasedata, vtkmprbasedata->GetImageData() );
+ wxwindow=_wxsphereview_B->GetWxVTKRenderWindowInteractor();
+ }
+
+ if (type==5)
+ {
+ wxSplitterWindow *panelMPR3D = new wxSplitterWindow( panel , -1);
+ _wxvtk3Dbaseview_MPR3D_B = new wxVtk3DBaseView( panelMPR3D );
+
+ _wxvtkmpr3Dview_B = new wxVtkMPR3DView(_wxvtk3Dbaseview_MPR3D_B);
+ vtkMPR3DDataViewer *vtkmpr3Ddataviewer = new vtkMPR3DDataViewer();
+ vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
+ vtkmpr3Ddataviewer->Configure();
+ _wxvtkmpr3Dview_B->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
+
+ wxWindow *window3D = _wxvtk3Dbaseview_MPR3D_B->GetWxVTKRenderWindowInteractor();
+ wxPanel *controlPanel3D = _wxvtkmpr3Dview_B->CreateControlPanel(panelMPR3D);
+
+//EEDxx2.4
+ panelMPR3D -> SetMinimumPaneSize( 5 );
+ panelMPR3D -> SplitHorizontally( controlPanel3D,window3D,600 );
+
+ wxwindow=panelMPR3D;
+ }
+
+ if (type==6)
+ {
+ wxSplitterWindow *panelClipping3D = new wxSplitterWindow( panel , -1);
+ _wxvtk3Dbaseview_Clipping3D_BB = new wxVtk3DBaseView( panelClipping3D );
+
+ _wxvtkclipping3Dview_BB = new wxVtkClipping3DView(_wxvtk3Dbaseview_Clipping3D_BB);
+ vtkClipping3DDataViewer *vtkclipping3Ddataviewer = new vtkClipping3DDataViewer();
+ vtkclipping3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
+ vtkclipping3Ddataviewer->Configure();
+ _wxvtkclipping3Dview_BB->SetVtkClipping3DDataViewer(vtkclipping3Ddataviewer);
+
+ _wxvtkmpr3Dview_BB = new wxVtkMPR3DView( _wxvtk3Dbaseview_Clipping3D_BB );
+ vtkMPR3DDataViewer *vtkmpr3Ddataviewer = new vtkMPR3DDataViewer();
+ vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
+ vtkmpr3Ddataviewer->Configure();
+ _wxvtkmpr3Dview_BB->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
+
+ wxWindow *window3D = _wxvtk3Dbaseview_Clipping3D_BB->GetWxVTKRenderWindowInteractor();
+
+ wxPanel *panelControl = new wxPanel(panelClipping3D,-1);
+ wxPanel *controlPanelMPR3D = _wxvtkmpr3Dview_BB->CreateControlPanel(panelControl);
+ wxPanel *controlPanelClipping3D = _wxvtkclipping3Dview_BB->CreateControlPanel(panelControl);
+ _btnCutImageData = new wxCheckBox(panelControl,-1,_T("Cut Module"));
+ Connect(_btnCutImageData->GetId() , wxEVT_COMMAND_CHECKBOX_CLICKED , (wxObjectEventFunction) &wxMPRWidget::OnCutImagaData );
+
+ wxFlexGridSizer *sizerCtrol = new wxFlexGridSizer(1);
+ sizerCtrol->Add(controlPanelMPR3D , 1, wxALL|wxEXPAND, 2);
+ sizerCtrol->Add(controlPanelClipping3D , 1, wxALL|wxEXPAND, 2);
+ sizerCtrol->Add( _btnCutImageData , 1, wxALL, 2);
+
+ panelControl->SetAutoLayout(true);
+ panelControl->SetSizer(sizerCtrol);
+ panelControl->SetSize(400,350);
+ panelControl->Layout();
+//EEDxx2.4
+// panelControl->FitInside();
+
+//EEDxx2.4
+ panelClipping3D -> SetMinimumPaneSize( 5 );
+ panelClipping3D -> SplitHorizontally( panelControl , window3D , 10 );
+ wxwindow=panelClipping3D;
+ }
+
+ wxBoxSizer *sizerH1 = new wxBoxSizer(wxHORIZONTAL);
+ sizerH1->Add(wxwindow , 1, wxALL|wxGROW, 0);
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizerH1);
+ panel->SetSize(400,400);
+ panel->Layout();
+
+ return panel;
+}
+
+//----------------------------------------------------------------------------
+
+wxPanel* wxMPRWidget::CreateMPRPanel(wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
+{
+ wxPanel *panel=new wxPanel(parent,-1);
+
+ wxNotebook *notebook = new wxNotebook( panel, -1 );
+
+ notebook->AddPage( CreateMPRPanel4View( notebook ,vtkmprbasedata), _T("4-View") );
+ notebook->AddPage( CreateView(0,notebook,vtkmprbasedata) , _T("Axial") );
+ notebook->AddPage( CreateView(1,notebook,vtkmprbasedata) , _T("Sagital") );
+ notebook->AddPage( CreateView(2,notebook,vtkmprbasedata) , _T("Coronal") );
+ notebook->AddPage( CreateView(3,notebook,vtkmprbasedata) , _T("Plane") );
+ notebook->AddPage( CreateView(4,notebook,vtkmprbasedata) , _T("Sphere") );
+ notebook->AddPage( CreateView(5,notebook,vtkmprbasedata) , _T("MPR 3D") );
+ notebook->AddPage( CreateView(6,notebook,vtkmprbasedata) , _T("Clipping") );
+ Connect(notebook->GetId() , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , (wxObjectEventFunction) &wxMPRWidget::OnPageAChanged );
+
+ wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
+ sizer->Add(notebook , 1, wxALL|wxGROW, 2);
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizer);
+ panel->SetSize(400,400);
+ panel->Layout();
+
+//EEDxx2.4
+// panel->FitInside();
+
+ panel->Refresh();
+ return panel;
+}
+
+//----------------------------------------------------------------------------
+
+wxPanel* wxMPRWidget::CreateMPRPanel4View(wxWindow *parent, vtkMPRBaseData *vtkmprbasedata)
+{
+ wxPanel *panel=new wxPanel(parent,-1);
+
+ // view 0
+ _vtkmpr2Dview[0] = new wxVtkMPR2DView(panel,0);
+ _vtkmpr2Dview[0]->SetVtkBaseData(vtkmprbasedata);
+ wxVTKRenderWindowInteractor *iren0 = _vtkmpr2Dview[0]->GetWxVTKRenderWindowInteractor();
+
+ // view 1
+ _vtkmpr2Dview[1] = new wxVtkMPR2DView(panel,1);
+ _vtkmpr2Dview[1]->SetVtkBaseData(vtkmprbasedata);
+ wxVTKRenderWindowInteractor *iren1 = _vtkmpr2Dview[1]->GetWxVTKRenderWindowInteractor();
+
+ // view 2
+ _vtkmpr2Dview[2] = new wxVtkMPR2DView(panel,2);
+ _vtkmpr2Dview[2]->SetVtkBaseData(vtkmprbasedata);
+ wxVTKRenderWindowInteractor *iren2 = _vtkmpr2Dview[2]->GetWxVTKRenderWindowInteractor();
+
+ // view 3
+ wxNotebook *notebook = new wxNotebook( panel, -1 );
+ notebook->SetSize(400,400);
+
+// EED 27 Oct 2007
+ // view 3.0
+ _widgetMesure = new wxWidgetMesure2D_Plane_in_MPR(notebook);
+ _vtkplane2Dview = new vtkPlane2DView( _widgetMesure->GetWindow2() );
+ _widgetMesure->SetVtkPlane2DView( _vtkplane2Dview );
+ _vtkplane2Dview->SetImgSize( 200 );
+ _vtkplane2Dview->SetVtkBaseData(vtkmprbasedata);
+ notebook->AddPage( _widgetMesure, _T("Plane") );
+
+ // view 3.1
+ _wxsphereview = new wxSphereView( notebook , vtkmprbasedata, vtkmprbasedata->GetImageData());
+ wxVTKRenderWindowInteractor *iren3B = _wxsphereview->GetWxVTKRenderWindowInteractor();
+ notebook->AddPage( iren3B, _T("Sphere") );
+
+
+ // view 3.2
+ wxSplitterWindow *panelMPR3D = new wxSplitterWindow( notebook , -1);
+ _wxvtk3Dbaseview_MPRClipping3D = new wxVtk3DBaseView( panelMPR3D );
+
+ _wxvtkmpr3Dview = new wxVtkMPR3DView( _wxvtk3Dbaseview_MPRClipping3D );
+ vtkMPR3DDataViewer *vtkmpr3Ddataviewer = new vtkMPR3DDataViewer();
+ vtkmpr3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
+ vtkmpr3Ddataviewer->Configure();
+ _wxvtkmpr3Dview->SetVtkMPR3DDataViewer(vtkmpr3Ddataviewer);
+
+
+ _wxvtkclipping3Dview = new wxVtkClipping3DView( _wxvtk3Dbaseview_MPRClipping3D );
+ vtkClipping3DDataViewer *vtkclipping3Ddataviewer = new vtkClipping3DDataViewer();
+ vtkclipping3Ddataviewer->SetVtkMPRBaseData(vtkmprbasedata);
+ vtkclipping3Ddataviewer->Configure();
+ _wxvtkclipping3Dview->SetVtkClipping3DDataViewer(vtkclipping3Ddataviewer);
+
+
+ wxWindow *window3D = _wxvtk3Dbaseview_MPRClipping3D->GetWxVTKRenderWindowInteractor();
+
+ wxPanel *panelControl = new wxPanel(panelMPR3D,-1);
+ wxPanel *controlPanelMPR3D = _wxvtkmpr3Dview->CreateControlPanel(panelControl);
+ wxPanel *controlPanelClipping3D = _wxvtkclipping3Dview->CreateControlPanel(panelControl);
+
+
+
+
+// wxBoxSizer *sizerCtrol = new wxBoxSizer(wxVERTICAL);
+ wxFlexGridSizer *sizerCtrol = new wxFlexGridSizer(1);
+ sizerCtrol->Add(controlPanelMPR3D , 1, wxALL|wxEXPAND, 2);
+ sizerCtrol->Add(controlPanelClipping3D , 1, wxALL|wxEXPAND, 2);
+
+
+ panelControl->SetAutoLayout(true);
+ panelControl->SetSizer(sizerCtrol);
+ panelControl->SetSize(400,150);
+ panelControl->Layout();
+
+//EEDxx2.4
+ panelMPR3D -> SetMinimumPaneSize( 5 );
+
+ panelMPR3D -> SplitHorizontally( panelControl,window3D,200 );
+
+ notebook->AddPage( panelMPR3D, _T("MPR 3D - Clipping") );
+
+
+ Connect(notebook->GetId() , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , (wxObjectEventFunction) &wxMPRWidget::OnPageBChanged );
+
+ wxBoxSizer *sizerV = new wxBoxSizer(wxVERTICAL);
+ wxBoxSizer *sizerH1= new wxBoxSizer(wxHORIZONTAL);
+ wxBoxSizer *sizerH2= new wxBoxSizer(wxHORIZONTAL);
+ sizerH1->Add(iren2 , 1, wxALL|wxEXPAND, 2);
+ sizerH1->Add(iren0 , 1, wxALL|wxEXPAND, 2);
+ sizerH2->Add(iren1 , 1, wxALL|wxEXPAND, 2);
+// sizerH2->Add(iren3 , 1, wxALL|wxEXPAND, 2);
+ sizerH2->Add(notebook , 1, wxALL|wxEXPAND, 2);
+
+ sizerV->Add(sizerH1, 1, wxALL|wxEXPAND, 0);
+ sizerV->Add(sizerH2, 1, wxALL|wxEXPAND, 0);
+
+ panel->SetAutoLayout(true);
+ panel->SetSizer(sizerV);
+ panel->SetSize(400,400);
+ panel->Layout();
+ return panel;
+}
+
+//----------------------------------------------------------------------------
+void wxMPRWidget::OnCutImagaData(wxCommandEvent &event)
+{
+ if (_btnCutImageData->GetValue()==true){
+ _framePanelCutting = new wxFrame(this,-1,_T("Cutting Module"),wxDefaultPosition,wxDefaultSize,wxCAPTION|wxSTAY_ON_TOP| wxRESIZE_BORDER );
+ _framePanelCutting->SetSize(550,400);
+ _panelCutting = new wxPanelCuttingImageData(_framePanelCutting);
+ _panelCutting->SetWxVtk3DBaseView( _wxvtk3Dbaseview_Clipping3D_BB );
+ _panelCutting->SetVtkMPRBaseData( GetVtkMPRBaseData() );
+ _panelCutting->SetVtkClipping3DDataViewer( this->_wxvtkclipping3Dview_BB->GetVtkClipping3DDataViewer() );
+ _panelCutting->Configure( );
+/*
+ wxBoxSizer *topsizer = new wxBoxSizer(wxHORIZONTAL );
+ topsizer -> Add( _panelCutting ,1,wxALL ,0);
+ _framePanelCutting->SetAutoLayout(true);
+ _framePanelCutting->SetSizer( topsizer ); // use the sizer for layout
+ _framePanelCutting->Layout();
+//EEDxx2.4
+// _framePanelCutting->FitInside();
+*/
+ _framePanelCutting->Show();
+ } else {
+ if (_framePanelCutting!=NULL){
+ _panelCutting->RemoveActors();
+ _framePanelCutting->Close();
+ _framePanelCutting = NULL;
+ _panelCutting = NULL;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void wxMPRWidget::ConfigureVTK(){
+ int x=0,y=0,z=0;
+
+ if (_vtkmprbasedata!=NULL)
+ {
+ x=_vtkmprbasedata -> GetMaxPositionX()/2;
+ y=_vtkmprbasedata -> GetMaxPositionY()/2;
+ z=_vtkmprbasedata -> GetMaxPositionZ()/2;
+ }
+
+ if(_vtkmpr2Dview[0]!=NULL) {_vtkmpr2Dview[0] -> Configure();}
+ if(_vtkmpr2Dview[1]!=NULL) {_vtkmpr2Dview[1] -> Configure();}
+ if(_vtkmpr2Dview[2]!=NULL) {_vtkmpr2Dview[2] -> Configure();}
+
+
+ if (_vtkmpr2Dview_B[0]!=NULL) { _vtkmpr2Dview_B[0] -> Configure(); }
+ if (_vtkmpr2Dview_B[1]!=NULL) { _vtkmpr2Dview_B[1] -> Configure(); }
+ if (_vtkmpr2Dview_B[2]!=NULL) { _vtkmpr2Dview_B[2] -> Configure(); }
+
+
+ if (_vtkmprbasedata!=NULL)
+ {
+ _vtkmprbasedata->SetX( x );
+ _vtkmprbasedata->SetY( y );
+ _vtkmprbasedata->SetZ( z );
+ }
+
+ if (_vtkplane2Dview!=NULL){_vtkplane2Dview -> Configure();}
+ if (_widgetMesure!=NULL){_widgetMesure -> ConfigureA(_vtkplane2Dview);}
+ if (_widgetMesure!=NULL){_widgetMesure -> SetActiveLink(true);}
+ if (_widgetMesure!=NULL){_widgetMesure -> SetMesureScale( _voxelSize );}
+ if (_wxsphereview!=NULL){_wxsphereview -> Configure();}
+
+ if (_wxvtk3Dbaseview_MPRClipping3D!=NULL){_wxvtk3Dbaseview_MPRClipping3D -> Configure();}
+ if (_wxvtkmpr3Dview!=NULL){
+ _wxvtkmpr3Dview -> Configure();
+ }
+ if (_wxvtkclipping3Dview!=NULL){_wxvtkclipping3Dview -> Configure();}
+
+ if (_vtkplane2Dview_B!=NULL){ _vtkplane2Dview_B -> Configure(); }
+ if (_widgetMesure_B!=NULL){ _widgetMesure_B -> ConfigureA( _vtkplane2Dview_B ); }
+ if (_widgetMesure_B!=NULL){ _widgetMesure_B -> SetActiveLink(true); }
+
+//EEDx3
+// double spc[3];
+// vtkImageData *imageData = _vtkmprbasedata->GetImageData();
+// imageData->Update();
+// imageData->GetSpacing(spc);
+// _widgetMesure_B->SetMesureScale(spc[0]);
+
+ if (_widgetMesure_B!=NULL) {_widgetMesure_B->SetMesureScale( _voxelSize );}
+
+
+ if (_wxsphereview_B!=NULL) {_wxsphereview_B -> Configure();}
+
+ if (_wxvtk3Dbaseview_MPR3D_B!=NULL) {_wxvtk3Dbaseview_MPR3D_B -> Configure();}
+ if (_wxvtkmpr3Dview_B!=NULL) {_wxvtkmpr3Dview_B -> Configure();}
+
+ if ( _wxvtk3Dbaseview_Clipping3D_BB!=NULL) {_wxvtk3Dbaseview_Clipping3D_BB -> Configure(); }
+ if ( _wxvtkmpr3Dview_BB!=NULL) {_wxvtkmpr3Dview_BB -> Configure(); }
+ if ( _wxvtkclipping3Dview_BB!=NULL) {_wxvtkclipping3Dview_BB -> Configure(); }
+
+
+ vtkInteractorStyle3DView *vtkinteractorstyle3Dview;
+ if (_wxvtkmpr3Dview_BB!=NULL)
+ {
+ vtkinteractorstyle3Dview = new vtkInteractorStyle3DView();
+ vtkinteractorstyle3Dview->SetWxVtkMPR3DView(_wxvtkmpr3Dview_BB);
+ vtkinteractorstyle3Dview->SetWxVtkClipping3DView(_wxvtkclipping3Dview_BB);
+ }
+
+ if (_wxvtk3Dbaseview_Clipping3D_BB!=NULL)
+ {
+ _wxvtk3Dbaseview_Clipping3D_BB->GetInteractorStyleBaseView()->AddInteractorStyleMaracas( vtkinteractorstyle3Dview );
+ }
+
+ RefreshView(true);
+}
+
+//----------------------------------------------------------------------------
+
+void wxMPRWidget::OnRefreshView(wxCommandEvent & event)
+{
+ RefreshView();
+}
+//----------------------------------------------------------------------------
+void wxMPRWidget::OnDClickLeft(wxCommandEvent & event)
+{
+ if (_wxsphereview!=NULL) {
+ _wxsphereview -> RefreshPoint();
+ }
+ if (_wxsphereview_B!=NULL) {
+ _wxsphereview_B -> RefreshPoint();
+ }
+}
+//----------------------------------------------------------------------------
+void wxMPRWidget::RefreshView(bool firsttime){
+
+ if (_refreshAPage == 0 )
+ {
+
+ if ((_vtkmpr2Dview[0]!=NULL) && (_vtkmpr2Dview[1]!=NULL) && (_vtkmpr2Dview[2]!=NULL) )
+ {
+ _vtkmpr2Dview[2] -> Refresh();
+ _vtkmpr2Dview[1] -> Refresh();
+ _vtkmpr2Dview[0] -> Refresh();
+
+ if (firsttime==false)
+ {
+ _vtkmpr2Dview[2] -> RefreshView();
+ _vtkmpr2Dview[1] -> RefreshView();
+ _vtkmpr2Dview[0] -> RefreshView();
+ }
+
+ if (_refreshBPage == 0 )
+ {
+ if (_vtkplane2Dview!=NULL)
+ {
+ _vtkplane2Dview -> Refresh();
+ if (firsttime==false)
+ {
+ _vtkplane2Dview -> RefreshView();
+ }
+// _wxvtk3Dbaseview_MPR3D_B -> Refresh();
+ }
+ }
+ if (_refreshBPage == 1 )
+ {
+ //sphere
+ }
+ if (_refreshBPage == 2 )
+ {
+ if ((_wxvtkmpr3Dview!=NULL) && (_wxvtk3Dbaseview_MPRClipping3D!=NULL) && (_wxvtkclipping3Dview!=NULL) )
+ {
+ _wxvtkmpr3Dview -> RefreshView();
+ _wxvtk3Dbaseview_MPRClipping3D -> Refresh();
+ _wxvtkclipping3Dview -> Refresh();
+ }
+ }
+ }
+ }
+
+ if (_refreshAPage == 1 )
+ {
+ if (_vtkmpr2Dview_B[0] !=NULL){
+ _vtkmpr2Dview_B[0] -> Refresh();
+ }
+ }
+ if (_refreshAPage == 2 )
+ {
+ if (_vtkmpr2Dview_B[1] !=NULL){
+ _vtkmpr2Dview_B[1] -> Refresh();
+ }
+ }
+ if (_refreshAPage == 3 )
+ {
+ if (_vtkmpr2Dview_B[2] !=NULL){
+ _vtkmpr2Dview_B[2] -> Refresh();
+ }
+ }
+ if (_refreshAPage == 4 )
+ {
+ if (_vtkplane2Dview_B!=NULL){
+ _vtkplane2Dview_B -> Refresh();
+ if (firsttime==false)
+ {
+ _vtkplane2Dview_B -> RefreshView();
+ }
+ }
+ }
+
+ if (_refreshAPage == 5 )
+ {
+ // sphere
+ }
+ if (_refreshAPage == 6 )
+ {
+ if (_wxvtkmpr3Dview_B!=NULL){
+ _wxvtkmpr3Dview_B -> Refresh();
+ _wxvtk3Dbaseview_MPR3D_B -> Refresh();
+ }
+ }
+ if (_refreshAPage == 7 )
+ {
+ if (_wxvtkmpr3Dview_BB!=NULL){
+ _wxvtkmpr3Dview_BB -> RefreshView();
+ _wxvtkclipping3Dview_BB -> Refresh();
+ _wxvtk3Dbaseview_Clipping3D_BB -> Refresh();
+ if (_panelCutting!=NULL)
+ {
+ _panelCutting->RefreshView();
+ }
+ }
+ }
+
+}
+//----------------------------------------------------------------------------
+vtkMPRBaseData *wxMPRWidget::GetVtkMPRBaseData(){
+ return _vtkmprbasedata;
+}
+//----------------------------------------------------------------------------
+vtkPlane2DView *wxMPRWidget::GetVtkPlane2DView()
+{
+ return _vtkplane2Dview;
+}
+//----------------------------------------------------------------------------
+wxVtkMPR3DView *wxMPRWidget::GetWxvtkmpr3Dview_BB()
+{
+ return _wxvtkmpr3Dview_BB;
+}
+//----------------------------------------------------------------------------
+wxVtkBaseView *wxMPRWidget::GetWxVtkBaseView(int page, int id)
+{
+ wxVtkBaseView *result=NULL;
+ if (page==0)
+ {
+ if ((id>=0) &&(id<=3)){
+ result=_vtkmpr2Dview[id];
+ }
+ if (id==3)
+ {
+ result=_vtkplane2Dview;
+ }
+ }
+ return result;
+}
+//----------------------------------------------------------------------------
+wxVtkMPR2DView *wxMPRWidget::GetWxvtkMPR2Dview(int direction)
+{
+ return _vtkmpr2Dview[direction];
+}
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+wxMPRWidget2::wxMPRWidget2(wxWindow* parent,marImageData *marimagedata,double voxelSize)
+: wxMPRWidget(parent,marimagedata,voxelSize)
+{
+}
+//----------------------------------------------------------------------------
+wxMPRWidget2::~wxMPRWidget2()
+{
+}
+//----------------------------------------------------------------------------
+void wxMPRWidget2::OnRefreshView(wxCommandEvent & event) // Virtual
+{
+ wxCommandEvent newevent1(wxEVT_COMMAND_MENU_SELECTED,12121); // Refresh
+ this->GetParent()->ProcessEvent(newevent1);
+}
+
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+figureCuttingModel::figureCuttingModel()
+{
+ _inversModel = vtkTransform::New();
+ _matrixModel = vtkTransform::New();
+ _matrixVisual = vtkTransform::New();
+
+ _spcX=1;
+ _spcY=1;
+ _spcZ=1;
+}
+//----------------------------------------------------------------------------
+figureCuttingModel::~figureCuttingModel() // virtual
+{
+ _inversModel->Delete();
+}
+//----------------------------------------------------------------------------
+void figureCuttingModel::SetPosition(double x,double y, double z)
+{
+ _px=x;
+ _py=y;
+ _pz=z;
+}
+//----------------------------------------------------------------------------
+void figureCuttingModel::SetScale(double sx,double sy, double sz)
+{
+ _sx=sx;
+ _sy=sy;
+ _sz=sz;
+}
+//----------------------------------------------------------------------------
+void figureCuttingModel::SetRotation(double alfa,double beta, double teta)
+{
+ _alfa=alfa;
+ _beta=beta;
+ _teta=teta;
+}
+
+//----------------------------------------------------------------------------
+void figureCuttingModel::CalculeMatrix()
+{
+ _matrixModel->Identity();
+ _matrixModel->Translate(_px,_py,_pz);
+ _matrixModel->RotateY(_beta);
+ _matrixModel->RotateX(_alfa);
+ _matrixModel->RotateY(_teta);
+ _matrixModel->Scale(_sx,_sy,_sz);
+
+ _matrixVisual->Identity();
+ _matrixVisual->Translate( _px*_spcX , _py*_spcY , _pz*_spcZ );
+ _matrixVisual->RotateY(_beta);
+ _matrixVisual->RotateX(_alfa);
+ _matrixVisual->RotateY(_teta);
+ _matrixVisual->Scale( _sx*_spcX , _sy*_spcY , _sz*_spcZ );
+
+}
+
+
+//----------------------------------------------------------------------------
+void figureCuttingModel::CalculeInversMatrix()
+{
+ _inversModel->Identity ();
+ _inversModel->Concatenate ( _matrixModel );
+ _inversModel->Inverse();
+}
+//----------------------------------------------------------------------------
+bool figureCuttingModel::IfPointInside(double x, double y, double z) // virtual
+{
+ return true;
+}
+
+//----------------------------------------------------------------------------
+vtkTransform *figureCuttingModel::GetVtkTransform()
+{
+ return _matrixVisual;
+}
+
+//----------------------------------------------------------------------------
+//void figureCuttingModel::SetVtkTransform(vtkTransform *matrix)
+//{
+// _matrixModel = matrix;
+//}
+
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetTheoricVolume() // virtual
+{
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetPositionX()
+{
+ return _px;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetPositionY()
+{
+ return _py;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetPositionZ()
+{
+ return _pz;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetScaleX()
+{
+ return _sx;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetScaleY()
+{
+ return _sy;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetScaleZ()
+{
+ return _sz;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetAngleAlfa()
+{
+ return _alfa;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetAngleBeta()
+{
+ return _beta;
+}
+//----------------------------------------------------------------------------
+double figureCuttingModel::GetAngleTeta()
+{
+ return _teta;
+}
+//----------------------------------------------------------------------------
+char *figureCuttingModel::GetName() // virtual
+{
+ return "--";
+}
+
+//----------------------------------------------------------------------------
+void figureCuttingModel::SetSpacing(double spcX,double spcY, double spcZ)
+{
+ _spcX = spcX;
+ _spcY = spcY;
+ _spcZ = spcZ;
+}
+
+//----------------------------------------------------------------------------
+
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+figureCuttingSphereModel::figureCuttingSphereModel()
+{
+}
+//----------------------------------------------------------------------------
+figureCuttingSphereModel::~figureCuttingSphereModel() // virtual
+{
+}
+//----------------------------------------------------------------------------
+bool figureCuttingSphereModel::IfPointInside(double x, double y, double z) // virtual
+{
+ double in[4],out[4];
+ in[0]=x;
+ in[1]=y;
+ in[2]=z;
+ in[3]=1;
+ _inversModel->MultiplyPoint (in, out);
+
+ bool result=false;
+ if (sqrt( out[0]*out[0] + out[1]*out[1] + out[2]*out[2] )<0.5 )
+ {
+ result=true;
+ }
+ return result;
+}
+//----------------------------------------------------------------------------
+double figureCuttingSphereModel::GetTheoricVolume() // virtual
+{
+ double piTMP=3.14159265;
+ return (4.0/3.0) * piTMP * (_sx/2)*(_sy/2)*(_sz/2);
+}
+//----------------------------------------------------------------------------
+char *figureCuttingSphereModel::GetName() // virtual
+{
+ return "Sphere";
+}
+
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+figureCuttingCubeModel::figureCuttingCubeModel()
+{
+}
+//----------------------------------------------------------------------------
+figureCuttingCubeModel::~figureCuttingCubeModel() // virtual
+{
+}
+//----------------------------------------------------------------------------
+bool figureCuttingCubeModel::IfPointInside(double x, double y, double z) // virtual
+{
+ double in[4],out[4];
+ in[0]=x;
+ in[1]=y;
+ in[2]=z;
+ in[3]=1;
+ _inversModel->MultiplyPoint (in, out);
+
+ bool result=false;
+ if ((out[0]>-0.5) && (out[0]<0.5) && (out[1]>-0.5) && (out[1]<0.5) && (out[2]>-0.5) && (out[2]<0.5) )
+ {
+ result=true;
+ }
+ return result;
+}
+//----------------------------------------------------------------------------
+double figureCuttingCubeModel::GetTheoricVolume() // virtual
+{
+ return _sx * _sy * _sz;
+}
+
+//----------------------------------------------------------------------------
+char *figureCuttingCubeModel::GetName() // virtual
+{
+ return "Cube";
+}
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+
+figureCuttingCylinderModel::figureCuttingCylinderModel()
+{
+}
+//----------------------------------------------------------------------------
+figureCuttingCylinderModel::~figureCuttingCylinderModel() // virtual
+{
+}
+//----------------------------------------------------------------------------
+bool figureCuttingCylinderModel::IfPointInside(double x, double y, double z) // virtual
+{
+ double in[4],out[4];
+ in[0]=x;
+ in[1]=y;
+ in[2]=z;
+ in[3]=1;
+ _inversModel->MultiplyPoint (in, out);
+
+ bool result=false;
+ if ((sqrt( out[0]*out[0] + out[2]*out[2] )<0.5 ) && (out[1]>-0.5) && (out[1]<0.5) )
+ {
+ result=true;
+ }
+ return result;
+}
+//----------------------------------------------------------------------------
+double figureCuttingCylinderModel::GetTheoricVolume() // virtual
+{
+ double piTMP=3.14159265;
+ return piTMP*(_sx/2)*(_sz/2)*_sy;
+}
+//----------------------------------------------------------------------------
+char *figureCuttingCylinderModel::GetName() // virtual
+{
+ return "Cylinder";
+}
+//----------------------------------------------------------------------------
+
+
+
+// EOF - wxMPRWidget.cxx
+
+
+
+