It does not let me attach any file. I include the code here as in the cpp. Thanks
//#include "stdafx.h"
#include <vtkColorTransferFunction.h>
#include <vtkCommonDataModelModule.h>
#include <vtkCompositeDataIterator.h>
#include <vtkLinearTransform.h>.
#include <vtkMultiBlockDataSet.h>
#include <vtkParametricSpline.h>
#include <vtkParametricFunctionSource.h>
#include <vtkPiecewiseFunction.h>
#include <vtkPolyDataMapper.h>
#include <vtkSmartVolumeMapper.h>
#include <vtkSphereSource.h>
#include <vtkSTLReader.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkTubeFilter.h>
#include <vtkUnstructuredGrid.h>
#include <vtkVolumeProperty.h>
#include <vtkXMLMultiBlockDataReader.h>
#include <vtkXMLMultiBlockDataWriter.h>
#include <itkVTKImageToImageFilter.h>
#include <vtkDICOMImageReader.h>
#include <vtkInteractorStyleImage.h>
#include <vtkImageSlab.h>
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkGDCMImageIO.h"
#include "itkImageSeriesReader.h"
#include "itkImageSeriesWriter.h"
#include "itkGDCMSeriesFileNames.h"
#include <itkCastImageFilter.h>
#include <itkImageToVTKImageFilter.h>
#include "itkBinaryThresholdImageFilter.h"
#include "itkExtractImageFilter.h"
#include "itkRegionOfInterestImageFilter.h"
#include "itkConnectedComponentImageFilter.h"
#include "itkLabelGeometryImageFilter.h"
#include "itkFlipImageFilter.h"
#include "itkFixedArray.h"
#include "vtkImageStencilData.h"
#include <vtkCellPicker.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include "vtkImageMagnitude.h"
#include <vtkImageViewer2.h>
#include <vtkMatrix4x4.h>
#include <vtkTransform.h>
#include <vtkImageAppend.h>
#include <vtkResliceImageViewer.h>
#include <vtkImageLogic.h>
#include <vtkMarchingCubes.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkImageStencil.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkLinearExtrusionFilter.h>
#include <itkGDCMImageIO.h>
#include <itkGDCMSeriesFileNames.h>
#include <itkMetaDataObject.h>
#include <vtkAbstractVolumeMapper.h>
#include <vtkBox.h>
#include <vtkCamera.h>
#include <vtkCellPicker.h>
#include <vtkCleanPolyData.h>
#include <vtkClipPolyData.h>
#include <vtkCommand.h>
#include <vtkFillHolesFilter.h>
#include <vtkGenericOpenGLRenderWindow.h>
#include <vtkImageAppend.h>
#include <vtkImageData.h>
#include <vtkImageMapToWindowLevelColors.h>
#include <vtkImageReslice.h>
#include <vtkImplicitBoolean.h>
#include <vtkInteractorStyleImage.h>
#include <vtkLightKit.h>
#include <vtkMapper.h>
#include <vtkObjectFactory.h>
#include <vtkParametricFunctionSource.h>
#include <vtkParametricSpline.h>
#include <vtkPlane.h>
#include <vtkPointData.h>
#include <vtkPoints.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkProperty.h>
#include <vtkPropPicker.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkRendererCollection.h>
#include <vtkResliceImageViewer.h>
#include <vtkSmartPointer.h>
#include <vtkSplineFilter.h>
#include <vtkSplineRepresentation.h>
#include <vtkStringArray.h>
#include <vtkStripper.h>
#include <vtkTransform.h>
#include <vtkTransformPolyDataFilter.h>
#include <vtkTriangleFilter.h>
#include <vtkWarpVector.h>
#include <vtkWindowLevelLookupTable.h>
#include <itkKernelImageFilter.h>
#include <vtkImageLogic.h>
#include <vtkMarchingCubes.h>
#include <vtkPolyDataToImageStencil.h>
#include <vtkImageStencil.h>
#include <vtkSmoothPolyDataFilter.h>
#include <vtkLinearExtrusionFilter.h>
#include "vtkImageCast.h"
#include "itkBinaryDilateImageFilter.h"
#include "itkImageFileReader.h"
#include "itkBinaryBallStructuringElement.h"
#include <itkImage.h>
vtkRenderer * global_renderer;
float *seeds = new float[3];
#include <vtkSmartPointer.h>
#include <vtkObjectFactory.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkRenderer.h>
#include <vtkActor.h>
// headers needed for this example
#include <vtkImageViewer2.h>
#include <vtkDICOMImageReader.h>
#include <vtkInteractorStyleImage.h>
#include <vtkActor2D.h>
#include <vtkTextProperty.h>
#include <vtkTextMapper.h>
// needed to easily convert int to std::string
#include <sstream>
vtkSmartPointer<vtkImageData> getFromPolydataToImage(vtkSmartPointer<vtkPolyData> pd) {
////////////////////
vtkSmartPointer<vtkImageData> whiteImage =
vtkSmartPointer<vtkImageData>::New();
double bounds[6];
pd->GetBounds(bounds);
double spacing[3]; // desired volume spacing
spacing[0] = 0.1;
spacing[1] = 0.1;
spacing[2] = 0.1;
whiteImage->SetSpacing(spacing);
// compute dimensions
int dim[3];
for (int i = 0; i < 3; i++)
{
dim[i] = static_cast<int>(ceil((bounds[i * 2 + 1] - bounds[i * 2]) / spacing[i]));
}
whiteImage->SetDimensions(dim);
whiteImage->SetExtent(0, dim[0] - 1, 0, dim[1] - 1, 0, dim[2] - 1);
double origin[3];
origin[0] = bounds[0] + spacing[0] / 2;
origin[1] = bounds[2] + spacing[1] / 2;
origin[2] = bounds[4] + spacing[2] / 2;
whiteImage->SetOrigin(origin);
#if VTK_MAJOR_VERSION <= 5
whiteImage->SetScalarTypeToUnsignedChar();
whiteImage->AllocateScalars();
#else
whiteImage->AllocateScalars(VTK_UNSIGNED_CHAR, 1);
#endif
// fill the image with foreground voxels:
unsigned char inval = 255;
unsigned char outval = 0;
vtkIdType count = whiteImage->GetNumberOfPoints();
for (vtkIdType i = 0; i < count; ++i)
{
whiteImage->GetPointData()->GetScalars()->SetTuple1(i, inval);
}
// polygonal data --> image stencil:
vtkSmartPointer<vtkPolyDataToImageStencil> pol2stenc =
vtkSmartPointer<vtkPolyDataToImageStencil>::New();
#if VTK_MAJOR_VERSION <= 5
pol2stenc->SetInput(pd);
#else
pol2stenc->SetInputData(pd);
#endif
pol2stenc->SetOutputOrigin(origin);
pol2stenc->SetOutputSpacing(spacing);
pol2stenc->SetOutputWholeExtent(whiteImage->GetExtent());
pol2stenc->Update();
// cut the corresponding white image and set the background:
vtkSmartPointer<vtkImageStencil> imgstenc =
vtkSmartPointer<vtkImageStencil>::New();
#if VTK_MAJOR_VERSION <= 5
imgstenc->SetInput(whiteImage);
imgstenc->SetStencil(pol2stenc->GetOutput());
#else
imgstenc->SetInputData(whiteImage);
imgstenc->SetStencilConnection(pol2stenc->GetOutputPort());
#endif
imgstenc->ReverseStencilOff();
imgstenc->SetBackgroundValue(outval);
imgstenc->Update();
return imgstenc->GetOutput();
}
int main() {
vtkSmartPointer<vtkSTLReader> reader =
vtkSmartPointer<vtkSTLReader>::New();
reader->SetFileName("stls.stl");
reader->Update();
/*vtkSmartPointer<vtkFillHolesFilter> fillHolesFilter =
vtkSmartPointer<vtkFillHolesFilter>::New();
fillHolesFilter->SetInputData(reader->GetOutput());
fillHolesFilter->SetHoleSize(100000.0);
fillHolesFilter->Update();*/
// Make the triangle winding order consistent
vtkSmartPointer<vtkPolyDataNormals> normals2 =
vtkSmartPointer<vtkPolyDataNormals>::New();
normals2->SetInputData(reader->GetOutput());
normals2->ConsistencyOn();
normals2->SetComputeCellNormals(1);
normals2->SplittingOff();
normals2->Update();
vtkSmartPointer<vtkImageData> pd1 = getFromPolydataToImage(normals2->GetOutput()); //tested it works
typedef itk::Image<signed short, 3> ImageType3d;
typedef itk::VTKImageToImageFilter<ImageType3d> VTKImageToImageType;
VTKImageToImageType::Pointer vtkImageToImageFilter =
VTKImageToImageType::New();
vtkSmartPointer<vtkImageData> image_data = vtkImageData::SafeDownCast(pd1);
vtkSmartPointer<vtkImageCast> cast_image = vtkSmartPointer<vtkImageCast>::New();
cast_image->SetInputData(image_data);
cast_image->SetOutputScalarTypeToShort();
cast_image->Update();
vtkImageToImageFilter->SetInput(cast_image->GetOutput());
using FilterType3d = itk::VTKImageToImageFilter<ImageType3d>;
FilterType3d::Pointer filter = FilterType3d::New();
filter->SetInput(cast_image->GetOutput());
try {
filter->Update();
}
catch (itk::ExceptionObject& error) {
std::cerr << "Error: " << error << std::endl;
return 0;
}
using StructuringElementType = itk::FlatStructuringElement< 3 >;
StructuringElementType::RadiusType radius;
radius.Fill(5);
StructuringElementType structuringElement =
StructuringElementType::Ball(radius);
using PixelType = signed short;
constexpr unsigned int Dimension = 3;
using ImageType = itk::Image< PixelType, Dimension >;
using ReaderType = itk::ImageFileReader< ImageType >;
using BinaryDilateImageFilterType = itk::BinaryDilateImageFilter< ImageType, ImageType,
StructuringElementType >;
BinaryDilateImageFilterType::Pointer dilateFilter =
BinaryDilateImageFilterType::New();
dilateFilter->SetInput(filter->GetOutput());
dilateFilter->SetKernel(structuringElement);
dilateFilter->SetForegroundValue(255);
dilateFilter->SetBackgroundValue(0);
using FilterType = itk::ImageToVTKImageFilter< ImageType >;
FilterType::Pointer filter2 = FilterType::New();
filter2->SetInput(dilateFilter->GetOutput());
filter2->Update();
vtkSmartPointer<vtkMarchingCubes> surface =
vtkSmartPointer<vtkMarchingCubes>::New();
surface->SetInputData(filter2->GetOutput());
surface->SetValue(0, 0.5);
surface->Update();
vtkSmartPointer<vtkSmoothPolyDataFilter> smoothFilter =
vtkSmartPointer<vtkSmoothPolyDataFilter>::New();
smoothFilter->SetInputConnection(surface->GetOutputPort());
smoothFilter->SetNumberOfIterations(15);
smoothFilter->SetRelaxationFactor(0.1);
smoothFilter->FeatureEdgeSmoothingOff();
smoothFilter->BoundarySmoothingOn();
smoothFilter->Update();
// Update normals on newly smoothed polydata
vtkSmartPointer<vtkPolyDataNormals> normalGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
normalGenerator->SetInputConnection(smoothFilter->GetOutputPort());
normalGenerator->ComputePointNormalsOn();
normalGenerator->ComputeCellNormalsOn();
normalGenerator->Update();
vtkSmartPointer<vtkPolyData> poly = vtkSmartPointer<vtkPolyData>::New();
poly = surface->GetOutput();
vtkSmartPointer<vtkPolyDataMapper> splintMapper =
vtkSmartPointer<vtkPolyDataMapper>::New();
splintMapper->SetInputConnection(surface->GetOutputPort());
splintMapper->ScalarVisibilityOff();
vtkSmartPointer<vtkActor> splintActor =
vtkSmartPointer<vtkActor>::New();
splintActor->SetMapper(splintMapper);
//originalActor->GetProperty()->SetInterpolationToFlat();
vtkSmartPointer<vtkRenderWindow> renderWindow =
vtkSmartPointer<vtkRenderWindow>::New();
renderWindow->SetSize(640, 480);
// Create a camera for all renderers
vtkSmartPointer<vtkCamera> camera =
vtkSmartPointer<vtkCamera>::New();
// Setup both renderers
vtkSmartPointer<vtkRenderer> renderer =
vtkSmartPointer<vtkRenderer>::New();
renderer->AddActor(splintActor);
//renderer->AddActor(warpedActor);
//renderer->AddActor(originalActor);
//renderer->AddActor(substractActor);
renderWindow->AddRenderer(renderer);
vtkSmartPointer<vtkRenderWindowInteractor> interactor =
vtkSmartPointer<vtkRenderWindowInteractor>::New();
interactor->SetRenderWindow(renderWindow);
renderWindow->Render();
interactor->Start();
//The end
return 0;
}