# SGrid

VTKExamples/Cxx/StructuredGrid/SGrid

### Code

SGrid.cxx

    // This example shows how to manually create a structured grid.
    // The basic idea is to instantiate vtkStructuredGrid, set its dimensions,
    // and then assign points defining the grid coordinate. The number of
    // points must equal the number of points implicit in the dimensions
    // (i.e., dimX*dimY*dimZ). Also, data attributes (either point or cell)
    // can be added to the dataset.
    //
    //
    #include <vtkActor.h>
    #include <vtkCamera.h>
    #include <vtkDoubleArray.h>
    #include <vtkHedgeHog.h>
    #include <vtkMath.h>
    #include <vtkNamedColors.h>
    #include <vtkPointData.h>
    #include <vtkPoints.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkProperty.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkRenderer.h>
    #include <vtkStructuredGrid.h>

    int main(int, char *[])
    {
      int i, j, k, kOffset, jOffset, offset;
      double x[3], v[3], rMin=0.5, rMax=1.0, deltaRad, deltaZ;
      double radius, theta;
      static int dims[3]={13,11,11};

      // Create the structured grid.
      vtkSmartPointer<vtkStructuredGrid> sgrid =
        vtkSmartPointer<vtkStructuredGrid>::New();
      sgrid->SetDimensions(dims);

      // We also create the points and vectors. The points
      // form a hemi-cylinder of data.
      vtkSmartPointer<vtkDoubleArray> vectors =
        vtkSmartPointer<vtkDoubleArray>::New();
      vectors->SetNumberOfComponents(3);
      vectors->SetNumberOfTuples(dims[0]*dims[1]*dims[2]);
      vtkSmartPointer<vtkPoints> points =
        vtkSmartPointer<vtkPoints>::New();
      points->Allocate(dims[0]*dims[1]*dims[2]);

      deltaZ = 2.0 / (dims[2]-1);
      deltaRad = (rMax-rMin) / (dims[1]-1);
      v[2]=0.0;
      for ( k=0; k<dims[2]; k++)
      {
        x[2] = -1.0 + k*deltaZ;
        kOffset = k * dims[0] * dims[1];
        for (j=0; j<dims[1]; j++)
        {
          radius = rMin + j*deltaRad;
          jOffset = j * dims[0];
          for (i=0; i<dims[0]; i++)
          {
            theta = i * vtkMath::RadiansFromDegrees(15.0);
            x[0] = radius * cos(theta);
            x[1] = radius * sin(theta);
            v[0] = -x[1];
            v[1] = x[0];
            offset = i + jOffset + kOffset;
            points->InsertPoint(offset,x);
            vectors->InsertTuple(offset,v);
          }
        }
      }
      sgrid->SetPoints(points);
      sgrid->GetPointData()->SetVectors(vectors);

      // We create a simple pipeline to display the data.
      vtkSmartPointer<vtkHedgeHog> hedgehog =
        vtkSmartPointer<vtkHedgeHog>::New();
      hedgehog->SetInputData(sgrid);
      hedgehog->SetScaleFactor(0.1);

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

      vtkSmartPointer<vtkPolyDataMapper> sgridMapper =
        vtkSmartPointer<vtkPolyDataMapper>::New();
      sgridMapper->SetInputConnection(hedgehog->GetOutputPort());
      vtkSmartPointer<vtkActor> sgridActor =
        vtkSmartPointer<vtkActor>::New();
      sgridActor->SetMapper(sgridMapper);
      sgridActor->GetProperty()->SetColor(colors->GetColor3d("Peacock").GetData());

      // Create the usual rendering stuff
      vtkSmartPointer<vtkRenderer> renderer =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderWindow> renWin =
        vtkSmartPointer<vtkRenderWindow>::New();
      renWin->AddRenderer(renderer);

      vtkSmartPointer<vtkRenderWindowInteractor> iren =
        vtkSmartPointer<vtkRenderWindowInteractor>::New();
      iren->SetRenderWindow(renWin);

      renderer->AddActor(sgridActor);
      renderer->SetBackground(colors->GetColor3d("Beige").GetData());
      renderer->ResetCamera();
      renderer->GetActiveCamera()->Elevation(60.0);
      renderer->GetActiveCamera()->Azimuth(30.0);
      renderer->GetActiveCamera()->Dolly(1.25);
      renWin->SetSize(640, 480);

      // interact with data
      renWin->Render();
      iren->Start();

      return EXIT_SUCCESS;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 2.8)

    PROJECT(SGrid)

    find_package(VTK REQUIRED)
    include(${VTK_USE_FILE})

    add_executable(SGrid MACOSX_BUNDLE SGrid.cxx )

    target_link_libraries(SGrid ${VTK_LIBRARIES})

### Download and Build SGrid

Click here to download SGrid and its CMakeLists.txt file. Once the tarball SGrid.tar has been downloaded and extracted,

    cd SGrid/build

If VTK is installed:

    cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

    cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

    make

and run it:

    ./SGrid

WINDOWS USERS

Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.