Added matplot_vtk to build.

CMakeLists.txt

@@ -1,12 +1,27 @@
 cmake_minimum_required (VERSION 2.8.7)
 
-project (Lemma)
+project (Lemma CXX)
+
+
+# required external programs (for runtime of nix, not buildtime)
+FIND_PROGRAM(HAVEGIT git
+  PATHS /usr/bin/ /bin ENV PATH NO_DEFAULT_PATH
+)
+if(NOT HAVEGIT)
+  message(FATAL_ERROR "Lemma requires that git is installed and in the path of your machine")
+endif(NOT HAVEGIT)
+
+# FIND_PROGRAM(HAVEHG hg
+#   PATHS /usr/bin/ /bin ENV PATH NO_DEFAULT_PATH
+# )
+# if(NOT HAVEHG)
+#   message(STATUS "Mercurial (hg) was not found.")
+# endif(NOT HAVEHG)
 
 ###################
 # External Projects
 ###################
 include(ExternalProject)
-
 # Eigen, this header-library is used extensively for linear algebra, matrices, and arrays
 # Mercurial (hg) repo pull, Would it be better to just download latest stable?
 #ExternalProject_Add(EIGEN
@@ -76,9 +91,25 @@ if (VTK_SUPPORT)
 	find_package(VTK 6 REQUIRED NO_MODULE)
 	include(${VTK_USE_FILE})
 	add_compile_options(-DLEMMAUSEVTK) 
+
+	# Compile Matplot_vtk if VTK is present
+	add_subdirectory(Matplot_vtk)	
+	include_directories ("${PROJECT_SOURCE_DIR}/Matplot_vtk")
+
 endif()
 
