# OverlappingAMR

VTKExamples/Python/CompositeData/OverlappingAMR

Other Languages

See (Cxx)

### Code

OverlappingAMR.py

    #!/usr/bin/env python
    import vtk

    def MakeScalars(dims, origin, spacing, scalars):
        # Implicit function used to compute scalars
        sphere = vtk.vtkSphere()
        sphere.SetRadius(3)
        sphere.SetCenter(5, 5, 5)
        scalars.SetNumberOfTuples(dims[0]*dims[1]*dims[2])
        for k in range(0, dims[2]):
            z = origin[2] + spacing[2]*k
            for j in range(0, dims[1]):
                y = origin[1] + spacing[1]*j
                for i in range(0,dims[0]):
                    x = origin[0] + spacing[0]*i
                    scalars.SetValue(k*dims[0]*dims[1] + j*dims[0] + i, sphere.EvaluateFunction(x, y, z))

    def main():
        # Create and populate the AMR dataset
        # The dataset should look like
        # Level 0
        #   uniform grid, dimensions 11, 11, 11, AMR box (0, 0, 0) - (9, 9, 9)
        # Level 1 - refinement ratio : 2
        #   uniform grid, dimensions 11, 11, 11, AMR box (0, 0, 0) - (9, 9, 9)
        #   uniform grid, dimensions 11, 11, 11, AMR box (10, 10, 10) - (19, 19, 19)
        # Use MakeScalars() above to fill the scalar arrays

        amr = vtk.vtkOverlappingAMR()
        blocksPerLevel = [1, 2]
        amr.Initialize(2, blocksPerLevel)

        origin = [0.0, 0.0, 0.0]
        spacing = [1.0, 1.0, 1.0]
        dims = [11, 11, 11]

        ug1 = vtk.vtkUniformGrid()
        # Geometry
        ug1.SetOrigin(origin)
        ug1.SetSpacing(spacing)
        ug1.SetDimensions(dims)

        # Data
        scalars = vtk.vtkFloatArray()
        ug1.GetPointData().SetScalars(scalars)
        MakeScalars(dims, origin, spacing, scalars)

        lo = [0, 0, 0]
        hi = [9, 9, 9]
        box1 = vtk.vtkAMRBox()
        amr.SetAMRBox(0, 0, box1)
        amr.SetDataSet(0, 0, ug1)

        spacing2 = [0.5, 0.5, 0.5]
        ug2 = vtk.vtkUniformGrid()
        # Geometry
        ug2.SetOrigin(origin)
        ug2.SetSpacing(spacing2)
        ug2.SetDimensions(dims)

        # Data
        scalars = vtk.vtkFloatArray()
        ug2.GetPointData().SetScalars(scalars)
        MakeScalars(dims, origin, spacing2, scalars)

        lo2 = [0, 0, 0]
        hi2 = [9, 9, 9]
        box2 = vtk.vtkAMRBox()
        amr.SetAMRBox(1, 0, box2)
        amr.SetDataSet(1, 0, ug2)

        origin3 = [5, 5, 5]
        ug3 = vtk.vtkUniformGrid()

        # Geometry
        ug3.SetOrigin(origin3)
        ug3.SetSpacing(spacing2)
        ug3.SetDimensions(dims)

        # Data
        scalars = vtk.vtkFloatArray()
        ug3.GetPointData().SetScalars(scalars)
        MakeScalars(dims, origin3, spacing2, scalars)

        lo3 = [10, 10, 10]
        hi3 = [19, 19, 19]
        box3 = vtk.vtkAMRBox()
        amr.SetAMRBox(1, 1, box3)
        amr.SetDataSet(1, 1, ug3)
        amr.SetRefinementRatio(0, 2)

        # Render the amr data here.
        of = vtk.vtkOutlineFilter()
        of.SetInputData(amr)

        geomFilter = vtk.vtkCompositeDataGeometryFilter()
        geomFilter.SetInputConnection(of.GetOutputPort())

        # Create an iso-surface - at 10.
        cf = vtk.vtkContourFilter()
        cf.SetInputData(amr)
        cf.SetNumberOfContours(1)
        cf.SetValue(0, 10.0)

        geomFilter2 = vtk.vtkCompositeDataGeometryFilter()
        geomFilter2.SetInputConnection(cf.GetOutputPort())

        # Create the render window, renderer, and interactor.
        aren =  vtk.vtkRenderer()
        renWin  = vtk.vtkRenderWindow()
        renWin.AddRenderer(aren)

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

        # Associate the geometry with a mapper and the mapper to an actor.
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(geomFilter.GetOutputPort())
        actor1 = vtk.vtkActor()
        actor1.SetMapper(mapper)

        # Associate the geometry with a mapper and the mapper to an actor.
        mapper2 = vtk.vtkPolyDataMapper()
        mapper2.SetInputConnection(geomFilter2.GetOutputPort())
        actor2 = vtk.vtkActor()
        actor2.SetMapper(mapper2)

        # Add the actor to the renderer and start handling events.
        aren.AddActor(actor1)
        aren.AddActor(actor2)
        renWin.Render()
        iren.Start()

    if __name__ == '__main__':
        main()