MyRenderer Class Reference

#include <MyRenderer.h>

Public Member Functions
	MyRenderer (bool isSplitted, vtkRenderWindow *renderWindow=nullptr)
	~MyRenderer ()
void	claculateDistanceToActor (int keyMainActor, int keyTumorActor, bool splittedMiddle=false, bool splittedBorder=false)
void	LoadPolydataFromFile (const char *filename, vtkMatrix4x4 *viewMatrix=NULL)
void	LoadShaders (QString path)
vtkSmartPointer< MyActor >	CopyActor (vtkSmartPointer< MyActor > actor, QString name)
void	SplitPolygons ()
void	LinkLabelToShader (int label, QString name, vtkSmartPointer< MyShaderCallback > callback=0)
void	SetShadingProperties ()
void	SetCameraProperties (double cameraPosition[3]=CAMERAPOSITION, double focalPoint[3]=FOCALPOINT, double viewUp[3]=CAMERAVIEWUP, double zoom=ZOOM)
void	Begin ()
void	SetDefaults ()
vtkSmartPointer< vtkPolyData >	FusePolygons (vtkSmartPointer< vtkPolyData > polyData1, vtkSmartPointer< vtkPolyData > polyData2)
vtkSmartPointer< vtkPolyData >	CloseOpenPolygons (vtkSmartPointer< vtkPolyData > polyData)
void	showTargetStructure (int keyTargetStructure, int keyRiskStructure)
vtkSmartPointer< vtkPolyData >	SplitPolygon (int actorID, bool safeToPolyDataMap=true)
vtkSmartPointer< vtkRenderWindow >	GetRenderWindow () const
void	ConnectInteractors ()
vtkSmartPointer< vtkRenderer >	GetRenderer () const
void	copyData (MyRenderer *renderer)
double *	GetOriginOfClipping ()
double *	GetNormalOfClipping ()
vtkSmartPointer< vtkPlaneSource >	GetClippingPlane ()
void	CreateClippingPlane (vtkSmartPointer< vtkPlaneSource > from)
void	CreateClippingPlane ()
void	UpdateClippingPlane (double normal[3])
void	UpdateClippingPlane (double step)

Detailed Description

Class which takes care of preparing the Data/Information for the shaders

Definition at line 53 of file MyRenderer.h.

Constructor & Destructor Documentation

MyRenderer()

MyRenderer::MyRenderer	(	bool	isSplitted,
		vtkRenderWindow *	renderWindow = nullptr
	)

Constructor of the RenderObject if the flag isSplitted is true the Renderer is used for the visualization of the clipped data

Definition at line 172 of file MyRenderer.cpp.

{
    if (renderWindow != nullptr)
    {
        // does not work properly
        this->renderWindow = renderWindow;
        this->renderer = vtkSmartPointer<vtkRenderer>::New();
        this->isSplitted = isSplitted;
    }
    else
    {
        this->renderWindow = vtkSmartPointer<vtkRenderWindow>::New();
        this->renderer = vtkSmartPointer<vtkRenderer>::New();
        this->isSplitted = isSplitted;
    }
}

~MyRenderer()

MyRenderer::~MyRenderer

(

)

Definition at line 190 of file MyRenderer.cpp.

{
}

Member Function Documentation

Begin()

void MyRenderer::Begin

(

)

starts the renderloop.

Definition at line 827 of file MyRenderer.cpp.

{
    renderWindow->Render();
    iren->Start();
}

claculateDistanceToActor()

void MyRenderer::claculateDistanceToActor	(	int	keyMainActor,
		int	keyTumorActor,
		bool	splittedMiddle = false,
		bool	splittedBorder = false
	)

calculates the distance between two actors and stores the minimal distances as scalar value for each Point at the MainActor it also generates a colormap with which the distance values can be decoded as color(red near, white far away) furthermore it shows black isolines at specified distance values

Definition at line 207 of file MyRenderer.cpp.