-add_compile_options(-std=c++11) 
+# Add the c++11 flag 
+include(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG(-std=c++11 COMPILER_SUPPORTS_CXX11)
+CHECK_CXX_COMPILER_FLAG(-std=c++0x COMPILER_SUPPORTS_CXX0X)
+if(COMPILER_SUPPORTS_CXX11)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+elseif(COMPILER_SUPPORTS_CXX0X)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+else()
+  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+endif()
+#add_compile_options(-std=c++11) 
 
 set(LEMMA_VERSION_MAJOR "0")
 set(LEMMA_VERSION_MINOR "0")

LemmaCore/CMakeLists.txt

@@ -14,7 +14,11 @@ if (MATIO_SUPPORT)
 endif()
 if (VTK_SUPPORT) 
 	target_link_libraries(lemmacore ${VTK_LIBRARIES})
+	target_link_libraries(lemmacore "matplot")
 endif()
 target_link_libraries(lemmacore "yaml-cpp")
 
-add_subdirectory(examples)
+option( BUILDEXAMPLES "Compile example Lemma applications" OFF )
+if (BUILDEXAMPLES)
+	add_subdirectory(examples)
+endif()

LemmaCore/examples/CMakeLists.txt

@@ -1,4 +1,4 @@
-FILE(GLOB  examples  "*.cpp")
+#FILE(GLOB  examples  "*.cpp")
 
 add_executable( datatem datatem.cpp )
 target_link_libraries(datatem "lemmacore")

Matplot_vtk/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_library( matplot matplot.cpp )
+target_link_libraries(matplot ${VTK_LIBRARIES})

Matplot_vtk/matplot.cpp

@@ -0,0 +1,700 @@
+#ifdef LEMMAUSEVTK
+
+#include "matplot.h"
+
+#include "vtkActor.h"
+#include "vtkAxesActor.h"
+#include "vtkCamera.h"
+#include "vtkCaptionActor2D.h"
+#include "vtkContourFilter.h"
+#include "vtkDataSetMapper.h"
+#include "vtkGlyph3D.h"
+#include "vtkGlyphSource2D.h"
+#include "vtkOutlineFilter.h"
+#include "vtkPolyData.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkPNGWriter.h"
+#include "vtkProperty.h"
+#include "vtkProperty2D.h"
+#include "vtkRectilinearGridGeometryFilter.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkStructuredGridGeometryFilter.h"
+#include "vtkScalarBarActor.h"
+#include "vtkTextProperty.h"
+#include "vtkTubeFilter.h"
+#include "vtkWarpScalar.h"
+#include "vtkWindowToImageFilter.h"
+#include "vtkRenderLargeImage.h"
+
+#include "vtkTextActor.h"
+#include "vtkVectorText.h"
+#include "vtkTransformPolyDataFilter.h"
+#include "vtkTransform.h"
+#include "vtkFollower.h"
+
+#include "vtkAxisActor2D.h"
+//#include "vtkCubeAxesActor.h"
+#include "vtkCubeAxesActor2D.h"
+
+using namespace matplot;
+
+/// Default constructor
+Plot2D_VTK::Plot2D_VTK(std::string x_label, std::string y_label,
+		       int xpix, int ypix, bool semilogX)
+{
+    semilogx = semilogX;
+    xPix = xpix;
+    yPix = ypix;
+
+    plot_no = 0;
+
+    // set up the renderer
+    rend = vtkRenderer::New();
+    rend->SetBackground(1., 1., 1.);
+
+    // set up the xy plot
+    xyplot = vtkXYPlotActor::New();
+
+    xyplot->GetProperty()->SetColor(0.0, 0.0, 0.0);
+
+    xyplot->SetBorder(10);
+    xyplot->GetPositionCoordinate()->SetValue(0.0, 0.0, 0);
+    xyplot->GetPosition2Coordinate()->SetValue(1.0, 1.0, 0);
+
+    xyplot->GetProperty()->SetLineWidth(1);
+    xyplot->GetProperty()->SetPointSize(5);
+
+    xyplot->PlotPointsOff();
+    xyplot->PlotLinesOff();
+    xyplot->PlotCurvePointsOn();
+    xyplot->PlotCurveLinesOn();
+
+    xyplot->SetXValuesToArcLength();
+
+    xyplot->SetLabelFormat("%2.1f");
+    xyplot->SetTitle("");
+    xyplot->SetXTitle(x_label.c_str());
+    xyplot->SetYTitle(y_label.c_str());
+
+    if (semilogx) {
+        xyplot->LogxOn();
+    }
+
+    vtkTextProperty* text_prop = xyplot->GetTitleTextProperty();
+    text_prop->SetColor(0.0, 0.0, 0.0);
+    text_prop->SetFontFamilyToArial();
+    xyplot->SetAxisTitleTextProperty(text_prop);
+    xyplot->SetAxisLabelTextProperty(text_prop);
+    xyplot->SetTitleTextProperty(text_prop);
+}
+
+/// Destructor
+Plot2D_VTK::~Plot2D_VTK()
+{
+    xyplot->Delete();
+    rend->Delete();
+}
+
+/// Render current figure to screen
+void Plot2D_VTK::show()
+{
+    rend->AddActor(xyplot);
+    render_interactive(rend,xPix,yPix);
+}
+
+/// Render current figure to file
+void Plot2D_VTK::draw_to_png(std::string filename)
+{
+    rend->AddActor(xyplot);
+    render_to_png(rend,xPix,yPix,filename);
+}
+//==============================================================================
+
+Surf_VTK::Surf_VTK(int px, int py)
+{
+    has_data = false;
+    Lxy = -1;
+    Lz = -1;
+    xPix = px;
+    yPix = py;
+
+    gridfunc = vtkStructuredGrid::New();
+    rend = vtkRenderer::New();
+}
+
+/// Destructor
+Surf_VTK::~Surf_VTK()
+{
+    gridfunc->Delete();
+    rend->Delete();
+}
+
+/// Clear plot data before reuse
+void Surf_VTK::purge()
+{
+    assert(has_data);
+    gridfunc->Delete();
+    rend->Delete();
+    gridfunc = vtkStructuredGrid::New();
+    rend = vtkRenderer::New();
+    has_data = false;
+    Lxy = -1;
+    Lz = -1;
+}
+
+void Surf_VTK::renderer(bool draw_axes, bool draw_colorbar, bool draw_box,
+			bool do_warp)
+{
+    assert(has_data);
+
+    // filter to geometry primitive
+    vtkStructuredGridGeometryFilter *geometry =
+	vtkStructuredGridGeometryFilter::New();
+    geometry->SetInputData(gridfunc);
+
+    // warp to fit in box
+    vtkWarpScalar *warp = vtkWarpScalar::New();
+    if (do_warp)
+    {
+	double scale = Lxy/Lz;
+	warp->SetInputConnection(geometry->GetOutputPort());
+	warp->XYPlaneOn();
+	warp->SetScaleFactor(scale);
+    }
+
+    // map gridfunction
+    vtkPolyDataMapper *mapper = vtkPolyDataMapper::New();
+    if (do_warp)
+	mapper->SetInputConnection(warp->GetOutputPort());
+    else
+	mapper->SetInputConnection(geometry->GetOutputPort());
+
+    double tmp[2];
+    gridfunc->GetScalarRange(tmp);
+    mapper->SetScalarRange(tmp[0], tmp[1]);
+
+    // create plot surface actor
+    vtkActor *surfplot = vtkActor::New();
+    surfplot->SetMapper(mapper);
+
+    // create outline
+    vtkOutlineFilter *outlinefilter = vtkOutlineFilter::New();
+    if (do_warp)
+	outlinefilter->SetInputConnection(warp->GetOutputPort());
+    else
+	outlinefilter->SetInputConnection(geometry->GetOutputPort());
+    vtkPolyDataMapper *outlineMapper = vtkPolyDataMapper::New();
+    outlineMapper->SetInputConnection(outlinefilter->GetOutputPort());
+    vtkActor *outline = vtkActor::New();
+    outline->SetMapper(outlineMapper);
+    outline->GetProperty()->SetColor(0, 0, 0);
+
+    // create axes
+    vtkAxesActor* axes = vtkAxesActor::New();
+    axes->SetShaftTypeToCylinder();
+    axes->SetNormalizedShaftLength( 0.85, 0.85, 0.85);
+    axes->SetNormalizedTipLength( 0.15, 0.15, 0.15);
+    axes->SetCylinderRadius( 0.500 * axes->GetCylinderRadius() );
+    axes->SetConeRadius( 1.025 * axes->GetConeRadius() );
+    axes->SetSphereRadius( 1.500 * axes->GetSphereRadius() );
+    vtkTextProperty* text_prop_ax = axes->GetXAxisCaptionActor2D()->
+	GetCaptionTextProperty();
+    text_prop_ax->SetColor(0.0, 0.0, 0.0);
+    text_prop_ax->SetFontFamilyToArial();
+    text_prop_ax->SetFontSize(8);
+    axes->GetYAxisCaptionActor2D()->GetCaptionTextProperty()->
+	ShallowCopy(text_prop_ax);
+    axes->GetZAxisCaptionActor2D()->GetCaptionTextProperty()->
+	ShallowCopy(text_prop_ax);
+
+    // create colorbar
+    vtkScalarBarActor *colorbar = vtkScalarBarActor::New();
+    colorbar->SetLookupTable(mapper->GetLookupTable());
+    colorbar->SetWidth(0.085);
+    colorbar->SetHeight(0.9);
+    colorbar->SetPosition(0.9, 0.1);
+    vtkTextProperty* text_prop_cb = colorbar->GetLabelTextProperty();
+    text_prop_cb->SetColor(1.0, 1.0, 1.0);
+    colorbar->SetLabelTextProperty(text_prop_cb);
+
+    // renderer
+    rend->AddActor(surfplot);
+    if (draw_box)
+	rend->AddActor(outline);
+    if (draw_axes)
+	rend->AddActor(axes);
+    if (draw_colorbar)
+	    rend->AddActor(colorbar);
+
+    rend->SetBackground(0.25, 0.25, 0.25);
+
+    // renderer is now set up!
+
+    // clean up
+    colorbar->Delete();
+    warp->Delete();
+    axes->Delete();
+    outline->Delete();
+    outlinefilter->Delete();
+    outlineMapper->Delete();
+    surfplot->Delete();
+    mapper->Delete();
+    geometry->Delete();
+}
+//==============================================================================
+
+/// Default constructor
+Contour_VTK::Contour_VTK(int px, int py)
+{
+	XScale = LINEAR;
+	YScale = LINEAR;
+
+    has_data = false;
+    xPix = px;
+    yPix = py;
+
+    gridfunc = vtkRectilinearGrid::New();
+    rend = vtkRenderer::New();
+}
+
+/// Default constructor
+Contour_VTK::Contour_VTK(int px, int py, SCALE xsc, SCALE ysc)
+{
+	XScale = xsc;
+	YScale = ysc;
+
+	xlabel  = "x";
+	ylabel  = "y";
+
+    has_data = false;
+    xPix = px;
+    yPix = py;
+
+    gridfunc = vtkRectilinearGrid::New();
+    rend = vtkRenderer::New();
+}
+
+/// Destructor
+Contour_VTK::~Contour_VTK()
+{
+    gridfunc->Delete();
+    rend->Delete();
+}
+
+/// Clear plot data before reuse
+void Contour_VTK::purge()
+{
+    assert(has_data);
+    gridfunc->Delete();
+    rend->Delete();
+    gridfunc = vtkRectilinearGrid::New();
+    rend = vtkRenderer::New();
+    has_data = false;
+}
+
+/// Set labels for contour plots
+void Contour_VTK::SetXLabel(const std::string &xlab) {
+	xlabel = xlab;
+}
+
+void Contour_VTK::SetYLabel(const std::string &ylab ) {
+	ylabel = ylab;
+}
+
+void Contour_VTK::renderer(bool draw_colorbar, bool draw_surf, int lines)
+{
+    assert(has_data);
+
+    // filter to geometry primitive
+    vtkRectilinearGridGeometryFilter *geometry =
+	vtkRectilinearGridGeometryFilter::New();
+    geometry->SetInputData(gridfunc);
+
+    // map gridfunction
+    vtkPolyDataMapper *mapper = vtkPolyDataMapper::New();
+    mapper->SetInputConnection(geometry->GetOutputPort());
+
+    double tmp[2];
+    gridfunc->GetScalarRange(tmp);
+    mapper->SetScalarRange(tmp[0], tmp[1]);
+
+    // create plot surface actor
+    vtkActor *surfplot = vtkActor::New();
+    surfplot->SetMapper(mapper);
+
+    // create contour lines (10 lines)
+    vtkContourFilter *contlines = vtkContourFilter::New();
+    contlines->SetInputConnection(geometry->GetOutputPort());
+    double tempdiff = (tmp[1]-tmp[0])/(10*lines);
+    contlines->GenerateValues(lines, tmp[0]+tempdiff, tmp[1]-tempdiff);
+    vtkPolyDataMapper *contourMapper = vtkPolyDataMapper::New();
+    contourMapper->SetInputConnection(contlines->GetOutputPort());
+    if (draw_surf)
+	contourMapper->ScalarVisibilityOff();
+    else
+	contourMapper->SetScalarRange(tmp[0], tmp[1]);
+    vtkActor *contours = vtkActor::New();
+    contours->SetMapper(contourMapper);
+	contours->GetProperty()->SetOpacity(.25);
+	contours->GetProperty()->SetColor(0.5,0.5,0.5);
+
+    // create outline
+    vtkOutlineFilter *outlinefilter = vtkOutlineFilter::New();
+    outlinefilter->SetInputConnection(geometry->GetOutputPort());
+    vtkPolyDataMapper *outlineMapper = vtkPolyDataMapper::New();
+    outlineMapper->SetInputConnection(outlinefilter->GetOutputPort());
+    vtkActor *outline = vtkActor::New();
+    outline->SetMapper(outlineMapper);
+    outline->GetProperty()->SetColor(0, 0, 0);
+
+    // create colorbar
+    vtkScalarBarActor *colorbar = vtkScalarBarActor::New();
+    if (draw_surf)
+	colorbar->SetLookupTable(mapper->GetLookupTable());
+    else
+	colorbar->SetLookupTable(contourMapper->GetLookupTable());
+//
+    colorbar->SetWidth(0.085);
+    colorbar->SetHeight(0.9);
+    colorbar->SetPosition(0.9, 0.1);
+    vtkTextProperty* text_prop_cb = colorbar->GetLabelTextProperty();
+    text_prop_cb->SetColor(1.0, 1.0, 1.0);
+    colorbar->SetLabelTextProperty(text_prop_cb);
+
+	double xrange[2];
+ 	double yrange[2];
+ 	gridfunc->GetXCoordinates()->GetRange(xrange);
+ 	gridfunc->GetYCoordinates()->GetRange(yrange);
+ 	vtkCubeAxesActor2D  *caxis = vtkCubeAxesActor2D::New();
+
+	caxis->ZAxisVisibilityOff();
+	caxis->SetXLabel(xlabel.c_str());
+	caxis->SetYLabel(ylabel.c_str());
+
+	vtkCamera* mycam = rend->MakeCamera(); // vtkCamera::New();
+	//rend->SetActiveCamera(mycam);
+  	caxis->SetBounds( xrange[0], xrange[1], yrange[0], yrange[1], 0, 0);
+  	caxis->SetRanges( xrange[0], xrange[1], ymin, ymax, 0, 0);
+	caxis->SetUseRanges(1);
+
+  	caxis->SetCamera( mycam );
+	caxis->SetNumberOfLabels(6);
+	// doesn't work, rotate y label 90 degrees
+	caxis->GetYAxisActor2D()->GetTitleTextProperty()->SetOrientation(90.);
+   	rend->AddActor(caxis);
+
+	mycam->Delete();
+	caxis->Delete();
+
+	// handdrwan label
+// 	// X label
+// 	vtkVectorText                     *xlabel = vtkVectorText::New();
+// 	vtkTransformPolyDataFilter  *transxlabel  = vtkTransformPolyDataFilter::New();
+// 	vtkTransform                      *trans  = vtkTransform::New();
+// 	vtkPolyDataMapper               *xlabmap  = vtkPolyDataMapper::New();
+// 	vtkFollower                     *xlabact  = vtkFollower::New();
+	// locate and rotate as needed
+ 	//double yranget = std::abs(yrange[1]-yrange[0]);
+	//double xranget = std::abs(xrange[1]-xrange[0]);
+// 	trans->Identity();
+// 	trans->Scale(5,5,5);  // TODO, is 5 always OK???
+// 	transxlabel->SetTransform(trans);
+// 	transxlabel->SetInputConnection(xlabel->GetOutputPort());
+// 	// TODO input name
+// 	xlabel->SetText("Frequency [Hz]");
+// 	transxlabel->SetInputConnection(xlabel->GetOutputPort());
+// 	xlabmap->SetInputConnection(transxlabel->GetOutputPort());
+// 	xlabact->SetMapper(xlabmap);
+// 	// centre between axis
+// 	xlabact->SetPosition( (xrange[0]+xrange[1])/2 - xlabact->GetCenter()[0],
+// 					       yrange[0]-.2*yranget, 0 );
+// 	//rend->AddActor(xlabact);
+// 	// Y label
+// 	vtkVectorText                     *ylabel = vtkVectorText::New();
+// 	vtkTransformPolyDataFilter  *transylabel  = vtkTransformPolyDataFilter::New();
+// 	vtkTransform                     *ytrans  = vtkTransform::New();
+// 	vtkPolyDataMapper               *ylabmap  = vtkPolyDataMapper::New();
+// 	vtkFollower                     *ylabact  = vtkFollower::New();
+// 	// locate and rotate as needed
+// 	ytrans->Identity();
+// 	ytrans->Scale(5,5,5); // TODO don't hard code, calc from window size maybe??
+// 	ytrans->RotateZ(90);
+// 	transylabel->SetTransform(ytrans);
+// 	transylabel->SetInputConnection(ylabel->GetOutputPort());
+//
+// 	ylabel->SetText("Pulse moment [A sec]");
+// 	transylabel->SetInputConnection(ylabel->GetOutputPort());
+// 	ylabmap->SetInputConnection(transylabel->GetOutputPort());
+// 	ylabact->SetMapper(ylabmap);
+// 	ylabact->SetPosition( xrange[0]-.2*xranget,
+// 					      (yrange[0]+yrange[1])/2 - ylabact->GetCenter()[1],
+// 						  0 );
+// 	//rend->AddActor(ylabact);
+
+    if (draw_surf)
+ 	rend->AddActor(surfplot);
+
+	rend->AddActor(contours);
+	rend->AddActor(outline);
+	if (draw_colorbar) {
+		rend->AddActor(colorbar);
+ 	}
+
+	rend->SetBackground(0.25, 0.25, 0.25);
+
+// 	double xrange[2];
+// 	double yrange[2];
+// 	gridfunc->GetXCoordinates()->GetRange(xrange);
+// 	gridfunc->GetYCoordinates()->GetRange(yrange);
+// 	vtkCubeAxesActor	 *caxis = vtkCubeAxesActor::New();
+// 	caxis->ZAxisVisibilityOff();
+// 	caxis->SetCamera(rend->GetActiveCamera());
+// 	caxis->SetBounds( xrange[0], xrange[1], yrange[0], yrange[1], 0, 1 );
+//  	rend->AddActor(caxis);
+
+ 	//rend->AddActor(yaxis);
+//     // clean up
+// 	xlabel->Delete();
+// 	transxlabel->Delete();
+// 	trans->Delete();
+// 	xlabmap->Delete();
+// 	xlabact->Delete();
+//
+// 	ylabel->Delete();
+// 	transylabel->Delete();
+// 	ytrans->Delete();
+// 	ylabmap->Delete();
+// 	ylabact->Delete();
+
+	// renderer is now set up!
+	//caxis->Delete();
+	//yaxis->Delete();
+
+    contours->Delete();
+    contlines->Delete();
+    contourMapper->Delete();
+    outline->Delete();
+    outlinefilter->Delete();
+    outlineMapper->Delete();
+    colorbar->Delete();
+    surfplot->Delete();
+    mapper->Delete();
+    geometry->Delete();
+
+}
+//==============================================================================
+
+/// Default constructor
+Quiver_VTK::Quiver_VTK(int px, int py)
+{
+    has_data = false;
+    xPix = px;
+    yPix = py;
+
+    gridfunc = vtkRectilinearGrid::New();
+    rend = vtkRenderer::New();
+}
+
+/// Destructor
+Quiver_VTK::~Quiver_VTK()
+{
+    gridfunc->Delete();
+    rend->Delete();
+}
+
+/// Clear plot data before reuse
+void Quiver_VTK::purge()
+{
+    assert(has_data);
+    gridfunc->Delete();
+    rend->Delete();
+    gridfunc = vtkRectilinearGrid::New();
+    rend = vtkRenderer::New();
+    has_data = false;
+}
+
+void Quiver_VTK::renderer(double s)
+{
+    assert(has_data);
+
+    // filter to geometry primitive
+    vtkRectilinearGridGeometryFilter *geometry =
+	vtkRectilinearGridGeometryFilter::New();
+    geometry->SetInputData(gridfunc);
+
+    // make a vector glyph
+    vtkGlyphSource2D* vec = vtkGlyphSource2D::New();
+    vec->SetGlyphTypeToArrow();
+    vec->SetScale(s);
+    vec->FilledOff();
+
+    vtkGlyph3D* glyph = vtkGlyph3D::New();
+    glyph->SetInputConnection(geometry->GetOutputPort());
+    glyph->SetSourceConnection(vec->GetOutputPort());
+    glyph->SetColorModeToColorByScalar();
+
+    // map gridfunction
+    vtkPolyDataMapper *mapper = vtkPolyDataMapper::New();
+    mapper->SetInputConnection(glyph->GetOutputPort());
+
+    double tmp[2];
+    gridfunc->GetScalarRange(tmp);
+    mapper->SetScalarRange(tmp[0], tmp[1]);
+
+    // create plot quiver actor
+    vtkActor *quiver_actor = vtkActor::New();
+    quiver_actor->SetMapper(mapper);
+
+    // create colorbar
+    vtkScalarBarActor *colorbar = vtkScalarBarActor::New();
+    colorbar->SetLookupTable(mapper->GetLookupTable());
+    colorbar->SetWidth(0.085);
+    colorbar->SetHeight(0.9);
+    colorbar->SetPosition(0.9, 0.1);
+    vtkTextProperty* text_prop_cb = colorbar->GetLabelTextProperty();
+    text_prop_cb->SetColor(1.0, 1.0, 1.0);
+    colorbar->SetLabelTextProperty(text_prop_cb);
+
+    // create outline
+    vtkOutlineFilter *outlinefilter = vtkOutlineFilter::New();
+    outlinefilter->SetInputConnection(geometry->GetOutputPort());
+    vtkPolyDataMapper *outlineMapper = vtkPolyDataMapper::New();
+    outlineMapper->SetInputConnection(outlinefilter->GetOutputPort());
+    vtkActor *outline = vtkActor::New();
+    outline->SetMapper(outlineMapper);
+    outline->GetProperty()->SetColor(0, 0, 0);
+
+    // add actors to renderer
+    rend->AddActor(quiver_actor);
+    rend->AddActor(colorbar);
+    rend->AddActor(outline);
+    rend->SetBackground(0.25, 0.25, 0.25);
+
+    // renderer is now set up!
+
+    // clean up
+    outline->Delete();
+    outlinefilter->Delete();
+    outlineMapper->Delete();
+    vec->Delete();
+    glyph->Delete();
+    colorbar->Delete();
+    quiver_actor->Delete();
+    mapper->Delete();
+
+}
+
+//==============================================================================
+
+/** Start interactive rendereing (default camera).
+ * Sets resolution to (xPix,yPix)
+ */
+void matplot::render_interactive(vtkRenderer *rend, int xPix, int yPix)
+{
+	vtkRenderWindow *renWin = vtkRenderWindow::New();
+    vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+    renWin->AddRenderer(rend);
+    iren->SetRenderWindow(renWin);
+    renWin->SetSize(xPix, yPix);
+
+	// makes first frame look reasonable interactive
+	renWin->Render();
+	renWin->Start();
+
+    // Start interactive rendering
+    iren->Initialize();
+    iren->Start();
+    iren->Disable();
+	iren->Delete();
+    renWin->Delete();
+}
+
+/** Start interactive rendereing (manual camera placement).
+ * Sets resolution to (xPix,yPix)
+ */
+void matplot::render_interactive_cam(vtkRenderer *rend, int xPix, int yPix,
+				     double cam[3], double focal[3])
+{
+    rend->GetActiveCamera()->SetViewUp(0, 0, 1);
+    rend->GetActiveCamera()->SetPosition(cam);
+    rend->GetActiveCamera()->SetFocalPoint(focal);
+
+    vtkRenderWindow *renWin = vtkRenderWindow::New();
+    vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
+    renWin->AddRenderer(rend);
+    iren->SetRenderWindow(renWin);
+    renWin->SetSize(xPix, yPix);
+
+    // Start interactive rendering
+    iren->Initialize();
+    iren->Start();
+
+    iren->Delete();
+    renWin->Delete();
+}
+
+/// Renders scene to PNG (default camera)
+void matplot::render_to_png(vtkRenderer *rend, int xPix, int yPix,
+			    std::string fname)
+{
+    vtkRenderWindow *renWin = vtkRenderWindow::New();
+    renWin->AddRenderer(rend);
+    renWin->SetSize(xPix, yPix);
+    renWin->Render();
+    rend->Render();
+
+    vtkRenderLargeImage* renderLarge = vtkRenderLargeImage::New();
+        renderLarge->SetInput(rend);
+        renderLarge->SetMagnification(1);
+
+    vtkPNGWriter *pngfile = vtkPNGWriter::New();
+        pngfile->SetFileName(fname.c_str());
+        pngfile->SetInputConnection(renderLarge->GetOutputPort());
+        pngfile->Update();
+        pngfile->Update();
+
+    pngfile->Update();
+    pngfile->Write();
+
+    renderLarge->Delete();
+    pngfile->Delete();
+    renWin->Delete();
+}
+
+/// Renders scene to PNG (manual camera placement)
+void matplot::render_to_png_cam(vtkRenderer *rend, int xPix, int yPix,
+				std::string fname, double cam[3],
+				double focal[3])
+{
+    rend->GetActiveCamera()->SetViewUp(0, 0, 1);
+    rend->GetActiveCamera()->SetPosition(cam);
+    rend->GetActiveCamera()->SetFocalPoint(focal);
+
+    vtkRenderWindow *renWin = vtkRenderWindow::New();
+    renWin->AddRenderer(rend);
+    renWin->SetSize(xPix, yPix);
+
+    vtkRenderLargeImage* renderLarge = vtkRenderLargeImage::New();
+        renderLarge->SetInput(rend);
+        renderLarge->SetMagnification(1);
+
+    //vtkWindowToImageFilter *w2i = vtkWindowToImageFilter::New();
+    vtkPNGWriter *pngfile = vtkPNGWriter::New();
+        //pngfile->SetInputConnection(w2i->GetOutputPort());
+        pngfile->SetInputConnection(renderLarge->GetOutputPort());
+    pngfile->SetFileName(fname.c_str());
+
+    //w2i->SetInput(renWin);
+    //w2i->Update();
+
+    renWin->Render();
+    pngfile->Write();
+
+    //w2i->Delete();
+    renderLarge->Delete();
+    pngfile->Delete();
+    renWin->Delete();
+}
+
+#endif

Matplot_vtk/matplot.h

@@ -0,0 +1,634 @@
+#ifndef __MATPLOT_VTK
+#define __MATPLOT_VTK
+
+/*
+ * MatPlot_VTK
+ *
+ * Simple plotting of vectors and matrices based on
+ * the VTK libraries.
+ *
+ * Four classes:
+ * Plot2D_VTK  - 2d plotting akin to plot(x,y)
+ * Surf_VTK    - Surface plotting akin to surf(x,y,z)
+ * Contour_VTK - Contour plotting
+ * Quiver_VTK  - Vector field plot
+ *
+ * See examples.cpp for usage instructions.
+ *
+ * These classes are released "as is", without any implied
+ * warranty or fitness for any particular purpose.
+ *
+ * Dag Lindbo, dag@csc.kth.se, 2007-12-09
+ */
+
+// matrix size functions
+// #include "ublas_dims.h"
+//#include "mtl4_dims.h"
+
+// system includes
+#include <assert.h>
+#include <string>
+#include <cmath>
+
+// vtk includes used by templates
+#include "vtkFloatArray.h"
+#include "vtkPointData.h"
+#include "vtkPoints.h"
+#include "vtkRectilinearGrid.h"
+#include "vtkRenderer.h"
+#include "vtkStructuredGrid.h"
+#include "vtkXYPlotActor.h"
+
+namespace matplot {
+
+	enum SCALE {LINEAR, LOG10};
+
+    void render_interactive(vtkRenderer *rend, int xPix, int yPix);
+
+	void render_interactive_camera(vtkRenderer *rend, int xPix, int yPix,
+					vtkCamera* mycam);
+
+    void render_interactive_cam(vtkRenderer *rend, int xPix, int yPix,
+				double cam[3], double focal[3]);
+
+    void render_to_png(vtkRenderer *rend, int xPix, int yPix,std::string fname);
+
+    void render_to_png_cam(vtkRenderer *rend, int xPix, int yPix,
+			   std::string fname, double cam[3], double focal[3]);
+
+    /** Plot vectors x versus y.
+     * Inspired by "plot" in Matlab.
+     *
+     * Notes:
+     *
+     * Call plot(x,y,<...>) multiple times before show() to
+     * get multiple curves in one figure.
+     *
+     * \author Dag Lindbo
+     */
+    class Plot2D_VTK {
+
+		public:
+
+			Plot2D_VTK(std::string x_label="x", std::string y_label="y",
+			   int xpix = 800, int ypix = 600, bool semilogx=false );
+			~Plot2D_VTK();
+
+			/** Insert curve x vs.\ y into plot.
+			 * - Default color is blue, {0 , 0, 1}.
+			 * - Default line style is solid line, "-".
+			 */
+			template<typename Vec_t>
+			void plot(const Vec_t &x, const Vec_t &y) {
+		    	double color[3] = { 0, 0, 1.0 };
+		    	plot(x, y, color, "-");
+			}
+
+			/** Insert curve x vs.\ y into plot (specify color and line style).
+			 * Color specification:
+			 * 		- RGB (normalized decimal), {0.32, 0.1, 0.0}
+			 *
+			 * Line style specification:
+			 * 		-	"-" 			solid line
+			 * 		-	"." 			dotted line
+			 * 		-	".-" or "-." 	solid line with dots
+			 */
+			template<typename Vec_t>
+			void plot(const Vec_t &x, const Vec_t &y, const double col[3],
+			  const std::string linespec) {
+
+				int i, N = x.size(), plot_points = 0, plot_lines = 0;
+
+			    vtkRectilinearGrid *curve;
+			    vtkFloatArray *yVal;
+			    vtkFloatArray *xVal;
+
+			    // determine line style
+			    if (linespec == "-")
+					plot_lines = 1;
+			    else if (linespec == ".")
+					plot_points = 1;
+			    else if (linespec == ".-" || linespec == "-.") {
+					plot_points = 1;
+					plot_lines = 1;
+			    }
+
+			    // put (x,y) into VTK FloatArrays
+			    xVal = vtkFloatArray::New();
+			    yVal = vtkFloatArray::New();
+
+			    for (i=0; i<N; i++) {
+					xVal->InsertNextTuple1(x[i]);
+					yVal->InsertNextTuple1(y[i]);
+			    }
+
+			    // Make a VTK Rectlinear grid from arrays
+			    curve = vtkRectilinearGrid::New();
+			    curve->SetDimensions(N, 1, 1);
+			    curve->SetXCoordinates(xVal);
+			    curve->GetPointData()->SetScalars(yVal);
+
+			    // attach gridfunction to plot
+			    xyplot->AddDataSetInput(curve);
+
+                if (semilogx) {
+                    xyplot->LogxOn();
+                }
+                // VTK doesn't have this? :(
+                //xyplot->LogyOn();
+
+			    // how to read data
+			    xyplot->SetXValuesToValue();
+
+			    // set attributes
+			    xyplot->SetPlotColor(plot_no, col[0], col[1], col[2]);
+			    xyplot->SetPlotLines(plot_no, plot_lines);
+			    xyplot->SetPlotPoints(plot_no, plot_points);
+
+			    plot_no++;
+
+			    xVal->Delete();
+			    yVal->Delete();
+			    curve->Delete();
+			}
+
+			void show();
+			void draw_to_png(std::string filename);
+
+    	private:
+
+			int xPix;
+			int yPix;
+            bool semilogx;
+			int plot_no;
+
+
+			vtkRenderer* rend;
+			vtkXYPlotActor* xyplot;
+    };
+
+    /** Plot z = f(x,y) surface.
+     * Inspired by "surf" in Matlab
+     *
+     * \author Dag Lindbo
+     */
+    class Surf_VTK
+    {
+    public:
+
+	Surf_VTK(int px = 800, int py = 600);
+	~Surf_VTK();
+
+	/** Create surface plot.
+	 * Matrix z, with respect to vectors x and y.
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void surf(const Vec_t &x, const Vec_t &y, const Mat_t &z)
+	{
+	    geometry(x, y, z);
+	    renderer(false, true, true, false);
+	    render_interactive(rend, xPix, yPix);
+	}
+
+	/** Create surface plot.
+	 * Matrix z, with respect to vectors x and y.
+	 *
+	 * Warp z-axis to produce better fit:
+	 * - do_warp = true
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void surf(const Vec_t &x, const Vec_t &y, const Mat_t &z, bool do_warp)
+	{
+	    geometry(x, y, z);
+	    renderer(false, true, true, do_warp);
+	    render_interactive(rend, xPix, yPix);
+	}
+
+	/** Create surface plot.
+	 * Matrix z, with respect to vectors x and y.
+	 *
+	 * Warp z-axis to produce better fit:
+	 * - do_warp = true
+	 *
+	 * Camera control:
+	 * - specify camera position: cam = { -15.0, 10.0, 12.0 }
+	 * - specify focal point: focal = { 0, 0, 0 }
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void surf(const Vec_t &x, const Vec_t &y, const Mat_t &z, bool do_warp,
+		  double observer[3], double focal[3])
+	{
+	    geometry(x, y, z);
+	    renderer(false, true, true, do_warp);
+	    render_interactive_cam(rend, xPix, yPix, observer, focal);
+	}
+
+	/** Create surface plot and render to file
+	 * Matrix z, with respect to vectors x and y.
+	 *
+	 * Warp z-axis to produce better fit:
+	 * - do_warp = true
+	 *
+	 * Camera control:
+	 * - specify camera position: cam = { -15.0, 10.0, 12.0 }
+	 * - specify focal point: focal = { 0, 0, 0 }
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void surf_to_file(const Vec_t &x, const Vec_t &y, const Mat_t &z,
+			  bool do_warp, std::string fname, double observer[3],
+			  double focal[3])
+	{
+	    geometry(x, y, z);
+	    renderer(false, true, true, do_warp);
+	    render_to_png_cam(rend, xPix, yPix, fname, observer, focal);
+	}
+
+	void purge();
+
+    private:
+	vtkStructuredGrid *gridfunc;
+	vtkRenderer *rend;
+
+	double Lxy, Lz;
+	bool has_data;
+
+	int xPix, yPix;
+
+	template<typename Vec_t, typename Mat_t>
+	void geometry(const Vec_t &x, const Vec_t &y, const Mat_t &z)
+	{
+	    const unsigned int Nx = x.size(); //vec_dim(x);
+	    const unsigned int Ny = y.size(); //vec_dim(y);
+	    unsigned int i, j, k;
+
+	    // make sure the input is ok and that this surfaceplot is free
+	    assert(Nx == z.rows() );
+	    assert(Ny == z.cols() );
+	    assert(!has_data);
+
+	    // determine x-y range of data
+	    if (x(Nx-1)-x(0) > y(Ny-1)-y(0))
+		Lxy = x(Nx-1)-x(0);
+	    else
+		Lxy = y(Ny-1)-y(0);
+	    double z_low = 10000, z_upp = -10000;
+
+	    // put data, z, into a 2D structured grid
+	    gridfunc->SetDimensions(Nx, Ny, 1);
+
+	    vtkPoints *points = vtkPoints::New();
+	    for (j = 0; j < Ny; j++)
+	    {
+		for (i = 0; i < Nx; i++)
+		{
+		    points->InsertNextPoint(x(i), y(j), z(i, j));
+
+		    if (z(i, j)< z_low)
+			z_low = z(i, j);
+		    if (z(i, j)> z_upp)
+			z_upp = z(i, j);
+		}
+	    }
+	    gridfunc->SetPoints(points);
+
+	    // get scalar field from z-values
+	    vtkFloatArray *colors = vtkFloatArray::New();
+	    colors->SetNumberOfComponents(1);
+	    colors->SetNumberOfTuples(Nx*Ny);
+	    k = 0;
+	    for (j = 0; j < Ny; j++)
+		for (i = 0; i < Nx; i++)
+		{
+		    colors->InsertComponent(k, 0, z(i, j));
+		    k++;
+		}
+
+	    gridfunc->GetPointData()->SetScalars(colors);
+
+	    points->Delete();
+	    colors->Delete();
+
+	    has_data = true;
+	    Lz = z_upp-z_low;
+	}
+
+	void renderer(bool, bool, bool, bool);
+
+    };
+
+    /** Plot contour lines for a function in the plane.
+     * Inspired by "contour" in Matlab
+     *
+     * \author Dag Lindbo
+     */
+
+	class Contour_VTK {
+
+		public:
+
+			Contour_VTK(int px = 800, int py = 600);
+
+			// specify linear or log on bars
+			Contour_VTK(int px = 800, int py = 600, SCALE xscale=LINEAR, SCALE
+							yscale=LINEAR);
+
+			~Contour_VTK();
+
+			/** Create contour plot.
+			 * Matrix z vs. vectors x and y.
+			 * Produces a default number of contour lines (10) and
+			 * colors the lines instead of the underlying surface.
+			 */
+			template<typename Vec_t, typename Mat_t>
+			void contour(const Vec_t &x, const Vec_t &y, const Mat_t &z) {
+				geometry(x, y, z);
+				renderer(true, false, 10);
+				render_interactive(rend, xPix, yPix);
+			}
+
+			/**Create contour plot.
+			 * Matrix z vs. vectors x and y.
+			 *
+			 * Number of contour lines:
+			 * - num_lines
+			 *
+			 * Coloring:
+			 * - draw_surf = false: color contour lines and omits underlying surface
+			 * - draw_surf = true:  draw contour lines white and color the
+			 *                      underlying surface
+			 */
+			template<typename Vec_t, typename Mat_t>
+			void contour(const Vec_t &x, const Vec_t &y, const Mat_t &z,
+				     bool draw_surf, int num_lines) {
+			    geometry(x, y, z);
+			    renderer(true, draw_surf, num_lines);
+			    render_interactive(rend, xPix, yPix);
+			}
+
+			/**Create contour plot and render to file.
+			 * Matrix z vs. vectors x and y.
+			 *
+			 * Number of contour lines:
+			 * - num_lines
+			 *
+			 * Coloring:
+			 * - draw_surf = false: color contour lines and omits underlying surface
+			 * - draw_surf = true:  draw contour lines white and color the
+			 *                      underlying surface
+			 */
+
+			template<typename Vec_t, typename Mat_t>
+			void contour_to_file(const Vec_t &x, const Vec_t &y, const Mat_t &z,
+				     bool draw_surf, int num_lines, std::string fname)
+			{
+			    geometry(x, y, z);
+			    renderer(true, draw_surf, num_lines);
+			    render_to_png(rend, xPix, yPix, fname);
+			}
+
+			void purge();
+
+			void SetXLabel(const std::string &xlab);
+			void SetYLabel(const std::string &ylab);
+
+		private:
+
+			SCALE XScale;
+			SCALE YScale;
+
+			vtkRectilinearGrid *gridfunc;
+			vtkRenderer *rend;
+
+			bool has_data;
+
+			int xPix, yPix;
+			double axscale;
+			double ymin;
+			double ymax;
+			std::string xlabel;
+			std::string ylabel;
+
+			template<typename Vec_t, typename Mat_t>
+
+			void geometry(const Vec_t &x, const Vec_t &y, const Mat_t &z) {
+
+		    	const unsigned int Nx = x.size();
+			    const unsigned int Ny = y.size();
+			    unsigned int i, j, k;
+
+			    // make sure the input is ok and that this contourplot is free
+	    		assert(Nx == z.rows() );
+	  	 	 	assert(Ny == z.cols() );
+	    		assert(!has_data);
+
+			    // x and y vectors go into vtkFloatArray
+			    vtkFloatArray *xcoord = vtkFloatArray::New();
+			    xcoord->SetNumberOfComponents(1);
+			    xcoord->SetNumberOfTuples(Nx);
+			    vtkFloatArray *ycoord = vtkFloatArray::New();
+			    ycoord->SetNumberOfComponents(1);
+			    ycoord->SetNumberOfTuples(Ny);
+
+				// We want the two axis to be equal, not squashed
+				// normalize axis ratio
+				axscale = 1.;
+				ymin = y.minCoeff();
+				ymax = y.maxCoeff();
+
+				if (YScale == LINEAR && XScale == LINEAR)
+					axscale =  (x.maxCoeff() - x.minCoeff()) /
+					           (y.maxCoeff() - y.minCoeff()) ;
+
+				if (YScale == LOG10 && XScale == LINEAR)
+					axscale = (           x.maxCoeff() -             x.minCoeff() ) /
+						      (std::log10(y.maxCoeff()) - std::log10(y.minCoeff())) ;
+
+				if (YScale == LOG10 && XScale == LOG10)
+					axscale =   ( (std::log10(x.maxCoeff()) - std::log10(x.minCoeff())) /
+						          (std::log10(y.maxCoeff()) - std::log10(y.minCoeff())) );
+
+				if (YScale == LINEAR && XScale == LOG10)
+					axscale =     (std::log10(x.maxCoeff()) - std::log10(x.minCoeff())) /
+						     (                y.maxCoeff()  -            y.minCoeff() ) ;
+
+				if (XScale == LINEAR) {
+			    	for (i=0; i<Nx; i++)
+						xcoord->InsertComponent(i, 0, x(i));
+				} else {
+			    	for (i=0; i<Nx; i++)
+						xcoord->InsertComponent(i, 0, std::log10(x(i)));
+				}
+
+				if (YScale == LINEAR) {
+			    	for (i=0; i<Ny; i++)
+						ycoord->InsertComponent(i, 0, axscale*y(i));
+				} else {
+			    	for (i=0; i<Ny; i++)
+						ycoord->InsertComponent(i, 0, axscale*std::log10(y(i)));
+				}
+
+
+			    // Create rectilinear grid
+			    gridfunc->SetDimensions(Nx, Ny, 1);
+			    gridfunc->SetXCoordinates(xcoord);
+			    gridfunc->SetYCoordinates(ycoord);
+
+			    // add z-values as scalars to grid
+			    vtkFloatArray *colors = vtkFloatArray::New();
+			    colors->SetNumberOfComponents(1);
+			    colors->SetNumberOfTuples(Nx*Ny);
+			    k = 0;
+			    for (j = 0; j < Ny; j++)
+				for (i = 0; i < Nx; i++) {
+			    	colors->InsertComponent(k, 0, z(i, j));
+			    	k++;
+				}
+
+		    	gridfunc->GetPointData()->SetScalars(colors);
+
+		    	colors->Delete();
+			    xcoord->Delete();
+			    ycoord->Delete();
+
+			    has_data = true;
+			}
+
+			void renderer(bool, bool, int);
+    };
+
+    /** Plot vector-valued function in the plane.
+     * Inspired by "quiver" in Matlab
+     *
+     * \author Dag Lindbo
+     */
+    class Quiver_VTK
+    {
+    public:
+
+	Quiver_VTK(int px = 800, int py = 600);
+	~Quiver_VTK();
+
+	/** Create vector arrow plot (quiver).
+	 * Pointwise vecotrs in matrices u and v, at grid
+	 * points given by vectors x and y. Color by magnitude.
+	 * Defaults to no scaling of arrow lengths.
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void quiver(const Vec_t &x, const Vec_t &y, const Mat_t &u,
+		    const Mat_t &v)
+	{
+	    geometry(x, y, u, v);
+	    renderer(1.0);
+	    render_interactive(rend, xPix, yPix);
+	}
+
+	/** Create vector arrow plot (quiver).
+	 * Pointwise vectors in matrices u and v, at grid
+	 * points given by vectors x and y. Color by magnitude.
+	 *
+	 * Scales arrows by a factor s.
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void quiver(const Vec_t &x, const Vec_t &y, const Mat_t &u,
+		    const Mat_t &v, double s)
+	{
+	    geometry(x, y, u, v);
+	    renderer(s);
+	    render_interactive(rend, xPix, yPix);
+	}
+
+	/** Create vector arrow plot (quiver) and render to file.
+	 * Pointwise vectors in matrices u and v, at grid
+	 * points given by vectors x and y. Color by magnitude
+	 *
+	 * Scales arrows by a factor s.
+	 */
+	template<typename Vec_t, typename Mat_t>
+	void quiver_to_file(const Vec_t &x, const Vec_t &y, const Mat_t &u,
+			    const Mat_t &v, double s, std::string filename)
+	{
+	    geometry(x, y, u, v);
+	    renderer(s);
+	    render_to_png(rend, xPix, yPix, filename);
+	}
+
+	void purge();
+
+    private:
+	vtkRectilinearGrid *gridfunc;
+	vtkRenderer *rend;
+
+	bool has_data;
+
+	int xPix, yPix;
+
+	template<typename Vec_t, typename Mat_t>
+	void geometry(const Vec_t& x, const Vec_t& y, const Mat_t& u,
+		      const Mat_t& v)
+	{
+	    const unsigned int Nx = x.size(); //vec_dim(x);
+	    const unsigned int Ny = y.size(); //vec_dim(y);
+	    unsigned int i, j, k;
+
+	    // make sure the input is ok and that this contourplot is free
+	    assert(Nx == u.rows());
+	    assert(Ny == u.cols());
+	    assert(Nx == v.rows());
+	    assert(Ny == v.cols());
+	    assert(!has_data);
+
+	    // x and y vectors go into vtkFloatArray
+	    vtkFloatArray *xcoord = vtkFloatArray::New();
+	    xcoord->SetNumberOfComponents(1);
+	    xcoord->SetNumberOfTuples(Nx);
+	    vtkFloatArray *ycoord = vtkFloatArray::New();
+	    ycoord->SetNumberOfComponents(1);
+	    ycoord->SetNumberOfTuples(Ny);
+
+	    for (i=0; i<Nx; i++)
+		xcoord->InsertComponent(i, 0, x(i));
+	    for (i=0; i<Ny; i++)
+		ycoord->InsertComponent(i, 0, y(i));
+
+	    // Create rectilinear grid
+	    gridfunc->SetDimensions(Nx, Ny, 1);
+	    gridfunc->SetXCoordinates(xcoord);
+	    gridfunc->SetYCoordinates(ycoord);
+
+	    // add magnitude of (u,v) as scalars to grid
+	    vtkFloatArray *colors = vtkFloatArray::New();
+	    colors->SetNumberOfComponents(1);
+	    colors->SetNumberOfTuples(Nx*Ny);
+
+	    // add vector (u,v) to grid
+	    vtkFloatArray *vectors = vtkFloatArray::New();
+	    vectors->SetNumberOfComponents(3);
+	    vectors->SetNumberOfTuples(Nx*Ny);
+
+	    k = 0;
+	    for (j = 0; j < Ny; j++)
+		for (i = 0; i < Nx; i++)
+		{
+		    colors->InsertTuple1(k,sqrt(u(i,j)*u(i,j)+v(i,j)*v(i,j)));
+		    vectors->InsertTuple3(k, u(i, j), v(i, j), 0.0);
+		    k++;
+		}
+
+	    gridfunc->GetPointData()->SetScalars(colors);
+	    gridfunc->GetPointData()->SetVectors(vectors);
+
+	    vectors->Delete();
+	    colors->Delete();
+	    xcoord->Delete();
+	    ycoord->Delete();
+
+	    has_data = true;
+	}
+
+	void renderer(double);
+
+    };
+
+}
+
+#endif