Exemplo n.º 1
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkImplicitTextureCoords(), 'Processing.',
         ('vtkDataSet',), ('vtkDataSet',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Exemplo n.º 2
0
def main():
    colors = vtk.vtkNamedColors()

    renWin = vtk.vtkRenderWindow()

    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    aren = vtk.vtkRenderer()

    # define two elliptical cylinders
    quadric1 = vtk.vtkQuadric()
    quadric1.SetCoefficients(1, 2, 0, 0, 0, 0, 0, 0, 0, -.07)

    quadric2 = vtk.vtkQuadric()
    quadric2.SetCoefficients(2, 1, 0, 0, 0, 0, 0, 0, 0, -.07)

    # Create a sphere for all to use.
    aSphere = vtk.vtkSphereSource()
    aSphere.SetPhiResolution(21)
    aSphere.SetThetaResolution(21)

    # Create texture coordinates for all.
    tcoords = vtk.vtkImplicitTextureCoords()
    tcoords.SetInputConnection(aSphere.GetOutputPort())
    tcoords.SetRFunction(quadric1)
    tcoords.SetSFunction(quadric2)

    aMapper = vtk.vtkDataSetMapper()
    aMapper.SetInputConnection(tcoords.GetOutputPort())

    # Create a mapper, sphere and texture map for each case.
    for i in range(0, 16):
        aBoolean = MakeBooleanTexture(i, 64, 0)

        aTexture2 = vtk.vtkTexture()
        aTexture2.SetInputConnection(aBoolean.GetOutputPort())
        aTexture2.InterpolateOff()
        aTexture2.RepeatOff()

        anActor2 = vtk.vtkActor()

        anActor2.SetMapper(aMapper)
        anActor2.SetTexture(aTexture2)
        anActor2.SetPosition(positions[i])
        anActor2.SetScale(2.0, 2.0, 2.0)
        anActor2.GetProperty().SetColor(colors.GetColor3d('MistyRose'))
        aren.AddActor(anActor2)

    aren.SetBackground(colors.GetColor3d('SlateGray'))
    renWin.SetSize(500, 500)
    renWin.AddRenderer(aren)
    renWin.SetWindowName('TextureCutQuadric')

    # Interact with the data.
    renWin.Render()

    iren.Start()
Exemplo n.º 3
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkImplicitTextureCoords(),
                                       'Processing.', ('vtkDataSet', ),
                                       ('vtkDataSet', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
Exemplo n.º 4
0
planes.SetNormals(norms)
# texture
texReader = vtk.vtkStructuredPointsReader()
texReader.SetFileName("" + str(VTK_DATA_ROOT) + "/Data/texThres2.vtk")
texture = vtk.vtkTexture()
texture.SetInputConnection(texReader.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()
# read motor parts...each part colored separately
#
byu = vtk.vtkBYUReader()
byu.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/motor.g")
byu.SetPartNumber(1)
normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(byu.GetOutputPort())
tex1 = vtk.vtkImplicitTextureCoords()
tex1.SetInputConnection(normals.GetOutputPort())
tex1.SetRFunction(planes)
#    tex1 FlipTextureOn
byuMapper = vtk.vtkDataSetMapper()
byuMapper.SetInputConnection(tex1.GetOutputPort())
byuActor = vtk.vtkActor()
byuActor.SetMapper(byuMapper)
byuActor.SetTexture(texture)
byuActor.GetProperty().SetColor(cold_grey)
byu2 = vtk.vtkBYUReader()
byu2.SetGeometryFileName("" + str(VTK_DATA_ROOT) + "/Data/motor.g")
byu2.SetPartNumber(2)
normals2 = vtk.vtkPolyDataNormals()
normals2.SetInputConnection(byu2.GetOutputPort())
tex2 = vtk.vtkImplicitTextureCoords()
Exemplo n.º 5
0
texReader.SetFileName(VTK_DATA_ROOT + "/Data/texThres2.vtk")
texture = vtk.vtkTexture()
texture.SetInputConnection(texReader.GetOutputPort())
texture.InterpolateOff()
texture.RepeatOff()

# read motor parts...each part colored separately
#
byu = vtk.vtkBYUReader()
byu.SetGeometryFileName(VTK_DATA_ROOT + "/Data/motor.g")
byu.SetPartNumber(1)

normals = vtk.vtkPolyDataNormals()
normals.SetInputConnection(byu.GetOutputPort())

tex1 = vtk.vtkImplicitTextureCoords()
tex1.SetInputConnection(normals.GetOutputPort())
tex1.SetRFunction(planes)
# tex1.FlipTextureOn()

byuMapper = vtk.vtkDataSetMapper()
byuMapper.SetInputConnection(tex1.GetOutputPort())

byuActor = vtk.vtkActor()
byuActor.SetMapper(byuMapper)
byuActor.SetTexture(texture)
byuActor.GetProperty().SetColor(GetRGBColor('cold_grey'))

byu2 = vtk.vtkBYUReader()
byu2.SetGeometryFileName(VTK_DATA_ROOT + "/Data/motor.g")
byu2.SetPartNumber(2)
Exemplo n.º 6
0
    def testQuadricCut(self):

        solidTexture = (255, 255)
        clearTexture = (255, 0)
        edgeTexture = (0, 255)

        def makeBooleanTexture(caseNumber, resolution, thickness):
            #global solidTexture, clearTexture, edgeTexture
            booleanTexturecaseNumber = vtk.vtkBooleanTexture()

            booleanTexturecaseNumber.SetXSize(resolution)
            booleanTexturecaseNumber.SetYSize(resolution)
            booleanTexturecaseNumber.SetThickness(thickness)

            if caseNumber == 0:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(solidTexture)
                booleanTexturecaseNumber.SetOnIn(solidTexture)
                booleanTexturecaseNumber.SetOnOut(solidTexture)
                booleanTexturecaseNumber.SetInOn(solidTexture)
                booleanTexturecaseNumber.SetOutOn(solidTexture)
            elif caseNumber == 1:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(solidTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
            elif caseNumber == 2:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(solidTexture)
                booleanTexturecaseNumber.SetInOn(solidTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 3:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(clearTexture)
                booleanTexturecaseNumber.SetOnOut(solidTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 4:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(solidTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(solidTexture)
            elif caseNumber == 5:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(clearTexture)
                booleanTexturecaseNumber.SetOutOn(solidTexture)
            elif caseNumber == 6:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 7:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutOut(solidTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(clearTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(clearTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 8:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(solidTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(solidTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 9:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 10:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(solidTexture)
                booleanTexturecaseNumber.SetOutOn(clearTexture)
            elif caseNumber == 11:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(solidTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(clearTexture)
                booleanTexturecaseNumber.SetOnOut(edgeTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(clearTexture)
            elif caseNumber == 12:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(solidTexture)
                booleanTexturecaseNumber.SetOnOut(clearTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 13:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutIn(solidTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(clearTexture)
                booleanTexturecaseNumber.SetInOn(clearTexture)
                booleanTexturecaseNumber.SetOutOn(edgeTexture)
            elif caseNumber == 14:
                booleanTexturecaseNumber.SetInIn(solidTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(edgeTexture)
                booleanTexturecaseNumber.SetOnIn(edgeTexture)
                booleanTexturecaseNumber.SetOnOut(clearTexture)
                booleanTexturecaseNumber.SetInOn(edgeTexture)
                booleanTexturecaseNumber.SetOutOn(clearTexture)
            elif caseNumber == 15:
                booleanTexturecaseNumber.SetInIn(clearTexture)
                booleanTexturecaseNumber.SetInOut(clearTexture)
                booleanTexturecaseNumber.SetOutIn(clearTexture)
                booleanTexturecaseNumber.SetOutOut(clearTexture)
                booleanTexturecaseNumber.SetOnOn(clearTexture)
                booleanTexturecaseNumber.SetOnIn(clearTexture)
                booleanTexturecaseNumber.SetOnOut(clearTexture)
                booleanTexturecaseNumber.SetInOn(clearTexture)
                booleanTexturecaseNumber.SetOutOn(clearTexture)


            booleanTexturecaseNumber.Update()
            return booleanTexturecaseNumber

        # A list of positions
        positions = []
        positions.append((-4, 4, 0))
        positions.append((-2, 4, 0))
        positions.append((0, 4, 0))
        positions.append((2, 4, 0))
        positions.append((-4, 2, 0))
        positions.append((-2, 2, 0))
        positions.append((0, 2, 0))
        positions.append((2, 2, 0))
        positions.append((-4, 0, 0))
        positions.append((-2, 0, 0))
        positions.append((0, 0, 0))
        positions.append((2, 0, 0))
        positions.append((-4, -2, 0))
        positions.append((-2, -2, 0))
        positions.append((0, -2, 0))
        positions.append((2, -2, 0))

        ren = vtk.vtkRenderer()
        renWin = vtk.vtkRenderWindow()
        renWin.AddRenderer(ren)

        # define two elliptical cylinders
        quadric1 = vtk.vtkQuadric()
        quadric1.SetCoefficients(1, 2, 0, 0, 0, 0, 0, 0, 0, -.07)

        quadric2 = vtk.vtkQuadric()
        quadric2.SetCoefficients(2, 1, 0, 0, 0, 0, 0, 0, 0, -.07)

        # create a sphere for all to use
        aSphere = vtk.vtkSphereSource()
        aSphere.SetPhiResolution(50)
        aSphere.SetThetaResolution(50)

        # create texture coordinates for all
        tcoords = vtk.vtkImplicitTextureCoords()
        tcoords.SetInputConnection(aSphere.GetOutputPort())
        tcoords.SetRFunction(quadric1)
        tcoords.SetSFunction(quadric2)

        aMapper = vtk.vtkDataSetMapper()
        aMapper.SetInputConnection(tcoords.GetOutputPort())

        # create a mapper, sphere and texture map for each case
        aTexture = []
        anActor = []
        for i in range(0, 16):
            aTexture.append(vtk.vtkTexture())
            aTexture[i].SetInputData(makeBooleanTexture(i, 256, 1).GetOutput())
            aTexture[i].InterpolateOff()
            aTexture[i].RepeatOff()
            anActor.append(vtk.vtkActor())
            anActor[i].SetMapper(aMapper)
            anActor[i].SetTexture(aTexture[i])
            anActor[i].SetPosition(positions[i])
            anActor[i].SetScale(2.0, 2.0, 2.0)
            ren.AddActor(anActor[i])


        ren.SetBackground(0.4392, 0.5020, 0.5647)
        ren.ResetCamera()
        ren.GetActiveCamera().Zoom(1.4)
        renWin.SetSize(500, 500)

        # render and interact with data

        iRen = vtk.vtkRenderWindowInteractor()
        iRen.SetRenderWindow(renWin);
        renWin.Render()

        img_file = "quadricCut.png"
        vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25)
        vtk.test.Testing.interact()
Exemplo n.º 7
0
def main():
    colors = vtk.vtkNamedColors()

    textureFile, motorFile = get_program_parameters()

    # Create the Renderer, RenderWindow and RenderWindowInteractor.
    ren = vtk.vtkRenderer()
    renWin = vtk.vtkRenderWindow()
    renWin.AddRenderer(ren)
    iren = vtk.vtkRenderWindowInteractor()
    iren.SetRenderWindow(renWin)

    # Create the cutting planes.
    planes = vtk.vtkPlanes()
    points = vtk.vtkPoints()
    norms = vtk.vtkFloatArray()

    norms.SetNumberOfComponents(3)
    points.InsertPoint(0, 0.0, 0.0, 0.0)
    norms.InsertTuple3(0, 0.0, 0.0, 1.0)
    points.InsertPoint(1, 0.0, 0.0, 0.0)
    norms.InsertTuple3(1, -1.0, 0.0, 0.0)
    planes.SetPoints(points)
    planes.SetNormals(norms)

    # Get the texture.
    texReader = vtk.vtkStructuredPointsReader()
    texReader.SetFileName(textureFile)
    texture = vtk.vtkTexture()
    texture.SetInputConnection(texReader.GetOutputPort())
    texture.InterpolateOff()
    texture.RepeatOff()

    # Set up the pipelines for the parts of the motor.
    # We will use lists of pipeline objects.
    numberOfParts = 5
    byu = list()
    normals = list()
    tex = list()
    byuMapper = list()
    byuActor = list()
    partColours = [
        'cold_grey', 'peacock', 'raw_sienna', 'banana', 'peach_puff'
    ]
    # Use this to control which parts to display.
    displayParts = [True] * numberOfParts
    # If displayParts[2] = False then an image like that in the VTK tests is produced.

    # Build the pipelines.
    for i in range(0, numberOfParts):
        byu.append(vtk.vtkBYUReader())
        byu[i].SetGeometryFileName(motorFile)
        byu[i].SetPartNumber(i + 1)

        normals.append(vtk.vtkPolyDataNormals())
        normals[i].SetInputConnection(byu[i].GetOutputPort())

        tex.append(vtk.vtkImplicitTextureCoords())
        tex[i].SetInputConnection(normals[i].GetOutputPort())
        tex[i].SetRFunction(planes)
        # tex[i].FlipTextureOn()

        byuMapper.append(vtk.vtkDataSetMapper())
        byuMapper[i].SetInputConnection(tex[i].GetOutputPort())

        byuActor.append(vtk.vtkActor())
        byuActor[i].SetMapper(byuMapper[i])
        byuActor[i].SetTexture(texture)
        byuActor[i].GetProperty().SetColor(colors.GetColor3d(partColours[i]))

        ren.AddActor(byuActor[i])
        if displayParts[i]:
            byuActor[i].VisibilityOn()
        else:
            byuActor[i].VisibilityOff()

    ren.SetBackground(colors.GetColor3d('AliceBlue'))

    renWin.SetSize(512, 512)
    renWin.SetWindowName('Motor')

    camera = vtk.vtkCamera()
    camera.SetFocalPoint(0.0286334, 0.0362996, 0.0379685)
    camera.SetPosition(1.37067, 1.08629, -1.30349)
    camera.SetViewAngle(17.673)
    camera.SetClippingRange(1, 10)
    camera.SetViewUp(-0.376306, -0.5085, -0.774482)
    ren.SetActiveCamera(camera)

    # Render the image.
    iren.Initialize()
    iren.Start()
Exemplo n.º 8
0
def main():
    colors = vtk.vtkNamedColors()

    fileName = get_program_parameters()

    # hidden sphere
    sphere1 = vtk.vtkSphereSource()
    sphere1.SetRadius(0.5)

    innerMapper = vtk.vtkPolyDataMapper()
    innerMapper.SetInputConnection(sphere1.GetOutputPort())

    innerSphere = vtk.vtkActor()
    innerSphere.SetMapper(innerMapper)
    innerSphere.GetProperty().SetColor(colors.GetColor3d('BlanchedAlmond'))

    # sphere to texture
    sphere2 = vtk.vtkSphereSource()
    sphere2.SetRadius(1.0)
    sphere2.SetPhiResolution(21)
    sphere2.SetThetaResolution(21)

    pts = [0.0] * 6
    points = vtk.vtkPoints()
    points.SetNumberOfPoints(2)
    points.SetPoint(0, pts[:3])
    points.SetPoint(1, pts[3:])

    nrms = [0.0] * 6
    nrms[0] = 1.0
    nrms[4] = 1.0
    normals = vtk.vtkDoubleArray()
    normals.SetNumberOfComponents(3)
    normals.SetNumberOfTuples(2)
    normals.SetTuple(0, nrms[:3])
    normals.SetTuple(1, nrms[3:])

    planes = vtk.vtkPlanes()
    planes.SetPoints(points)
    planes.SetNormals(normals)

    tcoords = vtk.vtkImplicitTextureCoords()
    tcoords.SetInputConnection(sphere2.GetOutputPort())
    tcoords.SetRFunction(planes)

    outerMapper = vtk.vtkDataSetMapper()
    outerMapper.SetInputConnection(tcoords.GetOutputPort())

    tmap = vtk.vtkStructuredPointsReader()
    tmap.SetFileName(fileName)

    texture = vtk.vtkTexture()
    texture.SetInputConnection(tmap.GetOutputPort())
    texture.InterpolateOff()
    texture.RepeatOff()

    outerSphere = vtk.vtkActor()
    outerSphere.SetMapper(outerMapper)
    outerSphere.SetTexture(texture)
    outerSphere.GetProperty().SetColor(colors.GetColor3d('LightSalmon'))

    renWin = vtk.vtkRenderWindow()
    iren = vtk.vtkRenderWindowInteractor()
    aren = vtk.vtkRenderer()
    iren.SetRenderWindow(renWin)
    renWin.AddRenderer(aren)

    aren.AddActor(innerSphere)
    aren.AddActor(outerSphere)
    aren.SetBackground(colors.GetColor3d('SlateGray'))
    aren.GetActiveCamera().Azimuth(-30)
    aren.GetActiveCamera().Elevation(-30)
    aren.ResetCamera()

    renWin.SetSize(500, 500)
    renWin.SetWindowName('TextureCutSphere')

    # interact with data
    renWin.Render()

    iren.Initialize()
    iren.Start()