{
    auto input1 = labeledPolydata.value(keyMainActor);
    auto input2 = labeledPolydata.value(keyTumorActor);

    if (isSplitted && splittedMiddle)
    {
        input1 = labeledPolydataSplitted.value(keyMainActor);
        input2 = labeledPolydataSplitted.value(keyTumorActor);
    }

    vtkSmartPointer<vtkCleanPolyData> clean1 =
        vtkSmartPointer<vtkCleanPolyData>::New();


    clean1->SetInputData(input1);

    vtkSmartPointer<vtkCleanPolyData> clean2 =
        vtkSmartPointer<vtkCleanPolyData>::New();
    clean2->SetInputData(input2);

    vtkSmartPointer<vtkDistancePolyDataFilter> distanceFilter =
        vtkSmartPointer<vtkDistancePolyDataFilter>::New();

    distanceFilter->SetInputConnection(0, clean1->GetOutputPort());
    distanceFilter->SetInputConnection(1, clean2->GetOutputPort());
    distanceFilter->SignedDistanceOff();
    distanceFilter->Update();

    auto output = distanceFilter->GetOutput();

    auto labels = output->GetPointData();

    if (output->GetPointData()->GetScalars() == NULL)
        return;
    int idx = vtkDoubleArray::SafeDownCast(output->GetPointData()->GetScalars())->GetSize();
    double max = 0.0;
    double min = 10000.0;

    for (int i = 0; i < idx; i++)
    {
        double currentDistance = vtkDoubleArray::SafeDownCast(output->GetPointData()->GetScalars())->GetValue(i);
        if (currentDistance > max)
            max = currentDistance;
        if (currentDistance < min)
            min = currentDistance;

    }


    vtkSmartPointer<vtkPolyDataMapper> mapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputData(output);
    mapper->SetScalarRange(
        distanceFilter->GetOutput()->GetPointData()->GetScalars()->GetRange()[0],
        distanceFilter->GetOutput()->GetPointData()->GetScalars()->GetRange()[1]);
    mapper->InterpolateScalarsBeforeMappingOn();



    vtkSmartPointer<vtkActor> actor =
        vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);

    vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();

    int maxInt = (int)max;


    vtkSmartPointer<vtkPolyDataMapper> mapperSplitt =
        vtkSmartPointer<vtkPolyDataMapper>::New();
    mapperSplitt->SetInputData(output);
    mapperSplitt->SetScalarRange(
        distanceFilter->GetOutput()->GetPointData()->GetScalars()->GetRange()[0],
        distanceFilter->GetOutput()->GetPointData()->GetScalars()->GetRange()[1]);
    mapperSplitt->InterpolateScalarsBeforeMappingOn();

    vtkSmartPointer<vtkActor> actorSplitted =
        vtkSmartPointer<vtkActor>::New();
    actorSplitted->SetMapper(mapperSplitt);

    vtkSmartPointer<vtkLookupTable> lookupTableSplitted = vtkSmartPointer<vtkLookupTable>::New();
    lookupTableSplitted->SetTableRange(0, maxInt * 2);
    lookupTableSplitted->SetNumberOfTableValues(maxInt * 2);

    lookupTable->SetTableRange(0, maxInt * 2);
    lookupTable->SetNumberOfTableValues(maxInt * 2);

    int count = 0;
    int countColor = 0;

    for (int i = 0; i < (maxInt * 2) - 1; i++)
    {
        while (count < 2)
        {
            if (splittedBorder)
            {
                lookupTable->SetTableValue(i, 1.0, (double)countColor / maxInt, (double)countColor / maxInt, 1);
            }
            else if (i % isoLineDistance == 0 && i != 0)
            {
                if (splittedMiddle)
                    lookupTableSplitted->SetTableValue(i, 0.0, 0.00, 0.00, 1);
                else
                    lookupTable->SetTableValue(i, 0.0, 0.00, 0.00, 1);
            }
            else
            {
                if (splittedMiddle)
                    lookupTableSplitted->SetTableValue(i, 0.6, 0.60, 0.60, 1);
                else
                    lookupTable->SetTableValue(i, 1.0, (double)countColor / maxInt, (double)countColor / maxInt, 1);
            }
            count++;
            i++;
        }
        i--;
        count = 0;
        countColor++;
    }

    lookupTable->Build();
    lookupTableSplitted->Build();

    actor->GetMapper()->SetLookupTable(lookupTable);
    actorSplitted->GetMapper()->SetLookupTable(lookupTableSplitted);

    if (!splittedMiddle)
    {
        renderer->AddActor(actor);
    }
    if (splittedMiddle && !splittedBorder)
        renderer->AddActor(actorSplitted);

}

CloseOpenPolygons()

vtkSmartPointer< vtkPolyData > MyRenderer::CloseOpenPolygons

