+ else if (compatible==false)
+ {
+*/
+
+ int i;
+ for (i=0;i<numberOfContours;i++)
+ {
+ instantVector.clear();
+ fscanf(pFile,"%s",tmp); // Instant
+
+ fscanf(pFile,"%s",tmp); // 1
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 2
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 3
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 4
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 5
+ instantVector.push_back( atoi(tmp) );
+ fscanf(pFile,"%s",tmp); // 6
+ instantVector.push_back( atoi(tmp) );
+
+ fscanf(pFile,"%s",tmp); // TypeContourModel
+ fscanf(pFile,"%s",tmp); // ##
+ typeContourModel = atoi(tmp);
+
+ manModelContour = kernelManager->factoryManualContourModel(typeContourModel);
+ manModelContour->Open(pFile);
+ if(pFileData != NULL)
+ {
+ manModelContour->OpenData(pFileData);
+ }
+
+ if (_tmpReadFileTypeOfTransformation==-1){
+ //nothing to do..
+ } else if (_tmpReadFileTypeOfTransformation==0){
+ double transX, transY;
+ transX = (double) imageDim[0]/_tmpReadFileImageDim[0]; // X
+ transY = (double) imageDim[1]/_tmpReadFileImageDim[1]; // Y
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ } else if (_tmpReadFileTypeOfTransformation==1) {
+ double transX, transY;
+ transX = (double) _tmpReadFileImageSpac[0]/imageSpac[0]; // X
+ transY = (double) _tmpReadFileImageSpac[1]/imageSpac[1]; // Y
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ } else if (_tmpReadFileTypeOfTransformation==2) { // with Z include
+ double transX, transY;
+ transX = (double) _tmpReadFileImageSpac[0]/imageSpac[0]; // X
+ transY = (double) _tmpReadFileImageSpac[1]/imageSpac[1]; // Y
+ instantVector[1]=instantVector[1]*_tmpReadFileImageSpac[2]/imageSpac[2]; // Z
+ manModelContour->Transform_Ax_Plus_B(transX,0,transY,0);
+ }else {
+ printf ("EED Warnning! wxContourMainFrame::openContours _tmpReadFileTypeOfTransformation not set. \n");
+ }
+
+ fscanf(pFile,"%s",tmp); // TypeView
+ fscanf(pFile,"%s",tmp); // ##
+ typeView = atoi(tmp);
+
+ std::string theName;
+ theName = kernelManager->createOutline( manModelContour, instantVector );
+ bool addedModel = theName.compare("") != 0;
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc , typeView) ;
+ }
+
+ if (staticContour) //StaticContours (will appear in all slices)
+ {
+ Instant instant(&instantVector);
+ kernelManager->changeContourOfManager( theName , &instant );
+ }
+ }// for numberOfContours
+
+/* } */
+
+printf ("EED wxContourMainFrame::openContours END \n");
+
+}
+
+void wxContourMainFrame::RefreshInterface()
+{
+ changeInstant();
+ _theViewPanel->RefreshInterface();
+ //wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)this->_theViewPanel->getWxVtkBaseView();
+ //wxvtk2dbaseview->Refresh();
+}
+
+vtkImageData* wxContourMainFrame::getImageData()
+{
+ return _theViewPanel->getImageData();
+}
+
+void wxContourMainFrame::onSegmentationOneSliceITK(wxString distance, wxString sigma, wxString alfa, wxString beta, wxString propagation, wxString iterations, wxString inflation)
+{
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ int x = _theViewPanel->GetX();
+ int y = _theViewPanel->GetY();
+ int z = _theViewPanel->GetZ();
+ SegmentationOneSliceITK( x,y,z,distance, sigma, alfa, beta, propagation, iterations, inflation);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::SegmentationOneSliceITK(int x, int y, int z, wxString distanc, wxString sigm, wxString alf, wxString bet, wxString prop, wxString iter, wxString inflation)
+{
+ int typeofcontour = 1;
+ //Image Data
+ vtkImageData *imagedata = getImageData();
+ //Tipo de pixeles a utilizar internamente en ITK
+ typedef float InternalPixelType;
+ const unsigned int Dimension = 2;
+ typedef itk::Image< InternalPixelType, Dimension > InternalImageType;
+ //Tipo de pixeles de salida 1
+ typedef unsigned char OutputPixelType;
+ typedef itk::Image< OutputPixelType, Dimension > OutputImageType;
+ //Tipo de pixeles de salida 2
+ typedef unsigned short OutputPixelType2;
+ typedef itk::Image< OutputPixelType2, Dimension > OutputImageType2;
+ //DefiniciÛn del thresholder
+ typedef itk::BinaryThresholdImageFilter<
+ InternalImageType,
+ OutputImageType > ThresholdingFilterType;
+ //DefiniciÛn del primer filtro de conversiÛn de pixeles
+ typedef itk::CastImageFilter<
+ OutputImageType, OutputImageType2 > CastFilterType;
+ //DefiniciÛn del segundo tipo de conversiÛn de pixeles
+ typedef itk::CastImageFilter<
+ OutputImageType2, InternalImageType > CastFilterType2;
+ //Tercer tipo de conversiÛn
+ typedef itk::RescaleIntensityImageFilter<
+ InternalImageType,
+ OutputImageType > CastFilterType3;
+ //Cuarto tipo de conversiÛn
+ typedef itk::RescaleIntensityImageFilter<
+ OutputImageType,
+ OutputImageType > CastFilterType4;
+ ThresholdingFilterType::Pointer thresholder = ThresholdingFilterType::New();
+ thresholder->SetLowerThreshold( 0.0 );
+ thresholder->SetUpperThreshold( 128 );
+ thresholder->SetOutsideValue( 255 );
+ thresholder->SetInsideValue( 0 );
+ //DefinciÛn de conexiÛnes entre VTK e ITK y el writer
+ typedef itk::VTKImageToImageFilter<OutputImageType2> ConnectorType;
+ typedef itk::ImageToVTKImageFilter<OutputImageType> ConnectorType2;
+//EED10JUIN2011 typedef itk::ImageFileWriter< OutputImageType > WriterType;
+ ConnectorType::Pointer connector = ConnectorType::New();
+ ConnectorType2::Pointer connector2 = ConnectorType2::New();
+ CastFilterType::Pointer filter = CastFilterType::New();
+ CastFilterType2::Pointer filter2 = CastFilterType2::New();
+ connector->SetInput( imagedata );
+ filter2->SetInput(connector->GetOutput());
+ typedef itk::CurvatureAnisotropicDiffusionImageFilter<
+ InternalImageType,
+ InternalImageType > SmoothingFilterType;
+ SmoothingFilterType::Pointer smoothing = SmoothingFilterType::New();
+ typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<
+ InternalImageType,
+ InternalImageType > GradientFilterType;
+ typedef itk::SigmoidImageFilter<
+ InternalImageType,
+ InternalImageType > SigmoidFilterType;
+ GradientFilterType::Pointer gradientMagnitude = GradientFilterType::New();
+ SigmoidFilterType::Pointer sigmoid = SigmoidFilterType::New();
+ sigmoid->SetOutputMinimum( 0.0 );
+ sigmoid->SetOutputMaximum( 255.0 );
+ typedef itk::FastMarchingImageFilter<
+ InternalImageType,
+ InternalImageType > FastMarchingFilterType;
+ FastMarchingFilterType::Pointer fastMarching = FastMarchingFilterType::New();
+ typedef itk::GeodesicActiveContourLevelSetImageFilter< InternalImageType,
+ InternalImageType > GeodesicActiveContourFilterType;
+ GeodesicActiveContourFilterType::Pointer geodesicActiveContour =
+ GeodesicActiveContourFilterType::New();
+ typedef itk::ZeroCrossingImageFilter<
+ InternalImageType,
+ InternalImageType > ZeroCrossingFilterType;
+ ZeroCrossingFilterType::Pointer zeroCrossing =
+ ZeroCrossingFilterType::New();
+ const double propagationScaling = atof( crea::wx2std(prop).c_str() );
+ geodesicActiveContour->SetPropagationScaling( propagationScaling );
+ geodesicActiveContour->SetCurvatureScaling( 1.0 );
+ geodesicActiveContour->SetAdvectionScaling( 1.0 );
+ geodesicActiveContour->SetMaximumRMSError( 0.02 );
+ int it=atoi( crea::wx2std(iter).c_str() );
+ geodesicActiveContour->SetNumberOfIterations( it );
+ smoothing->SetInput( filter2->GetOutput() );
+ gradientMagnitude->SetInput( smoothing->GetOutput() );
+ sigmoid->SetInput( gradientMagnitude->GetOutput() );
+ fastMarching->SetInput( sigmoid->GetOutput() );
+ geodesicActiveContour->SetInput( fastMarching->GetOutput() );
+ geodesicActiveContour->SetFeatureImage( sigmoid->GetOutput() );
+ zeroCrossing->SetInput( geodesicActiveContour->GetOutput() );
+ //thresholder->SetInput( zeroCrossing->GetOutput() );
+ thresholder->SetInput( geodesicActiveContour->GetOutput() );
+ connector2->SetInput( thresholder->GetOutput() );
+ smoothing->SetTimeStep( 0.125 );
+ smoothing->SetNumberOfIterations( 5 );
+ smoothing->SetConductanceParameter( 9.0 );
+ const double sigma = atof( crea::wx2std(sigm).c_str() );
+ gradientMagnitude->SetSigma( sigma );
+ const double alpha = atof( crea::wx2std(alf).c_str() );
+ const double beta = atof( crea::wx2std(bet).c_str() );
+ sigmoid->SetAlpha( alpha );
+ sigmoid->SetBeta( beta );
+ typedef FastMarchingFilterType::NodeContainer NodeContainer;
+ typedef FastMarchingFilterType::NodeType NodeType;
+ NodeContainer::Pointer seeds = NodeContainer::New();
+ InternalImageType::IndexType seedPosition;
+ seedPosition[0] = x;
+ seedPosition[1] = y;
+ const double initialDistance = atof( crea::wx2std(distanc).c_str() );
+ NodeType node;
+ const double seedValue = - initialDistance;
+ node.SetValue( seedValue );
+ node.SetIndex( seedPosition );
+ seeds->Initialize();
+ seeds->InsertElement( 0, node );
+ fastMarching->SetTrialPoints( seeds );
+ fastMarching->SetSpeedConstant( 1.0 );
+ fastMarching->SetOutputSize( connector->GetOutput()->GetBufferedRegion().GetSize() );
+ fastMarching->SetStoppingValue( 800 );
+ try
+ {
+// connector2->Update();
+ vtkImageData *idata = NULL;
+ idata = connector2->GetOutput();
+ vtkMarchingContourFilter* cntVTK = vtkMarchingContourFilter::New( );
+ cntVTK->SetNumberOfContours( 1 );
+ cntVTK->SetValue( 0, 255 );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cntVTK->SetInput( idata );
+ cntVTK->Update( );
+ cntVTK->UpdateInformation();
+#else
+ cntVTK->SetInputData( idata );
+#endif
+ vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cpd->SetInput( cntVTK->GetOutput( ) );
+ cpd->Update( );
+ cpd->UpdateInformation();
+#else
+ cpd->SetInputData( cntVTK->GetOutput( ) );
+#endif
+ vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
+ conn->SetExtractionModeToLargestRegion( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ conn->SetInput( cpd->GetOutput( ) );
+ conn->Update( );
+ conn->UpdateInformation();
+#else
+ conn->SetInputData( cpd->GetOutput( ) );
+#endif
+ vtkStripper* vtkstripper = vtkStripper::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ vtkstripper->SetInput( conn->GetOutput() );
+ vtkstripper->Update();
+ vtkstripper->UpdateInformation();
+#else
+ vtkstripper->SetInputData( conn->GetOutput() );
+ cntVTK->Update();
+#endif
+ vtkPolyData* polyDataResult = cntVTK->GetOutput();
+ //std::cout<<"Points "<<polyDataResult->GetNumberOfPoints()<<std::endl;
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ polyDataResult->Update( );
+ polyDataResult->UpdateInformation();
+#else
+ // ..
+#endif
+ cntVTK -> Delete();
+ cpd -> Delete();
+ conn -> Delete();
+ //--Calculating control points
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecXo;
+ std::vector<double> vecYo;
+ std::vector<double>::iterator vecXoi;
+ std::vector<double>::iterator vecYoi;
+ std::vector<double> vecZ;
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> vecCtrlPointZ;
+ double *p;
+ double xAct=0;
+ double yAct=0;
+ int ii,size=polyDataResult->GetNumberOfPoints();
+ ofstream myfile;
+ myfile.open ("C:/Creatis/example2.txt");
+ size=polyDataResult->GetNumberOfPoints();
+ for (ii=0;ii<size;ii++)
+ {
+ if(ii==0)
+ {
+ xAct=x;
+ yAct=y;
+ }
+ p = polyDataResult->GetPoint(ii);
+ double x=p[0];
+ double y=p[1];
+// if(fabs(yAct-y)>20)
+// {
+// if((xAct-x)>1 || (xAct-x)<-1)
+// {
+// vecX.push_back( p[0] );
+// vecY.push_back( p[1] );
+// myfile <<p[0]<<","<<p[1]<<"\n";
+// std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
+// std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
+// std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
+// vecZ.push_back( 900 );
+// xAct=x;
+// yAct=y;
+// } else {
+// vecXo.push_back(p[0]);
+// vecYo.push_back(p[1]);
+// }
+// } else
+
+ if(fabs(xAct-x)>11)
+ {
+ vecXo.push_back(p[0]);
+ vecYo.push_back(p[1]);
+ } else {
+ vecX.push_back( p[0] );
+ myfile <<p[0]<<","<<p[1]<<"\n";
+ //std::cout<<" x Anterior "<<xAct<<" x actual "<<x<<std::endl;
+ //std::cout<<" y Anterior "<<yAct<<" y actual "<<y<<std::endl;
+ //std::cout<<" x "<<p[0]<<" y "<<p[1]<<std::endl;
+ vecY.push_back( p[1] );
+//EED 2017-12-16
+ vecZ.push_back( -900 );
+ xAct = x;
+ yAct = y;
+ } // if xAct
+
+
+ } // for
+
+ while(!vecXo.empty())
+ {
+ vecX.push_back(vecXo.back());
+ //std::cout<<" x Siguiente "<<vecXo.back();
+ vecXo.pop_back();
+ //EED 2017-12-16
+ vecZ.push_back( -900 );
+ }
+ while(!vecYo.empty())
+ {
+ vecY.push_back(vecYo.back());
+ vecYo.pop_back();
+ }
+ myfile.close();
+
+// for(int l=0;l<vecX.size();l++)
+// {
+// if(l==0)
+// {
+// vecXo.push_back(p[0]);
+// vecYo.push_back(p[1]);
+// } else {
+// if(vecXoi[l-1]==)
+// {
+// }
+// } // if
+// } // for
+
+ ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
+ extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
+
+ int method=2;
+ if (method==0)
+ {
+ extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ } else if (method==1){
+ extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ } else if (method==2){
+ extractcontrolpoints2d->SetSamplingControlPoints( 15 );
+ extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ //--Adding contour to the system
+
+ std::vector<int> actualInstantVector;
+ _instantPanel->getInstant( actualInstantVector );
+ actualInstantVector[1]=z;
+
+ int j,sizeCtrPt = vecCtrlPointX.size();
+
+ manualBaseModel *manModelContour = kernelManager->factoryManualContourModel( typeofcontour );
+ manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 );
+ if (sizeCtrPt>=3){
+ for (j=0 ; j<sizeCtrPt ; j++)
+ {
+ manModelContour->AddPoint( vecCtrlPointX[j] , vecCtrlPointY[j] , vecCtrlPointZ[j] );
+ } // for
+ std::string theName;
+ //theName = _modelManager->createOutline( manModelContour, actualInstantVector );
+ theName = kernelManager->createOutline( manModelContour, actualInstantVector );
+ bool addedModel = theName.compare("") != 0;
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
+ //_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
+ } // if addedModel
+ } // if sizeCtrPt
+
+ } catch( itk::ExceptionObject & excep ) {
+ std::cerr << "Exception caught !" << std::endl;
+ std::cerr << excep << std::endl;
+ } // try
+
+}
+
+void wxContourMainFrame::onSegmentationOneSlice(int isovalue,int sampling,int method){
+
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ int x = _theViewPanel->GetX();
+ int y = _theViewPanel->GetY();
+ int z = _theViewPanel->GetZ();
+ SegmentationOneSlice( x,y,z,isovalue, sampling, method );
+ RefreshInterface();
+}
+
+
+void wxContourMainFrame::SegmentationOneSlice( int x, int y, int z, int isovalue, int sampling, int method )
+{
+
+//printf("EED wxContourMainFrame::SegmentationOneSlice Start=%d %d\n",sampling,method );
+//printf("EED wxContourMainFrame::SegmentationOneSlice %d %d %d \n",x,y,z );
+
+ int typeofcontour = 1;
+ //--Extracting Contour
+ vtkImageData *imagedata = getImageData();
+
+ vtkImageReslice *imageReslice = vtkImageReslice::New();
+//EED
+ double spc[3];
+ imagedata->GetSpacing(spc);
+ x = x*spc[0];
+ y = y*spc[1];
+ z = z;
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ imageReslice->SetInput( imagedata );
+#else
+ imageReslice->SetInputData( imagedata );
+#endif
+ imageReslice->SetInformationInput(imagedata);
+ imageReslice->SetResliceAxesDirectionCosines(1,0,0, 0,1,0 ,0,0,1);
+ imageReslice->SetResliceAxesOrigin(0,0,z*spc[2]);
+ imageReslice->SetOutputDimensionality(2);
+ imageReslice->SetInterpolationModeToLinear();
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ // ..
+#else
+ imageReslice->Update();
+#endif
+
+ imagedata = imageReslice->GetOutput();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ imagedata->Update();
+ imagedata->UpdateInformation();
+#else
+ // ..
+#endif
+
+ vtkContourFilter* cntVTK = vtkContourFilter::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cntVTK->SetInput( imagedata );
+#else
+ cntVTK->SetInputData( imagedata );
+#endif
+
+ cntVTK->SetNumberOfContours( 1 );
+ //cntVTK->SetValue( 0, vmin );
+// cntVTK->SetValue( 0, (range[1]*thr/100) );
+ cntVTK->SetValue( 1, isovalue );
+// cntVTK->SetValue( 1, vmax );
+ cntVTK->Update( );
+ cntVTK->UpdateInformation();
+
+ vtkCleanPolyData* cpd = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cpd->SetInput( cntVTK->GetOutput( ) );
+#else
+ cpd->SetInputData( cntVTK->GetOutput( ) );
+#endif
+ cpd->ConvertLinesToPointsOff( );
+ cpd->Update( );
+ cpd->UpdateInformation();
+
+ vtkPolyDataConnectivityFilter* conn = vtkPolyDataConnectivityFilter::New( );
+
+// conn->SetExtractionModeToPointSeededRegions();
+// conn->SetExtractionModeToCellSeededRegions();
+// conn->SetExtractionModeToSpecifiedRegions();
+// conn->SetExtractionModeToLargestRegion();
+// conn->SetExtractionModeToAllRegions();
+
+ conn->SetExtractionModeToClosestPointRegion();
+
+ //conn->SetMaxRecursionDepth( 3000 );
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ conn->SetInput( cpd->GetOutput( ) );
+#else
+ conn->SetInputData( cpd->GetOutput( ) );
+#endif
+
+ conn->SetClosestPoint( x, y, 0 );
+ conn->Update( );
+ conn->UpdateInformation();
+
+ vtkCleanPolyData* cpd2 = vtkCleanPolyData::New( );
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ cpd2->SetInput( conn->GetOutput( ) );
+#else
+ cpd2->SetInputData( conn->GetOutput( ) );
+#endif
+ cpd2->Update();
+ cpd2->UpdateInformation();
+
+ vtkStripper* vtkstripper = vtkStripper::New( );
+vtkstripper->SetJoinContiguousSegments(true);
+ vtkstripper->SetMaximumLength(20000);
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ vtkstripper->SetInput( cpd2->GetOutput() );
+#else
+ vtkstripper->SetInputData( cpd2->GetOutput() );
+// vtkstripper->SetInputData( cntVTK->GetOutput() );
+
+#endif
+ vtkstripper->Update();
+ vtkstripper->UpdateInformation();
+
+
+ vtkPolyData* polyDataResult = vtkstripper->GetOutput();
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ polyDataResult->Update( );
+ polyDataResult->UpdateInformation();
+#else
+ //...
+#endif
+
+/* EED
+ofstream myfile;
+myfile.open ("c:/temp/example.txt");
+myfile << "\n";
+polyDataResult->Print(myfile);
+myfile << "-------------------------------------\n";
+polyDataResult->GetLines()->Print(myfile);
+myfile.close();
+*/
+ cntVTK -> Delete();
+ cpd2 -> Delete();
+ cpd -> Delete();
+ conn -> Delete();
+
+//--Calculating control points
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> vecCtrlPointZ;
+
+//printf("EED wxContourMainFrame::SegmentationOneSlice GetNumberOfLines=%d \n",polyDataResult->GetNumberOfLines() );
+//int numberOfPointsInCell;
+//int numberOfcells=polyDataResult->GetNumberOfCells();
+//for (int jj=0; jj<numberOfcells ; jj++)
+//{
+// vtkCell* vtkcell = polyDataResult->GetCell( jj );
+// numberOfPointsInCell=vtkcell->GetNumberOfPoints();
+// printf("EED wxContourMainFrame::SegmentationOneSlice cell=%d points=%d \n",jj,numberOfPointsInCell );
+//}// for jj
+// printf("EED wxContourMainFrame::SegmentationOneSlice PrintSelf \n");
+// polyDataResult->PrintSelf( std::cout, vtkIndent(0) );
+
+
+ if (polyDataResult->GetNumberOfCells()>0)
+ {
+ double *p;
+ vtkCell* vtkcell = polyDataResult->GetCell( 0 );
+ // int ii,size=polyDataResult->GetNumberOfPoints();
+ int ii,size=vtkcell->GetNumberOfPoints();
+ int id;
+ for (ii=0;ii<size;ii++)
+ {
+ // id = polyDataResult->GetLines()->GetData()->GetValue(ii);
+ // p = polyDataResult->GetPoint(id);
+ p = vtkcell->GetPoints()->GetPoint(ii);
+// printf("EED wxContourMainFrame::SegmentationOneSlice (%d) id=%d px=%f py=%f\n",ii,id, p[0],p[1]);
+ // double x=p[0];
+ // double y=p[1];
+ vecX.push_back( p[0] );
+ vecY.push_back( p[1] );
+ //EED 2017-12-16
+ vecZ.push_back( -900 );
+ // vecZ.push_back( p[2] );
+ }
+ ExtractControlPoints2D *extractcontrolpoints2d = new ExtractControlPoints2D();
+ extractcontrolpoints2d->SetContour( &vecX , &vecY , &vecZ );
+ //PROOFS
+ /*if (methodRadiobox->GetSelection()==0){
+ extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ if (methodRadiobox->GetSelection()==1){
+ extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+ if (methodRadiobox->GetSelection()==2){
+ extractcontrolpoints2d->SetSamplingControlPoints( sampling );
+ extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }*/
+
+ if (method==0)
+ {
+ extractcontrolpoints2d->GetInitialControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ } else if (method==1){
+ extractcontrolpoints2d->GetControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ } else if (method==2){
+ extractcontrolpoints2d->SetSamplingControlPoints( sampling );
+ extractcontrolpoints2d->GetSamplingControlPoints( &vecCtrlPointX , &vecCtrlPointY , &vecCtrlPointZ );
+ }
+
+ //--Adding contour to the system
+ std::vector<int> actualInstantVector;
+ _instantPanel->getInstant( actualInstantVector );
+ actualInstantVector[1]=z;
+
+ int j,sizeCtrPt = vecCtrlPointX.size();
+ manualBaseModel *manModelContour = kernelManager->factoryManualContourModel( typeofcontour );
+ manModelContour->SetNumberOfPointsSpline( ((sizeCtrPt/100)+1)*100 *2 );
+ manModelContour->SetLabel2( std::to_string(z) );
+ if (sizeCtrPt>=3)
+ {
+ for (j=0 ; j<sizeCtrPt ; j++)
+ {
+ manModelContour->AddPoint( vecCtrlPointX[j] / spc[0], vecCtrlPointY[j] / spc[1], vecCtrlPointZ[j] );
+ } // for
+ std::string theName;
+ //theName = _modelManager->createOutline( manModelContour, actualInstantVector );
+ theName = kernelManager->createOutline( manModelContour, actualInstantVector );
+ bool addedModel = theName.compare("") != 0;
+ if( addedModel )
+ {
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ _theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->configureViewControlTo(theName, manModelContour, spc, typeofcontour);
+ //_theViewPanel->getSceneManager()->configureViewControlTo( theName, manModelContour,spc, typeofcontour ) ;
+ } // if addedModel
+ } // if sizeCtrPt
+ } // if NumberOfCells > 0
+//printf("EED wxContourMainFrame::SegmentationOneSlice End\n");
+}
+
+int wxContourMainFrame::GetImageDataSizeZ()
+{
+ return _theViewPanel->GetImageDataSizeZ();
+}
+
+void wxContourMainFrame::GetImageDataRange(double *range)
+{
+ _theViewPanel->GetImageDataRange(range);
+}
+
+void wxContourMainFrame::onSegmentationAllSlice(int minZ,int maxZ,int isovalue,int sampling,int method)
+{
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ wxBusyCursor wait;
+ int x = _theViewPanel->GetX();
+ int y = _theViewPanel->GetY();
+ int z;
+ double porcent;
+ wxString tmpString;
+ double totalZ = maxZ-minZ+1;
+ for( z=minZ ; z<=maxZ ; z++ )
+ {
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ,z );
+ interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(tmpString);
+ //_staticTextSegmentation->SetLabel(tmpString);
+ SegmentationOneSlice( x,y,z,isovalue, sampling,method );
+ }
+ interfMainPanel::getInstance()->setLabelSegmentationPanelVTK(_T(" "));
+ RefreshInterface();
+}
+
+
+//Creates a reference line to be used as the axis of the mirroring
+void wxContourMainFrame::referenceLine()
+{
+ if (_refLineControl==NULL)
+ {
+ wxBusyCursor wait;
+ double spc[3];
+
+ vtkImageData *vtkimagedata = _theViewPanel->getImageData();
+ vtkimagedata->GetSpacing(spc);
+
+ wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView();
+
+ _refLineControl = new manualLineControler();
+ _refLineModel = new manualContourModelLine();
+ _refLineView = new manualViewLine();
+ _refLineView->SetModel( _refLineModel );
+ _refLineView->SetWxVtkBaseView( viewer2D );
+ _refLineView->SetRange( 2 );
+ _refLineView->SetZ( 1200 );
+
+ _refLineView->SetSpacing(spc);
+
+ _refLineView->SetColorNormalContour(0, 0, 1);
+ _refLineView->SetColorEditContour(0, 0.5, 0.5);
+ _refLineView->SetWidthLine(4);
+
+ _refLineControl->SetModelView( _refLineModel , _refLineView );
+ vtkInteractorStyleBaseView* style = (vtkInteractorStyleBaseView*)viewer2D->GetInteractorStyleBaseView();
+ style->AddInteractorStyleMaracas( _refLineControl );
+ _refLineModel->SetCloseContour(false);
+ _refLineControl->CreateNewManualContour();
+
+//AD: Inicializar el mirroring con una linea ya pintada
+ /*
+ double z = _refLineControl->GetZ();
+
+ int imageDim[3];
+ image->GetDimensions(imageDim);
+ double x = (double) imageDim[0]/2;
+ double y1 = (double) (imageDim[1]/2)+15;
+ double y2 = (double) (imageDim[1]/2)-15;
+
+ _refLineControl->AddPoint(x,y1,z);
+ _refLineControl->AddPoint(x,y2,z);
+ _refLineControl->SetCompleteCreation(true);
+
+ _refLineModel->AddPoint(x,y1,z);
+ _refLineModel->AddPoint(x,y2,z);
+ _refLineModel->UpdateSpline();
+
+ _refLineView->UpdateViewPoint(0);
+ _refLineView->UpdateViewPoint(1);
+ */
+
+ _refLineControl->SetActive(true);
+ _refLineView->RefreshContour();
+ }
+}
+
+//Hides the referenceLine
+void wxContourMainFrame::refLineHide()
+{
+ if (_refLineControl!=NULL)
+ {
+ if (_refLineControl->GetActive())
+ {
+ _refLineView->RemoveCompleteContourActor();
+ _refLineControl->SetEditable(false);
+ _refLineControl->SetActive(false);
+
+ RefreshInterface();
+ }
+ }
+}
+
+//Shows the referenceLine
+void wxContourMainFrame::refLineShow()
+{
+ if (_refLineControl!=NULL)
+ {
+ if (_refLineControl->GetActive()==false)
+ {
+ wxVtkBaseView * viewer2D = _theViewPanel->getWxVtkBaseView();
+
+ _refLineView->SetModel( _refLineModel );
+ _refLineView->SetWxVtkBaseView( viewer2D );
+ _refLineView->SetRange( 2 );
+ _refLineView->SetZ( 1200 );
+
+ _refLineControl->SetModelView( _refLineModel , _refLineView );
+ vtkInteractorStyleBaseView* style = (vtkInteractorStyleBaseView*)viewer2D->GetInteractorStyleBaseView();
+ style->AddInteractorStyleMaracas( _refLineControl );
+ _refLineControl->CreateNewManualContour();
+ _refLineControl->SetActive(true);
+ _refLineView->RefreshContour();
+
+ RefreshInterface();
+ }
+ }
+}
+
+void wxContourMainFrame::refLineChangeWidth(int width)
+{
+ _refLineView->SetWidthLine(width);
+ _refLineView->RefreshContour();
+
+ RefreshInterface();
+}
+
+
+void wxContourMainFrame::onMirror()
+{
+ //AD:02-09
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+ std::vector<std::string> filterCurrentSelection;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ _performingOperation->reset();
+ _performingOperation->setStartCommand( COPY );
+ _performingOperation->setStartOperationInstantVector( tempVector );
+ _performingOperation->setKeyNamesOperationElems( currentSelection );
+
+ char theStartCommand = _performingOperation->getStartCommand();
+ if ( theStartCommand == COPY )
+ {
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ _performingOperation->setEndOperationInstantVector ( tempVector );
+ std::vector<std::string> elems = _performingOperation->getKeyNamesOperationElems();
+ int i,size = elems.size();
+ for( i=0; i<size; i++ )
+ {
+ createMirrorContourOf( elems[i], tempVector, i>0 );
+ }
+ }
+
+ //deleteContour( _refName );
+ //_refName = "";
+}
+
+
+void wxContourMainFrame::showAxis(bool show)
+{
+ _theViewPanel->SetVisibleAxis(show);
+ _theViewPanel->Refresh();
+}
+
+
+void wxContourMainFrame::onRigidPressed(){
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+ int elementsSelected = currentSelection.size();
+
+ if ( elementsSelected >= 1 ){
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ Instant instant(&tempVector);
+
+ int i , size=currentSelection.size();
+ for ( i=0 ; i<size ; i++ )
+ {
+ kernelManager->changeContourOfManager(currentSelection[i], &instant);
+ } // i
+ }
+}
+
+void wxContourMainFrame::onWidthOfContour(double width){
+
+ _theViewPanel->removeSceneContours();
+ _theViewPanel->SetWidthContour(width);
+
+ //_theViewPanel->getSceneManager()->SetWidthContour( width );
+
+ RefreshInterface();
+}
+
+int wxContourMainFrame::getColorWindow()
+{
+ /*
+ double range[2];
+ vtkImageData * img = getImageData();
+ img->GetScalarRange(range);
+
+ std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
+
+ return (int)range[1];
+ */
+ return _theViewPanel->getColorWindow();
+}
+
+int wxContourMainFrame::getWindowLevel()
+{
+ /*
+ double range[2];
+ vtkImageData * img = getImageData();
+ img->GetScalarRange(range);
+
+ std::cout<<"Val 1: "<<range[0]<<" Val 2: "<<range[1]<<std::endl;
+
+ return (int)range[1];
+ */
+ return _theViewPanel->getWindowLevel();
+}
+
+void wxContourMainFrame::onBrigthnessColorWindowLevel(int colorwindow,int windowlevel)
+{
+ _theViewPanel->onBrigthnessColorWindowLevel(colorwindow, windowlevel);
+
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onInterpolation(bool interpolate)
+{
+ _theViewPanel->onInterpolation(interpolate);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onBeforeAfterContour(bool before,bool after)
+{
+ _theViewPanel->onBeforeAfterContour(before,after);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onJumpSlice(int step, int shift)
+{
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int ss = abs(step);
+ int pos = tempVector[1];
+ int maxZ = interfMainPanel::getInstance()->GetImageDataSizeZ();
+ pos=(pos/ss)*ss+step+shift;
+ if ((pos>=0) && (pos<maxZ))
+ {
+ tempVector[1]=pos;
+ _instantPanel->setInstant( tempVector );
+ RefreshInterface();
+ } // if pos
+}
+
+void wxContourMainFrame::onShowTextContour(bool show)
+{
+ _theViewPanel->onShowTextContour(show);
+ RefreshInterface();
+}
+
+void wxContourMainFrame::onChangeInstant(std::string name,int actual)
+{
+ _instantPanel->setConceptValue( name, actual );
+}
+
+void wxContourMainFrame::resetAppend()
+{
+ kernelManager->resetAppend();
+}
+
+void wxContourMainFrame::onSpreadAdd()
+{
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ _theViewPanel->GetPointsOfActualContour(&vecX , &vecY , &vecZ );
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
+ interfMainPanel::getInstance()->appendStringSpread(val);
+}
+
+
+void wxContourMainFrame::onSpreadAddAll()
+{
+//EED02
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int minZ,maxZ;
+ minZ = 0;
+ maxZ = interfMainPanel::getInstance()->GetImageDataSizeZ();
+ int z;
+ int sizeLstContourThings;
+ for ( z=minZ ; z<=maxZ ; z++ )
+ {
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+ if (sizeLstContourThings>=1)
+ {
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ ContourThing **contourthing = lstContourThings[0];
+ manualBaseModel *cModel = (*contourthing)->getModel();
+ int i,size = cModel->GetNumberOfPointsSpline();
+ double x,y,z;
+ for (i=0; i<size; i++)
+ {
+ cModel->GetSpline_i_Point(i, &x, &y, &z);
+ vecX.push_back(x);
+ vecY.push_back(y);
+ vecZ.push_back(z);
+ } // for i
+ std::string val = kernelManager->onSpreadAdd(&vecX , &vecY , &vecZ, tempVector);
+ interfMainPanel::getInstance()->appendStringSpread(val);
+ }// if sizeLstContourThings
+ } // for z
+}
+
+
+void wxContourMainFrame::onSpreadGo(int type)
+{
+ //JCP 20-10-08 Undo redo implementation
+ saveState();
+ //JCP 20-10-08 Undo redo implementation
+ wxBusyCursor wait;
+ std::vector<double> vecCtrlPointX;
+ std::vector<double> vecCtrlPointY;
+ std::vector<double> vecCtrlPointZ;
+ double minZ,maxZ;
+ int z;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+// tempVector[1];
+
+ kernelManager->getMaxMinZ(&minZ,&maxZ);
+//JSTG_16-07-08_----------------------------------------------------------------
+ //_contourPropagation->setInterpolationNumber(maxZ-minZ+1);
+ kernelManager->CalculeSplinePropagation();
+
+ double totalZ = maxZ-minZ+1;
+ double porcent;
+ wxString tmpString;
+//--------------------------------------------------------------------
+ for ( z=(int)minZ ; z<=(int)maxZ ; z++ )
+ {
+ porcent = 100.0* (z-minZ)/totalZ;
+ int numero = (int)(z-minZ+1)/(int)totalZ;
+ std::string stringtemp = " "+kernelManager->intToString(porcent)+"% "+kernelManager->intToString(numero)+" "+kernelManager->intToString(z);
+
+ interfMainPanel::getInstance()->setStringSpread(stringtemp);
+
+ int typeofcontour = 1;
+ std::string theName;
+ manualBaseModel* manModelContour = kernelManager->GetPoints(z, type, &vecCtrlPointX,&vecCtrlPointY,&vecCtrlPointZ, theName,typeofcontour, tempVector);
+
+ if( manModelContour!=NULL ){
+ double spc[3];//Si no hay imagen pero hay contornos que spacing se pone por default
+ this->_theViewPanel->getSpacing(spc);
+ //Adding the manualContourControler to interface objects structure
+ //Adding the manualViewContour to interface objects structure
+ //_theViewPanel->getSceneManager()->setControlActiveStateOfALL( false );//This call is being done here because if the ROI is created underneath the previously created ROIS will still be active.
+ _theViewPanel->configureViewControlTo( theName, manModelContour,spc,typeofcontour ) ;
+ } // if addedModel
+ }
+ if(z > maxZ){
+ porcent = 100.0;
+ int numero = (int)(z-minZ+1)/(int)totalZ;
+ std::string stringtemp = " "+kernelManager->intToString(porcent)+"% "+kernelManager->intToString(numero)+" "+kernelManager->intToString(z);
+
+ interfMainPanel::getInstance()->setStringSpread(stringtemp);
+ }// for z
+ //RefreshInterface();
+}
+
+void wxContourMainFrame::getInstantVector(std::vector<int>& tempVector)
+{
+ _instantPanel->getInstant( tempVector );
+}
+
+std::vector<std::string> wxContourMainFrame::getOutlinesName(int slide)
+{
+ std::vector<int> tempVector;
+ _instantPanel->getInstant(tempVector);
+ //Asignation of slide number should be different ex by name
+ tempVector[1]=slide;
+ return kernelManager->getOutlinesNameAtInstant(tempVector);
+}
+
+
+void wxContourMainFrame::SetScalarRange(int grayRangeMin, int grayRangeMax)
+{
+ _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
+}
+
+
+void wxContourMainFrame::onInformationContourLabels(int typeContourGroup,int selection,int minimumZ,int maximumZ,int grayRangeMin, int grayRangeMax)
+{
+
+ wxString tempString;
+ int maxContourGroup = 0;
+
+ _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualBaseModel*> lstManConMod;
+ std::vector<manualBaseModel*> lstManConModTmp;
+ std::vector<manualBaseModel*> lstManConModExp;
+ std::vector<double> pLstValue;
+ std::vector<double> pLstValuePosX;
+ std::vector<double> pLstValuePosY;
+ std::vector<double> pLstValuePosZ;
+
+ int resultSize;
+ int resultGrayRangeCount;
+ double resultMin;
+ double resultMax;
+ double resultAverage;
+ double resultStandardeviation;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ int z;
+ int ii,sizeLstContourThings;
+
+
+ int minZ,maxZ;
+ double totalZ;
+ double porcent;
+ wxString tmpString;
+
+
+ if (selection==0 ) // actual slice
+ {
+ int actualSlice = tempVector[1];
+ minZ = actualSlice;
+ maxZ = actualSlice;
+ } else { // slice range
+ minZ = minimumZ;
+ maxZ = maximumZ;
+ }
+
+
+ totalZ = maxZ-minZ+1;
+
+ _contourextractdata->InitVolumeStatistics();
+
+// For each slice..
+ for ( z=minZ ; z<=maxZ ; z++ )
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+ //_staticTextInformation->SetLabel(tmpString);
+
+ //Extraction data from contours of each slice
+ _contourextractdata->SetZtoBeAnalys(z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+ tempString.Printf(_T("%d - %d"),z, sizeLstContourThings);
+ interfMainPanel::getInstance()->setRowLabelInfoPanel(z, tempString);
+ //_grid->SetRowLabelValue(z, tempString );
+//EED004
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ if ( maxContourGroup<sizeContourGroup )
+ {
+ maxContourGroup=sizeContourGroup;
+ }
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ maxContourGroup=1;
+ }
+
+ int tmpIntA;
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+
+
+
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ _contourextractdata->SetLstManualContourModel( lstManConModTmp );
+ _contourextractdata->SetScalarRange(grayRangeMin,grayRangeMax);
+
+ pLstValue.clear();
+ pLstValuePosX.clear();
+ pLstValuePosY.clear();
+ pLstValuePosZ.clear();
+
+
+ int numberOfPixels;
+ _contourextractdata->GetValuesInsideCrown( &numberOfPixels,
+ &pLstValue,
+ &pLstValuePosX,
+ &pLstValuePosY,
+ &pLstValuePosZ);
+
+ resultSize=numberOfPixels;
+ // Statistics of each slice.
+ _contourextractdata->Statistics( &pLstValue,
+ grayRangeMin,
+ grayRangeMax,
+ &resultGrayRangeCount,
+ &resultSize,
+ &resultMin,
+ &resultMax,
+ &resultAverage,
+ &resultStandardeviation);
+
+ if (interfMainPanel::getInstance()->getNumberColsInformationPanel()<_numberOfVariablesStatistics*(iContourGroup+1) )
+ {
+ interfMainPanel::getInstance()->appendColsInformationPanel(_numberOfVariablesStatistics);
+ }
+
+ tmpIntA=_numberOfVariablesStatistics*iContourGroup ;
+
+ tempString.Printf(_T("%d"),numberOfPixels);
+
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA, tempString);
+
+ tempString.Printf(_T("%d"),resultGrayRangeCount);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+1, tempString);
+
+ tempString.Printf(_T("%f"),resultMin);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+2, tempString);
+
+ tempString.Printf(_T("%f"),resultMax);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+3, tempString);
+
+ tempString.Printf(_T("%f"),resultAverage);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+4, tempString);
+
+ tempString.Printf(_T("%f"),resultStandardeviation);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(z, tmpIntA+5, tempString);
+
+
+ } // for iContourGroup
+ } // for z
+
+ // Print Volume Statistics
+
+
+ int vol_rCountRange;
+ int vol_rsize;
+ double vol_minValue;
+ double vol_maxValue;
+ double vol_average;
+ double vol_standardeviation;
+
+ if (selection!=0 ) // actual slice
+ {
+
+ _contourextractdata->GetVolumeStatistics(&vol_rCountRange, &vol_rsize,
+ &vol_minValue, &vol_maxValue,
+ &vol_average, &vol_standardeviation);
+
+ interfMainPanel::getInstance()->setRowLabelInfoPanel(maxZ+2, _T("Total:"));
+
+ tempString.Printf(_T("%d"),vol_rsize);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 0, tempString);
+
+ tempString.Printf(_T("%d"),vol_rCountRange);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 1, tempString);
+
+ tempString.Printf(_T("%f"),vol_minValue);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 2, tempString);
+
+ tempString.Printf(_T("%f"),vol_maxValue);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 3, tempString);
+
+ tempString.Printf(_T("%f"),vol_average);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 4, tempString);
+
+ tempString.Printf(_T("%f"),vol_standardeviation);
+ interfMainPanel::getInstance()->setCellValueInfoPanel(maxZ+2, 5, tempString);
+ }
+ //-----------------------------------------
+
+ int iTitleGroup;
+ wxString tmpTitleString;
+ int tmpIntB;
+ for ( iTitleGroup=0 ; iTitleGroup<maxContourGroup ; iTitleGroup++ )
+ {
+ tmpIntB =_numberOfVariablesStatistics*iTitleGroup;
+ tmpTitleString.Printf(_T("%d-Size Data"),iTitleGroup);
+ interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString);
+
+ interfMainPanel::getInstance()->setColLableInfoPanel(tmpIntB + 0, tmpTitleString );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 1, _T("Size Range") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 2, _T("Min") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 3, _T("Max") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 4, _T("Average") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 5, _T("St.Dev.") );
+ interfMainPanel::getInstance()->setColLableInfoPanel( tmpIntB + 6, _T(" ") );
+ }// for title
+ interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
+}
+
+//AD: 29-05-09
+void wxContourMainFrame::onSaveResults(std::string directory,std::string namefile, std::string filename,
+ int typeContourGroup, int selection, int minZ, int maxZ, bool XYZValues, bool contourImage, bool statistics)
+{
+ if (XYZValues)
+ {
+ SaveValuesXYZ( directory , namefile, typeContourGroup );
+ }
+
+ if (contourImage)
+ {
+ vtkImageData * mask;
+ vtkImageData * value;
+ this->getMaskValue(&mask, &value, typeContourGroup,selection,minZ,maxZ);
+ this->SaveImageResult( directory , namefile, mask, value);
+ }
+
+ if (statistics)
+ {
+ std::ostringstream name;
+ name << filename << ".xls";
+
+
+ FILE *pFile=fopen(name.str().c_str(),"w+");
+
+
+ wxString tmpString;
+ int i,j,maxX;
+
+// int sizeZ = _theViewPanel->GetImageDataSizeZ();
+// int maxY=sizeZ+2;
+
+ maxX= interfMainPanel::getInstance()->getNumberColsInformationPanel();//this->_grid->GetNumberCols();
+
+ // -- Title --
+ int iTitle,sizeTitle = (maxX / _numberOfVariablesStatistics);
+ for ( iTitle=0; iTitle<sizeTitle ; iTitle++)
+ {
+ // fprintf(pFile,"-- \t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle,tmpString.c_str() );
+ fprintf(pFile,"slice\t %d-Size \t SizeRange \t Min \t Max \t Ave \t StDv \t" , iTitle );
+ }
+ fprintf(pFile,"\n\n" );
+
+
+
+ if (selection==0 ) // actual slice
+ {
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int actualSlice = tempVector[1];
+ minZ = actualSlice;
+ maxZ = actualSlice;
+ }
+
+ // Stadistics...
+ for ( j=minZ; j<=maxZ ; j++)
+ {
+ fprintf(pFile,"%d\t" , j );
+ for (i=0 ; i<maxX ; i++){
+ tmpString = interfMainPanel::getInstance()->getCellValue(j, i);//_grid->GetCellValue( j , i );
+ fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
+ } // for i
+ fprintf(pFile,"\n" );
+ } // for j
+
+
+ // Total of stadistics.....
+ if (selection!=0)
+ {
+ fprintf(pFile,"\n Total:\t" );
+ for (i=0 ; i<maxX ; i++){
+ tmpString = interfMainPanel::getInstance()->getCellValue(maxZ+2, i);//_grid->GetCellValue( maxZ+2 , i );
+ fprintf(pFile,"%s\t" , (const char *)(tmpString.mb_str()) );
+ } // for i
+ fprintf(pFile,"\n" );
+ }
+
+ fclose(pFile);
+ }
+}
+
+//AD: 29-05-09
+void wxContourMainFrame::SaveValuesXYZ(std::string directory,std::string namefile,int typeContourGroup)
+{
+ wxBusyCursor wait;
+
+ //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
+ _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualBaseModel*> lstManConMod;
+ std::vector<manualBaseModel*> lstManConModTmp;
+ std::vector<manualBaseModel*> lstManConModExp;
+ std::vector<double> pLstValue;
+ std::vector<double> pLstValuePosX;
+ std::vector<double> pLstValuePosY;
+ std::vector<double> pLstValuePosZ;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ int sizeZ = _theViewPanel->getSceneManager()->GetImageDataSizeZ();
+ int z;
+ int ii,sizeLstContourThings;
+
+
+ int minZ,maxZ;
+ double totalZ;
+ double porcent;
+ wxString tmpString;
+ minZ = 0;// _mbarrange->GetStart();
+ maxZ = sizeZ;//_mbarrange->GetEnd();
+ totalZ = maxZ-minZ+1;
+
+
+// For each slice..
+ for ( z=0 ; z<sizeZ ; z++)
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+
+ tmpString.Printf(_T("Saving Values"));
+ tmpString.Printf(_T(" %d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+ //_staticTextInformation->SetLabel(tmpString);
+
+
+ //Extraction data from contours of each slice
+ _contourextractdata->SetZtoBeAnalys( z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant(&instant);//this->_modelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+
+//EED004
+
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ }
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ _contourextractdata->SetLstManualContourModel( lstManConModTmp );
+
+ pLstValue.clear();
+ pLstValuePosX.clear();
+ pLstValuePosY.clear();
+ pLstValuePosZ.clear();
+ int numberOfPixels;
+ _contourextractdata->GetValuesInsideCrown( &numberOfPixels,
+ &pLstValue,
+ &pLstValuePosX,
+ &pLstValuePosY,
+ &pLstValuePosZ);
+
+ std::string temp = directory + "/" + namefile + "-slice";
+ temp = temp + kernelManager->intToString(z) + "-cont" + kernelManager->intToString(iContourGroup);
+ temp = temp + ".txt";
+
+ // LG 14/01/09 : using crea
+ wxString filename = crea::std2wx(temp);
+ /*filename.Printf(_T("%s"),directory.c_str());
+ filename.append(_T("\\"));
+ filename.append(_T("%s"),namefile.c_str());
+ filename.append(_T("-slice"));
+ filename.append(_T("%d"),z);
+ filename.append(_T("-cont"));
+ filename.append(_T("%d"),iContourGroup);
+ filename.append(_T(".txt"));*/
+ // filename.Printf(temp.c_str());
+
+
+
+ FILE *pFile=fopen((const char *)filename.mb_str(),"w+");
+ fprintf(pFile,"value \t x \t y \t z\n" );
+ int iLstValue,sizeLstValue=pLstValue.size();
+ for (iLstValue=0 ; iLstValue<sizeLstValue ; iLstValue++ )
+ {
+ fprintf(pFile,"%f\t %f\t %f\t %f\n", (float)pLstValue[iLstValue] , (float)pLstValuePosX[iLstValue], (float)pLstValuePosY[iLstValue], (float)z );
+ }
+ fclose(pFile);
+ } // for iContourGroup
+ } // for z
+ interfMainPanel::getInstance()->setStringInfoPanel(_T(""));
+ //_staticTextInformation->SetLabel( _T("") );
+
+}
+
+void wxContourMainFrame::getMaskValue(vtkImageData ** mask,vtkImageData ** value,int typeContourGroup, int selection, int minZ, int maxZ){
+ wxBusyCursor wait;
+
+ //int typeContourGroup = this->_radiolstboxContourGroup->GetSelection();
+ if (typeContourGroup==3)
+ {
+ typeContourGroup=1;
+ }
+ _contourextractdata ->SetTypeOperation( typeContourGroup % 3 );
+
+ std::vector<manualBaseModel*> lstManConMod;
+ std::vector<manualBaseModel*> lstManConModTmp;
+ std::vector<manualBaseModel*> lstManConModExp;
+
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+
+ vtkImageData *imagedata = _theViewPanel->getImageData();
+ int ext[6];
+ imagedata->GetExtent(ext);
+ int sizeZimage = ext[5]-ext[4]+1;
+ int z;
+ int ii,sizeLstContourThings;
+
+ double totalZ;
+ double porcent;
+
+ wxString tmpString;
+
+
+ if (selection==0 ) // actual slice
+ {
+ int actualSlice = tempVector[1];
+ minZ = actualSlice;
+ maxZ = actualSlice;
+ }
+
+ totalZ = maxZ-minZ;
+
+
+ // cleanning image before range
+ for (z=0; z<minZ; z++){
+ _contourextractdata->ResetImageResult(z);
+ }
+ // cleanning image after range
+ for (z=maxZ+1; z<sizeZimage; z++){
+ _contourextractdata->ResetImageResult(z);
+ }
+
+
+// For each slice..
+ for ( z=minZ ; z<=maxZ ; z++)
+ {
+
+ porcent = 100.0* (z-minZ)/totalZ;
+ tmpString.Printf(_T("Saving Values"));
+ tmpString.Printf(_T("%d %c %d/%d %d"), (int)porcent , 37 , z-minZ+1, (int)totalZ ,z);
+ interfMainPanel::getInstance()->setStringInfoPanel(tmpString);
+
+ //Extraction data from contours of each slice
+ _contourextractdata->SetZtoBeAnalys( z);
+
+ tempVector[1]=z;
+ Instant instant(&tempVector);
+ std::vector<ContourThing**> lstContourThings = kernelManager->getOutlinesAtInstant( &instant );
+ sizeLstContourThings = lstContourThings.size();
+
+ lstManConMod.clear();
+ for (ii=0 ; ii<sizeLstContourThings ; ii++)
+ {
+ ContourThing **contourthing = lstContourThings[ii];
+ lstManConMod.push_back( (*contourthing)->getModel() );
+ }
+ lstManConModExp = kernelManager->ExploseEachModel( lstManConMod );
+
+
+ int iContourGroup,sizeContourGroup;
+ if (typeContourGroup==3) // contour separete
+ {
+ sizeContourGroup=lstManConModExp.size();
+ } else { // contour AND OR XOR
+ sizeContourGroup=1;
+ }
+
+ for( iContourGroup=0 ; iContourGroup<sizeContourGroup ; iContourGroup++ ){
+ lstManConModTmp.clear();
+ if (typeContourGroup==3) // contour separete
+ {
+ lstManConModTmp.push_back( lstManConModExp[iContourGroup]);
+ } else { // contour AND OR XOR
+ lstManConModTmp = lstManConModExp;
+ }
+
+ _contourextractdata->SetLstManualContourModel( lstManConModTmp );
+ _contourextractdata->CalculateImageResult(); // with actual Z
+
+ } // for iContourGroup
+ } // for z
+
+ (*value) = _contourextractdata->GetVtkImageValueResult();
+ (*mask) = _contourextractdata->GetVtkImageMaskResult();
+
+}
+
+std::string wxContourMainFrame::GetStringTypeImage( vtkImageData* image)
+{
+ std::string result="";
+ if ( image->GetScalarType()==VTK_CHAR )
+ {
+ result="CHAR";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_CHAR ){
+ result="UCHAR";
+ } else if ( image->GetScalarType()==VTK_FLOAT ){
+ result="FLOAT";
+ } else if ( image->GetScalarType()==VTK_DOUBLE ){
+ result="DOUBLE";
+ } else if ( image->GetScalarType()==VTK_INT ){
+ result="INT";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_INT ){
+ result="UINT";
+ } else if ( image->GetScalarType()==VTK_SHORT ){
+ result="SHORT";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_SHORT ){
+ result="USHORT";
+ } else if ( image->GetScalarType()==VTK_LONG ){
+ result="LONG";
+ } else if ( image->GetScalarType()==VTK_UNSIGNED_LONG ){
+ result="ULONG";
+ }
+ return result;
+}
+
+void wxContourMainFrame::SaveImageResult(std::string directory,std::string namefile, vtkImageData* mask,vtkImageData* value)
+{
+ std::string stringType;
+ double spc[3];
+ kernelManager->GetSpacing(spc,0); // returns the spacing of the first image
+ stringType = GetStringTypeImage(value);
+ std::string temp = directory + "/" + namefile + "-image-Value-"+stringType+".mhd";
+
+ wxString filename = crea::std2wx(temp);
+
+// Image Value
+
+ vtkImageChangeInformation *valueChInfo = vtkImageChangeInformation::New();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ valueChInfo->SetInput(value);
+#else
+ valueChInfo->SetInputData(value);
+#endif
+ valueChInfo->SetSpacingScale(spc);
+ valueChInfo->Update();
+ vtkMetaImageWriter *writerValueImage = vtkMetaImageWriter::New( );
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ writerValueImage->SetInput( valueChInfo->GetOutput() );
+#else
+ writerValueImage->SetInputData( valueChInfo->GetOutput() );
+#endif
+ writerValueImage->SetFileName( (const char *)filename.mb_str() );
+ writerValueImage->SetFileDimensionality( 3 );
+ writerValueImage->SetCompression(false);
+ writerValueImage->Write( );
+
+// Image Mask
+ stringType = GetStringTypeImage(mask);
+ temp = directory + "/" + namefile + "-image-Mask-"+stringType+".mhd";
+
+ // LG 14/01/09 : using crea
+ filename = crea::std2wx(temp);
+ // filename.Printf(_T(temp.c_str()));
+
+
+ vtkImageChangeInformation *maskChInfo = vtkImageChangeInformation::New();
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ maskChInfo->SetInput(mask);
+#else
+ maskChInfo->SetInputData(mask);
+#endif
+ maskChInfo->SetSpacingScale(spc);
+ maskChInfo->Update();
+ vtkMetaImageWriter *writerMaskImage = vtkMetaImageWriter::New( );
+
+//EED 2017-01-01 Migration VTK7
+#if VTK_MAJOR_VERSION <= 5
+ writerMaskImage->SetInput( maskChInfo->GetOutput() );
+#else
+ writerMaskImage->SetInputData( maskChInfo->GetOutput() );
+#endif
+
+ writerMaskImage->SetFileName( (const char *)filename.mb_str() );
+ writerMaskImage->SetFileDimensionality( 3 );
+ writerMaskImage->SetCompression(false);
+ writerMaskImage->Write( );
+
+ interfMainPanel::getInstance()->setStringInfoPanel( _T("") );
+
+}
+
+
+
+void wxContourMainFrame::onChangeInstantInstantPanel(std::string name,int value, int minshow, int maxshow){
+ if( name.compare( _theViewPanel->getVerticalConceptName() ) == 0){
+ _theViewPanel->setActualVertical( value);
+ }
+ else if( name.compare( _theViewPanel->getHorizontalConceptName() ) == 0|| _instantPanel->getIfConceptCheckedAt( name, 0 ) ) {
+ _theViewPanel->setHorizontalConcept( name, minshow, maxshow, minshow, maxshow, value);
+ }
+
+ changeInstant();
+}
+
+void wxContourMainFrame::onSnakePressed(){
+ std::vector<double> vecX;
+ std::vector<double> vecY;
+ std::vector<double> vecZ;
+ _theViewPanel->GetPointsOfActualContour( &vecX , &vecY , &vecZ );
+
+ if (vecX.size()!=0){
+ std::vector<int> tempVector;
+ _instantPanel->getInstant( tempVector );
+ int i,size=vecZ.size();
+ int actualSlice = tempVector[1];
+ for ( i=0 ; i<size ; i++ )
+ {
+ vecZ[i] = actualSlice;
+ } // for
+
+ wxDialog* dialog = new wxDialog(this, -1, wxString(_T("Snake")));
+ wxPanel* panel = new wxPanel(dialog,-1);
+ // wxStaticText* sttext = new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
+ new wxStaticText(panel, -1, wxString(_T("Panel para snake")));
+ dialog->ShowModal();
+ } // if
+
+}
+
+void wxContourMainFrame::saveFileWithContoursAutomatique()
+{
+printf("EED wxContourMainFrame::saveFileWithContoursAutomatique \n");
+ std::string filename = kernelManager->getCurrentFileName();
+ if(filename.compare("")!=0){
+ saveFileWithContours(filename);
+ }else{
+ onSave();
+ }
+}
+void wxContourMainFrame::ShowToolsPanel(bool show)
+{
+ _pannew->Show(show);
+}
+
+
+
+void wxContourMainFrame::SetContourGroup(int contourGroup)
+{
+ _contourGroup = contourGroup;
+}
+
+
+wxPanel *wxContourMainFrame::getMaskImageViewPanel(wxWindow *parent)
+{
+
+ if (_viewMaskImagePanel==NULL)
+ {
+ _contourextractdata = new ContourExtractData(true);
+ _contourextractdata->SetImage( _theViewPanel->getImageData() );
+// double range[2];
+// _theViewPanel->getImageData()->GetScalarRange(range);
+ //int min = (int)floor (range[0]);
+ //int max = (int)ceil (range[1]);
+
+//EED 2017-12-17
+ int min = 254;
+ int max = 256;
+
+ _viewMaskImagePanel = new ThresholdImageViewPanel( parent, -1, -1 , -1,-1, 0);
+ _viewMaskImage = new ThresholdImageView();
+ _viewMaskImage->SetImage( _contourextractdata->GetVtkImageMaskResult() );
+ _viewMaskImage->SetminMaxValue( min, max);
+ _viewMaskImage->SetBaseColor( 0,0,1 );
+
+
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( -999 );
+ colorbarposition.push_back( -999 );
+ _viewMaskImage->SetColorBarPosition( colorbarposition );
+ double spc[3];
+ _viewMaskImage->SetSpcBase( _theViewPanel->getImageData()->GetSpacing() );
+ _viewMaskImage->SetNewSpacingLayer( _theViewPanel->getImageData()->GetSpacing() );
+
+ _viewMaskImagePanel->SetThresholdImageView( _viewMaskImage );
+ _viewMaskImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
+ _viewMaskImage->onThresholdChangeOpacity( 25 );
+ }
+ return _viewMaskImagePanel;
+}
+
+
+wxPanel *wxContourMainFrame::getColorLayerImageViewPanel(wxWindow *parent)
+{
+ if (_viewColorLayerImagePanel==NULL)
+ {
+ double range[2];
+ _theViewPanel->getImageData()->GetScalarRange(range);
+ int min = (int)floor (range[0]);
+ int max = (int)ceil (range[1]);
+ _viewColorLayerImagePanel = new ColorLayerImageViewPanel( parent, min, max, 100, 1);
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetwxVtkBaseView( 0 , _theViewPanel->getWxVtkBaseView() );
+ // std::vector<double> range = bbGetInputlstRangeForColorBar();
+ // clivp->GetColorLayerImageViewManager()->SetRangeForColorBar( range );
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( 50 );
+ colorbarposition.push_back( 105 );
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetColorBarPosition( colorbarposition );
+ // std::vector<double> base_color;
+ // _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetBaseColors( base_color );
+ // std::vector<double> grey_level_boundaries;
+ // clivp->GetColorLayerImageViewManager()->SetGreyLevelBoundaries( grey_level_boundaries );
+ std::vector<double> transparence_level_boundaries;
+ transparence_level_boundaries.push_back(0);
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetBaseTransparence( transparence_level_boundaries );
+ _viewColorLayerImagePanel->GetColorLayerImageViewManager()->SetPlainOrGradientColor( false );
+// _viewColorLayerImagePanel->SetFittingMode( 3 );
+ }
+ return _viewColorLayerImagePanel;
+}
+
+void wxContourMainFrame::SetColorLayerImage(vtkImageData* img)
+{
+ if (_viewColorLayerImagePanel!=NULL)
+ {
+ if (img!=NULL)
+ {
+ _viewColorLayerImagePanel->SetActive(true);
+ _viewColorLayerImagePanel->SetImage( img );
+// RefreshInterface();
+ } // img
+ } // _viewColorLayerImagePanel
+}
+
+wxPanel *wxContourMainFrame::getThresholdImageViewPanel(wxWindow *parent)
+{
+ if (_viewThresholdImagePanel==NULL)
+ {
+ double range[2];
+ _theViewPanel->getImageData()->GetScalarRange(range);
+ int min = (int)floor (range[0]);
+ int max = (int)ceil (range[1]);
+ int start = (max+min)/2 - (max-min)*0.25;
+ int end = (max+min)/2 + (max-min)*0.25;
+ _viewThresholdImagePanel = new ThresholdImageViewPanel( parent, min, max, start, end , 1);
+ _viewThresholdImage = new ThresholdImageView();
+ _viewThresholdImage->SetminMaxValue(start,end);
+// _viewThresholdImage->SetminMaxValue(range[0],range[1]);
+ _viewThresholdImage->SetImage( _theViewPanel->getImageData() );
+ std::vector<int> colorbarposition;
+ colorbarposition.push_back( 10 );
+ colorbarposition.push_back( 105 );
+ _viewThresholdImage->SetColorBarPosition( colorbarposition );
+ double spc[3];
+ _viewThresholdImage->SetSpcBase( _theViewPanel->getImageData()->GetSpacing() );
+ _viewThresholdImage->SetNewSpacingLayer( _theViewPanel->getImageData()->GetSpacing() );
+
+ _viewThresholdImage->SetBaseColor( 1,0,0 );
+ _viewThresholdImagePanel->SetThresholdImageView( _viewThresholdImage );
+ _viewThresholdImage->SetwxVtkBaseView( _theViewPanel->getWxVtkBaseView() );
+ _viewThresholdImage->onThresholdChangeOpacity( 25 );
+ RefreshInterface();
+ }
+ return _viewThresholdImagePanel;
+}
+
+//CMRU 17-08-09-----------------------------------------------------------------------------------------------
+int wxContourMainFrame::getType ()
+{
+ int tipo = 0;
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+
+ if(!currentSelection.empty())
+ {
+ std::string cloneName = currentSelection [0];
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);
+ tipo = manualModel-> GetTypeModel();
+ }
+ return tipo;
+}
+
+double wxContourMainFrame::getContourSizeInPixels()
+{
+ double contourSize = 0;
+
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects(); if(!currentSelection.empty())
+ if(!currentSelection.empty())
+ {
+ std::string cloneName = currentSelection [0];
+
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
+
+// EED 2017-05-30
+// contourSize = manualModel->GetPathSize();
+ double spc[3];
+ spc[0]=1;
+ spc[1]=1;
+ spc[2]=1;
+ contourSize = manualModel->GetPathSize( spc );
+ }
+ return contourSize;
+}
+
+manualBaseModel * wxContourMainFrame::getContour ()
+{
+ std::vector<std::string> currentSelection = _theViewPanel->getSelectedObjects();
+
+ if(!currentSelection.empty())
+ {
+ std::string cloneName = currentSelection [0];
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(cloneName);//_modelManager->getOutlineByKeyName( cloneName )->getModel();
+ return manualModel;
+ }
+ return NULL;
+}
+void wxContourMainFrame::onPrintLabel (wxString label, manualBaseModel* manualModel)
+{
+ std::string labelAscii(label.ToAscii());
+ int pos = labelAscii.find(" ");
+
+ int j;
+
+ for (j=0 ; pos != string::npos;j++)
+ {
+ labelAscii.replace( pos, 1, "_" );
+ pos= labelAscii.find(" ");
+ }
+
+ manualModel -> SetLabel(labelAscii);
+}
+void wxContourMainFrame::onInsertCalculation(manualBaseModel* manualModel)
+{
+// EED 2017-05-30
+// double sizeInPixel = manualModel ->GetPathSize( );
+ double spc[3];
+ spc[0]=1; // ????
+ spc[1]=1; // ????
+ spc[2]=1; // ????
+ double sizeInPixel = manualModel ->GetPathSize( spc );
+
+ double onePixelRealSize = interfMainPanel::getInstance()->GetPixelValue();;
+ double realContourSize = sizeInPixel*onePixelRealSize;
+ manualModel ->SetRealSize(realContourSize);
+}
+
+double wxContourMainFrame::onePixelSize( double value)
+{
+ return _onePixelSize = value;
+}
+
+std::string wxContourMainFrame::GetFileLocation()
+{
+ return _fileLocation;
+}
+
+void wxContourMainFrame::SetFileLocation(std::string newFileLocation)
+{
+ _fileLocation = newFileLocation;
+ std::cout<<"GETFILELOCATION:"<<_fileLocation<<std::endl;
+
+//EED 2019-12-17
+ kernelManager->setCurrentFileName(_fileLocation);
+}
+//------------------------------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+void wxContourMainFrame::FlipSelectedContours(int flipDirection)
+{
+ FlipLstOfContours(
+ (std::vector<std::string>)_theViewPanel->getSceneManager()->getSelectedObjects() ,
+ flipDirection
+ );
+
+}
+
+void wxContourMainFrame::FlipActualSliceContours(int flipDirection)
+{
+ FlipLstOfContours(
+ (std::vector<std::string>)_theViewPanel->getSceneManager()->GetlstContoursNameActualSlice() ,
+ flipDirection
+ );
+}
+
+void wxContourMainFrame::FlipAllContours(int flipDirection)
+{
+ FlipLstOfContours(
+ kernelManager->GetLstNameThings() ,
+ flipDirection
+ );
+}
+
+void wxContourMainFrame::FlipLstOfContours(std::vector<std::string> lstNameThings, int flipDirection)
+{
+ int ext[6];
+ getImageData()->GetExtent(ext);
+ int sizeX = ext[1]-ext[0];
+ int sizeY = ext[3]-ext[2];
+
+
+ int i,sizeLstNameThings;
+ int ii,sizeLstPoints;
+
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ if (flipDirection==0)
+ {
+ manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
+ } else {
+ manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
+ }
+ }// for i list of Things
+
+ //-- Static Contours
+
+ lstNameThings = kernelManager->GetLstNameThingsStatic();
+ sizeLstNameThings = lstNameThings.size();
+ for (i=0 ; i<sizeLstNameThings ; i++)
+ {
+ manualBaseModel * manualModel = kernelManager->getOutlineByKeyName(lstNameThings[i]);
+ if (flipDirection==0)
+ {
+ manualModel->Transform_Ax_Plus_B(-1,sizeX,1,0 );
+ } else {
+ manualModel->Transform_Ax_Plus_B(1,0,-1,sizeY );
+ }
+ }// for i list of static things
+}
+
+void wxContourMainFrame::FlipContours(int typeContourFlip, int flipDirection)
+{
+ saveState();
+
+ if (typeContourFlip==0) //
+ {
+ FlipSelectedContours(flipDirection);
+ }
+
+ if (typeContourFlip==1) //
+ {
+ FlipActualSliceContours(flipDirection);
+ }
+
+ if (typeContourFlip==2) //
+ {
+ FlipAllContours(flipDirection);
+ }
+ RefreshInterface();
+}
+
+void wxContourMainFrame::SetXY(int x, int y)
+{
+ _theViewPanel->SetXY(x,y);
+}
+
+wxVtkBaseView* wxContourMainFrame::GetWxVtkBaseView()
+{
+ if (_theViewPanel!=NULL)
+ {
+ return _theViewPanel->getWxVtkBaseView();;
+ } else {
+ return NULL;
+ }
+}
+
+
+