Commit be28895f authored by Ben Boeckel's avatar Ben Boeckel
Browse files

Examples/HyperTree: remove unused example

It also depends on OpenGL1
parent 0243758e
cmake_minimum_required(VERSION 3.3 FATAL_ERROR)
project(HyperTreeGridExamples)
if(NOT VTK_BINARY_DIR)
find_package(VTK REQUIRED)
include(${VTK_USE_FILE})
endif()
link_directories(${VTK_LIBRARY_DIRS})
# Add example showing use use of synthetic vtkHyperTreeGrid along with various filters
add_executable(HyperTreeGridDemonstrator HyperTreeGridDemonstrator.cxx)
target_link_libraries(HyperTreeGridDemonstrator vtkCommonCore vtkCommonSystem vtkCommonDataModel vtkCommonExecutionModel vtkIOLegacy vtkIOGeometry vtkFiltersCore vtkFiltersSources vtkFiltersHyperTree)
/*=========================================================================
Copyright (c) Kitware Inc.
All rights reserved.
=========================================================================*/
// .SECTION Description
// This program illustrates the use of various filters acting upon hyper
// tree grid data sets. It generates output files in VTK format.
//
// .SECTION Usage
// --branch-factor opt Branching factor of hyper tree grid
// --dimension opt Dimension of hyper tree grid
// --grid-size-X opt Size of hyper tree grid in X direction
// --grid-size-Y opt Size of hyper tree grid in Y direction
// --grid-size-Z opt Size of hyper tree grid in Z direction
// --descriptor String of characters specifying tree structure
// --max-level opt Maximum depth of hyper tree grid
// --contours Number of iso-contours to be calculated
// --skip-Axis-Cut Skip axis cut filter
// --skip-Contour Skip contour filter
// --skip-Cut Skip cut filter
// --skip-Geometry Skip geometry filter
// --skip-Shrink Skip shrink filter
//
// .SECTION Thanks
// This example was written by Philippe Pebay and Charles Law, Kitware 2012
// This work was supported in part by Commissariat a l'Energie Atomique (CEA/DIF)
#include "vtkHyperTreeGrid.h"
#include "vtkHyperTreeGridAxisCut.h"
#include "vtkHyperTreeGridSource.h"
#include "vtkHyperTreeGridGeometry.h"
#include "vtkContourFilter.h"
#include "vtkCutter.h"
#include "vtkDataSetWriter.h"
#include "vtkMath.h"
#include "vtkNew.h"
#include "vtkPlane.h"
#include "vtkPointData.h"
#include "vtkPolyDataWriter.h"
#include "vtkShrinkFilter.h"
#include "vtkStdString.h"
#include "vtkTimerLog.h"
#include "vtkUnstructuredGrid.h"
#include "vtkUnstructuredGridWriter.h"
#include "vtksys/CommandLineArguments.hxx"
#include <sstream>
void SetInputParameters( int& dim,
int& branch,
int& nX,
int& nY,
int& nZ,
int max,
vtkStdString& str )
{
// Ensure that parsed dimensionality makes sense
if ( dim > 3 )
{
dim = 3;
}
else if ( dim < 1 )
{
dim = 1;
}
// Ensure that parsed branch factor makes sense
if ( branch > 3 )
{
branch = 3;
}
else if ( branch < 2 )
{
branch = 2;
}
// Ensure that parsed grid sizes make sense
if ( nX < 1 )
{
nX = 1;
}
if ( nY < 1 )
{
nY = 1;
}
if ( nZ < 1 )
{
nZ = 1;
}
// Ensure that parsed grid sizes are consistent with dimensionality
if ( dim < 3 )
{
nZ = 1;
if ( dim < 2 )
{
nY = 1;
}
}
// Ensure that maximum level makes sense
if ( max < 1 )
{
max = 1;
}
// Generate a descriptor if none was provided
if ( str = "" )
{
// Calculate refined block size
int blockSize = branch;
for ( int i = 1; i < dim; ++ i )
{
blockSize *= branch;
}
// Initialize character stream
std::ostringstream stream;
// Seed random number generator
vtkMath::RandomSeed( static_cast<int>( vtkTimerLog::GetUniversalTime() ) );
// Initialize per-level cardinality
int cardLevel = nX * nY * nZ;
// Iterate over refinement levels
for ( int l = 0; l < max - 1; ++ l )
{
// Initialize counters for this level
int nRefined = 0;
int nLeaves = 0;
// Insert separator if not first level
if ( l )
{
stream << '|';
}
// Iterate over entries in this level
for ( int i = 0; i < cardLevel; ++ i )
{
// Generate next character based on pseudo-random clause
double u = vtkMath::Random();
if ( u < .3 )
{
// Refined cell
stream << 'R';
++ nRefined;
} // if ( u < .1 )
else
{
// Leaf cell
stream << '.';
++ nLeaves;
} // else
} // i
// Update cardinality for next level
cardLevel = nRefined * blockSize;
} // l
// Last level contains only leaf cells
if ( max > 1 )
{
// Insert separator if not first level
stream << '|';
}
// Iterate over entries in this level
for ( int i = 0; i < cardLevel; ++ i )
{
stream << '.';
}
// Finally dump stream into descriptor
str = stream.str();
} // if ( str = "" )
}
int main( int argc, char* argv[] )
{
// Set default argument values and options
vtkStdString descriptor = "";
int dim = 3;
int branch = 3;
int max = 3;
int nX = 2;
int nY = 3;
int nZ = 2;
double sX = 1.5;
double sY = 1.;
double sZ = .7;
int nContours = 1;
bool skipAxisCut = false;
bool skipContour = false;
bool skipCut = false;
bool skipGeometry = false;
bool skipShrink = false;
bool printDescriptor = false;
// Initialize command line argument parser
vtksys::CommandLineArguments clArgs;
clArgs.Initialize( argc, argv );
clArgs.StoreUnusedArguments( false );
// Parse command line parameters and options
clArgs.AddArgument( "--dimension",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&dim, "Dimension of hyper tree grid" );
clArgs.AddArgument( "--branch-factor",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&branch, "Branching factor of hyper tree grid" );
clArgs.AddArgument( "--max-level",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&max, "Maximum depth of hyper tree grid" );
clArgs.AddArgument("--descriptor",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&descriptor, "String describing the hyper tree grid");
clArgs.AddArgument( "--grid-size-X",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&nX, "Size of hyper tree grid in X direction" );
clArgs.AddArgument( "--grid-size-Y",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&nY, "Size of hyper tree grid in Y direction" );
clArgs.AddArgument( "--grid-size-Z",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&nZ, "Size of hyper tree grid in Z direction" );
clArgs.AddArgument( "--grid-scale-X",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&sX, "Scale of hyper tree grid in X direction" );
clArgs.AddArgument( "--grid-scale-Y",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&sY, "Scale of hyper tree grid in Y direction" );
clArgs.AddArgument( "--grid-scale-Z",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&sZ, "Scale of hyper tree grid in Z direction" );
clArgs.AddArgument( "--contours",
vtksys::CommandLineArguments::SPACE_ARGUMENT,
&nContours, "Number of iso-contours to be calculated" );
clArgs.AddArgument( "--skip-Axis-Cut",
vtksys::CommandLineArguments::NO_ARGUMENT,
&skipAxisCut, "Skip axis cut filter" );
clArgs.AddArgument( "--skip-Contour",
vtksys::CommandLineArguments::NO_ARGUMENT,
&skipContour, "Skip contour filter" );
clArgs.AddArgument( "--skip-Cut",
vtksys::CommandLineArguments::NO_ARGUMENT,
&skipCut, "Skip cut filter" );
clArgs.AddArgument( "--skip-Geometry",
vtksys::CommandLineArguments::NO_ARGUMENT,
&skipGeometry, "Skip geometry filter" );
clArgs.AddArgument( "--skip-Shrink",
vtksys::CommandLineArguments::NO_ARGUMENT,
&skipShrink, "Skip shrink filter" );
clArgs.AddArgument( "--print-Descriptor",
vtksys::CommandLineArguments::NO_ARGUMENT,
&printDescriptor, "Print descriptor string" );
// If incorrect arguments were provided, provide some help and terminate in error.
if ( ! clArgs.Parse() )
{
cerr << "Usage: "
<< clArgs.GetHelp()
<< "\n";
return 1;
}
// Verify and set input parameters
SetInputParameters( dim, branch, nX, nY, nZ, max, descriptor );
if ( printDescriptor )
{
cerr << "# Hyper tree grid descriptor: "
<< endl
<< descriptor
<< endl;
}
// Create hyper tree grid source
vtkNew<vtkHyperTreeGridSource> source;
source->DualOn();
source->SetGridSize( nX, nY, nZ );
source->SetGridScale( sX, sY, sZ );
source->SetDimension( dim );
source->SetAxisBranchFactor( branch );
source->SetMaximumLevel( max );
source->SetDescriptor( descriptor.c_str() );
source->Update();
vtkHyperTreeGrid* htGrid = source->GetOutput();
cerr << " Number of hyper tree dual grid cells: "
<< htGrid->GetNumberOfCells()
<< endl;
if ( ! skipGeometry )
{
cerr << "# Geometry" << endl;
vtkNew<vtkHyperTreeGridGeometry> geometry;
geometry->SetInputConnection( source->GetOutputPort() );
vtkNew<vtkPolyDataWriter> writer4;
writer4->SetFileName( "./hyperTreeGridGeometry.vtk" );
writer4->SetInputConnection( geometry->GetOutputPort() );
writer4->Write();
cerr << " Number of surface cells: "
<< geometry->GetOutput()->GetNumberOfCells()
<< endl;
}
if ( ! skipContour )
{
cerr << "# Contour" << endl;
vtkNew<vtkContourFilter> contour;
contour->SetInputData( htGrid );
double* range = htGrid->GetPointData()->GetScalars()->GetRange();
cerr << " Calculating "
<< nContours
<< " iso-contours across ["
<< range[0]
<< ", "
<< range[1]
<< "] range:"
<< endl;
contour->SetNumberOfContours( nContours );
double resolution = ( range[1] - range[0] ) / ( nContours + 1. );
double isovalue = resolution;
for ( int i = 0; i < nContours; ++ i, isovalue += resolution )
{
cerr << " Contour "
<< i
<< " at iso-value: "
<< isovalue
<< endl;
contour->SetValue( i, isovalue );
}
vtkNew<vtkPolyDataWriter> writer0;
writer0->SetFileName( "./hyperTreeGridContour.vtk" );
writer0->SetInputConnection( contour->GetOutputPort() );
writer0->Write();
cerr << " Number of cells in iso-contours: "
<< contour->GetOutput()->GetNumberOfCells()
<< endl;
}
if ( ! skipShrink )
{
cerr << "# Shrink" << endl;
vtkNew<vtkShrinkFilter> shrink;
shrink->SetInputData( htGrid );
shrink->SetShrinkFactor( .5 );
vtkNew<vtkUnstructuredGridWriter> writer1;
writer1->SetFileName( "./hyperTreeGridShrink.vtk" );
writer1->SetInputConnection( shrink->GetOutputPort() );
writer1->Write();
cerr << " Number of shrunk cells: "
<< shrink->GetOutput()->GetNumberOfCells()
<< endl;
}
if ( ! skipAxisCut )
{
// Axis-aligned cut works only in 3D for now
if ( dim == 3 )
{
cerr << "# HyperTreeGridAxisCut" << endl;
vtkNew<vtkHyperTreeGridAxisCut> axisCut;
axisCut->SetInputConnection( source->GetOutputPort() );
axisCut->SetPlaneNormalAxis( 2 );
axisCut->SetPlanePosition( .499 * nZ * sZ );
vtkNew<vtkPolyDataWriter> writer2;
writer2->SetFileName( "./hyperTreeGridAxisCut.vtk" );
writer2->SetInputConnection( axisCut->GetOutputPort() );
writer2->Write();
cerr << " Number of cells in axis cut: "
<< axisCut->GetOutput()->GetNumberOfCells()
<< endl;
}
}
if ( ! skipCut )
{
cerr << "# Cut" << endl;
vtkNew<vtkCutter> cut;
vtkNew<vtkPlane> plane;
plane->SetOrigin( .5, .5, .15 );
plane->SetNormal( 0, 0, 1 );
cut->SetInputData( htGrid );
cut->SetCutFunction( plane.GetPointer() );
vtkNew<vtkPolyDataWriter> writer3;
writer3->SetFileName( "./hyperTreeGridCut.vtk" );
writer3->SetInputConnection( cut->GetOutputPort() );
writer3->Write();
cerr << " Number of cells in generic cut: "
<< cut->GetOutput()->GetNumberOfCells()
<< endl;
}
return 0;
}
cmake_minimum_required (VERSION 2.8.8)
project(HyperTreeGridSphere)
if(NOT VTK_BINARY_DIR)
find_package(VTK REQUIRED)
include(${VTK_USE_FILE})
endif()
link_directories(${VTK_LIBRARY_DIRS})
set(HyperTreeGridSphere_SRCS
Cell.cxx
Node.cxx
Mesh.cxx
HyperTreeGridSphere.cxx)
# Add example showing use use of synthetic vtkHyperTreeGrid along with various filters
add_executable(HyperTreeGridSphere ${HyperTreeGridSphere_SRCS})
target_link_libraries(HyperTreeGridSphere vtkCommonCore vtkCommonSystem vtkCommonDataModel vtkCommonExecutionModel vtkIOCore vtkIOLegacy vtkFiltersCore vtkFiltersGeometry vtkFiltersHyperTree vtkInteractionStyle vtkRenderingCore vtkRenderingOpenGL)
/*=========================================================================
Copyright (c) Kitware Inc.
All rights reserved.
=========================================================================*/
// This class was written by Daniel Aguilera and Philippe Pebay
// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF)
#include "Mesh.h"
#include "Cell.h"
#include "Node.h"
#include <math.h>
#include <iostream>
#include <algorithm>
using namespace std;
int Cell::_count = 0;
int Cell::_refinedCount = 0;
int Cell::_refineNumber = 0;
double Cell::_R = 10.0;
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
Cell::Cell (int id, vector<Node*>& nodes)
{
_refined = false;
_id = id;
_nodes = nodes;
_nodeIds = 0;
_count++;
for (vector<Node*>::iterator it = _nodes.begin(); it != _nodes.end(); ++it)
{
(*it)->registerCell (this);
}
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
Cell::~Cell()
{
for (vector<Node*>::iterator it = _nodes.begin(); it != _nodes.end(); ++it)
{
(*it)->unregisterCell (this);
}
delete [] _nodeIds;
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
void Cell::refineIfNeeded()
{
if (_refined) return;
double v1 = computeValue (_nodes[0]);
for (int i = 1; i < 8; i++)
{
double v2 = computeValue (_nodes[i]);
if (v1*v2 < 0)
{
this->refine();
return;
}
}
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
void Cell::refine ()
{
_refinedCount++;
// attention : petite inversion entre X et Z par rapport a la creation du maillage initial
_cells = Mesh::instance()->createCells (_refineNumber + 1, _refineNumber + 1, _refineNumber + 1,
_nodes[0], _nodes[3], _nodes[2], _nodes[1],
_nodes[4], _nodes[7], _nodes[6], _nodes[5]);
// desenregistrement de la maille aupres des noeuds
for (vector<Node*>::iterator it = _nodes.begin(); it != _nodes.end(); ++it)
{
(*it)->unregisterCell (this);
}
delete [] _nodeIds;
_count--;
_refined = true;
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
double Cell::computeValue (Node * n)
{
// sphere de rayon _R
double x = n->getX();
double y = n->getY();
double z = n->getZ();
return (sqrt (x*x + y*y + z*z) - _R);
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
vtkIdType * Cell::getNodeIds()
{
delete [] _nodeIds;
_nodeIds = new vtkIdType[_nodes.size()+1];
int index = 0;
for (vector<Node*>::iterator it = _nodes.begin(); it != _nodes.end(); ++it)
{
_nodeIds[index++] = (*it)->getId();
}
_nodeIds[index++] = -1;
return _nodeIds;
}
/*-------------------------------------------------------------------------
-----------------------------------------------------------------------*/
void Cell::replaceNode (Node* oldNode, Node* newNode)
{
vector<Node*>::iterator it = std::find (_nodes.begin(), _nodes.end(), oldNode);
if (it != _nodes.end())
{
_nodes.insert (it, newNode);
_nodes.erase (it);
oldNode->unregisterCell (this);
newNode->registerCell (this);
}
}
/*=========================================================================
Copyright (c) Kitware Inc.
All rights reserved.
=========================================================================*/
// This class was written by Daniel Aguilera and Philippe Pebay
// This work was supported by Commissariat a l'Energie Atomique (CEA/DIF)
#ifndef CELL_H
#define CELL_H