(

vtkSmartPointer< vtkPolyData >

polyData

)

CloseOpenPolygongs extracts the edges of the polyData and uses the vtkStripper which connects the edges with lines and generate polygons out of the lines to generate a set of Polygons which can be used to close the input polygonData It returns the set of polygons

Definition at line 361 of file MyRenderer.cpp.

{
    vtkSmartPointer<vtkDataSetMapper> clipMapper =
        vtkSmartPointer<vtkDataSetMapper>::New();
    clipMapper->SetInputData(polyData);

    vtkSmartPointer<vtkActor> clipActor =
        vtkSmartPointer<vtkActor>::New();
    clipActor->SetMapper(clipMapper);
    clipActor->GetProperty()->SetInterpolationToFlat();

    // Now extract feature edges
    vtkSmartPointer<vtkFeatureEdges> boundaryEdges =
        vtkSmartPointer<vtkFeatureEdges>::New();
    boundaryEdges->SetInputData(polyData);
    boundaryEdges->BoundaryEdgesOn();
    boundaryEdges->FeatureEdgesOff();
    boundaryEdges->NonManifoldEdgesOff();
    boundaryEdges->ManifoldEdgesOff();

    vtkSmartPointer<vtkStripper> boundaryStrips =
        vtkSmartPointer<vtkStripper>::New();
    boundaryStrips->SetInputConnection(boundaryEdges->GetOutputPort());
    boundaryStrips->Update();

    // Change the polylines into polygons
    vtkSmartPointer<vtkPolyData> boundaryPoly =
        vtkSmartPointer<vtkPolyData>::New();
    boundaryPoly->SetPoints(boundaryStrips->GetOutput()->GetPoints());
    boundaryPoly->SetPolys(boundaryStrips->GetOutput()->GetLines());

    return boundaryPoly;
}

ConnectInteractors()

void MyRenderer::ConnectInteractors

(

)

adds all actors of actorMap to the renderer and connects iren.

Definition at line 736 of file MyRenderer.cpp.

{
    renderWindow->AddRenderer(renderer.Get());

    for (auto val : actorMap.values())
        renderer->AddActor(val);

    iren->SetRenderWindow(renderWindow.GetPointer());

    if (!isSplitted)
    {
        vtkSmartPointer<KeyPressInteractorStyle> style =
            vtkSmartPointer<KeyPressInteractorStyle>::New();
        iren->SetInteractorStyle(style);
        style->SetCurrentRenderer(renderer);
        style->renderer = this;
        renderer->AddActor(clippingActor);
    }
}

CopyActor()

vtkSmartPointer< MyActor > MyRenderer::CopyActor	(	vtkSmartPointer< MyActor >	actor,
		QString	name
	)

returns a copy of the MyObject object with a given name. All information about the shaders is also copied

Definition at line 678 of file MyRenderer.cpp.

{

    vtkSmartPointer<vtkOpenGLPolyDataMapper> mapper = vtkSmartPointer<vtkOpenGLPolyDataMapper>::New();
    vtkSmartPointer<MyActor> actor;
    actor = CreateActor(GetStructureType(name));
    mapper->SetVertexShaderCode(reinterpret_cast<vtkOpenGLPolyDataMapper*>(from->GetMapper())->GetVertexShaderCode());
    mapper->SetFragmentShaderCode(reinterpret_cast<vtkOpenGLPolyDataMapper*>(from->GetMapper())->GetFragmentShaderCode());
    actor->SetMapper(mapper);
    actor->LinkCallback();
    return actor;

}

copyData()

void MyRenderer::copyData

(

MyRenderer *

renderer

)

copy the actor - data from the renderer to the renderer of the current object

Definition at line 756 of file MyRenderer.cpp.

{
    this->actorMap;

    for (auto key : renderer->actorMap.keys())
    {
        auto actor = renderer->actorMap.find(key).value();


        this->actorMap.insert(key, CopyActor(actor, key));
    }
    
    this->labeledPolydata = renderer->labeledPolydata;
}

References CopyActor().

CreateClippingPlane() [1/2]

void MyRenderer::CreateClippingPlane

(

vtkSmartPointer< vtkPlaneSource >

from

)

generates a new clippingPlaneSource with the same values as from

Definition at line 778 of file MyRenderer.cpp.

