Example #1
0
    void Clipper::Clip(Lazarus::image_3d_opencv_8uc1 *input, Lazarus::image_3d_opencv_8uc1 *output)
    {
        CHECK(UniversalAlgorithm::Check3DImage(input));
        CHECK(UniversalAlgorithm::isBinary(input));
        
        image_3d_opencv_8uc1* maskConnectivityFix = new image_3d_opencv_8uc1;
        maskConnectivityFix->Initialize();
        
        
        itk_3d_double::Pointer inITK = itk_3d_double::New();
        Converter::ocv_2_itk_3d(input, inITK);
        
        typedef itk::RescaleIntensityImageFilter<itk_3d_double> RescalerType;
        RescalerType::Pointer rescaler = RescalerType::New();
        rescaler->SetInput(inITK);
        rescaler->SetOutputMinimum(0);
        rescaler->SetOutputMaximum(255);
        rescaler->Update();
        
        typedef itk::ImageToVTKImageFilter<itk_3d_double> converterType;
        converterType::Pointer converter = converterType::New();
        converter->SetInput(rescaler->GetOutput());
        converter->Update();

        Pool::image=converter->GetOutput();
        
        int dim[3];
        Pool::image->GetDimensions(dim);
        
        Pool::pointSeries.clear();
        Pool::IdSeries.clear();
        for(int k=0; k<dim[2]; k++)
        {
            for(int j=0; j<dim[1]; j++)
            {
                for(int i=0; i<dim[0]; i++)
                {
                    double * voxel = static_cast<double*> (Pool::image->GetScalarPointer(i, j, k) );
                    if( *voxel > 0)
                    {
                        double p[3];
                        Pool::image->GetPoint(k*dim[1]*dim[0]+j*dim[0]+i,p);
                        Point3d pp;
                        {
                            pp.x = p[0];
                            pp.y = p[1];
                            pp.z = p[2];
                        }
                        Point3i ppp;
                        {
                            ppp.x = i;
                            ppp.y = j;
                            ppp.z = k;
                        }
                        Pool::pointSeries.push_back(pp);
                        Pool::IdSeries.push_back(ppp);
                    }
                }
            }
        }
//
//        vtkSmartPointer<vtkMarchingCubes> iso = vtkSmartPointer<vtkMarchingCubes>::New();
//        iso->SetInputData(Pool::image);
//        iso->SetNumberOfContours(1);
//        iso->SetValue(0,1);
//        iso->ComputeGradientsOn();
//        iso->ComputeNormalsOn();
//        iso->ComputeNormalsOn();
//        iso->ComputeScalarsOff();
//        iso->Update();
//        
//        vtkSmartPointer<vtkQuadricClustering> decimate =vtkSmartPointer<vtkQuadricClustering>::New();
//        decimate->SetNumberOfXDivisions(200);
//        decimate->SetNumberOfYDivisions(200);
//        decimate->SetNumberOfZDivisions(200);
//        decimate->SetInputData(iso->GetOutput());
//        decimate->Update();
//
//        vtkSmartPointer<vtkPolyDataMapper> dataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
//        dataMapper->SetInputData(decimate->GetOutput());
//        dataMapper->Update();
        
        //Pool::cubeActor->SetMapper(dataMapper);
        
        ClipperVisualizer vis;
        
        Pool::currentMask = new image_3d_opencv_8uc1;
        Pool::currentMask->Initialize();
        
        Pool::currentMask->SetData(input);
        
        Pool::renderWindow->AddRenderer(Pool::renderer);
        Pool::renderWindow->SetSize(600,600);
        Pool::interactor->SetRenderWindow(Pool::renderWindow);
        Pool::camera->GetParallelProjection();
        Pool::renderer->ResetCamera();
        vtkSmartPointer<myInteractorStyle> myStyle = vtkSmartPointer<myInteractorStyle>::New();
        myStyle->SetDefaultRenderer(Pool::renderer);
        Pool::interactor->SetInteractorStyle( myStyle );
        myStyle->SetWrappingQtWindow(&vis);
        myStyle->FirstDraw();
        //Pool::renderer->AddActor(Pool::cubeActor);
        
        
        
        //QvtkWindow* wnd = new QvtkWindow(NULL);
        //wnd->AddRenderWindow(Pool::renderWindow);
        Pool::interactor->Initialize();
        Pool::renderWindow->Render();
        //Pool::interactor->Start();
        //wnd->exec();
        vis.exec();
        
        
        LOG(INFO)<<"rendering terminate."<<endl;
        
        
        output->SetData(Pool::currentMask);

        //delete maskConnectivityFix;
        //delete wnd;
    }