{
    clippingPlaneSource = vtkSmartPointer<vtkPlaneSource>::New();
    clippingPlaneSource->SetOrigin(from->GetOrigin());
    clippingPlaneSource->SetPoint1(from->GetPoint1());
    clippingPlaneSource->SetPoint2(from->GetPoint2());
    clippingPlaneSource->Update();
}

CreateClippingPlane() [2/2]

void MyRenderer::CreateClippingPlane

(

)

generates the ClippingPlaneSource with the default values

Definition at line 787 of file MyRenderer.cpp.

{
    
    vtkSmartPointer<vtkNamedColors> colors =
        vtkSmartPointer<vtkNamedColors>::New();

    clippingPlaneSource = vtkSmartPointer<vtkPlaneSource>::New();
    
    clippingPlaneSource->SetOrigin(-150, -150, 0.0);
    clippingPlaneSource->SetPoint1(150.0, -150.0, 0.0);
    clippingPlaneSource->SetPoint2(-150.0, 150.0, 0.0);

    clippingPlaneSource->Update();

        

    vtkPolyData* plane = clippingPlaneSource->GetOutput();

    // Create a mapper and actor
    vtkSmartPointer<vtkPolyDataMapper> mapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
    mapper->SetInputData(plane);

    vtkSmartPointer<vtkActor> actor =
        vtkSmartPointer<vtkActor>::New();
    actor->SetMapper(mapper);
    actor->GetProperty()->SetOpacity(0.4);
    actor->GetProperty()->SetColor(colors->GetColor3d("Cyan").GetData());

    clippingActor = actor;
    
}

FusePolygons()

vtkSmartPointer< vtkPolyData > MyRenderer::FusePolygons	(	vtkSmartPointer< vtkPolyData >	polyData1,
		vtkSmartPointer< vtkPolyData >	polyData2
	)

This function is used to combine two different vtkPolyData object which each other. It returns a new vtkPolyData object which contains the information of both input objects

Definition at line 344 of file MyRenderer.cpp.

{
    //Append the two meshes 
    vtkSmartPointer<vtkAppendPolyData> appendFilter =
        vtkSmartPointer<vtkAppendPolyData>::New();
    appendFilter->AddInputData(polyData1);
    appendFilter->AddInputData(polyData2);
    appendFilter->Update();

    // Remove any duplicate points.
    vtkSmartPointer<vtkCleanPolyData> cleanFilter =
        vtkSmartPointer<vtkCleanPolyData>::New();
    cleanFilter->SetInputConnection(appendFilter->GetOutputPort());
    cleanFilter->Update();
    return cleanFilter->GetOutput();
}

GetClippingPlane()

vtkSmartPointer<vtkPlaneSource> MyRenderer::GetClippingPlane ( )

inline

returns the clippingPlaneSource

Definition at line 189 of file MyRenderer.h.

{ return clippingPlaneSource; }

GetNormalOfClipping()

double* MyRenderer::GetNormalOfClipping ( )

inline

returns the normal of the clippingPlaneSource

Definition at line 184 of file MyRenderer.h.

{ return clippingPlaneSource->GetNormal(); }

GetOriginOfClipping()

double* MyRenderer::GetOriginOfClipping ( )

inline

returns the Origin of the clippingPlaneSource

Definition at line 179 of file MyRenderer.h.

{ return clippingPlaneSource->GetOrigin(); }

GetRenderer()

vtkSmartPointer<vtkRenderer> MyRenderer::GetRenderer ( ) const

inline

returns the current renderer

Definition at line 167 of file MyRenderer.h.

{ return renderer; }

GetRenderWindow()

vtkSmartPointer<vtkRenderWindow> MyRenderer::GetRenderWindow ( ) const

inline

Definition at line 157 of file MyRenderer.h.

{ return renderWindow; };

LinkLabelToShader()

void MyRenderer::LinkLabelToShader	(	int	label,
		QString	name,
		vtkSmartPointer< MyShaderCallback >	callback = 0
	)

links the polydata in labeledPolydata with key label to the actor in actorMap of key name and sets a custom callback if callback is not null. if no callback is given, default callback will be set, which depends on class of actor.

Definition at line 704 of file MyRenderer.cpp.

{
    auto entry = actorMap.find(name);
    if (entry == actorMap.end())
    {
        qDebug() << "no " << name << " shader defined.";
        return;
    }

    auto dataEntry = labeledPolydata.find(label);
    if (dataEntry == labeledPolydata.end())
    {
        qDebug() << "no structure of label " << QString::number(label) << " found.";
        return;
    }

    vtkSmartPointer<MyActor> actor = entry.value();

    actor->LinkRenderer(renderer);
    actor->LinkPolydata(dataEntry.value());
    actor->LinkCallback(callback);
}

LoadPolydataFromFile()

void MyRenderer::LoadPolydataFromFile	(	const char *	filename,
		vtkMatrix4x4 *	viewMatrix = NULL
	)

loads the polydata from file and fills the labeledPolydata map

Definition at line 503 of file MyRenderer.cpp.

{
    vtkSmartPointer<vtkGenericDataObjectReader> reader =
        vtkSmartPointer<vtkGenericDataObjectReader>::New();
    reader->SetFileName(filename);
    reader->Update();

    if (reader->IsFilePolyData())
    {
        vtkPolyData* output = reader->GetPolyDataOutput();
        completeData = reader->GetPolyDataOutput();


        // translating the polydata to the center of mass to allow easier clipping
        vtkSmartPointer<vtkCenterOfMass> centerOfMassFilter =
            vtkSmartPointer<vtkCenterOfMass>::New();
        centerOfMassFilter->SetInputData(output);

        centerOfMassFilter->SetUseScalarsAsWeights(false);
        centerOfMassFilter->Update();

        double center[3];
        centerOfMassFilter->GetCenter(center);


        vtkSmartPointer<vtkTransform> translation =
            vtkSmartPointer<vtkTransform>::New();

        translation->Translate(-center[0], -center[1], -center[2]);

        vtkSmartPointer<vtkTransformPolyDataFilter> transformFilterPoly =
            vtkSmartPointer<vtkTransformPolyDataFilter>::New();
        transformFilterPoly->AddInputData(output);
        transformFilterPoly->SetTransform(translation);
        transformFilterPoly->Update();

        output = transformFilterPoly->GetOutput();



        auto polys = output->GetPolys();
        vtkSmartPointer<vtkIdList> pts = vtkSmartPointer<vtkIdList>::New();

        int idx = 0;
        auto labels = output->GetCellData()->GetArray(0);
        qDebug() << "output has " << labels->GetSize() << " labels.";
        int mlabel = 2;

        vtkSmartPointer<vtkCellArray> carr;

        QMap<int, vtkSmartPointer<vtkCellArray>> carrs;

        while (polys->GetNextCell(pts))
        {
            int lbl = labels->GetComponent(idx++, 0);

            auto entry = carrs.find(lbl);
            if (entry == carrs.end())
            {

                qDebug() << "creating new entry for label " << lbl;
                carr = vtkSmartPointer<vtkCellArray>::New();
                carrs.insert(lbl, carr);

            }
            else
            {
                carr = entry.value();
            }

            int a = pts->GetId(0);
            int b = pts->GetId(1);
            int c = pts->GetId(2);
            carr->InsertNextCell(3);
            carr->InsertCellPoint(pts->GetId(0));
            carr->InsertCellPoint(pts->GetId(1));
            carr->InsertCellPoint(pts->GetId(2));

        }


        for (int key : carrs.keys())
        {
            vtkSmartPointer<vtkPolyData> c = vtkSmartPointer<vtkPolyData>::New();
            c->DeepCopy(output);
            c->SetPolys(carrs.find(key).value());

            if (!isSplitted)
                labeledPolydata.insert(key, c);
            else
            {
                labeledPolydataSplitted.insert(key, c);
                SplitPolygon(key);
            }
        }

    }
}

References SplitPolygon().

LoadShaders()

void MyRenderer::LoadShaders

(

QString

path

)

loads shaders from directory path and fills actorMap. if custom class exists for some shader name (i.e. "context", ...) custom actor class will be used. MyActor is used otherwise.

Definition at line 602 of file MyRenderer.cpp.

{
    QDir dir(path);
    foreach(const QFileInfo &info, dir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot)) {
        if (info.isFile()) {

            qDebug() << info.fileName();
            qDebug() << info.filePath();
            qDebug() << info.suffix();

            ShaderType type = GetShaderType(info.suffix());
            QString name = info.fileName().mid(0, info.fileName().length() - info.suffix().length() - 1);

            // compile shader code
            std::string code;
            filehandling::readFromFile(info.filePath().toUtf8(), code);

            vtkSmartPointer<vtkOpenGLPolyDataMapper> mapper;
            vtkSmartPointer<MyActor> actor;

            auto entry = actorMap.find(name);
            if (entry == actorMap.end()) {
                qDebug() << "no actor for " << name << " exists. creating new.";

                mapper = vtkSmartPointer<vtkOpenGLPolyDataMapper>::New();
                actor = CreateActor(GetStructureType(name));
                actor->SetMapper(mapper);
                actor->LinkCallback();
                actorMap.insert(name, actor);
            }
            else
            {
                qDebug() << "adding code to " << name << ".";
                actor = entry.value();
                mapper = reinterpret_cast<vtkOpenGLPolyDataMapper*>(actor->GetMapper());
            }

            switch (type)
            {
            case VERTEX_SHADER:
                mapper->SetVertexShaderCode(code.c_str());
                qDebug() << "added shader type " << type;
                break;
            case FRAGMENT_SHADER:
                mapper->SetFragmentShaderCode(code.c_str());
                qDebug() << "added shader type " << type;
                break;
            default:
                qDebug() << "Invalid shader type " << type;
                break;
            }

        }
        else {
            qDebug() << "Unhandled item" << info.filePath();
        }
    }
}

References filehandling::readFromFile().

SetCameraProperties()

void MyRenderer::SetCameraProperties	(	double	cameraPosition[3] = CAMERAPOSITION,
		double	focalPoint[3] = FOCALPOINT,
		double	viewUp[3] = CAMERAVIEWUP,
		double	zoom = ZOOM
	)

Sets the camera properties for the current window

Definition at line 727 of file MyRenderer.cpp.

{
    renderer->GetActiveCamera()->SetPosition(cameraPosition);
    renderer->GetActiveCamera()->SetFocalPoint(focalPoint);
    renderer->GetActiveCamera()->SetViewUp(viewUp);
    renderer->ResetCamera();
    renderer->GetActiveCamera()->Zoom(zoom);
}

SetDefaults()

void MyRenderer::SetDefaults

(

)

Sets the properties of the current renderer / windows (for example the size of the window or the background)

Definition at line 661 of file MyRenderer.cpp.

{
    renderer->SetBackground(BACKGROUNDCOLOR);
    renderWindow->SetSize(RENDERWINDOWSIZE);
    SetCameraProperties();
    renderer->GradientBackgroundOn();
}

References SetCameraProperties().

SetShadingProperties()

void MyRenderer::SetShadingProperties

(

)

calls SetProperties for all actors and sets defaults also for renderer, i.e. camera stuff and light.

Definition at line 670 of file MyRenderer.cpp.

{

    for (auto val : actorMap.values())
        val->SetProperties();

}

showTargetStructure()

void MyRenderer::showTargetStructure	(	int	keyTargetStructure,
		int	keyRiskStructure
	)

This function is used to show the target-structure actors. If the current visualization is not clipped the target structure is colored from red to white, depending on the distance with additionally black lines at the distance 10, 20, 30mm.... If the view is clipped the target structure is shown two times. One time the unclipped target structure in grey, but with the distance lines And one time time clipped target structure colored from red to white.

Definition at line 194 of file MyRenderer.cpp.

{

    if (!isSplitted)
        claculateDistanceToActor(keyTargetStructure, keyRiskStructure);
    else
    {
        claculateDistanceToActor(keyTargetStructure, keyRiskStructure, true);
        claculateDistanceToActor(keyTargetStructure, keyRiskStructure, false, true);
    }

}

References claculateDistanceToActor().

SplitPolygon()

vtkSmartPointer< vtkPolyData > MyRenderer::SplitPolygon	(	int	actorID,
		bool	safeToPolyDataMap = true
	)

SplitPolygon splits the PolygonData according to the configured clippingPlaneSource. If the flag safeToPolyDataMap is set to true the splitted polyData is added to labeledPolydata map

Definition at line 398 of file MyRenderer.cpp.

{
    auto input1 = labeledPolydata.value(actorID);

    auto closedBasePoly = CloseOpenPolygons(input1);
    input1 = FusePolygons(input1, closedBasePoly);


    vtkSmartPointer<vtkCleanPolyData> clean1 =
        vtkSmartPointer<vtkCleanPolyData>::New();
    clean1->SetInputData(input1);

    QList<vtkSmartPointer<vtkPolyData>> polydataList;

    for (int i = 0; i < 2; ++i)
    {

        vtkSmartPointer<vtkClipPolyData> clip =
            vtkSmartPointer<vtkClipPolyData>::New();
        clip->SetValue(0);
        clip->GenerateClippedOutputOn();
        clip->SetInputConnection(clean1->GetOutputPort());
        vtkSmartPointer<vtkPlane> plane =
            vtkSmartPointer<vtkPlane>::New();
        plane->SetOrigin(clippingPlaneSource->GetOrigin());

        

        double * n = clippingPlaneSource->GetNormal();
        if (i > 0)
            plane->SetNormal(-n[0], -n[1], -n[2]);
        else
            plane->SetNormal(n[0], n[1], n[2]);
        

        clip->SetClipFunction(plane);
        clip->SetValue(0);
        clip->Update();

        vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
        vtkSmartPointer<vtkPolyData> boundaryPoly = vtkSmartPointer<vtkPolyData>::New();

        polyData = clip->GetOutput();

        if (polyData->GetNumberOfPolys() == 0)
        {
            if (i == 0)
            {
                continue;
            }
            break;
        }

    

        boundaryPoly = CloseOpenPolygons(polyData);

        vtkSmartPointer<vtkTransform> translation =
            vtkSmartPointer<vtkTransform>::New();
        if (i > 0)
        {
            translation->Translate(-60*n[0], -60*n[1], -60*n[2]);
            //translation->RotateY(-40.0);
            //translation->RotateWXYZ(-40, n[0], -60 * n[1], -60 * n[2]);
        }
        else
        {
            translation->Translate(60 * n[0], 60 * n[1], 60 * n[2]);
            //translation->RotateY(40.0);
            //translation->RotateWXYZ(40, n[0], -60 * n[1], -60 * n[2]);
        }

        vtkSmartPointer<vtkTransformPolyDataFilter> transformFilterPoly =
            vtkSmartPointer<vtkTransformPolyDataFilter>::New();
        transformFilterPoly->AddInputData(polyData);
        transformFilterPoly->SetTransform(translation);
        transformFilterPoly->Update();


        vtkSmartPointer<vtkTransformPolyDataFilter> transformFilterBoundary =
            vtkSmartPointer<vtkTransformPolyDataFilter>::New();
        transformFilterBoundary->AddInputData(boundaryPoly);
        transformFilterBoundary->SetTransform(translation);
        transformFilterBoundary->Update();

        polydataList.append(transformFilterPoly->GetOutput());
        polydataList.append(transformFilterBoundary->GetOutput());
    }

    vtkSmartPointer<vtkPolyData> currentPoly = 
        vtkSmartPointer<vtkPolyData>::New();

    for (vtkSmartPointer<vtkPolyData> poly : polydataList)
    {

        currentPoly = FusePolygons(currentPoly, poly);
    }

    if (safeToPolyDataMap)
        labeledPolydata.insert(actorID, currentPoly);

    return currentPoly;
}

References CloseOpenPolygons(), and FusePolygons().

SplitPolygons()

void MyRenderer::SplitPolygons

(

)

makes a copy of the labeledPolydata - map which is needed in order to perform clipping properly and stores it in the labeledPolydataSplitted - map

Definition at line 692 of file MyRenderer.cpp.

{
    for (int key : labeledPolydata.keys())
    {
        vtkSmartPointer<vtkPolyData> c = vtkSmartPointer<vtkPolyData>::New();
        c->DeepCopy(labeledPolydata.find(key).value());
        labeledPolydataSplitted.insert(key, c);
        SplitPolygon(key);
    }

}

References SplitPolygon().

UpdateClippingPlane() [1/2]

void MyRenderer::UpdateClippingPlane

(

double

normal[3]

)

updates the normal of the ClippingPlaneSource

UpdateClippingPlane() [2/2]

void MyRenderer::UpdateClippingPlane

(

double

step

)

moves the clipping plan by the value step in the direction of the normal vector

Definition at line 820 of file MyRenderer.cpp.

{
    clippingPlaneSource->Push(step);
    clippingPlaneSource->Update();
    reinterpret_cast<vtkOpenGLPolyDataMapper*>(clippingActor->GetMapper())->SetInputData(clippingPlaneSource->GetOutput());
}

---

The documentation for this class was generated from the following files:

• C:/PelVis/src/MyRenderer.h
• C:/PelVis/src/MyRenderer.cpp